1 /* 2 * Copyright (c) 1985, 1988 Regents of the University of California. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms are permitted 6 * provided that the above copyright notice and this paragraph are 7 * duplicated in all such forms and that any documentation, 8 * advertising materials, and other materials related to such 9 * distribution and use acknowledge that the software was developed 10 * by the University of California, Berkeley. The name of the 11 * University may not be used to endorse or promote products derived 12 * from this software without specific prior written permission. 13 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 14 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 15 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 16 */ 17 18 #ifndef lint 19 char copyright[] = 20 "@(#) Copyright (c) 1985, 1988 Regents of the University of California.\n\ 21 All rights reserved.\n"; 22 #endif /* not lint */ 23 24 #ifndef lint 25 static char sccsid[] = "@(#)ftpd.c 5.22 (Berkeley) 12/19/88"; 26 #endif /* not lint */ 27 28 /* 29 * FTP server. 30 */ 31 #include <sys/param.h> 32 #include <sys/stat.h> 33 #include <sys/ioctl.h> 34 #include <sys/socket.h> 35 #include <sys/file.h> 36 #include <sys/wait.h> 37 38 #include <netinet/in.h> 39 40 #include <arpa/ftp.h> 41 #include <arpa/inet.h> 42 #include <arpa/telnet.h> 43 44 #include <stdio.h> 45 #include <signal.h> 46 #include <pwd.h> 47 #include <setjmp.h> 48 #include <netdb.h> 49 #include <errno.h> 50 #include <strings.h> 51 #include <syslog.h> 52 #include <varargs.h> 53 54 /* 55 * File containing login names 56 * NOT to be used on this machine. 57 * Commonly used to disallow uucp. 58 */ 59 #define FTPUSERS "/etc/ftpusers" 60 61 extern int errno; 62 extern char *sys_errlist[]; 63 extern int sys_nerr; 64 extern char *crypt(); 65 extern char version[]; 66 extern char *home; /* pointer to home directory for glob */ 67 extern FILE *ftpd_popen(), *fopen(), *freopen(); 68 extern int ftpd_pclose(), fclose(); 69 extern char *getline(); 70 extern char cbuf[]; 71 72 struct sockaddr_in ctrl_addr; 73 struct sockaddr_in data_source; 74 struct sockaddr_in data_dest; 75 struct sockaddr_in his_addr; 76 77 int data; 78 jmp_buf errcatch, urgcatch; 79 int logged_in; 80 struct passwd *pw; 81 int debug; 82 int timeout = 900; /* timeout after 15 minutes of inactivity */ 83 int logging; 84 int guest; 85 int type; 86 int form; 87 int stru; /* avoid C keyword */ 88 int mode; 89 int usedefault = 1; /* for data transfers */ 90 int pdata = -1; /* for passive mode */ 91 int transflag; 92 char tmpline[7]; 93 char hostname[MAXHOSTNAMELEN]; 94 char remotehost[MAXHOSTNAMELEN]; 95 96 /* 97 * Timeout intervals for retrying connections 98 * to hosts that don't accept PORT cmds. This 99 * is a kludge, but given the problems with TCP... 100 */ 101 #define SWAITMAX 90 /* wait at most 90 seconds */ 102 #define SWAITINT 5 /* interval between retries */ 103 104 int swaitmax = SWAITMAX; 105 int swaitint = SWAITINT; 106 107 int lostconn(); 108 int myoob(); 109 FILE *getdatasock(), *dataconn(); 110 111 main(argc, argv) 112 int argc; 113 char *argv[]; 114 { 115 int addrlen, on = 1; 116 char *cp; 117 118 addrlen = sizeof (his_addr); 119 if (getpeername(0, (struct sockaddr *)&his_addr, &addrlen) < 0) { 120 syslog(LOG_ERR, "getpeername (%s): %m",argv[0]); 121 exit(1); 122 } 123 addrlen = sizeof (ctrl_addr); 124 if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) { 125 syslog(LOG_ERR, "getsockname (%s): %m",argv[0]); 126 exit(1); 127 } 128 data_source.sin_port = htons(ntohs(ctrl_addr.sin_port) - 1); 129 debug = 0; 130 openlog("ftpd", LOG_PID, LOG_DAEMON); 131 argc--, argv++; 132 while (argc > 0 && *argv[0] == '-') { 133 for (cp = &argv[0][1]; *cp; cp++) switch (*cp) { 134 135 case 'v': 136 debug = 1; 137 break; 138 139 case 'd': 140 debug = 1; 141 break; 142 143 case 'l': 144 logging = 1; 145 break; 146 147 case 't': 148 timeout = atoi(++cp); 149 goto nextopt; 150 151 default: 152 fprintf(stderr, "ftpd: Unknown flag -%c ignored.\n", 153 *cp); 154 break; 155 } 156 nextopt: 157 argc--, argv++; 158 } 159 (void) freopen("/dev/null", "w", stderr); 160 (void) signal(SIGPIPE, lostconn); 161 (void) signal(SIGCHLD, SIG_IGN); 162 if ((int)signal(SIGURG, myoob) < 0) 163 syslog(LOG_ERR, "signal: %m"); 164 165 /* handle urgent data inline */ 166 /* Sequent defines this, but it doesn't work */ 167 #ifdef SO_OOBINLINE 168 if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof(on)) < 0) 169 syslog(LOG_ERR, "setsockopt: %m"); 170 #endif 171 if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1) 172 syslog(LOG_ERR, "fcntl F_SETOWN: %m"); 173 dolog(&his_addr); 174 /* do telnet option negotiation here */ 175 /* 176 * Set up default state 177 */ 178 data = -1; 179 type = TYPE_A; 180 form = FORM_N; 181 stru = STRU_F; 182 mode = MODE_S; 183 tmpline[0] = '\0'; 184 (void) gethostname(hostname, sizeof (hostname)); 185 reply(220, "%s FTP server (%s) ready.", hostname, version); 186 (void) setjmp(errcatch); 187 for (;;) 188 (void) yyparse(); 189 } 190 191 lostconn() 192 { 193 194 if (debug) 195 syslog(LOG_DEBUG, "lost connection"); 196 dologout(-1); 197 } 198 199 static char ttyline[20]; 200 201 /* 202 * Helper function for sgetpwnam(). 203 */ 204 char * 205 sgetsave(s) 206 char *s; 207 { 208 char *malloc(); 209 char *new = malloc((unsigned) strlen(s) + 1); 210 211 if (new == NULL) { 212 reply(553, "Local resource failure: malloc"); 213 dologout(1); 214 } 215 (void) strcpy(new, s); 216 return (new); 217 } 218 219 /* 220 * Save the result of a getpwnam. Used for USER command, since 221 * the data returned must not be clobbered by any other command 222 * (e.g., globbing). 223 */ 224 struct passwd * 225 sgetpwnam(name) 226 char *name; 227 { 228 static struct passwd save; 229 register struct passwd *p; 230 char *sgetsave(); 231 232 if ((p = getpwnam(name)) == NULL) 233 return (p); 234 if (save.pw_name) { 235 free(save.pw_name); 236 free(save.pw_passwd); 237 free(save.pw_comment); 238 free(save.pw_gecos); 239 free(save.pw_dir); 240 free(save.pw_shell); 241 } 242 save = *p; 243 save.pw_name = sgetsave(p->pw_name); 244 save.pw_passwd = sgetsave(p->pw_passwd); 245 save.pw_comment = sgetsave(p->pw_comment); 246 save.pw_gecos = sgetsave(p->pw_gecos); 247 save.pw_dir = sgetsave(p->pw_dir); 248 save.pw_shell = sgetsave(p->pw_shell); 249 return (&save); 250 } 251 252 int login_attempts; /* number of failed login attempts */ 253 int askpasswd; /* had user command, ask for passwd */ 254 255 /* 256 * USER command. 257 * Sets global passwd pointer pw if named account exists 258 * and is acceptable; sets askpasswd if a PASS command is 259 * expected. If logged in previously, need to reset state. 260 * If name is "ftp" or "anonymous" and ftp account exists, 261 * set guest and pw, then just return. 262 * If account doesn't exist, ask for passwd anyway. 263 * Otherwise, check user requesting login privileges. 264 * Disallow anyone who does not have a standard 265 * shell returned by getusershell() (/etc/shells). 266 * Disallow anyone mentioned in the file FTPUSERS 267 * to allow people such as root and uucp to be avoided. 268 */ 269 user(name) 270 char *name; 271 { 272 register char *cp; 273 FILE *fd; 274 char *shell; 275 char line[BUFSIZ], *index(), *getusershell(); 276 277 if (logged_in) { 278 if (guest) { 279 reply(530, "Can't change user from guest login."); 280 return; 281 } 282 end_login(); 283 } 284 285 guest = 0; 286 if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) { 287 if ((pw = sgetpwnam("ftp")) != NULL) { 288 guest = 1; 289 askpasswd = 1; 290 reply(331, "Guest login ok, send ident as password."); 291 } else 292 reply(530, "User %s unknown.", name); 293 return; 294 } 295 if (pw = sgetpwnam(name)) { 296 if ((shell = pw->pw_shell) == NULL || *shell == 0) 297 shell = "/bin/sh"; 298 while ((cp = getusershell()) != NULL) 299 if (strcmp(cp, shell) == 0) 300 break; 301 endusershell(); 302 if (cp == NULL) { 303 reply(530, "User %s access denied.", name); 304 pw = (struct passwd *) NULL; 305 return; 306 } 307 if ((fd = fopen(FTPUSERS, "r")) != NULL) { 308 while (fgets(line, sizeof (line), fd) != NULL) { 309 if ((cp = index(line, '\n')) != NULL) 310 *cp = '\0'; 311 if (strcmp(line, name) == 0) { 312 reply(530, "User %s access denied.", name); 313 pw = (struct passwd *) NULL; 314 return; 315 } 316 } 317 } 318 (void) fclose(fd); 319 } 320 reply(331, "Password required for %s.", name); 321 askpasswd = 1; 322 /* 323 * Delay before reading passwd after first failed 324 * attempt to slow down passwd-guessing programs. 325 */ 326 if (login_attempts) 327 sleep((unsigned) login_attempts); 328 } 329 330 /* 331 * Terminate login as previous user, if any, resetting state; 332 * used when USER command is given or login fails. 333 */ 334 end_login() 335 { 336 337 (void) seteuid((uid_t)0); 338 if (logged_in) 339 logwtmp(ttyline, "", ""); 340 pw = NULL; 341 logged_in = 0; 342 guest = 0; 343 } 344 345 pass(passwd) 346 char *passwd; 347 { 348 char *xpasswd, *salt; 349 350 if (logged_in || askpasswd == 0) { 351 reply(503, "Login with USER first."); 352 return; 353 } 354 askpasswd = 0; 355 if (!guest) { /* "ftp" is only account allowed no password */ 356 if (pw == NULL) 357 salt = "xx"; 358 else 359 salt = pw->pw_passwd; 360 xpasswd = crypt(passwd, salt); 361 /* The strcmp does not catch null passwords! */ 362 if (pw == NULL || *pw->pw_passwd == '\0' || 363 strcmp(xpasswd, pw->pw_passwd)) { 364 reply(530, "Login incorrect."); 365 pw = NULL; 366 if (login_attempts++ >= 5) { 367 syslog(LOG_ERR, 368 "repeated login failures from %s", 369 remotehost); 370 exit(0); 371 } 372 return; 373 } 374 } 375 login_attempts = 0; /* this time successful */ 376 (void) setegid((gid_t)pw->pw_gid); 377 (void) initgroups(pw->pw_name, pw->pw_gid); 378 379 /* open wtmp before chroot */ 380 (void)sprintf(ttyline, "ftp%d", getpid()); 381 logwtmp(ttyline, pw->pw_name, remotehost); 382 logged_in = 1; 383 384 if (guest) { 385 if (chroot(pw->pw_dir) < 0) { 386 reply(550, "Can't set guest privileges."); 387 goto bad; 388 } 389 } 390 else if (chdir(pw->pw_dir)) 391 if (chdir("/")) { 392 reply(530, "User %s: can't change directory to %s.", 393 pw->pw_name, pw->pw_dir); 394 goto bad; 395 } 396 else 397 lreply(230, "No directory! Logging in with home=/"); 398 if (seteuid((uid_t)pw->pw_uid) < 0) { 399 reply(550, "Can't set uid."); 400 goto bad; 401 } 402 if (guest) 403 reply(230, "Guest login ok, access restrictions apply."); 404 else 405 reply(230, "User %s logged in.", pw->pw_name); 406 home = pw->pw_dir; /* home dir for globbing */ 407 return; 408 bad: 409 /* Forget all about it... */ 410 end_login(); 411 } 412 413 retrieve(cmd, name) 414 char *cmd, *name; 415 { 416 FILE *fin, *dout; 417 struct stat st; 418 int (*closefunc)(), tmp; 419 420 if (cmd == 0) 421 fin = fopen(name, "r"), closefunc = fclose; 422 else { 423 char line[BUFSIZ]; 424 425 (void) sprintf(line, cmd, name), name = line; 426 fin = ftpd_popen(line, "r"), closefunc = ftpd_pclose; 427 } 428 if (fin == NULL) { 429 if (errno != 0) 430 perror_reply(550, name); 431 return; 432 } 433 st.st_size = 0; 434 if (cmd == 0 && 435 (stat(name, &st) < 0 || (st.st_mode&S_IFMT) != S_IFREG)) { 436 reply(550, "%s: not a plain file.", name); 437 goto done; 438 } 439 dout = dataconn(name, st.st_size, "w"); 440 if (dout == NULL) 441 goto done; 442 if ((tmp = send_data(fin, dout, st.st_blksize)) > 0 || 443 ferror(dout) > 0) { 444 perror_reply(550, name); 445 } 446 else if (tmp == 0) { 447 reply(226, "Transfer complete."); 448 } 449 (void) fclose(dout); 450 data = -1; 451 pdata = -1; 452 done: 453 (*closefunc)(fin); 454 } 455 456 store(name, mode, unique) 457 char *name, *mode; 458 int unique; 459 { 460 FILE *fout, *din; 461 struct stat st; 462 int (*closefunc)(), tmp; 463 char *gunique(); 464 465 if (unique && stat(name, &st) == 0 && 466 (name = gunique(name)) == NULL) 467 return; 468 469 fout = fopen(name, mode), closefunc = fclose; 470 if (fout == NULL) { 471 perror_reply(553, name); 472 return; 473 } 474 din = dataconn(name, (off_t)-1, "r"); 475 if (din == NULL) 476 goto done; 477 if ((tmp = receive_data(din, fout)) > 0) 478 perror_reply(552, name); 479 else if (tmp == 0) { 480 if (ferror(fout) > 0) 481 perror_reply(552, name); 482 else if (unique) 483 reply(226, "Transfer complete (unique file name:%s).", 484 name); 485 else 486 reply(226, "Transfer complete."); 487 } 488 (void) fclose(din); 489 data = -1; 490 pdata = -1; 491 done: 492 (*closefunc)(fout); 493 } 494 495 FILE * 496 getdatasock(mode) 497 char *mode; 498 { 499 int s, on = 1; 500 501 if (data >= 0) 502 return (fdopen(data, mode)); 503 s = socket(AF_INET, SOCK_STREAM, 0); 504 if (s < 0) 505 return (NULL); 506 (void) seteuid((uid_t)0); 507 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &on, sizeof (on)) < 0) 508 goto bad; 509 /* anchor socket to avoid multi-homing problems */ 510 data_source.sin_family = AF_INET; 511 data_source.sin_addr = ctrl_addr.sin_addr; 512 if (bind(s, (struct sockaddr *)&data_source, sizeof (data_source)) < 0) 513 goto bad; 514 (void) seteuid((uid_t)pw->pw_uid); 515 return (fdopen(s, mode)); 516 bad: 517 (void) seteuid((uid_t)pw->pw_uid); 518 (void) close(s); 519 return (NULL); 520 } 521 522 FILE * 523 dataconn(name, size, mode) 524 char *name; 525 off_t size; 526 char *mode; 527 { 528 char sizebuf[32]; 529 FILE *file; 530 int retry = 0; 531 532 if (size != (off_t) -1) 533 (void) sprintf (sizebuf, " (%ld bytes)", size); 534 else 535 (void) strcpy(sizebuf, ""); 536 if (pdata >= 0) { 537 struct sockaddr_in from; 538 int s, fromlen = sizeof(from); 539 540 s = accept(pdata, (struct sockaddr *)&from, &fromlen); 541 if (s < 0) { 542 reply(425, "Can't open data connection."); 543 (void) close(pdata); 544 pdata = -1; 545 return(NULL); 546 } 547 (void) close(pdata); 548 pdata = s; 549 reply(150, "Opening %s mode data connection for %s%s.", 550 type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf); 551 return(fdopen(pdata, mode)); 552 } 553 if (data >= 0) { 554 reply(125, "Using existing data connection for %s%s.", 555 name, sizebuf); 556 usedefault = 1; 557 return (fdopen(data, mode)); 558 } 559 if (usedefault) 560 data_dest = his_addr; 561 usedefault = 1; 562 file = getdatasock(mode); 563 if (file == NULL) { 564 reply(425, "Can't create data socket (%s,%d): %s.", 565 inet_ntoa(data_source.sin_addr), 566 ntohs(data_source.sin_port), 567 errno < sys_nerr ? sys_errlist[errno] : "unknown error"); 568 return (NULL); 569 } 570 data = fileno(file); 571 while (connect(data, (struct sockaddr *)&data_dest, 572 sizeof (data_dest)) < 0) { 573 if (errno == EADDRINUSE && retry < swaitmax) { 574 sleep((unsigned) swaitint); 575 retry += swaitint; 576 continue; 577 } 578 perror_reply(425, "Can't build data connection"); 579 (void) fclose(file); 580 data = -1; 581 return (NULL); 582 } 583 reply(150, "Opening %s mode data connection for %s%s.", 584 type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf); 585 return (file); 586 } 587 588 /* 589 * Tranfer the contents of "instr" to 590 * "outstr" peer using the appropriate 591 * encapulation of the date subject 592 * to Mode, Structure, and Type. 593 * 594 * NB: Form isn't handled. 595 */ 596 send_data(instr, outstr, blksize) 597 FILE *instr, *outstr; 598 off_t blksize; 599 { 600 register int c, cnt; 601 register char *buf; 602 int netfd, filefd; 603 604 transflag++; 605 if (setjmp(urgcatch)) { 606 transflag = 0; 607 return(-1); 608 } 609 switch (type) { 610 611 case TYPE_A: 612 while ((c = getc(instr)) != EOF) { 613 if (c == '\n') { 614 if (ferror (outstr)) { 615 transflag = 0; 616 return (1); 617 } 618 (void) putc('\r', outstr); 619 } 620 (void) putc(c, outstr); 621 } 622 transflag = 0; 623 if (ferror (instr) || ferror (outstr)) { 624 return (1); 625 } 626 return (0); 627 628 case TYPE_I: 629 case TYPE_L: 630 if ((buf = malloc((u_int)blksize)) == NULL) { 631 transflag = 0; 632 return (1); 633 } 634 netfd = fileno(outstr); 635 filefd = fileno(instr); 636 while ((cnt = read(filefd, buf, sizeof(buf))) > 0 && 637 write(netfd, buf, cnt) == cnt); 638 transflag = 0; 639 (void)free(buf); 640 return (cnt != 0); 641 } 642 reply(550, "Unimplemented TYPE %d in send_data", type); 643 transflag = 0; 644 return (-1); 645 } 646 647 /* 648 * Transfer data from peer to 649 * "outstr" using the appropriate 650 * encapulation of the data subject 651 * to Mode, Structure, and Type. 652 * 653 * N.B.: Form isn't handled. 654 */ 655 receive_data(instr, outstr) 656 FILE *instr, *outstr; 657 { 658 register int c; 659 int cnt; 660 char buf[BUFSIZ]; 661 662 663 transflag++; 664 if (setjmp(urgcatch)) { 665 transflag = 0; 666 return(-1); 667 } 668 switch (type) { 669 670 case TYPE_I: 671 case TYPE_L: 672 while ((cnt = read(fileno(instr), buf, sizeof buf)) > 0) { 673 if (write(fileno(outstr), buf, cnt) < 0) { 674 transflag = 0; 675 return (1); 676 } 677 } 678 transflag = 0; 679 return (cnt < 0); 680 681 case TYPE_E: 682 reply(553, "TYPE E not implemented."); 683 transflag = 0; 684 return (-1); 685 686 case TYPE_A: 687 while ((c = getc(instr)) != EOF) { 688 while (c == '\r') { 689 if (ferror (outstr)) { 690 transflag = 0; 691 return (1); 692 } 693 if ((c = getc(instr)) != '\n') 694 (void) putc ('\r', outstr); 695 /* if (c == '\0') */ 696 /* continue; */ 697 } 698 (void) putc (c, outstr); 699 } 700 transflag = 0; 701 if (ferror (instr) || ferror (outstr)) 702 return (1); 703 return (0); 704 } 705 transflag = 0; 706 fatal("Unknown type in receive_data."); 707 /*NOTREACHED*/ 708 } 709 710 fatal(s) 711 char *s; 712 { 713 reply(451, "Error in server: %s\n", s); 714 reply(221, "Closing connection due to server error."); 715 dologout(0); 716 } 717 718 /* VARARGS2 */ 719 reply(n, fmt, p0, p1, p2, p3, p4, p5) 720 int n; 721 char *fmt; 722 { 723 printf("%d ", n); 724 printf(fmt, p0, p1, p2, p3, p4, p5); 725 printf("\r\n"); 726 (void)fflush(stdout); 727 if (debug) { 728 syslog(LOG_DEBUG, "<--- %d ", n); 729 syslog(LOG_DEBUG, fmt, p0, p1, p2, p3, p4, p5); 730 } 731 } 732 733 /* VARARGS2 */ 734 lreply(n, fmt, p0, p1, p2, p3, p4, p5) 735 int n; 736 char *fmt; 737 { 738 printf("%d- ", n); 739 printf(fmt, p0, p1, p2, p3, p4, p5); 740 printf("\r\n"); 741 (void)fflush(stdout); 742 if (debug) { 743 syslog(LOG_DEBUG, "<--- %d- ", n); 744 syslog(LOG_DEBUG, fmt, p0, p1, p2, p3, p4, p5); 745 } 746 } 747 748 ack(s) 749 char *s; 750 { 751 reply(250, "%s command successful.", s); 752 } 753 754 nack(s) 755 char *s; 756 { 757 reply(502, "%s command not implemented.", s); 758 } 759 760 /* ARGSUSED */ 761 yyerror(s) 762 char *s; 763 { 764 char *cp; 765 766 cp = index(cbuf,'\n'); 767 *cp = '\0'; 768 reply(500, "'%s': command not understood.",cbuf); 769 } 770 771 delete(name) 772 char *name; 773 { 774 struct stat st; 775 776 if (stat(name, &st) < 0) { 777 perror_reply(550, name); 778 return; 779 } 780 if ((st.st_mode&S_IFMT) == S_IFDIR) { 781 if (rmdir(name) < 0) { 782 perror_reply(550, name); 783 return; 784 } 785 goto done; 786 } 787 if (unlink(name) < 0) { 788 perror_reply(550, name); 789 return; 790 } 791 done: 792 ack("DELE"); 793 } 794 795 cwd(path) 796 char *path; 797 { 798 799 if (chdir(path) < 0) { 800 perror_reply(550, path); 801 return; 802 } 803 ack("CWD"); 804 } 805 806 makedir(name) 807 char *name; 808 { 809 if (mkdir(name, 0777) < 0) 810 perror_reply(550, name); 811 else 812 reply(257, "MKD command successful."); 813 } 814 815 removedir(name) 816 char *name; 817 { 818 819 if (rmdir(name) < 0) { 820 perror_reply(550, name); 821 return; 822 } 823 ack("RMD"); 824 } 825 826 pwd() 827 { 828 char path[MAXPATHLEN + 1]; 829 extern char *getwd(); 830 831 if (getwd(path) == (char *)NULL) { 832 reply(550, "%s.", path); 833 return; 834 } 835 reply(257, "\"%s\" is current directory.", path); 836 } 837 838 char * 839 renamefrom(name) 840 char *name; 841 { 842 struct stat st; 843 844 if (stat(name, &st) < 0) { 845 perror_reply(550, name); 846 return ((char *)0); 847 } 848 reply(350, "File exists, ready for destination name"); 849 return (name); 850 } 851 852 renamecmd(from, to) 853 char *from, *to; 854 { 855 856 if (rename(from, to) < 0) { 857 perror_reply(550, "rename"); 858 return; 859 } 860 ack("RNTO"); 861 } 862 863 dolog(sin) 864 struct sockaddr_in *sin; 865 { 866 struct hostent *hp = gethostbyaddr((char *)&sin->sin_addr, 867 sizeof (struct in_addr), AF_INET); 868 time_t t, time(); 869 extern char *ctime(); 870 871 if (hp) 872 (void) strncpy(remotehost, hp->h_name, sizeof (remotehost)); 873 else 874 (void) strncpy(remotehost, inet_ntoa(sin->sin_addr), 875 sizeof (remotehost)); 876 if (!logging) 877 return; 878 t = time((time_t *) 0); 879 syslog(LOG_INFO, "connection from %s at %s", 880 remotehost, ctime(&t)); 881 } 882 883 /* 884 * Record logout in wtmp file 885 * and exit with supplied status. 886 */ 887 dologout(status) 888 int status; 889 { 890 if (logged_in) { 891 (void) seteuid((uid_t)0); 892 logwtmp(ttyline, "", ""); 893 } 894 /* beware of flushing buffers after a SIGPIPE */ 895 _exit(status); 896 } 897 898 myoob() 899 { 900 char *cp; 901 902 /* only process if transfer occurring */ 903 if (!transflag) 904 return; 905 cp = tmpline; 906 if (getline(cp, 7, stdin) == NULL) { 907 reply(221, "You could at least say goodbye."); 908 dologout(0); 909 } 910 upper(cp); 911 if (strcmp(cp, "ABOR\r\n")) 912 return; 913 tmpline[0] = '\0'; 914 reply(426,"Transfer aborted. Data connection closed."); 915 reply(226,"Abort successful"); 916 longjmp(urgcatch, 1); 917 } 918 919 /* 920 * Note: The 530 reply codes could be 4xx codes, except nothing is 921 * given in the state tables except 421 which implies an exit. (RFC959) 922 */ 923 passive() 924 { 925 int len; 926 struct sockaddr_in tmp; 927 register char *p, *a; 928 929 pdata = socket(AF_INET, SOCK_STREAM, 0); 930 if (pdata < 0) { 931 reply(530, "Can't open passive connection"); 932 return; 933 } 934 tmp = ctrl_addr; 935 tmp.sin_port = 0; 936 (void) seteuid((uid_t)0); 937 if (bind(pdata, (struct sockaddr *) &tmp, sizeof(tmp)) < 0) { 938 (void) seteuid((uid_t)pw->pw_uid); 939 (void) close(pdata); 940 pdata = -1; 941 reply(530, "Can't open passive connection"); 942 return; 943 } 944 (void) seteuid((uid_t)pw->pw_uid); 945 len = sizeof(tmp); 946 if (getsockname(pdata, (struct sockaddr *) &tmp, &len) < 0) { 947 (void) close(pdata); 948 pdata = -1; 949 reply(530, "Can't open passive connection"); 950 return; 951 } 952 if (listen(pdata, 1) < 0) { 953 (void) close(pdata); 954 pdata = -1; 955 reply(530, "Can't open passive connection"); 956 return; 957 } 958 a = (char *) &tmp.sin_addr; 959 p = (char *) &tmp.sin_port; 960 961 #define UC(b) (((int) b) & 0xff) 962 963 reply(227, "Entering Passive Mode (%d,%d,%d,%d,%d,%d)", UC(a[0]), 964 UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1])); 965 } 966 967 /* 968 * Generate unique name for file with basename "local". 969 * The file named "local" is already known to exist. 970 * Generates failure reply on error. 971 */ 972 char * 973 gunique(local) 974 char *local; 975 { 976 static char new[MAXPATHLEN]; 977 struct stat st; 978 char *cp = rindex(local, '/'); 979 int d, count=0; 980 981 if (cp) 982 *cp = '\0'; 983 d = stat(cp ? local : ".", &st); 984 if (cp) 985 *cp = '/'; 986 if (d < 0) { 987 perror_reply(553, local); 988 return((char *) 0); 989 } 990 (void) strcpy(new, local); 991 cp = new + strlen(new); 992 *cp++ = '.'; 993 for (count = 1; count < 100; count++) { 994 (void) sprintf(cp, "%d", count); 995 if (stat(new, &st) < 0) 996 return(new); 997 } 998 reply(452, "Unique file name cannot be created."); 999 return((char *) 0); 1000 } 1001 1002 /* 1003 * Format and send reply containing system error number. 1004 */ 1005 perror_reply(code, string) 1006 int code; 1007 char *string; 1008 { 1009 1010 if (errno < sys_nerr) 1011 reply(code, "%s: %s.", string, sys_errlist[errno]); 1012 else 1013 reply(code, "%s: unknown error %d.", string, errno); 1014 } 1015