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