cmd-parse.y

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2019 Nicholas Marriott <nicholas.marriott@gmail.com>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
  15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 %{
  20
  21 #include <sys/types.h>
  22
  23 #include <ctype.h>
  24 #include <errno.h>
  25 #include <pwd.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <wchar.h>
  30
  31 #include "tmux.h"
  32
  33 static int                       yylex(void);
  34 static int                       yyparse(void);
  35 static int printflike(1,2)       yyerror(const char *, ...);
  36
  37 static char                     *yylex_token(int);
  38 static char                     *yylex_format(void);
  39
  40 struct cmd_parse_scope {
  41         int                              flag;
  42         TAILQ_ENTRY (cmd_parse_scope)    entry;
  43 };
  44
  45 enum cmd_parse_argument_type {
  46         CMD_PARSE_STRING,
  47         CMD_PARSE_COMMANDS,
  48         CMD_PARSE_PARSED_COMMANDS
  49 };
  50
  51 struct cmd_parse_argument {
  52         enum cmd_parse_argument_type     type;
  53         char                            *string;
  54         struct cmd_parse_commands       *commands;
  55         struct cmd_list                 *cmdlist;
  56
  57         TAILQ_ENTRY(cmd_parse_argument)  entry;
  58 };
  59 TAILQ_HEAD(cmd_parse_arguments, cmd_parse_argument);
  60
  61 struct cmd_parse_command {
  62         u_int                            line;
  63         struct cmd_parse_arguments       arguments;
  64
  65         TAILQ_ENTRY(cmd_parse_command)   entry;
  66 };
  67 TAILQ_HEAD(cmd_parse_commands, cmd_parse_command);
  68
  69 struct cmd_parse_state {
  70         FILE                            *f;
  71
  72         const char                      *buf;
  73         size_t                           len;
  74         size_t                           off;
  75
  76         int                              condition;
  77         int                              eol;
  78         int                              eof;
  79         struct cmd_parse_input          *input;
  80         u_int                            escapes;
  81
  82         char                            *error;
  83         struct cmd_parse_commands       *commands;
  84
  85         struct cmd_parse_scope          *scope;
  86         TAILQ_HEAD(, cmd_parse_scope)    stack;
  87 };
  88 static struct cmd_parse_state parse_state;
  89
  90 static char     *cmd_parse_get_error(const char *, u_int, const char *);
  91 static void      cmd_parse_free_command(struct cmd_parse_command *);
  92 static struct cmd_parse_commands *cmd_parse_new_commands(void);
  93 static void      cmd_parse_free_commands(struct cmd_parse_commands *);
  94 static void      cmd_parse_build_commands(struct cmd_parse_commands *,
  95                      struct cmd_parse_input *, struct cmd_parse_result *);
  96 static void      cmd_parse_print_commands(struct cmd_parse_input *,
  97                      struct cmd_list *);
  98
  99 %}
 100
 101 %union
 102 {
 103         char                                     *token;
 104         struct cmd_parse_arguments               *arguments;
 105         struct cmd_parse_argument                *argument;
 106         int                                       flag;
 107         struct {
 108                 int                               flag;
 109                 struct cmd_parse_commands        *commands;
 110         } elif;
 111         struct cmd_parse_commands                *commands;
 112         struct cmd_parse_command                 *command;
 113 }
 114
 115 %token ERROR
 116 %token HIDDEN
 117 %token IF
 118 %token ELSE
 119 %token ELIF
 120 %token ENDIF
 121 %token <token> FORMAT TOKEN EQUALS
 122
 123 %type <token> expanded format
 124 %type <arguments> arguments
 125 %type <argument> argument
 126 %type <flag> if_open if_elif
 127 %type <elif> elif elif1
 128 %type <commands> argument_statements statements statement
 129 %type <commands> commands condition condition1
 130 %type <command> command
 131
 132 %%
 133
 134 lines           : /* empty */
 135                 | statements
 136                 {
 137                         struct cmd_parse_state  *ps = &parse_state;
 138
 139                         ps->commands = $1;
 140                 }
 141
 142 statements      : statement '\n'
 143                 {
 144                         $$ = $1;
 145                 }
 146                 | statements statement '\n'
 147                 {
 148                         $$ = $1;
 149                         TAILQ_CONCAT($$, $2, entry);
 150                         free($2);
 151                 }
 152
 153 statement       : /* empty */
 154                 {
 155                         $$ = xmalloc (sizeof *$$);
 156                         TAILQ_INIT($$);
 157                 }
 158                 | hidden_assignment
 159                 {
 160                         $$ = xmalloc (sizeof *$$);
 161                         TAILQ_INIT($$);
 162                 }
 163                 | condition
 164                 {
 165                         struct cmd_parse_state  *ps = &parse_state;
 166
 167                         if (ps->scope == NULL || ps->scope->flag)
 168                                 $$ = $1;
 169                         else {
 170                                 $$ = cmd_parse_new_commands();
 171                                 cmd_parse_free_commands($1);
 172                         }
 173                 }
 174                 | commands
 175                 {
 176                         struct cmd_parse_state  *ps = &parse_state;
 177
 178                         if (ps->scope == NULL || ps->scope->flag)
 179                                 $$ = $1;
 180                         else {
 181                                 $$ = cmd_parse_new_commands();
 182                                 cmd_parse_free_commands($1);
 183                         }
 184                 }
 185
 186 format          : FORMAT
 187                 {
 188                         $$ = $1;
 189                 }
 190                 | TOKEN
 191                 {
 192                         $$ = $1;
 193                 }
 194
 195 expanded        : format
 196                 {
 197                         struct cmd_parse_state  *ps = &parse_state;
 198                         struct cmd_parse_input  *pi = ps->input;
 199                         struct format_tree      *ft;
 200                         struct client           *c = pi->c;
 201                         struct cmd_find_state   *fsp;
 202                         struct cmd_find_state    fs;
 203                         int                      flags = FORMAT_NOJOBS;
 204
 205                         if (cmd_find_valid_state(&pi->fs))
 206                                 fsp = &pi->fs;
 207                         else {
 208                                 cmd_find_from_client(&fs, c, 0);
 209                                 fsp = &fs;
 210                         }
 211                         ft = format_create(NULL, pi->item, FORMAT_NONE, flags);
 212                         format_defaults(ft, c, fsp->s, fsp->wl, fsp->wp);
 213
 214                         $$ = format_expand(ft, $1);
 215                         format_free(ft);
 216                         free($1);
 217                 }
 218
 219 optional_assignment     : /* empty */
 220                         | assignment
 221
 222 assignment      : EQUALS
 223                 {
 224                         struct cmd_parse_state  *ps = &parse_state;
 225                         int                      flags = ps->input->flags;
 226
 227                         if ((~flags & CMD_PARSE_PARSEONLY) &&
 228                             (ps->scope == NULL || ps->scope->flag))
 229                                 environ_put(global_environ, $1, 0);
 230                         free($1);
 231                 }
 232
 233 hidden_assignment : HIDDEN EQUALS
 234                 {
 235                         struct cmd_parse_state  *ps = &parse_state;
 236                         int                      flags = ps->input->flags;
 237
 238                         if ((~flags & CMD_PARSE_PARSEONLY) &&
 239                             (ps->scope == NULL || ps->scope->flag))
 240                                 environ_put(global_environ, $2, ENVIRON_HIDDEN);
 241                         free($2);
 242                 }
 243
 244 if_open         : IF expanded
 245                 {
 246                         struct cmd_parse_state  *ps = &parse_state;
 247                         struct cmd_parse_scope  *scope;
 248
 249                         scope = xmalloc(sizeof *scope);
 250                         $$ = scope->flag = format_true($2);
 251                         free($2);
 252
 253                         if (ps->scope != NULL)
 254                                 TAILQ_INSERT_HEAD(&ps->stack, ps->scope, entry);
 255                         ps->scope = scope;
 256                 }
 257
 258 if_else         : ELSE
 259                 {
 260                         struct cmd_parse_state  *ps = &parse_state;
 261                         struct cmd_parse_scope  *scope;
 262
 263                         scope = xmalloc(sizeof *scope);
 264                         scope->flag = !ps->scope->flag;
 265
 266                         free(ps->scope);
 267                         ps->scope = scope;
 268                 }
 269
 270 if_elif         : ELIF expanded
 271                 {
 272                         struct cmd_parse_state  *ps = &parse_state;
 273                         struct cmd_parse_scope  *scope;
 274
 275                         scope = xmalloc(sizeof *scope);
 276                         $$ = scope->flag = format_true($2);
 277                         free($2);
 278
 279                         free(ps->scope);
 280                         ps->scope = scope;
 281                 }
 282
 283 if_close        : ENDIF
 284                 {
 285                         struct cmd_parse_state  *ps = &parse_state;
 286
 287                         free(ps->scope);
 288                         ps->scope = TAILQ_FIRST(&ps->stack);
 289                         if (ps->scope != NULL)
 290                                 TAILQ_REMOVE(&ps->stack, ps->scope, entry);
 291                 }
 292
 293 condition       : if_open '\n' statements if_close
 294                 {
 295                         if ($1)
 296                                 $$ = $3;
 297                         else {
 298                                 $$ = cmd_parse_new_commands();
 299                                 cmd_parse_free_commands($3);
 300                         }
 301                 }
 302                 | if_open '\n' statements if_else '\n' statements if_close
 303                 {
 304                         if ($1) {
 305                                 $$ = $3;
 306                                 cmd_parse_free_commands($6);
 307                         } else {
 308                                 $$ = $6;
 309                                 cmd_parse_free_commands($3);
 310                         }
 311                 }
 312                 | if_open '\n' statements elif if_close
 313                 {
 314                         if ($1) {
 315                                 $$ = $3;
 316                                 cmd_parse_free_commands($4.commands);
 317                         } else if ($4.flag) {
 318                                 $$ = $4.commands;
 319                                 cmd_parse_free_commands($3);
 320                         } else {
 321                                 $$ = cmd_parse_new_commands();
 322                                 cmd_parse_free_commands($3);
 323                                 cmd_parse_free_commands($4.commands);
 324                         }
 325                 }
 326                 | if_open '\n' statements elif if_else '\n' statements if_close
 327                 {
 328                         if ($1) {
 329                                 $$ = $3;
 330                                 cmd_parse_free_commands($4.commands);
 331                                 cmd_parse_free_commands($7);
 332                         } else if ($4.flag) {
 333                                 $$ = $4.commands;
 334                                 cmd_parse_free_commands($3);
 335                                 cmd_parse_free_commands($7);
 336                         } else {
 337                                 $$ = $7;
 338                                 cmd_parse_free_commands($3);
 339                                 cmd_parse_free_commands($4.commands);
 340                         }
 341                 }
 342
 343 elif            : if_elif '\n' statements
 344                 {
 345                         if ($1) {
 346                                 $$.flag = 1;
 347                                 $$.commands = $3;
 348                         } else {
 349                                 $$.flag = 0;
 350                                 $$.commands = cmd_parse_new_commands();
 351                                 cmd_parse_free_commands($3);
 352                         }
 353                 }
 354                 | if_elif '\n' statements elif
 355                 {
 356                         if ($1) {
 357                                 $$.flag = 1;
 358                                 $$.commands = $3;
 359                                 cmd_parse_free_commands($4.commands);
 360                         } else if ($4.flag) {
 361                                 $$.flag = 1;
 362                                 $$.commands = $4.commands;
 363                                 cmd_parse_free_commands($3);
 364                         } else {
 365                                 $$.flag = 0;
 366                                 $$.commands = cmd_parse_new_commands();
 367                                 cmd_parse_free_commands($3);
 368                                 cmd_parse_free_commands($4.commands);
 369                         }
 370                 }
 371
 372 commands        : command
 373                 {
 374                         struct cmd_parse_state  *ps = &parse_state;
 375
 376                         $$ = cmd_parse_new_commands();
 377                         if (!TAILQ_EMPTY(&$1->arguments) &&
 378                             (ps->scope == NULL || ps->scope->flag))
 379                                 TAILQ_INSERT_TAIL($$, $1, entry);
 380                         else
 381                                 cmd_parse_free_command($1);
 382                 }
 383                 | commands ';'
 384                 {
 385                         $$ = $1;
 386                 }
 387                 | commands ';' condition1
 388                 {
 389                         $$ = $1;
 390                         TAILQ_CONCAT($$, $3, entry);
 391                         free($3);
 392                 }
 393                 | commands ';' command
 394                 {
 395                         struct cmd_parse_state  *ps = &parse_state;
 396
 397                         if (!TAILQ_EMPTY(&$3->arguments) &&
 398                             (ps->scope == NULL || ps->scope->flag)) {
 399                                 $$ = $1;
 400                                 TAILQ_INSERT_TAIL($$, $3, entry);
 401                         } else {
 402                                 $$ = cmd_parse_new_commands();
 403                                 cmd_parse_free_commands($1);
 404                                 cmd_parse_free_command($3);
 405                         }
 406                 }
 407                 | condition1
 408                 {
 409                         $$ = $1;
 410                 }
 411
 412 command         : assignment
 413                 {
 414                         struct cmd_parse_state  *ps = &parse_state;
 415
 416                         $$ = xcalloc(1, sizeof *$$);
 417                         $$->line = ps->input->line;
 418                         TAILQ_INIT(&$$->arguments);
 419                 }
 420                 | optional_assignment TOKEN
 421                 {
 422                         struct cmd_parse_state          *ps = &parse_state;
 423                         struct cmd_parse_argument       *arg;
 424
 425                         $$ = xcalloc(1, sizeof *$$);
 426                         $$->line = ps->input->line;
 427                         TAILQ_INIT(&$$->arguments);
 428
 429                         arg = xcalloc(1, sizeof *arg);
 430                         arg->type = CMD_PARSE_STRING;
 431                         arg->string = $2;
 432                         TAILQ_INSERT_HEAD(&$$->arguments, arg, entry);
 433                 }
 434                 | optional_assignment TOKEN arguments
 435                 {
 436                         struct cmd_parse_state          *ps = &parse_state;
 437                         struct cmd_parse_argument       *arg;
 438
 439                         $$ = xcalloc(1, sizeof *$$);
 440                         $$->line = ps->input->line;
 441                         TAILQ_INIT(&$$->arguments);
 442
 443                         TAILQ_CONCAT(&$$->arguments, $3, entry);
 444                         free($3);
 445
 446                         arg = xcalloc(1, sizeof *arg);
 447                         arg->type = CMD_PARSE_STRING;
 448                         arg->string = $2;
 449                         TAILQ_INSERT_HEAD(&$$->arguments, arg, entry);
 450                 }
 451
 452 condition1      : if_open commands if_close
 453                 {
 454                         if ($1)
 455                                 $$ = $2;
 456                         else {
 457                                 $$ = cmd_parse_new_commands();
 458                                 cmd_parse_free_commands($2);
 459                         }
 460                 }
 461                 | if_open commands if_else commands if_close
 462                 {
 463                         if ($1) {
 464                                 $$ = $2;
 465                                 cmd_parse_free_commands($4);
 466                         } else {
 467                                 $$ = $4;
 468                                 cmd_parse_free_commands($2);
 469                         }
 470                 }
 471                 | if_open commands elif1 if_close
 472                 {
 473                         if ($1) {
 474                                 $$ = $2;
 475                                 cmd_parse_free_commands($3.commands);
 476                         } else if ($3.flag) {
 477                                 $$ = $3.commands;
 478                                 cmd_parse_free_commands($2);
 479                         } else {
 480                                 $$ = cmd_parse_new_commands();
 481                                 cmd_parse_free_commands($2);
 482                                 cmd_parse_free_commands($3.commands);
 483                         }
 484                 }
 485                 | if_open commands elif1 if_else commands if_close
 486                 {
 487                         if ($1) {
 488                                 $$ = $2;
 489                                 cmd_parse_free_commands($3.commands);
 490                                 cmd_parse_free_commands($5);
 491                         } else if ($3.flag) {
 492                                 $$ = $3.commands;
 493                                 cmd_parse_free_commands($2);
 494                                 cmd_parse_free_commands($5);
 495                         } else {
 496                                 $$ = $5;
 497                                 cmd_parse_free_commands($2);
 498                                 cmd_parse_free_commands($3.commands);
 499                         }
 500                 }
 501
 502 elif1           : if_elif commands
 503                 {
 504                         if ($1) {
 505                                 $$.flag = 1;
 506                                 $$.commands = $2;
 507                         } else {
 508                                 $$.flag = 0;
 509                                 $$.commands = cmd_parse_new_commands();
 510                                 cmd_parse_free_commands($2);
 511                         }
 512                 }
 513                 | if_elif commands elif1
 514                 {
 515                         if ($1) {
 516                                 $$.flag = 1;
 517                                 $$.commands = $2;
 518                                 cmd_parse_free_commands($3.commands);
 519                         } else if ($3.flag) {
 520                                 $$.flag = 1;
 521                                 $$.commands = $3.commands;
 522                                 cmd_parse_free_commands($2);
 523                         } else {
 524                                 $$.flag = 0;
 525                                 $$.commands = cmd_parse_new_commands();
 526                                 cmd_parse_free_commands($2);
 527                                 cmd_parse_free_commands($3.commands);
 528                         }
 529                 }
 530
 531 arguments       : argument
 532                 {
 533                         $$ = xcalloc(1, sizeof *$$);
 534                         TAILQ_INIT($$);
 535
 536                         TAILQ_INSERT_HEAD($$, $1, entry);
 537                 }
 538                 | argument arguments
 539                 {
 540                         TAILQ_INSERT_HEAD($2, $1, entry);
 541                         $$ = $2;
 542                 }
 543
 544 argument        : TOKEN
 545                 {
 546                         $$ = xcalloc(1, sizeof *$$);
 547                         $$->type = CMD_PARSE_STRING;
 548                         $$->string = $1;
 549                 }
 550                 | EQUALS
 551                 {
 552                         $$ = xcalloc(1, sizeof *$$);
 553                         $$->type = CMD_PARSE_STRING;
 554                         $$->string = $1;
 555                 }
 556                 | '{' argument_statements
 557                 {
 558                         $$ = xcalloc(1, sizeof *$$);
 559                         $$->type = CMD_PARSE_COMMANDS;
 560                         $$->commands = $2;
 561                 }
 562
 563 argument_statements     : statement '}'
 564                         {
 565                                 $$ = $1;
 566                         }
 567                         | statements statement '}'
 568                         {
 569                                 $$ = $1;
 570                                 TAILQ_CONCAT($$, $2, entry);
 571                                 free($2);
 572                         }
 573
 574 %%
 575
 576 static char *
 577 cmd_parse_get_error(const char *file, u_int line, const char *error)
 578 {
 579         char    *s;
 580
 581         if (file == NULL)
 582                 s = xstrdup(error);
 583         else
 584                 xasprintf(&s, "%s:%u: %s", file, line, error);
 585         return (s);
 586 }
 587
 588 static void
 589 cmd_parse_print_commands(struct cmd_parse_input *pi, struct cmd_list *cmdlist)
 590 {
 591         char    *s;
 592
 593         if (pi->item == NULL || (~pi->flags & CMD_PARSE_VERBOSE))
 594                 return;
 595         s = cmd_list_print(cmdlist, 0);
 596         if (pi->file != NULL)
 597                 cmdq_print(pi->item, "%s:%u: %s", pi->file, pi->line, s);
 598         else
 599                 cmdq_print(pi->item, "%u: %s", pi->line, s);
 600         free(s);
 601 }
 602
 603 static void
 604 cmd_parse_free_argument(struct cmd_parse_argument *arg)
 605 {
 606         switch (arg->type) {
 607         case CMD_PARSE_STRING:
 608                 free(arg->string);
 609                 break;
 610         case CMD_PARSE_COMMANDS:
 611                 cmd_parse_free_commands(arg->commands);
 612                 break;
 613         case CMD_PARSE_PARSED_COMMANDS:
 614                 cmd_list_free(arg->cmdlist);
 615                 break;
 616         }
 617         free(arg);
 618 }
 619
 620 static void
 621 cmd_parse_free_arguments(struct cmd_parse_arguments *args)
 622 {
 623         struct cmd_parse_argument       *arg, *arg1;
 624
 625         TAILQ_FOREACH_SAFE(arg, args, entry, arg1) {
 626                 TAILQ_REMOVE(args, arg, entry);
 627                 cmd_parse_free_argument(arg);
 628         }
 629 }
 630
 631 static void
 632 cmd_parse_free_command(struct cmd_parse_command *cmd)
 633 {
 634         cmd_parse_free_arguments(&cmd->arguments);
 635         free(cmd);
 636 }
 637
 638 static struct cmd_parse_commands *
 639 cmd_parse_new_commands(void)
 640 {
 641         struct cmd_parse_commands       *cmds;
 642
 643         cmds = xmalloc(sizeof *cmds);
 644         TAILQ_INIT(cmds);
 645         return (cmds);
 646 }
 647
 648 static void
 649 cmd_parse_free_commands(struct cmd_parse_commands *cmds)
 650 {
 651         struct cmd_parse_command        *cmd, *cmd1;
 652
 653         TAILQ_FOREACH_SAFE(cmd, cmds, entry, cmd1) {
 654                 TAILQ_REMOVE(cmds, cmd, entry);
 655                 cmd_parse_free_command(cmd);
 656         }
 657         free(cmds);
 658 }
 659
 660 static struct cmd_parse_commands *
 661 cmd_parse_run_parser(char **cause)
 662 {
 663         struct cmd_parse_state  *ps = &parse_state;
 664         struct cmd_parse_scope  *scope, *scope1;
 665         int                      retval;
 666
 667         ps->commands = NULL;
 668         TAILQ_INIT(&ps->stack);
 669
 670         retval = yyparse();
 671         TAILQ_FOREACH_SAFE(scope, &ps->stack, entry, scope1) {
 672                 TAILQ_REMOVE(&ps->stack, scope, entry);
 673                 free(scope);
 674         }
 675         if (retval != 0) {
 676                 *cause = ps->error;
 677                 return (NULL);
 678         }
 679
 680         if (ps->commands == NULL)
 681                 return (cmd_parse_new_commands());
 682         return (ps->commands);
 683 }
 684
 685 static struct cmd_parse_commands *
 686 cmd_parse_do_file(FILE *f, struct cmd_parse_input *pi, char **cause)
 687 {
 688         struct cmd_parse_state  *ps = &parse_state;
 689
 690         memset(ps, 0, sizeof *ps);
 691         ps->input = pi;
 692         ps->f = f;
 693         return (cmd_parse_run_parser(cause));
 694 }
 695
 696 static struct cmd_parse_commands *
 697 cmd_parse_do_buffer(const char *buf, size_t len, struct cmd_parse_input *pi,
 698     char **cause)
 699 {
 700         struct cmd_parse_state  *ps = &parse_state;
 701
 702         memset(ps, 0, sizeof *ps);
 703         ps->input = pi;
 704         ps->buf = buf;
 705         ps->len = len;
 706         return (cmd_parse_run_parser(cause));
 707 }
 708
 709 static void
 710 cmd_parse_log_commands(struct cmd_parse_commands *cmds, const char *prefix)
 711 {
 712         struct cmd_parse_command        *cmd;
 713         struct cmd_parse_argument       *arg;
 714         u_int                            i, j;
 715         char                            *s;
 716
 717         i = 0;
 718         TAILQ_FOREACH(cmd, cmds, entry) {
 719                 j = 0;
 720                 TAILQ_FOREACH(arg, &cmd->arguments, entry) {
 721                         switch (arg->type) {
 722                         case CMD_PARSE_STRING:
 723                                 log_debug("%s %u:%u: %s", prefix, i, j,
 724                                     arg->string);
 725                                 break;
 726                         case CMD_PARSE_COMMANDS:
 727                                 xasprintf(&s, "%s %u:%u", prefix, i, j);
 728                                 cmd_parse_log_commands(arg->commands, s);
 729                                 free(s);
 730                                 break;
 731                         case CMD_PARSE_PARSED_COMMANDS:
 732                                 s = cmd_list_print(arg->cmdlist, 0);
 733                                 log_debug("%s %u:%u: %s", prefix, i, j, s);
 734                                 free(s);
 735                                 break;
 736                         }
 737                         j++;
 738                 }
 739                 i++;
 740         }
 741 }
 742
 743 static int
 744 cmd_parse_expand_alias(struct cmd_parse_command *cmd,
 745     struct cmd_parse_input *pi, struct cmd_parse_result *pr)
 746 {
 747         struct cmd_parse_argument       *arg, *arg1, *first;
 748         struct cmd_parse_commands       *cmds;
 749         struct cmd_parse_command        *last;
 750         char                            *alias, *name, *cause;
 751
 752         if (pi->flags & CMD_PARSE_NOALIAS)
 753                 return (0);
 754         memset(pr, 0, sizeof *pr);
 755
 756         first = TAILQ_FIRST(&cmd->arguments);
 757         if (first == NULL || first->type != CMD_PARSE_STRING) {
 758                 pr->status = CMD_PARSE_SUCCESS;
 759                 pr->cmdlist = cmd_list_new();
 760                 return (1);
 761         }
 762         name = first->string;
 763
 764         alias = cmd_get_alias(name);
 765         if (alias == NULL)
 766                 return (0);
 767         log_debug("%s: %u alias %s = %s", __func__, pi->line, name, alias);
 768
 769         cmds = cmd_parse_do_buffer(alias, strlen(alias), pi, &cause);
 770         free(alias);
 771         if (cmds == NULL) {
 772                 pr->status = CMD_PARSE_ERROR;
 773                 pr->error = cause;
 774                 return (1);
 775         }
 776
 777         last = TAILQ_LAST(cmds, cmd_parse_commands);
 778         if (last == NULL) {
 779                 pr->status = CMD_PARSE_SUCCESS;
 780                 pr->cmdlist = cmd_list_new();
 781                 return (1);
 782         }
 783
 784         TAILQ_REMOVE(&cmd->arguments, first, entry);
 785         cmd_parse_free_argument(first);
 786
 787         TAILQ_FOREACH_SAFE(arg, &cmd->arguments, entry, arg1) {
 788                 TAILQ_REMOVE(&cmd->arguments, arg, entry);
 789                 TAILQ_INSERT_TAIL(&last->arguments, arg, entry);
 790         }
 791         cmd_parse_log_commands(cmds, __func__);
 792
 793         pi->flags |= CMD_PARSE_NOALIAS;
 794         cmd_parse_build_commands(cmds, pi, pr);
 795         pi->flags &= ~CMD_PARSE_NOALIAS;
 796         return (1);
 797 }
 798
 799 static void
 800 cmd_parse_build_command(struct cmd_parse_command *cmd,
 801     struct cmd_parse_input *pi, struct cmd_parse_result *pr)
 802 {
 803         struct cmd_parse_argument       *arg;
 804         struct cmd                      *add;
 805         char                            *cause;
 806         struct args_value               *values = NULL;
 807         u_int                            count = 0, idx;
 808
 809         memset(pr, 0, sizeof *pr);
 810
 811         if (cmd_parse_expand_alias(cmd, pi, pr))
 812                 return;
 813
 814         TAILQ_FOREACH(arg, &cmd->arguments, entry) {
 815                 values = xrecallocarray(values, count, count + 1,
 816                     sizeof *values);
 817                 switch (arg->type) {
 818                 case CMD_PARSE_STRING:
 819                         values[count].type = ARGS_STRING;
 820                         values[count].string = xstrdup(arg->string);
 821                         break;
 822                 case CMD_PARSE_COMMANDS:
 823                         cmd_parse_build_commands(arg->commands, pi, pr);
 824                         if (pr->status != CMD_PARSE_SUCCESS)
 825                                 goto out;
 826                         values[count].type = ARGS_COMMANDS;
 827                         values[count].cmdlist = pr->cmdlist;
 828                         break;
 829                 case CMD_PARSE_PARSED_COMMANDS:
 830                         values[count].type = ARGS_COMMANDS;
 831                         values[count].cmdlist = arg->cmdlist;
 832                         values[count].cmdlist->references++;
 833                         break;
 834                 }
 835                 count++;
 836         }
 837
 838         add = cmd_parse(values, count, pi->file, pi->line, &cause);
 839         if (add == NULL) {
 840                 pr->status = CMD_PARSE_ERROR;
 841                 pr->error = cmd_parse_get_error(pi->file, pi->line, cause);
 842                 free(cause);
 843                 goto out;
 844         }
 845         pr->status = CMD_PARSE_SUCCESS;
 846         pr->cmdlist = cmd_list_new();
 847         cmd_list_append(pr->cmdlist, add);
 848
 849 out:
 850         for (idx = 0; idx < count; idx++)
 851                 args_free_value(&values[idx]);
 852         free(values);
 853 }
 854
 855 static void
 856 cmd_parse_build_commands(struct cmd_parse_commands *cmds,
 857     struct cmd_parse_input *pi, struct cmd_parse_result *pr)
 858 {
 859         struct cmd_parse_command        *cmd;
 860         u_int                            line = UINT_MAX;
 861         struct cmd_list                 *current = NULL, *result;
 862         char                            *s;
 863
 864         memset(pr, 0, sizeof *pr);
 865
 866         /* Check for an empty list. */
 867         if (TAILQ_EMPTY(cmds)) {
 868                 pr->status = CMD_PARSE_SUCCESS;
 869                 pr->cmdlist = cmd_list_new();
 870                 return;
 871         }
 872         cmd_parse_log_commands(cmds, __func__);
 873
 874         /*
 875          * Parse each command into a command list. Create a new command list
 876          * for each line (unless the flag is set) so they get a new group (so
 877          * the queue knows which ones to remove if a command fails when
 878          * executed).
 879          */
 880         result = cmd_list_new();
 881         TAILQ_FOREACH(cmd, cmds, entry) {
 882                 if (((~pi->flags & CMD_PARSE_ONEGROUP) && cmd->line != line)) {
 883                         if (current != NULL) {
 884                                 cmd_parse_print_commands(pi, current);
 885                                 cmd_list_move(result, current);
 886                                 cmd_list_free(current);
 887                         }
 888                         current = cmd_list_new();
 889                 }
 890                 if (current == NULL)
 891                         current = cmd_list_new();
 892                 line = pi->line = cmd->line;
 893
 894                 cmd_parse_build_command(cmd, pi, pr);
 895                 if (pr->status != CMD_PARSE_SUCCESS) {
 896                         cmd_list_free(result);
 897                         cmd_list_free(current);
 898                         return;
 899                 }
 900                 cmd_list_append_all(current, pr->cmdlist);
 901                 cmd_list_free(pr->cmdlist);
 902         }
 903         if (current != NULL) {
 904                 cmd_parse_print_commands(pi, current);
 905                 cmd_list_move(result, current);
 906                 cmd_list_free(current);
 907         }
 908
 909         s = cmd_list_print(result, 0);
 910         log_debug("%s: %s", __func__, s);
 911         free(s);
 912
 913         pr->status = CMD_PARSE_SUCCESS;
 914         pr->cmdlist = result;
 915 }
 916
 917 struct cmd_parse_result *
 918 cmd_parse_from_file(FILE *f, struct cmd_parse_input *pi)
 919 {
 920         static struct cmd_parse_result   pr;
 921         struct cmd_parse_input           input;
 922         struct cmd_parse_commands       *cmds;
 923         char                            *cause;
 924
 925         if (pi == NULL) {
 926                 memset(&input, 0, sizeof input);
 927                 pi = &input;
 928         }
 929         memset(&pr, 0, sizeof pr);
 930
 931         cmds = cmd_parse_do_file(f, pi, &cause);
 932         if (cmds == NULL) {
 933                 pr.status = CMD_PARSE_ERROR;
 934                 pr.error = cause;
 935                 return (&pr);
 936         }
 937         cmd_parse_build_commands(cmds, pi, &pr);
 938         cmd_parse_free_commands(cmds);
 939         return (&pr);
 940
 941 }
 942
 943 struct cmd_parse_result *
 944 cmd_parse_from_string(const char *s, struct cmd_parse_input *pi)
 945 {
 946         struct cmd_parse_input  input;
 947
 948         if (pi == NULL) {
 949                 memset(&input, 0, sizeof input);
 950                 pi = &input;
 951         }
 952
 953         /*
 954          * When parsing a string, put commands in one group even if there are
 955          * multiple lines. This means { a \n b } is identical to "a ; b" when
 956          * given as an argument to another command.
 957          */
 958         pi->flags |= CMD_PARSE_ONEGROUP;
 959         return (cmd_parse_from_buffer(s, strlen(s), pi));
 960 }
 961
 962 enum cmd_parse_status
 963 cmd_parse_and_insert(const char *s, struct cmd_parse_input *pi,
 964     struct cmdq_item *after, struct cmdq_state *state, char **error)
 965 {
 966         struct cmd_parse_result *pr;
 967         struct cmdq_item        *item;
 968
 969         pr = cmd_parse_from_string(s, pi);
 970         switch (pr->status) {
 971         case CMD_PARSE_ERROR:
 972                 if (error != NULL)
 973                         *error = pr->error;
 974                 else
 975                         free(pr->error);
 976                 break;
 977         case CMD_PARSE_SUCCESS:
 978                 item = cmdq_get_command(pr->cmdlist, state);
 979                 cmdq_insert_after(after, item);
 980                 cmd_list_free(pr->cmdlist);
 981                 break;
 982         }
 983         return (pr->status);
 984 }
 985
 986 enum cmd_parse_status
 987 cmd_parse_and_append(const char *s, struct cmd_parse_input *pi,
 988     struct client *c, struct cmdq_state *state, char **error)
 989 {
 990         struct cmd_parse_result *pr;
 991         struct cmdq_item        *item;
 992
 993         pr = cmd_parse_from_string(s, pi);
 994         switch (pr->status) {
 995         case CMD_PARSE_ERROR:
 996                 if (error != NULL)
 997                         *error = pr->error;
 998                 else
 999                         free(pr->error);
1000                 break;
1001         case CMD_PARSE_SUCCESS:
1002                 item = cmdq_get_command(pr->cmdlist, state);
1003                 cmdq_append(c, item);
1004                 cmd_list_free(pr->cmdlist);
1005                 break;
1006         }
1007         return (pr->status);
1008 }
1009
1010 struct cmd_parse_result *
1011 cmd_parse_from_buffer(const void *buf, size_t len, struct cmd_parse_input *pi)
1012 {
1013         static struct cmd_parse_result   pr;
1014         struct cmd_parse_input           input;
1015         struct cmd_parse_commands       *cmds;
1016         char                            *cause;
1017
1018         if (pi == NULL) {
1019                 memset(&input, 0, sizeof input);
1020                 pi = &input;
1021         }
1022         memset(&pr, 0, sizeof pr);
1023
1024         if (len == 0) {
1025                 pr.status = CMD_PARSE_SUCCESS;
1026                 pr.cmdlist = cmd_list_new();
1027                 return (&pr);
1028         }
1029
1030         cmds = cmd_parse_do_buffer(buf, len, pi, &cause);
1031         if (cmds == NULL) {
1032                 pr.status = CMD_PARSE_ERROR;
1033                 pr.error = cause;
1034                 return (&pr);
1035         }
1036         cmd_parse_build_commands(cmds, pi, &pr);
1037         cmd_parse_free_commands(cmds);
1038         return (&pr);
1039 }
1040
1041 struct cmd_parse_result *
1042 cmd_parse_from_arguments(struct args_value *values, u_int count,
1043     struct cmd_parse_input *pi)
1044 {
1045         static struct cmd_parse_result   pr;
1046         struct cmd_parse_input           input;
1047         struct cmd_parse_commands       *cmds;
1048         struct cmd_parse_command        *cmd;
1049         struct cmd_parse_argument       *arg;
1050         u_int                            i;
1051         char                            *copy;
1052         size_t                           size;
1053         int                              end;
1054
1055         /*
1056          * The commands are already split up into arguments, so just separate
1057          * into a set of commands by ';'.
1058          */
1059
1060         if (pi == NULL) {
1061                 memset(&input, 0, sizeof input);
1062                 pi = &input;
1063         }
1064         memset(&pr, 0, sizeof pr);
1065
1066         cmds = cmd_parse_new_commands();
1067
1068         cmd = xcalloc(1, sizeof *cmd);
1069         cmd->line = pi->line;
1070         TAILQ_INIT(&cmd->arguments);
1071
1072         for (i = 0; i < count; i++) {
1073                 end = 0;
1074                 if (values[i].type == ARGS_STRING) {
1075                         copy = xstrdup(values[i].string);
1076                         size = strlen(copy);
1077                         if (size != 0 && copy[size - 1] == ';') {
1078                                 copy[--size] = '\0';
1079                                 if (size > 0 && copy[size - 1] == '\\')
1080                                         copy[size - 1] = ';';
1081                                 else
1082                                         end = 1;
1083                         }
1084                         if (!end || size != 0) {
1085                                 arg = xcalloc(1, sizeof *arg);
1086                                 arg->type = CMD_PARSE_STRING;
1087                                 arg->string = copy;
1088                                 TAILQ_INSERT_TAIL(&cmd->arguments, arg, entry);
1089                         } else
1090                                 free(copy);
1091                 } else if (values[i].type == ARGS_COMMANDS) {
1092                         arg = xcalloc(1, sizeof *arg);
1093                         arg->type = CMD_PARSE_PARSED_COMMANDS;
1094                         arg->cmdlist = values[i].cmdlist;
1095                         arg->cmdlist->references++;
1096                         TAILQ_INSERT_TAIL(&cmd->arguments, arg, entry);
1097                 } else
1098                         fatalx("unknown argument type");
1099                 if (end) {
1100                         TAILQ_INSERT_TAIL(cmds, cmd, entry);
1101                         cmd = xcalloc(1, sizeof *cmd);
1102                         cmd->line = pi->line;
1103                         TAILQ_INIT(&cmd->arguments);
1104                 }
1105         }
1106         if (!TAILQ_EMPTY(&cmd->arguments))
1107                 TAILQ_INSERT_TAIL(cmds, cmd, entry);
1108         else
1109                 free(cmd);
1110
1111         cmd_parse_build_commands(cmds, pi, &pr);
1112         cmd_parse_free_commands(cmds);
1113         return (&pr);
1114 }
1115
1116 static int printflike(1, 2)
1117 yyerror(const char *fmt, ...)
1118 {
1119         struct cmd_parse_state  *ps = &parse_state;
1120         struct cmd_parse_input  *pi = ps->input;
1121         va_list                  ap;
1122         char                    *error;
1123
1124         if (ps->error != NULL)
1125                 return (0);
1126
1127         va_start(ap, fmt);
1128         xvasprintf(&error, fmt, ap);
1129         va_end(ap);
1130
1131         ps->error = cmd_parse_get_error(pi->file, pi->line, error);
1132         free(error);
1133         return (0);
1134 }
1135
1136 static int
1137 yylex_is_var(char ch, int first)
1138 {
1139         if (ch == '=')
1140                 return (0);
1141         if (first && isdigit((u_char)ch))
1142                 return (0);
1143         return (isalnum((u_char)ch) || ch == '_');
1144 }
1145
1146 static void
1147 yylex_append(char **buf, size_t *len, const char *add, size_t addlen)
1148 {
1149         if (addlen > SIZE_MAX - 1 || *len > SIZE_MAX - 1 - addlen)
1150                 fatalx("buffer is too big");
1151         *buf = xrealloc(*buf, (*len) + 1 + addlen);
1152         memcpy((*buf) + *len, add, addlen);
1153         (*len) += addlen;
1154 }
1155
1156 static void
1157 yylex_append1(char **buf, size_t *len, char add)
1158 {
1159         yylex_append(buf, len, &add, 1);
1160 }
1161
1162 static int
1163 yylex_getc1(void)
1164 {
1165         struct cmd_parse_state  *ps = &parse_state;
1166         int                      ch;
1167
1168         if (ps->f != NULL)
1169                 ch = getc(ps->f);
1170         else {
1171                 if (ps->off == ps->len)
1172                         ch = EOF;
1173                 else
1174                         ch = ps->buf[ps->off++];
1175         }
1176         return (ch);
1177 }
1178
1179 static void
1180 yylex_ungetc(int ch)
1181 {
1182         struct cmd_parse_state  *ps = &parse_state;
1183
1184         if (ps->f != NULL)
1185                 ungetc(ch, ps->f);
1186         else if (ps->off > 0 && ch != EOF)
1187                 ps->off--;
1188 }
1189
1190 static int
1191 yylex_getc(void)
1192 {
1193         struct cmd_parse_state  *ps = &parse_state;
1194         int                      ch;
1195
1196         if (ps->escapes != 0) {
1197                 ps->escapes--;
1198                 return ('\\');
1199         }
1200         for (;;) {
1201                 ch = yylex_getc1();
1202                 if (ch == '\\') {
1203                         ps->escapes++;
1204                         continue;
1205                 }
1206                 if (ch == '\n' && (ps->escapes % 2) == 1) {
1207                         ps->input->line++;
1208                         ps->escapes--;
1209                         continue;
1210                 }
1211
1212                 if (ps->escapes != 0) {
1213                         yylex_ungetc(ch);
1214                         ps->escapes--;
1215                         return ('\\');
1216                 }
1217                 return (ch);
1218         }
1219 }
1220
1221 static char *
1222 yylex_get_word(int ch)
1223 {
1224         char    *buf;
1225         size_t   len;
1226
1227         len = 0;
1228         buf = xmalloc(1);
1229
1230         do
1231                 yylex_append1(&buf, &len, ch);
1232         while ((ch = yylex_getc()) != EOF && strchr(" \t\n", ch) == NULL);
1233         yylex_ungetc(ch);
1234
1235         buf[len] = '\0';
1236         log_debug("%s: %s", __func__, buf);
1237         return (buf);
1238 }
1239
1240 static int
1241 yylex(void)
1242 {
1243         struct cmd_parse_state  *ps = &parse_state;
1244         char                    *token, *cp;
1245         int                      ch, next, condition;
1246
1247         if (ps->eol)
1248                 ps->input->line++;
1249         ps->eol = 0;
1250
1251         condition = ps->condition;
1252         ps->condition = 0;
1253
1254         for (;;) {
1255                 ch = yylex_getc();
1256
1257                 if (ch == EOF) {
1258                         /*
1259                          * Ensure every file or string is terminated by a
1260                          * newline. This keeps the parser simpler and avoids
1261                          * having to add a newline to each string.
1262                          */
1263                         if (ps->eof)
1264                                 break;
1265                         ps->eof = 1;
1266                         return ('\n');
1267                 }
1268
1269                 if (ch == ' ' || ch == '\t') {
1270                         /*
1271                          * Ignore whitespace.
1272                          */
1273                         continue;
1274                 }
1275
1276                 if (ch == '\n') {
1277                         /*
1278                          * End of line. Update the line number.
1279                          */
1280                         ps->eol = 1;
1281                         return ('\n');
1282                 }
1283
1284                 if (ch == ';' || ch == '{' || ch == '}') {
1285                         /*
1286                          * A semicolon or { or } is itself.
1287                          */
1288                         return (ch);
1289                 }
1290
1291                 if (ch == '#') {
1292                         /*
1293                          * #{ after a condition opens a format; anything else
1294                          * is a comment, ignore up to the end of the line.
1295                          */
1296                         next = yylex_getc();
1297                         if (condition && next == '{') {
1298                                 yylval.token = yylex_format();
1299                                 if (yylval.token == NULL)
1300                                         return (ERROR);
1301                                 return (FORMAT);
1302                         }
1303                         while (next != '\n' && next != EOF)
1304                                 next = yylex_getc();
1305                         if (next == '\n') {
1306                                 ps->input->line++;
1307                                 return ('\n');
1308                         }
1309                         continue;
1310                 }
1311
1312                 if (ch == '%') {
1313                         /*
1314                          * % is a condition unless it is all % or all numbers,
1315                          * then it is a token.
1316                          */
1317                         yylval.token = yylex_get_word('%');
1318                         for (cp = yylval.token; *cp != '\0'; cp++) {
1319                                 if (*cp != '%' && !isdigit((u_char)*cp))
1320                                         break;
1321                         }
1322                         if (*cp == '\0')
1323                                 return (TOKEN);
1324                         ps->condition = 1;
1325                         if (strcmp(yylval.token, "%hidden") == 0) {
1326                                 free(yylval.token);
1327                                 return (HIDDEN);
1328                         }
1329                         if (strcmp(yylval.token, "%if") == 0) {
1330                                 free(yylval.token);
1331                                 return (IF);
1332                         }
1333                         if (strcmp(yylval.token, "%else") == 0) {
1334                                 free(yylval.token);
1335                                 return (ELSE);
1336                         }
1337                         if (strcmp(yylval.token, "%elif") == 0) {
1338                                 free(yylval.token);
1339                                 return (ELIF);
1340                         }
1341                         if (strcmp(yylval.token, "%endif") == 0) {
1342                                 free(yylval.token);
1343                                 return (ENDIF);
1344                         }
1345                         free(yylval.token);
1346                         return (ERROR);
1347                 }
1348
1349                 /*
1350                  * Otherwise this is a token.
1351                  */
1352                 token = yylex_token(ch);
1353                 if (token == NULL)
1354                         return (ERROR);
1355                 yylval.token = token;
1356
1357                 if (strchr(token, '=') != NULL && yylex_is_var(*token, 1)) {
1358                         for (cp = token + 1; *cp != '='; cp++) {
1359                                 if (!yylex_is_var(*cp, 0))
1360                                         break;
1361                         }
1362                         if (*cp == '=')
1363                                 return (EQUALS);
1364                 }
1365                 return (TOKEN);
1366         }
1367         return (0);
1368 }
1369
1370 static char *
1371 yylex_format(void)
1372 {
1373         char    *buf;
1374         size_t   len;
1375         int      ch, brackets = 1;
1376
1377         len = 0;
1378         buf = xmalloc(1);
1379
1380         yylex_append(&buf, &len, "#{", 2);
1381         for (;;) {
1382                 if ((ch = yylex_getc()) == EOF || ch == '\n')
1383                         goto error;
1384                 if (ch == '#') {
1385                         if ((ch = yylex_getc()) == EOF || ch == '\n')
1386                                 goto error;
1387                         if (ch == '{')
1388                                 brackets++;
1389                         yylex_append1(&buf, &len, '#');
1390                 } else if (ch == '}') {
1391                         if (brackets != 0 && --brackets == 0) {
1392                                 yylex_append1(&buf, &len, ch);
1393                                 break;
1394                         }
1395                 }
1396                 yylex_append1(&buf, &len, ch);
1397         }
1398         if (brackets != 0)
1399                 goto error;
1400
1401         buf[len] = '\0';
1402         log_debug("%s: %s", __func__, buf);
1403         return (buf);
1404
1405 error:
1406         free(buf);
1407         return (NULL);
1408 }
1409
1410 static int
1411 yylex_token_escape(char **buf, size_t *len)
1412 {
1413         int      ch, type, o2, o3, mlen;
1414         u_int    size, i, tmp;
1415         char     s[9], m[MB_LEN_MAX];
1416
1417         ch = yylex_getc();
1418
1419         if (ch >= '4' && ch <= '7') {
1420                 yyerror("invalid octal escape");
1421                 return (0);
1422         }
1423         if (ch >= '0' && ch <= '3') {
1424                 o2 = yylex_getc();
1425                 if (o2 >= '0' && o2 <= '7') {
1426                         o3 = yylex_getc();
1427                         if (o3 >= '0' && o3 <= '7') {
1428                                 ch = 64 * (ch - '0') +
1429                                       8 * (o2 - '0') +
1430                                           (o3 - '0');
1431                                 yylex_append1(buf, len, ch);
1432                                 return (1);
1433                         }
1434                 }
1435                 yyerror("invalid octal escape");
1436                 return (0);
1437         }
1438
1439         switch (ch) {
1440         case EOF:
1441                 return (0);
1442         case 'a':
1443                 ch = '\a';
1444                 break;
1445         case 'b':
1446                 ch = '\b';
1447                 break;
1448         case 'e':
1449                 ch = '\033';
1450                 break;
1451         case 'f':
1452                 ch = '\f';
1453                 break;
1454         case 's':
1455                 ch = ' ';
1456                 break;
1457         case 'v':
1458                 ch = '\v';
1459                 break;
1460         case 'r':
1461                 ch = '\r';
1462                 break;
1463         case 'n':
1464                 ch = '\n';
1465                 break;
1466         case 't':
1467                 ch = '\t';
1468                 break;
1469         case 'u':
1470                 type = 'u';
1471                 size = 4;
1472                 goto unicode;
1473         case 'U':
1474                 type = 'U';
1475                 size = 8;
1476                 goto unicode;
1477         }
1478
1479         yylex_append1(buf, len, ch);
1480         return (1);
1481
1482 unicode:
1483         for (i = 0; i < size; i++) {
1484                 ch = yylex_getc();
1485                 if (ch == EOF || ch == '\n')
1486                         return (0);
1487                 if (!isxdigit((u_char)ch)) {
1488                         yyerror("invalid \\%c argument", type);
1489                         return (0);
1490                 }
1491                 s[i] = ch;
1492         }
1493         s[i] = '\0';
1494
1495         if ((size == 4 && sscanf(s, "%4x", &tmp) != 1) ||
1496             (size == 8 && sscanf(s, "%8x", &tmp) != 1)) {
1497                 yyerror("invalid \\%c argument", type);
1498                 return (0);
1499         }
1500         mlen = wctomb(m, tmp);
1501         if (mlen <= 0 || mlen > (int)sizeof m) {
1502                 yyerror("invalid \\%c argument", type);
1503                 return (0);
1504         }
1505         yylex_append(buf, len, m, mlen);
1506         return (1);
1507 }
1508
1509 static int
1510 yylex_token_variable(char **buf, size_t *len)
1511 {
1512         struct environ_entry    *envent;
1513         int                      ch, brackets = 0;
1514         char                     name[1024];
1515         size_t                   namelen = 0;
1516         const char              *value;
1517
1518         ch = yylex_getc();
1519         if (ch == EOF)
1520                 return (0);
1521         if (ch == '{')
1522                 brackets = 1;
1523         else {
1524                 if (!yylex_is_var(ch, 1)) {
1525                         yylex_append1(buf, len, '$');
1526                         yylex_ungetc(ch);
1527                         return (1);
1528                 }
1529                 name[namelen++] = ch;
1530         }
1531
1532         for (;;) {
1533                 ch = yylex_getc();
1534                 if (brackets && ch == '}')
1535                         break;
1536                 if (ch == EOF || !yylex_is_var(ch, 0)) {
1537                         if (!brackets) {
1538                                 yylex_ungetc(ch);
1539                                 break;
1540                         }
1541                         yyerror("invalid environment variable");
1542                         return (0);
1543                 }
1544                 if (namelen == (sizeof name) - 2) {
1545                         yyerror("environment variable is too long");
1546                         return (0);
1547                 }
1548                 name[namelen++] = ch;
1549         }
1550         name[namelen] = '\0';
1551
1552         envent = environ_find(global_environ, name);
1553         if (envent != NULL && envent->value != NULL) {
1554                 value = envent->value;
1555                 log_debug("%s: %s -> %s", __func__, name, value);
1556                 yylex_append(buf, len, value, strlen(value));
1557         }
1558         return (1);
1559 }
1560
1561 static int
1562 yylex_token_tilde(char **buf, size_t *len)
1563 {
1564         struct environ_entry    *envent;
1565         int                      ch;
1566         char                     name[1024];
1567         size_t                   namelen = 0;
1568         struct passwd           *pw;
1569         const char              *home = NULL;
1570
1571         for (;;) {
1572                 ch = yylex_getc();
1573                 if (ch == EOF || strchr("/ \t\n\"'", ch) != NULL) {
1574                         yylex_ungetc(ch);
1575                         break;
1576                 }
1577                 if (namelen == (sizeof name) - 2) {
1578                         yyerror("user name is too long");
1579                         return (0);
1580                 }
1581                 name[namelen++] = ch;
1582         }
1583         name[namelen] = '\0';
1584
1585         if (*name == '\0') {
1586                 envent = environ_find(global_environ, "HOME");
1587                 if (envent != NULL && *envent->value != '\0')
1588                         home = envent->value;
1589                 else if ((pw = getpwuid(getuid())) != NULL)
1590                         home = pw->pw_dir;
1591         } else {
1592                 if ((pw = getpwnam(name)) != NULL)
1593                         home = pw->pw_dir;
1594         }
1595         if (home == NULL)
1596                 return (0);
1597
1598         log_debug("%s: ~%s -> %s", __func__, name, home);
1599         yylex_append(buf, len, home, strlen(home));
1600         return (1);
1601 }
1602
1603 static char *
1604 yylex_token(int ch)
1605 {
1606         char                    *buf;
1607         size_t                   len;
1608         enum { START,
1609                NONE,
1610                DOUBLE_QUOTES,
1611                SINGLE_QUOTES }   state = NONE, last = START;
1612
1613         len = 0;
1614         buf = xmalloc(1);
1615
1616         for (;;) {
1617                 /* EOF or \n are always the end of the token. */
1618                 if (ch == EOF || (state == NONE && ch == '\n'))
1619                         break;
1620
1621                 /* Whitespace or ; or } ends a token unless inside quotes. */
1622                 if ((ch == ' ' || ch == '\t' || ch == ';' || ch == '}') &&
1623                     state == NONE)
1624                         break;
1625
1626                 /*
1627                  * Spaces and comments inside quotes after \n are removed but
1628                  * the \n is left.
1629                  */
1630                 if (ch == '\n' && state != NONE) {
1631                         yylex_append1(&buf, &len, '\n');
1632                         while ((ch = yylex_getc()) == ' ' || ch == '\t')
1633                                 /* nothing */;
1634                         if (ch != '#')
1635                                 continue;
1636                         ch = yylex_getc();
1637                         if (strchr(",#{}:", ch) != NULL) {
1638                                 yylex_ungetc(ch);
1639                                 ch = '#';
1640                         } else {
1641                                 while ((ch = yylex_getc()) != '\n' && ch != EOF)
1642                                         /* nothing */;
1643                         }
1644                         continue;
1645                 }
1646
1647                 /* \ ~ and $ are expanded except in single quotes. */
1648                 if (ch == '\\' && state != SINGLE_QUOTES) {
1649                         if (!yylex_token_escape(&buf, &len))
1650                                 goto error;
1651                         goto skip;
1652                 }
1653                 if (ch == '~' && last != state && state != SINGLE_QUOTES) {
1654                         if (!yylex_token_tilde(&buf, &len))
1655                                 goto error;
1656                         goto skip;
1657                 }
1658                 if (ch == '$' && state != SINGLE_QUOTES) {
1659                         if (!yylex_token_variable(&buf, &len))
1660                                 goto error;
1661                         goto skip;
1662                 }
1663                 if (ch == '}' && state == NONE)
1664                         goto error;  /* unmatched (matched ones were handled) */
1665
1666                 /* ' and " starts or end quotes (and is consumed). */
1667                 if (ch == '\'') {
1668                         if (state == NONE) {
1669                                 state = SINGLE_QUOTES;
1670                                 goto next;
1671                         }
1672                         if (state == SINGLE_QUOTES) {
1673                                 state = NONE;
1674                                 goto next;
1675                         }
1676                 }
1677                 if (ch == '"') {
1678                         if (state == NONE) {
1679                                 state = DOUBLE_QUOTES;
1680                                 goto next;
1681                         }
1682                         if (state == DOUBLE_QUOTES) {
1683                                 state = NONE;
1684                                 goto next;
1685                         }
1686                 }
1687
1688                 /* Otherwise add the character to the buffer. */
1689                 yylex_append1(&buf, &len, ch);
1690
1691         skip:
1692                 last = state;
1693
1694         next:
1695                 ch = yylex_getc();
1696         }
1697         yylex_ungetc(ch);
1698
1699         buf[len] = '\0';
1700         log_debug("%s: %s", __func__, buf);
1701         return (buf);
1702
1703 error:
1704         free(buf);
1705         return (NULL);
1706 }