recctrl/recctrl.c

   1 /* $Id: recctrl.c,v 1.7 2004-09-27 10:44:50 adam Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
   3    Index Data Aps
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #include <string.h>
  27 #include <dlfcn.h>
  28
  29 #include <direntz.h>
  30 #include <zebrautl.h>
  31 #include <recctrl.h>
  32
  33 struct recTypeClass {
  34     RecType recType;
  35     struct recTypeClass *next;
  36     void *module_handle;
  37 };
  38
  39 struct recTypeInstance {
  40     RecType recType;
  41     struct recTypeInstance *next;
  42     int init_flag;
  43     void *clientData;
  44 };
  45
  46 struct recTypes {
  47     data1_handle dh;
  48     struct recTypeInstance *entries;
  49 };
  50
  51 static void recTypeClass_add (struct recTypeClass **rts, RecType *rt,
  52                               NMEM nmem, void *module_handle);
  53
  54 RecTypeClass recTypeClass_create (Res res, NMEM nmem)
  55 {
  56     struct recTypeClass *rts = 0;
  57     const char *module_path = res_get_def(res, "modulePath",
  58                                           DEFAULT_MODULE_PATH);
  59
  60     extern RecType idzebra_filter_grs_sgml[];
  61     recTypeClass_add (&rts, idzebra_filter_grs_sgml, nmem, 0);
  62 #ifdef IDZEBRA_STATIC_TEXT
  63     extern RecType idzebra_filter_text[];
  64     recTypeClass_add (&rts, idzebra_filter_text, nmem, 0);
  65 #endif
  66 #ifdef IDZEBRA_STATIC_GRS_XML
  67     extern RecType idzebra_filter_grs_xml[];
  68     recTypeClass_add (&rts, idzebra_filter_grs_xml, nmem, 0);
  69 #endif
  70 #ifdef IDZEBRA_STATIC_GRS_REGX
  71     extern RecType idzebra_filter_grs_regx[];
  72     recTypeClass_add (&rts, idzebra_filter_grs_regx, nmem, 0);
  73 #endif
  74 #ifdef IDZEBRA_STATIC_GRS_MARC
  75     extern RecType idzebra_filter_grs_marc[];
  76     recTypeClass_add (&rts, idzebra_filter_grs_marc, nmem, 0);
  77 #endif
  78 #ifdef IDZEBRA_STATIC_GRS_PERL
  79     extern RecType idzebra_filter_grs_perl[];
  80     recTypeClass_add (&rts, idzebra_filter_grs_perl, nmem, 0);
  81 #endif
  82 #ifdef IDZEBRA_STATIC_GRS_DANBIB
  83     extern RecType idzebra_filter_grs_danbib[];
  84     recTypeClass_add (&rts, idzebra_filter_grs_danbib, nmem, 0);
  85 #endif
  86
  87     if (module_path)
  88     {
  89         DIR *dir = opendir(module_path);
  90         yaz_log(LOG_LOG, "searching filters in %s", module_path);
  91         if (dir)
  92         {
  93             struct dirent *de;
  94
  95             while ((de = readdir(dir)))
  96             {
  97                 size_t dlen = strlen(de->d_name);
  98                 if ((de->d_type == DT_REG || de->d_type == DT_LNK)
  99                     && dlen >= 5 &&
 100                     !memcmp(de->d_name, "mod-", 4) &&
 101                     !strcmp(de->d_name + dlen - 3, ".so"))
 102                 {
 103                     void *mod_p, *fl;
 104                     char fname[FILENAME_MAX*2+1];
 105                     sprintf(fname, "%.*s/%.*s",
 106                             FILENAME_MAX, module_path,
 107                             FILENAME_MAX, de->d_name);
 108                     mod_p = dlopen(fname, RTLD_NOW|RTLD_GLOBAL);
 109                     if (mod_p && (fl = dlsym(mod_p, "idzebra_filter")))
 110                     {
 111                         yaz_log(LOG_LOG, "Loaded filter module %s", fname);
 112                         recTypeClass_add(&rts, fl, nmem, mod_p);
 113                     }
 114                     else if (mod_p)
 115                     {
 116                         const char *err = dlerror();
 117                         yaz_log(LOG_WARN, "dlsym failed %s %s",
 118                                 fname, err ? err : "none");
 119                         dlclose(mod_p);
 120                     }
 121                     else
 122                     {
 123                         const char *err = dlerror();
 124                         yaz_log(LOG_WARN, "dlopen failed %s %s",
 125                                 fname, err ? err : "none");
 126
 127                     }
 128                 }
 129             }
 130             closedir(dir);
 131         }
 132     }
 133     return rts;
 134 }
 135
 136 static void recTypeClass_add (struct recTypeClass **rts, RecType *rt,
 137                               NMEM nmem, void *module_handle)
 138 {
 139     while (*rt)
 140     {
 141         struct recTypeClass *r = (struct recTypeClass *)
 142             nmem_malloc (nmem, sizeof(*r));
 143
 144         r->next = *rts;
 145         *rts = r;
 146
 147         yaz_log(LOG_LOG, "Adding filter %s", (*rt)->name);
 148         r->module_handle = module_handle;
 149         module_handle = 0; /* so that we only store module_handle once */
 150         r->recType = *rt;
 151
 152         rt++;
 153     }
 154 }
 155
 156 void recTypeClass_info(RecTypeClass rtc, void *cd,
 157                        void (*cb)(void *cd, const char *s))
 158 {
 159     for (; rtc; rtc = rtc->next)
 160         (*cb)(cd, rtc->recType->name);
 161 }
 162
 163 void recTypeClass_destroy(RecTypeClass rtc)
 164 {
 165     for (; rtc; rtc = rtc->next)
 166     {
 167         if (rtc->module_handle)
 168             dlclose(rtc->module_handle);
 169     }
 170 }
 171
 172 RecTypes recTypes_init(RecTypeClass rtc, data1_handle dh)
 173 {
 174     RecTypes rts = (RecTypes) nmem_malloc(data1_nmem_get(dh), sizeof(*rts));
 175
 176     struct recTypeInstance **rti = &rts->entries;
 177
 178     rts->dh = dh;
 179
 180     for (; rtc; rtc = rtc->next)
 181     {
 182         *rti = nmem_malloc(data1_nmem_get(dh), sizeof(**rti));
 183         (*rti)->recType = rtc->recType;
 184         (*rti)->init_flag = 0;
 185         rti = &(*rti)->next;
 186     }
 187     *rti = 0;
 188     return rts;
 189 }
 190
 191 void recTypes_destroy (RecTypes rts)
 192 {
 193     struct recTypeInstance *rti;
 194
 195     for (rti = rts->entries; rti; rti = rti->next)
 196     {
 197         if (rti->init_flag)
 198             (*(rti->recType)->destroy)(rti->clientData);
 199     }
 200 }
 201
 202 RecType recType_byName (RecTypes rts, Res res, const char *name,
 203                         void **clientDataP)
 204 {
 205     struct recTypeInstance *rti;
 206
 207     for (rti = rts->entries; rti; rti = rti->next)
 208     {
 209         size_t slen = strlen(rti->recType->name);
 210         if (!strncmp (rti->recType->name, name, slen)
 211             && (name[slen] == '\0' || name[slen] == '.'))
 212         {
 213             if (!rti->init_flag)
 214             {
 215                 rti->init_flag = 1;
 216                 rti->clientData =
 217                     (*(rti->recType)->init)(res, rti->recType);
 218             }
 219             *clientDataP = rti->clientData;
 220             if (name[slen])
 221                 slen++;  /* skip . */
 222
 223             if (rti->recType->config)
 224                 (*(rti->recType)->config)(rti->clientData, res, name+slen);
 225             return rti->recType;
 226         }
 227     }
 228     return 0;
 229 }
 230