Lowered some logging to debug
[pazpar2-moved-to-github.git] / src / database.c
1 /* This file is part of Pazpar2.
2    Copyright (C) 2006-2012 Index Data
3
4 Pazpar2 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 Pazpar2 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 #if HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <assert.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #include <yaz/log.h>
28 #include <yaz/nmem.h>
29
30 #include "ppmutex.h"
31 #include "session.h"
32 #include "host.h"
33 #include "pazpar2_config.h"
34 #include "settings.h"
35 #include "http.h"
36 #include "database.h"
37
38 #include <sys/types.h>
39
40 enum pazpar2_database_criterion_type {
41     PAZPAR2_STRING_MATCH,
42     PAZPAR2_SUBSTRING_MATCH
43 };
44
45 struct database_criterion_value {
46     char *value;
47     struct database_criterion_value *next;
48 };
49
50 struct database_criterion {
51     char *name;
52     enum pazpar2_database_criterion_type type;
53     struct database_criterion_value *values;
54     struct database_criterion *next;
55 };
56
57 struct database *new_database(const char *id, NMEM nmem)
58 {
59     return new_database_inherit_settings(id, nmem, 0);
60 }
61 struct database *new_database_inherit_settings(const char *id, NMEM nmem, struct settings_array *service_settings)
62 {
63     struct database *db;
64     struct setting *idset;
65
66     db = nmem_malloc(nmem, sizeof(*db));
67     db->id = nmem_strdup(nmem, id);
68     db->next = 0;
69
70     if (service_settings && service_settings->num_settings > 0) {
71         yaz_log(YLOG_DEBUG, "copying settings from service to database %s settings", db->id);
72         db->num_settings = service_settings->num_settings;
73         db->settings = nmem_malloc(nmem, sizeof(*db->settings) * db->num_settings);
74         // Initialize database settings with service settings
75         memcpy(db->settings, service_settings->settings,  sizeof(*db->settings) * db->num_settings);
76     }
77     else {
78         yaz_log(YLOG_DEBUG, "No service settings to database %s ", db->id);
79         db->num_settings = PZ_MAX_EOF;
80         db->settings = nmem_malloc(nmem, sizeof(*db->settings) * db->num_settings);
81         memset(db->settings, 0, sizeof(*db->settings) * db->num_settings);
82     }
83     idset = nmem_malloc(nmem, sizeof(*idset));
84     idset->precedence = 0;
85     idset->name = "pz:id";
86     idset->target = idset->value = db->id;
87     idset->next = db->settings[PZ_ID];
88     db->settings[PZ_ID] = idset;
89
90     return db;
91 }
92
93 // Return a database structure by ID. Load and add to list if necessary
94 // new==1 just means we know it's not in the list
95 struct database *create_database_for_service(const char *id,
96                                              struct conf_service *service)
97 {
98     struct database *p;
99     for (p = service->databases; p; p = p->next)
100         if (!strcmp(p->id, id))
101             return p;
102     
103     yaz_log(YLOG_DEBUG, "new database %s under service %s", id, service->id);
104     p = new_database_inherit_settings(id, service->nmem, service->settings);
105     p->next = service->databases;
106     service->databases = p;
107
108     return p;
109 }
110
111 // This whole session_grep database thing should be moved elsewhere
112
113 int match_zurl(const char *zurl, const char *pattern)
114 {
115     int len;
116
117     if (!strcmp(pattern, "*"))
118         return 1;
119     else if (!strncmp(pattern, "*/", 2))   // host wildcard.. what the heck is that for?
120     {
121         char *db = strchr(zurl, '/');
122         if (!db)
123             return 0;
124         if (!strcmp(pattern + 2, db))
125             return 1;
126         else
127             return 0;
128     }
129     else if (*(pattern + (len = strlen(pattern) - 1)) == '*')  // db wildcard
130     {
131         if (!strncmp(pattern, zurl, len))
132             return 1;
133         else
134             return 0;
135     }
136     else if (!strcmp(pattern, zurl))
137         return 1;
138     else
139         return 0;
140 }
141
142 // This will be generalized at some point
143 static int match_criterion(struct setting **settings,
144                            struct conf_service *service, 
145                            struct database_criterion *c)
146 {
147     int offset = settings_lookup_offset(service, c->name);
148     struct database_criterion_value *v;
149
150     if (offset < 0)
151     {
152         yaz_log(YLOG_WARN, "Criterion not found: %s", c->name);
153         return 0;
154     }
155     if (!settings[offset])
156         return 0;
157     for (v = c->values; v; v = v->next)
158     {
159         if (c->type == PAZPAR2_STRING_MATCH)
160         {
161             if (offset == PZ_ID)
162             {
163                 if (match_zurl(settings[offset]->value, v->value))
164                     break;
165             }
166             else 
167             {
168                 if (!strcmp(settings[offset]->value, v->value))
169                     break;
170             }
171         }            
172         else if (c->type == PAZPAR2_SUBSTRING_MATCH)
173         {
174             if (strstr(settings[offset]->value, v->value))
175                 break;
176         }
177     }
178     if (v)
179         return 1;
180     else
181         return 0;
182 }
183
184 // parses crit1=val1,crit2=val2|val3,...
185 static struct database_criterion *create_database_criterion(NMEM m,
186                                                             const char *buf)
187 {
188     struct database_criterion *res = 0;
189     char **values;
190     int num;
191     int i;
192
193     if (!buf || !*buf)
194         return 0;
195     nmem_strsplit(m, ",", buf,  &values, &num);
196     for (i = 0; i < num; i++)
197     {
198         char **subvalues;
199         int subnum;
200         int subi;
201         struct database_criterion *new = nmem_malloc(m, sizeof(*new));
202         char *eq;
203         if ((eq = strchr(values[i], '=')))
204             new->type = PAZPAR2_STRING_MATCH;
205         else if ((eq = strchr(values[i], '~')))
206             new->type = PAZPAR2_SUBSTRING_MATCH;
207         else
208         {
209             yaz_log(YLOG_WARN, "Missing equal-sign/tilde in filter");
210             return 0;
211         }
212         *(eq++) = '\0';
213         new->name = values[i];
214         nmem_strsplit(m, "|", eq, &subvalues, &subnum);
215         new->values = 0;
216         for (subi = 0; subi < subnum; subi++)
217         {
218             struct database_criterion_value *newv
219                 = nmem_malloc(m, sizeof(*newv));
220             newv->value = subvalues[subi];
221             newv->next = new->values;
222             new->values = newv;
223         }
224         new->next = res;
225         res = new;
226     }
227     return res;
228 }
229
230 static int database_match_criteria(struct setting **settings,
231                                    struct conf_service *service,
232                                    struct database_criterion *cl)
233 {
234     for (; cl; cl = cl->next)
235         if (!match_criterion(settings, service, cl))
236             break;
237     if (cl) // one of the criteria failed to match -- skip this db
238         return 0;
239     else
240         return 1;
241 }
242
243 // Cycles through databases, calling a handler function on the ones for
244 // which all criteria matched.
245 int session_grep_databases(struct session *se, const char *filter,
246                            void (*fun)(struct session *se, struct session_database *db))
247 {
248     struct session_database *p;
249     NMEM nmem = nmem_create();
250     int i = 0;
251     struct database_criterion *cl = create_database_criterion(nmem, filter);
252
253     for (p = se->databases; p; p = p->next)
254     {
255         if (p->settings && p->settings[PZ_ALLOW] && *p->settings[PZ_ALLOW]->value == '0')
256             continue;
257         if (!p->settings[PZ_NAME])
258             continue;
259         if (database_match_criteria(p->settings, se->service, cl))
260         {
261             (*fun)(se, p);
262             i++;
263         }
264     }
265     nmem_destroy(nmem);
266     return i;
267 }
268
269 int predef_grep_databases(void *context, struct conf_service *service,
270                           void (*fun)(void *context, struct database *db))
271 {
272     struct database *p;
273     int i = 0;
274
275     for (p = service->databases; p; p = p->next)
276         if (database_match_criteria(p->settings, service, 0))
277         {
278             (*fun)(context, p);
279             i++;
280         }
281     return i;
282 }
283
284 /*
285  * Local variables:
286  * c-basic-offset: 4
287  * c-file-style: "Stroustrup"
288  * indent-tabs-mode: nil
289  * End:
290  * vim: shiftwidth=4 tabstop=8 expandtab
291  */
292