contrib/gdb-7/gdb/remote-fileio.c

   1 /* Remote File-I/O communications
   2
   3    Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* See the GDB User Guide for details of the GDB remote protocol. */
  22
  23 #include "defs.h"
  24 #include "gdb_string.h"
  25 #include "gdbcmd.h"
  26 #include "remote.h"
  27 #include "gdb/fileio.h"
  28 #include "gdb_wait.h"
  29 #include "gdb_stat.h"
  30 #include "exceptions.h"
  31 #include "remote-fileio.h"
  32 #include "event-loop.h"
  33
  34 #include <fcntl.h>
  35 #include <sys/time.h>
  36 #ifdef __CYGWIN__
  37 #include <sys/cygwin.h>         /* For cygwin_conv_to_full_posix_path.  */
  38 #endif
  39 #include <signal.h>
  40
  41 static struct {
  42   int *fd_map;
  43   int fd_map_size;
  44 } remote_fio_data;
  45
  46 #define FIO_FD_INVALID          -1
  47 #define FIO_FD_CONSOLE_IN       -2
  48 #define FIO_FD_CONSOLE_OUT      -3
  49
  50 static int remote_fio_system_call_allowed = 0;
  51
  52 static struct async_signal_handler *sigint_fileio_token;
  53
  54 static int
  55 remote_fileio_init_fd_map (void)
  56 {
  57   int i;
  58
  59   if (!remote_fio_data.fd_map)
  60     {
  61       remote_fio_data.fd_map = (int *) xmalloc (10 * sizeof (int));
  62       remote_fio_data.fd_map_size = 10;
  63       remote_fio_data.fd_map[0] = FIO_FD_CONSOLE_IN;
  64       remote_fio_data.fd_map[1] = FIO_FD_CONSOLE_OUT;
  65       remote_fio_data.fd_map[2] = FIO_FD_CONSOLE_OUT;
  66       for (i = 3; i < 10; ++i)
  67         remote_fio_data.fd_map[i] = FIO_FD_INVALID;
  68     }
  69   return 3;
  70 }
  71
  72 static int
  73 remote_fileio_resize_fd_map (void)
  74 {
  75   int i = remote_fio_data.fd_map_size;
  76
  77   if (!remote_fio_data.fd_map)
  78     return remote_fileio_init_fd_map ();
  79   remote_fio_data.fd_map_size += 10;
  80   remote_fio_data.fd_map =
  81     (int *) xrealloc (remote_fio_data.fd_map,
  82                       remote_fio_data.fd_map_size * sizeof (int));
  83   for (; i < remote_fio_data.fd_map_size; i++)
  84     remote_fio_data.fd_map[i] = FIO_FD_INVALID;
  85   return remote_fio_data.fd_map_size - 10;
  86 }
  87
  88 static int
  89 remote_fileio_next_free_fd (void)
  90 {
  91   int i;
  92
  93   for (i = 0; i < remote_fio_data.fd_map_size; ++i)
  94     if (remote_fio_data.fd_map[i] == FIO_FD_INVALID)
  95       return i;
  96   return remote_fileio_resize_fd_map ();
  97 }
  98
  99 static int
 100 remote_fileio_fd_to_targetfd (int fd)
 101 {
 102   int target_fd = remote_fileio_next_free_fd ();
 103   remote_fio_data.fd_map[target_fd] = fd;
 104   return target_fd;
 105 }
 106
 107 static int
 108 remote_fileio_map_fd (int target_fd)
 109 {
 110   remote_fileio_init_fd_map ();
 111   if (target_fd < 0 || target_fd >= remote_fio_data.fd_map_size)
 112     return FIO_FD_INVALID;
 113   return remote_fio_data.fd_map[target_fd];
 114 }
 115
 116 static void
 117 remote_fileio_close_target_fd (int target_fd)
 118 {
 119   remote_fileio_init_fd_map ();
 120   if (target_fd >= 0 && target_fd < remote_fio_data.fd_map_size)
 121     remote_fio_data.fd_map[target_fd] = FIO_FD_INVALID;
 122 }
 123
 124 static int
 125 remote_fileio_oflags_to_host (long flags)
 126 {
 127   int hflags = 0;
 128
 129   if (flags & FILEIO_O_CREAT)
 130     hflags |= O_CREAT;
 131   if (flags & FILEIO_O_EXCL)
 132     hflags |= O_EXCL;
 133   if (flags & FILEIO_O_TRUNC)
 134     hflags |= O_TRUNC;
 135   if (flags & FILEIO_O_APPEND)
 136     hflags |= O_APPEND;
 137   if (flags & FILEIO_O_RDONLY)
 138     hflags |= O_RDONLY;
 139   if (flags & FILEIO_O_WRONLY)
 140     hflags |= O_WRONLY;
 141   if (flags & FILEIO_O_RDWR)
 142     hflags |= O_RDWR;
 143 /* On systems supporting binary and text mode, always open files in
 144    binary mode. */
 145 #ifdef O_BINARY
 146   hflags |= O_BINARY;
 147 #endif
 148   return hflags;
 149 }
 150
 151 static mode_t
 152 remote_fileio_mode_to_host (long mode, int open_call)
 153 {
 154   mode_t hmode = 0;
 155
 156   if (!open_call)
 157     {
 158       if (mode & FILEIO_S_IFREG)
 159         hmode |= S_IFREG;
 160       if (mode & FILEIO_S_IFDIR)
 161         hmode |= S_IFDIR;
 162       if (mode & FILEIO_S_IFCHR)
 163         hmode |= S_IFCHR;
 164     }
 165   if (mode & FILEIO_S_IRUSR)
 166     hmode |= S_IRUSR;
 167   if (mode & FILEIO_S_IWUSR)
 168     hmode |= S_IWUSR;
 169   if (mode & FILEIO_S_IXUSR)
 170     hmode |= S_IXUSR;
 171 #ifdef S_IRGRP
 172   if (mode & FILEIO_S_IRGRP)
 173     hmode |= S_IRGRP;
 174 #endif
 175 #ifdef S_IWGRP
 176   if (mode & FILEIO_S_IWGRP)
 177     hmode |= S_IWGRP;
 178 #endif
 179 #ifdef S_IXGRP
 180   if (mode & FILEIO_S_IXGRP)
 181     hmode |= S_IXGRP;
 182 #endif
 183   if (mode & FILEIO_S_IROTH)
 184     hmode |= S_IROTH;
 185 #ifdef S_IWOTH
 186   if (mode & FILEIO_S_IWOTH)
 187     hmode |= S_IWOTH;
 188 #endif
 189 #ifdef S_IXOTH
 190   if (mode & FILEIO_S_IXOTH)
 191     hmode |= S_IXOTH;
 192 #endif
 193   return hmode;
 194 }
 195
 196 static LONGEST
 197 remote_fileio_mode_to_target (mode_t mode)
 198 {
 199   mode_t tmode = 0;
 200
 201   if (S_ISREG(mode))
 202     tmode |= FILEIO_S_IFREG;
 203   if (S_ISDIR(mode))
 204     tmode |= FILEIO_S_IFDIR;
 205   if (S_ISCHR(mode))
 206     tmode |= FILEIO_S_IFCHR;
 207   if (mode & S_IRUSR)
 208     tmode |= FILEIO_S_IRUSR;
 209   if (mode & S_IWUSR)
 210     tmode |= FILEIO_S_IWUSR;
 211   if (mode & S_IXUSR)
 212     tmode |= FILEIO_S_IXUSR;
 213 #ifdef S_IRGRP
 214   if (mode & S_IRGRP)
 215     tmode |= FILEIO_S_IRGRP;
 216 #endif
 217 #ifdef S_IWRGRP
 218   if (mode & S_IWGRP)
 219     tmode |= FILEIO_S_IWGRP;
 220 #endif
 221 #ifdef S_IXGRP
 222   if (mode & S_IXGRP)
 223     tmode |= FILEIO_S_IXGRP;
 224 #endif
 225   if (mode & S_IROTH)
 226     tmode |= FILEIO_S_IROTH;
 227 #ifdef S_IWOTH
 228   if (mode & S_IWOTH)
 229     tmode |= FILEIO_S_IWOTH;
 230 #endif
 231 #ifdef S_IXOTH
 232   if (mode & S_IXOTH)
 233     tmode |= FILEIO_S_IXOTH;
 234 #endif
 235   return tmode;
 236 }
 237
 238 static int
 239 remote_fileio_errno_to_target (int error)
 240 {
 241   switch (error)
 242     {
 243       case EPERM:
 244         return FILEIO_EPERM;
 245       case ENOENT:
 246         return FILEIO_ENOENT;
 247       case EINTR:
 248         return FILEIO_EINTR;
 249       case EIO:
 250         return FILEIO_EIO;
 251       case EBADF:
 252         return FILEIO_EBADF;
 253       case EACCES:
 254         return FILEIO_EACCES;
 255       case EFAULT:
 256         return FILEIO_EFAULT;
 257       case EBUSY:
 258         return FILEIO_EBUSY;
 259       case EEXIST:
 260         return FILEIO_EEXIST;
 261       case ENODEV:
 262         return FILEIO_ENODEV;
 263       case ENOTDIR:
 264         return FILEIO_ENOTDIR;
 265       case EISDIR:
 266         return FILEIO_EISDIR;
 267       case EINVAL:
 268         return FILEIO_EINVAL;
 269       case ENFILE:
 270         return FILEIO_ENFILE;
 271       case EMFILE:
 272         return FILEIO_EMFILE;
 273       case EFBIG:
 274         return FILEIO_EFBIG;
 275       case ENOSPC:
 276         return FILEIO_ENOSPC;
 277       case ESPIPE:
 278         return FILEIO_ESPIPE;
 279       case EROFS:
 280         return FILEIO_EROFS;
 281       case ENOSYS:
 282         return FILEIO_ENOSYS;
 283       case ENAMETOOLONG:
 284         return FILEIO_ENAMETOOLONG;
 285     }
 286   return FILEIO_EUNKNOWN;
 287 }
 288
 289 static int
 290 remote_fileio_seek_flag_to_host (long num, int *flag)
 291 {
 292   if (!flag)
 293     return 0;
 294   switch (num)
 295     {
 296       case FILEIO_SEEK_SET:
 297         *flag = SEEK_SET;
 298         break;
 299       case FILEIO_SEEK_CUR:
 300         *flag =  SEEK_CUR;
 301         break;
 302       case FILEIO_SEEK_END:
 303         *flag =  SEEK_END;
 304         break;
 305       default:
 306         return -1;
 307     }
 308   return 0;
 309 }
 310
 311 static int
 312 remote_fileio_extract_long (char **buf, LONGEST *retlong)
 313 {
 314   char *c;
 315   int sign = 1;
 316
 317   if (!buf || !*buf || !**buf || !retlong)
 318     return -1;
 319   c = strchr (*buf, ',');
 320   if (c)
 321     *c++ = '\0';
 322   else
 323     c = strchr (*buf, '\0');
 324   while (strchr ("+-", **buf))
 325     {
 326       if (**buf == '-')
 327         sign = -sign;
 328       ++*buf;
 329     }
 330   for (*retlong = 0; **buf; ++*buf)
 331     {
 332       *retlong <<= 4;
 333       if (**buf >= '0' && **buf <= '9')
 334         *retlong += **buf - '0';
 335       else if (**buf >= 'a' && **buf <= 'f')
 336         *retlong += **buf - 'a' + 10;
 337       else if (**buf >= 'A' && **buf <= 'F')
 338         *retlong += **buf - 'A' + 10;
 339       else
 340         return -1;
 341     }
 342   *retlong *= sign;
 343   *buf = c;
 344   return 0;
 345 }
 346
 347 static int
 348 remote_fileio_extract_int (char **buf, long *retint)
 349 {
 350   int ret;
 351   LONGEST retlong;
 352
 353   if (!retint)
 354     return -1;
 355   ret = remote_fileio_extract_long (buf, &retlong);
 356   if (!ret)
 357     *retint = (long) retlong;
 358   return ret;
 359 }
 360
 361 static int
 362 remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length)
 363 {
 364   char *c;
 365   LONGEST retlong;
 366
 367   if (!buf || !*buf || !**buf || !ptrval || !length)
 368     return -1;
 369   c = strchr (*buf, '/');
 370   if (!c)
 371     return -1;
 372   *c++ = '\0';
 373   if (remote_fileio_extract_long (buf, &retlong))
 374     return -1;
 375   *ptrval = (CORE_ADDR) retlong;
 376   *buf = c;
 377   if (remote_fileio_extract_long (buf, &retlong))
 378     return -1;
 379   *length = (int) retlong;
 380   return 0;
 381 }
 382
 383 /* Convert to big endian */
 384 static void
 385 remote_fileio_to_be (LONGEST num, char *buf, int bytes)
 386 {
 387   int i;
 388
 389   for (i = 0; i < bytes; ++i)
 390     buf[i] = (num >> (8 * (bytes - i - 1))) & 0xff;
 391 }
 392
 393 static void
 394 remote_fileio_to_fio_uint (long num, fio_uint_t fnum)
 395 {
 396   remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4);
 397 }
 398
 399 static void
 400 remote_fileio_to_fio_mode (mode_t num, fio_mode_t fnum)
 401 {
 402   remote_fileio_to_be (remote_fileio_mode_to_target(num), (char *) fnum, 4);
 403 }
 404
 405 static void
 406 remote_fileio_to_fio_time (time_t num, fio_time_t fnum)
 407 {
 408   remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4);
 409 }
 410
 411 static void
 412 remote_fileio_to_fio_long (LONGEST num, fio_long_t fnum)
 413 {
 414   remote_fileio_to_be (num, (char *) fnum, 8);
 415 }
 416
 417 static void
 418 remote_fileio_to_fio_ulong (LONGEST num, fio_ulong_t fnum)
 419 {
 420   remote_fileio_to_be (num, (char *) fnum, 8);
 421 }
 422
 423 static void
 424 remote_fileio_to_fio_stat (struct stat *st, struct fio_stat *fst)
 425 {
 426   LONGEST blksize;
 427
 428   /* `st_dev' is set in the calling function */
 429   remote_fileio_to_fio_uint ((long) st->st_ino, fst->fst_ino);
 430   remote_fileio_to_fio_mode (st->st_mode, fst->fst_mode);
 431   remote_fileio_to_fio_uint ((long) st->st_nlink, fst->fst_nlink);
 432   remote_fileio_to_fio_uint ((long) st->st_uid, fst->fst_uid);
 433   remote_fileio_to_fio_uint ((long) st->st_gid, fst->fst_gid);
 434   remote_fileio_to_fio_uint ((long) st->st_rdev, fst->fst_rdev);
 435   remote_fileio_to_fio_ulong ((LONGEST) st->st_size, fst->fst_size);
 436 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
 437   blksize = st->st_blksize;
 438 #else
 439   blksize = 512;
 440 #endif
 441   remote_fileio_to_fio_ulong (blksize, fst->fst_blksize);
 442 #if HAVE_STRUCT_STAT_ST_BLOCKS
 443   remote_fileio_to_fio_ulong ((LONGEST) st->st_blocks, fst->fst_blocks);
 444 #else
 445   /* FIXME: This is correct for DJGPP, but other systems that don't
 446      have st_blocks, if any, might prefer 512 instead of st_blksize.
 447      (eliz, 30-12-2003)  */
 448   remote_fileio_to_fio_ulong (((LONGEST) st->st_size + blksize - 1)
 449                               / blksize,
 450                               fst->fst_blocks);
 451 #endif
 452   remote_fileio_to_fio_time (st->st_atime, fst->fst_atime);
 453   remote_fileio_to_fio_time (st->st_mtime, fst->fst_mtime);
 454   remote_fileio_to_fio_time (st->st_ctime, fst->fst_ctime);
 455 }
 456
 457 static void
 458 remote_fileio_to_fio_timeval (struct timeval *tv, struct fio_timeval *ftv)
 459 {
 460   remote_fileio_to_fio_time (tv->tv_sec, ftv->ftv_sec);
 461   remote_fileio_to_fio_long (tv->tv_usec, ftv->ftv_usec);
 462 }
 463
 464 static int remote_fio_ctrl_c_flag = 0;
 465 static int remote_fio_no_longjmp = 0;
 466
 467 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 468 static struct sigaction remote_fio_sa;
 469 static struct sigaction remote_fio_osa;
 470 #else
 471 static void (*remote_fio_ofunc)(int);
 472 #endif
 473
 474 static void
 475 remote_fileio_sig_init (void)
 476 {
 477 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 478   remote_fio_sa.sa_handler = SIG_IGN;
 479   sigemptyset (&remote_fio_sa.sa_mask);
 480   remote_fio_sa.sa_flags = 0;
 481   sigaction (SIGINT, &remote_fio_sa, &remote_fio_osa);
 482 #else
 483   remote_fio_ofunc = signal (SIGINT, SIG_IGN);
 484 #endif
 485 }
 486
 487 static void
 488 remote_fileio_sig_set (void (*sigint_func)(int))
 489 {
 490 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 491   remote_fio_sa.sa_handler = sigint_func;
 492   sigemptyset (&remote_fio_sa.sa_mask);
 493   remote_fio_sa.sa_flags = 0;
 494   sigaction (SIGINT, &remote_fio_sa, NULL);
 495 #else
 496   signal (SIGINT, sigint_func);
 497 #endif
 498 }
 499
 500 static void
 501 remote_fileio_sig_exit (void)
 502 {
 503 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
 504   sigaction (SIGINT, &remote_fio_osa, NULL);
 505 #else
 506   signal (SIGINT, remote_fio_ofunc);
 507 #endif
 508 }
 509
 510 static void
 511 async_remote_fileio_interrupt (gdb_client_data arg)
 512 {
 513   deprecated_throw_reason (RETURN_QUIT);
 514 }
 515
 516 static void
 517 remote_fileio_ctrl_c_signal_handler (int signo)
 518 {
 519   remote_fileio_sig_set (SIG_IGN);
 520   remote_fio_ctrl_c_flag = 1;
 521   if (!remote_fio_no_longjmp)
 522     gdb_call_async_signal_handler (sigint_fileio_token, 1);
 523   remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
 524 }
 525
 526 static void
 527 remote_fileio_reply (int retcode, int error)
 528 {
 529   char buf[32];
 530
 531   remote_fileio_sig_set (SIG_IGN);
 532   strcpy (buf, "F");
 533   if (retcode < 0)
 534     {
 535       strcat (buf, "-");
 536       retcode = -retcode;
 537     }
 538   sprintf (buf + strlen (buf), "%x", retcode);
 539   if (error || remote_fio_ctrl_c_flag)
 540     {
 541       if (error && remote_fio_ctrl_c_flag)
 542         error = FILEIO_EINTR;
 543       if (error < 0)
 544         {
 545           strcat (buf, "-");
 546           error = -error;
 547         }
 548       sprintf (buf + strlen (buf), ",%x", error);
 549       if (remote_fio_ctrl_c_flag)
 550         strcat (buf, ",C");
 551     }
 552   remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
 553   putpkt (buf);
 554 }
 555
 556 static void
 557 remote_fileio_ioerror (void)
 558 {
 559   remote_fileio_reply (-1, FILEIO_EIO);
 560 }
 561
 562 static void
 563 remote_fileio_badfd (void)
 564 {
 565   remote_fileio_reply (-1, FILEIO_EBADF);
 566 }
 567
 568 static void
 569 remote_fileio_return_errno (int retcode)
 570 {
 571   remote_fileio_reply (retcode,
 572                        retcode < 0 ? remote_fileio_errno_to_target (errno) : 0);
 573 }
 574
 575 static void
 576 remote_fileio_return_success (int retcode)
 577 {
 578   remote_fileio_reply (retcode, 0);
 579 }
 580
 581 /* Wrapper function for remote_write_bytes() which has the disadvantage to
 582    write only one packet, regardless of the requested number of bytes to
 583    transfer.  This wrapper calls remote_write_bytes() as often as needed. */
 584 static int
 585 remote_fileio_write_bytes (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
 586 {
 587   int ret = 0, written;
 588
 589   while (len > 0 && (written = remote_write_bytes (memaddr, myaddr, len)) > 0)
 590     {
 591       len -= written;
 592       memaddr += written;
 593       myaddr += written;
 594       ret += written;
 595     }
 596   return ret;
 597 }
 598
 599 static void
 600 remote_fileio_func_open (char *buf)
 601 {
 602   CORE_ADDR ptrval;
 603   int length, retlength;
 604   long num;
 605   int flags, fd;
 606   mode_t mode;
 607   char *pathname;
 608   struct stat st;
 609
 610   /* 1. Parameter: Ptr to pathname / length incl. trailing zero */
 611   if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
 612     {
 613       remote_fileio_ioerror ();
 614       return;
 615     }
 616   /* 2. Parameter: open flags */
 617   if (remote_fileio_extract_int (&buf, &num))
 618     {
 619       remote_fileio_ioerror ();
 620       return;
 621     }
 622   flags = remote_fileio_oflags_to_host (num);
 623   /* 3. Parameter: open mode */
 624   if (remote_fileio_extract_int (&buf, &num))
 625     {
 626       remote_fileio_ioerror ();
 627       return;
 628     }
 629   mode = remote_fileio_mode_to_host (num, 1);
 630
 631   /* Request pathname using 'm' packet */
 632   pathname = alloca (length);
 633   retlength = remote_read_bytes (ptrval, (gdb_byte *) pathname, length);
 634   if (retlength != length)
 635     {
 636       remote_fileio_ioerror ();
 637       return;
 638     }
 639
 640   /* Check if pathname exists and is not a regular file or directory.  If so,
 641      return an appropriate error code.  Same for trying to open directories
 642      for writing. */
 643   if (!stat (pathname, &st))
 644     {
 645       if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
 646         {
 647           remote_fileio_reply (-1, FILEIO_ENODEV);
 648           return;
 649         }
 650       if (S_ISDIR (st.st_mode)
 651           && ((flags & O_WRONLY) == O_WRONLY || (flags & O_RDWR) == O_RDWR))
 652         {
 653           remote_fileio_reply (-1, FILEIO_EISDIR);
 654           return;
 655         }
 656     }
 657
 658   remote_fio_no_longjmp = 1;
 659   fd = open (pathname, flags, mode);
 660   if (fd < 0)
 661     {
 662       remote_fileio_return_errno (-1);
 663       return;
 664     }
 665
 666   fd = remote_fileio_fd_to_targetfd (fd);
 667   remote_fileio_return_success (fd);
 668 }
 669
 670 static void
 671 remote_fileio_func_close (char *buf)
 672 {
 673   long num;
 674   int fd;
 675
 676   /* Parameter: file descriptor */
 677   if (remote_fileio_extract_int (&buf, &num))
 678     {
 679       remote_fileio_ioerror ();
 680       return;
 681     }
 682   fd = remote_fileio_map_fd ((int) num);
 683   if (fd == FIO_FD_INVALID)
 684     {
 685       remote_fileio_badfd ();
 686       return;
 687     }
 688
 689   remote_fio_no_longjmp = 1;
 690   if (fd != FIO_FD_CONSOLE_IN && fd != FIO_FD_CONSOLE_OUT && close (fd))
 691     remote_fileio_return_errno (-1);
 692   remote_fileio_close_target_fd ((int) num);
 693   remote_fileio_return_success (0);
 694 }
 695
 696 static void
 697 remote_fileio_func_read (char *buf)
 698 {
 699   long target_fd, num;
 700   LONGEST lnum;
 701   CORE_ADDR ptrval;
 702   int fd, ret, retlength;
 703   gdb_byte *buffer;
 704   size_t length;
 705   off_t old_offset, new_offset;
 706
 707   /* 1. Parameter: file descriptor */
 708   if (remote_fileio_extract_int (&buf, &target_fd))
 709     {
 710       remote_fileio_ioerror ();
 711       return;
 712     }
 713   fd = remote_fileio_map_fd ((int) target_fd);
 714   if (fd == FIO_FD_INVALID)
 715     {
 716       remote_fileio_badfd ();
 717       return;
 718     }
 719   /* 2. Parameter: buffer pointer */
 720   if (remote_fileio_extract_long (&buf, &lnum))
 721     {
 722       remote_fileio_ioerror ();
 723       return;
 724     }
 725   ptrval = (CORE_ADDR) lnum;
 726   /* 3. Parameter: buffer length */
 727   if (remote_fileio_extract_int (&buf, &num))
 728     {
 729       remote_fileio_ioerror ();
 730       return;
 731     }
 732   length = (size_t) num;
 733
 734   switch (fd)
 735     {
 736       case FIO_FD_CONSOLE_OUT:
 737         remote_fileio_badfd ();
 738         return;
 739       case FIO_FD_CONSOLE_IN:
 740         {
 741           static char *remaining_buf = NULL;
 742           static int remaining_length = 0;
 743
 744           buffer = (gdb_byte *) xmalloc (32768);
 745           if (remaining_buf)
 746             {
 747               remote_fio_no_longjmp = 1;
 748               if (remaining_length > length)
 749                 {
 750                   memcpy (buffer, remaining_buf, length);
 751                   memmove (remaining_buf, remaining_buf + length,
 752                            remaining_length - length);
 753                   remaining_length -= length;
 754                   ret = length;
 755                 }
 756               else
 757                 {
 758                   memcpy (buffer, remaining_buf, remaining_length);
 759                   xfree (remaining_buf);
 760                   remaining_buf = NULL;
 761                   ret = remaining_length;
 762                 }
 763             }
 764           else
 765             {
 766               ret = ui_file_read (gdb_stdtargin, (char *) buffer, 32767);
 767               remote_fio_no_longjmp = 1;
 768               if (ret > 0 && (size_t)ret > length)
 769                 {
 770                   remaining_buf = (char *) xmalloc (ret - length);
 771                   remaining_length = ret - length;
 772                   memcpy (remaining_buf, buffer + length, remaining_length);
 773                   ret = length;
 774                 }
 775             }
 776         }
 777         break;
 778       default:
 779         buffer = (gdb_byte *) xmalloc (length);
 780         /* POSIX defines EINTR behaviour of read in a weird way.  It's allowed
 781            for read() to return -1 even if "some" bytes have been read.  It
 782            has been corrected in SUSv2 but that doesn't help us much...
 783            Therefore a complete solution must check how many bytes have been
 784            read on EINTR to return a more reliable value to the target */
 785         old_offset = lseek (fd, 0, SEEK_CUR);
 786         remote_fio_no_longjmp = 1;
 787         ret = read (fd, buffer, length);
 788         if (ret < 0 && errno == EINTR)
 789           {
 790             new_offset = lseek (fd, 0, SEEK_CUR);
 791             /* If some data has been read, return the number of bytes read.
 792                The Ctrl-C flag is set in remote_fileio_reply() anyway */
 793             if (old_offset != new_offset)
 794               ret = new_offset - old_offset;
 795           }
 796         break;
 797     }
 798
 799   if (ret > 0)
 800     {
 801       retlength = remote_fileio_write_bytes (ptrval, buffer, ret);
 802       if (retlength != ret)
 803         ret = -1; /* errno has been set to EIO in remote_fileio_write_bytes() */
 804     }
 805
 806   if (ret < 0)
 807     remote_fileio_return_errno (-1);
 808   else
 809     remote_fileio_return_success (ret);
 810
 811   xfree (buffer);
 812 }
 813
 814 static void
 815 remote_fileio_func_write (char *buf)
 816 {
 817   long target_fd, num;
 818   LONGEST lnum;
 819   CORE_ADDR ptrval;
 820   int fd, ret, retlength;
 821   gdb_byte *buffer;
 822   size_t length;
 823
 824   /* 1. Parameter: file descriptor */
 825   if (remote_fileio_extract_int (&buf, &target_fd))
 826     {
 827       remote_fileio_ioerror ();
 828       return;
 829     }
 830   fd = remote_fileio_map_fd ((int) target_fd);
 831   if (fd == FIO_FD_INVALID)
 832     {
 833       remote_fileio_badfd ();
 834       return;
 835     }
 836   /* 2. Parameter: buffer pointer */
 837   if (remote_fileio_extract_long (&buf, &lnum))
 838     {
 839       remote_fileio_ioerror ();
 840       return;
 841     }
 842   ptrval = (CORE_ADDR) lnum;
 843   /* 3. Parameter: buffer length */
 844   if (remote_fileio_extract_int (&buf, &num))
 845     {
 846       remote_fileio_ioerror ();
 847       return;
 848     }
 849   length = (size_t) num;
 850
 851   buffer = (gdb_byte *) xmalloc (length);
 852   retlength = remote_read_bytes (ptrval, buffer, length);
 853   if (retlength != length)
 854     {
 855       xfree (buffer);
 856       remote_fileio_ioerror ();
 857       return;
 858     }
 859
 860   remote_fio_no_longjmp = 1;
 861   switch (fd)
 862     {
 863       case FIO_FD_CONSOLE_IN:
 864         remote_fileio_badfd ();
 865         xfree (buffer);
 866         return;
 867       case FIO_FD_CONSOLE_OUT:
 868         ui_file_write (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr,
 869                        (char *) buffer, length);
 870         gdb_flush (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr);
 871         ret = length;
 872         break;
 873       default:
 874         ret = write (fd, buffer, length);
 875         if (ret < 0 && errno == EACCES)
 876           errno = EBADF; /* Cygwin returns EACCESS when writing to a R/O file.*/
 877         break;
 878     }
 879
 880   if (ret < 0)
 881     remote_fileio_return_errno (-1);
 882   else
 883     remote_fileio_return_success (ret);
 884
 885   xfree (buffer);
 886 }
 887
 888 static void
 889 remote_fileio_func_lseek (char *buf)
 890 {
 891   long num;
 892   LONGEST lnum;
 893   int fd, flag;
 894   off_t offset, ret;
 895
 896   /* 1. Parameter: file descriptor */
 897   if (remote_fileio_extract_int (&buf, &num))
 898     {
 899       remote_fileio_ioerror ();
 900       return;
 901     }
 902   fd = remote_fileio_map_fd ((int) num);
 903   if (fd == FIO_FD_INVALID)
 904     {
 905       remote_fileio_badfd ();
 906       return;
 907     }
 908   else if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
 909     {
 910       remote_fileio_reply (-1, FILEIO_ESPIPE);
 911       return;
 912     }
 913
 914   /* 2. Parameter: offset */
 915   if (remote_fileio_extract_long (&buf, &lnum))
 916     {
 917       remote_fileio_ioerror ();
 918       return;
 919     }
 920   offset = (off_t) lnum;
 921   /* 3. Parameter: flag */
 922   if (remote_fileio_extract_int (&buf, &num))
 923     {
 924       remote_fileio_ioerror ();
 925       return;
 926     }
 927   if (remote_fileio_seek_flag_to_host (num, &flag))
 928     {
 929       remote_fileio_reply (-1, FILEIO_EINVAL);
 930       return;
 931     }
 932
 933   remote_fio_no_longjmp = 1;
 934   ret = lseek (fd, offset, flag);
 935
 936   if (ret == (off_t) -1)
 937     remote_fileio_return_errno (-1);
 938   else
 939     remote_fileio_return_success (ret);
 940 }
 941
 942 static void
 943 remote_fileio_func_rename (char *buf)
 944 {
 945   CORE_ADDR old_ptr, new_ptr;
 946   int old_len, new_len, retlength;
 947   char *oldpath, *newpath;
 948   int ret, of, nf;
 949   struct stat ost, nst;
 950
 951   /* 1. Parameter: Ptr to oldpath / length incl. trailing zero */
 952   if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len))
 953     {
 954       remote_fileio_ioerror ();
 955       return;
 956     }
 957
 958   /* 2. Parameter: Ptr to newpath / length incl. trailing zero */
 959   if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len))
 960     {
 961       remote_fileio_ioerror ();
 962       return;
 963     }
 964
 965   /* Request oldpath using 'm' packet */
 966   oldpath = alloca (old_len);
 967   retlength = remote_read_bytes (old_ptr, (gdb_byte *) oldpath, old_len);
 968   if (retlength != old_len)
 969     {
 970       remote_fileio_ioerror ();
 971       return;
 972     }
 973
 974   /* Request newpath using 'm' packet */
 975   newpath = alloca (new_len);
 976   retlength = remote_read_bytes (new_ptr, (gdb_byte *) newpath, new_len);
 977   if (retlength != new_len)
 978     {
 979       remote_fileio_ioerror ();
 980       return;
 981     }
 982
 983   /* Only operate on regular files and directories */
 984   of = stat (oldpath, &ost);
 985   nf = stat (newpath, &nst);
 986   if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode))
 987       || (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode)))
 988     {
 989       remote_fileio_reply (-1, FILEIO_EACCES);
 990       return;
 991     }
 992
 993   remote_fio_no_longjmp = 1;
 994   ret = rename (oldpath, newpath);
 995
 996   if (ret == -1)
 997     {
 998       /* Special case: newpath is a non-empty directory.  Some systems
 999          return ENOTEMPTY, some return EEXIST.  We coerce that to be
1000          always EEXIST. */
1001       if (errno == ENOTEMPTY)
1002         errno = EEXIST;
1003 #ifdef __CYGWIN__
1004       /* Workaround some Cygwin problems with correct errnos. */
1005       if (errno == EACCES)
1006         {
1007           if (!of && !nf && S_ISDIR (nst.st_mode))
1008             {
1009               if (S_ISREG (ost.st_mode))
1010                 errno = EISDIR;
1011               else
1012                 {
1013                   char oldfullpath[PATH_MAX + 1];
1014                   char newfullpath[PATH_MAX + 1];
1015                   int len;
1016
1017                   cygwin_conv_to_full_posix_path (oldpath, oldfullpath);
1018                   cygwin_conv_to_full_posix_path (newpath, newfullpath);
1019                   len = strlen (oldfullpath);
1020                   if (newfullpath[len] == '/'
1021                       && !strncmp (oldfullpath, newfullpath, len))
1022                     errno = EINVAL;
1023                   else
1024                     errno = EEXIST;
1025                 }
1026             }
1027         }
1028 #endif
1029
1030       remote_fileio_return_errno (-1);
1031     }
1032   else
1033     remote_fileio_return_success (ret);
1034 }
1035
1036 static void
1037 remote_fileio_func_unlink (char *buf)
1038 {
1039   CORE_ADDR ptrval;
1040   int length, retlength;
1041   char *pathname;
1042   int ret;
1043   struct stat st;
1044
1045   /* Parameter: Ptr to pathname / length incl. trailing zero */
1046   if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
1047     {
1048       remote_fileio_ioerror ();
1049       return;
1050     }
1051   /* Request pathname using 'm' packet */
1052   pathname = alloca (length);
1053   retlength = remote_read_bytes (ptrval, (gdb_byte *) pathname, length);
1054   if (retlength != length)
1055     {
1056       remote_fileio_ioerror ();
1057       return;
1058     }
1059
1060   /* Only operate on regular files (and directories, which allows to return
1061      the correct return code) */
1062   if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
1063     {
1064       remote_fileio_reply (-1, FILEIO_ENODEV);
1065       return;
1066     }
1067
1068   remote_fio_no_longjmp = 1;
1069   ret = unlink (pathname);
1070
1071   if (ret == -1)
1072     remote_fileio_return_errno (-1);
1073   else
1074     remote_fileio_return_success (ret);
1075 }
1076
1077 static void
1078 remote_fileio_func_stat (char *buf)
1079 {
1080   CORE_ADDR statptr, nameptr;
1081   int ret, namelength, retlength;
1082   char *pathname;
1083   LONGEST lnum;
1084   struct stat st;
1085   struct fio_stat fst;
1086
1087   /* 1. Parameter: Ptr to pathname / length incl. trailing zero */
1088   if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength))
1089     {
1090       remote_fileio_ioerror ();
1091       return;
1092     }
1093
1094   /* 2. Parameter: Ptr to struct stat */
1095   if (remote_fileio_extract_long (&buf, &lnum))
1096     {
1097       remote_fileio_ioerror ();
1098       return;
1099     }
1100   statptr = (CORE_ADDR) lnum;
1101
1102   /* Request pathname using 'm' packet */
1103   pathname = alloca (namelength);
1104   retlength = remote_read_bytes (nameptr, (gdb_byte *) pathname, namelength);
1105   if (retlength != namelength)
1106     {
1107       remote_fileio_ioerror ();
1108       return;
1109     }
1110
1111   remote_fio_no_longjmp = 1;
1112   ret = stat (pathname, &st);
1113
1114   if (ret == -1)
1115     {
1116       remote_fileio_return_errno (-1);
1117       return;
1118     }
1119   /* Only operate on regular files and directories */
1120   if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
1121     {
1122       remote_fileio_reply (-1, FILEIO_EACCES);
1123       return;
1124     }
1125   if (statptr)
1126     {
1127       remote_fileio_to_fio_stat (&st, &fst);
1128       remote_fileio_to_fio_uint (0, fst.fst_dev);
1129
1130       retlength = remote_fileio_write_bytes (statptr,
1131                                              (gdb_byte *) &fst, sizeof fst);
1132       if (retlength != sizeof fst)
1133         {
1134           remote_fileio_return_errno (-1);
1135           return;
1136         }
1137     }
1138   remote_fileio_return_success (ret);
1139 }
1140
1141 static void
1142 remote_fileio_func_fstat (char *buf)
1143 {
1144   CORE_ADDR ptrval;
1145   int fd, ret, retlength;
1146   long target_fd;
1147   LONGEST lnum;
1148   struct stat st;
1149   struct fio_stat fst;
1150   struct timeval tv;
1151
1152   /* 1. Parameter: file descriptor */
1153   if (remote_fileio_extract_int (&buf, &target_fd))
1154     {
1155       remote_fileio_ioerror ();
1156       return;
1157     }
1158   fd = remote_fileio_map_fd ((int) target_fd);
1159   if (fd == FIO_FD_INVALID)
1160     {
1161       remote_fileio_badfd ();
1162       return;
1163     }
1164   /* 2. Parameter: Ptr to struct stat */
1165   if (remote_fileio_extract_long (&buf, &lnum))
1166     {
1167       remote_fileio_ioerror ();
1168       return;
1169     }
1170   ptrval = (CORE_ADDR) lnum;
1171
1172   remote_fio_no_longjmp = 1;
1173   if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
1174     {
1175       remote_fileio_to_fio_uint (1, fst.fst_dev);
1176       st.st_mode = S_IFCHR | (fd == FIO_FD_CONSOLE_IN ? S_IRUSR : S_IWUSR);
1177       st.st_nlink = 1;
1178 #ifdef HAVE_GETUID
1179       st.st_uid = getuid ();
1180 #else
1181       st.st_uid = 0;
1182 #endif
1183 #ifdef HAVE_GETGID
1184       st.st_gid = getgid ();
1185 #else
1186       st.st_gid = 0;
1187 #endif
1188       st.st_rdev = 0;
1189       st.st_size = 0;
1190 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1191       st.st_blksize = 512;
1192 #endif
1193 #if HAVE_STRUCT_STAT_ST_BLOCKS
1194       st.st_blocks = 0;
1195 #endif
1196       if (!gettimeofday (&tv, NULL))
1197         st.st_atime = st.st_mtime = st.st_ctime = tv.tv_sec;
1198       else
1199         st.st_atime = st.st_mtime = st.st_ctime = (time_t) 0;
1200       ret = 0;
1201     }
1202   else
1203     ret = fstat (fd, &st);
1204
1205   if (ret == -1)
1206     {
1207       remote_fileio_return_errno (-1);
1208       return;
1209     }
1210   if (ptrval)
1211     {
1212       remote_fileio_to_fio_stat (&st, &fst);
1213
1214       retlength = remote_fileio_write_bytes (ptrval, (gdb_byte *) &fst, sizeof fst);
1215       if (retlength != sizeof fst)
1216         {
1217           remote_fileio_return_errno (-1);
1218           return;
1219         }
1220     }
1221   remote_fileio_return_success (ret);
1222 }
1223
1224 static void
1225 remote_fileio_func_gettimeofday (char *buf)
1226 {
1227   LONGEST lnum;
1228   CORE_ADDR ptrval;
1229   int ret, retlength;
1230   struct timeval tv;
1231   struct fio_timeval ftv;
1232
1233   /* 1. Parameter: struct timeval pointer */
1234   if (remote_fileio_extract_long (&buf, &lnum))
1235     {
1236       remote_fileio_ioerror ();
1237       return;
1238     }
1239   ptrval = (CORE_ADDR) lnum;
1240   /* 2. Parameter: some pointer value... */
1241   if (remote_fileio_extract_long (&buf, &lnum))
1242     {
1243       remote_fileio_ioerror ();
1244       return;
1245     }
1246   /* ...which has to be NULL */
1247   if (lnum)
1248     {
1249       remote_fileio_reply (-1, FILEIO_EINVAL);
1250       return;
1251     }
1252
1253   remote_fio_no_longjmp = 1;
1254   ret = gettimeofday (&tv, NULL);
1255
1256   if (ret == -1)
1257     {
1258       remote_fileio_return_errno (-1);
1259       return;
1260     }
1261
1262   if (ptrval)
1263     {
1264       remote_fileio_to_fio_timeval (&tv, &ftv);
1265
1266       retlength = remote_fileio_write_bytes (ptrval, (gdb_byte *) &ftv, sizeof ftv);
1267       if (retlength != sizeof ftv)
1268         {
1269           remote_fileio_return_errno (-1);
1270           return;
1271         }
1272     }
1273   remote_fileio_return_success (ret);
1274 }
1275
1276 static void
1277 remote_fileio_func_isatty (char *buf)
1278 {
1279   long target_fd;
1280   int fd;
1281
1282   /* Parameter: file descriptor */
1283   if (remote_fileio_extract_int (&buf, &target_fd))
1284     {
1285       remote_fileio_ioerror ();
1286       return;
1287     }
1288   remote_fio_no_longjmp = 1;
1289   fd = remote_fileio_map_fd ((int) target_fd);
1290   remote_fileio_return_success (fd == FIO_FD_CONSOLE_IN ||
1291                                 fd == FIO_FD_CONSOLE_OUT ? 1 : 0);
1292 }
1293
1294 static void
1295 remote_fileio_func_system (char *buf)
1296 {
1297   CORE_ADDR ptrval;
1298   int ret, length, retlength;
1299   char *cmdline = NULL;
1300
1301   /* Parameter: Ptr to commandline / length incl. trailing zero */
1302   if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
1303     {
1304       remote_fileio_ioerror ();
1305       return;
1306     }
1307
1308   if (length)
1309     {
1310       /* Request commandline using 'm' packet */
1311       cmdline = alloca (length);
1312       retlength = remote_read_bytes (ptrval, (gdb_byte *) cmdline, length);
1313       if (retlength != length)
1314         {
1315           remote_fileio_ioerror ();
1316           return;
1317         }
1318     }
1319
1320   /* Check if system(3) has been explicitely allowed using the
1321      `set remote system-call-allowed 1' command.  If length is 0,
1322      indicating a NULL parameter to the system call, return zero to
1323      indicate a shell is not available.  Otherwise fail with EPERM.  */
1324   if (!remote_fio_system_call_allowed)
1325     {
1326       if (!length)
1327         remote_fileio_return_success (0);
1328       else
1329         remote_fileio_reply (-1, FILEIO_EPERM);
1330       return;
1331     }
1332
1333   remote_fio_no_longjmp = 1;
1334   ret = system (cmdline);
1335
1336   if (!length)
1337     remote_fileio_return_success (ret);
1338   else if (ret == -1)
1339     remote_fileio_return_errno (-1);
1340   else
1341     remote_fileio_return_success (WEXITSTATUS (ret));
1342 }
1343
1344 static struct {
1345   char *name;
1346   void (*func)(char *);
1347 } remote_fio_func_map[] = {
1348   { "open", remote_fileio_func_open },
1349   { "close", remote_fileio_func_close },
1350   { "read", remote_fileio_func_read },
1351   { "write", remote_fileio_func_write },
1352   { "lseek", remote_fileio_func_lseek },
1353   { "rename", remote_fileio_func_rename },
1354   { "unlink", remote_fileio_func_unlink },
1355   { "stat", remote_fileio_func_stat },
1356   { "fstat", remote_fileio_func_fstat },
1357   { "gettimeofday", remote_fileio_func_gettimeofday },
1358   { "isatty", remote_fileio_func_isatty },
1359   { "system", remote_fileio_func_system },
1360   { NULL, NULL }
1361 };
1362
1363 static int
1364 do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
1365 {
1366   char *buf = buf_arg;
1367   char *c;
1368   int idx;
1369
1370   remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
1371
1372   c = strchr (++buf, ',');
1373   if (c)
1374     *c++ = '\0';
1375   else
1376     c = strchr (buf, '\0');
1377   for (idx = 0; remote_fio_func_map[idx].name; ++idx)
1378     if (!strcmp (remote_fio_func_map[idx].name, buf))
1379       break;
1380   if (!remote_fio_func_map[idx].name)   /* ERROR: No such function. */
1381     return RETURN_ERROR;
1382   remote_fio_func_map[idx].func (c);
1383   return 0;
1384 }
1385
1386 /* Close any open descriptors, and reinitialize the file mapping.  */
1387
1388 void
1389 remote_fileio_reset (void)
1390 {
1391   int ix;
1392
1393   for (ix = 0; ix != remote_fio_data.fd_map_size; ix++)
1394     {
1395       int fd = remote_fio_data.fd_map[ix];
1396
1397       if (fd >= 0)
1398         close (fd);
1399     }
1400   if (remote_fio_data.fd_map)
1401     {
1402       xfree (remote_fio_data.fd_map);
1403       remote_fio_data.fd_map = NULL;
1404       remote_fio_data.fd_map_size = 0;
1405     }
1406 }
1407
1408 void
1409 remote_fileio_request (char *buf)
1410 {
1411   int ex;
1412
1413   remote_fileio_sig_init ();
1414
1415   remote_fio_ctrl_c_flag = 0;
1416   remote_fio_no_longjmp = 0;
1417
1418   ex = catch_exceptions (uiout, do_remote_fileio_request, (void *)buf,
1419                          RETURN_MASK_ALL);
1420   switch (ex)
1421     {
1422       case RETURN_ERROR:
1423         remote_fileio_reply (-1, FILEIO_ENOSYS);
1424         break;
1425       case RETURN_QUIT:
1426         remote_fileio_reply (-1, FILEIO_EINTR);
1427         break;
1428       default:
1429         break;
1430     }
1431
1432   remote_fileio_sig_exit ();
1433 }
1434
1435 static void
1436 set_system_call_allowed (char *args, int from_tty)
1437 {
1438   if (args)
1439     {
1440       char *arg_end;
1441       int val = strtoul (args, &arg_end, 10);
1442       if (*args && *arg_end == '\0')
1443         {
1444           remote_fio_system_call_allowed = !!val;
1445           return;
1446         }
1447     }
1448   error (_("Illegal argument for \"set remote system-call-allowed\" command"));
1449 }
1450
1451 static void
1452 show_system_call_allowed (char *args, int from_tty)
1453 {
1454   if (args)
1455     error (_("Garbage after \"show remote system-call-allowed\" command: `%s'"), args);
1456   printf_unfiltered ("Calling host system(3) call from target is %sallowed\n",
1457                      remote_fio_system_call_allowed ? "" : "not ");
1458 }
1459
1460 void
1461 initialize_remote_fileio (struct cmd_list_element *remote_set_cmdlist,
1462                           struct cmd_list_element *remote_show_cmdlist)
1463 {
1464   sigint_fileio_token =
1465     create_async_signal_handler (async_remote_fileio_interrupt, NULL);
1466
1467   add_cmd ("system-call-allowed", no_class,
1468            set_system_call_allowed,
1469            _("Set if the host system(3) call is allowed for the target."),
1470            &remote_set_cmdlist);
1471   add_cmd ("system-call-allowed", no_class,
1472            show_system_call_allowed,
1473            _("Show if the host system(3) call is allowed for the target."),
1474            &remote_show_cmdlist);
1475 }