src/main.cpp

   1 /*
   2  * Copyright (c) 1997 Ben Harrison, and others
   3  *
   4  * This software may be copied and distributed for educational, research,
   5  * and not for profit purposes provided that this copyright and statement
   6  * are included in all such copies.
   7  */
   8
   9 #include "core/asking-player.h"
  10 #include "core/game-play.h"
  11 #include "core/scores.h"
  12 #include "game-option/runtime-arguments.h"
  13 #include "io/files-util.h"
  14 #include "io/inet.h"
  15 #include "io/record-play-movie.h"
  16 #include "io/signal-handlers.h"
  17 #include "io/uid-checker.h"
  18 #include "main/angband-initializer.h"
  19 #include "player/process-name.h"
  20 #include "system/angband-version.h"
  21 #include "system/angband.h"
  22 #include "system/system-variables.h"
  23 #include "term/gameterm.h"
  24 #include "term/term-color-types.h"
  25 #include "util/angband-files.h"
  26 #include "util/string-processor.h"
  27 #include "wizard/wizard-spoiler.h"
  28
  29 /*
  30  * Available graphic modes
  31  */
  32 #define GRAPHICS_NONE 0
  33 #define GRAPHICS_ORIGINAL 1
  34 #define GRAPHICS_ADAM_BOLT 2
  35 #define GRAPHICS_HENGBAND 3
  36
  37 /*
  38  * Some machines have a "main()" function in their "main-xxx.c" file,
  39  * all the others use this file for their "main()" function.
  40  */
  41
  42 #ifndef WINDOWS
  43 /*
  44  * A hook for "quit()".
  45  *
  46  * Close down, then fall back into "quit()".
  47  */
  48 static void quit_hook(concptr s)
  49 {
  50     int j;
  51
  52     /* Unused */
  53     (void)s;
  54
  55     /* Scan windows */
  56     for (j = 8 - 1; j >= 0; j--) {
  57         /* Unused */
  58         if (!angband_term[j])
  59             continue;
  60
  61         /* Nuke it */
  62         term_nuke(angband_term[j]);
  63     }
  64 }
  65
  66 /*
  67  * Set the stack size and overlay buffer (see main-286.c")
  68  */
  69 #ifdef PRIVATE_USER_PATH
  70
  71 /*
  72  * Create an ".angband/" directory in the users home directory.
  73  *
  74  * ToDo: Add error handling.
  75  * ToDo: Only create the directories when actually writing files.
  76  */
  77 static void create_user_dir(void)
  78 {
  79     char dirpath[1024];
  80     char subdirpath[1024];
  81
  82     /* Get an absolute path from the filename */
  83     path_parse(dirpath, 1024, PRIVATE_USER_PATH);
  84
  85     /* Create the ~/.angband/ directory */
  86     mkdir(dirpath, 0700);
  87
  88     /* Build the path to the variant-specific sub-directory */
  89     path_build(subdirpath, sizeof(subdirpath), dirpath, VERSION_NAME);
  90
  91     /* Create the directory */
  92     mkdir(subdirpath, 0700);
  93 }
  94
  95 #endif /* PRIVATE_USER_PATH */
  96
  97 /*
  98  * Initialize and verify the file paths, and the score file.
  99  *
 100  * Use the ANGBAND_PATH environment var if possible, else use
 101  * DEFAULT_(LIB|VAR)_PATH, and in either case, branch off
 102  * appropriately.
 103  *
 104  * First, we'll look for the ANGBAND_PATH environment variable,
 105  * and then look for the files in there.  If that doesn't work,
 106  * we'll try the DEFAULT_(LIB|VAR)_PATH constants.  So be sure
 107  * that one of these two things works...
 108  *
 109  * We must ensure that the path ends with "PATH_SEP" if needed,
 110  * since the "init_file_paths()" function will simply append the
 111  * relevant "sub-directory names" to the given path.
 112  *
 113  * Make sure that the path doesn't overflow the buffer.  We have
 114  * to leave enough space for the path separator, directory, and
 115  * filenames.
 116  */
 117 static void init_stuff(void)
 118 {
 119     char libpath[1024], varpath[1024];
 120
 121     concptr tail;
 122
 123     /* Get the environment variable */
 124     tail = getenv("ANGBAND_PATH");
 125
 126     /* Use the angband_path, or a default */
 127     strncpy(libpath, tail ? tail : DEFAULT_LIB_PATH, 511);
 128     strncpy(varpath, tail ? tail : DEFAULT_VAR_PATH, 511);
 129
 130     /* Make sure they're terminated */
 131     libpath[511] = '\0';
 132     varpath[511] = '\0';
 133
 134     /* Hack -- Add a path separator (only if needed) */
 135     if (!suffix(libpath, PATH_SEP))
 136         strcat(libpath, PATH_SEP);
 137     if (!suffix(varpath, PATH_SEP))
 138         strcat(varpath, PATH_SEP);
 139
 140     /* Initialize */
 141     init_file_paths(libpath, varpath);
 142 }
 143
 144 /*
 145  * Handle a "-d<what>=<path>" option
 146  *
 147  * The "<what>" can be any string starting with the same letter as the
 148  * name of a subdirectory of the "lib" folder (i.e. "i" or "info").
 149  *
 150  * The "<path>" can be any legal path for the given system, and should
 151  * not end in any special path separator (i.e. "/tmp" or "~/.ang-info").
 152  */
 153 static void change_path(concptr info)
 154 {
 155     concptr s;
 156
 157     /* Find equal sign */
 158     s = angband_strchr(info, '=');
 159
 160     /* Verify equal sign */
 161     if (!s)
 162         quit_fmt("Try '-d<what>=<path>' not '-d%s'", info);
 163
 164     /* Analyze */
 165     switch (tolower(info[0])) {
 166     case 'a': {
 167         string_free(ANGBAND_DIR_APEX);
 168         ANGBAND_DIR_APEX = string_make(s + 1);
 169         break;
 170     }
 171
 172     case 'f': {
 173         string_free(ANGBAND_DIR_FILE);
 174         ANGBAND_DIR_FILE = string_make(s + 1);
 175         break;
 176     }
 177
 178     case 'h': {
 179         string_free(ANGBAND_DIR_HELP);
 180         ANGBAND_DIR_HELP = string_make(s + 1);
 181         break;
 182     }
 183
 184     case 'i': {
 185         string_free(ANGBAND_DIR_INFO);
 186         ANGBAND_DIR_INFO = string_make(s + 1);
 187         break;
 188     }
 189
 190     case 'u': {
 191         string_free(ANGBAND_DIR_USER);
 192         ANGBAND_DIR_USER = string_make(s + 1);
 193         break;
 194     }
 195
 196     case 'x': {
 197         string_free(ANGBAND_DIR_XTRA);
 198         ANGBAND_DIR_XTRA = string_make(s + 1);
 199         break;
 200     }
 201
 202     case 'b': {
 203         string_free(ANGBAND_DIR_BONE);
 204         ANGBAND_DIR_BONE = string_make(s + 1);
 205         break;
 206     }
 207
 208     case 'd': {
 209         string_free(ANGBAND_DIR_DATA);
 210         ANGBAND_DIR_DATA = string_make(s + 1);
 211         break;
 212     }
 213
 214     case 'e': {
 215         string_free(ANGBAND_DIR_EDIT);
 216         ANGBAND_DIR_EDIT = string_make(s + 1);
 217         break;
 218     }
 219
 220     case 's': {
 221         string_free(ANGBAND_DIR_SAVE);
 222         ANGBAND_DIR_SAVE = string_make(s + 1);
 223         break;
 224     }
 225
 226     case 'z': {
 227         string_free(ANGBAND_DIR_SCRIPT);
 228         ANGBAND_DIR_SCRIPT = string_make(s + 1);
 229         break;
 230     }
 231
 232     default: {
 233         quit_fmt("Bad semantics in '-d%s'", info);
 234     }
 235     }
 236 }
 237
 238 static void display_usage(const char *program)
 239 {
 240     /* Dump usage information */
 241     printf("Usage: %s [options] [-- subopts]\n", program);
 242     puts("  -n       Start a new character");
 243     puts("  -f       Request fiddle mode");
 244     puts("  -w       Request wizard mode");
 245     puts("  -b       Request BGM mode");
 246     puts("  -v       Request sound mode");
 247     puts("  -g       Request graphics mode");
 248     puts("  -o       Request original keyset");
 249     puts("  -r       Request rogue-like keyset");
 250     puts("  -M       Request monochrome mode");
 251     puts("  -s<num>  Show <num> high scores");
 252     puts("  -u<who>  Use your <who> savefile");
 253     puts("  -m<sys>  Force 'main-<sys>.c' usage");
 254     puts("  -d<def>  Define a 'lib' dir sub-path");
 255     puts("  --output-spoilers");
 256     puts("           Output auto generated spoilers and exit");
 257     puts("");
 258
 259 #ifdef USE_X11
 260     puts("  -mx11    To use X11");
 261     puts("  --       Sub options");
 262     puts("  -- -d    Set display name");
 263     puts("  -- -o    Request old 8x8 tile graphics");
 264     puts("  -- -a    Request Adam Bolt 16x16 tile graphics");
 265     puts("  -- -b    Request Bigtile graphics mode");
 266     puts("  -- -s    Turn off smoothscaling graphics");
 267     puts("  -- -n#   Number of terms to use");
 268     puts("");
 269 #endif /* USE_X11 */
 270
 271 #ifdef USE_GCU
 272     puts("  -mgcu    To use GCU (GNU Curses)");
 273 #endif /* USE_GCU */
 274
 275 #ifdef USE_CAP
 276     puts("  -mcap    To use CAP (\"Termcap\" calls)");
 277 #endif /* USE_CAP */
 278
 279     /* Actually abort the process */
 280     quit(NULL);
 281 }
 282
 283 static bool parse_long_opt(const char *opt)
 284 {
 285     bool is_usage_needed = TRUE;
 286
 287     if (strcmp(opt + 2, "output-spoilers") == 0) {
 288         init_stuff();
 289         init_angband(p_ptr, TRUE);
 290         switch (output_all_spoilers()) {
 291         case SPOILER_OUTPUT_SUCCESS:
 292             puts("Successfully created a spoiler file.");
 293             quit(NULL);
 294             break;
 295         case SPOILER_OUTPUT_FAIL_FOPEN:
 296             quit("Cannot create spoiler file.");
 297             break;
 298         case SPOILER_OUTPUT_FAIL_FCLOSE:
 299             quit("Cannot close spoiler file.");
 300             break;
 301         default:
 302             break;
 303         }
 304         is_usage_needed = FALSE;
 305     }
 306
 307     return is_usage_needed;
 308 }
 309
 310 /*
 311  * Simple "main" function for multiple platforms.
 312  *
 313  * Note the special "--" option which terminates the processing of
 314  * standard options.  All non-standard options (if any) are passed
 315  * directly to the "init_xxx()" function.
 316  */
 317 int main(int argc, char *argv[])
 318 {
 319     int i;
 320
 321     bool done = FALSE;
 322     bool new_game = FALSE;
 323     int show_score = 0;
 324     concptr mstr = NULL;
 325     bool args = TRUE;
 326
 327     /* Save the "program name" XXX XXX XXX */
 328     argv0 = argv[0];
 329
 330 #ifdef SET_UID
 331
 332     /* Default permissions on files */
 333     (void)umask(022);
 334
 335 #endif
 336
 337     /* Get the file paths */
 338     init_stuff();
 339
 340 #ifdef SET_UID
 341
 342     /* Get the user id (?) */
 343     p_ptr->player_uid = getuid();
 344
 345 #ifdef VMS
 346     /* Mega-Hack -- Factor group id */
 347     p_ptr->player_uid += (getgid() * 1000);
 348 #endif
 349
 350 #ifdef SAFE_SETUID
 351
 352 #ifdef _POSIX_SAVED_IDS
 353
 354     /* Save some info for later */
 355     p_ptr->player_euid = geteuid();
 356     p_ptr->player_egid = getegid();
 357
 358 #endif
 359
 360 #endif
 361
 362 #endif
 363
 364     /* Drop permissions */
 365     safe_setuid_drop();
 366
 367 #ifdef SET_UID
 368
 369     /* Acquire the "user name" as a default player name */
 370     user_name(p_ptr->name, p_ptr->player_uid);
 371
 372 #ifdef PRIVATE_USER_PATH
 373
 374     /* Create a directory for the users files. */
 375     create_user_dir();
 376
 377 #endif /* PRIVATE_USER_PATH */
 378
 379 #endif /* SET_UID */
 380
 381     /* Process the command line arguments */
 382     bool browsing_movie = FALSE;
 383     for (i = 1; args && (i < argc); i++) {
 384         /* Require proper options */
 385         if (argv[i][0] != '-') {
 386             display_usage(argv[0]);
 387             continue;
 388         }
 389
 390         /* Analyze option */
 391         bool is_usage_needed = FALSE;
 392         switch (argv[i][1]) {
 393         case 'N':
 394         case 'n': {
 395             new_game = TRUE;
 396             break;
 397         }
 398         case 'F':
 399         case 'f': {
 400             arg_fiddle = TRUE;
 401             break;
 402         }
 403         case 'W':
 404         case 'w': {
 405             arg_wizard = TRUE;
 406             break;
 407         }
 408         case 'B':
 409         case 'b': {
 410             arg_music = TRUE;
 411             break;
 412         }
 413         case 'V':
 414         case 'v': {
 415             arg_sound = TRUE;
 416             break;
 417         }
 418         case 'G':
 419         case 'g': {
 420             /* HACK - Graphics mode switches on the original tiles */
 421             arg_graphics = GRAPHICS_ORIGINAL;
 422             break;
 423         }
 424         case 'R':
 425         case 'r': {
 426             arg_force_roguelike = TRUE;
 427             break;
 428         }
 429         case 'O':
 430         case 'o': {
 431             arg_force_original = TRUE;
 432             break;
 433         }
 434         case 'S':
 435         case 's': {
 436             show_score = atoi(&argv[i][2]);
 437             if (show_score <= 0)
 438                 show_score = 10;
 439             break;
 440         }
 441         case 'u':
 442         case 'U': {
 443             if (!argv[i][2]) {
 444                 is_usage_needed = TRUE;
 445                 break;
 446             }
 447
 448             strcpy(p_ptr->name, &argv[i][2]);
 449             break;
 450         }
 451         case 'm': {
 452             if (!argv[i][2]) {
 453                 is_usage_needed = TRUE;
 454                 break;
 455             }
 456
 457             mstr = &argv[i][2];
 458             break;
 459         }
 460         case 'M': {
 461             arg_monochrome = TRUE;
 462             break;
 463         }
 464         case 'd':
 465         case 'D': {
 466             change_path(&argv[i][2]);
 467             break;
 468         }
 469         case 'x': {
 470             if (!argv[i][2]) {
 471                 is_usage_needed = TRUE;
 472                 break;
 473             }
 474
 475             prepare_browse_movie_with_path_build(&argv[i][2]);
 476             browsing_movie = TRUE;
 477             break;
 478         }
 479         case '-': {
 480             if (argv[i][2] == '\0') {
 481                 argv[i] = argv[0];
 482                 argc = argc - i;
 483                 argv = argv + i;
 484                 args = FALSE;
 485             } else {
 486                 is_usage_needed = parse_long_opt(argv[i]);
 487             }
 488             break;
 489         }
 490         default: {
 491             is_usage_needed = TRUE;
 492             break;
 493         }
 494         }
 495
 496         if (!is_usage_needed)
 497             continue;
 498
 499         display_usage(argv[0]);
 500     }
 501
 502     /* Hack -- Forget standard args */
 503     if (args) {
 504         argc = 1;
 505         argv[1] = NULL;
 506     }
 507
 508     /* Process the player name */
 509     process_player_name(p_ptr, TRUE);
 510
 511     /* Install "quit" hook */
 512     quit_aux = quit_hook;
 513
 514 #ifdef USE_XAW
 515     /* Attempt to use the "main-xaw.c" support */
 516     if (!done && (!mstr || (streq(mstr, "xaw")))) {
 517         extern errr init_xaw(int, char **);
 518         if (0 == init_xaw(argc, argv)) {
 519             ANGBAND_SYS = "xaw";
 520             done = TRUE;
 521         }
 522     }
 523 #endif
 524
 525 #ifdef USE_X11
 526     /* Attempt to use the "main-x11.c" support */
 527     if (!done && (!mstr || (streq(mstr, "x11")))) {
 528         extern errr init_x11(int, char **);
 529         if (0 == init_x11(argc, argv)) {
 530             ANGBAND_SYS = "x11";
 531             done = TRUE;
 532         }
 533     }
 534 #endif
 535
 536 #ifdef USE_GCU
 537     /* Attempt to use the "main-gcu.c" support */
 538     if (!done && (!mstr || (streq(mstr, "gcu")))) {
 539         extern errr init_gcu(int, char **);
 540         if (0 == init_gcu(argc, argv)) {
 541             ANGBAND_SYS = "gcu";
 542             done = TRUE;
 543         }
 544     }
 545 #endif
 546
 547 #ifdef USE_CAP
 548     /* Attempt to use the "main-cap.c" support */
 549     if (!done && (!mstr || (streq(mstr, "cap")))) {
 550         extern errr init_cap(int, char **);
 551         if (0 == init_cap(argc, argv)) {
 552             ANGBAND_SYS = "cap";
 553             done = TRUE;
 554         }
 555     }
 556 #endif
 557
 558     /* Make sure we have a display! */
 559     if (!done)
 560         quit("Unable to prepare any 'display module'!");
 561
 562     /* Hack -- If requested, display scores and quit */
 563     if (show_score > 0)
 564         display_scores(0, show_score);
 565
 566     /* Catch nasty signals */
 567     signals_init();
 568
 569     /* Initialize */
 570     init_angband(p_ptr, FALSE);
 571
 572     /* Wait for response */
 573     pause_line(23);
 574
 575     /* Play the game */
 576     play_game(p_ptr, new_game, browsing_movie);
 577
 578     /* Quit */
 579     quit(NULL);
 580
 581     /* Exit */
 582     return (0);
 583 }
 584
 585 #endif