src/record_render.c

   1 /* This file is part of the YAZ toolkit.
   2  * Copyright (C) 1995-2012 Index Data
   3  * See the file LICENSE for details.
   4  */
   5 /**
   6  * \file record_render.c
   7  * \brief Render Z39.50 records (NamePlusRecord)
   8  */
   9 #if HAVE_CONFIG_H
  10 #include <config.h>
  11 #endif
  12
  13 #include <assert.h>
  14 #include <string.h>
  15 #include <errno.h>
  16
  17 #include <yaz/marcdisp.h>
  18 #include <yaz/record_render.h>
  19 #include <yaz/yaz-iconv.h>
  20 #include <yaz/proto.h>
  21 #include <yaz/oid_db.h>
  22 #include <yaz/nmem_xml.h>
  23 #include <yaz/base64.h>
  24
  25 #if YAZ_HAVE_XML2
  26 #include <libxml/xpath.h>
  27 #include <libxml/xpathInternals.h>
  28 #endif
  29
  30 static yaz_iconv_t iconv_create_charset(const char *record_charset,
  31                                         yaz_iconv_t *cd2)
  32 {
  33     char charset_buf[40];
  34     yaz_iconv_t cd = 0;
  35     char *from_set1 = 0;
  36     char *from_set2 = 0;
  37     char *to_set = "utf-8";
  38     if (record_charset && *record_charset)
  39     {
  40         char *cp = charset_buf;
  41
  42         strncpy(charset_buf, record_charset, sizeof(charset_buf)-1);
  43         charset_buf[sizeof(charset_buf)-1] = '\0';
  44
  45         from_set1 = cp;
  46         while (*cp && *cp != ',' && *cp != '/')
  47             cp++;
  48         if (*cp == '/')
  49         {
  50             *cp++ = '\0'; /* terminate from_set1 */
  51             from_set2 = cp;
  52             while (*cp && *cp != ',')
  53                 cp++;
  54         }
  55         if (*cp == ',')
  56         {
  57             *cp++ = '\0';  /* terminate from_set1 or from_set2 */
  58             to_set = cp;
  59             while (*cp)
  60                 cp++;
  61         }
  62     }
  63
  64     if (from_set1)
  65         cd = yaz_iconv_open(to_set, from_set1);
  66     if (cd2)
  67     {
  68         if (from_set2)
  69             *cd2 = yaz_iconv_open(to_set, from_set2);
  70         else
  71             *cd2 = 0;
  72     }
  73     return cd;
  74 }
  75
  76 static const char *return_marc_record(WRBUF wrbuf,
  77                                       int marc_type,
  78                                       int *len,
  79                                       const char *buf, int sz,
  80                                       const char *record_charset)
  81 {
  82     yaz_iconv_t cd = iconv_create_charset(record_charset, 0);
  83     yaz_marc_t mt = yaz_marc_create();
  84     const char *ret_string = 0;
  85
  86     if (cd)
  87         yaz_marc_iconv(mt, cd);
  88     yaz_marc_xml(mt, marc_type);
  89     if (yaz_marc_decode_wrbuf(mt, buf, sz, wrbuf) > 0)
  90     {
  91         *len = wrbuf_len(wrbuf);
  92         ret_string = wrbuf_cstr(wrbuf);
  93     }
  94     yaz_marc_destroy(mt);
  95     if (cd)
  96         yaz_iconv_close(cd);
  97     return ret_string;
  98 }
  99
 100 static const char *return_opac_record(WRBUF wrbuf,
 101                                       int marc_type,
 102                                       int *len,
 103                                       Z_OPACRecord *opac_rec,
 104                                       const char *record_charset)
 105 {
 106     yaz_iconv_t cd2;
 107     yaz_iconv_t cd = iconv_create_charset(record_charset, &cd2);
 108     yaz_marc_t mt = yaz_marc_create();
 109
 110     if (cd)
 111         yaz_marc_iconv(mt, cd);
 112     yaz_marc_xml(mt, marc_type);
 113
 114     if (cd2)
 115         yaz_opac_decode_wrbuf2(mt, opac_rec, wrbuf, cd2);
 116     else
 117         yaz_opac_decode_wrbuf(mt, opac_rec, wrbuf);
 118
 119     yaz_marc_destroy(mt);
 120
 121     if (cd)
 122         yaz_iconv_close(cd);
 123     if (cd2)
 124         yaz_iconv_close(cd2);
 125     *len = wrbuf_len(wrbuf);
 126     return wrbuf_cstr(wrbuf);
 127 }
 128
 129 static const char *return_string_record(WRBUF wrbuf,
 130                                         int *len,
 131                                         const char *buf, int sz,
 132                                         const char *record_charset)
 133 {
 134     yaz_iconv_t cd = iconv_create_charset(record_charset, 0);
 135
 136     if (cd)
 137     {
 138         wrbuf_iconv_write(wrbuf, cd, buf, sz);
 139         wrbuf_iconv_reset(wrbuf, cd);
 140
 141         buf = wrbuf_cstr(wrbuf);
 142         sz = wrbuf_len(wrbuf);
 143         yaz_iconv_close(cd);
 144     }
 145     *len = sz;
 146     return buf;
 147 }
 148
 149 static const char *return_record_wrbuf(WRBUF wrbuf, int *len,
 150                                        Z_NamePlusRecord *npr,
 151                                        int marctype, const char *charset)
 152 {
 153     Z_External *r = (Z_External *) npr->u.databaseRecord;
 154     const Odr_oid *oid = r->direct_reference;
 155
 156     wrbuf_rewind(wrbuf);
 157     /* render bibliographic record .. */
 158     if (r->which == Z_External_OPAC)
 159     {
 160         return return_opac_record(wrbuf, marctype, len,
 161                                   r->u.opac, charset);
 162     }
 163     if (r->which == Z_External_sutrs)
 164         return return_string_record(wrbuf, len,
 165                                     (char*) r->u.sutrs->buf,
 166                                     r->u.sutrs->len,
 167                                     charset);
 168     else if (r->which == Z_External_octet)
 169     {
 170         if (yaz_oid_is_iso2709(oid))
 171         {
 172             const char *ret_buf = return_marc_record(
 173                 wrbuf, marctype, len,
 174                 (const char *) r->u.octet_aligned->buf,
 175                 r->u.octet_aligned->len,
 176                 charset);
 177             if (ret_buf)
 178                 return ret_buf;
 179             /* bad ISO2709. Return fail unless raw (ISO2709) is wanted */
 180             if (marctype != YAZ_MARC_ISO2709)
 181                 return 0;
 182         }
 183         return return_string_record(wrbuf, len,
 184                                     (const char *) r->u.octet_aligned->buf,
 185                                     r->u.octet_aligned->len,
 186                                     charset);
 187     }
 188     else if (r->which == Z_External_grs1)
 189     {
 190         yaz_display_grs1(wrbuf, r->u.grs1, 0);
 191         return return_string_record(wrbuf, len,
 192                                     wrbuf_buf(wrbuf),
 193                                     wrbuf_len(wrbuf),
 194                                     charset);
 195     }
 196     return 0;
 197 }
 198
 199 static const char *get_record_format(WRBUF wrbuf, int *len,
 200                                      Z_NamePlusRecord *npr,
 201                                      int marctype, const char *charset,
 202                                      const char *format)
 203 {
 204     const char *res = return_record_wrbuf(wrbuf, len, npr, marctype, charset);
 205 #if YAZ_HAVE_XML2
 206     if (*format == '1')
 207     {
 208         /* try to XML format res */
 209         xmlDocPtr doc;
 210         xmlKeepBlanksDefault(0); /* get get xmlDocFormatMemory to work! */
 211         doc = xmlParseMemory(res, *len);
 212         if (doc)
 213         {
 214             xmlChar *xml_mem;
 215             int xml_size;
 216             xmlDocDumpFormatMemory(doc, &xml_mem, &xml_size, 1);
 217             wrbuf_rewind(wrbuf);
 218             wrbuf_write(wrbuf, (const char *) xml_mem, xml_size);
 219             xmlFree(xml_mem);
 220             xmlFreeDoc(doc);
 221             res = wrbuf_cstr(wrbuf);
 222             *len = wrbuf_len(wrbuf);
 223         }
 224     }
 225 #endif
 226     return res;
 227 }
 228
 229 #if YAZ_HAVE_XML2
 230 static int replace_node(NMEM nmem, xmlNode *ptr,
 231                         const char *type_spec, char *record_buf)
 232 {
 233     int ret = -1;
 234     const char *res;
 235     int len;
 236     int m_len;
 237     WRBUF wrbuf = wrbuf_alloc();
 238     ODR odr = odr_createmem(ODR_ENCODE);
 239     Z_NamePlusRecord *npr = odr_malloc(odr, sizeof(*npr));
 240     npr->which = Z_NamePlusRecord_databaseRecord;
 241
 242     if (atoi_n_check(record_buf, 5, &m_len))
 243         npr->u.databaseRecord =
 244             z_ext_record_usmarc(odr, record_buf, strlen(record_buf));
 245     else
 246         npr->u.databaseRecord =
 247             z_ext_record_xml(odr, record_buf, strlen(record_buf));
 248     res = yaz_record_render(npr, 0, wrbuf, type_spec, &len);
 249     if (res)
 250     {
 251         xmlDoc *doc = xmlParseMemory(res, strlen(res));
 252         if (doc)
 253         {
 254             xmlNode *nptr = xmlCopyNode(xmlDocGetRootElement(doc), 1);
 255             xmlReplaceNode(ptr, nptr);
 256             xmlFreeDoc(doc);
 257         }
 258         else
 259         {
 260             xmlNode *nptr = xmlNewText(BAD_CAST res);
 261             xmlReplaceNode(ptr, nptr);
 262         }
 263         ret = 0;
 264     }
 265     wrbuf_destroy(wrbuf);
 266     odr_destroy(odr);
 267     return ret;
 268 }
 269 #endif
 270
 271 static const char *base64_render(NMEM nmem, WRBUF wrbuf,
 272                                  const char *buf, int *len,
 273                                  const char *expr, const char *type_spec)
 274 {
 275 #if YAZ_HAVE_XML2
 276     xmlDocPtr doc = xmlParseMemory(buf, *len);
 277     if (doc)
 278     {
 279         xmlChar *buf_out;
 280         int len_out;
 281         xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
 282         if (xpathCtx)
 283         {
 284             xmlXPathObjectPtr xpathObj =
 285                 xmlXPathEvalExpression((const xmlChar *) expr, xpathCtx);
 286             if (xpathObj)
 287             {
 288                 xmlNodeSetPtr nodes = xpathObj->nodesetval;
 289                 if (nodes)
 290                 {
 291                     int i;
 292                     for (i = 0; i < nodes->nodeNr; i++)
 293                     {
 294                         xmlNode *ptr = nodes->nodeTab[i];
 295                         if (ptr->type == XML_TEXT_NODE)
 296                         {
 297                             const char *input =
 298                                 nmem_text_node_cdata(ptr, nmem);
 299                             char *output = nmem_malloc(
 300                                 nmem, strlen(input) + 1);
 301                             if (yaz_base64decode(input, output) == 0)
 302                             {
 303                                 if (!replace_node(nmem, ptr, type_spec, output))
 304                                 {
 305                                     /* replacement OK */
 306                                     xmlFreeNode(ptr);
 307                                     /* unset below to avoid a bad reference in
 308                                        xmlXPathFreeObject below */
 309                                     nodes->nodeTab[i] = 0;
 310                                 }
 311                             }
 312                         }
 313                     }
 314                 }
 315                 xmlXPathFreeObject(xpathObj);
 316             }
 317             xmlXPathFreeContext(xpathCtx);
 318         }
 319         xmlDocDumpMemory(doc, &buf_out, &len_out);
 320         if (buf_out)
 321         {
 322             wrbuf_rewind(wrbuf);
 323             wrbuf_write(wrbuf, (const char *) buf_out, len_out);
 324             buf = wrbuf_cstr(wrbuf);
 325             *len = len_out;
 326         }
 327         xmlFreeDoc(doc);
 328         xmlFree(buf_out);
 329     }
 330 #endif
 331     return buf;
 332 }
 333
 334 const char *yaz_record_render(Z_NamePlusRecord *npr, const char *schema,
 335                               WRBUF wrbuf,
 336                               const char *type_spec, int *len)
 337 {
 338     const char *ret = 0;
 339     NMEM nmem = 0;
 340     char *base64_xpath = 0;
 341     size_t i;
 342     char type[40];
 343     char charset[40];
 344     char format[3];
 345     const char *cp = type_spec;
 346     int len0;
 347
 348     if (!len)
 349         len = &len0;
 350
 351     for (i = 0; cp[i] && cp[i] != ';' && cp[i] != ' ' && i < sizeof(type)-1;
 352          i++)
 353         type[i] = cp[i];
 354     type[i] = '\0';
 355     charset[0] = '\0';
 356     format[0] = '\0';
 357     while (1)
 358     {
 359         while (cp[i] == ' ')
 360             i++;
 361         if (cp[i] != ';')
 362             break;
 363         i++;
 364         while (cp[i] == ' ')
 365             i++;
 366         if (!strncmp(cp + i, "charset=", 8))
 367         {
 368             size_t j = 0;
 369             i = i + 8; /* skip charset= */
 370             while (cp[i] == ' ')
 371                 i++;
 372             for (j = 0; cp[i] && cp[i] != ';' && cp[i] != ' '; i++)
 373             {
 374                 if (j < sizeof(charset)-1)
 375                     charset[j++] = cp[i];
 376             }
 377             charset[j] = '\0';
 378         }
 379         else if (!strncmp(cp + i, "format=", 7))
 380         {
 381             size_t j = 0;
 382             i = i + 7;
 383             while (cp[i] == ' ')
 384                 i++;
 385             for (j = 0; cp[i] && cp[i] != ';' && cp[i] != ' '; i++)
 386             {
 387                 if (j < sizeof(format)-1)
 388                     format[j++] = cp[i];
 389             }
 390             format[j] = '\0';
 391         }
 392         else if (!strncmp(cp + i, "base64=", 7))
 393         {
 394             size_t i0;
 395             i = i + 7;
 396             while (cp[i] == ' ')
 397                 i++;
 398             i0 = i;
 399             while (cp[i] && cp[i] != ';')
 400                 i++;
 401
 402             nmem = nmem_create();
 403             base64_xpath = nmem_strdupn(nmem, cp + i0, i - i0);
 404         }
 405     }
 406     if (!strcmp(type, "database"))
 407     {
 408         *len = (npr->databaseName ? strlen(npr->databaseName) : 0);
 409         ret = npr->databaseName;
 410     }
 411     else if (!strcmp(type, "schema"))
 412     {
 413         *len = schema ? strlen(schema) : 0;
 414         ret = schema;
 415     }
 416     else if (!strcmp(type, "syntax"))
 417     {
 418         const char *desc = 0;
 419         if (npr->which == Z_NamePlusRecord_databaseRecord)
 420         {
 421             Z_External *r = (Z_External *) npr->u.databaseRecord;
 422             desc = yaz_oid_to_string(yaz_oid_std(), r->direct_reference, 0);
 423         }
 424         if (!desc)
 425             desc = "none";
 426         *len = strlen(desc);
 427         ret = desc;
 428     }
 429     if (npr->which != Z_NamePlusRecord_databaseRecord)
 430         ;
 431     else if (!strcmp(type, "render"))
 432     {
 433         ret = get_record_format(wrbuf, len, npr, YAZ_MARC_LINE, charset, format);
 434     }
 435     else if (!strcmp(type, "xml"))
 436     {
 437         ret = get_record_format(wrbuf, len, npr, YAZ_MARC_MARCXML, charset,
 438                                 format);
 439     }
 440     else if (!strcmp(type, "txml"))
 441     {
 442         ret = get_record_format(wrbuf, len, npr, YAZ_MARC_TURBOMARC, charset,
 443                                 format);
 444     }
 445     else if (!strcmp(type, "raw"))
 446     {
 447         ret = get_record_format(wrbuf, len, npr, YAZ_MARC_ISO2709, charset,
 448                                 format);
 449     }
 450     else if (!strcmp(type, "ext"))
 451     {
 452         *len = -1;
 453         ret = (const char *) npr->u.databaseRecord;
 454     }
 455     else if (!strcmp(type, "opac"))
 456     {
 457         if (npr->u.databaseRecord->which == Z_External_OPAC)
 458             ret = get_record_format(wrbuf, len, npr, YAZ_MARC_MARCXML, charset,
 459                                     format);
 460     }
 461
 462     if (base64_xpath && *len != -1)
 463     {
 464         char *type_spec = nmem_malloc(nmem,
 465                                       strlen(type) + strlen(charset) + 11);
 466         strcpy(type_spec, type);
 467         if (*charset)
 468         {
 469             strcat(type_spec, "; charset=");
 470             strcat(type_spec, charset);
 471         }
 472         ret = base64_render(nmem, wrbuf, ret, len, base64_xpath, type_spec);
 473     }
 474     nmem_destroy(nmem);
 475     return ret;
 476 }
 477
 478 /*
 479  * Local variables:
 480  * c-basic-offset: 4
 481  * c-file-style: "Stroustrup"
 482  * indent-tabs-mode: nil
 483  * End:
 484  * vim: shiftwidth=4 tabstop=8 expandtab
 485  */
 486