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