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