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

   1 /* A Bison parser, made by GNU Bison 2.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free Software Foundation, Inc.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 /* As a special exception, you may create a larger work that contains
  24    part or all of the Bison parser skeleton and distribute that work
  25    under terms of your choice, so long as that work isn't itself a
  26    parser generator using the skeleton or a modified version thereof
  27    as a parser skeleton.  Alternatively, if you modify or redistribute
  28    the parser skeleton itself, you may (at your option) remove this
  29    special exception, which will cause the skeleton and the resulting
  30    Bison output files to be licensed under the GNU General Public
  31    License without this special exception.
  32
  33    This special exception was added by the Free Software Foundation in
  34    version 2.2 of Bison.  */
  35
  36 /* C LALR(1) parser skeleton written by Richard Stallman, by
  37    simplifying the original so-called "semantic" parser.  */
  38
  39 /* All symbols defined below should begin with yy or YY, to avoid
  40    infringing on user name space.  This should be done even for local
  41    variables, as they might otherwise be expanded by user macros.
  42    There are some unavoidable exceptions within include files to
  43    define necessary library symbols; they are noted "INFRINGES ON
  44    USER NAME SPACE" below.  */
  45
  46 /* Identify Bison output.  */
  47 #define YYBISON 1
  48
  49 /* Bison version.  */
  50 #define YYBISON_VERSION "2.3"
  51
  52 /* Skeleton name.  */
  53 #define YYSKELETON_NAME "yacc.c"
  54
  55 /* Pure parsers.  */
  56 #define YYPURE 0
  57
  58 /* Using locations.  */
  59 #define YYLSP_NEEDED 0
  60
  61
  62
  63 /* Tokens.  */
  64 #ifndef YYTOKENTYPE
  65 # define YYTOKENTYPE
  66    /* Put the tokens into the symbol table, so that GDB and other debuggers
  67       know about them.  */
  68    enum yytokentype {
  69      A = 258,
  70      B = 259,
  71      C = 260,
  72      E = 261,
  73      F = 262,
  74      I = 263,
  75      L = 264,
  76      N = 265,
  77      P = 266,
  78      R = 267,
  79      S = 268,
  80      T = 269,
  81      SP = 270,
  82      CRLF = 271,
  83      COMMA = 272,
  84      USER = 273,
  85      PASS = 274,
  86      ACCT = 275,
  87      REIN = 276,
  88      QUIT = 277,
  89      PORT = 278,
  90      PASV = 279,
  91      TYPE = 280,
  92      STRU = 281,
  93      MODE = 282,
  94      RETR = 283,
  95      STOR = 284,
  96      APPE = 285,
  97      MLFL = 286,
  98      MAIL = 287,
  99      MSND = 288,
 100      MSOM = 289,
 101      MSAM = 290,
 102      MRSQ = 291,
 103      MRCP = 292,
 104      ALLO = 293,
 105      REST = 294,
 106      RNFR = 295,
 107      RNTO = 296,
 108      ABOR = 297,
 109      DELE = 298,
 110      CWD = 299,
 111      LIST = 300,
 112      NLST = 301,
 113      SITE = 302,
 114      sTAT = 303,
 115      HELP = 304,
 116      NOOP = 305,
 117      MKD = 306,
 118      RMD = 307,
 119      PWD = 308,
 120      CDUP = 309,
 121      STOU = 310,
 122      SMNT = 311,
 123      SYST = 312,
 124      SIZE = 313,
 125      MDTM = 314,
 126      EPRT = 315,
 127      EPSV = 316,
 128      UMASK = 317,
 129      IDLE = 318,
 130      CHMOD = 319,
 131      AUTH = 320,
 132      ADAT = 321,
 133      PROT = 322,
 134      PBSZ = 323,
 135      CCC = 324,
 136      MIC = 325,
 137      CONF = 326,
 138      ENC = 327,
 139      KAUTH = 328,
 140      KLIST = 329,
 141      KDESTROY = 330,
 142      KRBTKFILE = 331,
 143      AFSLOG = 332,
 144      LOCATE = 333,
 145      URL = 334,
 146      FEAT = 335,
 147      OPTS = 336,
 148      LEXERR = 337,
 149      STRING = 338,
 150      NUMBER = 339
 151    };
 152 #endif
 153 /* Tokens.  */
 154 #define A 258
 155 #define B 259
 156 #define C 260
 157 #define E 261
 158 #define F 262
 159 #define I 263
 160 #define L 264
 161 #define N 265
 162 #define P 266
 163 #define R 267
 164 #define S 268
 165 #define T 269
 166 #define SP 270
 167 #define CRLF 271
 168 #define COMMA 272
 169 #define USER 273
 170 #define PASS 274
 171 #define ACCT 275
 172 #define REIN 276
 173 #define QUIT 277
 174 #define PORT 278
 175 #define PASV 279
 176 #define TYPE 280
 177 #define STRU 281
 178 #define MODE 282
 179 #define RETR 283
 180 #define STOR 284
 181 #define APPE 285
 182 #define MLFL 286
 183 #define MAIL 287
 184 #define MSND 288
 185 #define MSOM 289
 186 #define MSAM 290
 187 #define MRSQ 291
 188 #define MRCP 292
 189 #define ALLO 293
 190 #define REST 294
 191 #define RNFR 295
 192 #define RNTO 296
 193 #define ABOR 297
 194 #define DELE 298
 195 #define CWD 299
 196 #define LIST 300
 197 #define NLST 301
 198 #define SITE 302
 199 #define sTAT 303
 200 #define HELP 304
 201 #define NOOP 305
 202 #define MKD 306
 203 #define RMD 307
 204 #define PWD 308
 205 #define CDUP 309
 206 #define STOU 310
 207 #define SMNT 311
 208 #define SYST 312
 209 #define SIZE 313
 210 #define MDTM 314
 211 #define EPRT 315
 212 #define EPSV 316
 213 #define UMASK 317
 214 #define IDLE 318
 215 #define CHMOD 319
 216 #define AUTH 320
 217 #define ADAT 321
 218 #define PROT 322
 219 #define PBSZ 323
 220 #define CCC 324
 221 #define MIC 325
 222 #define CONF 326
 223 #define ENC 327
 224 #define KAUTH 328
 225 #define KLIST 329
 226 #define KDESTROY 330
 227 #define KRBTKFILE 331
 228 #define AFSLOG 332
 229 #define LOCATE 333
 230 #define URL 334
 231 #define FEAT 335
 232 #define OPTS 336
 233 #define LEXERR 337
 234 #define STRING 338
 235 #define NUMBER 339
 236
 237
 238
 239
 240 /* Copy the first part of user declarations.  */
 241 #line 43 "ftpcmd.y"
 242
 243
 244 #include "ftpd_locl.h"
 245 RCSID("$Id: ftpcmd.y 15677 2005-07-19 18:33:08Z lha $");
 246
 247 off_t   restart_point;
 248
 249 static  int hasyyerrored;
 250
 251
 252 static  int cmd_type;
 253 static  int cmd_form;
 254 static  int cmd_bytesz;
 255 char    cbuf[64*1024];
 256 char    *fromname;
 257
 258 struct tab {
 259         char    *name;
 260         short   token;
 261         short   state;
 262         short   implemented;    /* 1 if command is implemented */
 263         char    *help;
 264 };
 265
 266 extern struct tab cmdtab[];
 267 extern struct tab sitetab[];
 268
 269 static char             *copy (char *);
 270 static void              help (struct tab *, char *);
 271 static struct tab *
 272                          lookup (struct tab *, char *);
 273 static void              sizecmd (char *);
 274 static RETSIGTYPE        toolong (int);
 275 static int               yylex (void);
 276
 277 /* This is for bison */
 278
 279 #if !defined(alloca) && !defined(HAVE_ALLOCA)
 280 #define alloca(x) malloc(x)
 281 #endif
 282
 283
 284
 285 /* Enabling traces.  */
 286 #ifndef YYDEBUG
 287 # define YYDEBUG 0
 288 #endif
 289
 290 /* Enabling verbose error messages.  */
 291 #ifdef YYERROR_VERBOSE
 292 # undef YYERROR_VERBOSE
 293 # define YYERROR_VERBOSE 1
 294 #else
 295 # define YYERROR_VERBOSE 0
 296 #endif
 297
 298 /* Enabling the token table.  */
 299 #ifndef YYTOKEN_TABLE
 300 # define YYTOKEN_TABLE 0
 301 #endif
 302
 303 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 304 typedef union YYSTYPE
 305 #line 86 "ftpcmd.y"
 306 {
 307         int     i;
 308         char   *s;
 309 }
 310 /* Line 193 of yacc.c.  */
 311 #line 312 "ftpcmd.c"
 312         YYSTYPE;
 313 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 314 # define YYSTYPE_IS_DECLARED 1
 315 # define YYSTYPE_IS_TRIVIAL 1
 316 #endif
 317
 318
 319
 320 /* Copy the second part of user declarations.  */
 321
 322
 323 /* Line 216 of yacc.c.  */
 324 #line 325 "ftpcmd.c"
 325
 326 #ifdef short
 327 # undef short
 328 #endif
 329
 330 #ifdef YYTYPE_UINT8
 331 typedef YYTYPE_UINT8 yytype_uint8;
 332 #else
 333 typedef unsigned char yytype_uint8;
 334 #endif
 335
 336 #ifdef YYTYPE_INT8
 337 typedef YYTYPE_INT8 yytype_int8;
 338 #elif (defined __STDC__ || defined __C99__FUNC__ \
 339      || defined __cplusplus || defined _MSC_VER)
 340 typedef signed char yytype_int8;
 341 #else
 342 typedef short int yytype_int8;
 343 #endif
 344
 345 #ifdef YYTYPE_UINT16
 346 typedef YYTYPE_UINT16 yytype_uint16;
 347 #else
 348 typedef unsigned short int yytype_uint16;
 349 #endif
 350
 351 #ifdef YYTYPE_INT16
 352 typedef YYTYPE_INT16 yytype_int16;
 353 #else
 354 typedef short int yytype_int16;
 355 #endif
 356
 357 #ifndef YYSIZE_T
 358 # ifdef __SIZE_TYPE__
 359 #  define YYSIZE_T __SIZE_TYPE__
 360 # elif defined size_t
 361 #  define YYSIZE_T size_t
 362 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 363      || defined __cplusplus || defined _MSC_VER)
 364 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 365 #  define YYSIZE_T size_t
 366 # else
 367 #  define YYSIZE_T unsigned int
 368 # endif
 369 #endif
 370
 371 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 372
 373 #ifndef YY_
 374 # if defined YYENABLE_NLS && YYENABLE_NLS
 375 #  if ENABLE_NLS
 376 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 377 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 378 #  endif
 379 # endif
 380 # ifndef YY_
 381 #  define YY_(msgid) msgid
 382 # endif
 383 #endif
 384
 385 /* Suppress unused-variable warnings by "using" E.  */
 386 #if ! defined lint || defined __GNUC__
 387 # define YYUSE(e) ((void) (e))
 388 #else
 389 # define YYUSE(e) /* empty */
 390 #endif
 391
 392 /* Identity function, used to suppress warnings about constant conditions.  */
 393 #ifndef lint
 394 # define YYID(n) (n)
 395 #else
 396 #if (defined __STDC__ || defined __C99__FUNC__ \
 397      || defined __cplusplus || defined _MSC_VER)
 398 static int
 399 YYID (int i)
 400 #else
 401 static int
 402 YYID (i)
 403     int i;
 404 #endif
 405 {
 406   return i;
 407 }
 408 #endif
 409
 410 #if ! defined yyoverflow || YYERROR_VERBOSE
 411
 412 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 413
 414 # ifdef YYSTACK_USE_ALLOCA
 415 #  if YYSTACK_USE_ALLOCA
 416 #   ifdef __GNUC__
 417 #    define YYSTACK_ALLOC __builtin_alloca
 418 #   elif defined __BUILTIN_VA_ARG_INCR
 419 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 420 #   elif defined _AIX
 421 #    define YYSTACK_ALLOC __alloca
 422 #   elif defined _MSC_VER
 423 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 424 #    define alloca _alloca
 425 #   else
 426 #    define YYSTACK_ALLOC alloca
 427 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 428      || defined __cplusplus || defined _MSC_VER)
 429 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 430 #     ifndef _STDLIB_H
 431 #      define _STDLIB_H 1
 432 #     endif
 433 #    endif
 434 #   endif
 435 #  endif
 436 # endif
 437
 438 # ifdef YYSTACK_ALLOC
 439    /* Pacify GCC's `empty if-body' warning.  */
 440 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 441 #  ifndef YYSTACK_ALLOC_MAXIMUM
 442     /* The OS might guarantee only one guard page at the bottom of the stack,
 443        and a page size can be as small as 4096 bytes.  So we cannot safely
 444        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 445        to allow for a few compiler-allocated temporary stack slots.  */
 446 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 447 #  endif
 448 # else
 449 #  define YYSTACK_ALLOC YYMALLOC
 450 #  define YYSTACK_FREE YYFREE
 451 #  ifndef YYSTACK_ALLOC_MAXIMUM
 452 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 453 #  endif
 454 #  if (defined __cplusplus && ! defined _STDLIB_H \
 455        && ! ((defined YYMALLOC || defined malloc) \
 456              && (defined YYFREE || defined free)))
 457 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 458 #   ifndef _STDLIB_H
 459 #    define _STDLIB_H 1
 460 #   endif
 461 #  endif
 462 #  ifndef YYMALLOC
 463 #   define YYMALLOC malloc
 464 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 465      || defined __cplusplus || defined _MSC_VER)
 466 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 467 #   endif
 468 #  endif
 469 #  ifndef YYFREE
 470 #   define YYFREE free
 471 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 472      || defined __cplusplus || defined _MSC_VER)
 473 void free (void *); /* INFRINGES ON USER NAME SPACE */
 474 #   endif
 475 #  endif
 476 # endif
 477 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 478
 479
 480 #if (! defined yyoverflow \
 481      && (! defined __cplusplus \
 482          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 483
 484 /* A type that is properly aligned for any stack member.  */
 485 union yyalloc
 486 {
 487   yytype_int16 yyss;
 488   YYSTYPE yyvs;
 489   };
 490
 491 /* The size of the maximum gap between one aligned stack and the next.  */
 492 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 493
 494 /* The size of an array large to enough to hold all stacks, each with
 495    N elements.  */
 496 # define YYSTACK_BYTES(N) \
 497      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 498       + YYSTACK_GAP_MAXIMUM)
 499
 500 /* Copy COUNT objects from FROM to TO.  The source and destination do
 501    not overlap.  */
 502 # ifndef YYCOPY
 503 #  if defined __GNUC__ && 1 < __GNUC__
 504 #   define YYCOPY(To, From, Count) \
 505       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 506 #  else
 507 #   define YYCOPY(To, From, Count)              \
 508       do                                        \
 509         {                                       \
 510           YYSIZE_T yyi;                         \
 511           for (yyi = 0; yyi < (Count); yyi++)   \
 512             (To)[yyi] = (From)[yyi];            \
 513         }                                       \
 514       while (YYID (0))
 515 #  endif
 516 # endif
 517
 518 /* Relocate STACK from its old location to the new one.  The
 519    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 520    elements in the stack, and YYPTR gives the new location of the
 521    stack.  Advance YYPTR to a properly aligned location for the next
 522    stack.  */
 523 # define YYSTACK_RELOCATE(Stack)                                        \
 524     do                                                                  \
 525       {                                                                 \
 526         YYSIZE_T yynewbytes;                                            \
 527         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 528         Stack = &yyptr->Stack;                                          \
 529         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 530         yyptr += yynewbytes / sizeof (*yyptr);                          \
 531       }                                                                 \
 532     while (YYID (0))
 533
 534 #endif
 535
 536 /* YYFINAL -- State number of the termination state.  */
 537 #define YYFINAL  2
 538 /* YYLAST -- Last index in YYTABLE.  */
 539 #define YYLAST   327
 540
 541 /* YYNTOKENS -- Number of terminals.  */
 542 #define YYNTOKENS  85
 543 /* YYNNTS -- Number of nonterminals.  */
 544 #define YYNNTS  18
 545 /* YYNRULES -- Number of rules.  */
 546 #define YYNRULES  98
 547 /* YYNRULES -- Number of states.  */
 548 #define YYNSTATES  317
 549
 550 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 551 #define YYUNDEFTOK  2
 552 #define YYMAXUTOK   339
 553
 554 #define YYTRANSLATE(YYX)                                                \
 555   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 556
 557 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 558 static const yytype_uint8 yytranslate[] =
 559 {
 560        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 561        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 562        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 563        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 564        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 565        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 566        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 567        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 568        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 569        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 570        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 571        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 573        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 574        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 576        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 578        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 579        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 580        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 581        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 582        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 583        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 584        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 585        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 586        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 587       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 588       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 589       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 590       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
 591       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
 592       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
 593       75,    76,    77,    78,    79,    80,    81,    82,    83,    84
 594 };
 595
 596 #if YYDEBUG
 597 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 598    YYRHS.  */
 599 static const yytype_uint16 yyprhs[] =
 600 {
 601        0,     0,     3,     4,     7,    10,    16,    22,    28,    34,
 602       38,    42,    48,    54,    60,    66,    72,    82,    88,    94,
 603      100,   104,   110,   114,   120,   126,   130,   136,   142,   146,
 604      150,   156,   160,   166,   170,   176,   182,   186,   190,   194,
 605      200,   206,   214,   220,   228,   238,   244,   252,   260,   266,
 606      272,   280,   286,   294,   302,   308,   314,   318,   324,   330,
 607      334,   337,   343,   349,   354,   359,   365,   371,   375,   380,
 608      385,   390,   392,   393,   395,   397,   409,   411,   413,   415,
 609      417,   421,   423,   427,   429,   431,   435,   438,   440,   442,
 610      444,   446,   448,   450,   452,   454,   456,   458,   460
 611 };
 612
 613 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 614 static const yytype_int8 yyrhs[] =
 615 {
 616       86,     0,    -1,    -1,    86,    87,    -1,    86,    88,    -1,
 617       18,    15,    89,    16,   102,    -1,    19,    15,    90,    16,
 618      102,    -1,    23,    15,    92,    16,   102,    -1,    60,    15,
 619       83,    16,   102,    -1,    24,    16,   101,    -1,    61,    16,
 620      101,    -1,    61,    15,    83,    16,   101,    -1,    25,    15,
 621       94,    16,   102,    -1,    26,    15,    95,    16,   102,    -1,
 622       27,    15,    96,    16,   102,    -1,    38,    15,    84,    16,
 623      102,    -1,    38,    15,    84,    15,    12,    15,    84,    16,
 624      102,    -1,    28,    15,    97,    16,   101,    -1,    29,    15,
 625       97,    16,   101,    -1,    30,    15,    97,    16,   101,    -1,
 626       46,    16,   101,    -1,    46,    15,    83,    16,   101,    -1,
 627       45,    16,   101,    -1,    45,    15,    97,    16,   101,    -1,
 628       48,    15,    97,    16,   101,    -1,    48,    16,   102,    -1,
 629       43,    15,    97,    16,   100,    -1,    41,    15,    97,    16,
 630      100,    -1,    42,    16,   102,    -1,    44,    16,   101,    -1,
 631       44,    15,    97,    16,   101,    -1,    49,    16,   102,    -1,
 632       49,    15,    83,    16,   102,    -1,    50,    16,   102,    -1,
 633       51,    15,    97,    16,   101,    -1,    52,    15,    97,    16,
 634      100,    -1,    53,    16,   101,    -1,    54,    16,   101,    -1,
 635       80,    16,   102,    -1,    81,    15,    83,    16,   102,    -1,
 636       47,    15,    49,    16,   102,    -1,    47,    15,    49,    15,
 637       83,    16,   102,    -1,    47,    15,    62,    16,   101,    -1,
 638       47,    15,    62,    15,    99,    16,   100,    -1,    47,    15,
 639       64,    15,    99,    15,    97,    16,   100,    -1,    47,    15,
 640       63,    16,   102,    -1,    47,    15,    63,    15,    84,    16,
 641      102,    -1,    47,    15,    73,    15,    83,    16,   101,    -1,
 642       47,    15,    74,    16,   101,    -1,    47,    15,    75,    16,
 643      101,    -1,    47,    15,    76,    15,    83,    16,   101,    -1,
 644       47,    15,    77,    16,   101,    -1,    47,    15,    77,    15,
 645       83,    16,   101,    -1,    47,    15,    78,    15,    83,    16,
 646      101,    -1,    47,    15,    79,    16,   102,    -1,    55,    15,
 647       97,    16,   101,    -1,    57,    16,   102,    -1,    58,    15,
 648       97,    16,   101,    -1,    59,    15,    97,    16,   101,    -1,
 649       22,    16,   102,    -1,     1,    16,    -1,    40,    15,    97,
 650       16,   100,    -1,    39,    15,    91,    16,   102,    -1,    65,
 651       15,    83,    16,    -1,    66,    15,    83,    16,    -1,    68,
 652       15,    84,    16,   102,    -1,    67,    15,    83,    16,   102,
 653       -1,    69,    16,   102,    -1,    70,    15,    83,    16,    -1,
 654       71,    15,    83,    16,    -1,    72,    15,    83,    16,    -1,
 655       83,    -1,    -1,    83,    -1,    84,    -1,    84,    17,    84,
 656       17,    84,    17,    84,    17,    84,    17,    84,    -1,    10,
 657       -1,    14,    -1,     5,    -1,     3,    -1,     3,    15,    93,
 658       -1,     6,    -1,     6,    15,    93,    -1,     8,    -1,     9,
 659       -1,     9,    15,    91,    -1,     9,    91,    -1,     7,    -1,
 660       12,    -1,    11,    -1,    13,    -1,     4,    -1,     5,    -1,
 661       98,    -1,    83,    -1,    84,    -1,   101,    -1,   102,    -1,
 662       -1
 663 };
 664
 665 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 666 static const yytype_uint16 yyrline[] =
 667 {
 668        0,   129,   129,   131,   136,   140,   146,   153,   164,   170,
 669      175,   180,   186,   223,   237,   251,   257,   263,   272,   281,
 670      290,   295,   304,   309,   315,   322,   327,   334,   348,   353,
 671      358,   365,   370,   387,   392,   399,   406,   411,   416,   426,
 672      433,   438,   443,   451,   464,   478,   485,   502,   525,   530,
 673      539,   552,   563,   576,   583,   588,   595,   613,   630,   658,
 674      665,   671,   681,   691,   696,   701,   706,   711,   716,   721,
 675      726,   734,   739,   742,   746,   750,   763,   767,   771,   778,
 676      783,   788,   793,   798,   802,   807,   813,   821,   825,   829,
 677      836,   840,   844,   851,   879,   883,   909,   917,   928
 678 };
 679 #endif
 680
 681 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 682 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 683    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 684 static const char *const yytname[] =
 685 {
 686   "$end", "error", "$undefined", "A", "B", "C", "E", "F", "I", "L", "N",
 687   "P", "R", "S", "T", "SP", "CRLF", "COMMA", "USER", "PASS", "ACCT",
 688   "REIN", "QUIT", "PORT", "PASV", "TYPE", "STRU", "MODE", "RETR", "STOR",
 689   "APPE", "MLFL", "MAIL", "MSND", "MSOM", "MSAM", "MRSQ", "MRCP", "ALLO",
 690   "REST", "RNFR", "RNTO", "ABOR", "DELE", "CWD", "LIST", "NLST", "SITE",
 691   "sTAT", "HELP", "NOOP", "MKD", "RMD", "PWD", "CDUP", "STOU", "SMNT",
 692   "SYST", "SIZE", "MDTM", "EPRT", "EPSV", "UMASK", "IDLE", "CHMOD", "AUTH",
 693   "ADAT", "PROT", "PBSZ", "CCC", "MIC", "CONF", "ENC", "KAUTH", "KLIST",
 694   "KDESTROY", "KRBTKFILE", "AFSLOG", "LOCATE", "URL", "FEAT", "OPTS",
 695   "LEXERR", "STRING", "NUMBER", "$accept", "cmd_list", "cmd", "rcmd",
 696   "username", "password", "byte_size", "host_port", "form_code",
 697   "type_code", "struct_code", "mode_code", "pathname", "pathstring",
 698   "octal_number", "check_login_no_guest", "check_login", "check_secure", 0
 699 };
 700 #endif
 701
 702 # ifdef YYPRINT
 703 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 704    token YYLEX-NUM.  */
 705 static const yytype_uint16 yytoknum[] =
 706 {
 707        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 708      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 709      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
 710      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
 711      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
 712      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
 713      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
 714      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
 715      335,   336,   337,   338,   339
 716 };
 717 # endif
 718
 719 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 720 static const yytype_uint8 yyr1[] =
 721 {
 722        0,    85,    86,    86,    86,    87,    87,    87,    87,    87,
 723       87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
 724       87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
 725       87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
 726       87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
 727       87,    87,    87,    87,    87,    87,    87,    87,    87,    87,
 728       87,    88,    88,    88,    88,    88,    88,    88,    88,    88,
 729       88,    89,    90,    90,    91,    92,    93,    93,    93,    94,
 730       94,    94,    94,    94,    94,    94,    94,    95,    95,    95,
 731       96,    96,    96,    97,    98,    99,   100,   101,   102
 732 };
 733
 734 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 735 static const yytype_uint8 yyr2[] =
 736 {
 737        0,     2,     0,     2,     2,     5,     5,     5,     5,     3,
 738        3,     5,     5,     5,     5,     5,     9,     5,     5,     5,
 739        3,     5,     3,     5,     5,     3,     5,     5,     3,     3,
 740        5,     3,     5,     3,     5,     5,     3,     3,     3,     5,
 741        5,     7,     5,     7,     9,     5,     7,     7,     5,     5,
 742        7,     5,     7,     7,     5,     5,     3,     5,     5,     3,
 743        2,     5,     5,     4,     4,     5,     5,     3,     4,     4,
 744        4,     1,     0,     1,     1,    11,     1,     1,     1,     1,
 745        3,     1,     3,     1,     1,     3,     2,     1,     1,     1,
 746        1,     1,     1,     1,     1,     1,     1,     1,     0
 747 };
 748
 749 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 750    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 751    means the default is an error.  */
 752 static const yytype_uint8 yydefact[] =
 753 {
 754        2,     0,     1,     0,     0,     0,     0,     0,     0,     0,
 755        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 756        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 757        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 758        0,     0,     0,     0,     0,     0,     0,     0,     3,     4,
 759       60,     0,    72,    98,     0,    98,     0,     0,     0,     0,
 760        0,     0,     0,     0,     0,     0,    98,     0,     0,    98,
 761        0,    98,     0,    98,     0,     0,    98,     0,    98,    98,
 762        0,     0,    98,    98,     0,    98,     0,     0,     0,     0,
 763       98,     0,     0,     0,     0,    98,     0,     0,     0,    98,
 764        0,    71,     0,    73,     0,    59,     0,     0,     9,    97,
 765       79,    81,    83,    84,     0,    87,    89,    88,     0,    91,
 766       92,    90,     0,    94,     0,    93,     0,     0,     0,    74,
 767        0,     0,     0,    28,     0,     0,    29,     0,    22,     0,
 768       20,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 769        0,     0,     0,    25,     0,    31,    33,     0,     0,    36,
 770       37,     0,    56,     0,     0,     0,     0,    10,     0,     0,
 771        0,     0,    67,     0,     0,     0,    38,     0,    98,    98,
 772        0,    98,     0,     0,     0,    86,    98,    98,    98,    98,
 773       98,    98,     0,    98,    98,    98,    98,    98,    98,    98,
 774       98,     0,    98,     0,    98,     0,    98,     0,     0,    98,
 775       98,     0,     0,    98,     0,    98,    98,    98,    98,    98,
 776       98,    98,    98,    98,    98,    63,    64,    98,    98,    68,
 777       69,    70,    98,     5,     6,     0,     7,    78,    76,    77,
 778       80,    82,    85,    12,    13,    14,    17,    18,    19,     0,
 779       15,    62,    61,    96,    27,    26,    30,    23,    21,     0,
 780       40,    95,     0,    42,     0,    45,     0,     0,    48,    49,
 781        0,     0,    51,     0,    54,    24,    32,    34,    35,    55,
 782       57,    58,     8,    11,    66,    65,    39,     0,     0,    98,
 783       98,    98,     0,    98,    98,    98,    98,     0,     0,    41,
 784       43,    46,     0,    47,    50,    52,    53,     0,    98,    98,
 785        0,    16,    44,     0,     0,     0,    75
 786 };
 787
 788 /* YYDEFGOTO[NTERM-NUM].  */
 789 static const yytype_int16 yydefgoto[] =
 790 {
 791       -1,     1,    48,    49,   102,   104,   130,   107,   240,   114,
 792      118,   122,   124,   125,   262,   252,   253,   109
 793 };
 794
 795 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 796    STATE-NUM.  */
 797 #define YYPACT_NINF -196
 798 static const yytype_int16 yypact[] =
 799 {
 800     -196,   246,  -196,     3,    13,    20,    11,    24,    21,    26,
 801       30,    45,    66,    67,    68,    69,    70,    71,    72,    76,
 802       73,    -7,    -5,    15,    78,    28,    32,    80,    79,    82,
 803       83,    91,    93,    94,    96,    97,    98,    38,   100,   101,
 804      102,   103,   104,   106,   107,   108,   111,   109,  -196,  -196,
 805     -196,   -66,    36,  -196,    14,  -196,    12,    22,     1,    46,
 806       46,    46,    25,    48,    46,    46,  -196,    46,    46,  -196,
 807       46,  -196,    53,  -196,    27,    46,  -196,    55,  -196,  -196,
 808       46,    46,  -196,  -196,    46,  -196,    46,    46,    56,    59,
 809     -196,    60,    61,    62,    63,  -196,    65,    77,    85,  -196,
 810       86,  -196,   114,  -196,   115,  -196,   120,   130,  -196,  -196,
 811      135,   136,  -196,   -11,   138,  -196,  -196,  -196,   139,  -196,
 812     -196,  -196,   143,  -196,   145,  -196,   147,   156,    47,  -196,
 813      157,   162,   165,  -196,   166,   168,  -196,   170,  -196,   174,
 814     -196,    49,    52,    54,   137,   177,   178,   179,   181,    64,
 815      182,   183,   184,  -196,   185,  -196,  -196,   186,   187,  -196,
 816     -196,   188,  -196,   189,   190,   191,   192,  -196,   193,   194,
 817      195,   196,  -196,   197,   198,   199,  -196,   200,  -196,  -196,
 818      133,  -196,     2,     2,    48,  -196,  -196,  -196,  -196,  -196,
 819     -196,  -196,   206,  -196,  -196,  -196,  -196,  -196,  -196,  -196,
 820     -196,   110,  -196,   140,  -196,   141,  -196,   140,   144,  -196,
 821     -196,   146,   148,  -196,   149,  -196,  -196,  -196,  -196,  -196,
 822     -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,
 823     -196,  -196,  -196,  -196,  -196,   202,  -196,  -196,  -196,  -196,
 824     -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,   205,
 825     -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,  -196,   207,
 826     -196,  -196,   210,  -196,   212,  -196,   215,   217,  -196,  -196,
 827      218,   219,  -196,   221,  -196,  -196,  -196,  -196,  -196,  -196,
 828     -196,  -196,  -196,  -196,  -196,  -196,  -196,   155,   158,  -196,
 829     -196,  -196,    46,  -196,  -196,  -196,  -196,   204,   224,  -196,
 830     -196,  -196,   225,  -196,  -196,  -196,  -196,   159,  -196,  -196,
 831      227,  -196,  -196,   161,   231,   167,  -196
 832 };
 833
 834 /* YYPGOTO[NTERM-NUM].  */
 835 static const yytype_int16 yypgoto[] =
 836 {
 837     -196,  -196,  -196,  -196,  -196,  -196,  -110,  -196,    39,  -196,
 838     -196,  -196,    -9,  -196,    42,  -195,   -33,   -53
 839 };
 840
 841 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 842    positive, shift that token.  If negative, reduce the rule which
 843    number is the opposite.  If zero, do what YYDEFACT says.
 844    If YYTABLE_NINF, syntax error.  */
 845 #define YYTABLE_NINF -1
 846 static const yytype_uint16 yytable[] =
 847 {
 848      105,   254,   255,   185,   184,   119,   120,   237,    68,    69,
 849       70,    71,   238,   133,   121,   110,   239,   101,   111,    50,
 850      112,   113,   108,   153,   278,   155,   156,    53,    51,   115,
 851       72,    73,   162,   116,   117,    52,   136,    55,   138,    54,
 852      140,    56,   172,    75,    76,    57,   176,    77,    78,   159,
 853      160,   126,   127,    89,    90,   131,   132,   167,   134,   135,
 854       58,   137,   192,   193,   201,   202,   152,   203,   204,   205,
 855      206,   157,   158,   129,   242,   161,   141,   163,   164,   212,
 856      213,    59,    60,    61,    62,    63,    64,    65,    67,   142,
 857      143,   144,    66,    74,    80,   300,    79,    81,   106,    82,
 858      145,   146,   147,   148,   149,   150,   151,    83,    84,   128,
 859       85,    86,    87,    88,   312,    91,    92,    93,    94,   103,
 860       95,    96,    97,    98,   100,   233,   234,    99,   236,   123,
 861      178,   179,   129,   243,   244,   245,   139,   180,   154,   165,
 862      250,   251,   166,   168,   169,   170,   181,   171,   173,   260,
 863      182,   183,   207,   265,   186,   187,   246,   247,   248,   188,
 864      174,   189,   274,   190,   276,   256,   257,   258,   175,   177,
 865      282,   263,   191,   194,   284,   285,   268,   269,   195,   286,
 866      272,   196,   197,   275,   198,   277,   199,   279,   280,   281,
 867      200,   283,   208,   259,   209,   210,   211,   214,     0,   215,
 868      216,   217,   218,   219,   220,   221,   222,   223,   224,   225,
 869      226,   227,   228,   229,   230,   231,   232,   235,   249,   287,
 870      288,   307,   241,   289,   261,   264,   290,   267,   291,   270,
 871      292,   271,   273,   293,   294,   295,   299,   296,   301,   297,
 872      308,   309,   298,   310,   313,   314,     2,     3,   315,   266,
 873        0,   316,     0,     0,     0,   311,     0,     0,     0,     0,
 874      303,   304,   305,   306,     4,     5,     0,     0,     6,     7,
 875        8,     9,    10,    11,    12,    13,    14,     0,     0,     0,
 876        0,     0,     0,   302,    15,    16,    17,    18,    19,    20,
 877       21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
 878       31,    32,     0,    33,    34,    35,    36,    37,     0,     0,
 879        0,    38,    39,    40,    41,    42,    43,    44,    45,     0,
 880        0,     0,     0,     0,     0,     0,    46,    47
 881 };
 882
 883 static const yytype_int16 yycheck[] =
 884 {
 885       53,   196,   197,   113,    15,     4,     5,     5,    15,    16,
 886       15,    16,    10,    66,    13,     3,    14,    83,     6,    16,
 887        8,     9,    55,    76,   219,    78,    79,    16,    15,     7,
 888       15,    16,    85,    11,    12,    15,    69,    16,    71,    15,
 889       73,    15,    95,    15,    16,    15,    99,    15,    16,    82,
 890       83,    60,    61,    15,    16,    64,    65,    90,    67,    68,
 891       15,    70,    15,    16,    15,    16,    75,    15,    16,    15,
 892       16,    80,    81,    84,   184,    84,    49,    86,    87,    15,
 893       16,    15,    15,    15,    15,    15,    15,    15,    15,    62,
 894       63,    64,    16,    15,    15,   290,    16,    15,    84,    16,
 895       73,    74,    75,    76,    77,    78,    79,    16,    15,    84,
 896       16,    15,    15,    15,   309,    15,    15,    15,    15,    83,
 897       16,    15,    15,    15,    15,   178,   179,    16,   181,    83,
 898       16,    16,    84,   186,   187,   188,    83,    17,    83,    83,
 899      193,   194,    83,    83,    83,    83,    16,    84,    83,   202,
 900       15,    15,    15,   206,    16,    16,   189,   190,   191,    16,
 901       83,    16,   215,    16,   217,   198,   199,   200,    83,    83,
 902      223,   204,    16,    16,   227,   228,   209,   210,    16,   232,
 903      213,    16,    16,   216,    16,   218,    16,   220,   221,   222,
 904       16,   224,    15,    83,    16,    16,    15,    15,    -1,    16,
 905       16,    16,    16,    16,    16,    16,    16,    16,    16,    16,
 906       16,    16,    16,    16,    16,    16,    16,    84,    12,    17,
 907       15,    17,   183,    16,    84,    84,    16,    83,    16,    83,
 908       15,    83,    83,    16,    16,    16,   289,    16,   291,    84,
 909       16,    16,    84,    84,    17,    84,     0,     1,    17,   207,
 910       -1,    84,    -1,    -1,    -1,   308,    -1,    -1,    -1,    -1,
 911      293,   294,   295,   296,    18,    19,    -1,    -1,    22,    23,
 912       24,    25,    26,    27,    28,    29,    30,    -1,    -1,    -1,
 913       -1,    -1,    -1,   292,    38,    39,    40,    41,    42,    43,
 914       44,    45,    46,    47,    48,    49,    50,    51,    52,    53,
 915       54,    55,    -1,    57,    58,    59,    60,    61,    -1,    -1,
 916       -1,    65,    66,    67,    68,    69,    70,    71,    72,    -1,
 917       -1,    -1,    -1,    -1,    -1,    -1,    80,    81
 918 };
 919
 920 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 921    symbol of state STATE-NUM.  */
 922 static const yytype_uint8 yystos[] =
 923 {
 924        0,    86,     0,     1,    18,    19,    22,    23,    24,    25,
 925       26,    27,    28,    29,    30,    38,    39,    40,    41,    42,
 926       43,    44,    45,    46,    47,    48,    49,    50,    51,    52,
 927       53,    54,    55,    57,    58,    59,    60,    61,    65,    66,
 928       67,    68,    69,    70,    71,    72,    80,    81,    87,    88,
 929       16,    15,    15,    16,    15,    16,    15,    15,    15,    15,
 930       15,    15,    15,    15,    15,    15,    16,    15,    15,    16,
 931       15,    16,    15,    16,    15,    15,    16,    15,    16,    16,
 932       15,    15,    16,    16,    15,    16,    15,    15,    15,    15,
 933       16,    15,    15,    15,    15,    16,    15,    15,    15,    16,
 934       15,    83,    89,    83,    90,   102,    84,    92,   101,   102,
 935        3,     6,     8,     9,    94,     7,    11,    12,    95,     4,
 936        5,    13,    96,    83,    97,    98,    97,    97,    84,    84,
 937       91,    97,    97,   102,    97,    97,   101,    97,   101,    83,
 938      101,    49,    62,    63,    64,    73,    74,    75,    76,    77,
 939       78,    79,    97,   102,    83,   102,   102,    97,    97,   101,
 940      101,    97,   102,    97,    97,    83,    83,   101,    83,    83,
 941       83,    84,   102,    83,    83,    83,   102,    83,    16,    16,
 942       17,    16,    15,    15,    15,    91,    16,    16,    16,    16,
 943       16,    16,    15,    16,    16,    16,    16,    16,    16,    16,
 944       16,    15,    16,    15,    16,    15,    16,    15,    15,    16,
 945       16,    15,    15,    16,    15,    16,    16,    16,    16,    16,
 946       16,    16,    16,    16,    16,    16,    16,    16,    16,    16,
 947       16,    16,    16,   102,   102,    84,   102,     5,    10,    14,
 948       93,    93,    91,   102,   102,   102,   101,   101,   101,    12,
 949      102,   102,   100,   101,   100,   100,   101,   101,   101,    83,
 950      102,    84,    99,   101,    84,   102,    99,    83,   101,   101,
 951       83,    83,   101,    83,   102,   101,   102,   101,   100,   101,
 952      101,   101,   102,   101,   102,   102,   102,    17,    15,    16,
 953       16,    16,    15,    16,    16,    16,    16,    84,    84,   102,
 954      100,   102,    97,   101,   101,   101,   101,    17,    16,    16,
 955       84,   102,   100,    17,    84,    17,    84
 956 };
 957
 958 #define yyerrok         (yyerrstatus = 0)
 959 #define yyclearin       (yychar = YYEMPTY)
 960 #define YYEMPTY         (-2)
 961 #define YYEOF           0
 962
 963 #define YYACCEPT        goto yyacceptlab
 964 #define YYABORT         goto yyabortlab
 965 #define YYERROR         goto yyerrorlab
 966
 967
 968 /* Like YYERROR except do call yyerror.  This remains here temporarily
 969    to ease the transition to the new meaning of YYERROR, for GCC.
 970    Once GCC version 2 has supplanted version 1, this can go.  */
 971
 972 #define YYFAIL          goto yyerrlab
 973
 974 #define YYRECOVERING()  (!!yyerrstatus)
 975
 976 #define YYBACKUP(Token, Value)                                  \
 977 do                                                              \
 978   if (yychar == YYEMPTY && yylen == 1)                          \
 979     {                                                           \
 980       yychar = (Token);                                         \
 981       yylval = (Value);                                         \
 982       yytoken = YYTRANSLATE (yychar);                           \
 983       YYPOPSTACK (1);                                           \
 984       goto yybackup;                                            \
 985     }                                                           \
 986   else                                                          \
 987     {                                                           \
 988       yyerror (YY_("syntax error: cannot back up")); \
 989       YYERROR;                                                  \
 990     }                                                           \
 991 while (YYID (0))
 992
 993
 994 #define YYTERROR        1
 995 #define YYERRCODE       256
 996
 997
 998 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 999    If N is 0, then set CURRENT to the empty location which ends
1000    the previous symbol: RHS[0] (always defined).  */
1001
1002 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1003 #ifndef YYLLOC_DEFAULT
1004 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
1005     do                                                                  \
1006       if (YYID (N))                                                    \
1007         {                                                               \
1008           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
1009           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
1010           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
1011           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
1012         }                                                               \
1013       else                                                              \
1014         {                                                               \
1015           (Current).first_line   = (Current).last_line   =              \
1016             YYRHSLOC (Rhs, 0).last_line;                                \
1017           (Current).first_column = (Current).last_column =              \
1018             YYRHSLOC (Rhs, 0).last_column;                              \
1019         }                                                               \
1020     while (YYID (0))
1021 #endif
1022
1023
1024 /* YY_LOCATION_PRINT -- Print the location on the stream.
1025    This macro was not mandated originally: define only if we know
1026    we won't break user code: when these are the locations we know.  */
1027
1028 #ifndef YY_LOCATION_PRINT
1029 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1030 #  define YY_LOCATION_PRINT(File, Loc)                  \
1031      fprintf (File, "%d.%d-%d.%d",                      \
1032               (Loc).first_line, (Loc).first_column,     \
1033               (Loc).last_line,  (Loc).last_column)
1034 # else
1035 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1036 # endif
1037 #endif
1038
1039
1040 /* YYLEX -- calling `yylex' with the right arguments.  */
1041
1042 #ifdef YYLEX_PARAM
1043 # define YYLEX yylex (YYLEX_PARAM)
1044 #else
1045 # define YYLEX yylex ()
1046 #endif
1047
1048 /* Enable debugging if requested.  */
1049 #if YYDEBUG
1050
1051 # ifndef YYFPRINTF
1052 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1053 #  define YYFPRINTF fprintf
1054 # endif
1055
1056 # define YYDPRINTF(Args)                        \
1057 do {                                            \
1058   if (yydebug)                                  \
1059     YYFPRINTF Args;                             \
1060 } while (YYID (0))
1061
1062 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1063 do {                                                                      \
1064   if (yydebug)                                                            \
1065     {                                                                     \
1066       YYFPRINTF (stderr, "%s ", Title);                                   \
1067       yy_symbol_print (stderr,                                            \
1068                   Type, Value); \
1069       YYFPRINTF (stderr, "\n");                                           \
1070     }                                                                     \
1071 } while (YYID (0))
1072
1073
1074 /*--------------------------------.
1075 | Print this symbol on YYOUTPUT.  |
1076 `--------------------------------*/
1077
1078 /*ARGSUSED*/
1079 #if (defined __STDC__ || defined __C99__FUNC__ \
1080      || defined __cplusplus || defined _MSC_VER)
1081 static void
1082 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1083 #else
1084 static void
1085 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1086     FILE *yyoutput;
1087     int yytype;
1088     YYSTYPE const * const yyvaluep;
1089 #endif
1090 {
1091   if (!yyvaluep)
1092     return;
1093 # ifdef YYPRINT
1094   if (yytype < YYNTOKENS)
1095     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1096 # else
1097   YYUSE (yyoutput);
1098 # endif
1099   switch (yytype)
1100     {
1101       default:
1102         break;
1103     }
1104 }
1105
1106
1107 /*--------------------------------.
1108 | Print this symbol on YYOUTPUT.  |
1109 `--------------------------------*/
1110
1111 #if (defined __STDC__ || defined __C99__FUNC__ \
1112      || defined __cplusplus || defined _MSC_VER)
1113 static void
1114 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1115 #else
1116 static void
1117 yy_symbol_print (yyoutput, yytype, yyvaluep)
1118     FILE *yyoutput;
1119     int yytype;
1120     YYSTYPE const * const yyvaluep;
1121 #endif
1122 {
1123   if (yytype < YYNTOKENS)
1124     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1125   else
1126     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1127
1128   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1129   YYFPRINTF (yyoutput, ")");
1130 }
1131
1132 /*------------------------------------------------------------------.
1133 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1134 | TOP (included).                                                   |
1135 `------------------------------------------------------------------*/
1136
1137 #if (defined __STDC__ || defined __C99__FUNC__ \
1138      || defined __cplusplus || defined _MSC_VER)
1139 static void
1140 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1141 #else
1142 static void
1143 yy_stack_print (bottom, top)
1144     yytype_int16 *bottom;
1145     yytype_int16 *top;
1146 #endif
1147 {
1148   YYFPRINTF (stderr, "Stack now");
1149   for (; bottom <= top; ++bottom)
1150     YYFPRINTF (stderr, " %d", *bottom);
1151   YYFPRINTF (stderr, "\n");
1152 }
1153
1154 # define YY_STACK_PRINT(Bottom, Top)                            \
1155 do {                                                            \
1156   if (yydebug)                                                  \
1157     yy_stack_print ((Bottom), (Top));                           \
1158 } while (YYID (0))
1159
1160
1161 /*------------------------------------------------.
1162 | Report that the YYRULE is going to be reduced.  |
1163 `------------------------------------------------*/
1164
1165 #if (defined __STDC__ || defined __C99__FUNC__ \
1166      || defined __cplusplus || defined _MSC_VER)
1167 static void
1168 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1169 #else
1170 static void
1171 yy_reduce_print (yyvsp, yyrule)
1172     YYSTYPE *yyvsp;
1173     int yyrule;
1174 #endif
1175 {
1176   int yynrhs = yyr2[yyrule];
1177   int yyi;
1178   unsigned long int yylno = yyrline[yyrule];
1179   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1180              yyrule - 1, yylno);
1181   /* The symbols being reduced.  */
1182   for (yyi = 0; yyi < yynrhs; yyi++)
1183     {
1184       fprintf (stderr, "   $%d = ", yyi + 1);
1185       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1186                        &(yyvsp[(yyi + 1) - (yynrhs)])
1187                                        );
1188       fprintf (stderr, "\n");
1189     }
1190 }
1191
1192 # define YY_REDUCE_PRINT(Rule)          \
1193 do {                                    \
1194   if (yydebug)                          \
1195     yy_reduce_print (yyvsp, Rule); \
1196 } while (YYID (0))
1197
1198 /* Nonzero means print parse trace.  It is left uninitialized so that
1199    multiple parsers can coexist.  */
1200 int yydebug;
1201 #else /* !YYDEBUG */
1202 # define YYDPRINTF(Args)
1203 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1204 # define YY_STACK_PRINT(Bottom, Top)
1205 # define YY_REDUCE_PRINT(Rule)
1206 #endif /* !YYDEBUG */
1207
1208
1209 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1210 #ifndef YYINITDEPTH
1211 # define YYINITDEPTH 200
1212 #endif
1213
1214 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1215    if the built-in stack extension method is used).
1216
1217    Do not make this value too large; the results are undefined if
1218    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1219    evaluated with infinite-precision integer arithmetic.  */
1220
1221 #ifndef YYMAXDEPTH
1222 # define YYMAXDEPTH 10000
1223 #endif
1224
1225 \f
1226
1227 #if YYERROR_VERBOSE
1228
1229 # ifndef yystrlen
1230 #  if defined __GLIBC__ && defined _STRING_H
1231 #   define yystrlen strlen
1232 #  else
1233 /* Return the length of YYSTR.  */
1234 #if (defined __STDC__ || defined __C99__FUNC__ \
1235      || defined __cplusplus || defined _MSC_VER)
1236 static YYSIZE_T
1237 yystrlen (const char *yystr)
1238 #else
1239 static YYSIZE_T
1240 yystrlen (yystr)
1241     const char *yystr;
1242 #endif
1243 {
1244   YYSIZE_T yylen;
1245   for (yylen = 0; yystr[yylen]; yylen++)
1246     continue;
1247   return yylen;
1248 }
1249 #  endif
1250 # endif
1251
1252 # ifndef yystpcpy
1253 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1254 #   define yystpcpy stpcpy
1255 #  else
1256 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1257    YYDEST.  */
1258 #if (defined __STDC__ || defined __C99__FUNC__ \
1259      || defined __cplusplus || defined _MSC_VER)
1260 static char *
1261 yystpcpy (char *yydest, const char *yysrc)
1262 #else
1263 static char *
1264 yystpcpy (yydest, yysrc)
1265     char *yydest;
1266     const char *yysrc;
1267 #endif
1268 {
1269   char *yyd = yydest;
1270   const char *yys = yysrc;
1271
1272   while ((*yyd++ = *yys++) != '\0')
1273     continue;
1274
1275   return yyd - 1;
1276 }
1277 #  endif
1278 # endif
1279
1280 # ifndef yytnamerr
1281 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1282    quotes and backslashes, so that it's suitable for yyerror.  The
1283    heuristic is that double-quoting is unnecessary unless the string
1284    contains an apostrophe, a comma, or backslash (other than
1285    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1286    null, do not copy; instead, return the length of what the result
1287    would have been.  */
1288 static YYSIZE_T
1289 yytnamerr (char *yyres, const char *yystr)
1290 {
1291   if (*yystr == '"')
1292     {
1293       YYSIZE_T yyn = 0;
1294       char const *yyp = yystr;
1295
1296       for (;;)
1297         switch (*++yyp)
1298           {
1299           case '\'':
1300           case ',':
1301             goto do_not_strip_quotes;
1302
1303           case '\\':
1304             if (*++yyp != '\\')
1305               goto do_not_strip_quotes;
1306             /* Fall through.  */
1307           default:
1308             if (yyres)
1309               yyres[yyn] = *yyp;
1310             yyn++;
1311             break;
1312
1313           case '"':
1314             if (yyres)
1315               yyres[yyn] = '\0';
1316             return yyn;
1317           }
1318     do_not_strip_quotes: ;
1319     }
1320
1321   if (! yyres)
1322     return yystrlen (yystr);
1323
1324   return yystpcpy (yyres, yystr) - yyres;
1325 }
1326 # endif
1327
1328 /* Copy into YYRESULT an error message about the unexpected token
1329    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1330    including the terminating null byte.  If YYRESULT is null, do not
1331    copy anything; just return the number of bytes that would be
1332    copied.  As a special case, return 0 if an ordinary "syntax error"
1333    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1334    size calculation.  */
1335 static YYSIZE_T
1336 yysyntax_error (char *yyresult, int yystate, int yychar)
1337 {
1338   int yyn = yypact[yystate];
1339
1340   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1341     return 0;
1342   else
1343     {
1344       int yytype = YYTRANSLATE (yychar);
1345       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1346       YYSIZE_T yysize = yysize0;
1347       YYSIZE_T yysize1;
1348       int yysize_overflow = 0;
1349       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1350       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1351       int yyx;
1352
1353 # if 0
1354       /* This is so xgettext sees the translatable formats that are
1355          constructed on the fly.  */
1356       YY_("syntax error, unexpected %s");
1357       YY_("syntax error, unexpected %s, expecting %s");
1358       YY_("syntax error, unexpected %s, expecting %s or %s");
1359       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1360       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1361 # endif
1362       char *yyfmt;
1363       char const *yyf;
1364       static char const yyunexpected[] = "syntax error, unexpected %s";
1365       static char const yyexpecting[] = ", expecting %s";
1366       static char const yyor[] = " or %s";
1367       char yyformat[sizeof yyunexpected
1368                     + sizeof yyexpecting - 1
1369                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1370                        * (sizeof yyor - 1))];
1371       char const *yyprefix = yyexpecting;
1372
1373       /* Start YYX at -YYN if negative to avoid negative indexes in
1374          YYCHECK.  */
1375       int yyxbegin = yyn < 0 ? -yyn : 0;
1376
1377       /* Stay within bounds of both yycheck and yytname.  */
1378       int yychecklim = YYLAST - yyn + 1;
1379       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1380       int yycount = 1;
1381
1382       yyarg[0] = yytname[yytype];
1383       yyfmt = yystpcpy (yyformat, yyunexpected);
1384
1385       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1386         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1387           {
1388             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1389               {
1390                 yycount = 1;
1391                 yysize = yysize0;
1392                 yyformat[sizeof yyunexpected - 1] = '\0';
1393                 break;
1394               }
1395             yyarg[yycount++] = yytname[yyx];
1396             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1397             yysize_overflow |= (yysize1 < yysize);
1398             yysize = yysize1;
1399             yyfmt = yystpcpy (yyfmt, yyprefix);
1400             yyprefix = yyor;
1401           }
1402
1403       yyf = YY_(yyformat);
1404       yysize1 = yysize + yystrlen (yyf);
1405       yysize_overflow |= (yysize1 < yysize);
1406       yysize = yysize1;
1407
1408       if (yysize_overflow)
1409         return YYSIZE_MAXIMUM;
1410
1411       if (yyresult)
1412         {
1413           /* Avoid sprintf, as that infringes on the user's name space.
1414              Don't have undefined behavior even if the translation
1415              produced a string with the wrong number of "%s"s.  */
1416           char *yyp = yyresult;
1417           int yyi = 0;
1418           while ((*yyp = *yyf) != '\0')
1419             {
1420               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1421                 {
1422                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1423                   yyf += 2;
1424                 }
1425               else
1426                 {
1427                   yyp++;
1428                   yyf++;
1429                 }
1430             }
1431         }
1432       return yysize;
1433     }
1434 }
1435 #endif /* YYERROR_VERBOSE */
1436 \f
1437
1438 /*-----------------------------------------------.
1439 | Release the memory associated to this symbol.  |
1440 `-----------------------------------------------*/
1441
1442 /*ARGSUSED*/
1443 #if (defined __STDC__ || defined __C99__FUNC__ \
1444      || defined __cplusplus || defined _MSC_VER)
1445 static void
1446 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1447 #else
1448 static void
1449 yydestruct (yymsg, yytype, yyvaluep)
1450     const char *yymsg;
1451     int yytype;
1452     YYSTYPE *yyvaluep;
1453 #endif
1454 {
1455   YYUSE (yyvaluep);
1456
1457   if (!yymsg)
1458     yymsg = "Deleting";
1459   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1460
1461   switch (yytype)
1462     {
1463
1464       default:
1465         break;
1466     }
1467 }
1468 \f
1469
1470 /* Prevent warnings from -Wmissing-prototypes.  */
1471
1472 #ifdef YYPARSE_PARAM
1473 #if defined __STDC__ || defined __cplusplus
1474 int yyparse (void *YYPARSE_PARAM);
1475 #else
1476 int yyparse ();
1477 #endif
1478 #else /* ! YYPARSE_PARAM */
1479 #if defined __STDC__ || defined __cplusplus
1480 int yyparse (void);
1481 #else
1482 int yyparse ();
1483 #endif
1484 #endif /* ! YYPARSE_PARAM */
1485
1486
1487
1488 /* The look-ahead symbol.  */
1489 int yychar;
1490
1491 /* The semantic value of the look-ahead symbol.  */
1492 YYSTYPE yylval;
1493
1494 /* Number of syntax errors so far.  */
1495 int yynerrs;
1496
1497
1498
1499 /*----------.
1500 | yyparse.  |
1501 `----------*/
1502
1503 #ifdef YYPARSE_PARAM
1504 #if (defined __STDC__ || defined __C99__FUNC__ \
1505      || defined __cplusplus || defined _MSC_VER)
1506 int
1507 yyparse (void *YYPARSE_PARAM)
1508 #else
1509 int
1510 yyparse (YYPARSE_PARAM)
1511     void *YYPARSE_PARAM;
1512 #endif
1513 #else /* ! YYPARSE_PARAM */
1514 #if (defined __STDC__ || defined __C99__FUNC__ \
1515      || defined __cplusplus || defined _MSC_VER)
1516 int
1517 yyparse (void)
1518 #else
1519 int
1520 yyparse ()
1521
1522 #endif
1523 #endif
1524 {
1525
1526   int yystate;
1527   int yyn;
1528   int yyresult;
1529   /* Number of tokens to shift before error messages enabled.  */
1530   int yyerrstatus;
1531   /* Look-ahead token as an internal (translated) token number.  */
1532   int yytoken = 0;
1533 #if YYERROR_VERBOSE
1534   /* Buffer for error messages, and its allocated size.  */
1535   char yymsgbuf[128];
1536   char *yymsg = yymsgbuf;
1537   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1538 #endif
1539
1540   /* Three stacks and their tools:
1541      `yyss': related to states,
1542      `yyvs': related to semantic values,
1543      `yyls': related to locations.
1544
1545      Refer to the stacks thru separate pointers, to allow yyoverflow
1546      to reallocate them elsewhere.  */
1547
1548   /* The state stack.  */
1549   yytype_int16 yyssa[YYINITDEPTH];
1550   yytype_int16 *yyss = yyssa;
1551   yytype_int16 *yyssp;
1552
1553   /* The semantic value stack.  */
1554   YYSTYPE yyvsa[YYINITDEPTH];
1555   YYSTYPE *yyvs = yyvsa;
1556   YYSTYPE *yyvsp;
1557
1558
1559
1560 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1561
1562   YYSIZE_T yystacksize = YYINITDEPTH;
1563
1564   /* The variables used to return semantic value and location from the
1565      action routines.  */
1566   YYSTYPE yyval;
1567
1568
1569   /* The number of symbols on the RHS of the reduced rule.
1570      Keep to zero when no symbol should be popped.  */
1571   int yylen = 0;
1572
1573   YYDPRINTF ((stderr, "Starting parse\n"));
1574
1575   yystate = 0;
1576   yyerrstatus = 0;
1577   yynerrs = 0;
1578   yychar = YYEMPTY;             /* Cause a token to be read.  */
1579
1580   /* Initialize stack pointers.
1581      Waste one element of value and location stack
1582      so that they stay on the same level as the state stack.
1583      The wasted elements are never initialized.  */
1584
1585   yyssp = yyss;
1586   yyvsp = yyvs;
1587
1588   goto yysetstate;
1589
1590 /*------------------------------------------------------------.
1591 | yynewstate -- Push a new state, which is found in yystate.  |
1592 `------------------------------------------------------------*/
1593  yynewstate:
1594   /* In all cases, when you get here, the value and location stacks
1595      have just been pushed.  So pushing a state here evens the stacks.  */
1596   yyssp++;
1597
1598  yysetstate:
1599   *yyssp = yystate;
1600
1601   if (yyss + yystacksize - 1 <= yyssp)
1602     {
1603       /* Get the current used size of the three stacks, in elements.  */
1604       YYSIZE_T yysize = yyssp - yyss + 1;
1605
1606 #ifdef yyoverflow
1607       {
1608         /* Give user a chance to reallocate the stack.  Use copies of
1609            these so that the &'s don't force the real ones into
1610            memory.  */
1611         YYSTYPE *yyvs1 = yyvs;
1612         yytype_int16 *yyss1 = yyss;
1613
1614
1615         /* Each stack pointer address is followed by the size of the
1616            data in use in that stack, in bytes.  This used to be a
1617            conditional around just the two extra args, but that might
1618            be undefined if yyoverflow is a macro.  */
1619         yyoverflow (YY_("memory exhausted"),
1620                     &yyss1, yysize * sizeof (*yyssp),
1621                     &yyvs1, yysize * sizeof (*yyvsp),
1622
1623                     &yystacksize);
1624
1625         yyss = yyss1;
1626         yyvs = yyvs1;
1627       }
1628 #else /* no yyoverflow */
1629 # ifndef YYSTACK_RELOCATE
1630       goto yyexhaustedlab;
1631 # else
1632       /* Extend the stack our own way.  */
1633       if (YYMAXDEPTH <= yystacksize)
1634         goto yyexhaustedlab;
1635       yystacksize *= 2;
1636       if (YYMAXDEPTH < yystacksize)
1637         yystacksize = YYMAXDEPTH;
1638
1639       {
1640         yytype_int16 *yyss1 = yyss;
1641         union yyalloc *yyptr =
1642           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1643         if (! yyptr)
1644           goto yyexhaustedlab;
1645         YYSTACK_RELOCATE (yyss);
1646         YYSTACK_RELOCATE (yyvs);
1647
1648 #  undef YYSTACK_RELOCATE
1649         if (yyss1 != yyssa)
1650           YYSTACK_FREE (yyss1);
1651       }
1652 # endif
1653 #endif /* no yyoverflow */
1654
1655       yyssp = yyss + yysize - 1;
1656       yyvsp = yyvs + yysize - 1;
1657
1658
1659       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1660                   (unsigned long int) yystacksize));
1661
1662       if (yyss + yystacksize - 1 <= yyssp)
1663         YYABORT;
1664     }
1665
1666   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1667
1668   goto yybackup;
1669
1670 /*-----------.
1671 | yybackup.  |
1672 `-----------*/
1673 yybackup:
1674
1675   /* Do appropriate processing given the current state.  Read a
1676      look-ahead token if we need one and don't already have one.  */
1677
1678   /* First try to decide what to do without reference to look-ahead token.  */
1679   yyn = yypact[yystate];
1680   if (yyn == YYPACT_NINF)
1681     goto yydefault;
1682
1683   /* Not known => get a look-ahead token if don't already have one.  */
1684
1685   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1686   if (yychar == YYEMPTY)
1687     {
1688       YYDPRINTF ((stderr, "Reading a token: "));
1689       yychar = YYLEX;
1690     }
1691
1692   if (yychar <= YYEOF)
1693     {
1694       yychar = yytoken = YYEOF;
1695       YYDPRINTF ((stderr, "Now at end of input.\n"));
1696     }
1697   else
1698     {
1699       yytoken = YYTRANSLATE (yychar);
1700       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1701     }
1702
1703   /* If the proper action on seeing token YYTOKEN is to reduce or to
1704      detect an error, take that action.  */
1705   yyn += yytoken;
1706   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1707     goto yydefault;
1708   yyn = yytable[yyn];
1709   if (yyn <= 0)
1710     {
1711       if (yyn == 0 || yyn == YYTABLE_NINF)
1712         goto yyerrlab;
1713       yyn = -yyn;
1714       goto yyreduce;
1715     }
1716
1717   if (yyn == YYFINAL)
1718     YYACCEPT;
1719
1720   /* Count tokens shifted since error; after three, turn off error
1721      status.  */
1722   if (yyerrstatus)
1723     yyerrstatus--;
1724
1725   /* Shift the look-ahead token.  */
1726   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1727
1728   /* Discard the shifted token unless it is eof.  */
1729   if (yychar != YYEOF)
1730     yychar = YYEMPTY;
1731
1732   yystate = yyn;
1733   *++yyvsp = yylval;
1734
1735   goto yynewstate;
1736
1737
1738 /*-----------------------------------------------------------.
1739 | yydefault -- do the default action for the current state.  |
1740 `-----------------------------------------------------------*/
1741 yydefault:
1742   yyn = yydefact[yystate];
1743   if (yyn == 0)
1744     goto yyerrlab;
1745   goto yyreduce;
1746
1747
1748 /*-----------------------------.
1749 | yyreduce -- Do a reduction.  |
1750 `-----------------------------*/
1751 yyreduce:
1752   /* yyn is the number of a rule to reduce with.  */
1753   yylen = yyr2[yyn];
1754
1755   /* If YYLEN is nonzero, implement the default value of the action:
1756      `$$ = $1'.
1757
1758      Otherwise, the following line sets YYVAL to garbage.
1759      This behavior is undocumented and Bison
1760      users should not rely upon it.  Assigning to YYVAL
1761      unconditionally makes the parser a bit smaller, and it avoids a
1762      GCC warning that YYVAL may be used uninitialized.  */
1763   yyval = yyvsp[1-yylen];
1764
1765
1766   YY_REDUCE_PRINT (yyn);
1767   switch (yyn)
1768     {
1769         case 3:
1770 #line 132 "ftpcmd.y"
1771     {
1772                         fromname = (char *) 0;
1773                         restart_point = (off_t) 0;
1774                 }
1775     break;
1776
1777   case 5:
1778 #line 141 "ftpcmd.y"
1779     {
1780                     if ((yyvsp[(5) - (5)].i))
1781                         user((yyvsp[(3) - (5)].s));
1782                     free((yyvsp[(3) - (5)].s));
1783                 }
1784     break;
1785
1786   case 6:
1787 #line 147 "ftpcmd.y"
1788     {
1789                     if ((yyvsp[(5) - (5)].i))
1790                         pass((yyvsp[(3) - (5)].s));
1791                     memset ((yyvsp[(3) - (5)].s), 0, strlen((yyvsp[(3) - (5)].s)));
1792                     free((yyvsp[(3) - (5)].s));
1793                 }
1794     break;
1795
1796   case 7:
1797 #line 154 "ftpcmd.y"
1798     {
1799                     if ((yyvsp[(5) - (5)].i)) {
1800                         usedefault = 0;
1801                         if (pdata >= 0) {
1802                                 close(pdata);
1803                                 pdata = -1;
1804                         }
1805                         reply(200, "PORT command successful.");
1806                     }
1807                 }
1808     break;
1809
1810   case 8:
1811 #line 165 "ftpcmd.y"
1812     {
1813                     if ((yyvsp[(5) - (5)].i))
1814                         eprt ((yyvsp[(3) - (5)].s));
1815                     free ((yyvsp[(3) - (5)].s));
1816                 }
1817     break;
1818
1819   case 9:
1820 #line 171 "ftpcmd.y"
1821     {
1822                     if((yyvsp[(3) - (3)].i))
1823                         pasv ();
1824                 }
1825     break;
1826
1827   case 10:
1828 #line 176 "ftpcmd.y"
1829     {
1830                     if((yyvsp[(3) - (3)].i))
1831                         epsv (NULL);
1832                 }
1833     break;
1834
1835   case 11:
1836 #line 181 "ftpcmd.y"
1837     {
1838                     if((yyvsp[(5) - (5)].i))
1839                         epsv ((yyvsp[(3) - (5)].s));
1840                     free ((yyvsp[(3) - (5)].s));
1841                 }
1842     break;
1843
1844   case 12:
1845 #line 187 "ftpcmd.y"
1846     {
1847                     if ((yyvsp[(5) - (5)].i)) {
1848                         switch (cmd_type) {
1849
1850                         case TYPE_A:
1851                                 if (cmd_form == FORM_N) {
1852                                         reply(200, "Type set to A.");
1853                                         type = cmd_type;
1854                                         form = cmd_form;
1855                                 } else
1856                                         reply(504, "Form must be N.");
1857                                 break;
1858
1859                         case TYPE_E:
1860                                 reply(504, "Type E not implemented.");
1861                                 break;
1862
1863                         case TYPE_I:
1864                                 reply(200, "Type set to I.");
1865                                 type = cmd_type;
1866                                 break;
1867
1868                         case TYPE_L:
1869 #if NBBY == 8
1870                                 if (cmd_bytesz == 8) {
1871                                         reply(200,
1872                                             "Type set to L (byte size 8).");
1873                                         type = cmd_type;
1874                                 } else
1875                                         reply(504, "Byte size must be 8.");
1876 #else /* NBBY == 8 */
1877                                 UNIMPLEMENTED for NBBY != 8
1878 #endif /* NBBY == 8 */
1879                         }
1880                     }
1881                 }
1882     break;
1883
1884   case 13:
1885 #line 224 "ftpcmd.y"
1886     {
1887                     if ((yyvsp[(5) - (5)].i)) {
1888                         switch ((yyvsp[(3) - (5)].i)) {
1889
1890                         case STRU_F:
1891                                 reply(200, "STRU F ok.");
1892                                 break;
1893
1894                         default:
1895                                 reply(504, "Unimplemented STRU type.");
1896                         }
1897                     }
1898                 }
1899     break;
1900
1901   case 14:
1902 #line 238 "ftpcmd.y"
1903     {
1904                     if ((yyvsp[(5) - (5)].i)) {
1905                         switch ((yyvsp[(3) - (5)].i)) {
1906
1907                         case MODE_S:
1908                                 reply(200, "MODE S ok.");
1909                                 break;
1910
1911                         default:
1912                                 reply(502, "Unimplemented MODE type.");
1913                         }
1914                     }
1915                 }
1916     break;
1917
1918   case 15:
1919 #line 252 "ftpcmd.y"
1920     {
1921                     if ((yyvsp[(5) - (5)].i)) {
1922                         reply(202, "ALLO command ignored.");
1923                     }
1924                 }
1925     break;
1926
1927   case 16:
1928 #line 258 "ftpcmd.y"
1929     {
1930                     if ((yyvsp[(9) - (9)].i)) {
1931                         reply(202, "ALLO command ignored.");
1932                     }
1933                 }
1934     break;
1935
1936   case 17:
1937 #line 264 "ftpcmd.y"
1938     {
1939                         char *name = (yyvsp[(3) - (5)].s);
1940
1941                         if ((yyvsp[(5) - (5)].i) && name != NULL)
1942                                 retrieve(0, name);
1943                         if (name != NULL)
1944                                 free(name);
1945                 }
1946     break;
1947
1948   case 18:
1949 #line 273 "ftpcmd.y"
1950     {
1951                         char *name = (yyvsp[(3) - (5)].s);
1952
1953                         if ((yyvsp[(5) - (5)].i) && name != NULL)
1954                                 do_store(name, "w", 0);
1955                         if (name != NULL)
1956                                 free(name);
1957                 }
1958     break;
1959
1960   case 19:
1961 #line 282 "ftpcmd.y"
1962     {
1963                         char *name = (yyvsp[(3) - (5)].s);
1964
1965                         if ((yyvsp[(5) - (5)].i) && name != NULL)
1966                                 do_store(name, "a", 0);
1967                         if (name != NULL)
1968                                 free(name);
1969                 }
1970     break;
1971
1972   case 20:
1973 #line 291 "ftpcmd.y"
1974     {
1975                         if ((yyvsp[(3) - (3)].i))
1976                                 send_file_list(".");
1977                 }
1978     break;
1979
1980   case 21:
1981 #line 296 "ftpcmd.y"
1982     {
1983                         char *name = (yyvsp[(3) - (5)].s);
1984
1985                         if ((yyvsp[(5) - (5)].i) && name != NULL)
1986                                 send_file_list(name);
1987                         if (name != NULL)
1988                                 free(name);
1989                 }
1990     break;
1991
1992   case 22:
1993 #line 305 "ftpcmd.y"
1994     {
1995                     if((yyvsp[(3) - (3)].i))
1996                         list_file(".");
1997                 }
1998     break;
1999
2000   case 23:
2001 #line 310 "ftpcmd.y"
2002     {
2003                     if((yyvsp[(5) - (5)].i))
2004                         list_file((yyvsp[(3) - (5)].s));
2005                     free((yyvsp[(3) - (5)].s));
2006                 }
2007     break;
2008
2009   case 24:
2010 #line 316 "ftpcmd.y"
2011     {
2012                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2013                                 statfilecmd((yyvsp[(3) - (5)].s));
2014                         if ((yyvsp[(3) - (5)].s) != NULL)
2015                                 free((yyvsp[(3) - (5)].s));
2016                 }
2017     break;
2018
2019   case 25:
2020 #line 323 "ftpcmd.y"
2021     {
2022                     if ((yyvsp[(3) - (3)].i))
2023                         statcmd();
2024                 }
2025     break;
2026
2027   case 26:
2028 #line 328 "ftpcmd.y"
2029     {
2030                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2031                                 do_delete((yyvsp[(3) - (5)].s));
2032                         if ((yyvsp[(3) - (5)].s) != NULL)
2033                                 free((yyvsp[(3) - (5)].s));
2034                 }
2035     break;
2036
2037   case 27:
2038 #line 335 "ftpcmd.y"
2039     {
2040                         if((yyvsp[(5) - (5)].i)){
2041                                 if (fromname) {
2042                                         renamecmd(fromname, (yyvsp[(3) - (5)].s));
2043                                         free(fromname);
2044                                         fromname = (char *) 0;
2045                                 } else {
2046                                         reply(503, "Bad sequence of commands.");
2047                                 }
2048                         }
2049                         if ((yyvsp[(3) - (5)].s) != NULL)
2050                                 free((yyvsp[(3) - (5)].s));
2051                 }
2052     break;
2053
2054   case 28:
2055 #line 349 "ftpcmd.y"
2056     {
2057                     if ((yyvsp[(3) - (3)].i))
2058                         reply(225, "ABOR command successful.");
2059                 }
2060     break;
2061
2062   case 29:
2063 #line 354 "ftpcmd.y"
2064     {
2065                         if ((yyvsp[(3) - (3)].i))
2066                                 cwd(pw->pw_dir);
2067                 }
2068     break;
2069
2070   case 30:
2071 #line 359 "ftpcmd.y"
2072     {
2073                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2074                                 cwd((yyvsp[(3) - (5)].s));
2075                         if ((yyvsp[(3) - (5)].s) != NULL)
2076                                 free((yyvsp[(3) - (5)].s));
2077                 }
2078     break;
2079
2080   case 31:
2081 #line 366 "ftpcmd.y"
2082     {
2083                     if ((yyvsp[(3) - (3)].i))
2084                         help(cmdtab, (char *) 0);
2085                 }
2086     break;
2087
2088   case 32:
2089 #line 371 "ftpcmd.y"
2090     {
2091                     if ((yyvsp[(5) - (5)].i)) {
2092                         char *cp = (yyvsp[(3) - (5)].s);
2093
2094                         if (strncasecmp(cp, "SITE", 4) == 0) {
2095                                 cp = (yyvsp[(3) - (5)].s) + 4;
2096                                 if (*cp == ' ')
2097                                         cp++;
2098                                 if (*cp)
2099                                         help(sitetab, cp);
2100                                 else
2101                                         help(sitetab, (char *) 0);
2102                         } else
2103                                 help(cmdtab, (yyvsp[(3) - (5)].s));
2104                     }
2105                 }
2106     break;
2107
2108   case 33:
2109 #line 388 "ftpcmd.y"
2110     {
2111                     if ((yyvsp[(3) - (3)].i))
2112                         reply(200, "NOOP command successful.");
2113                 }
2114     break;
2115
2116   case 34:
2117 #line 393 "ftpcmd.y"
2118     {
2119                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2120                                 makedir((yyvsp[(3) - (5)].s));
2121                         if ((yyvsp[(3) - (5)].s) != NULL)
2122                                 free((yyvsp[(3) - (5)].s));
2123                 }
2124     break;
2125
2126   case 35:
2127 #line 400 "ftpcmd.y"
2128     {
2129                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2130                                 removedir((yyvsp[(3) - (5)].s));
2131                         if ((yyvsp[(3) - (5)].s) != NULL)
2132                                 free((yyvsp[(3) - (5)].s));
2133                 }
2134     break;
2135
2136   case 36:
2137 #line 407 "ftpcmd.y"
2138     {
2139                         if ((yyvsp[(3) - (3)].i))
2140                                 pwd();
2141                 }
2142     break;
2143
2144   case 37:
2145 #line 412 "ftpcmd.y"
2146     {
2147                         if ((yyvsp[(3) - (3)].i))
2148                                 cwd("..");
2149                 }
2150     break;
2151
2152   case 38:
2153 #line 417 "ftpcmd.y"
2154     {
2155                     if ((yyvsp[(3) - (3)].i)) {
2156                         lreply(211, "Supported features:");
2157                         lreply(0, " MDTM");
2158                         lreply(0, " REST STREAM");
2159                         lreply(0, " SIZE");
2160                         reply(211, "End");
2161                     }
2162                 }
2163     break;
2164
2165   case 39:
2166 #line 427 "ftpcmd.y"
2167     {
2168                     if ((yyvsp[(5) - (5)].i))
2169                         reply(501, "Bad options");
2170                     free ((yyvsp[(3) - (5)].s));
2171                 }
2172     break;
2173
2174   case 40:
2175 #line 434 "ftpcmd.y"
2176     {
2177                     if ((yyvsp[(5) - (5)].i))
2178                         help(sitetab, (char *) 0);
2179                 }
2180     break;
2181
2182   case 41:
2183 #line 439 "ftpcmd.y"
2184     {
2185                     if ((yyvsp[(7) - (7)].i))
2186                         help(sitetab, (yyvsp[(5) - (7)].s));
2187                 }
2188     break;
2189
2190   case 42:
2191 #line 444 "ftpcmd.y"
2192     {
2193                         if ((yyvsp[(5) - (5)].i)) {
2194                                 int oldmask = umask(0);
2195                                 umask(oldmask);
2196                                 reply(200, "Current UMASK is %03o", oldmask);
2197                         }
2198                 }
2199     break;
2200
2201   case 43:
2202 #line 452 "ftpcmd.y"
2203     {
2204                         if ((yyvsp[(7) - (7)].i)) {
2205                                 if (((yyvsp[(5) - (7)].i) == -1) || ((yyvsp[(5) - (7)].i) > 0777)) {
2206                                         reply(501, "Bad UMASK value");
2207                                 } else {
2208                                         int oldmask = umask((yyvsp[(5) - (7)].i));
2209                                         reply(200,
2210                                               "UMASK set to %03o (was %03o)",
2211                                               (yyvsp[(5) - (7)].i), oldmask);
2212                                 }
2213                         }
2214                 }
2215     break;
2216
2217   case 44:
2218 #line 465 "ftpcmd.y"
2219     {
2220                         if ((yyvsp[(9) - (9)].i) && (yyvsp[(7) - (9)].s) != NULL) {
2221                                 if ((yyvsp[(5) - (9)].i) > 0777)
2222                                         reply(501,
2223                                 "CHMOD: Mode value must be between 0 and 0777");
2224                                 else if (chmod((yyvsp[(7) - (9)].s), (yyvsp[(5) - (9)].i)) < 0)
2225                                         perror_reply(550, (yyvsp[(7) - (9)].s));
2226                                 else
2227                                         reply(200, "CHMOD command successful.");
2228                         }
2229                         if ((yyvsp[(7) - (9)].s) != NULL)
2230                                 free((yyvsp[(7) - (9)].s));
2231                 }
2232     break;
2233
2234   case 45:
2235 #line 479 "ftpcmd.y"
2236     {
2237                     if ((yyvsp[(5) - (5)].i))
2238                         reply(200,
2239                             "Current IDLE time limit is %d seconds; max %d",
2240                                 ftpd_timeout, maxtimeout);
2241                 }
2242     break;
2243
2244   case 46:
2245 #line 486 "ftpcmd.y"
2246     {
2247                     if ((yyvsp[(7) - (7)].i)) {
2248                         if ((yyvsp[(5) - (7)].i) < 30 || (yyvsp[(5) - (7)].i) > maxtimeout) {
2249                                 reply(501,
2250                         "Maximum IDLE time must be between 30 and %d seconds",
2251                                     maxtimeout);
2252                         } else {
2253                                 ftpd_timeout = (yyvsp[(5) - (7)].i);
2254                                 alarm((unsigned) ftpd_timeout);
2255                                 reply(200,
2256                                     "Maximum IDLE time set to %d seconds",
2257                                     ftpd_timeout);
2258                         }
2259                     }
2260                 }
2261     break;
2262
2263   case 47:
2264 #line 503 "ftpcmd.y"
2265     {
2266 #ifdef KRB4
2267                         char *p;
2268
2269                         if(guest)
2270                                 reply(500, "Can't be done as guest.");
2271                         else{
2272                                 if((yyvsp[(7) - (7)].i) && (yyvsp[(5) - (7)].s) != NULL){
2273                                     p = strpbrk((yyvsp[(5) - (7)].s), " \t");
2274                                     if(p){
2275                                         *p++ = 0;
2276                                         kauth((yyvsp[(5) - (7)].s), p + strspn(p, " \t"));
2277                                     }else
2278                                         kauth((yyvsp[(5) - (7)].s), NULL);
2279                                 }
2280                         }
2281                         if((yyvsp[(5) - (7)].s) != NULL)
2282                             free((yyvsp[(5) - (7)].s));
2283 #else
2284                         reply(500, "Command not implemented.");
2285 #endif
2286                 }
2287     break;
2288
2289   case 48:
2290 #line 526 "ftpcmd.y"
2291     {
2292                     if((yyvsp[(5) - (5)].i))
2293                         klist();
2294                 }
2295     break;
2296
2297   case 49:
2298 #line 531 "ftpcmd.y"
2299     {
2300 #ifdef KRB4
2301                     if((yyvsp[(5) - (5)].i))
2302                         kdestroy();
2303 #else
2304                     reply(500, "Command not implemented.");
2305 #endif
2306                 }
2307     break;
2308
2309   case 50:
2310 #line 540 "ftpcmd.y"
2311     {
2312 #ifdef KRB4
2313                     if(guest)
2314                         reply(500, "Can't be done as guest.");
2315                     else if((yyvsp[(7) - (7)].i) && (yyvsp[(5) - (7)].s))
2316                         krbtkfile((yyvsp[(5) - (7)].s));
2317                     if((yyvsp[(5) - (7)].s))
2318                         free((yyvsp[(5) - (7)].s));
2319 #else
2320                     reply(500, "Command not implemented.");
2321 #endif
2322                 }
2323     break;
2324
2325   case 51:
2326 #line 553 "ftpcmd.y"
2327     {
2328 #if defined(KRB4) || defined(KRB5)
2329                     if(guest)
2330                         reply(500, "Can't be done as guest.");
2331                     else if((yyvsp[(5) - (5)].i))
2332                         afslog(NULL, 0);
2333 #else
2334                     reply(500, "Command not implemented.");
2335 #endif
2336                 }
2337     break;
2338
2339   case 52:
2340 #line 564 "ftpcmd.y"
2341     {
2342 #if defined(KRB4) || defined(KRB5)
2343                     if(guest)
2344                         reply(500, "Can't be done as guest.");
2345                     else if((yyvsp[(7) - (7)].i))
2346                         afslog((yyvsp[(5) - (7)].s), 0);
2347                     if((yyvsp[(5) - (7)].s))
2348                         free((yyvsp[(5) - (7)].s));
2349 #else
2350                     reply(500, "Command not implemented.");
2351 #endif
2352                 }
2353     break;
2354
2355   case 53:
2356 #line 577 "ftpcmd.y"
2357     {
2358                     if((yyvsp[(7) - (7)].i) && (yyvsp[(5) - (7)].s) != NULL)
2359                         find((yyvsp[(5) - (7)].s));
2360                     if((yyvsp[(5) - (7)].s) != NULL)
2361                         free((yyvsp[(5) - (7)].s));
2362                 }
2363     break;
2364
2365   case 54:
2366 #line 584 "ftpcmd.y"
2367     {
2368                     if ((yyvsp[(5) - (5)].i))
2369                         reply(200, "http://www.pdc.kth.se/heimdal/");
2370                 }
2371     break;
2372
2373   case 55:
2374 #line 589 "ftpcmd.y"
2375     {
2376                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2377                                 do_store((yyvsp[(3) - (5)].s), "w", 1);
2378                         if ((yyvsp[(3) - (5)].s) != NULL)
2379                                 free((yyvsp[(3) - (5)].s));
2380                 }
2381     break;
2382
2383   case 56:
2384 #line 596 "ftpcmd.y"
2385     {
2386                     if ((yyvsp[(3) - (3)].i)) {
2387 #if !defined(WIN32) && !defined(__EMX__) && !defined(__OS2__) && !defined(__CYGWIN32__)
2388                         reply(215, "UNIX Type: L%d", NBBY);
2389 #else
2390                         reply(215, "UNKNOWN Type: L%d", NBBY);
2391 #endif
2392                     }
2393                 }
2394     break;
2395
2396   case 57:
2397 #line 614 "ftpcmd.y"
2398     {
2399                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL)
2400                                 sizecmd((yyvsp[(3) - (5)].s));
2401                         if ((yyvsp[(3) - (5)].s) != NULL)
2402                                 free((yyvsp[(3) - (5)].s));
2403                 }
2404     break;
2405
2406   case 58:
2407 #line 631 "ftpcmd.y"
2408     {
2409                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s) != NULL) {
2410                                 struct stat stbuf;
2411                                 if (stat((yyvsp[(3) - (5)].s), &stbuf) < 0)
2412                                         reply(550, "%s: %s",
2413                                             (yyvsp[(3) - (5)].s), strerror(errno));
2414                                 else if (!S_ISREG(stbuf.st_mode)) {
2415                                         reply(550,
2416                                               "%s: not a plain file.", (yyvsp[(3) - (5)].s));
2417                                 } else {
2418                                         struct tm *t;
2419                                         time_t mtime = stbuf.st_mtime;
2420
2421                                         t = gmtime(&mtime);
2422                                         reply(213,
2423                                               "%04d%02d%02d%02d%02d%02d",
2424                                               t->tm_year + 1900,
2425                                               t->tm_mon + 1,
2426                                               t->tm_mday,
2427                                               t->tm_hour,
2428                                               t->tm_min,
2429                                               t->tm_sec);
2430                                 }
2431                         }
2432                         if ((yyvsp[(3) - (5)].s) != NULL)
2433                                 free((yyvsp[(3) - (5)].s));
2434                 }
2435     break;
2436
2437   case 59:
2438 #line 659 "ftpcmd.y"
2439     {
2440                     if ((yyvsp[(3) - (3)].i)) {
2441                         reply(221, "Goodbye.");
2442                         dologout(0);
2443                     }
2444                 }
2445     break;
2446
2447   case 60:
2448 #line 666 "ftpcmd.y"
2449     {
2450                         yyerrok;
2451                 }
2452     break;
2453
2454   case 61:
2455 #line 672 "ftpcmd.y"
2456     {
2457                         restart_point = (off_t) 0;
2458                         if ((yyvsp[(5) - (5)].i) && (yyvsp[(3) - (5)].s)) {
2459                                 fromname = renamefrom((yyvsp[(3) - (5)].s));
2460                                 if (fromname == (char *) 0 && (yyvsp[(3) - (5)].s)) {
2461                                         free((yyvsp[(3) - (5)].s));
2462                                 }
2463                         }
2464                 }
2465     break;
2466
2467   case 62:
2468 #line 682 "ftpcmd.y"
2469     {
2470                     if ((yyvsp[(5) - (5)].i)) {
2471                         fromname = (char *) 0;
2472                         restart_point = (yyvsp[(3) - (5)].i);   /* XXX $3 is only "int" */
2473                         reply(350, "Restarting at %ld. %s",
2474                               (long)restart_point,
2475                               "Send STORE or RETRIEVE to initiate transfer.");
2476                     }
2477                 }
2478     break;
2479
2480   case 63:
2481 #line 692 "ftpcmd.y"
2482     {
2483                         auth((yyvsp[(3) - (4)].s));
2484                         free((yyvsp[(3) - (4)].s));
2485                 }
2486     break;
2487
2488   case 64:
2489 #line 697 "ftpcmd.y"
2490     {
2491                         adat((yyvsp[(3) - (4)].s));
2492                         free((yyvsp[(3) - (4)].s));
2493                 }
2494     break;
2495
2496   case 65:
2497 #line 702 "ftpcmd.y"
2498     {
2499                     if ((yyvsp[(5) - (5)].i))
2500                         pbsz((yyvsp[(3) - (5)].i));
2501                 }
2502     break;
2503
2504   case 66:
2505 #line 707 "ftpcmd.y"
2506     {
2507                     if ((yyvsp[(5) - (5)].i))
2508                         prot((yyvsp[(3) - (5)].s));
2509                 }
2510     break;
2511
2512   case 67:
2513 #line 712 "ftpcmd.y"
2514     {
2515                     if ((yyvsp[(3) - (3)].i))
2516                         ccc();
2517                 }
2518     break;
2519
2520   case 68:
2521 #line 717 "ftpcmd.y"
2522     {
2523                         mec((yyvsp[(3) - (4)].s), prot_safe);
2524                         free((yyvsp[(3) - (4)].s));
2525                 }
2526     break;
2527
2528   case 69:
2529 #line 722 "ftpcmd.y"
2530     {
2531                         mec((yyvsp[(3) - (4)].s), prot_confidential);
2532                         free((yyvsp[(3) - (4)].s));
2533                 }
2534     break;
2535
2536   case 70:
2537 #line 727 "ftpcmd.y"
2538     {
2539                         mec((yyvsp[(3) - (4)].s), prot_private);
2540                         free((yyvsp[(3) - (4)].s));
2541                 }
2542     break;
2543
2544   case 72:
2545 #line 739 "ftpcmd.y"
2546     {
2547                         (yyval.s) = (char *)calloc(1, sizeof(char));
2548                 }
2549     break;
2550
2551   case 75:
2552 #line 752 "ftpcmd.y"
2553     {
2554                         struct sockaddr_in *sin4 = (struct sockaddr_in *)data_dest;
2555
2556                         sin4->sin_family = AF_INET;
2557                         sin4->sin_port = htons((yyvsp[(9) - (11)].i) * 256 + (yyvsp[(11) - (11)].i));
2558                         sin4->sin_addr.s_addr =
2559                             htonl(((yyvsp[(1) - (11)].i) << 24) | ((yyvsp[(3) - (11)].i) << 16) | ((yyvsp[(5) - (11)].i) << 8) | (yyvsp[(7) - (11)].i));
2560                 }
2561     break;
2562
2563   case 76:
2564 #line 764 "ftpcmd.y"
2565     {
2566                         (yyval.i) = FORM_N;
2567                 }
2568     break;
2569
2570   case 77:
2571 #line 768 "ftpcmd.y"
2572     {
2573                         (yyval.i) = FORM_T;
2574                 }
2575     break;
2576
2577   case 78:
2578 #line 772 "ftpcmd.y"
2579     {
2580                         (yyval.i) = FORM_C;
2581                 }
2582     break;
2583
2584   case 79:
2585 #line 779 "ftpcmd.y"
2586     {
2587                         cmd_type = TYPE_A;
2588                         cmd_form = FORM_N;
2589                 }
2590     break;
2591
2592   case 80:
2593 #line 784 "ftpcmd.y"
2594     {
2595                         cmd_type = TYPE_A;
2596                         cmd_form = (yyvsp[(3) - (3)].i);
2597                 }
2598     break;
2599
2600   case 81:
2601 #line 789 "ftpcmd.y"
2602     {
2603                         cmd_type = TYPE_E;
2604                         cmd_form = FORM_N;
2605                 }
2606     break;
2607
2608   case 82:
2609 #line 794 "ftpcmd.y"
2610     {
2611                         cmd_type = TYPE_E;
2612                         cmd_form = (yyvsp[(3) - (3)].i);
2613                 }
2614     break;
2615
2616   case 83:
2617 #line 799 "ftpcmd.y"
2618     {
2619                         cmd_type = TYPE_I;
2620                 }
2621     break;
2622
2623   case 84:
2624 #line 803 "ftpcmd.y"
2625     {
2626                         cmd_type = TYPE_L;
2627                         cmd_bytesz = NBBY;
2628                 }
2629     break;
2630
2631   case 85:
2632 #line 808 "ftpcmd.y"
2633     {
2634                         cmd_type = TYPE_L;
2635                         cmd_bytesz = (yyvsp[(3) - (3)].i);
2636                 }
2637     break;
2638
2639   case 86:
2640 #line 814 "ftpcmd.y"
2641     {
2642                         cmd_type = TYPE_L;
2643                         cmd_bytesz = (yyvsp[(2) - (2)].i);
2644                 }
2645     break;
2646
2647   case 87:
2648 #line 822 "ftpcmd.y"
2649     {
2650                         (yyval.i) = STRU_F;
2651                 }
2652     break;
2653
2654   case 88:
2655 #line 826 "ftpcmd.y"
2656     {
2657                         (yyval.i) = STRU_R;
2658                 }
2659     break;
2660
2661   case 89:
2662 #line 830 "ftpcmd.y"
2663     {
2664                         (yyval.i) = STRU_P;
2665                 }
2666     break;
2667
2668   case 90:
2669 #line 837 "ftpcmd.y"
2670     {
2671                         (yyval.i) = MODE_S;
2672                 }
2673     break;
2674
2675   case 91:
2676 #line 841 "ftpcmd.y"
2677     {
2678                         (yyval.i) = MODE_B;
2679                 }
2680     break;
2681
2682   case 92:
2683 #line 845 "ftpcmd.y"
2684     {
2685                         (yyval.i) = MODE_C;
2686                 }
2687     break;
2688
2689   case 93:
2690 #line 852 "ftpcmd.y"
2691     {
2692                         /*
2693                          * Problem: this production is used for all pathname
2694                          * processing, but only gives a 550 error reply.
2695                          * This is a valid reply in some cases but not in others.
2696                          */
2697                         if (logged_in && (yyvsp[(1) - (1)].s) && *(yyvsp[(1) - (1)].s) == '~') {
2698                                 glob_t gl;
2699                                 int flags =
2700                                  GLOB_BRACE|GLOB_NOCHECK|GLOB_QUOTE|GLOB_TILDE;
2701
2702                                 memset(&gl, 0, sizeof(gl));
2703                                 if (glob((yyvsp[(1) - (1)].s), flags, NULL, &gl) ||
2704                                     gl.gl_pathc == 0) {
2705                                         reply(550, "not found");
2706                                         (yyval.s) = NULL;
2707                                 } else {
2708                                         (yyval.s) = strdup(gl.gl_pathv[0]);
2709                                 }
2710                                 globfree(&gl);
2711                                 free((yyvsp[(1) - (1)].s));
2712                         } else
2713                                 (yyval.s) = (yyvsp[(1) - (1)].s);
2714                 }
2715     break;
2716
2717   case 95:
2718 #line 884 "ftpcmd.y"
2719     {
2720                         int ret, dec, multby, digit;
2721
2722                         /*
2723                          * Convert a number that was read as decimal number
2724                          * to what it would be if it had been read as octal.
2725                          */
2726                         dec = (yyvsp[(1) - (1)].i);
2727                         multby = 1;
2728                         ret = 0;
2729                         while (dec) {
2730                                 digit = dec%10;
2731                                 if (digit > 7) {
2732                                         ret = -1;
2733                                         break;
2734                                 }
2735                                 ret += digit * multby;
2736                                 multby *= 8;
2737                                 dec /= 10;
2738                         }
2739                         (yyval.i) = ret;
2740                 }
2741     break;
2742
2743   case 96:
2744 #line 910 "ftpcmd.y"
2745     {
2746                         (yyval.i) = (yyvsp[(1) - (1)].i) && !guest;
2747                         if((yyvsp[(1) - (1)].i) && !(yyval.i))
2748                                 reply(550, "Permission denied");
2749                 }
2750     break;
2751
2752   case 97:
2753 #line 918 "ftpcmd.y"
2754     {
2755                     if((yyvsp[(1) - (1)].i)) {
2756                         if(((yyval.i) = logged_in) == 0)
2757                             reply(530, "Please login with USER and PASS.");
2758                     } else
2759                         (yyval.i) = 0;
2760                 }
2761     break;
2762
2763   case 98:
2764 #line 928 "ftpcmd.y"
2765     {
2766                     (yyval.i) = 1;
2767                     if(sec_complete && !ccc_passed && !secure_command()) {
2768                         (yyval.i) = 0;
2769                         reply(533, "Command protection level denied "
2770                               "for paranoid reasons.");
2771                     }
2772                 }
2773     break;
2774
2775
2776 /* Line 1267 of yacc.c.  */
2777 #line 2778 "ftpcmd.c"
2778       default: break;
2779     }
2780   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2781
2782   YYPOPSTACK (yylen);
2783   yylen = 0;
2784   YY_STACK_PRINT (yyss, yyssp);
2785
2786   *++yyvsp = yyval;
2787
2788
2789   /* Now `shift' the result of the reduction.  Determine what state
2790      that goes to, based on the state we popped back to and the rule
2791      number reduced by.  */
2792
2793   yyn = yyr1[yyn];
2794
2795   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2796   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2797     yystate = yytable[yystate];
2798   else
2799     yystate = yydefgoto[yyn - YYNTOKENS];
2800
2801   goto yynewstate;
2802
2803
2804 /*------------------------------------.
2805 | yyerrlab -- here on detecting error |
2806 `------------------------------------*/
2807 yyerrlab:
2808   /* If not already recovering from an error, report this error.  */
2809   if (!yyerrstatus)
2810     {
2811       ++yynerrs;
2812 #if ! YYERROR_VERBOSE
2813       yyerror (YY_("syntax error"));
2814 #else
2815       {
2816         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2817         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2818           {
2819             YYSIZE_T yyalloc = 2 * yysize;
2820             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2821               yyalloc = YYSTACK_ALLOC_MAXIMUM;
2822             if (yymsg != yymsgbuf)
2823               YYSTACK_FREE (yymsg);
2824             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2825             if (yymsg)
2826               yymsg_alloc = yyalloc;
2827             else
2828               {
2829                 yymsg = yymsgbuf;
2830                 yymsg_alloc = sizeof yymsgbuf;
2831               }
2832           }
2833
2834         if (0 < yysize && yysize <= yymsg_alloc)
2835           {
2836             (void) yysyntax_error (yymsg, yystate, yychar);
2837             yyerror (yymsg);
2838           }
2839         else
2840           {
2841             yyerror (YY_("syntax error"));
2842             if (yysize != 0)
2843               goto yyexhaustedlab;
2844           }
2845       }
2846 #endif
2847     }
2848
2849
2850
2851   if (yyerrstatus == 3)
2852     {
2853       /* If just tried and failed to reuse look-ahead token after an
2854          error, discard it.  */
2855
2856       if (yychar <= YYEOF)
2857         {
2858           /* Return failure if at end of input.  */
2859           if (yychar == YYEOF)
2860             YYABORT;
2861         }
2862       else
2863         {
2864           yydestruct ("Error: discarding",
2865                       yytoken, &yylval);
2866           yychar = YYEMPTY;
2867         }
2868     }
2869
2870   /* Else will try to reuse look-ahead token after shifting the error
2871      token.  */
2872   goto yyerrlab1;
2873
2874
2875 /*---------------------------------------------------.
2876 | yyerrorlab -- error raised explicitly by YYERROR.  |
2877 `---------------------------------------------------*/
2878 yyerrorlab:
2879
2880   /* Pacify compilers like GCC when the user code never invokes
2881      YYERROR and the label yyerrorlab therefore never appears in user
2882      code.  */
2883   if (/*CONSTCOND*/ 0)
2884      goto yyerrorlab;
2885
2886   /* Do not reclaim the symbols of the rule which action triggered
2887      this YYERROR.  */
2888   YYPOPSTACK (yylen);
2889   yylen = 0;
2890   YY_STACK_PRINT (yyss, yyssp);
2891   yystate = *yyssp;
2892   goto yyerrlab1;
2893
2894
2895 /*-------------------------------------------------------------.
2896 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
2897 `-------------------------------------------------------------*/
2898 yyerrlab1:
2899   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2900
2901   for (;;)
2902     {
2903       yyn = yypact[yystate];
2904       if (yyn != YYPACT_NINF)
2905         {
2906           yyn += YYTERROR;
2907           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2908             {
2909               yyn = yytable[yyn];
2910               if (0 < yyn)
2911                 break;
2912             }
2913         }
2914
2915       /* Pop the current state because it cannot handle the error token.  */
2916       if (yyssp == yyss)
2917         YYABORT;
2918
2919
2920       yydestruct ("Error: popping",
2921                   yystos[yystate], yyvsp);
2922       YYPOPSTACK (1);
2923       yystate = *yyssp;
2924       YY_STACK_PRINT (yyss, yyssp);
2925     }
2926
2927   if (yyn == YYFINAL)
2928     YYACCEPT;
2929
2930   *++yyvsp = yylval;
2931
2932
2933   /* Shift the error token.  */
2934   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2935
2936   yystate = yyn;
2937   goto yynewstate;
2938
2939
2940 /*-------------------------------------.
2941 | yyacceptlab -- YYACCEPT comes here.  |
2942 `-------------------------------------*/
2943 yyacceptlab:
2944   yyresult = 0;
2945   goto yyreturn;
2946
2947 /*-----------------------------------.
2948 | yyabortlab -- YYABORT comes here.  |
2949 `-----------------------------------*/
2950 yyabortlab:
2951   yyresult = 1;
2952   goto yyreturn;
2953
2954 #ifndef yyoverflow
2955 /*-------------------------------------------------.
2956 | yyexhaustedlab -- memory exhaustion comes here.  |
2957 `-------------------------------------------------*/
2958 yyexhaustedlab:
2959   yyerror (YY_("memory exhausted"));
2960   yyresult = 2;
2961   /* Fall through.  */
2962 #endif
2963
2964 yyreturn:
2965   if (yychar != YYEOF && yychar != YYEMPTY)
2966      yydestruct ("Cleanup: discarding lookahead",
2967                  yytoken, &yylval);
2968   /* Do not reclaim the symbols of the rule which action triggered
2969      this YYABORT or YYACCEPT.  */
2970   YYPOPSTACK (yylen);
2971   YY_STACK_PRINT (yyss, yyssp);
2972   while (yyssp != yyss)
2973     {
2974       yydestruct ("Cleanup: popping",
2975                   yystos[*yyssp], yyvsp);
2976       YYPOPSTACK (1);
2977     }
2978 #ifndef yyoverflow
2979   if (yyss != yyssa)
2980     YYSTACK_FREE (yyss);
2981 #endif
2982 #if YYERROR_VERBOSE
2983   if (yymsg != yymsgbuf)
2984     YYSTACK_FREE (yymsg);
2985 #endif
2986   /* Make sure YYID is used.  */
2987   return YYID (yyresult);
2988 }
2989
2990
2991 #line 938 "ftpcmd.y"
2992
2993
2994 #define CMD     0       /* beginning of command */
2995 #define ARGS    1       /* expect miscellaneous arguments */
2996 #define STR1    2       /* expect SP followed by STRING */
2997 #define STR2    3       /* expect STRING */
2998 #define OSTR    4       /* optional SP then STRING */
2999 #define ZSTR1   5       /* SP then optional STRING */
3000 #define ZSTR2   6       /* optional STRING after SP */
3001 #define SITECMD 7       /* SITE command */
3002 #define NSTR    8       /* Number followed by a string */
3003
3004 struct tab cmdtab[] = {         /* In order defined in RFC 765 */
3005         { "USER", USER, STR1, 1,        "<sp> username" },
3006         { "PASS", PASS, ZSTR1, 1,       "<sp> password" },
3007         { "ACCT", ACCT, STR1, 0,        "(specify account)" },
3008         { "SMNT", SMNT, ARGS, 0,        "(structure mount)" },
3009         { "REIN", REIN, ARGS, 0,        "(reinitialize server state)" },
3010         { "QUIT", QUIT, ARGS, 1,        "(terminate service)", },
3011         { "PORT", PORT, ARGS, 1,        "<sp> b0, b1, b2, b3, b4" },
3012         { "EPRT", EPRT, STR1, 1,        "<sp> string" },
3013         { "PASV", PASV, ARGS, 1,        "(set server in passive mode)" },
3014         { "EPSV", EPSV, OSTR, 1,        "[<sp> foo]" },
3015         { "TYPE", TYPE, ARGS, 1,        "<sp> [ A | E | I | L ]" },
3016         { "STRU", STRU, ARGS, 1,        "(specify file structure)" },
3017         { "MODE", MODE, ARGS, 1,        "(specify transfer mode)" },
3018         { "RETR", RETR, STR1, 1,        "<sp> file-name" },
3019         { "STOR", STOR, STR1, 1,        "<sp> file-name" },
3020         { "APPE", APPE, STR1, 1,        "<sp> file-name" },
3021         { "MLFL", MLFL, OSTR, 0,        "(mail file)" },
3022         { "MAIL", MAIL, OSTR, 0,        "(mail to user)" },
3023         { "MSND", MSND, OSTR, 0,        "(mail send to terminal)" },
3024         { "MSOM", MSOM, OSTR, 0,        "(mail send to terminal or mailbox)" },
3025         { "MSAM", MSAM, OSTR, 0,        "(mail send to terminal and mailbox)" },
3026         { "MRSQ", MRSQ, OSTR, 0,        "(mail recipient scheme question)" },
3027         { "MRCP", MRCP, STR1, 0,        "(mail recipient)" },
3028         { "ALLO", ALLO, ARGS, 1,        "allocate storage (vacuously)" },
3029         { "REST", REST, ARGS, 1,        "<sp> offset (restart command)" },
3030         { "RNFR", RNFR, STR1, 1,        "<sp> file-name" },
3031         { "RNTO", RNTO, STR1, 1,        "<sp> file-name" },
3032         { "ABOR", ABOR, ARGS, 1,        "(abort operation)" },
3033         { "DELE", DELE, STR1, 1,        "<sp> file-name" },
3034         { "CWD",  CWD,  OSTR, 1,        "[ <sp> directory-name ]" },
3035         { "XCWD", CWD,  OSTR, 1,        "[ <sp> directory-name ]" },
3036         { "LIST", LIST, OSTR, 1,        "[ <sp> path-name ]" },
3037         { "NLST", NLST, OSTR, 1,        "[ <sp> path-name ]" },
3038         { "SITE", SITE, SITECMD, 1,     "site-cmd [ <sp> arguments ]" },
3039         { "SYST", SYST, ARGS, 1,        "(get type of operating system)" },
3040         { "STAT", sTAT, OSTR, 1,        "[ <sp> path-name ]" },
3041         { "HELP", HELP, OSTR, 1,        "[ <sp> <string> ]" },
3042         { "NOOP", NOOP, ARGS, 1,        "" },
3043         { "MKD",  MKD,  STR1, 1,        "<sp> path-name" },
3044         { "XMKD", MKD,  STR1, 1,        "<sp> path-name" },
3045         { "RMD",  RMD,  STR1, 1,        "<sp> path-name" },
3046         { "XRMD", RMD,  STR1, 1,        "<sp> path-name" },
3047         { "PWD",  PWD,  ARGS, 1,        "(return current directory)" },
3048         { "XPWD", PWD,  ARGS, 1,        "(return current directory)" },
3049         { "CDUP", CDUP, ARGS, 1,        "(change to parent directory)" },
3050         { "XCUP", CDUP, ARGS, 1,        "(change to parent directory)" },
3051         { "STOU", STOU, STR1, 1,        "<sp> file-name" },
3052         { "SIZE", SIZE, OSTR, 1,        "<sp> path-name" },
3053         { "MDTM", MDTM, OSTR, 1,        "<sp> path-name" },
3054
3055         /* extensions from RFC2228 */
3056         { "AUTH", AUTH, STR1, 1,        "<sp> auth-type" },
3057         { "ADAT", ADAT, STR1, 1,        "<sp> auth-data" },
3058         { "PBSZ", PBSZ, ARGS, 1,        "<sp> buffer-size" },
3059         { "PROT", PROT, STR1, 1,        "<sp> prot-level" },
3060         { "CCC",  CCC,  ARGS, 1,        "" },
3061         { "MIC",  MIC,  STR1, 1,        "<sp> integrity command" },
3062         { "CONF", CONF, STR1, 1,        "<sp> confidentiality command" },
3063         { "ENC",  ENC,  STR1, 1,        "<sp> privacy command" },
3064
3065         /* RFC2389 */
3066         { "FEAT", FEAT, ARGS, 1,        "" },
3067         { "OPTS", OPTS, ARGS, 1,        "<sp> command [<sp> options]" },
3068
3069         { NULL,   0,    0,    0,        0 }
3070 };
3071
3072 struct tab sitetab[] = {
3073         { "UMASK", UMASK, ARGS, 1,      "[ <sp> umask ]" },
3074         { "IDLE", IDLE, ARGS, 1,        "[ <sp> maximum-idle-time ]" },
3075         { "CHMOD", CHMOD, NSTR, 1,      "<sp> mode <sp> file-name" },
3076         { "HELP", HELP, OSTR, 1,        "[ <sp> <string> ]" },
3077
3078         { "KAUTH", KAUTH, STR1, 1,      "<sp> principal [ <sp> ticket ]" },
3079         { "KLIST", KLIST, ARGS, 1,      "(show ticket file)" },
3080         { "KDESTROY", KDESTROY, ARGS, 1, "(destroy tickets)" },
3081         { "KRBTKFILE", KRBTKFILE, STR1, 1, "<sp> ticket-file" },
3082         { "AFSLOG", AFSLOG, OSTR, 1,    "[<sp> cell]" },
3083
3084         { "LOCATE", LOCATE, STR1, 1,    "<sp> globexpr" },
3085         { "FIND", LOCATE, STR1, 1,      "<sp> globexpr" },
3086
3087         { "URL",  URL,  ARGS, 1,        "?" },
3088
3089         { NULL,   0,    0,    0,        0 }
3090 };
3091
3092 static struct tab *
3093 lookup(struct tab *p, char *cmd)
3094 {
3095
3096         for (; p->name != NULL; p++)
3097                 if (strcmp(cmd, p->name) == 0)
3098                         return (p);
3099         return (0);
3100 }
3101
3102 /*
3103  * ftpd_getline - a hacked up version of fgets to ignore TELNET escape codes.
3104  */
3105 char *
3106 ftpd_getline(char *s, int n)
3107 {
3108         int c;
3109         char *cs;
3110
3111         cs = s;
3112
3113         /* might still be data within the security MIC/CONF/ENC */
3114         if(ftp_command){
3115             strlcpy(s, ftp_command, n);
3116             if (debug)
3117                 syslog(LOG_DEBUG, "command: %s", s);
3118             return s;
3119         }
3120         while ((c = getc(stdin)) != EOF) {
3121                 c &= 0377;
3122                 if (c == IAC) {
3123                     if ((c = getc(stdin)) != EOF) {
3124                         c &= 0377;
3125                         switch (c) {
3126                         case WILL:
3127                         case WONT:
3128                                 c = getc(stdin);
3129                                 printf("%c%c%c", IAC, DONT, 0377&c);
3130                                 fflush(stdout);
3131                                 continue;
3132                         case DO:
3133                         case DONT:
3134                                 c = getc(stdin);
3135                                 printf("%c%c%c", IAC, WONT, 0377&c);
3136                                 fflush(stdout);
3137                                 continue;
3138                         case IAC:
3139                                 break;
3140                         default:
3141                                 continue;       /* ignore command */
3142                         }
3143                     }
3144                 }
3145                 *cs++ = c;
3146                 if (--n <= 0 || c == '\n')
3147                         break;
3148         }
3149         if (c == EOF && cs == s)
3150                 return (NULL);
3151         *cs++ = '\0';
3152         if (debug) {
3153                 if (!guest && strncasecmp("pass ", s, 5) == 0) {
3154                         /* Don't syslog passwords */
3155                         syslog(LOG_DEBUG, "command: %.5s ???", s);
3156                 } else {
3157                         char *cp;
3158                         int len;
3159
3160                         /* Don't syslog trailing CR-LF */
3161                         len = strlen(s);
3162                         cp = s + len - 1;
3163                         while (cp >= s && (*cp == '\n' || *cp == '\r')) {
3164                                 --cp;
3165                                 --len;
3166                         }
3167                         syslog(LOG_DEBUG, "command: %.*s", len, s);
3168                 }
3169         }
3170 #ifdef XXX
3171         fprintf(stderr, "%s\n", s);
3172 #endif
3173         return (s);
3174 }
3175
3176 static RETSIGTYPE
3177 toolong(int signo)
3178 {
3179
3180         reply(421,
3181             "Timeout (%d seconds): closing control connection.",
3182               ftpd_timeout);
3183         if (logging)
3184                 syslog(LOG_INFO, "User %s timed out after %d seconds",
3185                     (pw ? pw -> pw_name : "unknown"), ftpd_timeout);
3186         dologout(1);
3187         SIGRETURN(0);
3188 }
3189
3190 static int
3191 yylex(void)
3192 {
3193         static int cpos, state;
3194         char *cp, *cp2;
3195         struct tab *p;
3196         int n;
3197         char c;
3198
3199         for (;;) {
3200                 switch (state) {
3201
3202                 case CMD:
3203                         hasyyerrored = 0;
3204
3205                         signal(SIGALRM, toolong);
3206                         alarm((unsigned) ftpd_timeout);
3207                         if (ftpd_getline(cbuf, sizeof(cbuf)-1) == NULL) {
3208                                 reply(221, "You could at least say goodbye.");
3209                                 dologout(0);
3210                         }
3211                         alarm(0);
3212 #ifdef HAVE_SETPROCTITLE
3213                         if (strncasecmp(cbuf, "PASS", 4) != 0)
3214                                 setproctitle("%s: %s", proctitle, cbuf);
3215 #endif /* HAVE_SETPROCTITLE */
3216                         if ((cp = strchr(cbuf, '\r'))) {
3217                                 *cp++ = '\n';
3218                                 *cp = '\0';
3219                         }
3220                         if ((cp = strpbrk(cbuf, " \n")))
3221                                 cpos = cp - cbuf;
3222                         if (cpos == 0)
3223                                 cpos = 4;
3224                         c = cbuf[cpos];
3225                         cbuf[cpos] = '\0';
3226                         strupr(cbuf);
3227                         p = lookup(cmdtab, cbuf);
3228                         cbuf[cpos] = c;
3229                         if (p != 0) {
3230                                 if (p->implemented == 0) {
3231                                         nack(p->name);
3232                                         hasyyerrored = 1;
3233                                         break;
3234                                 }
3235                                 state = p->state;
3236                                 yylval.s = p->name;
3237                                 return (p->token);
3238                         }
3239                         break;
3240
3241                 case SITECMD:
3242                         if (cbuf[cpos] == ' ') {
3243                                 cpos++;
3244                                 return (SP);
3245                         }
3246                         cp = &cbuf[cpos];
3247                         if ((cp2 = strpbrk(cp, " \n")))
3248                                 cpos = cp2 - cbuf;
3249                         c = cbuf[cpos];
3250                         cbuf[cpos] = '\0';
3251                         strupr(cp);
3252                         p = lookup(sitetab, cp);
3253                         cbuf[cpos] = c;
3254                         if (p != 0) {
3255                                 if (p->implemented == 0) {
3256                                         state = CMD;
3257                                         nack(p->name);
3258                                         hasyyerrored = 1;
3259                                         break;
3260                                 }
3261                                 state = p->state;
3262                                 yylval.s = p->name;
3263                                 return (p->token);
3264                         }
3265                         state = CMD;
3266                         break;
3267
3268                 case OSTR:
3269                         if (cbuf[cpos] == '\n') {
3270                                 state = CMD;
3271                                 return (CRLF);
3272                         }
3273                         /* FALLTHROUGH */
3274
3275                 case STR1:
3276                 case ZSTR1:
3277                 dostr1:
3278                         if (cbuf[cpos] == ' ') {
3279                                 cpos++;
3280                                 if(state == OSTR)
3281                                     state = STR2;
3282                                 else
3283                                     state++;
3284                                 return (SP);
3285                         }
3286                         break;
3287
3288                 case ZSTR2:
3289                         if (cbuf[cpos] == '\n') {
3290                                 state = CMD;
3291                                 return (CRLF);
3292                         }
3293                         /* FALLTHROUGH */
3294
3295                 case STR2:
3296                         cp = &cbuf[cpos];
3297                         n = strlen(cp);
3298                         cpos += n - 1;
3299                         /*
3300                          * Make sure the string is nonempty and \n terminated.
3301                          */
3302                         if (n > 1 && cbuf[cpos] == '\n') {
3303                                 cbuf[cpos] = '\0';
3304                                 yylval.s = copy(cp);
3305                                 cbuf[cpos] = '\n';
3306                                 state = ARGS;
3307                                 return (STRING);
3308                         }
3309                         break;
3310
3311                 case NSTR:
3312                         if (cbuf[cpos] == ' ') {
3313                                 cpos++;
3314                                 return (SP);
3315                         }
3316                         if (isdigit((unsigned char)cbuf[cpos])) {
3317                                 cp = &cbuf[cpos];
3318                                 while (isdigit((unsigned char)cbuf[++cpos]))
3319                                         ;
3320                                 c = cbuf[cpos];
3321                                 cbuf[cpos] = '\0';
3322                                 yylval.i = atoi(cp);
3323                                 cbuf[cpos] = c;
3324                                 state = STR1;
3325                                 return (NUMBER);
3326                         }
3327                         state = STR1;
3328                         goto dostr1;
3329
3330                 case ARGS:
3331                         if (isdigit((unsigned char)cbuf[cpos])) {
3332                                 cp = &cbuf[cpos];
3333                                 while (isdigit((unsigned char)cbuf[++cpos]))
3334                                         ;
3335                                 c = cbuf[cpos];
3336                                 cbuf[cpos] = '\0';
3337                                 yylval.i = atoi(cp);
3338                                 cbuf[cpos] = c;
3339                                 return (NUMBER);
3340                         }
3341                         switch (cbuf[cpos++]) {
3342
3343                         case '\n':
3344                                 state = CMD;
3345                                 return (CRLF);
3346
3347                         case ' ':
3348                                 return (SP);
3349
3350                         case ',':
3351                                 return (COMMA);
3352
3353                         case 'A':
3354                         case 'a':
3355                                 return (A);
3356
3357                         case 'B':
3358                         case 'b':
3359                                 return (B);
3360
3361                         case 'C':
3362                         case 'c':
3363                                 return (C);
3364
3365                         case 'E':
3366                         case 'e':
3367                                 return (E);
3368
3369                         case 'F':
3370                         case 'f':
3371                                 return (F);
3372
3373                         case 'I':
3374                         case 'i':
3375                                 return (I);
3376
3377                         case 'L':
3378                         case 'l':
3379                                 return (L);
3380
3381                         case 'N':
3382                         case 'n':
3383                                 return (N);
3384
3385                         case 'P':
3386                         case 'p':
3387                                 return (P);
3388
3389                         case 'R':
3390                         case 'r':
3391                                 return (R);
3392
3393                         case 'S':
3394                         case 's':
3395                                 return (S);
3396
3397                         case 'T':
3398                         case 't':
3399                                 return (T);
3400
3401                         }
3402                         break;
3403
3404                 default:
3405                         fatal("Unknown state in scanner.");
3406                 }
3407                 yyerror(NULL);
3408                 state = CMD;
3409                 return (0);
3410         }
3411 }
3412
3413 /* ARGSUSED */
3414 void
3415 yyerror(char *s)
3416 {
3417         char *cp;
3418
3419         if (hasyyerrored)
3420             return;
3421
3422         if ((cp = strchr(cbuf,'\n')))
3423                 *cp = '\0';
3424         reply(500, "'%s': command not understood.", cbuf);
3425         hasyyerrored = 1;
3426 }
3427
3428 static char *
3429 copy(char *s)
3430 {
3431         char *p;
3432
3433         p = strdup(s);
3434         if (p == NULL)
3435                 fatal("Ran out of memory.");
3436         return p;
3437 }
3438
3439 static void
3440 help(struct tab *ctab, char *s)
3441 {
3442         struct tab *c;
3443         int width, NCMDS;
3444         char *t;
3445         char buf[1024];
3446
3447         if (ctab == sitetab)
3448                 t = "SITE ";
3449         else
3450                 t = "";
3451         width = 0, NCMDS = 0;
3452         for (c = ctab; c->name != NULL; c++) {
3453                 int len = strlen(c->name);
3454
3455                 if (len > width)
3456                         width = len;
3457                 NCMDS++;
3458         }
3459         width = (width + 8) &~ 7;
3460         if (s == 0) {
3461                 int i, j, w;
3462                 int columns, lines;
3463
3464                 lreply(214, "The following %scommands are recognized %s.",
3465                     t, "(* =>'s unimplemented)");
3466                 columns = 76 / width;
3467                 if (columns == 0)
3468                         columns = 1;
3469                 lines = (NCMDS + columns - 1) / columns;
3470                 for (i = 0; i < lines; i++) {
3471                     strlcpy (buf, "   ", sizeof(buf));
3472                     for (j = 0; j < columns; j++) {
3473                         c = ctab + j * lines + i;
3474                         snprintf (buf + strlen(buf),
3475                                   sizeof(buf) - strlen(buf),
3476                                   "%s%c",
3477                                   c->name,
3478                                   c->implemented ? ' ' : '*');
3479                         if (c + lines >= &ctab[NCMDS])
3480                             break;
3481                         w = strlen(c->name) + 1;
3482                         while (w < width) {
3483                             strlcat (buf,
3484                                              " ",
3485                                              sizeof(buf));
3486                             w++;
3487                         }
3488                     }
3489                     lreply(214, "%s", buf);
3490                 }
3491                 reply(214, "Direct comments to kth-krb-bugs@pdc.kth.se");
3492                 return;
3493         }
3494         strupr(s);
3495         c = lookup(ctab, s);
3496         if (c == (struct tab *)0) {
3497                 reply(502, "Unknown command %s.", s);
3498                 return;
3499         }
3500         if (c->implemented)
3501                 reply(214, "Syntax: %s%s %s", t, c->name, c->help);
3502         else
3503                 reply(214, "%s%-*s\t%s; unimplemented.", t, width,
3504                     c->name, c->help);
3505 }
3506
3507 static void
3508 sizecmd(char *filename)
3509 {
3510         switch (type) {
3511         case TYPE_L:
3512         case TYPE_I: {
3513                 struct stat stbuf;
3514                 if (stat(filename, &stbuf) < 0 || !S_ISREG(stbuf.st_mode))
3515                         reply(550, "%s: not a plain file.", filename);
3516                 else
3517                         reply(213, "%lu", (unsigned long)stbuf.st_size);
3518                 break;
3519         }
3520         case TYPE_A: {
3521                 FILE *fin;
3522                 int c;
3523                 size_t count;
3524                 struct stat stbuf;
3525                 fin = fopen(filename, "r");
3526                 if (fin == NULL) {
3527                         perror_reply(550, filename);
3528                         return;
3529                 }
3530                 if (fstat(fileno(fin), &stbuf) < 0 || !S_ISREG(stbuf.st_mode)) {
3531                         reply(550, "%s: not a plain file.", filename);
3532                         fclose(fin);
3533                         return;
3534                 }
3535
3536                 count = 0;
3537                 while((c=getc(fin)) != EOF) {
3538                         if (c == '\n')  /* will get expanded to \r\n */
3539                                 count++;
3540                         count++;
3541                 }
3542                 fclose(fin);
3543
3544                 reply(213, "%lu", (unsigned long)count);
3545                 break;
3546         }
3547         default:
3548                 reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
3549         }
3550 }
3551