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 const char *res_get_named(Res r, const char *resName, const char *name)
 336 {
 337     //This part relies on dynamic stack allocation cus I'm lazy
 338     //resName.name = strlen(resName) + 1 + strlen(name) + (space for \0)
 339     unsigned int resLen = strlen(resName) + strlen(name) + 2;
 340     char wholeName[resLen];
 341     memset(wholeName, NULL, resLen);
 342
 343     strcat(wholeName, resName);
 344     strcat(wholeName, ".");
 345     strcat(wholeName, name);
 346
 347     const char *nr = res_get(r, wholeName);
 348     return nr;
 349 }
 350
 351 void res_set(Res r, const char *name, const char *value)
 352 {
 353     struct res_entry *re;
 354     assert(r);
 355
 356     if (!value)
 357         return;
 358     for (re = r->first; re; re=re->next)
 359         if (re->value && !yaz_matchstr(re->name, name))
 360         {
 361             xfree(re->value);
 362             re->value = xstrdup_env(value);
 363             return;
 364         }
 365     re = add_entry(r);
 366     re->name = xstrdup(name);
 367     re->value = xstrdup_env(value);
 368 }
 369
 370 int res_trav(Res r, const char *prefix, void *p,
 371              void (*f)(void *p, const char *name, const char *value))
 372 {
 373     struct res_entry *re;
 374     int l = 0;
 375     int no = 0;
 376
 377     if (!r)
 378         return 0;
 379     no = res_trav(r->over_res, prefix, p, f);
 380     if (no)
 381         return no;
 382     if (prefix)
 383         l = strlen(prefix);
 384     for (re = r->first; re; re=re->next)
 385         if (re->value)
 386             if (l==0 || !memcmp(re->name, prefix, l))
 387             {
 388                 (*f)(p, re->name, re->value);
 389                 no++;
 390             }
 391     if (!no)
 392         return res_trav(r->def_res, prefix, p, f);
 393     return no;
 394 }
 395
 396
 397 ZEBRA_RES res_write_file(Res r, const char *fname)
 398 {
 399     struct res_entry *re;
 400     FILE *fr;
 401
 402     assert(r);
 403     fr = fopen(fname, "w");
 404     if (!fr)
 405     {
 406         yaz_log(YLOG_FATAL|YLOG_ERRNO, "Cannot create `%s'", fname);
 407         return ZEBRA_FAIL;
 408     }
 409
 410     for (re = r->first; re; re=re->next)
 411     {
 412         int no = 0;
 413         int lefts = strlen(re->name)+2;
 414
 415         if (!re->value)
 416             fprintf(fr, "%s\n", re->name);
 417         else
 418         {
 419             fprintf(fr, "%s: ", re->name);
 420             while (lefts + strlen(re->value+no) > 78)
 421             {
 422                 int i = 20;
 423                 int ind = no+ 78-lefts;
 424                 while (--i >= 0)
 425                 {
 426                     if (re->value[ind] == ' ')
 427                         break;
 428                     --ind;
 429                 }
 430                 if (i<0)
 431                     ind = no + 78 - lefts;
 432                 for (i = no; i != ind; i++)
 433                     putc(re->value[i], fr);
 434                 fprintf(fr, "\\\n");
 435                 no=ind;
 436                 lefts = 0;
 437             }
 438             fprintf(fr, "%s\n", re->value+no);
 439         }
 440     }
 441     fclose(fr);
 442     return ZEBRA_OK;
 443 }
 444
 445 ZEBRA_RES res_get_int(Res r, const char *name, int *val)
 446 {
 447     const char *cp = res_get(r, name);
 448     if (cp)
 449     {
 450         if (sscanf(cp, "%d", val) == 1)
 451             return ZEBRA_OK;
 452         yaz_log(YLOG_WARN, "Expected integer for resource %s", name);
 453     }
 454     return ZEBRA_FAIL;
 455 }
 456
 457
 458 void res_add(Res r, const char *name, const char *value)
 459 {
 460     struct res_entry *re;
 461     assert(r);
 462     assert(name);
 463     assert(value);
 464     yaz_log(YLOG_RES, "res_add res=%p, name=%s, value=%s", r, name, value);
 465     re = add_entry(r);
 466     re->name = xstrdup(name);
 467     re->value = xstrdup_env(value);
 468 }
 469
 470 void res_dump(Res r, int level)
 471 {
 472     struct res_entry *re;
 473
 474     if (!r)
 475         return;
 476
 477     for (re = r->first; re; re=re->next) {
 478         printf("%*s - %s:='%s'\n",level * 4,"",re->name,re->value);
 479     }
 480
 481     if (r->def_res) {
 482         printf("%*s DEF ",level * 4,"");
 483         res_dump(r->def_res, level + 1);
 484     }
 485
 486     if (r->over_res) {
 487         printf("%*s OVER ",level * 4,"");
 488         res_dump(r->over_res, level + 1);
 489     }
 490 }
 491
 492 int res_check(Res r_i, Res r_v)
 493 {
 494     struct res_entry *e_i;
 495     int errors = 0;
 496
 497     for (e_i = r_i->first; e_i; e_i = e_i->next)
 498     {
 499         struct res_entry *e_v;
 500         for (e_v = r_v->first; e_v; e_v = e_v->next)
 501         {
 502             int prefix_allowed = 0;
 503             int suffix_allowed = 0;
 504             const char *name = e_i->name;
 505             size_t name_len = strlen(e_i->name);
 506             char namez[32];
 507             const char *first_dot = 0;
 508             const char *second_dot = 0;
 509
 510             if (strchr(e_v->value, 'p'))
 511                 prefix_allowed = 1;
 512             if (strchr(e_v->value, 's'))
 513                 suffix_allowed = 1;
 514
 515             first_dot = strchr(name, '.');
 516             if (prefix_allowed && first_dot)
 517             {
 518                 name = first_dot+1;
 519                 name_len = strlen(name);
 520             }
 521             second_dot = strchr(name, '.');
 522             if (suffix_allowed && second_dot)
 523             {
 524                 name_len = second_dot - name;
 525             }
 526             if (name_len < sizeof(namez)-1)
 527             {
 528                 memcpy(namez, name, name_len);
 529                 namez[name_len] = '\0';
 530                 if (!yaz_matchstr(namez, e_v->name))
 531                     break;
 532             }
 533             /* for case 'a.b' we have to check 'a' as well */
 534             if (prefix_allowed && suffix_allowed && first_dot && !second_dot)
 535             {
 536                 name = e_i->name;
 537                 name_len = first_dot - name;
 538                 if (name_len < sizeof(namez)-1)
 539                 {
 540                     memcpy(namez, name, name_len);
 541                     namez[name_len] = '\0';
 542                     if (!yaz_matchstr(namez, e_v->name))
 543                         break;
 544                 }
 545             }
 546         }
 547         if (!e_v)
 548         {
 549             yaz_log(YLOG_WARN, "The following setting is unrecognized: %s",
 550                     e_i->name);
 551             errors++;
 552         }
 553     }
 554     return errors;
 555 }
 556
 557 /*
 558  * Local variables:
 559  * c-basic-offset: 4
 560  * c-file-style: "Stroustrup"
 561  * indent-tabs-mode: nil
 562  * End:
 563  * vim: shiftwidth=4 tabstop=8 expandtab
 564  */
 565