![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ftp.tab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / yacc / test|
Return to ftp.tab.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / yacc / test |
1.1 root 1: #ifndef lint
2: char yysccsid[] = "@(#)yaccpar 1.3 (Berkeley) 01/21/90";
3: #endif
4: #define A 257
5: #define B 258
6: #define C 259
7: #define E 260
8: #define F 261
9: #define I 262
10: #define L 263
11: #define N 264
12: #define P 265
13: #define R 266
14: #define S 267
15: #define T 268
16: #define SP 269
17: #define CRLF 270
18: #define COMMA 271
19: #define STRING 272
20: #define NUMBER 273
21: #define USER 274
22: #define PASS 275
23: #define ACCT 276
24: #define REIN 277
25: #define QUIT 278
26: #define PORT 279
27: #define PASV 280
28: #define TYPE 281
29: #define STRU 282
30: #define MODE 283
31: #define RETR 284
32: #define STOR 285
33: #define APPE 286
34: #define MLFL 287
35: #define MAIL 288
36: #define MSND 289
37: #define MSOM 290
38: #define MSAM 291
39: #define MRSQ 292
40: #define MRCP 293
41: #define ALLO 294
42: #define REST 295
43: #define RNFR 296
44: #define RNTO 297
45: #define ABOR 298
46: #define DELE 299
47: #define CWD 300
48: #define LIST 301
49: #define NLST 302
50: #define SITE 303
51: #define STAT 304
52: #define HELP 305
53: #define NOOP 306
54: #define MKD 307
55: #define RMD 308
56: #define PWD 309
57: #define CDUP 310
58: #define STOU 311
59: #define SMNT 312
60: #define SYST 313
61: #define SIZE 314
62: #define MDTM 315
63: #define UMASK 316
64: #define IDLE 317
65: #define CHMOD 318
66: #define LEXERR 319
67: #define YYERRCODE 256
68: #line 26 "ftp.y"
69:
70: #ifndef lint
71: static char sccsid[] = "@(#)ftpcmd.y 5.20.1.1 (Berkeley) 3/2/89";
72: #endif /* not lint */
73:
74: #include <sys//param.h>
75: #include <sys//socket.h>
76:
77: #include <netinet//in.h>
78:
79: #include <arpa//ftp.h>
80:
81: #include <stdio.h>
82: #include <signal.h>
83: #include <ctype.h>
84: #include <pwd.h>
85: #include <setjmp.h>
86: #include <syslog.h>
87: #include <sys//stat.h>
88: #include <time.h>
89:
90: extern struct sockaddr_in data_dest;
91: extern int logged_in;
92: extern struct passwd *pw;
93: extern int guest;
94: extern int logging;
95: extern int type;
96: extern int form;
97: extern int debug;
98: extern int timeout;
99: extern int maxtimeout;
100: extern int pdata;
101: extern char hostname[], remotehost[];
102: extern char proctitle[];
103: extern char *globerr;
104: extern int usedefault;
105: extern int transflag;
106: extern char tmpline[];
107: char **glob();
108:
109: static int cmd_type;
110: static int cmd_form;
111: static int cmd_bytesz;
112: char cbuf[512];
113: char *fromname;
114:
115: char *index();
116: #line 116 "ftp.tab.c"
117: short yylhs[] = { -1,
118: 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
119: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
120: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
121: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
122: 1, 1, 1, 1, 1, 1, 2, 3, 4, 4,
123: 12, 5, 13, 13, 13, 6, 6, 6, 6, 6,
124: 6, 6, 6, 7, 7, 7, 8, 8, 8, 10,
125: 14, 11, 9,
126: };
127: short yylen[] = { 2,
128: 0, 2, 2, 4, 4, 4, 2, 4, 4, 4,
129: 4, 8, 5, 5, 5, 3, 5, 3, 5, 5,
130: 2, 5, 4, 2, 3, 5, 2, 4, 2, 5,
131: 5, 3, 3, 4, 6, 5, 7, 9, 4, 6,
132: 5, 2, 5, 5, 2, 2, 5, 1, 0, 1,
133: 1, 11, 1, 1, 1, 1, 3, 1, 3, 1,
134: 1, 3, 2, 1, 1, 1, 1, 1, 1, 1,
135: 1, 1, 0,
136: };
137: short yydefred[] = { 1,
138: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
139: 73, 73, 73, 0, 73, 0, 0, 73, 73, 73,
140: 73, 0, 0, 0, 0, 73, 73, 73, 73, 73,
141: 0, 73, 73, 2, 3, 46, 0, 0, 45, 0,
142: 7, 0, 0, 0, 0, 0, 0, 0, 0, 0,
143: 24, 0, 0, 0, 0, 0, 21, 0, 0, 27,
144: 29, 0, 0, 0, 0, 0, 42, 0, 0, 48,
145: 0, 50, 0, 0, 0, 0, 0, 60, 0, 0,
146: 64, 66, 65, 0, 68, 69, 67, 0, 0, 0,
147: 0, 0, 0, 71, 0, 70, 0, 0, 25, 0,
148: 18, 0, 16, 0, 73, 0, 73, 0, 0, 0,
149: 0, 32, 33, 0, 0, 0, 4, 5, 0, 6,
150: 0, 0, 0, 51, 63, 8, 9, 10, 0, 0,
151: 0, 0, 11, 0, 23, 0, 0, 0, 0, 0,
152: 34, 0, 0, 39, 0, 0, 28, 0, 0, 0,
153: 0, 0, 0, 55, 53, 54, 57, 59, 62, 13,
154: 14, 15, 0, 47, 22, 26, 19, 17, 0, 0,
155: 36, 0, 0, 20, 30, 31, 41, 43, 44, 0,
156: 0, 35, 72, 0, 40, 0, 0, 0, 37, 0,
157: 0, 12, 0, 0, 38, 0, 0, 0, 52,
158: };
159: short yydgoto[] = { 1,
160: 34, 35, 71, 73, 75, 80, 84, 88, 45, 95,
161: 184, 125, 157, 96,
162: };
163: short yysindex[] = { 0,
164: -224, -247, -239, -236, -232, -222, -204, -200, -181, -177,
165: 0, 0, 0, -166, 0, -161, -199, 0, 0, 0,
166: 0, -160, -159, -264, -158, 0, 0, 0, 0, 0,
167: -157, 0, 0, 0, 0, 0, -167, -162, 0, -156,
168: 0, -250, -198, -165, -155, -154, -153, -151, -150, -152,
169: 0, -145, -252, -229, -217, -302, 0, -144, -146, 0,
170: 0, -142, -141, -140, -139, -137, 0, -136, -135, 0,
171: -134, 0, -133, -132, -130, -131, -128, 0, -249, -127,
172: 0, 0, 0, -126, 0, 0, 0, -125, -152, -152,
173: -152, -205, -152, 0, -124, 0, -152, -152, 0, -152,
174: 0, -143, 0, -173, 0, -171, 0, -152, -123, -152,
175: -152, 0, 0, -152, -152, -152, 0, 0, -138, 0,
176: -164, -164, -122, 0, 0, 0, 0, 0, -121, -120,
177: -118, -148, 0, -117, 0, -116, -115, -114, -113, -112,
178: 0, -163, -111, 0, -110, -109, 0, -107, -106, -105,
179: -104, -103, -129, 0, 0, 0, 0, 0, 0, 0,
180: 0, 0, -101, 0, 0, 0, 0, 0, -100, -102,
181: 0, -98, -102, 0, 0, 0, 0, 0, 0, -99,
182: -97, 0, 0, -95, 0, -96, -94, -92, 0, -152,
183: -93, 0, -91, -90, 0, -88, -87, -86, 0,
184: };
185: short yyrindex[] = { 0,
186: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
187: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
188: 0, 0, -83, 0, 0, 0, 0, 0, 0, 0,
189: 0, 0, 0, 0, 0, 0, 0, -82, 0, 0,
190: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
191: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
192: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
193: 0, 0, 0, 0, 0, -81, -80, 0, -158, 0,
194: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
195: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
196: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
197: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
198: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
199: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
200: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
201: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
202: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
203: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
204: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
205: 0, 0, 0, 0, 0, 0, 0, 0, 0,
206: };
207: short yygindex[] = { 0,
208: 0, 0, 0, 0, 0, 0, 0, 0, 16, -89,
209: -25, 35, 47, 0,
210: };
211: #define YYTABLESIZE 190
212: short yytable[] = { 129,
213: 130, 131, 104, 134, 59, 60, 76, 136, 137, 77,
214: 138, 78, 79, 105, 106, 107, 98, 99, 146, 123,
215: 148, 149, 36, 124, 150, 151, 152, 46, 47, 37,
216: 49, 2, 38, 52, 53, 54, 55, 39, 58, 100,
217: 101, 62, 63, 64, 65, 66, 40, 68, 69, 3,
218: 4, 102, 103, 5, 6, 7, 8, 9, 10, 11,
219: 12, 13, 81, 132, 133, 41, 82, 83, 42, 14,
220: 51, 15, 16, 17, 18, 19, 20, 21, 22, 23,
221: 24, 25, 26, 27, 28, 29, 30, 43, 31, 32,
222: 33, 44, 85, 86, 154, 140, 141, 143, 144, 155,
223: 193, 87, 48, 156, 70, 170, 171, 50, 56, 72,
224: 57, 61, 67, 89, 90, 91, 74, 163, 93, 94,
225: 142, 92, 145, 97, 108, 109, 110, 111, 139, 112,
226: 113, 114, 115, 116, 153, 117, 118, 121, 119, 120,
227: 122, 180, 126, 127, 128, 135, 147, 186, 160, 161,
228: 124, 162, 164, 165, 166, 167, 168, 159, 173, 169,
229: 174, 172, 175, 176, 177, 178, 179, 181, 158, 182,
230: 183, 185, 190, 187, 189, 188, 191, 192, 195, 194,
231: 196, 0, 0, 198, 197, 73, 199, 49, 56, 58,
232: };
233: short yycheck[] = { 89,
234: 90, 91, 305, 93, 269, 270, 257, 97, 98, 260,
235: 100, 262, 263, 316, 317, 318, 269, 270, 108, 269,
236: 110, 111, 270, 273, 114, 115, 116, 12, 13, 269,
237: 15, 256, 269, 18, 19, 20, 21, 270, 23, 269,
238: 270, 26, 27, 28, 29, 30, 269, 32, 33, 274,
239: 275, 269, 270, 278, 279, 280, 281, 282, 283, 284,
240: 285, 286, 261, 269, 270, 270, 265, 266, 269, 294,
241: 270, 296, 297, 298, 299, 300, 301, 302, 303, 304,
242: 305, 306, 307, 308, 309, 310, 311, 269, 313, 314,
243: 315, 269, 258, 259, 259, 269, 270, 269, 270, 264,
244: 190, 267, 269, 268, 272, 269, 270, 269, 269, 272,
245: 270, 270, 270, 269, 269, 269, 273, 266, 269, 272,
246: 105, 273, 107, 269, 269, 272, 269, 269, 272, 270,
247: 270, 269, 269, 269, 273, 270, 270, 269, 271, 270,
248: 269, 271, 270, 270, 270, 270, 270, 173, 270, 270,
249: 273, 270, 270, 270, 270, 270, 270, 123, 269, 272,
250: 270, 273, 270, 270, 270, 270, 270, 269, 122, 270,
251: 273, 270, 269, 273, 270, 273, 271, 270, 270, 273,
252: 271, -1, -1, 271, 273, 269, 273, 270, 270, 270,
253: };
254: #define YYFINAL 1
255: #ifndef YYDEBUG
256: #define YYDEBUG 0
257: #endif
258: #define YYMAXTOKEN 319
259: #if YYDEBUG
260: char *yyname[] = {
261: "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
262: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
263: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
264: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
265: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
266: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
267: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"A","B","C","E","F","I","L","N",
268: "P","R","S","T","SP","CRLF","COMMA","STRING","NUMBER","USER","PASS","ACCT",
269: "REIN","QUIT","PORT","PASV","TYPE","STRU","MODE","RETR","STOR","APPE","MLFL",
270: "MAIL","MSND","MSOM","MSAM","MRSQ","MRCP","ALLO","REST","RNFR","RNTO","ABOR",
271: "DELE","CWD","LIST","NLST","SITE","STAT","HELP","NOOP","MKD","RMD","PWD","CDUP",
272: "STOU","SMNT","SYST","SIZE","MDTM","UMASK","IDLE","CHMOD","LEXERR",
273: };
274: char *yyrule[] = {
275: "$accept : cmd_list",
276: "cmd_list :",
277: "cmd_list : cmd_list cmd",
278: "cmd_list : cmd_list rcmd",
279: "cmd : USER SP username CRLF",
280: "cmd : PASS SP password CRLF",
281: "cmd : PORT SP host_port CRLF",
282: "cmd : PASV CRLF",
283: "cmd : TYPE SP type_code CRLF",
284: "cmd : STRU SP struct_code CRLF",
285: "cmd : MODE SP mode_code CRLF",
286: "cmd : ALLO SP NUMBER CRLF",
287: "cmd : ALLO SP NUMBER SP R SP NUMBER CRLF",
288: "cmd : RETR check_login SP pathname CRLF",
289: "cmd : STOR check_login SP pathname CRLF",
290: "cmd : APPE check_login SP pathname CRLF",
291: "cmd : NLST check_login CRLF",
292: "cmd : NLST check_login SP STRING CRLF",
293: "cmd : LIST check_login CRLF",
294: "cmd : LIST check_login SP pathname CRLF",
295: "cmd : STAT check_login SP pathname CRLF",
296: "cmd : STAT CRLF",
297: "cmd : DELE check_login SP pathname CRLF",
298: "cmd : RNTO SP pathname CRLF",
299: "cmd : ABOR CRLF",
300: "cmd : CWD check_login CRLF",
301: "cmd : CWD check_login SP pathname CRLF",
302: "cmd : HELP CRLF",
303: "cmd : HELP SP STRING CRLF",
304: "cmd : NOOP CRLF",
305: "cmd : MKD check_login SP pathname CRLF",
306: "cmd : RMD check_login SP pathname CRLF",
307: "cmd : PWD check_login CRLF",
308: "cmd : CDUP check_login CRLF",
309: "cmd : SITE SP HELP CRLF",
310: "cmd : SITE SP HELP SP STRING CRLF",
311: "cmd : SITE SP UMASK check_login CRLF",
312: "cmd : SITE SP UMASK check_login SP octal_number CRLF",
313: "cmd : SITE SP CHMOD check_login SP octal_number SP pathname CRLF",
314: "cmd : SITE SP IDLE CRLF",
315: "cmd : SITE SP IDLE SP NUMBER CRLF",
316: "cmd : STOU check_login SP pathname CRLF",
317: "cmd : SYST CRLF",
318: "cmd : SIZE check_login SP pathname CRLF",
319: "cmd : MDTM check_login SP pathname CRLF",
320: "cmd : QUIT CRLF",
321: "cmd : error CRLF",
322: "rcmd : RNFR check_login SP pathname CRLF",
323: "username : STRING",
324: "password :",
325: "password : STRING",
326: "byte_size : NUMBER",
327: "host_port : NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER",
328: "form_code : N",
329: "form_code : T",
330: "form_code : C",
331: "type_code : A",
332: "type_code : A SP form_code",
333: "type_code : E",
334: "type_code : E SP form_code",
335: "type_code : I",
336: "type_code : L",
337: "type_code : L SP byte_size",
338: "type_code : L byte_size",
339: "struct_code : F",
340: "struct_code : R",
341: "struct_code : P",
342: "mode_code : S",
343: "mode_code : B",
344: "mode_code : C",
345: "pathname : pathstring",
346: "pathstring : STRING",
347: "octal_number : NUMBER",
348: "check_login :",
349: };
350: #endif
351: #ifndef YYSTYPE
352: typedef int YYSTYPE;
353: #endif
354: #define yyclearin (yychar=(-1))
355: #define yyerrok (yyerrflag=0)
356: #ifndef YYSTACKSIZE
357: #ifdef YYMAXDEPTH
358: #define YYSTACKSIZE YYMAXDEPTH
359: #else
360: #define YYSTACKSIZE 300
361: #endif
362: #endif
363: int yydebug;
364: int yynerrs;
365: int yyerrflag;
366: int yychar;
367: short *yyssp;
368: YYSTYPE *yyvsp;
369: YYSTYPE yyval;
370: YYSTYPE yylval;
371: #define yystacksize YYSTACKSIZE
372: short yyss[YYSTACKSIZE];
373: YYSTYPE yyvs[YYSTACKSIZE];
374: #line 658 "ftp.y"
375:
376: extern jmp_buf errcatch;
377:
378: #define CMD 0 /* beginning of command */
379: #define ARGS 1 /* expect miscellaneous arguments */
380: #define STR1 2 /* expect SP followed by STRING */
381: #define STR2 3 /* expect STRING */
382: #define OSTR 4 /* optional SP then STRING */
383: #define ZSTR1 5 /* SP then optional STRING */
384: #define ZSTR2 6 /* optional STRING after SP */
385: #define SITECMD 7 /* SITE command */
386: #define NSTR 8 /* Number followed by a string */
387:
388: struct tab {
389: char *name;
390: short token;
391: short state;
392: short implemented; /* 1 if command is implemented */
393: char *help;
394: };
395:
396: struct tab cmdtab[] = { /* In order defined in RFC 765 */
397: { "USER", USER, STR1, 1, "<sp> username" },
398: { "PASS", PASS, ZSTR1, 1, "<sp> password" },
399: { "ACCT", ACCT, STR1, 0, "(specify account)" },
400: { "SMNT", SMNT, ARGS, 0, "(structure mount)" },
401: { "REIN", REIN, ARGS, 0, "(reinitialize server state)" },
402: { "QUIT", QUIT, ARGS, 1, "(terminate service)", },
403: { "PORT", PORT, ARGS, 1, "<sp> b0, b1, b2, b3, b4" },
404: { "PASV", PASV, ARGS, 1, "(set server in passive mode)" },
405: { "TYPE", TYPE, ARGS, 1, "<sp> [ A | E | I | L ]" },
406: { "STRU", STRU, ARGS, 1, "(specify file structure)" },
407: { "MODE", MODE, ARGS, 1, "(specify transfer mode)" },
408: { "RETR", RETR, STR1, 1, "<sp> file-name" },
409: { "STOR", STOR, STR1, 1, "<sp> file-name" },
410: { "APPE", APPE, STR1, 1, "<sp> file-name" },
411: { "MLFL", MLFL, OSTR, 0, "(mail file)" },
412: { "MAIL", MAIL, OSTR, 0, "(mail to user)" },
413: { "MSND", MSND, OSTR, 0, "(mail send to terminal)" },
414: { "MSOM", MSOM, OSTR, 0, "(mail send to terminal or mailbox)" },
415: { "MSAM", MSAM, OSTR, 0, "(mail send to terminal and mailbox)" },
416: { "MRSQ", MRSQ, OSTR, 0, "(mail recipient scheme question)" },
417: { "MRCP", MRCP, STR1, 0, "(mail recipient)" },
418: { "ALLO", ALLO, ARGS, 1, "allocate storage (vacuously)" },
419: { "REST", REST, ARGS, 0, "(restart command)" },
420: { "RNFR", RNFR, STR1, 1, "<sp> file-name" },
421: { "RNTO", RNTO, STR1, 1, "<sp> file-name" },
422: { "ABOR", ABOR, ARGS, 1, "(abort operation)" },
423: { "DELE", DELE, STR1, 1, "<sp> file-name" },
424: { "CWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
425: { "XCWD", CWD, OSTR, 1, "[ <sp> directory-name ]" },
426: { "LIST", LIST, OSTR, 1, "[ <sp> path-name ]" },
427: { "NLST", NLST, OSTR, 1, "[ <sp> path-name ]" },
428: { "SITE", SITE, SITECMD, 1, "site-cmd [ <sp> arguments ]" },
429: { "SYST", SYST, ARGS, 1, "(get type of operating system)" },
430: { "STAT", STAT, OSTR, 1, "[ <sp> path-name ]" },
431: { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
432: { "NOOP", NOOP, ARGS, 1, "" },
433: { "MKD", MKD, STR1, 1, "<sp> path-name" },
434: { "XMKD", MKD, STR1, 1, "<sp> path-name" },
435: { "RMD", RMD, STR1, 1, "<sp> path-name" },
436: { "XRMD", RMD, STR1, 1, "<sp> path-name" },
437: { "PWD", PWD, ARGS, 1, "(return current directory)" },
438: { "XPWD", PWD, ARGS, 1, "(return current directory)" },
439: { "CDUP", CDUP, ARGS, 1, "(change to parent directory)" },
440: { "XCUP", CDUP, ARGS, 1, "(change to parent directory)" },
441: { "STOU", STOU, STR1, 1, "<sp> file-name" },
442: { "SIZE", SIZE, OSTR, 1, "<sp> path-name" },
443: { "MDTM", MDTM, OSTR, 1, "<sp> path-name" },
444: { NULL, 0, 0, 0, 0 }
445: };
446:
447: struct tab sitetab[] = {
448: { "UMASK", UMASK, ARGS, 1, "[ <sp> umask ]" },
449: { "IDLE", IDLE, ARGS, 1, "[ <sp> maximum-idle-time ]" },
450: { "CHMOD", CHMOD, NSTR, 1, "<sp> mode <sp> file-name" },
451: { "HELP", HELP, OSTR, 1, "[ <sp> <string> ]" },
452: { NULL, 0, 0, 0, 0 }
453: };
454:
455: struct tab *
456: lookup(p, cmd)
457: register struct tab *p;
458: char *cmd;
459: {
460:
461: for (; p->name != NULL; p++)
462: if (strcmp(cmd, p->name) == 0)
463: return (p);
464: return (0);
465: }
466:
467: #include <arpa/telnet.h>
468:
469: /*
470: * getline - a hacked up version of fgets to ignore TELNET escape codes.
471: */
472: char *
473: getline(s, n, iop)
474: char *s;
475: register FILE *iop;
476: {
477: register c;
478: register char *cs;
479:
480: cs = s;
481: /* tmpline may contain saved command from urgent mode interruption */
482: for (c = 0; tmpline[c] != '\0' && --n > 0; ++c) {
483: *cs++ = tmpline[c];
484: if (tmpline[c] == '\n') {
485: *cs++ = '\0';
486: if (debug)
487: syslog(LOG_DEBUG, "command: %s", s);
488: tmpline[0] = '\0';
489: return(s);
490: }
491: if (c == 0)
492: tmpline[0] = '\0';
493: }
494: while ((c = getc(iop)) != EOF) {
495: c &= 0377;
496: if (c == IAC) {
497: if ((c = getc(iop)) != EOF) {
498: c &= 0377;
499: switch (c) {
500: case WILL:
501: case WONT:
502: c = getc(iop);
503: printf("%c%c%c", IAC, DONT, 0377&c);
504: (void) fflush(stdout);
505: continue;
506: case DO:
507: case DONT:
508: c = getc(iop);
509: printf("%c%c%c", IAC, WONT, 0377&c);
510: (void) fflush(stdout);
511: continue;
512: case IAC:
513: break;
514: default:
515: continue; /* ignore command */
516: }
517: }
518: }
519: *cs++ = c;
520: if (--n <= 0 || c == '\n')
521: break;
522: }
523: if (c == EOF && cs == s)
524: return (NULL);
525: *cs++ = '\0';
526: if (debug)
527: syslog(LOG_DEBUG, "command: %s", s);
528: return (s);
529: }
530:
531: static int
532: toolong()
533: {
534: time_t now;
535: extern char *ctime();
536: extern time_t time();
537:
538: reply(421,
539: "Timeout (%d seconds): closing control connection.", timeout);
540: (void) time(&now);
541: if (logging) {
542: syslog(LOG_INFO,
543: "User %s timed out after %d seconds at %s",
544: (pw ? pw -> pw_name : "unknown"), timeout, ctime(&now));
545: }
546: dologout(1);
547: }
548:
549: yylex()
550: {
551: static int cpos, state;
552: register char *cp, *cp2;
553: register struct tab *p;
554: int n;
555: char c, *strpbrk();
556: char *copy();
557:
558: for (;;) {
559: switch (state) {
560:
561: case CMD:
562: (void) signal(SIGALRM, toolong);
563: (void) alarm((unsigned) timeout);
564: if (getline(cbuf, sizeof(cbuf)-1, stdin) == NULL) {
565: reply(221, "You could at least say goodbye.");
566: dologout(0);
567: }
568: (void) alarm(0);
569: #ifdef SETPROCTITLE
570: if (strncasecmp(cbuf, "PASS", 4) != NULL)
571: setproctitle("%s: %s", proctitle, cbuf);
572: #endif /* SETPROCTITLE */
573: if ((cp = index(cbuf, '\r'))) {
574: *cp++ = '\n';
575: *cp = '\0';
576: }
577: if ((cp = strpbrk(cbuf, " \n")))
578: cpos = cp - cbuf;
579: if (cpos == 0)
580: cpos = 4;
581: c = cbuf[cpos];
582: cbuf[cpos] = '\0';
583: upper(cbuf);
584: p = lookup(cmdtab, cbuf);
585: cbuf[cpos] = c;
586: if (p != 0) {
587: if (p->implemented == 0) {
588: nack(p->name);
589: longjmp(errcatch,0);
590: /* NOTREACHED */
591: }
592: state = p->state;
593: *(char **)&yylval = p->name;
594: return (p->token);
595: }
596: break;
597:
598: case SITECMD:
599: if (cbuf[cpos] == ' ') {
600: cpos++;
601: return (SP);
602: }
603: cp = &cbuf[cpos];
604: if ((cp2 = strpbrk(cp, " \n")))
605: cpos = cp2 - cbuf;
606: c = cbuf[cpos];
607: cbuf[cpos] = '\0';
608: upper(cp);
609: p = lookup(sitetab, cp);
610: cbuf[cpos] = c;
611: if (p != 0) {
612: if (p->implemented == 0) {
613: state = CMD;
614: nack(p->name);
615: longjmp(errcatch,0);
616: /* NOTREACHED */
617: }
618: state = p->state;
619: *(char **)&yylval = p->name;
620: return (p->token);
621: }
622: state = CMD;
623: break;
624:
625: case OSTR:
626: if (cbuf[cpos] == '\n') {
627: state = CMD;
628: return (CRLF);
629: }
630: /* FALLTHROUGH */
631:
632: case STR1:
633: case ZSTR1:
634: dostr1:
635: if (cbuf[cpos] == ' ') {
636: cpos++;
637: state = state == OSTR ? STR2 : ++state;
638: return (SP);
639: }
640: break;
641:
642: case ZSTR2:
643: if (cbuf[cpos] == '\n') {
644: state = CMD;
645: return (CRLF);
646: }
647: /* FALLTHROUGH */
648:
649: case STR2:
650: cp = &cbuf[cpos];
651: n = strlen(cp);
652: cpos += n - 1;
653: /*
654: * Make sure the string is nonempty and \n terminated.
655: */
656: if (n > 1 && cbuf[cpos] == '\n') {
657: cbuf[cpos] = '\0';
658: *(char **)&yylval = copy(cp);
659: cbuf[cpos] = '\n';
660: state = ARGS;
661: return (STRING);
662: }
663: break;
664:
665: case NSTR:
666: if (cbuf[cpos] == ' ') {
667: cpos++;
668: return (SP);
669: }
670: if (isdigit(cbuf[cpos])) {
671: cp = &cbuf[cpos];
672: while (isdigit(cbuf[++cpos]))
673: ;
674: c = cbuf[cpos];
675: cbuf[cpos] = '\0';
676: yylval = atoi(cp);
677: cbuf[cpos] = c;
678: state = STR1;
679: return (NUMBER);
680: }
681: state = STR1;
682: goto dostr1;
683:
684: case ARGS:
685: if (isdigit(cbuf[cpos])) {
686: cp = &cbuf[cpos];
687: while (isdigit(cbuf[++cpos]))
688: ;
689: c = cbuf[cpos];
690: cbuf[cpos] = '\0';
691: yylval = atoi(cp);
692: cbuf[cpos] = c;
693: return (NUMBER);
694: }
695: switch (cbuf[cpos++]) {
696:
697: case '\n':
698: state = CMD;
699: return (CRLF);
700:
701: case ' ':
702: return (SP);
703:
704: case ',':
705: return (COMMA);
706:
707: case 'A':
708: case 'a':
709: return (A);
710:
711: case 'B':
712: case 'b':
713: return (B);
714:
715: case 'C':
716: case 'c':
717: return (C);
718:
719: case 'E':
720: case 'e':
721: return (E);
722:
723: case 'F':
724: case 'f':
725: return (F);
726:
727: case 'I':
728: case 'i':
729: return (I);
730:
731: case 'L':
732: case 'l':
733: return (L);
734:
735: case 'N':
736: case 'n':
737: return (N);
738:
739: case 'P':
740: case 'p':
741: return (P);
742:
743: case 'R':
744: case 'r':
745: return (R);
746:
747: case 'S':
748: case 's':
749: return (S);
750:
751: case 'T':
752: case 't':
753: return (T);
754:
755: }
756: break;
757:
758: default:
759: fatal("Unknown state in scanner.");
760: }
761: yyerror((char *) 0);
762: state = CMD;
763: longjmp(errcatch,0);
764: }
765: }
766:
767: upper(s)
768: register char *s;
769: {
770: while (*s != '\0') {
771: if (islower(*s))
772: *s = toupper(*s);
773: s++;
774: }
775: }
776:
777: char *
778: copy(s)
779: char *s;
780: {
781: char *p;
782: extern char *malloc(), *strcpy();
783:
784: p = malloc((unsigned) strlen(s) + 1);
785: if (p == NULL)
786: fatal("Ran out of memory.");
787: (void) strcpy(p, s);
788: return (p);
789: }
790:
791: help(ctab, s)
792: struct tab *ctab;
793: char *s;
794: {
795: register struct tab *c;
796: register int width, NCMDS;
797: char *type;
798:
799: if (ctab == sitetab)
800: type = "SITE ";
801: else
802: type = "";
803: width = 0, NCMDS = 0;
804: for (c = ctab; c->name != NULL; c++) {
805: int len = strlen(c->name);
806:
807: if (len > width)
808: width = len;
809: NCMDS++;
810: }
811: width = (width + 8) &~ 7;
812: if (s == 0) {
813: register int i, j, w;
814: int columns, lines;
815:
816: lreply(214, "The following %scommands are recognized %s.",
817: type, "(* =>'s unimplemented)");
818: columns = 76 / width;
819: if (columns == 0)
820: columns = 1;
821: lines = (NCMDS + columns - 1) / columns;
822: for (i = 0; i < lines; i++) {
823: printf(" ");
824: for (j = 0; j < columns; j++) {
825: c = ctab + j * lines + i;
826: printf("%s%c", c->name,
827: c->implemented ? ' ' : '*');
828: if (c + lines >= &ctab[NCMDS])
829: break;
830: w = strlen(c->name) + 1;
831: while (w < width) {
832: putchar(' ');
833: w++;
834: }
835: }
836: printf("\r\n");
837: }
838: (void) fflush(stdout);
839: reply(214, "Direct comments to ftp-bugs@%s.", hostname);
840: return;
841: }
842: upper(s);
843: c = lookup(ctab, s);
844: if (c == (struct tab *)0) {
845: reply(502, "Unknown command %s.", s);
846: return;
847: }
848: if (c->implemented)
849: reply(214, "Syntax: %s%s %s", type, c->name, c->help);
850: else
851: reply(214, "%s%-*s\t%s; unimplemented.", type, width,
852: c->name, c->help);
853: }
854:
855: sizecmd(filename)
856: char *filename;
857: {
858: switch (type) {
859: case TYPE_L:
860: case TYPE_I: {
861: struct stat stbuf;
862: if (stat(filename, &stbuf) < 0 ||
863: (stbuf.st_mode&S_IFMT) != S_IFREG)
864: reply(550, "%s: not a plain file.", filename);
865: else
866: reply(213, "%lu", stbuf.st_size);
867: break;}
868: case TYPE_A: {
869: FILE *fin;
870: register int c, count;
871: struct stat stbuf;
872: fin = fopen(filename, "r");
873: if (fin == NULL) {
874: perror_reply(550, filename);
875: return;
876: }
877: if (fstat(fileno(fin), &stbuf) < 0 ||
878: (stbuf.st_mode&S_IFMT) != S_IFREG) {
879: reply(550, "%s: not a plain file.", filename);
880: (void) fclose(fin);
881: return;
882: }
883:
884: count = 0;
885: while((c=getc(fin)) != EOF) {
886: if (c == '\n') /* will get expanded to \r\n */
887: count++;
888: count++;
889: }
890: (void) fclose(fin);
891:
892: reply(213, "%ld", count);
893: break;}
894: default:
895: reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
896: }
897: }
898: #line 898 "ftp.tab.c"
899: #define YYABORT goto yyabort
900: #define YYACCEPT goto yyaccept
901: #define YYERROR goto yyerrlab
902: int
903: yyparse()
904: {
905: register int yym, yyn, yystate;
906: #if YYDEBUG
907: register char *yys;
908: extern char *getenv();
909:
910: if (yys = getenv("YYDEBUG"))
911: {
912: yyn = *yys;
913: if (yyn == '0')
914: yydebug = 0;
915: else if (yyn >= '1' && yyn <= '9')
916: yydebug = yyn - '0';
917: }
918: #endif
919:
920: yynerrs = 0;
921: yyerrflag = 0;
922: yychar = (-1);
923:
924: yyssp = yyss;
925: yyvsp = yyvs;
926: *yyssp = yystate = 0;
927:
928: yyloop:
929: if (yyn = yydefred[yystate]) goto yyreduce;
930: if (yychar < 0)
931: {
932: if ((yychar = yylex()) < 0) yychar = 0;
933: #if YYDEBUG
934: if (yydebug)
935: {
936: yys = 0;
937: if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
938: if (!yys) yys = "illegal-symbol";
939: printf("yydebug: state %d, reading %d (%s)\n", yystate,
940: yychar, yys);
941: }
942: #endif
943: }
944: if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
945: yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
946: {
947: #if YYDEBUG
948: if (yydebug)
949: printf("yydebug: state %d, shifting to state %d\n",
950: yystate, yytable[yyn]);
951: #endif
952: if (yyssp >= yyss + yystacksize - 1)
953: {
954: goto yyoverflow;
955: }
956: *++yyssp = yystate = yytable[yyn];
957: *++yyvsp = yylval;
958: yychar = (-1);
959: if (yyerrflag > 0) --yyerrflag;
960: goto yyloop;
961: }
962: if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
963: yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
964: {
965: yyn = yytable[yyn];
966: goto yyreduce;
967: }
968: if (yyerrflag) goto yyinrecovery;
969: #ifdef lint
970: goto yynewerror;
971: #endif
972: yynewerror:
973: yyerror("syntax error");
974: #ifdef lint
975: goto yyerrlab;
976: #endif
977: yyerrlab:
978: ++yynerrs;
979: yyinrecovery:
980: if (yyerrflag < 3)
981: {
982: yyerrflag = 3;
983: for (;;)
984: {
985: if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
986: yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
987: {
988: #if YYDEBUG
989: if (yydebug)
990: printf("yydebug: state %d, error recovery shifting\
991: to state %d\n", *yyssp, yytable[yyn]);
992: #endif
993: if (yyssp >= yyss + yystacksize - 1)
994: {
995: goto yyoverflow;
996: }
997: *++yyssp = yystate = yytable[yyn];
998: *++yyvsp = yylval;
999: goto yyloop;
1000: }
1001: else
1002: {
1003: #if YYDEBUG
1004: if (yydebug)
1005: printf("yydebug: error recovery discarding state %d\n",
1006: *yyssp);
1007: #endif
1008: if (yyssp <= yyss) goto yyabort;
1009: --yyssp;
1010: --yyvsp;
1011: }
1012: }
1013: }
1014: else
1015: {
1016: if (yychar == 0) goto yyabort;
1017: #if YYDEBUG
1018: if (yydebug)
1019: {
1020: yys = 0;
1021: if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
1022: if (!yys) yys = "illegal-symbol";
1023: printf("yydebug: state %d, error recovery discards token %d (%s)\n",
1024: yystate, yychar, yys);
1025: }
1026: #endif
1027: yychar = (-1);
1028: goto yyloop;
1029: }
1030: yyreduce:
1031: #if YYDEBUG
1032: if (yydebug)
1033: printf("yydebug: state %d, reducing by rule %d (%s)\n",
1034: yystate, yyn, yyrule[yyn]);
1035: #endif
1036: yym = yylen[yyn];
1037: yyval = yyvsp[1-yym];
1038: switch (yyn)
1039: {
1040: case 2:
1041: #line 99 "ftp.y"
1042: {
1043: fromname = (char *) 0;
1044: }
1045: break;
1046: case 4:
1047: #line 106 "ftp.y"
1048: {
1049: user((char *) yyvsp[-1]);
1050: free((char *) yyvsp[-1]);
1051: }
1052: break;
1053: case 5:
1054: #line 111 "ftp.y"
1055: {
1056: pass((char *) yyvsp[-1]);
1057: free((char *) yyvsp[-1]);
1058: }
1059: break;
1060: case 6:
1061: #line 116 "ftp.y"
1062: {
1063: usedefault = 0;
1064: if (pdata >= 0) {
1065: (void) close(pdata);
1066: pdata = -1;
1067: }
1068: reply(200, "PORT command successful.");
1069: }
1070: break;
1071: case 7:
1072: #line 125 "ftp.y"
1073: {
1074: passive();
1075: }
1076: break;
1077: case 8:
1078: #line 129 "ftp.y"
1079: {
1080: switch (cmd_type) {
1081:
1082: case TYPE_A:
1083: if (cmd_form == FORM_N) {
1084: reply(200, "Type set to A.");
1085: type = cmd_type;
1086: form = cmd_form;
1087: } else
1088: reply(504, "Form must be N.");
1089: break;
1090:
1091: case TYPE_E:
1092: reply(504, "Type E not implemented.");
1093: break;
1094:
1095: case TYPE_I:
1096: reply(200, "Type set to I.");
1097: type = cmd_type;
1098: break;
1099:
1100: case TYPE_L:
1101: #if NBBY == 8
1102: if (cmd_bytesz == 8) {
1103: reply(200,
1104: "Type set to L (byte size 8).");
1105: type = cmd_type;
1106: } else
1107: reply(504, "Byte size must be 8.");
1108: #else /* NBBY == 8 */
1109: UNIMPLEMENTED for NBBY != 8
1110: #endif /* NBBY == 8 */
1111: }
1112: }
1113: break;
1114: case 9:
1115: #line 164 "ftp.y"
1116: {
1117: switch (yyvsp[-1]) {
1118:
1119: case STRU_F:
1120: reply(200, "STRU F ok.");
1121: break;
1122:
1123: default:
1124: reply(504, "Unimplemented STRU type.");
1125: }
1126: }
1127: break;
1128: case 10:
1129: #line 176 "ftp.y"
1130: {
1131: switch (yyvsp[-1]) {
1132:
1133: case MODE_S:
1134: reply(200, "MODE S ok.");
1135: break;
1136:
1137: default:
1138: reply(502, "Unimplemented MODE type.");
1139: }
1140: }
1141: break;
1142: case 11:
1143: #line 188 "ftp.y"
1144: {
1145: reply(202, "ALLO command ignored.");
1146: }
1147: break;
1148: case 12:
1149: #line 192 "ftp.y"
1150: {
1151: reply(202, "ALLO command ignored.");
1152: }
1153: break;
1154: case 13:
1155: #line 196 "ftp.y"
1156: {
1157: if (yyvsp[-3] && yyvsp[-1] != NULL)
1158: retrieve((char *) 0, (char *) yyvsp[-1]);
1159: if (yyvsp[-1] != NULL)
1160: free((char *) yyvsp[-1]);
1161: }
1162: break;
1163: case 14:
1164: #line 203 "ftp.y"
1165: {
1166: if (yyvsp[-3] && yyvsp[-1] != NULL)
1167: store((char *) yyvsp[-1], "w", 0);
1168: if (yyvsp[-1] != NULL)
1169: free((char *) yyvsp[-1]);
1170: }
1171: break;
1172: case 15:
1173: #line 210 "ftp.y"
1174: {
1175: if (yyvsp[-3] && yyvsp[-1] != NULL)
1176: store((char *) yyvsp[-1], "a", 0);
1177: if (yyvsp[-1] != NULL)
1178: free((char *) yyvsp[-1]);
1179: }
1180: break;
1181: case 16:
1182: #line 217 "ftp.y"
1183: {
1184: if (yyvsp[-1])
1185: send_file_list(".");
1186: }
1187: break;
1188: case 17:
1189: #line 222 "ftp.y"
1190: {
1191: if (yyvsp[-3] && yyvsp[-1] != NULL)
1192: send_file_list((char *) yyvsp[-1]);
1193: if (yyvsp[-1] != NULL)
1194: free((char *) yyvsp[-1]);
1195: }
1196: break;
1197: case 18:
1198: #line 229 "ftp.y"
1199: {
1200: if (yyvsp[-1])
1201: retrieve("/bin/ls -lgA", "");
1202: }
1203: break;
1204: case 19:
1205: #line 234 "ftp.y"
1206: {
1207: if (yyvsp[-3] && yyvsp[-1] != NULL)
1208: retrieve("/bin/ls -lgA %s", (char *) yyvsp[-1]);
1209: if (yyvsp[-1] != NULL)
1210: free((char *) yyvsp[-1]);
1211: }
1212: break;
1213: case 20:
1214: #line 241 "ftp.y"
1215: {
1216: if (yyvsp[-3] && yyvsp[-1] != NULL)
1217: statfilecmd((char *) yyvsp[-1]);
1218: if (yyvsp[-1] != NULL)
1219: free((char *) yyvsp[-1]);
1220: }
1221: break;
1222: case 21:
1223: #line 248 "ftp.y"
1224: {
1225: statcmd();
1226: }
1227: break;
1228: case 22:
1229: #line 252 "ftp.y"
1230: {
1231: if (yyvsp[-3] && yyvsp[-1] != NULL)
1232: delete((char *) yyvsp[-1]);
1233: if (yyvsp[-1] != NULL)
1234: free((char *) yyvsp[-1]);
1235: }
1236: break;
1237: case 23:
1238: #line 259 "ftp.y"
1239: {
1240: if (fromname) {
1241: renamecmd(fromname, (char *) yyvsp[-1]);
1242: free(fromname);
1243: fromname = (char *) 0;
1244: } else {
1245: reply(503, "Bad sequence of commands.");
1246: }
1247: free((char *) yyvsp[-1]);
1248: }
1249: break;
1250: case 24:
1251: #line 270 "ftp.y"
1252: {
1253: reply(225, "ABOR command successful.");
1254: }
1255: break;
1256: case 25:
1257: #line 274 "ftp.y"
1258: {
1259: if (yyvsp[-1])
1260: cwd(pw->pw_dir);
1261: }
1262: break;
1263: case 26:
1264: #line 279 "ftp.y"
1265: {
1266: if (yyvsp[-3] && yyvsp[-1] != NULL)
1267: cwd((char *) yyvsp[-1]);
1268: if (yyvsp[-1] != NULL)
1269: free((char *) yyvsp[-1]);
1270: }
1271: break;
1272: case 27:
1273: #line 286 "ftp.y"
1274: {
1275: help(cmdtab, (char *) 0);
1276: }
1277: break;
1278: case 28:
1279: #line 290 "ftp.y"
1280: {
1281: register char *cp = (char *)yyvsp[-1];
1282:
1283: if (strncasecmp(cp, "SITE", 4) == 0) {
1284: cp = (char *)yyvsp[-1] + 4;
1285: if (*cp == ' ')
1286: cp++;
1287: if (*cp)
1288: help(sitetab, cp);
1289: else
1290: help(sitetab, (char *) 0);
1291: } else
1292: help(cmdtab, (char *) yyvsp[-1]);
1293: }
1294: break;
1295: case 29:
1296: #line 305 "ftp.y"
1297: {
1298: reply(200, "NOOP command successful.");
1299: }
1300: break;
1301: case 30:
1302: #line 309 "ftp.y"
1303: {
1304: if (yyvsp[-3] && yyvsp[-1] != NULL)
1305: makedir((char *) yyvsp[-1]);
1306: if (yyvsp[-1] != NULL)
1307: free((char *) yyvsp[-1]);
1308: }
1309: break;
1310: case 31:
1311: #line 316 "ftp.y"
1312: {
1313: if (yyvsp[-3] && yyvsp[-1] != NULL)
1314: removedir((char *) yyvsp[-1]);
1315: if (yyvsp[-1] != NULL)
1316: free((char *) yyvsp[-1]);
1317: }
1318: break;
1319: case 32:
1320: #line 323 "ftp.y"
1321: {
1322: if (yyvsp[-1])
1323: pwd();
1324: }
1325: break;
1326: case 33:
1327: #line 328 "ftp.y"
1328: {
1329: if (yyvsp[-1])
1330: cwd("..");
1331: }
1332: break;
1333: case 34:
1334: #line 333 "ftp.y"
1335: {
1336: help(sitetab, (char *) 0);
1337: }
1338: break;
1339: case 35:
1340: #line 337 "ftp.y"
1341: {
1342: help(sitetab, (char *) yyvsp[-1]);
1343: }
1344: break;
1345: case 36:
1346: #line 341 "ftp.y"
1347: {
1348: int oldmask;
1349:
1350: if (yyvsp[-1]) {
1351: oldmask = umask(0);
1352: (void) umask(oldmask);
1353: reply(200, "Current UMASK is %03o", oldmask);
1354: }
1355: }
1356: break;
1357: case 37:
1358: #line 351 "ftp.y"
1359: {
1360: int oldmask;
1361:
1362: if (yyvsp[-3]) {
1363: if ((yyvsp[-1] == -1) || (yyvsp[-1] > 0777)) {
1364: reply(501, "Bad UMASK value");
1365: } else {
1366: oldmask = umask(yyvsp[-1]);
1367: reply(200,
1368: "UMASK set to %03o (was %03o)",
1369: yyvsp[-1], oldmask);
1370: }
1371: }
1372: }
1373: break;
1374: case 38:
1375: #line 366 "ftp.y"
1376: {
1377: if (yyvsp[-5] && (yyvsp[-1] != NULL)) {
1378: if (yyvsp[-3] > 0777)
1379: reply(501,
1380: "CHMOD: Mode value must be between 0 and 0777");
1381: else if (chmod((char *) yyvsp[-1], yyvsp[-3]) < 0)
1382: perror_reply(550, (char *) yyvsp[-1]);
1383: else
1384: reply(200, "CHMOD command successful.");
1385: }
1386: if (yyvsp[-1] != NULL)
1387: free((char *) yyvsp[-1]);
1388: }
1389: break;
1390: case 39:
1391: #line 380 "ftp.y"
1392: {
1393: reply(200,
1394: "Current IDLE time limit is %d seconds; max %d",
1395: timeout, maxtimeout);
1396: }
1397: break;
1398: case 40:
1399: #line 386 "ftp.y"
1400: {
1401: if (yyvsp[-1] < 30 || yyvsp[-1] > maxtimeout) {
1402: reply(501,
1403: "Maximum IDLE time must be between 30 and %d seconds",
1404: maxtimeout);
1405: } else {
1406: timeout = yyvsp[-1];
1407: (void) alarm((unsigned) timeout);
1408: reply(200,
1409: "Maximum IDLE time set to %d seconds",
1410: timeout);
1411: }
1412: }
1413: break;
1414: case 41:
1415: #line 400 "ftp.y"
1416: {
1417: if (yyvsp[-3] && yyvsp[-1] != NULL)
1418: store((char *) yyvsp[-1], "w", 1);
1419: if (yyvsp[-1] != NULL)
1420: free((char *) yyvsp[-1]);
1421: }
1422: break;
1423: case 42:
1424: #line 407 "ftp.y"
1425: {
1426: #ifdef unix
1427: #ifdef BSD
1428: reply(215, "UNIX Type: L%d Version: BSD-%d",
1429: NBBY, BSD);
1430: #else /* BSD */
1431: reply(215, "UNIX Type: L%d", NBBY);
1432: #endif /* BSD */
1433: #else /* unix */
1434: reply(215, "UNKNOWN Type: L%d", NBBY);
1435: #endif /* unix */
1436: }
1437: break;
1438: case 43:
1439: #line 428 "ftp.y"
1440: {
1441: if (yyvsp[-3] && yyvsp[-1] != NULL)
1442: sizecmd((char *) yyvsp[-1]);
1443: if (yyvsp[-1] != NULL)
1444: free((char *) yyvsp[-1]);
1445: }
1446: break;
1447: case 44:
1448: #line 445 "ftp.y"
1449: {
1450: if (yyvsp[-3] && yyvsp[-1] != NULL) {
1451: struct stat stbuf;
1452: if (stat((char *) yyvsp[-1], &stbuf) < 0)
1453: perror_reply(550, "%s", (char *) yyvsp[-1]);
1454: else if ((stbuf.st_mode&S_IFMT) != S_IFREG) {
1455: reply(550, "%s: not a plain file.",
1456: (char *) yyvsp[-1]);
1457: } else {
1458: register struct tm *t;
1459: struct tm *gmtime();
1460: t = gmtime(&stbuf.st_mtime);
1461: reply(213,
1462: "19%02d%02d%02d%02d%02d%02d",
1463: t->tm_year, t->tm_mon+1, t->tm_mday,
1464: t->tm_hour, t->tm_min, t->tm_sec);
1465: }
1466: }
1467: if (yyvsp[-1] != NULL)
1468: free((char *) yyvsp[-1]);
1469: }
1470: break;
1471: case 45:
1472: #line 467 "ftp.y"
1473: {
1474: reply(221, "Goodbye.");
1475: dologout(0);
1476: }
1477: break;
1478: case 46:
1479: #line 472 "ftp.y"
1480: {
1481: yyerrok;
1482: }
1483: break;
1484: case 47:
1485: #line 477 "ftp.y"
1486: {
1487: char *renamefrom();
1488:
1489: if (yyvsp[-3] && yyvsp[-1]) {
1490: fromname = renamefrom((char *) yyvsp[-1]);
1491: if (fromname == (char *) 0 && yyvsp[-1]) {
1492: free((char *) yyvsp[-1]);
1493: }
1494: }
1495: }
1496: break;
1497: case 49:
1498: #line 493 "ftp.y"
1499: {
1500: *(char **)&(yyval ) = "";
1501: }
1502: break;
1503: case 52:
1504: #line 504 "ftp.y"
1505: {
1506: register char *a, *p;
1507:
1508: a = (char *)&data_dest.sin_addr;
1509: a[0] = yyvsp[-10]; a[1] = yyvsp[-8]; a[2] = yyvsp[-6]; a[3] = yyvsp[-4];
1510: p = (char *)&data_dest.sin_port;
1511: p[0] = yyvsp[-2]; p[1] = yyvsp[0];
1512: data_dest.sin_family = AF_INET;
1513: }
1514: break;
1515: case 53:
1516: #line 516 "ftp.y"
1517: {
1518: yyval = FORM_N;
1519: }
1520: break;
1521: case 54:
1522: #line 520 "ftp.y"
1523: {
1524: yyval = FORM_T;
1525: }
1526: break;
1527: case 55:
1528: #line 524 "ftp.y"
1529: {
1530: yyval = FORM_C;
1531: }
1532: break;
1533: case 56:
1534: #line 530 "ftp.y"
1535: {
1536: cmd_type = TYPE_A;
1537: cmd_form = FORM_N;
1538: }
1539: break;
1540: case 57:
1541: #line 535 "ftp.y"
1542: {
1543: cmd_type = TYPE_A;
1544: cmd_form = yyvsp[0];
1545: }
1546: break;
1547: case 58:
1548: #line 540 "ftp.y"
1549: {
1550: cmd_type = TYPE_E;
1551: cmd_form = FORM_N;
1552: }
1553: break;
1554: case 59:
1555: #line 545 "ftp.y"
1556: {
1557: cmd_type = TYPE_E;
1558: cmd_form = yyvsp[0];
1559: }
1560: break;
1561: case 60:
1562: #line 550 "ftp.y"
1563: {
1564: cmd_type = TYPE_I;
1565: }
1566: break;
1567: case 61:
1568: #line 554 "ftp.y"
1569: {
1570: cmd_type = TYPE_L;
1571: cmd_bytesz = NBBY;
1572: }
1573: break;
1574: case 62:
1575: #line 559 "ftp.y"
1576: {
1577: cmd_type = TYPE_L;
1578: cmd_bytesz = yyvsp[0];
1579: }
1580: break;
1581: case 63:
1582: #line 565 "ftp.y"
1583: {
1584: cmd_type = TYPE_L;
1585: cmd_bytesz = yyvsp[0];
1586: }
1587: break;
1588: case 64:
1589: #line 572 "ftp.y"
1590: {
1591: yyval = STRU_F;
1592: }
1593: break;
1594: case 65:
1595: #line 576 "ftp.y"
1596: {
1597: yyval = STRU_R;
1598: }
1599: break;
1600: case 66:
1601: #line 580 "ftp.y"
1602: {
1603: yyval = STRU_P;
1604: }
1605: break;
1606: case 67:
1607: #line 586 "ftp.y"
1608: {
1609: yyval = MODE_S;
1610: }
1611: break;
1612: case 68:
1613: #line 590 "ftp.y"
1614: {
1615: yyval = MODE_B;
1616: }
1617: break;
1618: case 69:
1619: #line 594 "ftp.y"
1620: {
1621: yyval = MODE_C;
1622: }
1623: break;
1624: case 70:
1625: #line 600 "ftp.y"
1626: {
1627: /*
1628: * Problem: this production is used for all pathname
1629: * processing, but only gives a 550 error reply.
1630: * This is a valid reply in some cases but not in others.
1631: */
1632: if (logged_in && yyvsp[0] && strncmp((char *) yyvsp[0], "~", 1) == 0) {
1633: *(char **)&(yyval ) = *glob((char *) yyvsp[0]);
1634: if (globerr != NULL) {
1635: reply(550, globerr);
1636: yyval = NULL;
1637: }
1638: free((char *) yyvsp[0]);
1639: } else
1640: yyval = yyvsp[0];
1641: }
1642: break;
1643: case 72:
1644: #line 622 "ftp.y"
1645: {
1646: register int ret, dec, multby, digit;
1647:
1648: /*
1649: * Convert a number that was read as decimal number
1650: * to what it would be if it had been read as octal.
1651: */
1652: dec = yyvsp[0];
1653: multby = 1;
1654: ret = 0;
1655: while (dec) {
1656: digit = dec%10;
1657: if (digit > 7) {
1658: ret = -1;
1659: break;
1660: }
1661: ret += digit * multby;
1662: multby *= 8;
1663: dec /= 10;
1664: }
1665: yyval = ret;
1666: }
1667: break;
1668: case 73:
1669: #line 647 "ftp.y"
1670: {
1671: if (logged_in)
1672: yyval = 1;
1673: else {
1674: reply(530, "Please login with USER and PASS.");
1675: yyval = 0;
1676: }
1677: }
1678: break;
1679: #line 1679 "ftp.tab.c"
1680: }
1681: yyssp -= yym;
1682: yystate = *yyssp;
1683: yyvsp -= yym;
1684: yym = yylhs[yyn];
1685: if (yystate == 0 && yym == 0)
1686: {
1687: #ifdef YYDEBUG
1688: if (yydebug)
1689: printf("yydebug: after reduction, shifting from state 0 to\
1690: state %d\n", YYFINAL);
1691: #endif
1692: yystate = YYFINAL;
1693: *++yyssp = YYFINAL;
1694: *++yyvsp = yyval;
1695: if (yychar < 0)
1696: {
1697: if ((yychar = yylex()) < 0) yychar = 0;
1698: #if YYDEBUG
1699: if (yydebug)
1700: {
1701: yys = 0;
1702: if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
1703: if (!yys) yys = "illegal-symbol";
1704: printf("yydebug: state %d, reading %d (%s)\n",
1705: YYFINAL, yychar, yys);
1706: }
1707: #endif
1708: }
1709: if (yychar == 0) goto yyaccept;
1710: goto yyloop;
1711: }
1712: if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
1713: yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
1714: yystate = yytable[yyn];
1715: else
1716: yystate = yydgoto[yym];
1717: #ifdef YYDEBUG
1718: if (yydebug)
1719: printf("yydebug: after reduction, shifting from state %d \
1720: to state %d\n", *yyssp, yystate);
1721: #endif
1722: if (yyssp >= yyss + yystacksize - 1)
1723: {
1724: goto yyoverflow;
1725: }
1726: *++yyssp = yystate;
1727: *++yyvsp = yyval;
1728: goto yyloop;
1729: yyoverflow:
1730: yyerror("yacc stack overflow");
1731: yyabort:
1732: return (1);
1733: yyaccept:
1734: return (0);
1735: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.