X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=util%2Fres.c;h=417cc0a534e9dca47fbac3c2d3c635938d9f57f7;hb=3d3d0cebd23fa527a7e9d5d728e3c744acb37580;hp=a5c6c133b115fd24a597cf3d2c6aeb043364866a;hpb=ceeaeb9e63dfb8d03a084bbbc71e382d63251089;p=idzebra-moved-to-github.git diff --git a/util/res.c b/util/res.c index a5c6c13..417cc0a 100644 --- a/util/res.c +++ b/util/res.c @@ -1,237 +1,430 @@ -/* - * Copyright (C) 1994, Index Data I/S - * All rights reserved. - * Sebastian Hammer, Adam Dickmeiss - * - * $Log: res.c,v $ - * 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. - * - */ +/* $Id: res.c,v 1.45 2005-09-13 11:51:11 adam Exp $ + Copyright (C) 1995-2005 + Index Data ApS + +This file is part of the Zebra server. + +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 Zebra; see the file LICENSE.zebra. If not, write to the +Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. +*/ + #include #include #include -#include +#include +#ifdef WIN32 +#include +#endif +#if HAVE_UNISTD_H +#include +#endif + +#include +#include + +struct res_entry { + char *name; + char *value; + struct res_entry *next; +}; -const char *alex_path (const char *name) +struct res_struct { + struct res_entry *first, *last; + Res def_res; + Res over_res; +}; + +static struct res_entry *add_entry(Res r) { - static char path[256]; - char *alex_prefix; + struct res_entry *resp; - if (!(alex_prefix = getenv ("ALEXPREFIX"))) - alex_prefix = "./"; - - if (*alex_prefix && alex_prefix[strlen(alex_prefix)-1] == '/') - sprintf (path, "%s%s", alex_prefix, name); + if (!r->first) + resp = r->last = r->first = + (struct res_entry *) xmalloc(sizeof(*resp)); else - sprintf (path, "%s/%s", alex_prefix, name); - return path; + { + resp = (struct res_entry *) xmalloc(sizeof(*resp)); + r->last->next = resp; + r->last = resp; + } + resp->next = NULL; + return resp; } -static void reread (Res r) +static char *xstrdup_env(const char *src) +{ + 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'; + + 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) { struct res_entry *resp; char *line; char *val_buf; - int val_size, val_max = 1024; - char path[256]; + int val_size, val_max = 256; char fr_buf[1024]; FILE *fr; - r->init = 1; + assert(r); - val_buf = xmalloc (val_max); - - strcpy (path, alex_path(r->name)); - - fr = fopen (path, "r"); + fr = fopen(fname, "r"); if (!fr) { - log (LOG_FATAL|LOG_ERRNO, "cannot open %s", path); - exit (1); + yaz_log(YLOG_WARN|YLOG_ERRNO, "Cannot open `%s'", fname); + return ZEBRA_FAIL; } + val_buf = (char*) xmalloc(val_max); while (1) { - line = fgets (fr_buf, 1023, fr); + 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'; - - if (!r->first) - resp = r->last = r->first = xmalloc (sizeof(*resp)); - else - { - resp = xmalloc (sizeof(*resp)); - r->last->next = resp; - r->last = resp; - } - resp->next = NULL; - resp->name = xmalloc (no+1); - resp->value = NULL; - strcpy (resp->name, fr_buf); - } - else + if (*line != '#') { int no = 0; while (1) { if (fr_buf[no] == 0 || fr_buf[no] == '\n' ) { - no = -1; + no = 0; break; } - if (fr_buf[no] == ':') + if (strchr(": \t", fr_buf[no])) break; no++; } - if (no < 0) + if (!no) continue; fr_buf[no++] = '\0'; - if (!r->first) - resp = r->last = r->first = xmalloc (sizeof(*resp)); - else - { - resp = xmalloc (sizeof(*resp)); - r->last->next = resp; - r->last = resp; - } - resp->next = NULL; - resp->name = xmalloc (no); - strcpy (resp->name, fr_buf); + resp = add_entry(r); + resp->name = (char*) xmalloc(no); + strcpy(resp->name, fr_buf); - while (fr_buf[no] == ' ') + while (strchr(" \t", fr_buf[no])) no++; val_size = 0; while (1) { - if (fr_buf[no] == '\0' || fr_buf[no] == '\n') + if (fr_buf[no] == '\0' || strchr("\n\r\f", fr_buf[no])) { - val_buf[val_size++] = '\0'; - resp->value = xmalloc (val_size); - strcpy (resp->value, val_buf); - log (LOG_DEBUG, "(name=%s,value=%s)", + while (val_size > 0 && + (val_buf[val_size-1] == ' ' || + val_buf[val_size-1] == '\t')) + val_size--; + val_buf[val_size] = '\0'; + resp->value = xstrdup_env(val_buf); + yaz_log(YLOG_DEBUG, "(name=%s,value=%s)", resp->name, resp->value); break; } - else if (fr_buf[no] == '\\' && fr_buf[no+1] == '\n') + else if (fr_buf[no] == '\\' && strchr("\n\r\f", fr_buf[no+1])) { - line = fgets (fr_buf, 1023, fr); + line = fgets(fr_buf, sizeof(fr_buf)-1, fr); if (!line) { - resp->value = xmalloc (val_size); - strcpy (resp->value, val_buf); + val_buf[val_size] = '\0'; + resp->value = xstrdup_env(val_buf); break; } no = 0; } else + { val_buf[val_size++] = fr_buf[no++]; + if (val_size+1 >= val_max) + { + char *nb; + + nb = (char*) xmalloc(val_max+=1024); + memcpy(nb, val_buf, val_size); + xfree(val_buf); + val_buf = nb; + } + } } } } - xfree (val_buf); - fclose (fr); + xfree(val_buf); + fclose(fr); + return ZEBRA_OK; } -Res res_open (const char *name) +Res res_open(Res def_res, Res over_res) { - Res r = xmalloc (sizeof(*r)); - r->init = 0; - r->name = xstrdup (name); + Res r; + + r = (Res) xmalloc(sizeof(*r)); + r->first = r->last = NULL; + r->def_res = def_res; + r->over_res = over_res; return r; } -void res_close (Res r) +void res_clear(Res r) { - if (r->init) + struct res_entry *re, *re1; + for (re = r->first; re; re=re1) { - 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); - } + if (re->name) + xfree(re->name); + if (re->value) + xfree(re->value); + re1 = re->next; + xfree(re); } - xfree (r); + r->first = r->last = NULL; } -const char *res_get (Res r, const char *name) +void res_close(Res r) +{ + if (!r) + return; + res_clear(r); + + xfree(r); +} + +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; - if (!r->init) - reread (r); + const char *v; + + if (!r) + return 0; + v = res_get(r->over_res, name); + if (v) + return v; + for (re = r->first; re; re=re->next) - if (re->value && !strcmp (re->name, name)) + if (re->value && !yaz_matchstr(re->name, name)) return re->value; - return NULL; + + return res_get(r->def_res, name); } -void res_put (Res r, const char *name, const char *value) +const char *res_get_def(Res r, const char *name, const char *def) +{ + const char *t; + + if (!(t = res_get(r, name))) + { + yaz_log(YLOG_DEBUG, "CAUTION: 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) +{ + const char *cn = res_get(r, name); + + if (!cn) + cn = s; + if (cn && !yaz_matchstr(cn, value)) + return 1; + return 0; +} + +void res_set(Res r, const char *name, const char *value) { struct res_entry *re; - if (!r->init) - reread (r); + assert(r); for (re = r->first; re; re=re->next) - if (re->value && !strcmp (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; } - if (!r->first) - re = r->last = r->first = xmalloc (sizeof(*re)); - else - { - re = xmalloc (sizeof(*re)); - r->last->next = re; - r->last = re; - } - re->next = NULL; - re->name = xstrdup (name); - re->value = xstrdup (value); + re = add_entry(r); + re->name = xstrdup(name); + re->value = xstrdup_env(value); } -void res_trav (Res r, const char *prefix, - void (*f)(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; + + 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)) - (*f)(re->name, re->value); + 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) { - if (!r->init) - reread (r); - return 0; -} + struct res_entry *re; + FILE *fr; + + assert(r); + fr = fopen(fname, "w"); + if (!fr) + { + yaz_log(YLOG_FATAL|YLOG_ERRNO, "Cannot create `%s'", fname); + exit(1); + } + for (re = r->first; re; re=re->next) + { + int no = 0; + int lefts = strlen(re->name)+2; + if (!re->value) + fprintf(fr, "%s\n", re->name); + else + { + fprintf(fr, "%s: ", re->name); + while (lefts + strlen(re->value+no) > 78) + { + int i = 20; + int ind = no+ 78-lefts; + while (--i >= 0) + { + if (re->value[ind] == ' ') + break; + --ind; + } + if (i<0) + ind = no + 78 - lefts; + for (i = no; i != ind; i++) + putc(re->value[i], fr); + fprintf(fr, "\\\n"); + no=ind; + lefts = 0; + } + fprintf(fr, "%s\n", re->value+no); + } + } + 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; +}