home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 4 / CDPD_IV.bin / networking / uucp / amigauucpsrc / lib / config.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-29  |  4.4 KB  |  224 lines
  1.  
  2. /*
  3.  *  CONFIG.C
  4.  *
  5.  *  (C) Copyright 1989-1990 by Matthew Dillon,  All Rights Reserved.
  6.  *
  7.  *  Extract fields from UULIB:Config
  8.  */
  9.  
  10. #include <exec/types.h>
  11. #include <exec/libraries.h>
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <fcntl.h>
  16. #include "config.h"
  17.  
  18. Prototype char *FindLocalVariable(const char *);
  19. Prototype char *FindConfig(const char *);
  20. Prototype char *GetConfig(const char *, char *);
  21. Prototype char *GetConfigDir(char *);
  22. Prototype char *GetConfigProgram(char *);
  23. Prototype char *MakeConfigPath(const char *, const char *);
  24. Prototype char *MakeConfigPathBuf(char *, const char *, const char *);
  25. Prototype FILE *openlib(const char *);
  26. Prototype FILE *openlib_write(const char *);
  27.  
  28. #define CTLZ    ('z'&0x1F)
  29.  
  30. static char *ConfBuf = NULL;
  31.  
  32. extern struct Library *SysBase;
  33.  
  34. typedef struct LVarNode {
  35.     struct LVarNode *lv_Next;
  36.     char *lv_Name;
  37.     char lv_Buf[4];
  38. } LVarNode;
  39.  
  40. char *
  41. FindLocalVariable(field)
  42. const char *field;
  43. {
  44.     char *res = NULL;
  45.     static LVarNode *LVBase;
  46.  
  47.     {
  48.     LVarNode *lvnode;
  49.  
  50.     for (lvnode = LVBase; lvnode; lvnode = lvnode->lv_Next) {
  51.         if (stricmp(field, lvnode->lv_Name) == 0)
  52.         return(lvnode->lv_Buf);
  53.     }
  54.     }
  55. #ifdef INCLUDE_VERSION
  56. #if INCLUDE_VERSION >= 36
  57.     if (SysBase->lib_Version >= 37) {   /*  MUST be V37 or greater */
  58.     char buf[2];
  59.  
  60.     if (GetVar(field, buf, sizeof(buf) - 1, 0) >= 0) {
  61.         LVarNode *lvnode;
  62.         long len = IoErr() + 1;
  63.  
  64.         /*
  65.          *    probably do not need the +1 in the lvnode malloc due to
  66.          *    the + 1 above, but why take chances?
  67.          */
  68.  
  69.         lvnode = malloc(sizeof(LVarNode) + len + 1);
  70.         lvnode->lv_Name = strcpy(malloc(strlen(field) + 1), field);
  71.         lvnode->lv_Next = LVBase;
  72.         LVBase = lvnode;
  73.         GetVar(field, lvnode->lv_Buf, len, 0);
  74.         return(lvnode->lv_Buf);
  75.     }
  76.     }
  77. #endif
  78. #endif
  79.     return(res);
  80. }
  81.  
  82.  
  83. char *
  84. FindConfig(field)
  85. const char *field;
  86. {
  87.     char *str;
  88.     short flen = strlen(field);
  89.  
  90.     /*
  91.      *    If running under 2.0, check local variable overide
  92.      */
  93.  
  94.     if (str = FindLocalVariable(field))
  95.     return(str);
  96.  
  97.     /*
  98.      *    load config file if not already loaded
  99.      */
  100.  
  101.     if (ConfBuf == NULL) {
  102.     FILE *fi;
  103.     fi = fopen("S:UUConfig", "r");
  104.     if (fi == NULL)
  105.         fi = fopen("UULIB:Config", "r");
  106.     if (fi) {
  107.         long buflen;
  108.         fseek(fi, 0L, 2);
  109.         buflen = ftell(fi);
  110.         fseek(fi, 0L, 0);
  111.         if (buflen > 0 && (ConfBuf = malloc(buflen + 1))) {
  112.         fread(ConfBuf, buflen, 1, fi);
  113.         ConfBuf[buflen] = CTLZ;     /*    can't use \0 */
  114.         for (str = ConfBuf; *str && *str != CTLZ; ++str) {
  115.             char *bup;
  116.             if (*str == '\n') {     /*  make separate strs */
  117.             *str = 0;
  118.                         /*    remove white space at end */
  119.             for (bup = str - 1; bup >= ConfBuf && (*bup == ' ' || *bup == 9); --bup)
  120.                 *bup = 0;
  121.             }
  122.         }
  123.         } else {
  124.         ConfBuf = NULL;
  125.         }
  126.         fclose(fi);
  127.     } else {
  128.         fprintf(stderr, "Couldn't open S:UUConfig or UULIB:Config\n");
  129.     }
  130.     }
  131.     if (ConfBuf == NULL)
  132.     return(NULL);
  133.  
  134.     /*
  135.      *    Search ConfBuf for Field<space/tab>
  136.      */
  137.  
  138.     for (str = ConfBuf; *str != CTLZ; str += strlen(str) + 1) {
  139.     if (*str == 0 || *str == '#')
  140.         continue;
  141.     if (strnicmp(str, field, flen) == 0 && (str[flen] == ' ' || str[flen] == '\t')) {
  142.         str += flen;
  143.         while (*str == ' ' || *str == 9)
  144.         ++str;
  145.         return(str);
  146.     }
  147.     }
  148.     return(NULL);
  149. }
  150.  
  151. char *
  152. GetConfig(field, def)
  153. const char *field;
  154. char *def;
  155. {
  156.     char *result = FindConfig(field);
  157.  
  158.     if (result == NULL)
  159.     result = def;
  160.     return(result);
  161. }
  162.  
  163. char *
  164. GetConfigDir(field)
  165. char *field;
  166. {
  167.     char *result = FindConfig(field);
  168.  
  169.     if (result == NULL)
  170.     result = field + strlen(field) + 1;
  171.     return(result);
  172. }
  173.  
  174. char *
  175. GetConfigProgram(field)
  176. char *field;
  177. {
  178.     char *result = FindConfig(field);
  179.     if (result == NULL)
  180.     result = field;
  181.     return(result);
  182. }
  183.  
  184. char *
  185. MakeConfigPath(field, trailer)
  186. const char *field;
  187. const char *trailer;
  188. {
  189.     static char Buf[512];
  190.     return(MakeConfigPathBuf(Buf, field, trailer));
  191. }
  192.  
  193. char *
  194. MakeConfigPathBuf(buf, field, trailer)
  195. char *buf;
  196. const char *field;
  197. const char *trailer;
  198. {
  199.     char *result = GetConfigDir(field);
  200.     short len = strlen(result) - 1;
  201.  
  202.     if (len > 0 && result[len] == '/' || result[len] == ':')
  203.     sprintf(buf, "%s%s", result, trailer);
  204.     else
  205.     sprintf(buf, "%s/%s", result, trailer);
  206.     return(buf);
  207. }
  208.  
  209.  
  210. FILE *
  211. openlib(filename)
  212. const char *filename;
  213. {
  214.     return (fopen(MakeConfigPath(UULIB, filename), "r"));
  215. }
  216.  
  217. FILE *
  218. openlib_write(filename)
  219. const char *filename;
  220. {
  221.     return (fopen(MakeConfigPath(UULIB, filename), "w"));
  222. }
  223.  
  224.