gdb/remote-fileio.c

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