1 /* Remote File-I/O communications 2 3 Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 /* See the GDB User Guide for details of the GDB remote protocol. */ 22 23 #include "defs.h" 24 #include "gdb_string.h" 25 #include "gdbcmd.h" 26 #include "remote.h" 27 #include "gdb/fileio.h" 28 #include "gdb_wait.h" 29 #include "gdb_stat.h" 30 #include "exceptions.h" 31 #include "remote-fileio.h" 32 #include "event-loop.h" 33 #include "target.h" 34 #include "filenames.h" 35 36 #include <fcntl.h> 37 #include <sys/time.h> 38 #ifdef __CYGWIN__ 39 #include <sys/cygwin.h> /* For cygwin_conv_to_full_posix_path. */ 40 #include <cygwin/version.h> 41 #if CYGWIN_VERSION_DLL_MAKE_COMBINED(CYGWIN_VERSION_API_MAJOR,CYGWIN_VERSION_API_MINOR) < 181 42 # define CCP_POSIX_TO_WIN_A 0 43 # define CCP_WIN_A_TO_POSIX 2 44 # define cygwin_conv_path(op, from, to, size) \ 45 (op == CCP_WIN_A_TO_POSIX) ? \ 46 cygwin_conv_to_full_posix_path (from, to) : \ 47 cygwin_conv_to_win32_path (from, to) 48 #endif 49 #endif 50 #include <signal.h> 51 52 static struct { 53 int *fd_map; 54 int fd_map_size; 55 } remote_fio_data; 56 57 #define FIO_FD_INVALID -1 58 #define FIO_FD_CONSOLE_IN -2 59 #define FIO_FD_CONSOLE_OUT -3 60 61 static int remote_fio_system_call_allowed = 0; 62 63 static struct async_signal_handler *sigint_fileio_token; 64 65 static int 66 remote_fileio_init_fd_map (void) 67 { 68 int i; 69 70 if (!remote_fio_data.fd_map) 71 { 72 remote_fio_data.fd_map = (int *) xmalloc (10 * sizeof (int)); 73 remote_fio_data.fd_map_size = 10; 74 remote_fio_data.fd_map[0] = FIO_FD_CONSOLE_IN; 75 remote_fio_data.fd_map[1] = FIO_FD_CONSOLE_OUT; 76 remote_fio_data.fd_map[2] = FIO_FD_CONSOLE_OUT; 77 for (i = 3; i < 10; ++i) 78 remote_fio_data.fd_map[i] = FIO_FD_INVALID; 79 } 80 return 3; 81 } 82 83 static int 84 remote_fileio_resize_fd_map (void) 85 { 86 int i = remote_fio_data.fd_map_size; 87 88 if (!remote_fio_data.fd_map) 89 return remote_fileio_init_fd_map (); 90 remote_fio_data.fd_map_size += 10; 91 remote_fio_data.fd_map = 92 (int *) xrealloc (remote_fio_data.fd_map, 93 remote_fio_data.fd_map_size * sizeof (int)); 94 for (; i < remote_fio_data.fd_map_size; i++) 95 remote_fio_data.fd_map[i] = FIO_FD_INVALID; 96 return remote_fio_data.fd_map_size - 10; 97 } 98 99 static int 100 remote_fileio_next_free_fd (void) 101 { 102 int i; 103 104 for (i = 0; i < remote_fio_data.fd_map_size; ++i) 105 if (remote_fio_data.fd_map[i] == FIO_FD_INVALID) 106 return i; 107 return remote_fileio_resize_fd_map (); 108 } 109 110 static int 111 remote_fileio_fd_to_targetfd (int fd) 112 { 113 int target_fd = remote_fileio_next_free_fd (); 114 115 remote_fio_data.fd_map[target_fd] = fd; 116 return target_fd; 117 } 118 119 static int 120 remote_fileio_map_fd (int target_fd) 121 { 122 remote_fileio_init_fd_map (); 123 if (target_fd < 0 || target_fd >= remote_fio_data.fd_map_size) 124 return FIO_FD_INVALID; 125 return remote_fio_data.fd_map[target_fd]; 126 } 127 128 static void 129 remote_fileio_close_target_fd (int target_fd) 130 { 131 remote_fileio_init_fd_map (); 132 if (target_fd >= 0 && target_fd < remote_fio_data.fd_map_size) 133 remote_fio_data.fd_map[target_fd] = FIO_FD_INVALID; 134 } 135 136 static int 137 remote_fileio_oflags_to_host (long flags) 138 { 139 int hflags = 0; 140 141 if (flags & FILEIO_O_CREAT) 142 hflags |= O_CREAT; 143 if (flags & FILEIO_O_EXCL) 144 hflags |= O_EXCL; 145 if (flags & FILEIO_O_TRUNC) 146 hflags |= O_TRUNC; 147 if (flags & FILEIO_O_APPEND) 148 hflags |= O_APPEND; 149 if (flags & FILEIO_O_RDONLY) 150 hflags |= O_RDONLY; 151 if (flags & FILEIO_O_WRONLY) 152 hflags |= O_WRONLY; 153 if (flags & FILEIO_O_RDWR) 154 hflags |= O_RDWR; 155 /* On systems supporting binary and text mode, always open files in 156 binary mode. */ 157 #ifdef O_BINARY 158 hflags |= O_BINARY; 159 #endif 160 return hflags; 161 } 162 163 static mode_t 164 remote_fileio_mode_to_host (long mode, int open_call) 165 { 166 mode_t hmode = 0; 167 168 if (!open_call) 169 { 170 if (mode & FILEIO_S_IFREG) 171 hmode |= S_IFREG; 172 if (mode & FILEIO_S_IFDIR) 173 hmode |= S_IFDIR; 174 if (mode & FILEIO_S_IFCHR) 175 hmode |= S_IFCHR; 176 } 177 if (mode & FILEIO_S_IRUSR) 178 hmode |= S_IRUSR; 179 if (mode & FILEIO_S_IWUSR) 180 hmode |= S_IWUSR; 181 if (mode & FILEIO_S_IXUSR) 182 hmode |= S_IXUSR; 183 #ifdef S_IRGRP 184 if (mode & FILEIO_S_IRGRP) 185 hmode |= S_IRGRP; 186 #endif 187 #ifdef S_IWGRP 188 if (mode & FILEIO_S_IWGRP) 189 hmode |= S_IWGRP; 190 #endif 191 #ifdef S_IXGRP 192 if (mode & FILEIO_S_IXGRP) 193 hmode |= S_IXGRP; 194 #endif 195 if (mode & FILEIO_S_IROTH) 196 hmode |= S_IROTH; 197 #ifdef S_IWOTH 198 if (mode & FILEIO_S_IWOTH) 199 hmode |= S_IWOTH; 200 #endif 201 #ifdef S_IXOTH 202 if (mode & FILEIO_S_IXOTH) 203 hmode |= S_IXOTH; 204 #endif 205 return hmode; 206 } 207 208 static LONGEST 209 remote_fileio_mode_to_target (mode_t mode) 210 { 211 mode_t tmode = 0; 212 213 if (S_ISREG(mode)) 214 tmode |= FILEIO_S_IFREG; 215 if (S_ISDIR(mode)) 216 tmode |= FILEIO_S_IFDIR; 217 if (S_ISCHR(mode)) 218 tmode |= FILEIO_S_IFCHR; 219 if (mode & S_IRUSR) 220 tmode |= FILEIO_S_IRUSR; 221 if (mode & S_IWUSR) 222 tmode |= FILEIO_S_IWUSR; 223 if (mode & S_IXUSR) 224 tmode |= FILEIO_S_IXUSR; 225 #ifdef S_IRGRP 226 if (mode & S_IRGRP) 227 tmode |= FILEIO_S_IRGRP; 228 #endif 229 #ifdef S_IWRGRP 230 if (mode & S_IWGRP) 231 tmode |= FILEIO_S_IWGRP; 232 #endif 233 #ifdef S_IXGRP 234 if (mode & S_IXGRP) 235 tmode |= FILEIO_S_IXGRP; 236 #endif 237 if (mode & S_IROTH) 238 tmode |= FILEIO_S_IROTH; 239 #ifdef S_IWOTH 240 if (mode & S_IWOTH) 241 tmode |= FILEIO_S_IWOTH; 242 #endif 243 #ifdef S_IXOTH 244 if (mode & S_IXOTH) 245 tmode |= FILEIO_S_IXOTH; 246 #endif 247 return tmode; 248 } 249 250 static int 251 remote_fileio_errno_to_target (int error) 252 { 253 switch (error) 254 { 255 case EPERM: 256 return FILEIO_EPERM; 257 case ENOENT: 258 return FILEIO_ENOENT; 259 case EINTR: 260 return FILEIO_EINTR; 261 case EIO: 262 return FILEIO_EIO; 263 case EBADF: 264 return FILEIO_EBADF; 265 case EACCES: 266 return FILEIO_EACCES; 267 case EFAULT: 268 return FILEIO_EFAULT; 269 case EBUSY: 270 return FILEIO_EBUSY; 271 case EEXIST: 272 return FILEIO_EEXIST; 273 case ENODEV: 274 return FILEIO_ENODEV; 275 case ENOTDIR: 276 return FILEIO_ENOTDIR; 277 case EISDIR: 278 return FILEIO_EISDIR; 279 case EINVAL: 280 return FILEIO_EINVAL; 281 case ENFILE: 282 return FILEIO_ENFILE; 283 case EMFILE: 284 return FILEIO_EMFILE; 285 case EFBIG: 286 return FILEIO_EFBIG; 287 case ENOSPC: 288 return FILEIO_ENOSPC; 289 case ESPIPE: 290 return FILEIO_ESPIPE; 291 case EROFS: 292 return FILEIO_EROFS; 293 case ENOSYS: 294 return FILEIO_ENOSYS; 295 case ENAMETOOLONG: 296 return FILEIO_ENAMETOOLONG; 297 } 298 return FILEIO_EUNKNOWN; 299 } 300 301 static int 302 remote_fileio_seek_flag_to_host (long num, int *flag) 303 { 304 if (!flag) 305 return 0; 306 switch (num) 307 { 308 case FILEIO_SEEK_SET: 309 *flag = SEEK_SET; 310 break; 311 case FILEIO_SEEK_CUR: 312 *flag = SEEK_CUR; 313 break; 314 case FILEIO_SEEK_END: 315 *flag = SEEK_END; 316 break; 317 default: 318 return -1; 319 } 320 return 0; 321 } 322 323 static int 324 remote_fileio_extract_long (char **buf, LONGEST *retlong) 325 { 326 char *c; 327 int sign = 1; 328 329 if (!buf || !*buf || !**buf || !retlong) 330 return -1; 331 c = strchr (*buf, ','); 332 if (c) 333 *c++ = '\0'; 334 else 335 c = strchr (*buf, '\0'); 336 while (strchr ("+-", **buf)) 337 { 338 if (**buf == '-') 339 sign = -sign; 340 ++*buf; 341 } 342 for (*retlong = 0; **buf; ++*buf) 343 { 344 *retlong <<= 4; 345 if (**buf >= '0' && **buf <= '9') 346 *retlong += **buf - '0'; 347 else if (**buf >= 'a' && **buf <= 'f') 348 *retlong += **buf - 'a' + 10; 349 else if (**buf >= 'A' && **buf <= 'F') 350 *retlong += **buf - 'A' + 10; 351 else 352 return -1; 353 } 354 *retlong *= sign; 355 *buf = c; 356 return 0; 357 } 358 359 static int 360 remote_fileio_extract_int (char **buf, long *retint) 361 { 362 int ret; 363 LONGEST retlong; 364 365 if (!retint) 366 return -1; 367 ret = remote_fileio_extract_long (buf, &retlong); 368 if (!ret) 369 *retint = (long) retlong; 370 return ret; 371 } 372 373 static int 374 remote_fileio_extract_ptr_w_len (char **buf, CORE_ADDR *ptrval, int *length) 375 { 376 char *c; 377 LONGEST retlong; 378 379 if (!buf || !*buf || !**buf || !ptrval || !length) 380 return -1; 381 c = strchr (*buf, '/'); 382 if (!c) 383 return -1; 384 *c++ = '\0'; 385 if (remote_fileio_extract_long (buf, &retlong)) 386 return -1; 387 *ptrval = (CORE_ADDR) retlong; 388 *buf = c; 389 if (remote_fileio_extract_long (buf, &retlong)) 390 return -1; 391 *length = (int) retlong; 392 return 0; 393 } 394 395 /* Convert to big endian. */ 396 static void 397 remote_fileio_to_be (LONGEST num, char *buf, int bytes) 398 { 399 int i; 400 401 for (i = 0; i < bytes; ++i) 402 buf[i] = (num >> (8 * (bytes - i - 1))) & 0xff; 403 } 404 405 static void 406 remote_fileio_to_fio_uint (long num, fio_uint_t fnum) 407 { 408 remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4); 409 } 410 411 static void 412 remote_fileio_to_fio_mode (mode_t num, fio_mode_t fnum) 413 { 414 remote_fileio_to_be (remote_fileio_mode_to_target(num), (char *) fnum, 4); 415 } 416 417 static void 418 remote_fileio_to_fio_time (time_t num, fio_time_t fnum) 419 { 420 remote_fileio_to_be ((LONGEST) num, (char *) fnum, 4); 421 } 422 423 static void 424 remote_fileio_to_fio_long (LONGEST num, fio_long_t fnum) 425 { 426 remote_fileio_to_be (num, (char *) fnum, 8); 427 } 428 429 static void 430 remote_fileio_to_fio_ulong (LONGEST num, fio_ulong_t fnum) 431 { 432 remote_fileio_to_be (num, (char *) fnum, 8); 433 } 434 435 static void 436 remote_fileio_to_fio_stat (struct stat *st, struct fio_stat *fst) 437 { 438 LONGEST blksize; 439 440 /* `st_dev' is set in the calling function. */ 441 remote_fileio_to_fio_uint ((long) st->st_ino, fst->fst_ino); 442 remote_fileio_to_fio_mode (st->st_mode, fst->fst_mode); 443 remote_fileio_to_fio_uint ((long) st->st_nlink, fst->fst_nlink); 444 remote_fileio_to_fio_uint ((long) st->st_uid, fst->fst_uid); 445 remote_fileio_to_fio_uint ((long) st->st_gid, fst->fst_gid); 446 remote_fileio_to_fio_uint ((long) st->st_rdev, fst->fst_rdev); 447 remote_fileio_to_fio_ulong ((LONGEST) st->st_size, fst->fst_size); 448 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE 449 blksize = st->st_blksize; 450 #else 451 blksize = 512; 452 #endif 453 remote_fileio_to_fio_ulong (blksize, fst->fst_blksize); 454 #if HAVE_STRUCT_STAT_ST_BLOCKS 455 remote_fileio_to_fio_ulong ((LONGEST) st->st_blocks, fst->fst_blocks); 456 #else 457 /* FIXME: This is correct for DJGPP, but other systems that don't 458 have st_blocks, if any, might prefer 512 instead of st_blksize. 459 (eliz, 30-12-2003) */ 460 remote_fileio_to_fio_ulong (((LONGEST) st->st_size + blksize - 1) 461 / blksize, 462 fst->fst_blocks); 463 #endif 464 remote_fileio_to_fio_time (st->st_atime, fst->fst_atime); 465 remote_fileio_to_fio_time (st->st_mtime, fst->fst_mtime); 466 remote_fileio_to_fio_time (st->st_ctime, fst->fst_ctime); 467 } 468 469 static void 470 remote_fileio_to_fio_timeval (struct timeval *tv, struct fio_timeval *ftv) 471 { 472 remote_fileio_to_fio_time (tv->tv_sec, ftv->ftv_sec); 473 remote_fileio_to_fio_long (tv->tv_usec, ftv->ftv_usec); 474 } 475 476 static int remote_fio_ctrl_c_flag = 0; 477 static int remote_fio_no_longjmp = 0; 478 479 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 480 static struct sigaction remote_fio_sa; 481 static struct sigaction remote_fio_osa; 482 #else 483 static void (*remote_fio_ofunc)(int); 484 #endif 485 486 static void 487 remote_fileio_sig_init (void) 488 { 489 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 490 remote_fio_sa.sa_handler = SIG_IGN; 491 sigemptyset (&remote_fio_sa.sa_mask); 492 remote_fio_sa.sa_flags = 0; 493 sigaction (SIGINT, &remote_fio_sa, &remote_fio_osa); 494 #else 495 remote_fio_ofunc = signal (SIGINT, SIG_IGN); 496 #endif 497 } 498 499 static void 500 remote_fileio_sig_set (void (*sigint_func)(int)) 501 { 502 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 503 remote_fio_sa.sa_handler = sigint_func; 504 sigemptyset (&remote_fio_sa.sa_mask); 505 remote_fio_sa.sa_flags = 0; 506 sigaction (SIGINT, &remote_fio_sa, NULL); 507 #else 508 signal (SIGINT, sigint_func); 509 #endif 510 } 511 512 static void 513 remote_fileio_sig_exit (void) 514 { 515 #if defined (HAVE_SIGACTION) && defined (SA_RESTART) 516 sigaction (SIGINT, &remote_fio_osa, NULL); 517 #else 518 signal (SIGINT, remote_fio_ofunc); 519 #endif 520 } 521 522 static void 523 async_remote_fileio_interrupt (gdb_client_data arg) 524 { 525 deprecated_throw_reason (RETURN_QUIT); 526 } 527 528 static void 529 remote_fileio_ctrl_c_signal_handler (int signo) 530 { 531 remote_fileio_sig_set (SIG_IGN); 532 remote_fio_ctrl_c_flag = 1; 533 if (!remote_fio_no_longjmp) 534 gdb_call_async_signal_handler (sigint_fileio_token, 1); 535 remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler); 536 } 537 538 static void 539 remote_fileio_reply (int retcode, int error) 540 { 541 char buf[32]; 542 543 remote_fileio_sig_set (SIG_IGN); 544 strcpy (buf, "F"); 545 if (retcode < 0) 546 { 547 strcat (buf, "-"); 548 retcode = -retcode; 549 } 550 sprintf (buf + strlen (buf), "%x", retcode); 551 if (error || remote_fio_ctrl_c_flag) 552 { 553 if (error && remote_fio_ctrl_c_flag) 554 error = FILEIO_EINTR; 555 if (error < 0) 556 { 557 strcat (buf, "-"); 558 error = -error; 559 } 560 sprintf (buf + strlen (buf), ",%x", error); 561 if (remote_fio_ctrl_c_flag) 562 strcat (buf, ",C"); 563 } 564 remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler); 565 putpkt (buf); 566 } 567 568 static void 569 remote_fileio_ioerror (void) 570 { 571 remote_fileio_reply (-1, FILEIO_EIO); 572 } 573 574 static void 575 remote_fileio_badfd (void) 576 { 577 remote_fileio_reply (-1, FILEIO_EBADF); 578 } 579 580 static void 581 remote_fileio_return_errno (int retcode) 582 { 583 remote_fileio_reply (retcode, retcode < 0 584 ? remote_fileio_errno_to_target (errno) : 0); 585 } 586 587 static void 588 remote_fileio_return_success (int retcode) 589 { 590 remote_fileio_reply (retcode, 0); 591 } 592 593 static void 594 remote_fileio_func_open (char *buf) 595 { 596 CORE_ADDR ptrval; 597 int length; 598 long num; 599 int flags, fd; 600 mode_t mode; 601 char *pathname; 602 struct stat st; 603 604 /* 1. Parameter: Ptr to pathname / length incl. trailing zero. */ 605 if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) 606 { 607 remote_fileio_ioerror (); 608 return; 609 } 610 /* 2. Parameter: open flags */ 611 if (remote_fileio_extract_int (&buf, &num)) 612 { 613 remote_fileio_ioerror (); 614 return; 615 } 616 flags = remote_fileio_oflags_to_host (num); 617 /* 3. Parameter: open mode */ 618 if (remote_fileio_extract_int (&buf, &num)) 619 { 620 remote_fileio_ioerror (); 621 return; 622 } 623 mode = remote_fileio_mode_to_host (num, 1); 624 625 /* Request pathname. */ 626 pathname = alloca (length); 627 if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0) 628 { 629 remote_fileio_ioerror (); 630 return; 631 } 632 633 /* Check if pathname exists and is not a regular file or directory. If so, 634 return an appropriate error code. Same for trying to open directories 635 for writing. */ 636 if (!stat (pathname, &st)) 637 { 638 if (!S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) 639 { 640 remote_fileio_reply (-1, FILEIO_ENODEV); 641 return; 642 } 643 if (S_ISDIR (st.st_mode) 644 && ((flags & O_WRONLY) == O_WRONLY || (flags & O_RDWR) == O_RDWR)) 645 { 646 remote_fileio_reply (-1, FILEIO_EISDIR); 647 return; 648 } 649 } 650 651 remote_fio_no_longjmp = 1; 652 fd = open (pathname, flags, mode); 653 if (fd < 0) 654 { 655 remote_fileio_return_errno (-1); 656 return; 657 } 658 659 fd = remote_fileio_fd_to_targetfd (fd); 660 remote_fileio_return_success (fd); 661 } 662 663 static void 664 remote_fileio_func_close (char *buf) 665 { 666 long num; 667 int fd; 668 669 /* Parameter: file descriptor */ 670 if (remote_fileio_extract_int (&buf, &num)) 671 { 672 remote_fileio_ioerror (); 673 return; 674 } 675 fd = remote_fileio_map_fd ((int) num); 676 if (fd == FIO_FD_INVALID) 677 { 678 remote_fileio_badfd (); 679 return; 680 } 681 682 remote_fio_no_longjmp = 1; 683 if (fd != FIO_FD_CONSOLE_IN && fd != FIO_FD_CONSOLE_OUT && close (fd)) 684 remote_fileio_return_errno (-1); 685 remote_fileio_close_target_fd ((int) num); 686 remote_fileio_return_success (0); 687 } 688 689 static void 690 remote_fileio_func_read (char *buf) 691 { 692 long target_fd, num; 693 LONGEST lnum; 694 CORE_ADDR ptrval; 695 int fd, ret, retlength; 696 gdb_byte *buffer; 697 size_t length; 698 off_t old_offset, new_offset; 699 700 /* 1. Parameter: file descriptor */ 701 if (remote_fileio_extract_int (&buf, &target_fd)) 702 { 703 remote_fileio_ioerror (); 704 return; 705 } 706 fd = remote_fileio_map_fd ((int) target_fd); 707 if (fd == FIO_FD_INVALID) 708 { 709 remote_fileio_badfd (); 710 return; 711 } 712 /* 2. Parameter: buffer pointer */ 713 if (remote_fileio_extract_long (&buf, &lnum)) 714 { 715 remote_fileio_ioerror (); 716 return; 717 } 718 ptrval = (CORE_ADDR) lnum; 719 /* 3. Parameter: buffer length */ 720 if (remote_fileio_extract_int (&buf, &num)) 721 { 722 remote_fileio_ioerror (); 723 return; 724 } 725 length = (size_t) num; 726 727 switch (fd) 728 { 729 case FIO_FD_CONSOLE_OUT: 730 remote_fileio_badfd (); 731 return; 732 case FIO_FD_CONSOLE_IN: 733 { 734 static char *remaining_buf = NULL; 735 static int remaining_length = 0; 736 737 buffer = (gdb_byte *) xmalloc (16384); 738 if (remaining_buf) 739 { 740 remote_fio_no_longjmp = 1; 741 if (remaining_length > length) 742 { 743 memcpy (buffer, remaining_buf, length); 744 memmove (remaining_buf, remaining_buf + length, 745 remaining_length - length); 746 remaining_length -= length; 747 ret = length; 748 } 749 else 750 { 751 memcpy (buffer, remaining_buf, remaining_length); 752 xfree (remaining_buf); 753 remaining_buf = NULL; 754 ret = remaining_length; 755 } 756 } 757 else 758 { 759 /* Windows (at least XP and Server 2003) has difficulty 760 with large reads from consoles. If a handle is 761 backed by a real console device, overly large reads 762 from the handle will fail and set errno == ENOMEM. 763 On a Windows Server 2003 system where I tested, 764 reading 26608 bytes from the console was OK, but 765 anything above 26609 bytes would fail. The limit has 766 been observed to vary on different systems. So, we 767 limit this read to something smaller than that - by a 768 safe margin, in case the limit depends on system 769 resources or version. */ 770 ret = ui_file_read (gdb_stdtargin, (char *) buffer, 16383); 771 remote_fio_no_longjmp = 1; 772 if (ret > 0 && (size_t)ret > length) 773 { 774 remaining_buf = (char *) xmalloc (ret - length); 775 remaining_length = ret - length; 776 memcpy (remaining_buf, buffer + length, remaining_length); 777 ret = length; 778 } 779 } 780 } 781 break; 782 default: 783 buffer = (gdb_byte *) xmalloc (length); 784 /* POSIX defines EINTR behaviour of read in a weird way. It's allowed 785 for read() to return -1 even if "some" bytes have been read. It 786 has been corrected in SUSv2 but that doesn't help us much... 787 Therefore a complete solution must check how many bytes have been 788 read on EINTR to return a more reliable value to the target */ 789 old_offset = lseek (fd, 0, SEEK_CUR); 790 remote_fio_no_longjmp = 1; 791 ret = read (fd, buffer, length); 792 if (ret < 0 && errno == EINTR) 793 { 794 new_offset = lseek (fd, 0, SEEK_CUR); 795 /* If some data has been read, return the number of bytes read. 796 The Ctrl-C flag is set in remote_fileio_reply() anyway. */ 797 if (old_offset != new_offset) 798 ret = new_offset - old_offset; 799 } 800 break; 801 } 802 803 if (ret > 0) 804 { 805 errno = target_write_memory (ptrval, buffer, ret); 806 if (errno != 0) 807 ret = -1; 808 } 809 810 if (ret < 0) 811 remote_fileio_return_errno (-1); 812 else 813 remote_fileio_return_success (ret); 814 815 xfree (buffer); 816 } 817 818 static void 819 remote_fileio_func_write (char *buf) 820 { 821 long target_fd, num; 822 LONGEST lnum; 823 CORE_ADDR ptrval; 824 int fd, ret; 825 gdb_byte *buffer; 826 size_t length; 827 828 /* 1. Parameter: file descriptor */ 829 if (remote_fileio_extract_int (&buf, &target_fd)) 830 { 831 remote_fileio_ioerror (); 832 return; 833 } 834 fd = remote_fileio_map_fd ((int) target_fd); 835 if (fd == FIO_FD_INVALID) 836 { 837 remote_fileio_badfd (); 838 return; 839 } 840 /* 2. Parameter: buffer pointer */ 841 if (remote_fileio_extract_long (&buf, &lnum)) 842 { 843 remote_fileio_ioerror (); 844 return; 845 } 846 ptrval = (CORE_ADDR) lnum; 847 /* 3. Parameter: buffer length */ 848 if (remote_fileio_extract_int (&buf, &num)) 849 { 850 remote_fileio_ioerror (); 851 return; 852 } 853 length = (size_t) num; 854 855 buffer = (gdb_byte *) xmalloc (length); 856 if (target_read_memory (ptrval, buffer, length) != 0) 857 { 858 xfree (buffer); 859 remote_fileio_ioerror (); 860 return; 861 } 862 863 remote_fio_no_longjmp = 1; 864 switch (fd) 865 { 866 case FIO_FD_CONSOLE_IN: 867 remote_fileio_badfd (); 868 xfree (buffer); 869 return; 870 case FIO_FD_CONSOLE_OUT: 871 ui_file_write (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr, 872 (char *) buffer, length); 873 gdb_flush (target_fd == 1 ? gdb_stdtarg : gdb_stdtargerr); 874 ret = length; 875 break; 876 default: 877 ret = write (fd, buffer, length); 878 if (ret < 0 && errno == EACCES) 879 errno = EBADF; /* Cygwin returns EACCESS when writing to a 880 R/O file. */ 881 break; 882 } 883 884 if (ret < 0) 885 remote_fileio_return_errno (-1); 886 else 887 remote_fileio_return_success (ret); 888 889 xfree (buffer); 890 } 891 892 static void 893 remote_fileio_func_lseek (char *buf) 894 { 895 long num; 896 LONGEST lnum; 897 int fd, flag; 898 off_t offset, ret; 899 900 /* 1. Parameter: file descriptor */ 901 if (remote_fileio_extract_int (&buf, &num)) 902 { 903 remote_fileio_ioerror (); 904 return; 905 } 906 fd = remote_fileio_map_fd ((int) num); 907 if (fd == FIO_FD_INVALID) 908 { 909 remote_fileio_badfd (); 910 return; 911 } 912 else if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT) 913 { 914 remote_fileio_reply (-1, FILEIO_ESPIPE); 915 return; 916 } 917 918 /* 2. Parameter: offset */ 919 if (remote_fileio_extract_long (&buf, &lnum)) 920 { 921 remote_fileio_ioerror (); 922 return; 923 } 924 offset = (off_t) lnum; 925 /* 3. Parameter: flag */ 926 if (remote_fileio_extract_int (&buf, &num)) 927 { 928 remote_fileio_ioerror (); 929 return; 930 } 931 if (remote_fileio_seek_flag_to_host (num, &flag)) 932 { 933 remote_fileio_reply (-1, FILEIO_EINVAL); 934 return; 935 } 936 937 remote_fio_no_longjmp = 1; 938 ret = lseek (fd, offset, flag); 939 940 if (ret == (off_t) -1) 941 remote_fileio_return_errno (-1); 942 else 943 remote_fileio_return_success (ret); 944 } 945 946 static void 947 remote_fileio_func_rename (char *buf) 948 { 949 CORE_ADDR old_ptr, new_ptr; 950 int old_len, new_len; 951 char *oldpath, *newpath; 952 int ret, of, nf; 953 struct stat ost, nst; 954 955 /* 1. Parameter: Ptr to oldpath / length incl. trailing zero */ 956 if (remote_fileio_extract_ptr_w_len (&buf, &old_ptr, &old_len)) 957 { 958 remote_fileio_ioerror (); 959 return; 960 } 961 962 /* 2. Parameter: Ptr to newpath / length incl. trailing zero */ 963 if (remote_fileio_extract_ptr_w_len (&buf, &new_ptr, &new_len)) 964 { 965 remote_fileio_ioerror (); 966 return; 967 } 968 969 /* Request oldpath using 'm' packet */ 970 oldpath = alloca (old_len); 971 if (target_read_memory (old_ptr, (gdb_byte *) oldpath, old_len) != 0) 972 { 973 remote_fileio_ioerror (); 974 return; 975 } 976 977 /* Request newpath using 'm' packet */ 978 newpath = alloca (new_len); 979 if (target_read_memory (new_ptr, (gdb_byte *) newpath, new_len) != 0) 980 { 981 remote_fileio_ioerror (); 982 return; 983 } 984 985 /* Only operate on regular files and directories. */ 986 of = stat (oldpath, &ost); 987 nf = stat (newpath, &nst); 988 if ((!of && !S_ISREG (ost.st_mode) && !S_ISDIR (ost.st_mode)) 989 || (!nf && !S_ISREG (nst.st_mode) && !S_ISDIR (nst.st_mode))) 990 { 991 remote_fileio_reply (-1, FILEIO_EACCES); 992 return; 993 } 994 995 remote_fio_no_longjmp = 1; 996 ret = rename (oldpath, newpath); 997 998 if (ret == -1) 999 { 1000 /* Special case: newpath is a non-empty directory. Some systems 1001 return ENOTEMPTY, some return EEXIST. We coerce that to be 1002 always EEXIST. */ 1003 if (errno == ENOTEMPTY) 1004 errno = EEXIST; 1005 #ifdef __CYGWIN__ 1006 /* Workaround some Cygwin problems with correct errnos. */ 1007 if (errno == EACCES) 1008 { 1009 if (!of && !nf && S_ISDIR (nst.st_mode)) 1010 { 1011 if (S_ISREG (ost.st_mode)) 1012 errno = EISDIR; 1013 else 1014 { 1015 char oldfullpath[PATH_MAX]; 1016 char newfullpath[PATH_MAX]; 1017 int len; 1018 1019 cygwin_conv_path (CCP_WIN_A_TO_POSIX, oldpath, oldfullpath, 1020 PATH_MAX); 1021 cygwin_conv_path (CCP_WIN_A_TO_POSIX, newpath, newfullpath, 1022 PATH_MAX); 1023 len = strlen (oldfullpath); 1024 if (IS_DIR_SEPARATOR (newfullpath[len]) 1025 && !filename_ncmp (oldfullpath, newfullpath, len)) 1026 errno = EINVAL; 1027 else 1028 errno = EEXIST; 1029 } 1030 } 1031 } 1032 #endif 1033 1034 remote_fileio_return_errno (-1); 1035 } 1036 else 1037 remote_fileio_return_success (ret); 1038 } 1039 1040 static void 1041 remote_fileio_func_unlink (char *buf) 1042 { 1043 CORE_ADDR ptrval; 1044 int length; 1045 char *pathname; 1046 int ret; 1047 struct stat st; 1048 1049 /* Parameter: Ptr to pathname / length incl. trailing zero */ 1050 if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) 1051 { 1052 remote_fileio_ioerror (); 1053 return; 1054 } 1055 /* Request pathname using 'm' packet */ 1056 pathname = alloca (length); 1057 if (target_read_memory (ptrval, (gdb_byte *) pathname, length) != 0) 1058 { 1059 remote_fileio_ioerror (); 1060 return; 1061 } 1062 1063 /* Only operate on regular files (and directories, which allows to return 1064 the correct return code). */ 1065 if (!stat (pathname, &st) && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) 1066 { 1067 remote_fileio_reply (-1, FILEIO_ENODEV); 1068 return; 1069 } 1070 1071 remote_fio_no_longjmp = 1; 1072 ret = unlink (pathname); 1073 1074 if (ret == -1) 1075 remote_fileio_return_errno (-1); 1076 else 1077 remote_fileio_return_success (ret); 1078 } 1079 1080 static void 1081 remote_fileio_func_stat (char *buf) 1082 { 1083 CORE_ADDR statptr, nameptr; 1084 int ret, namelength; 1085 char *pathname; 1086 LONGEST lnum; 1087 struct stat st; 1088 struct fio_stat fst; 1089 1090 /* 1. Parameter: Ptr to pathname / length incl. trailing zero */ 1091 if (remote_fileio_extract_ptr_w_len (&buf, &nameptr, &namelength)) 1092 { 1093 remote_fileio_ioerror (); 1094 return; 1095 } 1096 1097 /* 2. Parameter: Ptr to struct stat */ 1098 if (remote_fileio_extract_long (&buf, &lnum)) 1099 { 1100 remote_fileio_ioerror (); 1101 return; 1102 } 1103 statptr = (CORE_ADDR) lnum; 1104 1105 /* Request pathname using 'm' packet */ 1106 pathname = alloca (namelength); 1107 if (target_read_memory (nameptr, (gdb_byte *) pathname, namelength) != 0) 1108 { 1109 remote_fileio_ioerror (); 1110 return; 1111 } 1112 1113 remote_fio_no_longjmp = 1; 1114 ret = stat (pathname, &st); 1115 1116 if (ret == -1) 1117 { 1118 remote_fileio_return_errno (-1); 1119 return; 1120 } 1121 /* Only operate on regular files and directories. */ 1122 if (!ret && !S_ISREG (st.st_mode) && !S_ISDIR (st.st_mode)) 1123 { 1124 remote_fileio_reply (-1, FILEIO_EACCES); 1125 return; 1126 } 1127 if (statptr) 1128 { 1129 remote_fileio_to_fio_stat (&st, &fst); 1130 remote_fileio_to_fio_uint (0, fst.fst_dev); 1131 1132 errno = target_write_memory (statptr, (gdb_byte *) &fst, sizeof fst); 1133 if (errno != 0) 1134 { 1135 remote_fileio_return_errno (-1); 1136 return; 1137 } 1138 } 1139 remote_fileio_return_success (ret); 1140 } 1141 1142 static void 1143 remote_fileio_func_fstat (char *buf) 1144 { 1145 CORE_ADDR ptrval; 1146 int fd, ret, retlength; 1147 long target_fd; 1148 LONGEST lnum; 1149 struct stat st; 1150 struct fio_stat fst; 1151 struct timeval tv; 1152 1153 /* 1. Parameter: file descriptor */ 1154 if (remote_fileio_extract_int (&buf, &target_fd)) 1155 { 1156 remote_fileio_ioerror (); 1157 return; 1158 } 1159 fd = remote_fileio_map_fd ((int) target_fd); 1160 if (fd == FIO_FD_INVALID) 1161 { 1162 remote_fileio_badfd (); 1163 return; 1164 } 1165 /* 2. Parameter: Ptr to struct stat */ 1166 if (remote_fileio_extract_long (&buf, &lnum)) 1167 { 1168 remote_fileio_ioerror (); 1169 return; 1170 } 1171 ptrval = (CORE_ADDR) lnum; 1172 1173 remote_fio_no_longjmp = 1; 1174 if (fd == FIO_FD_CONSOLE_IN || fd == FIO_FD_CONSOLE_OUT) 1175 { 1176 remote_fileio_to_fio_uint (1, fst.fst_dev); 1177 memset (&st, 0, sizeof (st)); 1178 st.st_mode = S_IFCHR | (fd == FIO_FD_CONSOLE_IN ? S_IRUSR : S_IWUSR); 1179 st.st_nlink = 1; 1180 #ifdef HAVE_GETUID 1181 st.st_uid = getuid (); 1182 #endif 1183 #ifdef HAVE_GETGID 1184 st.st_gid = getgid (); 1185 #endif 1186 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE 1187 st.st_blksize = 512; 1188 #endif 1189 #if HAVE_STRUCT_STAT_ST_BLOCKS 1190 st.st_blocks = 0; 1191 #endif 1192 if (!gettimeofday (&tv, NULL)) 1193 st.st_atime = st.st_mtime = st.st_ctime = tv.tv_sec; 1194 else 1195 st.st_atime = st.st_mtime = st.st_ctime = (time_t) 0; 1196 ret = 0; 1197 } 1198 else 1199 ret = fstat (fd, &st); 1200 1201 if (ret == -1) 1202 { 1203 remote_fileio_return_errno (-1); 1204 return; 1205 } 1206 if (ptrval) 1207 { 1208 remote_fileio_to_fio_stat (&st, &fst); 1209 1210 errno = target_write_memory (ptrval, (gdb_byte *) &fst, sizeof fst); 1211 if (errno != 0) 1212 { 1213 remote_fileio_return_errno (-1); 1214 return; 1215 } 1216 } 1217 remote_fileio_return_success (ret); 1218 } 1219 1220 static void 1221 remote_fileio_func_gettimeofday (char *buf) 1222 { 1223 LONGEST lnum; 1224 CORE_ADDR ptrval; 1225 int ret, retlength; 1226 struct timeval tv; 1227 struct fio_timeval ftv; 1228 1229 /* 1. Parameter: struct timeval pointer */ 1230 if (remote_fileio_extract_long (&buf, &lnum)) 1231 { 1232 remote_fileio_ioerror (); 1233 return; 1234 } 1235 ptrval = (CORE_ADDR) lnum; 1236 /* 2. Parameter: some pointer value... */ 1237 if (remote_fileio_extract_long (&buf, &lnum)) 1238 { 1239 remote_fileio_ioerror (); 1240 return; 1241 } 1242 /* ...which has to be NULL. */ 1243 if (lnum) 1244 { 1245 remote_fileio_reply (-1, FILEIO_EINVAL); 1246 return; 1247 } 1248 1249 remote_fio_no_longjmp = 1; 1250 ret = gettimeofday (&tv, NULL); 1251 1252 if (ret == -1) 1253 { 1254 remote_fileio_return_errno (-1); 1255 return; 1256 } 1257 1258 if (ptrval) 1259 { 1260 remote_fileio_to_fio_timeval (&tv, &ftv); 1261 1262 errno = target_write_memory (ptrval, (gdb_byte *) &ftv, sizeof ftv); 1263 if (errno != 0) 1264 { 1265 remote_fileio_return_errno (-1); 1266 return; 1267 } 1268 } 1269 remote_fileio_return_success (ret); 1270 } 1271 1272 static void 1273 remote_fileio_func_isatty (char *buf) 1274 { 1275 long target_fd; 1276 int fd; 1277 1278 /* Parameter: file descriptor */ 1279 if (remote_fileio_extract_int (&buf, &target_fd)) 1280 { 1281 remote_fileio_ioerror (); 1282 return; 1283 } 1284 remote_fio_no_longjmp = 1; 1285 fd = remote_fileio_map_fd ((int) target_fd); 1286 remote_fileio_return_success (fd == FIO_FD_CONSOLE_IN || 1287 fd == FIO_FD_CONSOLE_OUT ? 1 : 0); 1288 } 1289 1290 static void 1291 remote_fileio_func_system (char *buf) 1292 { 1293 CORE_ADDR ptrval; 1294 int ret, length, retlength; 1295 char *cmdline = NULL; 1296 1297 /* Parameter: Ptr to commandline / length incl. trailing zero */ 1298 if (remote_fileio_extract_ptr_w_len (&buf, &ptrval, &length)) 1299 { 1300 remote_fileio_ioerror (); 1301 return; 1302 } 1303 1304 if (length) 1305 { 1306 /* Request commandline using 'm' packet */ 1307 cmdline = alloca (length); 1308 if (target_read_memory (ptrval, (gdb_byte *) cmdline, length) != 0) 1309 { 1310 remote_fileio_ioerror (); 1311 return; 1312 } 1313 } 1314 1315 /* Check if system(3) has been explicitely allowed using the 1316 `set remote system-call-allowed 1' command. If length is 0, 1317 indicating a NULL parameter to the system call, return zero to 1318 indicate a shell is not available. Otherwise fail with EPERM. */ 1319 if (!remote_fio_system_call_allowed) 1320 { 1321 if (!length) 1322 remote_fileio_return_success (0); 1323 else 1324 remote_fileio_reply (-1, FILEIO_EPERM); 1325 return; 1326 } 1327 1328 remote_fio_no_longjmp = 1; 1329 ret = system (cmdline); 1330 1331 if (!length) 1332 remote_fileio_return_success (ret); 1333 else if (ret == -1) 1334 remote_fileio_return_errno (-1); 1335 else 1336 remote_fileio_return_success (WEXITSTATUS (ret)); 1337 } 1338 1339 static struct { 1340 char *name; 1341 void (*func)(char *); 1342 } remote_fio_func_map[] = { 1343 { "open", remote_fileio_func_open }, 1344 { "close", remote_fileio_func_close }, 1345 { "read", remote_fileio_func_read }, 1346 { "write", remote_fileio_func_write }, 1347 { "lseek", remote_fileio_func_lseek }, 1348 { "rename", remote_fileio_func_rename }, 1349 { "unlink", remote_fileio_func_unlink }, 1350 { "stat", remote_fileio_func_stat }, 1351 { "fstat", remote_fileio_func_fstat }, 1352 { "gettimeofday", remote_fileio_func_gettimeofday }, 1353 { "isatty", remote_fileio_func_isatty }, 1354 { "system", remote_fileio_func_system }, 1355 { NULL, NULL } 1356 }; 1357 1358 static int 1359 do_remote_fileio_request (struct ui_out *uiout, void *buf_arg) 1360 { 1361 char *buf = buf_arg; 1362 char *c; 1363 int idx; 1364 1365 remote_fileio_sig_set (remote_fileio_ctrl_c_signal_handler); 1366 1367 c = strchr (++buf, ','); 1368 if (c) 1369 *c++ = '\0'; 1370 else 1371 c = strchr (buf, '\0'); 1372 for (idx = 0; remote_fio_func_map[idx].name; ++idx) 1373 if (!strcmp (remote_fio_func_map[idx].name, buf)) 1374 break; 1375 if (!remote_fio_func_map[idx].name) /* ERROR: No such function. */ 1376 return RETURN_ERROR; 1377 remote_fio_func_map[idx].func (c); 1378 return 0; 1379 } 1380 1381 /* Close any open descriptors, and reinitialize the file mapping. */ 1382 1383 void 1384 remote_fileio_reset (void) 1385 { 1386 int ix; 1387 1388 for (ix = 0; ix != remote_fio_data.fd_map_size; ix++) 1389 { 1390 int fd = remote_fio_data.fd_map[ix]; 1391 1392 if (fd >= 0) 1393 close (fd); 1394 } 1395 if (remote_fio_data.fd_map) 1396 { 1397 xfree (remote_fio_data.fd_map); 1398 remote_fio_data.fd_map = NULL; 1399 remote_fio_data.fd_map_size = 0; 1400 } 1401 } 1402 1403 /* Handle a file I/O request. BUF points to the packet containing the 1404 request. CTRLC_PENDING_P should be nonzero if the target has not 1405 acknowledged the Ctrl-C sent asynchronously earlier. */ 1406 1407 void 1408 remote_fileio_request (char *buf, int ctrlc_pending_p) 1409 { 1410 int ex; 1411 1412 remote_fileio_sig_init (); 1413 1414 if (ctrlc_pending_p) 1415 { 1416 /* If the target hasn't responded to the Ctrl-C sent 1417 asynchronously earlier, take this opportunity to send the 1418 Ctrl-C synchronously. */ 1419 remote_fio_ctrl_c_flag = 1; 1420 remote_fio_no_longjmp = 0; 1421 remote_fileio_reply (-1, FILEIO_EINTR); 1422 } 1423 else 1424 { 1425 remote_fio_ctrl_c_flag = 0; 1426 remote_fio_no_longjmp = 0; 1427 1428 ex = catch_exceptions (uiout, do_remote_fileio_request, (void *)buf, 1429 RETURN_MASK_ALL); 1430 switch (ex) 1431 { 1432 case RETURN_ERROR: 1433 remote_fileio_reply (-1, FILEIO_ENOSYS); 1434 break; 1435 case RETURN_QUIT: 1436 remote_fileio_reply (-1, FILEIO_EINTR); 1437 break; 1438 default: 1439 break; 1440 } 1441 } 1442 1443 remote_fileio_sig_exit (); 1444 } 1445 1446 static void 1447 set_system_call_allowed (char *args, int from_tty) 1448 { 1449 if (args) 1450 { 1451 char *arg_end; 1452 int val = strtoul (args, &arg_end, 10); 1453 1454 if (*args && *arg_end == '\0') 1455 { 1456 remote_fio_system_call_allowed = !!val; 1457 return; 1458 } 1459 } 1460 error (_("Illegal argument for \"set remote system-call-allowed\" command")); 1461 } 1462 1463 static void 1464 show_system_call_allowed (char *args, int from_tty) 1465 { 1466 if (args) 1467 error (_("Garbage after \"show remote " 1468 "system-call-allowed\" command: `%s'"), args); 1469 printf_unfiltered ("Calling host system(3) call from target is %sallowed\n", 1470 remote_fio_system_call_allowed ? "" : "not "); 1471 } 1472 1473 void 1474 initialize_remote_fileio (struct cmd_list_element *remote_set_cmdlist, 1475 struct cmd_list_element *remote_show_cmdlist) 1476 { 1477 sigint_fileio_token = 1478 create_async_signal_handler (async_remote_fileio_interrupt, NULL); 1479 1480 add_cmd ("system-call-allowed", no_class, 1481 set_system_call_allowed, 1482 _("Set if the host system(3) call is allowed for the target."), 1483 &remote_set_cmdlist); 1484 add_cmd ("system-call-allowed", no_class, 1485 show_system_call_allowed, 1486 _("Show if the host system(3) call is allowed for the target."), 1487 &remote_show_cmdlist); 1488 } 1489