X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fremote-fileio.c;h=5b7ef1d197550d318422b9e0333abd3fa3b57413;hb=24ba069af8a2078bc634bbf2599381fc0ea471ad;hp=d2090e602a43a7197392dcbe77be204a2dcb40e4;hpb=1a966eabdfe5d28f2e17f73988c9124cc5b76f31;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/remote-fileio.c b/gdb/remote-fileio.c
index d2090e602a..5b7ef1d197 100644
--- a/gdb/remote-fileio.c
+++ b/gdb/remote-fileio.c
@@ -1,12 +1,12 @@
/* Remote File-I/O communications
- Copyright 2003 Free Software Foundation, Inc.
+ Copyright (C) 2003-2013 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -15,11 +15,9 @@
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see . */
-/* See the GDB User Guide for details of the GDB remote protocol. */
+/* See the GDB User Guide for details of the GDB remote protocol. */
#include "defs.h"
#include "gdb_string.h"
@@ -30,11 +28,15 @@
#include "gdb_stat.h"
#include "exceptions.h"
#include "remote-fileio.h"
+#include "event-loop.h"
+#include "target.h"
+#include "filenames.h"
+#include "filestuff.h"
#include
#include
#ifdef __CYGWIN__
-#include /* For cygwin_conv_to_full_posix_path. */
+#include /* For cygwin_conv_path. */
#endif
#include
@@ -49,6 +51,8 @@ static struct {
static int remote_fio_system_call_allowed = 0;
+static struct async_signal_handler *sigint_fileio_token;
+
static int
remote_fileio_init_fd_map (void)
{
@@ -70,12 +74,16 @@ remote_fileio_init_fd_map (void)
static int
remote_fileio_resize_fd_map (void)
{
+ int i = remote_fio_data.fd_map_size;
+
if (!remote_fio_data.fd_map)
return remote_fileio_init_fd_map ();
remote_fio_data.fd_map_size += 10;
remote_fio_data.fd_map =
(int *) xrealloc (remote_fio_data.fd_map,
remote_fio_data.fd_map_size * sizeof (int));
+ for (; i < remote_fio_data.fd_map_size; i++)
+ remote_fio_data.fd_map[i] = FIO_FD_INVALID;
return remote_fio_data.fd_map_size - 10;
}
@@ -94,6 +102,7 @@ static int
remote_fileio_fd_to_targetfd (int fd)
{
int target_fd = remote_fileio_next_free_fd ();
+
remote_fio_data.fd_map[target_fd] = fd;
return target_fd;
}
@@ -135,7 +144,7 @@ remote_fileio_oflags_to_host (long flags)
if (flags & FILEIO_O_RDWR)
hflags |= O_RDWR;
/* On systems supporting binary and text mode, always open files in
- binary mode. */
+ binary mode. */
#ifdef O_BINARY
hflags |= O_BINARY;
#endif
@@ -162,18 +171,28 @@ remote_fileio_mode_to_host (long mode, int open_call)
hmode |= S_IWUSR;
if (mode & FILEIO_S_IXUSR)
hmode |= S_IXUSR;
+#ifdef S_IRGRP
if (mode & FILEIO_S_IRGRP)
hmode |= S_IRGRP;
+#endif
+#ifdef S_IWGRP
if (mode & FILEIO_S_IWGRP)
hmode |= S_IWGRP;
+#endif
+#ifdef S_IXGRP
if (mode & FILEIO_S_IXGRP)
hmode |= S_IXGRP;
+#endif
if (mode & FILEIO_S_IROTH)
hmode |= S_IROTH;
+#ifdef S_IWOTH
if (mode & FILEIO_S_IWOTH)
hmode |= S_IWOTH;
+#endif
+#ifdef S_IXOTH
if (mode & FILEIO_S_IXOTH)
hmode |= S_IXOTH;
+#endif
return hmode;
}
@@ -182,11 +201,11 @@ remote_fileio_mode_to_target (mode_t mode)
{
mode_t tmode = 0;
- if (mode & S_IFREG)
+ if (S_ISREG(mode))
tmode |= FILEIO_S_IFREG;
- if (mode & S_IFDIR)
+ if (S_ISDIR(mode))
tmode |= FILEIO_S_IFDIR;
- if (mode & S_IFCHR)
+ if (S_ISCHR(mode))
tmode |= FILEIO_S_IFCHR;
if (mode & S_IRUSR)
tmode |= FILEIO_S_IRUSR;
@@ -194,18 +213,28 @@ remote_fileio_mode_to_target (mode_t mode)
tmode |= FILEIO_S_IWUSR;
if (mode & S_IXUSR)
tmode |= FILEIO_S_IXUSR;
+#ifdef S_IRGRP
if (mode & S_IRGRP)
tmode |= FILEIO_S_IRGRP;
+#endif
+#ifdef S_IWRGRP
if (mode & S_IWGRP)
tmode |= FILEIO_S_IWGRP;
+#endif
+#ifdef S_IXGRP
if (mode & S_IXGRP)
tmode |= FILEIO_S_IXGRP;
+#endif
if (mode & S_IROTH)
tmode |= FILEIO_S_IROTH;
+#ifdef S_IWOTH
if (mode & S_IWOTH)
tmode |= FILEIO_S_IWOTH;
+#endif
+#ifdef S_IXOTH
if (mode & S_IXOTH)
tmode |= FILEIO_S_IXOTH;
+#endif
return tmode;
}
@@ -354,7 +383,7 @@ remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length)
return 0;
}
-/* Convert to big endian */
+/* Convert to big endian. */
static void
remote_fileio_to_be (LONGEST num, char *buf, int bytes)
{
@@ -397,7 +426,9 @@ remote_fileio_to_fio_ulong (LONGEST num, fio_ulong_t fnum)
static void
remote_fileio_to_fio_stat (struct stat *st, struct fio_stat *fst)
{
- /* `st_dev' is set in the calling function */
+ LONGEST blksize;
+
+ /* `st_dev' is set in the calling function. */
remote_fileio_to_fio_uint ((long) st->st_ino, fst->fst_ino);
remote_fileio_to_fio_mode (st->st_mode, fst->fst_mode);
remote_fileio_to_fio_uint ((long) st->st_nlink, fst->fst_nlink);
@@ -405,15 +436,20 @@ remote_fileio_to_fio_stat (struct stat *st, struct fio_stat *fst)
remote_fileio_to_fio_uint ((long) st->st_gid, fst->fst_gid);
remote_fileio_to_fio_uint ((long) st->st_rdev, fst->fst_rdev);
remote_fileio_to_fio_ulong ((LONGEST) st->st_size, fst->fst_size);
- remote_fileio_to_fio_ulong ((LONGEST) st->st_blksize, fst->fst_blksize);
+#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
+ blksize = st->st_blksize;
+#else
+ blksize = 512;
+#endif
+ remote_fileio_to_fio_ulong (blksize, fst->fst_blksize);
#if HAVE_STRUCT_STAT_ST_BLOCKS
remote_fileio_to_fio_ulong ((LONGEST) st->st_blocks, fst->fst_blocks);
#else
/* FIXME: This is correct for DJGPP, but other systems that don't
have st_blocks, if any, might prefer 512 instead of st_blksize.
(eliz, 30-12-2003) */
- remote_fileio_to_fio_ulong (((LONGEST) st->st_size + st->st_blksize - 1)
- / (LONGEST) st->st_blksize,
+ remote_fileio_to_fio_ulong (((LONGEST) st->st_size + blksize - 1)
+ / blksize,
fst->fst_blocks);
#endif
remote_fileio_to_fio_time (st->st_atime, fst->fst_atime);
@@ -474,13 +510,19 @@ remote_fileio_sig_exit (void)
#endif
}
+static void
+async_remote_fileio_interrupt (gdb_client_data arg)
+{
+ quit ();
+}
+
static void
remote_fileio_ctrl_c_signal_handler (int signo)
{
remote_fileio_sig_set (SIG_IGN);
remote_fio_ctrl_c_flag = 1;
if (!remote_fio_no_longjmp)
- deprecated_throw_reason (RETURN_QUIT);
+ gdb_call_async_signal_handler (sigint_fileio_token, 1);
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
}
@@ -529,8 +571,8 @@ remote_fileio_badfd (void)
static void
remote_fileio_return_errno (int retcode)
{
- remote_fileio_reply (retcode,
- retcode < 0 ? remote_fileio_errno_to_target (errno) : 0);
+ remote_fileio_reply (retcode, retcode < 0
+ ? remote_fileio_errno_to_target (errno) : 0);
}
static void
@@ -539,36 +581,18 @@ remote_fileio_return_success (int retcode)
remote_fileio_reply (retcode, 0);
}
-/* Wrapper function for remote_write_bytes() which has the disadvantage to
- write only one packet, regardless of the requested number of bytes to
- transfer. This wrapper calls remote_write_bytes() as often as needed. */
-static int
-remote_fileio_write_bytes (CORE_ADDR memaddr, char *myaddr, int len)
-{
- int ret = 0, written;
-
- while (len > 0 && (written = remote_write_bytes (memaddr, myaddr, len)) > 0)
- {
- len -= written;
- memaddr += written;
- myaddr += written;
- ret += written;
- }
- return ret;
-}
-
static void
remote_fileio_func_open (char *buf)
{
CORE_ADDR ptrval;
- int length, retlength;
+ int length;
long num;
int flags, fd;
mode_t mode;
char *pathname;
struct stat st;
- /* 1. Parameter: Ptr to pathname / length incl. trailing zero */
+ /* 1. Parameter: Ptr to pathname / length incl. trailing zero. */
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
{
remote_fileio_ioerror ();
@@ -589,10 +613,9 @@ remote_fileio_func_open (char *buf)
}
mode = remote_fileio_mode_to_host (num, 1);
- /* Request pathname using 'm' packet */
+ /* Request pathname. */
pathname = alloca (length);
- retlength = remote_read_bytes (ptrval, pathname, length);
- if (retlength != length)
+ if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
{
remote_fileio_ioerror ();
return;
@@ -600,7 +623,7 @@ remote_fileio_func_open (char *buf)
/* Check if pathname exists and is not a regular file or directory. If so,
return an appropriate error code. Same for trying to open directories
- for writing. */
+ for writing. */
if (!stat (pathname, &st))
{
if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
@@ -617,7 +640,7 @@ remote_fileio_func_open (char *buf)
}
remote_fio_no_longjmp = 1;
- fd = open (pathname, flags, mode);
+ fd = gdb_open_cloexec (pathname, flags, mode);
if (fd < 0)
{
remote_fileio_return_errno (-1);
@@ -660,8 +683,8 @@ remote_fileio_func_read (char *buf)
long target_fd, num;
LONGEST lnum;
CORE_ADDR ptrval;
- int fd, ret, retlength;
- char *buffer;
+ int fd, ret;
+ gdb_byte *buffer;
size_t length;
off_t old_offset, new_offset;
@@ -702,7 +725,7 @@ remote_fileio_func_read (char *buf)
static char *remaining_buf = NULL;
static int remaining_length = 0;
- buffer = (char *) xmalloc (32768);
+ buffer = (gdb_byte *) xmalloc (16384);
if (remaining_buf)
{
remote_fio_no_longjmp = 1;
@@ -724,7 +747,18 @@ remote_fileio_func_read (char *buf)
}
else
{
- ret = ui_file_read (gdb_stdtargin, buffer, 32767);
+ /* Windows (at least XP and Server 2003) has difficulty
+ with large reads from consoles. If a handle is
+ backed by a real console device, overly large reads
+ from the handle will fail and set errno == ENOMEM.
+ On a Windows Server 2003 system where I tested,
+ reading 26608 bytes from the console was OK, but
+ anything above 26609 bytes would fail. The limit has
+ been observed to vary on different systems. So, we
+ limit this read to something smaller than that - by a
+ safe margin, in case the limit depends on system
+ resources or version. */
+ ret = ui_file_read (gdb_stdtargin, (char *) buffer, 16383);
remote_fio_no_longjmp = 1;
if (ret > 0 && (size_t)ret > length)
{
@@ -737,7 +771,7 @@ remote_fileio_func_read (char *buf)
}
break;
default:
- buffer = (char *) xmalloc (length);
+ buffer = (gdb_byte *) xmalloc (length);
/* POSIX defines EINTR behaviour of read in a weird way. It's allowed
for read() to return -1 even if "some" bytes have been read. It
has been corrected in SUSv2 but that doesn't help us much...
@@ -750,7 +784,7 @@ remote_fileio_func_read (char *buf)
{
new_offset = lseek (fd, 0, SEEK_CUR);
/* If some data has been read, return the number of bytes read.
- The Ctrl-C flag is set in remote_fileio_reply() anyway */
+ The Ctrl-C flag is set in remote_fileio_reply() anyway. */
if (old_offset != new_offset)
ret = new_offset - old_offset;
}
@@ -759,9 +793,9 @@ remote_fileio_func_read (char *buf)
if (ret > 0)
{
- retlength = remote_fileio_write_bytes (ptrval, buffer, ret);
- if (retlength != ret)
- ret = -1; /* errno has been set to EIO in remote_fileio_write_bytes() */
+ errno = target_write_memory (ptrval, buffer, ret);
+ if (errno != 0)
+ ret = -1;
}
if (ret < 0)
@@ -778,8 +812,8 @@ remote_fileio_func_write (char *buf)
long target_fd, num;
LONGEST lnum;
CORE_ADDR ptrval;
- int fd, ret, retlength;
- char *buffer;
+ int fd, ret;
+ gdb_byte *buffer;
size_t length;
/* 1. Parameter: file descriptor */
@@ -809,9 +843,8 @@ remote_fileio_func_write (char *buf)
}
length = (size_t) num;
- buffer = (char *) xmalloc (length);
- retlength = remote_read_bytes (ptrval, buffer, length);
- if (retlength != length)
+ buffer = (gdb_byte *) xmalloc (length);
+ if (target_read_memory (ptrval, buffer, length) != 0)
{
xfree (buffer);
remote_fileio_ioerror ();
@@ -823,17 +856,19 @@ remote_fileio_func_write (char *buf)
{
case FIO_FD_CONSOLE_IN:
remote_fileio_badfd ();
+ xfree (buffer);
return;
case FIO_FD_CONSOLE_OUT:
- ui_file_write (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr, buffer,
- length);
+ ui_file_write (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr,
+ (char *) buffer, length);
gdb_flush (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr);
ret = length;
break;
default:
ret = write (fd, buffer, length);
if (ret < 0 && errno == EACCES)
- errno = EBADF; /* Cygwin returns EACCESS when writing to a R/O file.*/
+ errno = EBADF; /* Cygwin returns EACCESS when writing to a
+ R/O file. */
break;
}
@@ -902,42 +937,43 @@ remote_fileio_func_lseek (char *buf)
static void
remote_fileio_func_rename (char *buf)
{
- CORE_ADDR ptrval;
- int length, retlength;
+ CORE_ADDR old_ptr, new_ptr;
+ int old_len, new_len;
char *oldpath, *newpath;
int ret, of, nf;
struct stat ost, nst;
/* 1. Parameter: Ptr to oldpath / length incl. trailing zero */
- if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
+ if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len))
{
remote_fileio_ioerror ();
return;
}
- /* Request oldpath using 'm' packet */
- oldpath = alloca (length);
- retlength = remote_read_bytes (ptrval, oldpath, length);
- if (retlength != length)
+
+ /* 2. Parameter: Ptr to newpath / length incl. trailing zero */
+ if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len))
{
remote_fileio_ioerror ();
return;
}
- /* 2. Parameter: Ptr to newpath / length incl. trailing zero */
- if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
+
+ /* Request oldpath using 'm' packet */
+ oldpath = alloca (old_len);
+ if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0)
{
remote_fileio_ioerror ();
return;
}
+
/* Request newpath using 'm' packet */
- newpath = alloca (length);
- retlength = remote_read_bytes (ptrval, newpath, length);
- if (retlength != length)
+ newpath = alloca (new_len);
+ if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0)
{
remote_fileio_ioerror ();
return;
}
- /* Only operate on regular files and directories */
+ /* Only operate on regular files and directories. */
of = stat (oldpath, &ost);
nf = stat (newpath, &nst);
if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode))
@@ -954,11 +990,11 @@ remote_fileio_func_rename (char *buf)
{
/* Special case: newpath is a non-empty directory. Some systems
return ENOTEMPTY, some return EEXIST. We coerce that to be
- always EEXIST. */
+ always EEXIST. */
if (errno == ENOTEMPTY)
errno = EEXIST;
#ifdef __CYGWIN__
- /* Workaround some Cygwin problems with correct errnos. */
+ /* Workaround some Cygwin problems with correct errnos. */
if (errno == EACCES)
{
if (!of && !nf && S_ISDIR (nst.st_mode))
@@ -967,15 +1003,17 @@ remote_fileio_func_rename (char *buf)
errno = EISDIR;
else
{
- char oldfullpath[PATH_MAX + 1];
- char newfullpath[PATH_MAX + 1];
+ char oldfullpath[PATH_MAX];
+ char newfullpath[PATH_MAX];
int len;
- cygwin_conv_to_full_posix_path (oldpath, oldfullpath);
- cygwin_conv_to_full_posix_path (newpath, newfullpath);
+ cygwin_conv_path (CCP_WIN_A_TO_POSIX, oldpath, oldfullpath,
+ PATH_MAX);
+ cygwin_conv_path (CCP_WIN_A_TO_POSIX, newpath, newfullpath,
+ PATH_MAX);
len = strlen (oldfullpath);
- if (newfullpath[len] == '/'
- && !strncmp (oldfullpath, newfullpath, len))
+ if (IS_DIR_SEPARATOR (newfullpath[len])
+ && !filename_ncmp (oldfullpath, newfullpath, len))
errno = EINVAL;
else
errno = EEXIST;
@@ -994,7 +1032,7 @@ static void
remote_fileio_func_unlink (char *buf)
{
CORE_ADDR ptrval;
- int length, retlength;
+ int length;
char *pathname;
int ret;
struct stat st;
@@ -1007,15 +1045,14 @@ remote_fileio_func_unlink (char *buf)
}
/* Request pathname using 'm' packet */
pathname = alloca (length);
- retlength = remote_read_bytes (ptrval, pathname, length);
- if (retlength != length)
+ if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
{
remote_fileio_ioerror ();
return;
}
/* Only operate on regular files (and directories, which allows to return
- the correct return code) */
+ the correct return code). */
if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
{
remote_fileio_reply (-1, FILEIO_ENODEV);
@@ -1034,35 +1071,35 @@ remote_fileio_func_unlink (char *buf)
static void
remote_fileio_func_stat (char *buf)
{
- CORE_ADDR ptrval;
- int ret, length, retlength;
+ CORE_ADDR statptr, nameptr;
+ int ret, namelength;
char *pathname;
LONGEST lnum;
struct stat st;
struct fio_stat fst;
/* 1. Parameter: Ptr to pathname / length incl. trailing zero */
- if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
+ if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength))
{
remote_fileio_ioerror ();
return;
}
- /* Request pathname using 'm' packet */
- pathname = alloca (length);
- retlength = remote_read_bytes (ptrval, pathname, length);
- if (retlength != length)
+
+ /* 2. Parameter: Ptr to struct stat */
+ if (remote_fileio_extract_long (&buf, &lnum))
{
remote_fileio_ioerror ();
return;
}
-
- /* 2. Parameter: Ptr to struct stat */
- if (remote_fileio_extract_long (&buf, &lnum))
+ statptr = (CORE_ADDR) lnum;
+
+ /* Request pathname using 'm' packet */
+ pathname = alloca (namelength);
+ if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0)
{
remote_fileio_ioerror ();
return;
}
- ptrval = (CORE_ADDR) lnum;
remote_fio_no_longjmp = 1;
ret = stat (pathname, &st);
@@ -1072,19 +1109,19 @@ remote_fileio_func_stat (char *buf)
remote_fileio_return_errno (-1);
return;
}
- /* Only operate on regular files and directories */
+ /* Only operate on regular files and directories. */
if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
{
remote_fileio_reply (-1, FILEIO_EACCES);
return;
}
- if (ptrval)
+ if (statptr)
{
remote_fileio_to_fio_stat (&st, &fst);
remote_fileio_to_fio_uint (0, fst.fst_dev);
-
- retlength = remote_fileio_write_bytes (ptrval, (char *) &fst, sizeof fst);
- if (retlength != sizeof fst)
+
+ errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst);
+ if (errno != 0)
{
remote_fileio_return_errno (-1);
return;
@@ -1097,7 +1134,7 @@ static void
remote_fileio_func_fstat (char *buf)
{
CORE_ADDR ptrval;
- int fd, ret, retlength;
+ int fd, ret;
long target_fd;
LONGEST lnum;
struct stat st;
@@ -1128,13 +1165,18 @@ remote_fileio_func_fstat (char *buf)
if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
{
remote_fileio_to_fio_uint (1, fst.fst_dev);
+ memset (&st, 0, sizeof (st));
st.st_mode = S_IFCHR | (fd == FIO_FD_CONSOLE_IN ? S_IRUSR : S_IWUSR);
st.st_nlink = 1;
+#ifdef HAVE_GETUID
st.st_uid = getuid ();
+#endif
+#ifdef HAVE_GETGID
st.st_gid = getgid ();
- st.st_rdev = 0;
- st.st_size = 0;
+#endif
+#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
st.st_blksize = 512;
+#endif
#if HAVE_STRUCT_STAT_ST_BLOCKS
st.st_blocks = 0;
#endif
@@ -1156,8 +1198,8 @@ remote_fileio_func_fstat (char *buf)
{
remote_fileio_to_fio_stat (&st, &fst);
- retlength = remote_fileio_write_bytes (ptrval, (char *) &fst, sizeof fst);
- if (retlength != sizeof fst)
+ errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst);
+ if (errno != 0)
{
remote_fileio_return_errno (-1);
return;
@@ -1171,7 +1213,7 @@ remote_fileio_func_gettimeofday (char *buf)
{
LONGEST lnum;
CORE_ADDR ptrval;
- int ret, retlength;
+ int ret;
struct timeval tv;
struct fio_timeval ftv;
@@ -1182,13 +1224,13 @@ remote_fileio_func_gettimeofday (char *buf)
return;
}
ptrval = (CORE_ADDR) lnum;
- /* 2. Parameter: some pointer value... */
+ /* 2. Parameter: some pointer value... */
if (remote_fileio_extract_long (&buf, &lnum))
{
remote_fileio_ioerror ();
return;
}
- /* ...which has to be NULL */
+ /* ...which has to be NULL. */
if (lnum)
{
remote_fileio_reply (-1, FILEIO_EINVAL);
@@ -1208,8 +1250,8 @@ remote_fileio_func_gettimeofday (char *buf)
{
remote_fileio_to_fio_timeval (&tv, &ftv);
- retlength = remote_fileio_write_bytes (ptrval, (char *) &ftv, sizeof ftv);
- if (retlength != sizeof ftv)
+ errno = target_write_memory (ptrval, (gdb_byte *) &ftv, sizeof ftv);
+ if (errno != 0)
{
remote_fileio_return_errno (-1);
return;
@@ -1240,17 +1282,8 @@ static void
remote_fileio_func_system (char *buf)
{
CORE_ADDR ptrval;
- int ret, length, retlength;
- char *cmdline;
-
- /* Check if system(3) has been explicitely allowed using the
- `set remote system-call-allowed 1' command. If not, return
- EPERM */
- if (!remote_fio_system_call_allowed)
- {
- remote_fileio_reply (-1, FILEIO_EPERM);
- return;
- }
+ int ret, length;
+ char *cmdline = NULL;
/* Parameter: Ptr to commandline / length incl. trailing zero */
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
@@ -1258,19 +1291,37 @@ remote_fileio_func_system (char *buf)
remote_fileio_ioerror ();
return;
}
- /* Request commandline using 'm' packet */
- cmdline = alloca (length);
- retlength = remote_read_bytes (ptrval, cmdline, length);
- if (retlength != length)
+
+ if (length)
{
- remote_fileio_ioerror ();
+ /* Request commandline using 'm' packet */
+ cmdline = alloca (length);
+ if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0)
+ {
+ remote_fileio_ioerror ();
+ return;
+ }
+ }
+
+ /* Check if system(3) has been explicitely allowed using the
+ `set remote system-call-allowed 1' command. If length is 0,
+ indicating a NULL parameter to the system call, return zero to
+ indicate a shell is not available. Otherwise fail with EPERM. */
+ if (!remote_fio_system_call_allowed)
+ {
+ if (!length)
+ remote_fileio_return_success (0);
+ else
+ remote_fileio_reply (-1, FILEIO_EPERM);
return;
}
remote_fio_no_longjmp = 1;
ret = system (cmdline);
- if (ret == -1)
+ if (!length)
+ remote_fileio_return_success (ret);
+ else if (ret == -1)
remote_fileio_return_errno (-1);
else
remote_fileio_return_success (WEXITSTATUS (ret));
@@ -1280,19 +1331,19 @@ static struct {
char *name;
void (*func)(char *);
} remote_fio_func_map[] = {
- "open", remote_fileio_func_open,
- "close", remote_fileio_func_close,
- "read", remote_fileio_func_read,
- "write", remote_fileio_func_write,
- "lseek", remote_fileio_func_lseek,
- "rename", remote_fileio_func_rename,
- "unlink", remote_fileio_func_unlink,
- "stat", remote_fileio_func_stat,
- "fstat", remote_fileio_func_fstat,
- "gettimeofday", remote_fileio_func_gettimeofday,
- "isatty", remote_fileio_func_isatty,
- "system", remote_fileio_func_system,
- NULL, NULL
+ { "open", remote_fileio_func_open },
+ { "close", remote_fileio_func_close },
+ { "read", remote_fileio_func_read },
+ { "write", remote_fileio_func_write },
+ { "lseek", remote_fileio_func_lseek },
+ { "rename", remote_fileio_func_rename },
+ { "unlink", remote_fileio_func_unlink },
+ { "stat", remote_fileio_func_stat },
+ { "fstat", remote_fileio_func_fstat },
+ { "gettimeofday", remote_fileio_func_gettimeofday },
+ { "isatty", remote_fileio_func_isatty },
+ { "system", remote_fileio_func_system },
+ { NULL, NULL }
};
static int
@@ -1312,34 +1363,73 @@ do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
for (idx = 0; remote_fio_func_map[idx].name; ++idx)
if (!strcmp (remote_fio_func_map[idx].name, buf))
break;
- if (!remote_fio_func_map[idx].name) /* ERROR: No such function. */
+ if (!remote_fio_func_map[idx].name) /* ERROR: No such function. */
return RETURN_ERROR;
remote_fio_func_map[idx].func (c);
return 0;
}
+/* Close any open descriptors, and reinitialize the file mapping. */
+
void
-remote_fileio_request (char *buf)
+remote_fileio_reset (void)
+{
+ int ix;
+
+ for (ix = 0; ix != remote_fio_data.fd_map_size; ix++)
+ {
+ int fd = remote_fio_data.fd_map[ix];
+
+ if (fd >= 0)
+ close (fd);
+ }
+ if (remote_fio_data.fd_map)
+ {
+ xfree (remote_fio_data.fd_map);
+ remote_fio_data.fd_map = NULL;
+ remote_fio_data.fd_map_size = 0;
+ }
+}
+
+/* Handle a file I/O request. BUF points to the packet containing the
+ request. CTRLC_PENDING_P should be nonzero if the target has not
+ acknowledged the Ctrl-C sent asynchronously earlier. */
+
+void
+remote_fileio_request (char *buf, int ctrlc_pending_p)
{
int ex;
remote_fileio_sig_init ();
- remote_fio_ctrl_c_flag = 0;
- remote_fio_no_longjmp = 0;
-
- ex = catch_exceptions (uiout, do_remote_fileio_request, (void *)buf,
- RETURN_MASK_ALL);
- switch (ex)
+ if (ctrlc_pending_p)
{
- case RETURN_ERROR:
- remote_fileio_reply (-1, FILEIO_ENOSYS);
- break;
- case RETURN_QUIT:
- remote_fileio_reply (-1, FILEIO_EINTR);
- break;
- default:
- break;
+ /* If the target hasn't responded to the Ctrl-C sent
+ asynchronously earlier, take this opportunity to send the
+ Ctrl-C synchronously. */
+ remote_fio_ctrl_c_flag = 1;
+ remote_fio_no_longjmp = 0;
+ remote_fileio_reply (-1, FILEIO_EINTR);
+ }
+ else
+ {
+ remote_fio_ctrl_c_flag = 0;
+ remote_fio_no_longjmp = 0;
+
+ ex = catch_exceptions (current_uiout,
+ do_remote_fileio_request, (void *)buf,
+ RETURN_MASK_ALL);
+ switch (ex)
+ {
+ case RETURN_ERROR:
+ remote_fileio_reply (-1, FILEIO_ENOSYS);
+ break;
+ case RETURN_QUIT:
+ remote_fileio_reply (-1, FILEIO_EINTR);
+ break;
+ default:
+ break;
+ }
}
remote_fileio_sig_exit ();
@@ -1352,6 +1442,7 @@ set_system_call_allowed (char *args, int from_tty)
{
char *arg_end;
int val = strtoul (args, &arg_end, 10);
+
if (*args && *arg_end == '\0')
{
remote_fio_system_call_allowed = !!val;
@@ -1365,7 +1456,8 @@ static void
show_system_call_allowed (char *args, int from_tty)
{
if (args)
- error (_("Garbage after \"show remote system-call-allowed\" command: `%s'"), args);
+ error (_("Garbage after \"show remote "
+ "system-call-allowed\" command: `%s'"), args);
printf_unfiltered ("Calling host system(3) call from target is %sallowed\n",
remote_fio_system_call_allowed ? "" : "not ");
}
@@ -1374,6 +1466,9 @@ void
initialize_remote_fileio (struct cmd_list_element *remote_set_cmdlist,
struct cmd_list_element *remote_show_cmdlist)
{
+ sigint_fileio_token =
+ create_async_signal_handler (async_remote_fileio_interrupt, NULL);
+
add_cmd ("system-call-allowed", no_class,
set_system_call_allowed,
_("Set if the host system(3) call is allowed for the target."),