?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
More doxygen.
[heimdal.git] / appl / ftp / ftpd / ftpcmd.y
blob5fb8e8e2e9c2cf8e26b30b41e482eac91042cb3c
1 /* $NetBSD: ftpcmd.y,v 1.6 1995/06/03 22:46:45 mycroft Exp $ */
2
3 /*
4 * Copyright (c) 1985, 1988, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by the University of
18 * California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 *
35 * @(#)ftpcmd.y 8.3 (Berkeley) 4/6/94
36 */
37
38 /*
39 * Grammar for FTP commands.
40 * See RFC 959.
41 */
42
43 %{
44
45 #include "ftpd_locl.h"
46 RCSID("$Id$");
47
48 off_t restart_point;
49
50 static int hasyyerrored;
51
52
53 static int cmd_type;
54 static int cmd_form;
55 static int cmd_bytesz;
56 char cbuf[64*1024];
57 char *fromname;
58
59 struct tab {
60 char *name;
61 short token;
62 short state;
63 short implemented; /* 1 if command is implemented */
64 char *help;
65 };
66
67 extern struct tab cmdtab[];
68 extern struct tab sitetab[];
69
70 static char *copy (char *);
71 static void help (struct tab *, char *);
72 static struct tab *
73 lookup (struct tab *, char *);
74 static void sizecmd (char *);
75 static RETSIGTYPE toolong (int);
76 static int yylex (void);
77
78 /* This is for bison */
79
80 #if !defined(alloca) && !defined(HAVE_ALLOCA)
81 #define alloca(x) malloc(x)
82 #endif
83
84 %}
85
86 %union {
87 int i;
88 char *s;
89 }
90
91 %token
92 A B C E F I
93 L N P R S T
94
95 SP CRLF COMMA
96
97 USER PASS ACCT REIN QUIT PORT
98 PASV TYPE STRU MODE RETR STOR
99 APPE MLFL MAIL MSND MSOM MSAM
100 MRSQ MRCP ALLO REST RNFR RNTO
101 ABOR DELE CWD LIST NLST SITE
102 sTAT HELP NOOP MKD RMD PWD
103 CDUP STOU SMNT SYST SIZE MDTM
104 EPRT EPSV
105
106 UMASK IDLE CHMOD
107
108 AUTH ADAT PROT PBSZ CCC MIC
109 CONF ENC
110
111 KAUTH KLIST KDESTROY KRBTKFILE AFSLOG
112 LOCATE URL
113
114 FEAT OPTS
115
116 LEXERR
117
118 %token <s> STRING
119 %token <i> NUMBER
120
121 %type <i> check_login check_login_no_guest check_secure octal_number byte_size
122 %type <i> struct_code mode_code type_code form_code
123 %type <s> pathstring pathname password username
124
125 %start cmd_list
126
127 %%
128
129 cmd_list
130 : /* empty */
131 | cmd_list cmd
132 {
133 fromname = (char *) 0;
134 restart_point = (off_t) 0;
135 }
136 | cmd_list rcmd
137 ;
138
139 cmd
140 : USER SP username CRLF check_secure
141 {
142 if ($5)
143 user($3);
144 free($3);
145 }
146 | PASS SP password CRLF check_secure
147 {
148 if ($5)
149 pass($3);
150 memset ($3, 0, strlen($3));
151 free($3);
152 }
153
154 | PORT SP host_port CRLF check_secure
155 {
156 if ($5) {
157 if (paranoid &&
158 (data_dest->sa_family != his_addr->sa_family ||
159 (socket_get_port(data_dest) < IPPORT_RESERVED) ||
160 memcmp(socket_get_address(data_dest),
161 socket_get_address(his_addr),
162 socket_addr_size(his_addr)) != 0)) {
163 usedefault = 1;
164 reply(500, "Illegal PORT range rejected.");
165 } else {
166 usedefault = 0;
167 if (pdata >= 0) {
168 close(pdata);
169 pdata = -1;
170 }
171 reply(200, "PORT command successful.");
172 }
173 }
174 }
175 | EPRT SP STRING CRLF check_secure
176 {
177 if ($5)
178 eprt ($3);
179 free ($3);
180 }
181 | PASV CRLF check_login
182 {
183 if($3)
184 pasv ();
185 }
186 | EPSV CRLF check_login
187 {
188 if($3)
189 epsv (NULL);
190 }
191 | EPSV SP STRING CRLF check_login
192 {
193 if($5)
194 epsv ($3);
195 free ($3);
196 }
197 | TYPE SP type_code CRLF check_secure
198 {
199 if ($5) {
200 switch (cmd_type) {
201
202 case TYPE_A:
203 if (cmd_form == FORM_N) {
204 reply(200, "Type set to A.");
205 type = cmd_type;
206 form = cmd_form;
207 } else
208 reply(504, "Form must be N.");
209 break;
210
211 case TYPE_E:
212 reply(504, "Type E not implemented.");
213 break;
214
215 case TYPE_I:
216 reply(200, "Type set to I.");
217 type = cmd_type;
218 break;
219
220 case TYPE_L:
221 #if NBBY == 8
222 if (cmd_bytesz == 8) {
223 reply(200,
224 "Type set to L (byte size 8).");
225 type = cmd_type;
226 } else
227 reply(504, "Byte size must be 8.");
228 #else /* NBBY == 8 */
229 UNIMPLEMENTED for NBBY != 8
230 #endif /* NBBY == 8 */
231 }
232 }
233 }
234 | STRU SP struct_code CRLF check_secure
235 {
236 if ($5) {
237 switch ($3) {
238
239 case STRU_F:
240 reply(200, "STRU F ok.");
241 break;
242
243 default:
244 reply(504, "Unimplemented STRU type.");
245 }
246 }
247 }
248 | MODE SP mode_code CRLF check_secure
249 {
250 if ($5) {
251 switch ($3) {
252
253 case MODE_S:
254 reply(200, "MODE S ok.");
255 break;
256
257 default:
258 reply(502, "Unimplemented MODE type.");
259 }
260 }
261 }
262 | ALLO SP NUMBER CRLF check_secure
263 {
264 if ($5) {
265 reply(202, "ALLO command ignored.");
266 }
267 }
268 | ALLO SP NUMBER SP R SP NUMBER CRLF check_secure
269 {
270 if ($9) {
271 reply(202, "ALLO command ignored.");
272 }
273 }
274 | RETR SP pathname CRLF check_login
275 {
276 char *name = $3;
277
278 if ($5 && name != NULL)
279 retrieve(0, name);
280 if (name != NULL)
281 free(name);
282 }
283 | STOR SP pathname CRLF check_login
284 {
285 char *name = $3;
286
287 if ($5 && name != NULL)
288 do_store(name, "w", 0);
289 if (name != NULL)
290 free(name);
291 }
292 | APPE SP pathname CRLF check_login
293 {
294 char *name = $3;
295
296 if ($5 && name != NULL)
297 do_store(name, "a", 0);
298 if (name != NULL)
299 free(name);
300 }
301 | NLST CRLF check_login
302 {
303 if ($3)
304 send_file_list(".");
305 }
306 | NLST SP STRING CRLF check_login
307 {
308 char *name = $3;
309
310 if ($5 && name != NULL)
311 send_file_list(name);
312 if (name != NULL)
313 free(name);
314 }
315 | LIST CRLF check_login
316 {
317 if($3)
318 list_file(".");
319 }
320 | LIST SP pathname CRLF check_login
321 {
322 if($5)
323 list_file($3);
324 free($3);
325 }
326 | sTAT SP pathname CRLF check_login
327 {
328 if ($5 && $3 != NULL)
329 statfilecmd($3);
330 if ($3 != NULL)
331 free($3);
332 }
333 | sTAT CRLF check_secure
334 {
335 if ($3)
336 statcmd();
337 }
338 | DELE SP pathname CRLF check_login_no_guest
339 {
340 if ($5 && $3 != NULL)
341 do_delete($3);
342 if ($3 != NULL)
343 free($3);
344 }
345 | RNTO SP pathname CRLF check_login_no_guest
346 {
347 if($5){
348 if (fromname) {
349 renamecmd(fromname, $3);
350 free(fromname);
351 fromname = (char *) 0;
352 } else {
353 reply(503, "Bad sequence of commands.");
354 }
355 }
356 if ($3 != NULL)
357 free($3);
358 }
359 | ABOR CRLF check_secure
360 {
361 if ($3)
362 reply(225, "ABOR command successful.");
363 }
364 | CWD CRLF check_login
365 {
366 if ($3) {
367 const char *path = pw->pw_dir;
368 if (dochroot || guest)
369 path = "/";
370 cwd(path);
371 }
372 }
373 | CWD SP pathname CRLF check_login
374 {
375 if ($5 && $3 != NULL)
376 cwd($3);
377 if ($3 != NULL)
378 free($3);
379 }
380 | HELP CRLF check_secure
381 {
382 if ($3)
383 help(cmdtab, (char *) 0);
384 }
385 | HELP SP STRING CRLF check_secure
386 {
387 if ($5) {
388 char *cp = $3;
389
390 if (strncasecmp(cp, "SITE", 4) == 0) {
391 cp = $3 + 4;
392 if (*cp == ' ')
393 cp++;
394 if (*cp)
395 help(sitetab, cp);
396 else
397 help(sitetab, (char *) 0);
398 } else
399 help(cmdtab, $3);
400 }
401 }
402 | NOOP CRLF check_secure
403 {
404 if ($3)
405 reply(200, "NOOP command successful.");
406 }
407 | MKD SP pathname CRLF check_login
408 {
409 if ($5 && $3 != NULL)
410 makedir($3);
411 if ($3 != NULL)
412 free($3);
413 }
414 | RMD SP pathname CRLF check_login_no_guest
415 {
416 if ($5 && $3 != NULL)
417 removedir($3);
418 if ($3 != NULL)
419 free($3);
420 }
421 | PWD CRLF check_login
422 {
423 if ($3)
424 pwd();
425 }
426 | CDUP CRLF check_login
427 {
428 if ($3)
429 cwd("..");
430 }
431 | FEAT CRLF check_secure
432 {
433 if ($3) {
434 lreply(211, "Supported features:");
435 lreply(0, " MDTM");
436 lreply(0, " REST STREAM");
437 lreply(0, " SIZE");
438 reply(211, "End");
439 }
440 }
441 | OPTS SP STRING CRLF check_secure
442 {
443 if ($5)
444 reply(501, "Bad options");
445 free ($3);
446 }
447
448 | SITE SP HELP CRLF check_secure
449 {
450 if ($5)
451 help(sitetab, (char *) 0);
452 }
453 | SITE SP HELP SP STRING CRLF check_secure
454 {
455 if ($7)
456 help(sitetab, $5);
457 }
458 | SITE SP UMASK CRLF check_login
459 {
460 if ($5) {
461 int oldmask = umask(0);
462 umask(oldmask);
463 reply(200, "Current UMASK is %03o", oldmask);
464 }
465 }
466 | SITE SP UMASK SP octal_number CRLF check_login_no_guest
467 {
468 if ($7) {
469 if (($5 == -1) || ($5 > 0777)) {
470 reply(501, "Bad UMASK value");
471 } else {
472 int oldmask = umask($5);
473 reply(200,
474 "UMASK set to %03o (was %03o)",
475 $5, oldmask);
476 }
477 }
478 }
479 | SITE SP CHMOD SP octal_number SP pathname CRLF check_login_no_guest
480 {
481 if ($9 && $7 != NULL) {
482 if ($5 > 0777)
483 reply(501,
484 "CHMOD: Mode value must be between 0 and 0777");
485 else if (chmod($7, $5) < 0)
486 perror_reply(550, $7);
487 else
488 reply(200, "CHMOD command successful.");
489 }
490 if ($7 != NULL)
491 free($7);
492 }
493 | SITE SP IDLE CRLF check_secure
494 {
495 if ($5)
496 reply(200,
497 "Current IDLE time limit is %d seconds; max %d",
498 ftpd_timeout, maxtimeout);
499 }
500 | SITE SP IDLE SP NUMBER CRLF check_secure
501 {
502 if ($7) {
503 if ($5 < 30 || $5 > maxtimeout) {
504 reply(501,
505 "Maximum IDLE time must be between 30 and %d seconds",
506 maxtimeout);
507 } else {
508 ftpd_timeout = $5;
509 alarm((unsigned) ftpd_timeout);
510 reply(200,
511 "Maximum IDLE time set to %d seconds",
512 ftpd_timeout);
513 }
514 }
515 }
516
517 | SITE SP KAUTH SP STRING CRLF check_login
518 {
519 reply(500, "Command not implemented.");
520 }
521 | SITE SP KLIST CRLF check_login
522 {
523 if($5)
524 klist();
525 }
526 | SITE SP KDESTROY CRLF check_login
527 {
528 reply(500, "Command not implemented.");
529 }
530 | SITE SP KRBTKFILE SP STRING CRLF check_login
531 {
532 reply(500, "Command not implemented.");
533 }
534 | SITE SP AFSLOG CRLF check_login
535 {
536 #if defined(KRB5)
537 if(guest)
538 reply(500, "Can't be done as guest.");
539 else if($5)
540 afslog(NULL, 0);
541 #else
542 reply(500, "Command not implemented.");
543 #endif
544 }
545 | SITE SP AFSLOG SP STRING CRLF check_login
546 {
547 #if defined(KRB5)
548 if(guest)
549 reply(500, "Can't be done as guest.");
550 else if($7)
551 afslog($5, 0);
552 if($5)
553 free($5);
554 #else
555 reply(500, "Command not implemented.");
556 #endif
557 }
558 | SITE SP LOCATE SP STRING CRLF check_login
559 {
560 if($7 && $5 != NULL)
561 find($5);
562 if($5 != NULL)
563 free($5);
564 }
565 | SITE SP URL CRLF check_secure
566 {
567 if ($5)
568 reply(200, "http://www.pdc.kth.se/heimdal/");
569 }
570 | STOU SP pathname CRLF check_login
571 {
572 if ($5 && $3 != NULL)
573 do_store($3, "w", 1);
574 if ($3 != NULL)
575 free($3);
576 }
577 | SYST CRLF check_secure
578 {
579 if ($3) {
580 #if !defined(WIN32) && !defined(__EMX__) && !defined(__OS2__) && !defined(__CYGWIN32__)
581 reply(215, "UNIX Type: L%d", NBBY);
582 #else
583 reply(215, "UNKNOWN Type: L%d", NBBY);
584 #endif
585 }
586 }
587
588 /*
589 * SIZE is not in RFC959, but Postel has blessed it and
590 * it will be in the updated RFC.
591 *
592 * Return size of file in a format suitable for
593 * using with RESTART (we just count bytes).
594 */
595 | SIZE SP pathname CRLF check_login
596 {
597 if ($5 && $3 != NULL)
598 sizecmd($3);
599 if ($3 != NULL)
600 free($3);
601 }
602
603 /*
604 * MDTM is not in RFC959, but Postel has blessed it and
605 * it will be in the updated RFC.
606 *
607 * Return modification time of file as an ISO 3307
608 * style time. E.g. YYYYMMDDHHMMSS or YYYYMMDDHHMMSS.xxx
609 * where xxx is the fractional second (of any precision,
610 * not necessarily 3 digits)
611 */
612 | MDTM SP pathname CRLF check_login
613 {
614 if ($5 && $3 != NULL) {
615 struct stat stbuf;
616 if (stat($3, &stbuf) < 0)
617 reply(550, "%s: %s",
618 $3, strerror(errno));
619 else if (!S_ISREG(stbuf.st_mode)) {
620 reply(550,
621 "%s: not a plain file.", $3);
622 } else {
623 struct tm *t;
624 time_t mtime = stbuf.st_mtime;
625
626 t = gmtime(&mtime);
627 reply(213,
628 "%04d%02d%02d%02d%02d%02d",
629 t->tm_year + 1900,
630 t->tm_mon + 1,
631 t->tm_mday,
632 t->tm_hour,
633 t->tm_min,
634 t->tm_sec);
635 }
636 }
637 if ($3 != NULL)
638 free($3);
639 }
640 | QUIT CRLF check_secure
641 {
642 if ($3) {
643 reply(221, "Goodbye.");
644 dologout(0);
645 }
646 }
647 | error CRLF
648 {
649 yyerrok;
650 }
651 ;
652 rcmd
653 : RNFR SP pathname CRLF check_login_no_guest
654 {
655 restart_point = (off_t) 0;
656 if ($5 && $3) {
657 fromname = renamefrom($3);
658 if (fromname == (char *) 0 && $3) {
659 free($3);
660 }
661 }
662 }
663 | REST SP byte_size CRLF check_secure
664 {
665 if ($5) {
666 fromname = (char *) 0;
667 restart_point = $3; /* XXX $3 is only "int" */
668 reply(350, "Restarting at %ld. %s",
669 (long)restart_point,
670 "Send STORE or RETRIEVE to initiate transfer.");
671 }
672 }
673 | AUTH SP STRING CRLF
674 {
675 auth($3);
676 free($3);
677 }
678 | ADAT SP STRING CRLF
679 {
680 adat($3);
681 free($3);
682 }
683 | PBSZ SP NUMBER CRLF check_secure
684 {
685 if ($5)
686 pbsz($3);
687 }
688 | PROT SP STRING CRLF check_secure
689 {
690 if ($5)
691 prot($3);
692 }
693 | CCC CRLF check_secure
694 {
695 if ($3)
696 ccc();
697 }
698 | MIC SP STRING CRLF
699 {
700 mec($3, prot_safe);
701 free($3);
702 }
703 | CONF SP STRING CRLF
704 {
705 mec($3, prot_confidential);
706 free($3);
707 }
708 | ENC SP STRING CRLF
709 {
710 mec($3, prot_private);
711 free($3);
712 }
713 ;
714
715 username
716 : STRING
717 ;
718
719 password
720 : /* empty */
721 {
722 $$ = (char *)calloc(1, sizeof(char));
723 }
724 | STRING
725 ;
726
727 byte_size
728 : NUMBER
729 ;
730
731 host_port
732 : NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA
733 NUMBER COMMA NUMBER
734 {
735 struct sockaddr_in *sin4 = (struct sockaddr_in *)data_dest;
736
737 sin4->sin_family = AF_INET;
738 sin4->sin_port = htons($9 * 256 + $11);
739 sin4->sin_addr.s_addr =
740 htonl(($1 << 24) | ($3 << 16) | ($5 << 8) | $7);
741 }
742 ;
743
744 form_code
745 : N
746 {
747 $$ = FORM_N;
748 }
749 | T
750 {
751 $$ = FORM_T;
752 }
753 | C
754 {
755 $$ = FORM_C;
756 }
757 ;
758
759 type_code
760 : A
761 {
762 cmd_type = TYPE_A;
763 cmd_form = FORM_N;
764 }
765 | A SP form_code
766 {
767 cmd_type = TYPE_A;
768 cmd_form = $3;
769 }
770 | E
771 {
772 cmd_type = TYPE_E;
773 cmd_form = FORM_N;
774 }
775 | E SP form_code
776 {
777 cmd_type = TYPE_E;
778 cmd_form = $3;
779 }
780 | I
781 {
782 cmd_type = TYPE_I;
783 }
784 | L
785 {
786 cmd_type = TYPE_L;
787 cmd_bytesz = NBBY;
788 }
789 | L SP byte_size
790 {
791 cmd_type = TYPE_L;
792 cmd_bytesz = $3;
793 }
794 /* this is for a bug in the BBN ftp */
795 | L byte_size
796 {
797 cmd_type = TYPE_L;
798 cmd_bytesz = $2;
799 }
800 ;
801
802 struct_code
803 : F
804 {
805 $$ = STRU_F;
806 }
807 | R
808 {
809 $$ = STRU_R;
810 }
811 | P
812 {
813 $$ = STRU_P;
814 }
815 ;
816
817 mode_code
818 : S
819 {
820 $$ = MODE_S;
821 }
822 | B
823 {
824 $$ = MODE_B;
825 }
826 | C
827 {
828 $$ = MODE_C;
829 }
830 ;
831
832 pathname
833 : pathstring
834 {
835 /*
836 * Problem: this production is used for all pathname
837 * processing, but only gives a 550 error reply.
838 * This is a valid reply in some cases but not in others.
839 */
840 if (logged_in && $1 && *$1 == '~') {
841 glob_t gl;
842 int flags =
843 GLOB_BRACE|GLOB_NOCHECK|GLOB_QUOTE|GLOB_TILDE;
844
845 memset(&gl, 0, sizeof(gl));
846 if (glob($1, flags, NULL, &gl) ||
847 gl.gl_pathc == 0) {
848 reply(550, "not found");
849 $$ = NULL;
850 } else {
851 $$ = strdup(gl.gl_pathv[0]);
852 }
853 globfree(&gl);
854 free($1);
855 } else
856 $$ = $1;
857 }
858 ;
859
860 pathstring
861 : STRING
862 ;
863
864 octal_number
865 : NUMBER
866 {
867 int ret, dec, multby, digit;
868
869 /*
870 * Convert a number that was read as decimal number
871 * to what it would be if it had been read as octal.
872 */
873 dec = $1;
874 multby = 1;
875 ret = 0;
876 while (dec) {
877 digit = dec%10;
878 if (digit > 7) {
879 ret = -1;
880 break;
881 }
882 ret += digit * multby;
883 multby *= 8;
884 dec /= 10;
885 }
886 $$ = ret;
887 }
888 ;
889
890
891 check_login_no_guest : check_login
892 {
893 $$ = $1 && !guest;
894 if($1 && !$$)
895 reply(550, "Permission denied");
896 }
897 ;
898
899 check_login : check_secure
900 {
901 if($1) {
902 if(($$ = logged_in) == 0)
903 reply(530, "Please login with USER and PASS.");
904 } else
905 $$ = 0;
906 }
907 ;
908
909 check_secure : /* empty */
910 {
911 $$ = 1;
912 if(sec_complete && !ccc_passed && !secure_command()) {
913 $$ = 0;
914 reply(533, "Command protection level denied "
915 "for paranoid reasons.");
916 }
917 }
918 ;
919
920 %%
921
922 #define CMD 0 /* beginning of command */
923 #define ARGS 1 /* expect miscellaneous arguments */
924 #define STR1 2 /* expect SP followed by STRING */
925 #define STR2 3 /* expect STRING */
926 #define OSTR 4 /* optional SP then STRING */
927 #define ZSTR1 5 /* SP then optional STRING */
928 #define ZSTR2 6 /* optional STRING after SP */
929 #define SITECMD 7 /* SITE command */
930 #define NSTR 8 /* Number followed by a string */
931
932 struct tab cmdtab[] = { /* In order defined in RFC 765 */
933 { "USER", USER, STR1, 1, "<sp> username" },
934 { "PASS", PASS, ZSTR1, 1, "<sp> password" },
935 { "ACCT", ACCT, STR1, 0, "(specify account)" },
936 { "SMNT", SMNT, ARGS, 0, "(structure mount)" },
937 { "REIN", REIN, ARGS, 0, "(reinitialize server state)" },
938 { "QUIT", QUIT, ARGS, 1, "(terminate service)", },
939 { "PORT", PORT, ARGS, 1, "<sp> b0, b1, b2, b3, b4" },
940 { "EPRT", EPRT, STR1, 1, "<sp> string" },
941 { "PASV", PASV, ARGS, 1, "(set server in passive mode)" },
942 { "EPSV", EPSV, OSTR, 1, "[<sp> foo]" },
943 { "TYPE", TYPE, ARGS, 1, "<sp> [ A | E | I | L ]" },
944 { "STRU", STRU, ARGS, 1, "(specify file structure)" },
945 { "MODE", MODE, ARGS, 1, "(specify transfer mode)" },
946 { "RETR", RETR, STR1, 1, "<sp> file-name" },
947 { "STOR", STOR, STR1, 1, "<sp> file-name" },
948 { "APPE", APPE, STR1, 1, "<sp> file-name" },
949 { "MLFL", MLFL, OSTR, 0, "(mail file)" },
950 { "MAIL", MAIL, OSTR, 0, "(mail to user)" },
951 { "MSND", MSND, OSTR, 0, "(mail send to terminal)" },
952 { "MSOM", MSOM, OSTR, 0, "(mail send to terminal or mailbox)" },
953 { "MSAM", MSAM, OSTR, 0, "(mail send to terminal and mailbox)" },
954 { "MRSQ", MRSQ, OSTR, 0, "(mail recipient scheme question)" },
955 { "MRCP", MRCP, STR1, 0, "(mail recipient)" },
956 { "ALLO", ALLO, ARGS, 1, "allocate storage (vacuously)" },
957 { "REST", REST, ARGS, 1, "<sp> offset (restart command)" },
958 { "RNFR", RNFR, STR1, 1, "<sp> file-name" },
959 { "RNTO", RNTO, STR1, 1, "<sp> file-name" },
960 { "ABOR", ABOR, ARGS, 1, "(abort operation)" },
961 { "DELE", DELE, STR1, 1, "<sp> file-name" },
962 { "CWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
963 { "XCWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
964 { "LIST", LIST, OSTR, 1, "[ <sp> path-name ]" },
965 { "NLST", NLST, OSTR, 1, "[ <sp> path-name ]" },
966 { "SITE", SITE, SITECMD, 1, "site-cmd [ <sp> arguments ]" },
967 { "SYST", SYST, ARGS, 1, "(get type of operating system)" },
968 { "STAT", sTAT, OSTR, 1, "[ <sp> path-name ]" },
969 { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
970 { "NOOP", NOOP, ARGS, 1, "" },
971 { "MKD", MKD, STR1, 1, "<sp> path-name" },
972 { "XMKD", MKD, STR1, 1, "<sp> path-name" },
973 { "RMD", RMD, STR1, 1, "<sp> path-name" },
974 { "XRMD", RMD, STR1, 1, "<sp> path-name" },
975 { "PWD", PWD, ARGS, 1, "(return current directory)" },
976 { "XPWD", PWD, ARGS, 1, "(return current directory)" },
977 { "CDUP", CDUP, ARGS, 1, "(change to parent directory)" },
978 { "XCUP", CDUP, ARGS, 1, "(change to parent directory)" },
979 { "STOU", STOU, STR1, 1, "<sp> file-name" },
980 { "SIZE", SIZE, OSTR, 1, "<sp> path-name" },
981 { "MDTM", MDTM, OSTR, 1, "<sp> path-name" },
982
983 /* extensions from RFC2228 */
984 { "AUTH", AUTH, STR1, 1, "<sp> auth-type" },
985 { "ADAT", ADAT, STR1, 1, "<sp> auth-data" },
986 { "PBSZ", PBSZ, ARGS, 1, "<sp> buffer-size" },
987 { "PROT", PROT, STR1, 1, "<sp> prot-level" },
988 { "CCC", CCC, ARGS, 1, "" },
989 { "MIC", MIC, STR1, 1, "<sp> integrity command" },
990 { "CONF", CONF, STR1, 1, "<sp> confidentiality command" },
991 { "ENC", ENC, STR1, 1, "<sp> privacy command" },
992
993 /* RFC2389 */
994 { "FEAT", FEAT, ARGS, 1, "" },
995 { "OPTS", OPTS, ARGS, 1, "<sp> command [<sp> options]" },
996
997 { NULL, 0, 0, 0, 0 }
998 };
999
1000 struct tab sitetab[] = {
1001 { "UMASK", UMASK, ARGS, 1, "[ <sp> umask ]" },
1002 { "IDLE", IDLE, ARGS, 1, "[ <sp> maximum-idle-time ]" },
1003 { "CHMOD", CHMOD, NSTR, 1, "<sp> mode <sp> file-name" },
1004 { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
1005
1006 { "KAUTH", KAUTH, STR1, 1, "<sp> principal [ <sp> ticket ]" },
1007 { "KLIST", KLIST, ARGS, 1, "(show ticket file)" },
1008 { "KDESTROY", KDESTROY, ARGS, 1, "(destroy tickets)" },
1009 { "KRBTKFILE", KRBTKFILE, STR1, 1, "<sp> ticket-file" },
1010 { "AFSLOG", AFSLOG, OSTR, 1, "[<sp> cell]" },
1011
1012 { "LOCATE", LOCATE, STR1, 1, "<sp> globexpr" },
1013 { "FIND", LOCATE, STR1, 1, "<sp> globexpr" },
1014
1015 { "URL", URL, ARGS, 1, "?" },
1016
1017 { NULL, 0, 0, 0, 0 }
1018 };
1019
1020 static struct tab *
1021 lookup(struct tab *p, char *cmd)
1022 {
1023
1024 for (; p->name != NULL; p++)
1025 if (strcmp(cmd, p->name) == 0)
1026 return (p);
1027 return (0);
1028 }
1029
1030 /*
1031 * ftpd_getline - a hacked up version of fgets to ignore TELNET escape codes.
1032 */
1033 char *
1034 ftpd_getline(char *s, int n)
1035 {
1036 int c;
1037 char *cs;
1038
1039 cs = s;
1040
1041 /* might still be data within the security MIC/CONF/ENC */
1042 if(ftp_command){
1043 strlcpy(s, ftp_command, n);
1044 if (debug)
1045 syslog(LOG_DEBUG, "command: %s", s);
1046 return s;
1047 }
1048 while ((c = getc(stdin)) != EOF) {
1049 c &= 0377;
1050 if (c == IAC) {
1051 if ((c = getc(stdin)) != EOF) {
1052 c &= 0377;
1053 switch (c) {
1054 case WILL:
1055 case WONT:
1056 c = getc(stdin);
1057 printf("%c%c%c", IAC, DONT, 0377&c);
1058 fflush(stdout);
1059 continue;
1060 case DO:
1061 case DONT:
1062 c = getc(stdin);
1063 printf("%c%c%c", IAC, WONT, 0377&c);
1064 fflush(stdout);
1065 continue;
1066 case IAC:
1067 break;
1068 default:
1069 continue; /* ignore command */
1070 }
1071 }
1072 }
1073 *cs++ = c;
1074 if (--n <= 0 || c == '\n')
1075 break;
1076 }
1077 if (c == EOF && cs == s)
1078 return (NULL);
1079 *cs++ = '\0';
1080 if (debug) {
1081 if (!guest && strncasecmp("pass ", s, 5) == 0) {
1082 /* Don't syslog passwords */
1083 syslog(LOG_DEBUG, "command: %.5s ???", s);
1084 } else {
1085 char *cp;
1086 int len;
1087
1088 /* Don't syslog trailing CR-LF */
1089 len = strlen(s);
1090 cp = s + len - 1;
1091 while (cp >= s && (*cp == '\n' || *cp == '\r')) {
1092 --cp;
1093 --len;
1094 }
1095 syslog(LOG_DEBUG, "command: %.*s", len, s);
1096 }
1097 }
1098 #ifdef XXX
1099 fprintf(stderr, "%s\n", s);
1100 #endif
1101 return (s);
1102 }
1103
1104 static RETSIGTYPE
1105 toolong(int signo)
1106 {
1107
1108 reply(421,
1109 "Timeout (%d seconds): closing control connection.",
1110 ftpd_timeout);
1111 if (logging)
1112 syslog(LOG_INFO, "User %s timed out after %d seconds",
1113 (pw ? pw -> pw_name : "unknown"), ftpd_timeout);
1114 dologout(1);
1115 SIGRETURN(0);
1116 }
1117
1118 static int
1119 yylex(void)
1120 {
1121 static int cpos, state;
1122 char *cp, *cp2;
1123 struct tab *p;
1124 int n;
1125 char c;
1126
1127 for (;;) {
1128 switch (state) {
1129
1130 case CMD:
1131 hasyyerrored = 0;
1132
1133 signal(SIGALRM, toolong);
1134 alarm((unsigned) ftpd_timeout);
1135 if (ftpd_getline(cbuf, sizeof(cbuf)-1) == NULL) {
1136 reply(221, "You could at least say goodbye.");
1137 dologout(0);
1138 }
1139 alarm(0);
1140 #ifdef HAVE_SETPROCTITLE
1141 if (strncasecmp(cbuf, "PASS", 4) != 0)
1142 setproctitle("%s: %s", proctitle, cbuf);
1143 #endif /* HAVE_SETPROCTITLE */
1144 if ((cp = strchr(cbuf, '\r'))) {
1145 *cp++ = '\n';
1146 *cp = '\0';
1147 }
1148 if ((cp = strpbrk(cbuf, " \n")))
1149 cpos = cp - cbuf;
1150 if (cpos == 0)
1151 cpos = 4;
1152 c = cbuf[cpos];
1153 cbuf[cpos] = '\0';
1154 strupr(cbuf);
1155 p = lookup(cmdtab, cbuf);
1156 cbuf[cpos] = c;
1157 if (p != 0) {
1158 if (p->implemented == 0) {
1159 nack(p->name);
1160 hasyyerrored = 1;
1161 break;
1162 }
1163 state = p->state;
1164 yylval.s = p->name;
1165 return (p->token);
1166 }
1167 break;
1168
1169 case SITECMD:
1170 if (cbuf[cpos] == ' ') {
1171 cpos++;
1172 return (SP);
1173 }
1174 cp = &cbuf[cpos];
1175 if ((cp2 = strpbrk(cp, " \n")))
1176 cpos = cp2 - cbuf;
1177 c = cbuf[cpos];
1178 cbuf[cpos] = '\0';
1179 strupr(cp);
1180 p = lookup(sitetab, cp);
1181 cbuf[cpos] = c;
1182 if (p != 0) {
1183 if (p->implemented == 0) {
1184 state = CMD;
1185 nack(p->name);
1186 hasyyerrored = 1;
1187 break;
1188 }
1189 state = p->state;
1190 yylval.s = p->name;
1191 return (p->token);
1192 }
1193 state = CMD;
1194 break;
1195
1196 case OSTR:
1197 if (cbuf[cpos] == '\n') {
1198 state = CMD;
1199 return (CRLF);
1200 }
1201 /* FALLTHROUGH */
1202
1203 case STR1:
1204 case ZSTR1:
1205 dostr1:
1206 if (cbuf[cpos] == ' ') {
1207 cpos++;
1208 if(state == OSTR)
1209 state = STR2;
1210 else
1211 state++;
1212 return (SP);
1213 }
1214 break;
1215
1216 case ZSTR2:
1217 if (cbuf[cpos] == '\n') {
1218 state = CMD;
1219 return (CRLF);
1220 }
1221 /* FALLTHROUGH */
1222
1223 case STR2:
1224 cp = &cbuf[cpos];
1225 n = strlen(cp);
1226 cpos += n - 1;
1227 /*
1228 * Make sure the string is nonempty and \n terminated.
1229 */
1230 if (n > 1 && cbuf[cpos] == '\n') {
1231 cbuf[cpos] = '\0';
1232 yylval.s = copy(cp);
1233 cbuf[cpos] = '\n';
1234 state = ARGS;
1235 return (STRING);
1236 }
1237 break;
1238
1239 case NSTR:
1240 if (cbuf[cpos] == ' ') {
1241 cpos++;
1242 return (SP);
1243 }
1244 if (isdigit((unsigned char)cbuf[cpos])) {
1245 cp = &cbuf[cpos];
1246 while (isdigit((unsigned char)cbuf[++cpos]))
1247 ;
1248 c = cbuf[cpos];
1249 cbuf[cpos] = '\0';
1250 yylval.i = atoi(cp);
1251 cbuf[cpos] = c;
1252 state = STR1;
1253 return (NUMBER);
1254 }
1255 state = STR1;
1256 goto dostr1;
1257
1258 case ARGS:
1259 if (isdigit((unsigned char)cbuf[cpos])) {
1260 cp = &cbuf[cpos];
1261 while (isdigit((unsigned char)cbuf[++cpos]))
1262 ;
1263 c = cbuf[cpos];
1264 cbuf[cpos] = '\0';
1265 yylval.i = atoi(cp);
1266 cbuf[cpos] = c;
1267 return (NUMBER);
1268 }
1269 switch (cbuf[cpos++]) {
1270
1271 case '\n':
1272 state = CMD;
1273 return (CRLF);
1274
1275 case ' ':
1276 return (SP);
1277
1278 case ',':
1279 return (COMMA);
1280
1281 case 'A':
1282 case 'a':
1283 return (A);
1284
1285 case 'B':
1286 case 'b':
1287 return (B);
1288
1289 case 'C':
1290 case 'c':
1291 return (C);
1292
1293 case 'E':
1294 case 'e':
1295 return (E);
1296
1297 case 'F':
1298 case 'f':
1299 return (F);
1300
1301 case 'I':
1302 case 'i':
1303 return (I);
1304
1305 case 'L':
1306 case 'l':
1307 return (L);
1308
1309 case 'N':
1310 case 'n':
1311 return (N);
1312
1313 case 'P':
1314 case 'p':
1315 return (P);
1316
1317 case 'R':
1318 case 'r':
1319 return (R);
1320
1321 case 'S':
1322 case 's':
1323 return (S);
1324
1325 case 'T':
1326 case 't':
1327 return (T);
1328
1329 }
1330 break;
1331
1332 default:
1333 fatal("Unknown state in scanner.");
1334 }
1335 yyerror(NULL);
1336 state = CMD;
1337 return (0);
1338 }
1339 }
1340
1341 /* ARGSUSED */
1342 void
1343 yyerror(char *s)
1344 {
1345 char *cp;
1346
1347 if (hasyyerrored)
1348 return;
1349
1350 if ((cp = strchr(cbuf,'\n')))
1351 *cp = '\0';
1352 reply(500, "'%s': command not understood.", cbuf);
1353 hasyyerrored = 1;
1354 }
1355
1356 static char *
1357 copy(char *s)
1358 {
1359 char *p;
1360
1361 p = strdup(s);
1362 if (p == NULL)
1363 fatal("Ran out of memory.");
1364 return p;
1365 }
1366
1367 static void
1368 help(struct tab *ctab, char *s)
1369 {
1370 struct tab *c;
1371 int width, NCMDS;
1372 char *t;
1373 char buf[1024];
1374
1375 if (ctab == sitetab)
1376 t = "SITE ";
1377 else
1378 t = "";
1379 width = 0, NCMDS = 0;
1380 for (c = ctab; c->name != NULL; c++) {
1381 int len = strlen(c->name);
1382
1383 if (len > width)
1384 width = len;
1385 NCMDS++;
1386 }
1387 width = (width + 8) &~ 7;
1388 if (s == 0) {
1389 int i, j, w;
1390 int columns, lines;
1391
1392 lreply(214, "The following %scommands are recognized %s.",
1393 t, "(* =>'s unimplemented)");
1394 columns = 76 / width;
1395 if (columns == 0)
1396 columns = 1;
1397 lines = (NCMDS + columns - 1) / columns;
1398 for (i = 0; i < lines; i++) {
1399 strlcpy (buf, " ", sizeof(buf));
1400 for (j = 0; j < columns; j++) {
1401 c = ctab + j * lines + i;
1402 snprintf (buf + strlen(buf),
1403 sizeof(buf) - strlen(buf),
1404 "%s%c",
1405 c->name,
1406 c->implemented ? ' ' : '*');
1407 if (c + lines >= &ctab[NCMDS])
1408 break;
1409 w = strlen(c->name) + 1;
1410 while (w < width) {
1411 strlcat (buf,
1412 " ",
1413 sizeof(buf));
1414 w++;
1415 }
1416 }
1417 lreply(214, "%s", buf);
1418 }
1419 reply(214, "Direct comments to kth-krb-bugs@pdc.kth.se");
1420 return;
1421 }
1422 strupr(s);
1423 c = lookup(ctab, s);
1424 if (c == (struct tab *)0) {
1425 reply(502, "Unknown command %s.", s);
1426 return;
1427 }
1428 if (c->implemented)
1429 reply(214, "Syntax: %s%s %s", t, c->name, c->help);
1430 else
1431 reply(214, "%s%-*s\t%s; unimplemented.", t, width,
1432 c->name, c->help);
1433 }
1434
1435 static void
1436 sizecmd(char *filename)
1437 {
1438 switch (type) {
1439 case TYPE_L:
1440 case TYPE_I: {
1441 struct stat stbuf;
1442 if (stat(filename, &stbuf) < 0 || !S_ISREG(stbuf.st_mode))
1443 reply(550, "%s: not a plain file.", filename);
1444 else
1445 reply(213, "%lu", (unsigned long)stbuf.st_size);
1446 break;
1447 }
1448 case TYPE_A: {
1449 FILE *fin;
1450 int c;
1451 size_t count;
1452 struct stat stbuf;
1453 fin = fopen(filename, "r");
1454 if (fin == NULL) {
1455 perror_reply(550, filename);
1456 return;
1457 }
1458 if (fstat(fileno(fin), &stbuf) < 0 || !S_ISREG(stbuf.st_mode)) {
1459 reply(550, "%s: not a plain file.", filename);
1460 fclose(fin);
1461 return;
1462 }
1463
1464 count = 0;
1465 while((c=getc(fin)) != EOF) {
1466 if (c == '\n') /* will get expanded to \r\n */
1467 count++;
1468 count++;
1469 }
1470 fclose(fin);
1471
1472 reply(213, "%lu", (unsigned long)count);
1473 break;
1474 }
1475 default:
1476 reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
1477 }
1478 }
Heimdal