1 /* 2 * Copyright (c) 2000-2004 Markus Friedl. All rights reserved. 3 * 4 * Permission to use, copy, modify, and distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 /* $OpenBSD: sftp-server.c,v 1.71 2007/01/03 07:22:36 stevesk Exp $ */ 18 19 #include "includes.h" 20 21 #include <sys/types.h> 22 #include <sys/param.h> 23 #include <sys/stat.h> 24 #ifdef HAVE_SYS_TIME_H 25 # include <sys/time.h> 26 #endif 27 28 #include <dirent.h> 29 #include <errno.h> 30 #include <fcntl.h> 31 #include <pwd.h> 32 #include <stdlib.h> 33 #include <stdio.h> 34 #include <string.h> 35 #include <pwd.h> 36 #include <time.h> 37 #include <unistd.h> 38 #include <stdarg.h> 39 40 #include "xmalloc.h" 41 #include "buffer.h" 42 #include "bufaux.h" 43 #include "log.h" 44 #include "misc.h" 45 #include "uidswap.h" 46 47 #include "sftp.h" 48 #include "sftp-common.h" 49 50 #ifdef HAVE___PROGNAME 51 extern char *__progname; 52 #else 53 char *__progname; 54 #endif 55 56 /* helper */ 57 #define get_int64() buffer_get_int64(&iqueue); 58 #define get_int() buffer_get_int(&iqueue); 59 #define get_string(lenp) buffer_get_string(&iqueue, lenp); 60 61 void cleanup_exit(int i); 62 63 /* Our verbosity */ 64 LogLevel log_level = SYSLOG_LEVEL_ERROR; 65 66 /* Our client */ 67 struct passwd *pw = NULL; 68 char *client_addr = NULL; 69 70 /* input and output queue */ 71 Buffer iqueue; 72 Buffer oqueue; 73 74 /* Version of client */ 75 int version; 76 77 /* portable attributes, etc. */ 78 79 typedef struct Stat Stat; 80 81 struct Stat { 82 char *name; 83 char *long_name; 84 Attrib attrib; 85 }; 86 87 static int 88 errno_to_portable(int unixerrno) 89 { 90 int ret = 0; 91 92 switch (unixerrno) { 93 case 0: 94 ret = SSH2_FX_OK; 95 break; 96 case ENOENT: 97 case ENOTDIR: 98 case EBADF: 99 case ELOOP: 100 ret = SSH2_FX_NO_SUCH_FILE; 101 break; 102 case EPERM: 103 case EACCES: 104 case EFAULT: 105 ret = SSH2_FX_PERMISSION_DENIED; 106 break; 107 case ENAMETOOLONG: 108 case EINVAL: 109 ret = SSH2_FX_BAD_MESSAGE; 110 break; 111 default: 112 ret = SSH2_FX_FAILURE; 113 break; 114 } 115 return ret; 116 } 117 118 static int 119 flags_from_portable(int pflags) 120 { 121 int flags = 0; 122 123 if ((pflags & SSH2_FXF_READ) && 124 (pflags & SSH2_FXF_WRITE)) { 125 flags = O_RDWR; 126 } else if (pflags & SSH2_FXF_READ) { 127 flags = O_RDONLY; 128 } else if (pflags & SSH2_FXF_WRITE) { 129 flags = O_WRONLY; 130 } 131 if (pflags & SSH2_FXF_CREAT) 132 flags |= O_CREAT; 133 if (pflags & SSH2_FXF_TRUNC) 134 flags |= O_TRUNC; 135 if (pflags & SSH2_FXF_EXCL) 136 flags |= O_EXCL; 137 return flags; 138 } 139 140 static const char * 141 string_from_portable(int pflags) 142 { 143 static char ret[128]; 144 145 *ret = '\0'; 146 147 #define PAPPEND(str) { \ 148 if (*ret != '\0') \ 149 strlcat(ret, ",", sizeof(ret)); \ 150 strlcat(ret, str, sizeof(ret)); \ 151 } 152 153 if (pflags & SSH2_FXF_READ) 154 PAPPEND("READ") 155 if (pflags & SSH2_FXF_WRITE) 156 PAPPEND("WRITE") 157 if (pflags & SSH2_FXF_CREAT) 158 PAPPEND("CREATE") 159 if (pflags & SSH2_FXF_TRUNC) 160 PAPPEND("TRUNCATE") 161 if (pflags & SSH2_FXF_EXCL) 162 PAPPEND("EXCL") 163 164 return ret; 165 } 166 167 static Attrib * 168 get_attrib(void) 169 { 170 return decode_attrib(&iqueue); 171 } 172 173 /* handle handles */ 174 175 typedef struct Handle Handle; 176 struct Handle { 177 int use; 178 DIR *dirp; 179 int fd; 180 char *name; 181 u_int64_t bytes_read, bytes_write; 182 }; 183 184 enum { 185 HANDLE_UNUSED, 186 HANDLE_DIR, 187 HANDLE_FILE 188 }; 189 190 Handle handles[100]; 191 192 static void 193 handle_init(void) 194 { 195 u_int i; 196 197 for (i = 0; i < sizeof(handles)/sizeof(Handle); i++) 198 handles[i].use = HANDLE_UNUSED; 199 } 200 201 static int 202 handle_new(int use, const char *name, int fd, DIR *dirp) 203 { 204 u_int i; 205 206 for (i = 0; i < sizeof(handles)/sizeof(Handle); i++) { 207 if (handles[i].use == HANDLE_UNUSED) { 208 handles[i].use = use; 209 handles[i].dirp = dirp; 210 handles[i].fd = fd; 211 handles[i].name = xstrdup(name); 212 handles[i].bytes_read = handles[i].bytes_write = 0; 213 return i; 214 } 215 } 216 return -1; 217 } 218 219 static int 220 handle_is_ok(int i, int type) 221 { 222 return i >= 0 && (u_int)i < sizeof(handles)/sizeof(Handle) && 223 handles[i].use == type; 224 } 225 226 static int 227 handle_to_string(int handle, char **stringp, int *hlenp) 228 { 229 if (stringp == NULL || hlenp == NULL) 230 return -1; 231 *stringp = xmalloc(sizeof(int32_t)); 232 put_u32(*stringp, handle); 233 *hlenp = sizeof(int32_t); 234 return 0; 235 } 236 237 static int 238 handle_from_string(const char *handle, u_int hlen) 239 { 240 int val; 241 242 if (hlen != sizeof(int32_t)) 243 return -1; 244 val = get_u32(handle); 245 if (handle_is_ok(val, HANDLE_FILE) || 246 handle_is_ok(val, HANDLE_DIR)) 247 return val; 248 return -1; 249 } 250 251 static char * 252 handle_to_name(int handle) 253 { 254 if (handle_is_ok(handle, HANDLE_DIR)|| 255 handle_is_ok(handle, HANDLE_FILE)) 256 return handles[handle].name; 257 return NULL; 258 } 259 260 static DIR * 261 handle_to_dir(int handle) 262 { 263 if (handle_is_ok(handle, HANDLE_DIR)) 264 return handles[handle].dirp; 265 return NULL; 266 } 267 268 static int 269 handle_to_fd(int handle) 270 { 271 if (handle_is_ok(handle, HANDLE_FILE)) 272 return handles[handle].fd; 273 return -1; 274 } 275 276 static void 277 handle_update_read(int handle, ssize_t bytes) 278 { 279 if (handle_is_ok(handle, HANDLE_FILE) && bytes > 0) 280 handles[handle].bytes_read += bytes; 281 } 282 283 static void 284 handle_update_write(int handle, ssize_t bytes) 285 { 286 if (handle_is_ok(handle, HANDLE_FILE) && bytes > 0) 287 handles[handle].bytes_write += bytes; 288 } 289 290 static u_int64_t 291 handle_bytes_read(int handle) 292 { 293 if (handle_is_ok(handle, HANDLE_FILE)) 294 return (handles[handle].bytes_read); 295 return 0; 296 } 297 298 static u_int64_t 299 handle_bytes_write(int handle) 300 { 301 if (handle_is_ok(handle, HANDLE_FILE)) 302 return (handles[handle].bytes_write); 303 return 0; 304 } 305 306 static int 307 handle_close(int handle) 308 { 309 int ret = -1; 310 311 if (handle_is_ok(handle, HANDLE_FILE)) { 312 ret = close(handles[handle].fd); 313 handles[handle].use = HANDLE_UNUSED; 314 xfree(handles[handle].name); 315 } else if (handle_is_ok(handle, HANDLE_DIR)) { 316 ret = closedir(handles[handle].dirp); 317 handles[handle].use = HANDLE_UNUSED; 318 xfree(handles[handle].name); 319 } else { 320 errno = ENOENT; 321 } 322 return ret; 323 } 324 325 static void 326 handle_log_close(int handle, char *emsg) 327 { 328 if (handle_is_ok(handle, HANDLE_FILE)) { 329 log("%s%sclose \"%s\" bytes read %llu written %llu", 330 emsg == NULL ? "" : emsg, emsg == NULL ? "" : " ", 331 handle_to_name(handle), 332 (unsigned long long)handle_bytes_read(handle), 333 (unsigned long long)handle_bytes_write(handle)); 334 } else { 335 log("%s%sclosedir \"%s\"", 336 emsg == NULL ? "" : emsg, emsg == NULL ? "" : " ", 337 handle_to_name(handle)); 338 } 339 } 340 341 static void 342 handle_log_exit(void) 343 { 344 u_int i; 345 346 for (i = 0; i < sizeof(handles)/sizeof(Handle); i++) 347 if (handles[i].use != HANDLE_UNUSED) 348 handle_log_close(i, "forced"); 349 } 350 351 static int 352 get_handle(void) 353 { 354 char *handle; 355 int val = -1; 356 u_int hlen; 357 358 handle = get_string(&hlen); 359 if (hlen < 256) 360 val = handle_from_string(handle, hlen); 361 xfree(handle); 362 return val; 363 } 364 365 /* send replies */ 366 367 static void 368 send_msg(Buffer *m) 369 { 370 int mlen = buffer_len(m); 371 372 buffer_put_int(&oqueue, mlen); 373 buffer_append(&oqueue, buffer_ptr(m), mlen); 374 buffer_consume(m, mlen); 375 } 376 377 static const char * 378 status_to_message(u_int32_t status) 379 { 380 const char *status_messages[] = { 381 "Success", /* SSH_FX_OK */ 382 "End of file", /* SSH_FX_EOF */ 383 "No such file", /* SSH_FX_NO_SUCH_FILE */ 384 "Permission denied", /* SSH_FX_PERMISSION_DENIED */ 385 "Failure", /* SSH_FX_FAILURE */ 386 "Bad message", /* SSH_FX_BAD_MESSAGE */ 387 "No connection", /* SSH_FX_NO_CONNECTION */ 388 "Connection lost", /* SSH_FX_CONNECTION_LOST */ 389 "Operation unsupported", /* SSH_FX_OP_UNSUPPORTED */ 390 "Unknown error" /* Others */ 391 }; 392 return (status_messages[MIN(status,SSH2_FX_MAX)]); 393 } 394 395 static void 396 send_status(u_int32_t id, u_int32_t status) 397 { 398 Buffer msg; 399 400 debug3("request %u: sent status %u", id, status); 401 if (log_level > SYSLOG_LEVEL_VERBOSE || 402 (status != SSH2_FX_OK && status != SSH2_FX_EOF)) 403 log("sent status %s", status_to_message(status)); 404 buffer_init(&msg); 405 buffer_put_char(&msg, SSH2_FXP_STATUS); 406 buffer_put_int(&msg, id); 407 buffer_put_int(&msg, status); 408 if (version >= 3) { 409 buffer_put_cstring(&msg, status_to_message(status)); 410 buffer_put_cstring(&msg, ""); 411 } 412 send_msg(&msg); 413 buffer_free(&msg); 414 } 415 static void 416 send_data_or_handle(char type, u_int32_t id, const char *data, int dlen) 417 { 418 Buffer msg; 419 420 buffer_init(&msg); 421 buffer_put_char(&msg, type); 422 buffer_put_int(&msg, id); 423 buffer_put_string(&msg, data, dlen); 424 send_msg(&msg); 425 buffer_free(&msg); 426 } 427 428 static void 429 send_data(u_int32_t id, const char *data, int dlen) 430 { 431 debug("request %u: sent data len %d", id, dlen); 432 send_data_or_handle(SSH2_FXP_DATA, id, data, dlen); 433 } 434 435 static void 436 send_handle(u_int32_t id, int handle) 437 { 438 char *string; 439 int hlen; 440 441 handle_to_string(handle, &string, &hlen); 442 debug("request %u: sent handle handle %d", id, handle); 443 send_data_or_handle(SSH2_FXP_HANDLE, id, string, hlen); 444 xfree(string); 445 } 446 447 static void 448 send_names(u_int32_t id, int count, const Stat *stats) 449 { 450 Buffer msg; 451 int i; 452 453 buffer_init(&msg); 454 buffer_put_char(&msg, SSH2_FXP_NAME); 455 buffer_put_int(&msg, id); 456 buffer_put_int(&msg, count); 457 debug("request %u: sent names count %d", id, count); 458 for (i = 0; i < count; i++) { 459 buffer_put_cstring(&msg, stats[i].name); 460 buffer_put_cstring(&msg, stats[i].long_name); 461 encode_attrib(&msg, &stats[i].attrib); 462 } 463 send_msg(&msg); 464 buffer_free(&msg); 465 } 466 467 static void 468 send_attrib(u_int32_t id, const Attrib *a) 469 { 470 Buffer msg; 471 472 debug("request %u: sent attrib have 0x%x", id, a->flags); 473 buffer_init(&msg); 474 buffer_put_char(&msg, SSH2_FXP_ATTRS); 475 buffer_put_int(&msg, id); 476 encode_attrib(&msg, a); 477 send_msg(&msg); 478 buffer_free(&msg); 479 } 480 481 /* parse incoming */ 482 483 static void 484 process_init(void) 485 { 486 Buffer msg; 487 488 version = get_int(); 489 verbose("received client version %d", version); 490 buffer_init(&msg); 491 buffer_put_char(&msg, SSH2_FXP_VERSION); 492 buffer_put_int(&msg, SSH2_FILEXFER_VERSION); 493 send_msg(&msg); 494 buffer_free(&msg); 495 } 496 497 static void 498 process_open(void) 499 { 500 u_int32_t id, pflags; 501 Attrib *a; 502 char *name; 503 int handle, fd, flags, mode, status = SSH2_FX_FAILURE; 504 505 id = get_int(); 506 name = get_string(NULL); 507 pflags = get_int(); /* portable flags */ 508 debug3("request %u: open flags %d", id, pflags); 509 a = get_attrib(); 510 flags = flags_from_portable(pflags); 511 mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? a->perm : 0666; 512 log("open \"%s\" flags %s mode 0%o", 513 name, string_from_portable(pflags), mode); 514 fd = open(name, flags, mode); 515 if (fd < 0) { 516 status = errno_to_portable(errno); 517 } else { 518 handle = handle_new(HANDLE_FILE, name, fd, NULL); 519 if (handle < 0) { 520 close(fd); 521 } else { 522 send_handle(id, handle); 523 status = SSH2_FX_OK; 524 } 525 } 526 if (status != SSH2_FX_OK) 527 send_status(id, status); 528 xfree(name); 529 } 530 531 static void 532 process_close(void) 533 { 534 u_int32_t id; 535 int handle, ret, status = SSH2_FX_FAILURE; 536 537 id = get_int(); 538 handle = get_handle(); 539 debug3("request %u: close handle %u", id, handle); 540 handle_log_close(handle, NULL); 541 ret = handle_close(handle); 542 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK; 543 send_status(id, status); 544 } 545 546 static void 547 process_read(void) 548 { 549 char buf[64*1024]; 550 u_int32_t id, len; 551 int handle, fd, ret, status = SSH2_FX_FAILURE; 552 u_int64_t off; 553 554 id = get_int(); 555 handle = get_handle(); 556 off = get_int64(); 557 len = get_int(); 558 559 debug("request %u: read \"%s\" (handle %d) off %llu len %d", 560 id, handle_to_name(handle), handle, (unsigned long long)off, len); 561 if (len > sizeof buf) { 562 len = sizeof buf; 563 debug2("read change len %d", len); 564 } 565 fd = handle_to_fd(handle); 566 if (fd >= 0) { 567 if (lseek(fd, off, SEEK_SET) < 0) { 568 error("process_read: seek failed"); 569 status = errno_to_portable(errno); 570 } else { 571 ret = read(fd, buf, len); 572 if (ret < 0) { 573 status = errno_to_portable(errno); 574 } else if (ret == 0) { 575 status = SSH2_FX_EOF; 576 } else { 577 send_data(id, buf, ret); 578 status = SSH2_FX_OK; 579 handle_update_read(handle, ret); 580 } 581 } 582 } 583 if (status != SSH2_FX_OK) 584 send_status(id, status); 585 } 586 587 static void 588 process_write(void) 589 { 590 u_int32_t id; 591 u_int64_t off; 592 u_int len; 593 int handle, fd, ret, status = SSH2_FX_FAILURE; 594 char *data; 595 596 id = get_int(); 597 handle = get_handle(); 598 off = get_int64(); 599 data = get_string(&len); 600 601 debug("request %u: write \"%s\" (handle %d) off %llu len %d", 602 id, handle_to_name(handle), handle, (unsigned long long)off, len); 603 fd = handle_to_fd(handle); 604 if (fd >= 0) { 605 if (lseek(fd, off, SEEK_SET) < 0) { 606 status = errno_to_portable(errno); 607 error("process_write: seek failed"); 608 } else { 609 /* XXX ATOMICIO ? */ 610 ret = write(fd, data, len); 611 if (ret < 0) { 612 error("process_write: write failed"); 613 status = errno_to_portable(errno); 614 } else if ((size_t)ret == len) { 615 status = SSH2_FX_OK; 616 handle_update_write(handle, ret); 617 } else { 618 debug2("nothing at all written"); 619 } 620 } 621 } 622 send_status(id, status); 623 xfree(data); 624 } 625 626 static void 627 process_do_stat(int do_lstat) 628 { 629 Attrib a; 630 struct stat st; 631 u_int32_t id; 632 char *name; 633 int ret, status = SSH2_FX_FAILURE; 634 635 id = get_int(); 636 name = get_string(NULL); 637 debug3("request %u: %sstat", id, do_lstat ? "l" : ""); 638 verbose("%sstat name \"%s\"", do_lstat ? "l" : "", name); 639 ret = do_lstat ? lstat(name, &st) : stat(name, &st); 640 if (ret < 0) { 641 status = errno_to_portable(errno); 642 } else { 643 stat_to_attrib(&st, &a); 644 send_attrib(id, &a); 645 status = SSH2_FX_OK; 646 } 647 if (status != SSH2_FX_OK) 648 send_status(id, status); 649 xfree(name); 650 } 651 652 static void 653 process_stat(void) 654 { 655 process_do_stat(0); 656 } 657 658 static void 659 process_lstat(void) 660 { 661 process_do_stat(1); 662 } 663 664 static void 665 process_fstat(void) 666 { 667 Attrib a; 668 struct stat st; 669 u_int32_t id; 670 int fd, ret, handle, status = SSH2_FX_FAILURE; 671 672 id = get_int(); 673 handle = get_handle(); 674 debug("request %u: fstat \"%s\" (handle %u)", 675 id, handle_to_name(handle), handle); 676 fd = handle_to_fd(handle); 677 if (fd >= 0) { 678 ret = fstat(fd, &st); 679 if (ret < 0) { 680 status = errno_to_portable(errno); 681 } else { 682 stat_to_attrib(&st, &a); 683 send_attrib(id, &a); 684 status = SSH2_FX_OK; 685 } 686 } 687 if (status != SSH2_FX_OK) 688 send_status(id, status); 689 } 690 691 static struct timeval * 692 attrib_to_tv(const Attrib *a) 693 { 694 static struct timeval tv[2]; 695 696 tv[0].tv_sec = a->atime; 697 tv[0].tv_usec = 0; 698 tv[1].tv_sec = a->mtime; 699 tv[1].tv_usec = 0; 700 return tv; 701 } 702 703 static void 704 process_setstat(void) 705 { 706 Attrib *a; 707 u_int32_t id; 708 char *name; 709 int status = SSH2_FX_OK, ret; 710 711 id = get_int(); 712 name = get_string(NULL); 713 a = get_attrib(); 714 debug("request %u: setstat name \"%s\"", id, name); 715 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) { 716 log("set \"%s\" size %llu", 717 name, (unsigned long long)a->size); 718 ret = truncate(name, a->size); 719 if (ret == -1) 720 status = errno_to_portable(errno); 721 } 722 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) { 723 log("set \"%s\" mode %04o", name, a->perm); 724 ret = chmod(name, a->perm & 07777); 725 if (ret == -1) 726 status = errno_to_portable(errno); 727 } 728 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) { 729 char buf[64]; 730 time_t t = a->mtime; 731 732 strftime(buf, sizeof(buf), "%Y" "%m%d-%H:%M:%S", 733 localtime(&t)); 734 log("set \"%s\" modtime %s", name, buf); 735 ret = utimes(name, attrib_to_tv(a)); 736 if (ret == -1) 737 status = errno_to_portable(errno); 738 } 739 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) { 740 log("set \"%s\" owner %lu group %lu", name, 741 (u_long)a->uid, (u_long)a->gid); 742 ret = chown(name, a->uid, a->gid); 743 if (ret == -1) 744 status = errno_to_portable(errno); 745 } 746 send_status(id, status); 747 xfree(name); 748 } 749 750 static void 751 process_fsetstat(void) 752 { 753 Attrib *a; 754 u_int32_t id; 755 int handle, fd, ret; 756 int status = SSH2_FX_OK; 757 758 id = get_int(); 759 handle = get_handle(); 760 a = get_attrib(); 761 debug("request %u: fsetstat handle %d", id, handle); 762 fd = handle_to_fd(handle); 763 if (fd < 0) { 764 status = SSH2_FX_FAILURE; 765 } else { 766 char *name = handle_to_name(handle); 767 768 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) { 769 log("set \"%s\" size %llu", 770 name, (unsigned long long)a->size); 771 ret = ftruncate(fd, a->size); 772 if (ret == -1) 773 status = errno_to_portable(errno); 774 } 775 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) { 776 log("set \"%s\" mode %04o", name, a->perm); 777 #ifdef HAVE_FCHMOD 778 ret = fchmod(fd, a->perm & 07777); 779 #else 780 ret = chmod(name, a->perm & 07777); 781 #endif 782 if (ret == -1) 783 status = errno_to_portable(errno); 784 } 785 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) { 786 char buf[64]; 787 time_t t = a->mtime; 788 789 strftime(buf, sizeof(buf), "%Y" "%m%d-%H:%M:%S", 790 localtime(&t)); 791 log("set \"%s\" modtime %s", name, buf); 792 #ifdef HAVE_FUTIMES 793 ret = futimes(fd, attrib_to_tv(a)); 794 #else 795 ret = utimes(name, attrib_to_tv(a)); 796 #endif 797 if (ret == -1) 798 status = errno_to_portable(errno); 799 } 800 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) { 801 log("set \"%s\" owner %lu group %lu", name, 802 (u_long)a->uid, (u_long)a->gid); 803 #ifdef HAVE_FCHOWN 804 ret = fchown(fd, a->uid, a->gid); 805 #else 806 ret = chown(name, a->uid, a->gid); 807 #endif 808 if (ret == -1) 809 status = errno_to_portable(errno); 810 } 811 } 812 send_status(id, status); 813 } 814 815 static void 816 process_opendir(void) 817 { 818 DIR *dirp = NULL; 819 char *path; 820 int handle, status = SSH2_FX_FAILURE; 821 u_int32_t id; 822 823 id = get_int(); 824 path = get_string(NULL); 825 debug3("request %u: opendir", id); 826 log("opendir \"%s\"", path); 827 dirp = opendir(path); 828 if (dirp == NULL) { 829 status = errno_to_portable(errno); 830 } else { 831 handle = handle_new(HANDLE_DIR, path, 0, dirp); 832 if (handle < 0) { 833 closedir(dirp); 834 } else { 835 send_handle(id, handle); 836 status = SSH2_FX_OK; 837 } 838 839 } 840 if (status != SSH2_FX_OK) 841 send_status(id, status); 842 xfree(path); 843 } 844 845 static void 846 process_readdir(void) 847 { 848 DIR *dirp; 849 struct dirent *dp; 850 char *path; 851 int handle; 852 u_int32_t id; 853 854 id = get_int(); 855 handle = get_handle(); 856 debug("request %u: readdir \"%s\" (handle %d)", id, 857 handle_to_name(handle), handle); 858 dirp = handle_to_dir(handle); 859 path = handle_to_name(handle); 860 if (dirp == NULL || path == NULL) { 861 send_status(id, SSH2_FX_FAILURE); 862 } else { 863 struct stat st; 864 char pathname[MAXPATHLEN]; 865 Stat *stats; 866 int nstats = 10, count = 0, i; 867 868 stats = xcalloc(nstats, sizeof(Stat)); 869 while ((dp = readdir(dirp)) != NULL) { 870 if (count >= nstats) { 871 nstats *= 2; 872 stats = xrealloc(stats, nstats * sizeof(Stat)); 873 } 874 /* XXX OVERFLOW ? */ 875 snprintf(pathname, sizeof pathname, "%s%s%s", path, 876 strcmp(path, "/") ? "/" : "", dp->d_name); 877 if (lstat(pathname, &st) < 0) 878 continue; 879 stat_to_attrib(&st, &(stats[count].attrib)); 880 stats[count].name = xstrdup(dp->d_name); 881 stats[count].long_name = ls_file(dp->d_name, &st, 0); 882 count++; 883 /* send up to 100 entries in one message */ 884 /* XXX check packet size instead */ 885 if (count == 100) 886 break; 887 } 888 if (count > 0) { 889 send_names(id, count, stats); 890 for (i = 0; i < count; i++) { 891 xfree(stats[i].name); 892 xfree(stats[i].long_name); 893 } 894 } else { 895 send_status(id, SSH2_FX_EOF); 896 } 897 xfree(stats); 898 } 899 } 900 901 static void 902 process_remove(void) 903 { 904 char *name; 905 u_int32_t id; 906 int status = SSH2_FX_FAILURE; 907 int ret; 908 909 id = get_int(); 910 name = get_string(NULL); 911 debug3("request %u: remove", id); 912 log("remove name \"%s\"", name); 913 ret = unlink(name); 914 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK; 915 send_status(id, status); 916 xfree(name); 917 } 918 919 static void 920 process_mkdir(void) 921 { 922 Attrib *a; 923 u_int32_t id; 924 char *name; 925 int ret, mode, status = SSH2_FX_FAILURE; 926 927 id = get_int(); 928 name = get_string(NULL); 929 a = get_attrib(); 930 mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? 931 a->perm & 0777 : 0777; 932 debug3("request %u: mkdir", id); 933 log("mkdir name \"%s\" mode 0%o", name, mode); 934 ret = mkdir(name, mode); 935 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK; 936 send_status(id, status); 937 xfree(name); 938 } 939 940 static void 941 process_rmdir(void) 942 { 943 u_int32_t id; 944 char *name; 945 int ret, status; 946 947 id = get_int(); 948 name = get_string(NULL); 949 debug3("request %u: rmdir", id); 950 log("rmdir name \"%s\"", name); 951 ret = rmdir(name); 952 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK; 953 send_status(id, status); 954 xfree(name); 955 } 956 957 static void 958 process_realpath(void) 959 { 960 char resolvedname[MAXPATHLEN]; 961 u_int32_t id; 962 char *path; 963 964 id = get_int(); 965 path = get_string(NULL); 966 if (path[0] == '\0') { 967 xfree(path); 968 path = xstrdup("."); 969 } 970 debug3("request %u: realpath", id); 971 verbose("realpath \"%s\"", path); 972 if (realpath(path, resolvedname) == NULL) { 973 send_status(id, errno_to_portable(errno)); 974 } else { 975 Stat s; 976 attrib_clear(&s.attrib); 977 s.name = s.long_name = resolvedname; 978 send_names(id, 1, &s); 979 } 980 xfree(path); 981 } 982 983 static void 984 process_rename(void) 985 { 986 u_int32_t id; 987 char *oldpath, *newpath; 988 int status; 989 struct stat sb; 990 991 id = get_int(); 992 oldpath = get_string(NULL); 993 newpath = get_string(NULL); 994 debug3("request %u: rename", id); 995 log("rename old \"%s\" new \"%s\"", oldpath, newpath); 996 status = SSH2_FX_FAILURE; 997 if (lstat(oldpath, &sb) == -1) 998 status = errno_to_portable(errno); 999 else if (S_ISREG(sb.st_mode)) { 1000 /* Race-free rename of regular files */ 1001 if (link(oldpath, newpath) == -1) { 1002 if (errno == EOPNOTSUPP 1003 #ifdef LINK_OPNOTSUPP_ERRNO 1004 || errno == LINK_OPNOTSUPP_ERRNO 1005 #endif 1006 ) { 1007 struct stat st; 1008 1009 /* 1010 * fs doesn't support links, so fall back to 1011 * stat+rename. This is racy. 1012 */ 1013 if (stat(newpath, &st) == -1) { 1014 if (rename(oldpath, newpath) == -1) 1015 status = 1016 errno_to_portable(errno); 1017 else 1018 status = SSH2_FX_OK; 1019 } 1020 } else { 1021 status = errno_to_portable(errno); 1022 } 1023 } else if (unlink(oldpath) == -1) { 1024 status = errno_to_portable(errno); 1025 /* clean spare link */ 1026 unlink(newpath); 1027 } else 1028 status = SSH2_FX_OK; 1029 } else if (stat(newpath, &sb) == -1) { 1030 if (rename(oldpath, newpath) == -1) 1031 status = errno_to_portable(errno); 1032 else 1033 status = SSH2_FX_OK; 1034 } 1035 send_status(id, status); 1036 xfree(oldpath); 1037 xfree(newpath); 1038 } 1039 1040 static void 1041 process_readlink(void) 1042 { 1043 u_int32_t id; 1044 int len; 1045 char buf[MAXPATHLEN]; 1046 char *path; 1047 1048 id = get_int(); 1049 path = get_string(NULL); 1050 debug3("request %u: readlink", id); 1051 verbose("readlink \"%s\"", path); 1052 if ((len = readlink(path, buf, sizeof(buf) - 1)) == -1) 1053 send_status(id, errno_to_portable(errno)); 1054 else { 1055 Stat s; 1056 1057 buf[len] = '\0'; 1058 attrib_clear(&s.attrib); 1059 s.name = s.long_name = buf; 1060 send_names(id, 1, &s); 1061 } 1062 xfree(path); 1063 } 1064 1065 static void 1066 process_symlink(void) 1067 { 1068 u_int32_t id; 1069 char *oldpath, *newpath; 1070 int ret, status; 1071 1072 id = get_int(); 1073 oldpath = get_string(NULL); 1074 newpath = get_string(NULL); 1075 debug3("request %u: symlink", id); 1076 log("symlink old \"%s\" new \"%s\"", oldpath, newpath); 1077 /* this will fail if 'newpath' exists */ 1078 ret = symlink(oldpath, newpath); 1079 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK; 1080 send_status(id, status); 1081 xfree(oldpath); 1082 xfree(newpath); 1083 } 1084 1085 static void 1086 process_extended(void) 1087 { 1088 u_int32_t id; 1089 char *request; 1090 1091 id = get_int(); 1092 request = get_string(NULL); 1093 send_status(id, SSH2_FX_OP_UNSUPPORTED); /* MUST */ 1094 xfree(request); 1095 } 1096 1097 /* stolen from ssh-agent */ 1098 1099 static void 1100 process(void) 1101 { 1102 u_int msg_len; 1103 u_int buf_len; 1104 u_int consumed; 1105 u_int type; 1106 u_char *cp; 1107 1108 buf_len = buffer_len(&iqueue); 1109 if (buf_len < 5) 1110 return; /* Incomplete message. */ 1111 cp = buffer_ptr(&iqueue); 1112 msg_len = get_u32(cp); 1113 if (msg_len > SFTP_MAX_MSG_LENGTH) { 1114 error("bad message from %s local user %s", 1115 client_addr, pw->pw_name); 1116 cleanup_exit(11); 1117 } 1118 if (buf_len < msg_len + 4) 1119 return; 1120 buffer_consume(&iqueue, 4); 1121 buf_len -= 4; 1122 type = buffer_get_char(&iqueue); 1123 switch (type) { 1124 case SSH2_FXP_INIT: 1125 process_init(); 1126 break; 1127 case SSH2_FXP_OPEN: 1128 process_open(); 1129 break; 1130 case SSH2_FXP_CLOSE: 1131 process_close(); 1132 break; 1133 case SSH2_FXP_READ: 1134 process_read(); 1135 break; 1136 case SSH2_FXP_WRITE: 1137 process_write(); 1138 break; 1139 case SSH2_FXP_LSTAT: 1140 process_lstat(); 1141 break; 1142 case SSH2_FXP_FSTAT: 1143 process_fstat(); 1144 break; 1145 case SSH2_FXP_SETSTAT: 1146 process_setstat(); 1147 break; 1148 case SSH2_FXP_FSETSTAT: 1149 process_fsetstat(); 1150 break; 1151 case SSH2_FXP_OPENDIR: 1152 process_opendir(); 1153 break; 1154 case SSH2_FXP_READDIR: 1155 process_readdir(); 1156 break; 1157 case SSH2_FXP_REMOVE: 1158 process_remove(); 1159 break; 1160 case SSH2_FXP_MKDIR: 1161 process_mkdir(); 1162 break; 1163 case SSH2_FXP_RMDIR: 1164 process_rmdir(); 1165 break; 1166 case SSH2_FXP_REALPATH: 1167 process_realpath(); 1168 break; 1169 case SSH2_FXP_STAT: 1170 process_stat(); 1171 break; 1172 case SSH2_FXP_RENAME: 1173 process_rename(); 1174 break; 1175 case SSH2_FXP_READLINK: 1176 process_readlink(); 1177 break; 1178 case SSH2_FXP_SYMLINK: 1179 process_symlink(); 1180 break; 1181 case SSH2_FXP_EXTENDED: 1182 process_extended(); 1183 break; 1184 default: 1185 error("Unknown message %d", type); 1186 break; 1187 } 1188 /* discard the remaining bytes from the current packet */ 1189 if (buf_len < buffer_len(&iqueue)) 1190 fatal("iqueue grew unexpectedly"); 1191 consumed = buf_len - buffer_len(&iqueue); 1192 if (msg_len < consumed) 1193 fatal("msg_len %d < consumed %d", msg_len, consumed); 1194 if (msg_len > consumed) 1195 buffer_consume(&iqueue, msg_len - consumed); 1196 } 1197 1198 /* 1199 * Cleanup handler that logs active handles upon normal exit. Not static since 1200 * sftp-server-main.c file needs that as well. 1201 */ 1202 void 1203 cleanup_exit(int i) 1204 { 1205 if (pw != NULL && client_addr != NULL) { 1206 handle_log_exit(); 1207 log("session closed for local user %s from [%s]", 1208 pw->pw_name, client_addr); 1209 } 1210 _exit(i); 1211 } 1212 1213 static void 1214 usage(void) 1215 { 1216 fprintf(stderr, 1217 "Usage: %s [-he] [-l log_level] [-f log_facility]\n", __progname); 1218 exit(1); 1219 } 1220 1221 int 1222 sftp_server_main(int argc, char **argv, struct passwd *user_pw) 1223 { 1224 fd_set *rset, *wset; 1225 int in, out, max, ch, skipargs = 0, log_stderr = 0; 1226 ssize_t len, olen, set_size; 1227 SyslogFacility log_facility = SYSLOG_FACILITY_AUTH; 1228 char *cp, buf[4*4096]; 1229 1230 extern char *optarg; 1231 1232 __progname = get_progname(argv[0]); 1233 1234 (void) g11n_setlocale(LC_ALL, ""); 1235 1236 log_init(__progname, log_level, log_facility, log_stderr); 1237 1238 while (!skipargs && (ch = getopt(argc, argv, "C:f:l:che")) != -1) { 1239 switch (ch) { 1240 case 'c': 1241 /* 1242 * Ignore all arguments if we are invoked as a 1243 * shell using "sftp-server -c command" 1244 */ 1245 skipargs = 1; 1246 break; 1247 case 'e': 1248 log_stderr = 1; 1249 break; 1250 case 'l': 1251 log_level = log_level_number(optarg); 1252 if (log_level == SYSLOG_LEVEL_NOT_SET) 1253 error("Invalid log level \"%s\"", optarg); 1254 break; 1255 case 'f': 1256 log_facility = log_facility_number(optarg); 1257 if (log_facility == SYSLOG_FACILITY_NOT_SET) 1258 error("Invalid log facility \"%s\"", optarg); 1259 break; 1260 case 'h': 1261 default: 1262 usage(); 1263 } 1264 } 1265 1266 log_init(__progname, log_level, log_facility, log_stderr); 1267 1268 if ((cp = getenv("SSH_CONNECTION")) != NULL) { 1269 client_addr = xstrdup(cp); 1270 if ((cp = strchr(client_addr, ' ')) == NULL) 1271 fatal("Malformed SSH_CONNECTION variable: \"%s\"", 1272 getenv("SSH_CONNECTION")); 1273 *cp = '\0'; 1274 } else 1275 client_addr = xstrdup("UNKNOWN"); 1276 1277 pw = pwcopy(user_pw); 1278 1279 log("session opened for local user %s from [%s]", 1280 pw->pw_name, client_addr); 1281 1282 handle_init(); 1283 1284 in = dup(STDIN_FILENO); 1285 out = dup(STDOUT_FILENO); 1286 1287 #ifdef HAVE_CYGWIN 1288 setmode(in, O_BINARY); 1289 setmode(out, O_BINARY); 1290 #endif 1291 1292 max = 0; 1293 if (in > max) 1294 max = in; 1295 if (out > max) 1296 max = out; 1297 1298 buffer_init(&iqueue); 1299 buffer_init(&oqueue); 1300 1301 set_size = howmany(max + 1, NFDBITS) * sizeof(fd_mask); 1302 rset = (fd_set *)xmalloc(set_size); 1303 wset = (fd_set *)xmalloc(set_size); 1304 1305 for (;;) { 1306 memset(rset, 0, set_size); 1307 memset(wset, 0, set_size); 1308 1309 /* 1310 * Ensure that we can read a full buffer and handle 1311 * the worst-case length packet it can generate, 1312 * otherwise apply backpressure by stopping reads. 1313 */ 1314 if (buffer_check_alloc(&iqueue, sizeof(buf)) && 1315 buffer_check_alloc(&oqueue, SFTP_MAX_MSG_LENGTH)) 1316 FD_SET(in, rset); 1317 1318 olen = buffer_len(&oqueue); 1319 if (olen > 0) 1320 FD_SET(out, wset); 1321 1322 if (select(max+1, rset, wset, NULL, NULL) < 0) { 1323 if (errno == EINTR) 1324 continue; 1325 error("select: %s", strerror(errno)); 1326 cleanup_exit(2); 1327 } 1328 1329 /* copy stdin to iqueue */ 1330 if (FD_ISSET(in, rset)) { 1331 len = read(in, buf, sizeof buf); 1332 if (len == 0) { 1333 debug("read eof"); 1334 cleanup_exit(0); 1335 } else if (len < 0) { 1336 error("read: %s", strerror(errno)); 1337 cleanup_exit(1); 1338 } else { 1339 buffer_append(&iqueue, buf, len); 1340 } 1341 } 1342 /* send oqueue to stdout */ 1343 if (FD_ISSET(out, wset)) { 1344 len = write(out, buffer_ptr(&oqueue), olen); 1345 if (len < 0) { 1346 error("write: %s", strerror(errno)); 1347 cleanup_exit(1); 1348 } else { 1349 buffer_consume(&oqueue, len); 1350 } 1351 } 1352 1353 /* 1354 * Process requests from client if we can fit the results 1355 * into the output buffer, otherwise stop processing input 1356 * and let the output queue drain. 1357 */ 1358 if (buffer_check_alloc(&oqueue, SFTP_MAX_MSG_LENGTH)) 1359 process(); 1360 } 1361 1362 /* NOTREACHED */ 1363 return (0); 1364 } 1365