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