X-Git-Url: http://git.indexdata.com/?p=idzebra-moved-to-github.git;a=blobdiff_plain;f=util%2Fres.c;h=efb6473806a4dc26c503fee9d13c204e9566f855;hp=571064852cc8e9b6f39552c5787fd41ddbe17984;hb=96e4c5479e111511f5df3531b6648931251b9e5d;hpb=bb761dd62f7718bb3040cd146ca5a2de40544cdf diff --git a/util/res.c b/util/res.c index 5710648..efb6473 100644 --- a/util/res.c +++ b/util/res.c @@ -1,99 +1,72 @@ -/* - * Copyright (C) 1994, Index Data I/S - * All rights reserved. - * Sebastian Hammer, Adam Dickmeiss - * - * $Log: res.c,v $ - * Revision 1.22 1998-01-12 15:04:32 adam - * Removed exit - call. - * - * Revision 1.21 1997/11/18 10:04:03 adam - * Function res_trav returns number of 'hits'. - * - * Revision 1.20 1997/10/31 12:39:15 adam - * Resouce name can be terminated with either white-space or colon. - * - * Revision 1.19 1997/10/27 14:27:59 adam - * Fixed memory leak. - * - * Revision 1.18 1997/09/17 12:19:24 adam - * Zebra version corresponds to YAZ version 1.4. - * Changed Zebra server so that it doesn't depend on global common_resource. - * - * Revision 1.17 1997/09/09 13:38:19 adam - * Partial port to WIN95/NT. - * - * Revision 1.16 1996/10/29 13:47:49 adam - * Implemented res_get_match. Updated to use zebrautl instead of alexpath. - * - * Revision 1.15 1996/05/22 08:23:43 adam - * Bug fix: trailing blanks in resource values where not removed. - * - * Revision 1.14 1996/04/26 11:51:20 adam - * Resource names are matched by the yaz_matchstr routine instead of strcmp. - * - * Revision 1.13 1995/09/04 12:34:05 adam - * Various cleanup. YAZ util used instead. - * - * Revision 1.12 1995/01/24 16:40:32 adam - * Bug fix. - * - * Revision 1.11 1994/10/05 16:54:52 adam - * Minor changes. - * - * Revision 1.10 1994/10/05 10:47:31 adam - * Small bug fix. - * - * Revision 1.9 1994/09/16 14:41:12 quinn - * Added log warning to res_get_def - * - * Revision 1.8 1994/09/16 14:37:12 quinn - * added res_get_def - * - * Revision 1.7 1994/09/06 13:01:03 quinn - * Removed const from declaration of res_get - * - * Revision 1.6 1994/09/01 17:45:14 adam - * Work on resource manager. - * - * Revision 1.5 1994/08/18 11:02:28 adam - * Implementation of res_write. - * - * Revision 1.4 1994/08/18 10:02:01 adam - * Module alexpath moved from res.c to alexpath.c. Minor changes in res-test.c - * - * Revision 1.3 1994/08/18 09:43:51 adam - * Development of resource manager. Only missing is res_write. - * - * Revision 1.2 1994/08/18 08:23:26 adam - * Res.c now use handles. xmalloc defines xstrdup. - * - * Revision 1.1 1994/08/17 15:34:23 adam - * Initial version of resource manager. - * - */ +/* This file is part of the Zebra server. + Copyright (C) 1994-2011 Index Data + +Zebra is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. + +Zebra is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +*/ + +#if HAVE_CONFIG_H +#include +#endif #include #include #include #include -#ifdef WINDOWS +#ifdef WIN32 #include -#else +#endif +#if HAVE_UNISTD_H #include #endif -#include -#include +#include +#include +#include + +#define YLOG_RES 0 + +struct res_entry { + char *name; + char *value; + struct res_entry *next; +}; + +struct res_struct { + int ref_count; + struct res_entry *first, *last; + Res def_res; + Res over_res; +}; + +static Res res_incref(Res r) +{ + if (r) + r->ref_count++; + return r; +} -static struct res_entry *add_entry (Res r) +static struct res_entry *add_entry(Res r) { struct res_entry *resp; if (!r->first) - resp = r->last = r->first = xmalloc (sizeof(*resp)); + resp = r->last = r->first = + (struct res_entry *) xmalloc(sizeof(*resp)); else { - resp = xmalloc (sizeof(*resp)); + resp = (struct res_entry *) xmalloc(sizeof(*resp)); r->last->next = resp; r->last = resp; } @@ -101,243 +74,324 @@ static struct res_entry *add_entry (Res r) return resp; } -static void reread (Res r) +static char *xstrdup_env(const char *src) { - struct res_entry *resp; - char *line; - char *val_buf; - int val_size, val_max = 256; - char fr_buf[1024]; - FILE *fr; + int i = 0; + int j = 0; + char *dst; + int env_strlen = 0; + + while (src[i]) + { + if (src[i] == '$' && src[i+1] == '{') + { + char envname[128]; + char *env_val; + int k = 0; + i = i + 2; + while (k < 127 && src[i] && !strchr(":}\n\r\f", src[i])) + envname[k++] = src[i++]; + envname[k] = '\0'; - assert (r); - r->init = 1; + env_val = getenv(envname); + if (env_val) + env_strlen += 1 + strlen(env_val); + else + env_strlen++; + while (src[i] && !strchr("}\n\r\f", src[i])) + i++; + if (src[i] == '}') + i++; + } + else + i++; + } + dst = xmalloc(1 + env_strlen + i); + i = 0; + while (src[i]) + { + if (src[i] == '$' && src[i+1] == '{') + { + char envname[128]; + char *env_val; + int k = 0; + i = i + 2; + while(k < 127 && src[i] && !strchr(":}\n\r\f", src[i])) + envname[k++] = src[i++]; + envname[k] = '\0'; + env_val = getenv(envname); + if (env_val) + { + strcpy(dst+j, env_val); + j += strlen(env_val); + } + else if (src[i] == ':' && src[i+1] == '-') + { + i = i + 2; + while (src[i] && !strchr("}\n\r\f", src[i])) + dst[j++] = src[i++]; + } + while (src[i] && !strchr("}\n\r\f", src[i])) + i++; + if (src[i] == '}') + i++; + } + else + dst[j++] = src[i++]; + } + dst[j] = '\0'; + return dst; +} + +ZEBRA_RES res_read_file(Res r, const char *fname) +{ + FILE *fr; + int errors = 0; - val_buf = xmalloc (val_max); + assert(r); - fr = fopen (r->name, "r"); + fr = fopen(fname, "r"); if (!fr) { - logf (LOG_WARN|LOG_ERRNO, "Cannot open %s", r->name); - return ; + yaz_log(YLOG_WARN|YLOG_ERRNO, "Cannot open `%s'", fname); + errors++; } - while (1) + else { - line = fgets (fr_buf, sizeof(fr_buf)-1, fr); - if (!line) - break; - if (*line == '#') - { - int no = 0; - - while (fr_buf[no] && fr_buf[no] != '\n') - no++; - fr_buf[no] = '\0'; - - resp = add_entry (r); - resp->name = xmalloc (no+1); - resp->value = NULL; - strcpy (resp->name, fr_buf); - } - else + char fr_buf[1024]; + char *line; + int lineno = 1; + WRBUF wrbuf_val = wrbuf_alloc(); + yaz_tok_cfg_t yt = yaz_tok_cfg_create(); + + while ((line = fgets(fr_buf, sizeof(fr_buf)-1, fr))) { - int no = 0; - while (1) + yaz_tok_parse_t tp = yaz_tok_parse_buf(yt, line); + int t = yaz_tok_move(tp); + + if (t == YAZ_TOK_STRING) { - if (fr_buf[no] == 0 || fr_buf[no] == '\n' ) + size_t sz; + struct res_entry *resp; + const char *cp = yaz_tok_parse_string(tp); + const char *cp1 = strchr(cp, ':'); + + if (!cp1) { - no = 0; + yaz_log(YLOG_FATAL, "%s:%d missing colon after '%s'", + fname, lineno, cp); + errors++; break; } - if (strchr (": \t", fr_buf[no])) - break; - no++; - } - if (!no) - continue; - fr_buf[no++] = '\0'; - resp = add_entry (r); - resp->name = xmalloc (no); - strcpy (resp->name, fr_buf); - - while (strchr (" \t", fr_buf[no])) - no++; - val_size = 0; - while (1) - { - if (fr_buf[no] == '\0' || fr_buf[no] == '\n') + resp = add_entry(r); + sz = cp1 - cp; + resp->name = xmalloc(sz + 1); + memcpy(resp->name, cp, sz); + resp->name[sz] = '\0'; + + wrbuf_rewind(wrbuf_val); + + if (cp1[1]) { - while (val_size > 0 && - (val_buf[val_size-1] == ' ' || - val_buf[val_size-1] == '\t')) - val_size--; - val_buf[val_size++] = '\0'; - resp->value = xmalloc (val_size); - strcpy (resp->value, val_buf); - logf (LOG_DEBUG, "(name=%s,value=%s)", - resp->name, resp->value); - break; + /* name:value */ + wrbuf_puts(wrbuf_val, cp1+1); } - else if (fr_buf[no] == '\\' && fr_buf[no+1] == '\n') + else { - line = fgets (fr_buf, sizeof(fr_buf)-1, fr); - if (!line) + /* name: value */ + t = yaz_tok_move(tp); + + if (t != YAZ_TOK_STRING) { - resp->value = xmalloc (val_size); - strcpy (resp->value, val_buf); + resp->value = xstrdup(""); + yaz_log(YLOG_FATAL, "%s:%d missing value after '%s'", + fname, lineno, resp->name); + errors++; break; } - no = 0; + wrbuf_puts(wrbuf_val, yaz_tok_parse_string(tp)); } - else + while ((t=yaz_tok_move(tp)) == YAZ_TOK_STRING) { - val_buf[val_size++] = fr_buf[no++]; - if (val_size+1 >= val_max) - { - char *nb; - - nb = xmalloc (val_max+=1024); - memcpy (nb, val_buf, val_size); - xfree (val_buf); - val_buf = nb; - } + wrbuf_putc(wrbuf_val, ' '); + wrbuf_puts(wrbuf_val, yaz_tok_parse_string(tp)); } + resp->value = xstrdup_env(wrbuf_cstr(wrbuf_val)); + /* printf("name=%s value=%s\n", resp->name, resp->value); */ } - } - } - xfree (val_buf); - fclose (fr); + lineno++; + yaz_tok_parse_destroy(tp); + } + fclose(fr); + yaz_tok_cfg_destroy(yt); + wrbuf_destroy(wrbuf_val); + } + if (errors) + return ZEBRA_FAIL; + return ZEBRA_OK; } -Res res_open (const char *name) +Res res_open(Res def_res, Res over_res) { Res r; -#ifdef WINDOWS - if (access (name, 4)) -#else - if (access (name, R_OK)) -#endif + r = (Res) xmalloc(sizeof(*r)); + + r->ref_count = 1; + r->first = r->last = NULL; + r->def_res = res_incref(def_res); + r->over_res = res_incref(over_res); + return r; +} + +void res_clear(Res r) +{ + struct res_entry *re, *re1; + for (re = r->first; re; re=re1) { - logf (LOG_LOG|LOG_ERRNO, "Cannot access resource file `%s'", name); - return NULL; + if (re->name) + xfree(re->name); + if (re->value) + xfree(re->value); + re1 = re->next; + xfree(re); } - r = xmalloc (sizeof(*r)); - r->init = 0; r->first = r->last = NULL; - r->name = xstrdup (name); - return r; } -void res_close (Res r) +void res_close(Res r) { - assert (r); - if (r->init) + if (r && --(r->ref_count) == 0) { - struct res_entry *re, *re1; - for (re = r->first; re; re=re1) - { - if (re->name) - xfree (re->name); - if (re->value) - xfree (re->value); - re1 = re->next; - xfree (re); - } + res_clear(r); + res_close(r->def_res); + res_close(r->over_res); + xfree(r); } - xfree (r->name); - xfree (r); } -char *res_get (Res r, const char *name) +const char *res_get_prefix(Res r, const char *name, const char *prefix, + const char *def) +{ + const char *v = 0;; + if (prefix) + { + char rname[128]; + + if (strlen(name) + strlen(prefix) >= (sizeof(rname)-2)) + return 0; + strcpy(rname, prefix); + strcat(rname, "."); + strcat(rname, name); + v = res_get(r, rname); + } + if (!v) + v = res_get(r, name); + if (!v) + v = def; + return v; +} + +const char *res_get(Res r, const char *name) { struct res_entry *re; + const char *v; + + if (!r) + return 0; + + v = res_get(r->over_res, name); + if (v) + return v; - assert (r); - if (!r->init) - reread (r); for (re = r->first; re; re=re->next) - if (re->value && !yaz_matchstr (re->name, name)) + if (re->value && !yaz_matchstr(re->name, name)) return re->value; - return NULL; + + return res_get(r->def_res, name); } -char *res_get_def (Res r, const char *name, char *def) +const char *res_get_def(Res r, const char *name, const char *def) { - char *t; + const char *t; - if (!(t = res_get (r, name))) + if (!(t = res_get(r, name))) { - logf (LOG_DEBUG, "CAUTION: Using default resource %s:%s", name, def); + if (def) + yaz_log(YLOG_DEBUG, "Using default resource %s:%s", name, def); return def; } else return t; } -int res_get_match (Res r, const char *name, const char *value, const char *s) +int res_get_match(Res r, const char *name, const char *value, const char *s) { - const char *cn = res_get (r, name); + const char *cn = res_get(r, name); - if (cn && !yaz_matchstr (cn, value)) + if (!cn) + cn = s; + if (cn && !yaz_matchstr(cn, value)) return 1; return 0; } -void res_put (Res r, const char *name, const char *value) +void res_set(Res r, const char *name, const char *value) { struct res_entry *re; - assert (r); - if (!r->init) - reread (r); + assert(r); + if (!value) + return; for (re = r->first; re; re=re->next) - if (re->value && !yaz_matchstr (re->name, name)) + if (re->value && !yaz_matchstr(re->name, name)) { - xfree (re->value); - re->value = xstrdup (value); + xfree(re->value); + re->value = xstrdup_env(value); return; } - re = add_entry (r); - re->name = xstrdup (name); - re->value = xstrdup (value); + re = add_entry(r); + re->name = xstrdup(name); + re->value = xstrdup_env(value); } -int res_trav (Res r, const char *prefix, void *p, - void (*f)(void *p, const char *name, const char *value)) +int res_trav(Res r, const char *prefix, void *p, + void (*f)(void *p, const char *name, const char *value)) { struct res_entry *re; int l = 0; int no = 0; - assert (r); + if (!r) + return 0; + no = res_trav(r->over_res, prefix, p, f); + if (no) + return no; if (prefix) l = strlen(prefix); - if (!r->init) - reread (r); for (re = r->first; re; re=re->next) if (re->value) - if (l==0 || !memcmp (re->name, prefix, l)) + if (l==0 || !memcmp(re->name, prefix, l)) { (*f)(p, re->name, re->value); no++; } + if (!no) + return res_trav(r->def_res, prefix, p, f); return no; } -int res_write (Res r) +ZEBRA_RES res_write_file(Res r, const char *fname) { struct res_entry *re; FILE *fr; - assert (r); - if (!r->init) - reread (r); - fr = fopen (r->name, "w"); + assert(r); + fr = fopen(fname, "w"); if (!fr) { - logf (LOG_FATAL|LOG_ERRNO, "Cannot create %s", r->name); - exit (1); + yaz_log(YLOG_FATAL|YLOG_ERRNO, "Cannot create `%s'", fname); + return ZEBRA_FAIL; } for (re = r->first; re; re=re->next) @@ -346,10 +400,10 @@ int res_write (Res r) int lefts = strlen(re->name)+2; if (!re->value) - fprintf (fr, "%s\n", re->name); + fprintf(fr, "%s\n", re->name); else { - fprintf (fr, "%s: ", re->name); + fprintf(fr, "%s: ", re->name); while (lefts + strlen(re->value+no) > 78) { int i = 20; @@ -363,17 +417,136 @@ int res_write (Res r) if (i<0) ind = no + 78 - lefts; for (i = no; i != ind; i++) - putc (re->value[i], fr); - fprintf (fr, "\\\n"); + putc(re->value[i], fr); + fprintf(fr, "\\\n"); no=ind; lefts = 0; } - fprintf (fr, "%s\n", re->value+no); + fprintf(fr, "%s\n", re->value+no); } } - fclose (fr); - return 0; + fclose(fr); + return ZEBRA_OK; +} + +ZEBRA_RES res_get_int(Res r, const char *name, int *val) +{ + const char *cp = res_get(r, name); + if (cp) + { + if (sscanf(cp, "%d", val) == 1) + return ZEBRA_OK; + yaz_log(YLOG_WARN, "Expected integer for resource %s", name); + } + return ZEBRA_FAIL; } +void res_add(Res r, const char *name, const char *value) +{ + struct res_entry *re; + assert(r); + assert(name); + assert(value); + yaz_log(YLOG_RES, "res_add res=%p, name=%s, value=%s", r, name, value); + re = add_entry(r); + re->name = xstrdup(name); + re->value = xstrdup_env(value); +} + +void res_dump(Res r, int level) +{ + struct res_entry *re; + + if (!r) + return; + + for (re = r->first; re; re=re->next) { + printf("%*s - %s:='%s'\n",level * 4,"",re->name,re->value); + } + + if (r->def_res) { + printf("%*s DEF ",level * 4,""); + res_dump(r->def_res, level + 1); + } + + if (r->over_res) { + printf("%*s OVER ",level * 4,""); + res_dump(r->over_res, level + 1); + } +} + +int res_check(Res r_i, Res r_v) +{ + struct res_entry *e_i; + int errors = 0; + + for (e_i = r_i->first; e_i; e_i = e_i->next) + { + struct res_entry *e_v; + for (e_v = r_v->first; e_v; e_v = e_v->next) + { + int prefix_allowed = 0; + int suffix_allowed = 0; + const char *name = e_i->name; + size_t name_len = strlen(e_i->name); + char namez[32]; + const char *first_dot = 0; + const char *second_dot = 0; + + if (strchr(e_v->value, 'p')) + prefix_allowed = 1; + if (strchr(e_v->value, 's')) + suffix_allowed = 1; + + first_dot = strchr(name, '.'); + if (prefix_allowed && first_dot) + { + name = first_dot+1; + name_len = strlen(name); + } + second_dot = strchr(name, '.'); + if (suffix_allowed && second_dot) + { + name_len = second_dot - name; + } + if (name_len < sizeof(namez)-1) + { + memcpy(namez, name, name_len); + namez[name_len] = '\0'; + if (!yaz_matchstr(namez, e_v->name)) + break; + } + /* for case 'a.b' we have to check 'a' as well */ + if (prefix_allowed && suffix_allowed && first_dot && !second_dot) + { + name = e_i->name; + name_len = first_dot - name; + if (name_len < sizeof(namez)-1) + { + memcpy(namez, name, name_len); + namez[name_len] = '\0'; + if (!yaz_matchstr(namez, e_v->name)) + break; + } + } + } + if (!e_v) + { + yaz_log(YLOG_WARN, "The following setting is unrecognized: %s", + e_i->name); + errors++; + } + } + return errors; +} + +/* + * Local variables: + * c-basic-offset: 4 + * c-file-style: "Stroustrup" + * indent-tabs-mode: nil + * End: + * vim: shiftwidth=4 tabstop=8 expandtab + */