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