arguments.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2010 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 #include <sys/types.h>
  20
  21 #include <ctype.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <vis.h>
  25
  26 #include "tmux.h"
  27
  28 /*
  29  * Manipulate command arguments.
  30  */
  31
  32 /* List of argument values. */
  33 TAILQ_HEAD(args_values, args_value);
  34
  35 /* Single arguments flag. */
  36 struct args_entry {
  37         u_char                   flag;
  38         struct args_values       values;
  39         u_int                    count;
  40
  41         int                      flags;
  42 #define ARGS_ENTRY_OPTIONAL_VALUE 0x1
  43
  44         RB_ENTRY(args_entry)     entry;
  45 };
  46
  47 /* Parsed argument flags and values. */
  48 struct args {
  49         struct args_tree         tree;
  50         u_int                    count;
  51         struct args_value       *values;
  52 };
  53
  54 /* Prepared command state. */
  55 struct args_command_state {
  56         struct cmd_list         *cmdlist;
  57         char                    *cmd;
  58         struct cmd_parse_input   pi;
  59 };
  60
  61 static struct args_entry        *args_find(struct args *, u_char);
  62
  63 static int      args_cmp(struct args_entry *, struct args_entry *);
  64 RB_GENERATE_STATIC(args_tree, args_entry, entry, args_cmp);
  65
  66 /* Arguments tree comparison function. */
  67 static int
  68 args_cmp(struct args_entry *a1, struct args_entry *a2)
  69 {
  70         return (a1->flag - a2->flag);
  71 }
  72
  73 /* Find a flag in the arguments tree. */
  74 static struct args_entry *
  75 args_find(struct args *args, u_char flag)
  76 {
  77         struct args_entry       entry;
  78
  79         entry.flag = flag;
  80         return (RB_FIND(args_tree, &args->tree, &entry));
  81 }
  82
  83 /* Copy value. */
  84 static void
  85 args_copy_value(struct args_value *to, struct args_value *from)
  86 {
  87         to->type = from->type;
  88         switch (from->type) {
  89         case ARGS_NONE:
  90                 break;
  91         case ARGS_COMMANDS:
  92                 to->cmdlist = from->cmdlist;
  93                 to->cmdlist->references++;
  94                 break;
  95         case ARGS_STRING:
  96                 to->string = xstrdup(from->string);
  97                 break;
  98         }
  99 }
 100
 101 /* Type to string. */
 102 static const char *
 103 args_type_to_string (enum args_type type)
 104 {
 105         switch (type)
 106         {
 107         case ARGS_NONE:
 108                 return "NONE";
 109         case ARGS_STRING:
 110                 return "STRING";
 111         case ARGS_COMMANDS:
 112                 return "COMMANDS";
 113         }
 114         return "INVALID";
 115 }
 116
 117 /* Get value as string. */
 118 static const char *
 119 args_value_as_string(struct args_value *value)
 120 {
 121         switch (value->type) {
 122         case ARGS_NONE:
 123                 return ("");
 124         case ARGS_COMMANDS:
 125                 if (value->cached == NULL)
 126                         value->cached = cmd_list_print(value->cmdlist, 0);
 127                 return (value->cached);
 128         case ARGS_STRING:
 129                 return (value->string);
 130         }
 131         fatalx("unexpected argument type");
 132 }
 133
 134 /* Create an empty arguments set. */
 135 struct args *
 136 args_create(void)
 137 {
 138         struct args      *args;
 139
 140         args = xcalloc(1, sizeof *args);
 141         RB_INIT(&args->tree);
 142         return (args);
 143 }
 144
 145 /* Parse a single flag. */
 146 static int
 147 args_parse_flag_argument(struct args_value *values, u_int count, char **cause,
 148     struct args *args, u_int *i, const char *string, int flag,
 149     int optional_argument)
 150 {
 151         struct args_value       *argument, *new;
 152         const char              *s;
 153
 154         new = xcalloc(1, sizeof *new);
 155         if (*string != '\0') {
 156                 new->type = ARGS_STRING;
 157                 new->string = xstrdup(string);
 158                 goto out;
 159         }
 160
 161         if (*i == count)
 162                 argument = NULL;
 163         else {
 164                 argument = &values[*i];
 165                 if (argument->type != ARGS_STRING) {
 166                         xasprintf(cause, "-%c argument must be a string", flag);
 167                         return (-1);
 168                 }
 169         }
 170         if (argument == NULL) {
 171                 if (optional_argument) {
 172                         log_debug("%s: -%c (optional)", __func__, flag);
 173                         args_set(args, flag, NULL, ARGS_ENTRY_OPTIONAL_VALUE);
 174                         return (0); /* either - or end */
 175                 }
 176                 xasprintf(cause, "-%c expects an argument", flag);
 177                 return (-1);
 178         }
 179         args_copy_value(new, argument);
 180         (*i)++;
 181
 182 out:
 183         s = args_value_as_string(new);
 184         log_debug("%s: -%c = %s", __func__, flag, s);
 185         args_set(args, flag, new, 0);
 186         return (0);
 187 }
 188
 189 /* Parse flags argument. */
 190 static int
 191 args_parse_flags(const struct args_parse *parse, struct args_value *values,
 192     u_int count, char **cause, struct args *args, u_int *i)
 193 {
 194         struct args_value       *value;
 195         u_char                   flag;
 196         const char              *found, *string;
 197         int                      optional_argument;
 198
 199         value = &values[*i];
 200         if (value->type != ARGS_STRING)
 201                 return (1);
 202
 203         string = value->string;
 204         log_debug("%s: next %s", __func__, string);
 205         if (*string++ != '-' || *string == '\0')
 206                 return (1);
 207         (*i)++;
 208         if (string[0] == '-' && string[1] == '\0')
 209                 return (1);
 210
 211         for (;;) {
 212                 flag = *string++;
 213                 if (flag == '\0')
 214                         return (0);
 215                 if (flag == '?')
 216                         return (-1);
 217                 if (!isalnum(flag)) {
 218                         xasprintf(cause, "invalid flag -%c", flag);
 219                         return (-1);
 220                 }
 221
 222                 found = strchr(parse->template, flag);
 223                 if (found == NULL) {
 224                         xasprintf(cause, "unknown flag -%c", flag);
 225                         return (-1);
 226                 }
 227                 if (found[1] != ':') {
 228                         log_debug("%s: -%c", __func__, flag);
 229                         args_set(args, flag, NULL, 0);
 230                         continue;
 231                 }
 232                 optional_argument = (found[2] == ':');
 233                 return (args_parse_flag_argument(values, count, cause, args, i,
 234                     string, flag, optional_argument));
 235         }
 236 }
 237
 238 /* Parse arguments into a new argument set. */
 239 struct args *
 240 args_parse(const struct args_parse *parse, struct args_value *values,
 241     u_int count, char **cause)
 242 {
 243         struct args             *args;
 244         u_int                    i;
 245         enum args_parse_type     type;
 246         struct args_value       *value, *new;
 247         const char              *s;
 248         int                      stop;
 249
 250         if (count == 0)
 251                 return (args_create());
 252
 253         args = args_create();
 254         for (i = 1; i < count; /* nothing */) {
 255                 stop = args_parse_flags(parse, values, count, cause, args, &i);
 256                 if (stop == -1) {
 257                         args_free(args);
 258                         return (NULL);
 259                 }
 260                 if (stop == 1)
 261                         break;
 262         }
 263         log_debug("%s: flags end at %u of %u", __func__, i, count);
 264         if (i != count) {
 265                 for (/* nothing */; i < count; i++) {
 266                         value = &values[i];
 267
 268                         s = args_value_as_string(value);
 269                         log_debug("%s: %u = %s (type %s)", __func__, i, s,
 270                             args_type_to_string (value->type));
 271
 272                         if (parse->cb != NULL) {
 273                                 type = parse->cb(args, args->count, cause);
 274                                 if (type == ARGS_PARSE_INVALID) {
 275                                         args_free(args);
 276                                         return (NULL);
 277                                 }
 278                         } else
 279                                 type = ARGS_PARSE_STRING;
 280
 281                         args->values = xrecallocarray(args->values,
 282                             args->count, args->count + 1, sizeof *args->values);
 283                         new = &args->values[args->count++];
 284
 285                         switch (type) {
 286                         case ARGS_PARSE_INVALID:
 287                                 fatalx("unexpected argument type");
 288                         case ARGS_PARSE_STRING:
 289                                 if (value->type != ARGS_STRING) {
 290                                         xasprintf(cause,
 291                                             "argument %u must be \"string\"",
 292                                             args->count);
 293                                         args_free(args);
 294                                         return (NULL);
 295                                 }
 296                                 args_copy_value(new, value);
 297                                 break;
 298                         case ARGS_PARSE_COMMANDS_OR_STRING:
 299                                 args_copy_value(new, value);
 300                                 break;
 301                         case ARGS_PARSE_COMMANDS:
 302                                 if (value->type != ARGS_COMMANDS) {
 303                                         xasprintf(cause,
 304                                             "argument %u must be { commands }",
 305                                             args->count);
 306                                         args_free(args);
 307                                         return (NULL);
 308                                 }
 309                                 args_copy_value(new, value);
 310                                 break;
 311                         }
 312                 }
 313         }
 314
 315         if (parse->lower != -1 && args->count < (u_int)parse->lower) {
 316                 xasprintf(cause,
 317                     "too few arguments (need at least %u)",
 318                     parse->lower);
 319                 args_free(args);
 320                 return (NULL);
 321         }
 322         if (parse->upper != -1 && args->count > (u_int)parse->upper) {
 323                 xasprintf(cause,
 324                     "too many arguments (need at most %u)",
 325                     parse->upper);
 326                 args_free(args);
 327                 return (NULL);
 328         }
 329         return (args);
 330 }
 331
 332 /* Copy and expand a value. */
 333 static void
 334 args_copy_copy_value(struct args_value *to, struct args_value *from, int argc,
 335     char **argv)
 336 {
 337         char    *s, *expanded;
 338         int      i;
 339
 340         to->type = from->type;
 341         switch (from->type) {
 342         case ARGS_NONE:
 343                 break;
 344         case ARGS_STRING:
 345                 expanded = xstrdup(from->string);
 346                 for (i = 0; i < argc; i++) {
 347                         s = cmd_template_replace(expanded, argv[i], i + 1);
 348                         free(expanded);
 349                         expanded = s;
 350                 }
 351                 to->string = expanded;
 352                 break;
 353         case ARGS_COMMANDS:
 354                 to->cmdlist = cmd_list_copy(from->cmdlist, argc, argv);
 355                 break;
 356         }
 357 }
 358
 359 /* Copy an arguments set. */
 360 struct args *
 361 args_copy(struct args *args, int argc, char **argv)
 362 {
 363         struct args             *new_args;
 364         struct args_entry       *entry;
 365         struct args_value       *value, *new_value;
 366         u_int                    i;
 367
 368         cmd_log_argv(argc, argv, "%s", __func__);
 369
 370         new_args = args_create();
 371         RB_FOREACH(entry, args_tree, &args->tree) {
 372                 if (TAILQ_EMPTY(&entry->values)) {
 373                         for (i = 0; i < entry->count; i++)
 374                                 args_set(new_args, entry->flag, NULL, 0);
 375                         continue;
 376                 }
 377                 TAILQ_FOREACH(value, &entry->values, entry) {
 378                         new_value = xcalloc(1, sizeof *new_value);
 379                         args_copy_copy_value(new_value, value, argc, argv);
 380                         args_set(new_args, entry->flag, new_value, 0);
 381                 }
 382         }
 383         if (args->count == 0)
 384                 return (new_args);
 385         new_args->count = args->count;
 386         new_args->values = xcalloc(args->count, sizeof *new_args->values);
 387         for (i = 0; i < args->count; i++) {
 388                 new_value = &new_args->values[i];
 389                 args_copy_copy_value(new_value, &args->values[i], argc, argv);
 390         }
 391         return (new_args);
 392 }
 393
 394 /* Free a value. */
 395 void
 396 args_free_value(struct args_value *value)
 397 {
 398         switch (value->type) {
 399         case ARGS_NONE:
 400                 break;
 401         case ARGS_STRING:
 402                 free(value->string);
 403                 break;
 404         case ARGS_COMMANDS:
 405                 cmd_list_free(value->cmdlist);
 406                 break;
 407         }
 408         free(value->cached);
 409 }
 410
 411 /* Free values. */
 412 void
 413 args_free_values(struct args_value *values, u_int count)
 414 {
 415         u_int   i;
 416
 417         for (i = 0; i < count; i++)
 418                 args_free_value(&values[i]);
 419 }
 420
 421 /* Free an arguments set. */
 422 void
 423 args_free(struct args *args)
 424 {
 425         struct args_entry       *entry;
 426         struct args_entry       *entry1;
 427         struct args_value       *value;
 428         struct args_value       *value1;
 429
 430         args_free_values(args->values, args->count);
 431         free(args->values);
 432
 433         RB_FOREACH_SAFE(entry, args_tree, &args->tree, entry1) {
 434                 RB_REMOVE(args_tree, &args->tree, entry);
 435                 TAILQ_FOREACH_SAFE(value, &entry->values, entry, value1) {
 436                         TAILQ_REMOVE(&entry->values, value, entry);
 437                         args_free_value(value);
 438                         free(value);
 439                 }
 440                 free(entry);
 441         }
 442
 443         free(args);
 444 }
 445
 446 /* Convert arguments to vector. */
 447 void
 448 args_to_vector(struct args *args, int *argc, char ***argv)
 449 {
 450         char    *s;
 451         u_int    i;
 452
 453         *argc = 0;
 454         *argv = NULL;
 455
 456         for (i = 0; i < args->count; i++) {
 457                 switch (args->values[i].type) {
 458                 case ARGS_NONE:
 459                         break;
 460                 case ARGS_STRING:
 461                         cmd_append_argv(argc, argv, args->values[i].string);
 462                         break;
 463                 case ARGS_COMMANDS:
 464                         s = cmd_list_print(args->values[i].cmdlist, 0);
 465                         cmd_append_argv(argc, argv, s);
 466                         free(s);
 467                         break;
 468                 }
 469         }
 470 }
 471
 472 /* Convert arguments from vector. */
 473 struct args_value *
 474 args_from_vector(int argc, char **argv)
 475 {
 476         struct args_value       *values;
 477         int                      i;
 478
 479         values = xcalloc(argc, sizeof *values);
 480         for (i = 0; i < argc; i++) {
 481                 values[i].type = ARGS_STRING;
 482                 values[i].string = xstrdup(argv[i]);
 483         }
 484         return (values);
 485 }
 486
 487 /* Add to string. */
 488 static void printflike(3, 4)
 489 args_print_add(char **buf, size_t *len, const char *fmt, ...)
 490 {
 491         va_list  ap;
 492         char    *s;
 493         size_t   slen;
 494
 495         va_start(ap, fmt);
 496         slen = xvasprintf(&s, fmt, ap);
 497         va_end(ap);
 498
 499         *len += slen;
 500         *buf = xrealloc(*buf, *len);
 501
 502         strlcat(*buf, s, *len);
 503         free(s);
 504 }
 505
 506 /* Add value to string. */
 507 static void
 508 args_print_add_value(char **buf, size_t *len, struct args_value *value)
 509 {
 510         char    *expanded = NULL;
 511
 512         if (**buf != '\0')
 513                 args_print_add(buf, len, " ");
 514
 515         switch (value->type) {
 516         case ARGS_NONE:
 517                 break;
 518         case ARGS_COMMANDS:
 519                 expanded = cmd_list_print(value->cmdlist, 0);
 520                 args_print_add(buf, len, "{ %s }", expanded);
 521                 break;
 522         case ARGS_STRING:
 523                 expanded = args_escape(value->string);
 524                 args_print_add(buf, len, "%s", expanded);
 525                 break;
 526         }
 527         free(expanded);
 528 }
 529
 530 /* Print a set of arguments. */
 531 char *
 532 args_print(struct args *args)
 533 {
 534         size_t                   len;
 535         char                    *buf;
 536         u_int                    i, j;
 537         struct args_entry       *entry;
 538         struct args_entry       *last = NULL;
 539         struct args_value       *value;
 540
 541         len = 1;
 542         buf = xcalloc(1, len);
 543
 544         /* Process the flags first. */
 545         RB_FOREACH(entry, args_tree, &args->tree) {
 546                 if (entry->flags & ARGS_ENTRY_OPTIONAL_VALUE)
 547                         continue;
 548                 if (!TAILQ_EMPTY(&entry->values))
 549                         continue;
 550
 551                 if (*buf == '\0')
 552                         args_print_add(&buf, &len, "-");
 553                 for (j = 0; j < entry->count; j++)
 554                         args_print_add(&buf, &len, "%c", entry->flag);
 555         }
 556
 557         /* Then the flags with arguments. */
 558         RB_FOREACH(entry, args_tree, &args->tree) {
 559                 if (entry->flags & ARGS_ENTRY_OPTIONAL_VALUE) {
 560                         if (*buf != '\0')
 561                                 args_print_add(&buf, &len, " -%c", entry->flag);
 562                         else
 563                                 args_print_add(&buf, &len, "-%c", entry->flag);
 564                         last = entry;
 565                         continue;
 566                 }
 567                 if (TAILQ_EMPTY(&entry->values))
 568                         continue;
 569                 TAILQ_FOREACH(value, &entry->values, entry) {
 570                         if (*buf != '\0')
 571                                 args_print_add(&buf, &len, " -%c", entry->flag);
 572                         else
 573                                 args_print_add(&buf, &len, "-%c", entry->flag);
 574                         args_print_add_value(&buf, &len, value);
 575                 }
 576                 last = entry;
 577         }
 578         if (last && (last->flags & ARGS_ENTRY_OPTIONAL_VALUE))
 579                 args_print_add(&buf, &len, " --");
 580
 581         /* And finally the argument vector. */
 582         for (i = 0; i < args->count; i++)
 583                 args_print_add_value(&buf, &len, &args->values[i]);
 584
 585         return (buf);
 586 }
 587
 588 /* Escape an argument. */
 589 char *
 590 args_escape(const char *s)
 591 {
 592         static const char        dquoted[] = " #';${}%";
 593         static const char        squoted[] = " \"";
 594         char                    *escaped, *result;
 595         int                      flags, quotes = 0;
 596
 597         if (*s == '\0') {
 598                 xasprintf(&result, "''");
 599                 return (result);
 600         }
 601         if (s[strcspn(s, dquoted)] != '\0')
 602                 quotes = '"';
 603         else if (s[strcspn(s, squoted)] != '\0')
 604                 quotes = '\'';
 605
 606         if (s[0] != ' ' &&
 607             s[1] == '\0' &&
 608             (quotes != 0 || s[0] == '~')) {
 609                 xasprintf(&escaped, "\\%c", s[0]);
 610                 return (escaped);
 611         }
 612
 613         flags = VIS_OCTAL|VIS_CSTYLE|VIS_TAB|VIS_NL;
 614         if (quotes == '"')
 615                 flags |= VIS_DQ;
 616         utf8_stravis(&escaped, s, flags);
 617
 618         if (quotes == '\'')
 619                 xasprintf(&result, "'%s'", escaped);
 620         else if (quotes == '"') {
 621                 if (*escaped == '~')
 622                         xasprintf(&result, "\"\\%s\"", escaped);
 623                 else
 624                         xasprintf(&result, "\"%s\"", escaped);
 625         } else {
 626                 if (*escaped == '~')
 627                         xasprintf(&result, "\\%s", escaped);
 628                 else
 629                         result = xstrdup(escaped);
 630         }
 631         free(escaped);
 632         return (result);
 633 }
 634
 635 /* Return if an argument is present. */
 636 int
 637 args_has(struct args *args, u_char flag)
 638 {
 639         struct args_entry       *entry;
 640
 641         entry = args_find(args, flag);
 642         if (entry == NULL)
 643                 return (0);
 644         return (entry->count);
 645 }
 646
 647 /* Set argument value in the arguments tree. */
 648 void
 649 args_set(struct args *args, u_char flag, struct args_value *value, int flags)
 650 {
 651         struct args_entry       *entry;
 652
 653         entry = args_find(args, flag);
 654         if (entry == NULL) {
 655                 entry = xcalloc(1, sizeof *entry);
 656                 entry->flag = flag;
 657                 entry->count = 1;
 658                 entry->flags = flags;
 659                 TAILQ_INIT(&entry->values);
 660                 RB_INSERT(args_tree, &args->tree, entry);
 661         } else
 662                 entry->count++;
 663         if (value != NULL && value->type != ARGS_NONE)
 664                 TAILQ_INSERT_TAIL(&entry->values, value, entry);
 665 }
 666
 667 /* Get argument value. Will be NULL if it isn't present. */
 668 const char *
 669 args_get(struct args *args, u_char flag)
 670 {
 671         struct args_entry       *entry;
 672
 673         if ((entry = args_find(args, flag)) == NULL)
 674                 return (NULL);
 675         if (TAILQ_EMPTY(&entry->values))
 676                 return (NULL);
 677         return (TAILQ_LAST(&entry->values, args_values)->string);
 678 }
 679
 680 /* Get first argument. */
 681 u_char
 682 args_first(struct args *args, struct args_entry **entry)
 683 {
 684         *entry = RB_MIN(args_tree, &args->tree);
 685         if (*entry == NULL)
 686                 return (0);
 687         return ((*entry)->flag);
 688 }
 689
 690 /* Get next argument. */
 691 u_char
 692 args_next(struct args_entry **entry)
 693 {
 694         *entry = RB_NEXT(args_tree, &args->tree, *entry);
 695         if (*entry == NULL)
 696                 return (0);
 697         return ((*entry)->flag);
 698 }
 699
 700 /* Get argument count. */
 701 u_int
 702 args_count(struct args *args)
 703 {
 704         return (args->count);
 705 }
 706
 707 /* Get argument values. */
 708 struct args_value *
 709 args_values(struct args *args)
 710 {
 711         return (args->values);
 712 }
 713
 714 /* Get argument value. */
 715 struct args_value *
 716 args_value(struct args *args, u_int idx)
 717 {
 718         if (idx >= args->count)
 719                 return (NULL);
 720         return (&args->values[idx]);
 721 }
 722
 723 /* Return argument as string. */
 724 const char *
 725 args_string(struct args *args, u_int idx)
 726 {
 727         if (idx >= args->count)
 728                 return (NULL);
 729         return (args_value_as_string(&args->values[idx]));
 730 }
 731
 732 /* Make a command now. */
 733 struct cmd_list *
 734 args_make_commands_now(struct cmd *self, struct cmdq_item *item, u_int idx,
 735     int expand)
 736 {
 737         struct args_command_state       *state;
 738         char                            *error;
 739         struct cmd_list                 *cmdlist;
 740
 741         state = args_make_commands_prepare(self, item, idx, NULL, 0, expand);
 742         cmdlist = args_make_commands(state, 0, NULL, &error);
 743         if (cmdlist == NULL) {
 744                 cmdq_error(item, "%s", error);
 745                 free(error);
 746         }
 747         else
 748                 cmdlist->references++;
 749         args_make_commands_free(state);
 750         return (cmdlist);
 751 }
 752
 753 /* Save bits to make a command later. */
 754 struct args_command_state *
 755 args_make_commands_prepare(struct cmd *self, struct cmdq_item *item, u_int idx,
 756     const char *default_command, int wait, int expand)
 757 {
 758         struct args                     *args = cmd_get_args(self);
 759         struct cmd_find_state           *target = cmdq_get_target(item);
 760         struct client                   *tc = cmdq_get_target_client(item);
 761         struct args_value               *value;
 762         struct args_command_state       *state;
 763         const char                      *cmd;
 764         const char                      *file;
 765
 766         state = xcalloc(1, sizeof *state);
 767
 768         if (idx < args->count) {
 769                 value = &args->values[idx];
 770                 if (value->type == ARGS_COMMANDS) {
 771                         state->cmdlist = value->cmdlist;
 772                         state->cmdlist->references++;
 773                         return (state);
 774                 }
 775                 cmd = value->string;
 776         } else {
 777                 if (default_command == NULL)
 778                         fatalx("argument out of range");
 779                 cmd = default_command;
 780         }
 781
 782
 783         if (expand)
 784                 state->cmd = format_single_from_target(item, cmd);
 785         else
 786                 state->cmd = xstrdup(cmd);
 787         log_debug("%s: %s", __func__, state->cmd);
 788
 789         if (wait)
 790                 state->pi.item = item;
 791         cmd_get_source(self, &file, &state->pi.line);
 792         if (file != NULL)
 793                 state->pi.file = xstrdup(file);
 794         state->pi.c = tc;
 795         if (state->pi.c != NULL)
 796                 state->pi.c->references++;
 797         cmd_find_copy_state(&state->pi.fs, target);
 798
 799         return (state);
 800 }
 801
 802 /* Return argument as command. */
 803 struct cmd_list *
 804 args_make_commands(struct args_command_state *state, int argc, char **argv,
 805     char **error)
 806 {
 807         struct cmd_parse_result *pr;
 808         char                    *cmd, *new_cmd;
 809         int                      i;
 810
 811         if (state->cmdlist != NULL) {
 812                 if (argc == 0)
 813                         return (state->cmdlist);
 814                 return (cmd_list_copy(state->cmdlist, argc, argv));
 815         }
 816
 817         cmd = xstrdup(state->cmd);
 818         log_debug("%s: %s", __func__, cmd);
 819         cmd_log_argv(argc, argv, __func__);
 820         for (i = 0; i < argc; i++) {
 821                 new_cmd = cmd_template_replace(cmd, argv[i], i + 1);
 822                 log_debug("%s: %%%u %s: %s", __func__, i + 1, argv[i], new_cmd);
 823                 free(cmd);
 824                 cmd = new_cmd;
 825         }
 826         log_debug("%s: %s", __func__, cmd);
 827
 828         pr = cmd_parse_from_string(cmd, &state->pi);
 829         free(cmd);
 830         switch (pr->status) {
 831         case CMD_PARSE_ERROR:
 832                 *error = pr->error;
 833                 return (NULL);
 834         case CMD_PARSE_SUCCESS:
 835                 return (pr->cmdlist);
 836         }
 837         fatalx("invalid parse return state");
 838 }
 839
 840 /* Free commands state. */
 841 void
 842 args_make_commands_free(struct args_command_state *state)
 843 {
 844         if (state->cmdlist != NULL)
 845                 cmd_list_free(state->cmdlist);
 846         if (state->pi.c != NULL)
 847                 server_client_unref(state->pi.c);
 848         free((void *)state->pi.file);
 849         free(state->cmd);
 850         free(state);
 851 }
 852
 853 /* Get prepared command. */
 854 char *
 855 args_make_commands_get_command(struct args_command_state *state)
 856 {
 857         struct cmd      *first;
 858         int              n;
 859         char            *s;
 860
 861         if (state->cmdlist != NULL) {
 862                 first = cmd_list_first(state->cmdlist);
 863                 if (first == NULL)
 864                         return (xstrdup(""));
 865                 return (xstrdup(cmd_get_entry(first)->name));
 866         }
 867         n = strcspn(state->cmd, " ,");
 868         xasprintf(&s, "%.*s", n, state->cmd);
 869         return (s);
 870 }
 871
 872 /* Get first value in argument. */
 873 struct args_value *
 874 args_first_value(struct args *args, u_char flag)
 875 {
 876         struct args_entry       *entry;
 877
 878         if ((entry = args_find(args, flag)) == NULL)
 879                 return (NULL);
 880         return (TAILQ_FIRST(&entry->values));
 881 }
 882
 883 /* Get next value in argument. */
 884 struct args_value *
 885 args_next_value(struct args_value *value)
 886 {
 887         return (TAILQ_NEXT(value, entry));
 888 }
 889
 890 /* Convert an argument value to a number. */
 891 long long
 892 args_strtonum(struct args *args, u_char flag, long long minval,
 893     long long maxval, char **cause)
 894 {
 895         const char              *errstr;
 896         long long                ll;
 897         struct args_entry       *entry;
 898         struct args_value       *value;
 899
 900         if ((entry = args_find(args, flag)) == NULL) {
 901                 *cause = xstrdup("missing");
 902                 return (0);
 903         }
 904         value = TAILQ_LAST(&entry->values, args_values);
 905         if (value == NULL ||
 906             value->type != ARGS_STRING ||
 907             value->string == NULL) {
 908                 *cause = xstrdup("missing");
 909                 return (0);
 910         }
 911
 912         ll = strtonum(value->string, minval, maxval, &errstr);
 913         if (errstr != NULL) {
 914                 *cause = xstrdup(errstr);
 915                 return (0);
 916         }
 917
 918         *cause = NULL;
 919         return (ll);
 920 }
 921
 922 /* Convert an argument value to a number, and expand formats. */
 923 long long
 924 args_strtonum_and_expand(struct args *args, u_char flag, long long minval,
 925     long long maxval, struct cmdq_item *item, char **cause)
 926 {
 927         const char              *errstr;
 928         char                    *formatted;
 929         long long                ll;
 930         struct args_entry       *entry;
 931         struct args_value       *value;
 932
 933         if ((entry = args_find(args, flag)) == NULL) {
 934                 *cause = xstrdup("missing");
 935                 return (0);
 936         }
 937         value = TAILQ_LAST(&entry->values, args_values);
 938         if (value == NULL ||
 939             value->type != ARGS_STRING ||
 940             value->string == NULL) {
 941                 *cause = xstrdup("missing");
 942                 return (0);
 943         }
 944
 945         formatted = format_single_from_target(item, value->string);
 946         ll = strtonum(formatted, minval, maxval, &errstr);
 947         free(formatted);
 948         if (errstr != NULL) {
 949                 *cause = xstrdup(errstr);
 950                 return (0);
 951         }
 952
 953         *cause = NULL;
 954         return (ll);
 955 }
 956
 957 /* Convert an argument to a number which may be a percentage. */
 958 long long
 959 args_percentage(struct args *args, u_char flag, long long minval,
 960     long long maxval, long long curval, char **cause)
 961 {
 962         const char              *value;
 963         struct args_entry       *entry;
 964
 965         if ((entry = args_find(args, flag)) == NULL) {
 966                 *cause = xstrdup("missing");
 967                 return (0);
 968         }
 969         if (TAILQ_EMPTY(&entry->values)) {
 970                 *cause = xstrdup("empty");
 971                 return (0);
 972         }
 973         value = TAILQ_LAST(&entry->values, args_values)->string;
 974         return (args_string_percentage(value, minval, maxval, curval, cause));
 975 }
 976
 977 /* Convert a string to a number which may be a percentage. */
 978 long long
 979 args_string_percentage(const char *value, long long minval, long long maxval,
 980     long long curval, char **cause)
 981 {
 982         const char      *errstr;
 983         long long        ll;
 984         size_t           valuelen = strlen(value);
 985         char            *copy;
 986
 987         if (valuelen == 0) {
 988                 *cause = xstrdup("empty");
 989                 return (0);
 990         }
 991         if (value[valuelen - 1] == '%') {
 992                 copy = xstrdup(value);
 993                 copy[valuelen - 1] = '\0';
 994
 995                 ll = strtonum(copy, 0, 100, &errstr);
 996                 free(copy);
 997                 if (errstr != NULL) {
 998                         *cause = xstrdup(errstr);
 999                         return (0);
1000                 }
1001                 ll = (curval * ll) / 100;
1002                 if (ll < minval) {
1003                         *cause = xstrdup("too small");
1004                         return (0);
1005                 }
1006                 if (ll > maxval) {
1007                         *cause = xstrdup("too large");
1008                         return (0);
1009                 }
1010         } else {
1011                 ll = strtonum(value, minval, maxval, &errstr);
1012                 if (errstr != NULL) {
1013                         *cause = xstrdup(errstr);
1014                         return (0);
1015                 }
1016         }
1017
1018         *cause = NULL;
1019         return (ll);
1020 }
1021
1022 /*
1023  * Convert an argument to a number which may be a percentage, and expand
1024  * formats.
1025  */
1026 long long
1027 args_percentage_and_expand(struct args *args, u_char flag, long long minval,
1028     long long maxval, long long curval, struct cmdq_item *item, char **cause)
1029 {
1030         const char              *value;
1031         struct args_entry       *entry;
1032
1033         if ((entry = args_find(args, flag)) == NULL) {
1034                 *cause = xstrdup("missing");
1035                 return (0);
1036         }
1037         if (TAILQ_EMPTY(&entry->values)) {
1038                 *cause = xstrdup("empty");
1039                 return (0);
1040         }
1041         value = TAILQ_LAST(&entry->values, args_values)->string;
1042         return (args_string_percentage_and_expand(value, minval, maxval, curval,
1043                     item, cause));
1044 }
1045
1046 /*
1047  * Convert a string to a number which may be a percentage, and expand formats.
1048  */
1049 long long
1050 args_string_percentage_and_expand(const char *value, long long minval,
1051     long long maxval, long long curval, struct cmdq_item *item, char **cause)
1052 {
1053         const char      *errstr;
1054         long long        ll;
1055         size_t           valuelen = strlen(value);
1056         char            *copy, *f;
1057
1058         if (value[valuelen - 1] == '%') {
1059                 copy = xstrdup(value);
1060                 copy[valuelen - 1] = '\0';
1061
1062                 f = format_single_from_target(item, copy);
1063                 ll = strtonum(f, 0, 100, &errstr);
1064                 free(f);
1065                 free(copy);
1066                 if (errstr != NULL) {
1067                         *cause = xstrdup(errstr);
1068                         return (0);
1069                 }
1070                 ll = (curval * ll) / 100;
1071                 if (ll < minval) {
1072                         *cause = xstrdup("too small");
1073                         return (0);
1074                 }
1075                 if (ll > maxval) {
1076                         *cause = xstrdup("too large");
1077                         return (0);
1078                 }
1079         } else {
1080                 f = format_single_from_target(item, value);
1081                 ll = strtonum(f, minval, maxval, &errstr);
1082                 free(f);
1083                 if (errstr != NULL) {
1084                         *cause = xstrdup(errstr);
1085                         return (0);
1086                 }
1087         }
1088
1089         *cause = NULL;
1090         return (ll);
1091 }