src/config/cmdline.c

   1 /* Command line processing */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <sys/types.h>
  10 #ifdef HAVE_SYS_SOCKET_H
  11 #include <sys/socket.h> /* OS/2 needs this after sys/types.h */
  12 #endif
  13 #include <sys/stat.h> /* OS/2 needs this after sys/types.h */
  14 #ifdef HAVE_NETDB_H
  15 #include <netdb.h>
  16 #endif
  17
  18 /* We need to have it here. Stupid BSD. */
  19 #ifdef HAVE_NETINET_IN_H
  20 #include <netinet/in.h>
  21 #endif
  22 #ifdef HAVE_ARPA_INET_H
  23 #include <arpa/inet.h>
  24 #endif
  25
  26 #include "elinks.h"
  27
  28 #include "config/cmdline.h"
  29 #include "config/conf.h"
  30 #include "config/options.h"
  31 #include "config/opttypes.h"
  32 #include "intl/gettext/libintl.h"
  33 #include "network/dns.h"
  34 #include "protocol/uri.h"
  35 #include "session/session.h"
  36 #include "util/error.h"
  37 #include "util/file.h"
  38 #include "util/lists.h"
  39 #include "util/memory.h"
  40 #include "util/string.h"
  41
  42
  43 /* Hack to handle URL extraction for -remote commands */
  44 static unsigned char *remote_url;
  45
  46 static enum retval
  47 parse_options_(int argc, unsigned char *argv[], struct option *opt,
  48                LIST_OF(struct string_list_item) *url_list)
  49 {
  50         while (argc) {
  51                 argv++, argc--;
  52
  53                 if (argv[-1][0] == '-' && argv[-1][1]) {
  54                         struct option *option;
  55                         unsigned char *argname = &argv[-1][1];
  56                         unsigned char *oname = stracpy(argname);
  57                         unsigned char *err;
  58
  59                         if (!oname) continue;
  60
  61                         /* Treat --foo same as -foo. */
  62                         if (argname[0] == '-') argname++;
  63
  64                         option = get_opt_rec(opt, argname);
  65                         if (!option) option = get_opt_rec(opt, oname);
  66                         if (!option) {
  67                                 unsigned char *pos;
  68
  69                                 oname++; /* the '-' */
  70                                 /* Substitute '-' by '_'. This helps
  71                                  * compatibility with that very wicked browser
  72                                  * called 'lynx'. */
  73                                 for (pos = strchr(oname, '_'); pos;
  74                                      pos = strchr(pos, '_'))
  75                                         *pos = '-';
  76                                 option = get_opt_rec(opt, oname);
  77                                 oname--;
  78                         }
  79
  80                         mem_free(oname);
  81
  82                         if (!option) goto unknown_option;
  83
  84                         if (!option_types[option->type].cmdline)
  85                                 goto unknown_option;
  86
  87                         err = option_types[option->type].cmdline(option, &argv, &argc);
  88
  89                         if (err) {
  90                                 if (err[0]) {
  91                                         usrerror(gettext("Cannot parse option %s: %s"), argv[-1], err);
  92
  93                                         return RET_SYNTAX;
  94                                 }
  95
  96                                 /* XXX: Empty strings means all is well and have
  97                                  * a cup of shut the fsck up. */
  98                                 return RET_COMMAND;
  99
 100                         } else if (remote_url) {
 101                                 if (url_list) add_to_string_list(url_list, remote_url, -1);
 102                                 mem_free(remote_url);
 103                                 remote_url = NULL;
 104                         }
 105
 106                 } else if (url_list) {
 107                         add_to_string_list(url_list, argv[-1], -1);
 108                 }
 109         }
 110
 111         return RET_OK;
 112
 113 unknown_option:
 114         usrerror(gettext("Unknown option %s"), argv[-1]);
 115         return RET_SYNTAX;
 116 }
 117
 118 enum retval
 119 parse_options(int argc, unsigned char *argv[],
 120               LIST_OF(struct string_list_item) *url_list)
 121 {
 122         return parse_options_(argc, argv, cmdline_options, url_list);
 123 }
 124
 125
 126 /**********************************************************************
 127  Options handlers
 128 **********************************************************************/
 129
 130 static unsigned char *
 131 eval_cmd(struct option *o, unsigned char ***argv, int *argc)
 132 {
 133         if (*argc < 1) return gettext("Parameter expected");
 134
 135         (*argv)++; (*argc)--;   /* Consume next argument */
 136
 137         parse_config_file(config_options, "-eval", *(*argv - 1), NULL, 0);
 138
 139         fflush(stdout);
 140
 141         return NULL;
 142 }
 143
 144 static unsigned char *
 145 forcehtml_cmd(struct option *o, unsigned char ***argv, int *argc)
 146 {
 147         safe_strncpy(get_opt_str("mime.default_type"), "text/html", MAX_STR_LEN);
 148         return NULL;
 149 }
 150
 151 static unsigned char *
 152 lookup_cmd(struct option *o, unsigned char ***argv, int *argc)
 153 {
 154         struct sockaddr_storage *addrs = NULL;
 155         int addrno, i;
 156
 157         if (!*argc) return gettext("Parameter expected");
 158         if (*argc > 1) return gettext("Too many parameters");
 159
 160         (*argv)++; (*argc)--;
 161         if (do_real_lookup(*(*argv - 1), &addrs, &addrno, 0) == DNS_ERROR) {
 162 #ifdef HAVE_HERROR
 163                 herror(gettext("error"));
 164 #else
 165                 usrerror(gettext("Host not found"));
 166 #endif
 167                 return "";
 168         }
 169
 170         for (i = 0; i < addrno; i++) {
 171 #ifdef CONFIG_IPV6
 172                 struct sockaddr_in6 addr = *((struct sockaddr_in6 *) &(addrs)[i]);
 173                 unsigned char p[INET6_ADDRSTRLEN];
 174
 175                 if (! inet_ntop(addr.sin6_family,
 176                                 (addr.sin6_family == AF_INET6 ? (void *) &addr.sin6_addr
 177                                                               : (void *) &((struct sockaddr_in *) &addr)->sin_addr),
 178                                 p, INET6_ADDRSTRLEN))
 179                         ERROR(gettext("Resolver error"));
 180                 else
 181                         printf("%s\n", p);
 182 #else
 183                 struct sockaddr_in addr = *((struct sockaddr_in *) &(addrs)[i]);
 184                 unsigned char *p = (unsigned char *) &addr.sin_addr.s_addr;
 185
 186                 printf("%d.%d.%d.%d\n", (int) p[0], (int) p[1],
 187                                         (int) p[2], (int) p[3]);
 188 #endif
 189         }
 190
 191         mem_free_if(addrs);
 192
 193         fflush(stdout);
 194
 195         return "";
 196 }
 197
 198 #define skipback_whitespace(start, S) \
 199         while ((start) < (S) && isspace((S)[-1])) (S)--;
 200
 201 static unsigned char *
 202 remote_cmd(struct option *o, unsigned char ***argv, int *argc)
 203 {
 204         struct {
 205                 unsigned char *name;
 206                 enum {
 207                         REMOTE_METHOD_OPENURL,
 208                         REMOTE_METHOD_PING,
 209                         REMOTE_METHOD_XFEDOCOMMAND,
 210                         REMOTE_METHOD_ADDBOOKMARK,
 211                         REMOTE_METHOD_INFOBOX,
 212                         REMOTE_METHOD_NOT_SUPPORTED,
 213                 } type;
 214         } remote_methods[] = {
 215                 { "openURL",      REMOTE_METHOD_OPENURL },
 216                 { "ping",         REMOTE_METHOD_PING },
 217                 { "addBookmark",  REMOTE_METHOD_ADDBOOKMARK },
 218                 { "infoBox",      REMOTE_METHOD_INFOBOX },
 219                 { "xfeDoCommand", REMOTE_METHOD_XFEDOCOMMAND },
 220                 { NULL,           REMOTE_METHOD_NOT_SUPPORTED },
 221         };
 222         unsigned char *command, *arg, *argend, *argstring;
 223         int method, len = 0;
 224         unsigned char *remote_argv[10];
 225         int remote_argc;
 226
 227         if (*argc < 1) return gettext("Parameter expected");
 228
 229         command = *(*argv);
 230
 231         while (isasciialpha(command[len]))
 232                 len++;
 233
 234         /* Find the begining and end of the argument list. */
 235
 236         arg = command + len;
 237         skip_space(arg);
 238
 239         argend = arg + strlen(arg);
 240         skipback_whitespace(arg, argend);
 241         if (argend > arg)
 242                 argend--;
 243
 244         /* Decide whether to use the "extended" --remote format where
 245          * all URLs following should be opened in tabs. */
 246         if (len == 0 || *arg != '(' || *argend != ')') {
 247                 /* Just open any passed URLs in new tabs */
 248                 remote_session_flags |= SES_REMOTE_NEW_TAB;
 249                 return NULL;
 250         }
 251
 252         arg++;
 253
 254         arg = argstring = memacpy(arg, argend - arg);
 255         if (!argstring)
 256                 return gettext("Out of memory");
 257
 258         remote_argc = 0;
 259         do {
 260                 unsigned char *start, *end;
 261
 262                 if (remote_argc > sizeof_array(remote_argv)) {
 263                         mem_free(argstring);
 264                         return gettext("Too many arguments");
 265                 }
 266
 267                 /* Skip parenthesis, comma, and surrounding whitespace. */
 268                 skip_space(arg);
 269                 start = arg;
 270
 271                 if (*start == '"') {
 272                         end = ++start;
 273                         while ((end = strchr(end, '"'))) {
 274                                 /* Treat "" inside quoted arg as ". */
 275                                 if (end[1] != '"')
 276                                         break;
 277
 278                                 end += 2;
 279                         }
 280
 281                         if (!end)
 282                                 return gettext("Mismatched ending argument quoting");
 283
 284                         arg = end + 1;
 285                         skip_space(arg);
 286                         if (*arg && *arg != ',')
 287                                 return gettext("Garbage after quoted argument");
 288
 289                         remote_argv[remote_argc++] = start;
 290                         *end = 0;
 291
 292                         /* Unescape "" to ". */
 293                         for (end = start; *end; start++, end++) {
 294                                 *start = *end;
 295                                 if (*end == '"')
 296                                         end++;
 297                         }
 298                         *start = 0;
 299
 300                 } else {
 301                         end = strchr(start, ',');
 302                         if (!end) {
 303                                 end = start + strlen(start);
 304                                 arg = end;
 305                         } else {
 306                                 arg = end + 1;
 307                         }
 308                         skipback_whitespace(start, end);
 309
 310                         if (start != end)
 311                                 remote_argv[remote_argc++] = start;
 312                         *end = 0;
 313                 }
 314
 315                 if (*arg == ',')
 316                         arg++;
 317         } while (*arg);
 318
 319         for (method = 0; remote_methods[method].name; method++) {
 320                 unsigned char *name = remote_methods[method].name;
 321
 322                 if (!strlcasecmp(command, len, name, -1))
 323                         break;
 324         }
 325
 326         switch (remote_methods[method].type) {
 327         case REMOTE_METHOD_OPENURL:
 328                 if (remote_argc < 1) {
 329                         /* Prompt for a URL with a dialog box */
 330                         remote_session_flags |= SES_REMOTE_PROMPT_URL;
 331                         break;
 332                 }
 333
 334                 if (remote_argc == 2) {
 335                         unsigned char *where = remote_argv[1];
 336
 337                         if (strstr(where, "new-window")) {
 338                                 remote_session_flags |= SES_REMOTE_NEW_WINDOW;
 339
 340                         } else if (strstr(where, "new-tab")) {
 341                                 remote_session_flags |= SES_REMOTE_NEW_TAB;
 342
 343                         } else {
 344                                 /* Bail out when getting unknown parameter */
 345                                 /* TODO: new-screen */
 346                                 break;
 347                         }
 348
 349                 } else {
 350                         remote_session_flags |= SES_REMOTE_CURRENT_TAB;
 351                 }
 352
 353                 remote_url = stracpy(remote_argv[0]);
 354                 break;
 355
 356         case REMOTE_METHOD_XFEDOCOMMAND:
 357                 if (remote_argc < 1)
 358                         break;
 359
 360                 if (!strcasecmp(remote_argv[0], "openBrowser")) {
 361                         remote_session_flags = SES_REMOTE_NEW_WINDOW;
 362                 }
 363                 break;
 364
 365         case REMOTE_METHOD_PING:
 366                 remote_session_flags = SES_REMOTE_PING;
 367                 break;
 368
 369         case REMOTE_METHOD_ADDBOOKMARK:
 370                 if (remote_argc < 1)
 371                         break;
 372                 remote_url = stracpy(remote_argv[0]);
 373                 remote_session_flags = SES_REMOTE_ADD_BOOKMARK;
 374                 break;
 375
 376         case REMOTE_METHOD_INFOBOX:
 377                 if (remote_argc < 1)
 378                         break;
 379                 remote_url = stracpy(remote_argv[0]);
 380                 if (remote_url)
 381                         insert_in_string(&remote_url, 0, "about:", 6);
 382                 remote_session_flags = SES_REMOTE_INFO_BOX;
 383                 break;
 384
 385         case REMOTE_METHOD_NOT_SUPPORTED:
 386                 break;
 387         }
 388
 389         mem_free(argstring);
 390
 391         /* If no flags was applied it can only mean we are dealing with
 392          * unknown method. */
 393         if (!remote_session_flags)
 394                 return gettext("Remote method not supported");
 395
 396         (*argv)++; (*argc)--;   /* Consume next argument */
 397
 398         return NULL;
 399 }
 400
 401 static unsigned char *
 402 version_cmd(struct option *o, unsigned char ***argv, int *argc)
 403 {
 404         printf("%s\n", full_static_version);
 405         fflush(stdout);
 406         return "";
 407 }
 408
 409
 410 /* Below we handle help usage printing.
 411  *
 412  * We're trying to achieve several goals here:
 413  *
 414  * - Genericly define a function to print option trees iteratively.
 415  * - Make output parsable for various doc tools (to make manpages).
 416  * - Do some non generic fancy stuff like printing semi-aliased
 417  *   options (like: -?, -h and -help) on one line when printing
 418  *   short help. */
 419
 420 #define gettext_nonempty(x) (*(x) ? gettext(x) : (x))
 421
 422 static void
 423 print_full_help(struct option *tree, unsigned char *path)
 424 {
 425         struct option *option;
 426         unsigned char saved[MAX_STR_LEN];
 427         unsigned char *savedpos = saved;
 428
 429         *savedpos = 0;
 430
 431         foreach (option, *tree->value.tree) {
 432                 enum option_type type = option->type;
 433                 unsigned char *help;
 434                 unsigned char *capt = option->capt;
 435                 unsigned char *desc = (option->desc && *option->desc)
 436                                       ? (unsigned char *) gettext(option->desc)
 437                                       : (unsigned char *) "N/A";
 438
 439                 /* Don't print deprecated aliases (if we don't walk command
 440                  * line options which use aliases for legitimate options). */
 441                 if ((type == OPT_ALIAS && tree != cmdline_options)
 442                     || (option->flags & OPT_HIDDEN))
 443                         continue;
 444
 445                 if (!capt && !strncasecmp(option->name, "_template_", 10))
 446                         capt = (unsigned char *) N_("Template option folder");
 447
 448                 if (!capt) {
 449                         int len = strlen(option->name);
 450                         int max = MAX_STR_LEN - (savedpos - saved);
 451
 452                         safe_strncpy(savedpos, option->name, max);
 453                         safe_strncpy(savedpos + len, ", -", max - len);
 454                         savedpos += len + 3;
 455                         continue;
 456                 }
 457
 458                 help = gettext_nonempty(option_types[option->type].help_str);
 459
 460                 if (type != OPT_TREE)
 461                         printf("    %s%s%s %s ",
 462                                 path, saved, option->name, help);
 463
 464                 /* Print the 'title' of each option type. */
 465                 switch (type) {
 466                         case OPT_BOOL:
 467                         case OPT_INT:
 468                         case OPT_LONG:
 469                                 printf(gettext("(default: %ld)"),
 470                                         type == OPT_LONG
 471                                         ? option->value.big_number
 472                                         : (long) option->value.number);
 473                                 break;
 474
 475                         case OPT_STRING:
 476                                 printf(gettext("(default: \"%s\")"),
 477                                         option->value.string);
 478                                 break;
 479
 480                         case OPT_ALIAS:
 481                                 printf(gettext("(alias for %s)"),
 482                                         option->value.string);
 483                                 break;
 484
 485                         case OPT_CODEPAGE:
 486                                 printf(gettext("(default: %s)"),
 487                                         get_cp_name(option->value.number));
 488                                 break;
 489
 490                         case OPT_COLOR:
 491                         {
 492                                 color_T color = option->value.color;
 493                                 unsigned char hexcolor[8];
 494
 495                                 printf(gettext("(default: %s)"),
 496                                        get_color_string(color, hexcolor));
 497                                 break;
 498                         }
 499
 500                         case OPT_COMMAND:
 501                                 break;
 502
 503                         case OPT_LANGUAGE:
 504 #ifdef CONFIG_NLS
 505                                 printf(gettext("(default: \"%s\")"),
 506                                        language_to_name(option->value.number));
 507 #endif
 508                                 break;
 509
 510                         case OPT_TREE:
 511                         {
 512                                 int pathlen = strlen(path);
 513                                 int namelen = strlen(option->name);
 514
 515                                 if (pathlen + namelen + 2 > MAX_STR_LEN)
 516                                         continue;
 517
 518                                 /* Append option name to path */
 519                                 if (pathlen > 0) {
 520                                         memcpy(saved, path, pathlen);
 521                                         savedpos = saved + pathlen;
 522                                 } else {
 523                                         savedpos = saved;
 524                                 }
 525                                 memcpy(savedpos, option->name, namelen + 1);
 526                                 savedpos += namelen;
 527
 528                                 capt = gettext_nonempty(capt);
 529                                 printf("  %s: (%s)", capt, saved);
 530                                 break;
 531                         }
 532                 }
 533
 534                 printf("\n    %8s", "");
 535                 {
 536                         int l = strlen(desc);
 537                         int i;
 538
 539                         for (i = 0; i < l; i++) {
 540                                 putchar(desc[i]);
 541
 542                                 if (desc[i] == '\n')
 543                                         printf("    %8s", "");
 544                         }
 545                 }
 546                 printf("\n\n");
 547
 548                 if (option->type == OPT_TREE) {
 549                         memcpy(savedpos, ".", 2);
 550                         print_full_help(option, saved);
 551                 }
 552
 553                 savedpos = saved;
 554                 *savedpos = 0;
 555         }
 556 }
 557
 558 static void
 559 print_short_help(void)
 560 {
 561 #define ALIGN_WIDTH 20
 562         struct option *option;
 563         struct string string = NULL_STRING;
 564         struct string *saved = NULL;
 565         unsigned char align[ALIGN_WIDTH];
 566
 567         /* Initialize @space used to align captions. */
 568         memset(align, ' ', sizeof(align) - 1);
 569         align[sizeof(align) - 1] = 0;
 570
 571         foreach (option, *cmdline_options->value.tree) {
 572                 unsigned char *capt;
 573                 unsigned char *help;
 574                 unsigned char *info = saved ? saved->source
 575                                             : (unsigned char *) "";
 576                 int len = strlen(option->name);
 577
 578                 /* Avoid printing compatibility options */
 579                 if (option->flags & OPT_HIDDEN)
 580                         continue;
 581
 582                 /* When no caption is available the option name is 'stacked'
 583                  * and the caption is shared with next options that has one. */
 584                 if (!option->capt) {
 585                         if (!saved) {
 586                                 if (!init_string(&string))
 587                                         continue;
 588
 589                                 saved = &string;
 590                         }
 591
 592                         add_to_string(saved, option->name);
 593                         add_to_string(saved, ", -");
 594                         continue;
 595                 }
 596
 597                 capt = gettext_nonempty(option->capt);
 598                 help = gettext_nonempty(option_types[option->type].help_str);
 599
 600                 /* When @help string is non empty align at least one space. */
 601                 len = ALIGN_WIDTH - len - strlen(help);
 602                 len -= (saved ? saved->length : 0);
 603                 len = (len < 0) ? !!(*help) : len;
 604
 605                 align[len] = '\0';
 606                 printf("  -%s%s %s%s%s\n",
 607                        info, option->name, help, align, capt);
 608                 align[len] = ' ';
 609                 if (saved) {
 610                         done_string(saved);
 611                         saved = NULL;
 612                 }
 613         }
 614 #undef ALIGN_WIDTH
 615 }
 616
 617 #undef gettext_nonempty
 618
 619 static unsigned char *
 620 printhelp_cmd(struct option *option, unsigned char ***argv, int *argc)
 621 {
 622         unsigned char *lineend = strchr(full_static_version, '\n');
 623
 624         if (lineend) *lineend = '\0';
 625
 626         printf("%s\n\n", full_static_version);
 627
 628         if (!strcmp(option->name, "config-help")) {
 629                 printf("%s:\n", gettext("Configuration options"));
 630                 print_full_help(config_options, "");
 631         } else {
 632                 printf("%s\n\n%s:\n",
 633                        gettext("Usage: elinks [OPTION]... [URL]..."),
 634                        gettext("Options"));
 635                 if (!strcmp(option->name, "long-help")) {
 636                         print_full_help(cmdline_options, "-");
 637                 } else {
 638                         print_short_help();
 639                 }
 640         }
 641
 642         fflush(stdout);
 643         return "";
 644 }
 645
 646 static unsigned char *
 647 redir_cmd(struct option *option, unsigned char ***argv, int *argc)
 648 {
 649         unsigned char *target;
 650
 651         /* I can't get any dirtier. --pasky */
 652
 653         if (!strcmp(option->name, "confdir")) {
 654                 target = "config-dir";
 655         } else if (!strcmp(option->name, "conffile")) {
 656                 target = "config-file";
 657         } else if (!strcmp(option->name, "stdin")) {
 658                 static int complained;
 659
 660                 if (complained)
 661                         return NULL;
 662                 complained = 1;
 663
 664                 /* Emulate bool option, possibly eating following 0/1. */
 665                 if ((*argv)[0]
 666                     && ((*argv)[0][0] == '0' || (*argv)[0][0] == '1')
 667                     && !(*argv)[0][1])
 668                         (*argv)++, (*argc)--;
 669                 fprintf(stderr, "Warning: Deprecated option -stdin used!\n");
 670                 fprintf(stderr, "ELinks now determines the -stdin option value automatically.\n");
 671                 fprintf(stderr, "In the future versions ELinks will report error when you will\n");
 672                 fprintf(stderr, "continue to use this option.\a\n");
 673                 return NULL;
 674
 675         } else {
 676                 return gettext("Internal consistency error");
 677         }
 678
 679         option = get_opt_rec(cmdline_options, target);
 680         assert(option);
 681         option_types[option->type].cmdline(option, argv, argc);
 682         return NULL;
 683 }
 684
 685 static unsigned char *
 686 printconfigdump_cmd(struct option *option, unsigned char ***argv, int *argc)
 687 {
 688         unsigned char *config_string;
 689
 690         /* Print all. */
 691         get_opt_int("config.saving_style") = 2;
 692
 693         config_string = create_config_string("", "", config_options);
 694         if (config_string) {
 695                 printf("%s", config_string);
 696                 mem_free(config_string);
 697         }
 698
 699         fflush(stdout);
 700         return "";
 701 }
 702
 703
 704 /**********************************************************************
 705  Options values
 706 **********************************************************************/
 707
 708 /* Keep options in alphabetical order. */
 709
 710 struct option_info cmdline_options_info[] = {
 711         /* [gettext_accelerator_context(IGNORE)] */
 712         INIT_OPT_BOOL("", N_("Restrict to anonymous mode"),
 713                 "anonymous", 0, 0,
 714                 N_("Restricts ELinks so it can run on an anonymous account.\n"
 715                 "Local file browsing, downloads, and modification of options\n"
 716                 "will be disabled. Execution of viewers is allowed, but entries\n"
 717                 "in the association table can't be added or modified.")),
 718
 719         INIT_OPT_BOOL("", N_("Autosubmit first form"),
 720                 "auto-submit", 0, 0,
 721                 N_("Automatically submit the first form in the given URLs.")),
 722
 723         INIT_OPT_INT("", N_("Clone internal session with given ID"),
 724                 "base-session", 0, 0, INT_MAX, 0,
 725                 N_("Used internally when opening ELinks instances in new windows.\n"
 726                 "The ID maps to information that will be used when creating the\n"
 727                 "new instance. You don't want to use it.")),
 728
 729         INIT_OPT_COMMAND("", NULL, "confdir", OPT_HIDDEN, redir_cmd, NULL),
 730
 731         INIT_OPT_STRING("", N_("Name of directory with configuration file"),
 732                 "config-dir", 0, "",
 733                 N_("Path of the directory ELinks will read and write its\n"
 734                 "config and runtime state files to instead of ~/.elinks.\n"
 735                 "If the path does not begin with a '/' it is assumed to be\n"
 736                 "relative to your HOME directory.")),
 737
 738         INIT_OPT_COMMAND("", N_("Print default configuration file to stdout"),
 739                 "config-dump", 0, printconfigdump_cmd,
 740                 N_("Print a configuration file with options set to the built-in\n"
 741                 "defaults to stdout.")),
 742
 743         INIT_OPT_COMMAND("", NULL, "conffile", OPT_HIDDEN, redir_cmd, NULL),
 744
 745         INIT_OPT_STRING("", N_("Name of configuration file"),
 746                 "config-file", 0, "elinks.conf",
 747                 N_("Name of the configuration file that all configuration\n"
 748                 "options will be read from and written to. It should be\n"
 749                 "relative to config-dir.")),
 750
 751         INIT_OPT_COMMAND("", N_("Print help for configuration options"),
 752                 "config-help", 0, printhelp_cmd,
 753                 N_("Print help for configuration options and exit.")),
 754
 755         INIT_OPT_CMDALIAS("", N_("MIME type assumed for unknown document types"),
 756                 "default-mime-type", 0, "mime.default_type",
 757                 N_("The default MIME type used for documents of unknown type.")),
 758
 759         INIT_OPT_BOOL("", N_("Ignore user-defined keybindings"),
 760                 "default-keys", 0, 0,
 761                 N_("When set, all keybindings from configuration files will be\n"
 762                 "ignored. It forces use of default keybindings and will reset\n"
 763                 "user-defined ones on save.")),
 764
 765         INIT_OPT_BOOL("", N_("Print formatted versions of given URLs to stdout"),
 766                 "dump", 0, 0,
 767                 N_("Print formatted plain-text versions of given URLs to stdout.")),
 768
 769         INIT_OPT_CMDALIAS("", N_("Codepage to use with -dump"),
 770                 "dump-charset", 0, "document.dump.codepage",
 771                 N_("Codepage used when formatting dump output.")),
 772
 773         INIT_OPT_CMDALIAS("", N_("Color mode used with -dump"),
 774                 "dump-color-mode", 0, "document.dump.color_mode",
 775                 N_("Color mode used with -dump.")),
 776
 777         INIT_OPT_CMDALIAS("", N_("Width of document formatted with -dump"),
 778                 "dump-width", 0, "document.dump.width",
 779                 N_("Width of the dump output.")),
 780
 781         INIT_OPT_COMMAND("", N_("Evaluate configuration file directive"),
 782                 "eval", 0, eval_cmd,
 783                 N_("Specify configuration file directives on the command-line\n"
 784                 "which will be evaluated after all configuration files has been\n"
 785                 "read. Example usage:\n"
 786                 "\t-eval 'set protocol.file.allow_special_files = 1'")),
 787
 788         /* lynx compatibility */
 789         INIT_OPT_COMMAND("", N_("Interpret documents of unknown types as HTML"),
 790                 "force-html", 0, forcehtml_cmd,
 791                 N_("Makes ELinks assume documents of unknown types are HTML.\n"
 792                 "Useful when using ELinks as an external viewer from MUAs.\n"
 793                 "This is equivalent to -default-mime-type text/html.")),
 794
 795         /* XXX: -?, -h and -help share the same caption and should be kept in
 796          * the current order for usage help printing to be ok */
 797         INIT_OPT_COMMAND("", NULL, "?", 0, printhelp_cmd, NULL),
 798
 799         INIT_OPT_COMMAND("", NULL, "h", 0, printhelp_cmd, NULL),
 800
 801         INIT_OPT_COMMAND("", N_("Print usage help and exit"),
 802                 "help", 0, printhelp_cmd,
 803                 N_("Print usage help and exit.")),
 804
 805         INIT_OPT_BOOL("", N_("Only permit local connections"),
 806                 "localhost", 0, 0,
 807                 N_("Restricts ELinks to work offline and only connect to servers\n"
 808                 "with local addresses (ie. 127.0.0.1). No connections to remote\n"
 809                 "servers will be permitted.")),
 810
 811         INIT_OPT_COMMAND("", N_("Print detailed usage help and exit"),
 812                 "long-help", 0, printhelp_cmd,
 813                 N_("Print detailed usage help and exit.")),
 814
 815         INIT_OPT_COMMAND("", N_("Look up specified host"),
 816                 "lookup", 0, lookup_cmd,
 817                 N_("Look up specified host and print all DNS resolved IP addresses.")),
 818
 819         INIT_OPT_BOOL("", N_("Run as separate instance"),
 820                 "no-connect", 0, 0,
 821                 N_("Run ELinks as a separate instance instead of connecting to an\n"
 822                 "existing instance. Note that normally no runtime state files\n"
 823                 "(bookmarks, history, etc.) are written to the disk when this\n"
 824                 "option is used. See also -touch-files.")),
 825
 826         INIT_OPT_BOOL("", N_("Disable use of files in ~/.elinks"),
 827                 "no-home", 0, 0,
 828                 N_("Disables creation and use of files in the user specific home\n"
 829                 "configuration directory (~/.elinks). It forces default configuration\n"
 830                 "values to be used and disables saving of runtime state files.")),
 831
 832         INIT_OPT_CMDALIAS("", N_("Disable link numbering in dump output"),
 833                 "no-numbering", OPT_ALIAS_NEGATE, "document.dump.numbering",
 834                 N_("Prevents printing of link number in dump output.\n"
 835                 "Note that this really affects only -dump, nothing else.")),
 836
 837         INIT_OPT_CMDALIAS("", N_("Disable printing of link references in dump output"),
 838                 "no-references", OPT_ALIAS_NEGATE, "document.dump.references",
 839                 N_("Prevents printing of references (URIs) of document links\n"
 840                 "in dump output.\n"
 841                 "Note that this really affects only -dump, nothing else.")),
 842
 843         INIT_OPT_COMMAND("", N_("Control an already running ELinks"),
 844                 "remote", 0, remote_cmd,
 845                 N_("Control a remote ELinks instance by passing commands to it.\n"
 846                 "The option takes an additional argument containing the method\n"
 847                 "which should be invoked and any parameters that should be passed\n"
 848                 "to it. For ease of use, the additional method argument can be\n"
 849                 "omitted in which case any URL arguments will be opened in new\n"
 850                 "tabs in the remote instance.\n"
 851                 "Following is a list of the supported methods:\n"
 852                 "\tping()                    : look for a remote instance\n"
 853                 "\topenURL()                 : prompt URL in current tab\n"
 854                 "\topenURL(URL)              : open URL in current tab\n"
 855                 "\topenURL(URL, new-tab)     : open URL in new tab\n"
 856                 "\topenURL(URL, new-window)  : open URL in new window\n"
 857                 "\taddBookmark(URL)          : bookmark URL\n"
 858                 "\tinfoBox(text)             : show text in a message box\n"
 859                 "\txfeDoCommand(openBrowser) : open new window")),
 860
 861         INIT_OPT_INT("", N_("Connect to session ring with given ID"),
 862                 "session-ring", 0, 0, INT_MAX, 0,
 863                 N_("ID of session ring this ELinks session should connect to. ELinks\n"
 864                 "works in so-called session rings, whereby all instances of ELinks\n"
 865                 "are interconnected and share state (cache, bookmarks, cookies,\n"
 866                 "and so on). By default, all ELinks instances connect to session\n"
 867                 "ring 0. You can change that behaviour with this switch and form as\n"
 868                 "many session rings as you want. Obviously, if the session-ring with\n"
 869                 "this number doesn't exist yet, it's created and this ELinks instance\n"
 870                 "will become the master instance (that usually doesn't matter for you\n"
 871                 "as a user much). Note that you usually don't want to use this unless\n"
 872                 "you're a developer and you want to do some testing - if you want the\n"
 873                 "ELinks instances each running standalone, rather use the -no-connect\n"
 874                 "command-line option. Also note that normally no runtime state files\n"
 875                 "are written to the disk when this option is used. See also\n"
 876                 "-touch-files.")),
 877
 878         INIT_OPT_BOOL("", N_("Print the source of given URLs to stdout"),
 879                 "source", 0, 0,
 880                 N_("Print given URLs in source form to stdout.")),
 881
 882         INIT_OPT_COMMAND("", NULL, "stdin", OPT_HIDDEN, redir_cmd, NULL),
 883
 884         INIT_OPT_BOOL("", N_("Touch files in ~/.elinks when running with -no-connect/-session-ring"),
 885                 "touch-files", 0, 0,
 886                 N_("When enabled, runtime state files (bookmarks, history, etc.) are\n"
 887                 "written to disk, even when -no-connect or -session-ring is used.\n"
 888                 "The option has no effect if not used in conjunction with any of\n"
 889                 "these options.")),
 890
 891         INIT_OPT_INT("", N_("Verbose level"),
 892                 "verbose", 0, 0, VERBOSE_LEVELS - 1, VERBOSE_WARNINGS,
 893                 N_("The verbose level controls what messages are shown at\n"
 894                 "start up and while running:\n"
 895                 "\t0 means only show serious errors\n"
 896                 "\t1 means show serious errors and warnings\n"
 897                 "\t2 means show all messages")),
 898
 899         INIT_OPT_COMMAND("", N_("Print version information and exit"),
 900                 "version", 0, version_cmd,
 901                 N_("Print ELinks version information and exit.")),
 902
 903         NULL_OPTION_INFO,
 904 };