home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / X / mit / fonts / server / os / osglue.c.orig < prev    next >
Encoding:
Text File  |  1991-07-19  |  7.0 KB  |  316 lines
  1. /* $XConsortium: osglue.c,v 1.4 91/07/19 20:49:41 rws Exp $ */
  2. /*
  3.  * Copyright 1990, 1991 Network Computing Devices;
  4.  * Portions Copyright 1987 by Digital Equipment Corporation and the
  5.  * Massachusetts Institute of Technology
  6.  *
  7.  * Permission to use, copy, modify, and distribute this protoype software
  8.  * and its documentation to Members and Affiliates of the MIT X Consortium
  9.  * any purpose and without fee is hereby granted, provided
  10.  * that the above copyright notice appear in all copies and that both that
  11.  * copyright notice and this permission notice appear in supporting
  12.  * documentation, and that the names of Network Computing Devices, Digital or
  13.  * MIT not be used in advertising or publicity pertaining to distribution of
  14.  * the software without specific, written prior permission.
  15.  *
  16.  * NETWORK COMPUTING DEVICES, DIGITAL AND MIT DISCLAIM ALL WARRANTIES WITH
  17.  * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18.  * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES, DIGITAL OR MIT BE
  19.  * LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  20.  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  21.  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22.  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23.  *
  24.  * $NCDId: @(#)osglue.c,v 4.6 1991/07/09 14:07:30 lemke Exp $
  25.  *
  26.  */
  27.  
  28. /*
  29.  * this is miscellaneous OS specific stuff.
  30.  *
  31.  * Catalogue support, alternate servers, and cloneing
  32.  */
  33.  
  34. #include "osstruct.h"
  35. #include <stdio.h>
  36. #define  XK_LATIN1
  37. #include <X11/keysymdef.h>
  38.  
  39. Bool        drone_server = FALSE;
  40. extern Bool CloneSelf;
  41. extern int  ListenSock;
  42. extern char *progname;
  43. extern char *configfilename;
  44.  
  45. static int  num_alts;
  46. static AlternateServerPtr alt_servers = (AlternateServerPtr) 0;
  47.  
  48. /*
  49.  * XXX
  50.  *
  51.  * Catalogue support is minimal at best.  the guts are here, but
  52.  * we don't actually do anything with them so the only one exported is
  53.  * 'all'.
  54.  *
  55.  */
  56.  
  57. static char *catalogue_name = "all";
  58.  
  59. static Bool            /* stolen from R4 Match() */
  60. pattern_match(pat, plen, string)
  61.     char       *pat;
  62.     int         plen;
  63.     char       *string;
  64. {
  65.     register int i,
  66.                 l;
  67.     int         j,
  68.                 m,
  69.                 res;
  70.     register char cp,
  71.                 cs;
  72.     int         head,
  73.                 tail;
  74.  
  75.     head = 0;
  76.     tail = plen;
  77.  
  78.     res = -1;
  79.     for (i = 0; i < head; i++) {
  80.     cp = pat[i];
  81.     if (cp == XK_question) {
  82.         if (!string[i])
  83.         return res;
  84.         res = 0;
  85.     } else if (cp != string[i])
  86.         return res;
  87.     }
  88.     if (head == plen)
  89.     return (string[head] ? res : 1);
  90.     l = head;
  91.     while (++i < tail) {
  92.     /* we just skipped an asterisk */
  93.     j = i;
  94.     m = l;
  95.     while ((cp = pat[i]) != XK_asterisk) {
  96.         if (!(cs = string[l]))
  97.         return 0;
  98.         if ((cp != cs) && (cp != XK_question)) {
  99.         m++;
  100.         cp = pat[j];
  101.         if (cp == XK_asterisk) {
  102.             if (!string[m])
  103.             return 0;
  104.         } else {
  105.             while ((cs = string[m]) != cp) {
  106.             if (!cs)
  107.                 return 0;
  108.             m++;
  109.             }
  110.         }
  111.         l = m;
  112.         i = j;
  113.         }
  114.         l++;
  115.         i++;
  116.     }
  117.     }
  118.     m = strlen(&string[l]);
  119.     j = plen - tail;
  120.     if (m < j)
  121.     return 0;
  122.     l = (l + m) - j;
  123.     while (cp = pat[i]) {
  124.     if ((cp != string[l]) && (cp != XK_question))
  125.         return 0;
  126.     l++;
  127.     i++;
  128.     }
  129.     return 1;
  130. }
  131.  
  132. int
  133. ListCatalogues(pattern, patlen, maxnames, catalogues, len)
  134.     char       *pattern;
  135.     int         patlen;
  136.     int         maxnames;
  137.     char      **catalogues;
  138.     int        *len;
  139. {
  140.     int         count = 0;
  141.     char       *catlist = NULL;
  142.     int         size = 0;
  143.  
  144.     if (maxnames) {
  145.     if (pattern_match(pattern, patlen, catalogue_name)) {
  146.         size = strlen(catalogue_name);
  147.         catlist = (char *) fsalloc(size + 1);
  148.         if (!catlist)
  149.         goto bail;
  150.         *catlist = size;
  151.         bcopy(catalogue_name, &catlist[1], size);
  152.         size++;        /* for length */
  153.         count++;
  154.     }
  155.     }
  156. bail:
  157.     *len = size;
  158.     *catalogues = catlist;
  159.     return count;
  160. }
  161.  
  162. /*
  163.  * check if catalogue list is valid
  164.  */
  165.  
  166. int
  167. ValidateCatalogues(num, cats)
  168.     int        *num;
  169.     char       *cats;
  170. {
  171.     char       *c = cats;
  172.     int         i,
  173.                 len;
  174.  
  175.     for (i = 0; i < *num; i++) {
  176.     len = *c++;
  177.     if (strncmp(c, catalogue_name, len)) {
  178.         *num = i;        /* return bad entry index */
  179.         return FSBadName;
  180.     }
  181.     c += len;
  182.     }
  183.     return FSSuccess;
  184. }
  185.  
  186. int
  187. SetAlternateServers(list)
  188.     char       *list;
  189. {
  190.     char       *t,
  191.                *st;
  192.     AlternateServerPtr alts,
  193.                 a;
  194.     int         num,
  195.                 i;
  196.  
  197.     t = list;
  198.     num = 1;
  199.     while (*t) {
  200.     if (*t == ',')
  201.         num++;
  202.     t++;
  203.     }
  204.  
  205.     a = alts = (AlternateServerPtr) fsalloc(sizeof(AlternateServerRec) * num);
  206.     if (!alts)
  207.     return FSBadAlloc;
  208.  
  209.     st = t = list;
  210.     a->namelen = 0;
  211.     while (*t) {
  212.     if (*t == ',') {
  213.         a->name = (char *) fsalloc(a->namelen);
  214.         if (!a->name) {
  215.         /* XXX  -- leak */
  216.         return FSBadAlloc;
  217.         }
  218.         bcopy(st, a->name, a->namelen);
  219.         a->subset = FALSE;    /* XXX */
  220.         a++;
  221.         t++;
  222.         st = t;
  223.         a->namelen = 0;
  224.     } else {
  225.         a->namelen++;
  226.         t++;
  227.     }
  228.     }
  229.     a->name = (char *) fsalloc(a->namelen);
  230.     if (!a->name) {
  231.     /* XXX  -- leak */
  232.     return FSBadAlloc;
  233.     }
  234.     bcopy(st, a->name, a->namelen);
  235.     a->subset = FALSE;        /* XXX */
  236.  
  237.     for (i = 0; i < num_alts; i++) {
  238.     fsfree((char *) alt_servers[i].name);
  239.     }
  240.     fsfree((char *) alt_servers);
  241.     num_alts = num;
  242.     alt_servers = alts;
  243.     return FSSuccess;
  244. }
  245.  
  246. int
  247. ListAlternateServers(svrs)
  248.     AlternateServerPtr *svrs;
  249. {
  250.     *svrs = alt_servers;
  251.     return num_alts;
  252. }
  253.  
  254. /*
  255.  * here's some fun stuff.  in order to cleanly handle becoming overloaded,
  256.  * this allows us to clone ourselves.  the parent keeps the Listen
  257.  * socket open, and sends it to itself.  the child stops listening,
  258.  * and becomes a drone, hanging out till it loses all its clients.
  259.  */
  260. int
  261. CloneMyself()
  262. {
  263.     int         child;
  264.     char        sockarg[32];
  265.     int         i;
  266.     int         lastfdesc;
  267.  
  268.     assert(!drone_server);    /* a drone shouldn't hit this */
  269.  
  270.     if (!CloneSelf)
  271.     return -1;
  272.  
  273. #if defined(hpux) || defined(SVR4)
  274.     lastfdesc = _NFILE - 1;
  275. #else
  276.     lastfdesc = getdtablesize() - 1;
  277. #endif                /* hpux */
  278.  
  279.     NoticeF("attempting clone...\n");
  280.     child = fork();
  281.     if (child == -1) {
  282.     /* failed to fork */
  283.     ErrorF("Clone failed to fork()\n");
  284.     return -1;
  285.     }
  286.     /*
  287.      * Note:  they still share the same process group, and killing the parent
  288.      * will take out all the kids as well.  this is considered a feature (at
  289.      * least until i'm convinced otherwise)
  290.      */
  291.     if (child == 0) {
  292.     StopListening();
  293.     NoticeF("Clone: child becoming drone\n");
  294.     drone_server = TRUE;
  295.     return 1;
  296.     } else {            /* parent */
  297.     NoticeF("Clone: parent revitalizing as %s\n", progname);
  298.     CloseErrors();
  299.     /* XXX should we close stdio as well? */
  300.     for (i = 3; i < lastfdesc; i++) {
  301.         if (i != ListenSock)
  302.         (void) close(i);
  303.     }
  304.     sprintf(sockarg, "%d", ListenSock);
  305.     execlp(progname, progname,
  306.            "-ls", sockarg,
  307.            "-cf", configfilename,
  308.            NULL);
  309.     InitErrors();        /* reopen errors, since we don't want to lose
  310.                  * this */
  311.     Error("Clone failed");
  312.     FatalError("Failed to clone self\n");
  313.     }
  314.     /* NOTREACHED */
  315. }
  316.