libexec/ftpd/conf.c

   1 /*      $NetBSD: conf.c,v 1.64 2012/11/04 20:46:46 christos Exp $       */
   2
   3 /*-
   4  * Copyright (c) 1997-2009 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Simon Burge and 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  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 __RCSID("$NetBSD: conf.c,v 1.64 2012/11/04 20:46:46 christos Exp $");
  35 #endif /* not lint */
  36
  37 #include <sys/types.h>
  38 #include <sys/param.h>
  39 #include <sys/socket.h>
  40 #include <sys/stat.h>
  41
  42 #include <ctype.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <pwd.h>
  46 #include <glob.h>
  47 #include <netdb.h>
  48 #include <signal.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <stringlist.h>
  53 #include <syslog.h>
  54 #include <time.h>
  55 #include <unistd.h>
  56 #include <util.h>
  57
  58 #ifdef KERBEROS5
  59 #include <krb5/krb5.h>
  60 #endif
  61
  62 #include "extern.h"
  63 #include "pathnames.h"
  64
  65 static char *strend(const char *, char *);
  66 static int filetypematch(char *, int);
  67
  68
  69                 /* class defaults */
  70 #define DEFAULT_LIMIT           -1              /* unlimited connections */
  71 #define DEFAULT_MAXFILESIZE     -1              /* unlimited file size */
  72 #define DEFAULT_MAXTIMEOUT      7200            /* 2 hours */
  73 #define DEFAULT_TIMEOUT         900             /* 15 minutes */
  74 #define DEFAULT_UMASK           027             /* rw-r----- */
  75
  76 /*
  77  * Initialise curclass to an `empty' state
  78  */
  79 void
  80 init_curclass(void)
  81 {
  82         struct ftpconv  *conv, *cnext;
  83
  84         for (conv = curclass.conversions; conv != NULL; conv = cnext) {
  85                 REASSIGN(conv->suffix, NULL);
  86                 REASSIGN(conv->types, NULL);
  87                 REASSIGN(conv->disable, NULL);
  88                 REASSIGN(conv->command, NULL);
  89                 cnext = conv->next;
  90                 free(conv);
  91         }
  92
  93         memset((char *)&curclass.advertise, 0, sizeof(curclass.advertise));
  94         curclass.advertise.su_len = 0;          /* `not used' */
  95         REASSIGN(curclass.chroot, NULL);
  96         REASSIGN(curclass.classname, NULL);
  97         curclass.conversions =  NULL;
  98         REASSIGN(curclass.display, NULL);
  99         REASSIGN(curclass.homedir, NULL);
 100         curclass.limit =        DEFAULT_LIMIT;
 101         REASSIGN(curclass.limitfile, NULL);
 102         curclass.maxfilesize =  DEFAULT_MAXFILESIZE;
 103         curclass.maxrateget =   0;
 104         curclass.maxrateput =   0;
 105         curclass.maxtimeout =   DEFAULT_MAXTIMEOUT;
 106         REASSIGN(curclass.motd, ftpd_strdup(_NAME_FTPLOGINMESG));
 107         REASSIGN(curclass.notify, NULL);
 108         curclass.portmin =      0;
 109         curclass.portmax =      0;
 110         curclass.rateget =      0;
 111         curclass.rateput =      0;
 112         curclass.timeout =      DEFAULT_TIMEOUT;
 113             /* curclass.type is set elsewhere */
 114         curclass.umask =        DEFAULT_UMASK;
 115         curclass.mmapsize =     0;
 116         curclass.readsize =     0;
 117         curclass.writesize =    0;
 118         curclass.sendbufsize =  0;
 119         curclass.sendlowat =    0;
 120
 121         CURCLASS_FLAGS_SET(checkportcmd);
 122         CURCLASS_FLAGS_CLR(denyquick);
 123         CURCLASS_FLAGS_CLR(hidesymlinks);
 124         CURCLASS_FLAGS_SET(modify);
 125         CURCLASS_FLAGS_SET(passive);
 126         CURCLASS_FLAGS_CLR(private);
 127         CURCLASS_FLAGS_CLR(sanenames);
 128         CURCLASS_FLAGS_SET(upload);
 129 }
 130
 131 /*
 132  * Parse the configuration file, looking for the named class, and
 133  * define curclass to contain the appropriate settings.
 134  */
 135 void
 136 parse_conf(const char *findclass)
 137 {
 138         FILE            *f;
 139         char            *buf, *p;
 140         size_t           len;
 141         LLT              llval;
 142         int              none, match;
 143         char            *endp, errbuf[100];
 144         char            *class, *word, *arg, *template;
 145         const char      *infile;
 146         size_t           line;
 147         struct ftpconv  *conv, *cnext;
 148
 149         init_curclass();
 150         REASSIGN(curclass.classname, ftpd_strdup(findclass));
 151                         /* set more guest defaults */
 152         if (strcasecmp(findclass, "guest") == 0) {
 153                 CURCLASS_FLAGS_CLR(modify);
 154                 curclass.umask = 0707;
 155         }
 156
 157         infile = conffilename(_NAME_FTPDCONF);
 158         if ((f = fopen(infile, "r")) == NULL)
 159                 return;
 160
 161         line = 0;
 162         template = NULL;
 163         for (;
 164             (buf = fparseln(f, &len, &line, NULL, FPARSELN_UNESCCOMM |
 165                             FPARSELN_UNESCCONT | FPARSELN_UNESCESC)) != NULL;
 166             free(buf)) {
 167                 none = match = 0;
 168                 p = buf;
 169                 if (len < 1)
 170                         continue;
 171                 if (p[len - 1] == '\n')
 172                         p[--len] = '\0';
 173                 if (EMPTYSTR(p))
 174                         continue;
 175
 176                 NEXTWORD(p, word);
 177                 NEXTWORD(p, class);
 178                 NEXTWORD(p, arg);
 179                 if (EMPTYSTR(word) || EMPTYSTR(class))
 180                         continue;
 181                 if (strcasecmp(class, "none") == 0)
 182                         none = 1;
 183                 if (! (strcasecmp(class, findclass) == 0 ||
 184                        (template != NULL && strcasecmp(class, template) == 0) ||
 185                        none ||
 186                        strcasecmp(class, "all") == 0) )
 187                         continue;
 188
 189 #define CONF_FLAG(Field)                                                \
 190         do {                                                            \
 191                 if (none ||                                             \
 192                     (!EMPTYSTR(arg) && strcasecmp(arg, "off") == 0))    \
 193                         CURCLASS_FLAGS_CLR(Field);                      \
 194                 else                                                    \
 195                         CURCLASS_FLAGS_SET(Field);                      \
 196         } while (0)
 197
 198 #define CONF_STRING(Field)                                              \
 199         do {                                                            \
 200                 if (none || EMPTYSTR(arg))                              \
 201                         arg = NULL;                                     \
 202                 else                                                    \
 203                         arg = ftpd_strdup(arg);                         \
 204                 REASSIGN(curclass.Field, arg);                          \
 205         } while (0)
 206
 207 #define CONF_LL(Field,Arg,Min,Max)                                      \
 208         do {                                                            \
 209                 if (none || EMPTYSTR(Arg))                              \
 210                         goto nextline;                                  \
 211                 llval = strsuftollx(#Field, Arg, Min, Max,              \
 212                     errbuf, sizeof(errbuf));                            \
 213                 if (errbuf[0]) {                                        \
 214                         syslog(LOG_WARNING, "%s line %d: %s",           \
 215                             infile, (int)line, errbuf);                 \
 216                         goto nextline;                                  \
 217                 }                                                       \
 218                 curclass.Field = llval;                                 \
 219         } while(0)
 220
 221                 if (0)  {
 222                         /* no-op */
 223
 224                 } else if ((strcasecmp(word, "advertise") == 0)
 225                         || (strcasecmp(word, "advertize") == 0)) {
 226                         struct addrinfo hints, *res;
 227                         int             error;
 228
 229                         memset((char *)&curclass.advertise, 0,
 230                             sizeof(curclass.advertise));
 231                         curclass.advertise.su_len = 0;
 232                         if (none || EMPTYSTR(arg))
 233                                 continue;
 234                         res = NULL;
 235                         memset(&hints, 0, sizeof(hints));
 236                                         /*
 237                                          * only get addresses of the family
 238                                          * that we're listening on
 239                                          */
 240                         hints.ai_family = ctrl_addr.su_family;
 241                         hints.ai_socktype = SOCK_STREAM;
 242                         error = getaddrinfo(arg, "0", &hints, &res);
 243                         if (error) {
 244                                 syslog(LOG_WARNING, "%s line %d: %s",
 245                                     infile, (int)line, gai_strerror(error));
 246  advertiseparsefail:
 247                                 if (res)
 248                                         freeaddrinfo(res);
 249                                 continue;
 250                         }
 251                         if (res->ai_next) {
 252                                 syslog(LOG_WARNING,
 253     "%s line %d: multiple addresses returned for `%s'; please be more specific",
 254                                     infile, (int)line, arg);
 255                                 goto advertiseparsefail;
 256                         }
 257                         if (sizeof(curclass.advertise) < res->ai_addrlen || (
 258 #ifdef INET6
 259                             res->ai_family != AF_INET6 &&
 260 #endif
 261                             res->ai_family != AF_INET)) {
 262                                 syslog(LOG_WARNING,
 263     "%s line %d: unsupported protocol %d for `%s'",
 264                                     infile, (int)line, res->ai_family, arg);
 265                                 goto advertiseparsefail;
 266                         }
 267                         memcpy(&curclass.advertise, res->ai_addr,
 268                             res->ai_addrlen);
 269                         curclass.advertise.su_len = res->ai_addrlen;
 270                         freeaddrinfo(res);
 271
 272                 } else if (strcasecmp(word, "checkportcmd") == 0) {
 273                         CONF_FLAG(checkportcmd);
 274
 275                 } else if (strcasecmp(word, "chroot") == 0) {
 276                         CONF_STRING(chroot);
 277
 278                 } else if (strcasecmp(word, "classtype") == 0) {
 279                         if (!none && !EMPTYSTR(arg)) {
 280                                 if (strcasecmp(arg, "GUEST") == 0)
 281                                         curclass.type = CLASS_GUEST;
 282                                 else if (strcasecmp(arg, "CHROOT") == 0)
 283                                         curclass.type = CLASS_CHROOT;
 284                                 else if (strcasecmp(arg, "REAL") == 0)
 285                                         curclass.type = CLASS_REAL;
 286                                 else {
 287                                         syslog(LOG_WARNING,
 288                                     "%s line %d: unknown class type `%s'",
 289                                             infile, (int)line, arg);
 290                                         continue;
 291                                 }
 292                         }
 293
 294                 } else if (strcasecmp(word, "conversion") == 0) {
 295                         char *suffix, *types, *disable, *convcmd;
 296
 297                         if (EMPTYSTR(arg)) {
 298                                 syslog(LOG_WARNING,
 299                                     "%s line %d: %s requires a suffix",
 300                                     infile, (int)line, word);
 301                                 continue;       /* need a suffix */
 302                         }
 303                         NEXTWORD(p, types);
 304                         NEXTWORD(p, disable);
 305                         convcmd = p;
 306                         if (convcmd)
 307                                 convcmd += strspn(convcmd, " \t");
 308                         suffix = ftpd_strdup(arg);
 309                         if (none || EMPTYSTR(types) ||
 310                             EMPTYSTR(disable) || EMPTYSTR(convcmd)) {
 311                                 types = NULL;
 312                                 disable = NULL;
 313                                 convcmd = NULL;
 314                         } else {
 315                                 types = ftpd_strdup(types);
 316                                 disable = ftpd_strdup(disable);
 317                                 convcmd = ftpd_strdup(convcmd);
 318                         }
 319                         for (conv = curclass.conversions; conv != NULL;
 320                             conv = conv->next) {
 321                                 if (strcmp(conv->suffix, suffix) == 0)
 322                                         break;
 323                         }
 324                         if (conv == NULL) {
 325                                 conv = (struct ftpconv *)
 326                                     calloc(1, sizeof(struct ftpconv));
 327                                 if (conv == NULL) {
 328                                         syslog(LOG_WARNING, "can't malloc");
 329                                         continue;
 330                                 }
 331                                 conv->next = NULL;
 332                                 for (cnext = curclass.conversions;
 333                                     cnext != NULL; cnext = cnext->next)
 334                                         if (cnext->next == NULL)
 335                                                 break;
 336                                 if (cnext != NULL)
 337                                         cnext->next = conv;
 338                                 else
 339                                         curclass.conversions = conv;
 340                         }
 341                         REASSIGN(conv->suffix, suffix);
 342                         REASSIGN(conv->types, types);
 343                         REASSIGN(conv->disable, disable);
 344                         REASSIGN(conv->command, convcmd);
 345
 346                 } else if (strcasecmp(word, "denyquick") == 0) {
 347                         CONF_FLAG(denyquick);
 348
 349                 } else if (strcasecmp(word, "display") == 0) {
 350                         CONF_STRING(display);
 351
 352                 } else if (strcasecmp(word, "hidesymlinks") == 0) {
 353                         CONF_FLAG(hidesymlinks);
 354
 355                 } else if (strcasecmp(word, "homedir") == 0) {
 356                         CONF_STRING(homedir);
 357
 358                 } else if (strcasecmp(word, "limit") == 0) {
 359                         curclass.limit = DEFAULT_LIMIT;
 360                         REASSIGN(curclass.limitfile, NULL);
 361                         CONF_LL(limit, arg, -1, LLTMAX);
 362                         REASSIGN(curclass.limitfile,
 363                             EMPTYSTR(p) ? NULL : ftpd_strdup(p));
 364
 365                 } else if (strcasecmp(word, "maxfilesize") == 0) {
 366                         curclass.maxfilesize = DEFAULT_MAXFILESIZE;
 367                         CONF_LL(maxfilesize, arg, -1, LLTMAX);
 368
 369                 } else if (strcasecmp(word, "maxtimeout") == 0) {
 370                         curclass.maxtimeout = DEFAULT_MAXTIMEOUT;
 371                         CONF_LL(maxtimeout, arg,
 372                             MIN(30, curclass.timeout), LLTMAX);
 373
 374                 } else if (strcasecmp(word, "mmapsize") == 0) {
 375                         curclass.mmapsize = 0;
 376                         CONF_LL(mmapsize, arg, 0, SSIZE_MAX);
 377
 378                 } else if (strcasecmp(word, "readsize") == 0) {
 379                         curclass.readsize = 0;
 380                         CONF_LL(readsize, arg, 0, SSIZE_MAX);
 381
 382                 } else if (strcasecmp(word, "writesize") == 0) {
 383                         curclass.writesize = 0;
 384                         CONF_LL(writesize, arg, 0, SSIZE_MAX);
 385
 386                 } else if (strcasecmp(word, "recvbufsize") == 0) {
 387                         curclass.recvbufsize = 0;
 388                         CONF_LL(recvbufsize, arg, 0, INT_MAX);
 389
 390                 } else if (strcasecmp(word, "sendbufsize") == 0) {
 391                         curclass.sendbufsize = 0;
 392                         CONF_LL(sendbufsize, arg, 0, INT_MAX);
 393
 394                 } else if (strcasecmp(word, "sendlowat") == 0) {
 395                         curclass.sendlowat = 0;
 396                         CONF_LL(sendlowat, arg, 0, INT_MAX);
 397
 398                 } else if (strcasecmp(word, "modify") == 0) {
 399                         CONF_FLAG(modify);
 400
 401                 } else if (strcasecmp(word, "motd") == 0) {
 402                         CONF_STRING(motd);
 403
 404                 } else if (strcasecmp(word, "notify") == 0) {
 405                         CONF_STRING(notify);
 406
 407                 } else if (strcasecmp(word, "passive") == 0) {
 408                         CONF_FLAG(passive);
 409
 410                 } else if (strcasecmp(word, "portrange") == 0) {
 411                         long minport, maxport;
 412
 413                         curclass.portmin = 0;
 414                         curclass.portmax = 0;
 415                         if (none || EMPTYSTR(arg))
 416                                 continue;
 417                         if (EMPTYSTR(p)) {
 418                                 syslog(LOG_WARNING,
 419                                    "%s line %d: missing maxport argument",
 420                                    infile, (int)line);
 421                                 continue;
 422                         }
 423                         minport = strsuftollx("minport", arg, IPPORT_RESERVED,
 424                             IPPORT_ANONMAX, errbuf, sizeof(errbuf));
 425                         if (errbuf[0]) {
 426                                 syslog(LOG_WARNING, "%s line %d: %s",
 427                                     infile, (int)line, errbuf);
 428                                 continue;
 429                         }
 430                         maxport = strsuftollx("maxport", p, IPPORT_RESERVED,
 431                             IPPORT_ANONMAX, errbuf, sizeof(errbuf));
 432                         if (errbuf[0]) {
 433                                 syslog(LOG_WARNING, "%s line %d: %s",
 434                                     infile, (int)line, errbuf);
 435                                 continue;
 436                         }
 437                         if (minport >= maxport) {
 438                                 syslog(LOG_WARNING,
 439                                     "%s line %d: minport %ld >= maxport %ld",
 440                                     infile, (int)line, minport, maxport);
 441                                 continue;
 442                         }
 443                         curclass.portmin = (int)minport;
 444                         curclass.portmax = (int)maxport;
 445
 446                 } else if (strcasecmp(word, "private") == 0) {
 447                         CONF_FLAG(private);
 448
 449                 } else if (strcasecmp(word, "rateget") == 0) {
 450                         curclass.maxrateget = curclass.rateget = 0;
 451                         CONF_LL(rateget, arg, 0, LLTMAX);
 452                         curclass.maxrateget = curclass.rateget;
 453
 454                 } else if (strcasecmp(word, "rateput") == 0) {
 455                         curclass.maxrateput = curclass.rateput = 0;
 456                         CONF_LL(rateput, arg, 0, LLTMAX);
 457                         curclass.maxrateput = curclass.rateput;
 458
 459                 } else if (strcasecmp(word, "sanenames") == 0) {
 460                         CONF_FLAG(sanenames);
 461
 462                 } else if (strcasecmp(word, "timeout") == 0) {
 463                         curclass.timeout = DEFAULT_TIMEOUT;
 464                         CONF_LL(timeout, arg, 30, curclass.maxtimeout);
 465
 466                 } else if (strcasecmp(word, "template") == 0) {
 467                         if (none)
 468                                 continue;
 469                         REASSIGN(template, EMPTYSTR(arg) ? NULL : ftpd_strdup(arg));
 470
 471                 } else if (strcasecmp(word, "umask") == 0) {
 472                         unsigned long fumask;
 473
 474                         curclass.umask = DEFAULT_UMASK;
 475                         if (none || EMPTYSTR(arg))
 476                                 continue;
 477                         errno = 0;
 478                         endp = NULL;
 479                         fumask = strtoul(arg, &endp, 8);
 480                         if (errno || *arg == '\0' || *endp != '\0' ||
 481                             fumask > 0777) {
 482                                 syslog(LOG_WARNING,
 483                                     "%s line %d: invalid umask %s",
 484                                     infile, (int)line, arg);
 485                                 continue;
 486                         }
 487                         curclass.umask = (mode_t)fumask;
 488
 489                 } else if (strcasecmp(word, "upload") == 0) {
 490                         CONF_FLAG(upload);
 491                         if (! CURCLASS_FLAGS_ISSET(upload))
 492                                 CURCLASS_FLAGS_CLR(modify);
 493
 494                 } else {
 495                         syslog(LOG_WARNING,
 496                             "%s line %d: unknown directive '%s'",
 497                             infile, (int)line, word);
 498                         continue;
 499                 }
 500  nextline:
 501                 ;
 502         }
 503         REASSIGN(template, NULL);
 504         fclose(f);
 505 }
 506
 507 /*
 508  * Show file listed in curclass.display first time in, and list all the
 509  * files named in curclass.notify in the current directory.
 510  * Send back responses with the prefix `code' + "-".
 511  * If code == -1, flush the internal cache of directory names and return.
 512  */
 513 void
 514 show_chdir_messages(int code)
 515 {
 516         static StringList *slist = NULL;
 517
 518         struct stat st;
 519         struct tm *t;
 520         glob_t   gl;
 521         time_t   now, then;
 522         int      age;
 523         char     curwd[MAXPATHLEN];
 524         char    *cp, **rlist;
 525
 526         if (code == -1) {
 527                 if (slist != NULL)
 528                         sl_free(slist, 1);
 529                 slist = NULL;
 530                 return;
 531         }
 532
 533         if (quietmessages)
 534                 return;
 535
 536                 /* Setup list for directory cache */
 537         if (slist == NULL)
 538                 slist = sl_init();
 539         if (slist == NULL) {
 540                 syslog(LOG_WARNING, "can't allocate memory for stringlist");
 541                 return;
 542         }
 543
 544                 /* Check if this directory has already been visited */
 545         if (getcwd(curwd, sizeof(curwd) - 1) == NULL) {
 546                 syslog(LOG_WARNING, "can't getcwd: %s", strerror(errno));
 547                 return;
 548         }
 549         if (sl_find(slist, curwd) != NULL)
 550                 return;
 551
 552         cp = ftpd_strdup(curwd);
 553         if (sl_add(slist, cp) == -1)
 554                 syslog(LOG_WARNING, "can't add `%s' to stringlist", cp);
 555
 556                 /* First check for a display file */
 557         (void)display_file(curclass.display, code);
 558
 559                 /* Now see if there are any notify files */
 560         if (EMPTYSTR(curclass.notify))
 561                 return;
 562
 563         memset(&gl, 0, sizeof(gl));
 564         if (glob(curclass.notify, GLOB_BRACE|GLOB_LIMIT, NULL, &gl) != 0
 565             || gl.gl_matchc == 0) {
 566                 globfree(&gl);
 567                 return;
 568         }
 569         time(&now);
 570         for (rlist = gl.gl_pathv; *rlist != NULL; rlist++) {
 571                 if (stat(*rlist, &st) != 0)
 572                         continue;
 573                 if (!S_ISREG(st.st_mode))
 574                         continue;
 575                 then = st.st_mtime;
 576                 if (code != 0) {
 577                         reply(-code, "%s", "");
 578                         code = 0;
 579                 }
 580                 reply(-code, "Please read the file %s", *rlist);
 581                 t = localtime(&now);
 582                 age = 365 * t->tm_year + t->tm_yday;
 583                 t = localtime(&then);
 584                 age -= 365 * t->tm_year + t->tm_yday;
 585                 reply(-code, "  it was last modified on %.24s - %d day%s ago",
 586                     ctime(&then), age, PLURAL(age));
 587         }
 588         globfree(&gl);
 589 }
 590
 591 int
 592 display_file(const char *file, int code)
 593 {
 594         FILE   *f;
 595         char   *buf, *p;
 596         char    curwd[MAXPATHLEN];
 597         size_t  len;
 598         off_t   lastnum;
 599         time_t  now;
 600
 601         lastnum = 0;
 602         if (quietmessages)
 603                 return (0);
 604
 605         if (EMPTYSTR(file))
 606                 return(0);
 607         if ((f = fopen(file, "r")) == NULL)
 608                 return (0);
 609         reply(-code, "%s", "");
 610
 611         for (;
 612             (buf = fparseln(f, &len, NULL, "\0\0\0", 0)) != NULL; free(buf)) {
 613                 if (len > 0)
 614                         if (buf[len - 1] == '\n')
 615                                 buf[--len] = '\0';
 616                 cprintf(stdout, "    ");
 617
 618                 for (p = buf; *p; p++) {
 619                         if (*p == '%') {
 620                                 p++;
 621                                 switch (*p) {
 622
 623                                 case 'c':
 624                                         cprintf(stdout, "%s",
 625                                             curclass.classname ?
 626                                             curclass.classname : "<unknown>");
 627                                         break;
 628
 629                                 case 'C':
 630                                         if (getcwd(curwd, sizeof(curwd)-1)
 631                                             == NULL){
 632                                                 syslog(LOG_WARNING,
 633                                                     "can't getcwd: %s",
 634                                                     strerror(errno));
 635                                                 continue;
 636                                         }
 637                                         cprintf(stdout, "%s", curwd);
 638                                         break;
 639
 640                                 case 'E':
 641                                         if (! EMPTYSTR(emailaddr))
 642                                                 cprintf(stdout, "%s",
 643                                                     emailaddr);
 644                                         break;
 645
 646                                 case 'L':
 647                                         cprintf(stdout, "%s", hostname);
 648                                         break;
 649
 650                                 case 'M':
 651                                         if (curclass.limit == -1) {
 652                                                 cprintf(stdout, "unlimited");
 653                                                 lastnum = 0;
 654                                         } else {
 655                                                 cprintf(stdout, LLF,
 656                                                     (LLT)curclass.limit);
 657                                                 lastnum = curclass.limit;
 658                                         }
 659                                         break;
 660
 661                                 case 'N':
 662                                         cprintf(stdout, "%d", connections);
 663                                         lastnum = connections;
 664                                         break;
 665
 666                                 case 'R':
 667                                         cprintf(stdout, "%s", remotehost);
 668                                         break;
 669
 670                                 case 's':
 671                                         if (lastnum != 1)
 672                                                 cprintf(stdout, "s");
 673                                         break;
 674
 675                                 case 'S':
 676                                         if (lastnum != 1)
 677                                                 cprintf(stdout, "S");
 678                                         break;
 679
 680                                 case 'T':
 681                                         now = time(NULL);
 682                                         cprintf(stdout, "%.24s", ctime(&now));
 683                                         break;
 684
 685                                 case 'U':
 686                                         cprintf(stdout, "%s",
 687                                             pw ? pw->pw_name : "<unknown>");
 688                                         break;
 689
 690                                 case '%':
 691                                         CPUTC('%', stdout);
 692                                         break;
 693
 694                                 }
 695                         } else
 696                                 CPUTC(*p, stdout);
 697                 }
 698                 cprintf(stdout, "\r\n");
 699         }
 700
 701         (void)fflush(stdout);
 702         (void)fclose(f);
 703         return (1);
 704 }
 705
 706 /*
 707  * Parse src, expanding '%' escapes, into dst (which must be at least
 708  * MAXPATHLEN long).
 709  */
 710 void
 711 format_path(char *dst, const char *src)
 712 {
 713         size_t len;
 714         const char *p;
 715
 716         dst[0] = '\0';
 717         len = 0;
 718         if (src == NULL)
 719                 return;
 720         for (p = src; *p && len < MAXPATHLEN; p++) {
 721                 if (*p == '%') {
 722                         p++;
 723                         switch (*p) {
 724
 725                         case 'c':
 726                                 len += strlcpy(dst + len, curclass.classname,
 727                                     MAXPATHLEN - len);
 728                                 break;
 729
 730                         case 'd':
 731                                 len += strlcpy(dst + len, pw->pw_dir,
 732                                     MAXPATHLEN - len);
 733                                 break;
 734
 735                         case 'u':
 736                                 len += strlcpy(dst + len, pw->pw_name,
 737                                     MAXPATHLEN - len);
 738                                 break;
 739
 740                         case '%':
 741                                 dst[len++] = '%';
 742                                 break;
 743
 744                         }
 745                 } else
 746                         dst[len++] = *p;
 747         }
 748         if (len < MAXPATHLEN)
 749                 dst[len] = '\0';
 750         dst[MAXPATHLEN - 1] = '\0';
 751 }
 752
 753 /*
 754  * Find s2 at the end of s1.  If found, return a string up to (but
 755  * not including) s2, otherwise returns NULL.
 756  */
 757 static char *
 758 strend(const char *s1, char *s2)
 759 {
 760         static  char buf[MAXPATHLEN];
 761
 762         char    *start;
 763         size_t  l1, l2;
 764
 765         l1 = strlen(s1);
 766         l2 = strlen(s2);
 767
 768         if (l2 >= l1 || l1 >= sizeof(buf))
 769                 return(NULL);
 770
 771         strlcpy(buf, s1, sizeof(buf));
 772         start = buf + (l1 - l2);
 773
 774         if (strcmp(start, s2) == 0) {
 775                 *start = '\0';
 776                 return(buf);
 777         } else
 778                 return(NULL);
 779 }
 780
 781 static int
 782 filetypematch(char *types, int mode)
 783 {
 784         for ( ; types[0] != '\0'; types++)
 785                 switch (*types) {
 786                   case 'd':
 787                         if (S_ISDIR(mode))
 788                                 return(1);
 789                         break;
 790                   case 'f':
 791                         if (S_ISREG(mode))
 792                                 return(1);
 793                         break;
 794                 }
 795         return(0);
 796 }
 797
 798 /*
 799  * Look for a conversion.  If we succeed, return a pointer to the
 800  * command to execute for the conversion.
 801  *
 802  * The command is stored in a static array so there's no memory
 803  * leak problems, and not too much to change in ftpd.c.  This
 804  * routine doesn't need to be re-entrant unless we start using a
 805  * multi-threaded ftpd, and that's not likely for a while...
 806  */
 807 const char **
 808 do_conversion(const char *fname)
 809 {
 810         struct ftpconv  *cp;
 811         struct stat      st;
 812         int              o_errno;
 813         char            *base = NULL;
 814         char            *cmd, *p, *lp;
 815         char           **argv;
 816         StringList      *sl;
 817
 818         o_errno = errno;
 819         sl = NULL;
 820         cmd = NULL;
 821         for (cp = curclass.conversions; cp != NULL; cp = cp->next) {
 822                 if (cp->suffix == NULL) {
 823                         syslog(LOG_WARNING,
 824                             "cp->suffix==NULL in conv list; SHOULDN'T HAPPEN!");
 825                         continue;
 826                 }
 827                 if ((base = strend(fname, cp->suffix)) == NULL)
 828                         continue;
 829                 if (cp->types == NULL || cp->disable == NULL ||
 830                     cp->command == NULL)
 831                         continue;
 832                                         /* Is it enabled? */
 833                 if (strcmp(cp->disable, ".") != 0 &&
 834                     stat(cp->disable, &st) == 0)
 835                                 continue;
 836                                         /* Does the base exist? */
 837                 if (stat(base, &st) < 0)
 838                         continue;
 839                                         /* Is the file type ok */
 840                 if (!filetypematch(cp->types, st.st_mode))
 841                         continue;
 842                 break;                  /* "We have a winner!" */
 843         }
 844
 845         /* If we got through the list, no conversion */
 846         if (cp == NULL)
 847                 goto cleanup_do_conv;
 848
 849         /* Split up command into an argv */
 850         if ((sl = sl_init()) == NULL)
 851                 goto cleanup_do_conv;
 852         cmd = ftpd_strdup(cp->command);
 853         p = cmd;
 854         while (p) {
 855                 NEXTWORD(p, lp);
 856                 if (strcmp(lp, "%s") == 0)
 857                         lp = base;
 858                 if (sl_add(sl, ftpd_strdup(lp)) == -1)
 859                         goto cleanup_do_conv;
 860         }
 861
 862         if (sl_add(sl, NULL) == -1)
 863                 goto cleanup_do_conv;
 864         argv = sl->sl_str;
 865         free(cmd);
 866         free(sl);
 867         return (void *)(intptr_t)argv;
 868
 869  cleanup_do_conv:
 870         if (sl)
 871                 sl_free(sl, 1);
 872         free(cmd);
 873         errno = o_errno;
 874         return(NULL);
 875 }
 876
 877 /*
 878  * Count the number of current connections, reading from
 879  *      /var/run/ftpd.pids-<class>
 880  * Does a kill -0 on each pid in that file, and only counts
 881  * processes that exist (or frees the slot if it doesn't).
 882  * Adds getpid() to the first free slot. Truncates the file
 883  * if possible.
 884  */
 885 void
 886 count_users(void)
 887 {
 888         char    fn[MAXPATHLEN];
 889         int     fd;
 890         size_t  i, last, count;
 891         ssize_t scount;
 892         pid_t  *pids, mypid;
 893         struct stat sb;
 894         struct flock fl;
 895
 896         (void)strlcpy(fn, _PATH_CLASSPIDS, sizeof(fn));
 897         (void)strlcat(fn, curclass.classname, sizeof(fn));
 898         pids = NULL;
 899         connections = 1;
 900         fl.l_start = 0;
 901         fl.l_len = 0;
 902         fl.l_pid = 0;
 903         fl.l_type = F_WRLCK;
 904         fl.l_whence = SEEK_SET;
 905
 906         if ((fd = open(fn, O_RDWR | O_CREAT, 0600)) == -1)
 907                 return;
 908         if (fcntl(fd, F_SETLK, &fl) == -1)
 909                 goto cleanup_count;
 910         if (fstat(fd, &sb) == -1)
 911                 goto cleanup_count;
 912         if ((pids = malloc(sb.st_size + sizeof(pid_t))) == NULL)
 913                 goto cleanup_count;
 914 /* XXX: implement a better read loop */
 915         scount = read(fd, pids, sb.st_size);
 916         if (scount == -1 || scount != sb.st_size || scount < 0)
 917                 goto cleanup_count;
 918         count = (size_t)scount / sizeof(pid_t);
 919         mypid = getpid();
 920         last = 0;
 921         for (i = 0; i < count; i++) {
 922                 if (pids[i] == 0)
 923                         continue;
 924                 if (kill(pids[i], 0) == -1 && errno != EPERM) {
 925                         if (mypid != 0) {
 926                                 pids[i] = mypid;
 927                                 mypid = 0;
 928                                 last = i;
 929                         }
 930                 } else {
 931                         connections++;
 932                         last = i;
 933                 }
 934         }
 935         if (mypid != 0) {
 936                 if (pids[last] != 0)
 937                         last++;
 938                 pids[last] = mypid;
 939         }
 940         count = (last + 1) * sizeof(pid_t);
 941         if (lseek(fd, 0, SEEK_SET) == -1)
 942                 goto cleanup_count;
 943 /* XXX: implement a better write loop */
 944         scount = write(fd, pids, count);
 945         if (scount == -1 || (size_t)scount != count)
 946                 goto cleanup_count;
 947         (void)ftruncate(fd, count);
 948
 949  cleanup_count:
 950         fl.l_type = F_UNLCK;
 951         (void)fcntl(fd, F_SETLK, &fl);
 952         close(fd);
 953         REASSIGN(pids, NULL);
 954 }