From http://www.jwz.org/xscreensaver/xscreensaver-5.18.tar.gz
[xscreensaver] / driver / prefs.c
1 /* dotfile.c --- management of the ~/.xscreensaver file.
2  * xscreensaver, Copyright (c) 1998-2011 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 <time.h>
27 #include <sys/stat.h>
28 #include <sys/time.h>
29 #include <sys/param.h>   /* for PATH_MAX */
30
31 #include <X11/Xlib.h>
32 #include <X11/Xresource.h>
33
34 #ifndef VMS
35 # include <pwd.h>
36 #else /* VMS */
37 # include "vms-pwd.h"
38 #endif /* VMS */
39
40
41 /* This file doesn't need the Xt headers, so stub these types out... */
42 #undef XtPointer
43 #define XtAppContext void*
44 #define XtIntervalId void*
45 #define XtPointer    void*
46 #define Widget       void*
47
48
49 /* Just in case there's something pathological about stat.h... */
50 #ifndef  S_IRUSR
51 # define S_IRUSR 00400
52 #endif
53 #ifndef  S_IWUSR
54 # define S_IWUSR 00200
55 #endif
56 #ifndef  S_IXUSR
57 # define S_IXUSR 00100
58 #endif
59 #ifndef  S_IXGRP
60 # define S_IXGRP 00010
61 #endif
62 #ifndef  S_IXOTH
63 # define S_IXOTH 00001
64 #endif
65
66
67 #include "prefs.h"
68 #include "resources.h"
69
70 /* don't use realpath() on fedora system */
71 #ifdef _FORTIFY_SOURCE
72 #undef HAVE_REALPATH
73 #endif
74
75
76 extern char *progname;
77 extern char *progclass;
78 extern const char *blurb (void);
79
80
81
82 static void get_screenhacks (Display *, saver_preferences *);
83 static char *format_command (const char *cmd, Bool wrap_p);
84 static void merge_system_screenhacks (Display *, saver_preferences *,
85                                       screenhack **system_list, int count);
86 static void stop_the_insanity (saver_preferences *p);
87
88
89 static char *
90 chase_symlinks (const char *file)
91 {
92 # ifdef HAVE_REALPATH
93   if (file)
94     {
95 # ifndef PATH_MAX
96 #  ifdef MAXPATHLEN
97 #   define PATH_MAX MAXPATHLEN
98 #  else
99 #   define PATH_MAX 2048
100 #  endif
101 # endif
102       char buf[PATH_MAX];
103       if (realpath (file, buf))
104         return strdup (buf);
105
106 /*      sprintf (buf, "%.100s: realpath %.200s", blurb(), file);
107       perror(buf);*/
108     }
109 # endif /* HAVE_REALPATH */
110   return 0;
111 }
112
113
114 static Bool
115 i_am_a_nobody (uid_t uid)
116 {
117   struct passwd *p;
118
119   p = getpwnam ("nobody");
120   if (! p) p = getpwnam ("noaccess");
121   if (! p) p = getpwnam ("daemon");
122
123   if (! p) /* There is no nobody? */
124     return False;
125
126   return (uid == p->pw_uid);
127 }
128
129
130 const char *
131 init_file_name (void)
132 {
133   static char *file = 0;
134
135   if (!file)
136     {
137       uid_t uid = getuid ();
138       struct passwd *p = getpwuid (uid);
139
140       if (i_am_a_nobody (uid))
141         /* If we're running as nobody, then use root's .xscreensaver file
142            (since ~root/.xscreensaver and ~nobody/.xscreensaver are likely
143            to be different -- if we didn't do this, then xscreensaver-demo
144            would appear to have no effect when the luser is running as root.)
145          */
146         uid = 0;
147
148       p = getpwuid (uid);
149
150       if (!p || !p->pw_name || !*p->pw_name)
151         {
152           fprintf (stderr, "%s: couldn't get user info of uid %d\n",
153                    blurb(), getuid ());
154           file = "";
155         }
156       else if (!p->pw_dir || !*p->pw_dir)
157         {
158           fprintf (stderr, "%s: couldn't get home directory of \"%s\"\n",
159                    blurb(), (p->pw_name ? p->pw_name : "???"));
160           file = "";
161         }
162       else
163         {
164           const char *home = p->pw_dir;
165           const char *name = ".xscreensaver";
166           file = (char *) malloc(strlen(home) + strlen(name) + 2);
167           strcpy(file, home);
168           if (!*home || home[strlen(home)-1] != '/')
169             strcat(file, "/");
170           strcat(file, name);
171         }
172     }
173
174   if (file && *file)
175     return file;
176   else
177     return 0;
178 }
179
180
181 static const char *
182 init_file_tmp_name (void)
183 {
184   static char *file = 0;
185   if (!file)
186     {
187       const char *name = init_file_name();
188       const char *suffix = ".tmp";
189
190       char *n2 = chase_symlinks (name);
191       if (n2) name = n2;
192
193       if (!name || !*name)
194         file = "";
195       else
196         {
197           file = (char *) malloc(strlen(name) + strlen(suffix) + 2);
198           strcpy(file, name);
199           strcat(file, suffix);
200         }
201
202       if (n2) free (n2);
203     }
204
205   if (file && *file)
206     return file;
207   else
208     return 0;
209 }
210
211 static int
212 get_byte_resource (Display *dpy, char *name, char *class)
213 {
214   char *s = get_string_resource (dpy, name, class);
215   char *s2 = s;
216   int n = 0;
217   if (!s) return 0;
218
219   while (isspace(*s2)) s2++;
220   while (*s2 >= '0' && *s2 <= '9')
221     {
222       n = (n * 10) + (*s2 - '0');
223       s2++;
224     }
225   while (isspace(*s2)) s2++;
226   if      (*s2 == 'k' || *s2 == 'K') n <<= 10;
227   else if (*s2 == 'm' || *s2 == 'M') n <<= 20;
228   else if (*s2 == 'g' || *s2 == 'G') n <<= 30;
229   else if (*s2)
230     {
231     LOSE:
232       fprintf (stderr, "%s: %s must be a number of bytes, not \"%s\".\n",
233                progname, name, s);
234       free (s);
235       return 0;
236     }
237   s2++;
238   if (*s2 == 'b' || *s2 == 'B') s2++;
239   while (isspace(*s2)) s2++;
240   if (*s2) goto LOSE;
241
242   free (s);
243   return n;
244 }
245
246
247 static const char * const prefs[] = {
248   "timeout",
249   "cycle",
250   "lock",
251   "lockVTs",                    /* not saved */
252   "lockTimeout",
253   "passwdTimeout",
254   "visualID",
255   "installColormap",
256   "verbose",
257   "timestamp",
258   "splash",
259   "splashDuration",
260   "quad",
261   "demoCommand",
262   "prefsCommand",
263   "newLoginCommand",
264   "helpURL",                    /* not saved */
265   "loadURL",                    /* not saved */
266   "newLoginCommand",            /* not saved */
267   "nice",
268   "memoryLimit",
269   "fade",
270   "unfade",
271   "fadeSeconds",
272   "fadeTicks",
273   "captureStderr",
274   "captureStdout",              /* not saved -- obsolete */
275   "logFile",                    /* not saved */
276   "ignoreUninstalledPrograms",
277   "font",
278   "dpmsEnabled",
279   "dpmsQuickOff",
280   "dpmsStandby",
281   "dpmsSuspend",
282   "dpmsOff",
283   "grabDesktopImages",
284   "grabVideoFrames",
285   "chooseRandomImages",
286   "imageDirectory",
287   "mode",
288   "selected",
289   "textMode",
290   "textLiteral",
291   "textFile",
292   "textProgram",
293   "textURL",
294   "",
295   "programs",
296   "",
297   "pointerPollTime",
298   "pointerHysteresis",
299   "windowCreationTimeout",
300   "initialDelay",
301   "sgiSaverExtension",          /* not saved -- obsolete */
302   "mitSaverExtension",          /* not saved -- obsolete */
303   "xidleExtension",             /* not saved -- obsolete */
304   "GetViewPortIsFullOfLies",
305   "procInterrupts",
306   "xinputExtensionDev",
307   "overlayStderr",
308   "overlayTextBackground",      /* not saved -- X resources only */
309   "overlayTextForeground",      /* not saved -- X resources only */
310   "bourneShell",                /* not saved -- X resources only */
311   0
312 };
313
314 static char *
315 strip (char *s)
316 {
317   char *s2;
318   while (*s == '\t' || *s == ' ' || *s == '\r' || *s == '\n')
319     s++;
320   for (s2 = s; *s2; s2++)
321     ;
322   for (s2--; s2 >= s; s2--) 
323     if (*s2 == '\t' || *s2 == ' ' || *s2 == '\r' || *s2 =='\n') 
324       *s2 = 0;
325     else
326       break;
327   return s;
328 }
329
330 \f
331 /* Reading
332  */
333
334 static int
335 handle_entry (XrmDatabase *db, const char *key, const char *value,
336               const char *filename, int line)
337 {
338   int i;
339   for (i = 0; prefs[i]; i++)
340     if (*prefs[i] && !strcasecmp(key, prefs[i]))
341       {
342         char *val = strdup(value);
343         char *spec = (char *) malloc(strlen(progclass) + strlen(prefs[i]) +10);
344         strcpy(spec, progclass);
345         strcat(spec, ".");
346         strcat(spec, prefs[i]);
347
348         XrmPutStringResource (db, spec, val);
349
350         free(spec);
351         free(val);
352         return 0;
353       }
354
355   fprintf(stderr, "%s: %s:%d: unknown option \"%s\"\n",
356           blurb(), filename, line, key);
357   return 1;
358 }
359
360
361 static int
362 parse_init_file (saver_preferences *p)
363 {
364   time_t write_date = 0;
365   const char *name = init_file_name();
366   int line = 0;
367   struct stat st;
368   FILE *in;
369   int buf_size = 1024;
370   char *buf;
371
372   if (!name) return 0;
373
374   if (stat(name, &st) != 0)
375     {
376       p->init_file_date = 0;
377       return 0;
378     }
379
380   in = fopen(name, "r");
381   if (!in)
382     {
383       char *buf = (char *) malloc(1024 + strlen(name));
384       sprintf(buf, "%s: error reading \"%s\"", blurb(), name);
385       perror(buf);
386       free(buf);
387       return -1;
388     }
389
390   if (fstat (fileno(in), &st) == 0)
391     {
392       write_date = st.st_mtime;
393     }
394   else
395     {
396       char *buf = (char *) malloc(1024 + strlen(name));
397       sprintf(buf, "%s: couldn't re-stat \"%s\"", blurb(), name);
398       perror(buf);
399       free(buf);
400       return -1;
401     }
402
403   buf = (char *) malloc(buf_size);
404
405   while (fgets (buf, buf_size-1, in))
406     {
407       char *key, *value;
408       int L = strlen(buf);
409
410       line++;
411       while (L > 2 &&
412              (buf[L-1] != '\n' ||       /* whole line didn't fit in buffer */
413               buf[L-2] == '\\'))        /* or line ended with backslash */
414         {
415           if (buf[L-2] == '\\')         /* backslash-newline gets swallowed */
416             {
417               buf[L-2] = 0;
418               L -= 2;
419             }
420           buf_size += 1024;
421           buf = (char *) realloc(buf, buf_size);
422           if (!buf) exit(1);
423
424           line++;
425           if (!fgets (buf + L, buf_size-L-1, in))
426             break;
427           L = strlen(buf);
428         }
429
430       /* Now handle other backslash escapes. */
431       {
432         int i, j;
433         for (i = 0; buf[i]; i++)
434           if (buf[i] == '\\')
435             {
436               switch (buf[i+1])
437                 {
438                 case 'n': buf[i] = '\n'; break;
439                 case 'r': buf[i] = '\r'; break;
440                 case 't': buf[i] = '\t'; break;
441                 default:  buf[i] = buf[i+1]; break;
442                 }
443               for (j = i+2; buf[j]; j++)
444                 buf[j-1] = buf[j];
445               buf[j-1] = 0;
446             }
447       }
448
449       key = strip(buf);
450
451       if (*key == '#' || *key == '!' || *key == ';' ||
452           *key == '\n' || *key == 0)
453         continue;
454
455       value = strchr (key, ':');
456       if (!value)
457         {
458           fprintf(stderr, "%s: %s:%d: unparsable line: %s\n", blurb(),
459                   name, line, key);
460           continue;
461         }
462       else
463         {
464           *value++ = 0;
465           value = strip(value);
466         }
467
468       if (!p->db) abort();
469       handle_entry (&p->db, key, value, name, line);
470     }
471   fclose (in);
472   free(buf);
473
474   p->init_file_date = write_date;
475   return 0;
476 }
477
478
479 Bool
480 init_file_changed_p (saver_preferences *p)
481 {
482   const char *name = init_file_name();
483   struct stat st;
484
485   if (!name) return False;
486
487   if (stat(name, &st) != 0)
488     return False;
489
490   if (p->init_file_date == st.st_mtime)
491     return False;
492
493   return True;
494 }
495
496 \f
497 /* Writing
498  */
499
500 static int
501 tab_to (FILE *out, int from, int to)
502 {
503   int tab_width = 8;
504   int to_mod = (to / tab_width) * tab_width;
505   while (from < to_mod)
506     {
507       fprintf(out, "\t");
508       from = (((from / tab_width) + 1) * tab_width);
509     }
510   while (from < to)
511     {
512       fprintf(out, " ");
513       from++;
514     }
515   return from;
516 }
517
518 static char *
519 stab_to (char *out, int from, int to)
520 {
521   int tab_width = 8;
522   int to_mod = (to / tab_width) * tab_width;
523   while (from < to_mod)
524     {
525       *out++ = '\t';
526       from = (((from / tab_width) + 1) * tab_width);
527     }
528   while (from < to)
529     {
530       *out++ = ' ';
531       from++;
532     }
533   return out;
534 }
535
536 static int
537 string_columns (const char *string, int length, int start)
538 {
539   int tab_width = 8;
540   int col = start;
541   const char *end = string + length;
542   while (string < end)
543     {
544       if (*string == '\n')
545         col = 0;
546       else if (*string == '\t')
547         col = (((col / tab_width) + 1) * tab_width);
548       else
549         col++;
550       string++;
551     }
552   return col;
553 }
554
555
556 static void
557 write_entry (FILE *out, const char *key, const char *value)
558 {
559   char *v = strdup(value ? value : "");
560   char *v2 = v;
561   char *nl = 0;
562   int col;
563   Bool programs_p = (!strcmp(key, "programs"));
564   int tab = (programs_p ? 32 : 16);
565   Bool first = True;
566
567   fprintf(out, "%s:", key);
568   col = strlen(key) + 1;
569
570   if (strlen(key) > 14)
571     col = tab_to (out, col, 20);
572
573   while (1)
574     {
575       if (!programs_p)
576         v2 = strip(v2);
577       nl = strchr(v2, '\n');
578       if (nl)
579         *nl = 0;
580
581       if (first && programs_p)
582         {
583           col = tab_to (out, col, 77);
584           fprintf (out, " \\\n");
585           col = 0;
586         }
587
588       if (first)
589         first = False;
590       else
591         {
592           col = tab_to (out, col, 75);
593           fprintf (out, " \\n\\\n");
594           col = 0;
595         }
596
597       if (!programs_p)
598         col = tab_to (out, col, tab);
599
600       if (programs_p &&
601           string_columns(v2, strlen (v2), col) + col > 75)
602         {
603           int L = strlen (v2);
604           int start = 0;
605           int end = start;
606           while (start < L)
607             {
608               while (v2[end] == ' ' || v2[end] == '\t')
609                 end++;
610               while (v2[end] != ' ' && v2[end] != '\t' &&
611                      v2[end] != '\n' && v2[end] != 0)
612                 end++;
613               if (string_columns (v2 + start, (end - start), col) >= 74)
614                 {
615                   col = tab_to (out, col, 75);
616                   fprintf(out, "   \\\n");
617                   col = tab_to (out, 0, tab + 2);
618                   while (v2[start] == ' ' || v2[start] == '\t')
619                     start++;
620                 }
621
622               col = string_columns (v2 + start, (end - start), col);
623               while (start < end)
624                 fputc(v2[start++], out);
625             }
626         }
627       else
628         {
629           fprintf (out, "%s", v2);
630           col += string_columns(v2, strlen (v2), col);
631         }
632
633       if (nl)
634         v2 = nl + 1;
635       else
636         break;
637     }
638
639   fprintf(out, "\n");
640   free(v);
641 }
642
643 int
644 write_init_file (Display *dpy,
645                  saver_preferences *p, const char *version_string,
646                  Bool verbose_p)
647 {
648   int status = -1;
649   const char *name = init_file_name();
650   const char *tmp_name = init_file_tmp_name();
651   char *n2 = chase_symlinks (name);
652   struct stat st;
653   int i, j;
654
655   /* Kludge, since these aren't in the saver_preferences struct as strings...
656    */
657   char *visual_name;
658   char *programs;
659   Bool overlay_stderr_p;
660   char *stderr_font;
661   FILE *out;
662
663   if (!name) goto END;
664
665   if (n2) name = n2;
666
667   /* Throttle the various timeouts to reasonable values before writing
668      the file to disk. */
669   stop_the_insanity (p);
670
671
672   if (verbose_p)
673     fprintf (stderr, "%s: writing \"%s\".\n", blurb(), name);
674
675   unlink (tmp_name);
676   out = fopen(tmp_name, "w");
677   if (!out)
678     {
679       char *buf = (char *) malloc(1024 + strlen(name));
680       sprintf(buf, "%s: error writing \"%s\"", blurb(), name);
681       perror(buf);
682       free(buf);
683       goto END;
684     }
685
686   /* Give the new .xscreensaver file the same permissions as the old one;
687      except ensure that it is readable and writable by owner, and not
688      executable.  Extra hack: if we're running as root, make the file
689      be world-readable (so that the daemon, running as "nobody", will
690      still be able to read it.)
691    */
692   if (stat(name, &st) == 0)
693     {
694       mode_t mode = st.st_mode;
695       mode |= S_IRUSR | S_IWUSR;                /* read/write by user */
696       mode &= ~(S_IXUSR | S_IXGRP | S_IXOTH);   /* executable by none */
697
698       if (getuid() == (uid_t) 0)                /* read by group/other */
699         mode |= S_IRGRP | S_IROTH;
700
701       if (fchmod (fileno(out), mode) != 0)
702         {
703           char *buf = (char *) malloc(1024 + strlen(name));
704           sprintf (buf, "%s: error fchmodding \"%s\" to 0%o", blurb(),
705                    tmp_name, (unsigned int) mode);
706           perror(buf);
707           free(buf);
708           goto END;
709         }
710     }
711
712   /* Kludge, since these aren't in the saver_preferences struct... */
713   visual_name = get_string_resource (dpy, "visualID", "VisualID");
714   programs = 0;
715   overlay_stderr_p = get_boolean_resource (dpy, "overlayStderr", "Boolean");
716   stderr_font = get_string_resource (dpy, "font", "Font");
717
718   i = 0;
719   {
720     char *ss;
721     char **hack_strings = (char **)
722       calloc (p->screenhacks_count, sizeof(char *));
723
724     for (j = 0; j < p->screenhacks_count; j++)
725       {
726         hack_strings[j] = format_hack (dpy, p->screenhacks[j], True);
727         i += strlen (hack_strings[j]);
728         i += 2;
729       }
730
731     ss = programs = (char *) malloc(i + 10);
732     *ss = 0;
733     for (j = 0; j < p->screenhacks_count; j++)
734       {
735         strcat (ss, hack_strings[j]);
736         free (hack_strings[j]);
737         ss += strlen(ss);
738         *ss++ = '\n';
739         *ss = 0;
740       }
741     free (hack_strings);
742   }
743
744   {
745     struct passwd *pw = getpwuid (getuid ());
746     char *whoami = (pw && pw->pw_name && *pw->pw_name
747                     ? pw->pw_name
748                     : "<unknown>");
749     time_t now = time ((time_t *) 0);
750     char *timestr = (char *) ctime (&now);
751     char *nl = (char *) strchr (timestr, '\n');
752     if (nl) *nl = 0;
753     fprintf (out,
754              "# %s Preferences File\n"
755              "# Written by %s %s for %s on %s.\n"
756              "# http://www.jwz.org/xscreensaver/\n"
757              "\n",
758              progclass, progname, version_string, whoami, timestr);
759   }
760
761   for (j = 0; prefs[j]; j++)
762     {
763       char buf[255];
764       const char *pr = prefs[j];
765       enum pref_type { pref_str, pref_int, pref_bool, pref_byte, pref_time
766       } type = pref_str;
767       const char *s = 0;
768       int i = 0;
769       Bool b = False;
770       Time t = 0;
771
772       if (pr && !*pr)
773         {
774           fprintf(out, "\n");
775           continue;
776         }
777
778 # undef CHECK
779 # define CHECK(X) else if (!strcmp(pr, X))
780       if (!pr || !*pr)          ;
781       CHECK("timeout")          type = pref_time, t = p->timeout;
782       CHECK("cycle")            type = pref_time, t = p->cycle;
783       CHECK("lock")             type = pref_bool, b = p->lock_p;
784       CHECK("lockVTs")          continue;  /* don't save, unused */
785       CHECK("lockTimeout")      type = pref_time, t = p->lock_timeout;
786       CHECK("passwdTimeout")    type = pref_time, t = p->passwd_timeout;
787       CHECK("visualID")         type = pref_str,  s =    visual_name;
788       CHECK("installColormap")  type = pref_bool, b = p->install_cmap_p;
789       CHECK("verbose")          type = pref_bool, b = p->verbose_p;
790       CHECK("timestamp")        type = pref_bool, b = p->timestamp_p;
791       CHECK("splash")           type = pref_bool, b = p->splash_p;
792       CHECK("splashDuration")   type = pref_time, t = p->splash_duration;
793 # ifdef QUAD_MODE
794       CHECK("quad")             type = pref_bool, b = p->quad_p;
795 # else  /* !QUAD_MODE */
796       CHECK("quad")             continue;  /* don't save */
797 # endif /* !QUAD_MODE */
798       CHECK("demoCommand")      type = pref_str,  s = p->demo_command;
799       CHECK("prefsCommand")     type = pref_str,  s = p->prefs_command;
800 /*    CHECK("helpURL")          type = pref_str,  s = p->help_url; */
801       CHECK("helpURL")          continue;  /* don't save */
802 /*    CHECK("loadURL")          type = pref_str,  s = p->load_url_command; */
803       CHECK("loadURL")          continue;  /* don't save */
804 /*    CHECK("newLoginCommand")  type = pref_str,  s = p->new_login_command; */
805       CHECK("newLoginCommand")  continue;  /* don't save */
806       CHECK("nice")             type = pref_int,  i = p->nice_inferior;
807       CHECK("memoryLimit")      type = pref_byte, i = p->inferior_memory_limit;
808       CHECK("fade")             type = pref_bool, b = p->fade_p;
809       CHECK("unfade")           type = pref_bool, b = p->unfade_p;
810       CHECK("fadeSeconds")      type = pref_time, t = p->fade_seconds;
811       CHECK("fadeTicks")        type = pref_int,  i = p->fade_ticks;
812       CHECK("captureStderr")    type = pref_bool, b = p->capture_stderr_p;
813       CHECK("captureStdout")    continue;  /* don't save */
814       CHECK("logFile")          continue;  /* don't save */
815       CHECK("ignoreUninstalledPrograms")
816                                 type = pref_bool, b = p->ignore_uninstalled_p;
817
818       CHECK("font")             type = pref_str,  s =    stderr_font;
819
820       CHECK("dpmsEnabled")      type = pref_bool, b = p->dpms_enabled_p;
821       CHECK("dpmsQuickOff")     type = pref_bool, b = p->dpms_quickoff_p;
822       CHECK("dpmsStandby")      type = pref_time, t = p->dpms_standby;
823       CHECK("dpmsSuspend")      type = pref_time, t = p->dpms_suspend;
824       CHECK("dpmsOff")          type = pref_time, t = p->dpms_off;
825
826       CHECK("grabDesktopImages") type =pref_bool, b = p->grab_desktop_p;
827       CHECK("grabVideoFrames")   type =pref_bool, b = p->grab_video_p;
828       CHECK("chooseRandomImages")type =pref_bool, b = p->random_image_p;
829       CHECK("imageDirectory")    type =pref_str,  s = p->image_directory;
830
831       CHECK("mode")             type = pref_str,
832                                 s = (p->mode == ONE_HACK ? "one" :
833                                      p->mode == BLANK_ONLY ? "blank" :
834                                      p->mode == DONT_BLANK ? "off" :
835                                      p->mode == RANDOM_HACKS_SAME
836                                      ? "random-same"
837                                      : "random");
838       CHECK("selected")         type = pref_int,  i = p->selected_hack;
839
840       CHECK("textMode")         type = pref_str,
841                                 s = (p->tmode == TEXT_URL     ? "url" :
842                                      p->tmode == TEXT_LITERAL ? "literal" :
843                                      p->tmode == TEXT_FILE    ? "file" :
844                                      p->tmode == TEXT_PROGRAM ? "program" :
845                                      "date");
846       CHECK("textLiteral")      type = pref_str,  s = p->text_literal;
847       CHECK("textFile")         type = pref_str,  s = p->text_file;
848       CHECK("textProgram")      type = pref_str,  s = p->text_program;
849       CHECK("textURL")          type = pref_str,  s = p->text_url;
850
851       CHECK("programs")         type = pref_str,  s =    programs;
852       CHECK("pointerPollTime")  type = pref_time, t = p->pointer_timeout;
853       CHECK("pointerHysteresis")type = pref_int,  i = p->pointer_hysteresis;
854       CHECK("windowCreationTimeout")type=pref_time,t= p->notice_events_timeout;
855       CHECK("initialDelay")     type = pref_time, t = p->initial_delay;
856       CHECK("sgiSaverExtension") continue;  /* don't save */
857       CHECK("mitSaverExtension") continue;  /* don't save */
858       CHECK("xidleExtension")    continue;  /* don't save */
859       CHECK("procInterrupts")   type = pref_bool, b = p->use_proc_interrupts;
860       CHECK("xinputExtensionDev") type = pref_bool, b = p->use_xinput_extension;
861       CHECK("GetViewPortIsFullOfLies")  type = pref_bool,
862                                         b = p->getviewport_full_of_lies_p;
863       CHECK("overlayStderr")    type = pref_bool, b = overlay_stderr_p;
864       CHECK("overlayTextBackground") continue;  /* don't save */
865       CHECK("overlayTextForeground") continue;  /* don't save */
866       CHECK("bourneShell")           continue;  /* don't save */
867       else                      abort();
868 # undef CHECK
869
870       switch (type)
871         {
872         case pref_str:
873           break;
874         case pref_int:
875           sprintf(buf, "%d", i);
876           s = buf;
877           break;
878         case pref_bool:
879           s = b ? "True" : "False";
880           break;
881         case pref_time:
882           {
883             unsigned int hour = 0, min = 0, sec = (unsigned int) (t/1000);
884             if (sec >= 60)
885               {
886                 min += (sec / 60);
887                 sec %= 60;
888               }
889             if (min >= 60)
890               {
891                 hour += (min / 60);
892                 min %= 60;
893               }
894             sprintf (buf, "%u:%02u:%02u", hour, min, sec);
895             s = buf;
896           }
897           break;
898         case pref_byte:
899           {
900             if      (i >= (1<<30) && i == ((i >> 30) << 30))
901               sprintf(buf, "%dG", i >> 30);
902             else if (i >= (1<<20) && i == ((i >> 20) << 20))
903               sprintf(buf, "%dM", i >> 20);
904             else if (i >= (1<<10) && i == ((i >> 10) << 10))
905               sprintf(buf, "%dK", i >> 10);
906             else
907               sprintf(buf, "%d", i);
908             s = buf;
909           }
910           break;
911         default:
912           abort();
913           break;
914         }
915
916       if (pr && (!strcmp(pr, "mode") || !strcmp(pr, "textMode")))
917         fprintf(out, "\n");
918
919       write_entry (out, pr, s);
920     }
921
922   fprintf(out, "\n");
923
924   if (visual_name) free(visual_name);
925   if (stderr_font) free(stderr_font);
926   if (programs) free(programs);
927
928   if (fclose(out) == 0)
929     {
930       time_t write_date = 0;
931
932       if (stat(tmp_name, &st) == 0)
933         {
934           write_date = st.st_mtime;
935         }
936       else
937         {
938           char *buf = (char *) malloc(1024 + strlen(tmp_name) + strlen(name));
939           sprintf(buf, "%s: couldn't stat \"%s\"", blurb(), tmp_name);
940           perror(buf);
941           unlink (tmp_name);
942           free(buf);
943           goto END;
944         }
945
946       if (rename (tmp_name, name) != 0)
947         {
948           char *buf = (char *) malloc(1024 + strlen(tmp_name) + strlen(name));
949           sprintf(buf, "%s: error renaming \"%s\" to \"%s\"",
950                   blurb(), tmp_name, name);
951           perror(buf);
952           unlink (tmp_name);
953           free(buf);
954           goto END;
955         }
956       else
957         {
958           p->init_file_date = write_date;
959
960           /* Since the .xscreensaver file is used for IPC, let's try and make
961              sure that the bits actually land on the disk right away. */
962           sync ();
963
964           status = 0;    /* wrote and renamed successfully! */
965         }
966     }
967   else
968     {
969       char *buf = (char *) malloc(1024 + strlen(name));
970       sprintf(buf, "%s: error closing \"%s\"", blurb(), name);
971       perror(buf);
972       free(buf);
973       unlink (tmp_name);
974       goto END;
975     }
976
977  END:
978   if (n2) free (n2);
979   return status;
980 }
981
982 \f
983 /* Parsing the resource database
984  */
985
986 void
987 free_screenhack (screenhack *hack)
988 {
989   if (hack->visual) free (hack->visual);
990   if (hack->name) free (hack->name);
991   free (hack->command);
992   memset (hack, 0, sizeof(*hack));
993   free (hack);
994 }
995
996 static void
997 free_screenhack_list (screenhack **list, int count)
998 {
999   int i;
1000   if (!list) return;
1001   for (i = 0; i < count; i++)
1002     if (list[i])
1003       free_screenhack (list[i]);
1004   free (list);
1005 }
1006
1007
1008
1009 /* Populate `saver_preferences' with the contents of the resource database.
1010    Note that this may be called multiple times -- it is re-run each time
1011    the ~/.xscreensaver file is reloaded.
1012
1013    This function can be very noisy, since it issues resource syntax errors
1014    and so on.
1015  */
1016 void
1017 load_init_file (Display *dpy, saver_preferences *p)
1018 {
1019   static Bool first_time = True;
1020   
1021   screenhack **system_default_screenhacks = 0;
1022   int system_default_screenhack_count = 0;
1023
1024   if (first_time)
1025     {
1026       /* Get the programs resource before the .xscreensaver file has been
1027          parsed and merged into the resource database for the first time:
1028          this is the value of *programs from the app-defaults file.
1029          Then clear it out so that it will be parsed again later, after
1030          the init file has been read.
1031        */
1032       get_screenhacks (dpy, p);
1033       system_default_screenhacks = p->screenhacks;
1034       system_default_screenhack_count = p->screenhacks_count;
1035       p->screenhacks = 0;
1036       p->screenhacks_count = 0;
1037     }
1038
1039   if (parse_init_file (p) != 0)         /* file might have gone away */
1040     if (!first_time) return;
1041
1042   first_time = False;
1043
1044   p->xsync_p        = get_boolean_resource (dpy, "synchronous", "Synchronous");
1045   p->verbose_p      = get_boolean_resource (dpy, "verbose", "Boolean");
1046   p->timestamp_p    = get_boolean_resource (dpy, "timestamp", "Boolean");
1047   p->lock_p         = get_boolean_resource (dpy, "lock", "Boolean");
1048   p->fade_p         = get_boolean_resource (dpy, "fade", "Boolean");
1049   p->unfade_p       = get_boolean_resource (dpy, "unfade", "Boolean");
1050   p->fade_seconds   = 1000 * get_seconds_resource (dpy, "fadeSeconds", "Time");
1051   p->fade_ticks     = get_integer_resource (dpy, "fadeTicks", "Integer");
1052   p->install_cmap_p = get_boolean_resource (dpy, "installColormap", "Boolean");
1053   p->nice_inferior  = get_integer_resource (dpy, "nice", "Nice");
1054   p->inferior_memory_limit = get_byte_resource (dpy, "memoryLimit",
1055                                                 "MemoryLimit");
1056   p->splash_p       = get_boolean_resource (dpy, "splash", "Boolean");
1057 # ifdef QUAD_MODE
1058   p->quad_p         = get_boolean_resource (dpy, "quad", "Boolean");
1059 # endif
1060   p->capture_stderr_p = get_boolean_resource (dpy, "captureStderr", "Boolean");
1061   p->ignore_uninstalled_p = get_boolean_resource (dpy, 
1062                                                   "ignoreUninstalledPrograms",
1063                                                   "Boolean");
1064
1065   p->initial_delay   = 1000 * get_seconds_resource (dpy, "initialDelay", "Time");
1066   p->splash_duration = 1000 * get_seconds_resource (dpy, "splashDuration", "Time");
1067   p->timeout         = 1000 * get_minutes_resource (dpy, "timeout", "Time");
1068   p->lock_timeout    = 1000 * get_minutes_resource (dpy, "lockTimeout", "Time");
1069   p->cycle           = 1000 * get_minutes_resource (dpy, "cycle", "Time");
1070   p->passwd_timeout  = 1000 * get_seconds_resource (dpy, "passwdTimeout", "Time");
1071   p->pointer_timeout = 1000 * get_seconds_resource (dpy, "pointerPollTime", "Time");
1072   p->pointer_hysteresis = get_integer_resource (dpy, "pointerHysteresis","Integer");
1073   p->notice_events_timeout = 1000*get_seconds_resource(dpy,
1074                                                        "windowCreationTimeout",
1075                                                        "Time");
1076
1077   p->dpms_enabled_p  = get_boolean_resource (dpy, "dpmsEnabled", "Boolean");
1078   p->dpms_quickoff_p = get_boolean_resource (dpy, "dpmsQuickOff", "Boolean");
1079   p->dpms_standby    = 1000 * get_minutes_resource (dpy, "dpmsStandby", "Time");
1080   p->dpms_suspend    = 1000 * get_minutes_resource (dpy, "dpmsSuspend", "Time");
1081   p->dpms_off        = 1000 * get_minutes_resource (dpy, "dpmsOff",     "Time");
1082
1083   p->grab_desktop_p  = get_boolean_resource (dpy, "grabDesktopImages",  "Boolean");
1084   p->grab_video_p    = get_boolean_resource (dpy, "grabVideoFrames",    "Boolean");
1085   p->random_image_p  = get_boolean_resource (dpy, "chooseRandomImages", "Boolean");
1086   p->image_directory = get_string_resource  (dpy,
1087                                              "imageDirectory",
1088                                              "ImageDirectory");
1089
1090   p->text_literal = get_string_resource (dpy, "textLiteral", "TextLiteral");
1091   p->text_file    = get_string_resource (dpy, "textFile",    "TextFile");
1092   p->text_program = get_string_resource (dpy, "textProgram", "TextProgram");
1093   p->text_url     = get_string_resource (dpy, "textURL",     "TextURL");
1094
1095   p->shell = get_string_resource (dpy, "bourneShell", "BourneShell");
1096
1097   p->demo_command = get_string_resource(dpy, "demoCommand", "URL");
1098   p->prefs_command = get_string_resource(dpy, "prefsCommand", "URL");
1099   p->help_url = get_string_resource(dpy, "helpURL", "URL");
1100   p->load_url_command = get_string_resource(dpy, "loadURL", "LoadURL");
1101   p->new_login_command = get_string_resource(dpy,
1102                                              "newLoginCommand",
1103                                              "NewLoginCommand");
1104
1105   /* If "*splash" is unset, default to true. */
1106   {
1107     char *s = get_string_resource (dpy, "splash", "Boolean");
1108     if (s)
1109       free (s);
1110     else
1111       p->splash_p = True;
1112   }
1113
1114   /* If "*grabDesktopImages" is unset, default to true. */
1115   {
1116     char *s = get_string_resource (dpy, "grabDesktopImages", "Boolean");
1117     if (s)
1118       free (s);
1119     else
1120       p->grab_desktop_p = True;
1121   }
1122
1123   p->use_xidle_extension = get_boolean_resource (dpy, "xidleExtension","Boolean");
1124 #if 0 /* obsolete. */
1125   p->use_sgi_saver_extension = get_boolean_resource (dpy,
1126                                                      "sgiSaverExtension",
1127                                                      "Boolean");
1128 #endif
1129 #ifdef HAVE_XINPUT
1130   p->use_xinput_extension = get_boolean_resource (dpy, "xinputExtensionDev",
1131                                                   "Boolean");
1132 #endif
1133 #if 0 /* broken and evil. */
1134   p->use_mit_saver_extension = get_boolean_resource (dpy, 
1135                                                      "mitSaverExtension",
1136                                                      "Boolean");
1137 #endif
1138
1139   p->use_proc_interrupts = get_boolean_resource (dpy,
1140                                                  "procInterrupts", "Boolean");
1141
1142   p->getviewport_full_of_lies_p =
1143     get_boolean_resource (dpy, "GetViewPortIsFullOfLies", "Boolean");
1144
1145   get_screenhacks (dpy, p);             /* Parse the "programs" resource. */
1146
1147   {
1148     char *s = get_string_resource (dpy, "selected", "Integer");
1149     if (!s || !*s)
1150       p->selected_hack = -1;
1151     else
1152       p->selected_hack = get_integer_resource (dpy, "selected", "Integer");
1153     if (s) free (s);
1154     if (p->selected_hack < 0 || p->selected_hack >= p->screenhacks_count)
1155       p->selected_hack = -1;
1156   }
1157
1158   {
1159     char *s = get_string_resource (dpy, "mode", "Mode");
1160     if      (s && !strcasecmp (s, "one"))         p->mode = ONE_HACK;
1161     else if (s && !strcasecmp (s, "blank"))       p->mode = BLANK_ONLY;
1162     else if (s && !strcasecmp (s, "off"))         p->mode = DONT_BLANK;
1163     else if (s && !strcasecmp (s, "random-same")) p->mode = RANDOM_HACKS_SAME;
1164     else                                          p->mode = RANDOM_HACKS;
1165     if (s) free (s);
1166   }
1167
1168   {
1169     char *s = get_string_resource (dpy, "textMode", "TextMode");
1170     if      (s && !strcasecmp (s, "url"))         p->tmode = TEXT_URL;
1171     else if (s && !strcasecmp (s, "literal"))     p->tmode = TEXT_LITERAL;
1172     else if (s && !strcasecmp (s, "file"))        p->tmode = TEXT_FILE;
1173     else if (s && !strcasecmp (s, "program"))     p->tmode = TEXT_PROGRAM;
1174     else                                          p->tmode = TEXT_DATE;
1175     if (s) free (s);
1176   }
1177
1178   if (system_default_screenhack_count)  /* note: first_time is also true */
1179     {
1180       merge_system_screenhacks (dpy, p, system_default_screenhacks,
1181                                 system_default_screenhack_count);
1182       free_screenhack_list (system_default_screenhacks,
1183                             system_default_screenhack_count);
1184       system_default_screenhacks = 0;
1185       system_default_screenhack_count = 0;
1186     }
1187
1188   if (p->debug_p)
1189     {
1190       p->xsync_p = True;
1191       p->verbose_p = True;
1192       p->timestamp_p = True;
1193       p->initial_delay = 0;
1194     }
1195
1196   /* Throttle the various timeouts to reasonable values after reading the
1197      disk file. */
1198   stop_the_insanity (p);
1199 }
1200
1201
1202 /* If there are any hacks in the system-wide defaults that are not in
1203    the ~/.xscreensaver file, add the new ones to the end of the list.
1204    This does *not* actually save the file.
1205  */
1206 static void
1207 merge_system_screenhacks (Display *dpy, saver_preferences *p,
1208                           screenhack **system_list, int system_count)
1209 {
1210   /* Yeah yeah, this is an N^2 operation, but I don't have hashtables handy,
1211      so fuck it. */
1212
1213   int made_space = 0;
1214   int i;
1215   for (i = 0; i < system_count; i++)
1216     {
1217       int j;
1218       Bool matched_p = False;
1219
1220       for (j = 0; j < p->screenhacks_count; j++)
1221         {
1222           char *name;
1223           if (!system_list[i]->name)
1224             system_list[i]->name = make_hack_name (dpy, 
1225                                                    system_list[i]->command);
1226
1227           name = p->screenhacks[j]->name;
1228           if (!name)
1229             name = make_hack_name (dpy, p->screenhacks[j]->command);
1230
1231           matched_p = !strcasecmp (name, system_list[i]->name);
1232
1233           if (name != p->screenhacks[j]->name)
1234             free (name);
1235
1236           if (matched_p)
1237             break;
1238         }
1239
1240       if (!matched_p)
1241         {
1242           /* We have an entry in the system-wide list that is not in the
1243              user's .xscreensaver file.  Add it to the end.
1244              Note that p->screenhacks is a single malloc block, not a
1245              linked list, so we have to realloc it.
1246            */
1247           screenhack *oh = system_list[i];
1248           screenhack *nh = (screenhack *) malloc (sizeof(screenhack));
1249
1250           if (made_space == 0)
1251             {
1252               made_space = 10;
1253               p->screenhacks = (screenhack **)
1254                 realloc (p->screenhacks,
1255                          (p->screenhacks_count + made_space + 1)
1256                          * sizeof(screenhack));
1257               if (!p->screenhacks) abort();
1258             }
1259
1260           nh->enabled_p = oh->enabled_p;
1261           nh->visual    = oh->visual  ? strdup(oh->visual)  : 0;
1262           nh->name      = oh->name    ? strdup(oh->name)    : 0;
1263           nh->command   = oh->command ? strdup(oh->command) : 0;
1264
1265           p->screenhacks[p->screenhacks_count++] = nh;
1266           p->screenhacks[p->screenhacks_count] = 0;
1267           made_space--;
1268
1269 #if 0
1270           fprintf (stderr, "%s: noticed new hack: %s\n", blurb(),
1271                    (nh->name ? nh->name : make_hack_name (dpy, nh->command)));
1272 #endif
1273         }
1274     }
1275 }
1276
1277
1278 \f
1279 /* Parsing the programs resource.
1280  */
1281
1282 screenhack *
1283 parse_screenhack (const char *line)
1284 {
1285   screenhack *h = (screenhack *) calloc (1, sizeof(*h));
1286   const char *s;
1287
1288   h->enabled_p = True;
1289
1290   while (isspace(*line)) line++;                /* skip whitespace */
1291   if (*line == '-')                             /* handle "-" */
1292     {
1293       h->enabled_p = False;
1294       line++;
1295       while (isspace(*line)) line++;            /* skip whitespace */
1296     }
1297
1298   s = line;                                     /* handle "visual:" */
1299   while (*line && *line != ':' && *line != '"' && !isspace(*line))
1300     line++;
1301   if (*line != ':')
1302     line = s;
1303   else
1304     {
1305       h->visual = (char *) malloc (line-s+1);
1306       strncpy (h->visual, s, line-s);
1307       h->visual[line-s] = 0;
1308       if (*line == ':') line++;                 /* skip ":" */
1309       while (isspace(*line)) line++;            /* skip whitespace */
1310     }
1311
1312   if (*line == '"')                             /* handle "name" */
1313     {
1314       line++;
1315       s = line;
1316       while (*line && *line != '"')
1317         line++;
1318       h->name = (char *) malloc (line-s+1);
1319       strncpy (h->name, s, line-s);
1320       h->name[line-s] = 0;
1321       if (*line == '"') line++;                 /* skip "\"" */
1322       while (isspace(*line)) line++;            /* skip whitespace */
1323     }
1324
1325   h->command = format_command (line, False);    /* handle command */
1326   return h;
1327 }
1328
1329
1330 static char *
1331 format_command (const char *cmd, Bool wrap_p)
1332 {
1333   int tab = 30;
1334   int col = tab;
1335   char *cmd2 = (char *) calloc (1, 2 * (strlen (cmd) + 1));
1336   const char *in = cmd;
1337   char *out = cmd2;
1338   while (*in)
1339     {
1340       /* shrink all whitespace to one space, for the benefit of the "demo"
1341          mode display.  We only do this when we can easily tell that the
1342          whitespace is not significant (no shell metachars).
1343        */
1344       switch (*in)
1345         {
1346         case '\'': case '"': case '`': case '\\':
1347           /* Metachars are scary.  Copy the rest of the line unchanged. */
1348           while (*in)
1349             *out++ = *in++, col++;
1350           break;
1351
1352         case ' ': case '\t':
1353           /* Squeeze all other whitespace down to one space. */
1354           while (*in == ' ' || *in == '\t')
1355             in++;
1356           *out++ = ' ', col++;
1357           break;
1358
1359         default:
1360           /* Copy other chars unchanged. */
1361           *out++ = *in++, col++;
1362           break;
1363         }
1364     }
1365
1366   *out = 0;
1367
1368   /* Strip trailing whitespace */
1369   while (out > cmd2 && isspace (out[-1]))
1370     *(--out) = 0;
1371
1372   return cmd2;
1373 }
1374
1375
1376 /* Returns a new string describing the shell command.
1377    This may be just the name of the program, capitalized.
1378    It also may be something from the resource database (gotten
1379    by looking for "hacks.XYZ.name", where XYZ is the program.)
1380  */
1381 char *
1382 make_hack_name (Display *dpy, const char *shell_command)
1383 {
1384   char *s = strdup (shell_command);
1385   char *s2;
1386   char res_name[255];
1387
1388   for (s2 = s; *s2; s2++)       /* truncate at first whitespace */
1389     if (isspace (*s2))
1390       {
1391         *s2 = 0;
1392         break;
1393       }
1394
1395   s2 = strrchr (s, '/');        /* if pathname, take last component */
1396   if (s2)
1397     {
1398       s2 = strdup (s2+1);
1399       free (s);
1400       s = s2;
1401     }
1402
1403   if (strlen (s) > 50)          /* 51 is hereby defined as "unreasonable" */
1404     s[50] = 0;
1405
1406   sprintf (res_name, "hacks.%s.name", s);               /* resource? */
1407   s2 = get_string_resource (dpy, res_name, res_name);
1408   if (s2)
1409     {
1410       free (s);
1411       return s2;
1412     }
1413
1414   for (s2 = s; *s2; s2++)       /* if it has any capitals, return it */
1415     if (*s2 >= 'A' && *s2 <= 'Z')
1416       return s;
1417
1418   if (s[0] >= 'a' && s[0] <= 'z')                       /* else cap it */
1419     s[0] -= 'a'-'A';
1420   if (s[0] == 'X' && s[1] >= 'a' && s[1] <= 'z')        /* (magic leading X) */
1421     s[1] -= 'a'-'A';
1422   if (s[0] == 'G' && s[1] == 'l' && 
1423       s[2] >= 'a' && s[2] <= 'z')                      /* (magic leading GL) */
1424     s[1] -= 'a'-'A',
1425     s[2] -= 'a'-'A';
1426   return s;
1427 }
1428
1429
1430 char *
1431 format_hack (Display *dpy, screenhack *hack, Bool wrap_p)
1432 {
1433   int tab = 32;
1434   int size;
1435   char *h2, *out, *s;
1436   int col = 0;
1437
1438   char *def_name = make_hack_name (dpy, hack->command);
1439
1440   /* Don't ever write out a name for a hack if it's the same as the default.
1441    */
1442   if (hack->name && !strcmp (hack->name, def_name))
1443     {
1444       free (hack->name);
1445       hack->name = 0;
1446     }
1447   free (def_name);
1448
1449   size = (2 * (strlen(hack->command) +
1450                (hack->visual ? strlen(hack->visual) : 0) +
1451                (hack->name ? strlen(hack->name) : 0) +
1452                tab));
1453   h2 = (char *) malloc (size);
1454   out = h2;
1455
1456   if (!hack->enabled_p) *out++ = '-';           /* write disabled flag */
1457
1458   if (hack->visual && *hack->visual)            /* write visual name */
1459     {
1460       if (hack->enabled_p) *out++ = ' ';
1461       *out++ = ' ';
1462       strcpy (out, hack->visual);
1463       out += strlen (hack->visual);
1464       *out++ = ':';
1465       *out++ = ' ';
1466     }
1467
1468   *out = 0;
1469   col = string_columns (h2, strlen (h2), 0);
1470
1471   if (hack->name && *hack->name)                /* write pretty name */
1472     {
1473       int L = (strlen (hack->name) + 2);
1474       if (L + col < tab)
1475         out = stab_to (out, col, tab - L - 2);
1476       else
1477         *out++ = ' ';
1478       *out++ = '"';
1479       strcpy (out, hack->name);
1480       out += strlen (hack->name);
1481       *out++ = '"';
1482       *out = 0;
1483
1484       col = string_columns (h2, strlen (h2), 0);
1485       if (wrap_p && col >= tab)
1486         out = stab_to (out, col, 77);
1487       else
1488         *out++ = ' ';
1489
1490       if (out >= h2+size) abort();
1491     }
1492
1493   *out = 0;
1494   col = string_columns (h2, strlen (h2), 0);
1495   out = stab_to (out, col, tab);                /* indent */
1496
1497   if (out >= h2+size) abort();
1498   s = format_command (hack->command, wrap_p);
1499   strcpy (out, s);
1500   out += strlen (s);
1501   free (s);
1502   *out = 0;
1503
1504   return h2;
1505 }
1506
1507
1508 static void
1509 get_screenhacks (Display *dpy, saver_preferences *p)
1510 {
1511   int i, j;
1512   int start = 0;
1513   int end = 0;
1514   int size;
1515   char *d;
1516
1517   d = get_string_resource (dpy, "monoPrograms", "MonoPrograms");
1518   if (d && !*d) { free(d); d = 0; }
1519   if (!d)
1520     d = get_string_resource (dpy, "colorPrograms", "ColorPrograms");
1521   if (d && !*d) { free(d); d = 0; }
1522
1523   if (d)
1524     {
1525       fprintf (stderr,
1526        "%s: the `monoPrograms' and `colorPrograms' resources are obsolete;\n\
1527         see the manual for details.\n", blurb());
1528       free(d);
1529     }
1530
1531   d = get_string_resource (dpy, "programs", "Programs");
1532
1533   free_screenhack_list (p->screenhacks, p->screenhacks_count);
1534   p->screenhacks = 0;
1535   p->screenhacks_count = 0;
1536
1537   if (!d || !*d)
1538     return;
1539
1540   size = strlen (d);
1541
1542
1543   /* Count up the number of newlines (which will be equal to or larger than
1544      one less than the number of hacks.)
1545    */
1546   for (i = j = 0; d[i]; i++)
1547     if (d[i] == '\n')
1548       j++;
1549   j++;
1550
1551   p->screenhacks = (screenhack **) calloc (j + 1, sizeof (screenhack *));
1552
1553   /* Iterate over the lines in `d' (the string with newlines)
1554      and make new strings to stuff into the `screenhacks' array.
1555    */
1556   p->screenhacks_count = 0;
1557   while (start < size)
1558     {
1559       /* skip forward over whitespace. */
1560       while (d[start] == ' ' || d[start] == '\t' || d[start] == '\n')
1561         start++;
1562
1563       /* skip forward to newline or end of string. */
1564       end = start;
1565       while (d[end] != 0 && d[end] != '\n')
1566         end++;
1567
1568       /* null terminate. */
1569       d[end] = 0;
1570
1571       p->screenhacks[p->screenhacks_count++] = parse_screenhack (d + start);
1572       if (p->screenhacks_count >= i)
1573         abort();
1574
1575       start = end+1;
1576     }
1577
1578   free (d);
1579
1580   if (p->screenhacks_count == 0)
1581     {
1582       free (p->screenhacks);
1583       p->screenhacks = 0;
1584     }
1585 }
1586
1587
1588 /* Make sure all the values in the preferences struct are sane.
1589  */
1590 static void
1591 stop_the_insanity (saver_preferences *p)
1592 {
1593   if (p->passwd_timeout <= 0) p->passwd_timeout = 30000;         /* 30 secs */
1594   if (p->timeout < 15000) p->timeout = 15000;                    /* 15 secs */
1595   if (p->cycle != 0 && p->cycle < 2000) p->cycle = 2000;         /*  2 secs */
1596   if (p->pointer_timeout <= 0) p->pointer_timeout = 5000;        /*  5 secs */
1597   if (p->notice_events_timeout <= 0)
1598     p->notice_events_timeout = 10000;                            /* 10 secs */
1599   if (p->fade_seconds <= 0 || p->fade_ticks <= 0)
1600     p->fade_p = False;
1601   if (! p->fade_p) p->unfade_p = False;
1602
1603   /* The DPMS settings may have the value 0.
1604      But if they are negative, or are a range less than 10 seconds,
1605      reset them to sensible defaults.  (Since that must be a mistake.)
1606    */
1607   if (p->dpms_standby != 0 &&
1608       p->dpms_standby < 10 * 1000)
1609     p->dpms_standby =  2 * 60 * 60 * 1000;                       /* 2 hours */
1610   if (p->dpms_suspend != 0 &&
1611       p->dpms_suspend < 10 * 1000)
1612     p->dpms_suspend =  2 * 60 * 60 * 1000;                       /* 2 hours */
1613   if (p->dpms_off != 0 &&
1614       p->dpms_off < 10 * 1000)
1615     p->dpms_off      = 4 * 60 * 60 * 1000;                       /* 4 hours */
1616
1617   /* suspend may not be greater than off, unless off is 0.
1618      standby may not be greater than suspend, unless suspend is 0.
1619    */
1620   if (p->dpms_off != 0 &&
1621       p->dpms_suspend > p->dpms_off)
1622     p->dpms_suspend = p->dpms_off;
1623   if (p->dpms_suspend != 0 &&
1624       p->dpms_standby > p->dpms_suspend)
1625     p->dpms_standby = p->dpms_suspend;
1626
1627   /* These fixes above ignores the case
1628      suspend = 0 and standby > off ...
1629    */
1630   if (p->dpms_off != 0 &&
1631       p->dpms_standby > p->dpms_off)
1632     p->dpms_standby = p->dpms_off;
1633
1634
1635   if (p->dpms_standby == 0 &&      /* if *all* are 0, then DPMS is disabled */
1636       p->dpms_suspend == 0 &&
1637       p->dpms_off     == 0)
1638     p->dpms_enabled_p = False;
1639
1640
1641   /* Set watchdog timeout to about half of the cycle timeout, but
1642      don't let it be faster than 1/2 minute or slower than 1 minute.
1643    */
1644   p->watchdog_timeout = p->cycle * 0.6;
1645   if (p->watchdog_timeout < 27000) p->watchdog_timeout = 27000;   /* 27 secs */
1646   if (p->watchdog_timeout > 57000) p->watchdog_timeout = 57000;   /* 57 secs */
1647
1648   if (p->pointer_hysteresis < 0)   p->pointer_hysteresis = 0;
1649   if (p->pointer_hysteresis > 100) p->pointer_hysteresis = 100;
1650 }