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