openssh/sftp-server.c

   1 /*
   2  * Copyright (c) 2000, 2001 Markus Friedl.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24 #include "includes.h"
  25 RCSID("$OpenBSD: sftp-server.c,v 1.30 2001/07/31 12:42:50 jakob Exp $");
  26
  27 #include "buffer.h"
  28 #include "bufaux.h"
  29 #include "getput.h"
  30 #include "log.h"
  31 #include "xmalloc.h"
  32
  33 #include "sftp.h"
  34 #include "sftp-common.h"
  35
  36 /* helper */
  37 #define get_int64()                     buffer_get_int64(&iqueue);
  38 #define get_int()                       buffer_get_int(&iqueue);
  39 #define get_string(lenp)                buffer_get_string(&iqueue, lenp);
  40 #define TRACE                           debug
  41
  42 #ifdef HAVE___PROGNAME
  43 extern char *__progname;
  44 #else
  45 char *__progname;
  46 #endif
  47
  48 /* input and output queue */
  49 Buffer iqueue;
  50 Buffer oqueue;
  51
  52 /* Version of client */
  53 int version;
  54
  55 /* portable attibutes, etc. */
  56
  57 typedef struct Stat Stat;
  58
  59 struct Stat {
  60         char *name;
  61         char *long_name;
  62         Attrib attrib;
  63 };
  64
  65 static int
  66 errno_to_portable(int unixerrno)
  67 {
  68         int ret = 0;
  69
  70         switch (unixerrno) {
  71         case 0:
  72                 ret = SSH2_FX_OK;
  73                 break;
  74         case ENOENT:
  75         case ENOTDIR:
  76         case EBADF:
  77         case ELOOP:
  78                 ret = SSH2_FX_NO_SUCH_FILE;
  79                 break;
  80         case EPERM:
  81         case EACCES:
  82         case EFAULT:
  83                 ret = SSH2_FX_PERMISSION_DENIED;
  84                 break;
  85         case ENAMETOOLONG:
  86         case EINVAL:
  87                 ret = SSH2_FX_BAD_MESSAGE;
  88                 break;
  89         default:
  90                 ret = SSH2_FX_FAILURE;
  91                 break;
  92         }
  93         return ret;
  94 }
  95
  96 static int
  97 flags_from_portable(int pflags)
  98 {
  99         int flags = 0;
 100
 101         if ((pflags & SSH2_FXF_READ) &&
 102             (pflags & SSH2_FXF_WRITE)) {
 103                 flags = O_RDWR;
 104         } else if (pflags & SSH2_FXF_READ) {
 105                 flags = O_RDONLY;
 106         } else if (pflags & SSH2_FXF_WRITE) {
 107                 flags = O_WRONLY;
 108         }
 109         if (pflags & SSH2_FXF_CREAT)
 110                 flags |= O_CREAT;
 111         if (pflags & SSH2_FXF_TRUNC)
 112                 flags |= O_TRUNC;
 113         if (pflags & SSH2_FXF_EXCL)
 114                 flags |= O_EXCL;
 115         return flags;
 116 }
 117
 118 static Attrib *
 119 get_attrib(void)
 120 {
 121         return decode_attrib(&iqueue);
 122 }
 123
 124 /* handle handles */
 125
 126 typedef struct Handle Handle;
 127 struct Handle {
 128         int use;
 129         DIR *dirp;
 130         int fd;
 131         char *name;
 132 };
 133
 134 enum {
 135         HANDLE_UNUSED,
 136         HANDLE_DIR,
 137         HANDLE_FILE
 138 };
 139
 140 Handle  handles[100];
 141
 142 static void
 143 handle_init(void)
 144 {
 145         int i;
 146
 147         for(i = 0; i < sizeof(handles)/sizeof(Handle); i++)
 148                 handles[i].use = HANDLE_UNUSED;
 149 }
 150
 151 static int
 152 handle_new(int use, char *name, int fd, DIR *dirp)
 153 {
 154         int i;
 155
 156         for(i = 0; i < sizeof(handles)/sizeof(Handle); i++) {
 157                 if (handles[i].use == HANDLE_UNUSED) {
 158                         handles[i].use = use;
 159                         handles[i].dirp = dirp;
 160                         handles[i].fd = fd;
 161                         handles[i].name = name;
 162                         return i;
 163                 }
 164         }
 165         return -1;
 166 }
 167
 168 static int
 169 handle_is_ok(int i, int type)
 170 {
 171         return i >= 0 && i < sizeof(handles)/sizeof(Handle) &&
 172             handles[i].use == type;
 173 }
 174
 175 static int
 176 handle_to_string(int handle, char **stringp, int *hlenp)
 177 {
 178         if (stringp == NULL || hlenp == NULL)
 179                 return -1;
 180         *stringp = xmalloc(sizeof(int32_t));
 181         PUT_32BIT(*stringp, handle);
 182         *hlenp = sizeof(int32_t);
 183         return 0;
 184 }
 185
 186 static int
 187 handle_from_string(char *handle, u_int hlen)
 188 {
 189         int val;
 190
 191         if (hlen != sizeof(int32_t))
 192                 return -1;
 193         val = GET_32BIT(handle);
 194         if (handle_is_ok(val, HANDLE_FILE) ||
 195             handle_is_ok(val, HANDLE_DIR))
 196                 return val;
 197         return -1;
 198 }
 199
 200 static char *
 201 handle_to_name(int handle)
 202 {
 203         if (handle_is_ok(handle, HANDLE_DIR)||
 204             handle_is_ok(handle, HANDLE_FILE))
 205                 return handles[handle].name;
 206         return NULL;
 207 }
 208
 209 static DIR *
 210 handle_to_dir(int handle)
 211 {
 212         if (handle_is_ok(handle, HANDLE_DIR))
 213                 return handles[handle].dirp;
 214         return NULL;
 215 }
 216
 217 static int
 218 handle_to_fd(int handle)
 219 {
 220         if (handle_is_ok(handle, HANDLE_FILE))
 221                 return handles[handle].fd;
 222         return -1;
 223 }
 224
 225 static int
 226 handle_close(int handle)
 227 {
 228         int ret = -1;
 229
 230         if (handle_is_ok(handle, HANDLE_FILE)) {
 231                 ret = close(handles[handle].fd);
 232                 handles[handle].use = HANDLE_UNUSED;
 233         } else if (handle_is_ok(handle, HANDLE_DIR)) {
 234                 ret = closedir(handles[handle].dirp);
 235                 handles[handle].use = HANDLE_UNUSED;
 236         } else {
 237                 errno = ENOENT;
 238         }
 239         return ret;
 240 }
 241
 242 static int
 243 get_handle(void)
 244 {
 245         char *handle;
 246         int val = -1;
 247         u_int hlen;
 248
 249         handle = get_string(&hlen);
 250         if (hlen < 256)
 251                 val = handle_from_string(handle, hlen);
 252         xfree(handle);
 253         return val;
 254 }
 255
 256 /* send replies */
 257
 258 static void
 259 send_msg(Buffer *m)
 260 {
 261         int mlen = buffer_len(m);
 262
 263         buffer_put_int(&oqueue, mlen);
 264         buffer_append(&oqueue, buffer_ptr(m), mlen);
 265         buffer_consume(m, mlen);
 266 }
 267
 268 static void
 269 send_status(u_int32_t id, u_int32_t error)
 270 {
 271         Buffer msg;
 272         const char *status_messages[] = {
 273                 "Success",                      /* SSH_FX_OK */
 274                 "End of file",                  /* SSH_FX_EOF */
 275                 "No such file",                 /* SSH_FX_NO_SUCH_FILE */
 276                 "Permission denied",            /* SSH_FX_PERMISSION_DENIED */
 277                 "Failure",                      /* SSH_FX_FAILURE */
 278                 "Bad message",                  /* SSH_FX_BAD_MESSAGE */
 279                 "No connection",                /* SSH_FX_NO_CONNECTION */
 280                 "Connection lost",              /* SSH_FX_CONNECTION_LOST */
 281                 "Operation unsupported",        /* SSH_FX_OP_UNSUPPORTED */
 282                 "Unknown error"                 /* Others */
 283         };
 284
 285         TRACE("sent status id %d error %d", id, error);
 286         buffer_init(&msg);
 287         buffer_put_char(&msg, SSH2_FXP_STATUS);
 288         buffer_put_int(&msg, id);
 289         buffer_put_int(&msg, error);
 290         if (version >= 3) {
 291                 buffer_put_cstring(&msg,
 292                     status_messages[MIN(error,SSH2_FX_MAX)]);
 293                 buffer_put_cstring(&msg, "");
 294         }
 295         send_msg(&msg);
 296         buffer_free(&msg);
 297 }
 298 static void
 299 send_data_or_handle(char type, u_int32_t id, char *data, int dlen)
 300 {
 301         Buffer msg;
 302
 303         buffer_init(&msg);
 304         buffer_put_char(&msg, type);
 305         buffer_put_int(&msg, id);
 306         buffer_put_string(&msg, data, dlen);
 307         send_msg(&msg);
 308         buffer_free(&msg);
 309 }
 310
 311 static void
 312 send_data(u_int32_t id, char *data, int dlen)
 313 {
 314         TRACE("sent data id %d len %d", id, dlen);
 315         send_data_or_handle(SSH2_FXP_DATA, id, data, dlen);
 316 }
 317
 318 static void
 319 send_handle(u_int32_t id, int handle)
 320 {
 321         char *string;
 322         int hlen;
 323
 324         handle_to_string(handle, &string, &hlen);
 325         TRACE("sent handle id %d handle %d", id, handle);
 326         send_data_or_handle(SSH2_FXP_HANDLE, id, string, hlen);
 327         xfree(string);
 328 }
 329
 330 static void
 331 send_names(u_int32_t id, int count, Stat *stats)
 332 {
 333         Buffer msg;
 334         int i;
 335
 336         buffer_init(&msg);
 337         buffer_put_char(&msg, SSH2_FXP_NAME);
 338         buffer_put_int(&msg, id);
 339         buffer_put_int(&msg, count);
 340         TRACE("sent names id %d count %d", id, count);
 341         for (i = 0; i < count; i++) {
 342                 buffer_put_cstring(&msg, stats[i].name);
 343                 buffer_put_cstring(&msg, stats[i].long_name);
 344                 encode_attrib(&msg, &stats[i].attrib);
 345         }
 346         send_msg(&msg);
 347         buffer_free(&msg);
 348 }
 349
 350 static void
 351 send_attrib(u_int32_t id, Attrib *a)
 352 {
 353         Buffer msg;
 354
 355         TRACE("sent attrib id %d have 0x%x", id, a->flags);
 356         buffer_init(&msg);
 357         buffer_put_char(&msg, SSH2_FXP_ATTRS);
 358         buffer_put_int(&msg, id);
 359         encode_attrib(&msg, a);
 360         send_msg(&msg);
 361         buffer_free(&msg);
 362 }
 363
 364 /* parse incoming */
 365
 366 static void
 367 process_init(void)
 368 {
 369         Buffer msg;
 370
 371         version = buffer_get_int(&iqueue);
 372         TRACE("client version %d", version);
 373         buffer_init(&msg);
 374         buffer_put_char(&msg, SSH2_FXP_VERSION);
 375         buffer_put_int(&msg, SSH2_FILEXFER_VERSION);
 376         send_msg(&msg);
 377         buffer_free(&msg);
 378 }
 379
 380 static void
 381 process_open(void)
 382 {
 383         u_int32_t id, pflags;
 384         Attrib *a;
 385         char *name;
 386         int handle, fd, flags, mode, status = SSH2_FX_FAILURE;
 387
 388         id = get_int();
 389         name = get_string(NULL);
 390         pflags = get_int();             /* portable flags */
 391         a = get_attrib();
 392         flags = flags_from_portable(pflags);
 393         mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? a->perm : 0666;
 394         TRACE("open id %d name %s flags %d mode 0%o", id, name, pflags, mode);
 395         fd = open(name, flags, mode);
 396         if (fd < 0) {
 397                 status = errno_to_portable(errno);
 398         } else {
 399                 handle = handle_new(HANDLE_FILE, xstrdup(name), fd, NULL);
 400                 if (handle < 0) {
 401                         close(fd);
 402                 } else {
 403                         send_handle(id, handle);
 404                         status = SSH2_FX_OK;
 405                 }
 406         }
 407         if (status != SSH2_FX_OK)
 408                 send_status(id, status);
 409         xfree(name);
 410 }
 411
 412 static void
 413 process_close(void)
 414 {
 415         u_int32_t id;
 416         int handle, ret, status = SSH2_FX_FAILURE;
 417
 418         id = get_int();
 419         handle = get_handle();
 420         TRACE("close id %d handle %d", id, handle);
 421         ret = handle_close(handle);
 422         status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
 423         send_status(id, status);
 424 }
 425
 426 static void
 427 process_read(void)
 428 {
 429         char buf[64*1024];
 430         u_int32_t id, len;
 431         int handle, fd, ret, status = SSH2_FX_FAILURE;
 432         u_int64_t off;
 433
 434         id = get_int();
 435         handle = get_handle();
 436         off = get_int64();
 437         len = get_int();
 438
 439         TRACE("read id %d handle %d off %llu len %d", id, handle,
 440             (u_int64_t)off, len);
 441         if (len > sizeof buf) {
 442                 len = sizeof buf;
 443                 log("read change len %d", len);
 444         }
 445         fd = handle_to_fd(handle);
 446         if (fd >= 0) {
 447                 if (lseek(fd, off, SEEK_SET) < 0) {
 448                         error("process_read: seek failed");
 449                         status = errno_to_portable(errno);
 450                 } else {
 451                         ret = read(fd, buf, len);
 452                         if (ret < 0) {
 453                                 status = errno_to_portable(errno);
 454                         } else if (ret == 0) {
 455                                 status = SSH2_FX_EOF;
 456                         } else {
 457                                 send_data(id, buf, ret);
 458                                 status = SSH2_FX_OK;
 459                         }
 460                 }
 461         }
 462         if (status != SSH2_FX_OK)
 463                 send_status(id, status);
 464 }
 465
 466 static void
 467 process_write(void)
 468 {
 469         u_int32_t id;
 470         u_int64_t off;
 471         u_int len;
 472         int handle, fd, ret, status = SSH2_FX_FAILURE;
 473         char *data;
 474
 475         id = get_int();
 476         handle = get_handle();
 477         off = get_int64();
 478         data = get_string(&len);
 479
 480         TRACE("write id %d handle %d off %llu len %d", id, handle,
 481             (u_int64_t)off, len);
 482         fd = handle_to_fd(handle);
 483         if (fd >= 0) {
 484                 if (lseek(fd, off, SEEK_SET) < 0) {
 485                         status = errno_to_portable(errno);
 486                         error("process_write: seek failed");
 487                 } else {
 488 /* XXX ATOMICIO ? */
 489                         ret = write(fd, data, len);
 490                         if (ret == -1) {
 491                                 error("process_write: write failed");
 492                                 status = errno_to_portable(errno);
 493                         } else if (ret == len) {
 494                                 status = SSH2_FX_OK;
 495                         } else {
 496                                 log("nothing at all written");
 497                         }
 498                 }
 499         }
 500         send_status(id, status);
 501         xfree(data);
 502 }
 503
 504 static void
 505 process_do_stat(int do_lstat)
 506 {
 507         Attrib a;
 508         struct stat st;
 509         u_int32_t id;
 510         char *name;
 511         int ret, status = SSH2_FX_FAILURE;
 512
 513         id = get_int();
 514         name = get_string(NULL);
 515         TRACE("%sstat id %d name %s", do_lstat ? "l" : "", id, name);
 516         ret = do_lstat ? lstat(name, &st) : stat(name, &st);
 517         if (ret < 0) {
 518                 status = errno_to_portable(errno);
 519         } else {
 520                 stat_to_attrib(&st, &a);
 521                 send_attrib(id, &a);
 522                 status = SSH2_FX_OK;
 523         }
 524         if (status != SSH2_FX_OK)
 525                 send_status(id, status);
 526         xfree(name);
 527 }
 528
 529 static void
 530 process_stat(void)
 531 {
 532         process_do_stat(0);
 533 }
 534
 535 static void
 536 process_lstat(void)
 537 {
 538         process_do_stat(1);
 539 }
 540
 541 static void
 542 process_fstat(void)
 543 {
 544         Attrib a;
 545         struct stat st;
 546         u_int32_t id;
 547         int fd, ret, handle, status = SSH2_FX_FAILURE;
 548
 549         id = get_int();
 550         handle = get_handle();
 551         TRACE("fstat id %d handle %d", id, handle);
 552         fd = handle_to_fd(handle);
 553         if (fd  >= 0) {
 554                 ret = fstat(fd, &st);
 555                 if (ret < 0) {
 556                         status = errno_to_portable(errno);
 557                 } else {
 558                         stat_to_attrib(&st, &a);
 559                         send_attrib(id, &a);
 560                         status = SSH2_FX_OK;
 561                 }
 562         }
 563         if (status != SSH2_FX_OK)
 564                 send_status(id, status);
 565 }
 566
 567 static struct timeval *
 568 attrib_to_tv(Attrib *a)
 569 {
 570         static struct timeval tv[2];
 571
 572         tv[0].tv_sec = a->atime;
 573         tv[0].tv_usec = 0;
 574         tv[1].tv_sec = a->mtime;
 575         tv[1].tv_usec = 0;
 576         return tv;
 577 }
 578
 579 static void
 580 process_setstat(void)
 581 {
 582         Attrib *a;
 583         u_int32_t id;
 584         char *name;
 585         int ret;
 586         int status = SSH2_FX_OK;
 587
 588         id = get_int();
 589         name = get_string(NULL);
 590         a = get_attrib();
 591         TRACE("setstat id %d name %s", id, name);
 592         if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {
 593                 ret = chmod(name, a->perm & 0777);
 594                 if (ret == -1)
 595                         status = errno_to_portable(errno);
 596         }
 597         if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {
 598                 ret = utimes(name, attrib_to_tv(a));
 599                 if (ret == -1)
 600                         status = errno_to_portable(errno);
 601         }
 602         if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {
 603                 ret = chown(name, a->uid, a->gid);
 604                 if (ret == -1)
 605                         status = errno_to_portable(errno);
 606         }
 607         send_status(id, status);
 608         xfree(name);
 609 }
 610
 611 static void
 612 process_fsetstat(void)
 613 {
 614         Attrib *a;
 615         u_int32_t id;
 616         int handle, fd, ret;
 617         int status = SSH2_FX_OK;
 618         char *name;
 619
 620         id = get_int();
 621         handle = get_handle();
 622         a = get_attrib();
 623         TRACE("fsetstat id %d handle %d", id, handle);
 624         fd = handle_to_fd(handle);
 625         name = handle_to_name(handle);
 626         if (fd < 0 || name == NULL) {
 627                 status = SSH2_FX_FAILURE;
 628         } else {
 629                 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {
 630 #ifdef HAVE_FCHMOD
 631                         ret = fchmod(fd, a->perm & 0777);
 632 #else
 633                         ret = chmod(name, a->perm & 0777);
 634 #endif
 635                         if (ret == -1)
 636                                 status = errno_to_portable(errno);
 637                 }
 638                 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {
 639 #ifdef HAVE_FUTIMES
 640                         ret = futimes(fd, attrib_to_tv(a));
 641 #else
 642                         ret = utimes(name, attrib_to_tv(a));
 643 #endif
 644                         if (ret == -1)
 645                                 status = errno_to_portable(errno);
 646                 }
 647                 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {
 648 #ifdef HAVE_FCHOWN
 649                         ret = fchown(fd, a->uid, a->gid);
 650 #else
 651                         ret = chown(name, a->uid, a->gid);
 652 #endif
 653                         if (ret == -1)
 654                                 status = errno_to_portable(errno);
 655                 }
 656         }
 657         send_status(id, status);
 658 }
 659
 660 static void
 661 process_opendir(void)
 662 {
 663         DIR *dirp = NULL;
 664         char *path;
 665         int handle, status = SSH2_FX_FAILURE;
 666         u_int32_t id;
 667
 668         id = get_int();
 669         path = get_string(NULL);
 670         TRACE("opendir id %d path %s", id, path);
 671         dirp = opendir(path);
 672         if (dirp == NULL) {
 673                 status = errno_to_portable(errno);
 674         } else {
 675                 handle = handle_new(HANDLE_DIR, xstrdup(path), 0, dirp);
 676                 if (handle < 0) {
 677                         closedir(dirp);
 678                 } else {
 679                         send_handle(id, handle);
 680                         status = SSH2_FX_OK;
 681                 }
 682
 683         }
 684         if (status != SSH2_FX_OK)
 685                 send_status(id, status);
 686         xfree(path);
 687 }
 688
 689 /*
 690  * drwxr-xr-x    5 markus   markus       1024 Jan 13 18:39 .ssh
 691  */
 692 static char *
 693 ls_file(char *name, struct stat *st)
 694 {
 695         int ulen, glen, sz = 0;
 696         struct passwd *pw;
 697         struct group *gr;
 698         struct tm *ltime = localtime(&st->st_mtime);
 699         char *user, *group;
 700         char buf[1024], mode[11+1], tbuf[12+1], ubuf[11+1], gbuf[11+1];
 701
 702         strmode(st->st_mode, mode);
 703         if ((pw = getpwuid(st->st_uid)) != NULL) {
 704                 user = pw->pw_name;
 705         } else {
 706                 snprintf(ubuf, sizeof ubuf, "%d", st->st_uid);
 707                 user = ubuf;
 708         }
 709         if ((gr = getgrgid(st->st_gid)) != NULL) {
 710                 group = gr->gr_name;
 711         } else {
 712                 snprintf(gbuf, sizeof gbuf, "%d", st->st_gid);
 713                 group = gbuf;
 714         }
 715         if (ltime != NULL) {
 716                 if (time(NULL) - st->st_mtime < (365*24*60*60)/2)
 717                         sz = strftime(tbuf, sizeof tbuf, "%b %e %H:%M", ltime);
 718                 else
 719                         sz = strftime(tbuf, sizeof tbuf, "%b %e  %Y", ltime);
 720         }
 721         if (sz == 0)
 722                 tbuf[0] = '\0';
 723         ulen = MAX(strlen(user), 8);
 724         glen = MAX(strlen(group), 8);
 725         snprintf(buf, sizeof buf, "%s %3d %-*s %-*s %8llu %s %s", mode,
 726             st->st_nlink, ulen, user, glen, group,
 727             (u_int64_t)st->st_size, tbuf, name);
 728         return xstrdup(buf);
 729 }
 730
 731 static void
 732 process_readdir(void)
 733 {
 734         DIR *dirp;
 735         struct dirent *dp;
 736         char *path;
 737         int handle;
 738         u_int32_t id;
 739
 740         id = get_int();
 741         handle = get_handle();
 742         TRACE("readdir id %d handle %d", id, handle);
 743         dirp = handle_to_dir(handle);
 744         path = handle_to_name(handle);
 745         if (dirp == NULL || path == NULL) {
 746                 send_status(id, SSH2_FX_FAILURE);
 747         } else {
 748                 struct stat st;
 749                 char pathname[1024];
 750                 Stat *stats;
 751                 int nstats = 10, count = 0, i;
 752                 stats = xmalloc(nstats * sizeof(Stat));
 753                 while ((dp = readdir(dirp)) != NULL) {
 754                         if (count >= nstats) {
 755                                 nstats *= 2;
 756                                 stats = xrealloc(stats, nstats * sizeof(Stat));
 757                         }
 758 /* XXX OVERFLOW ? */
 759                         snprintf(pathname, sizeof pathname, "%s%s%s", path,
 760                             strcmp(path, "/") ? "/" : "", dp->d_name);
 761                         if (lstat(pathname, &st) < 0)
 762                                 continue;
 763                         stat_to_attrib(&st, &(stats[count].attrib));
 764                         stats[count].name = xstrdup(dp->d_name);
 765                         stats[count].long_name = ls_file(dp->d_name, &st);
 766                         count++;
 767                         /* send up to 100 entries in one message */
 768                         /* XXX check packet size instead */
 769                         if (count == 100)
 770                                 break;
 771                 }
 772                 if (count > 0) {
 773                         send_names(id, count, stats);
 774                         for(i = 0; i < count; i++) {
 775                                 xfree(stats[i].name);
 776                                 xfree(stats[i].long_name);
 777                         }
 778                 } else {
 779                         send_status(id, SSH2_FX_EOF);
 780                 }
 781                 xfree(stats);
 782         }
 783 }
 784
 785 static void
 786 process_remove(void)
 787 {
 788         char *name;
 789         u_int32_t id;
 790         int status = SSH2_FX_FAILURE;
 791         int ret;
 792
 793         id = get_int();
 794         name = get_string(NULL);
 795         TRACE("remove id %d name %s", id, name);
 796         ret = unlink(name);
 797         status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
 798         send_status(id, status);
 799         xfree(name);
 800 }
 801
 802 static void
 803 process_mkdir(void)
 804 {
 805         Attrib *a;
 806         u_int32_t id;
 807         char *name;
 808         int ret, mode, status = SSH2_FX_FAILURE;
 809
 810         id = get_int();
 811         name = get_string(NULL);
 812         a = get_attrib();
 813         mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ?
 814             a->perm & 0777 : 0777;
 815         TRACE("mkdir id %d name %s mode 0%o", id, name, mode);
 816         ret = mkdir(name, mode);
 817         status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
 818         send_status(id, status);
 819         xfree(name);
 820 }
 821
 822 static void
 823 process_rmdir(void)
 824 {
 825         u_int32_t id;
 826         char *name;
 827         int ret, status;
 828
 829         id = get_int();
 830         name = get_string(NULL);
 831         TRACE("rmdir id %d name %s", id, name);
 832         ret = rmdir(name);
 833         status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
 834         send_status(id, status);
 835         xfree(name);
 836 }
 837
 838 static void
 839 process_realpath(void)
 840 {
 841         char resolvedname[MAXPATHLEN];
 842         u_int32_t id;
 843         char *path;
 844
 845         id = get_int();
 846         path = get_string(NULL);
 847         if (path[0] == '\0') {
 848                 xfree(path);
 849                 path = xstrdup(".");
 850         }
 851         TRACE("realpath id %d path %s", id, path);
 852         if (realpath(path, resolvedname) == NULL) {
 853                 send_status(id, errno_to_portable(errno));
 854         } else {
 855                 Stat s;
 856                 attrib_clear(&s.attrib);
 857                 s.name = s.long_name = resolvedname;
 858                 send_names(id, 1, &s);
 859         }
 860         xfree(path);
 861 }
 862
 863 static void
 864 process_rename(void)
 865 {
 866         u_int32_t id;
 867         struct stat st;
 868         char *oldpath, *newpath;
 869         int ret, status = SSH2_FX_FAILURE;
 870
 871         id = get_int();
 872         oldpath = get_string(NULL);
 873         newpath = get_string(NULL);
 874         TRACE("rename id %d old %s new %s", id, oldpath, newpath);
 875         /* fail if 'newpath' exists */
 876         if (stat(newpath, &st) == -1) {
 877                 ret = rename(oldpath, newpath);
 878                 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
 879         }
 880         send_status(id, status);
 881         xfree(oldpath);
 882         xfree(newpath);
 883 }
 884
 885 static void
 886 process_readlink(void)
 887 {
 888         u_int32_t id;
 889         int len;
 890         char link[MAXPATHLEN];
 891         char *path;
 892
 893         id = get_int();
 894         path = get_string(NULL);
 895         TRACE("readlink id %d path %s", id, path);
 896         if ((len = readlink(path, link, sizeof(link) - 1)) == -1)
 897                 send_status(id, errno_to_portable(errno));
 898         else {
 899                 Stat s;
 900
 901                 link[len] = '\0';
 902                 attrib_clear(&s.attrib);
 903                 s.name = s.long_name = link;
 904                 send_names(id, 1, &s);
 905         }
 906         xfree(path);
 907 }
 908
 909 static void
 910 process_symlink(void)
 911 {
 912         u_int32_t id;
 913         struct stat st;
 914         char *oldpath, *newpath;
 915         int ret, status = SSH2_FX_FAILURE;
 916
 917         id = get_int();
 918         oldpath = get_string(NULL);
 919         newpath = get_string(NULL);
 920         TRACE("symlink id %d old %s new %s", id, oldpath, newpath);
 921         /* fail if 'newpath' exists */
 922         if (stat(newpath, &st) == -1) {
 923                 ret = symlink(oldpath, newpath);
 924                 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
 925         }
 926         send_status(id, status);
 927         xfree(oldpath);
 928         xfree(newpath);
 929 }
 930
 931 static void
 932 process_extended(void)
 933 {
 934         u_int32_t id;
 935         char *request;
 936
 937         id = get_int();
 938         request = get_string(NULL);
 939         send_status(id, SSH2_FX_OP_UNSUPPORTED);                /* MUST */
 940         xfree(request);
 941 }
 942
 943 /* stolen from ssh-agent */
 944
 945 static void
 946 process(void)
 947 {
 948         u_int msg_len;
 949         u_int type;
 950         u_char *cp;
 951
 952         if (buffer_len(&iqueue) < 5)
 953                 return;         /* Incomplete message. */
 954         cp = (u_char *) buffer_ptr(&iqueue);
 955         msg_len = GET_32BIT(cp);
 956         if (msg_len > 256 * 1024) {
 957                 error("bad message ");
 958                 exit(11);
 959         }
 960         if (buffer_len(&iqueue) < msg_len + 4)
 961                 return;
 962         buffer_consume(&iqueue, 4);
 963         type = buffer_get_char(&iqueue);
 964         switch (type) {
 965         case SSH2_FXP_INIT:
 966                 process_init();
 967                 break;
 968         case SSH2_FXP_OPEN:
 969                 process_open();
 970                 break;
 971         case SSH2_FXP_CLOSE:
 972                 process_close();
 973                 break;
 974         case SSH2_FXP_READ:
 975                 process_read();
 976                 break;
 977         case SSH2_FXP_WRITE:
 978                 process_write();
 979                 break;
 980         case SSH2_FXP_LSTAT:
 981                 process_lstat();
 982                 break;
 983         case SSH2_FXP_FSTAT:
 984                 process_fstat();
 985                 break;
 986         case SSH2_FXP_SETSTAT:
 987                 process_setstat();
 988                 break;
 989         case SSH2_FXP_FSETSTAT:
 990                 process_fsetstat();
 991                 break;
 992         case SSH2_FXP_OPENDIR:
 993                 process_opendir();
 994                 break;
 995         case SSH2_FXP_READDIR:
 996                 process_readdir();
 997                 break;
 998         case SSH2_FXP_REMOVE:
 999                 process_remove();
1000                 break;
1001         case SSH2_FXP_MKDIR:
1002                 process_mkdir();
1003                 break;
1004         case SSH2_FXP_RMDIR:
1005                 process_rmdir();
1006                 break;
1007         case SSH2_FXP_REALPATH:
1008                 process_realpath();
1009                 break;
1010         case SSH2_FXP_STAT:
1011                 process_stat();
1012                 break;
1013         case SSH2_FXP_RENAME:
1014                 process_rename();
1015                 break;
1016         case SSH2_FXP_READLINK:
1017                 process_readlink();
1018                 break;
1019         case SSH2_FXP_SYMLINK:
1020                 process_symlink();
1021                 break;
1022         case SSH2_FXP_EXTENDED:
1023                 process_extended();
1024                 break;
1025         default:
1026                 error("Unknown message %d", type);
1027                 break;
1028         }
1029 }
1030
1031 int
1032 main(int ac, char **av)
1033 {
1034         fd_set *rset, *wset;
1035         int in, out, max;
1036         ssize_t len, olen, set_size;
1037
1038         /* XXX should use getopt */
1039
1040         __progname = get_progname(av[0]);
1041         handle_init();
1042
1043 #ifdef DEBUG_SFTP_SERVER
1044         log_init("sftp-server", SYSLOG_LEVEL_DEBUG1, SYSLOG_FACILITY_AUTH, 0);
1045 #endif
1046
1047         in = dup(STDIN_FILENO);
1048         out = dup(STDOUT_FILENO);
1049
1050 #ifdef HAVE_CYGWIN
1051         setmode(in, O_BINARY);
1052         setmode(out, O_BINARY);
1053 #endif
1054
1055         max = 0;
1056         if (in > max)
1057                 max = in;
1058         if (out > max)
1059                 max = out;
1060
1061         buffer_init(&iqueue);
1062         buffer_init(&oqueue);
1063
1064         set_size = howmany(max + 1, NFDBITS) * sizeof(fd_mask);
1065         rset = (fd_set *)xmalloc(set_size);
1066         wset = (fd_set *)xmalloc(set_size);
1067
1068         for (;;) {
1069                 memset(rset, 0, set_size);
1070                 memset(wset, 0, set_size);
1071
1072                 FD_SET(in, rset);
1073                 olen = buffer_len(&oqueue);
1074                 if (olen > 0)
1075                         FD_SET(out, wset);
1076
1077                 if (select(max+1, rset, wset, NULL, NULL) < 0) {
1078                         if (errno == EINTR)
1079                                 continue;
1080                         exit(2);
1081                 }
1082
1083                 /* copy stdin to iqueue */
1084                 if (FD_ISSET(in, rset)) {
1085                         char buf[4*4096];
1086                         len = read(in, buf, sizeof buf);
1087                         if (len == 0) {
1088                                 debug("read eof");
1089                                 exit(0);
1090                         } else if (len < 0) {
1091                                 error("read error");
1092                                 exit(1);
1093                         } else {
1094                                 buffer_append(&iqueue, buf, len);
1095                         }
1096                 }
1097                 /* send oqueue to stdout */
1098                 if (FD_ISSET(out, wset)) {
1099                         len = write(out, buffer_ptr(&oqueue), olen);
1100                         if (len < 0) {
1101                                 error("write error");
1102                                 exit(1);
1103                         } else {
1104                                 buffer_consume(&oqueue, len);
1105                         }
1106                 }
1107                 /* process requests from client */
1108                 process();
1109         }
1110 }