gdb/remote-fileio.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Remote File-I/O communications

  3.    Copyright (C) 2003-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. /* See the GDB User Guide for details of the GDB remote protocol.  */

  22. #include "defs.h"
  23. #include "gdbcmd.h"
  24. #include "remote.h"
  25. #include "gdb/fileio.h"
  26. #include "gdb_wait.h"
  27. #include <sys/stat.h>
  28. #include "remote-fileio.h"
  29. #include "event-loop.h"
  30. #include "target.h"
  31. #include "filenames.h"
  32. #include "filestuff.h"

  34. #include <fcntl.h>
  35. #include <sys/time.h>
  36. #ifdef __CYGWIN__
  37. #include <sys/cygwin.h>                /* For cygwin_conv_path.  */
  38. #endif
  39. #include <signal.h>

  41. static struct {
  42.   int *fd_map;
  43.   int fd_map_size;
  44. ‌} remote_fio_data;

  46. ‌#define FIO_FD_INVALID                -1
  47. ‌#define FIO_FD_CONSOLE_IN        -2
  48. ‌#define FIO_FD_CONSOLE_OUT        -3

  50. ‌static int remote_fio_system_call_allowed = 0;

  52. ‌static struct async_signal_handler *sigint_fileio_token;

  54. static int
  55. ‌remote_fileio_init_fd_map (void)
  56. {
  57.   int i;

  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. }

  72. static int
  73. ‌remote_fileio_resize_fd_map (void)
  74. {
  75.   int i = remote_fio_data.fd_map_size;

  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. }

  88. static int
  89. ‌remote_fileio_next_free_fd (void)
  90. {
  91.   int i;

  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. }

  99. static int
  100. ‌remote_fileio_fd_to_targetfd (int fd)
  101. {
  102.   int target_fd = remote_fileio_next_free_fd ();

  104.   remote_fio_data.fd_map[target_fd] = fd;
  105.   return target_fd;
  106. }

  108. static int
  109. ‌remote_fileio_map_fd (int target_fd)
  110. {
  111.   remote_fileio_init_fd_map ();
  112.   if (target_fd < 0 || target_fd >= remote_fio_data.fd_map_size)
  113.     return FIO_FD_INVALID;
  114.   return remote_fio_data.fd_map[target_fd];
  115. }

  117. static void
  118. ‌remote_fileio_close_target_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.     remote_fio_data.fd_map[target_fd] = FIO_FD_INVALID;
  123. }

  125. static int
  126. ‌remote_fileio_oflags_to_host (long flags)
  127. {
  128.   int hflags = 0;

  130.   if (flags & FILEIO_O_CREAT)
  131.     hflags |= O_CREAT;
  132.   if (flags & FILEIO_O_EXCL)
  133.     hflags |= O_EXCL;
  134.   if (flags & FILEIO_O_TRUNC)
  135.     hflags |= O_TRUNC;
  136.   if (flags & FILEIO_O_APPEND)
  137.     hflags |= O_APPEND;
  138.   if (flags & FILEIO_O_RDONLY)
  139.     hflags |= O_RDONLY;
  140.   if (flags & FILEIO_O_WRONLY)
  141.     hflags |= O_WRONLY;
  142.   if (flags & FILEIO_O_RDWR)
  143.     hflags |= O_RDWR;
  144. /* On systems supporting binary and text mode, always open files in
  145.    binary mode.  */
  146. #ifdef O_BINARY
  147.   hflags |= O_BINARY;
  148. #endif
  149.   return hflags;
  150. }

  152. static mode_t
  153. ‌remote_fileio_mode_to_host (long mode, int open_call)
  154. {
  155.   mode_t hmode = 0;

  157.   if (!open_call)
  158.     {
  159.       if (mode & FILEIO_S_IFREG)
  160.         hmode |= S_IFREG;
  161.       if (mode & FILEIO_S_IFDIR)
  162.         hmode |= S_IFDIR;
  163.       if (mode & FILEIO_S_IFCHR)
  164.         hmode |= S_IFCHR;
  165.     }
  166.   if (mode & FILEIO_S_IRUSR)
  167.     hmode |= S_IRUSR;
  168.   if (mode & FILEIO_S_IWUSR)
  169.     hmode |= S_IWUSR;
  170.   if (mode & FILEIO_S_IXUSR)
  171.     hmode |= S_IXUSR;
  172. #ifdef S_IRGRP
  173.   if (mode & FILEIO_S_IRGRP)
  174.     hmode |= S_IRGRP;
  175. #endif
  176. #ifdef S_IWGRP
  177.   if (mode & FILEIO_S_IWGRP)
  178.     hmode |= S_IWGRP;
  179. #endif
  180. #ifdef S_IXGRP
  181.   if (mode & FILEIO_S_IXGRP)
  182.     hmode |= S_IXGRP;
  183. #endif
  184.   if (mode & FILEIO_S_IROTH)
  185.     hmode |= S_IROTH;
  186. #ifdef S_IWOTH
  187.   if (mode & FILEIO_S_IWOTH)
  188.     hmode |= S_IWOTH;
  189. #endif
  190. #ifdef S_IXOTH
  191.   if (mode & FILEIO_S_IXOTH)
  192.     hmode |= S_IXOTH;
  193. #endif
  194.   return hmode;
  195. }

  197. static LONGEST
  198. ‌remote_fileio_mode_to_target (mode_t mode)
  199. {
  200.   mode_t tmode = 0;

  202.   if (S_ISREG(mode))
  203.     tmode |= FILEIO_S_IFREG;
  204.   if (S_ISDIR(mode))
  205.     tmode |= FILEIO_S_IFDIR;
  206.   if (S_ISCHR(mode))
  207.     tmode |= FILEIO_S_IFCHR;
  208.   if (mode & S_IRUSR)
  209.     tmode |= FILEIO_S_IRUSR;
  210.   if (mode & S_IWUSR)
  211.     tmode |= FILEIO_S_IWUSR;
  212.   if (mode & S_IXUSR)
  213.     tmode |= FILEIO_S_IXUSR;
  214. #ifdef S_IRGRP
  215.   if (mode & S_IRGRP)
  216.     tmode |= FILEIO_S_IRGRP;
  217. #endif
  218. #ifdef S_IWRGRP
  219.   if (mode & S_IWGRP)
  220.     tmode |= FILEIO_S_IWGRP;
  221. #endif
  222. #ifdef S_IXGRP
  223.   if (mode & S_IXGRP)
  224.     tmode |= FILEIO_S_IXGRP;
  225. #endif
  226.   if (mode & S_IROTH)
  227.     tmode |= FILEIO_S_IROTH;
  228. #ifdef S_IWOTH
  229.   if (mode & S_IWOTH)
  230.     tmode |= FILEIO_S_IWOTH;
  231. #endif
  232. #ifdef S_IXOTH
  233.   if (mode & S_IXOTH)
  234.     tmode |= FILEIO_S_IXOTH;
  235. #endif
  236.   return tmode;
  237. }

  239. static int
  240. ‌remote_fileio_errno_to_target (int error)
  241. {
  242.   switch (error)
  243.     {
  244.       case EPERM:
  245.         return FILEIO_EPERM;
  246.       case ENOENT:
  247.         return FILEIO_ENOENT;
  248.       case EINTR:
  249.         return FILEIO_EINTR;
  250.       case EIO:
  251.         return FILEIO_EIO;
  252.       case EBADF:
  253.         return FILEIO_EBADF;
  254.       case EACCES:
  255.         return FILEIO_EACCES;
  256.       case EFAULT:
  257.         return FILEIO_EFAULT;
  258.       case EBUSY:
  259.         return FILEIO_EBUSY;
  260.       case EEXIST:
  261.         return FILEIO_EEXIST;
  262.       case ENODEV:
  263.         return FILEIO_ENODEV;
  264.       case ENOTDIR:
  265.         return FILEIO_ENOTDIR;
  266.       case EISDIR:
  267.         return FILEIO_EISDIR;
  268.       case EINVAL:
  269.         return FILEIO_EINVAL;
  270.       case ENFILE:
  271.         return FILEIO_ENFILE;
  272.       case EMFILE:
  273.         return FILEIO_EMFILE;
  274.       case EFBIG:
  275.         return FILEIO_EFBIG;
  276.       case ENOSPC:
  277.         return FILEIO_ENOSPC;
  278.       case ESPIPE:
  279.         return FILEIO_ESPIPE;
  280.       case EROFS:
  281.         return FILEIO_EROFS;
  282.       case ENOSYS:
  283.         return FILEIO_ENOSYS;
  284.       case ENAMETOOLONG:
  285.         return FILEIO_ENAMETOOLONG;
  286.     }
  287.   return FILEIO_EUNKNOWN;
  288. }

  290. static int
  291. ‌remote_fileio_seek_flag_to_host (long num, int *flag)
  292. {
  293.   if (!flag)
  294.     return 0;
  295.   switch (num)
  296.     {
  297.       case FILEIO_SEEK_SET:
  298.         *flag = SEEK_SET;
  299.         break;
  300.       case FILEIO_SEEK_CUR:
  301.         *flag =  SEEK_CUR;
  302.         break;
  303.       case FILEIO_SEEK_END:
  304.         *flag =  SEEK_END;
  305.         break;
  306.       default:
  307.         return -1;
  308.     }
  309.   return 0;
  310. }

  312. static int
  313. ‌remote_fileio_extract_long (char **buf, LONGEST *retlong)
  314. {
  315.   char *c;
  316.   int sign = 1;

  318.   if (!buf || !*buf || !**buf || !retlong)
  319.     return -1;
  320.   c = strchr (*buf, ',');
  321.   if (c)
  322.     *c++ = '\0';
  323.   else
  324.     c = strchr (*buf, '\0');
  325.   while (strchr ("+-", **buf))
  326.     {
  327.       if (**buf == '-')
  328.         sign = -sign;
  329.       ++*buf;
  330.     }
  331.   for (*retlong = 0; **buf; ++*buf)
  332.     {
  333.       *retlong <<= 4;
  334.       if (**buf >= '0' && **buf <= '9')
  335.         *retlong += **buf - '0';
  336.       else if (**buf >= 'a' && **buf <= 'f')
  337.         *retlong += **buf - 'a' + 10;
  338.       else if (**buf >= 'A' && **buf <= 'F')
  339.         *retlong += **buf - 'A' + 10;
  340.       else
  341.         return -1;
  342.     }
  343.   *retlong *= sign;
  344.   *buf = c;
  345.   return 0;
  346. }

  348. static int
  349. ‌remote_fileio_extract_int (char **buf, long *retint)
  350. {
  351.   int ret;
  352.   LONGEST retlong;

  354.   if (!retint)
  355.     return -1;
  356.   ret = remote_fileio_extract_long (buf, &retlong);
  357.   if (!ret)
  358.     *retint = (long) retlong;
  359.   return ret;
  360. }

  362. static int
  363. ‌remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length)
  364. {
  365.   char *c;
  366.   LONGEST retlong;

  368.   if (!buf || !*buf || !**buf || !ptrval || !length)
  369.     return -1;
  370.   c = strchr (*buf, '/');
  371.   if (!c)
  372.     return -1;
  373.   *c++ = '\0';
  374.   if (remote_fileio_extract_long (buf, &retlong))
  375.     return -1;
  376.   *ptrval = (CORE_ADDR) retlong;
  377.   *buf = c;
  378.   if (remote_fileio_extract_long (buf, &retlong))
  379.     return -1;
  380.   *length = (int) retlong;
  381.   return 0;
  382. }

  384. /* Convert to big endian.  */
  385. static void
  386. ‌remote_fileio_to_be (LONGEST num, char *buf, int bytes)
  387. {
  388.   int i;

  390.   for (i = 0; i < bytes; ++i)
  391.     buf[i] = (num >> (8 * (bytes - i - 1))) & 0xff;
  392. }

  394. static void
  395. ‌remote_fileio_to_fio_uint (long num, fio_uint_t fnum)
  396. {
  397.   remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4);
  398. }

  400. static void
  401. ‌remote_fileio_to_fio_mode (mode_t num, fio_mode_t fnum)
  402. {
  403.   remote_fileio_to_be (remote_fileio_mode_to_target(num), (char *) fnum, 4);
  404. }

  406. static void
  407. ‌remote_fileio_to_fio_time (time_t num, fio_time_t fnum)
  408. {
  409.   remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4);
  410. }

  412. static void
  413. ‌remote_fileio_to_fio_long (LONGEST num, fio_long_t fnum)
  414. {
  415.   remote_fileio_to_be (num, (char *) fnum, 8);
  416. }

  418. static void
  419. ‌remote_fileio_to_fio_ulong (LONGEST num, fio_ulong_t fnum)
  420. {
  421.   remote_fileio_to_be (num, (char *) fnum, 8);
  422. }

  424. static void
  425. ‌remote_fileio_to_fio_stat (struct stat *st, struct fio_stat *fst)
  426. {
  427.   LONGEST blksize;

  429.   /* `st_dev' is set in the calling function.  */
  430.   remote_fileio_to_fio_uint ((long) st->st_ino, fst->fst_ino);
  431.   remote_fileio_to_fio_mode (st->st_mode, fst->fst_mode);
  432.   remote_fileio_to_fio_uint ((long) st->st_nlink, fst->fst_nlink);
  433.   remote_fileio_to_fio_uint ((long) st->st_uid, fst->fst_uid);
  434.   remote_fileio_to_fio_uint ((long) st->st_gid, fst->fst_gid);
  435.   remote_fileio_to_fio_uint ((long) st->st_rdev, fst->fst_rdev);
  436.   remote_fileio_to_fio_ulong ((LONGEST) st->st_size, fst->fst_size);
  437. #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
  438.   blksize = st->st_blksize;
  439. #else
  440.   blksize = 512;
  441. #endif
  442.   remote_fileio_to_fio_ulong (blksize, fst->fst_blksize);
  443. #if HAVE_STRUCT_STAT_ST_BLOCKS
  444.   remote_fileio_to_fio_ulong ((LONGEST) st->st_blocks, fst->fst_blocks);
  445. #else
  446.   /* FIXME: This is correct for DJGPP, but other systems that don't
  447.      have st_blocks, if any, might prefer 512 instead of st_blksize.
  448.      (eliz, 30-12-2003)  */
  449.   remote_fileio_to_fio_ulong (((LONGEST) st->st_size + blksize - 1)
  450.                               / blksize,
  451.                               fst->fst_blocks);
  452. #endif
  453.   remote_fileio_to_fio_time (st->st_atime, fst->fst_atime);
  454.   remote_fileio_to_fio_time (st->st_mtime, fst->fst_mtime);
  455.   remote_fileio_to_fio_time (st->st_ctime, fst->fst_ctime);
  456. }

  458. static void
  459. ‌remote_fileio_to_fio_timeval (struct timeval *tv, struct fio_timeval *ftv)
  460. {
  461.   remote_fileio_to_fio_time (tv->tv_sec, ftv->ftv_sec);
  462.   remote_fileio_to_fio_long (tv->tv_usec, ftv->ftv_usec);
  463. }

  465. ‌static int remote_fio_ctrl_c_flag = 0;
  466. ‌static int remote_fio_no_longjmp = 0;

  468. #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
  469. ‌static struct sigaction remote_fio_sa;
  470. ‌static struct sigaction remote_fio_osa;
  471. #else
  472. ‌static void (*remote_fio_ofunc)(int);
  473. #endif

  475. static void
  476. ‌remote_fileio_sig_init (void)
  477. {
  478. #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
  479.   remote_fio_sa.sa_handler = SIG_IGN;
  480.   sigemptyset (&remote_fio_sa.sa_mask);
  481.   remote_fio_sa.sa_flags = 0;
  482.   sigaction (SIGINT, &remote_fio_sa, &remote_fio_osa);
  483. #else
  484.   remote_fio_ofunc = signal (SIGINT, SIG_IGN);
  485. #endif
  486. }

  488. static void
  489. ‌remote_fileio_sig_set (void (*sigint_func)(int))
  490. {
  491. #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
  492.   remote_fio_sa.sa_handler = sigint_func;
  493.   sigemptyset (&remote_fio_sa.sa_mask);
  494.   remote_fio_sa.sa_flags = 0;
  495.   sigaction (SIGINT, &remote_fio_sa, NULL);
  496. #else
  497.   signal (SIGINT, sigint_func);
  498. #endif
  499. }

  501. static void
  502. ‌remote_fileio_sig_exit (void)
  503. {
  504. #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
  505.   sigaction (SIGINT, &remote_fio_osa, NULL);
  506. #else
  507.   signal (SIGINT, remote_fio_ofunc);
  508. #endif
  509. }

  511. static void
  512. ‌async_remote_fileio_interrupt (gdb_client_data arg)
  513. {
  514.   quit ();
  515. }

  517. static void
  518. ‌remote_fileio_ctrl_c_signal_handler (int signo)
  519. {
  520.   remote_fileio_sig_set (SIG_IGN);
  521.   remote_fio_ctrl_c_flag = 1;
  522.   if (!remote_fio_no_longjmp)
  523.     gdb_call_async_signal_handler (sigint_fileio_token, 1);
  524.   remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
  525. }

  527. static void
  528. ‌remote_fileio_reply (int retcode, int error)
  529. {
  530.   char buf[32];

  532.   remote_fileio_sig_set (SIG_IGN);
  533.   strcpy (buf, "F");
  534.   if (retcode < 0)
  535.     {
  536.       strcat (buf, "-");
  537.       retcode = -retcode;
  538.     }
  539.   sprintf (buf + strlen (buf), "%x", retcode);
  540.   if (error || remote_fio_ctrl_c_flag)
  541.     {
  542.       if (error && remote_fio_ctrl_c_flag)
  543.         error = FILEIO_EINTR;
  544.       if (error < 0)
  545.         {
  546.           strcat (buf, "-");
  547.           error = -error;
  548.         }
  549.       sprintf (buf + strlen (buf), ",%x", error);
  550.       if (remote_fio_ctrl_c_flag)
  551.         strcat (buf, ",C");
  552.     }
  553.   remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
  554.   putpkt (buf);
  555. }

  557. static void
  558. ‌remote_fileio_ioerror (void)
  559. {
  560.   remote_fileio_reply (-1, FILEIO_EIO);
  561. }

  563. static void
  564. ‌remote_fileio_badfd (void)
  565. {
  566.   remote_fileio_reply (-1, FILEIO_EBADF);
  567. }

  569. static void
  570. ‌remote_fileio_return_errno (int retcode)
  571. {
  572.   remote_fileio_reply (retcode, retcode < 0
  573.                        ? remote_fileio_errno_to_target (errno) : 0);
  574. }

  576. static void
  577. ‌remote_fileio_return_success (int retcode)
  578. {
  579.   remote_fileio_reply (retcode, 0);
  580. }

  582. static void
  583. ‌remote_fileio_func_open (char *buf)
  584. {
  585.   CORE_ADDR ptrval;
  586.   int length;
  587.   long num;
  588.   int flags, fd;
  589.   mode_t mode;
  590.   char *pathname;
  591.   struct stat st;

  593.   /* 1. Parameter: Ptr to pathname / length incl. trailing zero.  */
  594.   if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
  595.     {
  596.       remote_fileio_ioerror ();
  597.       return;
  598.     }
  599.   /* 2. Parameter: open flags */
  600.   if (remote_fileio_extract_int (&buf, &num))
  601.     {
  602.       remote_fileio_ioerror ();
  603.       return;
  604.     }
  605.   flags = remote_fileio_oflags_to_host (num);
  606.   /* 3. Parameter: open mode */
  607.   if (remote_fileio_extract_int (&buf, &num))
  608.     {
  609.       remote_fileio_ioerror ();
  610.       return;
  611.     }
  612.   mode = remote_fileio_mode_to_host (num, 1);

  614.   /* Request pathname.  */
  615.   pathname = alloca (length);
  616.   if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
  617.     {
  618.       remote_fileio_ioerror ();
  619.       return;
  620.     }

  622.   /* Check if pathname exists and is not a regular file or directory.  If so,
  623.      return an appropriate error code.  Same for trying to open directories
  624.      for writing.  */
  625.   if (!stat (pathname, &st))
  626.     {
  627.       if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
  628.         {
  629.           remote_fileio_reply (-1, FILEIO_ENODEV);
  630.           return;
  631.         }
  632.       if (S_ISDIR (st.st_mode)
  633.           && ((flags & O_WRONLY) == O_WRONLY || (flags & O_RDWR) == O_RDWR))
  634.         {
  635.           remote_fileio_reply (-1, FILEIO_EISDIR);
  636.           return;
  637.         }
  638.     }

  640.   remote_fio_no_longjmp = 1;
  641.   fd = gdb_open_cloexec (pathname, flags, mode);
  642.   if (fd < 0)
  643.     {
  644.       remote_fileio_return_errno (-1);
  645.       return;
  646.     }

  648.   fd = remote_fileio_fd_to_targetfd (fd);
  649.   remote_fileio_return_success (fd);
  650. }

  652. static void
  653. ‌remote_fileio_func_close (char *buf)
  654. {
  655.   long num;
  656.   int fd;

  658.   /* Parameter: file descriptor */
  659.   if (remote_fileio_extract_int (&buf, &num))
  660.     {
  661.       remote_fileio_ioerror ();
  662.       return;
  663.     }
  664.   fd = remote_fileio_map_fd ((int) num);
  665.   if (fd == FIO_FD_INVALID)
  666.     {
  667.       remote_fileio_badfd ();
  668.       return;
  669.     }

  671.   remote_fio_no_longjmp = 1;
  672.   if (fd != FIO_FD_CONSOLE_IN && fd != FIO_FD_CONSOLE_OUT && close (fd))
  673.     remote_fileio_return_errno (-1);
  674.   remote_fileio_close_target_fd ((int) num);
  675.   remote_fileio_return_success (0);
  676. }

  678. static void
  679. ‌remote_fileio_func_read (char *buf)
  680. {
  681.   long target_fd, num;
  682.   LONGEST lnum;
  683.   CORE_ADDR ptrval;
  684.   int fd, ret;
  685.   gdb_byte *buffer;
  686.   size_t length;
  687.   off_t old_offset, new_offset;

  689.   /* 1. Parameter: file descriptor */
  690.   if (remote_fileio_extract_int (&buf, &target_fd))
  691.     {
  692.       remote_fileio_ioerror ();
  693.       return;
  694.     }
  695.   fd = remote_fileio_map_fd ((int) target_fd);
  696.   if (fd == FIO_FD_INVALID)
  697.     {
  698.       remote_fileio_badfd ();
  699.       return;
  700.     }
  701.   /* 2. Parameter: buffer pointer */
  702.   if (remote_fileio_extract_long (&buf, &lnum))
  703.     {
  704.       remote_fileio_ioerror ();
  705.       return;
  706.     }
  707.   ptrval = (CORE_ADDR) lnum;
  708.   /* 3. Parameter: buffer length */
  709.   if (remote_fileio_extract_int (&buf, &num))
  710.     {
  711.       remote_fileio_ioerror ();
  712.       return;
  713.     }
  714.   length = (size_t) num;

  716.   switch (fd)
  717.     {
  718.       case FIO_FD_CONSOLE_OUT:
  719.         remote_fileio_badfd ();
  720.         return;
  721.       case FIO_FD_CONSOLE_IN:
  722.         {
  723.           static char *remaining_buf = NULL;
  724.           static int remaining_length = 0;

  726.           buffer = (gdb_byte *) xmalloc (16384);
  727.           if (remaining_buf)
  728.             {
  729.               remote_fio_no_longjmp = 1;
  730.               if (remaining_length > length)
  731.                 {
  732.                   memcpy (buffer, remaining_buf, length);
  733.                   memmove (remaining_buf, remaining_buf + length,
  734.                            remaining_length - length);
  735.                   remaining_length -= length;
  736.                   ret = length;
  737.                 }
  738.               else
  739.                 {
  740.                   memcpy (buffer, remaining_buf, remaining_length);
  741.                   xfree (remaining_buf);
  742.                   remaining_buf = NULL;
  743.                   ret = remaining_length;
  744.                 }
  745.             }
  746.           else
  747.             {
  748.               /* Windows (at least XP and Server 2003) has difficulty
  749.                  with large reads from consoles.  If a handle is
  750.                  backed by a real console device, overly large reads
  751.                  from the handle will fail and set errno == ENOMEM.
  752.                  On a Windows Server 2003 system where I tested,
  753.                  reading 26608 bytes from the console was OK, but
  754.                  anything above 26609 bytes would fail.  The limit has
  755.                  been observed to vary on different systems.  So, we
  756.                  limit this read to something smaller than that - by a
  757.                  safe margin, in case the limit depends on system
  758.                  resources or version.  */
  759.               ret = ui_file_read (gdb_stdtargin, (char *) buffer, 16383);
  760.               remote_fio_no_longjmp = 1;
  761.               if (ret > 0 && (size_t)ret > length)
  762.                 {
  763.                   remaining_buf = (char *) xmalloc (ret - length);
  764.                   remaining_length = ret - length;
  765.                   memcpy (remaining_buf, buffer + length, remaining_length);
  766.                   ret = length;
  767.                 }
  768.             }
  769.         }
  770.         break;
  771.       default:
  772.         buffer = (gdb_byte *) xmalloc (length);
  773.         /* POSIX defines EINTR behaviour of read in a weird way.  It's allowed
  774.            for read() to return -1 even if "some" bytes have been read.  It
  775.            has been corrected in SUSv2 but that doesn't help us much...
  776.            Therefore a complete solution must check how many bytes have been
  777.            read on EINTR to return a more reliable value to the target */
  778.         old_offset = lseek (fd, 0, SEEK_CUR);
  779.         remote_fio_no_longjmp = 1;
  780.         ret = read (fd, buffer, length);
  781.         if (ret < 0 && errno == EINTR)
  782.           {
  783.             new_offset = lseek (fd, 0, SEEK_CUR);
  784.             /* If some data has been read, return the number of bytes read.
  785.                The Ctrl-C flag is set in remote_fileio_reply() anyway.  */
  786.             if (old_offset != new_offset)
  787.               ret = new_offset - old_offset;
  788.           }
  789.         break;
  790.     }

  792.   if (ret > 0)
  793.     {
  794.       errno = target_write_memory (ptrval, buffer, ret);
  795.       if (errno != 0)
  796.         ret = -1;
  797.     }

  799.   if (ret < 0)
  800.     remote_fileio_return_errno (-1);
  801.   else
  802.     remote_fileio_return_success (ret);

  804.   xfree (buffer);
  805. }

  807. static void
  808. ‌remote_fileio_func_write (char *buf)
  809. {
  810.   long target_fd, num;
  811.   LONGEST lnum;
  812.   CORE_ADDR ptrval;
  813.   int fd, ret;
  814.   gdb_byte *buffer;
  815.   size_t length;

  817.   /* 1. Parameter: file descriptor */
  818.   if (remote_fileio_extract_int (&buf, &target_fd))
  819.     {
  820.       remote_fileio_ioerror ();
  821.       return;
  822.     }
  823.   fd = remote_fileio_map_fd ((int) target_fd);
  824.   if (fd == FIO_FD_INVALID)
  825.     {
  826.       remote_fileio_badfd ();
  827.       return;
  828.     }
  829.   /* 2. Parameter: buffer pointer */
  830.   if (remote_fileio_extract_long (&buf, &lnum))
  831.     {
  832.       remote_fileio_ioerror ();
  833.       return;
  834.     }
  835.   ptrval = (CORE_ADDR) lnum;
  836.   /* 3. Parameter: buffer length */
  837.   if (remote_fileio_extract_int (&buf, &num))
  838.     {
  839.       remote_fileio_ioerror ();
  840.       return;
  841.     }
  842.   length = (size_t) num;

  844.   buffer = (gdb_byte *) xmalloc (length);
  845.   if (target_read_memory (ptrval, buffer, length) != 0)
  846.     {
  847.       xfree (buffer);
  848.       remote_fileio_ioerror ();
  849.       return;
  850.     }

  852.   remote_fio_no_longjmp = 1;
  853.   switch (fd)
  854.     {
  855.       case FIO_FD_CONSOLE_IN:
  856.         remote_fileio_badfd ();
  857.         xfree (buffer);
  858.         return;
  859.       case FIO_FD_CONSOLE_OUT:
  860.         ui_file_write (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr,
  861.                        (char *) buffer, length);
  862.         gdb_flush (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr);
  863.         ret = length;
  864.         break;
  865.       default:
  866.         ret = write (fd, buffer, length);
  867.         if (ret < 0 && errno == EACCES)
  868.           errno = EBADF; /* Cygwin returns EACCESS when writing to a
  869.                             R/O file.  */
  870.         break;
  871.     }

  873.   if (ret < 0)
  874.     remote_fileio_return_errno (-1);
  875.   else
  876.     remote_fileio_return_success (ret);

  878.   xfree (buffer);
  879. }

  881. static void
  882. ‌remote_fileio_func_lseek (char *buf)
  883. {
  884.   long num;
  885.   LONGEST lnum;
  886.   int fd, flag;
  887.   off_t offset, ret;

  889.   /* 1. Parameter: file descriptor */
  890.   if (remote_fileio_extract_int (&buf, &num))
  891.     {
  892.       remote_fileio_ioerror ();
  893.       return;
  894.     }
  895.   fd = remote_fileio_map_fd ((int) num);
  896.   if (fd == FIO_FD_INVALID)
  897.     {
  898.       remote_fileio_badfd ();
  899.       return;
  900.     }
  901.   else if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
  902.     {
  903.       remote_fileio_reply (-1, FILEIO_ESPIPE);
  904.       return;
  905.     }

  907.   /* 2. Parameter: offset */
  908.   if (remote_fileio_extract_long (&buf, &lnum))
  909.     {
  910.       remote_fileio_ioerror ();
  911.       return;
  912.     }
  913.   offset = (off_t) lnum;
  914.   /* 3. Parameter: flag */
  915.   if (remote_fileio_extract_int (&buf, &num))
  916.     {
  917.       remote_fileio_ioerror ();
  918.       return;
  919.     }
  920.   if (remote_fileio_seek_flag_to_host (num, &flag))
  921.     {
  922.       remote_fileio_reply (-1, FILEIO_EINVAL);
  923.       return;
  924.     }

  926.   remote_fio_no_longjmp = 1;
  927.   ret = lseek (fd, offset, flag);

  929.   if (ret == (off_t) -1)
  930.     remote_fileio_return_errno (-1);
  931.   else
  932.     remote_fileio_return_success (ret);
  933. }

  935. static void
  936. ‌remote_fileio_func_rename (char *buf)
  937. {
  938.   CORE_ADDR old_ptr, new_ptr;
  939.   int old_len, new_len;
  940.   char *oldpath, *newpath;
  941.   int ret, of, nf;
  942.   struct stat ost, nst;

  944.   /* 1. Parameter: Ptr to oldpath / length incl. trailing zero */
  945.   if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len))
  946.     {
  947.       remote_fileio_ioerror ();
  948.       return;
  949.     }

  951.   /* 2. Parameter: Ptr to newpath / length incl. trailing zero */
  952.   if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len))
  953.     {
  954.       remote_fileio_ioerror ();
  955.       return;
  956.     }

  958.   /* Request oldpath using 'm' packet */
  959.   oldpath = alloca (old_len);
  960.   if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0)
  961.     {
  962.       remote_fileio_ioerror ();
  963.       return;
  964.     }

  966.   /* Request newpath using 'm' packet */
  967.   newpath = alloca (new_len);
  968.   if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0)
  969.     {
  970.       remote_fileio_ioerror ();
  971.       return;
  972.     }

  974.   /* Only operate on regular files and directories.  */
  975.   of = stat (oldpath, &ost);
  976.   nf = stat (newpath, &nst);
  977.   if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode))
  978.       || (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode)))
  979.     {
  980.       remote_fileio_reply (-1, FILEIO_EACCES);
  981.       return;
  982.     }

  984.   remote_fio_no_longjmp = 1;
  985.   ret = rename (oldpath, newpath);

  987.   if (ret == -1)
  988.     {
  989.       /* Special case: newpath is a non-empty directory.  Some systems
  990.          return ENOTEMPTY, some return EEXIST.  We coerce that to be
  991.          always EEXIST.  */
  992.       if (errno == ENOTEMPTY)
  993.         errno = EEXIST;
  994. #ifdef __CYGWIN__
  995.       /* Workaround some Cygwin problems with correct errnos.  */
  996.       if (errno == EACCES)
  997.         {
  998.           if (!of && !nf && S_ISDIR (nst.st_mode))
  999.             {
  1000.               if (S_ISREG (ost.st_mode))
  1001.                 errno = EISDIR;
  1002.               else
  1003.                 {
  1004.                   char oldfullpath[PATH_MAX];
  1005.                   char newfullpath[PATH_MAX];
  1006.                   int len;

  1008.                   cygwin_conv_path (CCP_WIN_A_TO_POSIX, oldpath, oldfullpath,
  1009.                                     PATH_MAX);
  1010.                   cygwin_conv_path (CCP_WIN_A_TO_POSIX, newpath, newfullpath,
  1011.                                     PATH_MAX);
  1012.                   len = strlen (oldfullpath);
  1013.                   if (IS_DIR_SEPARATOR (newfullpath[len])
  1014.                       && !filename_ncmp (oldfullpath, newfullpath, len))
  1015.                     errno = EINVAL;
  1016.                   else
  1017.                     errno = EEXIST;
  1018.                 }
  1019.             }
  1020.         }
  1021. #endif

  1023.       remote_fileio_return_errno (-1);
  1024.     }
  1025.   else
  1026.     remote_fileio_return_success (ret);
  1027. }

  1029. static void
  1030. ‌remote_fileio_func_unlink (char *buf)
  1031. {
  1032.   CORE_ADDR ptrval;
  1033.   int length;
  1034.   char *pathname;
  1035.   int ret;
  1036.   struct stat st;

  1038.   /* Parameter: Ptr to pathname / length incl. trailing zero */
  1039.   if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
  1040.     {
  1041.       remote_fileio_ioerror ();
  1042.       return;
  1043.     }
  1044.   /* Request pathname using 'm' packet */
  1045.   pathname = alloca (length);
  1046.   if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
  1047.     {
  1048.       remote_fileio_ioerror ();
  1049.       return;
  1050.     }

  1052.   /* Only operate on regular files (and directories, which allows to return
  1053.      the correct return code).  */
  1054.   if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
  1055.     {
  1056.       remote_fileio_reply (-1, FILEIO_ENODEV);
  1057.       return;
  1058.     }

  1060.   remote_fio_no_longjmp = 1;
  1061.   ret = unlink (pathname);

  1063.   if (ret == -1)
  1064.     remote_fileio_return_errno (-1);
  1065.   else
  1066.     remote_fileio_return_success (ret);
  1067. }

  1069. static void
  1070. ‌remote_fileio_func_stat (char *buf)
  1071. {
  1072.   CORE_ADDR statptr, nameptr;
  1073.   int ret, namelength;
  1074.   char *pathname;
  1075.   LONGEST lnum;
  1076.   struct stat st;
  1077.   struct fio_stat fst;

  1079.   /* 1. Parameter: Ptr to pathname / length incl. trailing zero */
  1080.   if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength))
  1081.     {
  1082.       remote_fileio_ioerror ();
  1083.       return;
  1084.     }

  1086.   /* 2. Parameter: Ptr to struct stat */
  1087.   if (remote_fileio_extract_long (&buf, &lnum))
  1088.     {
  1089.       remote_fileio_ioerror ();
  1090.       return;
  1091.     }
  1092.   statptr = (CORE_ADDR) lnum;

  1094.   /* Request pathname using 'm' packet */
  1095.   pathname = alloca (namelength);
  1096.   if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0)
  1097.     {
  1098.       remote_fileio_ioerror ();
  1099.       return;
  1100.     }

  1102.   remote_fio_no_longjmp = 1;
  1103.   ret = stat (pathname, &st);

  1105.   if (ret == -1)
  1106.     {
  1107.       remote_fileio_return_errno (-1);
  1108.       return;
  1109.     }
  1110.   /* Only operate on regular files and directories.  */
  1111.   if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
  1112.     {
  1113.       remote_fileio_reply (-1, FILEIO_EACCES);
  1114.       return;
  1115.     }
  1116.   if (statptr)
  1117.     {
  1118.       remote_fileio_to_fio_stat (&st, &fst);
  1119.       remote_fileio_to_fio_uint (0, fst.fst_dev);

  1121.       errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst);
  1122.       if (errno != 0)
  1123.         {
  1124.           remote_fileio_return_errno (-1);
  1125.           return;
  1126.         }
  1127.     }
  1128.   remote_fileio_return_success (ret);
  1129. }

  1131. static void
  1132. ‌remote_fileio_func_fstat (char *buf)
  1133. {
  1134.   CORE_ADDR ptrval;
  1135.   int fd, ret;
  1136.   long target_fd;
  1137.   LONGEST lnum;
  1138.   struct stat st;
  1139.   struct fio_stat fst;
  1140.   struct timeval tv;

  1142.   /* 1. Parameter: file descriptor */
  1143.   if (remote_fileio_extract_int (&buf, &target_fd))
  1144.     {
  1145.       remote_fileio_ioerror ();
  1146.       return;
  1147.     }
  1148.   fd = remote_fileio_map_fd ((int) target_fd);
  1149.   if (fd == FIO_FD_INVALID)
  1150.     {
  1151.       remote_fileio_badfd ();
  1152.       return;
  1153.     }
  1154.   /* 2. Parameter: Ptr to struct stat */
  1155.   if (remote_fileio_extract_long (&buf, &lnum))
  1156.     {
  1157.       remote_fileio_ioerror ();
  1158.       return;
  1159.     }
  1160.   ptrval = (CORE_ADDR) lnum;

  1162.   remote_fio_no_longjmp = 1;
  1163.   if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
  1164.     {
  1165.       remote_fileio_to_fio_uint (1, fst.fst_dev);
  1166.       memset (&st, 0, sizeof (st));
  1167.       st.st_mode = S_IFCHR | (fd == FIO_FD_CONSOLE_IN ? S_IRUSR : S_IWUSR);
  1168.       st.st_nlink = 1;
  1169. #ifdef HAVE_GETUID
  1170.       st.st_uid = getuid ();
  1171. #endif
  1172. #ifdef HAVE_GETGID
  1173.       st.st_gid = getgid ();
  1174. #endif
  1175. #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
  1176.       st.st_blksize = 512;
  1177. #endif
  1178. #if HAVE_STRUCT_STAT_ST_BLOCKS
  1179.       st.st_blocks = 0;
  1180. #endif
  1181.       if (!gettimeofday (&tv, NULL))
  1182.         st.st_atime = st.st_mtime = st.st_ctime = tv.tv_sec;
  1183.       else
  1184.         st.st_atime = st.st_mtime = st.st_ctime = (time_t) 0;
  1185.       ret = 0;
  1186.     }
  1187.   else
  1188.     ret = fstat (fd, &st);

  1190.   if (ret == -1)
  1191.     {
  1192.       remote_fileio_return_errno (-1);
  1193.       return;
  1194.     }
  1195.   if (ptrval)
  1196.     {
  1197.       remote_fileio_to_fio_stat (&st, &fst);

  1199.       errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst);
  1200.       if (errno != 0)
  1201.         {
  1202.           remote_fileio_return_errno (-1);
  1203.           return;
  1204.         }
  1205.     }
  1206.   remote_fileio_return_success (ret);
  1207. }

  1209. static void
  1210. ‌remote_fileio_func_gettimeofday (char *buf)
  1211. {
  1212.   LONGEST lnum;
  1213.   CORE_ADDR ptrval;
  1214.   int ret;
  1215.   struct timeval tv;
  1216.   struct fio_timeval ftv;

  1218.   /* 1. Parameter: struct timeval pointer */
  1219.   if (remote_fileio_extract_long (&buf, &lnum))
  1220.     {
  1221.       remote_fileio_ioerror ();
  1222.       return;
  1223.     }
  1224.   ptrval = (CORE_ADDR) lnum;
  1225.   /* 2. Parameter: some pointer value...  */
  1226.   if (remote_fileio_extract_long (&buf, &lnum))
  1227.     {
  1228.       remote_fileio_ioerror ();
  1229.       return;
  1230.     }
  1231.   /* ...which has to be NULL.  */
  1232.   if (lnum)
  1233.     {
  1234.       remote_fileio_reply (-1, FILEIO_EINVAL);
  1235.       return;
  1236.     }

  1238.   remote_fio_no_longjmp = 1;
  1239.   ret = gettimeofday (&tv, NULL);

  1241.   if (ret == -1)
  1242.     {
  1243.       remote_fileio_return_errno (-1);
  1244.       return;
  1245.     }

  1247.   if (ptrval)
  1248.     {
  1249.       remote_fileio_to_fio_timeval (&tv, &ftv);

  1251.       errno = target_write_memory (ptrval, (gdb_byte *) &ftv, sizeof ftv);
  1252.       if (errno != 0)
  1253.         {
  1254.           remote_fileio_return_errno (-1);
  1255.           return;
  1256.         }
  1257.     }
  1258.   remote_fileio_return_success (ret);
  1259. }

  1261. static void
  1262. ‌remote_fileio_func_isatty (char *buf)
  1263. {
  1264.   long target_fd;
  1265.   int fd;

  1267.   /* Parameter: file descriptor */
  1268.   if (remote_fileio_extract_int (&buf, &target_fd))
  1269.     {
  1270.       remote_fileio_ioerror ();
  1271.       return;
  1272.     }
  1273.   remote_fio_no_longjmp = 1;
  1274.   fd = remote_fileio_map_fd ((int) target_fd);
  1275.   remote_fileio_return_success (fd == FIO_FD_CONSOLE_IN ||
  1276.                                   fd == FIO_FD_CONSOLE_OUT ? 1 : 0);
  1277. }

  1279. static void
  1280. ‌remote_fileio_func_system (char *buf)
  1281. {
  1282.   CORE_ADDR ptrval;
  1283.   int ret, length;
  1284.   char *cmdline = NULL;

  1286.   /* Parameter: Ptr to commandline / length incl. trailing zero */
  1287.   if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
  1288.     {
  1289.       remote_fileio_ioerror ();
  1290.       return;
  1291.     }

  1293.   if (length)
  1294.     {
  1295.       /* Request commandline using 'm' packet */
  1296.       cmdline = alloca (length);
  1297.       if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0)
  1298.         {
  1299.           remote_fileio_ioerror ();
  1300.           return;
  1301.         }
  1302.     }

  1304.   /* Check if system(3) has been explicitely allowed using the
  1305.      `set remote system-call-allowed 1' command.  If length is 0,
  1306.      indicating a NULL parameter to the system call, return zero to
  1307.      indicate a shell is not available.  Otherwise fail with EPERM.  */
  1308.   if (!remote_fio_system_call_allowed)
  1309.     {
  1310.       if (!length)
  1311.         remote_fileio_return_success (0);
  1312.       else
  1313.         remote_fileio_reply (-1, FILEIO_EPERM);
  1314.       return;
  1315.     }

  1317.   remote_fio_no_longjmp = 1;
  1318.   ret = system (cmdline);

  1320.   if (!length)
  1321.     remote_fileio_return_success (ret);
  1322.   else if (ret == -1)
  1323.     remote_fileio_return_errno (-1);
  1324.   else
  1325.     remote_fileio_return_success (WEXITSTATUS (ret));
  1326. }

  1328. static struct {
  1329.   char *name;
  1330.   void (*func)(char *);
  1331. ‌} remote_fio_func_map[] = {
  1332.   { "open", remote_fileio_func_open },
  1333.   { "close", remote_fileio_func_close },
  1334.   { "read", remote_fileio_func_read },
  1335.   { "write", remote_fileio_func_write },
  1336.   { "lseek", remote_fileio_func_lseek },
  1337.   { "rename", remote_fileio_func_rename },
  1338.   { "unlink", remote_fileio_func_unlink },
  1339.   { "stat", remote_fileio_func_stat },
  1340.   { "fstat", remote_fileio_func_fstat },
  1341.   { "gettimeofday", remote_fileio_func_gettimeofday },
  1342.   { "isatty", remote_fileio_func_isatty },
  1343.   { "system", remote_fileio_func_system },
  1344.   { NULL, NULL }
  1345. };

  1347. static int
  1348. ‌do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
  1349. {
  1350.   char *buf = buf_arg;
  1351.   char *c;
  1352.   int idx;

  1354.   remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);

  1356.   c = strchr (++buf, ',');
  1357.   if (c)
  1358.     *c++ = '\0';
  1359.   else
  1360.     c = strchr (buf, '\0');
  1361.   for (idx = 0; remote_fio_func_map[idx].name; ++idx)
  1362.     if (!strcmp (remote_fio_func_map[idx].name, buf))
  1363.       break;
  1364.   if (!remote_fio_func_map[idx].name)        /* ERROR: No such function.  */
  1365.     return RETURN_ERROR;
  1366.   remote_fio_func_map[idx].func (c);
  1367.   return 0;
  1368. }

  1370. /* Close any open descriptors, and reinitialize the file mapping.  */

  1372. void
  1373. ‌remote_fileio_reset (void)
  1374. {
  1375.   int ix;

  1377.   for (ix = 0; ix != remote_fio_data.fd_map_size; ix++)
  1378.     {
  1379.       int fd = remote_fio_data.fd_map[ix];

  1381.       if (fd >= 0)
  1382.         close (fd);
  1383.     }
  1384.   if (remote_fio_data.fd_map)
  1385.     {
  1386.       xfree (remote_fio_data.fd_map);
  1387.       remote_fio_data.fd_map = NULL;
  1388.       remote_fio_data.fd_map_size = 0;
  1389.     }
  1390. }

  1392. /* Handle a file I/O request.  BUF points to the packet containing the
  1393.    request.  CTRLC_PENDING_P should be nonzero if the target has not
  1394.    acknowledged the Ctrl-C sent asynchronously earlier.  */

  1396. void
  1397. ‌remote_fileio_request (char *buf, int ctrlc_pending_p)
  1398. {
  1399.   int ex;

  1401.   remote_fileio_sig_init ();

  1403.   if (ctrlc_pending_p)
  1404.     {
  1405.       /* If the target hasn't responded to the Ctrl-C sent
  1406.          asynchronously earlier, take this opportunity to send the
  1407.          Ctrl-C synchronously.  */
  1408.       remote_fio_ctrl_c_flag = 1;
  1409.       remote_fio_no_longjmp = 0;
  1410.       remote_fileio_reply (-1, FILEIO_EINTR);
  1411.     }
  1412.   else
  1413.     {
  1414.       remote_fio_ctrl_c_flag = 0;
  1415.       remote_fio_no_longjmp = 0;

  1417.       ex = catch_exceptions (current_uiout,
  1418.                              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.     }

  1433.   remote_fileio_sig_exit ();
  1434. }

  1436. static void
  1437. ‌set_system_call_allowed (char *args, int from_tty)
  1438. {
  1439.   if (args)
  1440.     {
  1441.       char *arg_end;
  1442.       int val = strtoul (args, &arg_end, 10);

  1444.       if (*args && *arg_end == '\0')
  1445.         {
  1446.           remote_fio_system_call_allowed = !!val;
  1447.           return;
  1448.         }
  1449.     }
  1450.   error (_("Illegal argument for \"set remote system-call-allowed\" command"));
  1451. }

  1453. static void
  1454. ‌show_system_call_allowed (char *args, int from_tty)
  1455. {
  1456.   if (args)
  1457.     error (_("Garbage after \"show remote "
  1458.              "system-call-allowed\" command: `%s'"), args);
  1459.   printf_unfiltered ("Calling host system(3) call from target is %sallowed\n",
  1460.                      remote_fio_system_call_allowed ? "" : "not ");
  1461. }

  1463. void
  1464. ‌initialize_remote_fileio (struct cmd_list_element *remote_set_cmdlist,
  1465.                           struct cmd_list_element *remote_show_cmdlist)
  1466. {
  1467.   sigint_fileio_token =
  1468.     create_async_signal_handler (async_remote_fileio_interrupt, NULL);

  1470.   add_cmd ("system-call-allowed", no_class,
  1471.            set_system_call_allowed,
  1472.            _("Set if the host system(3) call is allowed for the target."),
  1473.            &remote_set_cmdlist);
  1474.   add_cmd ("system-call-allowed", no_class,
  1475.            show_system_call_allowed,
  1476.            _("Show if the host system(3) call is allowed for the target."),
  1477.            &remote_show_cmdlist);
  1478. }