Enhanced security for lost filter objects. Added calls to support virtual
[idzebra-moved-to-github.git] / perl / zebra_api_ext.c
1 #include <assert.h>
2 #include <stdio.h>
3 #ifdef WIN32
4 #include <io.h>
5 #include <process.h>
6 #include <direct.h>
7 #else
8 #include <unistd.h>
9 #endif
10
11 #include <yaz/diagbib1.h>
12 #include "index.h"
13 #include <charmap.h>
14 #include <data1.h>
15 #include "zebra_perl.h"
16 #include "zebra_api_ext.h"
17 #include "yaz/log.h"
18 #include <yaz/pquery.h>
19 #include <yaz/cql.h>
20 #include <yaz/sortspec.h>
21
22 void data1_print_tree(data1_handle dh, data1_node *n, FILE *out) {
23   data1_pr_tree(dh, n, stdout);
24 }
25
26 int zebra_get_shadow_enable (ZebraHandle zh) {
27   return (zh->shadow_enable);
28 }
29
30 void zebra_set_shadow_enable (ZebraHandle zh, int value) {
31   zh->shadow_enable = value;
32 }
33
34 void init_recordGroup (recordGroup *rg) {
35     rg->groupName = NULL;
36     rg->databaseName = NULL;
37     rg->path = NULL;
38     rg->recordId = NULL;
39     rg->recordType = NULL;
40     rg->flagStoreData = -1;
41     rg->flagStoreKeys = -1; 
42     rg->flagRw = 1;
43     rg->databaseNamePath = 0;
44     rg->explainDatabase = 0; 
45     rg->fileVerboseLimit = 100000; 
46     rg->followLinks = -1;
47
48
49
50 /* This is from extract.c... it seems useful, when extract_rec_in mem is 
51    called... and in general... Should be moved to somewhere else */
52 void res_get_recordGroup (ZebraHandle zh,
53                           recordGroup *rGroup,
54                           const char *ext) {
55   char gprefix[128];
56   char ext_res[128]; 
57     
58   if (!rGroup->groupName || !*rGroup->groupName)
59     *gprefix = '\0';
60   else 
61     sprintf (gprefix, "%s.", rGroup->groupName);
62   
63   /* determine file type - depending on extension */
64   if (!rGroup->recordType) {
65     sprintf (ext_res, "%srecordType.%s", gprefix, ext);
66     if (!(rGroup->recordType = res_get (zh->res, ext_res))) {
67       sprintf (ext_res, "%srecordType", gprefix);
68       rGroup->recordType = res_get (zh->res, ext_res);
69     }
70   }
71   /* determine match criteria */
72   if (!rGroup->recordId) { 
73     sprintf (ext_res, "%srecordId.%s", gprefix, ext);
74     if (!(rGroup->recordId = res_get (zh->res, ext_res))) {
75       sprintf (ext_res, "%srecordId", gprefix);
76       rGroup->recordId = res_get (zh->res, ext_res);
77     }
78   } 
79   
80   /* determine database name */
81   if (!rGroup->databaseName) {
82     sprintf (ext_res, "%sdatabase.%s", gprefix, ext);
83     if (!(rGroup->databaseName = res_get (zh->res, ext_res))) { 
84       sprintf (ext_res, "%sdatabase", gprefix);
85       rGroup->databaseName = res_get (zh->res, ext_res);
86     }
87   }
88   if (!rGroup->databaseName)
89     rGroup->databaseName = "Default";
90
91   /* determine if explain database */
92   sprintf (ext_res, "%sexplainDatabase", gprefix);
93   rGroup->explainDatabase =
94     atoi (res_get_def (zh->res, ext_res, "0"));
95
96   /* storeData */
97   if (rGroup->flagStoreData == -1) {
98     const char *sval;
99     sprintf (ext_res, "%sstoreData.%s", gprefix, ext);
100     if (!(sval = res_get (zh->res, ext_res))) {
101       sprintf (ext_res, "%sstoreData", gprefix);
102       sval = res_get (zh->res, ext_res);
103     }
104     if (sval)
105       rGroup->flagStoreData = atoi (sval);
106   }
107   if (rGroup->flagStoreData == -1)  rGroup->flagStoreData = 0;
108
109   /* storeKeys */
110   if (rGroup->flagStoreKeys == -1)  {
111     const char *sval;
112     
113     sprintf (ext_res, "%sstoreKeys.%s", gprefix, ext);
114     sval = res_get (zh->res, ext_res);
115     if (!sval) {
116       sprintf (ext_res, "%sstoreKeys", gprefix);
117       sval = res_get (zh->res, ext_res);
118     }
119     if (!sval)  sval = res_get (zh->res, "storeKeys");
120     if (sval) rGroup->flagStoreKeys = atoi (sval);
121   }
122   if (rGroup->flagStoreKeys == -1) rGroup->flagStoreKeys = 0;
123   
124
125
126 int zebra_trans_processed(ZebraTransactionStatus s) {
127   return (s.processed);
128 }
129
130 /* ---------------------------------------------------------------------------
131   Record insert(=update), delete 
132
133   If sysno is provided, then it's used to identify the reocord.
134   If not, and match_criteria is provided, then sysno is guessed
135   If not, and a record is provided, then sysno is got from there
136 */
137
138 int zebra_update_record (ZebraHandle zh, 
139                          struct recordGroup *rGroup,
140                          const char *recordType,
141                          int sysno, const char *match, const char *fname,
142                          const char *buf, int buf_size)
143
144 {
145     int res;
146
147     if (buf_size < 1) buf_size = strlen(buf);
148
149     zebra_begin_trans(zh);
150     res=bufferExtractRecord (zh, buf, buf_size, rGroup, 
151                              0, // delete_flag 
152                              0, // test_mode,
153                              recordType,
154                              &sysno,   
155                              match, fname);     
156     zebra_end_trans(zh); 
157     return sysno; 
158 }
159
160 int zebra_delete_record (ZebraHandle zh, 
161                          struct recordGroup *rGroup, 
162                          const char *recordType,
163                          int sysno, const char *match, const char *fname,
164                          const char *buf, int buf_size)
165 {
166     int res;
167
168     if (buf_size < 1) buf_size = strlen(buf);
169
170     zebra_begin_trans(zh);
171     res=bufferExtractRecord (zh, buf, buf_size, rGroup, 
172                              1, // delete_flag
173                              0, // test_mode, 
174                              recordType,
175                              &sysno,
176                              match,fname);    
177     zebra_end_trans(zh);
178     return sysno;   
179 }
180
181 /* ---------------------------------------------------------------------------
182   Searching 
183
184   zebra_search_RPN is the same as zebra_search_rpn, except that read locking
185   is not mandatory. (it's repeatable now, also in zebraapi.c)
186 */
187
188 void zebra_search_RPN (ZebraHandle zh, ODR decode, ODR stream,
189                        Z_RPNQuery *query, const char *setname, int *hits)
190 {
191     zh->hits = 0;
192     *hits = 0;
193
194     if (zebra_begin_read (zh))
195         return;
196     resultSetAddRPN (zh, decode, stream, query, 
197                      zh->num_basenames, zh->basenames, setname);
198
199     zebra_end_read (zh);
200
201     *hits = zh->hits;
202 }
203
204 int zebra_search_PQF (ZebraHandle zh, 
205                       ODR odr_input, ODR odr_output, 
206                       const char *pqf_query,
207                       const char *setname)
208
209 {
210   int hits;
211   Z_RPNQuery *query;
212   query = p_query_rpn (odr_input, PROTO_Z3950, pqf_query);
213
214   if (!query) {
215     logf (LOG_WARN, "bad query %s\n", pqf_query);
216     odr_reset (odr_input);
217     return(0);
218   }
219   zebra_search_RPN (zh, odr_input, odr_output, query, setname, &hits);
220
221   odr_reset (odr_input);
222   odr_reset (odr_output);
223   
224   return(hits);
225 }
226
227 int zebra_cql2pqf (cql_transform_t ct, 
228                    const char *query, char *res, int len) {
229   
230   int status;
231   const char *addinfo;
232   CQL_parser cp = cql_parser_create();
233
234   if (status = cql_transform_error(ct, &addinfo)) {
235     logf (LOG_WARN,"Transform error %d %s\n", status, addinfo ? addinfo : "");
236     return (status);
237   }
238
239   if (status = cql_parser_string(cp, query))
240     return (status);
241
242   if (status = cql_transform_buf(ct, cql_parser_result(cp), res, len)) {
243     logf (LOG_WARN,"Transform error %d %s\n", status, addinfo ? addinfo : "");
244     return (status);
245   }
246
247   return (0);
248 }
249
250 void zebra_scan_PQF (ZebraHandle zh,
251                      ScanObj *so,
252                      ODR stream,
253                      const char *pqf_query)
254 {
255   Z_AttributesPlusTerm *zapt;
256   Odr_oid *attrsetid;
257   const char* oidname;
258   oid_value attributeset;
259   ZebraScanEntry *entries;
260   int i, class;
261
262   logf(LOG_DEBUG,  
263        "scan req: pos:%d, num:%d, partial:%d", 
264        so->position, so->num_entries, so->is_partial);
265
266   zapt = p_query_scan (stream, PROTO_Z3950, &attrsetid, pqf_query);
267
268   oidname = yaz_z3950oid_to_str (attrsetid, &class); 
269   logf (LOG_DEBUG, "Attributreset: %s", oidname);
270   attributeset = oid_getvalbyname(oidname);
271
272   if (!zapt) {
273     logf (LOG_WARN, "bad query %s\n", pqf_query);
274     odr_reset (stream);
275     return;
276   }
277
278   so->entries = (ScanEntry *)
279     odr_malloc (stream, sizeof(so->entries) * (so->num_entries));
280
281
282   zebra_scan (zh, stream, zapt, attributeset, 
283               &so->position, &so->num_entries, 
284               (ZebraScanEntry **) &so->entries, &so->is_partial);
285
286   logf(LOG_DEBUG, 
287        "scan res: pos:%d, num:%d, partial:%d", 
288        so->position, so->num_entries, so->is_partial);
289 }
290
291 ScanEntry *getScanEntry(ScanObj *so, int pos) {
292   return (&so->entries[pos-1]);
293 }
294
295 /* ---------------------------------------------------------------------------
296   Record retrieval 
297   2 phase retrieval - I didn't manage to return array of blessed references
298   to wrapped structures... it's feasible, but I'll need some time 
299   / pop - 2002-11-17
300 */
301
302 void record_retrieve(RetrievalObj *ro,
303                      ODR stream,
304                      RetrievalRecord *res,
305                      int pos) 
306 {
307   int i = pos - 1;
308
309
310   RetrievalRecordBuf *buf = 
311     (RetrievalRecordBuf *) odr_malloc(stream, sizeof(*buf));  
312
313   res->errCode    = ro->records[i].errCode;
314   res->errString  = ro->records[i].errString;
315   res->position   = ro->records[i].position;
316   res->base       = ro->records[i].base;
317   res->format     = ro->records[i].format;
318   res->buf        = buf;
319   res->buf->len   = ro->records[i].len;
320   res->buf->buf   = ro->records[i].buf;
321
322 }
323
324 /* most of the code here was copied from yaz-client */
325 void records_retrieve(ZebraHandle zh,
326                       ODR stream,
327                       const char *setname,
328                       const char *a_eset, 
329                       const char *a_schema,
330                       const char *a_format,
331                       int from,
332                       int to,
333                       RetrievalObj *res) 
334 {
335   static enum oid_value recordsyntax = VAL_SUTRS;
336   static enum oid_value schema = VAL_NONE;
337   static Z_ElementSetNames *elementSetNames = 0; 
338   static Z_RecordComposition compo;
339   static Z_ElementSetNames esn;
340   static char what[100];
341   int i;
342   int oid[OID_SIZE];
343
344   compo.which = -1;
345
346   if (from < 1) from = 1;
347   if (from > to) to = from;
348   res->noOfRecords = to - from + 1;
349
350   res->records = odr_malloc (stream, 
351                              sizeof(*res->records) * (res->noOfRecords));  
352
353   for (i = 0; i<res->noOfRecords; i++) res->records[i].position = from+i;
354
355   if (!a_eset || !*a_eset) {
356     elementSetNames = 0;
357   } else {
358     strcpy(what, a_eset);
359     esn.which = Z_ElementSetNames_generic;
360     esn.u.generic = what;
361     elementSetNames = &esn;
362   }
363
364   if (!a_schema || !*a_schema) {
365     schema = VAL_NONE;
366   } else {
367     schema = oid_getvalbyname (a_schema);
368     if (schema == VAL_NONE) {
369       logf(LOG_WARN,"unknown schema '%s'",a_schema);
370     }
371   }
372
373   
374   if (!a_format || !*a_format) {
375     recordsyntax = VAL_SUTRS;
376   } else {
377     recordsyntax = oid_getvalbyname (a_format);
378     if (recordsyntax == VAL_NONE) {
379       logf(LOG_WARN,"unknown record syntax '%s', using SUTRS",a_schema);
380       recordsyntax = VAL_SUTRS;
381     }
382   }
383
384   if (schema != VAL_NONE) {
385     oident prefschema;
386
387     prefschema.proto = PROTO_Z3950;
388     prefschema.oclass = CLASS_SCHEMA;
389     prefschema.value = schema;
390     
391     compo.which = Z_RecordComp_complex;
392     compo.u.complex = (Z_CompSpec *)
393       odr_malloc(stream, sizeof(*compo.u.complex));
394     compo.u.complex->selectAlternativeSyntax = (bool_t *) 
395       odr_malloc(stream, sizeof(bool_t));
396     *compo.u.complex->selectAlternativeSyntax = 0;
397     
398     compo.u.complex->generic = (Z_Specification *)
399       odr_malloc(stream, sizeof(*compo.u.complex->generic));
400     compo.u.complex->generic->which = Z_Schema_oid;
401     compo.u.complex->generic->schema.oid = (Odr_oid *)
402       odr_oiddup(stream, oid_ent_to_oid(&prefschema, oid));
403     if (!compo.u.complex->generic->schema.oid)
404       {
405         /* OID wasn't a schema! Try record syntax instead. */
406         prefschema.oclass = CLASS_RECSYN;
407         compo.u.complex->generic->schema.oid = (Odr_oid *)
408           odr_oiddup(stream, oid_ent_to_oid(&prefschema, oid));
409       }
410     if (!elementSetNames)
411       compo.u.complex->generic->elementSpec = 0;
412     else
413       {
414         compo.u.complex->generic->elementSpec = (Z_ElementSpec *)
415           odr_malloc(stream, sizeof(Z_ElementSpec));
416         compo.u.complex->generic->elementSpec->which =
417           Z_ElementSpec_elementSetName;
418         compo.u.complex->generic->elementSpec->u.elementSetName =
419           elementSetNames->u.generic;
420       }
421     compo.u.complex->num_dbSpecific = 0;
422     compo.u.complex->dbSpecific = 0;
423     compo.u.complex->num_recordSyntax = 0;
424     compo.u.complex->recordSyntax = 0;
425   } 
426   else if (elementSetNames) {
427     compo.which = Z_RecordComp_simple;
428     compo.u.simple = elementSetNames;
429   }
430
431   if (compo.which == -1) {
432     api_records_retrieve (zh, stream, setname, 
433                             NULL, 
434                             recordsyntax,
435                             res->noOfRecords, res->records);
436   } else {
437     api_records_retrieve (zh, stream, setname, 
438                             &compo,
439                             recordsyntax,
440                             res->noOfRecords, res->records);
441   }
442
443 }
444  
445 int zebra_trans_no (ZebraHandle zh) {
446   return (zh->trans_no);
447 }
448
449 /* almost the same as zebra_records_retrieve ... but how did it work? 
450    I mean for multiple records ??? CHECK ??? */
451 void api_records_retrieve (ZebraHandle zh, ODR stream,
452                            const char *setname, Z_RecordComposition *comp,
453                            oid_value input_format, int num_recs,
454                            ZebraRetrievalRecord *recs)
455 {
456     ZebraPosSet poset;
457     int i, *pos_array;
458
459     if (!zh->res)
460     {
461         zh->errCode = 30;
462         zh->errString = odr_strdup (stream, setname);
463         return;
464     }
465     
466     zh->errCode = 0; 
467
468     if (zebra_begin_read (zh))
469         return;
470
471     pos_array = (int *) xmalloc (num_recs * sizeof(*pos_array));
472     for (i = 0; i<num_recs; i++)
473         pos_array[i] = recs[i].position;
474     poset = zebraPosSetCreate (zh, setname, num_recs, pos_array);
475     if (!poset)
476     {
477         logf (LOG_DEBUG, "zebraPosSetCreate error");
478         zh->errCode = 30;
479         zh->errString = nmem_strdup (stream->mem, setname);
480     }
481     else
482     {
483         for (i = 0; i<num_recs; i++)
484         {
485             if (poset[i].term)
486             {
487                 recs[i].errCode = 0;
488                 recs[i].format = VAL_SUTRS;
489                 recs[i].len = strlen(poset[i].term);
490                 recs[i].buf = poset[i].term;
491                 recs[i].base = poset[i].db;
492             
493             }
494             else if (poset[i].sysno)
495             {
496               /* changed here ??? CHECK ??? */
497               char *b;
498                 recs[i].errCode =
499                     zebra_record_fetch (zh, poset[i].sysno, poset[i].score,
500                                         stream, input_format, comp,
501                                         &recs[i].format, 
502                                         &b,
503                                         &recs[i].len,
504                                         &recs[i].base);
505                 recs[i].buf = (char *) odr_malloc(stream,recs[i].len);
506                 memcpy(recs[i].buf, b, recs[i].len);
507                 recs[i].errString = NULL;
508             }
509             else
510             {
511                 char num_str[20];
512
513                 sprintf (num_str, "%d", pos_array[i]);  
514                 zh->errCode = 13;
515                 zh->errString = odr_strdup (stream, num_str);
516                 break;
517             }
518
519         }
520         zebraPosSetDestroy (zh, poset, num_recs);
521     }
522     zebra_end_read (zh);
523     xfree (pos_array);
524 }
525
526
527 /* ---------------------------------------------------------------------------
528   Sort - a simplified interface, with optional read locks.
529 */
530 int sort (ZebraHandle zh, 
531           ODR stream,
532           const char *sort_spec,
533           const char *output_setname,
534           const char **input_setnames
535           ) 
536 {
537   int num_input_setnames = 0;
538   int sort_status = 0;
539   Z_SortKeySpecList *sort_sequence = yaz_sort_spec (stream, sort_spec);
540
541   /* we can do this, since the typemap code for char** will 
542      put a NULL at the end of list */
543     while (input_setnames[num_input_setnames]) num_input_setnames++;
544
545     if (zebra_begin_read (zh))
546         return;
547
548     resultSetSort (zh, stream->mem, num_input_setnames, input_setnames,
549                    output_setname, sort_sequence, &sort_status);
550
551     zebra_end_read(zh);
552     return (sort_status);
553 }