gdb/gdbserver/hostio.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Host file transfer support for gdbserver.
  2.    Copyright (C) 2007-2015 Free Software Foundation, Inc.

  4.    Contributed by CodeSourcery.

  6.    This file is part of GDB.

  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.

  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.

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

  21. #include "server.h"
  22. #include "gdb/fileio.h"
  23. #include "hostio.h"

  25. #include <fcntl.h>
  26. #include <limits.h>
  27. #include <unistd.h>

  29. extern int remote_debug;

  31. ‌struct fd_list
  32. {
  33.   int fd;
  34.   struct fd_list *next;
  35. };

  37. ‌static struct fd_list *open_fds;

  39. static int
  40. ‌safe_fromhex (char a, int *nibble)
  41. {
  42.   if (a >= '0' && a <= '9')
  43.     *nibble = a - '0';
  44.   else if (a >= 'a' && a <= 'f')
  45.     *nibble = a - 'a' + 10;
  46.   else if (a >= 'A' && a <= 'F')
  47.     *nibble = a - 'A' + 10;
  48.   else
  49.     return -1;

  51.   return 0;
  52. }

  54. /* Filenames are hex encoded, so the maximum we can handle is half the
  55.    packet buffer size.  Cap to PATH_MAX, if it is shorter.  */
  56. #if !defined (PATH_MAX) || (PATH_MAX > (PBUFSIZ / 2 + 1))
  57. ‌#  define HOSTIO_PATH_MAX (PBUFSIZ / 2 + 1)
  58. #else
  59. ‌#  define HOSTIO_PATH_MAX PATH_MAX
  60. #endif

  62. static int
  63. ‌require_filename (char **pp, char *filename)
  64. {
  65.   int count;
  66.   char *p;

  68.   p = *pp;
  69.   count = 0;

  71.   while (*p && *p != ',')
  72.     {
  73.       int nib1, nib2;

  75.       /* Don't allow overflow.  */
  76.       if (count >= HOSTIO_PATH_MAX - 1)
  77.         return -1;

  79.       if (safe_fromhex (p[0], &nib1)
  80.           || safe_fromhex (p[1], &nib2))
  81.         return -1;

  83.       filename[count++] = nib1 * 16 + nib2;
  84.       p += 2;
  85.     }

  87.   filename[count] = '\0';
  88.   *pp = p;
  89.   return 0;
  90. }

  92. static int
  93. ‌require_int (char **pp, int *value)
  94. {
  95.   char *p;
  96.   int count;

  98.   p = *pp;
  99.   *value = 0;
  100.   count = 0;

  102.   while (*p && *p != ',')
  103.     {
  104.       int nib;

  106.       /* Don't allow overflow.  */
  107.       if (count >= 7)
  108.         return -1;

  110.       if (safe_fromhex (p[0], &nib))
  111.         return -1;
  112.       *value = *value * 16 + nib;
  113.       p++;
  114.       count++;
  115.     }

  117.   *pp = p;
  118.   return 0;
  119. }

  121. static int
  122. ‌require_data (char *p, int p_len, char **data, int *data_len)
  123. {
  124.   int input_index, output_index, escaped;

  126.   *data = xmalloc (p_len);

  128.   output_index = 0;
  129.   escaped = 0;
  130.   for (input_index = 0; input_index < p_len; input_index++)
  131.     {
  132.       char b = p[input_index];

  134.       if (escaped)
  135.         {
  136.           (*data)[output_index++] = b ^ 0x20;
  137.           escaped = 0;
  138.         }
  139.       else if (b == '}')
  140.         escaped = 1;
  141.       else
  142.         (*data)[output_index++] = b;
  143.     }

  145.   if (escaped)
  146.     {
  147.       free (*data);
  148.       return -1;
  149.     }

  151.   *data_len = output_index;
  152.   return 0;
  153. }

  155. static int
  156. ‌require_comma (char **pp)
  157. {
  158.   if (**pp == ',')
  159.     {
  160.       (*pp)++;
  161.       return 0;
  162.     }
  163.   else
  164.     return -1;
  165. }

  167. static int
  168. ‌require_end (char *p)
  169. {
  170.   if (*p == '\0')
  171.     return 0;
  172.   else
  173.     return -1;
  174. }

  176. static int
  177. ‌require_valid_fd (int fd)
  178. {
  179.   struct fd_list *fd_ptr;

  181.   for (fd_ptr = open_fds; fd_ptr != NULL; fd_ptr = fd_ptr->next)
  182.     if (fd_ptr->fd == fd)
  183.       return 0;

  185.   return -1;
  186. }

  188. /* Fill in own_buf with the last hostio error packet, however it
  189.    suitable for the target.  */
  190. static void
  191. ‌hostio_error (char *own_buf)
  192. {
  193.   the_target->hostio_last_error (own_buf);
  194. }

  196. static void
  197. ‌hostio_packet_error (char *own_buf)
  198. {
  199.   sprintf (own_buf, "F-1,%x", FILEIO_EINVAL);
  200. }

  202. static void
  203. ‌hostio_reply (char *own_buf, int result)
  204. {
  205.   sprintf (own_buf, "F%x", result);
  206. }

  208. static int
  209. ‌hostio_reply_with_data (char *own_buf, char *buffer, int len,
  210.                         int *new_packet_len)
  211. {
  212.   int input_index, output_index, out_maxlen;

  214.   sprintf (own_buf, "F%x;", len);
  215.   output_index = strlen (own_buf);

  217.   out_maxlen = PBUFSIZ;

  219.   for (input_index = 0; input_index < len; input_index++)
  220.     {
  221.       char b = buffer[input_index];

  223.       if (b == '$' || b == '#' || b == '}' || b == '*')
  224.         {
  225.           /* These must be escaped.  */
  226.           if (output_index + 2 > out_maxlen)
  227.             break;
  228.           own_buf[output_index++] = '}';
  229.           own_buf[output_index++] = b ^ 0x20;
  230.         }
  231.       else
  232.         {
  233.           if (output_index + 1 > out_maxlen)
  234.             break;
  235.           own_buf[output_index++] = b;
  236.         }
  237.     }

  239.   *new_packet_len = output_index;
  240.   return input_index;
  241. }

  243. static int
  244. ‌fileio_open_flags_to_host (int fileio_open_flags, int *open_flags_p)
  245. {
  246.   int open_flags = 0;

  248.   if (fileio_open_flags & ~FILEIO_O_SUPPORTED)
  249.     return -1;

  251.   if (fileio_open_flags & FILEIO_O_CREAT)
  252.     open_flags |= O_CREAT;
  253.   if (fileio_open_flags & FILEIO_O_EXCL)
  254.     open_flags |= O_EXCL;
  255.   if (fileio_open_flags & FILEIO_O_TRUNC)
  256.     open_flags |= O_TRUNC;
  257.   if (fileio_open_flags & FILEIO_O_APPEND)
  258.     open_flags |= O_APPEND;
  259.   if (fileio_open_flags & FILEIO_O_RDONLY)
  260.     open_flags |= O_RDONLY;
  261.   if (fileio_open_flags & FILEIO_O_WRONLY)
  262.     open_flags |= O_WRONLY;
  263.   if (fileio_open_flags & FILEIO_O_RDWR)
  264.     open_flags |= O_RDWR;
  265. /* On systems supporting binary and text mode, always open files in
  266.    binary mode. */
  267. #ifdef O_BINARY
  268.   open_flags |= O_BINARY;
  269. #endif

  271.   *open_flags_p = open_flags;
  272.   return 0;
  273. }

  275. static void
  276. ‌handle_open (char *own_buf)
  277. {
  278.   char filename[HOSTIO_PATH_MAX];
  279.   char *p;
  280.   int fileio_flags, mode, flags, fd;
  281.   struct fd_list *new_fd;

  283.   p = own_buf + strlen ("vFile:open:");

  285.   if (require_filename (&p, filename)
  286.       || require_comma (&p)
  287.       || require_int (&p, &fileio_flags)
  288.       || require_comma (&p)
  289.       || require_int (&p, &mode)
  290.       || require_end (p)
  291.       || fileio_open_flags_to_host (fileio_flags, &flags))
  292.     {
  293.       hostio_packet_error (own_buf);
  294.       return;
  295.     }

  297.   /* We do not need to convert MODE, since the fileio protocol
  298.      uses the standard values.  */
  299.   fd = open (filename, flags, mode);

  301.   if (fd == -1)
  302.     {
  303.       hostio_error (own_buf);
  304.       return;
  305.     }

  307.   /* Record the new file descriptor.  */
  308.   new_fd = xmalloc (sizeof (struct fd_list));
  309.   new_fd->fd = fd;
  310.   new_fd->next = open_fds;
  311.   open_fds = new_fd;

  313.   hostio_reply (own_buf, fd);
  314. }

  316. static void
  317. ‌handle_pread (char *own_buf, int *new_packet_len)
  318. {
  319.   int fd, ret, len, offset, bytes_sent;
  320.   char *p, *data;

  322.   p = own_buf + strlen ("vFile:pread:");

  324.   if (require_int (&p, &fd)
  325.       || require_comma (&p)
  326.       || require_valid_fd (fd)
  327.       || require_int (&p, &len)
  328.       || require_comma (&p)
  329.       || require_int (&p, &offset)
  330.       || require_end (p))
  331.     {
  332.       hostio_packet_error (own_buf);
  333.       return;
  334.     }

  336.   data = xmalloc (len);
  337. #ifdef HAVE_PREAD
  338.   ret = pread (fd, data, len, offset);
  339. #else
  340.   ret = -1;
  341. #endif
  342.   /* If we have no pread or it failed for this file, use lseek/read.  */
  343.   if (ret == -1)
  344.     {
  345.       ret = lseek (fd, offset, SEEK_SET);
  346.       if (ret != -1)
  347.         ret = read (fd, data, len);
  348.     }

  350.   if (ret == -1)
  351.     {
  352.       hostio_error (own_buf);
  353.       free (data);
  354.       return;
  355.     }

  357.   bytes_sent = hostio_reply_with_data (own_buf, data, ret, new_packet_len);

  359.   /* If we were using read, and the data did not all fit in the reply,
  360.      we would have to back up using lseek here.  With pread it does
  361.      not matter.  But we still have a problem; the return value in the
  362.      packet might be wrong, so we must fix it.  This time it will
  363.      definitely fit.  */
  364.   if (bytes_sent < ret)
  365.     bytes_sent = hostio_reply_with_data (own_buf, data, bytes_sent,
  366.                                          new_packet_len);

  368.   free (data);
  369. }

  371. static void
  372. ‌handle_pwrite (char *own_buf, int packet_len)
  373. {
  374.   int fd, ret, len, offset;
  375.   char *p, *data;

  377.   p = own_buf + strlen ("vFile:pwrite:");

  379.   if (require_int (&p, &fd)
  380.       || require_comma (&p)
  381.       || require_valid_fd (fd)
  382.       || require_int (&p, &offset)
  383.       || require_comma (&p)
  384.       || require_data (p, packet_len - (p - own_buf), &data, &len))
  385.     {
  386.       hostio_packet_error (own_buf);
  387.       return;
  388.     }

  390. #ifdef HAVE_PWRITE
  391.   ret = pwrite (fd, data, len, offset);
  392. #else
  393.   ret = -1;
  394. #endif
  395.   /* If we have no pwrite or it failed for this file, use lseek/write.  */
  396.   if (ret == -1)
  397.     {
  398.       ret = lseek (fd, offset, SEEK_SET);
  399.       if (ret != -1)
  400.         ret = write (fd, data, len);
  401.     }

  403.   if (ret == -1)
  404.     {
  405.       hostio_error (own_buf);
  406.       free (data);
  407.       return;
  408.     }

  410.   hostio_reply (own_buf, ret);
  411.   free (data);
  412. }

  414. static void
  415. ‌handle_close (char *own_buf)
  416. {
  417.   int fd, ret;
  418.   char *p;
  419.   struct fd_list **open_fd_p, *old_fd;

  421.   p = own_buf + strlen ("vFile:close:");

  423.   if (require_int (&p, &fd)
  424.       || require_valid_fd (fd)
  425.       || require_end (p))
  426.     {
  427.       hostio_packet_error (own_buf);
  428.       return;
  429.     }

  431.   ret = close (fd);

  433.   if (ret == -1)
  434.     {
  435.       hostio_error (own_buf);
  436.       return;
  437.     }

  439.   open_fd_p = &open_fds;
  440.   /* We know that fd is in the list, thanks to require_valid_fd.  */
  441.   while ((*open_fd_p)->fd != fd)
  442.     open_fd_p = &(*open_fd_p)->next;

  444.   old_fd = *open_fd_p;
  445.   *open_fd_p = (*open_fd_p)->next;
  446.   free (old_fd);

  448.   hostio_reply (own_buf, ret);
  449. }

  451. static void
  452. ‌handle_unlink (char *own_buf)
  453. {
  454.   char filename[HOSTIO_PATH_MAX];
  455.   char *p;
  456.   int ret;

  458.   p = own_buf + strlen ("vFile:unlink:");

  460.   if (require_filename (&p, filename)
  461.       || require_end (p))
  462.     {
  463.       hostio_packet_error (own_buf);
  464.       return;
  465.     }

  467.   ret = unlink (filename);

  469.   if (ret == -1)
  470.     {
  471.       hostio_error (own_buf);
  472.       return;
  473.     }

  475.   hostio_reply (own_buf, ret);
  476. }

  478. static void
  479. ‌handle_readlink (char *own_buf, int *new_packet_len)
  480. {
  481.   char filename[HOSTIO_PATH_MAX], linkname[HOSTIO_PATH_MAX];
  482.   char *p;
  483.   int ret, bytes_sent;

  485.   p = own_buf + strlen ("vFile:readlink:");

  487.   if (require_filename (&p, filename)
  488.       || require_end (p))
  489.     {
  490.       hostio_packet_error (own_buf);
  491.       return;
  492.     }

  494.   ret = readlink (filename, linkname, sizeof (linkname) - 1);
  495.   if (ret == -1)
  496.     {
  497.       hostio_error (own_buf);
  498.       return;
  499.     }

  501.   bytes_sent = hostio_reply_with_data (own_buf, linkname, ret, new_packet_len);

  503.   /* If the response does not fit into a single packet, do not attempt
  504.      to return a partial response, but simply fail.  */
  505.   if (bytes_sent < ret)
  506.     sprintf (own_buf, "F-1,%x", FILEIO_ENAMETOOLONG);
  507. }

  509. /* Handle all the 'F' file transfer packets.  */

  511. int
  512. ‌handle_vFile (char *own_buf, int packet_len, int *new_packet_len)
  513. {
  514.   if (strncmp (own_buf, "vFile:open:", 11) == 0)
  515.     handle_open (own_buf);
  516.   else if (strncmp (own_buf, "vFile:pread:", 11) == 0)
  517.     handle_pread (own_buf, new_packet_len);
  518.   else if (strncmp (own_buf, "vFile:pwrite:", 12) == 0)
  519.     handle_pwrite (own_buf, packet_len);
  520.   else if (strncmp (own_buf, "vFile:close:", 12) == 0)
  521.     handle_close (own_buf);
  522.   else if (strncmp (own_buf, "vFile:unlink:", 13) == 0)
  523.     handle_unlink (own_buf);
  524.   else if (strncmp (own_buf, "vFile:readlink:", 15) == 0)
  525.     handle_readlink (own_buf, new_packet_len);
  526.   else
  527.     return 0;

  529.   return 1;
  530. }