/* Remote File-I/O communications
- Copyright 2003 Free Software Foundation, Inc.
+ Copyright 2003, 2005 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "remote.h"
#include "gdb/fileio.h"
+#include "gdb_wait.h"
+#include "gdb_stat.h"
+#include "exceptions.h"
+#include "remote-fileio.h"
-#include <ctype.h>
#include <fcntl.h>
#include <sys/time.h>
-#ifdef USG
-#include <sys/types.h>
-#endif
-#include <sys/stat.h>
#ifdef __CYGWIN__
-#include <sys/cygwin.h>
+#include <sys/cygwin.h> /* For cygwin_conv_to_full_posix_path. */
#endif
-#include <setjmp.h>
#include <signal.h>
static struct {
static int remote_fio_system_call_allowed = 0;
static int
-remote_fileio_init_fd_map ()
+remote_fileio_init_fd_map (void)
{
int i;
}
static int
-remote_fileio_resize_fd_map ()
+remote_fileio_resize_fd_map (void)
{
if (!remote_fio_data.fd_map)
return remote_fileio_init_fd_map ();
}
static int
-remote_fileio_next_free_fd ()
+remote_fileio_next_free_fd (void)
{
int i;
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;
}
-static long long
+static LONGEST
remote_fileio_mode_to_target (mode_t mode)
{
mode_t tmode = 0;
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;
}
}
static int
-remote_fileio_extract_long (char **buf, long long *retlong)
+remote_fileio_extract_long (char **buf, LONGEST *retlong)
{
char *c;
int sign = 1;
remote_fileio_extract_int (char **buf, long *retint)
{
int ret;
- long long retlong;
+ LONGEST retlong;
if (!retint)
return -1;
- if (!(ret = remote_fileio_extract_long (buf, &retlong)))
+ ret = remote_fileio_extract_long (buf, &retlong);
+ if (!ret)
*retint = (long) retlong;
return ret;
}
remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length)
{
char *c;
- long long retlong;
+ LONGEST retlong;
if (!buf || !*buf || !**buf || !ptrval || !length)
return -1;
/* Convert to big endian */
static void
-remote_fileio_to_be (long long num, char *buf, int bytes)
+remote_fileio_to_be (LONGEST num, char *buf, int bytes)
{
int i;
buf[i] = (num >> (8 * (bytes - i - 1))) & 0xff;
}
-static void
-remote_fileio_to_fio_int (long num, fio_int_t fnum)
-{
- remote_fileio_to_be ((long long) num, (char *) fnum, 4);
-}
-
static void
remote_fileio_to_fio_uint (long num, fio_uint_t fnum)
{
- remote_fileio_to_be ((long long) num, (char *) fnum, 4);
+ remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4);
}
static void
static void
remote_fileio_to_fio_time (time_t num, fio_time_t fnum)
{
- remote_fileio_to_be ((long long) num, (char *) fnum, 4);
+ remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4);
}
static void
-remote_fileio_to_fio_long (long long num, fio_long_t fnum)
+remote_fileio_to_fio_long (LONGEST num, fio_long_t fnum)
{
remote_fileio_to_be (num, (char *) fnum, 8);
}
static void
-remote_fileio_to_fio_ulong (long long num, fio_ulong_t fnum)
+remote_fileio_to_fio_ulong (LONGEST num, fio_ulong_t fnum)
{
remote_fileio_to_be (num, (char *) fnum, 8);
}
static void
remote_fileio_to_fio_stat (struct stat *st, struct fio_stat *fst)
{
+ 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_uid, fst->fst_uid);
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 ((long long) st->st_size, fst->fst_size);
- remote_fileio_to_fio_ulong ((long long) st->st_blksize, fst->fst_blksize);
- remote_fileio_to_fio_ulong ((long long) st->st_blocks, fst->fst_blocks);
+ remote_fileio_to_fio_ulong ((LONGEST) st->st_size, fst->fst_size);
+#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 + blksize - 1)
+ / blksize,
+ fst->fst_blocks);
+#endif
remote_fileio_to_fio_time (st->st_atime, fst->fst_atime);
remote_fileio_to_fio_time (st->st_mtime, fst->fst_mtime);
remote_fileio_to_fio_time (st->st_ctime, fst->fst_ctime);
static int remote_fio_ctrl_c_flag = 0;
static int remote_fio_no_longjmp = 0;
-jmp_buf remote_fio_jmp_buf;
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
static struct sigaction remote_fio_sa;
#endif
static void
-remote_fileio_sig_init ()
+remote_fileio_sig_init (void)
{
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
remote_fio_sa.sa_handler = SIG_IGN;
}
static void
-remote_fileio_sig_exit ()
+remote_fileio_sig_exit (void)
{
#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
sigaction (SIGINT, &remote_fio_osa, NULL);
remote_fileio_sig_set (SIG_IGN);
remote_fio_ctrl_c_flag = 1;
if (!remote_fio_no_longjmp)
- throw_exception (RETURN_QUIT);
+ deprecated_throw_reason (RETURN_QUIT);
remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler);
}
}
static void
-remote_fileio_ioerror ()
+remote_fileio_ioerror (void)
{
remote_fileio_reply (-1, FILEIO_EIO);
}
static void
-remote_fileio_badfd ()
+remote_fileio_badfd (void)
{
remote_fileio_reply (-1, FILEIO_EBADF);
}
remote_fileio_ioerror ();
return;
}
- if ((fd = remote_fileio_map_fd ((int) num)) == FIO_FD_INVALID)
+ fd = remote_fileio_map_fd ((int) num);
+ if (fd == FIO_FD_INVALID)
{
remote_fileio_badfd ();
return;
remote_fileio_func_read (char *buf)
{
long target_fd, num;
- long long lnum;
+ LONGEST lnum;
CORE_ADDR ptrval;
int fd, ret, retlength;
char *buffer;
remote_fileio_ioerror ();
return;
}
- if ((fd = remote_fileio_map_fd ((int) target_fd)) == FIO_FD_INVALID)
+ fd = remote_fileio_map_fd ((int) target_fd);
+ if (fd == FIO_FD_INVALID)
{
remote_fileio_badfd ();
return;
remote_fileio_func_write (char *buf)
{
long target_fd, num;
- long long lnum;
+ LONGEST lnum;
CORE_ADDR ptrval;
int fd, ret, retlength;
char *buffer;
remote_fileio_ioerror ();
return;
}
- if ((fd = remote_fileio_map_fd ((int) target_fd)) == FIO_FD_INVALID)
+ fd = remote_fileio_map_fd ((int) target_fd);
+ if (fd == FIO_FD_INVALID)
{
remote_fileio_badfd ();
return;
remote_fileio_func_lseek (char *buf)
{
long num;
- long long lnum;
+ LONGEST lnum;
int fd, flag;
off_t offset, ret;
remote_fileio_ioerror ();
return;
}
- if ((fd = remote_fileio_map_fd ((int) num)) == FIO_FD_INVALID)
+ fd = remote_fileio_map_fd ((int) num);
+ if (fd == FIO_FD_INVALID)
{
remote_fileio_badfd ();
return;
}
/* Only operate on regular files and directories */
- if ((!(of = stat (oldpath, &ost))
- && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode))
- || (!(nf = stat (newpath, &nst))
- && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode)))
+ 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)))
{
remote_fileio_reply (-1, FILEIO_EACCES);
return;
CORE_ADDR ptrval;
int ret, length, retlength;
char *pathname;
- long long lnum;
+ LONGEST lnum;
struct stat st;
struct fio_stat fst;
CORE_ADDR ptrval;
int fd, ret, retlength;
long target_fd;
- long long lnum;
+ LONGEST lnum;
struct stat st;
struct fio_stat fst;
struct timeval tv;
remote_fileio_ioerror ();
return;
}
- if ((fd = remote_fileio_map_fd ((int) target_fd)) == FIO_FD_INVALID)
+ fd = remote_fileio_map_fd ((int) target_fd);
+ if (fd == FIO_FD_INVALID)
{
remote_fileio_badfd ();
return;
remote_fileio_to_fio_uint (1, fst.fst_dev);
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 ();
+#else
+ st.st_uid = 0;
+#endif
+#ifdef HAVE_GETGID
st.st_gid = getgid ();
+#else
+ st.st_gid = 0;
+#endif
st.st_rdev = 0;
st.st_size = 0;
+#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
st.st_blksize = 512;
+#endif
+#if HAVE_STRUCT_STAT_ST_BLOCKS
st.st_blocks = 0;
+#endif
if (!gettimeofday (&tv, NULL))
st.st_atime = st.st_mtime = st.st_ctime = tv.tv_sec;
else
static void
remote_fileio_func_gettimeofday (char *buf)
{
- long long lnum;
+ LONGEST lnum;
CORE_ADDR ptrval;
int ret, retlength;
struct timeval tv;
remote_fio_no_longjmp = 0;
ex = catch_exceptions (uiout, do_remote_fileio_request, (void *)buf,
- NULL, RETURN_MASK_ALL);
+ RETURN_MASK_ALL);
switch (ex)
{
case RETURN_ERROR:
return;
}
}
- error ("Illegal argument for \"set remote system-call-allowed\" command");
+ error (_("Illegal argument for \"set remote system-call-allowed\" command"));
}
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 ");
}
{
add_cmd ("system-call-allowed", no_class,
set_system_call_allowed,
- "Set if the host system(3) call is allowed for the target.\n",
+ _("Set if the host system(3) call is allowed for the target."),
&remote_set_cmdlist);
add_cmd ("system-call-allowed", no_class,
show_system_call_allowed,
- "Show if the host system(3) call is allowed for the target.\n",
+ _("Show if the host system(3) call is allowed for the target."),
&remote_show_cmdlist);
}
projects / deliverable / binutils-gdb.git / blobdiff