2003-06-10 16:37:04 +02:00
|
|
|
/* Remote File-I/O communications
|
|
|
|
|
2015-01-01 10:32:14 +01:00
|
|
|
Copyright (C) 2003-2015 Free Software Foundation, Inc.
|
2003-06-10 16:37:04 +02:00
|
|
|
|
|
|
|
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
|
2007-08-23 20:08:50 +02:00
|
|
|
the Free Software Foundation; either version 3 of the License, or
|
2003-06-10 16:37:04 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
2007-08-23 20:08:50 +02:00
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
2003-06-10 16:37:04 +02:00
|
|
|
|
2011-01-10 21:38:51 +01:00
|
|
|
/* See the GDB User Guide for details of the GDB remote protocol. */
|
2003-06-10 16:37:04 +02:00
|
|
|
|
|
|
|
#include "defs.h"
|
|
|
|
#include "gdbcmd.h"
|
|
|
|
#include "remote.h"
|
2003-06-10 21:29:57 +02:00
|
|
|
#include "gdb_wait.h"
|
remove gdb_stat.h
This patch is purely mechanical. It removes gdb_stat.h and changes
the code to use sys/stat.h.
2013-11-18 Tom Tromey <tromey@redhat.com>
* common/gdb_stat.h: Remove.
* ada-lang.c: Use sys/stat.h, not gdb_stat.h.
* common/filestuff.c: Use sys/stat.h, not gdb_stat.h.
* common/linux-osdata.c: Use sys/stat.h, not gdb_stat.h.
* corefile.c: Use sys/stat.h, not gdb_stat.h.
* ctf.c: Use sys/stat.h, not gdb_stat.h.
* darwin-nat.c: Use sys/stat.h, not gdb_stat.h.
* dbxread.c: Use sys/stat.h, not gdb_stat.h.
* dwarf2read.c: Use sys/stat.h, not gdb_stat.h.
* exec.c: Use sys/stat.h, not gdb_stat.h.
* gdbserver/linux-low.c: Use sys/stat.h, not gdb_stat.h.
* gdbserver/remote-utils.c: Use sys/stat.h, not gdb_stat.h.
* inf-child.c: Use sys/stat.h, not gdb_stat.h.
* jit.c: Use sys/stat.h, not gdb_stat.h.
* linux-nat.c: Use sys/stat.h, not gdb_stat.h.
* m68klinux-nat.c: Use sys/stat.h, not gdb_stat.h.
* main.c: Use sys/stat.h, not gdb_stat.h.
* mdebugread.c: Use sys/stat.h, not gdb_stat.h.
* mi/mi-cmd-env.c: Use sys/stat.h, not gdb_stat.h.
* nto-tdep.c: Use sys/stat.h, not gdb_stat.h.
* objfiles.c: Use sys/stat.h, not gdb_stat.h.
* procfs.c: Use sys/stat.h, not gdb_stat.h.
* remote-fileio.c: Use sys/stat.h, not gdb_stat.h.
* remote-mips.c: Use sys/stat.h, not gdb_stat.h.
* remote.c: Use sys/stat.h, not gdb_stat.h.
* rs6000-nat.c: Use sys/stat.h, not gdb_stat.h.
* sol-thread.c: Use sys/stat.h, not gdb_stat.h.
* solib-spu.c: Use sys/stat.h, not gdb_stat.h.
* source.c: Use sys/stat.h, not gdb_stat.h.
* symfile.c: Use sys/stat.h, not gdb_stat.h.
* symmisc.c: Use sys/stat.h, not gdb_stat.h.
* symtab.c: Use sys/stat.h, not gdb_stat.h.
* top.c: Use sys/stat.h, not gdb_stat.h.
* xcoffread.c: Use sys/stat.h, not gdb_stat.h.
2013-11-06 15:55:51 +01:00
|
|
|
#include <sys/stat.h>
|
2003-06-11 15:50:11 +02:00
|
|
|
#include "remote-fileio.h"
|
2008-03-05 18:21:10 +01:00
|
|
|
#include "event-loop.h"
|
2011-01-25 12:54:00 +01:00
|
|
|
#include "target.h"
|
2011-03-23 19:23:56 +01:00
|
|
|
#include "filenames.h"
|
PR gdb/7912:
* Makefile.in (SFILES): Add filestuff.c
(COMMON_OBS): Add filestuff.o.
(filestuff.o): New target.
* auto-load.c (auto_load_objfile_script_1): Use
gdb_fopen_cloexec.
* auxv.c (procfs_xfer_auxv): Use gdb_open_cloexec.
* cli/cli-cmds.c (shell_escape): Call close_most_fds.
* cli/cli-dump.c (fopen_with_cleanup): Use gdb_fopen_cloexec.
* common/agent.c (gdb_connect_sync_socket): Use
gdb_socket_cloexec.
* common/filestuff.c: New file.
* common/filestuff.h: New file.
* common/linux-osdata.c (linux_common_core_of_thread)
(command_from_pid, commandline_from_pid, print_source_lines)
(linux_xfer_osdata_shm, linux_xfer_osdata_sem)
(linux_xfer_osdata_msg, linux_xfer_osdata_modules): Use
gdb_fopen_cloexec.
* common/linux-procfs.c (linux_proc_get_int)
(linux_proc_pid_has_state): Use gdb_fopen_cloexec.
* config.in, configure: Rebuild.
* configure.ac: Don't check for sys/socket.h. Check for
fdwalk, pipe2.
* corelow.c (core_open): Use gdb_open_cloexec.
* dwarf2read.c (write_psymtabs_to_index): Use gdb_fopen_cloexec.
* fork-child.c (fork_inferior): Call close_most_fds.
* gdb_bfd.c (gdb_bfd_open): Use gdb_open_cloexec.
* inf-child.c (inf_child_fileio_readlink): Use gdb_open_cloexec.
* linux-nat.c (linux_nat_thread_name, linux_proc_pending_signals):
Use gdb_fopen_cloexec.
(linux_proc_xfer_partial, linux_proc_xfer_spu): Use
gdb_open_cloexec.
(linux_async_pipe): Use gdb_pipe_cloexec.
* remote-fileio.c (remote_fileio_func_open): Use
gdb_open_cloexec.
* remote.c (remote_file_put, remote_file_get): Use
gdb_fopen_cloexec.
* ser-pipe.c (pipe_open): Use gdb_socketpair_cloexec,
close_most_fds.
* ser-tcp.c (net_open): Use gdb_socket_cloexec.
* ser-unix.c (hardwire_open): Use gdb_open_cloexec.
* solib.c (solib_find): Use gdb_open_cloexec.
* source.c (openp, find_and_open_source): Use gdb_open_cloexec.
* tracepoint.c (tfile_start): Use gdb_fopen_cloexec.
(tfile_open): Use gdb_open_cloexec.
* tui/tui-io.c (tui_initialize_io): Use gdb_pipe_cloexec.
* ui-file.c (gdb_fopen): Use gdb_fopen_cloexec.
* xml-support.c (xml_fetch_content_from_file): Use
gdb_fopen_cloexec.
* main.c (captured_main): Call notice_open_fds.
gdbserver
* Makefile.in (SFILES): Add filestuff.c.
(OBS): Add filestuff.o.
(filestuff.o): New target.
* config.in, configure: Rebuild.
* configure.ac: Check for fdwalk, pipe2.
2013-04-22 18:46:15 +02:00
|
|
|
#include "filestuff.h"
|
2003-06-10 16:37:04 +02:00
|
|
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#ifdef __CYGWIN__
|
2011-04-08 00:24:17 +02:00
|
|
|
#include <sys/cygwin.h> /* For cygwin_conv_path. */
|
2003-06-10 16:37:04 +02:00
|
|
|
#endif
|
|
|
|
#include <signal.h>
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
int *fd_map;
|
|
|
|
int fd_map_size;
|
|
|
|
} remote_fio_data;
|
|
|
|
|
|
|
|
#define FIO_FD_INVALID -1
|
|
|
|
#define FIO_FD_CONSOLE_IN -2
|
|
|
|
#define FIO_FD_CONSOLE_OUT -3
|
|
|
|
|
|
|
|
static int remote_fio_system_call_allowed = 0;
|
|
|
|
|
2008-03-05 18:21:10 +01:00
|
|
|
static struct async_signal_handler *sigint_fileio_token;
|
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
static int
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_init_fd_map (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!remote_fio_data.fd_map)
|
|
|
|
{
|
|
|
|
remote_fio_data.fd_map = (int *) xmalloc (10 * sizeof (int));
|
|
|
|
remote_fio_data.fd_map_size = 10;
|
|
|
|
remote_fio_data.fd_map[0] = FIO_FD_CONSOLE_IN;
|
|
|
|
remote_fio_data.fd_map[1] = FIO_FD_CONSOLE_OUT;
|
|
|
|
remote_fio_data.fd_map[2] = FIO_FD_CONSOLE_OUT;
|
|
|
|
for (i = 3; i < 10; ++i)
|
|
|
|
remote_fio_data.fd_map[i] = FIO_FD_INVALID;
|
|
|
|
}
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_resize_fd_map (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
2007-08-10 19:49:48 +02:00
|
|
|
int i = remote_fio_data.fd_map_size;
|
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
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));
|
2007-08-10 19:49:48 +02:00
|
|
|
for (; i < remote_fio_data.fd_map_size; i++)
|
|
|
|
remote_fio_data.fd_map[i] = FIO_FD_INVALID;
|
2003-06-10 16:37:04 +02:00
|
|
|
return remote_fio_data.fd_map_size - 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_next_free_fd (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < remote_fio_data.fd_map_size; ++i)
|
|
|
|
if (remote_fio_data.fd_map[i] == FIO_FD_INVALID)
|
|
|
|
return i;
|
|
|
|
return remote_fileio_resize_fd_map ();
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_fd_to_targetfd (int fd)
|
|
|
|
{
|
|
|
|
int target_fd = remote_fileio_next_free_fd ();
|
2010-05-16 23:11:14 +02:00
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
remote_fio_data.fd_map[target_fd] = fd;
|
|
|
|
return target_fd;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_map_fd (int target_fd)
|
|
|
|
{
|
|
|
|
remote_fileio_init_fd_map ();
|
|
|
|
if (target_fd < 0 || target_fd >= remote_fio_data.fd_map_size)
|
|
|
|
return FIO_FD_INVALID;
|
|
|
|
return remote_fio_data.fd_map[target_fd];
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_close_target_fd (int target_fd)
|
|
|
|
{
|
|
|
|
remote_fileio_init_fd_map ();
|
|
|
|
if (target_fd >= 0 && target_fd < remote_fio_data.fd_map_size)
|
|
|
|
remote_fio_data.fd_map[target_fd] = FIO_FD_INVALID;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_oflags_to_host (long flags)
|
|
|
|
{
|
|
|
|
int hflags = 0;
|
|
|
|
|
|
|
|
if (flags & FILEIO_O_CREAT)
|
|
|
|
hflags |= O_CREAT;
|
|
|
|
if (flags & FILEIO_O_EXCL)
|
|
|
|
hflags |= O_EXCL;
|
|
|
|
if (flags & FILEIO_O_TRUNC)
|
|
|
|
hflags |= O_TRUNC;
|
|
|
|
if (flags & FILEIO_O_APPEND)
|
|
|
|
hflags |= O_APPEND;
|
|
|
|
if (flags & FILEIO_O_RDONLY)
|
|
|
|
hflags |= O_RDONLY;
|
|
|
|
if (flags & FILEIO_O_WRONLY)
|
|
|
|
hflags |= O_WRONLY;
|
|
|
|
if (flags & FILEIO_O_RDWR)
|
|
|
|
hflags |= O_RDWR;
|
|
|
|
/* On systems supporting binary and text mode, always open files in
|
2011-01-10 21:38:51 +01:00
|
|
|
binary mode. */
|
2003-06-10 16:37:04 +02:00
|
|
|
#ifdef O_BINARY
|
|
|
|
hflags |= O_BINARY;
|
|
|
|
#endif
|
|
|
|
return hflags;
|
|
|
|
}
|
|
|
|
|
|
|
|
static mode_t
|
|
|
|
remote_fileio_mode_to_host (long mode, int open_call)
|
|
|
|
{
|
|
|
|
mode_t hmode = 0;
|
|
|
|
|
|
|
|
if (!open_call)
|
|
|
|
{
|
|
|
|
if (mode & FILEIO_S_IFREG)
|
|
|
|
hmode |= S_IFREG;
|
|
|
|
if (mode & FILEIO_S_IFDIR)
|
|
|
|
hmode |= S_IFDIR;
|
|
|
|
if (mode & FILEIO_S_IFCHR)
|
|
|
|
hmode |= S_IFCHR;
|
|
|
|
}
|
|
|
|
if (mode & FILEIO_S_IRUSR)
|
|
|
|
hmode |= S_IRUSR;
|
|
|
|
if (mode & FILEIO_S_IWUSR)
|
|
|
|
hmode |= S_IWUSR;
|
|
|
|
if (mode & FILEIO_S_IXUSR)
|
|
|
|
hmode |= S_IXUSR;
|
2005-03-16 16:58:41 +01:00
|
|
|
#ifdef S_IRGRP
|
2003-06-10 16:37:04 +02:00
|
|
|
if (mode & FILEIO_S_IRGRP)
|
|
|
|
hmode |= S_IRGRP;
|
2005-03-16 16:58:41 +01:00
|
|
|
#endif
|
|
|
|
#ifdef S_IWGRP
|
2003-06-10 16:37:04 +02:00
|
|
|
if (mode & FILEIO_S_IWGRP)
|
|
|
|
hmode |= S_IWGRP;
|
2005-03-16 16:58:41 +01:00
|
|
|
#endif
|
|
|
|
#ifdef S_IXGRP
|
2003-06-10 16:37:04 +02:00
|
|
|
if (mode & FILEIO_S_IXGRP)
|
|
|
|
hmode |= S_IXGRP;
|
2005-03-16 16:58:41 +01:00
|
|
|
#endif
|
2003-06-10 16:37:04 +02:00
|
|
|
if (mode & FILEIO_S_IROTH)
|
|
|
|
hmode |= S_IROTH;
|
2005-03-16 16:58:41 +01:00
|
|
|
#ifdef S_IWOTH
|
2003-06-10 16:37:04 +02:00
|
|
|
if (mode & FILEIO_S_IWOTH)
|
|
|
|
hmode |= S_IWOTH;
|
2005-03-16 16:58:41 +01:00
|
|
|
#endif
|
|
|
|
#ifdef S_IXOTH
|
2003-06-10 16:37:04 +02:00
|
|
|
if (mode & FILEIO_S_IXOTH)
|
|
|
|
hmode |= S_IXOTH;
|
2005-03-16 16:58:41 +01:00
|
|
|
#endif
|
2003-06-10 16:37:04 +02:00
|
|
|
return hmode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_errno_to_target (int error)
|
|
|
|
{
|
|
|
|
switch (error)
|
|
|
|
{
|
|
|
|
case EPERM:
|
|
|
|
return FILEIO_EPERM;
|
|
|
|
case ENOENT:
|
|
|
|
return FILEIO_ENOENT;
|
|
|
|
case EINTR:
|
|
|
|
return FILEIO_EINTR;
|
|
|
|
case EIO:
|
|
|
|
return FILEIO_EIO;
|
|
|
|
case EBADF:
|
|
|
|
return FILEIO_EBADF;
|
|
|
|
case EACCES:
|
|
|
|
return FILEIO_EACCES;
|
|
|
|
case EFAULT:
|
|
|
|
return FILEIO_EFAULT;
|
|
|
|
case EBUSY:
|
|
|
|
return FILEIO_EBUSY;
|
|
|
|
case EEXIST:
|
|
|
|
return FILEIO_EEXIST;
|
|
|
|
case ENODEV:
|
|
|
|
return FILEIO_ENODEV;
|
|
|
|
case ENOTDIR:
|
|
|
|
return FILEIO_ENOTDIR;
|
|
|
|
case EISDIR:
|
|
|
|
return FILEIO_EISDIR;
|
|
|
|
case EINVAL:
|
|
|
|
return FILEIO_EINVAL;
|
|
|
|
case ENFILE:
|
|
|
|
return FILEIO_ENFILE;
|
|
|
|
case EMFILE:
|
|
|
|
return FILEIO_EMFILE;
|
|
|
|
case EFBIG:
|
|
|
|
return FILEIO_EFBIG;
|
|
|
|
case ENOSPC:
|
|
|
|
return FILEIO_ENOSPC;
|
|
|
|
case ESPIPE:
|
|
|
|
return FILEIO_ESPIPE;
|
|
|
|
case EROFS:
|
|
|
|
return FILEIO_EROFS;
|
|
|
|
case ENOSYS:
|
|
|
|
return FILEIO_ENOSYS;
|
|
|
|
case ENAMETOOLONG:
|
|
|
|
return FILEIO_ENAMETOOLONG;
|
|
|
|
}
|
|
|
|
return FILEIO_EUNKNOWN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_seek_flag_to_host (long num, int *flag)
|
|
|
|
{
|
|
|
|
if (!flag)
|
|
|
|
return 0;
|
|
|
|
switch (num)
|
|
|
|
{
|
|
|
|
case FILEIO_SEEK_SET:
|
|
|
|
*flag = SEEK_SET;
|
|
|
|
break;
|
|
|
|
case FILEIO_SEEK_CUR:
|
|
|
|
*flag = SEEK_CUR;
|
|
|
|
break;
|
|
|
|
case FILEIO_SEEK_END:
|
|
|
|
*flag = SEEK_END;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_extract_long (char **buf, LONGEST *retlong)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
char *c;
|
|
|
|
int sign = 1;
|
|
|
|
|
|
|
|
if (!buf || !*buf || !**buf || !retlong)
|
|
|
|
return -1;
|
|
|
|
c = strchr (*buf, ',');
|
|
|
|
if (c)
|
|
|
|
*c++ = '\0';
|
|
|
|
else
|
|
|
|
c = strchr (*buf, '\0');
|
|
|
|
while (strchr ("+-", **buf))
|
|
|
|
{
|
|
|
|
if (**buf == '-')
|
|
|
|
sign = -sign;
|
|
|
|
++*buf;
|
|
|
|
}
|
|
|
|
for (*retlong = 0; **buf; ++*buf)
|
|
|
|
{
|
|
|
|
*retlong <<= 4;
|
|
|
|
if (**buf >= '0' && **buf <= '9')
|
|
|
|
*retlong += **buf - '0';
|
|
|
|
else if (**buf >= 'a' && **buf <= 'f')
|
|
|
|
*retlong += **buf - 'a' + 10;
|
|
|
|
else if (**buf >= 'A' && **buf <= 'F')
|
|
|
|
*retlong += **buf - 'A' + 10;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
*retlong *= sign;
|
|
|
|
*buf = c;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_extract_int (char **buf, long *retint)
|
|
|
|
{
|
|
|
|
int ret;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST retlong;
|
2003-06-10 16:37:04 +02:00
|
|
|
|
|
|
|
if (!retint)
|
|
|
|
return -1;
|
2003-06-11 12:24:53 +02:00
|
|
|
ret = remote_fileio_extract_long (buf, &retlong);
|
|
|
|
if (!ret)
|
2003-06-10 16:37:04 +02:00
|
|
|
*retint = (long) retlong;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length)
|
|
|
|
{
|
|
|
|
char *c;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST retlong;
|
2003-06-10 16:37:04 +02:00
|
|
|
|
|
|
|
if (!buf || !*buf || !**buf || !ptrval || !length)
|
|
|
|
return -1;
|
|
|
|
c = strchr (*buf, '/');
|
|
|
|
if (!c)
|
|
|
|
return -1;
|
|
|
|
*c++ = '\0';
|
|
|
|
if (remote_fileio_extract_long (buf, &retlong))
|
|
|
|
return -1;
|
|
|
|
*ptrval = (CORE_ADDR) retlong;
|
|
|
|
*buf = c;
|
|
|
|
if (remote_fileio_extract_long (buf, &retlong))
|
|
|
|
return -1;
|
|
|
|
*length = (int) retlong;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_to_fio_long (LONGEST num, fio_long_t fnum)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_to_be (num, (char *) fnum, 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_to_fio_timeval (struct timeval *tv, struct fio_timeval *ftv)
|
|
|
|
{
|
|
|
|
remote_fileio_to_fio_time (tv->tv_sec, ftv->ftv_sec);
|
|
|
|
remote_fileio_to_fio_long (tv->tv_usec, ftv->ftv_usec);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int remote_fio_ctrl_c_flag = 0;
|
|
|
|
static int remote_fio_no_longjmp = 0;
|
|
|
|
|
|
|
|
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
|
|
|
|
static struct sigaction remote_fio_sa;
|
|
|
|
static struct sigaction remote_fio_osa;
|
|
|
|
#else
|
|
|
|
static void (*remote_fio_ofunc)(int);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_sig_init (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
|
|
|
|
remote_fio_sa.sa_handler = SIG_IGN;
|
|
|
|
sigemptyset (&remote_fio_sa.sa_mask);
|
|
|
|
remote_fio_sa.sa_flags = 0;
|
|
|
|
sigaction (SIGINT, &remote_fio_sa, &remote_fio_osa);
|
|
|
|
#else
|
|
|
|
remote_fio_ofunc = signal (SIGINT, SIG_IGN);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_sig_set (void (*sigint_func)(int))
|
|
|
|
{
|
|
|
|
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
|
|
|
|
remote_fio_sa.sa_handler = sigint_func;
|
|
|
|
sigemptyset (&remote_fio_sa.sa_mask);
|
|
|
|
remote_fio_sa.sa_flags = 0;
|
|
|
|
sigaction (SIGINT, &remote_fio_sa, NULL);
|
|
|
|
#else
|
|
|
|
signal (SIGINT, sigint_func);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_sig_exit (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
|
|
|
|
sigaction (SIGINT, &remote_fio_osa, NULL);
|
|
|
|
#else
|
|
|
|
signal (SIGINT, remote_fio_ofunc);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-03-05 18:21:10 +01:00
|
|
|
static void
|
|
|
|
async_remote_fileio_interrupt (gdb_client_data arg)
|
|
|
|
{
|
2013-07-31 14:44:33 +02:00
|
|
|
quit ();
|
2008-03-05 18:21:10 +01:00
|
|
|
}
|
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
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)
|
2008-03-05 18:21:10 +01:00
|
|
|
gdb_call_async_signal_handler (sigint_fileio_token, 1);
|
2003-06-10 16:37:04 +02:00
|
|
|
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_reply (int retcode, int error)
|
|
|
|
{
|
|
|
|
char buf[32];
|
|
|
|
|
|
|
|
remote_fileio_sig_set (SIG_IGN);
|
|
|
|
strcpy (buf, "F");
|
|
|
|
if (retcode < 0)
|
|
|
|
{
|
|
|
|
strcat (buf, "-");
|
|
|
|
retcode = -retcode;
|
|
|
|
}
|
|
|
|
sprintf (buf + strlen (buf), "%x", retcode);
|
|
|
|
if (error || remote_fio_ctrl_c_flag)
|
|
|
|
{
|
|
|
|
if (error && remote_fio_ctrl_c_flag)
|
|
|
|
error = FILEIO_EINTR;
|
|
|
|
if (error < 0)
|
|
|
|
{
|
|
|
|
strcat (buf, "-");
|
|
|
|
error = -error;
|
|
|
|
}
|
|
|
|
sprintf (buf + strlen (buf), ",%x", error);
|
|
|
|
if (remote_fio_ctrl_c_flag)
|
|
|
|
strcat (buf, ",C");
|
|
|
|
}
|
|
|
|
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
|
|
|
|
putpkt (buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_ioerror (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2003-06-11 12:24:53 +02:00
|
|
|
remote_fileio_badfd (void)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EBADF);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_return_errno (int retcode)
|
|
|
|
{
|
2011-01-05 23:22:53 +01:00
|
|
|
remote_fileio_reply (retcode, retcode < 0
|
|
|
|
? remote_fileio_errno_to_target (errno) : 0);
|
2003-06-10 16:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_return_success (int retcode)
|
|
|
|
{
|
|
|
|
remote_fileio_reply (retcode, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_open (char *buf)
|
|
|
|
{
|
|
|
|
CORE_ADDR ptrval;
|
2011-01-25 12:54:00 +01:00
|
|
|
int length;
|
2003-06-10 16:37:04 +02:00
|
|
|
long num;
|
|
|
|
int flags, fd;
|
|
|
|
mode_t mode;
|
|
|
|
char *pathname;
|
|
|
|
struct stat st;
|
|
|
|
|
2011-01-10 21:38:51 +01:00
|
|
|
/* 1. Parameter: Ptr to pathname / length incl. trailing zero. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* 2. Parameter: open flags */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
flags = remote_fileio_oflags_to_host (num);
|
|
|
|
/* 3. Parameter: open mode */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
mode = remote_fileio_mode_to_host (num, 1);
|
|
|
|
|
2011-01-25 12:54:00 +01:00
|
|
|
/* Request pathname. */
|
2003-06-10 16:37:04 +02:00
|
|
|
pathname = alloca (length);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
2011-01-10 21:38:51 +01:00
|
|
|
for writing. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (!stat (pathname, &st))
|
|
|
|
{
|
|
|
|
if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_ENODEV);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (S_ISDIR (st.st_mode)
|
|
|
|
&& ((flags & O_WRONLY) == O_WRONLY || (flags & O_RDWR) == O_RDWR))
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EISDIR);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
PR gdb/7912:
* Makefile.in (SFILES): Add filestuff.c
(COMMON_OBS): Add filestuff.o.
(filestuff.o): New target.
* auto-load.c (auto_load_objfile_script_1): Use
gdb_fopen_cloexec.
* auxv.c (procfs_xfer_auxv): Use gdb_open_cloexec.
* cli/cli-cmds.c (shell_escape): Call close_most_fds.
* cli/cli-dump.c (fopen_with_cleanup): Use gdb_fopen_cloexec.
* common/agent.c (gdb_connect_sync_socket): Use
gdb_socket_cloexec.
* common/filestuff.c: New file.
* common/filestuff.h: New file.
* common/linux-osdata.c (linux_common_core_of_thread)
(command_from_pid, commandline_from_pid, print_source_lines)
(linux_xfer_osdata_shm, linux_xfer_osdata_sem)
(linux_xfer_osdata_msg, linux_xfer_osdata_modules): Use
gdb_fopen_cloexec.
* common/linux-procfs.c (linux_proc_get_int)
(linux_proc_pid_has_state): Use gdb_fopen_cloexec.
* config.in, configure: Rebuild.
* configure.ac: Don't check for sys/socket.h. Check for
fdwalk, pipe2.
* corelow.c (core_open): Use gdb_open_cloexec.
* dwarf2read.c (write_psymtabs_to_index): Use gdb_fopen_cloexec.
* fork-child.c (fork_inferior): Call close_most_fds.
* gdb_bfd.c (gdb_bfd_open): Use gdb_open_cloexec.
* inf-child.c (inf_child_fileio_readlink): Use gdb_open_cloexec.
* linux-nat.c (linux_nat_thread_name, linux_proc_pending_signals):
Use gdb_fopen_cloexec.
(linux_proc_xfer_partial, linux_proc_xfer_spu): Use
gdb_open_cloexec.
(linux_async_pipe): Use gdb_pipe_cloexec.
* remote-fileio.c (remote_fileio_func_open): Use
gdb_open_cloexec.
* remote.c (remote_file_put, remote_file_get): Use
gdb_fopen_cloexec.
* ser-pipe.c (pipe_open): Use gdb_socketpair_cloexec,
close_most_fds.
* ser-tcp.c (net_open): Use gdb_socket_cloexec.
* ser-unix.c (hardwire_open): Use gdb_open_cloexec.
* solib.c (solib_find): Use gdb_open_cloexec.
* source.c (openp, find_and_open_source): Use gdb_open_cloexec.
* tracepoint.c (tfile_start): Use gdb_fopen_cloexec.
(tfile_open): Use gdb_open_cloexec.
* tui/tui-io.c (tui_initialize_io): Use gdb_pipe_cloexec.
* ui-file.c (gdb_fopen): Use gdb_fopen_cloexec.
* xml-support.c (xml_fetch_content_from_file): Use
gdb_fopen_cloexec.
* main.c (captured_main): Call notice_open_fds.
gdbserver
* Makefile.in (SFILES): Add filestuff.c.
(OBS): Add filestuff.o.
(filestuff.o): New target.
* config.in, configure: Rebuild.
* configure.ac: Check for fdwalk, pipe2.
2013-04-22 18:46:15 +02:00
|
|
|
fd = gdb_open_cloexec (pathname, flags, mode);
|
2003-06-10 16:37:04 +02:00
|
|
|
if (fd < 0)
|
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fd = remote_fileio_fd_to_targetfd (fd);
|
|
|
|
remote_fileio_return_success (fd);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_close (char *buf)
|
|
|
|
{
|
|
|
|
long num;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
/* Parameter: file descriptor */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2003-06-11 12:24:53 +02:00
|
|
|
fd = remote_fileio_map_fd ((int) num);
|
|
|
|
if (fd == FIO_FD_INVALID)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_badfd ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
if (fd != FIO_FD_CONSOLE_IN && fd != FIO_FD_CONSOLE_OUT && close (fd))
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
remote_fileio_close_target_fd ((int) num);
|
|
|
|
remote_fileio_return_success (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_read (char *buf)
|
|
|
|
{
|
|
|
|
long target_fd, num;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST lnum;
|
2003-06-10 16:37:04 +02:00
|
|
|
CORE_ADDR ptrval;
|
2012-05-18 23:02:52 +02:00
|
|
|
int fd, ret;
|
2006-01-17 15:11:16 +01:00
|
|
|
gdb_byte *buffer;
|
2003-06-10 16:37:04 +02:00
|
|
|
size_t length;
|
|
|
|
off_t old_offset, new_offset;
|
|
|
|
|
|
|
|
/* 1. Parameter: file descriptor */
|
|
|
|
if (remote_fileio_extract_int (&buf, &target_fd))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2003-06-11 12:24:53 +02:00
|
|
|
fd = remote_fileio_map_fd ((int) target_fd);
|
|
|
|
if (fd == FIO_FD_INVALID)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_badfd ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* 2. Parameter: buffer pointer */
|
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ptrval = (CORE_ADDR) lnum;
|
|
|
|
/* 3. Parameter: buffer length */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
length = (size_t) num;
|
|
|
|
|
|
|
|
switch (fd)
|
|
|
|
{
|
|
|
|
case FIO_FD_CONSOLE_OUT:
|
|
|
|
remote_fileio_badfd ();
|
|
|
|
return;
|
|
|
|
case FIO_FD_CONSOLE_IN:
|
|
|
|
{
|
|
|
|
static char *remaining_buf = NULL;
|
|
|
|
static int remaining_length = 0;
|
|
|
|
|
2009-11-12 22:01:00 +01:00
|
|
|
buffer = (gdb_byte *) xmalloc (16384);
|
2003-06-10 16:37:04 +02:00
|
|
|
if (remaining_buf)
|
|
|
|
{
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
if (remaining_length > length)
|
|
|
|
{
|
|
|
|
memcpy (buffer, remaining_buf, length);
|
|
|
|
memmove (remaining_buf, remaining_buf + length,
|
|
|
|
remaining_length - length);
|
|
|
|
remaining_length -= length;
|
|
|
|
ret = length;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy (buffer, remaining_buf, remaining_length);
|
|
|
|
xfree (remaining_buf);
|
|
|
|
remaining_buf = NULL;
|
|
|
|
ret = remaining_length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-11-12 22:01:00 +01:00
|
|
|
/* 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);
|
2003-06-10 16:37:04 +02:00
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
if (ret > 0 && (size_t)ret > length)
|
|
|
|
{
|
|
|
|
remaining_buf = (char *) xmalloc (ret - length);
|
|
|
|
remaining_length = ret - length;
|
|
|
|
memcpy (remaining_buf, buffer + length, remaining_length);
|
|
|
|
ret = length;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2006-01-17 15:11:16 +01:00
|
|
|
buffer = (gdb_byte *) xmalloc (length);
|
2003-06-10 16:37:04 +02:00
|
|
|
/* 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...
|
|
|
|
Therefore a complete solution must check how many bytes have been
|
|
|
|
read on EINTR to return a more reliable value to the target */
|
|
|
|
old_offset = lseek (fd, 0, SEEK_CUR);
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = read (fd, buffer, length);
|
|
|
|
if (ret < 0 && errno == EINTR)
|
|
|
|
{
|
|
|
|
new_offset = lseek (fd, 0, SEEK_CUR);
|
|
|
|
/* If some data has been read, return the number of bytes read.
|
2011-01-10 21:38:51 +01:00
|
|
|
The Ctrl-C flag is set in remote_fileio_reply() anyway. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (old_offset != new_offset)
|
|
|
|
ret = new_offset - old_offset;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0)
|
|
|
|
{
|
2011-01-25 12:54:00 +01:00
|
|
|
errno = target_write_memory (ptrval, buffer, ret);
|
|
|
|
if (errno != 0)
|
|
|
|
ret = -1;
|
2003-06-10 16:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
else
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
|
|
|
|
xfree (buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_write (char *buf)
|
|
|
|
{
|
|
|
|
long target_fd, num;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST lnum;
|
2003-06-10 16:37:04 +02:00
|
|
|
CORE_ADDR ptrval;
|
2011-01-25 12:54:00 +01:00
|
|
|
int fd, ret;
|
2006-01-17 15:11:16 +01:00
|
|
|
gdb_byte *buffer;
|
2003-06-10 16:37:04 +02:00
|
|
|
size_t length;
|
|
|
|
|
|
|
|
/* 1. Parameter: file descriptor */
|
|
|
|
if (remote_fileio_extract_int (&buf, &target_fd))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2003-06-11 12:24:53 +02:00
|
|
|
fd = remote_fileio_map_fd ((int) target_fd);
|
|
|
|
if (fd == FIO_FD_INVALID)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_badfd ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* 2. Parameter: buffer pointer */
|
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ptrval = (CORE_ADDR) lnum;
|
|
|
|
/* 3. Parameter: buffer length */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
length = (size_t) num;
|
|
|
|
|
2006-01-17 15:11:16 +01:00
|
|
|
buffer = (gdb_byte *) xmalloc (length);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (ptrval, buffer, length) != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
xfree (buffer);
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
switch (fd)
|
|
|
|
{
|
|
|
|
case FIO_FD_CONSOLE_IN:
|
|
|
|
remote_fileio_badfd ();
|
2007-08-05 03:04:31 +02:00
|
|
|
xfree (buffer);
|
2003-06-10 16:37:04 +02:00
|
|
|
return;
|
|
|
|
case FIO_FD_CONSOLE_OUT:
|
2006-01-17 15:11:16 +01:00
|
|
|
ui_file_write (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr,
|
|
|
|
(char *) buffer, length);
|
2003-06-10 16:37:04 +02:00
|
|
|
gdb_flush (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr);
|
|
|
|
ret = length;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = write (fd, buffer, length);
|
|
|
|
if (ret < 0 && errno == EACCES)
|
2011-01-05 23:22:53 +01:00
|
|
|
errno = EBADF; /* Cygwin returns EACCESS when writing to a
|
2011-01-10 21:38:51 +01:00
|
|
|
R/O file. */
|
2003-06-10 16:37:04 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
else
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
|
|
|
|
xfree (buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_lseek (char *buf)
|
|
|
|
{
|
|
|
|
long num;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST lnum;
|
2003-06-10 16:37:04 +02:00
|
|
|
int fd, flag;
|
|
|
|
off_t offset, ret;
|
|
|
|
|
|
|
|
/* 1. Parameter: file descriptor */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2003-06-11 12:24:53 +02:00
|
|
|
fd = remote_fileio_map_fd ((int) num);
|
|
|
|
if (fd == FIO_FD_INVALID)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_badfd ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_ESPIPE);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 2. Parameter: offset */
|
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
offset = (off_t) lnum;
|
|
|
|
/* 3. Parameter: flag */
|
|
|
|
if (remote_fileio_extract_int (&buf, &num))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (remote_fileio_seek_flag_to_host (num, &flag))
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EINVAL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = lseek (fd, offset, flag);
|
|
|
|
|
|
|
|
if (ret == (off_t) -1)
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
else
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_rename (char *buf)
|
|
|
|
{
|
2006-07-19 08:21:23 +02:00
|
|
|
CORE_ADDR old_ptr, new_ptr;
|
2011-01-25 12:54:00 +01:00
|
|
|
int old_len, new_len;
|
2003-06-10 16:37:04 +02:00
|
|
|
char *oldpath, *newpath;
|
|
|
|
int ret, of, nf;
|
|
|
|
struct stat ost, nst;
|
|
|
|
|
|
|
|
/* 1. Parameter: Ptr to oldpath / length incl. trailing zero */
|
2006-07-19 08:21:23 +02:00
|
|
|
if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len))
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2006-07-19 08:21:23 +02:00
|
|
|
|
|
|
|
/* 2. Parameter: Ptr to newpath / length incl. trailing zero */
|
|
|
|
if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len))
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2006-07-19 08:21:23 +02:00
|
|
|
|
|
|
|
/* Request oldpath using 'm' packet */
|
|
|
|
oldpath = alloca (old_len);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2006-07-19 08:21:23 +02:00
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
/* Request newpath using 'm' packet */
|
2006-07-19 08:21:23 +02:00
|
|
|
newpath = alloca (new_len);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-01-10 21:38:51 +01:00
|
|
|
/* Only operate on regular files and directories. */
|
2003-06-11 12:24:53 +02:00
|
|
|
of = stat (oldpath, &ost);
|
|
|
|
nf = stat (newpath, &nst);
|
|
|
|
if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode))
|
|
|
|
|| (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode)))
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EACCES);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = rename (oldpath, newpath);
|
|
|
|
|
|
|
|
if (ret == -1)
|
|
|
|
{
|
|
|
|
/* Special case: newpath is a non-empty directory. Some systems
|
|
|
|
return ENOTEMPTY, some return EEXIST. We coerce that to be
|
2011-01-10 21:38:51 +01:00
|
|
|
always EEXIST. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (errno == ENOTEMPTY)
|
|
|
|
errno = EEXIST;
|
|
|
|
#ifdef __CYGWIN__
|
2011-01-10 21:38:51 +01:00
|
|
|
/* Workaround some Cygwin problems with correct errnos. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (errno == EACCES)
|
|
|
|
{
|
|
|
|
if (!of && !nf && S_ISDIR (nst.st_mode))
|
|
|
|
{
|
|
|
|
if (S_ISREG (ost.st_mode))
|
|
|
|
errno = EISDIR;
|
|
|
|
else
|
|
|
|
{
|
2010-03-01 10:09:24 +01:00
|
|
|
char oldfullpath[PATH_MAX];
|
|
|
|
char newfullpath[PATH_MAX];
|
2003-06-10 16:37:04 +02:00
|
|
|
int len;
|
|
|
|
|
2010-03-01 10:09:24 +01:00
|
|
|
cygwin_conv_path (CCP_WIN_A_TO_POSIX, oldpath, oldfullpath,
|
|
|
|
PATH_MAX);
|
|
|
|
cygwin_conv_path (CCP_WIN_A_TO_POSIX, newpath, newfullpath,
|
|
|
|
PATH_MAX);
|
2003-06-10 16:37:04 +02:00
|
|
|
len = strlen (oldfullpath);
|
2011-03-23 19:23:56 +01:00
|
|
|
if (IS_DIR_SEPARATOR (newfullpath[len])
|
|
|
|
&& !filename_ncmp (oldfullpath, newfullpath, len))
|
2003-06-10 16:37:04 +02:00
|
|
|
errno = EINVAL;
|
|
|
|
else
|
|
|
|
errno = EEXIST;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_unlink (char *buf)
|
|
|
|
{
|
|
|
|
CORE_ADDR ptrval;
|
2011-01-25 12:54:00 +01:00
|
|
|
int length;
|
2003-06-10 16:37:04 +02:00
|
|
|
char *pathname;
|
|
|
|
int ret;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
/* Parameter: Ptr to pathname / length incl. trailing zero */
|
|
|
|
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* Request pathname using 'm' packet */
|
|
|
|
pathname = alloca (length);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only operate on regular files (and directories, which allows to return
|
2011-01-10 21:38:51 +01:00
|
|
|
the correct return code). */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_ENODEV);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = unlink (pathname);
|
|
|
|
|
|
|
|
if (ret == -1)
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
else
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_stat (char *buf)
|
|
|
|
{
|
2006-07-19 08:21:23 +02:00
|
|
|
CORE_ADDR statptr, nameptr;
|
2011-01-25 12:54:00 +01:00
|
|
|
int ret, namelength;
|
2003-06-10 16:37:04 +02:00
|
|
|
char *pathname;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST lnum;
|
2003-06-10 16:37:04 +02:00
|
|
|
struct stat st;
|
|
|
|
struct fio_stat fst;
|
|
|
|
|
|
|
|
/* 1. Parameter: Ptr to pathname / length incl. trailing zero */
|
2006-07-19 08:21:23 +02:00
|
|
|
if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength))
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2006-07-19 08:21:23 +02:00
|
|
|
|
|
|
|
/* 2. Parameter: Ptr to struct stat */
|
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2006-07-19 08:21:23 +02:00
|
|
|
statptr = (CORE_ADDR) lnum;
|
|
|
|
|
|
|
|
/* Request pathname using 'm' packet */
|
|
|
|
pathname = alloca (namelength);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = stat (pathname, &st);
|
|
|
|
|
|
|
|
if (ret == -1)
|
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
2011-01-10 21:38:51 +01:00
|
|
|
/* Only operate on regular files and directories. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode))
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EACCES);
|
|
|
|
return;
|
|
|
|
}
|
2006-07-19 08:21:23 +02:00
|
|
|
if (statptr)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_to_fio_stat (&st, &fst);
|
|
|
|
remote_fileio_to_fio_uint (0, fst.fst_dev);
|
2011-01-25 12:54:00 +01:00
|
|
|
|
|
|
|
errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst);
|
|
|
|
if (errno != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_fstat (char *buf)
|
|
|
|
{
|
|
|
|
CORE_ADDR ptrval;
|
2012-05-18 23:02:52 +02:00
|
|
|
int fd, ret;
|
2003-06-10 16:37:04 +02:00
|
|
|
long target_fd;
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST lnum;
|
2003-06-10 16:37:04 +02:00
|
|
|
struct stat st;
|
|
|
|
struct fio_stat fst;
|
|
|
|
struct timeval tv;
|
|
|
|
|
|
|
|
/* 1. Parameter: file descriptor */
|
|
|
|
if (remote_fileio_extract_int (&buf, &target_fd))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2003-06-11 12:24:53 +02:00
|
|
|
fd = remote_fileio_map_fd ((int) target_fd);
|
|
|
|
if (fd == FIO_FD_INVALID)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_badfd ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* 2. Parameter: Ptr to struct stat */
|
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ptrval = (CORE_ADDR) lnum;
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
|
|
|
|
{
|
|
|
|
remote_fileio_to_fio_uint (1, fst.fst_dev);
|
2011-03-03 19:35:32 +01:00
|
|
|
memset (&st, 0, sizeof (st));
|
2003-06-10 16:37:04 +02:00
|
|
|
st.st_mode = S_IFCHR | (fd == FIO_FD_CONSOLE_IN ? S_IRUSR : S_IWUSR);
|
|
|
|
st.st_nlink = 1;
|
2005-03-21 22:23:35 +01:00
|
|
|
#ifdef HAVE_GETUID
|
2003-06-10 16:37:04 +02:00
|
|
|
st.st_uid = getuid ();
|
2005-03-21 22:23:35 +01:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_GETGID
|
2003-06-10 16:37:04 +02:00
|
|
|
st.st_gid = getgid ();
|
2005-03-21 22:23:35 +01:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
|
2003-06-10 16:37:04 +02:00
|
|
|
st.st_blksize = 512;
|
2005-03-21 22:23:35 +01:00
|
|
|
#endif
|
2003-12-30 07:52:09 +01:00
|
|
|
#if HAVE_STRUCT_STAT_ST_BLOCKS
|
2003-06-10 16:37:04 +02:00
|
|
|
st.st_blocks = 0;
|
2003-12-30 07:52:09 +01:00
|
|
|
#endif
|
2003-06-10 16:37:04 +02:00
|
|
|
if (!gettimeofday (&tv, NULL))
|
|
|
|
st.st_atime = st.st_mtime = st.st_ctime = tv.tv_sec;
|
|
|
|
else
|
|
|
|
st.st_atime = st.st_mtime = st.st_ctime = (time_t) 0;
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ret = fstat (fd, &st);
|
|
|
|
|
|
|
|
if (ret == -1)
|
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (ptrval)
|
|
|
|
{
|
|
|
|
remote_fileio_to_fio_stat (&st, &fst);
|
|
|
|
|
2011-01-25 12:54:00 +01:00
|
|
|
errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst);
|
|
|
|
if (errno != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_gettimeofday (char *buf)
|
|
|
|
{
|
2003-06-11 12:24:53 +02:00
|
|
|
LONGEST lnum;
|
2003-06-10 16:37:04 +02:00
|
|
|
CORE_ADDR ptrval;
|
2012-05-18 23:02:52 +02:00
|
|
|
int ret;
|
2003-06-10 16:37:04 +02:00
|
|
|
struct timeval tv;
|
|
|
|
struct fio_timeval ftv;
|
|
|
|
|
|
|
|
/* 1. Parameter: struct timeval pointer */
|
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ptrval = (CORE_ADDR) lnum;
|
2011-01-10 21:38:51 +01:00
|
|
|
/* 2. Parameter: some pointer value... */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (remote_fileio_extract_long (&buf, &lnum))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2011-01-10 21:38:51 +01:00
|
|
|
/* ...which has to be NULL. */
|
2003-06-10 16:37:04 +02:00
|
|
|
if (lnum)
|
|
|
|
{
|
|
|
|
remote_fileio_reply (-1, FILEIO_EINVAL);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = gettimeofday (&tv, NULL);
|
|
|
|
|
|
|
|
if (ret == -1)
|
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ptrval)
|
|
|
|
{
|
|
|
|
remote_fileio_to_fio_timeval (&tv, &ftv);
|
|
|
|
|
2011-01-25 12:54:00 +01:00
|
|
|
errno = target_write_memory (ptrval, (gdb_byte *) &ftv, sizeof ftv);
|
|
|
|
if (errno != 0)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_isatty (char *buf)
|
|
|
|
{
|
|
|
|
long target_fd;
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
/* Parameter: file descriptor */
|
|
|
|
if (remote_fileio_extract_int (&buf, &target_fd))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
fd = remote_fileio_map_fd ((int) target_fd);
|
|
|
|
remote_fileio_return_success (fd == FIO_FD_CONSOLE_IN ||
|
|
|
|
fd == FIO_FD_CONSOLE_OUT ? 1 : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remote_fileio_func_system (char *buf)
|
|
|
|
{
|
|
|
|
CORE_ADDR ptrval;
|
2012-05-18 23:02:52 +02:00
|
|
|
int ret, length;
|
2006-06-13 10:55:22 +02:00
|
|
|
char *cmdline = NULL;
|
2003-06-10 16:37:04 +02:00
|
|
|
|
|
|
|
/* Parameter: Ptr to commandline / length incl. trailing zero */
|
|
|
|
if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length))
|
|
|
|
{
|
|
|
|
remote_fileio_ioerror ();
|
|
|
|
return;
|
|
|
|
}
|
2006-06-13 10:55:22 +02:00
|
|
|
|
|
|
|
if (length)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
2006-06-13 10:55:22 +02:00
|
|
|
/* Request commandline using 'm' packet */
|
|
|
|
cmdline = alloca (length);
|
2011-01-25 12:54:00 +01:00
|
|
|
if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0)
|
2006-06-13 10:55:22 +02:00
|
|
|
{
|
|
|
|
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);
|
2003-06-10 16:37:04 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
remote_fio_no_longjmp = 1;
|
|
|
|
ret = system (cmdline);
|
|
|
|
|
2006-06-13 10:55:22 +02:00
|
|
|
if (!length)
|
|
|
|
remote_fileio_return_success (ret);
|
|
|
|
else if (ret == -1)
|
2003-06-10 16:37:04 +02:00
|
|
|
remote_fileio_return_errno (-1);
|
|
|
|
else
|
|
|
|
remote_fileio_return_success (WEXITSTATUS (ret));
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
char *name;
|
|
|
|
void (*func)(char *);
|
|
|
|
} remote_fio_func_map[] = {
|
2007-01-03 20:01:25 +01:00
|
|
|
{ "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 }
|
2003-06-10 16:37:04 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
|
|
|
|
{
|
|
|
|
char *buf = buf_arg;
|
|
|
|
char *c;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
|
|
|
|
|
|
|
|
c = strchr (++buf, ',');
|
|
|
|
if (c)
|
|
|
|
*c++ = '\0';
|
|
|
|
else
|
|
|
|
c = strchr (buf, '\0');
|
|
|
|
for (idx = 0; remote_fio_func_map[idx].name; ++idx)
|
|
|
|
if (!strcmp (remote_fio_func_map[idx].name, buf))
|
|
|
|
break;
|
2011-01-10 21:38:51 +01:00
|
|
|
if (!remote_fio_func_map[idx].name) /* ERROR: No such function. */
|
2003-06-10 16:37:04 +02:00
|
|
|
return RETURN_ERROR;
|
|
|
|
remote_fio_func_map[idx].func (c);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-06-08 21:08:22 +02:00
|
|
|
/* Close any open descriptors, and reinitialize the file mapping. */
|
|
|
|
|
|
|
|
void
|
|
|
|
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)
|
|
|
|
{
|
2008-09-14 01:37:05 +02:00
|
|
|
xfree (remote_fio_data.fd_map);
|
2006-06-08 21:08:22 +02:00
|
|
|
remote_fio_data.fd_map = NULL;
|
|
|
|
remote_fio_data.fd_map_size = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-10 21:38:51 +01:00
|
|
|
/* 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
|
2009-11-13 23:36:30 +01:00
|
|
|
acknowledged the Ctrl-C sent asynchronously earlier. */
|
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
void
|
2009-11-13 23:36:30 +01:00
|
|
|
remote_fileio_request (char *buf, int ctrlc_pending_p)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
|
|
|
int ex;
|
|
|
|
|
|
|
|
remote_fileio_sig_init ();
|
|
|
|
|
2009-11-13 23:36:30 +01:00
|
|
|
if (ctrlc_pending_p)
|
2003-06-10 16:37:04 +02:00
|
|
|
{
|
2009-11-13 23:36:30 +01:00
|
|
|
/* 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;
|
|
|
|
|
2011-08-04 Pedro Alves <pedro@codesourcery.com>
* ui-out.h (uiout): Rename to ...
(current_uiout): ... this.
* ui-out.c (uiout): Rename to ...
(current_uiout): ... this.
* ada-lang.c (print_it_exception, print_one_exception)
(print_mention_exception): Adjust.
* breakpoint.c (watchpoint_check): Adjust.
(print_breakpoint_location, print_one_breakpoint, breakpoint_1)
(default_collect_info, watchpoints_info, print_one_catch_fork)
(print_one_catch_vfork, print_one_catch_syscall)
(print_one_catch_exec, mention, print_it_ranged_breakpoint)
(print_one_ranged_breakpoint, print_mention_ranged_breakpoint)
(print_it_watchpoint, print_mention_watchpoint)
(print_it_masked_watchpoint, print_mention_masked_watchpoint)
(print_it_exception_catchpoint, print_one_exception_catchpoint)
(print_mention_exception_catchpoint, say_where, bkpt_print_it)
(bkpt_print_mention, momentary_bkpt_print_it)
(tracepoint_print_mention, update_static_tracepoint)
(tracepoints_info, save_breakpoints): Adjust.
* cli-out.c (field_separator): Adjust.
* cp-abi.c (list_cp_abis, show_cp_abi_cmd): Adjust.
* exceptions.c (catch_exceptions_with_msg, catch_errors): Adjust.
* frame.c (get_current_frame): Adjust.
* infcmd.c (run_command_1, print_return_value): Adjust.
* inferior.c (inferior_command, info_inferiors_command): Adjust.
* infrun.c (print_end_stepping_range_reason): Adjust.
(print_signal_exited_reason, print_exited_reason): Adjust.
(print_signal_received_reason, print_no_history_reason): Adjust.
* interps.c (interp_set): Adjust.
* osdata.c (info_osdata_command): Adjust.
* progspace.c (maintenance_info_program_spaces_command): Adjust.
* remote-fileio.c (remote_fileio_request): Adjust.
* remote.c (show_remote_cmd): Adjust.
* solib.c (info_sharedlibrary_command): Adjust.
* source.c (print_source_lines_base): Adjust.
* stack.c (print_stack_frame): Adjust.
(do_gdb_disassembly, print_frame_info, print_frame): Adjust.
* symfile-mem.c (add_vsyscall_page): Adjust.
* symfile.c (load_progress, generic_load)
(print_transfer_performance): Adjust.
* thread.c (info_threads_command, restore_selected_frame)
(thread_command): Adjust.
* top.c (make_cleanup_restore_ui_file): Adjust.
* tracepoint.c (tvariables_info_1, trace_status_mi, tfind_1)
(print_one_static_tracepoint_marker): Adjust.
* cli/cli-cmds.c (print_disassembly): Adjust.
* cli/cli-decode.c (print_doc_line): Adjust.
* cli/cli-interp.c (safe_execute_command): Adjust.
* cli/cli-logging.c (set_logging_redirect, pop_output_files)
(handle_redirections): Adjust.
* cli/cli-script.c (show_user_1): Adjust.
* cli/cli-setshow.c (do_setshow_command, cmd_show_list): Adjust.
* mi/mi-cmd-break.c (breakpoint_notify): Adjust.
* mi/mi-cmd-disas.c (mi_cmd_disassemble): Adjust.
* mi/mi-cmd-env.c (mi_cmd_env_pwd, mi_cmd_env_path)
(mi_cmd_env_dir): Adjust.
* mi/mi-cmd-file.c (mi_cmd_file_list_exec_source_file)
(print_partial_file_name, mi_cmd_file_list_exec_source_files): Adjust.
* mi/mi-cmd-stack.c (mi_cmd_stack_list_frames)
(mi_cmd_stack_info_depth, mi_cmd_stack_list_args)
(list_args_or_locals): Adjust.
* mi/mi-cmd-var.c (print_varobj, mi_cmd_var_create)
(mi_cmd_var_delete, mi_cmd_var_set_format, mi_cmd_var_set_frozen)
(mi_cmd_var_show_format, mi_cmd_var_info_num_children)
(mi_cmd_var_list_children, mi_cmd_var_info_type)
(mi_cmd_var_info_path_expression, mi_cmd_var_info_expression)
(mi_cmd_var_show_attributes, mi_cmd_var_evaluate_expression)
(mi_cmd_var_assign, mi_cmd_var_update, varobj_update_one): Adjust.
* mi/mi-interp.c (mi_on_normal_stop): Adjust.
* mi/mi-main.c (mi_cmd_gdb_exit, mi_cmd_thread_select)
(mi_cmd_thread_list_ids, mi_cmd_thread_info, print_one_inferior)
(list_available_thread_groups, mi_cmd_list_thread_groups)
(mi_cmd_data_list_register_names)
(mi_cmd_data_list_changed_registers)
(mi_cmd_data_list_register_values, get_register)
(mi_cmd_data_evaluate_expression, mi_cmd_data_read_memory)
(mi_cmd_data_read_memory_bytes, mi_cmd_list_features)
(mi_cmd_list_target_features, mi_cmd_add_inferior)
(mi_execute_command, mi_load_progress): Adjust.
* mi/mi-symbol-cmds.c (mi_cmd_symbol_list_lines): Adjust.
* python/py-auto-load.c (print_script, info_auto_load_scripts):
Adjust.
* python/py-breakpoint.c (bppy_get_commands): Adjust.
* tui/tui-interp.c (tui_command_loop): Adjust.
* tui/tui-io.c (tui_setup_io, tui_initialize_io): Adjust.
2011-08-04 21:10:14 +02:00
|
|
|
ex = catch_exceptions (current_uiout,
|
|
|
|
do_remote_fileio_request, (void *)buf,
|
2009-11-13 23:36:30 +01:00
|
|
|
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;
|
|
|
|
}
|
2003-06-10 16:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
remote_fileio_sig_exit ();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
set_system_call_allowed (char *args, int from_tty)
|
|
|
|
{
|
|
|
|
if (args)
|
|
|
|
{
|
|
|
|
char *arg_end;
|
|
|
|
int val = strtoul (args, &arg_end, 10);
|
2010-05-16 23:11:14 +02:00
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
if (*args && *arg_end == '\0')
|
|
|
|
{
|
|
|
|
remote_fio_system_call_allowed = !!val;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2005-02-10 Andrew Cagney <cagney@gnu.org>
Mark up all error and warning messages.
* ada-lang.c, amd64-tdep.c, arch-utils.c, breakpoint.c: Update.
* bsd-kvm.c, bsd-uthread.c, coff-solib.h, coffread.c: Update.
* core-aout.c, core-regset.c, corefile.c, corelow.c: Update.
* cp-abi.c, cp-support.c, cp-valprint.c, cris-tdep.c: Update.
* dbxread.c, demangle.c, doublest.c, dsrec.c: Update.
* dve3900-rom.c, dwarf2expr.c, dwarf2loc.c: Update.
* dwarf2read.c, dwarfread.c, elfread.c, eval.c: Update.
* event-top.c, exec.c, expprint.c, f-lang.c: Update.
* f-typeprint.c, f-valprint.c, fbsd-nat.c, findvar.c: Update.
* frame.c, frv-linux-tdep.c, gcore.c, gdbtypes.c: Update.
* gnu-nat.c, gnu-v2-abi.c, gnu-v3-abi.c, go32-nat.c: Update.
* hpacc-abi.c, hppa-hpux-nat.c, hppa-hpux-tdep.c: Update.
* hppa-linux-nat.c, hppa-linux-tdep.c, hppa-tdep.c: Update.
* hpread.c, hpux-thread.c, i386-linux-nat.c: Update.
* i386-linux-tdep.c, i386-tdep.c, i386bsd-nat.c: Update.
* i386gnu-nat.c, i387-tdep.c, ia64-linux-nat.c: Update.
* ia64-tdep.c, inf-child.c, inf-ptrace.c, inf-ttrace.c: Update.
* infcall.c, infcmd.c, inflow.c, infptrace.c, infrun.c: Update.
* inftarg.c, interps.c, irix5-nat.c, jv-lang.c: Update.
* kod-cisco.c, kod.c, language.c, libunwind-frame.c: Update.
* linespec.c, linux-nat.c, linux-thread-db.c, m2-lang.c: Update.
* m32r-rom.c, m68hc11-tdep.c, m68k-tdep.c: Update.
* m68klinux-nat.c, macrocmd.c, macroexp.c, main.c: Update.
* maint.c, mdebugread.c, mem-break.c, memattr.c: Update.
* mips-linux-tdep.c, mips-tdep.c, mipsread.c, monitor.c: Update.
* nlmread.c, nto-procfs.c, objc-lang.c, objfiles.c: Update.
* observer.c, ocd.c, p-lang.c, p-typeprint.c: Update.
* p-valprint.c, pa64solib.c, parse.c, ppc-linux-tdep.c: Update.
* ppcnbsd-tdep.c, printcmd.c, procfs.c, remote-e7000.c: Update.
* remote-fileio.c, remote-m32r-sdi.c, remote-rdi.c: Update.
* remote-rdp.c, remote-sim.c, remote-st.c: Update.
* remote-utils.c, remote-utils.h, remote.c: Update.
* rom68k-rom.c, rs6000-nat.c, s390-tdep.c, scm-lang.c: Update.
* ser-e7kpc.c, ser-tcp.c, ser-unix.c, sh-tdep.c: Update.
* sh3-rom.c, shnbsd-tdep.c, sol-thread.c, solib-aix5.c: Update.
* solib-frv.c, solib-irix.c, solib-osf.c, solib-pa64.c: Update.
* solib-som.c, solib-sunos.c, solib-svr4.c, solib.c: Update.
* somread.c, somsolib.c, source.c, stabsread.c: Update.
* stack.c, std-regs.c, symfile-mem.c, symfile.c: Update.
* symmisc.c, symtab.c, target.c, thread.c, top.c: Update.
* tracepoint.c, trad-frame.c, typeprint.c, utils.c: Update.
* uw-thread.c, valarith.c, valops.c, valprint.c: Update.
* value.c, varobj.c, version.in, win32-nat.c, wince.c: Update.
* xcoffread.c, xcoffsolib.c, cli/cli-cmds.c: Update.
* cli/cli-decode.c, cli/cli-dump.c, cli/cli-logging.c: Update.
* cli/cli-script.c, cli/cli-setshow.c, mi/mi-cmd-break.c: Update.
* mi/mi-cmd-disas.c, mi/mi-cmd-env.c, mi/mi-cmd-file.c: Update.
* mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-getopt.c: Update.
* mi/mi-symbol-cmds.c, tui/tui-layout.c, tui/tui-stack.c: Update.
* tui/tui-win.c: Update.
2005-02-11 05:06:14 +01:00
|
|
|
error (_("Illegal argument for \"set remote system-call-allowed\" command"));
|
2003-06-10 16:37:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
show_system_call_allowed (char *args, int from_tty)
|
|
|
|
{
|
|
|
|
if (args)
|
2011-01-05 23:22:53 +01:00
|
|
|
error (_("Garbage after \"show remote "
|
|
|
|
"system-call-allowed\" command: `%s'"), args);
|
2003-06-10 16:37:04 +02:00
|
|
|
printf_unfiltered ("Calling host system(3) call from target is %sallowed\n",
|
|
|
|
remote_fio_system_call_allowed ? "" : "not ");
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
initialize_remote_fileio (struct cmd_list_element *remote_set_cmdlist,
|
|
|
|
struct cmd_list_element *remote_show_cmdlist)
|
|
|
|
{
|
2008-03-05 18:21:10 +01:00
|
|
|
sigint_fileio_token =
|
|
|
|
create_async_signal_handler (async_remote_fileio_interrupt, NULL);
|
|
|
|
|
2003-06-10 16:37:04 +02:00
|
|
|
add_cmd ("system-call-allowed", no_class,
|
|
|
|
set_system_call_allowed,
|
2005-02-14 Andrew Cagney <cagney@gnu.org>
Mark up add_cmd.
* arch-utils.c, avr-tdep.c, breakpoint.c, corefile.c: Update.
* cp-abi.c, cp-namespace.c, cp-support.c, dummy-frame.c: Update.
* exec.c, gnu-nat.c, go32-nat.c, hppa-tdep.c, infcmd.c: Update.
* infrun.c, interps.c, macrocmd.c, maint.c, memattr.c: Update.
* mips-tdep.c, ocd.c, osabi.c, printcmd.c, regcache.c: Update.
* reggroups.c, remote-fileio.c, remote-rdi.c, remote.c: Update.
* sol-thread.c, source.c, stack.c, symfile-mem.c: Update.
* symfile.c, thread.c, tracepoint.c, valprint.c, value.c: Update.
* win32-nat.c, cli/cli-cmds.c, cli/cli-dump.c: Update.
* cli/cli-logging.c, tui/tui-regs.c: Update.
2005-02-14 19:10:11 +01:00
|
|
|
_("Set if the host system(3) call is allowed for the target."),
|
2003-06-10 16:37:04 +02:00
|
|
|
&remote_set_cmdlist);
|
|
|
|
add_cmd ("system-call-allowed", no_class,
|
|
|
|
show_system_call_allowed,
|
2005-02-14 Andrew Cagney <cagney@gnu.org>
Mark up add_cmd.
* arch-utils.c, avr-tdep.c, breakpoint.c, corefile.c: Update.
* cp-abi.c, cp-namespace.c, cp-support.c, dummy-frame.c: Update.
* exec.c, gnu-nat.c, go32-nat.c, hppa-tdep.c, infcmd.c: Update.
* infrun.c, interps.c, macrocmd.c, maint.c, memattr.c: Update.
* mips-tdep.c, ocd.c, osabi.c, printcmd.c, regcache.c: Update.
* reggroups.c, remote-fileio.c, remote-rdi.c, remote.c: Update.
* sol-thread.c, source.c, stack.c, symfile-mem.c: Update.
* symfile.c, thread.c, tracepoint.c, valprint.c, value.c: Update.
* win32-nat.c, cli/cli-cmds.c, cli/cli-dump.c: Update.
* cli/cli-logging.c, tui/tui-regs.c: Update.
2005-02-14 19:10:11 +01:00
|
|
|
_("Show if the host system(3) call is allowed for the target."),
|
2003-06-10 16:37:04 +02:00
|
|
|
&remote_show_cmdlist);
|
|
|
|
}
|