?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
time: Use clock_gettime
[dragonfly.git] / contrib / opie / ftpcmd.y
blob34c9c5a21fed46d42cb1d0406e9cc9e6e3288c68
1 /* ftpcmd.y: yacc parser for the FTP daemon.
2
3 %%% portions-copyright-cmetz-96
4 Portions of this software are Copyright 1996-1999 by Craig Metz, All Rights
5 Reserved. The Inner Net License Version 2 applies to these portions of
6 the software.
7 You should have received a copy of the license with this software. If
8 you didn't get a copy, you may request one from <license@inner.net>.
9
10 History:
11
12 Modified by cmetz for OPIE 2.4. Use DOTITLE rather than SETPROCTITLE.
13 Modified by cmetz for OPIE 2.3. Moved LS_COMMAND here.
14 Modified by cmetz for OPIE 2.2. Fixed a *lot* of warnings.
15 Use FUNCTION declaration et al. Removed useless strings.
16 Changed some char []s to char *s. Deleted comment address.
17 Changed tmpline references to be more pure-pointer
18 references. Changed tmpline declaration back to char [].
19 Modified at NRL for OPIE 2.1. Minor changes for autoconf.
20 Modified at NRL for OPIE 2.01. Added forward declaration for sitetab[]
21 -- fixes problems experienced by bison users. Merged in new
22 PORT attack fixes from Hobbit.
23 Modified at NRL for OPIE 2.0.
24 Originally from BSD.
25
26 $FreeBSD: head/contrib/opie/ftpcmd.y 92914 2002-03-21 23:42:52Z markm $
27 */
28 /*
29 * Copyright (c) 1985, 1988 Regents of the University of California.
30 * All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)ftpcmd.y 5.24 (Berkeley) 2/25/91
61 */
62
63 /*
64 * Grammar for FTP commands.
65 * See RFC 959.
66 */
67
68 %{
69 #include "opie_cfg.h"
70
71 #include <sys/param.h>
72 #include <sys/types.h>
73 #include <sys/socket.h>
74 #include <sys/stat.h>
75 #include <netinet/in.h>
76 #include <arpa/ftp.h>
77 #include <signal.h>
78 #include <setjmp.h>
79 #include <syslog.h>
80 #if TM_IN_SYS_TIME
81 #include <sys/time.h>
82 #else /* TM_IN_SYS_TIME */
83 #include <time.h>
84 #endif /* TM_IN_SYS_TIME */
85 #include <pwd.h>
86 #include <unistd.h>
87 #include <stdio.h>
88 #include <ctype.h>
89 #include <stdlib.h>
90 #include <string.h>
91
92 #include "opie.h"
93
94 #if HAVE_LS_G_FLAG
95 #define LS_COMMAND "/bin/ls -lgA"
96 #else /* HAVE_LS_G_FLAG */
97 #define LS_COMMAND "/bin/ls -lA"
98 #endif /* HAVE_LS_G_FLAG */
99
100 extern struct sockaddr_in data_dest;
101 extern struct sockaddr_in his_addr;
102 extern int logged_in;
103 extern struct passwd *pw;
104 extern int guest;
105 extern int type;
106 extern int form;
107 extern int debug;
108 extern int timeout;
109 extern int maxtimeout;
110 extern int pdata;
111 extern char *remotehost;
112 extern char *proctitle;
113 extern char *globerr;
114 extern int usedefault;
115 extern int transflag;
116 extern char tmpline[];
117 char **ftpglob();
118
119 VOIDRET dologout __P((int));
120 VOIDRET upper __P((char *));
121 VOIDRET nack __P((char *));
122 VOIDRET opiefatal __P((char *));
123
124 VOIDRET pass __P((char *));
125 int user __P((char *));
126 VOIDRET passive __P((void));
127 VOIDRET retrieve __P((char *, char *));
128 VOIDRET store __P((char *, char *, int));
129 VOIDRET send_file_list __P((char *));
130 VOIDRET statfilecmd __P((char *));
131 VOIDRET statcmd __P((void));
132 VOIDRET delete __P((char *));
133 VOIDRET renamecmd __P((char *, char *));
134 VOIDRET cwd __P((char *));
135 VOIDRET makedir __P((char *));
136 VOIDRET removedir __P((char *));
137 VOIDRET pwd __P((void));
138
139 VOIDRET sizecmd __P((char *));
140
141 off_t restart_point;
142
143 static int cmd_type;
144 static int cmd_form;
145 static int cmd_bytesz;
146 static unsigned short cliport = 0;
147 char cbuf[512];
148 char *fromname;
149
150 struct tab {
151 char *name;
152 short token;
153 short state;
154 short implemented; /* 1 if command is implemented */
155 char *help;
156 };
157
158 VOIDRET help __P((struct tab *, char *));
159
160 struct tab cmdtab[], sitetab[];
161
162 %}
163
164 %token
165 A B C E F I
166 L N P R S T
167
168 SP CRLF COMMA STRING NUMBER
169
170 USER PASS ACCT REIN QUIT PORT
171 PASV TYPE STRU MODE RETR STOR
172 APPE MLFL MAIL MSND MSOM MSAM
173 MRSQ MRCP ALLO REST RNFR RNTO
174 ABOR DELE CWD LIST NLST SITE
175 STAT HELP NOOP MKD RMD PWD
176 CDUP STOU SMNT SYST SIZE MDTM
177
178 UMASK IDLE CHMOD
179
180 LEXERR
181
182 %start cmd_list
183
184 %%
185
186 cmd_list: /* empty */
187 | cmd_list cmd
188 = {
189 fromname = (char *) 0;
190 restart_point = (off_t) 0;
191 }
192 | cmd_list rcmd
193 ;
194
195 cmd: USER SP username CRLF
196 = {
197 user((char *) $3);
198 free((char *) $3);
199 }
200 | PASS SP password CRLF
201 = {
202 pass((char *) $3);
203 free((char *) $3);
204 }
205 | PORT check_login SP host_port CRLF
206 = {
207 usedefault = 0;
208 if (pdata >= 0) {
209 (void) close(pdata);
210 pdata = -1;
211 }
212 /* H* port fix, part B: admonish the twit.
213 Also require login before PORT works */
214 if ($2) {
215 if ((cliport > 1023) && (data_dest.sin_addr.s_addr > 0)) {
216 reply(200, "PORT command successful.");
217 } else {
218 syslog (LOG_WARNING, "refused %s from %s",
219 cbuf, remotehost);
220 reply(500, "You've GOT to be joking.");
221 }
222 }
223 }
224 /* | PASV CRLF
225 = {
226 passive();
227 } */
228 | PASV check_login CRLF
229 = {
230 /* Require login for PASV, too. This actually fixes a bug -- telnet to an
231 unfixed wu-ftpd and type PASV first off, and it crashes! */
232 if ($2) {
233 passive();
234 }
235 }
236 | TYPE SP type_code CRLF
237 = {
238 switch (cmd_type) {
239
240 case TYPE_A:
241 if (cmd_form == FORM_N) {
242 reply(200, "Type set to A.");
243 type = cmd_type;
244 form = cmd_form;
245 } else
246 reply(504, "Form must be N.");
247 break;
248
249 case TYPE_E:
250 reply(504, "Type E not implemented.");
251 break;
252
253 case TYPE_I:
254 reply(200, "Type set to I.");
255 type = cmd_type;
256 break;
257
258 case TYPE_L:
259 #if NBBY == 8
260 if (cmd_bytesz == 8) {
261 reply(200,
262 "Type set to L (byte size 8).");
263 type = cmd_type;
264 } else
265 reply(504, "Byte size must be 8.");
266 #else /* NBBY == 8 */
267 UNIMPLEMENTED for NBBY != 8
268 #endif /* NBBY == 8 */
269 }
270 }
271 | STRU SP struct_code CRLF
272 = {
273 switch ($3) {
274
275 case STRU_F:
276 reply(200, "STRU F ok.");
277 break;
278
279 default:
280 reply(504, "Unimplemented STRU type.");
281 }
282 }
283 | MODE SP mode_code CRLF
284 = {
285 switch ($3) {
286
287 case MODE_S:
288 reply(200, "MODE S ok.");
289 break;
290
291 default:
292 reply(502, "Unimplemented MODE type.");
293 }
294 }
295 | ALLO SP NUMBER CRLF
296 = {
297 reply(202, "ALLO command ignored.");
298 }
299 | ALLO SP NUMBER SP R SP NUMBER CRLF
300 = {
301 reply(202, "ALLO command ignored.");
302 }
303 | RETR check_login SP pathname CRLF
304 = {
305 if ($2 && $4)
306 retrieve((char *) 0, (char *) $4);
307 if ($4)
308 free((char *) $4);
309 }
310 | STOR check_login SP pathname CRLF
311 = {
312 if ($2 && $4)
313 store((char *) $4, "w", 0);
314 if ($4)
315 free((char *) $4);
316 }
317 | APPE check_login SP pathname CRLF
318 = {
319 if ($2 && $4)
320 store((char *) $4, "a", 0);
321 if ($4)
322 free((char *) $4);
323 }
324 | NLST check_login CRLF
325 = {
326 if ($2)
327 send_file_list(".");
328 }
329 | NLST check_login SP STRING CRLF
330 = {
331 if ($2 && $4)
332 send_file_list((char *) $4);
333 if ($4)
334 free((char *) $4);
335 }
336 | LIST check_login CRLF
337 = {
338 if ($2)
339 retrieve(LS_COMMAND, "");
340 }
341 | LIST check_login SP pathname CRLF
342 = {
343 if ($2 && $4)
344 {
345 char buffer[sizeof(LS_COMMAND)+3];
346 strcpy(buffer, LS_COMMAND);
347 strcat(buffer, " %s");
348 retrieve(buffer, (char *) $4);
349 }
350 if ($4)
351 free((char *) $4);
352 }
353 | STAT check_login SP pathname CRLF
354 = {
355 if ($2 && $4)
356 statfilecmd((char *) $4);
357 if ($4)
358 free((char *) $4);
359 }
360 | STAT CRLF
361 = {
362 statcmd();
363 }
364 | DELE check_login SP pathname CRLF
365 = {
366 if ($2 && $4)
367 delete((char *) $4);
368 if ($4)
369 free((char *) $4);
370 }
371 | RNTO SP pathname CRLF
372 = {
373 if (fromname) {
374 renamecmd(fromname, (char *) $3);
375 free(fromname);
376 fromname = (char *) 0;
377 } else {
378 reply(503, "Bad sequence of commands.");
379 }
380 free((char *) $3);
381 }
382 | ABOR CRLF
383 = {
384 reply(225, "ABOR command successful.");
385 }
386 | CWD check_login CRLF
387 = {
388 if ($2)
389 cwd(pw->pw_dir);
390 }
391 | CWD check_login SP pathname CRLF
392 = {
393 if ($2 && $4)
394 cwd((char *) $4);
395 if ($4)
396 free((char *) $4);
397 }
398 | HELP CRLF
399 = {
400 help(cmdtab, (char *) 0);
401 }
402 | HELP SP STRING CRLF
403 = {
404 register char *cp = (char *)$3;
405
406 if (strncasecmp(cp, "SITE", 4) == 0) {
407 cp = (char *)$3 + 4;
408 if (*cp == ' ')
409 cp++;
410 if (*cp)
411 help(sitetab, cp);
412 else
413 help(sitetab, (char *) 0);
414 } else
415 help(cmdtab, (char *) $3);
416 }
417 | NOOP CRLF
418 = {
419 reply(200, "NOOP command successful.");
420 }
421 | MKD check_login SP pathname CRLF
422 = {
423 if ($2 && $4)
424 makedir((char *) $4);
425 if ($4)
426 free((char *) $4);
427 }
428 | RMD check_login SP pathname CRLF
429 = {
430 if ($2 && $4)
431 removedir((char *) $4);
432 if ($4)
433 free((char *) $4);
434 }
435 | PWD check_login CRLF
436 = {
437 if ($2)
438 pwd();
439 }
440 | CDUP check_login CRLF
441 = {
442 if ($2)
443 cwd("..");
444 }
445 | SITE SP HELP CRLF
446 = {
447 help(sitetab, (char *) 0);
448 }
449 | SITE SP HELP SP STRING CRLF
450 = {
451 help(sitetab, (char *) $5);
452 }
453 | SITE SP UMASK check_login CRLF
454 = {
455 int oldmask;
456
457 if ($4) {
458 oldmask = umask(0);
459 (void) umask(oldmask);
460 reply(200, "Current UMASK is %03o", oldmask);
461 }
462 }
463 | SITE SP UMASK check_login SP octal_number CRLF
464 = {
465 int oldmask;
466
467 if ($4) {
468 if (($6 == -1) || ($6 > 0777)) {
469 reply(501, "Bad UMASK value");
470 } else {
471 oldmask = umask($6);
472 reply(200,
473 "UMASK set to %03o (was %03o)",
474 $6, oldmask);
475 }
476 }
477 }
478 | SITE SP CHMOD check_login SP octal_number SP pathname CRLF
479 = {
480 if ($4 && $8) {
481 if ($6 > 0777)
482 reply(501,
483 "CHMOD: Mode value must be between 0 and 0777");
484 else if (chmod((char *) $8, $6) < 0)
485 perror_reply(550, (char *) $8);
486 else
487 reply(200, "CHMOD command successful.");
488 }
489 if ($8)
490 free((char *) $8);
491 }
492 | SITE SP IDLE CRLF
493 = {
494 reply(200,
495 "Current IDLE time limit is %d seconds; max %d",
496 timeout, maxtimeout);
497 }
498 | SITE SP IDLE SP NUMBER CRLF
499 = {
500 if ($5 < 30 || $5 > maxtimeout) {
501 reply(501,
502 "Maximum IDLE time must be between 30 and %d seconds",
503 maxtimeout);
504 } else {
505 timeout = $5;
506 (void) alarm((unsigned) timeout);
507 reply(200,
508 "Maximum IDLE time set to %d seconds",
509 timeout);
510 }
511 }
512 | STOU check_login SP pathname CRLF
513 = {
514 if ($2 && $4)
515 store((char *) $4, "w", 1);
516 if ($4)
517 free((char *) $4);
518 }
519 | SYST CRLF
520 = {
521 #ifdef unix
522 #ifdef BSD
523 reply(215, "UNIX Type: L%d Version: BSD-%d",
524 NBBY, BSD);
525 #else /* BSD */
526 reply(215, "UNIX Type: L%d", NBBY);
527 #endif /* BSD */
528 #else /* unix */
529 reply(215, "UNKNOWN Type: L%d", NBBY);
530 #endif /* unix */
531 }
532
533 /*
534 * SIZE is not in RFC959, but Postel has blessed it and
535 * it will be in the updated RFC.
536 *
537 * Return size of file in a format suitable for
538 * using with RESTART (we just count bytes).
539 */
540 | SIZE check_login SP pathname CRLF
541 = {
542 if ($2 && $4)
543 sizecmd((char *) $4);
544 if ($4)
545 free((char *) $4);
546 }
547
548 /*
549 * MDTM is not in RFC959, but Postel has blessed it and
550 * it will be in the updated RFC.
551 *
552 * Return modification time of file as an ISO 3307
553 * style time. E.g. YYYYMMDDHHMMSS or YYYYMMDDHHMMSS.xxx
554 * where xxx is the fractional second (of any precision,
555 * not necessarily 3 digits)
556 */
557 | MDTM check_login SP pathname CRLF
558 = {
559 if ($2 && $4) {
560 struct stat stbuf;
561 if (stat((char *) $4, &stbuf) < 0)
562 perror_reply(550, (char *) $4);
563 else if ((stbuf.st_mode&S_IFMT) != S_IFREG) {
564 reply(550, "%s: not a plain file.",
565 (char *) $4);
566 } else {
567 register struct tm *t;
568 struct tm *gmtime();
569 t = gmtime(&stbuf.st_mtime);
570 reply(213,
571 "%d%02d%02d%02d%02d%02d",
572 t->tm_year+1900, t->tm_mon+1, t->tm_mday,
573 t->tm_hour, t->tm_min, t->tm_sec);
574 }
575 }
576 if ($4)
577 free((char *) $4);
578 }
579 | QUIT CRLF
580 = {
581 reply(221, "Goodbye.");
582 dologout(0);
583 }
584 | error CRLF
585 = {
586 yyerrok;
587 }
588 ;
589 rcmd: RNFR check_login SP pathname CRLF
590 = {
591 char *renamefrom();
592
593 restart_point = (off_t) 0;
594 if ($2 && $4) {
595 fromname = renamefrom((char *) $4);
596 if (fromname == (char *) 0 && $4) {
597 free((char *) $4);
598 }
599 }
600 }
601 | REST SP byte_size CRLF
602 = {
603 long atol();
604
605 fromname = (char *) 0;
606 restart_point = $3;
607 reply(350, "Restarting at %ld. %s", restart_point,
608 "Send STORE or RETRIEVE to initiate transfer.");
609 }
610 ;
611
612 username: STRING
613 ;
614
615 password: /* empty */
616 = {
617 *(char **)&($$) = (char *)calloc(1, sizeof(char));
618 }
619 | STRING
620 ;
621
622 byte_size: NUMBER
623 ;
624
625 host_port: NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA
626 NUMBER COMMA NUMBER
627 = {
628 register char *a, *p;
629
630 a = (char *)&data_dest.sin_addr;
631 a[0] = $1; a[1] = $3; a[2] = $5; a[3] = $7;
632
633 /* H* port fix, part A-1: Check the args against the client addr */
634 p = (char *)&his_addr.sin_addr;
635 if (memcmp (a, p, sizeof (data_dest.sin_addr)))
636 memset (a, 0, sizeof (data_dest.sin_addr)); /* XXX */
637
638 p = (char *)&data_dest.sin_port;
639
640 /* H* port fix, part A-2: only allow client ports in "user space" */
641 p[0] = 0; p[1] = 0;
642 cliport = ($9 << 8) + $11;
643 if (cliport > 1023) {
644 p[0] = $9; p[1] = $11;
645 }
646
647 p[0] = $9; p[1] = $11;
648 data_dest.sin_family = AF_INET;
649 }
650 ;
651
652 form_code: N
653 = {
654 $$ = FORM_N;
655 }
656 | T
657 = {
658 $$ = FORM_T;
659 }
660 | C
661 = {
662 $$ = FORM_C;
663 }
664 ;
665
666 type_code: A
667 = {
668 cmd_type = TYPE_A;
669 cmd_form = FORM_N;
670 }
671 | A SP form_code
672 = {
673 cmd_type = TYPE_A;
674 cmd_form = $3;
675 }
676 | E
677 = {
678 cmd_type = TYPE_E;
679 cmd_form = FORM_N;
680 }
681 | E SP form_code
682 = {
683 cmd_type = TYPE_E;
684 cmd_form = $3;
685 }
686 | I
687 = {
688 cmd_type = TYPE_I;
689 }
690 | L
691 = {
692 cmd_type = TYPE_L;
693 cmd_bytesz = NBBY;
694 }
695 | L SP byte_size
696 = {
697 cmd_type = TYPE_L;
698 cmd_bytesz = $3;
699 }
700 /* this is for a bug in the BBN ftp */
701 | L byte_size
702 = {
703 cmd_type = TYPE_L;
704 cmd_bytesz = $2;
705 }
706 ;
707
708 struct_code: F
709 = {
710 $$ = STRU_F;
711 }
712 | R
713 = {
714 $$ = STRU_R;
715 }
716 | P
717 = {
718 $$ = STRU_P;
719 }
720 ;
721
722 mode_code: S
723 = {
724 $$ = MODE_S;
725 }
726 | B
727 = {
728 $$ = MODE_B;
729 }
730 | C
731 = {
732 $$ = MODE_C;
733 }
734 ;
735
736 pathname: pathstring
737 = {
738 /*
739 * Problem: this production is used for all pathname
740 * processing, but only gives a 550 error reply.
741 * This is a valid reply in some cases but not in others.
742 */
743 if (logged_in && $1 && strncmp((char *) $1, "~", 1) == 0) {
744 *(char **)&($$) = *ftpglob((char *) $1);
745 if (globerr != NULL) {
746 reply(550, globerr);
747 /* $$ = NULL; */
748 $$ = 0;
749 }
750 free((char *) $1);
751 } else
752 $$ = $1;
753 }
754 ;
755
756 pathstring: STRING
757 ;
758
759 octal_number: NUMBER
760 = {
761 register int ret, dec, multby, digit;
762
763 /*
764 * Convert a number that was read as decimal number
765 * to what it would be if it had been read as octal.
766 */
767 dec = $1;
768 multby = 1;
769 ret = 0;
770 while (dec) {
771 digit = dec%10;
772 if (digit > 7) {
773 ret = -1;
774 break;
775 }
776 ret += digit * multby;
777 multby *= 8;
778 dec /= 10;
779 }
780 $$ = ret;
781 }
782 ;
783
784 check_login: /* empty */
785 = {
786 if (logged_in)
787 $$ = 1;
788 else {
789 reply(530, "Please login with USER and PASS.");
790 $$ = 0;
791 }
792 }
793 ;
794
795 %%
796
797 extern jmp_buf errcatch;
798
799 #define CMD 0 /* beginning of command */
800 #define ARGS 1 /* expect miscellaneous arguments */
801 #define STR1 2 /* expect SP followed by STRING */
802 #define STR2 3 /* expect STRING */
803 #define OSTR 4 /* optional SP then STRING */
804 #define ZSTR1 5 /* SP then optional STRING */
805 #define ZSTR2 6 /* optional STRING after SP */
806 #define SITECMD 7 /* SITE command */
807 #define NSTR 8 /* Number followed by a string */
808
809 struct tab cmdtab[] = { /* In order defined in RFC 765 */
810 { "USER", USER, STR1, 1, "<sp> username" },
811 { "PASS", PASS, ZSTR1, 1, "<sp> password" },
812 { "ACCT", ACCT, STR1, 0, "(specify account)" },
813 { "SMNT", SMNT, ARGS, 0, "(structure mount)" },
814 { "REIN", REIN, ARGS, 0, "(reinitialize server state)" },
815 { "QUIT", QUIT, ARGS, 1, "(terminate service)", },
816 { "PORT", PORT, ARGS, 1, "<sp> b0, b1, b2, b3, b4" },
817 { "PASV", PASV, ARGS, 1, "(set server in passive mode)" },
818 { "TYPE", TYPE, ARGS, 1, "<sp> [ A | E | I | L ]" },
819 { "STRU", STRU, ARGS, 1, "(specify file structure)" },
820 { "MODE", MODE, ARGS, 1, "(specify transfer mode)" },
821 { "RETR", RETR, STR1, 1, "<sp> file-name" },
822 { "STOR", STOR, STR1, 1, "<sp> file-name" },
823 { "APPE", APPE, STR1, 1, "<sp> file-name" },
824 { "MLFL", MLFL, OSTR, 0, "(mail file)" },
825 { "MAIL", MAIL, OSTR, 0, "(mail to user)" },
826 { "MSND", MSND, OSTR, 0, "(mail send to terminal)" },
827 { "MSOM", MSOM, OSTR, 0, "(mail send to terminal or mailbox)" },
828 { "MSAM", MSAM, OSTR, 0, "(mail send to terminal and mailbox)" },
829 { "MRSQ", MRSQ, OSTR, 0, "(mail recipient scheme question)" },
830 { "MRCP", MRCP, STR1, 0, "(mail recipient)" },
831 { "ALLO", ALLO, ARGS, 1, "allocate storage (vacuously)" },
832 { "REST", REST, ARGS, 1, "(restart command)" },
833 { "RNFR", RNFR, STR1, 1, "<sp> file-name" },
834 { "RNTO", RNTO, STR1, 1, "<sp> file-name" },
835 { "ABOR", ABOR, ARGS, 1, "(abort operation)" },
836 { "DELE", DELE, STR1, 1, "<sp> file-name" },
837 { "CWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
838 { "XCWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
839 { "LIST", LIST, OSTR, 1, "[ <sp> path-name ]" },
840 { "NLST", NLST, OSTR, 1, "[ <sp> path-name ]" },
841 { "SITE", SITE, SITECMD, 1, "site-cmd [ <sp> arguments ]" },
842 { "SYST", SYST, ARGS, 1, "(get type of operating system)" },
843 { "STAT", STAT, OSTR, 1, "[ <sp> path-name ]" },
844 { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
845 { "NOOP", NOOP, ARGS, 1, "" },
846 { "MKD", MKD, STR1, 1, "<sp> path-name" },
847 { "XMKD", MKD, STR1, 1, "<sp> path-name" },
848 { "RMD", RMD, STR1, 1, "<sp> path-name" },
849 { "XRMD", RMD, STR1, 1, "<sp> path-name" },
850 { "PWD", PWD, ARGS, 1, "(return current directory)" },
851 { "XPWD", PWD, ARGS, 1, "(return current directory)" },
852 { "CDUP", CDUP, ARGS, 1, "(change to parent directory)" },
853 { "XCUP", CDUP, ARGS, 1, "(change to parent directory)" },
854 { "STOU", STOU, STR1, 1, "<sp> file-name" },
855 { "SIZE", SIZE, OSTR, 1, "<sp> path-name" },
856 { "MDTM", MDTM, OSTR, 1, "<sp> path-name" },
857 { NULL, 0, 0, 0, 0 }
858 };
859
860 struct tab sitetab[] = {
861 { "UMASK", UMASK, ARGS, 1, "[ <sp> umask ]" },
862 { "IDLE", IDLE, ARGS, 1, "[ <sp> maximum-idle-time ]" },
863 { "CHMOD", CHMOD, NSTR, 1, "<sp> mode <sp> file-name" },
864 { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
865 { NULL, 0, 0, 0, 0 }
866 };
867
868 struct tab *lookup FUNCTION((p, cmd), register struct tab *p AND char *cmd)
869 {
870
871 for (; p->name != NULL; p++)
872 if (strcmp(cmd, p->name) == 0)
873 return (p);
874 return (0);
875 }
876
877 #include <arpa/telnet.h>
878
879 /*
880 * getline - a hacked up version of fgets to ignore TELNET escape codes.
881 */
882 char *getline FUNCTION((s, n, iop), char *s AND int n AND FILE *iop)
883 {
884 register c;
885 register char *cs;
886
887 cs = s;
888 /* tmpline may contain saved command from urgent mode interruption */
889 for (c = 0; *(tmpline + c) && --n > 0; ++c) {
890 *cs++ = *(tmpline + c);
891 if (*(tmpline + c) == '\n') {
892 *cs++ = '\0';
893 if (debug)
894 syslog(LOG_DEBUG, "command: %s", s);
895 *tmpline = '\0';
896 return(s);
897 }
898 if (c == 0)
899 *tmpline = '\0';
900 }
901 while ((c = getc(iop)) != EOF) {
902 c &= 0377;
903 if (c == IAC) {
904 if ((c = getc(iop)) != EOF) {
905 c &= 0377;
906 switch (c) {
907 case WILL:
908 case WONT:
909 c = getc(iop);
910 printf("%c%c%c", IAC, DONT, 0377&c);
911 (void) fflush(stdout);
912 continue;
913 case DO:
914 case DONT:
915 c = getc(iop);
916 printf("%c%c%c", IAC, WONT, 0377&c);
917 (void) fflush(stdout);
918 continue;
919 case IAC:
920 break;
921 default:
922 continue; /* ignore command */
923 }
924 }
925 }
926 *cs++ = c;
927 if (--n <= 0 || c == '\n')
928 break;
929 }
930 if (c == EOF && cs == s)
931 return (NULL);
932 *cs++ = '\0';
933 if (debug)
934 syslog(LOG_DEBUG, "command: %s", s);
935 return (s);
936 }
937
938 static VOIDRET toolong FUNCTION((input), int input)
939 {
940 time_t now;
941
942 reply(421, "Timeout (%d seconds): closing control connection.", timeout);
943 (void) time(&now);
944 syslog(LOG_INFO, "User %s timed out after %d seconds at %s",
945 (pw ? pw -> pw_name : "unknown"), timeout, ctime(&now));
946 dologout(1);
947 }
948
949 int yylex FUNCTION_NOARGS
950 {
951 static int cpos, state;
952 register char *cp, *cp2;
953 register struct tab *p;
954 int n;
955 char c, *copy();
956
957 for (;;) {
958 switch (state) {
959
960 case CMD:
961 (void) signal(SIGALRM, toolong);
962 (void) alarm((unsigned) timeout);
963 if (getline(cbuf, sizeof(cbuf)-1, stdin) == NULL) {
964 reply(221, "You could at least say goodbye.");
965 dologout(0);
966 }
967 (void) alarm(0);
968 #if DOTITLE
969 if (strncasecmp(cbuf, "PASS", 4) != NULL)
970 setproctitle("%s: %s", proctitle, cbuf);
971 #endif /* DOTITLE */
972 if ((cp = strchr(cbuf, '\r'))) {
973 *cp++ = '\n';
974 *cp = '\0';
975 }
976 if ((cp = strpbrk(cbuf, " \n")))
977 cpos = cp - cbuf;
978 if (cpos == 0)
979 cpos = 4;
980 c = cbuf[cpos];
981 cbuf[cpos] = '\0';
982 upper(cbuf);
983 p = lookup(cmdtab, cbuf);
984 cbuf[cpos] = c;
985 if (p != 0) {
986 if (p->implemented == 0) {
987 nack(p->name);
988 longjmp(errcatch,0);
989 /* NOTREACHED */
990 }
991 state = p->state;
992 *(char **)&yylval = p->name;
993 return (p->token);
994 }
995 break;
996
997 case SITECMD:
998 if (cbuf[cpos] == ' ') {
999 cpos++;
1000 return (SP);
1001 }
1002 cp = &cbuf[cpos];
1003 if ((cp2 = strpbrk(cp, " \n")))
1004 cpos = cp2 - cbuf;
1005 c = cbuf[cpos];
1006 cbuf[cpos] = '\0';
1007 upper(cp);
1008 p = lookup(sitetab, cp);
1009 cbuf[cpos] = c;
1010 if (p != 0) {
1011 if (p->implemented == 0) {
1012 state = CMD;
1013 nack(p->name);
1014 longjmp(errcatch,0);
1015 /* NOTREACHED */
1016 }
1017 state = p->state;
1018 *(char **)&yylval = p->name;
1019 return (p->token);
1020 }
1021 state = CMD;
1022 break;
1023
1024 case OSTR:
1025 if (cbuf[cpos] == '\n') {
1026 state = CMD;
1027 return (CRLF);
1028 }
1029 /* FALLTHROUGH */
1030
1031 case STR1:
1032 case ZSTR1:
1033 dostr1:
1034 if (cbuf[cpos] == ' ') {
1035 cpos++;
1036 state = state == OSTR ? STR2 : ++state;
1037 return (SP);
1038 }
1039 break;
1040
1041 case ZSTR2:
1042 if (cbuf[cpos] == '\n') {
1043 state = CMD;
1044 return (CRLF);
1045 }
1046 /* FALLTHROUGH */
1047
1048 case STR2:
1049 cp = &cbuf[cpos];
1050 n = strlen(cp);
1051 cpos += n - 1;
1052 /*
1053 * Make sure the string is nonempty and \n terminated.
1054 */
1055 if (n > 1 && cbuf[cpos] == '\n') {
1056 cbuf[cpos] = '\0';
1057 *(char **)&yylval = copy(cp);
1058 cbuf[cpos] = '\n';
1059 state = ARGS;
1060 return (STRING);
1061 }
1062 break;
1063
1064 case NSTR:
1065 if (cbuf[cpos] == ' ') {
1066 cpos++;
1067 return (SP);
1068 }
1069 if (isdigit(cbuf[cpos])) {
1070 cp = &cbuf[cpos];
1071 while (isdigit(cbuf[++cpos]))
1072 ;
1073 c = cbuf[cpos];
1074 cbuf[cpos] = '\0';
1075 yylval = atoi(cp);
1076 cbuf[cpos] = c;
1077 state = STR1;
1078 return (NUMBER);
1079 }
1080 state = STR1;
1081 goto dostr1;
1082
1083 case ARGS:
1084 if (isdigit(cbuf[cpos])) {
1085 cp = &cbuf[cpos];
1086 while (isdigit(cbuf[++cpos]))
1087 ;
1088 c = cbuf[cpos];
1089 cbuf[cpos] = '\0';
1090 yylval = atoi(cp);
1091 cbuf[cpos] = c;
1092 return (NUMBER);
1093 }
1094 switch (cbuf[cpos++]) {
1095
1096 case '\n':
1097 state = CMD;
1098 return (CRLF);
1099
1100 case ' ':
1101 return (SP);
1102
1103 case ',':
1104 return (COMMA);
1105
1106 case 'A':
1107 case 'a':
1108 return (A);
1109
1110 case 'B':
1111 case 'b':
1112 return (B);
1113
1114 case 'C':
1115 case 'c':
1116 return (C);
1117
1118 case 'E':
1119 case 'e':
1120 return (E);
1121
1122 case 'F':
1123 case 'f':
1124 return (F);
1125
1126 case 'I':
1127 case 'i':
1128 return (I);
1129
1130 case 'L':
1131 case 'l':
1132 return (L);
1133
1134 case 'N':
1135 case 'n':
1136 return (N);
1137
1138 case 'P':
1139 case 'p':
1140 return (P);
1141
1142 case 'R':
1143 case 'r':
1144 return (R);
1145
1146 case 'S':
1147 case 's':
1148 return (S);
1149
1150 case 'T':
1151 case 't':
1152 return (T);
1153
1154 }
1155 break;
1156
1157 default:
1158 opiefatal("Unknown state in scanner.");
1159 }
1160 yyerror((char *) 0);
1161 state = CMD;
1162 longjmp(errcatch,0);
1163 }
1164 }
1165
1166 VOIDRET upper FUNCTION((s), char *s)
1167 {
1168 while (*s != '\0') {
1169 if (islower(*s))
1170 *s = toupper(*s);
1171 s++;
1172 }
1173 }
1174
1175 char *copy FUNCTION((s), char *s)
1176 {
1177 char *p;
1178
1179 p = malloc((unsigned) strlen(s) + 1);
1180 if (p == NULL)
1181 opiefatal("Ran out of memory.");
1182 (void) strcpy(p, s);
1183 return (p);
1184 }
1185
1186 VOIDRET help FUNCTION((ctab, s), struct tab *ctab AND char *s)
1187 {
1188 register struct tab *c;
1189 register int width, NCMDS;
1190 char *type;
1191
1192 if (ctab == sitetab)
1193 type = "SITE ";
1194 else
1195 type = "";
1196 width = 0, NCMDS = 0;
1197 for (c = ctab; c->name != NULL; c++) {
1198 int len = strlen(c->name);
1199
1200 if (len > width)
1201 width = len;
1202 NCMDS++;
1203 }
1204 width = (width + 8) &~ 7;
1205 if (s == 0) {
1206 register int i, j, w;
1207 int columns, lines;
1208
1209 lreply(214, "The following %scommands are recognized %s.",
1210 type, "(* =>'s unimplemented)");
1211 columns = 76 / width;
1212 if (columns == 0)
1213 columns = 1;
1214 lines = (NCMDS + columns - 1) / columns;
1215 for (i = 0; i < lines; i++) {
1216 printf(" ");
1217 for (j = 0; j < columns; j++) {
1218 c = ctab + j * lines + i;
1219 printf("%s%c", c->name,
1220 c->implemented ? ' ' : '*');
1221 if (c + lines >= &ctab[NCMDS])
1222 break;
1223 w = strlen(c->name) + 1;
1224 while (w < width) {
1225 putchar(' ');
1226 w++;
1227 }
1228 }
1229 printf("\r\n");
1230 }
1231 (void) fflush(stdout);
1232 reply(214, " ");
1233 return;
1234 }
1235 upper(s);
1236 c = lookup(ctab, s);
1237 if (c == (struct tab *)0) {
1238 reply(502, "Unknown command %s.", s);
1239 return;
1240 }
1241 if (c->implemented)
1242 reply(214, "Syntax: %s%s %s", type, c->name, c->help);
1243 else
1244 reply(214, "%s%-*s\t%s; unimplemented.", type, width,
1245 c->name, c->help);
1246 }
1247
1248 VOIDRET sizecmd FUNCTION((filename), char *filename)
1249 {
1250 switch (type) {
1251 case TYPE_L:
1252 case TYPE_I: {
1253 struct stat stbuf;
1254 if (stat(filename, &stbuf) < 0 ||
1255 (stbuf.st_mode&S_IFMT) != S_IFREG)
1256 reply(550, "%s: not a plain file.", filename);
1257 else
1258 reply(213, "%lu", stbuf.st_size);
1259 break;}
1260 case TYPE_A: {
1261 FILE *fin;
1262 register int c;
1263 register long count;
1264 struct stat stbuf;
1265 fin = fopen(filename, "r");
1266 if (fin == NULL) {
1267 perror_reply(550, filename);
1268 return;
1269 }
1270 if (fstat(fileno(fin), &stbuf) < 0 ||
1271 (stbuf.st_mode&S_IFMT) != S_IFREG) {
1272 reply(550, "%s: not a plain file.", filename);
1273 (void) fclose(fin);
1274 return;
1275 }
1276
1277 count = 0;
1278 while((c=getc(fin)) != EOF) {
1279 if (c == '\n') /* will get expanded to \r\n */
1280 count++;
1281 count++;
1282 }
1283 (void) fclose(fin);
1284
1285 reply(213, "%ld", count);
1286 break;}
1287 default:
1288 reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
1289 }
1290 }
DragonFly BSD