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