For trunctations, only 20 temp sets are merged at a time (truncchunk)
[idzebra-moved-to-github.git] / recctrl / xslt.c
1 /* $Id: xslt.c,v 1.17 2005-08-24 08:30:37 adam Exp $
2    Copyright (C) 1995-2005
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 #include <stdio.h>
24 #include <assert.h>
25 #include <ctype.h>
26
27 #include <yaz/diagbib1.h>
28 #include <libxml/xmlversion.h>
29 #include <libxml/parser.h>
30 #include <libxml/tree.h>
31 #include <libxml/xmlIO.h>
32 #include <libxml/xmlreader.h>
33 #include <libxslt/transform.h>
34
35 #include <idzebra/util.h>
36 #include <idzebra/recctrl.h>
37
38 struct filter_schema {
39     const char *name;
40     const char *identifier;
41     const char *stylesheet;
42     struct filter_schema *next;
43     const char *default_schema;
44     const char *include_snippet;
45     xsltStylesheetPtr stylesheet_xsp;
46 };
47
48 struct filter_info {
49     xmlDocPtr doc;
50     char *fname;
51     const char *split_level;
52     const char *split_path;
53     ODR odr;
54     struct filter_schema *schemas;
55     xmlTextReaderPtr reader;
56 };
57
58 #define ZEBRA_SCHEMA_XSLT_NS "http://indexdata.dk/zebra/xslt/1"
59
60 #define XML_STRCMP(a,b)   strcmp((char*)a, b)
61 #define XML_STRLEN(a) strlen((char*)a)
62
63 static const char *zebra_xslt_ns = ZEBRA_SCHEMA_XSLT_NS;
64
65 static void set_param_xml(const char **params, const char *name,
66                           const char *value, ODR odr)
67 {
68     while (*params)
69         params++;
70     params[0] = name;
71     params[1] = value;
72     params[2] = 0;
73 }
74
75 static void set_param_str(const char **params, const char *name,
76                           const char *value, ODR odr)
77 {
78     char *quoted = odr_malloc(odr, 3 + strlen(value));
79     sprintf(quoted, "'%s'", value);
80     while (*params)
81         params++;
82     params[0] = name;
83     params[1] = quoted;
84     params[2] = 0;
85 }
86
87 static void set_param_int(const char **params, const char *name,
88                           zint value, ODR odr)
89 {
90     char *quoted = odr_malloc(odr, 30); /* 25 digits enough for 2^64 */
91     while (*params)
92         params++;
93     sprintf(quoted, "'" ZINT_FORMAT "'", value);
94     params[0] = name;
95     params[1] = quoted;
96     params[2] = 0;
97 }
98
99 #define ENABLE_INPUT_CALLBACK 0
100
101 #if ENABLE_INPUT_CALLBACK
102 static int zebra_xmlInputMatchCallback (char const *filename)
103 {
104     yaz_log(YLOG_LOG, "match %s", filename);
105     return 0;
106 }
107
108 static void * zebra_xmlInputOpenCallback (char const *filename)
109 {
110     return 0;
111 }
112
113 static int zebra_xmlInputReadCallback (void * context, char * buffer, int len)
114 {
115     return 0;
116 }
117
118 static int zebra_xmlInputCloseCallback (void * context)
119 {
120     return 0;
121 }
122 #endif
123
124 static void *filter_init(Res res, RecType recType)
125 {
126     struct filter_info *tinfo = (struct filter_info *) xmalloc(sizeof(*tinfo));
127     tinfo->reader = 0;
128     tinfo->fname = 0;
129     tinfo->split_level = 0;
130     tinfo->split_path = 0;
131     tinfo->odr = odr_createmem(ODR_ENCODE);
132     tinfo->doc = 0;
133     tinfo->schemas = 0;
134
135 #if ENABLE_INPUT_CALLBACK
136     xmlRegisterDefaultInputCallbacks();
137     xmlRegisterInputCallbacks(zebra_xmlInputMatchCallback,
138                               zebra_xmlInputOpenCallback,
139                               zebra_xmlInputReadCallback,
140                               zebra_xmlInputCloseCallback);
141 #endif
142     return tinfo;
143 }
144
145 static int attr_content(struct _xmlAttr *attr, const char *name,
146                         const char **dst_content)
147 {
148     if (!XML_STRCMP(attr->name, name) && attr->children &&
149         attr->children->type == XML_TEXT_NODE)
150     {
151         *dst_content = (const char *)(attr->children->content);
152         return 1;
153     }
154     return 0;
155 }
156
157 static void destroy_schemas(struct filter_info *tinfo)
158 {
159     struct filter_schema *schema = tinfo->schemas;
160     while (schema)
161     {
162         struct filter_schema *schema_next = schema->next;
163         if (schema->stylesheet_xsp)
164             xsltFreeStylesheet(schema->stylesheet_xsp);
165         xfree(schema);
166         schema = schema_next;
167     }
168     tinfo->schemas = 0;
169     xfree(tinfo->fname);
170     if (tinfo->doc)
171         xmlFreeDoc(tinfo->doc);    
172     tinfo->doc = 0;
173 }
174
175 static ZEBRA_RES create_schemas(struct filter_info *tinfo, const char *fname)
176 {
177     xmlNodePtr ptr;
178     tinfo->fname = xstrdup(fname);
179     tinfo->doc = xmlParseFile(tinfo->fname);
180     if (!tinfo->doc)
181         return ZEBRA_FAIL;
182     ptr = xmlDocGetRootElement(tinfo->doc);
183     if (!ptr || ptr->type != XML_ELEMENT_NODE ||
184         XML_STRCMP(ptr->name, "schemaInfo"))
185         return ZEBRA_FAIL;
186     for (ptr = ptr->children; ptr; ptr = ptr->next)
187     {
188         if (ptr->type != XML_ELEMENT_NODE)
189             continue;
190         if (!XML_STRCMP(ptr->name, "schema"))
191         {
192             struct _xmlAttr *attr;
193             struct filter_schema *schema = xmalloc(sizeof(*schema));
194             schema->name = 0;
195             schema->identifier = 0;
196             schema->stylesheet = 0;
197             schema->default_schema = 0;
198             schema->next = tinfo->schemas;
199             schema->stylesheet_xsp = 0;
200             schema->include_snippet = 0;
201             tinfo->schemas = schema;
202             for (attr = ptr->properties; attr; attr = attr->next)
203             {
204                 attr_content(attr, "identifier", &schema->identifier);
205                 attr_content(attr, "name", &schema->name);
206                 attr_content(attr, "stylesheet", &schema->stylesheet);
207                 attr_content(attr, "default", &schema->default_schema);
208                 attr_content(attr, "snippet", &schema->include_snippet);
209             }
210             if (schema->stylesheet)
211                 schema->stylesheet_xsp =
212                     xsltParseStylesheetFile(
213                         (const xmlChar*) schema->stylesheet);
214         }
215         else if (!XML_STRCMP(ptr->name, "split"))
216         {
217             struct _xmlAttr *attr;
218             for (attr = ptr->properties; attr; attr = attr->next)
219             {
220                 attr_content(attr, "level", &tinfo->split_level);
221                 attr_content(attr, "path", &tinfo->split_path);
222             }
223         }
224         else
225         {
226             yaz_log(YLOG_WARN, "Bad element %s in %s", ptr->name, fname);
227             return ZEBRA_FAIL;
228         }
229     }
230     return ZEBRA_OK;
231 }
232
233 static struct filter_schema *lookup_schema(struct filter_info *tinfo,
234                                            const char *est)
235 {
236     struct filter_schema *schema;
237     for (schema = tinfo->schemas; schema; schema = schema->next)
238     {
239         if (est)
240         {
241             if (schema->identifier && !strcmp(schema->identifier, est))
242                 return schema;
243             if (schema->name && !strcmp(schema->name, est))
244                 return schema;
245         }
246         if (schema->default_schema)
247             return schema;
248     }
249     return 0;
250 }
251
252 static void filter_config(void *clientData, Res res, const char *args)
253 {
254     struct filter_info *tinfo = clientData;
255     if (!args || !*args)
256         args = "xsltfilter.xml";
257     if (tinfo->fname && !strcmp(args, tinfo->fname))
258         return;
259     destroy_schemas(tinfo);
260     create_schemas(tinfo, args);
261 }
262
263 static void filter_destroy(void *clientData)
264 {
265     struct filter_info *tinfo = clientData;
266     destroy_schemas(tinfo);
267     if (tinfo->reader)
268         xmlFreeTextReader(tinfo->reader);
269     odr_destroy(tinfo->odr);
270     xfree(tinfo);
271 }
272
273 static int ioread_ex(void *context, char *buffer, int len)
274 {
275     struct recExtractCtrl *p = context;
276     return (*p->readf)(p->fh, buffer, len);
277 }
278
279 static int ioclose_ex(void *context)
280 {
281     return 0;
282 }
283
284 static void index_cdata(struct filter_info *tinfo, struct recExtractCtrl *ctrl,
285                         xmlNodePtr ptr, RecWord *recWord)
286 {
287     for(; ptr; ptr = ptr->next)
288     {
289         index_cdata(tinfo, ctrl, ptr->children, recWord);
290         if (ptr->type != XML_TEXT_NODE)
291             continue;
292         recWord->term_buf = (const char *)ptr->content;
293         recWord->term_len = XML_STRLEN(ptr->content);
294         (*ctrl->tokenAdd)(recWord);
295     }
296 }
297
298 static void index_node(struct filter_info *tinfo,  struct recExtractCtrl *ctrl,
299                        xmlNodePtr ptr, RecWord *recWord)
300 {
301     for(; ptr; ptr = ptr->next)
302     {
303         index_node(tinfo, ctrl, ptr->children, recWord);
304         if (ptr->type != XML_ELEMENT_NODE || !ptr->ns ||
305             XML_STRCMP(ptr->ns->href, zebra_xslt_ns))
306             continue;
307         if (!XML_STRCMP(ptr->name, "index"))
308         {
309             const char *name_str = 0;
310             const char *type_str = 0;
311             const char *xpath_str = 0;
312             struct _xmlAttr *attr;
313             for (attr = ptr->properties; attr; attr = attr->next)
314             {
315                 attr_content(attr, "name", &name_str);
316                 attr_content(attr, "xpath", &xpath_str);
317                 attr_content(attr, "type", &type_str);
318             }
319             if (name_str)
320             {
321                 int prev_type = recWord->index_type; /* save default type */
322
323                 if (type_str && *type_str)
324                     recWord->index_type = *type_str; /* type was given */
325                 recWord->index_name = name_str;
326                 index_cdata(tinfo, ctrl, ptr->children, recWord);
327
328                 recWord->index_type = prev_type;     /* restore it again */
329             }
330         }
331     }
332 }
333
334 static void index_record(struct filter_info *tinfo,struct recExtractCtrl *ctrl,
335                          xmlNodePtr ptr, RecWord *recWord)
336 {
337     if (ptr && ptr->type == XML_ELEMENT_NODE && ptr->ns &&
338         !XML_STRCMP(ptr->ns->href, zebra_xslt_ns)
339         && !XML_STRCMP(ptr->name, "record"))
340     {
341         const char *type_str = "update";
342         const char *id_str = 0;
343         const char *rank_str = 0;
344         struct _xmlAttr *attr;
345         for (attr = ptr->properties; attr; attr = attr->next)
346         {
347             attr_content(attr, "type", &type_str);
348             attr_content(attr, "id", &id_str);
349             attr_content(attr, "rank", &rank_str);
350         }
351         if (id_str)
352             sscanf(id_str, "%255s", ctrl->match_criteria);
353         if (rank_str)
354         {
355             ctrl->staticrank = atoi(rank_str);
356             yaz_log(YLOG_LOG, "rank=%d",ctrl->staticrank);
357         }
358         else
359             yaz_log(YLOG_LOG, "no rank");
360         
361         ptr = ptr->children;
362     }
363     index_node(tinfo, ctrl, ptr, recWord);
364 }
365     
366 static int extract_doc(struct filter_info *tinfo, struct recExtractCtrl *p,
367                        xmlDocPtr doc)
368 {
369     RecWord recWord;
370     const char *params[10];
371     xmlChar *buf_out;
372     int len_out;
373
374     struct filter_schema *schema = lookup_schema(tinfo, zebra_xslt_ns);
375
376     params[0] = 0;
377     set_param_str(params, "schema", zebra_xslt_ns, tinfo->odr);
378
379     (*p->init)(p, &recWord);
380
381     if (schema && schema->stylesheet_xsp)
382     {
383         xmlNodePtr root_ptr;
384         xmlDocPtr resDoc = 
385             xsltApplyStylesheet(schema->stylesheet_xsp,
386                                 doc, params);
387         if (p->flagShowRecords)
388         {
389             xmlDocDumpMemory(resDoc, &buf_out, &len_out);
390             fwrite(buf_out, len_out, 1, stdout);
391             xmlFree(buf_out);
392         }
393         root_ptr = xmlDocGetRootElement(resDoc);
394         if (root_ptr)
395             index_record(tinfo, p, root_ptr, &recWord);
396         else
397         {
398             yaz_log(YLOG_WARN, "No root for index XML record."
399                     " split_level=%s stylesheet=%s",
400                     tinfo->split_level, schema->stylesheet);
401         }
402         xmlFreeDoc(resDoc);
403     }
404     xmlDocDumpMemory(doc, &buf_out, &len_out);
405     if (p->flagShowRecords)
406         fwrite(buf_out, len_out, 1, stdout);
407     (*p->setStoreData)(p, buf_out, len_out);
408     xmlFree(buf_out);
409     
410     xmlFreeDoc(doc);
411     return RECCTRL_EXTRACT_OK;
412 }
413
414 static int extract_split(struct filter_info *tinfo, struct recExtractCtrl *p)
415 {
416     int ret;
417     int split_depth = 0;
418     if (p->first_record)
419     {
420         if (tinfo->reader)
421             xmlFreeTextReader(tinfo->reader);
422         tinfo->reader = xmlReaderForIO(ioread_ex, ioclose_ex,
423                                        p /* I/O handler */,
424                                        0 /* URL */, 
425                                        0 /* encoding */,
426                                        XML_PARSE_XINCLUDE);
427     }
428     if (!tinfo->reader)
429         return RECCTRL_EXTRACT_ERROR_GENERIC;
430
431     if (tinfo->split_level)
432         split_depth = atoi(tinfo->split_level);
433     ret = xmlTextReaderRead(tinfo->reader);
434     while (ret == 1) {
435         int type = xmlTextReaderNodeType(tinfo->reader);
436         int depth = xmlTextReaderDepth(tinfo->reader);
437         if (split_depth == 0 ||
438             (split_depth > 0 &&
439              type == XML_READER_TYPE_ELEMENT && split_depth == depth))
440         {
441             xmlNodePtr ptr = xmlTextReaderExpand(tinfo->reader);
442             xmlNodePtr ptr2 = xmlCopyNode(ptr, 1);
443             xmlDocPtr doc = xmlNewDoc((const xmlChar*) "1.0");
444
445             xmlDocSetRootElement(doc, ptr2);
446
447             return extract_doc(tinfo, p, doc);   
448         }
449         ret = xmlTextReaderRead(tinfo->reader);
450     }
451     xmlFreeTextReader(tinfo->reader);
452     tinfo->reader = 0;
453     return RECCTRL_EXTRACT_EOF;
454 }
455
456 static int extract_full(struct filter_info *tinfo, struct recExtractCtrl *p)
457 {
458     if (p->first_record) /* only one record per stream */
459     {
460         xmlDocPtr doc = xmlReadIO(ioread_ex, ioclose_ex, p /* I/O handler */,
461                                   0 /* URL */,
462                                   0 /* encoding */,
463                                   XML_PARSE_XINCLUDE);
464         if (!doc)
465         {
466             return RECCTRL_EXTRACT_ERROR_GENERIC;
467         }
468         return extract_doc(tinfo, p, doc);
469     }
470     else
471         return RECCTRL_EXTRACT_EOF;
472 }
473
474 static int filter_extract(void *clientData, struct recExtractCtrl *p)
475 {
476     struct filter_info *tinfo = clientData;
477
478     odr_reset(tinfo->odr);
479
480     if (tinfo->split_level == 0 && tinfo->split_path == 0)
481         return extract_full(tinfo, p);
482     else
483     {
484         return extract_split(tinfo, p);
485     }
486 }
487
488 static int ioread_ret(void *context, char *buffer, int len)
489 {
490     struct recRetrieveCtrl *p = context;
491     return (*p->readf)(p->fh, buffer, len);
492 }
493
494 static int ioclose_ret(void *context)
495 {
496     return 0;
497 }
498
499
500 static const char *snippet_doc(struct recRetrieveCtrl *p, int text_mode,
501                                int window_size)
502 {
503     const char *xml_doc_str;
504     int ord = 0;
505     WRBUF wrbuf = wrbuf_alloc();
506     zebra_snippets *res = 
507         zebra_snippets_window(p->doc_snippet, p->hit_snippet, window_size);
508     zebra_snippet_word *w = zebra_snippets_list(res);
509
510     if (text_mode)
511         wrbuf_printf(wrbuf, "\'");
512     else
513         wrbuf_printf(wrbuf, "<snippet xmlns='%s'>\n", zebra_xslt_ns);
514     for (; w; w = w->next)
515     {
516         if (ord == 0)
517             ord = w->ord;
518         else if (ord != w->ord)
519
520             break;
521         if (text_mode)
522             wrbuf_printf(wrbuf, "%s%s%s ", 
523                          w->match ? "*" : "",
524                          w->term,
525                          w->match ? "*" : "");
526         else
527         {
528             wrbuf_printf(wrbuf, " <term ord='%d' seqno='" ZINT_FORMAT "' %s>", 
529                          w->ord, w->seqno,
530                          (w->match ? "match='1'" : ""));
531             wrbuf_xmlputs(wrbuf, w->term);
532             wrbuf_printf(wrbuf, "</term>\n");
533         }
534     }
535     if (text_mode)
536         wrbuf_printf(wrbuf, "\'");
537     else
538         wrbuf_printf(wrbuf, "</snippet>\n");
539
540     xml_doc_str = odr_strdup(p->odr, wrbuf_buf(wrbuf));
541
542     zebra_snippets_destroy(res);
543     wrbuf_free(wrbuf, 1);
544     return xml_doc_str;
545 }
546
547 static int filter_retrieve (void *clientData, struct recRetrieveCtrl *p)
548 {
549     const char *esn = zebra_xslt_ns;
550     const char *params[20];
551     struct filter_info *tinfo = clientData;
552     xmlDocPtr resDoc;
553     xmlDocPtr doc;
554     struct filter_schema *schema;
555     int window_size = -1;
556
557     if (p->comp)
558     {
559         if (p->comp->which == Z_RecordComp_simple
560             && p->comp->u.simple->which == Z_ElementSetNames_generic)
561         {
562             esn = p->comp->u.simple->u.generic;
563         }
564         else if (p->comp->which == Z_RecordComp_complex 
565                  && p->comp->u.complex->generic->elementSpec
566                  && p->comp->u.complex->generic->elementSpec->which ==
567                  Z_ElementSpec_elementSetName)
568         {
569             esn = p->comp->u.complex->generic->elementSpec->u.elementSetName;
570         }
571     }
572     schema = lookup_schema(tinfo, esn);
573     if (!schema)
574     {
575         p->diagnostic =
576             YAZ_BIB1_SPECIFIED_ELEMENT_SET_NAME_NOT_VALID_FOR_SPECIFIED_;
577         return 0;
578     }
579
580     if (schema->include_snippet)
581         window_size = atoi(schema->include_snippet);
582
583     params[0] = 0;
584     set_param_str(params, "schema", esn, p->odr);
585     if (p->fname)
586         set_param_str(params, "filename", p->fname, p->odr);
587     if (p->score >= 0)
588         set_param_int(params, "score", p->score, p->odr);
589     set_param_int(params, "size", p->recordSize, p->odr);
590     set_param_int(params, "id", p->localno, p->odr);
591
592     if (window_size >= 0)
593         set_param_xml(params, "snippet", snippet_doc(p, 1, window_size),
594                       p->odr);
595     doc = xmlReadIO(ioread_ret, ioclose_ret, p /* I/O handler */,
596                     0 /* URL */,
597                     0 /* encoding */,
598                     XML_PARSE_XINCLUDE);
599     if (!doc)
600     {
601         p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
602         return 0;
603     }
604
605     if (window_size >= 0)
606     {
607         xmlNodePtr node = xmlDocGetRootElement(doc);
608         const char *snippet_str = snippet_doc(p, 0, window_size);
609         xmlDocPtr snippet_doc = xmlParseMemory(snippet_str, strlen(snippet_str));
610         xmlAddChild(node, xmlDocGetRootElement(snippet_doc));
611     }
612     if (!schema->stylesheet_xsp)
613         resDoc = doc;
614     else
615     {
616         resDoc = xsltApplyStylesheet(schema->stylesheet_xsp,
617                                      doc, params);
618         xmlFreeDoc(doc);
619     }
620     if (!resDoc)
621     {
622         p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
623     }
624     else if (p->input_format == VAL_NONE || p->input_format == VAL_TEXT_XML)
625     {
626         xmlChar *buf_out;
627         int len_out;
628         xmlDocDumpMemory(resDoc, &buf_out, &len_out);
629
630         p->output_format = VAL_TEXT_XML;
631         p->rec_len = len_out;
632         p->rec_buf = odr_malloc(p->odr, p->rec_len);
633         memcpy(p->rec_buf, buf_out, p->rec_len);
634         
635         xmlFree(buf_out);
636     }
637     else if (p->output_format == VAL_SUTRS)
638     {
639         xmlChar *buf_out;
640         int len_out;
641         xmlDocDumpMemory(resDoc, &buf_out, &len_out);
642
643         p->output_format = VAL_SUTRS;
644         p->rec_len = len_out;
645         p->rec_buf = odr_malloc(p->odr, p->rec_len);
646         memcpy(p->rec_buf, buf_out, p->rec_len);
647         
648         xmlFree(buf_out);
649     }
650     else
651     {
652         p->diagnostic = YAZ_BIB1_RECORD_SYNTAX_UNSUPP;
653     }
654     xmlFreeDoc(resDoc);
655     return 0;
656 }
657
658 static struct recType filter_type = {
659     0,
660     "xslt",
661     filter_init,
662     filter_config,
663     filter_destroy,
664     filter_extract,
665     filter_retrieve
666 };
667
668 RecType
669 #ifdef IDZEBRA_STATIC_XSLT
670 idzebra_filter_xslt
671 #else
672 idzebra_filter
673 #endif
674
675 [] = {
676     &filter_type,
677     0,
678 };