c287228958cf4f4dccfe3d2e19f926cb9750e859
[idzebra-moved-to-github.git] / util / res.c
1 /* This file is part of the Zebra server.
2    Copyright (C) 1994-2010 Index Data
3
4 Zebra is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
7 version.
8
9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
17
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <assert.h>
24 #ifdef WIN32
25 #include <io.h>
26 #endif
27 #if HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 #include <yaz/tokenizer.h>
32 #include <yaz/yaz-util.h>
33 #include <idzebra/res.h>
34
35 #define YLOG_RES 0
36
37 struct res_entry {
38     char *name;
39     char *value;
40     struct res_entry *next;
41 };
42
43 struct res_struct {
44     int ref_count;
45     struct res_entry *first, *last;
46     Res def_res;
47     Res over_res;
48 };
49
50 static Res res_incref(Res r)
51 {
52     if (r)
53         r->ref_count++;
54     return r;
55 }
56
57 static struct res_entry *add_entry(Res r)
58 {
59     struct res_entry *resp;
60
61     if (!r->first)
62         resp = r->last = r->first =
63             (struct res_entry *) xmalloc(sizeof(*resp));
64     else
65     {
66         resp = (struct res_entry *) xmalloc(sizeof(*resp));
67         r->last->next = resp;
68         r->last = resp;
69     }
70     resp->next = NULL;
71     return resp;
72 }
73
74 static char *xstrdup_env(const char *src)
75 {
76     int i = 0;
77     int j = 0;
78     char *dst;
79     int env_strlen = 0;
80
81     while (src[i])
82     {
83         if (src[i] == '$' && src[i+1] == '{')
84         {
85             char envname[128];
86             char *env_val;
87             int k = 0;
88             i = i + 2;
89             while (k < 127 && src[i] && !strchr(":}\n\r\f", src[i]))
90                 envname[k++] = src[i++];
91             envname[k] = '\0';
92
93             env_val = getenv(envname);
94             if (env_val)
95                 env_strlen += 1 + strlen(env_val);
96             else
97                 env_strlen++;
98             while (src[i] && !strchr("}\n\r\f", src[i]))
99                 i++;
100             if (src[i] == '}')
101                 i++;
102         }
103         else
104             i++;
105     }
106     dst = xmalloc(1 + env_strlen + i);
107     i = 0;
108     while (src[i])
109     {
110         if (src[i] == '$' && src[i+1] == '{')
111         {
112             char envname[128];
113             char *env_val;
114             int k = 0;
115             i = i + 2;
116             while(k < 127 && src[i] && !strchr(":}\n\r\f", src[i]))
117                 envname[k++] = src[i++];
118             envname[k] = '\0';
119             env_val = getenv(envname);
120             if (env_val)
121             {
122                 strcpy(dst+j, env_val);
123                 j += strlen(env_val);
124             }
125             else if (src[i] == ':' && src[i+1] == '-') 
126             {
127                 i = i + 2;
128                 while (src[i] && !strchr("}\n\r\f", src[i]))
129                     dst[j++] = src[i++];
130             }
131             while (src[i] && !strchr("}\n\r\f", src[i]))
132                 i++;
133             if (src[i] == '}')
134                 i++;
135         }
136         else
137             dst[j++] = src[i++];
138     }
139     dst[j] = '\0';
140     return dst;
141 }
142
143 ZEBRA_RES res_read_file(Res r, const char *fname)
144 {
145     FILE *fr;
146     int errors = 0;
147
148     assert(r);
149
150     fr = fopen(fname, "r");
151     if (!fr)
152     {
153         yaz_log(YLOG_WARN|YLOG_ERRNO, "Cannot open `%s'", fname);
154         errors++;
155     }
156     else
157     {
158         char fr_buf[1024];
159         char *line;
160         int lineno = 1;
161         WRBUF wrbuf_val = wrbuf_alloc();
162         yaz_tok_cfg_t yt = yaz_tok_cfg_create();
163         
164         while ((line = fgets(fr_buf, sizeof(fr_buf)-1, fr)))
165         {
166             yaz_tok_parse_t tp = yaz_tok_parse_buf(yt, line);
167             int t = yaz_tok_move(tp);
168             
169             if (t == YAZ_TOK_STRING)
170             {
171                 size_t sz;
172                 struct res_entry *resp;
173                 const char *cp = yaz_tok_parse_string(tp);
174                 const char *cp1 = strchr(cp, ':');
175
176                 if (!cp1)
177                 {
178                     yaz_log(YLOG_FATAL, "%s:%d missing colon after '%s'",
179                             fname, lineno, cp);
180                     errors++;
181                     break;
182                 }
183                 resp = add_entry(r);
184                 sz = cp1 - cp;
185                 resp->name = xmalloc(sz + 1);
186                 memcpy(resp->name, cp, sz);
187                 resp->name[sz] = '\0';
188
189                 wrbuf_rewind(wrbuf_val);
190
191                 if (cp1[1])
192                 {
193                     /* name:value  */
194                     wrbuf_puts(wrbuf_val, cp1+1);
195                 }
196                 else
197                 {
198                     /* name:   value */
199                     t = yaz_tok_move(tp);
200                     
201                     if (t != YAZ_TOK_STRING)
202                     {
203                         resp->value = xstrdup("");
204                         yaz_log(YLOG_FATAL, "%s:%d missing value after '%s'",
205                                 fname, lineno, resp->name);
206                         errors++;
207                         break;
208                     }
209                     wrbuf_puts(wrbuf_val, yaz_tok_parse_string(tp));
210                 }
211                 while ((t=yaz_tok_move(tp)) == YAZ_TOK_STRING)
212                 {
213                     wrbuf_putc(wrbuf_val, ' ');
214                     wrbuf_puts(wrbuf_val, yaz_tok_parse_string(tp));
215                 }
216                 resp->value = xstrdup_env(wrbuf_cstr(wrbuf_val));
217                 /* printf("name=%s value=%s\n", resp->name, resp->value); */
218             }
219             lineno++;
220             yaz_tok_parse_destroy(tp);
221         }         
222         fclose(fr);
223         yaz_tok_cfg_destroy(yt);
224         wrbuf_destroy(wrbuf_val);
225     }
226     if (errors)
227         return ZEBRA_FAIL;
228     return ZEBRA_OK;
229 }
230
231 Res res_open(Res def_res, Res over_res)
232 {
233     Res r;
234     r = (Res) xmalloc(sizeof(*r));
235
236     r->ref_count = 1;
237     r->first = r->last = NULL;
238     r->def_res = res_incref(def_res);
239     r->over_res = res_incref(over_res);
240     return r;
241 }
242
243 void res_clear(Res r)
244 {
245     struct res_entry *re, *re1;
246     for (re = r->first; re; re=re1)
247     {
248         if (re->name)
249             xfree(re->name);
250         if (re->value)
251             xfree(re->value);
252         re1 = re->next;
253         xfree(re);
254     }
255     r->first = r->last = NULL;
256 }
257
258 void res_close(Res r)
259 {
260     if (r && --(r->ref_count) == 0)
261     {
262         res_clear(r);
263         res_close(r->def_res);
264         res_close(r->over_res);
265         xfree(r);
266     }
267 }
268
269 const char *res_get_prefix(Res r, const char *name, const char *prefix,
270                             const char *def)
271 {
272     const char *v = 0;;
273     if (prefix)
274     {
275         char rname[128];
276         
277         if (strlen(name) + strlen(prefix) >= (sizeof(rname)-2))
278             return 0;
279         strcpy(rname, prefix);
280         strcat(rname, ".");
281         strcat(rname, name);
282         v = res_get(r, rname);
283     }
284     if (!v)
285         v = res_get(r, name);
286     if (!v)
287         v = def;
288     return v;
289 }
290
291 const char *res_get(Res r, const char *name)
292 {
293     struct res_entry *re;
294     const char *v;
295
296     if (!r)
297         return 0;
298     
299     v = res_get(r->over_res, name);
300     if (v)
301         return v;
302
303     for (re = r->first; re; re=re->next)
304         if (re->value && !yaz_matchstr(re->name, name))
305             return re->value;
306
307     return res_get(r->def_res, name);
308 }
309
310 const char *res_get_def(Res r, const char *name, const char *def)
311 {
312     const char *t;
313
314     if (!(t = res_get(r, name)))
315     {
316         if (def)
317             yaz_log(YLOG_DEBUG, "Using default resource %s:%s", name, def);
318         return def;
319     }
320     else
321         return t;
322 }
323
324 int res_get_match(Res r, const char *name, const char *value, const char *s)
325 {
326     const char *cn = res_get(r, name);
327
328     if (!cn)
329         cn = s;
330     if (cn && !yaz_matchstr(cn, value))
331         return 1;
332     return 0;
333 }
334
335 void res_set(Res r, const char *name, const char *value)
336 {
337     struct res_entry *re;
338     assert(r);
339
340     if (!value)
341         return;
342     for (re = r->first; re; re=re->next)
343         if (re->value && !yaz_matchstr(re->name, name))
344         {
345             xfree(re->value);
346             re->value = xstrdup_env(value);
347             return;
348         }
349     re = add_entry(r);
350     re->name = xstrdup(name);
351     re->value = xstrdup_env(value);
352 }
353
354 int res_trav(Res r, const char *prefix, void *p,
355              void (*f)(void *p, const char *name, const char *value))
356 {
357     struct res_entry *re;
358     int l = 0;
359     int no = 0;
360     
361     if (!r)
362         return 0;
363     no = res_trav(r->over_res, prefix, p, f);
364     if (no)
365         return no;
366     if (prefix)
367         l = strlen(prefix);
368     for (re = r->first; re; re=re->next)
369         if (re->value)
370             if (l==0 || !memcmp(re->name, prefix, l))
371             {
372                 (*f)(p, re->name, re->value);
373                 no++;
374             }
375     if (!no)
376         return res_trav(r->def_res, prefix, p, f);
377     return no;
378 }
379
380
381 ZEBRA_RES res_write_file(Res r, const char *fname)
382 {
383     struct res_entry *re;
384     FILE *fr;
385
386     assert(r);
387     fr = fopen(fname, "w");
388     if (!fr)
389     {
390         yaz_log(YLOG_FATAL|YLOG_ERRNO, "Cannot create `%s'", fname);
391         return ZEBRA_FAIL;
392     }
393
394     for (re = r->first; re; re=re->next)
395     {
396         int no = 0;
397         int lefts = strlen(re->name)+2;
398
399         if (!re->value)
400             fprintf(fr, "%s\n", re->name);
401         else
402         {
403             fprintf(fr, "%s: ", re->name);
404             while (lefts + strlen(re->value+no) > 78)
405             {
406                 int i = 20;
407                 int ind = no+ 78-lefts;
408                 while (--i >= 0)
409                 {
410                     if (re->value[ind] == ' ')
411                         break;
412                     --ind;
413                 }
414                 if (i<0)
415                     ind = no + 78 - lefts;
416                 for (i = no; i != ind; i++)
417                     putc(re->value[i], fr);
418                 fprintf(fr, "\\\n");
419                 no=ind;
420                 lefts = 0;
421             }
422             fprintf(fr, "%s\n", re->value+no);
423         }
424     }
425     fclose(fr);
426     return ZEBRA_OK;
427 }
428
429 ZEBRA_RES res_get_int(Res r, const char *name, int *val)
430 {
431     const char *cp = res_get(r, name);
432     if (cp)
433     {
434         if (sscanf(cp, "%d", val) == 1)
435             return ZEBRA_OK;
436         yaz_log(YLOG_WARN, "Expected integer for resource %s", name);
437     }
438     return ZEBRA_FAIL;
439 }
440
441
442 void res_add(Res r, const char *name, const char *value)
443 {
444     struct res_entry *re;
445     assert(r);
446     assert(name);
447     assert(value);
448     yaz_log(YLOG_RES, "res_add res=%p, name=%s, value=%s", r, name, value);
449     re = add_entry(r);
450     re->name = xstrdup(name);
451     re->value = xstrdup_env(value);
452 }
453
454 void res_dump(Res r, int level) 
455 {
456     struct res_entry *re;
457     
458     if (!r)
459         return;
460     
461     for (re = r->first; re; re=re->next) {
462         printf("%*s - %s:='%s'\n",level * 4,"",re->name,re->value);
463     }
464     
465     if (r->def_res) {
466         printf("%*s DEF ",level * 4,"");
467         res_dump(r->def_res, level + 1);
468     }
469     
470     if (r->over_res) {
471         printf("%*s OVER ",level * 4,"");
472         res_dump(r->over_res, level + 1);
473     }
474 }
475
476 int res_check(Res r_i, Res r_v)
477 {
478     struct res_entry *e_i;
479     int errors = 0;
480     
481     for (e_i = r_i->first; e_i; e_i = e_i->next)
482     {
483         struct res_entry *e_v;
484         for (e_v = r_v->first; e_v; e_v = e_v->next)
485         {
486             int prefix_allowed = 0;
487             int suffix_allowed = 0;
488             const char *name = e_i->name;
489             size_t name_len = strlen(e_i->name);
490             char namez[32];
491             const char *first_dot = 0;
492             const char *second_dot = 0;
493
494             if (strchr(e_v->value, 'p'))
495                 prefix_allowed = 1;
496             if (strchr(e_v->value, 's'))
497                 suffix_allowed = 1;
498             
499             first_dot = strchr(name, '.');
500             if (prefix_allowed && first_dot)
501             {
502                 name = first_dot+1;
503                 name_len = strlen(name);
504             }
505             second_dot = strchr(name, '.');
506             if (suffix_allowed && second_dot)
507             {
508                 name_len = second_dot - name;
509             }
510             if (name_len < sizeof(namez)-1)
511             {
512                 memcpy(namez, name, name_len);
513                 namez[name_len] = '\0';
514                 if (!yaz_matchstr(namez, e_v->name))
515                     break;
516             }
517             /* for case 'a.b' we have to check 'a' as well */
518             if (prefix_allowed && suffix_allowed && first_dot && !second_dot)
519             {
520                 name = e_i->name;
521                 name_len = first_dot - name;
522                 if (name_len < sizeof(namez)-1)
523                 {
524                     memcpy(namez, name, name_len);
525                     namez[name_len] = '\0';
526                     if (!yaz_matchstr(namez, e_v->name))
527                         break;
528                 }
529             }
530         }
531         if (!e_v)
532         {
533             yaz_log(YLOG_WARN, "The following setting is unrecognized: %s",
534                     e_i->name);
535             errors++;
536         }
537     }
538     return errors;
539 }
540
541 /*
542  * Local variables:
543  * c-basic-offset: 4
544  * c-file-style: "Stroustrup"
545  * indent-tabs-mode: nil
546  * End:
547  * vim: shiftwidth=4 tabstop=8 expandtab
548  */
549