1 /* $NetBSD: conf.c,v 1.65 2023/09/29 14:49:03 shm 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.65 2023/09/29 14:49:03 shm 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 = calloc(sb.st_size + sizeof(pid_t), 1)) == 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 } 955
Indexes created Sat Sep 20 22:09:52 GMT 2025