src/filter_sru_to_z3950.cpp

   1 /* This file is part of Metaproxy.
   2    Copyright (C) 2005-2012 Index Data
   3
   4 Metaproxy 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 Metaproxy 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 // make std::min actually work on Windows
  20 #define NOMINMAX 1
  21
  22 #include "config.hpp"
  23 #include <metaproxy/package.hpp>
  24 #include <metaproxy/util.hpp>
  25 #include "gduutil.hpp"
  26 #include "sru_util.hpp"
  27 #include "filter_sru_to_z3950.hpp"
  28
  29 #include <yaz/srw.h>
  30 #include <yaz/pquery.h>
  31 #include <yaz/oid_db.h>
  32 #include <yaz/log.h>
  33
  34 #include <boost/thread/mutex.hpp>
  35 #include <boost/thread/condition.hpp>
  36
  37 #include <iostream>
  38 #include <sstream>
  39 #include <string>
  40 #include <map>
  41
  42 namespace mp = metaproxy_1;
  43 namespace mp_util = metaproxy_1::util;
  44 namespace yf = mp::filter;
  45
  46 namespace metaproxy_1 {
  47     namespace filter {
  48         class SRUtoZ3950::Frontend : boost::noncopyable {
  49             friend class Impl;
  50             bool m_in_use;
  51         public:
  52             Frontend();
  53             ~Frontend();
  54         };
  55         class SRUtoZ3950::Impl {
  56         public:
  57             void configure(const xmlNode *xmlnode);
  58             void process(metaproxy_1::Package &package);
  59         private:
  60             FrontendPtr get_frontend(mp::Package &package);
  61             void release_frontend(mp::Package &package);
  62             std::map<std::string, const xmlNode *> m_database_explain;
  63
  64             typedef std::map<std::string, int> ActiveUrlMap;
  65
  66             boost::mutex m_url_mutex;
  67             boost::condition m_cond_url_ready;
  68             ActiveUrlMap m_active_urls;
  69
  70
  71             boost::mutex m_mutex_session;
  72             boost::condition m_cond_session_ready;
  73             std::map<mp::Session, FrontendPtr> m_clients;
  74         private:
  75             void sru(metaproxy_1::Package &package, Z_GDU *zgdu_req);
  76             int z3950_build_query(
  77                 mp::odr &odr_en, Z_Query *z_query,
  78                 const Z_SRW_searchRetrieveRequest *req
  79                 ) const;
  80
  81             bool z3950_init_request(
  82                 mp::Package &package,
  83                 mp::odr &odr_en,
  84                 std::string zurl,
  85                 Z_SRW_PDU *sru_pdu_res,
  86                 const Z_SRW_PDU *sru_pdu_req
  87                 ) const;
  88
  89             bool z3950_close_request(mp::Package &package) const;
  90
  91             bool z3950_search_request(
  92                 mp::Package &package,
  93                 mp::odr &odr_en,
  94                 Z_SRW_PDU *sru_pdu_res,
  95                 Z_SRW_searchRetrieveRequest const *sr_req,
  96                 std::string zurl
  97                 ) const;
  98
  99             bool z3950_present_request(
 100                 mp::Package &package,
 101                 mp::odr &odr_en,
 102                 Z_SRW_PDU *sru_pdu_res,
 103                 Z_SRW_searchRetrieveRequest const *sr_req
 104                 ) const;
 105
 106             bool z3950_to_srw_diagnostics_ok(
 107                 mp::odr &odr_en,
 108                 Z_SRW_searchRetrieveResponse *srw_res,
 109                 Z_Records *records
 110                 ) const;
 111
 112             int z3950_to_srw_diag(
 113                 mp::odr &odr_en,
 114                 Z_SRW_searchRetrieveResponse *srw_res,
 115                 Z_DefaultDiagFormat *ddf
 116                 ) const;
 117
 118         };
 119     }
 120 }
 121
 122 yf::SRUtoZ3950::SRUtoZ3950() : m_p(new Impl)
 123 {
 124 }
 125
 126 yf::SRUtoZ3950::~SRUtoZ3950()
 127 {  // must have a destructor because of boost::scoped_ptr
 128 }
 129
 130 void yf::SRUtoZ3950::configure(const xmlNode *xmlnode, bool test_only,
 131                                const char *path)
 132 {
 133     m_p->configure(xmlnode);
 134 }
 135
 136 void yf::SRUtoZ3950::process(mp::Package &package) const
 137 {
 138     m_p->process(package);
 139 }
 140
 141 void yf::SRUtoZ3950::Impl::configure(const xmlNode *confignode)
 142 {
 143     const xmlNode * dbnode;
 144
 145     for (dbnode = confignode->children; dbnode; dbnode = dbnode->next)
 146     {
 147         if (dbnode->type != XML_ELEMENT_NODE)
 148             continue;
 149
 150         std::string database;
 151         mp::xml::check_element_mp(dbnode, "database");
 152
 153         for (struct _xmlAttr *attr = dbnode->properties;
 154              attr; attr = attr->next)
 155         {
 156
 157             mp::xml::check_attribute(attr, "", "name");
 158             database = mp::xml::get_text(attr);
 159
 160             const xmlNode *explainnode;
 161             for (explainnode = dbnode->children;
 162                  explainnode; explainnode = explainnode->next)
 163             {
 164                 if (explainnode->type != XML_ELEMENT_NODE)
 165                     continue;
 166                 if (explainnode)
 167                     break;
 168             }
 169             // assigning explain node to database name - no check yet
 170             m_database_explain.insert(std::make_pair(database, explainnode));
 171         }
 172     }
 173 }
 174
 175 void yf::SRUtoZ3950::Impl::sru(mp::Package &package, Z_GDU *zgdu_req)
 176 {
 177     bool ok = true;
 178
 179     mp::odr odr_de(ODR_DECODE);
 180     Z_SRW_PDU *sru_pdu_req = 0;
 181
 182     mp::odr odr_en(ODR_ENCODE);
 183     Z_SRW_PDU *sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 184
 185     // determine database with the HTTP header information only
 186     mp_util::SRUServerInfo sruinfo = mp_util::get_sru_server_info(package);
 187     std::map<std::string, const xmlNode *>::iterator idbexp;
 188     idbexp = m_database_explain.find(sruinfo.database);
 189
 190     // assign explain config XML DOM node if database is known
 191     const xmlNode *explainnode = 0;
 192     if (idbexp != m_database_explain.end())
 193     {
 194         explainnode = idbexp->second;
 195     }
 196
 197     // decode SRU request
 198     Z_SOAP *soap = 0;
 199     char *charset = 0;
 200     char *stylesheet = 0;
 201
 202     // filter acts as sink for non-valid SRU requests
 203     if (! (sru_pdu_req = mp_util::decode_sru_request(package, odr_de, odr_en,
 204                                                      sru_pdu_res, &soap,
 205                                                      charset, stylesheet)))
 206     {
 207         if (soap)
 208         {
 209             mp_util::build_sru_explain(package, odr_en, sru_pdu_res,
 210                                        sruinfo, explainnode);
 211             mp_util::build_sru_response(package, odr_en, soap,
 212                                         sru_pdu_res, charset, stylesheet);
 213         }
 214         else
 215         {
 216             metaproxy_1::odr odr;
 217             Z_GDU *zgdu_res =
 218                 odr.create_HTTP_Response(package.session(),
 219                                          zgdu_req->u.HTTP_Request, 400);
 220             package.response() = zgdu_res;
 221         }
 222         return;
 223     }
 224
 225     bool enable_package_log = false;
 226     std::string zurl;
 227     Z_SRW_extra_arg *arg;
 228
 229     for ( arg = sru_pdu_req->extra_args; arg; arg = arg->next)
 230         if (!strcmp(arg->name, "x-target"))
 231         {
 232             zurl = std::string(arg->value);
 233         }
 234         else if (!strcmp(arg->name, "x-max-sockets"))
 235         {
 236             package.origin().set_max_sockets(atoi(arg->value));
 237         }
 238         else if (!strcmp(arg->name, "x-session-id"))
 239         {
 240             package.origin().set_custom_session(arg->value);
 241         }
 242         else if (!strcmp(arg->name, "x-log-enable"))
 243         {
 244             if (*arg->value == '1')
 245             {
 246                 enable_package_log = true;
 247                 package.log_enable();
 248             }
 249         }
 250     assert(sru_pdu_req);
 251
 252     // filter acts as sink for SRU explain requests
 253     if (sru_pdu_req->which == Z_SRW_explain_request)
 254     {
 255         Z_SRW_explainRequest *er_req = sru_pdu_req->u.explain_request;
 256         mp_util::build_sru_explain(package, odr_en, sru_pdu_res,
 257                                    sruinfo, explainnode, er_req);
 258     }
 259     else if (sru_pdu_req->which == Z_SRW_searchRetrieve_request
 260              && sru_pdu_req->u.request)
 261     {   // searchRetrieve
 262         Z_SRW_searchRetrieveRequest *sr_req = sru_pdu_req->u.request;
 263
 264         sru_pdu_res = yaz_srw_get_pdu(odr_en, Z_SRW_searchRetrieve_response,
 265                                       sru_pdu_req->srw_version);
 266
 267         // checking that we have a query
 268         ok = mp_util::check_sru_query_exists(package, odr_en,
 269                                              sru_pdu_res, sr_req);
 270
 271         if (ok && z3950_init_request(package, odr_en,
 272                                      zurl, sru_pdu_res, sru_pdu_req))
 273         {
 274             ok = z3950_search_request(package, odr_en,
 275                                       sru_pdu_res, sr_req, zurl);
 276
 277             if (ok
 278                 && sru_pdu_res->u.response->numberOfRecords
 279                 && *(sru_pdu_res->u.response->numberOfRecords))
 280
 281                 ok = z3950_present_request(package, odr_en,
 282                                            sru_pdu_res,
 283                                            sr_req);
 284             z3950_close_request(package);
 285         }
 286     }
 287
 288     // scan
 289     else if (sru_pdu_req->which == Z_SRW_scan_request
 290              && sru_pdu_req->u.scan_request)
 291     {
 292         sru_pdu_res = yaz_srw_get_pdu(odr_en, Z_SRW_scan_response,
 293                                       sru_pdu_req->srw_version);
 294
 295         // we do not do scan at the moment, therefore issuing a diagnostic
 296         yaz_add_srw_diagnostic(odr_en,
 297                                &(sru_pdu_res->u.scan_response->diagnostics),
 298                                &(sru_pdu_res->u.scan_response->num_diagnostics),
 299                                YAZ_SRW_UNSUPP_OPERATION, "scan");
 300     }
 301     else
 302     {
 303         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 304
 305         yaz_add_srw_diagnostic(odr_en,
 306                                &(sru_pdu_res->u.explain_response->diagnostics),
 307                                &(sru_pdu_res->u.explain_response->num_diagnostics),
 308                                YAZ_SRW_UNSUPP_OPERATION, "unknown");
 309     }
 310
 311     if (enable_package_log)
 312     {
 313         std::string l;
 314         package.log_reset(l);
 315         if (l.length())
 316         {
 317             mp::wrbuf w;
 318
 319             wrbuf_puts(w, "<log>\n");
 320             wrbuf_xmlputs(w, l.c_str());
 321             wrbuf_puts(w, "</log>");
 322
 323             sru_pdu_res->extraResponseData_len = w.len();
 324             sru_pdu_res->extraResponseData_buf =
 325                 odr_strdup(odr_en, wrbuf_cstr(w));
 326         }
 327     }
 328
 329     // build and send SRU response
 330     mp_util::build_sru_response(package, odr_en, soap,
 331                                 sru_pdu_res, charset, stylesheet);
 332 }
 333
 334
 335 yf::SRUtoZ3950::Frontend::Frontend() :  m_in_use(true)
 336 {
 337 }
 338
 339 yf::SRUtoZ3950::Frontend::~Frontend()
 340 {
 341 }
 342
 343
 344 yf::SRUtoZ3950::FrontendPtr yf::SRUtoZ3950::Impl::get_frontend(
 345     mp::Package &package)
 346 {
 347     boost::mutex::scoped_lock lock(m_mutex_session);
 348
 349     std::map<mp::Session,yf::SRUtoZ3950::FrontendPtr>::iterator it;
 350
 351     while (true)
 352     {
 353         it = m_clients.find(package.session());
 354         if (it == m_clients.end())
 355             break;
 356
 357         if (!it->second->m_in_use)
 358         {
 359             it->second->m_in_use = true;
 360             return it->second;
 361         }
 362         m_cond_session_ready.wait(lock);
 363     }
 364     FrontendPtr f(new Frontend);
 365     m_clients[package.session()] = f;
 366     f->m_in_use = true;
 367     return f;
 368 }
 369
 370 void yf::SRUtoZ3950::Impl::release_frontend(mp::Package &package)
 371 {
 372     boost::mutex::scoped_lock lock(m_mutex_session);
 373     std::map<mp::Session,FrontendPtr>::iterator it;
 374
 375     it = m_clients.find(package.session());
 376     if (it != m_clients.end())
 377     {
 378         if (package.session().is_closed())
 379         {
 380             m_clients.erase(it);
 381         }
 382         else
 383         {
 384             it->second->m_in_use = false;
 385         }
 386         m_cond_session_ready.notify_all();
 387     }
 388 }
 389
 390 void yf::SRUtoZ3950::Impl::process(mp::Package &package)
 391 {
 392     FrontendPtr f = get_frontend(package);
 393
 394     Z_GDU *zgdu_req = package.request().get();
 395
 396     if (zgdu_req && zgdu_req->which == Z_GDU_HTTP_Request)
 397     {
 398         if (zgdu_req->u.HTTP_Request->content_len == 0)
 399         {
 400             const char *path = zgdu_req->u.HTTP_Request->path;
 401             boost::mutex::scoped_lock lock(m_url_mutex);
 402             while (1)
 403             {
 404                 ActiveUrlMap::iterator it = m_active_urls.find(path);
 405                 if (it == m_active_urls.end())
 406                 {
 407                     m_active_urls[path] = 1;
 408                     break;
 409                 }
 410                 yaz_log(YLOG_LOG, "Waiting for %s to complete", path);
 411                 m_cond_url_ready.wait(lock);
 412             }
 413         }
 414         sru(package, zgdu_req);
 415         if (zgdu_req && zgdu_req->u.HTTP_Request->content_len == 0)
 416         {
 417             const char *path = zgdu_req->u.HTTP_Request->path;
 418             boost::mutex::scoped_lock lock(m_url_mutex);
 419
 420             ActiveUrlMap::iterator it = m_active_urls.find(path);
 421
 422             m_active_urls.erase(it);
 423             m_cond_url_ready.notify_all();
 424         }
 425     }
 426     else
 427     {
 428         package.move();
 429     }
 430     release_frontend(package);
 431 }
 432
 433 bool
 434 yf::SRUtoZ3950::Impl::z3950_init_request(mp::Package &package,
 435                                          mp::odr &odr_en,
 436                                          std::string zurl,
 437                                          Z_SRW_PDU *sru_pdu_res,
 438                                          const Z_SRW_PDU *sru_pdu_req) const
 439 {
 440     // prepare Z3950 package
 441     Package z3950_package(package.session(), package.origin());
 442     z3950_package.copy_filter(package);
 443
 444     // set initRequest APDU
 445     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_initRequest);
 446     Z_InitRequest *init_req = apdu->u.initRequest;
 447
 448     Z_IdAuthentication *auth = NULL;
 449     if (sru_pdu_req->username && !sru_pdu_req->password)
 450     {
 451         auth = (Z_IdAuthentication *) odr_malloc(odr_en, sizeof(Z_IdAuthentication));
 452         auth->which = Z_IdAuthentication_open;
 453         auth->u.open = odr_strdup(odr_en, sru_pdu_req->username);
 454     }
 455     else if (sru_pdu_req->username && sru_pdu_req->password)
 456     {
 457         auth = (Z_IdAuthentication *) odr_malloc(odr_en, sizeof(Z_IdAuthentication));
 458         auth->which = Z_IdAuthentication_idPass;
 459         auth->u.idPass = (Z_IdPass *) odr_malloc(odr_en, sizeof(Z_IdPass));
 460         auth->u.idPass->groupId = NULL;
 461         auth->u.idPass->password = odr_strdup(odr_en, sru_pdu_req->password);
 462         auth->u.idPass->userId = odr_strdup(odr_en, sru_pdu_req->username);
 463     }
 464
 465     init_req->idAuthentication = auth;
 466
 467     *init_req->preferredMessageSize = 10*1024*1024;
 468     *init_req->maximumRecordSize = 10*1024*1024;
 469
 470     ODR_MASK_SET(init_req->options, Z_Options_search);
 471     ODR_MASK_SET(init_req->options, Z_Options_present);
 472     ODR_MASK_SET(init_req->options, Z_Options_namedResultSets);
 473     ODR_MASK_SET(init_req->options, Z_Options_scan);
 474
 475     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_1);
 476     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_2);
 477     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_3);
 478
 479     if (zurl.length())
 480     {
 481         std::string host;
 482         std::list<std::string> dblist;
 483         mp_util::split_zurl(zurl, host, dblist);
 484         mp_util::set_vhost_otherinfo(&init_req->otherInfo, odr_en, host, 1);
 485     }
 486
 487     z3950_package.request() = apdu;
 488
 489     // send Z3950 package
 490     z3950_package.move();
 491
 492     // check successful initResponse
 493     Z_GDU *z3950_gdu = z3950_package.response().get();
 494
 495     int error = YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE;
 496     const char *addinfo = 0;
 497     if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 498         && z3950_gdu->u.z3950->which == Z_APDU_initResponse)
 499     {
 500         Z_InitResponse *initrs = z3950_gdu->u.z3950->u.initResponse;
 501         if (*initrs->result)
 502             return true;
 503         int no = 0;
 504         while (1)
 505         {
 506             Z_DefaultDiagFormat *df = yaz_decode_init_diag(no, initrs);
 507
 508             if (!df)
 509                 break;
 510             yaz_add_srw_diagnostic(odr_en,
 511                                    &(sru_pdu_res->u.response->diagnostics),
 512                                    &(sru_pdu_res->u.response->num_diagnostics),
 513                                    yaz_diag_bib1_to_srw(*df->condition),
 514                                    df->u.v2Addinfo);
 515             no++;
 516         }
 517         if (no)
 518             return false; // got least one diagnostic from init
 519
 520         // we just have result=false.
 521         error = YAZ_SRW_AUTHENTICATION_ERROR;
 522     }
 523     else
 524         addinfo = "sru_z3950: expected initResponse";
 525     yaz_add_srw_diagnostic(odr_en,
 526                            &(sru_pdu_res->u.response->diagnostics),
 527                            &(sru_pdu_res->u.response->num_diagnostics),
 528                            error, addinfo);
 529     return false;
 530 }
 531
 532 bool yf::SRUtoZ3950::Impl::z3950_close_request(mp::Package &package) const
 533 {
 534     Package z3950_package(package.session(), package.origin());
 535     z3950_package.copy_filter(package);
 536     z3950_package.session().close();
 537
 538     z3950_package.move();
 539
 540     if (z3950_package.session().is_closed())
 541     {
 542         return true;
 543     }
 544     return false;
 545 }
 546
 547 bool yf::SRUtoZ3950::Impl::z3950_search_request(mp::Package &package,
 548                                                 mp::odr &odr_en,
 549                                                 Z_SRW_PDU *sru_pdu_res,
 550                                                 Z_SRW_searchRetrieveRequest
 551                                                 const *sr_req,
 552                                                 std::string zurl) const
 553 {
 554
 555     assert(sru_pdu_res->u.response);
 556
 557     Package z3950_package(package.session(), package.origin());
 558     z3950_package.copy_filter(package);
 559
 560     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_searchRequest);
 561     Z_SearchRequest *z_searchRequest = apdu->u.searchRequest;
 562
 563     // RecordSyntax will always be XML
 564     z_searchRequest->preferredRecordSyntax
 565         = odr_oiddup(odr_en, yaz_oid_recsyn_xml);
 566
 567     if (!mp_util::set_databases_from_zurl(odr_en, zurl,
 568                                           &z_searchRequest->num_databaseNames,
 569                                           &z_searchRequest->databaseNames))
 570     {
 571         z_searchRequest->num_databaseNames = 1;
 572         z_searchRequest->databaseNames = (char**)
 573             odr_malloc(odr_en, sizeof(char *));
 574
 575         if (sr_req->database)
 576             z_searchRequest->databaseNames[0]
 577                 = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 578         else
 579             z_searchRequest->databaseNames[0]
 580                 = odr_strdup(odr_en, "Default");
 581     }
 582
 583     Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 584     z_searchRequest->query = z_query;
 585
 586     int sru_diagnostic = z3950_build_query(odr_en, z_query, sr_req);
 587     if (sru_diagnostic)
 588     {
 589         yaz_add_srw_diagnostic(odr_en,
 590                                &(sru_pdu_res->u.response->diagnostics),
 591                                &(sru_pdu_res->u.response->num_diagnostics),
 592                                sru_diagnostic,
 593                                "query");
 594         return false;
 595     }
 596
 597     z3950_package.request() = apdu;
 598
 599     z3950_package.move();
 600
 601     Z_GDU *z3950_gdu = z3950_package.response().get();
 602
 603     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 604         || z3950_gdu->u.z3950->which != Z_APDU_searchResponse
 605         || !z3950_gdu->u.z3950->u.searchResponse
 606         || !z3950_gdu->u.z3950->u.searchResponse->searchStatus)
 607     {
 608         yaz_add_srw_diagnostic(odr_en,
 609                                &(sru_pdu_res->u.response->diagnostics),
 610                                &(sru_pdu_res->u.response->num_diagnostics),
 611                                YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE, 0);
 612         return false;
 613     }
 614
 615     Z_SearchResponse *sr = z3950_gdu->u.z3950->u.searchResponse;
 616
 617     if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 618                                      sr->records))
 619     {
 620         return false;
 621     }
 622
 623     sru_pdu_res->u.response->numberOfRecords
 624         = odr_intdup(odr_en, *sr->resultCount);
 625     return true;
 626 }
 627
 628 bool yf::SRUtoZ3950::Impl::z3950_present_request(
 629     mp::Package &package,
 630     mp::odr &odr_en,
 631     Z_SRW_PDU *sru_pdu_res,
 632     const Z_SRW_searchRetrieveRequest *sr_req)
 633     const
 634 {
 635     assert(sru_pdu_res->u.response);
 636     int start = 1;
 637     int max_recs = 0;
 638
 639     if (!sr_req)
 640         return false;
 641
 642     if (sr_req->maximumRecords)
 643         max_recs = *sr_req->maximumRecords;
 644     if (sr_req->startRecord)
 645         start = *sr_req->startRecord;
 646
 647     // no need to work if nobody wants record ..
 648     if (max_recs == 0)
 649         return true;
 650
 651     bool send_z3950_present = true;
 652
 653     // recordXPath unsupported.
 654     if (sr_req->recordXPath)
 655     {
 656         send_z3950_present = false;
 657         yaz_add_srw_diagnostic(odr_en,
 658                                &(sru_pdu_res->u.response->diagnostics),
 659                                &(sru_pdu_res->u.response->num_diagnostics),
 660                                YAZ_SRW_XPATH_RETRIEVAL_UNSUPP, 0);
 661     }
 662
 663     // resultSetTTL unsupported.
 664     // resultSetIdleTime in response
 665     if (sr_req->resultSetTTL)
 666     {
 667         send_z3950_present = false;
 668         yaz_add_srw_diagnostic(odr_en,
 669                                &(sru_pdu_res->u.response->diagnostics),
 670                                &(sru_pdu_res->u.response->num_diagnostics),
 671                                YAZ_SRW_RESULT_SETS_UNSUPP, 0);
 672     }
 673
 674     // sort unsupported
 675     if (sr_req->sort_type != Z_SRW_sort_type_none)
 676     {
 677         send_z3950_present = false;
 678         yaz_add_srw_diagnostic(odr_en,
 679                                &(sru_pdu_res->u.response->diagnostics),
 680                                &(sru_pdu_res->u.response->num_diagnostics),
 681                                YAZ_SRW_SORT_UNSUPP, 0);
 682     }
 683
 684     // start record requested negative, or larger than number of records
 685     if (start < 0 || start > *sru_pdu_res->u.response->numberOfRecords)
 686     {
 687         send_z3950_present = false;
 688         yaz_add_srw_diagnostic(odr_en,
 689                                &(sru_pdu_res->u.response->diagnostics),
 690                                &(sru_pdu_res->u.response->num_diagnostics),
 691                                YAZ_SRW_FIRST_RECORD_POSITION_OUT_OF_RANGE, 0);
 692     }
 693
 694     // maximumRecords requested negative
 695     if (max_recs < 0)
 696     {
 697         send_z3950_present = false;
 698         yaz_add_srw_diagnostic(odr_en,
 699                                &(sru_pdu_res->u.response->diagnostics),
 700                                &(sru_pdu_res->u.response->num_diagnostics),
 701                                YAZ_SRW_UNSUPP_PARAMETER_VALUE,
 702                                "maximumRecords");
 703     }
 704
 705     // exit on all these above diagnostics
 706     if (!send_z3950_present)
 707         return false;
 708
 709     if (max_recs > *sru_pdu_res->u.response->numberOfRecords - start)
 710         max_recs = *sru_pdu_res->u.response->numberOfRecords - start + 1;
 711
 712     Z_SRW_searchRetrieveResponse *sru_res = sru_pdu_res->u.response;
 713     sru_res->records = (Z_SRW_record *)
 714         odr_malloc(odr_en, max_recs * sizeof(Z_SRW_record));
 715     int num = 0;
 716     while (num < max_recs)
 717     {
 718         // now packaging the z3950 present request
 719         Package z3950_package(package.session(), package.origin());
 720         z3950_package.copy_filter(package);
 721         Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_presentRequest);
 722
 723         assert(apdu->u.presentRequest);
 724
 725         *apdu->u.presentRequest->resultSetStartPoint = start + num;
 726         *apdu->u.presentRequest->numberOfRecordsRequested = max_recs - num;
 727
 728         // set response packing to be same as "request" packing..
 729         int record_packing = Z_SRW_recordPacking_XML;
 730         if (sr_req->recordPacking && 's' == *(sr_req->recordPacking))
 731             record_packing = Z_SRW_recordPacking_string;
 732
 733         // RecordSyntax will always be XML
 734         apdu->u.presentRequest->preferredRecordSyntax
 735             = odr_oiddup(odr_en, yaz_oid_recsyn_xml);
 736
 737         // z3950'fy record schema
 738         if (sr_req->recordSchema)
 739         {
 740             apdu->u.presentRequest->recordComposition
 741                 = (Z_RecordComposition *)
 742                 odr_malloc(odr_en, sizeof(Z_RecordComposition));
 743             apdu->u.presentRequest->recordComposition->which
 744                 = Z_RecordComp_simple;
 745             apdu->u.presentRequest->recordComposition->u.simple
 746                 = mp_util::build_esn_from_schema(odr_en,
 747                                                  (const char *)
 748                                                  sr_req->recordSchema);
 749         }
 750
 751         // attaching Z3950 package to filter chain
 752         z3950_package.request() = apdu;
 753
 754         // sending Z30.50 present request
 755         z3950_package.move();
 756
 757         //check successful Z3950 present response
 758         Z_GDU *z3950_gdu = z3950_package.response().get();
 759         if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 760             || z3950_gdu->u.z3950->which != Z_APDU_presentResponse
 761             || !z3950_gdu->u.z3950->u.presentResponse)
 762
 763         {
 764             yaz_add_srw_diagnostic(odr_en,
 765                                    &(sru_pdu_res->u.response->diagnostics),
 766                                    &(sru_pdu_res->u.response->num_diagnostics),
 767                                    YAZ_SRW_SYSTEM_TEMPORARILY_UNAVAILABLE, 0);
 768             return false;
 769         }
 770         // everything fine, continuing
 771
 772         Z_PresentResponse *pr = z3950_gdu->u.z3950->u.presentResponse;
 773
 774         // checking non surrogate diagnostics in Z3950 present response package
 775         if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 776                                          pr->records))
 777             return false;
 778
 779         // if anything but database or surrogate diagnostics, stop
 780         if (!pr->records || pr->records->which != Z_Records_DBOSD)
 781             break;
 782         else
 783         {
 784             // inserting all records
 785             int returned_recs =
 786                 pr->records->u.databaseOrSurDiagnostics->num_records;
 787             for (int i = 0; i < returned_recs; i++)
 788             {
 789                 int position = i + *apdu->u.presentRequest->resultSetStartPoint;
 790                 Z_NamePlusRecord *npr
 791                     = pr->records->u.databaseOrSurDiagnostics->records[i];
 792
 793                 sru_res->records[i + num].recordPacking = record_packing;
 794
 795                 if (npr->which == Z_NamePlusRecord_surrogateDiagnostic)
 796                 {
 797                     Z_DiagRec *p = npr->u.surrogateDiagnostic;
 798                     if (p->which == Z_DiagRec_defaultFormat)
 799                     {
 800                         Z_DefaultDiagFormat *df = p->u.defaultFormat;
 801                         int c = yaz_diag_bib1_to_srw(*df->condition);
 802
 803                         yaz_mk_sru_surrogate(
 804                             odr_en, sru_res->records + i + num, position,
 805                             c, df->u.v2Addinfo);
 806                     }
 807                     else
 808                     {
 809                         yaz_mk_sru_surrogate(
 810                             odr_en, sru_res->records + i + num, position,
 811                             YAZ_SRW_RECORD_TEMPORARILY_UNAVAILABLE, 0);
 812                     }
 813                 }
 814                 else if (npr->which == Z_NamePlusRecord_databaseRecord &&
 815                     npr->u.databaseRecord->direct_reference
 816                     && !oid_oidcmp(npr->u.databaseRecord->direct_reference,
 817                                    yaz_oid_recsyn_xml))
 818                 {
 819                     // got XML record back
 820                     Z_External *r = npr->u.databaseRecord;
 821                     sru_res->records[i + num].recordPosition =
 822                         odr_intdup(odr_en, position);
 823                     sru_res->records[i + num].recordSchema = sr_req->recordSchema;
 824                     sru_res->records[i + num].recordData_buf
 825                         = odr_strdupn(odr_en,
 826                                       (const char *)r->u.octet_aligned->buf,
 827                                       r->u.octet_aligned->len);
 828                     sru_res->records[i + num].recordData_len
 829                         = r->u.octet_aligned->len;
 830                 }
 831                 else
 832                 {
 833                     // not XML or no database record at all
 834                     yaz_mk_sru_surrogate(
 835                         odr_en, sru_res->records + i + num, position,
 836                         YAZ_SRW_RECORD_NOT_AVAILABLE_IN_THIS_SCHEMA, 0);
 837                 }
 838             }
 839             num += returned_recs;
 840         }
 841     }
 842     sru_res->num_records = num;
 843     if (start - 1 + num < *sru_pdu_res->u.response->numberOfRecords)
 844         sru_res->nextRecordPosition =
 845             odr_intdup(odr_en, start + num);
 846     return true;
 847 }
 848
 849 int yf::SRUtoZ3950::Impl::z3950_build_query(
 850     mp::odr &odr_en, Z_Query *z_query,
 851     const Z_SRW_searchRetrieveRequest *req
 852     ) const
 853 {
 854     if (req->query_type == Z_SRW_query_type_cql)
 855     {
 856         Z_External *ext = (Z_External *)
 857             odr_malloc(odr_en, sizeof(*ext));
 858         ext->direct_reference =
 859             odr_getoidbystr(odr_en, "1.2.840.10003.16.2");
 860         ext->indirect_reference = 0;
 861         ext->descriptor = 0;
 862         ext->which = Z_External_CQL;
 863         ext->u.cql = odr_strdup(odr_en, req->query.cql);
 864
 865         z_query->which = Z_Query_type_104;
 866         z_query->u.type_104 =  ext;
 867         return 0;
 868     }
 869
 870     if (req->query_type == Z_SRW_query_type_pqf)
 871     {
 872         Z_RPNQuery *RPNquery;
 873         YAZ_PQF_Parser pqf_parser;
 874
 875         pqf_parser = yaz_pqf_create ();
 876
 877         RPNquery = yaz_pqf_parse (pqf_parser, odr_en, req->query.pqf);
 878
 879         yaz_pqf_destroy(pqf_parser);
 880
 881         if (!RPNquery)
 882             return YAZ_SRW_QUERY_SYNTAX_ERROR;
 883
 884         z_query->which = Z_Query_type_1;
 885         z_query->u.type_1 =  RPNquery;
 886
 887         return 0;
 888     }
 889     return YAZ_SRW_MANDATORY_PARAMETER_NOT_SUPPLIED;
 890 }
 891
 892 bool yf::SRUtoZ3950::Impl::z3950_to_srw_diagnostics_ok(
 893     mp::odr &odr_en,
 894     Z_SRW_searchRetrieveResponse
 895     *sru_res,
 896     Z_Records *records) const
 897 {
 898     // checking non surrogate diagnostics in Z3950 present response package
 899     if (records
 900         && records->which == Z_Records_NSD
 901         && records->u.nonSurrogateDiagnostic)
 902     {
 903         z3950_to_srw_diag(odr_en, sru_res,
 904                           records->u.nonSurrogateDiagnostic);
 905         return false;
 906     }
 907     return true;
 908 }
 909
 910 int yf::SRUtoZ3950::Impl::z3950_to_srw_diag(
 911     mp::odr &odr_en,
 912     Z_SRW_searchRetrieveResponse *sru_res,
 913     Z_DefaultDiagFormat *ddf) const
 914 {
 915     int bib1_code = *ddf->condition;
 916     sru_res->num_diagnostics = 1;
 917     sru_res->diagnostics = (Z_SRW_diagnostic *)
 918         odr_malloc(odr_en, sizeof(*sru_res->diagnostics));
 919     yaz_mk_std_diagnostic(odr_en, sru_res->diagnostics,
 920                           yaz_diag_bib1_to_srw(bib1_code),
 921                           ddf->u.v2Addinfo);
 922     return 0;
 923 }
 924
 925 static mp::filter::Base* filter_creator()
 926 {
 927     return new mp::filter::SRUtoZ3950;
 928 }
 929
 930 extern "C" {
 931     struct metaproxy_1_filter_struct metaproxy_1_filter_sru_to_z3950 = {
 932         0,
 933         "sru_z3950",
 934         filter_creator
 935     };
 936 }
 937
 938
 939 /*
 940  * Local variables:
 941  * c-basic-offset: 4
 942  * c-file-style: "Stroustrup"
 943  * indent-tabs-mode: nil
 944  * End:
 945  * vim: shiftwidth=4 tabstop=8 expandtab
 946  */
 947