1 /* Host file transfer support for gdbserver.
2 Copyright (C) 2007-2024 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 "gdbsupport/fileio.h"
27 #include <sys/types.h>
29 #include "gdbsupport/fileio.h"
37 static struct fd_list
*open_fds
;
40 safe_fromhex (char a
, int *nibble
)
42 if (a
>= '0' && a
<= '9')
44 else if (a
>= 'a' && a
<= 'f')
45 *nibble
= a
- 'a' + 10;
46 else if (a
>= 'A' && a
<= 'F')
47 *nibble
= a
- 'A' + 10;
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)
59 # define HOSTIO_PATH_MAX PATH_MAX
63 require_filename (char **pp
, char *filename
)
71 while (*p
&& *p
!= ',')
75 /* Don't allow overflow. */
76 if (count
>= HOSTIO_PATH_MAX
- 1)
79 if (safe_fromhex (p
[0], &nib1
)
80 || safe_fromhex (p
[1], &nib2
))
83 filename
[count
++] = nib1
* 16 + nib2
;
87 filename
[count
] = '\0';
93 require_int (char **pp
, int *value
)
96 int count
, firstdigit
;
103 while (*p
&& *p
!= ',')
107 if (safe_fromhex (p
[0], &nib
))
110 if (firstdigit
== -1)
113 /* Don't allow overflow. */
114 if (count
>= 8 || (count
== 7 && firstdigit
>= 0x8))
117 *value
= *value
* 16 + nib
;
127 require_data (char *p
, int p_len
, char **data
, int *data_len
)
129 int input_index
, output_index
, escaped
;
131 *data
= (char *) xmalloc (p_len
);
135 for (input_index
= 0; input_index
< p_len
; input_index
++)
137 char b
= p
[input_index
];
141 (*data
)[output_index
++] = b
^ 0x20;
147 (*data
)[output_index
++] = b
;
156 *data_len
= output_index
;
161 require_comma (char **pp
)
173 require_end (char *p
)
182 require_valid_fd (int fd
)
184 struct fd_list
*fd_ptr
;
186 for (fd_ptr
= open_fds
; fd_ptr
!= NULL
; fd_ptr
= fd_ptr
->next
)
187 if (fd_ptr
->fd
== fd
)
193 /* Fill BUF with an hostio error packet representing the last hostio
194 error, from errno. */
197 hostio_error (char *own_buf
)
199 int fileio_error
= host_to_fileio_error (errno
);
200 sprintf (own_buf
, "F-1,%x", fileio_error
);
204 hostio_packet_error (char *own_buf
)
206 sprintf (own_buf
, "F-1,%x", FILEIO_EINVAL
);
210 hostio_reply (char *own_buf
, int result
)
212 sprintf (own_buf
, "F%x", result
);
216 hostio_reply_with_data (char *own_buf
, char *buffer
, int len
,
219 int input_index
, output_index
, out_maxlen
;
221 sprintf (own_buf
, "F%x;", len
);
222 output_index
= strlen (own_buf
);
224 out_maxlen
= PBUFSIZ
;
226 for (input_index
= 0; input_index
< len
; input_index
++)
228 char b
= buffer
[input_index
];
230 if (b
== '$' || b
== '#' || b
== '}' || b
== '*')
232 /* These must be escaped. */
233 if (output_index
+ 2 > out_maxlen
)
235 own_buf
[output_index
++] = '}';
236 own_buf
[output_index
++] = b
^ 0x20;
240 if (output_index
+ 1 > out_maxlen
)
242 own_buf
[output_index
++] = b
;
246 *new_packet_len
= output_index
;
250 /* Process ID of inferior whose filesystem hostio functions
251 that take FILENAME arguments will use. Zero means to use
252 our own filesystem. */
254 static int hostio_fs_pid
;
259 hostio_handle_new_gdb_connection (void)
264 /* Handle a "vFile:setfs:" packet. */
267 handle_setfs (char *own_buf
)
272 /* If the target doesn't have any of the in-filesystem-of methods
273 then there's no point in GDB sending "vFile:setfs:" packets. We
274 reply with an empty packet (i.e. we pretend we don't understand
275 "vFile:setfs:") and that should stop GDB sending any more. */
276 if (!the_target
->supports_multifs ())
282 p
= own_buf
+ strlen ("vFile:setfs:");
284 if (require_int (&p
, &pid
)
288 hostio_packet_error (own_buf
);
294 hostio_reply (own_buf
, 0);
298 handle_open (char *own_buf
)
300 char filename
[HOSTIO_PATH_MAX
];
302 int fileio_flags
, fileio_mode
, flags
, fd
;
304 struct fd_list
*new_fd
;
306 p
= own_buf
+ strlen ("vFile:open:");
308 if (require_filename (&p
, filename
)
309 || require_comma (&p
)
310 || require_int (&p
, &fileio_flags
)
311 || require_comma (&p
)
312 || require_int (&p
, &fileio_mode
)
314 || fileio_to_host_openflags (fileio_flags
, &flags
)
315 || fileio_to_host_mode (fileio_mode
, &mode
))
317 hostio_packet_error (own_buf
);
321 /* We do not need to convert MODE, since the fileio protocol
322 uses the standard values. */
323 if (hostio_fs_pid
!= 0)
324 fd
= the_target
->multifs_open (hostio_fs_pid
, filename
, flags
, mode
);
326 fd
= open (filename
, flags
, mode
);
330 hostio_error (own_buf
);
334 /* Record the new file descriptor. */
335 new_fd
= XNEW (struct fd_list
);
337 new_fd
->next
= open_fds
;
340 hostio_reply (own_buf
, fd
);
344 handle_pread (char *own_buf
, int *new_packet_len
)
346 int fd
, ret
, len
, offset
, bytes_sent
;
348 static int max_reply_size
= -1;
350 p
= own_buf
+ strlen ("vFile:pread:");
352 if (require_int (&p
, &fd
)
353 || require_comma (&p
)
354 || require_valid_fd (fd
)
355 || require_int (&p
, &len
)
356 || require_comma (&p
)
357 || require_int (&p
, &offset
)
360 hostio_packet_error (own_buf
);
364 /* Do not attempt to read more than the maximum number of bytes
365 hostio_reply_with_data can fit in a packet. We may still read
366 too much because of escaping, but this is handled below. */
367 if (max_reply_size
== -1)
369 sprintf (own_buf
, "F%x;", PBUFSIZ
);
370 max_reply_size
= PBUFSIZ
- strlen (own_buf
);
372 if (len
> max_reply_size
)
373 len
= max_reply_size
;
375 data
= (char *) xmalloc (len
);
377 ret
= pread (fd
, data
, len
, offset
);
381 /* If we have no pread or it failed for this file, use lseek/read. */
384 ret
= lseek (fd
, offset
, SEEK_SET
);
386 ret
= read (fd
, data
, len
);
391 hostio_error (own_buf
);
396 bytes_sent
= hostio_reply_with_data (own_buf
, data
, ret
, new_packet_len
);
398 /* If we were using read, and the data did not all fit in the reply,
399 we would have to back up using lseek here. With pread it does
400 not matter. But we still have a problem; the return value in the
401 packet might be wrong, so we must fix it. This time it will
403 if (bytes_sent
< ret
)
404 bytes_sent
= hostio_reply_with_data (own_buf
, data
, bytes_sent
,
411 handle_pwrite (char *own_buf
, int packet_len
)
413 int fd
, ret
, len
, offset
;
416 p
= own_buf
+ strlen ("vFile:pwrite:");
418 if (require_int (&p
, &fd
)
419 || require_comma (&p
)
420 || require_valid_fd (fd
)
421 || require_int (&p
, &offset
)
422 || require_comma (&p
)
423 || require_data (p
, packet_len
- (p
- own_buf
), &data
, &len
))
425 hostio_packet_error (own_buf
);
430 ret
= pwrite (fd
, data
, len
, offset
);
434 /* If we have no pwrite or it failed for this file, use lseek/write. */
437 ret
= lseek (fd
, offset
, SEEK_SET
);
439 ret
= write (fd
, data
, len
);
444 hostio_error (own_buf
);
449 hostio_reply (own_buf
, ret
);
454 handle_fstat (char *own_buf
, int *new_packet_len
)
461 p
= own_buf
+ strlen ("vFile:fstat:");
463 if (require_int (&p
, &fd
)
464 || require_valid_fd (fd
)
467 hostio_packet_error (own_buf
);
471 if (fstat (fd
, &st
) == -1)
473 hostio_error (own_buf
);
477 host_to_fileio_stat (&st
, &fst
);
479 bytes_sent
= hostio_reply_with_data (own_buf
,
480 (char *) &fst
, sizeof (fst
),
483 /* If the response does not fit into a single packet, do not attempt
484 to return a partial response, but simply fail. */
485 if (bytes_sent
< sizeof (fst
))
490 handle_close (char *own_buf
)
494 struct fd_list
**open_fd_p
, *old_fd
;
496 p
= own_buf
+ strlen ("vFile:close:");
498 if (require_int (&p
, &fd
)
499 || require_valid_fd (fd
)
502 hostio_packet_error (own_buf
);
510 hostio_error (own_buf
);
514 open_fd_p
= &open_fds
;
515 /* We know that fd is in the list, thanks to require_valid_fd. */
516 while ((*open_fd_p
)->fd
!= fd
)
517 open_fd_p
= &(*open_fd_p
)->next
;
520 *open_fd_p
= (*open_fd_p
)->next
;
523 hostio_reply (own_buf
, ret
);
527 handle_unlink (char *own_buf
)
529 char filename
[HOSTIO_PATH_MAX
];
533 p
= own_buf
+ strlen ("vFile:unlink:");
535 if (require_filename (&p
, filename
)
538 hostio_packet_error (own_buf
);
542 if (hostio_fs_pid
!= 0)
543 ret
= the_target
->multifs_unlink (hostio_fs_pid
, filename
);
545 ret
= unlink (filename
);
549 hostio_error (own_buf
);
553 hostio_reply (own_buf
, ret
);
557 handle_readlink (char *own_buf
, int *new_packet_len
)
559 char filename
[HOSTIO_PATH_MAX
], linkname
[HOSTIO_PATH_MAX
];
563 p
= own_buf
+ strlen ("vFile:readlink:");
565 if (require_filename (&p
, filename
)
568 hostio_packet_error (own_buf
);
572 if (hostio_fs_pid
!= 0)
573 ret
= the_target
->multifs_readlink (hostio_fs_pid
, filename
,
575 sizeof (linkname
) - 1);
577 ret
= readlink (filename
, linkname
, sizeof (linkname
) - 1);
581 hostio_error (own_buf
);
585 bytes_sent
= hostio_reply_with_data (own_buf
, linkname
, ret
, new_packet_len
);
587 /* If the response does not fit into a single packet, do not attempt
588 to return a partial response, but simply fail. */
589 if (bytes_sent
< ret
)
590 sprintf (own_buf
, "F-1,%x", FILEIO_ENAMETOOLONG
);
593 /* Handle all the 'F' file transfer packets. */
596 handle_vFile (char *own_buf
, int packet_len
, int *new_packet_len
)
598 if (startswith (own_buf
, "vFile:open:"))
599 handle_open (own_buf
);
600 else if (startswith (own_buf
, "vFile:pread:"))
601 handle_pread (own_buf
, new_packet_len
);
602 else if (startswith (own_buf
, "vFile:pwrite:"))
603 handle_pwrite (own_buf
, packet_len
);
604 else if (startswith (own_buf
, "vFile:fstat:"))
605 handle_fstat (own_buf
, new_packet_len
);
606 else if (startswith (own_buf
, "vFile:close:"))
607 handle_close (own_buf
);
608 else if (startswith (own_buf
, "vFile:unlink:"))
609 handle_unlink (own_buf
);
610 else if (startswith (own_buf
, "vFile:readlink:"))
611 handle_readlink (own_buf
, new_packet_len
);
612 else if (startswith (own_buf
, "vFile:setfs:"))
613 handle_setfs (own_buf
);