contrib/lukemftpd/src/cmds.c

   1 /*      $NetBSD: cmds.c,v 1.24 2006/02/01 14:20:12 christos Exp $       */
   2
   3 /*
   4  * Copyright (c) 1999-2004 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Luke Mewburn.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *        This product includes software developed by the NetBSD
  21  *        Foundation, Inc. and its contributors.
  22  * 4. Neither the name of The NetBSD Foundation nor the names of its
  23  *    contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 /*
  40  * Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994
  41  *      The Regents of the University of California.  All rights reserved.
  42  *
  43  * Redistribution and use in source and binary forms, with or without
  44  * modification, are permitted provided that the following conditions
  45  * are met:
  46  * 1. Redistributions of source code must retain the above copyright
  47  *    notice, this list of conditions and the following disclaimer.
  48  * 2. Redistributions in binary form must reproduce the above copyright
  49  *    notice, this list of conditions and the following disclaimer in the
  50  *    documentation and/or other materials provided with the distribution.
  51  * 3. Neither the name of the University nor the names of its contributors
  52  *    may be used to endorse or promote products derived from this software
  53  *    without specific prior written permission.
  54  *
  55  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  56  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  57  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  58  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  59  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  60  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  61  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  62  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  63  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  64  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  65  * SUCH DAMAGE.
  66  */
  67
  68 /*
  69  * Copyright (C) 1997 and 1998 WIDE Project.
  70  * All rights reserved.
  71  *
  72  * Redistribution and use in source and binary forms, with or without
  73  * modification, are permitted provided that the following conditions
  74  * are met:
  75  * 1. Redistributions of source code must retain the above copyright
  76  *    notice, this list of conditions and the following disclaimer.
  77  * 2. Redistributions in binary form must reproduce the above copyright
  78  *    notice, this list of conditions and the following disclaimer in the
  79  *    documentation and/or other materials provided with the distribution.
  80  * 3. Neither the name of the project nor the names of its contributors
  81  *    may be used to endorse or promote products derived from this software
  82  *    without specific prior written permission.
  83  *
  84  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  85  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  86  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  87  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  88  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  89  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  90  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  91  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  92  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  93  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  94  * SUCH DAMAGE.
  95  */
  96
  97
  98 #include <sys/cdefs.h>
  99 #ifndef lint
 100 __RCSID("$NetBSD: cmds.c,v 1.24 2006/02/01 14:20:12 christos Exp $");
 101 #endif /* not lint */
 102
 103 #include <sys/param.h>
 104 #include <sys/stat.h>
 105
 106 #include <arpa/ftp.h>
 107
 108 #include <dirent.h>
 109 #include <errno.h>
 110 #include <stdio.h>
 111 #include <stdlib.h>
 112 #include <string.h>
 113 #include <tzfile.h>
 114 #include <unistd.h>
 115 #include <ctype.h>
 116
 117 #ifdef KERBEROS5
 118 #include <krb5/krb5.h>
 119 #endif
 120
 121 #include "extern.h"
 122
 123 typedef enum {
 124         FE_MLSD         = 1<<0,         /* if op is MLSD (MLST otherwise ) */
 125         FE_ISCURDIR     = 1<<1,         /* if name is the current directory */
 126 } factflag_t;
 127
 128 typedef struct {
 129         const char      *path;          /* full pathname */
 130         const char      *display;       /* name to display */
 131         struct stat     *stat;          /* stat of path */
 132         struct stat     *pdirstat;      /* stat of path's parent dir */
 133         factflag_t       flags;         /* flags */
 134 } factelem;
 135
 136 static void     ack(const char *);
 137 static void     base64_encode(const char *, size_t, char *, int);
 138 static void     fact_type(const char *, FILE *, factelem *);
 139 static void     fact_size(const char *, FILE *, factelem *);
 140 static void     fact_modify(const char *, FILE *, factelem *);
 141 static void     fact_perm(const char *, FILE *, factelem *);
 142 static void     fact_unique(const char *, FILE *, factelem *);
 143 static int      matchgroup(gid_t);
 144 static void     mlsname(FILE *, factelem *);
 145 static void     replydirname(const char *, const char *);
 146
 147 struct ftpfact {
 148         const char       *name;         /* name of fact */
 149         int               enabled;      /* if fact is enabled */
 150         void            (*display)(const char *, FILE *, factelem *);
 151                                         /* function to display fact */
 152 };
 153
 154 struct ftpfact facttab[] = {
 155         { "Type",       1, fact_type },
 156 #define FACT_TYPE 0
 157         { "Size",       1, fact_size },
 158         { "Modify",     1, fact_modify },
 159         { "Perm",       1, fact_perm },
 160         { "Unique",     1, fact_unique },
 161         /* "Create" */
 162         /* "Lang" */
 163         /* "Media-Type" */
 164         /* "CharSet" */
 165 };
 166
 167 #define FACTTABSIZE     (sizeof(facttab) / sizeof(struct ftpfact))
 168
 169 static char cached_path[MAXPATHLEN + 1] = "/";
 170 static void discover_path(char *, const char *);
 171
 172 void
 173 cwd(const char *path)
 174 {
 175
 176         if (chdir(path) < 0)
 177                 perror_reply(550, path);
 178         else {
 179                 show_chdir_messages(250);
 180                 ack("CWD");
 181                 if (getcwd(cached_path, MAXPATHLEN) == NULL) {
 182                         discover_path(cached_path, path);
 183                 }
 184         }
 185 }
 186
 187 void
 188 delete(const char *name)
 189 {
 190         char *p = NULL;
 191
 192         if (remove(name) < 0) {
 193                 p = strerror(errno);
 194                 perror_reply(550, name);
 195         } else
 196                 ack("DELE");
 197         logxfer("delete", -1, name, NULL, NULL, p);
 198 }
 199
 200 void
 201 feat(void)
 202 {
 203         int i;
 204
 205         reply(-211, "Features supported");
 206         cprintf(stdout, " MDTM\r\n");
 207         cprintf(stdout, " MLST ");
 208         for (i = 0; i < FACTTABSIZE; i++)
 209                 cprintf(stdout, "%s%s;", facttab[i].name,
 210                     facttab[i].enabled ? "*" : "");
 211         cprintf(stdout, "\r\n");
 212         cprintf(stdout, " REST STREAM\r\n");
 213         cprintf(stdout, " SIZE\r\n");
 214         cprintf(stdout, " TVFS\r\n");
 215         reply(211,  "End");
 216 }
 217
 218 void
 219 makedir(const char *name)
 220 {
 221         char *p = NULL;
 222
 223         if (mkdir(name, 0777) < 0) {
 224                 p = strerror(errno);
 225                 perror_reply(550, name);
 226         } else
 227                 replydirname(name, "directory created.");
 228         logxfer("mkdir", -1, name, NULL, NULL, p);
 229 }
 230
 231 void
 232 mlsd(const char *path)
 233 {
 234         struct dirent   *dp;
 235         struct stat      sb, pdirstat;
 236         factelem f;
 237         FILE    *dout;
 238         DIR     *dirp;
 239         char    name[MAXPATHLEN];
 240         int     hastypefact;
 241
 242         hastypefact = facttab[FACT_TYPE].enabled;
 243         if (path == NULL)
 244                 path = ".";
 245         if (stat(path, &pdirstat) == -1) {
 246  mlsdperror:
 247                 perror_reply(550, path);
 248                 return;
 249         }
 250         if (! S_ISDIR(pdirstat.st_mode)) {
 251                 errno = ENOTDIR;
 252                 perror_reply(501, path);
 253                 return;
 254         }
 255         if ((dirp = opendir(path)) == NULL)
 256                 goto mlsdperror;
 257
 258         dout = dataconn("MLSD", (off_t)-1, "w");
 259         if (dout == NULL)
 260                 return;
 261
 262         memset(&f, 0, sizeof(f));
 263         f.stat = &sb;
 264         f.flags |= FE_MLSD;
 265         while ((dp = readdir(dirp)) != NULL) {
 266                 snprintf(name, sizeof(name), "%s/%s", path, dp->d_name);
 267                 if (ISDOTDIR(dp->d_name)) {     /* special case curdir: */
 268                         if (! hastypefact)
 269                                 continue;
 270                         f.pdirstat = NULL;      /*   require stat of parent */
 271                         f.display = path;       /*   set name to real name */
 272                         f.flags |= FE_ISCURDIR; /*   flag name is curdir */
 273                 } else {
 274                         if (ISDOTDOTDIR(dp->d_name)) {
 275                                 if (! hastypefact)
 276                                         continue;
 277                                 f.pdirstat = NULL;
 278                         } else
 279                                 f.pdirstat = &pdirstat; /* cache parent stat */
 280                         f.display = dp->d_name;
 281                         f.flags &= ~FE_ISCURDIR;
 282                 }
 283                 if (stat(name, &sb) == -1)
 284                         continue;
 285                 f.path = name;
 286                 mlsname(dout, &f);
 287         }
 288         (void)closedir(dirp);
 289
 290         if (ferror(dout) != 0)
 291                 perror_reply(550, "Data connection");
 292         else
 293                 reply(226, "MLSD complete.");
 294         closedataconn(dout);
 295         total_xfers_out++;
 296         total_xfers++;
 297 }
 298
 299 void
 300 mlst(const char *path)
 301 {
 302         struct stat sb;
 303         factelem f;
 304
 305         if (path == NULL)
 306                 path = ".";
 307         if (stat(path, &sb) == -1) {
 308                 perror_reply(550, path);
 309                 return;
 310         }
 311         reply(-250, "MLST %s", path);
 312         memset(&f, 0, sizeof(f));
 313         f.path = path;
 314         f.display = path;
 315         f.stat = &sb;
 316         f.pdirstat = NULL;
 317         CPUTC(' ', stdout);
 318         mlsname(stdout, &f);
 319         reply(250, "End");
 320 }
 321
 322
 323 void
 324 opts(const char *command)
 325 {
 326         struct tab *c;
 327         char *ep;
 328
 329         if ((ep = strchr(command, ' ')) != NULL)
 330                 *ep++ = '\0';
 331         c = lookup(cmdtab, command);
 332         if (c == NULL) {
 333                 reply(502, "Unknown command '%s'.", command);
 334                 return;
 335         }
 336         if (! CMD_IMPLEMENTED(c)) {
 337                 reply(502, "%s command not implemented.", c->name);
 338                 return;
 339         }
 340         if (! CMD_HAS_OPTIONS(c)) {
 341                 reply(501, "%s command does not support persistent options.",
 342                     c->name);
 343                 return;
 344         }
 345
 346                         /* special case: MLST */
 347         if (strcasecmp(command, "MLST") == 0) {
 348                 int      enabled[FACTTABSIZE];
 349                 int      i, onedone;
 350                 size_t   len;
 351                 char    *p;
 352
 353                 for (i = 0; i < sizeof(enabled) / sizeof(int); i++)
 354                         enabled[i] = 0;
 355                 if (ep == NULL || *ep == '\0')
 356                         goto displaymlstopts;
 357
 358                                 /* don't like spaces, and need trailing ; */
 359                 len = strlen(ep);
 360                 if (strchr(ep, ' ') != NULL || ep[len - 1] != ';') {
 361  badmlstopt:
 362                         reply(501, "Invalid MLST options");
 363                         return;
 364                 }
 365                 ep[len - 1] = '\0';
 366                 while ((p = strsep(&ep, ";")) != NULL) {
 367                         if (*p == '\0')
 368                                 goto badmlstopt;
 369                         for (i = 0; i < FACTTABSIZE; i++)
 370                                 if (strcasecmp(p, facttab[i].name) == 0) {
 371                                         enabled[i] = 1;
 372                                         break;
 373                                 }
 374                 }
 375
 376  displaymlstopts:
 377                 for (i = 0; i < FACTTABSIZE; i++)
 378                         facttab[i].enabled = enabled[i];
 379                 cprintf(stdout, "200 MLST OPTS");
 380                 for (i = onedone = 0; i < FACTTABSIZE; i++) {
 381                         if (facttab[i].enabled) {
 382                                 cprintf(stdout, "%s%s;", onedone ? "" : " ",
 383                                     facttab[i].name);
 384                                 onedone++;
 385                         }
 386                 }
 387                 cprintf(stdout, "\r\n");
 388                 fflush(stdout);
 389                 return;
 390         }
 391
 392                         /* default cases */
 393         if (ep != NULL && *ep != '\0')
 394                 REASSIGN(c->options, ftpd_strdup(ep));
 395         if (c->options != NULL)
 396                 reply(200, "Options for %s are '%s'.", c->name,
 397                     c->options);
 398         else
 399                 reply(200, "No options defined for %s.", c->name);
 400 }
 401
 402 void
 403 pwd(void)
 404 {
 405         char path[MAXPATHLEN];
 406
 407         if (getcwd(path, sizeof(path) - 1) == NULL) {
 408                 if (chdir(cached_path) < 0) {
 409                         reply(550, "Can't get the current directory: %s.",
 410                             strerror(errno));
 411                         return;
 412                 }
 413                 (void)strlcpy(path, cached_path, MAXPATHLEN);
 414         }
 415         replydirname(path, "is the current directory.");
 416 }
 417
 418 void
 419 removedir(const char *name)
 420 {
 421         char *p = NULL;
 422
 423         if (rmdir(name) < 0) {
 424                 p = strerror(errno);
 425                 perror_reply(550, name);
 426         } else
 427                 ack("RMD");
 428         logxfer("rmdir", -1, name, NULL, NULL, p);
 429 }
 430
 431 char *
 432 renamefrom(const char *name)
 433 {
 434         struct stat st;
 435
 436         if (stat(name, &st) < 0) {
 437                 perror_reply(550, name);
 438                 return (NULL);
 439         }
 440         reply(350, "File exists, ready for destination name");
 441         return (ftpd_strdup(name));
 442 }
 443
 444 void
 445 renamecmd(const char *from, const char *to)
 446 {
 447         char *p = NULL;
 448
 449         if (rename(from, to) < 0) {
 450                 p = strerror(errno);
 451                 perror_reply(550, "rename");
 452         } else
 453                 ack("RNTO");
 454         logxfer("rename", -1, from, to, NULL, p);
 455 }
 456
 457 void
 458 sizecmd(const char *filename)
 459 {
 460         switch (type) {
 461         case TYPE_L:
 462         case TYPE_I:
 463             {
 464                 struct stat stbuf;
 465                 if (stat(filename, &stbuf) < 0 || !S_ISREG(stbuf.st_mode))
 466                         reply(550, "%s: not a plain file.", filename);
 467                 else
 468                         reply(213, ULLF, (ULLT)stbuf.st_size);
 469                 break;
 470             }
 471         case TYPE_A:
 472             {
 473                 FILE *fin;
 474                 int c;
 475                 off_t count;
 476                 struct stat stbuf;
 477                 fin = fopen(filename, "r");
 478                 if (fin == NULL) {
 479                         perror_reply(550, filename);
 480                         return;
 481                 }
 482                 if (fstat(fileno(fin), &stbuf) < 0 || !S_ISREG(stbuf.st_mode)) {
 483                         reply(550, "%s: not a plain file.", filename);
 484                         (void) fclose(fin);
 485                         return;
 486                 }
 487                 if (stbuf.st_size > 10240) {
 488                         reply(550, "%s: file too large for SIZE.", filename);
 489                         (void) fclose(fin);
 490                         return;
 491                 }
 492
 493                 count = 0;
 494                 while((c = getc(fin)) != EOF) {
 495                         if (c == '\n')  /* will get expanded to \r\n */
 496                                 count++;
 497                         count++;
 498                 }
 499                 (void) fclose(fin);
 500
 501                 reply(213, LLF, (LLT)count);
 502                 break;
 503             }
 504         default:
 505                 reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
 506         }
 507 }
 508
 509 void
 510 statfilecmd(const char *filename)
 511 {
 512         FILE *fin;
 513         int c;
 514         int atstart;
 515         char *argv[] = { INTERNAL_LS, "-lgA", "", NULL };
 516
 517         argv[2] = (char *)filename;
 518         fin = ftpd_popen(argv, "r", STDOUT_FILENO);
 519         reply(-211, "status of %s:", filename);
 520 /* XXX: use fgetln() or fparseln() here? */
 521         atstart = 1;
 522         while ((c = getc(fin)) != EOF) {
 523                 if (c == '\n') {
 524                         if (ferror(stdout)){
 525                                 perror_reply(421, "control connection");
 526                                 (void) ftpd_pclose(fin);
 527                                 dologout(1);
 528                                 /* NOTREACHED */
 529                         }
 530                         if (ferror(fin)) {
 531                                 perror_reply(551, filename);
 532                                 (void) ftpd_pclose(fin);
 533                                 return;
 534                         }
 535                         CPUTC('\r', stdout);
 536                 }
 537                 if (atstart && isdigit(c))
 538                         CPUTC(' ', stdout);
 539                 CPUTC(c, stdout);
 540                 atstart = (c == '\n');
 541         }
 542         (void) ftpd_pclose(fin);
 543         reply(211, "End of Status");
 544 }
 545
 546 /* -- */
 547
 548 static void
 549 ack(const char *s)
 550 {
 551
 552         reply(250, "%s command successful.", s);
 553 }
 554
 555 /*
 556  * Encode len bytes starting at clear using base64 encoding into encoded,
 557  * which should be at least ((len + 2) * 4 / 3 + 1) in size.
 558  * If nulterm is non-zero, terminate with \0 otherwise pad to 3 byte boundary
 559  * with `='.
 560  */
 561 static void
 562 base64_encode(const char *clear, size_t len, char *encoded, int nulterm)
 563 {
 564         static const char base64[] =
 565             "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 566         const char *c;
 567         char    *e, termchar;
 568         int      i;
 569
 570                         /* determine whether to pad with '=' or NUL terminate */
 571         termchar = nulterm ? '\0' : '=';
 572         c = clear;
 573         e = encoded;
 574                         /* convert all but last 2 bytes */
 575         for (i = len; i > 2; i -= 3, c += 3) {
 576                 *e++ = base64[(c[0] >> 2) & 0x3f];
 577                 *e++ = base64[((c[0] << 4) & 0x30) | ((c[1] >> 4) & 0x0f)];
 578                 *e++ = base64[((c[1] << 2) & 0x3c) | ((c[2] >> 6) & 0x03)];
 579                 *e++ = base64[(c[2]) & 0x3f];
 580         }
 581                         /* handle slop at end */
 582         if (i > 0) {
 583                 *e++ = base64[(c[0] >> 2) & 0x3f];
 584                 *e++ = base64[((c[0] << 4) & 0x30) |
 585                      (i > 1 ? ((c[1] >> 4) & 0x0f) : 0)];
 586                 *e++ = (i > 1) ? base64[(c[1] << 2) & 0x3c] : termchar;
 587                 *e++ = termchar;
 588         }
 589         *e = '\0';
 590 }
 591
 592 static void
 593 fact_modify(const char *fact, FILE *fd, factelem *fe)
 594 {
 595         struct tm *t;
 596
 597         t = gmtime(&(fe->stat->st_mtime));
 598         cprintf(fd, "%s=%04d%02d%02d%02d%02d%02d;", fact,
 599             TM_YEAR_BASE + t->tm_year,
 600             t->tm_mon+1, t->tm_mday,
 601             t->tm_hour, t->tm_min, t->tm_sec);
 602 }
 603
 604 static void
 605 fact_perm(const char *fact, FILE *fd, factelem *fe)
 606 {
 607         int             rok, wok, xok, pdirwok;
 608         struct stat     *pdir;
 609
 610         if (fe->stat->st_uid == geteuid()) {
 611                 rok = ((fe->stat->st_mode & S_IRUSR) != 0);
 612                 wok = ((fe->stat->st_mode & S_IWUSR) != 0);
 613                 xok = ((fe->stat->st_mode & S_IXUSR) != 0);
 614         } else if (matchgroup(fe->stat->st_gid)) {
 615                 rok = ((fe->stat->st_mode & S_IRGRP) != 0);
 616                 wok = ((fe->stat->st_mode & S_IWGRP) != 0);
 617                 xok = ((fe->stat->st_mode & S_IXGRP) != 0);
 618         } else {
 619                 rok = ((fe->stat->st_mode & S_IROTH) != 0);
 620                 wok = ((fe->stat->st_mode & S_IWOTH) != 0);
 621                 xok = ((fe->stat->st_mode & S_IXOTH) != 0);
 622         }
 623
 624         cprintf(fd, "%s=", fact);
 625
 626                         /*
 627                          * if parent info not provided, look it up, but
 628                          * only if the current class has modify rights,
 629                          * since we only need this info in such a case.
 630                          */
 631         pdir = fe->pdirstat;
 632         if (pdir == NULL && CURCLASS_FLAGS_ISSET(modify)) {
 633                 size_t          len;
 634                 char            realdir[MAXPATHLEN], *p;
 635                 struct stat     dir;
 636
 637                 len = strlcpy(realdir, fe->path, sizeof(realdir));
 638                 if (len < sizeof(realdir) - 4) {
 639                         if (S_ISDIR(fe->stat->st_mode))
 640                                 strlcat(realdir, "/..", sizeof(realdir));
 641                         else {
 642                                         /* if has a /, move back to it */
 643                                         /* otherwise use '..' */
 644                                 if ((p = strrchr(realdir, '/')) != NULL) {
 645                                         if (p == realdir)
 646                                                 p++;
 647                                         *p = '\0';
 648                                 } else
 649                                         strlcpy(realdir, "..", sizeof(realdir));
 650                         }
 651                         if (stat(realdir, &dir) == 0)
 652                                 pdir = &dir;
 653                 }
 654         }
 655         pdirwok = 0;
 656         if (pdir != NULL) {
 657                 if (pdir->st_uid == geteuid())
 658                         pdirwok = ((pdir->st_mode & S_IWUSR) != 0);
 659                 else if (matchgroup(pdir->st_gid))
 660                         pdirwok = ((pdir->st_mode & S_IWGRP) != 0);
 661                 else
 662                         pdirwok = ((pdir->st_mode & S_IWOTH) != 0);
 663         }
 664
 665                         /* 'a': can APPE to file */
 666         if (wok && CURCLASS_FLAGS_ISSET(upload) && S_ISREG(fe->stat->st_mode))
 667                 CPUTC('a', fd);
 668
 669                         /* 'c': can create or append to files in directory */
 670         if (wok && CURCLASS_FLAGS_ISSET(modify) && S_ISDIR(fe->stat->st_mode))
 671                 CPUTC('c', fd);
 672
 673                         /* 'd': can delete file or directory */
 674         if (pdirwok && CURCLASS_FLAGS_ISSET(modify)) {
 675                 int candel;
 676
 677                 candel = 1;
 678                 if (S_ISDIR(fe->stat->st_mode)) {
 679                         DIR *dirp;
 680                         struct dirent *dp;
 681
 682                         if ((dirp = opendir(fe->display)) == NULL)
 683                                 candel = 0;
 684                         else {
 685                                 while ((dp = readdir(dirp)) != NULL) {
 686                                         if (ISDOTDIR(dp->d_name) ||
 687                                             ISDOTDOTDIR(dp->d_name))
 688                                                 continue;
 689                                         candel = 0;
 690                                         break;
 691                                 }
 692                                 closedir(dirp);
 693                         }
 694                 }
 695                 if (candel)
 696                         CPUTC('d', fd);
 697         }
 698
 699                         /* 'e': can enter directory */
 700         if (xok && S_ISDIR(fe->stat->st_mode))
 701                 CPUTC('e', fd);
 702
 703                         /* 'f': can rename file or directory */
 704         if (pdirwok && CURCLASS_FLAGS_ISSET(modify))
 705                 CPUTC('f', fd);
 706
 707                         /* 'l': can list directory */
 708         if (rok && xok && S_ISDIR(fe->stat->st_mode))
 709                 CPUTC('l', fd);
 710
 711                         /* 'm': can create directory */
 712         if (wok && CURCLASS_FLAGS_ISSET(modify) && S_ISDIR(fe->stat->st_mode))
 713                 CPUTC('m', fd);
 714
 715                         /* 'p': can remove files in directory */
 716         if (wok && CURCLASS_FLAGS_ISSET(modify) && S_ISDIR(fe->stat->st_mode))
 717                 CPUTC('p', fd);
 718
 719                         /* 'r': can RETR file */
 720         if (rok && S_ISREG(fe->stat->st_mode))
 721                 CPUTC('r', fd);
 722
 723                         /* 'w': can STOR file */
 724         if (wok && CURCLASS_FLAGS_ISSET(upload) && S_ISREG(fe->stat->st_mode))
 725                 CPUTC('w', fd);
 726
 727         CPUTC(';', fd);
 728 }
 729
 730 static void
 731 fact_size(const char *fact, FILE *fd, factelem *fe)
 732 {
 733
 734         if (S_ISREG(fe->stat->st_mode))
 735                 cprintf(fd, "%s=" LLF ";", fact, (LLT)fe->stat->st_size);
 736 }
 737
 738 static void
 739 fact_type(const char *fact, FILE *fd, factelem *fe)
 740 {
 741
 742         cprintf(fd, "%s=", fact);
 743         switch (fe->stat->st_mode & S_IFMT) {
 744         case S_IFDIR:
 745                 if (fe->flags & FE_MLSD) {
 746                         if ((fe->flags & FE_ISCURDIR) || ISDOTDIR(fe->display))
 747                                 cprintf(fd, "cdir");
 748                         else if (ISDOTDOTDIR(fe->display))
 749                                 cprintf(fd, "pdir");
 750                         else
 751                                 cprintf(fd, "dir");
 752                 } else {
 753                         cprintf(fd, "dir");
 754                 }
 755                 break;
 756         case S_IFREG:
 757                 cprintf(fd, "file");
 758                 break;
 759         case S_IFIFO:
 760                 cprintf(fd, "OS.unix=fifo");
 761                 break;
 762         case S_IFLNK:           /* XXX: probably a NO-OP with stat() */
 763                 cprintf(fd, "OS.unix=slink");
 764                 break;
 765         case S_IFSOCK:
 766                 cprintf(fd, "OS.unix=socket");
 767                 break;
 768         case S_IFBLK:
 769         case S_IFCHR:
 770                 cprintf(fd, "OS.unix=%s-%d/%d",
 771                     S_ISBLK(fe->stat->st_mode) ? "blk" : "chr",
 772                     major(fe->stat->st_rdev), minor(fe->stat->st_rdev));
 773                 break;
 774         default:
 775                 cprintf(fd, "OS.unix=UNKNOWN(0%o)", fe->stat->st_mode & S_IFMT);
 776                 break;
 777         }
 778         CPUTC(';', fd);
 779 }
 780
 781 static void
 782 fact_unique(const char *fact, FILE *fd, factelem *fe)
 783 {
 784         char obuf[(sizeof(dev_t) + sizeof(ino_t) + 2) * 4 / 3 + 2];
 785         char tbuf[sizeof(dev_t) + sizeof(ino_t)];
 786
 787         memcpy(tbuf,
 788             (char *)&(fe->stat->st_dev), sizeof(dev_t));
 789         memcpy(tbuf + sizeof(dev_t),
 790             (char *)&(fe->stat->st_ino), sizeof(ino_t));
 791         base64_encode(tbuf, sizeof(dev_t) + sizeof(ino_t), obuf, 1);
 792         cprintf(fd, "%s=%s;", fact, obuf);
 793 }
 794
 795 static int
 796 matchgroup(gid_t gid)
 797 {
 798         int     i;
 799
 800         for (i = 0; i < gidcount; i++)
 801                 if (gid == gidlist[i])
 802                         return(1);
 803         return (0);
 804 }
 805
 806 static void
 807 mlsname(FILE *fp, factelem *fe)
 808 {
 809         char realfile[MAXPATHLEN];
 810         int i, userf = 0;
 811
 812         for (i = 0; i < FACTTABSIZE; i++) {
 813                 if (facttab[i].enabled)
 814                         (facttab[i].display)(facttab[i].name, fp, fe);
 815         }
 816         if ((fe->flags & FE_MLSD) &&
 817             !(fe->flags & FE_ISCURDIR) && !ISDOTDIR(fe->display)) {
 818                         /* if MLSD and not "." entry, display as-is */
 819                 userf = 0;
 820         } else {
 821                         /* if MLST, or MLSD and "." entry, realpath(3) it */
 822                 if (realpath(fe->display, realfile) != NULL)
 823                         userf = 1;
 824         }
 825         cprintf(fp, " %s\r\n", userf ? realfile : fe->display);
 826 }
 827
 828 static void
 829 replydirname(const char *name, const char *message)
 830 {
 831         char *p, *ep;
 832         char npath[MAXPATHLEN * 2];
 833
 834         p = npath;
 835         ep = &npath[sizeof(npath) - 1];
 836         while (*name) {
 837                 if (*name == '"') {
 838                         if (ep - p < 2)
 839                                 break;
 840                         *p++ = *name++;
 841                         *p++ = '"';
 842                 } else {
 843                         if (ep - p < 1)
 844                                 break;
 845                         *p++ = *name++;
 846                 }
 847         }
 848         *p = '\0';
 849         reply(257, "\"%s\" %s", npath, message);
 850 }
 851
 852 static void
 853 discover_path(last_path, new_path)
 854         char *last_path;
 855         const char *new_path;
 856 {
 857         char tp[MAXPATHLEN + 1] = "";
 858         char tq[MAXPATHLEN + 1] = "";
 859         char *cp;
 860         char *cq;
 861         int sz1, sz2;
 862         int nomorelink;
 863         struct stat st1, st2;
 864
 865         if (new_path[0] != '/') {
 866                 (void)strlcpy(tp, last_path, MAXPATHLEN);
 867                 (void)strlcat(tp, "/", MAXPATHLEN);
 868         }
 869         (void)strlcat(tp, new_path, MAXPATHLEN);
 870         (void)strlcat(tp, "/", MAXPATHLEN);
 871
 872         /*
 873          * resolve symlinks. A symlink may introduce another symlink, so we
 874          * loop trying to resolve symlinks until we don't find any of them.
 875          */
 876         do {
 877                 /* Collapse any // into / */
 878                 while ((cp = strstr(tp, "//")) != NULL)
 879                         (void)memmove(cp, cp + 1, strlen(cp) - 1 + 1);
 880
 881                 /* Collapse any /./ into / */
 882                 while ((cp = strstr(tp, "/./")) != NULL)
 883                         (void)memmove(cp, cp + 2, strlen(cp) - 2 + 1);
 884
 885                 cp = tp;
 886                 nomorelink = 1;
 887
 888                 while ((cp = strstr(++cp, "/")) != NULL) {
 889                         sz1 = (u_long)cp - (u_long)tp;
 890                         if (sz1 > MAXPATHLEN)
 891                                 goto bad;
 892                         *cp = 0;
 893                         sz2 = readlink(tp, tq, MAXPATHLEN);
 894                         *cp = '/';
 895
 896                         /* If this is not a symlink, move to next / */
 897                         if (sz2 <= 0)
 898                                 continue;
 899
 900                         /*
 901                          * We found a symlink, so we will have to
 902                          * do one more pass to check there is no
 903                          * more symlink in the path
 904                          */
 905                         nomorelink = 0;
 906
 907                         /*
 908                          * Null terminate the string and remove trailing /
 909                          */
 910                         tq[sz2] = 0;
 911                         sz2 = strlen(tq);
 912                         if (tq[sz2 - 1] == '/')
 913                                 tq[--sz2] = 0;
 914
 915                         /*
 916                          * Is this an absolute link or a relative link?
 917                          */
 918                         if (tq[0] == '/') {
 919                                 /* absolute link */
 920                                 if (strlen(cp) + sz2 > MAXPATHLEN)
 921                                         goto bad;
 922                                 memmove(tp + sz2, cp, strlen(cp) + 1);
 923                                 memcpy(tp, tq, sz2);
 924                         } else {
 925                                 /* relative link */
 926                                 for (cq = cp - 1; *cq != '/'; cq--);
 927                                 if (strlen(tp) - ((u_long)cq - (u_long)cp)
 928                                     + 1 + sz2 > MAXPATHLEN)
 929                                         goto bad;
 930                                 (void)memmove(cq + 1 + sz2,
 931                                     cp, strlen(cp) + 1);
 932                                 (void)memcpy(cq + 1, tq, sz2);
 933                         }
 934
 935                         /*
 936                          * start over, looking for new symlinks
 937                          */
 938                         break;
 939                 }
 940         } while (nomorelink == 0);
 941
 942         /* Collapse any /foo/../ into /foo/ */
 943         while ((cp = strstr(tp, "/../")) != NULL) {
 944                 /* ^/../foo/ becomes ^/foo/ */
 945                 if (cp == tp) {
 946                         (void)memmove(cp, cp + 3,
 947                             strlen(cp) - 3 + 1);
 948                 } else {
 949                         for (cq = cp - 1; *cq != '/'; cq--);
 950                         (void)memmove(cq, cp + 3,
 951                             strlen(cp) - 3 + 1);
 952                 }
 953         }
 954
 955         /* strip strailing / */
 956         if (strlen(tp) != 1)
 957                 tp[strlen(tp) - 1] = '\0';
 958
 959         /* check that the path is correct */
 960         stat(tp, &st1);
 961         stat(".", &st2);
 962         if ((st1.st_dev != st2.st_dev) || (st1.st_ino != st2.st_ino))
 963                 goto bad;
 964
 965         (void)strlcpy(last_path, tp, MAXPATHLEN);
 966         return;
 967
 968 bad:
 969         (void)strlcat(last_path, "/", MAXPATHLEN);
 970         (void)strlcat(last_path, new_path, MAXPATHLEN);
 971         return;
 972 }
 973