home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xlock / resource.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-09  |  21.9 KB  |  753 lines
  1. #ifndef lint
  2. static char sccsid[] = "@(#)resource.c    1.20 91/09/27 XLOCK";
  3. #endif
  4. /*-
  5.  * resource.c - resource management for xlock, the X Window System lockscreen.
  6.  *
  7.  * Copyright (c) 1991 by Patrick J. Naughton.
  8.  *
  9.  * See xlock.c for copying information.
  10.  *
  11.  * Revision History:
  12.  * 22-Jan-93: Added spline mode and points option.
  13.  * 25-Sep-91: added worm mode.
  14.  * 24-Jun-91: changed name to username.
  15.  * 06-Jun-91: Added flame mode.
  16.  * 24-May-91: Added -name and -usefirst and -resources.
  17.  * 16-May-91: Added random mode and pyro mode.
  18.  * 26-Mar-91: CheckResources: delay must be >= 0.
  19.  * 29-Oct-90: Added #include <ctype.h> for missing isupper() on some OS revs.
  20.  *          moved -mode option, reordered Xrm database evaluation.
  21.  * 28-Oct-90: Added text strings.
  22.  * 26-Oct-90: Fix bug in mode specific options.
  23.  * 31-Jul-90: Fix ':' handling in parsefilepath
  24.  * 07-Jul-90: Created from resource work in xlock.c
  25.  *
  26.  */
  27.  
  28. #include <stdio.h>
  29. #include "xlock.h"
  30. #include <netdb.h>
  31. #include <math.h>
  32. #include <ctype.h>
  33.  
  34. #include <X11/Xresource.h>
  35.  
  36. /*
  37.  * Declare external interface routines for supported screen savers.
  38.  */
  39.  
  40. extern void inithop();
  41. extern void drawhop();
  42.  
  43. extern void initlife();
  44. extern void drawlife();
  45.  
  46. extern void initqix();
  47. extern void drawqix();
  48.  
  49. extern void initblank();
  50. extern void drawblank();
  51.  
  52. extern void initswarm();
  53. extern void drawswarm();
  54.  
  55. extern void initrotor();
  56. extern void drawrotor();
  57.  
  58. extern void initpyro();
  59. extern void drawpyro();
  60.  
  61. extern void initflame();
  62. extern void drawflame();
  63.  
  64. extern void initworm();
  65. extern void drawworm();
  66.  
  67. extern void initspline();
  68. extern void drawspline();
  69.  
  70. typedef struct {
  71.     char       *cmdline_arg;
  72.     void        (*lp_init) ();
  73.     void        (*lp_callback) ();
  74.     int         def_delay;
  75.     int         def_batchcount;
  76.     float       def_saturation;
  77.     char       *desc;
  78. }           LockStruct;
  79.  
  80. static char randomstring[] = "random";
  81.  
  82. static LockStruct LockProcs[] = {
  83.     {"hop", inithop, drawhop, 0, 1000, 1.0, "Hopalong iterated fractals"},
  84.     {"qix", initqix, drawqix, 30000, 64, 1.0, "Spinning lines a la Qix(tm)"},
  85.     {"life", initlife, drawlife, 1000000, 100, 1.0, "Conway's game of Life"},
  86.     {"swarm", initswarm, drawswarm, 10000, 100, 1.0, "Swarm of bees"},
  87.     {"rotor", initrotor, drawrotor, 10000, 4, 0.4, "Tom's Roto-Rooter"},
  88.     {"pyro", initpyro, drawpyro, 15000, 40, 1.0, "Fireworks"},
  89.     {"flame", initflame, drawflame, 10000, 20, 1.0, "Cosmic Flame Fractals"},
  90.     {"worm", initworm, drawworm, 10000, 20, 1.0, "Wiggly Worms"},
  91.     {"spline", initspline, drawspline, 2000, 5, 1.0, "Bouncing Spline"},
  92.     {"blank", initblank, drawblank, 5000000, 1, 1.0, "Blank screen"},
  93.     {randomstring, NULL, NULL, 0, 0, 0.0, "Random mode"},
  94. };
  95. #define NUMPROCS (sizeof LockProcs / sizeof LockProcs[0])
  96.  
  97. #ifndef MAXHOSTNAMELEN
  98. #define MAXHOSTNAMELEN 64    /* SunOS 3.5 does not define this */
  99. #endif
  100.  
  101. extern char *getenv();
  102.  
  103. #ifndef DEF_FILESEARCHPATH
  104. #define DEF_FILESEARCHPATH "/usr/lib/X11/%T/%N%S"
  105. #endif
  106. #define DEF_DISPLAY    ":0"
  107. #define DEF_MODE    "spline"
  108. #define DEF_FONT    "-b&h-lucida-medium-r-normal-sans-24-*-*-*-*-*-iso8859-1"
  109. #define DEF_BG        "White"
  110. #define DEF_FG        "Black"
  111. #define DEF_NAME    "Name: "
  112. #define DEF_PASS    "Password: "
  113. #define DEF_INFO    "Enter password to unlock; select icon to lock."
  114. #define DEF_VALID    "Validating login..."
  115. #define DEF_INVALID    "Invalid login."
  116. #define DEF_TIMEOUT    "30"    /* secs till password entry times out */
  117. #define DEF_BC        "100"    /* vectors (or whatever) per batch */
  118. #define DEF_PT          "5"     /* number of spline points */
  119. #define DEF_DELAY    "200000"/* microseconds between batches */
  120. #define DEF_NICE    "10"    /* xlock process nicelevel */
  121. #define DEF_SAT        "1.0"    /* color ramp saturation 0->1 */
  122. #define DEF_CLASSNAME    "XLock"
  123.  
  124. static char *classname;
  125. static char modename[1024];
  126. static char modeclass[1024];
  127.  
  128. static XrmOptionDescRec genTable[] = {
  129.     {"-mode", ".mode", XrmoptionSepArg, (caddr_t) NULL},
  130.     {"-nolock", ".nolock", XrmoptionNoArg, (caddr_t) "on"},
  131.     {"+nolock", ".nolock", XrmoptionNoArg, (caddr_t) "off"},
  132.     {"-remote", ".remote", XrmoptionNoArg, (caddr_t) "on"},
  133.     {"+remote", ".remote", XrmoptionNoArg, (caddr_t) "off"},
  134.     {"-mono", ".mono", XrmoptionNoArg, (caddr_t) "on"},
  135.     {"+mono", ".mono", XrmoptionNoArg, (caddr_t) "off"},
  136.     {"-allowroot", ".allowroot", XrmoptionNoArg, (caddr_t) "on"},
  137.     {"+allowroot", ".allowroot", XrmoptionNoArg, (caddr_t) "off"},
  138.     {"-enablesaver", ".enablesaver", XrmoptionNoArg, (caddr_t) "on"},
  139.     {"+enablesaver", ".enablesaver", XrmoptionNoArg, (caddr_t) "off"},
  140.     {"-allowaccess", ".allowaccess", XrmoptionNoArg, (caddr_t) "on"},
  141.     {"+allowaccess", ".allowaccess", XrmoptionNoArg, (caddr_t) "off"},
  142.     {"-echokeys", ".echokeys", XrmoptionNoArg, (caddr_t) "on"},
  143.     {"+echokeys", ".echokeys", XrmoptionNoArg, (caddr_t) "off"},
  144.     {"-usefirst", ".usefirst", XrmoptionNoArg, (caddr_t) "on"},
  145.     {"+usefirst", ".usefirst", XrmoptionNoArg, (caddr_t) "off"},
  146.     {"-v", ".verbose", XrmoptionNoArg, (caddr_t) "on"},
  147.     {"+v", ".verbose", XrmoptionNoArg, (caddr_t) "off"},
  148.     {"-nice", ".nice", XrmoptionSepArg, (caddr_t) NULL},
  149.     {"-timeout", ".timeout", XrmoptionSepArg, (caddr_t) NULL},
  150.     {"-font", ".font", XrmoptionSepArg, (caddr_t) NULL},
  151.     {"-bg", ".background", XrmoptionSepArg, (caddr_t) NULL},
  152.     {"-fg", ".foreground", XrmoptionSepArg, (caddr_t) NULL},
  153.     {"-background", ".background", XrmoptionSepArg, (caddr_t) NULL},
  154.     {"-foreground", ".foreground", XrmoptionSepArg, (caddr_t) NULL},
  155.     {"-username", ".username", XrmoptionSepArg, (caddr_t) NULL},
  156.     {"-password", ".password", XrmoptionSepArg, (caddr_t) NULL},
  157.     {"-info", ".info", XrmoptionSepArg, (caddr_t) NULL},
  158.     {"-validate", ".validate", XrmoptionSepArg, (caddr_t) NULL},
  159.     {"-invalid", ".invalid", XrmoptionSepArg, (caddr_t) NULL},
  160. };
  161. #define genEntries (sizeof genTable / sizeof genTable[0])
  162.  
  163. static XrmOptionDescRec modeTable[] = {
  164.     {"-delay", ".delay", XrmoptionSepArg, (caddr_t) NULL},
  165.     {"-batchcount", ".batchcount", XrmoptionSepArg, (caddr_t) NULL},
  166.     {"-saturation", ".saturation", XrmoptionSepArg, (caddr_t) NULL},
  167.     {"-points", ".points", XrmoptionSepArg, (caddr_t) NULL},
  168. };
  169. #define modeEntries (sizeof modeTable / sizeof modeTable[0])
  170.  
  171. static XrmOptionDescRec cmdlineTable[] = {
  172.     {"-display", ".display", XrmoptionSepArg, (caddr_t) NULL},
  173.     {"-nolock", ".nolock", XrmoptionNoArg, (caddr_t) "on"},
  174.     {"+nolock", ".nolock", XrmoptionNoArg, (caddr_t) "off"},
  175.     {"-remote", ".remote", XrmoptionNoArg, (caddr_t) "on"},
  176.     {"+remote", ".remote", XrmoptionNoArg, (caddr_t) "off"},
  177. };
  178. #define cmdlineEntries (sizeof cmdlineTable / sizeof cmdlineTable[0])
  179.  
  180. static XrmOptionDescRec nameTable[] = {
  181.     {"-name", ".name", XrmoptionSepArg, (caddr_t) NULL},
  182. };
  183.  
  184.  
  185. typedef struct {
  186.     char       *opt;
  187.     char       *desc;
  188. }           OptionStruct;
  189.  
  190. static OptionStruct opDesc[] = {
  191.     {"-help", "print out this message"},
  192.     {"-resources", "print default resource file to standard output"},
  193.     {"-display displayname", "X server to contact"},
  194.     {"-name resourcename", "class name to use for resources (default is XLock)"},
  195.     {"-/+mono", "turn on/off monochrome override"},
  196.     {"-/+nolock", "turn on/off no password required mode"},
  197.     {"-/+remote", "turn on/off remote host access"},
  198.     {"-/+allowroot", "turn on/off allow root password mode"},
  199.     {"-/+enablesaver", "turn on/off enable X server screen saver"},
  200.     {"-/+allowaccess", "turn on/off allow new clients to connect"},
  201.     {"-/+echokeys", "turn on/off echo '?' for each password key"},
  202.     {"-/+usefirst", "turn on/off using the first char typed in password"},
  203.     {"-/+v", "turn on/off verbose mode"},
  204.     {"-delay usecs", "microsecond delay between screen updates"},
  205.     {"-batchcount num", "number of things per batch"},
  206.     {"-points num", "number of spline points"},
  207.     {"-nice level", "nice level for xlock process"},
  208.     {"-timeout seconds", "number of seconds before password times out"},
  209.     {"-saturation value", "saturation of color ramp"},
  210.     {"-font fontname", "font to use for password prompt"},
  211.     {"-bg color", "background color to use for password prompt"},
  212.     {"-fg color", "foreground color to use for password prompt"},
  213.     {"-username string", "text string to use for Name prompt"},
  214.     {"-password string", "text string to use for Password prompt"},
  215.     {"-info string", "text string to use for instructions"},
  216.     {"-validate string", "text string to use for validating password message"},
  217.     {"-invalid string", "text string to use for invalid password message"},
  218. };
  219. #define opDescEntries (sizeof opDesc / sizeof opDesc[0])
  220.  
  221. char       *display;
  222. char       *mode;
  223. char       *fontname;
  224. char       *background;
  225. char       *foreground;
  226. char       *text_name;
  227. char       *text_pass;
  228. char       *text_info;
  229. char       *text_valid;
  230. char       *text_invalid;
  231. float       saturation;
  232. int         nicelevel;
  233. int         delay;
  234. int         batchcount;
  235. int         points;
  236. int         timeout;
  237. Bool        mono;
  238. Bool        nolock;
  239. Bool        remote;
  240. Bool        allowroot;
  241. Bool        enablesaver;
  242. Bool        allowaccess;
  243. Bool        echokeys;
  244. Bool        usefirst;
  245. Bool        verbose;
  246.  
  247. #define t_String    0
  248. #define t_Float        1
  249. #define t_Int        2
  250. #define t_Bool        3
  251.  
  252. typedef struct {
  253.     caddr_t    *var;
  254.     char       *name;
  255.     char       *class;
  256.     char       *def;
  257.     int         type;
  258. }           argtype;
  259.  
  260. static argtype genvars[] = {
  261.     {(caddr_t *) &fontname, "font", "Font", DEF_FONT, t_String},
  262.     {(caddr_t *) &background, "background", "Background", DEF_BG, t_String},
  263.     {(caddr_t *) &foreground, "foreground", "Foreground", DEF_FG, t_String},
  264.     {(caddr_t *) &text_name, "username", "Username", DEF_NAME, t_String},
  265.     {(caddr_t *) &text_pass, "password", "Password", DEF_PASS, t_String},
  266.     {(caddr_t *) &text_info, "info", "Info", DEF_INFO, t_String},
  267.     {(caddr_t *) &text_valid, "validate", "Validate", DEF_VALID, t_String},
  268.     {(caddr_t *) &text_invalid, "invalid", "Invalid", DEF_INVALID, t_String},
  269.     {(caddr_t *) &nicelevel, "nice", "Nice", DEF_NICE, t_Int},
  270.     {(caddr_t *) &timeout, "timeout", "Timeout", DEF_TIMEOUT, t_Int},
  271.     {(caddr_t *) &mono, "mono", "Mono", "off", t_Bool},
  272.     {(caddr_t *) &nolock, "nolock", "NoLock", "off", t_Bool},
  273.     {(caddr_t *) &remote, "remote", "Remote", "off", t_Bool},
  274.     {(caddr_t *) &allowroot, "allowroot", "AllowRoot", "off", t_Bool},
  275.     {(caddr_t *) &enablesaver, "enablesaver", "EnableSaver", "off", t_Bool},
  276.     {(caddr_t *) &allowaccess, "allowaccess", "AllowAccess", "off", t_Bool},
  277.     {(caddr_t *) &echokeys, "echokeys", "EchoKeys", "off", t_Bool},
  278.     {(caddr_t *) &usefirst, "usefirst", "Usefirst", "off", t_Bool},
  279.     {(caddr_t *) &verbose, "verbose", "Verbose", "off", t_Bool},
  280. };
  281. #define NGENARGS (sizeof genvars / sizeof genvars[0])
  282.  
  283. static argtype modevars[] = {
  284.     {(caddr_t *) &delay, "delay", "Delay", DEF_DELAY, t_Int},
  285.     {(caddr_t *) &batchcount, "batchcount", "BatchCount", DEF_BC, t_Int},
  286.     {(caddr_t *) &saturation, "saturation", "Saturation", DEF_SAT, t_Float},
  287.     {(caddr_t *) &points, "points", "Points", DEF_PT, t_Int},
  288. };
  289. #define NMODEARGS (sizeof modevars / sizeof modevars[0])
  290.  
  291.  
  292. static void
  293. Syntax(badOption)
  294.     char       *badOption;
  295. {
  296.     int         col, len, i;
  297.  
  298.     fprintf(stderr, "%s:  bad command line option \"%s\"\n\n",
  299.         ProgramName, badOption);
  300.  
  301.     fprintf(stderr, "usage:  %s", ProgramName);
  302.     col = 8 + strlen(ProgramName);
  303.     for (i = 0; i < opDescEntries; i++) {
  304.     len = 3 + strlen(opDesc[i].opt);    /* space [ string ] */
  305.     if (col + len > 79) {
  306.         fprintf(stderr, "\n   ");    /* 3 spaces */
  307.         col = 3;
  308.     }
  309.     fprintf(stderr, " [%s]", opDesc[i].opt);
  310.     col += len;
  311.     }
  312.  
  313.     len = 8 + strlen(LockProcs[0].cmdline_arg);
  314.     if (col + len > 79) {
  315.     fprintf(stderr, "\n   ");    /* 3 spaces */
  316.     col = 3;
  317.     }
  318.     fprintf(stderr, " [-mode %s", LockProcs[0].cmdline_arg);
  319.     col += len;
  320.     for (i = 1; i < NUMPROCS; i++) {
  321.     len = 3 + strlen(LockProcs[i].cmdline_arg);
  322.     if (col + len > 79) {
  323.         fprintf(stderr, "\n   ");    /* 3 spaces */
  324.         col = 3;
  325.     }
  326.     fprintf(stderr, " | %s", LockProcs[i].cmdline_arg);
  327.     col += len;
  328.     }
  329.     fprintf(stderr, "]\n");
  330.  
  331.     fprintf(stderr, "\nType %s -help for a full description.\n\n",
  332.         ProgramName);
  333.     exit(1);
  334. }
  335.  
  336. static void
  337. Help()
  338. {
  339.     int         i;
  340.  
  341.     fprintf(stderr, "usage:\n        %s [-options ...]\n\n", ProgramName);
  342.     fprintf(stderr, "where options include:\n");
  343.     for (i = 0; i < opDescEntries; i++) {
  344.     fprintf(stderr, "    %-28s %s\n", opDesc[i].opt, opDesc[i].desc);
  345.     }
  346.  
  347.     fprintf(stderr, "    %-28s %s\n", "-mode mode", "animation mode");
  348.     fprintf(stderr, "    where mode is one of:\n");
  349.     for (i = 0; i < NUMPROCS; i++) {
  350.     fprintf(stderr, "          %-23s %s\n",
  351.         LockProcs[i].cmdline_arg, LockProcs[i].desc);
  352.     }
  353.     putc('\n', stderr);
  354.  
  355.     exit(0);
  356. }
  357.  
  358. static void
  359. DumpResources()
  360. {
  361.     int         i;
  362.  
  363.     printf("%s.mode: %s\n", classname, DEF_MODE);
  364.  
  365.     for (i = 0; i < NGENARGS; i++)
  366.     printf("%s.%s: %s\n",
  367.            classname, genvars[i].name, genvars[i].def);
  368.  
  369.     for (i = 0; i < NUMPROCS - 1; i++) {
  370.     printf("%s.%s.%s: %d\n", classname, LockProcs[i].cmdline_arg,
  371.            "delay", LockProcs[i].def_delay);
  372.     printf("%s.%s.%s: %d\n", classname, LockProcs[i].cmdline_arg,
  373.            "batchcount", LockProcs[i].def_batchcount);
  374.     printf("%s.%s.%s: %g\n", classname, LockProcs[i].cmdline_arg,
  375.            "saturation", LockProcs[i].def_saturation);
  376.     }
  377.     exit(0);
  378. }
  379.  
  380.  
  381. static void
  382. LowerString(s)
  383.     char       *s;
  384. {
  385.  
  386.     while (*s) {
  387.     if (isupper(*s))
  388.         *s += ('a' - 'A');
  389.     s++;
  390.     }
  391. }
  392.  
  393. static void
  394. GetResource(database, parentname, parentclass,
  395.         name, class, valueType, def, valuep)
  396.     XrmDatabase database;
  397.     char       *parentname;
  398.     char       *parentclass;
  399.     char       *name;
  400.     char       *class;
  401.     int         valueType;
  402.     char       *def;
  403.     caddr_t    *valuep;        /* RETURN */
  404. {
  405.     char       *type;
  406.     XrmValue    value;
  407.     char       *string;
  408.     char        buffer[1024];
  409.     char        fullname[1024];
  410.     char        fullclass[1024];
  411.     int         len;
  412.  
  413.     sprintf(fullname, "%s.%s", parentname, name);
  414.     sprintf(fullclass, "%s.%s", parentclass, class);
  415.     if (XrmGetResource(database, fullname, fullclass, &type, &value)) {
  416.     string = value.addr;
  417.     len = value.size;
  418.     } else {
  419.     string = def;
  420.     len = strlen(string);
  421.     }
  422.     (void) strncpy(buffer, string, sizeof(buffer));
  423.     buffer[sizeof(buffer) - 1] = '\0';
  424.  
  425.     switch (valueType) {
  426.     case t_String:
  427.     {
  428.         char       *s = (char *) malloc(len + 1);
  429.         if (s == (char *) NULL)
  430.         error("%s: GetResource - couldn't allocate memory");
  431.         (void) strncpy(s, string, len);
  432.         s[len] = '\0';
  433.         *((char **) valuep) = s;
  434.     }
  435.     break;
  436.     case t_Bool:
  437.     LowerString(buffer);
  438.     *((int *) valuep) = (!strcmp(buffer, "true") ||
  439.                  !strcmp(buffer, "on") ||
  440.                  !strcmp(buffer, "enabled") ||
  441.                  !strcmp(buffer, "yes")) ? True : False;
  442.     break;
  443.     case t_Int:
  444.     *((int *) valuep) = atoi(buffer);
  445.     break;
  446.     case t_Float:
  447.     *((float *) valuep) = (float) atof(buffer);
  448.     break;
  449.     }
  450. }
  451.  
  452.  
  453. static      XrmDatabase
  454. parsefilepath(xfilesearchpath, TypeName, ClassName)
  455.     char       *xfilesearchpath;
  456.     char       *TypeName;
  457.     char       *ClassName;
  458. {
  459.     XrmDatabase database = NULL;
  460.     char        appdefaults[1024];
  461.     char       *src;
  462.     char       *dst;
  463.  
  464.     src = xfilesearchpath;
  465.     appdefaults[0] = '\0';
  466.     dst = appdefaults;
  467.     while (1) {
  468.     if (*src == '%') {
  469.         src++;
  470.         switch (*src) {
  471.         case '%':
  472.         case ':':
  473.         *dst++ = *src++;
  474.         *dst = '\0';
  475.         break;
  476.         case 'T':
  477.         (void) strcat(dst, TypeName);
  478.         src++;
  479.         dst += strlen(TypeName);
  480.         break;
  481.         case 'N':
  482.         (void) strcat(dst, ClassName);
  483.         src++;
  484.         dst += strlen(ClassName);
  485.         break;
  486.         case 'S':
  487.         src++;
  488.         break;
  489.         default:
  490.         src++;
  491.         break;
  492.         }
  493.     } else if (*src == ':') {
  494.         database = XrmGetFileDatabase(appdefaults);
  495.         if (database == NULL) {
  496.         dst = appdefaults;
  497.         src++;
  498.         } else
  499.         break;
  500.     } else if (*src == '\0') {
  501.         database = XrmGetFileDatabase(appdefaults);
  502.         break;
  503.     } else {
  504.         *dst++ = *src++;
  505.         *dst = '\0';
  506.     }
  507.     }
  508.     return database;
  509. }
  510.  
  511.  
  512. static void
  513. open_display()
  514. {
  515.     if (display != NULL) {
  516.     extern char *strchr();
  517.     char       *colon = strchr(display, ':');
  518.     int         n = colon - display;
  519.  
  520.     if (colon == NULL)
  521.         error("%s: Malformed -display argument, \"%s\"\n", display);
  522.  
  523.     /*
  524.      * only restrict access to other displays if we are locking and if the
  525.      * Remote resource is not set.
  526.      */
  527.     if (nolock)
  528.         remote = True;
  529.     if (!remote && n
  530.         && strncmp(display, "unix", n)
  531.         && strncmp(display, "localhost", n)) {
  532.         char        hostname[MAXHOSTNAMELEN];
  533.         struct hostent *host;
  534.         char      **hp;
  535.         int         badhost = 1;
  536.  
  537.         if (gethostname(hostname, MAXHOSTNAMELEN))
  538.         error("%s: Can't get local hostname.\n");
  539.  
  540.         if (!(host = gethostbyname(hostname)))
  541.         error("%s: Can't get hostbyname.\n");
  542.  
  543.         if (strncmp(display, host->h_name, n)) {
  544.         for (hp = host->h_aliases; *hp; hp++) {
  545.             if (!strncmp(display, *hp, n)) {
  546.             badhost = 0;
  547.             break;
  548.             }
  549.         }
  550.         if (badhost) {
  551.             *colon = (char) 0;
  552.             error("%s: can't lock %s's display\n", display);
  553.         }
  554.         }
  555.     }
  556.     } else
  557.     display = ":0.0";
  558.     if (!(dsp = XOpenDisplay(display)))
  559.     error("%s: unable to open display %s.\n", display);
  560. }
  561.  
  562.  
  563. void
  564. printvar(class, var)
  565.     char       *class;
  566.     argtype     var;
  567. {
  568.     switch (var.type) {
  569.     case t_String:
  570.     fprintf(stderr, "%s.%s: %s\n",
  571.         class, var.name, *((char **) var.var));
  572.     break;
  573.     case t_Bool:
  574.     fprintf(stderr, "%s.%s: %s\n",
  575.         class, var.name, *((int *) var.var)
  576.         ? "True" : "False");
  577.     break;
  578.     case t_Int:
  579.     fprintf(stderr, "%s.%s: %d\n",
  580.         class, var.name, *((int *) var.var));
  581.     break;
  582.     case t_Float:
  583.     fprintf(stderr, "%s.%s: %g\n",
  584.         class, var.name, *((float *) var.var));
  585.     break;
  586.     }
  587. }
  588.  
  589.  
  590. void
  591. GetResources(argc, argv)
  592.     int         argc;
  593.     char       *argv[];
  594. {
  595.     XrmDatabase RDB = NULL;
  596.     XrmDatabase nameDB = NULL;
  597.     XrmDatabase modeDB = NULL;
  598.     XrmDatabase cmdlineDB = NULL;
  599.     XrmDatabase generalDB = NULL;
  600.     XrmDatabase homeDB = NULL;
  601.     XrmDatabase applicationDB = NULL;
  602.     XrmDatabase serverDB = NULL;
  603.     XrmDatabase userDB = NULL;
  604.     char        userfile[1024];
  605.     char       *homeenv;
  606.     char       *userpath;
  607.     char       *env;
  608.     char       *serverString;
  609.     int         i;
  610.  
  611.     XrmInitialize();
  612.  
  613.     for (i = 0; i < argc; i++) {
  614.     if (!strncmp(argv[i], "-help", strlen(argv[i])))
  615.         Help();
  616.     /* NOTREACHED */
  617.     }
  618.  
  619.     /*
  620.      * get -name arg from command line so you can have different resource
  621.      * files for different configurations/machines etc...
  622.      */
  623.     XrmParseCommand(&nameDB, nameTable, 1, ProgramName,
  624.             &argc, argv);
  625.     GetResource(nameDB, ProgramName, "*", "name", "Name", t_String,
  626.         DEF_CLASSNAME, &classname);
  627.  
  628.  
  629.     homeenv = getenv("HOME");
  630.     if (!homeenv)
  631.     homeenv = "";
  632.  
  633.     env = getenv("XFILESEARCHPATH");
  634.     applicationDB = parsefilepath(env ? env : DEF_FILESEARCHPATH,
  635.                   "app-defaults", classname);
  636.  
  637.     XrmParseCommand(&cmdlineDB, cmdlineTable, cmdlineEntries, ProgramName,
  638.             &argc, argv);
  639.  
  640.     userpath = getenv("XUSERFILESEARCHPATH");
  641.     if (!userpath) {
  642.     env = getenv("XAPPLRESDIR");
  643.     if (env)
  644.         sprintf(userfile, "%s/%%N:%s/%%N", env, homeenv);
  645.     else
  646.         sprintf(userfile, "%s/%%N", homeenv);
  647.     userpath = userfile;
  648.     }
  649.     userDB = parsefilepath(userpath, "app-defaults", classname);
  650.  
  651.     (void) XrmMergeDatabases(applicationDB, &RDB);
  652.     (void) XrmMergeDatabases(userDB, &RDB);
  653.     (void) XrmMergeDatabases(cmdlineDB, &RDB);
  654.  
  655.     env = getenv("DISPLAY");
  656.     GetResource(RDB, ProgramName, classname, "display", "Display", t_String,
  657.         env ? env : DEF_DISPLAY, &display);
  658.     GetResource(RDB, ProgramName, classname, "nolock", "NoLock", t_Bool,
  659.         "off", (caddr_t *) &nolock);
  660.     GetResource(RDB, ProgramName, classname, "remote", "Remote", t_Bool,
  661.         "off", (caddr_t *) &remote);
  662.  
  663.     open_display();
  664.     serverString = XResourceManagerString(dsp);
  665.     if (serverString) {
  666.     serverDB = XrmGetStringDatabase(serverString);
  667.     (void) XrmMergeDatabases(serverDB, &RDB);
  668.     } else {
  669.     char        buf[1024];
  670.     sprintf(buf, "%s/.Xdefaults", homeenv);
  671.     homeDB = XrmGetFileDatabase(buf);
  672.     (void) XrmMergeDatabases(homeDB, &RDB);
  673.     }
  674.  
  675.     XrmParseCommand(&generalDB, genTable, genEntries, ProgramName, &argc, argv);
  676.     (void) XrmMergeDatabases(generalDB, &RDB);
  677.  
  678.     GetResource(RDB, ProgramName, classname, "mode", "Mode", t_String,
  679.         DEF_MODE, (caddr_t *) &mode);
  680.  
  681.     /*
  682.      * if random< mode, then just grab a random entry from the table
  683.      */
  684.     if (!strcmp(mode, randomstring))
  685.     mode = LockProcs[random() % (NUMPROCS - 2)].cmdline_arg;
  686.  
  687.     sprintf(modename, "%s.%s", ProgramName, mode);
  688.     sprintf(modeclass, "%s.%s", classname, mode);
  689.  
  690.     XrmParseCommand(&modeDB, modeTable, modeEntries, modeclass, &argc, argv);
  691.     (void) XrmMergeDatabases(modeDB, &RDB);
  692.  
  693.     /* Parse the rest of the command line */
  694.     for (argc--, argv++; argc > 0; argc--, argv++) {
  695.     if (**argv != '-')
  696.         Syntax(*argv);
  697.     switch (argv[0][1]) {
  698.     case 'r':
  699.         DumpResources();
  700.         /* NOTREACHED */
  701.     default:
  702.         Syntax(*argv);
  703.         /* NOTREACHED */
  704.     }
  705.     }
  706.  
  707.     /* the RDB is set, now query load the variables from the database */
  708.  
  709.     for (i = 0; i < NGENARGS; i++)
  710.     GetResource(RDB, ProgramName, classname,
  711.             genvars[i].name, genvars[i].class,
  712.             genvars[i].type, genvars[i].def, genvars[i].var);
  713.  
  714.     for (i = 0; i < NMODEARGS; i++)
  715.     GetResource(RDB, modename, modeclass,
  716.             modevars[i].name, modevars[i].class,
  717.             modevars[i].type, modevars[i].def, modevars[i].var);
  718.  
  719.     (void) XrmDestroyDatabase(RDB);
  720.  
  721.     if (verbose) {
  722.     for (i = 0; i < NGENARGS; i++)
  723.         printvar(classname, genvars[i]);
  724.     for (i = 0; i < NMODEARGS; i++)
  725.         printvar(modename, modevars[i]);
  726.     }
  727. }
  728.  
  729.  
  730. CheckResources()
  731. {
  732.     int         i;
  733.  
  734.     if (batchcount < 1)
  735.     Syntax("-batchcount argument must be positive.");
  736.     if (saturation < 0.0 || saturation > 1.0)
  737.     Syntax("-saturation argument must be between 0.0 and 1.0.");
  738.     if (delay < 0)
  739.     Syntax("-delay argument must be positive.");
  740.  
  741.     for (i = 0; i < NUMPROCS; i++) {
  742.     if (!strncmp(LockProcs[i].cmdline_arg, mode, strlen(mode))) {
  743.         init = LockProcs[i].lp_init;
  744.         callback = LockProcs[i].lp_callback;
  745.         break;
  746.     }
  747.     }
  748.     if (i == NUMPROCS) {
  749.     fprintf(stderr, "Unknown mode: ");
  750.     Syntax(mode);
  751.     }
  752. }
  753.