![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftpcmd.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc / ftpd|
Return to ftpcmd.y CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc / ftpd |
1.1 root 1: /*
2: * Copyright (c) 1985 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that the above copyright notice and this paragraph are
7: * duplicated in all such forms and that any documentation,
8: * advertising materials, and other materials related to such
9: * distribution and use acknowledge that the software was developed
10: * by the University of California, Berkeley. The name of the
11: * University may not be used to endorse or promote products derived
12: * from this software without specific prior written permission.
13: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16: *
17: * @(#)ftpcmd.y 5.11 (Berkeley) 6/18/88
18: */
19:
20: /*
21: * Grammar for FTP commands.
22: * See RFC 765.
23: */
24:
25: %{
26:
27: #ifndef lint
28: static char sccsid[] = "@(#)ftpcmd.y 5.11 (Berkeley) 6/18/88";
29: #endif /* not lint */
30:
31: #include <sys/types.h>
32: #include <sys/socket.h>
33:
34: #include <netinet/in.h>
35:
36: #include <arpa/ftp.h>
37:
38: #include <stdio.h>
39: #include <signal.h>
40: #include <ctype.h>
41: #include <pwd.h>
42: #include <setjmp.h>
43: #include <syslog.h>
44:
45: extern struct sockaddr_in data_dest;
46: extern int logged_in;
47: extern struct passwd *pw;
48: extern int guest;
49: extern int logging;
50: extern int type;
51: extern int form;
52: extern int debug;
53: extern int timeout;
54: extern int pdata;
55: extern char hostname[];
56: extern char *globerr;
57: extern int usedefault;
58: extern int unique;
59: extern int transflag;
60: extern char tmpline[];
61: char **glob();
62:
63: static int cmd_type;
64: static int cmd_form;
65: static int cmd_bytesz;
66: char cbuf[512];
67: char *fromname;
68:
69: char *index();
70: %}
71:
72: %token
73: A B C E F I
74: L N P R S T
75:
76: SP CRLF COMMA STRING NUMBER
77:
78: USER PASS ACCT REIN QUIT PORT
79: PASV TYPE STRU MODE RETR STOR
80: APPE MLFL MAIL MSND MSOM MSAM
81: MRSQ MRCP ALLO REST RNFR RNTO
82: ABOR DELE CWD LIST NLST SITE
83: STAT HELP NOOP XMKD XRMD XPWD
84: XCUP STOU
85:
86: LEXERR
87:
88: %start cmd_list
89:
90: %%
91:
92: cmd_list: /* empty */
93: | cmd_list cmd
94: = {
95: fromname = (char *) 0;
96: }
97: | cmd_list rcmd
98: ;
99:
100: cmd: USER SP username CRLF
101: = {
102: extern struct passwd *getpwnam();
103:
104: logged_in = 0;
105: if (strcmp((char *) $3, "ftp") == 0 ||
106: strcmp((char *) $3, "anonymous") == 0) {
107: if ((pw = getpwnam("ftp")) != NULL) {
108: guest = 1;
109: reply(331,
110: "Guest login ok, send ident as password.");
111: }
112: else {
113: reply(530, "User %s unknown.", $3);
114: }
115: } else if (checkuser((char *) $3)) {
116: guest = 0;
117: pw = getpwnam((char *) $3);
118: if (pw == NULL) {
119: reply(530, "User %s unknown.", $3);
120: }
121: else {
122: reply(331, "Password required for %s.", $3);
123: }
124: } else {
125: reply(530, "User %s access denied.", $3);
126: }
127: free((char *) $3);
128: }
129: | PASS SP password CRLF
130: = {
131: pass((char *) $3);
132: free((char *) $3);
133: }
134: | PORT SP host_port CRLF
135: = {
136: usedefault = 0;
137: if (pdata > 0) {
138: (void) close(pdata);
139: }
140: pdata = -1;
141: reply(200, "PORT command successful.");
142: }
143: | PASV CRLF
144: = {
145: passive();
146: }
147: | TYPE SP type_code CRLF
148: = {
149: switch (cmd_type) {
150:
151: case TYPE_A:
152: if (cmd_form == FORM_N) {
153: reply(200, "Type set to A.");
154: type = cmd_type;
155: form = cmd_form;
156: } else
157: reply(504, "Form must be N.");
158: break;
159:
160: case TYPE_E:
161: reply(504, "Type E not implemented.");
162: break;
163:
164: case TYPE_I:
165: reply(200, "Type set to I.");
166: type = cmd_type;
167: break;
168:
169: case TYPE_L:
170: if (cmd_bytesz == 8) {
171: reply(200,
172: "Type set to L (byte size 8).");
173: type = cmd_type;
174: } else
175: reply(504, "Byte size must be 8.");
176: }
177: }
178: | STRU SP struct_code CRLF
179: = {
180: switch ($3) {
181:
182: case STRU_F:
183: reply(200, "STRU F ok.");
184: break;
185:
186: default:
187: reply(504, "Unimplemented STRU type.");
188: }
189: }
190: | MODE SP mode_code CRLF
191: = {
192: switch ($3) {
193:
194: case MODE_S:
195: reply(200, "MODE S ok.");
196: break;
197:
198: default:
199: reply(502, "Unimplemented MODE type.");
200: }
201: }
202: | ALLO SP NUMBER CRLF
203: = {
204: reply(202, "ALLO command ignored.");
205: }
206: | RETR check_login SP pathname CRLF
207: = {
208: if ($2 && $4 != NULL)
209: retrieve((char *) 0, (char *) $4);
210: if ($4 != NULL)
211: free((char *) $4);
212: }
213: | STOR check_login SP pathname CRLF
214: = {
215: if ($2 && $4 != NULL)
216: store((char *) $4, "w");
217: if ($4 != NULL)
218: free((char *) $4);
219: }
220: | APPE check_login SP pathname CRLF
221: = {
222: if ($2 && $4 != NULL)
223: store((char *) $4, "a");
224: if ($4 != NULL)
225: free((char *) $4);
226: }
227: | NLST check_login CRLF
228: = {
229: if ($2)
230: retrieve("/bin/ls", "");
231: }
232: | NLST check_login SP pathname CRLF
233: = {
234: if ($2 && $4 != NULL)
235: retrieve("/bin/ls %s", (char *) $4);
236: if ($4 != NULL)
237: free((char *) $4);
238: }
239: | LIST check_login CRLF
240: = {
241: if ($2)
242: retrieve("/bin/ls -lg", "");
243: }
244: | LIST check_login SP pathname CRLF
245: = {
246: if ($2 && $4 != NULL)
247: retrieve("/bin/ls -lg %s", (char *) $4);
248: if ($4 != NULL)
249: free((char *) $4);
250: }
251: | DELE check_login SP pathname CRLF
252: = {
253: if ($2 && $4 != NULL)
254: delete((char *) $4);
255: if ($4 != NULL)
256: free((char *) $4);
257: }
258: | RNTO SP pathname CRLF
259: = {
260: if (fromname) {
261: renamecmd(fromname, (char *) $3);
262: free(fromname);
263: fromname = (char *) 0;
264: } else {
265: reply(503, "Bad sequence of commands.");
266: }
267: free((char *) $3);
268: }
269: | ABOR CRLF
270: = {
271: reply(225, "ABOR command successful.");
272: }
273: | CWD check_login CRLF
274: = {
275: if ($2)
276: cwd(pw->pw_dir);
277: }
278: | CWD check_login SP pathname CRLF
279: = {
280: if ($2 && $4 != NULL)
281: cwd((char *) $4);
282: if ($4 != NULL)
283: free((char *) $4);
284: }
285: | HELP CRLF
286: = {
287: help((char *) 0);
288: }
289: | HELP SP STRING CRLF
290: = {
291: help((char *) $3);
292: }
293: | NOOP CRLF
294: = {
295: reply(200, "NOOP command successful.");
296: }
297: | XMKD check_login SP pathname CRLF
298: = {
299: if ($2 && $4 != NULL)
300: makedir((char *) $4);
301: if ($4 != NULL)
302: free((char *) $4);
303: }
304: | XRMD check_login SP pathname CRLF
305: = {
306: if ($2 && $4 != NULL)
307: removedir((char *) $4);
308: if ($4 != NULL)
309: free((char *) $4);
310: }
311: | XPWD check_login CRLF
312: = {
313: if ($2)
314: pwd();
315: }
316: | XCUP check_login CRLF
317: = {
318: if ($2)
319: cwd("..");
320: }
321: | STOU check_login SP pathname CRLF
322: = {
323: if ($2 && $4 != NULL) {
324: unique++;
325: store((char *) $4, "w");
326: unique = 0;
327: }
328: if ($4 != NULL)
329: free((char *) $4);
330: }
331: | QUIT CRLF
332: = {
333: reply(221, "Goodbye.");
334: dologout(0);
335: }
336: | error CRLF
337: = {
338: yyerrok;
339: }
340: ;
341:
342: rcmd: RNFR check_login SP pathname CRLF
343: = {
344: char *renamefrom();
345:
346: if ($2 && $4) {
347: fromname = renamefrom((char *) $4);
348: if (fromname == (char *) 0 && $4) {
349: free((char *) $4);
350: }
351: }
352: }
353: ;
354:
355: username: STRING
356: ;
357:
358: password: STRING
359: ;
360:
361: byte_size: NUMBER
362: ;
363:
364: host_port: NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA
365: NUMBER COMMA NUMBER
366: = {
367: register char *a, *p;
368:
369: a = (char *)&data_dest.sin_addr;
370: a[0] = $1; a[1] = $3; a[2] = $5; a[3] = $7;
371: p = (char *)&data_dest.sin_port;
372: p[0] = $9; p[1] = $11;
373: data_dest.sin_family = AF_INET;
374: }
375: ;
376:
377: form_code: N
378: = {
379: $$ = FORM_N;
380: }
381: | T
382: = {
383: $$ = FORM_T;
384: }
385: | C
386: = {
387: $$ = FORM_C;
388: }
389: ;
390:
391: type_code: A
392: = {
393: cmd_type = TYPE_A;
394: cmd_form = FORM_N;
395: }
396: | A SP form_code
397: = {
398: cmd_type = TYPE_A;
399: cmd_form = $3;
400: }
401: | E
402: = {
403: cmd_type = TYPE_E;
404: cmd_form = FORM_N;
405: }
406: | E SP form_code
407: = {
408: cmd_type = TYPE_E;
409: cmd_form = $3;
410: }
411: | I
412: = {
413: cmd_type = TYPE_I;
414: }
415: | L
416: = {
417: cmd_type = TYPE_L;
418: cmd_bytesz = 8;
419: }
420: | L SP byte_size
421: = {
422: cmd_type = TYPE_L;
423: cmd_bytesz = $3;
424: }
425: /* this is for a bug in the BBN ftp */
426: | L byte_size
427: = {
428: cmd_type = TYPE_L;
429: cmd_bytesz = $2;
430: }
431: ;
432:
433: struct_code: F
434: = {
435: $$ = STRU_F;
436: }
437: | R
438: = {
439: $$ = STRU_R;
440: }
441: | P
442: = {
443: $$ = STRU_P;
444: }
445: ;
446:
447: mode_code: S
448: = {
449: $$ = MODE_S;
450: }
451: | B
452: = {
453: $$ = MODE_B;
454: }
455: | C
456: = {
457: $$ = MODE_C;
458: }
459: ;
460:
461: pathname: pathstring
462: = {
463: /*
464: * Problem: this production is used for all pathname
465: * processing, but only gives a 550 error reply.
466: * This is a valid reply in some cases but not in others.
467: */
468: if ($1 && strncmp((char *) $1, "~", 1) == 0) {
469: $$ = (int)*glob((char *) $1);
470: if (globerr != NULL) {
471: reply(550, globerr);
472: $$ = NULL;
473: }
474: free((char *) $1);
475: } else
476: $$ = $1;
477: }
478: ;
479:
480: pathstring: STRING
481: ;
482:
483: check_login: /* empty */
484: = {
485: if (logged_in)
486: $$ = 1;
487: else {
488: reply(530, "Please login with USER and PASS.");
489: $$ = 0;
490: }
491: }
492: ;
493:
494: %%
495:
496: extern jmp_buf errcatch;
497:
498: #define CMD 0 /* beginning of command */
499: #define ARGS 1 /* expect miscellaneous arguments */
500: #define STR1 2 /* expect SP followed by STRING */
501: #define STR2 3 /* expect STRING */
502: #define OSTR 4 /* optional STRING */
503:
504: struct tab {
505: char *name;
506: short token;
507: short state;
508: short implemented; /* 1 if command is implemented */
509: char *help;
510: };
511:
512: struct tab cmdtab[] = { /* In order defined in RFC 765 */
513: { "USER", USER, STR1, 1, "<sp> username" },
514: { "PASS", PASS, STR1, 1, "<sp> password" },
515: { "ACCT", ACCT, STR1, 0, "(specify account)" },
516: { "REIN", REIN, ARGS, 0, "(reinitialize server state)" },
517: { "QUIT", QUIT, ARGS, 1, "(terminate service)", },
518: { "PORT", PORT, ARGS, 1, "<sp> b0, b1, b2, b3, b4" },
519: { "PASV", PASV, ARGS, 1, "(set server in passive mode)" },
520: { "TYPE", TYPE, ARGS, 1, "<sp> [ A | E | I | L ]" },
521: { "STRU", STRU, ARGS, 1, "(specify file structure)" },
522: { "MODE", MODE, ARGS, 1, "(specify transfer mode)" },
523: { "RETR", RETR, STR1, 1, "<sp> file-name" },
524: { "STOR", STOR, STR1, 1, "<sp> file-name" },
525: { "APPE", APPE, STR1, 1, "<sp> file-name" },
526: { "MLFL", MLFL, OSTR, 0, "(mail file)" },
527: { "MAIL", MAIL, OSTR, 0, "(mail to user)" },
528: { "MSND", MSND, OSTR, 0, "(mail send to terminal)" },
529: { "MSOM", MSOM, OSTR, 0, "(mail send to terminal or mailbox)" },
530: { "MSAM", MSAM, OSTR, 0, "(mail send to terminal and mailbox)" },
531: { "MRSQ", MRSQ, OSTR, 0, "(mail recipient scheme question)" },
532: { "MRCP", MRCP, STR1, 0, "(mail recipient)" },
533: { "ALLO", ALLO, ARGS, 1, "allocate storage (vacuously)" },
534: { "REST", REST, STR1, 0, "(restart command)" },
535: { "RNFR", RNFR, STR1, 1, "<sp> file-name" },
536: { "RNTO", RNTO, STR1, 1, "<sp> file-name" },
537: { "ABOR", ABOR, ARGS, 1, "(abort operation)" },
538: { "DELE", DELE, STR1, 1, "<sp> file-name" },
539: { "CWD", CWD, OSTR, 1, "[ <sp> directory-name]" },
540: { "XCWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
541: { "LIST", LIST, OSTR, 1, "[ <sp> path-name ]" },
542: { "NLST", NLST, OSTR, 1, "[ <sp> path-name ]" },
543: { "SITE", SITE, STR1, 0, "(get site parameters)" },
544: { "STAT", STAT, OSTR, 0, "(get server status)" },
545: { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
546: { "NOOP", NOOP, ARGS, 1, "" },
547: { "MKD", XMKD, STR1, 1, "<sp> path-name" },
548: { "XMKD", XMKD, STR1, 1, "<sp> path-name" },
549: { "RMD", XRMD, STR1, 1, "<sp> path-name" },
550: { "XRMD", XRMD, STR1, 1, "<sp> path-name" },
551: { "PWD", XPWD, ARGS, 1, "(return current directory)" },
552: { "XPWD", XPWD, ARGS, 1, "(return current directory)" },
553: { "CDUP", XCUP, ARGS, 1, "(change to parent directory)" },
554: { "XCUP", XCUP, ARGS, 1, "(change to parent directory)" },
555: { "STOU", STOU, STR1, 1, "<sp> file-name" },
556: { NULL, 0, 0, 0, 0 }
557: };
558:
559: struct tab *
560: lookup(cmd)
561: char *cmd;
562: {
563: register struct tab *p;
564:
565: for (p = cmdtab; p->name != NULL; p++)
566: if (strcmp(cmd, p->name) == 0)
567: return (p);
568: return (0);
569: }
570:
571: #include <arpa/telnet.h>
572:
573: /*
574: * getline - a hacked up version of fgets to ignore TELNET escape codes.
575: */
576: char *
577: getline(s, n, iop)
578: char *s;
579: register FILE *iop;
580: {
581: register c;
582: register char *cs;
583:
584: cs = s;
585: /* tmpline may contain saved command from urgent mode interruption */
586: for (c = 0; tmpline[c] != '\0' && --n > 0; ++c) {
587: *cs++ = tmpline[c];
588: if (tmpline[c] == '\n') {
589: *cs++ = '\0';
590: if (debug) {
591: syslog(LOG_DEBUG, "FTPD: command: %s", s);
592: }
593: tmpline[0] = '\0';
594: return(s);
595: }
596: if (c == 0) {
597: tmpline[0] = '\0';
598: }
599: }
600: while (--n > 0 && (c = getc(iop)) != EOF) {
601: c = 0377 & c;
602: while (c == IAC) {
603: switch (c = 0377 & getc(iop)) {
604: case WILL:
605: case WONT:
606: c = 0377 & getc(iop);
607: printf("%c%c%c", IAC, WONT, c);
608: (void) fflush(stdout);
609: break;
610: case DO:
611: case DONT:
612: c = 0377 & getc(iop);
613: printf("%c%c%c", IAC, DONT, c);
614: (void) fflush(stdout);
615: break;
616: default:
617: break;
618: }
619: c = 0377 & getc(iop); /* try next character */
620: }
621: *cs++ = c;
622: if (c=='\n')
623: break;
624: }
625: if (c == EOF && cs == s)
626: return (NULL);
627: *cs++ = '\0';
628: if (debug) {
629: syslog(LOG_DEBUG, "FTPD: command: %s", s);
630: }
631: return (s);
632: }
633:
634: static int
635: toolong()
636: {
637: time_t now;
638: extern char *ctime();
639: extern time_t time();
640:
641: reply(421,
642: "Timeout (%d seconds): closing control connection.", timeout);
643: (void) time(&now);
644: if (logging) {
645: syslog(LOG_INFO,
646: "FTPD: User %s timed out after %d seconds at %s",
647: (pw ? pw -> pw_name : "unknown"), timeout, ctime(&now));
648: }
649: dologout(1);
650: }
651:
652: yylex()
653: {
654: static int cpos, state;
655: register char *cp;
656: register struct tab *p;
657: int n;
658: char c;
659:
660: for (;;) {
661: switch (state) {
662:
663: case CMD:
664: (void) signal(SIGALRM, toolong);
665: (void) alarm((unsigned) timeout);
666: if (getline(cbuf, sizeof(cbuf)-1, stdin) == NULL) {
667: reply(221, "You could at least say goodbye.");
668: dologout(0);
669: }
670: (void) alarm(0);
671: if (index(cbuf, '\r')) {
672: cp = index(cbuf, '\r');
673: cp[0] = '\n'; cp[1] = 0;
674: }
675: if (index(cbuf, ' '))
676: cpos = index(cbuf, ' ') - cbuf;
677: else
678: cpos = index(cbuf, '\n') - cbuf;
679: if (cpos == 0) {
680: cpos = 4;
681: }
682: c = cbuf[cpos];
683: cbuf[cpos] = '\0';
684: upper(cbuf);
685: p = lookup(cbuf);
686: cbuf[cpos] = c;
687: if (p != 0) {
688: if (p->implemented == 0) {
689: nack(p->name);
690: longjmp(errcatch,0);
691: /* NOTREACHED */
692: }
693: state = p->state;
694: yylval = (int) p->name;
695: return (p->token);
696: }
697: break;
698:
699: case OSTR:
700: if (cbuf[cpos] == '\n') {
701: state = CMD;
702: return (CRLF);
703: }
704: /* FALL THRU */
705:
706: case STR1:
707: if (cbuf[cpos] == ' ') {
708: cpos++;
709: state = STR2;
710: return (SP);
711: }
712: break;
713:
714: case STR2:
715: cp = &cbuf[cpos];
716: n = strlen(cp);
717: cpos += n - 1;
718: /*
719: * Make sure the string is nonempty and \n terminated.
720: */
721: if (n > 1 && cbuf[cpos] == '\n') {
722: cbuf[cpos] = '\0';
723: yylval = copy(cp);
724: cbuf[cpos] = '\n';
725: state = ARGS;
726: return (STRING);
727: }
728: break;
729:
730: case ARGS:
731: if (isdigit(cbuf[cpos])) {
732: cp = &cbuf[cpos];
733: while (isdigit(cbuf[++cpos]))
734: ;
735: c = cbuf[cpos];
736: cbuf[cpos] = '\0';
737: yylval = atoi(cp);
738: cbuf[cpos] = c;
739: return (NUMBER);
740: }
741: switch (cbuf[cpos++]) {
742:
743: case '\n':
744: state = CMD;
745: return (CRLF);
746:
747: case ' ':
748: return (SP);
749:
750: case ',':
751: return (COMMA);
752:
753: case 'A':
754: case 'a':
755: return (A);
756:
757: case 'B':
758: case 'b':
759: return (B);
760:
761: case 'C':
762: case 'c':
763: return (C);
764:
765: case 'E':
766: case 'e':
767: return (E);
768:
769: case 'F':
770: case 'f':
771: return (F);
772:
773: case 'I':
774: case 'i':
775: return (I);
776:
777: case 'L':
778: case 'l':
779: return (L);
780:
781: case 'N':
782: case 'n':
783: return (N);
784:
785: case 'P':
786: case 'p':
787: return (P);
788:
789: case 'R':
790: case 'r':
791: return (R);
792:
793: case 'S':
794: case 's':
795: return (S);
796:
797: case 'T':
798: case 't':
799: return (T);
800:
801: }
802: break;
803:
804: default:
805: fatal("Unknown state in scanner.");
806: }
807: yyerror((char *) 0);
808: state = CMD;
809: longjmp(errcatch,0);
810: }
811: }
812:
813: upper(s)
814: char *s;
815: {
816: while (*s != '\0') {
817: if (islower(*s))
818: *s = toupper(*s);
819: s++;
820: }
821: }
822:
823: copy(s)
824: char *s;
825: {
826: char *p;
827: extern char *malloc(), *strcpy();
828:
829: p = malloc((unsigned) strlen(s) + 1);
830: if (p == NULL)
831: fatal("Ran out of memory.");
832: (void) strcpy(p, s);
833: return ((int)p);
834: }
835:
836: help(s)
837: char *s;
838: {
839: register struct tab *c;
840: register int width, NCMDS;
841:
842: width = 0, NCMDS = 0;
843: for (c = cmdtab; c->name != NULL; c++) {
844: int len = strlen(c->name) + 1;
845:
846: if (len > width)
847: width = len;
848: NCMDS++;
849: }
850: width = (width + 8) &~ 7;
851: if (s == 0) {
852: register int i, j, w;
853: int columns, lines;
854:
855: lreply(214,
856: "The following commands are recognized (* =>'s unimplemented).");
857: columns = 76 / width;
858: if (columns == 0)
859: columns = 1;
860: lines = (NCMDS + columns - 1) / columns;
861: for (i = 0; i < lines; i++) {
862: printf(" ");
863: for (j = 0; j < columns; j++) {
864: c = cmdtab + j * lines + i;
865: printf("%s%c", c->name,
866: c->implemented ? ' ' : '*');
867: if (c + lines >= &cmdtab[NCMDS])
868: break;
869: w = strlen(c->name) + 1;
870: while (w < width) {
871: putchar(' ');
872: w++;
873: }
874: }
875: printf("\r\n");
876: }
877: (void) fflush(stdout);
878: reply(214, "Direct comments to ftp-bugs@%s.", hostname);
879: return;
880: }
881: upper(s);
882: c = lookup(s);
883: if (c == (struct tab *)0) {
884: reply(502, "Unknown command %s.", s);
885: return;
886: }
887: if (c->implemented)
888: reply(214, "Syntax: %s %s", c->name, c->help);
889: else
890: reply(214, "%-*s\t%s; unimplemented.", width, c->name, c->help);
891: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.