![[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] / 43BSDReno / libexec / ftpd|
Return to ftpd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / libexec / ftpd |
1.1 root 1: /*
2: * Copyright (c) 1985, 1988, 1990 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: char copyright[] =
22: "@(#) Copyright (c) 1985, 1988, 1990 Regents of the University of California.\n\
23: All rights reserved.\n";
24: #endif /* not lint */
25:
26: #ifndef lint
27: static char sccsid[] = "@(#)ftpd.c 5.37 (Berkeley) 6/27/90";
28: #endif /* not lint */
29:
30: /*
31: * FTP server.
32: */
33: #include <sys/param.h>
34: #include <sys/stat.h>
35: #include <sys/ioctl.h>
36: #include <sys/socket.h>
37: #include <sys/file.h>
38: #include <sys/wait.h>
39: #include <sys/dir.h>
40:
41: #include <netinet/in.h>
42: #include <netinet/in_systm.h>
43: #include <netinet/ip.h>
44:
45: #define FTP_NAMES
46: #include <arpa/ftp.h>
47: #include <arpa/inet.h>
48: #include <arpa/telnet.h>
49:
50: #include <ctype.h>
51: #include <stdio.h>
52: #include <signal.h>
53: #include <pwd.h>
54: #include <setjmp.h>
55: #include <netdb.h>
56: #include <errno.h>
57: #include <string.h>
58: #include <syslog.h>
59: #include <varargs.h>
60: #include "pathnames.h"
61:
62: /*
63: * File containing login names
64: * NOT to be used on this machine.
65: * Commonly used to disallow uucp.
66: */
67: extern int errno;
68: extern char *crypt();
69: extern char version[];
70: extern char *home; /* pointer to home directory for glob */
71: extern FILE *ftpd_popen(), *fopen(), *freopen();
72: extern int ftpd_pclose(), fclose();
73: extern char *getline();
74: extern char cbuf[];
75: extern off_t restart_point;
76:
77: struct sockaddr_in ctrl_addr;
78: struct sockaddr_in data_source;
79: struct sockaddr_in data_dest;
80: struct sockaddr_in his_addr;
81: struct sockaddr_in pasv_addr;
82:
83: int data;
84: jmp_buf errcatch, urgcatch;
85: int logged_in;
86: struct passwd *pw;
87: int debug;
88: int timeout = 900; /* timeout after 15 minutes of inactivity */
89: int maxtimeout = 7200;/* don't allow idle time to be set beyond 2 hours */
90: int logging;
91: int guest;
92: int type;
93: int form;
94: int stru; /* avoid C keyword */
95: int mode;
96: int usedefault = 1; /* for data transfers */
97: int pdata = -1; /* for passive mode */
98: int transflag;
99: off_t file_size;
100: off_t byte_count;
101: #if !defined(CMASK) || CMASK == 0
102: #undef CMASK
103: #define CMASK 027
104: #endif
105: int defumask = CMASK; /* default umask value */
106: char tmpline[7];
107: char hostname[MAXHOSTNAMELEN];
108: char remotehost[MAXHOSTNAMELEN];
109:
110: /*
111: * Timeout intervals for retrying connections
112: * to hosts that don't accept PORT cmds. This
113: * is a kludge, but given the problems with TCP...
114: */
115: #define SWAITMAX 90 /* wait at most 90 seconds */
116: #define SWAITINT 5 /* interval between retries */
117:
118: int swaitmax = SWAITMAX;
119: int swaitint = SWAITINT;
120:
121: int lostconn();
122: int myoob();
123: FILE *getdatasock(), *dataconn();
124:
125: #ifdef SETPROCTITLE
126: char **Argv = NULL; /* pointer to argument vector */
127: char *LastArgv = NULL; /* end of argv */
128: char proctitle[BUFSIZ]; /* initial part of title */
129: #endif /* SETPROCTITLE */
130:
131: main(argc, argv, envp)
132: int argc;
133: char *argv[];
134: char **envp;
135: {
136: int addrlen, on = 1, tos;
137: char *cp;
138:
139: addrlen = sizeof (his_addr);
140: if (getpeername(0, (struct sockaddr *)&his_addr, &addrlen) < 0) {
141: syslog(LOG_ERR, "getpeername (%s): %m",argv[0]);
142: exit(1);
143: }
144: addrlen = sizeof (ctrl_addr);
145: if (getsockname(0, (struct sockaddr *)&ctrl_addr, &addrlen) < 0) {
146: syslog(LOG_ERR, "getsockname (%s): %m",argv[0]);
147: exit(1);
148: }
149: #ifdef IP_TOS
150: tos = IPTOS_LOWDELAY;
151: if (setsockopt(0, IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(int)) < 0)
152: syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
153: #endif
154: data_source.sin_port = htons(ntohs(ctrl_addr.sin_port) - 1);
155: debug = 0;
156: openlog("ftpd", LOG_PID, LOG_DAEMON);
157: #ifdef SETPROCTITLE
158: /*
159: * Save start and extent of argv for setproctitle.
160: */
161: Argv = argv;
162: while (*envp)
163: envp++;
164: LastArgv = envp[-1] + strlen(envp[-1]);
165: #endif /* SETPROCTITLE */
166:
167: argc--, argv++;
168: while (argc > 0 && *argv[0] == '-') {
169: for (cp = &argv[0][1]; *cp; cp++) switch (*cp) {
170:
171: case 'v':
172: debug = 1;
173: break;
174:
175: case 'd':
176: debug = 1;
177: break;
178:
179: case 'l':
180: logging = 1;
181: break;
182:
183: case 't':
184: timeout = atoi(++cp);
185: if (maxtimeout < timeout)
186: maxtimeout = timeout;
187: goto nextopt;
188:
189: case 'T':
190: maxtimeout = atoi(++cp);
191: if (timeout > maxtimeout)
192: timeout = maxtimeout;
193: goto nextopt;
194:
195: case 'u':
196: {
197: int val = 0;
198:
199: while (*++cp && *cp >= '0' && *cp <= '9')
200: val = val*8 + *cp - '0';
201: if (*cp)
202: fprintf(stderr, "ftpd: Bad value for -u\n");
203: else
204: defumask = val;
205: goto nextopt;
206: }
207:
208: default:
209: fprintf(stderr, "ftpd: Unknown flag -%c ignored.\n",
210: *cp);
211: break;
212: }
213: nextopt:
214: argc--, argv++;
215: }
216: (void) freopen(_PATH_DEVNULL, "w", stderr);
217: (void) signal(SIGPIPE, lostconn);
218: (void) signal(SIGCHLD, SIG_IGN);
219: if ((int)signal(SIGURG, myoob) < 0)
220: syslog(LOG_ERR, "signal: %m");
221:
222: /* Try to handle urgent data inline */
223: #ifdef SO_OOBINLINE
224: if (setsockopt(0, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof(on)) < 0)
225: syslog(LOG_ERR, "setsockopt: %m");
226: #endif
227:
228: #ifdef F_SETOWN
229: if (fcntl(fileno(stdin), F_SETOWN, getpid()) == -1)
230: syslog(LOG_ERR, "fcntl F_SETOWN: %m");
231: #endif
232: dolog(&his_addr);
233: /*
234: * Set up default state
235: */
236: data = -1;
237: type = TYPE_A;
238: form = FORM_N;
239: stru = STRU_F;
240: mode = MODE_S;
241: tmpline[0] = '\0';
242: (void) gethostname(hostname, sizeof (hostname));
243: reply(220, "%s FTP server (%s) ready.", hostname, version);
244: (void) setjmp(errcatch);
245: for (;;)
246: (void) yyparse();
247: /* NOTREACHED */
248: }
249:
250: lostconn()
251: {
252:
253: if (debug)
254: syslog(LOG_DEBUG, "lost connection");
255: dologout(-1);
256: }
257:
258: static char ttyline[20];
259:
260: /*
261: * Helper function for sgetpwnam().
262: */
263: char *
264: sgetsave(s)
265: char *s;
266: {
267: char *malloc();
268: char *new = malloc((unsigned) strlen(s) + 1);
269:
270: if (new == NULL) {
271: perror_reply(421, "Local resource failure: malloc");
272: dologout(1);
273: /* NOTREACHED */
274: }
275: (void) strcpy(new, s);
276: return (new);
277: }
278:
279: /*
280: * Save the result of a getpwnam. Used for USER command, since
281: * the data returned must not be clobbered by any other command
282: * (e.g., globbing).
283: */
284: struct passwd *
285: sgetpwnam(name)
286: char *name;
287: {
288: static struct passwd save;
289: register struct passwd *p;
290: char *sgetsave();
291:
292: if ((p = getpwnam(name)) == NULL)
293: return (p);
294: if (save.pw_name) {
295: free(save.pw_name);
296: free(save.pw_passwd);
297: free(save.pw_gecos);
298: free(save.pw_dir);
299: free(save.pw_shell);
300: }
301: save = *p;
302: save.pw_name = sgetsave(p->pw_name);
303: save.pw_passwd = sgetsave(p->pw_passwd);
304: save.pw_gecos = sgetsave(p->pw_gecos);
305: save.pw_dir = sgetsave(p->pw_dir);
306: save.pw_shell = sgetsave(p->pw_shell);
307: return (&save);
308: }
309:
310: int login_attempts; /* number of failed login attempts */
311: int askpasswd; /* had user command, ask for passwd */
312:
313: /*
314: * USER command.
315: * Sets global passwd pointer pw if named account exists and is acceptable;
316: * sets askpasswd if a PASS command is expected. If logged in previously,
317: * need to reset state. If name is "ftp" or "anonymous", the name is not in
318: * _PATH_FTPUSERS, and ftp account exists, set guest and pw, then just return.
319: * If account doesn't exist, ask for passwd anyway. Otherwise, check user
320: * requesting login privileges. Disallow anyone who does not have a standard
321: * shell as returned by getusershell(). Disallow anyone mentioned in the file
322: * _PATH_FTPUSERS to allow people such as root and uucp to be avoided.
323: */
324: user(name)
325: char *name;
326: {
327: register char *cp;
328: char *shell;
329: char *getusershell();
330:
331: if (logged_in) {
332: if (guest) {
333: reply(530, "Can't change user from guest login.");
334: return;
335: }
336: end_login();
337: }
338:
339: guest = 0;
340: if (strcmp(name, "ftp") == 0 || strcmp(name, "anonymous") == 0) {
341: if (checkuser("ftp") || checkuser("anonymous"))
342: reply(530, "User %s access denied.", name);
343: else if ((pw = sgetpwnam("ftp")) != NULL) {
344: guest = 1;
345: askpasswd = 1;
346: reply(331, "Guest login ok, send ident as password.");
347: } else
348: reply(530, "User %s unknown.", name);
349: return;
350: }
351: if (pw = sgetpwnam(name)) {
352: if ((shell = pw->pw_shell) == NULL || *shell == 0)
353: shell = _PATH_BSHELL;
354: while ((cp = getusershell()) != NULL)
355: if (strcmp(cp, shell) == 0)
356: break;
357: endusershell();
358: if (cp == NULL || checkuser(name)) {
359: reply(530, "User %s access denied.", name);
360: if (logging)
361: syslog(LOG_NOTICE,
362: "FTP LOGIN REFUSED FROM %s, %s",
363: remotehost, name);
364: pw = (struct passwd *) NULL;
365: return;
366: }
367: }
368: reply(331, "Password required for %s.", name);
369: askpasswd = 1;
370: /*
371: * Delay before reading passwd after first failed
372: * attempt to slow down passwd-guessing programs.
373: */
374: if (login_attempts)
375: sleep((unsigned) login_attempts);
376: }
377:
378: /*
379: * Check if a user is in the file _PATH_FTPUSERS
380: */
381: checkuser(name)
382: char *name;
383: {
384: register FILE *fd;
385: register char *p;
386: char line[BUFSIZ];
387:
388: if ((fd = fopen(_PATH_FTPUSERS, "r")) != NULL) {
389: while (fgets(line, sizeof(line), fd) != NULL)
390: if ((p = index(line, '\n')) != NULL) {
391: *p = '\0';
392: if (line[0] == '#')
393: continue;
394: if (strcmp(line, name) == 0)
395: return (1);
396: }
397: (void) fclose(fd);
398: }
399: return (0);
400: }
401:
402: /*
403: * Terminate login as previous user, if any, resetting state;
404: * used when USER command is given or login fails.
405: */
406: end_login()
407: {
408:
409: (void) seteuid((uid_t)0);
410: if (logged_in)
411: logwtmp(ttyline, "", "");
412: pw = NULL;
413: logged_in = 0;
414: guest = 0;
415: }
416:
417: pass(passwd)
418: char *passwd;
419: {
420: char *xpasswd, *salt;
421:
422: if (logged_in || askpasswd == 0) {
423: reply(503, "Login with USER first.");
424: return;
425: }
426: askpasswd = 0;
427: if (!guest) { /* "ftp" is only account allowed no password */
428: if (pw == NULL)
429: salt = "xx";
430: else
431: salt = pw->pw_passwd;
432: xpasswd = crypt(passwd, salt);
433: /* The strcmp does not catch null passwords! */
434: if (pw == NULL || *pw->pw_passwd == '\0' ||
435: strcmp(xpasswd, pw->pw_passwd)) {
436: reply(530, "Login incorrect.");
437: pw = NULL;
438: if (login_attempts++ >= 5) {
439: syslog(LOG_NOTICE,
440: "repeated login failures from %s",
441: remotehost);
442: exit(0);
443: }
444: return;
445: }
446: }
447: login_attempts = 0; /* this time successful */
448: (void) setegid((gid_t)pw->pw_gid);
449: (void) initgroups(pw->pw_name, pw->pw_gid);
450:
451: /* open wtmp before chroot */
452: (void)sprintf(ttyline, "ftp%d", getpid());
453: logwtmp(ttyline, pw->pw_name, remotehost);
454: logged_in = 1;
455:
456: if (guest) {
457: /*
458: * We MUST do a chdir() after the chroot. Otherwise
459: * the old current directory will be accessible as "."
460: * outside the new root!
461: */
462: if (chroot(pw->pw_dir) < 0 || chdir("/") < 0) {
463: reply(550, "Can't set guest privileges.");
464: goto bad;
465: }
466: } else if (chdir(pw->pw_dir) < 0) {
467: if (chdir("/") < 0) {
468: reply(530, "User %s: can't change directory to %s.",
469: pw->pw_name, pw->pw_dir);
470: goto bad;
471: } else
472: lreply(230, "No directory! Logging in with home=/");
473: }
474: if (seteuid((uid_t)pw->pw_uid) < 0) {
475: reply(550, "Can't set uid.");
476: goto bad;
477: }
478: if (guest) {
479: reply(230, "Guest login ok, access restrictions apply.");
480: #ifdef SETPROCTITLE
481: sprintf(proctitle, "%s: anonymous/%.*s", remotehost,
482: sizeof(proctitle) - sizeof(remotehost) -
483: sizeof(": anonymous/"), passwd);
484: setproctitle(proctitle);
485: #endif /* SETPROCTITLE */
486: if (logging)
487: syslog(LOG_INFO, "ANONYMOUS FTP LOGIN FROM %s, %s",
488: remotehost, passwd);
489: } else {
490: reply(230, "User %s logged in.", pw->pw_name);
491: #ifdef SETPROCTITLE
492: sprintf(proctitle, "%s: %s", remotehost, pw->pw_name);
493: setproctitle(proctitle);
494: #endif /* SETPROCTITLE */
495: if (logging)
496: syslog(LOG_INFO, "FTP LOGIN FROM %s, %s",
497: remotehost, pw->pw_name);
498: }
499: home = pw->pw_dir; /* home dir for globbing */
500: (void) umask(defumask);
501: return;
502: bad:
503: /* Forget all about it... */
504: end_login();
505: }
506:
507: retrieve(cmd, name)
508: char *cmd, *name;
509: {
510: FILE *fin, *dout;
511: struct stat st;
512: int (*closefunc)();
513:
514: if (cmd == 0) {
515: fin = fopen(name, "r"), closefunc = fclose;
516: st.st_size = 0;
517: } else {
518: char line[BUFSIZ];
519:
520: (void) sprintf(line, cmd, name), name = line;
521: fin = ftpd_popen(line, "r"), closefunc = ftpd_pclose;
522: st.st_size = -1;
523: st.st_blksize = BUFSIZ;
524: }
525: if (fin == NULL) {
526: if (errno != 0)
527: perror_reply(550, name);
528: return;
529: }
530: if (cmd == 0 &&
531: (fstat(fileno(fin), &st) < 0 || (st.st_mode&S_IFMT) != S_IFREG)) {
532: reply(550, "%s: not a plain file.", name);
533: goto done;
534: }
535: if (restart_point) {
536: if (type == TYPE_A) {
537: register int i, n, c;
538:
539: n = restart_point;
540: i = 0;
541: while (i++ < n) {
542: if ((c=getc(fin)) == EOF) {
543: perror_reply(550, name);
544: goto done;
545: }
546: if (c == '\n')
547: i++;
548: }
549: } else if (lseek(fileno(fin), restart_point, L_SET) < 0) {
550: perror_reply(550, name);
551: goto done;
552: }
553: }
554: dout = dataconn(name, st.st_size, "w");
555: if (dout == NULL)
556: goto done;
557: send_data(fin, dout, st.st_blksize);
558: (void) fclose(dout);
559: data = -1;
560: pdata = -1;
561: done:
562: (*closefunc)(fin);
563: }
564:
565: store(name, mode, unique)
566: char *name, *mode;
567: int unique;
568: {
569: FILE *fout, *din;
570: struct stat st;
571: int (*closefunc)();
572: char *gunique();
573:
574: if (unique && stat(name, &st) == 0 &&
575: (name = gunique(name)) == NULL)
576: return;
577:
578: if (restart_point)
579: mode = "r+w";
580: fout = fopen(name, mode);
581: closefunc = fclose;
582: if (fout == NULL) {
583: perror_reply(553, name);
584: return;
585: }
586: if (restart_point) {
587: if (type == TYPE_A) {
588: register int i, n, c;
589:
590: n = restart_point;
591: i = 0;
592: while (i++ < n) {
593: if ((c=getc(fout)) == EOF) {
594: perror_reply(550, name);
595: goto done;
596: }
597: if (c == '\n')
598: i++;
599: }
600: /*
601: * We must do this seek to "current" position
602: * because we are changing from reading to
603: * writing.
604: */
605: if (fseek(fout, 0L, L_INCR) < 0) {
606: perror_reply(550, name);
607: goto done;
608: }
609: } else if (lseek(fileno(fout), restart_point, L_SET) < 0) {
610: perror_reply(550, name);
611: goto done;
612: }
613: }
614: din = dataconn(name, (off_t)-1, "r");
615: if (din == NULL)
616: goto done;
617: if (receive_data(din, fout) == 0) {
618: if (unique)
619: reply(226, "Transfer complete (unique file name:%s).",
620: name);
621: else
622: reply(226, "Transfer complete.");
623: }
624: (void) fclose(din);
625: data = -1;
626: pdata = -1;
627: done:
628: (*closefunc)(fout);
629: }
630:
631: FILE *
632: getdatasock(mode)
633: char *mode;
634: {
635: int s, on = 1, tries;
636:
637: if (data >= 0)
638: return (fdopen(data, mode));
639: s = socket(AF_INET, SOCK_STREAM, 0);
640: if (s < 0)
641: return (NULL);
642: (void) seteuid((uid_t)0);
643: if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,
644: (char *) &on, sizeof (on)) < 0)
645: goto bad;
646: /* anchor socket to avoid multi-homing problems */
647: data_source.sin_family = AF_INET;
648: data_source.sin_addr = ctrl_addr.sin_addr;
649: for (tries = 1; ; tries++) {
650: if (bind(s, (struct sockaddr *)&data_source,
651: sizeof (data_source)) >= 0)
652: break;
653: if (errno != EADDRINUSE || tries > 10)
654: goto bad;
655: sleep(tries);
656: }
657: (void) seteuid((uid_t)pw->pw_uid);
658: #ifdef IP_TOS
659: on = IPTOS_THROUGHPUT;
660: if (setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&on, sizeof(int)) < 0)
661: syslog(LOG_WARNING, "setsockopt (IP_TOS): %m");
662: #endif
663: return (fdopen(s, mode));
664: bad:
665: (void) seteuid((uid_t)pw->pw_uid);
666: (void) close(s);
667: return (NULL);
668: }
669:
670: FILE *
671: dataconn(name, size, mode)
672: char *name;
673: off_t size;
674: char *mode;
675: {
676: char sizebuf[32];
677: FILE *file;
678: int retry = 0, tos;
679:
680: file_size = size;
681: byte_count = 0;
682: if (size != (off_t) -1)
683: (void) sprintf (sizebuf, " (%ld bytes)", size);
684: else
685: (void) strcpy(sizebuf, "");
686: if (pdata >= 0) {
687: struct sockaddr_in from;
688: int s, fromlen = sizeof(from);
689:
690: s = accept(pdata, (struct sockaddr *)&from, &fromlen);
691: if (s < 0) {
692: reply(425, "Can't open data connection.");
693: (void) close(pdata);
694: pdata = -1;
695: return(NULL);
696: }
697: (void) close(pdata);
698: pdata = s;
699: #ifdef IP_TOS
700: tos = IPTOS_LOWDELAY;
701: (void) setsockopt(s, IPPROTO_IP, IP_TOS, (char *)&tos,
702: sizeof(int));
703: #endif
704: reply(150, "Opening %s mode data connection for %s%s.",
705: type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
706: return(fdopen(pdata, mode));
707: }
708: if (data >= 0) {
709: reply(125, "Using existing data connection for %s%s.",
710: name, sizebuf);
711: usedefault = 1;
712: return (fdopen(data, mode));
713: }
714: if (usedefault)
715: data_dest = his_addr;
716: usedefault = 1;
717: file = getdatasock(mode);
718: if (file == NULL) {
719: reply(425, "Can't create data socket (%s,%d): %s.",
720: inet_ntoa(data_source.sin_addr),
721: ntohs(data_source.sin_port), strerror(errno));
722: return (NULL);
723: }
724: data = fileno(file);
725: while (connect(data, (struct sockaddr *)&data_dest,
726: sizeof (data_dest)) < 0) {
727: if (errno == EADDRINUSE && retry < swaitmax) {
728: sleep((unsigned) swaitint);
729: retry += swaitint;
730: continue;
731: }
732: perror_reply(425, "Can't build data connection");
733: (void) fclose(file);
734: data = -1;
735: return (NULL);
736: }
737: reply(150, "Opening %s mode data connection for %s%s.",
738: type == TYPE_A ? "ASCII" : "BINARY", name, sizebuf);
739: return (file);
740: }
741:
742: /*
743: * Tranfer the contents of "instr" to
744: * "outstr" peer using the appropriate
745: * encapsulation of the data subject
746: * to Mode, Structure, and Type.
747: *
748: * NB: Form isn't handled.
749: */
750: send_data(instr, outstr, blksize)
751: FILE *instr, *outstr;
752: off_t blksize;
753: {
754: register int c, cnt;
755: register char *buf;
756: int netfd, filefd;
757:
758: transflag++;
759: if (setjmp(urgcatch)) {
760: transflag = 0;
761: return;
762: }
763: switch (type) {
764:
765: case TYPE_A:
766: while ((c = getc(instr)) != EOF) {
767: byte_count++;
768: if (c == '\n') {
769: if (ferror(outstr))
770: goto data_err;
771: (void) putc('\r', outstr);
772: }
773: (void) putc(c, outstr);
774: }
775: fflush(outstr);
776: transflag = 0;
777: if (ferror(instr))
778: goto file_err;
779: if (ferror(outstr))
780: goto data_err;
781: reply(226, "Transfer complete.");
782: return;
783:
784: case TYPE_I:
785: case TYPE_L:
786: if ((buf = malloc((u_int)blksize)) == NULL) {
787: transflag = 0;
788: perror_reply(451, "Local resource failure: malloc");
789: return;
790: }
791: netfd = fileno(outstr);
792: filefd = fileno(instr);
793: while ((cnt = read(filefd, buf, (u_int)blksize)) > 0 &&
794: write(netfd, buf, cnt) == cnt)
795: byte_count += cnt;
796: transflag = 0;
797: (void)free(buf);
798: if (cnt != 0) {
799: if (cnt < 0)
800: goto file_err;
801: goto data_err;
802: }
803: reply(226, "Transfer complete.");
804: return;
805: default:
806: transflag = 0;
807: reply(550, "Unimplemented TYPE %d in send_data", type);
808: return;
809: }
810:
811: data_err:
812: transflag = 0;
813: perror_reply(426, "Data connection");
814: return;
815:
816: file_err:
817: transflag = 0;
818: perror_reply(551, "Error on input file");
819: }
820:
821: /*
822: * Transfer data from peer to
823: * "outstr" using the appropriate
824: * encapulation of the data subject
825: * to Mode, Structure, and Type.
826: *
827: * N.B.: Form isn't handled.
828: */
829: receive_data(instr, outstr)
830: FILE *instr, *outstr;
831: {
832: register int c;
833: int cnt, bare_lfs = 0;
834: char buf[BUFSIZ];
835:
836: transflag++;
837: if (setjmp(urgcatch)) {
838: transflag = 0;
839: return (-1);
840: }
841: switch (type) {
842:
843: case TYPE_I:
844: case TYPE_L:
845: while ((cnt = read(fileno(instr), buf, sizeof buf)) > 0) {
846: if (write(fileno(outstr), buf, cnt) != cnt)
847: goto file_err;
848: byte_count += cnt;
849: }
850: if (cnt < 0)
851: goto data_err;
852: transflag = 0;
853: return (0);
854:
855: case TYPE_E:
856: reply(553, "TYPE E not implemented.");
857: transflag = 0;
858: return (-1);
859:
860: case TYPE_A:
861: while ((c = getc(instr)) != EOF) {
862: byte_count++;
863: if (c == '\n')
864: bare_lfs++;
865: while (c == '\r') {
866: if (ferror(outstr))
867: goto data_err;
868: if ((c = getc(instr)) != '\n') {
869: (void) putc ('\r', outstr);
870: if (c == '\0' || c == EOF)
871: goto contin2;
872: }
873: }
874: (void) putc(c, outstr);
875: contin2: ;
876: }
877: fflush(outstr);
878: if (ferror(instr))
879: goto data_err;
880: if (ferror(outstr))
881: goto file_err;
882: transflag = 0;
883: if (bare_lfs) {
884: lreply(230, "WARNING! %d bare linefeeds received in ASCII mode", bare_lfs);
885: printf(" File may not have transferred correctly.\r\n");
886: }
887: return (0);
888: default:
889: reply(550, "Unimplemented TYPE %d in receive_data", type);
890: transflag = 0;
891: return (-1);
892: }
893:
894: data_err:
895: transflag = 0;
896: perror_reply(426, "Data Connection");
897: return (-1);
898:
899: file_err:
900: transflag = 0;
901: perror_reply(452, "Error writing file");
902: return (-1);
903: }
904:
905: statfilecmd(filename)
906: char *filename;
907: {
908: char line[BUFSIZ];
909: FILE *fin;
910: int c;
911:
912: (void) sprintf(line, "/bin/ls -lgA %s", filename);
913: fin = ftpd_popen(line, "r");
914: lreply(211, "status of %s:", filename);
915: while ((c = getc(fin)) != EOF) {
916: if (c == '\n') {
917: if (ferror(stdout)){
918: perror_reply(421, "control connection");
919: (void) ftpd_pclose(fin);
920: dologout(1);
921: /* NOTREACHED */
922: }
923: if (ferror(fin)) {
924: perror_reply(551, filename);
925: (void) ftpd_pclose(fin);
926: return;
927: }
928: (void) putc('\r', stdout);
929: }
930: (void) putc(c, stdout);
931: }
932: (void) ftpd_pclose(fin);
933: reply(211, "End of Status");
934: }
935:
936: statcmd()
937: {
938: struct sockaddr_in *sin;
939: u_char *a, *p;
940:
941: lreply(211, "%s FTP server status:", hostname, version);
942: printf(" %s\r\n", version);
943: printf(" Connected to %s", remotehost);
944: if (!isdigit(remotehost[0]))
945: printf(" (%s)", inet_ntoa(his_addr.sin_addr));
946: printf("\r\n");
947: if (logged_in) {
948: if (guest)
949: printf(" Logged in anonymously\r\n");
950: else
951: printf(" Logged in as %s\r\n", pw->pw_name);
952: } else if (askpasswd)
953: printf(" Waiting for password\r\n");
954: else
955: printf(" Waiting for user name\r\n");
956: printf(" TYPE: %s", typenames[type]);
957: if (type == TYPE_A || type == TYPE_E)
958: printf(", FORM: %s", formnames[form]);
959: if (type == TYPE_L)
960: #if NBBY == 8
961: printf(" %d", NBBY);
962: #else
963: printf(" %d", bytesize); /* need definition! */
964: #endif
965: printf("; STRUcture: %s; transfer MODE: %s\r\n",
966: strunames[stru], modenames[mode]);
967: if (data != -1)
968: printf(" Data connection open\r\n");
969: else if (pdata != -1) {
970: printf(" in Passive mode");
971: sin = &pasv_addr;
972: goto printaddr;
973: } else if (usedefault == 0) {
974: printf(" PORT");
975: sin = &data_dest;
976: printaddr:
977: a = (u_char *) &sin->sin_addr;
978: p = (u_char *) &sin->sin_port;
979: #define UC(b) (((int) b) & 0xff)
980: printf(" (%d,%d,%d,%d,%d,%d)\r\n", UC(a[0]),
981: UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
982: #undef UC
983: } else
984: printf(" No data connection\r\n");
985: reply(211, "End of status");
986: }
987:
988: fatal(s)
989: char *s;
990: {
991: reply(451, "Error in server: %s\n", s);
992: reply(221, "Closing connection due to server error.");
993: dologout(0);
994: /* NOTREACHED */
995: }
996:
997: /* VARARGS2 */
998: reply(n, fmt, p0, p1, p2, p3, p4, p5)
999: int n;
1000: char *fmt;
1001: {
1002: printf("%d ", n);
1003: printf(fmt, p0, p1, p2, p3, p4, p5);
1004: printf("\r\n");
1005: (void)fflush(stdout);
1006: if (debug) {
1007: syslog(LOG_DEBUG, "<--- %d ", n);
1008: syslog(LOG_DEBUG, fmt, p0, p1, p2, p3, p4, p5);
1009: }
1010: }
1011:
1012: /* VARARGS2 */
1013: lreply(n, fmt, p0, p1, p2, p3, p4, p5)
1014: int n;
1015: char *fmt;
1016: {
1017: printf("%d- ", n);
1018: printf(fmt, p0, p1, p2, p3, p4, p5);
1019: printf("\r\n");
1020: (void)fflush(stdout);
1021: if (debug) {
1022: syslog(LOG_DEBUG, "<--- %d- ", n);
1023: syslog(LOG_DEBUG, fmt, p0, p1, p2, p3, p4, p5);
1024: }
1025: }
1026:
1027: ack(s)
1028: char *s;
1029: {
1030: reply(250, "%s command successful.", s);
1031: }
1032:
1033: nack(s)
1034: char *s;
1035: {
1036: reply(502, "%s command not implemented.", s);
1037: }
1038:
1039: /* ARGSUSED */
1040: yyerror(s)
1041: char *s;
1042: {
1043: char *cp;
1044:
1045: if (cp = index(cbuf,'\n'))
1046: *cp = '\0';
1047: reply(500, "'%s': command not understood.", cbuf);
1048: }
1049:
1050: delete(name)
1051: char *name;
1052: {
1053: struct stat st;
1054:
1055: if (stat(name, &st) < 0) {
1056: perror_reply(550, name);
1057: return;
1058: }
1059: if ((st.st_mode&S_IFMT) == S_IFDIR) {
1060: if (rmdir(name) < 0) {
1061: perror_reply(550, name);
1062: return;
1063: }
1064: goto done;
1065: }
1066: if (unlink(name) < 0) {
1067: perror_reply(550, name);
1068: return;
1069: }
1070: done:
1071: ack("DELE");
1072: }
1073:
1074: cwd(path)
1075: char *path;
1076: {
1077: if (chdir(path) < 0)
1078: perror_reply(550, path);
1079: else
1080: ack("CWD");
1081: }
1082:
1083: makedir(name)
1084: char *name;
1085: {
1086: if (mkdir(name, 0777) < 0)
1087: perror_reply(550, name);
1088: else
1089: reply(257, "MKD command successful.");
1090: }
1091:
1092: removedir(name)
1093: char *name;
1094: {
1095: if (rmdir(name) < 0)
1096: perror_reply(550, name);
1097: else
1098: ack("RMD");
1099: }
1100:
1101: pwd()
1102: {
1103: char path[MAXPATHLEN + 1];
1104: extern char *getwd();
1105:
1106: if (getwd(path) == (char *)NULL)
1107: reply(550, "%s.", path);
1108: else
1109: reply(257, "\"%s\" is current directory.", path);
1110: }
1111:
1112: char *
1113: renamefrom(name)
1114: char *name;
1115: {
1116: struct stat st;
1117:
1118: if (stat(name, &st) < 0) {
1119: perror_reply(550, name);
1120: return ((char *)0);
1121: }
1122: reply(350, "File exists, ready for destination name");
1123: return (name);
1124: }
1125:
1126: renamecmd(from, to)
1127: char *from, *to;
1128: {
1129: if (rename(from, to) < 0)
1130: perror_reply(550, "rename");
1131: else
1132: ack("RNTO");
1133: }
1134:
1135: dolog(sin)
1136: struct sockaddr_in *sin;
1137: {
1138: struct hostent *hp = gethostbyaddr((char *)&sin->sin_addr,
1139: sizeof (struct in_addr), AF_INET);
1140: time_t t, time();
1141: extern char *ctime();
1142:
1143: if (hp)
1144: (void) strncpy(remotehost, hp->h_name, sizeof (remotehost));
1145: else
1146: (void) strncpy(remotehost, inet_ntoa(sin->sin_addr),
1147: sizeof (remotehost));
1148: #ifdef SETPROCTITLE
1149: sprintf(proctitle, "%s: connected", remotehost);
1150: setproctitle(proctitle);
1151: #endif /* SETPROCTITLE */
1152:
1153: if (logging) {
1154: t = time((time_t *) 0);
1155: syslog(LOG_INFO, "connection from %s at %s",
1156: remotehost, ctime(&t));
1157: }
1158: }
1159:
1160: /*
1161: * Record logout in wtmp file
1162: * and exit with supplied status.
1163: */
1164: dologout(status)
1165: int status;
1166: {
1167: if (logged_in) {
1168: (void) seteuid((uid_t)0);
1169: logwtmp(ttyline, "", "");
1170: }
1171: /* beware of flushing buffers after a SIGPIPE */
1172: _exit(status);
1173: }
1174:
1175: myoob()
1176: {
1177: char *cp;
1178:
1179: /* only process if transfer occurring */
1180: if (!transflag)
1181: return;
1182: cp = tmpline;
1183: if (getline(cp, 7, stdin) == NULL) {
1184: reply(221, "You could at least say goodbye.");
1185: dologout(0);
1186: }
1187: upper(cp);
1188: if (strcmp(cp, "ABOR\r\n") == 0) {
1189: tmpline[0] = '\0';
1190: reply(426, "Transfer aborted. Data connection closed.");
1191: reply(226, "Abort successful");
1192: longjmp(urgcatch, 1);
1193: }
1194: if (strcmp(cp, "STAT\r\n") == 0) {
1195: if (file_size != (off_t) -1)
1196: reply(213, "Status: %lu of %lu bytes transferred",
1197: byte_count, file_size);
1198: else
1199: reply(213, "Status: %lu bytes transferred", byte_count);
1200: }
1201: }
1202:
1203: /*
1204: * Note: a response of 425 is not mentioned as a possible response to
1205: * the PASV command in RFC959. However, it has been blessed as
1206: * a legitimate response by Jon Postel in a telephone conversation
1207: * with Rick Adams on 25 Jan 89.
1208: */
1209: passive()
1210: {
1211: int len;
1212: register char *p, *a;
1213:
1214: pdata = socket(AF_INET, SOCK_STREAM, 0);
1215: if (pdata < 0) {
1216: perror_reply(425, "Can't open passive connection");
1217: return;
1218: }
1219: pasv_addr = ctrl_addr;
1220: pasv_addr.sin_port = 0;
1221: (void) seteuid((uid_t)0);
1222: if (bind(pdata, (struct sockaddr *)&pasv_addr, sizeof(pasv_addr)) < 0) {
1223: (void) seteuid((uid_t)pw->pw_uid);
1224: goto pasv_error;
1225: }
1226: (void) seteuid((uid_t)pw->pw_uid);
1227: len = sizeof(pasv_addr);
1228: if (getsockname(pdata, (struct sockaddr *) &pasv_addr, &len) < 0)
1229: goto pasv_error;
1230: if (listen(pdata, 1) < 0)
1231: goto pasv_error;
1232: a = (char *) &pasv_addr.sin_addr;
1233: p = (char *) &pasv_addr.sin_port;
1234:
1235: #define UC(b) (((int) b) & 0xff)
1236:
1237: reply(227, "Entering Passive Mode (%d,%d,%d,%d,%d,%d)", UC(a[0]),
1238: UC(a[1]), UC(a[2]), UC(a[3]), UC(p[0]), UC(p[1]));
1239: return;
1240:
1241: pasv_error:
1242: (void) close(pdata);
1243: pdata = -1;
1244: perror_reply(425, "Can't open passive connection");
1245: return;
1246: }
1247:
1248: /*
1249: * Generate unique name for file with basename "local".
1250: * The file named "local" is already known to exist.
1251: * Generates failure reply on error.
1252: */
1253: char *
1254: gunique(local)
1255: char *local;
1256: {
1257: static char new[MAXPATHLEN];
1258: struct stat st;
1259: char *cp = rindex(local, '/');
1260: int count = 0;
1261:
1262: if (cp)
1263: *cp = '\0';
1264: if (stat(cp ? local : ".", &st) < 0) {
1265: perror_reply(553, cp ? local : ".");
1266: return((char *) 0);
1267: }
1268: if (cp)
1269: *cp = '/';
1270: (void) strcpy(new, local);
1271: cp = new + strlen(new);
1272: *cp++ = '.';
1273: for (count = 1; count < 100; count++) {
1274: (void) sprintf(cp, "%d", count);
1275: if (stat(new, &st) < 0)
1276: return(new);
1277: }
1278: reply(452, "Unique file name cannot be created.");
1279: return((char *) 0);
1280: }
1281:
1282: /*
1283: * Format and send reply containing system error number.
1284: */
1285: perror_reply(code, string)
1286: int code;
1287: char *string;
1288: {
1289: reply(code, "%s: %s.", string, strerror(errno));
1290: }
1291:
1292: static char *onefile[] = {
1293: "",
1294: 0
1295: };
1296:
1297: send_file_list(whichfiles)
1298: char *whichfiles;
1299: {
1300: struct stat st;
1301: DIR *dirp = NULL;
1302: struct direct *dir;
1303: FILE *dout = NULL;
1304: register char **dirlist, *dirname;
1305: int simple = 0;
1306: char *strpbrk();
1307:
1308: if (strpbrk(whichfiles, "~{[*?") != NULL) {
1309: extern char **glob(), *globerr;
1310:
1311: globerr = NULL;
1312: dirlist = glob(whichfiles);
1313: if (globerr != NULL) {
1314: reply(550, globerr);
1315: return;
1316: } else if (dirlist == NULL) {
1317: errno = ENOENT;
1318: perror_reply(550, whichfiles);
1319: return;
1320: }
1321: } else {
1322: onefile[0] = whichfiles;
1323: dirlist = onefile;
1324: simple = 1;
1325: }
1326:
1327: if (setjmp(urgcatch)) {
1328: transflag = 0;
1329: return;
1330: }
1331: while (dirname = *dirlist++) {
1332: if (stat(dirname, &st) < 0) {
1333: /*
1334: * If user typed "ls -l", etc, and the client
1335: * used NLST, do what the user meant.
1336: */
1337: if (dirname[0] == '-' && *dirlist == NULL &&
1338: transflag == 0) {
1339: retrieve("/bin/ls %s", dirname);
1340: return;
1341: }
1342: perror_reply(550, whichfiles);
1343: if (dout != NULL) {
1344: (void) fclose(dout);
1345: transflag = 0;
1346: data = -1;
1347: pdata = -1;
1348: }
1349: return;
1350: }
1351:
1352: if ((st.st_mode&S_IFMT) == S_IFREG) {
1353: if (dout == NULL) {
1354: dout = dataconn("file list", (off_t)-1, "w");
1355: if (dout == NULL)
1356: return;
1357: transflag++;
1358: }
1359: fprintf(dout, "%s%s\n", dirname,
1360: type == TYPE_A ? "\r" : "");
1361: byte_count += strlen(dirname) + 1;
1362: continue;
1363: } else if ((st.st_mode&S_IFMT) != S_IFDIR)
1364: continue;
1365:
1366: if ((dirp = opendir(dirname)) == NULL)
1367: continue;
1368:
1369: while ((dir = readdir(dirp)) != NULL) {
1370: char nbuf[MAXPATHLEN];
1371:
1372: if (dir->d_name[0] == '.' && dir->d_namlen == 1)
1373: continue;
1374: if (dir->d_name[0] == '.' && dir->d_name[1] == '.' &&
1375: dir->d_namlen == 2)
1376: continue;
1377:
1378: sprintf(nbuf, "%s/%s", dirname, dir->d_name);
1379:
1380: /*
1381: * We have to do a stat to insure it's
1382: * not a directory or special file.
1383: */
1384: if (simple || (stat(nbuf, &st) == 0 &&
1385: (st.st_mode&S_IFMT) == S_IFREG)) {
1386: if (dout == NULL) {
1387: dout = dataconn("file list", (off_t)-1,
1388: "w");
1389: if (dout == NULL)
1390: return;
1391: transflag++;
1392: }
1393: if (nbuf[0] == '.' && nbuf[1] == '/')
1394: fprintf(dout, "%s%s\n", &nbuf[2],
1395: type == TYPE_A ? "\r" : "");
1396: else
1397: fprintf(dout, "%s%s\n", nbuf,
1398: type == TYPE_A ? "\r" : "");
1399: byte_count += strlen(nbuf) + 1;
1400: }
1401: }
1402: (void) closedir(dirp);
1403: }
1404:
1405: if (dout == NULL)
1406: reply(550, "No files found.");
1407: else if (ferror(dout) != 0)
1408: perror_reply(550, "Data connection");
1409: else
1410: reply(226, "Transfer complete.");
1411:
1412: transflag = 0;
1413: if (dout != NULL)
1414: (void) fclose(dout);
1415: data = -1;
1416: pdata = -1;
1417: }
1418:
1419: #ifdef SETPROCTITLE
1420: /*
1421: * clobber argv so ps will show what we're doing.
1422: * (stolen from sendmail)
1423: * warning, since this is usually started from inetd.conf, it
1424: * often doesn't have much of an environment or arglist to overwrite.
1425: */
1426:
1427: /*VARARGS1*/
1428: setproctitle(fmt, a, b, c)
1429: char *fmt;
1430: {
1431: register char *p, *bp, ch;
1432: register int i;
1433: char buf[BUFSIZ];
1434:
1435: (void) sprintf(buf, fmt, a, b, c);
1436:
1437: /* make ps print our process name */
1438: p = Argv[0];
1439: *p++ = '-';
1440:
1441: i = strlen(buf);
1442: if (i > LastArgv - p - 2) {
1443: i = LastArgv - p - 2;
1444: buf[i] = '\0';
1445: }
1446: bp = buf;
1447: while (ch = *bp++)
1448: if (ch != '\n' && ch != '\r')
1449: *p++ = ch;
1450: while (p < LastArgv)
1451: *p++ = ' ';
1452: }
1453: #endif /* SETPROCTITLE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.