crypto/heimdal/appl/ftp/ftpd/ftpcmd.y

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