gdb/remote-fileio.c

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