1 /* $OpenBSD: ftpd.c,v 1.223 2016/09/03 15:00:48 jca Exp $ */ 2 /* $NetBSD: ftpd.c,v 1.15 1995/06/03 22:46:47 mycroft Exp $ */ 3 4 /* 5 * Copyright (C) 1997 and 1998 WIDE Project. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the project nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 */ 32 33 /* 34 * Copyright (c) 1985, 1988, 1990, 1992, 1993, 1994 35 * The Regents of the University of California. All rights reserved. 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 3. Neither the name of the University nor the names of its contributors 46 * may be used to endorse or promote products derived from this software 47 * without specific prior written permission. 48 * 49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 59 * SUCH DAMAGE. 60 */ 61 62 /* 63 * FTP server. 64 */ 65 #include <sys/stat.h> 66 #include <sys/ioctl.h> 67 #include <sys/socket.h> 68 #include <sys/wait.h> 69 #include <sys/mman.h> 70 71 #include <netinet/in.h> 72 #include <netinet/ip.h> 73 #include <netinet/tcp.h> 74 75 #define FTP_NAMES 76 #include <arpa/ftp.h> 77 #include <arpa/inet.h> 78 #include <arpa/telnet.h> 79 80 #include <bsd_auth.h> 81 #include <ctype.h> 82 #include <dirent.h> 83 #include <errno.h> 84 #include <fcntl.h> 85 #include <glob.h> 86 #include <limits.h> 87 #include <login_cap.h> 88 #include <netdb.h> 89 #include <pwd.h> 90 #include <signal.h> 91 #include <stdarg.h> 92 #include <stdio.h> 93 #include <stdlib.h> 94 #include <string.h> 95 #include <syslog.h> 96 #include <time.h> 97 #include <vis.h> 98 #include <unistd.h> 99 #include <utmp.h> 100 #include <poll.h> 101 102 #include "pathnames.h" 103 #include "monitor.h" 104 #include "extern.h" 105 106 extern off_t restart_point; 107 extern char cbuf[]; 108 109 union sockunion ctrl_addr; 110 union sockunion data_source; 111 union sockunion data_dest; 112 union sockunion his_addr; 113 union sockunion pasv_addr; 114 115 sigset_t allsigs; 116 117 int daemon_mode = 0; 118 int data; 119 int logged_in; 120 struct passwd *pw; 121 int debug = 0; 122 int timeout = 900; /* timeout after 15 minutes of inactivity */ 123 int maxtimeout = 7200;/* don't allow idle time to be set beyond 2 hours */ 124 int logging; 125 int anon_ok = 1; 126 int anon_only = 0; 127 unsigned int minuid = 1000; 128 int multihome = 0; 129 int guest; 130 int stats; 131 int statfd = -1; 132 int portcheck = 1; 133 int dochroot; 134 int type; 135 int form; 136 int stru; /* avoid C keyword */ 137 int mode; 138 int doutmp = 0; /* update utmp file */ 139 int nowtmp = 0; /* do not update wtmp file */ 140 int usedefault = 1; /* for data transfers */ 141 int pdata = -1; /* for passive mode */ 142 int family = AF_UNSPEC; 143 volatile sig_atomic_t transflag; 144 off_t file_size; 145 off_t byte_count; 146 mode_t defumask = S_IWGRP|S_IWOTH; /* default umask value */ 147 int umaskchange = 1; /* allow user to change umask value. */ 148 char tmpline[7]; 149 char hostname[HOST_NAME_MAX+1]; 150 char remotehost[HOST_NAME_MAX+1]; 151 char dhostname[HOST_NAME_MAX+1]; 152 char *guestpw; 153 char ttyline[20]; 154 static struct utmp utmp; /* for utmp */ 155 static login_cap_t *lc; 156 static auth_session_t *as; 157 static volatile sig_atomic_t recvurg; 158 159 int epsvall = 0; 160 161 /* 162 * Timeout intervals for retrying connections 163 * to hosts that don't accept PORT cmds. This 164 * is a kludge, but given the problems with TCP... 165 */ 166 #define SWAITMAX 90 /* wait at most 90 seconds */ 167 #define SWAITINT 5 /* interval between retries */ 168 169 int swaitmax = SWAITMAX; 170 int swaitint = SWAITINT; 171 172 char proctitle[BUFSIZ]; /* initial part of title */ 173 174 #define LOGCMD(cmd, file) \ 175 if (logging > 1) \ 176 syslog(LOG_INFO,"%s %s%s", cmd, \ 177 *(file) == '/' ? "" : curdir(), file); 178 #define LOGCMD2(cmd, file1, file2) \ 179 if (logging > 1) \ 180 syslog(LOG_INFO,"%s %s%s %s%s", cmd, \ 181 *(file1) == '/' ? "" : curdir(), file1, \ 182 *(file2) == '/' ? "" : curdir(), file2); 183 #define LOGBYTES(cmd, file, cnt) \ 184 if (logging > 1) { \ 185 if ((cnt) == -1) \ 186 syslog(LOG_INFO,"%s %s%s", cmd, \ 187 *(file) == '/' ? "" : curdir(), file); \ 188 else \ 189 syslog(LOG_INFO, "%s %s%s = %lld bytes", \ 190 cmd, (*(file) == '/') ? "" : curdir(), file, \ 191 (long long)(cnt)); \ 192 } 193 194 static void ack(char *); 195 static void sigurg(int); 196 static void myoob(void); 197 static int checkuser(char *, char *); 198 static FILE *dataconn(char *, off_t, char *); 199 static void dolog(struct sockaddr *); 200 static char *copy_dir(char *, struct passwd *); 201 static char *curdir(void); 202 static void end_login(void); 203 static FILE *getdatasock(char *); 204 static int guniquefd(char *, char **); 205 static void lostconn(int); 206 static void sigquit(int); 207 static int receive_data(FILE *, FILE *); 208 static void replydirname(const char *, const char *); 209 static int send_data(FILE *, FILE *, off_t, off_t, int); 210 static struct passwd * 211 sgetpwnam(char *, struct passwd *); 212 static void reapchild(int); 213 static void usage(void); 214 215 void logxfer(char *, off_t, time_t); 216 void set_slave_signals(void); 217 218 static char * 219 curdir(void) 220 { 221 static char path[PATH_MAX+1]; /* path + '/' */ 222 223 if (getcwd(path, sizeof(path)-1) == NULL) 224 return (""); 225 if (path[1] != '\0') /* special case for root dir. */ 226 strlcat(path, "/", sizeof path); 227 /* For guest account, skip / since it's chrooted */ 228 return (guest ? path+1 : path); 229 } 230 231 char *argstr = "AdDhnlm:MSt:T:u:PUvW46"; 232 233 static void 234 usage(void) 235 { 236 syslog(LOG_ERR, 237 "usage: ftpd [-46ADdlMnPSUW] [-m minuid] [-T maxtimeout] " 238 "[-t timeout] [-u mask]"); 239 exit(2); 240 } 241 242 int 243 main(int argc, char *argv[]) 244 { 245 socklen_t addrlen; 246 int ch, on = 1, tos; 247 char line[LINE_MAX]; 248 FILE *fp; 249 struct hostent *hp; 250 struct sigaction sa; 251 int error = 0; 252 const char *errstr; 253 254 tzset(); /* in case no timezone database in ~ftp */ 255 sigfillset(&allsigs); /* used to block signals while root */ 256 sigemptyset(&sa.sa_mask); 257 sa.sa_flags = SA_RESTART; 258 259 while ((ch = getopt(argc, argv, argstr)) != -1) { 260 switch (ch) { 261 case 'A': 262 anon_only = 1; 263 break; 264 265 case 'd': 266 case 'v': /* deprecated */ 267 debug = 1; 268 break; 269 270 case 'D': 271 daemon_mode = 1; 272 break; 273 274 case 'P': 275 portcheck = 0; 276 break; 277 278 case 'h': /* deprecated */ 279 break; 280 281 case 'l': 282 logging++; /* > 1 == extra logging */ 283 break; 284 285 case 'm': 286 minuid = strtonum(optarg, 0, UINT_MAX, &errstr); 287 if (errstr) { 288 syslog(LOG_ERR, 289 "%s is a bad value for -m, aborting", 290 optarg); 291 exit(2); 292 } 293 break; 294 295 case 'M': 296 multihome = 1; 297 break; 298 299 case 'n': 300 anon_ok = 0; 301 break; 302 303 case 'S': 304 stats = 1; 305 break; 306 307 case 't': 308 timeout = strtonum(optarg, 0, INT_MAX, &errstr); 309 if (errstr) { 310 syslog(LOG_ERR, 311 "%s is a bad value for -t, aborting", 312 optarg); 313 exit(2); 314 } 315 if (maxtimeout < timeout) 316 maxtimeout = timeout; 317 break; 318 319 case 'T': 320 maxtimeout = strtonum(optarg, 0, INT_MAX, 321 &errstr); 322 if (errstr) { 323 syslog(LOG_ERR, 324 "%s is a bad value for -T, aborting", 325 optarg); 326 exit(2); 327 } 328 if (timeout > maxtimeout) 329 timeout = maxtimeout; 330 break; 331 332 case 'u': 333 { 334 long val = 0; 335 char *p; 336 umaskchange = 0; 337 338 val = strtol(optarg, &p, 8); 339 if (*optarg == '\0' || *p != '\0' || val < 0 || 340 (val & ~ACCESSPERMS)) { 341 syslog(LOG_ERR, 342 "%s is a bad value for -u, aborting", 343 optarg); 344 exit(2); 345 } 346 defumask = val; 347 break; 348 } 349 350 case 'U': 351 doutmp = 1; 352 break; 353 354 case 'W': 355 nowtmp = 1; 356 break; 357 358 case '4': 359 family = AF_INET; 360 break; 361 362 case '6': 363 family = AF_INET6; 364 break; 365 366 default: 367 usage(); 368 break; 369 } 370 } 371 372 if (nowtmp && doutmp) { 373 syslog(LOG_ERR, "options 'U' and 'W' are mutually exclusive"); 374 exit(1); 375 } 376 377 (void) freopen(_PATH_DEVNULL, "w", stderr); 378 379 /* 380 * LOG_NDELAY sets up the logging connection immediately, 381 * necessary for anonymous ftp's that chroot and can't do it later. 382 */ 383 openlog("ftpd", LOG_PID | LOG_NDELAY, LOG_FTP); 384 385 if (getpwnam(FTPD_PRIVSEP_USER) == NULL) { 386 syslog(LOG_ERR, "privilege separation user %s not found", 387 FTPD_PRIVSEP_USER); 388 exit(1); 389 } 390 endpwent(); 391 392 if (daemon_mode) { 393 int *fds, i, fd; 394 struct pollfd *pfds; 395 struct addrinfo hints, *res, *res0; 396 nfds_t n; 397 398 /* 399 * Detach from parent. 400 */ 401 if (daemon(1, 1) < 0) { 402 syslog(LOG_ERR, "failed to become a daemon"); 403 exit(1); 404 } 405 sa.sa_handler = reapchild; 406 (void) sigaction(SIGCHLD, &sa, NULL); 407 408 memset(&hints, 0, sizeof(hints)); 409 hints.ai_family = family; 410 hints.ai_socktype = SOCK_STREAM; 411 hints.ai_protocol = IPPROTO_TCP; 412 hints.ai_flags = AI_PASSIVE; 413 error = getaddrinfo(NULL, "ftp", &hints, &res0); 414 if (error) { 415 syslog(LOG_ERR, "%s", gai_strerror(error)); 416 exit(1); 417 } 418 419 n = 0; 420 for (res = res0; res; res = res->ai_next) 421 n++; 422 423 fds = calloc(n, sizeof(int)); 424 pfds = calloc(n, sizeof(struct pollfd)); 425 if (!fds || !pfds) { 426 syslog(LOG_ERR, "%s", strerror(errno)); 427 exit(1); 428 } 429 430 /* 431 * Open sockets, bind it to the FTP port, and start 432 * listening. 433 */ 434 n = 0; 435 for (res = res0; res; res = res->ai_next) { 436 fds[n] = socket(res->ai_family, res->ai_socktype, 437 res->ai_protocol); 438 if (fds[n] < 0) 439 continue; 440 441 if (setsockopt(fds[n], SOL_SOCKET, SO_KEEPALIVE, 442 &on, sizeof(on)) < 0) { 443 close(fds[n]); 444 fds[n] = -1; 445 continue; 446 } 447 448 if (setsockopt(fds[n], SOL_SOCKET, SO_REUSEADDR, 449 &on, sizeof(on)) < 0) { 450 close(fds[n]); 451 fds[n] = -1; 452 continue; 453 } 454 455 if (bind(fds[n], res->ai_addr, res->ai_addrlen) < 0) { 456 close(fds[n]); 457 fds[n] = -1; 458 continue; 459 } 460 if (listen(fds[n], 32) < 0) { 461 close(fds[n]); 462 fds[n] = -1; 463 continue; 464 } 465 466 pfds[n].fd = fds[n]; 467 pfds[n].events = POLLIN; 468 n++; 469 } 470 freeaddrinfo(res0); 471 472 if (n == 0) { 473 syslog(LOG_ERR, "could not open control socket"); 474 exit(1); 475 } 476 477 /* 478 * Loop forever accepting connection requests and forking off 479 * children to handle them. 480 */ 481 while (1) { 482 if (poll(pfds, n, INFTIM) < 0) { 483 if (errno == EINTR) 484 continue; 485 syslog(LOG_ERR, "poll: %m"); 486 exit(1); 487 } 488 for (i = 0; i < n; i++) 489 if (pfds[i].revents & POLLIN) { 490 addrlen = sizeof(his_addr); 491 fd = accept(pfds[i].fd, 492 (struct sockaddr *)&his_addr, 493 &addrlen); 494 if (fd != -1) { 495 if (fork() == 0) 496 goto child; 497 close(fd); 498 } 499 } 500 } 501 502 child: 503 /* child */ 504 (void)dup2(fd, STDIN_FILENO); 505 (void)dup2(fd, STDOUT_FILENO); 506 for (i = 0; i < n; i++) 507 close(fds[i]); 508 } else { 509 addrlen = sizeof(his_addr); 510 if (getpeername(0, (struct sockaddr *)&his_addr, 511 &addrlen) < 0) { 512 /* syslog(LOG_ERR, "getpeername (%s): %m", argv[0]); */ 513 exit(1); 514 } 515 } 516 517 /* set this here so klogin can use it... */ 518 (void)snprintf(ttyline, sizeof(ttyline), "ftp%ld", (long)getpid()); 519 520 set_slave_signals(); 521 522 addrlen = sizeof(ctrl_addr); 523 if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) { 524 syslog(LOG_ERR, "getsockname: %m"); 525 exit(1); 526 } 527 if (his_addr.su_family == AF_INET6 && 528 IN6_IS_ADDR_V4MAPPED(&his_addr.su_sin6.sin6_addr)) { 529 syslog(LOG_WARNING, 530 "Connection from IPv4 mapped address is not supported."); 531 reply(530, "System not available."); 532 exit(1); 533 } 534 tos = IPTOS_LOWDELAY; 535 switch (his_addr.su_family) { 536 case AF_INET: 537 if (setsockopt(0, IPPROTO_IP, IP_TOS, &tos, 538 sizeof(int)) < 0) 539 syslog(LOG_WARNING, "setsockopt (IP_TOS): %m"); 540 break; 541 case AF_INET6: 542 if (setsockopt(0, IPPROTO_IPV6, IPV6_TCLASS, &tos, 543 sizeof(int)) < 0) 544 syslog(LOG_WARNING, "setsockopt (IPV6_TCLASS): %m"); 545 break; 546 } 547 data_source.su_port = htons(ntohs(ctrl_addr.su_port) - 1); 548 549 /* Try to handle urgent data inline */ 550 if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, &on, sizeof(on)) < 0) 551 syslog(LOG_ERR, "setsockopt: %m"); 552 553 dolog((struct sockaddr *)&his_addr); 554 555 /* 556 * Set up default state 557 */ 558 data = -1; 559 type = TYPE_A; 560 form = FORM_N; 561 stru = STRU_F; 562 mode = MODE_S; 563 tmpline[0] = '\0'; 564 565 /* If logins are disabled, print out the message. */ 566 if ((fp = fopen(_PATH_NOLOGIN, "r")) != NULL) { 567 while (fgets(line, sizeof(line), fp) != NULL) { 568 line[strcspn(line, "\n")] = '\0'; 569 lreply(530, "%s", line); 570 } 571 (void) fflush(stdout); 572 (void) fclose(fp); 573 reply(530, "System not available."); 574 exit(0); 575 } 576 if ((fp = fopen(_PATH_FTPWELCOME, "r")) != NULL) { 577 while (fgets(line, sizeof(line), fp) != NULL) { 578 line[strcspn(line, "\n")] = '\0'; 579 lreply(220, "%s", line); 580 } 581 (void) fflush(stdout); 582 (void) fclose(fp); 583 /* reply(220,) must follow */ 584 } 585 (void) gethostname(hostname, sizeof(hostname)); 586 587 /* Make sure hostname is fully qualified. */ 588 hp = gethostbyname(hostname); 589 if (hp != NULL) 590 strlcpy(hostname, hp->h_name, sizeof(hostname)); 591 592 if (multihome) { 593 error = getnameinfo((struct sockaddr *)&ctrl_addr, 594 ctrl_addr.su_len, dhostname, sizeof(dhostname), NULL, 0, 0); 595 } 596 597 if (error != 0) 598 reply(220, "FTP server ready."); 599 else 600 reply(220, "%s FTP server ready.", 601 (multihome ? dhostname : hostname)); 602 603 monitor_init(); 604 605 for (;;) 606 (void) yyparse(); 607 /* NOTREACHED */ 608 } 609 610 /* 611 * Signal handlers. 612 */ 613 /*ARGSUSED*/ 614 static void 615 lostconn(int signo) 616 { 617 struct syslog_data sdata = SYSLOG_DATA_INIT; 618 619 sdata.log_fac = LOG_FTP; 620 if (debug) 621 syslog_r(LOG_DEBUG, &sdata, "lost connection"); 622 dologout(1); 623 } 624 625 static void 626 sigquit(int signo) 627 { 628 struct syslog_data sdata = SYSLOG_DATA_INIT; 629 630 sdata.log_fac = LOG_FTP; 631 syslog_r(LOG_DEBUG, &sdata, "got signal %s", sys_signame[signo]); 632 dologout(1); 633 } 634 635 /* 636 * Save the result of a getpwnam. Used for USER command, since 637 * the data returned must not be clobbered by any other command 638 * (e.g., globbing). 639 */ 640 static struct passwd * 641 sgetpwnam(char *name, struct passwd *pw) 642 { 643 static struct passwd *save; 644 struct passwd *old; 645 646 if (pw == NULL && (pw = getpwnam(name)) == NULL) 647 return (NULL); 648 old = save; 649 save = pw_dup(pw); 650 if (save == NULL) { 651 perror_reply(421, "Local resource failure: malloc"); 652 dologout(1); 653 /* NOTREACHED */ 654 } 655 if (old) { 656 explicit_bzero(old->pw_passwd, strlen(old->pw_passwd)); 657 free(old); 658 } 659 return (save); 660 } 661 662 static int login_attempts; /* number of failed login attempts */ 663 static int askpasswd; /* had user command, ask for passwd */ 664 static char curname[LOGIN_NAME_MAX]; /* current USER name */ 665 666 /* 667 * USER command. 668 * Sets global passwd pointer pw if named account exists and is acceptable; 669 * sets askpasswd if a PASS command is expected. If logged in previously, 670 * need to reset state. If name is "ftp" or "anonymous", the name is not in 671 * _PATH_FTPUSERS, and ftp account exists, set guest and pw, then just return. 672 * If account doesn't exist, ask for passwd anyway. Otherwise, check user 673 * requesting login privileges. Disallow anyone who does not have a standard 674 * shell as returned by getusershell(). Disallow anyone mentioned in the file 675 * _PATH_FTPUSERS to allow people such as root and uucp to be avoided. 676 */ 677 void 678 user(char *name) 679 { 680 char *cp, *shell, *style, *host; 681 char *class = NULL; 682 683 if (logged_in) { 684 kill_slave("user already logged in"); 685 end_login(); 686 } 687 688 /* Close session from previous user if there was one. */ 689 if (as) { 690 auth_close(as); 691 as = NULL; 692 } 693 if (lc) { 694 login_close(lc); 695 lc = NULL; 696 } 697 698 if ((style = strchr(name, ':')) != NULL) 699 *style++ = 0; 700 701 guest = 0; 702 askpasswd = 0; 703 host = multihome ? dhostname : hostname; 704 if (anon_ok && 705 (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0)) { 706 if (checkuser(_PATH_FTPUSERS, "ftp") || 707 checkuser(_PATH_FTPUSERS, "anonymous")) 708 reply(530, "User %s access denied.", name); 709 else if ((pw = sgetpwnam("ftp", NULL)) != NULL) { 710 if ((lc = login_getclass(pw->pw_class)) == NULL || 711 (as = auth_open()) == NULL || 712 auth_setpwd(as, pw) != 0 || 713 auth_setoption(as, "FTPD_HOST", host) < 0) { 714 if (as) { 715 auth_close(as); 716 as = NULL; 717 } 718 if (lc) { 719 login_close(lc); 720 lc = NULL; 721 } 722 reply(421, "Local resource failure"); 723 return; 724 } 725 guest = 1; 726 askpasswd = 1; 727 reply(331, 728 "Guest login ok, send your email address as password."); 729 } else 730 reply(530, "User %s unknown.", name); 731 if (!askpasswd && logging) 732 syslog(LOG_NOTICE, 733 "ANONYMOUS FTP LOGIN REFUSED FROM %s", remotehost); 734 return; 735 } 736 737 shell = _PATH_BSHELL; 738 if ((pw = sgetpwnam(name, NULL))) { 739 class = pw->pw_class; 740 if (pw->pw_shell != NULL && *pw->pw_shell != '\0') 741 shell = pw->pw_shell; 742 while ((cp = getusershell()) != NULL) 743 if (strcmp(cp, shell) == 0) 744 break; 745 shell = cp; 746 endusershell(); 747 } 748 749 /* Get login class; if invalid style treat like unknown user. */ 750 lc = login_getclass(class); 751 if (lc && (style = login_getstyle(lc, style, "auth-ftp")) == NULL) { 752 login_close(lc); 753 lc = NULL; 754 pw = NULL; 755 } 756 757 /* Do pre-authentication setup. */ 758 if (lc && ((as = auth_open()) == NULL || 759 (pw != NULL && auth_setpwd(as, pw) != 0) || 760 auth_setitem(as, AUTHV_STYLE, style) < 0 || 761 auth_setitem(as, AUTHV_NAME, name) < 0 || 762 auth_setitem(as, AUTHV_CLASS, class) < 0 || 763 auth_setoption(as, "login", "yes") < 0 || 764 auth_setoption(as, "notickets", "yes") < 0 || 765 auth_setoption(as, "FTPD_HOST", host) < 0)) { 766 if (as) { 767 auth_close(as); 768 as = NULL; 769 } 770 login_close(lc); 771 lc = NULL; 772 reply(421, "Local resource failure"); 773 return; 774 } 775 if (logging) 776 strlcpy(curname, name, sizeof(curname)); 777 778 dochroot = (lc && login_getcapbool(lc, "ftp-chroot", 0)) || 779 checkuser(_PATH_FTPCHROOT, name); 780 if (anon_only && !dochroot) { 781 reply(530, "User %s access denied.", name); 782 return; 783 } 784 if (pw) { 785 if (pw->pw_uid < minuid) { 786 reply(530, "User %s access denied.", name); 787 if (logging) 788 syslog(LOG_NOTICE, 789 "FTP LOGIN REFUSED FROM %s, %s (UID))", 790 remotehost, name); 791 return; 792 } 793 if ((!shell && !dochroot) || checkuser(_PATH_FTPUSERS, name)) { 794 reply(530, "User %s access denied.", name); 795 if (logging) 796 syslog(LOG_NOTICE, 797 "FTP LOGIN REFUSED FROM %s, %s", 798 remotehost, name); 799 pw = NULL; 800 return; 801 } 802 } 803 804 if (as != NULL && (cp = auth_challenge(as)) != NULL) 805 reply(331, "%s", cp); 806 else 807 reply(331, "Password required for %s.", name); 808 809 askpasswd = 1; 810 /* 811 * Delay before reading passwd after first failed 812 * attempt to slow down passwd-guessing programs. 813 */ 814 if (login_attempts) 815 sleep((unsigned) login_attempts); 816 } 817 818 /* 819 * Check if a user is in the file "fname" 820 */ 821 static int 822 checkuser(char *fname, char *name) 823 { 824 FILE *fp; 825 int found = 0; 826 char *p, line[BUFSIZ]; 827 828 if ((fp = fopen(fname, "r")) != NULL) { 829 while (fgets(line, sizeof(line), fp) != NULL) 830 if ((p = strchr(line, '\n')) != NULL) { 831 *p = '\0'; 832 if (line[0] == '#') 833 continue; 834 if (strcmp(line, name) == 0) { 835 found = 1; 836 break; 837 } 838 } 839 (void) fclose(fp); 840 } 841 return (found); 842 } 843 844 /* 845 * Terminate login as previous user, if any, resetting state; 846 * used when USER command is given or login fails. 847 */ 848 static void 849 end_login(void) 850 { 851 sigprocmask (SIG_BLOCK, &allsigs, NULL); 852 if (logged_in) { 853 if (!nowtmp) 854 ftpdlogwtmp(ttyline, "", ""); 855 if (doutmp) 856 ftpd_logout(utmp.ut_line); 857 } 858 reply(530, "Please reconnect to work as another user"); 859 _exit(0); 860 } 861 862 enum auth_ret 863 pass(char *passwd) 864 { 865 int authok; 866 unsigned int flags; 867 FILE *fp; 868 static char homedir[PATH_MAX]; 869 char *motd, *dir, rootdir[PATH_MAX]; 870 size_t sz_pw_dir; 871 872 if (logged_in || askpasswd == 0) { 873 reply(503, "Login with USER first."); 874 return (AUTH_FAILED); 875 } 876 askpasswd = 0; 877 if (!guest) { /* "ftp" is only account allowed no password */ 878 authok = 0; 879 if (pw == NULL || pw->pw_passwd[0] == '\0') { 880 useconds_t us; 881 882 /* Sleep between 1 and 3 seconds to emulate a crypt. */ 883 us = arc4random_uniform(3000000); 884 usleep(us); 885 if (as != NULL) { 886 auth_close(as); 887 as = NULL; 888 } 889 } else { 890 authok = auth_userresponse(as, passwd, 0); 891 as = NULL; 892 } 893 if (authok == 0) { 894 reply(530, "Login incorrect."); 895 if (logging) 896 syslog(LOG_NOTICE, 897 "FTP LOGIN FAILED FROM %s, %s", 898 remotehost, curname); 899 pw = NULL; 900 if (login_attempts++ >= 5) { 901 syslog(LOG_NOTICE, 902 "repeated login failures from %s", 903 remotehost); 904 kill_slave("repeated login failures"); 905 _exit(0); 906 } 907 return (AUTH_FAILED); 908 } 909 } else if (lc != NULL) { 910 /* Save anonymous' password. */ 911 free(guestpw); 912 guestpw = strdup(passwd); 913 if (guestpw == NULL) { 914 kill_slave("out of mem"); 915 fatal("Out of memory."); 916 } 917 918 authok = auth_approval(as, lc, pw->pw_name, "ftp"); 919 auth_close(as); 920 as = NULL; 921 if (authok == 0) { 922 syslog(LOG_INFO|LOG_AUTH, 923 "FTP LOGIN FAILED (HOST) as %s: approval failure.", 924 pw->pw_name); 925 reply(530, "Approval failure."); 926 kill_slave("approval failure"); 927 _exit(0); 928 } 929 } else { 930 syslog(LOG_INFO|LOG_AUTH, 931 "FTP LOGIN CLASS %s MISSING for %s: approval failure.", 932 pw->pw_class, pw->pw_name); 933 reply(530, "Permission denied."); 934 kill_slave("permission denied"); 935 _exit(0); 936 } 937 938 if (monitor_post_auth() == 1) { 939 /* Post-auth monitor process */ 940 logged_in = 1; 941 return (AUTH_MONITOR); 942 } 943 944 login_attempts = 0; /* this time successful */ 945 /* set umask via setusercontext() unless -u flag was given. */ 946 flags = LOGIN_SETGROUP|LOGIN_SETPRIORITY|LOGIN_SETRESOURCES; 947 if (umaskchange) 948 flags |= LOGIN_SETUMASK; 949 else 950 (void) umask(defumask); 951 if (setusercontext(lc, pw, 0, flags) != 0) { 952 perror_reply(421, "Local resource failure: setusercontext"); 953 syslog(LOG_NOTICE, "setusercontext: %m"); 954 dologout(1); 955 /* NOTREACHED */ 956 } 957 958 /* open wtmp before chroot */ 959 if (!nowtmp) 960 ftpdlogwtmp(ttyline, pw->pw_name, remotehost); 961 962 /* open utmp before chroot */ 963 if (doutmp) { 964 memset(&utmp, 0, sizeof(utmp)); 965 (void)time(&utmp.ut_time); 966 (void)strncpy(utmp.ut_name, pw->pw_name, sizeof(utmp.ut_name)); 967 (void)strncpy(utmp.ut_host, remotehost, sizeof(utmp.ut_host)); 968 (void)strncpy(utmp.ut_line, ttyline, sizeof(utmp.ut_line)); 969 ftpd_login(&utmp); 970 } 971 972 /* open stats file before chroot */ 973 if (guest && (stats == 1) && (statfd < 0)) 974 if ((statfd = open(_PATH_FTPDSTATFILE, O_WRONLY|O_APPEND)) < 0) 975 stats = 0; 976 977 logged_in = 1; 978 979 if ((dir = login_getcapstr(lc, "ftp-dir", NULL, NULL))) { 980 char *newdir; 981 982 newdir = copy_dir(dir, pw); 983 if (newdir == NULL) { 984 perror_reply(421, "Local resource failure: malloc"); 985 dologout(1); 986 /* NOTREACHED */ 987 } 988 pw->pw_dir = newdir; 989 pw = sgetpwnam(NULL, pw); 990 free(dir); 991 free(newdir); 992 } 993 994 /* make sure pw->pw_dir is big enough to hold "/" */ 995 sz_pw_dir = strlen(pw->pw_dir) + 1; 996 if (sz_pw_dir < 2) { 997 pw->pw_dir = "/"; 998 pw = sgetpwnam(NULL, pw); 999 sz_pw_dir = 2; 1000 } 1001 1002 if (guest || dochroot) { 1003 if (multihome && guest) { 1004 struct stat ts; 1005 1006 /* Compute root directory. */ 1007 snprintf(rootdir, sizeof(rootdir), "%s/%s", 1008 pw->pw_dir, dhostname); 1009 if (stat(rootdir, &ts) < 0) { 1010 snprintf(rootdir, sizeof(rootdir), "%s/%s", 1011 pw->pw_dir, hostname); 1012 } 1013 } else 1014 strlcpy(rootdir, pw->pw_dir, sizeof(rootdir)); 1015 } 1016 if (guest) { 1017 /* 1018 * We MUST do a chdir() after the chroot. Otherwise 1019 * the old current directory will be accessible as "." 1020 * outside the new root! 1021 */ 1022 if (chroot(rootdir) < 0 || chdir("/") < 0) { 1023 reply(550, "Can't set guest privileges."); 1024 goto bad; 1025 } 1026 strlcpy(pw->pw_dir, "/", sz_pw_dir); 1027 if (setenv("HOME", "/", 1) == -1) { 1028 reply(550, "Can't setup environment."); 1029 goto bad; 1030 } 1031 } else if (dochroot) { 1032 if (chroot(rootdir) < 0 || chdir("/") < 0) { 1033 reply(550, "Can't change root."); 1034 goto bad; 1035 } 1036 strlcpy(pw->pw_dir, "/", sz_pw_dir); 1037 if (setenv("HOME", "/", 1) == -1) { 1038 reply(550, "Can't setup environment."); 1039 goto bad; 1040 } 1041 } else if (chdir(pw->pw_dir) < 0) { 1042 if (chdir("/") < 0) { 1043 reply(530, "User %s: can't change directory to %s.", 1044 pw->pw_name, pw->pw_dir); 1045 goto bad; 1046 } else 1047 lreply(230, "No directory! Logging in with home=/"); 1048 } 1049 if (setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) < 0) { 1050 reply(550, "Can't set gid."); 1051 goto bad; 1052 } 1053 if (setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid) < 0) { 1054 reply(550, "Can't set uid."); 1055 goto bad; 1056 } 1057 sigprocmask(SIG_UNBLOCK, &allsigs, NULL); 1058 1059 /* 1060 * Set home directory so that use of ~ (tilde) works correctly. 1061 */ 1062 if (getcwd(homedir, PATH_MAX) != NULL) { 1063 if (setenv("HOME", homedir, 1) == -1) { 1064 reply(550, "Can't setup environment."); 1065 goto bad; 1066 } 1067 } 1068 1069 /* 1070 * Display a login message, if it exists. 1071 * N.B. reply(230,) must follow the message. 1072 */ 1073 motd = login_getcapstr(lc, "welcome", NULL, NULL); 1074 if ((fp = fopen(motd ? motd : _PATH_FTPLOGINMESG, "r")) != NULL) { 1075 char line[LINE_MAX]; 1076 1077 while (fgets(line, sizeof(line), fp) != NULL) { 1078 line[strcspn(line, "\n")] = '\0'; 1079 lreply(230, "%s", line); 1080 } 1081 (void) fflush(stdout); 1082 (void) fclose(fp); 1083 } 1084 free(motd); 1085 if (guest) { 1086 reply(230, "Guest login ok, access restrictions apply."); 1087 snprintf(proctitle, sizeof(proctitle), 1088 "%s: anonymous/%.*s", remotehost, 1089 (int)(sizeof(proctitle) - sizeof(remotehost) - 1090 sizeof(": anonymous/")), passwd); 1091 setproctitle("%s", proctitle); 1092 if (logging) 1093 syslog(LOG_INFO, "ANONYMOUS FTP LOGIN FROM %s, %s", 1094 remotehost, passwd); 1095 } else { 1096 reply(230, "User %s logged in.", pw->pw_name); 1097 snprintf(proctitle, sizeof(proctitle), 1098 "%s: %s", remotehost, pw->pw_name); 1099 setproctitle("%s", proctitle); 1100 if (logging) 1101 syslog(LOG_INFO, "FTP LOGIN FROM %s as %s", 1102 remotehost, pw->pw_name); 1103 } 1104 login_close(lc); 1105 lc = NULL; 1106 return (AUTH_SLAVE); 1107 bad: 1108 /* Forget all about it... */ 1109 login_close(lc); 1110 lc = NULL; 1111 end_login(); 1112 return (AUTH_FAILED); 1113 } 1114 1115 void 1116 retrieve(char *cmd, char *name) 1117 { 1118 FILE *fin, *dout; 1119 struct stat st; 1120 pid_t pid; 1121 time_t start; 1122 1123 if (cmd == NULL) { 1124 fin = fopen(name, "r"); 1125 st.st_size = 0; 1126 } else { 1127 char line[BUFSIZ]; 1128 1129 (void) snprintf(line, sizeof(line), cmd, name); 1130 name = line; 1131 fin = ftpd_popen(line, "r", &pid); 1132 st.st_size = -1; 1133 st.st_blksize = BUFSIZ; 1134 } 1135 if (fin == NULL) { 1136 if (errno != 0) { 1137 perror_reply(550, name); 1138 if (cmd == NULL) { 1139 LOGCMD("get", name); 1140 } 1141 } 1142 return; 1143 } 1144 byte_count = -1; 1145 if (cmd == NULL && 1146 (fstat(fileno(fin), &st) < 0 || !S_ISREG(st.st_mode))) { 1147 reply(550, "%s: not a plain file.", name); 1148 goto done; 1149 } 1150 if (restart_point) { 1151 if (type == TYPE_A) { 1152 off_t i, n; 1153 int c; 1154 1155 n = restart_point; 1156 i = 0; 1157 while (i++ < n) { 1158 if ((c = getc(fin)) == EOF) { 1159 if (ferror(fin)) { 1160 perror_reply(550, name); 1161 goto done; 1162 } else 1163 break; 1164 } 1165 if (c == '\n') 1166 i++; 1167 } 1168 } else if (lseek(fileno(fin), restart_point, SEEK_SET) < 0) { 1169 perror_reply(550, name); 1170 goto done; 1171 } 1172 } 1173 dout = dataconn(name, st.st_size, "w"); 1174 if (dout == NULL) 1175 goto done; 1176 time(&start); 1177 send_data(fin, dout, st.st_blksize, st.st_size, 1178 (restart_point == 0 && cmd == NULL && S_ISREG(st.st_mode))); 1179 if ((cmd == NULL) && stats) 1180 logxfer(name, byte_count, start); 1181 (void) fclose(dout); 1182 data = -1; 1183 done: 1184 if (pdata >= 0) 1185 (void) close(pdata); 1186 pdata = -1; 1187 if (cmd == NULL) { 1188 LOGBYTES("get", name, byte_count); 1189 fclose(fin); 1190 } else { 1191 ftpd_pclose(fin, pid); 1192 } 1193 } 1194 1195 void 1196 store(char *name, char *mode, int unique) 1197 { 1198 FILE *fout, *din; 1199 int (*closefunc)(FILE *); 1200 struct stat st; 1201 int fd; 1202 1203 if (restart_point && *mode != 'a') 1204 mode = "r+"; 1205 1206 if (unique && stat(name, &st) == 0) { 1207 char *nam; 1208 1209 fd = guniquefd(name, &nam); 1210 if (fd == -1) { 1211 LOGCMD(*mode == 'w' ? "put" : "append", name); 1212 return; 1213 } 1214 name = nam; 1215 fout = fdopen(fd, mode); 1216 } else 1217 fout = fopen(name, mode); 1218 1219 closefunc = fclose; 1220 if (fout == NULL) { 1221 perror_reply(553, name); 1222 LOGCMD(*mode == 'w' ? "put" : "append", name); 1223 return; 1224 } 1225 byte_count = -1; 1226 if (restart_point) { 1227 if (type == TYPE_A) { 1228 off_t i, n; 1229 int c; 1230 1231 n = restart_point; 1232 i = 0; 1233 while (i++ < n) { 1234 if ((c = getc(fout)) == EOF) { 1235 if (ferror(fout)) { 1236 perror_reply(550, name); 1237 goto done; 1238 } else 1239 break; 1240 } 1241 if (c == '\n') 1242 i++; 1243 } 1244 /* 1245 * We must do this seek to "current" position 1246 * because we are changing from reading to 1247 * writing. 1248 */ 1249 if (fseek(fout, 0, SEEK_CUR) < 0) { 1250 perror_reply(550, name); 1251 goto done; 1252 } 1253 } else if (lseek(fileno(fout), restart_point, SEEK_SET) < 0) { 1254 perror_reply(550, name); 1255 goto done; 1256 } 1257 } 1258 din = dataconn(name, -1, "r"); 1259 if (din == NULL) 1260 goto done; 1261 if (receive_data(din, fout) == 0) { 1262 if (unique) 1263 reply(226, "Transfer complete (unique file name:%s).", 1264 name); 1265 else 1266 reply(226, "Transfer complete."); 1267 } 1268 (void) fclose(din); 1269 data = -1; 1270 pdata = -1; 1271 done: 1272 LOGBYTES(*mode == 'w' ? "put" : "append", name, byte_count); 1273 (*closefunc)(fout); 1274 } 1275 1276 static FILE * 1277 getdatasock(char *mode) 1278 { 1279 int opt, s, t, tries; 1280 1281 if (data >= 0) 1282 return (fdopen(data, mode)); 1283 sigprocmask (SIG_BLOCK, &allsigs, NULL); 1284 s = monitor_socket(ctrl_addr.su_family); 1285 if (s < 0) 1286 goto bad; 1287 opt = 1; 1288 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, 1289 &opt, sizeof(opt)) < 0) 1290 goto bad; 1291 /* anchor socket to avoid multi-homing problems */ 1292 data_source = ctrl_addr; 1293 data_source.su_port = htons(20); /* ftp-data port */ 1294 for (tries = 1; ; tries++) { 1295 if (monitor_bind(s, (struct sockaddr *)&data_source, 1296 data_source.su_len) >= 0) 1297 break; 1298 if (errno != EADDRINUSE || tries > 10) 1299 goto bad; 1300 sleep((unsigned int)tries); 1301 } 1302 sigprocmask (SIG_UNBLOCK, &allsigs, NULL); 1303 1304 opt = IPTOS_THROUGHPUT; 1305 switch (ctrl_addr.su_family) { 1306 case AF_INET: 1307 if (setsockopt(s, IPPROTO_IP, IP_TOS, &opt, 1308 sizeof(opt)) < 0) 1309 syslog(LOG_WARNING, "setsockopt (IP_TOS): %m"); 1310 break; 1311 case AF_INET6: 1312 if (setsockopt(s, IPPROTO_IPV6, IPV6_TCLASS, &opt, 1313 sizeof(opt)) < 0) 1314 syslog(LOG_WARNING, "setsockopt (IPV6_TCLASS): %m"); 1315 break; 1316 } 1317 /* 1318 * Turn off push flag to keep sender TCP from sending short packets 1319 * at the boundaries of each write(). Should probably do a SO_SNDBUF 1320 * to set the send buffer size as well, but that may not be desirable 1321 * in heavy-load situations. 1322 */ 1323 opt = 1; 1324 if (setsockopt(s, IPPROTO_TCP, TCP_NOPUSH, &opt, sizeof(opt)) < 0) 1325 syslog(LOG_WARNING, "setsockopt (TCP_NOPUSH): %m"); 1326 opt = 65536; 1327 if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) < 0) 1328 syslog(LOG_WARNING, "setsockopt (SO_SNDBUF): %m"); 1329 1330 return (fdopen(s, mode)); 1331 bad: 1332 /* Return the real value of errno (close may change it) */ 1333 t = errno; 1334 sigprocmask (SIG_UNBLOCK, &allsigs, NULL); 1335 if (s >= 0) 1336 (void) close(s); 1337 errno = t; 1338 return (NULL); 1339 } 1340 1341 static FILE * 1342 dataconn(char *name, off_t size, char *mode) 1343 { 1344 char sizebuf[32]; 1345 FILE *file = NULL; 1346 int retry = 0; 1347 in_port_t *p; 1348 u_char *fa, *ha; 1349 size_t alen; 1350 int error; 1351 1352 file_size = size; 1353 byte_count = 0; 1354 if (size != -1) { 1355 (void) snprintf(sizebuf, sizeof(sizebuf), " (%lld bytes)", 1356 (long long)size); 1357 } else 1358 sizebuf[0] = '\0'; 1359 if (pdata >= 0) { 1360 union sockunion from; 1361 int s; 1362 socklen_t fromlen = sizeof(from); 1363 1364 (void) alarm ((unsigned) timeout); 1365 s = accept(pdata, (struct sockaddr *)&from, &fromlen); 1366 (void) alarm (0); 1367 if (s < 0) { 1368 reply(425, "Can't open data connection."); 1369 (void) close(pdata); 1370 pdata = -1; 1371 return (NULL); 1372 } 1373 switch (from.su_family) { 1374 case AF_INET: 1375 p = (in_port_t *)&from.su_sin.sin_port; 1376 fa = (u_char *)&from.su_sin.sin_addr; 1377 ha = (u_char *)&his_addr.su_sin.sin_addr; 1378 alen = sizeof(struct in_addr); 1379 break; 1380 case AF_INET6: 1381 p = (in_port_t *)&from.su_sin6.sin6_port; 1382 fa = (u_char *)&from.su_sin6.sin6_addr; 1383 ha = (u_char *)&his_addr.su_sin6.sin6_addr; 1384 alen = sizeof(struct in6_addr); 1385 break; 1386 default: 1387 reply(425, "Can't build data connection: " 1388 "unknown address family"); 1389 (void) close(pdata); 1390 (void) close(s); 1391 pdata = -1; 1392 return (NULL); 1393 } 1394 if (from.su_family != his_addr.su_family || 1395 ntohs(*p) < IPPORT_RESERVED) { 1396 reply(425, "Can't build data connection: " 1397 "address family or port error"); 1398 (void) close(pdata); 1399 (void) close(s); 1400 pdata = -1; 1401 return (NULL); 1402 } 1403 if (portcheck && memcmp(fa, ha, alen) != 0) { 1404 reply(425, "Can't build data connection: " 1405 "illegal port number"); 1406 (void) close(pdata); 1407 (void) close(s); 1408 pdata = -1; 1409 return (NULL); 1410 } 1411 (void) close(pdata); 1412 pdata = s; 1413 reply(150, "Opening %s mode data connection for '%s'%s.", 1414 type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf); 1415 return (fdopen(pdata, mode)); 1416 } 1417 if (data >= 0) { 1418 reply(125, "Using existing data connection for '%s'%s.", 1419 name, sizebuf); 1420 usedefault = 1; 1421 return (fdopen(data, mode)); 1422 } 1423 if (usedefault) 1424 data_dest = his_addr; 1425 usedefault = 1; 1426 do { 1427 if (file != NULL) 1428 (void) fclose(file); 1429 file = getdatasock(mode); 1430 if (file == NULL) { 1431 char hbuf[HOST_NAME_MAX+1], pbuf[10]; 1432 1433 error = getnameinfo((struct sockaddr *)&data_source, 1434 data_source.su_len, hbuf, sizeof(hbuf), pbuf, 1435 sizeof(pbuf), NI_NUMERICHOST | NI_NUMERICSERV); 1436 if (error != 0) 1437 reply(425, "Can't create data socket: %s.", 1438 strerror(errno)); 1439 else 1440 reply(425, 1441 "Can't create data socket (%s,%s): %s.", 1442 hbuf, pbuf, strerror(errno)); 1443 return (NULL); 1444 } 1445 1446 /* 1447 * attempt to connect to reserved port on client machine; 1448 * this looks like an attack 1449 */ 1450 switch (data_dest.su_family) { 1451 case AF_INET: 1452 p = (in_port_t *)&data_dest.su_sin.sin_port; 1453 fa = (u_char *)&data_dest.su_sin.sin_addr; 1454 ha = (u_char *)&his_addr.su_sin.sin_addr; 1455 alen = sizeof(struct in_addr); 1456 break; 1457 case AF_INET6: 1458 p = (in_port_t *)&data_dest.su_sin6.sin6_port; 1459 fa = (u_char *)&data_dest.su_sin6.sin6_addr; 1460 ha = (u_char *)&his_addr.su_sin6.sin6_addr; 1461 alen = sizeof(struct in6_addr); 1462 break; 1463 default: 1464 reply(425, "Can't build data connection: " 1465 "unknown address family"); 1466 (void) fclose(file); 1467 pdata = -1; 1468 return (NULL); 1469 } 1470 if (data_dest.su_family != his_addr.su_family || 1471 ntohs(*p) < IPPORT_RESERVED || ntohs(*p) == 2049) { /* XXX */ 1472 reply(425, "Can't build data connection: " 1473 "address family or port error"); 1474 (void) fclose(file); 1475 return NULL; 1476 } 1477 if (portcheck && memcmp(fa, ha, alen) != 0) { 1478 reply(435, "Can't build data connection: " 1479 "illegal port number"); 1480 (void) fclose(file); 1481 return NULL; 1482 } 1483 1484 if (connect(fileno(file), (struct sockaddr *)&data_dest, 1485 data_dest.su_len) == 0) { 1486 reply(150, "Opening %s mode data connection for '%s'%s.", 1487 type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf); 1488 data = fileno(file); 1489 return (file); 1490 } 1491 if (errno != EADDRINUSE) 1492 break; 1493 sleep((unsigned) swaitint); 1494 retry += swaitint; 1495 } while (retry <= swaitmax); 1496 perror_reply(425, "Can't build data connection"); 1497 (void) fclose(file); 1498 return (NULL); 1499 } 1500 1501 /* 1502 * Transfer the contents of "instr" to "outstr" peer using the appropriate 1503 * encapsulation of the data subject to Mode, Structure, and Type. 1504 * 1505 * NB: Form isn't handled. 1506 */ 1507 static int 1508 send_data(FILE *instr, FILE *outstr, off_t blksize, off_t filesize, int isreg) 1509 { 1510 int c, cnt, filefd, netfd; 1511 char *buf, *bp; 1512 size_t len; 1513 1514 transflag++; 1515 switch (type) { 1516 1517 case TYPE_A: 1518 while ((c = getc(instr)) != EOF) { 1519 if (recvurg) 1520 goto got_oob; 1521 byte_count++; 1522 if (c == '\n') { 1523 if (ferror(outstr)) 1524 goto data_err; 1525 (void) putc('\r', outstr); 1526 } 1527 (void) putc(c, outstr); 1528 } 1529 fflush(outstr); 1530 transflag = 0; 1531 if (ferror(instr)) 1532 goto file_err; 1533 if (ferror(outstr)) 1534 goto data_err; 1535 reply(226, "Transfer complete."); 1536 return(0); 1537 1538 case TYPE_I: 1539 case TYPE_L: 1540 /* 1541 * isreg is only set if we are not doing restart and we 1542 * are sending a regular file 1543 */ 1544 netfd = fileno(outstr); 1545 filefd = fileno(instr); 1546 1547 if (isreg && filesize < 16 * 1024 * 1024) { 1548 size_t fsize = (size_t)filesize; 1549 1550 if (fsize == 0) { 1551 transflag = 0; 1552 reply(226, "Transfer complete."); 1553 return(0); 1554 } 1555 1556 buf = mmap(0, fsize, PROT_READ, MAP_SHARED, filefd, 0); 1557 if (buf == MAP_FAILED) { 1558 syslog(LOG_WARNING, "mmap(%llu): %m", 1559 (unsigned long long)fsize); 1560 goto oldway; 1561 } 1562 bp = buf; 1563 len = fsize; 1564 do { 1565 cnt = write(netfd, bp, len); 1566 if (recvurg) { 1567 munmap(buf, fsize); 1568 goto got_oob; 1569 } 1570 len -= cnt; 1571 bp += cnt; 1572 if (cnt > 0) 1573 byte_count += cnt; 1574 } while(cnt > 0 && len > 0); 1575 1576 transflag = 0; 1577 munmap(buf, fsize); 1578 if (cnt < 0) 1579 goto data_err; 1580 reply(226, "Transfer complete."); 1581 return(0); 1582 } 1583 1584 oldway: 1585 if ((buf = malloc((size_t)blksize)) == NULL) { 1586 transflag = 0; 1587 perror_reply(451, "Local resource failure: malloc"); 1588 return(-1); 1589 } 1590 1591 while ((cnt = read(filefd, buf, (size_t)blksize)) > 0 && 1592 write(netfd, buf, cnt) == cnt) 1593 byte_count += cnt; 1594 transflag = 0; 1595 (void)free(buf); 1596 if (cnt != 0) { 1597 if (cnt < 0) 1598 goto file_err; 1599 goto data_err; 1600 } 1601 reply(226, "Transfer complete."); 1602 return(0); 1603 default: 1604 transflag = 0; 1605 reply(550, "Unimplemented TYPE %d in send_data", type); 1606 return(-1); 1607 } 1608 1609 data_err: 1610 transflag = 0; 1611 reply(426, "Data connection"); 1612 return(-1); 1613 1614 file_err: 1615 transflag = 0; 1616 reply(551, "Error on input file"); 1617 return(-1); 1618 1619 got_oob: 1620 myoob(); 1621 recvurg = 0; 1622 transflag = 0; 1623 return(-1); 1624 } 1625 1626 /* 1627 * Transfer data from peer to "outstr" using the appropriate encapulation of 1628 * the data subject to Mode, Structure, and Type. 1629 * 1630 * N.B.: Form isn't handled. 1631 */ 1632 static int 1633 receive_data(FILE *instr, FILE *outstr) 1634 { 1635 int c; 1636 int cnt; 1637 char buf[BUFSIZ]; 1638 struct sigaction sa, sa_saved; 1639 volatile int bare_lfs = 0; 1640 1641 transflag++; 1642 switch (type) { 1643 1644 case TYPE_I: 1645 case TYPE_L: 1646 memset(&sa, 0, sizeof(sa)); 1647 sigfillset(&sa.sa_mask); 1648 sa.sa_flags = SA_RESTART; 1649 sa.sa_handler = lostconn; 1650 (void) sigaction(SIGALRM, &sa, &sa_saved); 1651 do { 1652 (void) alarm ((unsigned) timeout); 1653 cnt = read(fileno(instr), buf, sizeof(buf)); 1654 (void) alarm (0); 1655 if (recvurg) 1656 goto got_oob; 1657 1658 if (cnt > 0) { 1659 if (write(fileno(outstr), buf, cnt) != cnt) 1660 goto file_err; 1661 byte_count += cnt; 1662 } 1663 } while (cnt > 0); 1664 (void) sigaction(SIGALRM, &sa_saved, NULL); 1665 if (cnt < 0) 1666 goto data_err; 1667 transflag = 0; 1668 return (0); 1669 1670 case TYPE_E: 1671 reply(553, "TYPE E not implemented."); 1672 transflag = 0; 1673 return (-1); 1674 1675 case TYPE_A: 1676 while ((c = getc(instr)) != EOF) { 1677 if (recvurg) 1678 goto got_oob; 1679 byte_count++; 1680 if (c == '\n') 1681 bare_lfs++; 1682 while (c == '\r') { 1683 if (ferror(outstr)) 1684 goto data_err; 1685 if ((c = getc(instr)) != '\n') { 1686 (void) putc ('\r', outstr); 1687 if (c == '\0' || c == EOF) 1688 goto contin2; 1689 } 1690 } 1691 (void) putc(c, outstr); 1692 contin2: ; 1693 } 1694 fflush(outstr); 1695 if (ferror(instr)) 1696 goto data_err; 1697 if (ferror(outstr)) 1698 goto file_err; 1699 transflag = 0; 1700 if (bare_lfs) { 1701 lreply(226, 1702 "WARNING! %d bare linefeeds received in ASCII mode", 1703 bare_lfs); 1704 printf(" File may not have transferred correctly.\r\n"); 1705 } 1706 return (0); 1707 default: 1708 reply(550, "Unimplemented TYPE %d in receive_data", type); 1709 transflag = 0; 1710 return (-1); 1711 } 1712 1713 data_err: 1714 transflag = 0; 1715 reply(426, "Data Connection"); 1716 return (-1); 1717 1718 file_err: 1719 transflag = 0; 1720 reply(452, "Error writing file"); 1721 return (-1); 1722 1723 got_oob: 1724 myoob(); 1725 recvurg = 0; 1726 transflag = 0; 1727 return (-1); 1728 } 1729 1730 void 1731 statfilecmd(char *filename) 1732 { 1733 FILE *fin; 1734 int c; 1735 int atstart; 1736 pid_t pid; 1737 char line[LINE_MAX]; 1738 1739 (void)snprintf(line, sizeof(line), "/bin/ls -lgA %s", filename); 1740 fin = ftpd_popen(line, "r", &pid); 1741 if (fin == NULL) { 1742 reply(451, "Local resource failure"); 1743 return; 1744 } 1745 lreply(211, "status of %s:", filename); 1746 atstart = 1; 1747 while ((c = getc(fin)) != EOF) { 1748 if (c == '\n') { 1749 if (ferror(stdout)){ 1750 perror_reply(421, "control connection"); 1751 (void) ftpd_pclose(fin, pid); 1752 dologout(1); 1753 /* NOTREACHED */ 1754 } 1755 if (ferror(fin)) { 1756 perror_reply(551, filename); 1757 (void) ftpd_pclose(fin, pid); 1758 return; 1759 } 1760 (void) putc('\r', stdout); 1761 } 1762 if (atstart && isdigit(c)) 1763 (void) putc(' ', stdout); 1764 (void) putc(c, stdout); 1765 atstart = (c == '\n'); 1766 } 1767 (void) ftpd_pclose(fin, pid); 1768 reply(211, "End of Status"); 1769 } 1770 1771 void 1772 statcmd(void) 1773 { 1774 union sockunion *su; 1775 u_char *a, *p; 1776 char hbuf[HOST_NAME_MAX+1]; 1777 int ispassive; 1778 int error; 1779 1780 lreply(211, "%s FTP server status:", hostname); 1781 error = getnameinfo((struct sockaddr *)&his_addr, his_addr.su_len, 1782 hbuf, sizeof(hbuf), NULL, 0, NI_NUMERICHOST); 1783 printf(" Connected to %s", remotehost); 1784 if (error == 0 && strcmp(remotehost, hbuf) != 0) 1785 printf(" (%s)", hbuf); 1786 printf("\r\n"); 1787 if (logged_in) { 1788 if (guest) 1789 printf(" Logged in anonymously\r\n"); 1790 else 1791 printf(" Logged in as %s\r\n", pw->pw_name); 1792 } else if (askpasswd) 1793 printf(" Waiting for password\r\n"); 1794 else 1795 printf(" Waiting for user name\r\n"); 1796 printf(" TYPE: %s", typenames[type]); 1797 if (type == TYPE_A || type == TYPE_E) 1798 printf(", FORM: %s", formnames[form]); 1799 if (type == TYPE_L) 1800 printf(" 8"); 1801 printf("; STRUcture: %s; transfer MODE: %s\r\n", 1802 strunames[stru], modenames[mode]); 1803 ispassive = 0; 1804 if (data != -1) 1805 printf(" Data connection open\r\n"); 1806 else if (pdata != -1) { 1807 printf(" in Passive mode\r\n"); 1808 su = (union sockunion *)&pasv_addr; 1809 ispassive++; 1810 goto printaddr; 1811 } else if (usedefault == 0) { 1812 size_t alen; 1813 int af, i; 1814 1815 su = (union sockunion *)&data_dest; 1816 printaddr: 1817 /* PASV/PORT */ 1818 if (su->su_family == AF_INET) { 1819 if (ispassive) 1820 printf("211- PASV "); 1821 else 1822 printf("211- PORT "); 1823 a = (u_char *)&su->su_sin.sin_addr; 1824 p = (u_char *)&su->su_sin.sin_port; 1825 printf("(%u,%u,%u,%u,%u,%u)\r\n", 1826 a[0], a[1], a[2], a[3], 1827 p[0], p[1]); 1828 } 1829 1830 /* LPSV/LPRT */ 1831 alen = 0; 1832 switch (su->su_family) { 1833 case AF_INET: 1834 a = (u_char *)&su->su_sin.sin_addr; 1835 p = (u_char *)&su->su_sin.sin_port; 1836 alen = sizeof(su->su_sin.sin_addr); 1837 af = 4; 1838 break; 1839 case AF_INET6: 1840 a = (u_char *)&su->su_sin6.sin6_addr; 1841 p = (u_char *)&su->su_sin6.sin6_port; 1842 alen = sizeof(su->su_sin6.sin6_addr); 1843 af = 6; 1844 break; 1845 default: 1846 af = 0; 1847 break; 1848 } 1849 if (af) { 1850 if (ispassive) 1851 printf("211- LPSV "); 1852 else 1853 printf("211- LPRT "); 1854 printf("(%u,%llu", af, (unsigned long long)alen); 1855 for (i = 0; i < alen; i++) 1856 printf(",%u", a[i]); 1857 printf(",%u,%u,%u)\r\n", 2, p[0], p[1]); 1858 } 1859 1860 /* EPRT/EPSV */ 1861 switch (su->su_family) { 1862 case AF_INET: 1863 af = 1; 1864 break; 1865 case AF_INET6: 1866 af = 2; 1867 break; 1868 default: 1869 af = 0; 1870 break; 1871 } 1872 if (af) { 1873 char pbuf[10]; 1874 union sockunion tmp = *su; 1875 1876 if (tmp.su_family == AF_INET6) 1877 tmp.su_sin6.sin6_scope_id = 0; 1878 if (getnameinfo((struct sockaddr *)&tmp, tmp.su_len, 1879 hbuf, sizeof(hbuf), pbuf, sizeof(pbuf), 1880 NI_NUMERICHOST | NI_NUMERICSERV) == 0) { 1881 if (ispassive) 1882 printf("211- EPSV "); 1883 else 1884 printf("211- EPRT "); 1885 printf("(|%u|%s|%s|)\r\n", 1886 af, hbuf, pbuf); 1887 } 1888 } 1889 } else 1890 printf(" No data connection\r\n"); 1891 reply(211, "End of status"); 1892 } 1893 1894 void 1895 fatal(char *s) 1896 { 1897 1898 reply(451, "Error in server: %s", s); 1899 reply(221, "Closing connection due to server error."); 1900 dologout(0); 1901 /* NOTREACHED */ 1902 } 1903 1904 void 1905 reply(int n, const char *fmt, ...) 1906 { 1907 char *buf, *p, *next; 1908 int rval; 1909 va_list ap; 1910 1911 va_start(ap, fmt); 1912 rval = vasprintf(&buf, fmt, ap); 1913 va_end(ap); 1914 if (rval == -1 || buf == NULL) { 1915 printf("421 Local resource failure: malloc\r\n"); 1916 fflush(stdout); 1917 dologout(1); 1918 } 1919 next = buf; 1920 while ((p = strsep(&next, "\n\r"))) { 1921 printf("%d%s %s\r\n", n, (next != NULL) ? "-" : "", p); 1922 if (debug) 1923 syslog(LOG_DEBUG, "<--- %d%s %s", n, 1924 (next != NULL) ? "-" : "", p); 1925 } 1926 (void)fflush(stdout); 1927 free(buf); 1928 } 1929 1930 1931 void 1932 reply_r(int n, const char *fmt, ...) 1933 { 1934 char *p, *next; 1935 char msg[BUFSIZ]; 1936 char buf[BUFSIZ]; 1937 va_list ap; 1938 struct syslog_data sdata = SYSLOG_DATA_INIT; 1939 1940 sdata.log_fac = LOG_FTP; 1941 va_start(ap, fmt); 1942 vsnprintf(msg, sizeof(msg), fmt, ap); 1943 va_end(ap); 1944 1945 next = msg; 1946 1947 while ((p = strsep(&next, "\n\r"))) { 1948 snprintf(buf, sizeof(buf), "%d%s %s\r\n", n, 1949 (next != NULL) ? "-" : "", p); 1950 write(STDOUT_FILENO, buf, strlen(buf)); 1951 if (debug) { 1952 buf[strlen(buf) - 2] = '\0'; 1953 syslog_r(LOG_DEBUG, &sdata, "<--- %s", buf); 1954 } 1955 } 1956 } 1957 1958 void 1959 lreply(int n, const char *fmt, ...) 1960 { 1961 va_list ap; 1962 1963 va_start(ap, fmt); 1964 (void)printf("%d- ", n); 1965 (void)vprintf(fmt, ap); 1966 va_end(ap); 1967 (void)printf("\r\n"); 1968 (void)fflush(stdout); 1969 if (debug) { 1970 va_start(ap, fmt); 1971 syslog(LOG_DEBUG, "<--- %d- ", n); 1972 vsyslog(LOG_DEBUG, fmt, ap); 1973 va_end(ap); 1974 } 1975 } 1976 1977 static void 1978 ack(char *s) 1979 { 1980 1981 reply(250, "%s command successful.", s); 1982 } 1983 1984 void 1985 nack(char *s) 1986 { 1987 1988 reply(502, "%s command not implemented.", s); 1989 } 1990 1991 /* ARGSUSED */ 1992 void 1993 yyerror(char *s) 1994 { 1995 cbuf[strcspn(cbuf, "\n")] = '\0'; 1996 reply(500, "'%s': command not understood.", cbuf); 1997 } 1998 1999 void 2000 delete(char *name) 2001 { 2002 struct stat st; 2003 2004 LOGCMD("delete", name); 2005 if (stat(name, &st) < 0) { 2006 perror_reply(550, name); 2007 return; 2008 } 2009 if ((st.st_mode&S_IFMT) == S_IFDIR) { 2010 if (rmdir(name) < 0) { 2011 perror_reply(550, name); 2012 return; 2013 } 2014 goto done; 2015 } 2016 if (unlink(name) < 0) { 2017 perror_reply(550, name); 2018 return; 2019 } 2020 done: 2021 ack("DELE"); 2022 } 2023 2024 void 2025 cwd(char *path) 2026 { 2027 FILE *message; 2028 2029 if (chdir(path) < 0) 2030 perror_reply(550, path); 2031 else { 2032 if ((message = fopen(_PATH_CWDMESG, "r")) != NULL) { 2033 char line[LINE_MAX]; 2034 2035 while (fgets(line, sizeof(line), message) != NULL) { 2036 line[strcspn(line, "\n")] = '\0'; 2037 lreply(250, "%s", line); 2038 } 2039 (void) fflush(stdout); 2040 (void) fclose(message); 2041 } 2042 ack("CWD"); 2043 } 2044 } 2045 2046 void 2047 replydirname(const char *name, const char *message) 2048 { 2049 char *p, *ep; 2050 char npath[PATH_MAX * 2]; 2051 2052 p = npath; 2053 ep = &npath[sizeof(npath) - 1]; 2054 while (*name) { 2055 if (*name == '"') { 2056 if (ep - p < 2) 2057 break; 2058 *p++ = *name++; 2059 *p++ = '"'; 2060 } else { 2061 if (ep - p < 1) 2062 break; 2063 *p++ = *name++; 2064 } 2065 } 2066 *p = '\0'; 2067 reply(257, "\"%s\" %s", npath, message); 2068 } 2069 2070 void 2071 makedir(char *name) 2072 { 2073 2074 LOGCMD("mkdir", name); 2075 if (mkdir(name, 0777) < 0) 2076 perror_reply(550, name); 2077 else 2078 replydirname(name, "directory created."); 2079 } 2080 2081 void 2082 removedir(char *name) 2083 { 2084 2085 LOGCMD("rmdir", name); 2086 if (rmdir(name) < 0) 2087 perror_reply(550, name); 2088 else 2089 ack("RMD"); 2090 } 2091 2092 void 2093 pwd(void) 2094 { 2095 char path[PATH_MAX]; 2096 2097 if (getcwd(path, sizeof(path)) == NULL) 2098 perror_reply(550, "Can't get current directory"); 2099 else 2100 replydirname(path, "is current directory."); 2101 } 2102 2103 char * 2104 renamefrom(char *name) 2105 { 2106 struct stat st; 2107 2108 if (stat(name, &st) < 0) { 2109 perror_reply(550, name); 2110 return (NULL); 2111 } 2112 reply(350, "File exists, ready for destination name"); 2113 return (name); 2114 } 2115 2116 void 2117 renamecmd(char *from, char *to) 2118 { 2119 2120 LOGCMD2("rename", from, to); 2121 if (rename(from, to) < 0) 2122 perror_reply(550, "rename"); 2123 else 2124 ack("RNTO"); 2125 } 2126 2127 static void 2128 dolog(struct sockaddr *sa) 2129 { 2130 char hbuf[sizeof(remotehost)]; 2131 2132 if (getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), NULL, 0, 0) == 0) 2133 (void) strlcpy(remotehost, hbuf, sizeof(remotehost)); 2134 else 2135 (void) strlcpy(remotehost, "unknown", sizeof(remotehost)); 2136 2137 snprintf(proctitle, sizeof(proctitle), "%s: connected", remotehost); 2138 setproctitle("%s", proctitle); 2139 2140 if (logging) { 2141 int error; 2142 error = getnameinfo(sa, sa->sa_len, hbuf, sizeof(hbuf), 2143 NULL, 0, NI_NUMERICHOST); 2144 syslog(LOG_INFO, "connection from %s [%s]", remotehost, 2145 error ? gai_strerror(error) : hbuf); 2146 } 2147 } 2148 2149 /* 2150 * Record logout in wtmp file and exit with supplied status. 2151 * NOTE: because this is called from signal handlers it cannot 2152 * use stdio (or call other functions that use stdio). 2153 */ 2154 void 2155 dologout(int status) 2156 { 2157 2158 transflag = 0; 2159 2160 if (logged_in) { 2161 sigprocmask(SIG_BLOCK, &allsigs, NULL); 2162 if (!nowtmp) 2163 ftpdlogwtmp(ttyline, "", ""); 2164 if (doutmp) 2165 ftpd_logout(utmp.ut_line); 2166 } 2167 /* beware of flushing buffers after a SIGPIPE */ 2168 _exit(status); 2169 } 2170 2171 /*ARGSUSED*/ 2172 static void 2173 sigurg(int signo) 2174 { 2175 2176 recvurg = 1; 2177 } 2178 2179 static void 2180 myoob(void) 2181 { 2182 char *cp; 2183 int ret; 2184 2185 /* only process if transfer occurring */ 2186 if (!transflag) 2187 return; 2188 cp = tmpline; 2189 ret = get_line(cp, sizeof(tmpline)-1, stdin); 2190 if (ret == -1) { 2191 reply(221, "You could at least say goodbye."); 2192 dologout(0); 2193 } else if (ret == -2) { 2194 /* Ignore truncated command */ 2195 return; 2196 } 2197 upper(cp); 2198 if (strcmp(cp, "ABOR\r\n") == 0) { 2199 tmpline[0] = '\0'; 2200 reply(426, "Transfer aborted. Data connection closed."); 2201 reply(226, "Abort successful"); 2202 } 2203 if (strcmp(cp, "STAT\r\n") == 0) { 2204 tmpline[0] = '\0'; 2205 if (file_size != -1) 2206 reply(213, "Status: %lld of %lld bytes transferred", 2207 (long long)byte_count, (long long)file_size); 2208 else 2209 reply(213, "Status: %lld bytes transferred", 2210 (long long)byte_count); 2211 } 2212 } 2213 2214 /* 2215 * Note: a response of 425 is not mentioned as a possible response to 2216 * the PASV command in RFC959. However, it has been blessed as 2217 * a legitimate response by Jon Postel in a telephone conversation 2218 * with Rick Adams on 25 Jan 89. 2219 */ 2220 void 2221 passive(void) 2222 { 2223 socklen_t len; 2224 int on = 1; 2225 u_char *p, *a; 2226 2227 if (pw == NULL) { 2228 reply(530, "Please login with USER and PASS"); 2229 return; 2230 } 2231 if (pdata >= 0) 2232 close(pdata); 2233 /* 2234 * XXX 2235 * At this point, it would be nice to have an algorithm that 2236 * inserted a growing delay in an attack scenario. Such a thing 2237 * would look like continual passive sockets being opened, but 2238 * nothing serious being done with them. They're not used to 2239 * move data; the entire attempt is just to use tcp FIN_WAIT 2240 * resources. 2241 */ 2242 pdata = socket(AF_INET, SOCK_STREAM, 0); 2243 if (pdata < 0) { 2244 perror_reply(425, "Can't open passive connection"); 2245 return; 2246 } 2247 2248 if (setsockopt(pdata, SOL_SOCKET, SO_KEEPALIVE, 2249 &on, sizeof(on)) < 0) 2250 goto pasv_error; 2251 2252 on = IP_PORTRANGE_HIGH; 2253 if (setsockopt(pdata, IPPROTO_IP, IP_PORTRANGE, 2254 &on, sizeof(on)) < 0) 2255 goto pasv_error; 2256 2257 pasv_addr = ctrl_addr; 2258 pasv_addr.su_sin.sin_port = 0; 2259 if (bind(pdata, (struct sockaddr *)&pasv_addr, 2260 pasv_addr.su_len) < 0) 2261 goto pasv_error; 2262 2263 len = sizeof(pasv_addr); 2264 if (getsockname(pdata, (struct sockaddr *)&pasv_addr, &len) < 0) 2265 goto pasv_error; 2266 if (listen(pdata, 1) < 0) 2267 goto pasv_error; 2268 a = (u_char *)&pasv_addr.su_sin.sin_addr; 2269 p = (u_char *)&pasv_addr.su_sin.sin_port; 2270 2271 reply(227, "Entering Passive Mode (%u,%u,%u,%u,%u,%u)", a[0], 2272 a[1], a[2], a[3], p[0], p[1]); 2273 return; 2274 2275 pasv_error: 2276 perror_reply(425, "Can't open passive connection"); 2277 (void) close(pdata); 2278 pdata = -1; 2279 return; 2280 } 2281 2282 int 2283 epsvproto2af(int proto) 2284 { 2285 2286 switch (proto) { 2287 case 1: return AF_INET; 2288 case 2: return AF_INET6; 2289 default: return -1; 2290 } 2291 } 2292 2293 int 2294 af2epsvproto(int af) 2295 { 2296 2297 switch (af) { 2298 case AF_INET: return 1; 2299 case AF_INET6: return 2; 2300 default: return -1; 2301 } 2302 } 2303 2304 /* 2305 * 228 Entering Long Passive Mode (af, hal, h1, h2, h3,..., pal, p1, p2...) 2306 * 229 Entering Extended Passive Mode (|||port|) 2307 */ 2308 void 2309 long_passive(char *cmd, int pf) 2310 { 2311 socklen_t len; 2312 int on = 1; 2313 u_char *p, *a; 2314 2315 if (!logged_in) { 2316 syslog(LOG_NOTICE, "long passive but not logged in"); 2317 reply(503, "Login with USER first."); 2318 return; 2319 } 2320 2321 if (pf != PF_UNSPEC && ctrl_addr.su_family != pf) { 2322 /* 2323 * XXX 2324 * only EPRT/EPSV ready clients will understand this 2325 */ 2326 if (strcmp(cmd, "EPSV") != 0) 2327 reply(501, "Network protocol mismatch"); /*XXX*/ 2328 else 2329 epsv_protounsupp("Network protocol mismatch"); 2330 2331 return; 2332 } 2333 2334 if (pdata >= 0) 2335 close(pdata); 2336 /* 2337 * XXX 2338 * At this point, it would be nice to have an algorithm that 2339 * inserted a growing delay in an attack scenario. Such a thing 2340 * would look like continual passive sockets being opened, but 2341 * nothing serious being done with them. They not used to move 2342 * data; the entire attempt is just to use tcp FIN_WAIT 2343 * resources. 2344 */ 2345 pdata = socket(ctrl_addr.su_family, SOCK_STREAM, 0); 2346 if (pdata < 0) { 2347 perror_reply(425, "Can't open passive connection"); 2348 return; 2349 } 2350 2351 if (setsockopt(pdata, SOL_SOCKET, SO_KEEPALIVE, 2352 &on, sizeof(on)) < 0) 2353 goto pasv_error; 2354 2355 switch (ctrl_addr.su_family) { 2356 case AF_INET: 2357 on = IP_PORTRANGE_HIGH; 2358 if (setsockopt(pdata, IPPROTO_IP, IP_PORTRANGE, 2359 &on, sizeof(on)) < 0) 2360 goto pasv_error; 2361 break; 2362 case AF_INET6: 2363 on = IPV6_PORTRANGE_HIGH; 2364 if (setsockopt(pdata, IPPROTO_IPV6, IPV6_PORTRANGE, 2365 &on, sizeof(on)) < 0) 2366 goto pasv_error; 2367 break; 2368 } 2369 2370 pasv_addr = ctrl_addr; 2371 pasv_addr.su_port = 0; 2372 if (bind(pdata, (struct sockaddr *)&pasv_addr, pasv_addr.su_len) < 0) 2373 goto pasv_error; 2374 len = pasv_addr.su_len; 2375 if (getsockname(pdata, (struct sockaddr *)&pasv_addr, &len) < 0) 2376 goto pasv_error; 2377 if (listen(pdata, 1) < 0) 2378 goto pasv_error; 2379 p = (u_char *)&pasv_addr.su_port; 2380 2381 if (strcmp(cmd, "LPSV") == 0) { 2382 switch (pasv_addr.su_family) { 2383 case AF_INET: 2384 a = (u_char *)&pasv_addr.su_sin.sin_addr; 2385 reply(228, 2386 "Entering Long Passive Mode (%u,%u,%u,%u,%u,%u,%u,%u,%u)", 2387 4, 4, a[0], a[1], a[2], a[3], 2, p[0], p[1]); 2388 return; 2389 case AF_INET6: 2390 a = (u_char *)&pasv_addr.su_sin6.sin6_addr; 2391 reply(228, 2392 "Entering Long Passive Mode (%u,%u,%u,%u,%u,%u," 2393 "%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u,%u)", 2394 6, 16, a[0], a[1], a[2], a[3], a[4], 2395 a[5], a[6], a[7], a[8], a[9], a[10], 2396 a[11], a[12], a[13], a[14], a[15], 2397 2, p[0], p[1]); 2398 return; 2399 } 2400 } else if (strcmp(cmd, "EPSV") == 0) { 2401 switch (pasv_addr.su_family) { 2402 case AF_INET: 2403 case AF_INET6: 2404 reply(229, "Entering Extended Passive Mode (|||%u|)", 2405 ntohs(pasv_addr.su_port)); 2406 return; 2407 } 2408 } else { 2409 /* more proper error code? */ 2410 } 2411 2412 pasv_error: 2413 perror_reply(425, "Can't open passive connection"); 2414 (void) close(pdata); 2415 pdata = -1; 2416 return; 2417 } 2418 2419 /* 2420 * EPRT |proto|addr|port| 2421 */ 2422 int 2423 extended_port(const char *arg) 2424 { 2425 char *tmp = NULL; 2426 char *result[3]; 2427 char *p, *q; 2428 char delim; 2429 struct addrinfo hints; 2430 struct addrinfo *res = NULL; 2431 int i; 2432 unsigned long proto; 2433 2434 if (epsvall) { 2435 reply(501, "EPRT disallowed after EPSV ALL"); 2436 return -1; 2437 } 2438 2439 usedefault = 0; 2440 if (pdata >= 0) { 2441 (void) close(pdata); 2442 pdata = -1; 2443 } 2444 2445 tmp = strdup(arg); 2446 if (!tmp) { 2447 fatal("not enough core."); 2448 /*NOTREACHED*/ 2449 } 2450 p = tmp; 2451 delim = p[0]; 2452 p++; 2453 memset(result, 0, sizeof(result)); 2454 for (i = 0; i < 3; i++) { 2455 q = strchr(p, delim); 2456 if (!q || *q != delim) 2457 goto parsefail; 2458 *q++ = '\0'; 2459 result[i] = p; 2460 p = q; 2461 } 2462 2463 /* some more sanity check */ 2464 p = NULL; 2465 (void)strtoul(result[2], &p, 10); 2466 if (!*result[2] || *p) 2467 goto protounsupp; 2468 p = NULL; 2469 proto = strtoul(result[0], &p, 10); 2470 if (!*result[0] || *p) 2471 goto protounsupp; 2472 2473 memset(&hints, 0, sizeof(hints)); 2474 hints.ai_family = epsvproto2af((int)proto); 2475 if (hints.ai_family < 0) 2476 goto protounsupp; 2477 hints.ai_socktype = SOCK_STREAM; 2478 hints.ai_flags = AI_NUMERICHOST; /*no DNS*/ 2479 if (getaddrinfo(result[1], result[2], &hints, &res)) 2480 goto parsefail; 2481 if (res->ai_next) 2482 goto parsefail; 2483 if (sizeof(data_dest) < res->ai_addrlen) 2484 goto parsefail; 2485 memcpy(&data_dest, res->ai_addr, res->ai_addrlen); 2486 if (his_addr.su_family == AF_INET6 && 2487 data_dest.su_family == AF_INET6) { 2488 /* XXX more sanity checks! */ 2489 data_dest.su_sin6.sin6_scope_id = 2490 his_addr.su_sin6.sin6_scope_id; 2491 } 2492 if (pdata >= 0) { 2493 (void) close(pdata); 2494 pdata = -1; 2495 } 2496 reply(200, "EPRT command successful."); 2497 2498 free(tmp); 2499 if (res) 2500 freeaddrinfo(res); 2501 return 0; 2502 2503 parsefail: 2504 reply(500, "Invalid argument, rejected."); 2505 usedefault = 1; 2506 free(tmp); 2507 if (res) 2508 freeaddrinfo(res); 2509 return -1; 2510 2511 protounsupp: 2512 epsv_protounsupp("Protocol not supported"); 2513 usedefault = 1; 2514 free(tmp); 2515 if (res) 2516 freeaddrinfo(res); 2517 return -1; 2518 } 2519 2520 /* 2521 * 522 Protocol not supported (proto,...) 2522 * as we assume address family for control and data connections are the same, 2523 * we do not return the list of address families we support - instead, we 2524 * return the address family of the control connection. 2525 */ 2526 void 2527 epsv_protounsupp(const char *message) 2528 { 2529 int proto; 2530 2531 proto = af2epsvproto(ctrl_addr.su_family); 2532 if (proto < 0) 2533 reply(501, "%s", message); /*XXX*/ 2534 else 2535 reply(522, "%s, use (%d)", message, proto); 2536 } 2537 2538 /* 2539 * Generate unique name for file with basename "local". 2540 * The file named "local" is already known to exist. 2541 * Generates failure reply on error. 2542 */ 2543 static int 2544 guniquefd(char *local, char **nam) 2545 { 2546 static char new[PATH_MAX]; 2547 struct stat st; 2548 int count, len, fd; 2549 char *cp; 2550 2551 cp = strrchr(local, '/'); 2552 if (cp) 2553 *cp = '\0'; 2554 if (stat(cp ? local : ".", &st) < 0) { 2555 perror_reply(553, cp ? local : "."); 2556 return (-1); 2557 } 2558 if (cp) 2559 *cp = '/'; 2560 len = strlcpy(new, local, sizeof(new)); 2561 if (len+2+1 >= sizeof(new)-1) 2562 return (-1); 2563 cp = new + len; 2564 *cp++ = '.'; 2565 for (count = 1; count < 100; count++) { 2566 (void)snprintf(cp, sizeof(new) - (cp - new), "%d", count); 2567 fd = open(new, O_RDWR|O_CREAT|O_EXCL, 0666); 2568 if (fd == -1) 2569 continue; 2570 if (nam) 2571 *nam = new; 2572 return (fd); 2573 } 2574 reply(452, "Unique file name cannot be created."); 2575 return (-1); 2576 } 2577 2578 /* 2579 * Format and send reply containing system error number. 2580 */ 2581 void 2582 perror_reply(int code, char *string) 2583 { 2584 2585 reply(code, "%s: %s.", string, strerror(errno)); 2586 } 2587 2588 static char *onefile[] = { 2589 "", 2590 0 2591 }; 2592 2593 void 2594 send_file_list(char *whichf) 2595 { 2596 struct stat st; 2597 DIR *dirp = NULL; 2598 struct dirent *dir; 2599 FILE *dout = NULL; 2600 char **dirlist; 2601 char *dirname; 2602 int simple = 0; 2603 volatile int freeglob = 0; 2604 glob_t gl; 2605 size_t prefixlen; 2606 2607 if (strpbrk(whichf, "~{[*?") != NULL) { 2608 memset(&gl, 0, sizeof(gl)); 2609 freeglob = 1; 2610 if (glob(whichf, 2611 GLOB_BRACE|GLOB_NOCHECK|GLOB_QUOTE|GLOB_TILDE|GLOB_LIMIT, 2612 0, &gl)) { 2613 reply(550, "not found"); 2614 goto out; 2615 } else if (gl.gl_pathc == 0) { 2616 errno = ENOENT; 2617 perror_reply(550, whichf); 2618 goto out; 2619 } 2620 dirlist = gl.gl_pathv; 2621 } else { 2622 onefile[0] = whichf; 2623 dirlist = onefile; 2624 simple = 1; 2625 } 2626 2627 while ((dirname = *dirlist++)) { 2628 if (stat(dirname, &st) < 0) { 2629 /* 2630 * If user typed "ls -l", etc, and the client 2631 * used NLST, do what the user meant. 2632 */ 2633 if (dirname[0] == '-' && *dirlist == NULL && 2634 transflag == 0) { 2635 retrieve("/bin/ls %s", dirname); 2636 goto out; 2637 } 2638 perror_reply(550, whichf); 2639 if (dout != NULL) { 2640 (void) fclose(dout); 2641 transflag = 0; 2642 data = -1; 2643 pdata = -1; 2644 } 2645 goto out; 2646 } 2647 2648 if (S_ISREG(st.st_mode)) { 2649 if (dout == NULL) { 2650 dout = dataconn("file list", -1, "w"); 2651 if (dout == NULL) 2652 goto out; 2653 transflag++; 2654 } 2655 fprintf(dout, "%s%s\n", dirname, 2656 type == TYPE_A ? "\r" : ""); 2657 byte_count += strlen(dirname) + 1; 2658 continue; 2659 } else if (!S_ISDIR(st.st_mode)) 2660 continue; 2661 2662 if ((dirp = opendir(dirname)) == NULL) 2663 continue; 2664 2665 if (dirname[0] == '.' && dirname[1] == '\0') 2666 prefixlen = 0; 2667 else 2668 prefixlen = strlen(dirname) + 1; 2669 while ((dir = readdir(dirp)) != NULL) { 2670 if (recvurg) { 2671 myoob(); 2672 recvurg = 0; 2673 transflag = 0; 2674 goto out; 2675 } 2676 2677 if (dir->d_name[0] == '.' && dir->d_namlen == 1) 2678 continue; 2679 if (dir->d_name[0] == '.' && dir->d_name[1] == '.' && 2680 dir->d_namlen == 2) 2681 continue; 2682 2683 /* 2684 * We have to do a stat to insure it's 2685 * not a directory or special file. 2686 */ 2687 if (simple || 2688 (fstatat(dirfd(dirp), dir->d_name, &st, 0) == 0 && 2689 S_ISREG(st.st_mode))) { 2690 if (dout == NULL) { 2691 dout = dataconn("file list", -1, "w"); 2692 if (dout == NULL) 2693 goto out; 2694 transflag++; 2695 } 2696 2697 if (prefixlen) { 2698 fprintf(dout, "%s/", dirname); 2699 byte_count += prefixlen; 2700 } 2701 fprintf(dout, "%s%s\n", dir->d_name, 2702 type == TYPE_A ? "\r" : ""); 2703 byte_count += dir->d_namlen + 1; 2704 } 2705 } 2706 (void) closedir(dirp); 2707 } 2708 2709 if (dout == NULL) 2710 reply(550, "No files found."); 2711 else if (ferror(dout) != 0) 2712 perror_reply(550, "Data connection"); 2713 else 2714 reply(226, "Transfer complete."); 2715 2716 transflag = 0; 2717 if (dout != NULL) 2718 (void) fclose(dout); 2719 else { 2720 if (pdata >= 0) 2721 close(pdata); 2722 } 2723 data = -1; 2724 pdata = -1; 2725 out: 2726 if (freeglob) { 2727 freeglob = 0; 2728 globfree(&gl); 2729 } 2730 } 2731 2732 /*ARGSUSED*/ 2733 static void 2734 reapchild(int signo) 2735 { 2736 int save_errno = errno; 2737 int rval; 2738 2739 do { 2740 rval = waitpid(-1, NULL, WNOHANG); 2741 } while (rval > 0 || (rval == -1 && errno == EINTR)); 2742 errno = save_errno; 2743 } 2744 2745 void 2746 logxfer(char *name, off_t size, time_t start) 2747 { 2748 char buf[400 + (HOST_NAME_MAX+1)*4 + PATH_MAX*4]; 2749 char dir[PATH_MAX], path[PATH_MAX], rpath[PATH_MAX]; 2750 char vremotehost[(HOST_NAME_MAX+1)*4], vpath[PATH_MAX*4]; 2751 char *vpw; 2752 time_t now; 2753 int len; 2754 2755 if ((statfd >= 0) && (getcwd(dir, sizeof(dir)) != NULL)) { 2756 time(&now); 2757 2758 vpw = malloc(strlen(guest ? guestpw : pw->pw_name) * 4 + 1); 2759 if (vpw == NULL) 2760 return; 2761 2762 snprintf(path, sizeof(path), "%s/%s", dir, name); 2763 if (realpath(path, rpath) == NULL) 2764 strlcpy(rpath, path, sizeof(rpath)); 2765 strvis(vpath, rpath, VIS_SAFE|VIS_NOSLASH); 2766 2767 strvis(vremotehost, remotehost, VIS_SAFE|VIS_NOSLASH); 2768 strvis(vpw, guest? guestpw : pw->pw_name, VIS_SAFE|VIS_NOSLASH); 2769 2770 len = snprintf(buf, sizeof(buf), 2771 "%.24s %lld %s %lld %s %c %s %c %c %s ftp %d %s %s\n", 2772 ctime(&now), (long long)(now - start + (now == start)), 2773 vremotehost, (long long)size, vpath, 2774 ((type == TYPE_A) ? 'a' : 'b'), "*" /* none yet */, 2775 'o', ((guest) ? 'a' : 'r'), 2776 vpw, 0 /* none yet */, 2777 ((guest) ? "*" : pw->pw_name), dhostname); 2778 free(vpw); 2779 2780 if (len >= sizeof(buf) || len == -1) { 2781 if ((len = strlen(buf)) == 0) 2782 return; /* should not happen */ 2783 buf[len - 1] = '\n'; 2784 } 2785 write(statfd, buf, len); 2786 } 2787 } 2788 2789 void 2790 set_slave_signals(void) 2791 { 2792 struct sigaction sa; 2793 2794 sigemptyset(&sa.sa_mask); 2795 sa.sa_flags = SA_RESTART; 2796 2797 sa.sa_handler = SIG_DFL; 2798 (void) sigaction(SIGCHLD, &sa, NULL); 2799 2800 sa.sa_handler = sigurg; 2801 sa.sa_flags = 0; /* don't restart syscalls for SIGURG */ 2802 (void) sigaction(SIGURG, &sa, NULL); 2803 2804 sigfillset(&sa.sa_mask); /* block all signals in handler */ 2805 sa.sa_flags = SA_RESTART; 2806 sa.sa_handler = sigquit; 2807 (void) sigaction(SIGHUP, &sa, NULL); 2808 (void) sigaction(SIGINT, &sa, NULL); 2809 (void) sigaction(SIGQUIT, &sa, NULL); 2810 (void) sigaction(SIGTERM, &sa, NULL); 2811 2812 sa.sa_handler = lostconn; 2813 (void) sigaction(SIGPIPE, &sa, NULL); 2814 2815 sa.sa_handler = toolong; 2816 (void) sigaction(SIGALRM, &sa, NULL); 2817 2818 if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1) 2819 syslog(LOG_ERR, "fcntl F_SETOWN: %m"); 2820 } 2821 2822 /* 2823 * Allocate space and return a copy of the specified dir. 2824 * If 'dir' begins with a tilde (~), expand it. 2825 */ 2826 char * 2827 copy_dir(char *dir, struct passwd *pw) 2828 { 2829 char *cp; 2830 char *newdir; 2831 char *user = NULL; 2832 2833 /* Nothing to expand */ 2834 if (dir[0] != '~') 2835 return (strdup(dir)); 2836 2837 /* "dir" is of form ~user/some/dir, lookup user. */ 2838 if (dir[1] != '/' && dir[1] != '\0') { 2839 if ((cp = strchr(dir + 1, '/')) == NULL) 2840 cp = dir + strlen(dir); 2841 if ((user = malloc((size_t)(cp - dir))) == NULL) 2842 return (NULL); 2843 strlcpy(user, dir + 1, (size_t)(cp - dir)); 2844 2845 /* Only do lookup if it is a different user. */ 2846 if (strcmp(user, pw->pw_name) != 0) { 2847 if ((pw = getpwnam(user)) == NULL) { 2848 /* No such user, interpret literally */ 2849 free(user); 2850 return(strdup(dir)); 2851 } 2852 } 2853 free(user); 2854 } 2855 2856 /* 2857 * If there is no directory separator (/) then it is just pw_dir. 2858 * Otherwise, replace ~foo with pw_dir. 2859 */ 2860 if ((cp = strchr(dir + 1, '/')) == NULL) { 2861 newdir = strdup(pw->pw_dir); 2862 } else { 2863 if (asprintf(&newdir, "%s%s", pw->pw_dir, cp) == -1) 2864 return (NULL); 2865 } 2866 2867 return(newdir); 2868 } 2869