git.hungrycats.org Git - xscreensaver/blob - driver/prefs.c

   1 /* dotfile.c --- management of the ~/.xscreensaver file.
   2  * xscreensaver, Copyright (c) 1998 Jamie Zawinski <jwz@jwz.org>
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation.  No representations are made about the suitability of this
   9  * software for any purpose.  It is provided "as is" without express or
  10  * implied warranty.
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 # include "config.h"
  15 #endif
  16
  17 #include <stdlib.h>
  18
  19 #ifdef HAVE_UNISTD_H
  20 # include <unistd.h>
  21 #endif
  22
  23 #include <stdio.h>
  24 #include <ctype.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <sys/time.h>
  28
  29 #include <X11/Xlib.h>
  30 #include <X11/Xresource.h>
  31
  32 #ifndef VMS
  33 # include <pwd.h>
  34 #else /* VMS */
  35 # include "vms-pwd.h"
  36 #endif /* VMS */
  37
  38
  39 /* This file doesn't need the Xt headers, so stub these types out... */
  40 #undef XtPointer
  41 #define XtAppContext void*
  42 #define XtIntervalId void*
  43 #define XtPointer    void*
  44 #define Widget       void*
  45
  46
  47 /* Just in case there's something pathological about stat.h... */
  48 #ifndef  S_IRUSR
  49 # define S_IRUSR 00400
  50 #endif
  51 #ifndef  S_IWUSR
  52 # define S_IWUSR 00200
  53 #endif
  54 #ifndef  S_IXUSR
  55 # define S_IXUSR 00100
  56 #endif
  57 #ifndef  S_IXGRP
  58 # define S_IXGRP 00010
  59 #endif
  60 #ifndef  S_IXOTH
  61 # define S_IXOTH 00001
  62 #endif
  63
  64
  65 #include "prefs.h"
  66 #include "resources.h"
  67
  68
  69 extern char *progname;
  70 extern char *progclass;
  71 extern const char *blurb (void);
  72
  73
  74
  75 static void get_screenhacks (saver_preferences *p);
  76
  77
  78 static char *
  79 chase_symlinks (const char *file)
  80 {
  81 # ifdef HAVE_REALPATH
  82   if (file)
  83     {
  84       char buf [2048];
  85       if (realpath (file, buf))
  86         return strdup (buf);
  87
  88       sprintf (buf, "%s: realpath", blurb());
  89       perror(buf);
  90     }
  91 # endif /* HAVE_REALPATH */
  92   return 0;
  93 }
  94
  95
  96 const char *
  97 init_file_name (void)
  98 {
  99   static char *file = 0;
 100
 101   if (!file)
 102     {
 103       struct passwd *p = getpwuid (getuid ());
 104
 105       if (!p || !p->pw_name || !*p->pw_name)
 106         {
 107           fprintf (stderr, "%s: couldn't get user info of uid %d\n",
 108                    blurb(), getuid ());
 109           file = "";
 110         }
 111       else if (!p->pw_dir || !*p->pw_dir)
 112         {
 113           fprintf (stderr, "%s: couldn't get home directory of \"%s\"\n",
 114                    blurb(), (p->pw_name ? p->pw_name : "???"));
 115           file = "";
 116         }
 117       else
 118         {
 119           const char *home = p->pw_dir;
 120           const char *name = ".xscreensaver";
 121           file = (char *) malloc(strlen(home) + strlen(name) + 2);
 122           strcpy(file, home);
 123           if (!*home || home[strlen(home)-1] != '/')
 124             strcat(file, "/");
 125           strcat(file, name);
 126         }
 127     }
 128
 129   if (file && *file)
 130     return file;
 131   else
 132     return 0;
 133 }
 134
 135
 136 static const char *
 137 init_file_tmp_name (void)
 138 {
 139   static char *file = 0;
 140   if (!file)
 141     {
 142       const char *name = init_file_name();
 143       const char *suffix = ".tmp";
 144
 145       char *n2 = chase_symlinks (name);
 146       if (n2) name = n2;
 147
 148       if (!name || !*name)
 149         file = "";
 150       else
 151         {
 152           file = (char *) malloc(strlen(name) + strlen(suffix) + 2);
 153           strcpy(file, name);
 154           strcat(file, suffix);
 155         }
 156
 157       if (n2) free (n2);
 158     }
 159
 160   if (file && *file)
 161     return file;
 162   else
 163     return 0;
 164 }
 165
 166
 167 static const char * const prefs[] = {
 168   "timeout",
 169   "cycle",
 170   "lock",
 171   "lockVTs",
 172   "lockTimeout",
 173   "passwdTimeout",
 174   "visualID",
 175   "installColormap",
 176   "verbose",
 177   "timestamp",
 178   "splash",                     /* not saved -- same as "splashDuration: 0" */
 179   "splashDuration",
 180   "demoCommand",
 181   "prefsCommand",
 182   "helpURL",
 183   "loadURL",
 184   "nice",
 185   "fade",
 186   "unfade",
 187   "fadeSeconds",
 188   "fadeTicks",
 189   "captureStderr",
 190   "captureStdout",              /* not saved -- obsolete */
 191   "font",
 192   "",
 193   "programs",
 194   "",
 195   "pointerPollTime",
 196   "windowCreationTimeout",
 197   "initialDelay",
 198   "sgiSaverExtension",
 199   "mitSaverExtension",
 200   "xidleExtension",
 201   "procInterrupts",
 202   "overlayStderr",
 203   "overlayTextBackground",      /* not saved -- X resources only */
 204   "overlayTextForeground",      /* not saved -- X resources only */
 205   "bourneShell",                /* not saved -- X resources only */
 206   0
 207 };
 208
 209 static char *
 210 strip (char *s)
 211 {
 212   char *s2;
 213   while (*s == '\t' || *s == ' ' || *s == '\r' || *s == '\n')
 214     s++;
 215   for (s2 = s; *s2; s2++)
 216     ;
 217   for (s2--; s2 >= s; s2--)
 218     if (*s2 == '\t' || *s2 == ' ' || *s2 == '\r' || *s2 =='\n')
 219       *s2 = 0;
 220     else
 221       break;
 222   return s;
 223 }
 224
 225 \f
 226 /* Reading
 227  */
 228
 229 static int
 230 handle_entry (XrmDatabase *db, const char *key, const char *value,
 231               const char *filename, int line)
 232 {
 233   int i;
 234   for (i = 0; prefs[i]; i++)
 235     if (*prefs[i] && !strcasecmp(key, prefs[i]))
 236       {
 237         char *val = strdup(value);
 238         char *spec = (char *) malloc(strlen(progclass) + strlen(prefs[i]) +10);
 239         strcpy(spec, progclass);
 240         strcat(spec, ".");
 241         strcat(spec, prefs[i]);
 242
 243         XrmPutStringResource (db, spec, val);
 244
 245         free(spec);
 246         free(val);
 247         return 0;
 248       }
 249
 250   fprintf(stderr, "%s: %s:%d: unknown option \"%s\"\n",
 251           blurb(), filename, line, key);
 252   return 1;
 253 }
 254
 255
 256 static int
 257 parse_init_file (saver_preferences *p)
 258 {
 259   time_t write_date = 0;
 260   const char *name = init_file_name();
 261   int line = 0;
 262   struct stat st;
 263   FILE *in;
 264   int buf_size = 1024;
 265   char *buf;
 266
 267   if (!name) return 0;
 268
 269   if (stat(name, &st) != 0)
 270     {
 271       p->init_file_date = 0;
 272       return 0;
 273     }
 274
 275   in = fopen(name, "r");
 276   if (!in)
 277     {
 278       char *buf = (char *) malloc(1024 + strlen(name));
 279       sprintf(buf, "%s: error reading \"%s\"", blurb(), name);
 280       perror(buf);
 281       free(buf);
 282       return -1;
 283     }
 284
 285   if (fstat (fileno(in), &st) == 0)
 286     {
 287       write_date = st.st_mtime;
 288     }
 289   else
 290     {
 291       char *buf = (char *) malloc(1024 + strlen(name));
 292       sprintf(buf, "%s: couldn't re-stat \"%s\"", blurb(), name);
 293       perror(buf);
 294       free(buf);
 295       return -1;
 296     }
 297
 298   buf = (char *) malloc(buf_size);
 299
 300   while (fgets (buf, buf_size-1, in))
 301     {
 302       char *key, *value;
 303       int L = strlen(buf);
 304
 305       line++;
 306       while (L > 2 &&
 307              (buf[L-1] != '\n' ||       /* whole line didn't fit in buffer */
 308               buf[L-2] == '\\'))        /* or line ended with backslash */
 309         {
 310           if (buf[L-2] == '\\')         /* backslash-newline gets swallowed */
 311             {
 312               buf[L-2] = 0;
 313               L -= 2;
 314             }
 315           buf_size += 1024;
 316           buf = (char *) realloc(buf, buf_size);
 317           if (!buf) exit(1);
 318
 319           line++;
 320           if (!fgets (buf + L, buf_size-L-1, in))
 321             break;
 322           L = strlen(buf);
 323         }
 324
 325       /* Now handle other backslash escapes. */
 326       {
 327         int i, j;
 328         for (i = 0; buf[i]; i++)
 329           if (buf[i] == '\\')
 330             {
 331               switch (buf[i+1])
 332                 {
 333                 case 'n': buf[i] = '\n'; break;
 334                 case 'r': buf[i] = '\r'; break;
 335                 case 't': buf[i] = '\t'; break;
 336                 default:  buf[i] = buf[i+1]; break;
 337                 }
 338               for (j = i+2; buf[j]; j++)
 339                 buf[j-1] = buf[j];
 340               buf[j-1] = 0;
 341             }
 342       }
 343
 344       key = strip(buf);
 345
 346       if (*key == '#' || *key == '!' || *key == ';' ||
 347           *key == '\n' || *key == 0)
 348         continue;
 349
 350       value = strchr (key, ':');
 351       if (!value)
 352         {
 353           fprintf(stderr, "%s: %s:%d: unparsable line: %s\n", blurb(),
 354                   name, line, key);
 355           continue;
 356         }
 357       else
 358         {
 359           *value++ = 0;
 360           value = strip(value);
 361         }
 362
 363       if (!p->db) abort();
 364       handle_entry (&p->db, key, value, name, line);
 365     }
 366   fclose (in);
 367   free(buf);
 368
 369   p->init_file_date = write_date;
 370   return 0;
 371 }
 372
 373
 374 Bool
 375 init_file_changed_p (saver_preferences *p)
 376 {
 377   const char *name = init_file_name();
 378   struct stat st;
 379
 380   if (!name) return False;
 381
 382   if (stat(name, &st) != 0)
 383     return False;
 384
 385   if (p->init_file_date == st.st_mtime)
 386     return False;
 387
 388   return True;
 389 }
 390
 391 \f
 392 /* Writing
 393  */
 394
 395 static int
 396 tab_to (FILE *out, int from, int to)
 397 {
 398   int tab_width = 8;
 399   int to_mod = (to / tab_width) * tab_width;
 400   while (from < to_mod)
 401     {
 402       fprintf(out, "\t");
 403       from = (((from / tab_width) + 1) * tab_width);
 404     }
 405   while (from < to)
 406     {
 407       fprintf(out, " ");
 408       from++;
 409     }
 410   return from;
 411 }
 412
 413 static void
 414 write_entry (FILE *out, const char *key, const char *value)
 415 {
 416   char *v = strdup(value ? value : "");
 417   char *v2 = v;
 418   char *nl = 0;
 419   int col;
 420   Bool do_visual_kludge = (!strcmp(key, "programs"));
 421   Bool do_wrap = do_visual_kludge;
 422   int tab = (do_visual_kludge ? 16 : 23);
 423   int tab2 = 3;
 424   Bool first = True;
 425
 426   fprintf(out, "%s:", key);
 427   col = strlen(key) + 1;
 428
 429   while (1)
 430     {
 431       char *s;
 432       Bool disabled_p = False;
 433
 434       v2 = strip(v2);
 435       nl = strchr(v2, '\n');
 436       if (nl)
 437         *nl = 0;
 438
 439       if (do_visual_kludge && *v2 == '-')
 440         {
 441           disabled_p = True;
 442           v2++;
 443           v2 = strip(v2);
 444         }
 445
 446       if (first && disabled_p)
 447         first = False;
 448
 449       if (first)
 450         first = False;
 451       else
 452         {
 453           col = tab_to(out, col, 75);
 454           fprintf(out, " \\n\\\n");
 455           col = 0;
 456         }
 457
 458       if (disabled_p)
 459         {
 460           fprintf(out, "-");
 461           col++;
 462         }
 463
 464       s = (do_visual_kludge ? strpbrk(v2, " \t\n:") : 0);
 465       if (s && *s == ':')
 466         col = tab_to (out, col, tab2);
 467       else
 468         col = tab_to (out, col, tab);
 469
 470       if (do_wrap &&
 471           strlen(v2) + col > 75)
 472         {
 473           int L = strlen(v2);
 474           int start = 0;
 475           int end = start;
 476           while (start < L)
 477             {
 478               while (v2[end] == ' ' || v2[end] == '\t')
 479                 end++;
 480               while (v2[end] != ' ' && v2[end] != '\t' &&
 481                      v2[end] != '\n' && v2[end] != 0)
 482                 end++;
 483               if (col + (end - start) >= 74)
 484                 {
 485                   col = tab_to (out, col, 75);
 486                   fprintf(out, "   \\\n");
 487                   col = tab_to (out, 0, tab + 2);
 488                   while (v2[start] == ' ' || v2[start] == '\t')
 489                     start++;
 490                 }
 491
 492               while (start < end)
 493                 {
 494                   fputc(v2[start++], out);
 495                   col++;
 496                 }
 497             }
 498         }
 499       else
 500         {
 501           fprintf (out, "%s", v2);
 502           col += strlen(v2);
 503         }
 504
 505       if (nl)
 506         v2 = nl + 1;
 507       else
 508         break;
 509     }
 510
 511   fprintf(out, "\n");
 512   free(v);
 513 }
 514
 515 void
 516 write_init_file (saver_preferences *p, const char *version_string)
 517 {
 518   const char *name = init_file_name();
 519   const char *tmp_name = init_file_tmp_name();
 520   char *n2 = chase_symlinks (name);
 521   struct stat st;
 522   int i, j;
 523
 524   /* Kludge, since these aren't in the saver_preferences struct as strings...
 525    */
 526   char *visual_name;
 527   char *programs;
 528   Bool capture_stderr_p;
 529   Bool overlay_stderr_p;
 530   char *stderr_font;
 531   FILE *out;
 532
 533   if (!name) goto END;
 534
 535   if (n2) name = n2;
 536
 537   if (p->verbose_p)
 538     fprintf (stderr, "%s: writing \"%s\".\n", blurb(), name);
 539
 540   unlink (tmp_name);
 541   out = fopen(tmp_name, "w");
 542   if (!out)
 543     {
 544       char *buf = (char *) malloc(1024 + strlen(name));
 545       sprintf(buf, "%s: error writing \"%s\"", blurb(), name);
 546       perror(buf);
 547       free(buf);
 548       goto END;
 549     }
 550
 551   /* Give the new .xscreensaver file the same permissions as the old one;
 552      except ensure that it is readable and writable by owner, and not
 553      executable.
 554    */
 555   if (stat(name, &st) == 0)
 556     {
 557       mode_t mode = st.st_mode;
 558       mode |= S_IRUSR | S_IWUSR;
 559       mode &= ~(S_IXUSR | S_IXGRP | S_IXOTH);
 560       if (fchmod (fileno(out), mode) != 0)
 561         {
 562           char *buf = (char *) malloc(1024 + strlen(name));
 563           sprintf (buf, "%s: error fchmodding \"%s\" to 0%o", blurb(),
 564                    tmp_name, (unsigned int) mode);
 565           perror(buf);
 566           free(buf);
 567           goto END;
 568         }
 569     }
 570
 571   /* Kludge, since these aren't in the saver_preferences struct... */
 572   visual_name = get_string_resource ("visualID", "VisualID");
 573   programs = 0;
 574   capture_stderr_p = get_boolean_resource ("captureStderr", "Boolean");
 575   overlay_stderr_p = get_boolean_resource ("overlayStderr", "Boolean");
 576   stderr_font = get_string_resource ("font", "Font");
 577
 578   i = 0;
 579   for (j = 0; j < p->screenhacks_count; j++)
 580     i += strlen(p->screenhacks[j]) + 2;
 581   {
 582     char *ss = programs = (char *) malloc(i + 10);
 583     *ss = 0;
 584     for (j = 0; j < p->screenhacks_count; j++)
 585       {
 586         strcat(ss, p->screenhacks[j]);
 587         ss += strlen(ss);
 588         *ss++ = '\n';
 589         *ss = 0;
 590       }
 591   }
 592
 593   {
 594     struct passwd *pw = getpwuid (getuid ());
 595     char *whoami = (pw && pw->pw_name && *pw->pw_name
 596                     ? pw->pw_name
 597                     : "<unknown>");
 598     time_t now = time ((time_t *) 0);
 599     char *timestr = (char *) ctime (&now);
 600     char *nl = (char *) strchr (timestr, '\n');
 601     if (nl) *nl = 0;
 602     fprintf (out,
 603              "# %s Preferences File\n"
 604              "# Written by %s %s for %s on %s.\n"
 605              "# http://www.jwz.org/xscreensaver/\n"
 606              "\n",
 607              progclass, progname, version_string, whoami, timestr);
 608   }
 609
 610   for (j = 0; prefs[j]; j++)
 611     {
 612       char buf[255];
 613       const char *pr = prefs[j];
 614       enum pref_type { pref_str, pref_int, pref_bool, pref_time
 615       } type = pref_str;
 616       const char *s = 0;
 617       int i = 0;
 618       Bool b = False;
 619       Time t = 0;
 620
 621       if (pr && !*pr)
 622         {
 623           fprintf(out, "\n");
 624           continue;
 625         }
 626
 627 # undef CHECK
 628 # define CHECK(X) else if (!strcmp(pr, X))
 629       if (!pr || !*pr)          ;
 630       CHECK("timeout")          type = pref_time, t = p->timeout;
 631       CHECK("cycle")            type = pref_time, t = p->cycle;
 632       CHECK("lock")             type = pref_bool, b = p->lock_p;
 633 # if 0 /* #### not ready yet */
 634       CHECK("lockVTs")          type = pref_bool, b = p->lock_vt_p;
 635 # else
 636       CHECK("lockVTs")          continue;  /* don't save */
 637 # endif
 638       CHECK("lockTimeout")      type = pref_time, t = p->lock_timeout;
 639       CHECK("passwdTimeout")    type = pref_time, t = p->passwd_timeout;
 640       CHECK("visualID")         type = pref_str,  s =    visual_name;
 641       CHECK("installColormap")  type = pref_bool, b = p->install_cmap_p;
 642       CHECK("verbose")          type = pref_bool, b = p->verbose_p;
 643       CHECK("timestamp")        type = pref_bool, b = p->timestamp_p;
 644       CHECK("splash")           continue;  /* don't save */
 645       CHECK("splashDuration")   type = pref_time, t = p->splash_duration;
 646       CHECK("demoCommand")      type = pref_str,  s = p->demo_command;
 647       CHECK("prefsCommand")     type = pref_str,  s = p->prefs_command;
 648       CHECK("helpURL")          type = pref_str,  s = p->help_url;
 649       CHECK("loadURL")          type = pref_str,  s = p->load_url_command;
 650       CHECK("nice")             type = pref_int,  i = p->nice_inferior;
 651       CHECK("fade")             type = pref_bool, b = p->fade_p;
 652       CHECK("unfade")           type = pref_bool, b = p->unfade_p;
 653       CHECK("fadeSeconds")      type = pref_time, t = p->fade_seconds;
 654       CHECK("fadeTicks")        type = pref_int,  i = p->fade_ticks;
 655       CHECK("captureStderr")    type = pref_bool, b =    capture_stderr_p;
 656       CHECK("captureStdout")    continue;  /* don't save */
 657       CHECK("font")             type = pref_str,  s =    stderr_font;
 658       CHECK("programs")         type = pref_str,  s =    programs;
 659       CHECK("pointerPollTime")  type = pref_time, t = p->pointer_timeout;
 660       CHECK("windowCreationTimeout")type=pref_time,t= p->notice_events_timeout;
 661       CHECK("initialDelay")     type = pref_time, t = p->initial_delay;
 662       CHECK("sgiSaverExtension")type = pref_bool, b=p->use_sgi_saver_extension;
 663       CHECK("mitSaverExtension")type = pref_bool, b=p->use_mit_saver_extension;
 664       CHECK("xidleExtension")   type = pref_bool, b = p->use_xidle_extension;
 665       CHECK("procInterrupts")   type = pref_bool, b = p->use_proc_interrupts;
 666       CHECK("overlayStderr")    type = pref_bool, b = overlay_stderr_p;
 667       CHECK("overlayTextBackground") continue;  /* don't save */
 668       CHECK("overlayTextForeground") continue;  /* don't save */
 669       CHECK("bourneShell")      continue;
 670       else                      abort();
 671 # undef CHECK
 672
 673       switch (type)
 674         {
 675         case pref_str:
 676           break;
 677         case pref_int:
 678           sprintf(buf, "%d", i);
 679           s = buf;
 680           break;
 681         case pref_bool:
 682           s = b ? "True" : "False";
 683           break;
 684         case pref_time:
 685           {
 686             unsigned int hour = 0, min = 0, sec = (unsigned int) (t/1000);
 687             if (sec >= 60)
 688               {
 689                 min += (sec / 60);
 690                 sec %= 60;
 691               }
 692             if (min >= 60)
 693               {
 694                 hour += (min / 60);
 695                 min %= 60;
 696               }
 697             sprintf (buf, "%u:%02u:%02u", hour, min, sec);
 698             s = buf;
 699           }
 700           break;
 701         default:
 702           abort();
 703           break;
 704         }
 705       write_entry (out, pr, s);
 706     }
 707
 708   fprintf(out, "\n");
 709
 710   if (visual_name) free(visual_name);
 711   if (stderr_font) free(stderr_font);
 712   if (programs) free(programs);
 713
 714   if (fclose(out) == 0)
 715     {
 716       time_t write_date = 0;
 717
 718       if (stat(tmp_name, &st) == 0)
 719         {
 720           write_date = st.st_mtime;
 721         }
 722       else
 723         {
 724           char *buf = (char *) malloc(1024 + strlen(tmp_name) + strlen(name));
 725           sprintf(buf, "%s: couldn't stat \"%s\"", blurb(), tmp_name);
 726           perror(buf);
 727           unlink (tmp_name);
 728           free(buf);
 729           goto END;
 730         }
 731
 732       if (rename (tmp_name, name) != 0)
 733         {
 734           char *buf = (char *) malloc(1024 + strlen(tmp_name) + strlen(name));
 735           sprintf(buf, "%s: error renaming \"%s\" to \"%s\"",
 736                   blurb(), tmp_name, name);
 737           perror(buf);
 738           unlink (tmp_name);
 739           free(buf);
 740           goto END;
 741         }
 742       else
 743         {
 744           p->init_file_date = write_date;
 745
 746           /* Since the .xscreensaver file is used for IPC, let's try and make
 747              sure that the bits actually land on the disk right away. */
 748           sync ();
 749         }
 750     }
 751   else
 752     {
 753       char *buf = (char *) malloc(1024 + strlen(name));
 754       sprintf(buf, "%s: error closing \"%s\"", blurb(), name);
 755       perror(buf);
 756       free(buf);
 757       unlink (tmp_name);
 758       goto END;
 759     }
 760
 761  END:
 762   if (n2) free (n2);
 763 }
 764
 765 \f
 766 /* Parsing the resource database
 767  */
 768
 769
 770 /* Populate `saver_preferences' with the contents of the resource database.
 771    Note that this may be called multiple times -- it is re-run each time
 772    the ~/.xscreensaver file is reloaded.
 773
 774    This function can be very noisy, since it issues resource syntax errors
 775    and so on.
 776  */
 777 void
 778 load_init_file (saver_preferences *p)
 779 {
 780   static Bool first_time = True;
 781
 782   if (parse_init_file (p) != 0)         /* file might have gone away */
 783     if (!first_time) return;
 784
 785   first_time = False;
 786
 787   p->xsync_p        = get_boolean_resource ("synchronous", "Synchronous");
 788   p->verbose_p      = get_boolean_resource ("verbose", "Boolean");
 789   p->timestamp_p    = get_boolean_resource ("timestamp", "Boolean");
 790   p->lock_p         = get_boolean_resource ("lock", "Boolean");
 791   p->lock_vt_p      = get_boolean_resource ("lockVTs", "Boolean");
 792   p->fade_p         = get_boolean_resource ("fade", "Boolean");
 793   p->unfade_p       = get_boolean_resource ("unfade", "Boolean");
 794   p->fade_seconds   = 1000 * get_seconds_resource ("fadeSeconds", "Time");
 795   p->fade_ticks     = get_integer_resource ("fadeTicks", "Integer");
 796   p->install_cmap_p = get_boolean_resource ("installColormap", "Boolean");
 797   p->nice_inferior  = get_integer_resource ("nice", "Nice");
 798
 799   p->initial_delay   = 1000 * get_seconds_resource ("initialDelay", "Time");
 800   p->splash_duration = 1000 * get_seconds_resource ("splashDuration", "Time");
 801   p->timeout         = 1000 * get_minutes_resource ("timeout", "Time");
 802   p->lock_timeout    = 1000 * get_minutes_resource ("lockTimeout", "Time");
 803   p->cycle           = 1000 * get_minutes_resource ("cycle", "Time");
 804   p->passwd_timeout  = 1000 * get_seconds_resource ("passwdTimeout", "Time");
 805   p->pointer_timeout = 1000 * get_seconds_resource ("pointerPollTime", "Time");
 806   p->notice_events_timeout = 1000*get_seconds_resource("windowCreationTimeout",
 807                                                        "Time");
 808   p->shell = get_string_resource ("bourneShell", "BourneShell");
 809
 810   p->demo_command = get_string_resource("demoCommand", "URL");
 811   p->prefs_command = get_string_resource("prefsCommand", "URL");
 812   p->help_url = get_string_resource("helpURL", "URL");
 813   p->load_url_command = get_string_resource("loadURL", "LoadURL");
 814
 815   {
 816     char *s;
 817     if ((s = get_string_resource ("splash", "Boolean")))
 818       if (!get_boolean_resource("splash", "Boolean"))
 819         p->splash_duration = 0;
 820     if (s) free (s);
 821   }
 822
 823   p->use_xidle_extension = get_boolean_resource ("xidleExtension","Boolean");
 824   p->use_mit_saver_extension = get_boolean_resource ("mitSaverExtension",
 825                                                      "Boolean");
 826   p->use_sgi_saver_extension = get_boolean_resource ("sgiSaverExtension",
 827                                                      "Boolean");
 828   p->use_proc_interrupts = get_boolean_resource ("procInterrupts", "Boolean");
 829
 830   /* Throttle the various timeouts to reasonable values.
 831    */
 832   if (p->passwd_timeout <= 0) p->passwd_timeout = 30000;         /* 30 secs */
 833   if (p->timeout < 10000) p->timeout = 10000;                    /* 10 secs */
 834   if (p->cycle != 0 && p->cycle < 2000) p->cycle = 2000;         /*  2 secs */
 835   if (p->pointer_timeout <= 0) p->pointer_timeout = 5000;        /*  5 secs */
 836   if (p->notice_events_timeout <= 0)
 837     p->notice_events_timeout = 10000;                            /* 10 secs */
 838   if (p->fade_seconds <= 0 || p->fade_ticks <= 0)
 839     p->fade_p = False;
 840   if (! p->fade_p) p->unfade_p = False;
 841
 842   p->watchdog_timeout = p->cycle * 0.6;
 843   if (p->watchdog_timeout < 30000) p->watchdog_timeout = 30000;   /* 30 secs */
 844   if (p->watchdog_timeout > 3600000) p->watchdog_timeout = 3600000; /*  1 hr */
 845
 846   get_screenhacks (p);
 847
 848   if (p->debug_p)
 849     {
 850       p->xsync_p = True;
 851       p->verbose_p = True;
 852       p->timestamp_p = True;
 853       p->initial_delay = 0;
 854     }
 855 }
 856
 857 \f
 858 /* Parsing the programs resource.
 859  */
 860
 861 static char *
 862 reformat_hack (const char *hack)
 863 {
 864   int i;
 865   const char *in = hack;
 866   int indent = 15;
 867   char *h2 = (char *) malloc(strlen(in) + indent + 2);
 868   char *out = h2;
 869   Bool disabled_p = False;
 870
 871   while (isspace(*in)) in++;            /* skip whitespace */
 872
 873   if (*in == '-')                       /* Handle a leading "-". */
 874     {
 875       in++;
 876       hack = in;
 877       *out++ = '-';
 878       *out++ = ' ';
 879       disabled_p = True;
 880       while (isspace(*in)) in++;
 881     }
 882   else
 883     {
 884       *out++ = ' ';
 885       *out++ = ' ';
 886     }
 887
 888   while (*in && !isspace(*in) && *in != ':')
 889     *out++ = *in++;                     /* snarf first token */
 890   while (isspace(*in)) in++;            /* skip whitespace */
 891
 892   if (*in == ':')
 893     *out++ = *in++;                     /* copy colon */
 894   else
 895     {
 896       in = hack;
 897       out = h2 + 2;                     /* reset to beginning */
 898     }
 899
 900   *out = 0;
 901
 902   while (isspace(*in)) in++;            /* skip whitespace */
 903   for (i = strlen(h2); i < indent; i++) /* indent */
 904     *out++ = ' ';
 905
 906   /* copy the rest of the line. */
 907   while (*in)
 908     {
 909       /* shrink all whitespace to one space, for the benefit of the "demo"
 910          mode display.  We only do this when we can easily tell that the
 911          whitespace is not significant (no shell metachars).
 912        */
 913       switch (*in)
 914         {
 915         case '\'': case '"': case '`': case '\\':
 916           {
 917             /* Metachars are scary.  Copy the rest of the line unchanged. */
 918             while (*in)
 919               *out++ = *in++;
 920           }
 921           break;
 922         case ' ': case '\t':
 923           {
 924             while (*in == ' ' || *in == '\t')
 925               in++;
 926             *out++ = ' ';
 927           }
 928           break;
 929         default:
 930           *out++ = *in++;
 931           break;
 932         }
 933     }
 934   *out = 0;
 935
 936   /* strip trailing whitespace. */
 937   out = out-1;
 938   while (out > h2 && (*out == ' ' || *out == '\t' || *out == '\n'))
 939     *out-- = 0;
 940
 941   return h2;
 942 }
 943
 944
 945 static void
 946 get_screenhacks (saver_preferences *p)
 947 {
 948   int i = 0;
 949   int start = 0;
 950   int end = 0;
 951   int size;
 952   char *d;
 953
 954   d = get_string_resource ("monoPrograms", "MonoPrograms");
 955   if (d && !*d) { free(d); d = 0; }
 956   if (!d)
 957     d = get_string_resource ("colorPrograms", "ColorPrograms");
 958   if (d && !*d) { free(d); d = 0; }
 959
 960   if (d)
 961     {
 962       fprintf (stderr,
 963        "%s: the `monoPrograms' and `colorPrograms' resources are obsolete;\n\
 964         see the manual for details.\n", blurb());
 965       free(d);
 966     }
 967
 968   d = get_string_resource ("programs", "Programs");
 969
 970   if (p->screenhacks)
 971     {
 972       for (i = 0; i < p->screenhacks_count; i++)
 973         if (p->screenhacks[i])
 974           free (p->screenhacks[i]);
 975       free(p->screenhacks);
 976       p->screenhacks = 0;
 977     }
 978
 979   if (!d || !*d)
 980     {
 981       p->screenhacks_count = 0;
 982       p->screenhacks = 0;
 983       return;
 984     }
 985
 986   size = strlen (d);
 987
 988
 989   /* Count up the number of newlines (which will be equal to or larger than
 990      the number of hacks.)
 991    */
 992   i = 0;
 993   for (i = 0; d[i]; i++)
 994     if (d[i] == '\n')
 995       i++;
 996   i++;
 997
 998   p->screenhacks = (char **) calloc (sizeof (char *), i+1);
 999
1000   /* Iterate over the lines in `d' (the string with newlines)
1001      and make new strings to stuff into the `screenhacks' array.
1002    */
1003   p->screenhacks_count = 0;
1004   while (start < size)
1005     {
1006       /* skip forward over whitespace. */
1007       while (d[start] == ' ' || d[start] == '\t' || d[start] == '\n')
1008         start++;
1009
1010       /* skip forward to newline or end of string. */
1011       end = start;
1012       while (d[end] != 0 && d[end] != '\n')
1013         end++;
1014
1015       /* null terminate. */
1016       d[end] = 0;
1017
1018       p->screenhacks[p->screenhacks_count++] = reformat_hack (d + start);
1019       if (p->screenhacks_count >= i)
1020         abort();
1021
1022       start = end+1;
1023     }
1024
1025   if (p->screenhacks_count == 0)
1026     {
1027       free (p->screenhacks);
1028       p->screenhacks = 0;
1029     }
1030 }