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