sftp-server.c

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