/[radius]/radius/lib/envar.c
ViewVC logotype

Diff of /radius/lib/envar.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.3 by gray, Fri Aug 2 11:18:43 2002 UTC revision 1.4 by gray, Tue Apr 29 13:57:59 2003 UTC
# Line 23  Line 23 
23  #include <mem.h>  #include <mem.h>
24  #include <envar.h>  #include <envar.h>
25  #include <argcv.h>  #include <argcv.h>
26  #include <slist.h>  #include <list.h>
27    
28    typedef struct envar {
29            char *name;
30            char *value;
31    } ENVAR;
32    
33  static void  static void
34  envar_parse_internal(str, phead, ptail)  envar_parse_internal(char *str, LIST **plist)
         char *str;  
         envar_t **phead;  
         envar_t **ptail;  
35  {  {
36          int i;          int i;
37          int argc;          int argc;
38          char **argv;          char **argv;
         envar_t *head = NULL, *tail;  
39    
         *phead = *ptail = NULL;  
40          if (argcv_get(str, ",", &argc, &argv)) {          if (argcv_get(str, ",", &argc, &argv)) {
41                  if (argv)                  if (argv)
42                          argcv_free(argc, argv);                          argcv_free(argc, argv);
# Line 44  envar_parse_internal(str, phead, ptail) Line 44  envar_parse_internal(str, phead, ptail)
44          }          }
45    
46          for (i = 0; i < argc; i++) {          for (i = 0; i < argc; i++) {
47                  envar_t *env;                  ENVAR *env;
48                  char *p;                  char *p;
49                                    
50                  if (argv[i][0] == ',')                  if (argv[i][0] == ',')
51                          continue;                          continue;
52                  env = mem_alloc(sizeof(*env));                  env = emalloc(sizeof(*env));
53                  p = strchr(argv[i], '=');                  p = strchr(argv[i], '=');
54                  if (p) {                  if (p) {
55                          int len = p - argv[i];                          int len = p - argv[i];
# Line 65  envar_parse_internal(str, phead, ptail) Line 65  envar_parse_internal(str, phead, ptail)
65                          env->name = estrdup(argv[i]);                          env->name = estrdup(argv[i]);
66                          env->value = estrdup("1");                          env->value = estrdup("1");
67                  }                  }
68                  if (!head)                  if (!*plist)
69                          head = env;                          *plist = list_create();
70                  else                  list_append(*plist, env);
                         tail->next = env;  
                 tail = env;  
71          }          }
   
         argcv_free(argc, argv);  
         *phead = head;  
         *ptail = tail;  
72  }  }
73    
74  envar_t *  envar_t *
75  envar_parse(str)  envar_parse(char *str)
         char *str;  
76  {  {
77          envar_t *head, *tail;          LIST *list = NULL;
78          envar_parse_internal(str, &head, &tail);          envar_parse_internal(str, &list);
79          return head;          return list;
80  }  }
81    
82  envar_t *  envar_t *
83  envar_parse_argcv(argc, argv)  envar_parse_argcv(int argc, char **argv)
         int argc;  
         char **argv;  
84  {  {
85          envar_t *head = NULL, *tail;          LIST *list = NULL;
86          while (argc--) {          while (argc--) {
87                  envar_t *ph, *pt;                  envar_parse_internal(*argv++, &list);
                 envar_parse_internal(*argv++, &ph, &pt);  
                 if (!head)  
                         head = ph;  
                 else  
                         tail->next = ph;  
                 tail = pt;  
88          }          }
89          return head;          return list;
90  }  }
91    
92  void  static int
93  envar_free(env)  envar_free(void *item, void *data)
         envar_t *env;  
94  {  {
95            ENVAR *env = item;
96          efree(env->name);          efree(env->name);
97          efree(env->value);          efree(env->value);
98            efree(env);
99            return 0;
100  }  }
101    
102  void  void
103  envar_free_list(env)  envar_free_list(envar_t **evp)
         envar_t *env;  
104  {  {
105          free_slist((struct slist*)env, envar_free);          list_destroy(evp, envar_free, NULL);
106  }  }
107    
108  char *  char *
109  envar_lookup(env, name)  envar_lookup(envar_t *env, char *name)
         envar_t *env;  
         char *name;  
110  {  {
111          for (; env; env = env->next) {          ENVAR *p;
112                  if (strcmp(env->name, name) == 0)  
113                          return env->value;          for (p = list_first(env); p; p = list_next(env)) {
114                    if (strcmp(p->name, name) == 0)
115                            return p->value;
116          }          }
117          return NULL;          return NULL;
118  }  }
119    
120  char *  char *
121  envar_lookup_str(env, name, defval)  envar_lookup_str(envar_t *env, char *name, char *defval)
         envar_t *env;  
         char *name;  
         char *defval;  
122  {  {
123          char *s;          char *s;
124    
# Line 145  envar_lookup_str(env, name, defval) Line 128  envar_lookup_str(env, name, defval)
128  }  }
129    
130  int  int
131  envar_lookup_int(env, name, defval)  envar_lookup_int(envar_t *env, char *name, int defval)
         envar_t *env;  
         char *name;  
         int defval;  
132  {  {
133          char *s;          char *s;
134                    
# Line 157  envar_lookup_int(env, name, defval) Line 137  envar_lookup_int(env, name, defval)
137          return defval;          return defval;
138  }  }
139    
140  envar_t *  ENVAR *
141  envar_dup(env)  envar_dup(ENVAR *env)
         envar_t *env;  
142  {  {
143          envar_t *ep;          ENVAR *ep;
144    
145          ep = mem_alloc(sizeof(*ep));          ep = emalloc(sizeof(*ep));
146          ep->name  = estrdup(env->name);          ep->name  = estrdup(env->name);
147          ep->value = estrdup(env->value);          ep->value = estrdup(env->value);
148          return ep;          return ep;
149  }  }
150    
151  envar_t *  envar_t *
152  envar_merge_lists(prim, sec)  envar_merge_lists(envar_t *prim, envar_t *sec)
153          envar_t *prim;  {
154          envar_t *sec;          envar_t *list;
155  {          ENVAR *p;
156          envar_t *list, *p;  
157            list = list_create();
158          list = NULL;          for (p = list_first(sec); p; p = list_next(sec))
159          for (; sec; sec = sec->next)                  if (!envar_lookup(prim, p->name)) {
160                  if (!envar_lookup(prim, sec->name)) {                          list_append(list, envar_dup(p));
                         p = envar_dup(sec);  
                         p->next = list;  
                         list = p;  
161                  }                  }
162          for (; prim; prim = prim->next) {          for (p = list_first(prim); p; p = list_next(prim)) {
163                  p = envar_dup(prim);                  list_append(list, envar_dup(p));
                 p->next = list;  
                 list = p;  
164          }          }
165          return list;          return list;
166  }  }

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.4

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26