home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume13 / conf / part02 / confopts.c < prev   
C/C++ Source or Header  |  1988-03-13  |  11KB  |  502 lines
  1. /*
  2.  *    conf - An interactive multi-user chat program.
  3.  *
  4.  *    conf Copyright (c) 1986, 1987 by Keith Gabryelski
  5.  *
  6.  *    Conf is quasi-public domain software; it may be used and copied
  7.  *    freely and may be modified to suit the indivuals needs as long
  8.  *    as:
  9.  *
  10.  *    [1] It is not sold.
  11.  *    [2] It is not made part of any licensed product.
  12.  *    [3] This header and others like it are not modified or removed.
  13.  *    [4] You allow others to use and copy without charge.
  14.  *    
  15.  *    without expressed written permission from the original
  16.  *    author (Keith Gabryelski).
  17.  *
  18.  */
  19.  
  20. #include "conf.h"
  21.  
  22. int set_name(), set_integer(), set_ptrstr();
  23.  
  24. #ifdef    USE_TERMCAP
  25. char *ocls;
  26. int use_ocap, ocol, olin;
  27. #endif    USE_TERMCAP
  28.  
  29. gettcap()
  30. {
  31.     char *ptr;
  32.  
  33. #ifdef    USE_TERMCAP
  34.     char buf[1024];
  35.  
  36.     use_ocap = FALSE;
  37.     if (tgetent(buf, getenv("TERM")) == 1)
  38.     {
  39.     columns=tgetnum("co");
  40.     lines=tgetnum("li");
  41.     tcapstr("cl", &cls);
  42.     use_ocap= TRUE;
  43.     ocol = columns;
  44.     olin = lines;
  45.     ocls = mymalloc(strlen(cls)+1);
  46.     (void) strcpy(ocls, cls);
  47.     }
  48. #endif    USE_TERMCAP
  49.  
  50.     if ((ptr = getenv("COLUMNS")) != NULL)
  51.     columns = atoi(ptr);
  52.  
  53.     if ((ptr = getenv("LINES")) != NULL)
  54.     lines = atoi(ptr);
  55.  
  56.     if ((ptr = getenv("CLS")) != NULL)
  57.     {
  58.     cls = myrealloc(cls, strlen(ptr)+1);
  59.     (void) strcpy(cls, ptr);
  60.     }
  61.  
  62.     if ((ptr = getenv("SHELL")) != NULL)
  63.     {
  64.     shell = myrealloc(shell, strlen(ptr)+1);
  65.     (void) strcpy(shell, ptr);
  66.     }
  67.  
  68.     if ((ptr = getenv("PG")) != NULL)
  69.     {
  70.     pager = myrealloc(pager, strlen(ptr)+1);
  71.     (void) strcpy(pager, ptr);
  72.     }
  73. }
  74.  
  75. getrc()
  76. {
  77.     char *fname;
  78.     char tmp[100];
  79.     char *bp, *p;
  80.     int c;
  81.     FILE *fp;
  82.  
  83.     if (homedir == NULL)
  84.     {
  85.     (void)fprintf(stderr, "%s: Can't figure you out!  Not using %s.\n",
  86.         progname, CONFRC);
  87.     return;
  88.     }
  89.  
  90.     fname = mymalloc((unsigned)(strlen(homedir) + 1 + strlen(CONFRC) + 1));
  91.  
  92.     (void)strcpy(fname, homedir);
  93.     (void)strcat(fname, "/");
  94.     (void)strcat(fname, CONFRC);
  95.  
  96.     if ((fp = fopen(fname, "r")) == (FILE *)NULL)
  97.     {
  98.         if (errno != ENOENT)
  99.         (void)fprintf(stderr, "%s: Couldn't open confrc file %s (%s).\n",
  100.         progname, fname, puterr(errno));
  101.  
  102.     free(fname);
  103.     return;
  104.     }
  105.  
  106.     forever
  107.     {
  108.     p = bp = tmp;
  109.  
  110.     while (((c = getc(fp)) != EOF) && (c != '\n'))
  111.         *p++ = c;
  112.  
  113.     if (c == EOF)
  114.         break;
  115.  
  116.     *p = '\0';
  117.  
  118.     while (isspace(*bp))
  119.         bp++;
  120.  
  121.     if ((*bp == '#') || (*bp == ';') || (*bp == '\0'))
  122.         continue;
  123.  
  124.     if (*bp == ':')        /* a colon command? */
  125.     {
  126.         linelen = strlen(bp+1);
  127.         if (!intpret(bp+1))
  128.         {
  129.         (void) printf("Invalid confrc line in %s @\"%s\".\n",fname,bp);
  130.         return;
  131.         }
  132.     }
  133.     else
  134.     {
  135.         if ((bp = parsestr(bp, p-bp, NEXTWORD)) == NULL)
  136.         continue;
  137.  
  138.         do
  139.         {
  140.         if ((c = setopts(bp)) != FOUNDOPT)
  141.         {
  142.             if (c == AMBIGUOUS)
  143.             (void)fputs("Ambiguous", stdout);
  144.             else
  145.             (void)fputs("Invalid", stdout);
  146.  
  147.             (void)printf(" confrc file %s @\"%s\"\n", fname, bp);
  148.             free(fname);
  149.             return;
  150.         }
  151.         } while ((bp = parsestr((char *)NULL, 0, NEXTWORD)) != NULL);
  152.     }
  153.     }
  154.  
  155.     free(fname);
  156.  
  157.     (void)fclose(fp);
  158. }
  159.  
  160. getopts()
  161. {
  162.     char *ptr;
  163.     int x;
  164.  
  165. #ifdef    USE_TERMCAP
  166.     if (use_ocap)
  167.     {
  168.     columns= ocol;
  169.     lines=olin;
  170.     cls = myrealloc(cls, strlen(ocls)+1);
  171.     (void) strcpy(cls, ocls);
  172.     free(ocls);
  173.     }
  174. #endif    USE_TERMCAP
  175.  
  176.     if ((ptr = getenv("COLUMNS")) != NULL)
  177.     columns = atoi(ptr);
  178.  
  179.     if ((ptr = getenv("LINES")) != NULL)
  180.     lines = atoi(ptr);
  181.  
  182.     if ((ptr = getenv("CLS")) != NULL)
  183.     {
  184.     cls = myrealloc(cls, strlen(ptr)+1);
  185.     (void) strcpy(cls, ptr);
  186.     }
  187.  
  188.     if ((ptr = getenv("SHELL")) != NULL)
  189.     {
  190.     shell = myrealloc(shell, strlen(ptr)+1);
  191.     (void) strcpy(shell, ptr);
  192.     }
  193.  
  194.     if ((ptr = getenv("PAGER")) != NULL)
  195.     {
  196.     pager = myrealloc(pager, strlen(ptr)+1);
  197.     (void) strcpy(pager, ptr);
  198.     }
  199.  
  200.     if ((ptr = getenv(CONFOPTS)) != NULL)
  201.     {
  202.     ptr = parsestr(ptr, strlen(ptr), NEXTWORD);
  203.  
  204.     do
  205.     {
  206.         if ((x = setopts(ptr)) != FOUNDOPT)
  207.         {
  208.         if (x == AMBIGUOUS)
  209.             (void)fputs("Ambiuous", stdout);
  210.         else
  211.             (void)fputs("Invalid", stdout);
  212.  
  213.         (void)printf(" %s environment variable @%s\n", CONFOPTS, ptr);
  214.         break;
  215.         }
  216.     } while ((ptr = parsestr((char *)NULL, 0, NEXTWORD)) != NULL);
  217.     }
  218. }
  219.  
  220. setopts(opt)
  221. char *opt;
  222. {
  223.     int found;
  224.  
  225.     static struct varopts vartab[] =
  226.     {
  227.     { "askdump", BOOLEAN|DISPLAY, &askdump, TRUE, },
  228.     { "noaskdump", BOOLEAN|DISPLAY, &askdump, FALSE, },
  229.     { "!askdump", BOOLEAN|NODISPLAY, &askdump, FALSE, },
  230.     { "autowho", BOOLEAN|DISPLAY, &autowho, TRUE, },
  231.     { "noautowho", BOOLEAN|DISPLAY, &autowho, FALSE, },
  232.     { "!autowho", BOOLEAN|NODISPLAY, &autowho, FALSE, },
  233.     { "banner", BOOLEAN|DISPLAY, &banner, TRUE, },
  234.     { "nobanner", BOOLEAN|DISPLAY, &banner, FALSE, },
  235.     { "!banner", BOOLEAN|NODISPLAY, &banner, FALSE, },
  236.     { "beep", BOOLEAN|DISPLAY, &beep, TRUE, },
  237.     { "nobeep", BOOLEAN|DISPLAY, &beep, FALSE, },
  238.     { "!beep", BOOLEAN|NODISPLAY, &beep, FALSE, },
  239.     { "columns", NUMBER|DISPLAY, &columns, 0, set_integer, },
  240.     { "cls", STRING|DISPLAY, (int *)&cls, POINTER, set_ptrstr, },
  241.     { "expand8bit", BOOLEAN|DISPLAY, &expand8bit, TRUE, },
  242.     { "noexpand8bit", BOOLEAN|DISPLAY, &expand8bit, FALSE, },
  243.     { "!expand8bit", BOOLEAN|NODISPLAY, &expand8bit, FALSE, },
  244.     { "expandctrl", BOOLEAN|DISPLAY, &expandctrl, TRUE, },
  245.     { "noexpandctrl", BOOLEAN|DISPLAY, &expandctrl, FALSE, },
  246.     { "!expandctrl", BOOLEAN|NODISPLAY, &expandctrl, FALSE, },
  247.     { "inform-format", STRING|DISPLAY, (int *)&informform, POINTER, set_ptrstr, },
  248.     { "line", NUMBER|DISPLAY, &cuser.cu_line, 0, do_to, },
  249.     { "line-format", STRING|DISPLAY, (int *)&lineform, POINTER, set_ptrstr, },
  250.     { "lines", NUMBER|DISPLAY, &lines, 0, set_integer, },
  251.     { "lineinput", BOOLEAN|DISPLAY, &lineinput, TRUE, },
  252.     { "nolineinput", BOOLEAN|DISPLAY, &lineinput, FALSE, },
  253.     { "nolineinput", BOOLEAN|DISPLAY, &lineinput, FALSE, },
  254.     { "!lineinput", BOOLEAN|NODISPLAY, &lineinput, FALSE, },
  255.     { "name", STRING|DISPLAY, (int *)cuser.cu_cname, ROUTINE, set_name, },
  256.     { "normal-format", STRING|DISPLAY, (int *)&normform, POINTER, set_ptrstr, },
  257.     { "pager", STRING|DISPLAY, (int *)&pager, POINTER, set_ptrstr, },
  258.     { "password", STRING|NODISPLAY, (int *)curpass, ROUTINE, set_pass, },
  259.     { "recfile", STRING|DISPLAY, (int *)&recfile, POINTER, set_ptrstr, },
  260.     { "seeme", BOOLEAN|DISPLAY, &seeme, TRUE, },
  261.     { "noseeme", BOOLEAN|DISPLAY, &seeme, FALSE, },
  262.     { "!seeme", BOOLEAN|NODISPLAY, &seeme, FALSE, },
  263.     { "seemyinform", BOOLEAN|DISPLAY, &informe, TRUE, },
  264.     { "noseemyinform", BOOLEAN|DISPLAY, &informe, FALSE, },
  265.     { "!seemyinform", BOOLEAN|NODISPLAY, &informe, FALSE, },
  266.     { "send-format", STRING|DISPLAY, (int *)&sendform, POINTER, set_ptrstr, },
  267.     { "shell", STRING|DISPLAY, (int *)&shell, POINTER, set_ptrstr, },
  268.     { "shout-format", STRING|DISPLAY, (int *)&shoutform, POINTER, set_ptrstr, },
  269.     { "warncrypt", BOOLEAN|DISPLAY, &warncrypt, TRUE, },
  270.     { "nowarncrypt", BOOLEAN|DISPLAY, &warncrypt, FALSE, },
  271.     { "!warncrypt", BOOLEAN|NODISPLAY, &warncrypt, FALSE, },
  272.     { NULL, }
  273.     }, *varptr, *keepptr;
  274.  
  275.     if (opt == NULL)
  276.     {
  277.     char *string;
  278.     int tmp;
  279.     int len=0;
  280.  
  281.     for (varptr = vartab; varptr->name != NULL; varptr++)
  282.         if ((varptr->type == BOOLEAN) && (*varptr->var == varptr->extra))
  283.         if ((tmp = strlen(varptr->name)) > len)
  284.             len = tmp;
  285.  
  286.     len += TABAGE;
  287.  
  288.     (void)fputs("Boolean flags:\n\n", stdout);
  289.  
  290.     for (varptr = vartab; varptr->name != NULL; varptr++)
  291.         if ((varptr->type == BOOLEAN) && (*varptr->var == varptr->extra))
  292.         colprnt(varptr->name, len);
  293.  
  294.     terpri();
  295.  
  296.     len = 0;
  297.  
  298.     for (varptr = vartab; varptr->name != NULL; varptr++)
  299.         if (varptr->type == NUMBER)
  300.         if ((tmp = strlen(varptr->name)+1+declen(varptr->var)) > len)
  301.             len = tmp;
  302.  
  303.     len += TABAGE;
  304.  
  305.     (void)fputs("\nNumeric options:\n\n", stdout);
  306.  
  307.     string = mymalloc((unsigned)(len+1));
  308.     for (varptr = vartab; varptr->name != NULL; varptr++)
  309.         if (varptr->type == NUMBER)
  310.         {
  311.         (void) sprintf(string, "%s=%d", varptr->name, *varptr->var);
  312.         colprnt(string, len);
  313.         }
  314.  
  315.     terpri();
  316.  
  317.     len = 0;
  318.  
  319.     for (varptr = vartab; varptr->name != NULL; varptr++)
  320.         if (varptr->type == STRING)
  321.         if (varptr->extra&POINTER)
  322.         {
  323.             if ((tmp=strlen(varptr->name)+vislen(*varptr->var)+3) > len)
  324.             len = tmp;
  325.         }
  326.         else
  327.         {
  328.             if ((tmp= strlen(varptr->name)+vislen(varptr->var)+3) > len)
  329.             len = tmp;
  330.         }
  331.  
  332.     len += TABAGE;
  333.  
  334.     (void)fputs("\nString options:\n\n", stdout);
  335.  
  336.     string = myrealloc(string, (unsigned)(len+1));
  337.     for (varptr = vartab; varptr->name != NULL; varptr++)
  338.         if (varptr->type == STRING)
  339.         {
  340.         if (varptr->extra&POINTER)
  341.             (void) sprintf(string, "%s=\"%s\"", varptr->name,
  342.                 *varptr->var);
  343.         else
  344.             (void) sprintf(string, "%s=\"%s\"", varptr->name,
  345.                 varptr->var);
  346.         colprnt(string, len);
  347.         }
  348.  
  349.     terpri();
  350.     free(string);
  351.  
  352.     return FOUNDOPT;
  353.     }
  354.  
  355.     keepptr = (struct varopts *)NULL;
  356.     found = 0;
  357.     for (varptr = vartab; varptr->name != NULL; varptr++)
  358.     if (!strncmp(varptr->name, opt, strlen(opt)))
  359.     {
  360.         if (!found)
  361.         keepptr = varptr;
  362.  
  363.         if (found >= 0)
  364.         ++found;
  365.  
  366.         if (strlen(varptr->name) == strlen(opt))
  367.         {
  368.         found = -1;
  369.         keepptr = varptr;
  370.         }
  371.     }
  372.  
  373.     if (!found)
  374.     return NOOPT;
  375.  
  376.     if (found > 1)
  377.     return AMBIGUOUS;
  378.  
  379.     switch(keepptr->type&VARMASK)
  380.     {
  381.     case BOOLEAN:
  382.         *keepptr->var = keepptr->extra;
  383.         break;
  384.  
  385.     case NUMBER:
  386.         return (*keepptr->var_func)(keepptr->name, keepptr->var);
  387.  
  388.     case STRING:
  389.         return (*keepptr->var_func)(keepptr->name, keepptr->var);
  390.  
  391.     default:
  392.         return NOOPT;
  393.     }
  394.  
  395.     return FOUNDOPT;
  396. }
  397.  
  398. set_name()
  399. {
  400.     char *ptr, *ptr2;
  401.     char nbuf[20+MAXNAMELEN];
  402.  
  403.     if ((ptr = ptr2 = parsestr((char *)NULL, 0, NEXTWORD)) == NULL)
  404.     {
  405.     if (confing)
  406.     {
  407.         (void) printf("name = \"%s\"\n", cuser.cu_cname);
  408.         return TRUE;
  409.     }
  410.  
  411.     return FALSE;
  412.     }
  413.  
  414.     while(*ptr2 != '\0')
  415.     {
  416.     if ((*ptr2 > ' ') && !strchr(",:/", *ptr2))
  417.         ptr2++;
  418.     else
  419.         *ptr2 = '\0';
  420.     }
  421.  
  422.     if (*ptr == '\0')
  423.     {
  424.     if (confing)
  425.     {
  426.         (void)puts("Invalid name given.");
  427.         return TRUE;
  428.     }
  429.  
  430.     return FALSE;
  431.     }
  432.  
  433.     (void) sprintf(nbuf, "Changed name from %s", cuser.cu_cname);
  434.  
  435.     (void) strncpy(cuser.cu_cname, ptr, MAXNAMELEN);
  436.     cuser.cu_cname[MAXNAMELEN-1] = '\0';
  437.     clog.f_usrlen = strlen(cuser.cu_cname) + 1;
  438.  
  439.     if (confing)
  440.     {
  441.     write_log(INFORM, nbuf, (char *)NULL, 0, (unsigned)strlen(nbuf));
  442.     write_usr();
  443.     (void)printf("Name changed to \"%s\"\n", cuser.cu_cname);
  444.     }
  445.  
  446.     return TRUE;
  447. }
  448.  
  449. set_integer(name, var)
  450. char *name;
  451. int *var;
  452. {
  453.     char *ptr;
  454.  
  455.     if ((ptr = parsestr((char *)NULL, 0, NEXTWORD)) != NULL)
  456.     *var = atoi(ptr);
  457.  
  458.     (void) printf("%s = %d\n", name, *var);
  459.     return FOUNDOPT;
  460. }
  461.  
  462. set_ptrstr(name, var)
  463. char *name, **var;
  464. {
  465.     char *ptr;
  466.  
  467.     if ((ptr = parsestr((char *)NULL, 0, NEXTWORD)) != NULL)
  468.     {
  469.     *var = myrealloc(*var, strlen(ptr)+1);
  470.     (void) strcpy(*var, ptr);
  471.     }
  472.  
  473.     (void) printf("%s = \"", name);
  474.     visprnt(*var, stdout);
  475.     (void) puts("\"");
  476.  
  477.     return FOUNDOPT;
  478. }
  479.  
  480. declen(num)
  481. register int num;
  482. {
  483.     register int places = 1;
  484.  
  485.     while ((num /= 10) >= 1)
  486.     ++places;
  487.  
  488.     return places;
  489. }
  490.  
  491. tcapstr(string, var)
  492. char *string, **var;
  493. {
  494.     char *tcapbuf = mymalloc(1024);
  495.     char *tmp = tcapbuf;
  496.  
  497.     (void) tgetstr(string, &tmp);
  498.     *var = realloc(*var, tmp-tcapbuf);
  499.     (void) strcpy(*var, tcapbuf);
  500.     free(tcapbuf);
  501. }
  502.