/* Remote File-I/O communications
- Copyright (C) 2003-2015 Free Software Foundation, Inc.
+ Copyright (C) 2003-2016 Free Software Foundation, Inc.
This file is part of GDB.
static int remote_fio_system_call_allowed = 0;
-static struct async_signal_handler *sigint_fileio_token;
-
static int
remote_fileio_init_fd_map (void)
{
if (!remote_fio_data.fd_map)
{
- remote_fio_data.fd_map = (int *) xmalloc (10 * sizeof (int));
+ remote_fio_data.fd_map = XNEWVEC (int, 10);
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;
}
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;
#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)
- gdb_call_async_signal_handler (sigint_fileio_token, 1);
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
+ remote_fio_ctrl_c_flag = 1;
}
static void
if (remote_fio_ctrl_c_flag)
strcat (buf, ",C");
}
+ remote_fio_ctrl_c_flag = 0;
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
putpkt (buf);
}
mode = remote_fileio_mode_to_host (num, 1);
/* Request pathname. */
- pathname = alloca (length);
+ pathname = (char *) alloca (length);
if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
{
remote_fileio_ioerror ();
}
}
- remote_fio_no_longjmp = 1;
fd = gdb_open_cloexec (pathname, flags, mode);
if (fd < 0)
{
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);
buffer = (gdb_byte *) xmalloc (16384);
if (remaining_buf)
{
- remote_fio_no_longjmp = 1;
if (remaining_length > length)
{
memcpy (buffer, remaining_buf, length);
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)
{
remaining_buf = (char *) xmalloc (ret - length);
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)
{
return;
}
- remote_fio_no_longjmp = 1;
switch (fd)
{
case FIO_FD_CONSOLE_IN:
return;
}
- remote_fio_no_longjmp = 1;
ret = lseek (fd, offset, flag);
if (ret == (off_t) -1)
}
/* Request oldpath using 'm' packet */
- oldpath = alloca (old_len);
+ oldpath = (char *) alloca (old_len);
if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0)
{
remote_fileio_ioerror ();
}
/* Request newpath using 'm' packet */
- newpath = alloca (new_len);
+ newpath = (char *) alloca (new_len);
if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0)
{
remote_fileio_ioerror ();
return;
}
- remote_fio_no_longjmp = 1;
ret = rename (oldpath, newpath);
if (ret == -1)
return;
}
/* Request pathname using 'm' packet */
- pathname = alloca (length);
+ pathname = (char *) alloca (length);
if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0)
{
remote_fileio_ioerror ();
return;
}
- remote_fio_no_longjmp = 1;
ret = unlink (pathname);
if (ret == -1)
statptr = (CORE_ADDR) lnum;
/* Request pathname using 'm' packet */
- pathname = alloca (namelength);
+ pathname = (char *) alloca (namelength);
if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0)
{
remote_fileio_ioerror ();
return;
}
- remote_fio_no_longjmp = 1;
ret = stat (pathname, &st);
if (ret == -1)
}
ptrval = (CORE_ADDR) lnum;
- remote_fio_no_longjmp = 1;
if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT)
{
host_to_fileio_uint (1, fst.fst_dev);
return;
}
- remote_fio_no_longjmp = 1;
ret = gettimeofday (&tv, NULL);
if (ret == -1)
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);
if (length)
{
/* Request commandline using 'm' packet */
- cmdline = alloca (length);
+ cmdline = (char *) alloca (length);
if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0)
{
remote_fileio_ioerror ();
return;
}
- remote_fio_no_longjmp = 1;
ret = system (cmdline);
if (!length)
static int
do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
{
- char *buf = buf_arg;
+ char *buf = (char *) buf_arg;
char *c;
int idx;
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,
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."),