gdb/remote-fileio.c

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