util/res.c

   1 /* This file is part of the Zebra server.
   2    Copyright (C) 1994-2009 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  * indent-tabs-mode: nil
 545  * End:
 546  * vim: shiftwidth=4 tabstop=8 expandtab
 547  */
 548