1 /* Host file transfer support for gdbserver.
2 Copyright (C) 2007-2020 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/>. */
22 #include "gdb/fileio.h"
28 #include <sys/types.h>
30 #include "gdbsupport/fileio.h"
38 static struct fd_list
*open_fds
;
41 safe_fromhex (char a
, int *nibble
)
43 if (a
>= '0' && a
<= '9')
45 else if (a
>= 'a' && a
<= 'f')
46 *nibble
= a
- 'a' + 10;
47 else if (a
>= 'A' && a
<= 'F')
48 *nibble
= a
- 'A' + 10;
55 /* Filenames are hex encoded, so the maximum we can handle is half the
56 packet buffer size. Cap to PATH_MAX, if it is shorter. */
57 #if !defined (PATH_MAX) || (PATH_MAX > (PBUFSIZ / 2 + 1))
58 # define HOSTIO_PATH_MAX (PBUFSIZ / 2 + 1)
60 # define HOSTIO_PATH_MAX PATH_MAX
64 require_filename (char **pp
, char *filename
)
72 while (*p
&& *p
!= ',')
76 /* Don't allow overflow. */
77 if (count
>= HOSTIO_PATH_MAX
- 1)
80 if (safe_fromhex (p
[0], &nib1
)
81 || safe_fromhex (p
[1], &nib2
))
84 filename
[count
++] = nib1
* 16 + nib2
;
88 filename
[count
] = '\0';
94 require_int (char **pp
, int *value
)
97 int count
, firstdigit
;
104 while (*p
&& *p
!= ',')
108 if (safe_fromhex (p
[0], &nib
))
111 if (firstdigit
== -1)
114 /* Don't allow overflow. */
115 if (count
>= 8 || (count
== 7 && firstdigit
>= 0x8))
118 *value
= *value
* 16 + nib
;
128 require_data (char *p
, int p_len
, char **data
, int *data_len
)
130 int input_index
, output_index
, escaped
;
132 *data
= (char *) xmalloc (p_len
);
136 for (input_index
= 0; input_index
< p_len
; input_index
++)
138 char b
= p
[input_index
];
142 (*data
)[output_index
++] = b
^ 0x20;
148 (*data
)[output_index
++] = b
;
157 *data_len
= output_index
;
162 require_comma (char **pp
)
174 require_end (char *p
)
183 require_valid_fd (int fd
)
185 struct fd_list
*fd_ptr
;
187 for (fd_ptr
= open_fds
; fd_ptr
!= NULL
; fd_ptr
= fd_ptr
->next
)
188 if (fd_ptr
->fd
== fd
)
194 /* Fill in own_buf with the last hostio error packet, however it
195 suitable for the target. */
197 hostio_error (char *own_buf
)
199 the_target
->pt
->hostio_last_error (own_buf
);
203 hostio_packet_error (char *own_buf
)
205 sprintf (own_buf
, "F-1,%x", FILEIO_EINVAL
);
209 hostio_reply (char *own_buf
, int result
)
211 sprintf (own_buf
, "F%x", result
);
215 hostio_reply_with_data (char *own_buf
, char *buffer
, int len
,
218 int input_index
, output_index
, out_maxlen
;
220 sprintf (own_buf
, "F%x;", len
);
221 output_index
= strlen (own_buf
);
223 out_maxlen
= PBUFSIZ
;
225 for (input_index
= 0; input_index
< len
; input_index
++)
227 char b
= buffer
[input_index
];
229 if (b
== '$' || b
== '#' || b
== '}' || b
== '*')
231 /* These must be escaped. */
232 if (output_index
+ 2 > out_maxlen
)
234 own_buf
[output_index
++] = '}';
235 own_buf
[output_index
++] = b
^ 0x20;
239 if (output_index
+ 1 > out_maxlen
)
241 own_buf
[output_index
++] = b
;
245 *new_packet_len
= output_index
;
249 /* Process ID of inferior whose filesystem hostio functions
250 that take FILENAME arguments will use. Zero means to use
251 our own filesystem. */
253 static int hostio_fs_pid
;
258 hostio_handle_new_gdb_connection (void)
263 /* Handle a "vFile:setfs:" packet. */
266 handle_setfs (char *own_buf
)
271 /* If the target doesn't have any of the in-filesystem-of methods
272 then there's no point in GDB sending "vFile:setfs:" packets. We
273 reply with an empty packet (i.e. we pretend we don't understand
274 "vFile:setfs:") and that should stop GDB sending any more. */
275 if (!the_target
->pt
->supports_multifs ())
281 p
= own_buf
+ strlen ("vFile:setfs:");
283 if (require_int (&p
, &pid
)
287 hostio_packet_error (own_buf
);
293 hostio_reply (own_buf
, 0);
297 handle_open (char *own_buf
)
299 char filename
[HOSTIO_PATH_MAX
];
301 int fileio_flags
, fileio_mode
, flags
, fd
;
303 struct fd_list
*new_fd
;
305 p
= own_buf
+ strlen ("vFile:open:");
307 if (require_filename (&p
, filename
)
308 || require_comma (&p
)
309 || require_int (&p
, &fileio_flags
)
310 || require_comma (&p
)
311 || require_int (&p
, &fileio_mode
)
313 || fileio_to_host_openflags (fileio_flags
, &flags
)
314 || fileio_to_host_mode (fileio_mode
, &mode
))
316 hostio_packet_error (own_buf
);
320 /* We do not need to convert MODE, since the fileio protocol
321 uses the standard values. */
322 if (hostio_fs_pid
!= 0)
323 fd
= the_target
->pt
->multifs_open (hostio_fs_pid
, filename
,
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
->pt
->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
->pt
->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
);
This page took 0.041989 seconds and 4 git commands to generate.