1 /* Remote File-I/O communications
3 Copyright (C) 2003-2016 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. */
27 #include "remote-fileio.h"
28 #include "event-loop.h"
30 #include "filenames.h"
31 #include "filestuff.h"
34 #include "gdb_sys_time.h"
36 #include <sys/cygwin.h> /* For cygwin_conv_path. */
45 #define FIO_FD_INVALID -1
46 #define FIO_FD_CONSOLE_IN -2
47 #define FIO_FD_CONSOLE_OUT -3
49 static int remote_fio_system_call_allowed
= 0;
52 remote_fileio_init_fd_map (void)
56 if (!remote_fio_data
.fd_map
)
58 remote_fio_data
.fd_map
= XNEWVEC (int, 10);
59 remote_fio_data
.fd_map_size
= 10;
60 remote_fio_data
.fd_map
[0] = FIO_FD_CONSOLE_IN
;
61 remote_fio_data
.fd_map
[1] = FIO_FD_CONSOLE_OUT
;
62 remote_fio_data
.fd_map
[2] = FIO_FD_CONSOLE_OUT
;
63 for (i
= 3; i
< 10; ++i
)
64 remote_fio_data
.fd_map
[i
] = FIO_FD_INVALID
;
70 remote_fileio_resize_fd_map (void)
72 int i
= remote_fio_data
.fd_map_size
;
74 if (!remote_fio_data
.fd_map
)
75 return remote_fileio_init_fd_map ();
76 remote_fio_data
.fd_map_size
+= 10;
77 remote_fio_data
.fd_map
=
78 (int *) xrealloc (remote_fio_data
.fd_map
,
79 remote_fio_data
.fd_map_size
* sizeof (int));
80 for (; i
< remote_fio_data
.fd_map_size
; i
++)
81 remote_fio_data
.fd_map
[i
] = FIO_FD_INVALID
;
82 return remote_fio_data
.fd_map_size
- 10;
86 remote_fileio_next_free_fd (void)
90 for (i
= 0; i
< remote_fio_data
.fd_map_size
; ++i
)
91 if (remote_fio_data
.fd_map
[i
] == FIO_FD_INVALID
)
93 return remote_fileio_resize_fd_map ();
97 remote_fileio_fd_to_targetfd (int fd
)
99 int target_fd
= remote_fileio_next_free_fd ();
101 remote_fio_data
.fd_map
[target_fd
] = fd
;
106 remote_fileio_map_fd (int target_fd
)
108 remote_fileio_init_fd_map ();
109 if (target_fd
< 0 || target_fd
>= remote_fio_data
.fd_map_size
)
110 return FIO_FD_INVALID
;
111 return remote_fio_data
.fd_map
[target_fd
];
115 remote_fileio_close_target_fd (int target_fd
)
117 remote_fileio_init_fd_map ();
118 if (target_fd
>= 0 && target_fd
< remote_fio_data
.fd_map_size
)
119 remote_fio_data
.fd_map
[target_fd
] = FIO_FD_INVALID
;
123 remote_fileio_oflags_to_host (long flags
)
127 if (flags
& FILEIO_O_CREAT
)
129 if (flags
& FILEIO_O_EXCL
)
131 if (flags
& FILEIO_O_TRUNC
)
133 if (flags
& FILEIO_O_APPEND
)
135 if (flags
& FILEIO_O_RDONLY
)
137 if (flags
& FILEIO_O_WRONLY
)
139 if (flags
& FILEIO_O_RDWR
)
141 /* On systems supporting binary and text mode, always open files in
150 remote_fileio_mode_to_host (long mode
, int open_call
)
156 if (mode
& FILEIO_S_IFREG
)
158 if (mode
& FILEIO_S_IFDIR
)
160 if (mode
& FILEIO_S_IFCHR
)
163 if (mode
& FILEIO_S_IRUSR
)
165 if (mode
& FILEIO_S_IWUSR
)
167 if (mode
& FILEIO_S_IXUSR
)
170 if (mode
& FILEIO_S_IRGRP
)
174 if (mode
& FILEIO_S_IWGRP
)
178 if (mode
& FILEIO_S_IXGRP
)
181 if (mode
& FILEIO_S_IROTH
)
184 if (mode
& FILEIO_S_IWOTH
)
188 if (mode
& FILEIO_S_IXOTH
)
195 remote_fileio_seek_flag_to_host (long num
, int *flag
)
201 case FILEIO_SEEK_SET
:
204 case FILEIO_SEEK_CUR
:
207 case FILEIO_SEEK_END
:
217 remote_fileio_extract_long (char **buf
, LONGEST
*retlong
)
222 if (!buf
|| !*buf
|| !**buf
|| !retlong
)
224 c
= strchr (*buf
, ',');
228 c
= strchr (*buf
, '\0');
229 while (strchr ("+-", **buf
))
235 for (*retlong
= 0; **buf
; ++*buf
)
238 if (**buf
>= '0' && **buf
<= '9')
239 *retlong
+= **buf
- '0';
240 else if (**buf
>= 'a' && **buf
<= 'f')
241 *retlong
+= **buf
- 'a' + 10;
242 else if (**buf
>= 'A' && **buf
<= 'F')
243 *retlong
+= **buf
- 'A' + 10;
253 remote_fileio_extract_int (char **buf
, long *retint
)
260 ret
= remote_fileio_extract_long (buf
, &retlong
);
262 *retint
= (long) retlong
;
267 remote_fileio_extract_ptr_w_len (char **buf
, CORE_ADDR
*ptrval
, int *length
)
272 if (!buf
|| !*buf
|| !**buf
|| !ptrval
|| !length
)
274 c
= strchr (*buf
, '/');
278 if (remote_fileio_extract_long (buf
, &retlong
))
280 *ptrval
= (CORE_ADDR
) retlong
;
282 if (remote_fileio_extract_long (buf
, &retlong
))
284 *length
= (int) retlong
;
289 remote_fileio_to_fio_long (LONGEST num
, fio_long_t fnum
)
291 host_to_bigendian (num
, (char *) fnum
, 8);
295 remote_fileio_to_fio_timeval (struct timeval
*tv
, struct fio_timeval
*ftv
)
297 host_to_fileio_time (tv
->tv_sec
, ftv
->ftv_sec
);
298 remote_fileio_to_fio_long (tv
->tv_usec
, ftv
->ftv_usec
);
301 /* The quit handler originally installed. */
302 static quit_handler_ftype
*remote_fileio_o_quit_handler
;
304 /* What to do on a QUIT call while handling a file I/O request. We
305 throw a quit exception, which is caught by remote_fileio_request
306 and translated to an EINTR reply back to the target. */
309 remote_fileio_quit_handler (void)
315 remote_fileio_reply (int retcode
, int error
)
318 int ctrl_c
= check_quit_flag ();
326 sprintf (buf
+ strlen (buf
), "%x", retcode
);
330 error
= FILEIO_EINTR
;
336 sprintf (buf
+ strlen (buf
), ",%x", error
);
340 quit_handler
= remote_fileio_o_quit_handler
;
345 remote_fileio_ioerror (void)
347 remote_fileio_reply (-1, FILEIO_EIO
);
351 remote_fileio_badfd (void)
353 remote_fileio_reply (-1, FILEIO_EBADF
);
357 remote_fileio_return_errno (int retcode
)
359 remote_fileio_reply (retcode
, retcode
< 0
360 ? host_to_fileio_error (errno
) : 0);
364 remote_fileio_return_success (int retcode
)
366 remote_fileio_reply (retcode
, 0);
370 remote_fileio_func_open (char *buf
)
380 /* 1. Parameter: Ptr to pathname / length incl. trailing zero. */
381 if (remote_fileio_extract_ptr_w_len (&buf
, &ptrval
, &length
))
383 remote_fileio_ioerror ();
386 /* 2. Parameter: open flags */
387 if (remote_fileio_extract_int (&buf
, &num
))
389 remote_fileio_ioerror ();
392 flags
= remote_fileio_oflags_to_host (num
);
393 /* 3. Parameter: open mode */
394 if (remote_fileio_extract_int (&buf
, &num
))
396 remote_fileio_ioerror ();
399 mode
= remote_fileio_mode_to_host (num
, 1);
401 /* Request pathname. */
402 pathname
= (char *) alloca (length
);
403 if (target_read_memory (ptrval
, (gdb_byte
*) pathname
, length
) != 0)
405 remote_fileio_ioerror ();
409 /* Check if pathname exists and is not a regular file or directory. If so,
410 return an appropriate error code. Same for trying to open directories
412 if (!stat (pathname
, &st
))
414 if (!S_ISREG (st
.st_mode
) && !S_ISDIR (st
.st_mode
))
416 remote_fileio_reply (-1, FILEIO_ENODEV
);
419 if (S_ISDIR (st
.st_mode
)
420 && ((flags
& O_WRONLY
) == O_WRONLY
|| (flags
& O_RDWR
) == O_RDWR
))
422 remote_fileio_reply (-1, FILEIO_EISDIR
);
427 fd
= gdb_open_cloexec (pathname
, flags
, mode
);
430 remote_fileio_return_errno (-1);
434 fd
= remote_fileio_fd_to_targetfd (fd
);
435 remote_fileio_return_success (fd
);
439 remote_fileio_func_close (char *buf
)
444 /* Parameter: file descriptor */
445 if (remote_fileio_extract_int (&buf
, &num
))
447 remote_fileio_ioerror ();
450 fd
= remote_fileio_map_fd ((int) num
);
451 if (fd
== FIO_FD_INVALID
)
453 remote_fileio_badfd ();
457 if (fd
!= FIO_FD_CONSOLE_IN
&& fd
!= FIO_FD_CONSOLE_OUT
&& close (fd
))
458 remote_fileio_return_errno (-1);
459 remote_fileio_close_target_fd ((int) num
);
460 remote_fileio_return_success (0);
464 remote_fileio_func_read (char *buf
)
472 off_t old_offset
, new_offset
;
474 /* 1. Parameter: file descriptor */
475 if (remote_fileio_extract_int (&buf
, &target_fd
))
477 remote_fileio_ioerror ();
480 fd
= remote_fileio_map_fd ((int) target_fd
);
481 if (fd
== FIO_FD_INVALID
)
483 remote_fileio_badfd ();
486 /* 2. Parameter: buffer pointer */
487 if (remote_fileio_extract_long (&buf
, &lnum
))
489 remote_fileio_ioerror ();
492 ptrval
= (CORE_ADDR
) lnum
;
493 /* 3. Parameter: buffer length */
494 if (remote_fileio_extract_int (&buf
, &num
))
496 remote_fileio_ioerror ();
499 length
= (size_t) num
;
503 case FIO_FD_CONSOLE_OUT
:
504 remote_fileio_badfd ();
506 case FIO_FD_CONSOLE_IN
:
508 static char *remaining_buf
= NULL
;
509 static int remaining_length
= 0;
511 buffer
= (gdb_byte
*) xmalloc (16384);
514 if (remaining_length
> length
)
516 memcpy (buffer
, remaining_buf
, length
);
517 memmove (remaining_buf
, remaining_buf
+ length
,
518 remaining_length
- length
);
519 remaining_length
-= length
;
524 memcpy (buffer
, remaining_buf
, remaining_length
);
525 xfree (remaining_buf
);
526 remaining_buf
= NULL
;
527 ret
= remaining_length
;
532 /* Windows (at least XP and Server 2003) has difficulty
533 with large reads from consoles. If a handle is
534 backed by a real console device, overly large reads
535 from the handle will fail and set errno == ENOMEM.
536 On a Windows Server 2003 system where I tested,
537 reading 26608 bytes from the console was OK, but
538 anything above 26609 bytes would fail. The limit has
539 been observed to vary on different systems. So, we
540 limit this read to something smaller than that - by a
541 safe margin, in case the limit depends on system
542 resources or version. */
543 ret
= ui_file_read (gdb_stdtargin
, (char *) buffer
, 16383);
544 if (ret
> 0 && (size_t)ret
> length
)
546 remaining_buf
= (char *) xmalloc (ret
- length
);
547 remaining_length
= ret
- length
;
548 memcpy (remaining_buf
, buffer
+ length
, remaining_length
);
555 buffer
= (gdb_byte
*) xmalloc (length
);
556 /* POSIX defines EINTR behaviour of read in a weird way. It's allowed
557 for read() to return -1 even if "some" bytes have been read. It
558 has been corrected in SUSv2 but that doesn't help us much...
559 Therefore a complete solution must check how many bytes have been
560 read on EINTR to return a more reliable value to the target */
561 old_offset
= lseek (fd
, 0, SEEK_CUR
);
562 ret
= read (fd
, buffer
, length
);
563 if (ret
< 0 && errno
== EINTR
)
565 new_offset
= lseek (fd
, 0, SEEK_CUR
);
566 /* If some data has been read, return the number of bytes read.
567 The Ctrl-C flag is set in remote_fileio_reply() anyway. */
568 if (old_offset
!= new_offset
)
569 ret
= new_offset
- old_offset
;
576 errno
= target_write_memory (ptrval
, buffer
, ret
);
582 remote_fileio_return_errno (-1);
584 remote_fileio_return_success (ret
);
590 remote_fileio_func_write (char *buf
)
599 /* 1. Parameter: file descriptor */
600 if (remote_fileio_extract_int (&buf
, &target_fd
))
602 remote_fileio_ioerror ();
605 fd
= remote_fileio_map_fd ((int) target_fd
);
606 if (fd
== FIO_FD_INVALID
)
608 remote_fileio_badfd ();
611 /* 2. Parameter: buffer pointer */
612 if (remote_fileio_extract_long (&buf
, &lnum
))
614 remote_fileio_ioerror ();
617 ptrval
= (CORE_ADDR
) lnum
;
618 /* 3. Parameter: buffer length */
619 if (remote_fileio_extract_int (&buf
, &num
))
621 remote_fileio_ioerror ();
624 length
= (size_t) num
;
626 buffer
= (gdb_byte
*) xmalloc (length
);
627 if (target_read_memory (ptrval
, buffer
, length
) != 0)
630 remote_fileio_ioerror ();
636 case FIO_FD_CONSOLE_IN
:
637 remote_fileio_badfd ();
640 case FIO_FD_CONSOLE_OUT
:
641 ui_file_write (target_fd
== 1 ? gdb_stdtarg
: gdb_stdtargerr
,
642 (char *) buffer
, length
);
643 gdb_flush (target_fd
== 1 ? gdb_stdtarg
: gdb_stdtargerr
);
647 ret
= write (fd
, buffer
, length
);
648 if (ret
< 0 && errno
== EACCES
)
649 errno
= EBADF
; /* Cygwin returns EACCESS when writing to a
655 remote_fileio_return_errno (-1);
657 remote_fileio_return_success (ret
);
663 remote_fileio_func_lseek (char *buf
)
670 /* 1. Parameter: file descriptor */
671 if (remote_fileio_extract_int (&buf
, &num
))
673 remote_fileio_ioerror ();
676 fd
= remote_fileio_map_fd ((int) num
);
677 if (fd
== FIO_FD_INVALID
)
679 remote_fileio_badfd ();
682 else if (fd
== FIO_FD_CONSOLE_IN
|| fd
== FIO_FD_CONSOLE_OUT
)
684 remote_fileio_reply (-1, FILEIO_ESPIPE
);
688 /* 2. Parameter: offset */
689 if (remote_fileio_extract_long (&buf
, &lnum
))
691 remote_fileio_ioerror ();
694 offset
= (off_t
) lnum
;
695 /* 3. Parameter: flag */
696 if (remote_fileio_extract_int (&buf
, &num
))
698 remote_fileio_ioerror ();
701 if (remote_fileio_seek_flag_to_host (num
, &flag
))
703 remote_fileio_reply (-1, FILEIO_EINVAL
);
707 ret
= lseek (fd
, offset
, flag
);
709 if (ret
== (off_t
) -1)
710 remote_fileio_return_errno (-1);
712 remote_fileio_return_success (ret
);
716 remote_fileio_func_rename (char *buf
)
718 CORE_ADDR old_ptr
, new_ptr
;
719 int old_len
, new_len
;
720 char *oldpath
, *newpath
;
722 struct stat ost
, nst
;
724 /* 1. Parameter: Ptr to oldpath / length incl. trailing zero */
725 if (remote_fileio_extract_ptr_w_len (&buf
, &old_ptr
, &old_len
))
727 remote_fileio_ioerror ();
731 /* 2. Parameter: Ptr to newpath / length incl. trailing zero */
732 if (remote_fileio_extract_ptr_w_len (&buf
, &new_ptr
, &new_len
))
734 remote_fileio_ioerror ();
738 /* Request oldpath using 'm' packet */
739 oldpath
= (char *) alloca (old_len
);
740 if (target_read_memory (old_ptr
, (gdb_byte
*) oldpath
, old_len
) != 0)
742 remote_fileio_ioerror ();
746 /* Request newpath using 'm' packet */
747 newpath
= (char *) alloca (new_len
);
748 if (target_read_memory (new_ptr
, (gdb_byte
*) newpath
, new_len
) != 0)
750 remote_fileio_ioerror ();
754 /* Only operate on regular files and directories. */
755 of
= stat (oldpath
, &ost
);
756 nf
= stat (newpath
, &nst
);
757 if ((!of
&& !S_ISREG (ost
.st_mode
) && !S_ISDIR (ost
.st_mode
))
758 || (!nf
&& !S_ISREG (nst
.st_mode
) && !S_ISDIR (nst
.st_mode
)))
760 remote_fileio_reply (-1, FILEIO_EACCES
);
764 ret
= rename (oldpath
, newpath
);
768 /* Special case: newpath is a non-empty directory. Some systems
769 return ENOTEMPTY, some return EEXIST. We coerce that to be
771 if (errno
== ENOTEMPTY
)
774 /* Workaround some Cygwin problems with correct errnos. */
777 if (!of
&& !nf
&& S_ISDIR (nst
.st_mode
))
779 if (S_ISREG (ost
.st_mode
))
783 char oldfullpath
[PATH_MAX
];
784 char newfullpath
[PATH_MAX
];
787 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, oldpath
, oldfullpath
,
789 cygwin_conv_path (CCP_WIN_A_TO_POSIX
, newpath
, newfullpath
,
791 len
= strlen (oldfullpath
);
792 if (IS_DIR_SEPARATOR (newfullpath
[len
])
793 && !filename_ncmp (oldfullpath
, newfullpath
, len
))
802 remote_fileio_return_errno (-1);
805 remote_fileio_return_success (ret
);
809 remote_fileio_func_unlink (char *buf
)
817 /* Parameter: Ptr to pathname / length incl. trailing zero */
818 if (remote_fileio_extract_ptr_w_len (&buf
, &ptrval
, &length
))
820 remote_fileio_ioerror ();
823 /* Request pathname using 'm' packet */
824 pathname
= (char *) alloca (length
);
825 if (target_read_memory (ptrval
, (gdb_byte
*) pathname
, length
) != 0)
827 remote_fileio_ioerror ();
831 /* Only operate on regular files (and directories, which allows to return
832 the correct return code). */
833 if (!stat (pathname
, &st
) && !S_ISREG (st
.st_mode
) && !S_ISDIR (st
.st_mode
))
835 remote_fileio_reply (-1, FILEIO_ENODEV
);
839 ret
= unlink (pathname
);
842 remote_fileio_return_errno (-1);
844 remote_fileio_return_success (ret
);
848 remote_fileio_func_stat (char *buf
)
850 CORE_ADDR statptr
, nameptr
;
857 /* 1. Parameter: Ptr to pathname / length incl. trailing zero */
858 if (remote_fileio_extract_ptr_w_len (&buf
, &nameptr
, &namelength
))
860 remote_fileio_ioerror ();
864 /* 2. Parameter: Ptr to struct stat */
865 if (remote_fileio_extract_long (&buf
, &lnum
))
867 remote_fileio_ioerror ();
870 statptr
= (CORE_ADDR
) lnum
;
872 /* Request pathname using 'm' packet */
873 pathname
= (char *) alloca (namelength
);
874 if (target_read_memory (nameptr
, (gdb_byte
*) pathname
, namelength
) != 0)
876 remote_fileio_ioerror ();
880 ret
= stat (pathname
, &st
);
884 remote_fileio_return_errno (-1);
887 /* Only operate on regular files and directories. */
888 if (!ret
&& !S_ISREG (st
.st_mode
) && !S_ISDIR (st
.st_mode
))
890 remote_fileio_reply (-1, FILEIO_EACCES
);
895 host_to_fileio_stat (&st
, &fst
);
896 host_to_fileio_uint (0, fst
.fst_dev
);
898 errno
= target_write_memory (statptr
, (gdb_byte
*) &fst
, sizeof fst
);
901 remote_fileio_return_errno (-1);
905 remote_fileio_return_success (ret
);
909 remote_fileio_func_fstat (char *buf
)
919 /* 1. Parameter: file descriptor */
920 if (remote_fileio_extract_int (&buf
, &target_fd
))
922 remote_fileio_ioerror ();
925 fd
= remote_fileio_map_fd ((int) target_fd
);
926 if (fd
== FIO_FD_INVALID
)
928 remote_fileio_badfd ();
931 /* 2. Parameter: Ptr to struct stat */
932 if (remote_fileio_extract_long (&buf
, &lnum
))
934 remote_fileio_ioerror ();
937 ptrval
= (CORE_ADDR
) lnum
;
939 if (fd
== FIO_FD_CONSOLE_IN
|| fd
== FIO_FD_CONSOLE_OUT
)
941 host_to_fileio_uint (1, fst
.fst_dev
);
942 memset (&st
, 0, sizeof (st
));
943 st
.st_mode
= S_IFCHR
| (fd
== FIO_FD_CONSOLE_IN
? S_IRUSR
: S_IWUSR
);
946 st
.st_uid
= getuid ();
949 st
.st_gid
= getgid ();
951 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
954 #if HAVE_STRUCT_STAT_ST_BLOCKS
957 if (!gettimeofday (&tv
, NULL
))
958 st
.st_atime
= st
.st_mtime
= st
.st_ctime
= tv
.tv_sec
;
960 st
.st_atime
= st
.st_mtime
= st
.st_ctime
= (time_t) 0;
964 ret
= fstat (fd
, &st
);
968 remote_fileio_return_errno (-1);
973 host_to_fileio_stat (&st
, &fst
);
975 errno
= target_write_memory (ptrval
, (gdb_byte
*) &fst
, sizeof fst
);
978 remote_fileio_return_errno (-1);
982 remote_fileio_return_success (ret
);
986 remote_fileio_func_gettimeofday (char *buf
)
992 struct fio_timeval ftv
;
994 /* 1. Parameter: struct timeval pointer */
995 if (remote_fileio_extract_long (&buf
, &lnum
))
997 remote_fileio_ioerror ();
1000 ptrval
= (CORE_ADDR
) lnum
;
1001 /* 2. Parameter: some pointer value... */
1002 if (remote_fileio_extract_long (&buf
, &lnum
))
1004 remote_fileio_ioerror ();
1007 /* ...which has to be NULL. */
1010 remote_fileio_reply (-1, FILEIO_EINVAL
);
1014 ret
= gettimeofday (&tv
, NULL
);
1018 remote_fileio_return_errno (-1);
1024 remote_fileio_to_fio_timeval (&tv
, &ftv
);
1026 errno
= target_write_memory (ptrval
, (gdb_byte
*) &ftv
, sizeof ftv
);
1029 remote_fileio_return_errno (-1);
1033 remote_fileio_return_success (ret
);
1037 remote_fileio_func_isatty (char *buf
)
1042 /* Parameter: file descriptor */
1043 if (remote_fileio_extract_int (&buf
, &target_fd
))
1045 remote_fileio_ioerror ();
1048 fd
= remote_fileio_map_fd ((int) target_fd
);
1049 remote_fileio_return_success (fd
== FIO_FD_CONSOLE_IN
||
1050 fd
== FIO_FD_CONSOLE_OUT
? 1 : 0);
1054 remote_fileio_func_system (char *buf
)
1058 char *cmdline
= NULL
;
1060 /* Parameter: Ptr to commandline / length incl. trailing zero */
1061 if (remote_fileio_extract_ptr_w_len (&buf
, &ptrval
, &length
))
1063 remote_fileio_ioerror ();
1069 /* Request commandline using 'm' packet */
1070 cmdline
= (char *) alloca (length
);
1071 if (target_read_memory (ptrval
, (gdb_byte
*) cmdline
, length
) != 0)
1073 remote_fileio_ioerror ();
1078 /* Check if system(3) has been explicitely allowed using the
1079 `set remote system-call-allowed 1' command. If length is 0,
1080 indicating a NULL parameter to the system call, return zero to
1081 indicate a shell is not available. Otherwise fail with EPERM. */
1082 if (!remote_fio_system_call_allowed
)
1085 remote_fileio_return_success (0);
1087 remote_fileio_reply (-1, FILEIO_EPERM
);
1091 ret
= system (cmdline
);
1094 remote_fileio_return_success (ret
);
1096 remote_fileio_return_errno (-1);
1098 remote_fileio_return_success (WEXITSTATUS (ret
));
1103 void (*func
)(char *);
1104 } remote_fio_func_map
[] = {
1105 { "open", remote_fileio_func_open
},
1106 { "close", remote_fileio_func_close
},
1107 { "read", remote_fileio_func_read
},
1108 { "write", remote_fileio_func_write
},
1109 { "lseek", remote_fileio_func_lseek
},
1110 { "rename", remote_fileio_func_rename
},
1111 { "unlink", remote_fileio_func_unlink
},
1112 { "stat", remote_fileio_func_stat
},
1113 { "fstat", remote_fileio_func_fstat
},
1114 { "gettimeofday", remote_fileio_func_gettimeofday
},
1115 { "isatty", remote_fileio_func_isatty
},
1116 { "system", remote_fileio_func_system
},
1121 do_remote_fileio_request (struct ui_out
*uiout
, void *buf_arg
)
1123 char *buf
= (char *) buf_arg
;
1127 quit_handler
= remote_fileio_quit_handler
;
1129 c
= strchr (++buf
, ',');
1133 c
= strchr (buf
, '\0');
1134 for (idx
= 0; remote_fio_func_map
[idx
].name
; ++idx
)
1135 if (!strcmp (remote_fio_func_map
[idx
].name
, buf
))
1137 if (!remote_fio_func_map
[idx
].name
) /* ERROR: No such function. */
1138 return RETURN_ERROR
;
1139 remote_fio_func_map
[idx
].func (c
);
1143 /* Close any open descriptors, and reinitialize the file mapping. */
1146 remote_fileio_reset (void)
1150 for (ix
= 0; ix
!= remote_fio_data
.fd_map_size
; ix
++)
1152 int fd
= remote_fio_data
.fd_map
[ix
];
1157 if (remote_fio_data
.fd_map
)
1159 xfree (remote_fio_data
.fd_map
);
1160 remote_fio_data
.fd_map
= NULL
;
1161 remote_fio_data
.fd_map_size
= 0;
1165 /* Handle a file I/O request. BUF points to the packet containing the
1166 request. CTRLC_PENDING_P should be nonzero if the target has not
1167 acknowledged the Ctrl-C sent asynchronously earlier. */
1170 remote_fileio_request (char *buf
, int ctrlc_pending_p
)
1174 /* Save the previous quit handler, so we can restore it. No need
1175 for a cleanup since we catch all exceptions below. Note that the
1176 quit handler is also restored by remote_fileio_reply just before
1177 pushing a packet. */
1178 remote_fileio_o_quit_handler
= quit_handler
;
1180 if (ctrlc_pending_p
)
1182 /* If the target hasn't responded to the Ctrl-C sent
1183 asynchronously earlier, take this opportunity to send the
1184 Ctrl-C synchronously. */
1186 remote_fileio_reply (-1, FILEIO_EINTR
);
1190 ex
= catch_exceptions (current_uiout
,
1191 do_remote_fileio_request
, (void *)buf
,
1196 remote_fileio_reply (-1, FILEIO_ENOSYS
);
1199 remote_fileio_reply (-1, FILEIO_EINTR
);
1206 quit_handler
= remote_fileio_o_quit_handler
;
1210 /* Unpack an fio_uint_t. */
1213 remote_fileio_to_host_uint (fio_uint_t fnum
)
1215 return extract_unsigned_integer ((gdb_byte
*) fnum
, 4,
1219 /* Unpack an fio_ulong_t. */
1222 remote_fileio_to_host_ulong (fio_ulong_t fnum
)
1224 return extract_unsigned_integer ((gdb_byte
*) fnum
, 8,
1228 /* Unpack an fio_mode_t. */
1231 remote_fileio_to_host_mode (fio_mode_t fnum
)
1233 return remote_fileio_mode_to_host (remote_fileio_to_host_uint (fnum
),
1237 /* Unpack an fio_time_t. */
1240 remote_fileio_to_host_time (fio_time_t fnum
)
1242 return remote_fileio_to_host_uint (fnum
);
1246 /* See remote-fileio.h. */
1249 remote_fileio_to_host_stat (struct fio_stat
*fst
, struct stat
*st
)
1251 memset (st
, 0, sizeof (struct stat
));
1253 st
->st_dev
= remote_fileio_to_host_uint (fst
->fst_dev
);
1254 st
->st_ino
= remote_fileio_to_host_uint (fst
->fst_ino
);
1255 st
->st_mode
= remote_fileio_to_host_mode (fst
->fst_mode
);
1256 st
->st_nlink
= remote_fileio_to_host_uint (fst
->fst_nlink
);
1257 st
->st_uid
= remote_fileio_to_host_uint (fst
->fst_uid
);
1258 st
->st_gid
= remote_fileio_to_host_uint (fst
->fst_gid
);
1259 st
->st_rdev
= remote_fileio_to_host_uint (fst
->fst_rdev
);
1260 st
->st_size
= remote_fileio_to_host_ulong (fst
->fst_size
);
1261 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1262 st
->st_blksize
= remote_fileio_to_host_ulong (fst
->fst_blksize
);
1264 #if HAVE_STRUCT_STAT_ST_BLOCKS
1265 st
->st_blocks
= remote_fileio_to_host_ulong (fst
->fst_blocks
);
1267 st
->st_atime
= remote_fileio_to_host_time (fst
->fst_atime
);
1268 st
->st_mtime
= remote_fileio_to_host_time (fst
->fst_mtime
);
1269 st
->st_ctime
= remote_fileio_to_host_time (fst
->fst_ctime
);
1274 set_system_call_allowed (char *args
, int from_tty
)
1279 int val
= strtoul (args
, &arg_end
, 10);
1281 if (*args
&& *arg_end
== '\0')
1283 remote_fio_system_call_allowed
= !!val
;
1287 error (_("Illegal argument for \"set remote system-call-allowed\" command"));
1291 show_system_call_allowed (char *args
, int from_tty
)
1294 error (_("Garbage after \"show remote "
1295 "system-call-allowed\" command: `%s'"), args
);
1296 printf_unfiltered ("Calling host system(3) call from target is %sallowed\n",
1297 remote_fio_system_call_allowed
? "" : "not ");
1301 initialize_remote_fileio (struct cmd_list_element
*remote_set_cmdlist
,
1302 struct cmd_list_element
*remote_show_cmdlist
)
1304 add_cmd ("system-call-allowed", no_class
,
1305 set_system_call_allowed
,
1306 _("Set if the host system(3) call is allowed for the target."),
1307 &remote_set_cmdlist
);
1308 add_cmd ("system-call-allowed", no_class
,
1309 show_system_call_allowed
,
1310 _("Show if the host system(3) call is allowed for the target."),
1311 &remote_show_cmdlist
);