src/filter_sru_to_z3950.cpp

   1 /* $Id: filter_sru_to_z3950.cpp,v 1.33 2007-04-13 09:57:51 adam Exp $
   2    Copyright (c) 2005-2007, Index Data.
   3
   4    See the LICENSE file for details
   5 */
   6
   7 #include "config.hpp"
   8 #include "filter.hpp"
   9 #include "package.hpp"
  10 #include "util.hpp"
  11 #include "gduutil.hpp"
  12 #include "sru_util.hpp"
  13 #include "filter_sru_to_z3950.hpp"
  14
  15 #include <yaz/zgdu.h>
  16 #include <yaz/z-core.h>
  17 #include <yaz/srw.h>
  18 #include <yaz/pquery.h>
  19 #include <yaz/oid_db.h>
  20
  21 #include <boost/thread/mutex.hpp>
  22
  23 #include <iostream>
  24 #include <sstream>
  25 #include <string>
  26 #include <algorithm>
  27 #include <map>
  28
  29 namespace mp = metaproxy_1;
  30 namespace mp_util = metaproxy_1::util;
  31 namespace yf = mp::filter;
  32
  33
  34 namespace metaproxy_1 {
  35     namespace filter {
  36         class SRUtoZ3950::Impl {
  37         public:
  38             void configure(const xmlNode *xmlnode);
  39             void process(metaproxy_1::Package &package);
  40         private:
  41             union SRW_query {char * cql; char * xcql; char * pqf;};
  42             typedef const int& SRW_query_type;
  43             std::map<std::string, const xmlNode *> m_database_explain;
  44         private:
  45
  46             bool z3950_build_query(mp::odr &odr_en, Z_Query *z_query,
  47                                    const SRW_query &query,
  48                                    SRW_query_type query_type) const;
  49
  50             bool z3950_init_request(mp::Package &package,
  51                                     mp::odr &odr_en,
  52                                     Z_SRW_PDU *sru_pdu_res,
  53                                     const std::string
  54                                     &database = "Default") const;
  55
  56             bool z3950_close_request(mp::Package &package) const;
  57
  58             bool z3950_search_request(mp::Package &package,
  59                                       mp::odr &odr_en,
  60                                       Z_SRW_PDU *sru_pdu_res,
  61                                       Z_SRW_searchRetrieveRequest
  62                                           const *sr_req) const;
  63
  64             bool z3950_present_request(mp::Package &package,
  65                                        mp::odr &odr_en,
  66                                        Z_SRW_PDU *sru_pdu_res,
  67                                        Z_SRW_searchRetrieveRequest
  68                                        const *sr_req) const;
  69
  70             bool z3950_scan_request(mp::Package &package,
  71                                     mp::odr &odr_en,
  72                                     Z_SRW_PDU *sru_pdu_res,
  73                                     Z_SRW_scanRequest
  74                                     const *sr_req) const;
  75
  76             bool z3950_to_srw_diagnostics_ok(mp::odr &odr_en,
  77                                   Z_SRW_searchRetrieveResponse *srw_res,
  78                                   Z_Records *records) const;
  79
  80             int z3950_to_srw_diag(mp::odr &odr_en,
  81                                   Z_SRW_searchRetrieveResponse *srw_res,
  82                                   Z_DefaultDiagFormat *ddf) const;
  83         };
  84     }
  85 }
  86
  87 yf::SRUtoZ3950::SRUtoZ3950() : m_p(new Impl)
  88 {
  89 }
  90
  91 yf::SRUtoZ3950::~SRUtoZ3950()
  92 {  // must have a destructor because of boost::scoped_ptr
  93 }
  94
  95 void yf::SRUtoZ3950::configure(const xmlNode *xmlnode)
  96 {
  97     m_p->configure(xmlnode);
  98 }
  99
 100 void yf::SRUtoZ3950::process(mp::Package &package) const
 101 {
 102     m_p->process(package);
 103 }
 104
 105 void yf::SRUtoZ3950::Impl::configure(const xmlNode *confignode)
 106 {
 107     const xmlNode * dbnode;
 108
 109     for (dbnode = confignode->children; dbnode; dbnode = dbnode->next){
 110         if (dbnode->type != XML_ELEMENT_NODE)
 111             continue;
 112
 113         std::string database;
 114         mp::xml::check_element_mp(dbnode, "database");
 115
 116         for (struct _xmlAttr *attr = dbnode->properties;
 117              attr; attr = attr->next){
 118
 119             mp::xml::check_attribute(attr, "", "name");
 120             database = mp::xml::get_text(attr);
 121
 122             const xmlNode *explainnode;
 123             for (explainnode = dbnode->children;
 124                  explainnode; explainnode = explainnode->next){
 125                 if (explainnode->type != XML_ELEMENT_NODE)
 126                     continue;
 127                 if (explainnode)
 128                     break;
 129             }
 130             // assigning explain node to database name - no check yet
 131             m_database_explain.insert(std::make_pair(database, explainnode));
 132          }
 133     }
 134 }
 135
 136 void yf::SRUtoZ3950::Impl::process(mp::Package &package)
 137 {
 138     Z_GDU *zgdu_req = package.request().get();
 139
 140     // ignoring all non HTTP_Request packages
 141     if (!zgdu_req || !(zgdu_req->which == Z_GDU_HTTP_Request)){
 142         package.move();
 143         return;
 144     }
 145
 146     // only working on  HTTP_Request packages now
 147
 148     bool ok = true;
 149
 150     mp::odr odr_de(ODR_DECODE);
 151     Z_SRW_PDU *sru_pdu_req = 0;
 152
 153     mp::odr odr_en(ODR_ENCODE);
 154     Z_SRW_PDU *sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 155
 156     // determine database with the HTTP header information only
 157     mp_util::SRUServerInfo sruinfo = mp_util::get_sru_server_info(package);
 158     std::map<std::string, const xmlNode *>::iterator idbexp;
 159     idbexp = m_database_explain.find(sruinfo.database);
 160
 161     // assign explain config XML DOM node if database is known
 162     const xmlNode *explainnode = 0;
 163     if (idbexp != m_database_explain.end()){
 164         explainnode = idbexp->second;
 165     }
 166     // just moving package if database is not known
 167     else {
 168         package.move();
 169         return;
 170     }
 171
 172
 173     // decode SRU request
 174     Z_SOAP *soap = 0;
 175     char *charset = 0;
 176     char *stylesheet = 0;
 177
 178     // filter acts as sink for non-valid SRU requests
 179     if (! (sru_pdu_req = mp_util::decode_sru_request(package, odr_de, odr_en,
 180                                             sru_pdu_res, &soap,
 181                                             charset, stylesheet)))
 182     {
 183         if (soap)
 184         {
 185             mp_util::build_sru_explain(package, odr_en, sru_pdu_res,
 186                                        sruinfo, explainnode);
 187             mp_util::build_sru_response(package, odr_en, soap,
 188                                         sru_pdu_res, charset, stylesheet);
 189         }
 190         else
 191         {
 192             metaproxy_1::odr odr;
 193             Z_GDU *zgdu_res =
 194                 odr.create_HTTP_Response(package.session(),
 195                                          zgdu_req->u.HTTP_Request, 400);
 196             package.response() = zgdu_res;
 197         }
 198         return;
 199     }
 200
 201     // filter acts as sink for SRU explain requests
 202     if (sru_pdu_req && sru_pdu_req->which == Z_SRW_explain_request)
 203     {
 204         Z_SRW_explainRequest *er_req = sru_pdu_req->u.explain_request;
 205         //mp_util::build_simple_explain(package, odr_en, sru_pdu_res,
 206         //                           sruinfo, er_req);
 207         mp_util::build_sru_explain(package, odr_en, sru_pdu_res,
 208                                    sruinfo, explainnode, er_req);
 209     }
 210     else if (sru_pdu_req
 211         && sru_pdu_req->which == Z_SRW_searchRetrieve_request
 212         && sru_pdu_req->u.request)
 213     {   // searchRetrieve
 214         Z_SRW_searchRetrieveRequest *sr_req = sru_pdu_req->u.request;
 215
 216         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_searchRetrieve_response);
 217
 218         // checking that we have a query
 219         ok = mp_util::check_sru_query_exists(package, odr_en,
 220                                              sru_pdu_res, sr_req);
 221
 222         if (ok && z3950_init_request(package, odr_en, sru_pdu_res))
 223         {
 224             {
 225                 ok = z3950_search_request(package, odr_en,
 226                                           sru_pdu_res, sr_req);
 227
 228                 if (ok
 229                     && sru_pdu_res->u.response->numberOfRecords
 230                     && *(sru_pdu_res->u.response->numberOfRecords)
 231                     && sr_req->maximumRecords
 232                     && *(sr_req->maximumRecords))
 233
 234                     ok = z3950_present_request(package, odr_en,
 235                                                sru_pdu_res,
 236                                                sr_req);
 237                 z3950_close_request(package);
 238             }
 239         }
 240     }
 241
 242     // scan
 243     else if (sru_pdu_req
 244              && sru_pdu_req->which == Z_SRW_scan_request
 245              && sru_pdu_req->u.scan_request)
 246     {
 247         Z_SRW_scanRequest  *sr_req = sru_pdu_req->u.scan_request;
 248
 249         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_scan_response);
 250
 251         // we do not do scan at the moment, therefore issuing a diagnostic
 252         yaz_add_srw_diagnostic(odr_en,
 253                                &(sru_pdu_res->u.scan_response->diagnostics),
 254                                &(sru_pdu_res->u.scan_response->num_diagnostics),
 255                                4, "scan");
 256
 257         // to be used when we do scan
 258         if (false && z3950_init_request(package, odr_en, sru_pdu_res))
 259         {
 260             z3950_scan_request(package, odr_en, sru_pdu_res, sr_req);
 261             z3950_close_request(package);
 262         }
 263     }
 264     else
 265     {
 266         //std::cout << "SRU OPERATION NOT SUPPORTED \n";
 267         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 268
 269         // TODO: make nice diagnostic return package
 270         return;
 271     }
 272
 273     // build and send SRU response
 274     mp_util::build_sru_response(package, odr_en, soap,
 275                                 sru_pdu_res, charset, stylesheet);
 276 }
 277
 278
 279
 280 bool
 281 yf::SRUtoZ3950::Impl::z3950_init_request(mp::Package &package,
 282                                          mp::odr &odr_en,
 283                                          Z_SRW_PDU *sru_pdu_res,
 284                                          const std::string &database) const
 285 {
 286     // prepare Z3950 package
 287     Package z3950_package(package.session(), package.origin());
 288     z3950_package.copy_filter(package);
 289
 290     // set initRequest APDU
 291     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_initRequest);
 292     Z_InitRequest *init_req = apdu->u.initRequest;
 293     //TODO: add user name in apdu
 294     //TODO: add user passwd in apdu
 295     //init_req->idAuthentication = org_init->idAuthentication;
 296     //init_req->implementationId = "IDxyz";
 297     //init_req->implementationName = "NAMExyz";
 298     //init_req->implementationVersion = "VERSIONxyz";
 299
 300     ODR_MASK_SET(init_req->options, Z_Options_search);
 301     ODR_MASK_SET(init_req->options, Z_Options_present);
 302     ODR_MASK_SET(init_req->options, Z_Options_namedResultSets);
 303     ODR_MASK_SET(init_req->options, Z_Options_scan);
 304
 305     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_1);
 306     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_2);
 307     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_3);
 308
 309     z3950_package.request() = apdu;
 310
 311     // send Z3950 package
 312     z3950_package.move();
 313
 314     // dead Z3950 backend detection
 315     if (z3950_package.session().is_closed()){
 316         yaz_add_srw_diagnostic(odr_en,
 317                                &(sru_pdu_res->u.response->diagnostics),
 318                                &(sru_pdu_res->u.response->num_diagnostics),
 319                                2, 0);
 320         return false;
 321     }
 322
 323     // check successful initResponse
 324     Z_GDU *z3950_gdu = z3950_package.response().get();
 325
 326     if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 327         && z3950_gdu->u.z3950->which == Z_APDU_initResponse
 328         && *z3950_gdu->u.z3950->u.initResponse->result)
 329          return true;
 330
 331     yaz_add_srw_diagnostic(odr_en,
 332                            &(sru_pdu_res->u.response->diagnostics),
 333                            &(sru_pdu_res->u.response->num_diagnostics),
 334                            2, 0);
 335     return false;
 336 }
 337
 338 bool
 339 yf::SRUtoZ3950::Impl::z3950_close_request(mp::Package &package) const
 340 {
 341     // prepare and close Z3950 package
 342     Package z3950_package(package.session(), package.origin());
 343     z3950_package.copy_filter(package);
 344     z3950_package.session().close();
 345
 346     // set close APDU
 347     //mp::odr odr_en(ODR_ENCODE);
 348     //Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_close);
 349     //z3950_package.request() = apdu;
 350
 351     z3950_package.move();
 352
 353     // check successful close response
 354     //Z_GDU *z3950_gdu = z3950_package.response().get();
 355     //if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 356     //    && z3950_gdu->u.z3950->which == Z_APDU_close)
 357     //    return true;
 358
 359     if (z3950_package.session().is_closed()){
 360         return true;
 361     }
 362     return false;
 363 }
 364
 365 bool yf::SRUtoZ3950::Impl::z3950_search_request(mp::Package &package,
 366                                                 mp::odr &odr_en,
 367                                                 Z_SRW_PDU *sru_pdu_res,
 368                                                 Z_SRW_searchRetrieveRequest
 369                                                 const *sr_req) const
 370 {
 371
 372     assert(sru_pdu_res->u.response);
 373
 374     Package z3950_package(package.session(), package.origin());
 375     z3950_package.copy_filter(package);
 376
 377     //add stuff in z3950 apdu
 378     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_searchRequest);
 379     Z_SearchRequest *z_searchRequest = apdu->u.searchRequest;
 380
 381     // z3950'fy database
 382     z_searchRequest->num_databaseNames = 1;
 383     z_searchRequest->databaseNames = (char**)
 384         odr_malloc(odr_en, sizeof(char *));
 385
 386     if (sr_req->database)
 387         z_searchRequest->databaseNames[0]
 388             = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 389     else
 390         z_searchRequest->databaseNames[0]
 391             = odr_strdup(odr_en, "Default");
 392
 393
 394     // z3950'fy query
 395     Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 396     z_searchRequest->query = z_query;
 397
 398     if (!z3950_build_query(odr_en, z_query,
 399                            (const SRW_query&)sr_req->query,
 400                            sr_req->query_type))
 401     {
 402         yaz_add_srw_diagnostic(odr_en,
 403                                &(sru_pdu_res->u.response->diagnostics),
 404                                &(sru_pdu_res->u.response->num_diagnostics),
 405                                7, "query");
 406         return false;
 407     }
 408
 409     z3950_package.request() = apdu;
 410
 411     // send Z39.50 package off to backend
 412     z3950_package.move();
 413
 414
 415     Z_GDU *z3950_gdu = z3950_package.response().get();
 416
 417     //TODO: check success condition
 418     //int yaz_diag_bib1_to_srw (int bib1_code);
 419     //int yaz_diag_srw_to_bib1(int srw_code);
 420     //Se kode i src/seshigh.c (srw_bend_search, srw_bend_init).
 421
 422     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 423         || z3950_gdu->u.z3950->which != Z_APDU_searchResponse
 424         || !z3950_gdu->u.z3950->u.searchResponse
 425         || !z3950_gdu->u.z3950->u.searchResponse->searchStatus)
 426     {
 427         yaz_add_srw_diagnostic(odr_en,
 428                                &(sru_pdu_res->u.response->diagnostics),
 429                                &(sru_pdu_res->u.response->num_diagnostics),
 430                                2, 0);
 431         return false;
 432     }
 433
 434     // everything fine, continuing
 435     Z_SearchResponse *sr = z3950_gdu->u.z3950->u.searchResponse;
 436
 437     // checking non surrogate diagnostics in Z3950 search response package
 438     if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 439                                      sr->records))
 440     {
 441         return false;
 442     }
 443
 444     // Finally, roll on and srw'fy number of records
 445     sru_pdu_res->u.response->numberOfRecords
 446         = (int *) odr_malloc(odr_en, sizeof(int *));
 447     *(sru_pdu_res->u.response->numberOfRecords) = *(sr->resultCount);
 448
 449     // srw'fy nextRecordPosition
 450     //sru_pdu_res->u.response->nextRecordPosition
 451     //    = (int *) odr_malloc(odr_en, sizeof(int *));
 452     //*(sru_pdu_res->u.response->nextRecordPosition) = 1;
 453
 454     return true;
 455 }
 456
 457 bool
 458 yf::SRUtoZ3950::Impl::z3950_present_request(mp::Package &package,
 459                                            mp::odr &odr_en,
 460                                            Z_SRW_PDU *sru_pdu_res,
 461                                            Z_SRW_searchRetrieveRequest
 462                                            const *sr_req)
 463     const
 464 {
 465     assert(sru_pdu_res->u.response);
 466
 467     if (!sr_req)
 468         return false;
 469
 470
 471     // no need to work if nobody wants record ..
 472     if (!(sr_req->maximumRecords) || 0 == *(sr_req->maximumRecords))
 473         return true;
 474
 475     bool send_z3950_present = true;
 476
 477     // recordXPath unsupported.
 478     if (sr_req->recordXPath)
 479     {
 480         send_z3950_present = false;
 481         yaz_add_srw_diagnostic(odr_en,
 482                                &(sru_pdu_res->u.response->diagnostics),
 483                                &(sru_pdu_res->u.response->num_diagnostics),
 484                                72, 0);
 485     }
 486
 487     // resultSetTTL unsupported.
 488     // resultSetIdleTime in response
 489     if (sr_req->resultSetTTL)
 490     {
 491         send_z3950_present = false;
 492         yaz_add_srw_diagnostic(odr_en,
 493                                &(sru_pdu_res->u.response->diagnostics),
 494                                &(sru_pdu_res->u.response->num_diagnostics),
 495                                50, 0);
 496     }
 497
 498     // sort unsupported
 499     if (sr_req->sort_type != Z_SRW_sort_type_none)
 500     {
 501         send_z3950_present = false;
 502         yaz_add_srw_diagnostic(odr_en,
 503                                &(sru_pdu_res->u.response->diagnostics),
 504                                &(sru_pdu_res->u.response->num_diagnostics),
 505                                80, 0);
 506     }
 507
 508     // start record requested negative, or larger than number of records
 509     if (sr_req->startRecord
 510         &&
 511         ((*(sr_req->startRecord) < 0)       // negative
 512          ||
 513          (sru_pdu_res->u.response->numberOfRecords  //out of range
 514           && *(sr_req->startRecord)
 515           > *(sru_pdu_res->u.response->numberOfRecords))
 516         ))
 517     {
 518         send_z3950_present = false;
 519         yaz_add_srw_diagnostic(odr_en,
 520                                &(sru_pdu_res->u.response->diagnostics),
 521                                &(sru_pdu_res->u.response->num_diagnostics),
 522                                61, 0);
 523     }
 524
 525     // maximumRecords requested negative
 526     if (sr_req->maximumRecords
 527         && *(sr_req->maximumRecords) < 0)
 528
 529     {
 530         send_z3950_present = false;
 531         yaz_add_srw_diagnostic(odr_en,
 532                                &(sru_pdu_res->u.response->diagnostics),
 533                                &(sru_pdu_res->u.response->num_diagnostics),
 534                                6, "maximumRecords");
 535     }
 536
 537     // exit on all these above diagnostics
 538     if (!send_z3950_present)
 539         return false;
 540
 541     // now packaging the z3950 present request
 542     Package z3950_package(package.session(), package.origin());
 543     z3950_package.copy_filter(package);
 544     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_presentRequest);
 545
 546     assert(apdu->u.presentRequest);
 547
 548     // z3950'fy start record position
 549     if (sr_req->startRecord)
 550         *(apdu->u.presentRequest->resultSetStartPoint)
 551             = *(sr_req->startRecord);
 552     else
 553         *(apdu->u.presentRequest->resultSetStartPoint) = 1;
 554
 555     // z3950'fy number of records requested
 556     // protect against requesting records out of range
 557     if (sr_req->maximumRecords)
 558         *(apdu->u.presentRequest->numberOfRecordsRequested)
 559             = std::min(*(sr_req->maximumRecords),
 560                   *(sru_pdu_res->u.response->numberOfRecords)
 561                   - *(apdu->u.presentRequest->resultSetStartPoint)
 562                   + 1);
 563
 564     // z3950'fy recordPacking
 565     int record_packing = Z_SRW_recordPacking_XML;
 566     if (sr_req->recordPacking && 's' == *(sr_req->recordPacking))
 567         record_packing = Z_SRW_recordPacking_string;
 568
 569     // RecordSyntax will always be XML
 570     apdu->u.presentRequest->preferredRecordSyntax
 571         = yaz_string_to_oid_odr(yaz_oid_std(), CLASS_RECSYN, OID_STR_XML,
 572                                 odr_en);
 573
 574     // z3950'fy record schema
 575      if (sr_req->recordSchema)
 576      {
 577          apdu->u.presentRequest->recordComposition
 578              = (Z_RecordComposition *)
 579                odr_malloc(odr_en, sizeof(Z_RecordComposition));
 580          apdu->u.presentRequest->recordComposition->which
 581              = Z_RecordComp_simple;
 582          apdu->u.presentRequest->recordComposition->u.simple
 583              = mp_util::build_esn_from_schema(odr_en,
 584                                       (const char *) sr_req->recordSchema);
 585      }
 586
 587     // z3950'fy time to live - flagged as diagnostics above
 588     //if (sr_req->resultSetTTL)
 589
 590     // attaching Z3950 package to filter chain
 591     z3950_package.request() = apdu;
 592
 593     // sending Z30.50 present request
 594     z3950_package.move();
 595
 596     //check successful Z3950 present response
 597     Z_GDU *z3950_gdu = z3950_package.response().get();
 598     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 599         || z3950_gdu->u.z3950->which != Z_APDU_presentResponse
 600         || !z3950_gdu->u.z3950->u.presentResponse)
 601
 602     {
 603         yaz_add_srw_diagnostic(odr_en,
 604                                &(sru_pdu_res->u.response->diagnostics),
 605                                &(sru_pdu_res->u.response->num_diagnostics),
 606                                2, 0);
 607         return false;
 608     }
 609
 610
 611     // everything fine, continuing
 612
 613     Z_PresentResponse *pr = z3950_gdu->u.z3950->u.presentResponse;
 614     Z_SRW_searchRetrieveResponse *sru_res = sru_pdu_res->u.response;
 615
 616
 617     // checking non surrogate diagnostics in Z3950 present response package
 618     if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 619                                      pr->records))
 620         return false;
 621
 622
 623
 624     // copy all records if existing
 625     if (pr->records && pr->records->which == Z_Records_DBOSD)
 626     {
 627         // srw'fy number of returned records
 628         sru_res->num_records
 629             = pr->records->u.databaseOrSurDiagnostics->num_records;
 630
 631         sru_res->records
 632             = (Z_SRW_record *) odr_malloc(odr_en,
 633                                           sru_res->num_records
 634                                              * sizeof(Z_SRW_record));
 635
 636
 637         // srw'fy nextRecordPosition
 638         // next position never zero or behind the last z3950 record
 639         if (pr->nextResultSetPosition
 640             && *(pr->nextResultSetPosition) > 0
 641             && *(pr->nextResultSetPosition)
 642                <= *(sru_pdu_res->u.response->numberOfRecords))
 643             sru_res->nextRecordPosition
 644                 = odr_intdup(odr_en, *(pr->nextResultSetPosition));
 645
 646         // inserting all records
 647         for (int i = 0; i < sru_res->num_records; i++)
 648         {
 649             Z_NamePlusRecord *npr
 650                 = pr->records->u.databaseOrSurDiagnostics->records[i];
 651
 652             sru_res->records[i].recordPosition
 653                 = odr_intdup(odr_en,
 654                            i + *(apdu->u.presentRequest->resultSetStartPoint));
 655
 656             sru_res->records[i].recordPacking = record_packing;
 657
 658             if (npr->which != Z_NamePlusRecord_databaseRecord)
 659             {
 660                 sru_res->records[i].recordSchema = "diagnostic";
 661                 sru_res->records[i].recordData_buf = "67";
 662                 sru_res->records[i].recordData_len = 2;
 663             }
 664             else
 665             {
 666                 Z_External *r = npr->u.databaseRecord;
 667                 const int *xml_oid = yaz_string_to_oid(yaz_oid_std(),
 668                                                        CLASS_RECSYN,
 669                                                        OID_STR_XML);
 670                 if (xml_oid && r->direct_reference
 671                     && !oid_oidcmp(r->direct_reference, xml_oid))
 672                 {
 673                     sru_res->records[i].recordSchema = "dc";
 674                     sru_res->records[i].recordData_buf
 675                         = odr_strdupn(odr_en,
 676                                       (const char *)r->u.octet_aligned->buf,
 677                                       r->u.octet_aligned->len);
 678                     sru_res->records[i].recordData_len
 679                         = r->u.octet_aligned->len;
 680                 }
 681                 else
 682                 {
 683                     sru_res->records[i].recordSchema = "diagnostic";
 684                     sru_res->records[i].recordData_buf = "67";
 685                     sru_res->records[i].recordData_len = 2;
 686                 }
 687             }
 688         }
 689     }
 690
 691     return true;
 692 }
 693
 694 bool
 695 yf::SRUtoZ3950::Impl::z3950_scan_request(mp::Package &package,
 696                                         mp::odr &odr_en,
 697                                         Z_SRW_PDU *sru_pdu_res,
 698                                         Z_SRW_scanRequest const *sr_req) const
 699 {
 700     assert(sru_pdu_res->u.scan_response);
 701
 702     Package z3950_package(package.session(), package.origin());
 703     z3950_package.copy_filter(package);
 704     //mp::odr odr_en(ODR_ENCODE);
 705     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_scanRequest);
 706
 707     //TODO: add stuff in apdu
 708     Z_ScanRequest *z_scanRequest = apdu->u.scanRequest;
 709
 710     // database repackaging
 711     z_scanRequest->num_databaseNames = 1;
 712     z_scanRequest->databaseNames = (char**)
 713         odr_malloc(odr_en, sizeof(char *));
 714     if (sr_req->database)
 715         z_scanRequest->databaseNames[0]
 716             = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 717     else
 718         z_scanRequest->databaseNames[0]
 719             = odr_strdup(odr_en, "Default");
 720
 721
 722     // query repackaging
 723     // CQL or XCQL scan is not possible in Z3950, flagging a diagnostic
 724     if (sr_req->query_type != Z_SRW_query_type_pqf)
 725     {
 726         //send_to_srw_client_error(7, "query");
 727         return false;
 728     }
 729
 730     // PQF query repackaging
 731     // need to use Z_AttributesPlusTerm structure, not Z_Query
 732     // this can be digget out of a
 733     // Z_query->type1(Z_RPNQuery)->RPNStructure(Z_RPNStructure)
 734     //   ->u.simple(Z_Operand)->u.attributesPlusTerm(Z_AttributesPlusTerm )
 735
 736     //Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 737     //z_searchRequest->query = z_query;
 738
 739     //if (!z3950_build_query(odr_en, z_query,
 740     //                       (const SRW_query&)sr_req->query,
 741     //                       sr_req->query_type))
 742     //{
 743         //send_to_srw_client_error(7, "query");
 744     //    return false;
 745     //}
 746
 747     // TODO:
 748
 749     z3950_package.request() = apdu;
 750     std::cout << "z3950_scan_request " << *apdu << "\n";
 751
 752     z3950_package.move();
 753     //TODO: check success condition
 754     return true;
 755     return false;
 756 }
 757
 758 bool yf::SRUtoZ3950::Impl::z3950_build_query(mp::odr &odr_en, Z_Query *z_query,
 759                                             const SRW_query &query,
 760                                             SRW_query_type query_type) const
 761 {
 762     if (query_type == Z_SRW_query_type_cql)
 763     {
 764         Z_External *ext = (Z_External *)
 765             odr_malloc(odr_en, sizeof(*ext));
 766         ext->direct_reference =
 767             odr_getoidbystr(odr_en, "1.2.840.10003.16.2");
 768         ext->indirect_reference = 0;
 769         ext->descriptor = 0;
 770         ext->which = Z_External_CQL;
 771         ext->u.cql = const_cast<char *>(query.cql);
 772
 773         z_query->which = Z_Query_type_104;
 774         z_query->u.type_104 =  ext;
 775         return true;
 776     }
 777
 778     if (query_type == Z_SRW_query_type_pqf)
 779     {
 780         Z_RPNQuery *RPNquery;
 781         YAZ_PQF_Parser pqf_parser;
 782
 783         pqf_parser = yaz_pqf_create ();
 784
 785         RPNquery = yaz_pqf_parse (pqf_parser, odr_en, query.pqf);
 786         if (!RPNquery)
 787         {
 788             std::cout << "TODO: Handeling of bad PQF\n";
 789             std::cout << "TODO: Diagnostic to be send\n";
 790         }
 791         z_query->which = Z_Query_type_1;
 792         z_query->u.type_1 =  RPNquery;
 793
 794         yaz_pqf_destroy(pqf_parser);
 795         return true;
 796     }
 797     return false;
 798 }
 799
 800
 801 bool
 802 yf::SRUtoZ3950::Impl::z3950_to_srw_diagnostics_ok(mp::odr &odr_en,
 803                                                   Z_SRW_searchRetrieveResponse
 804                                                   *sru_res,
 805                                                   Z_Records *records) const
 806 {
 807     // checking non surrogate diagnostics in Z3950 present response package
 808     if (records
 809         && records->which == Z_Records_NSD
 810         && records->u.nonSurrogateDiagnostic)
 811     {
 812         z3950_to_srw_diag(odr_en, sru_res,
 813                           records->u.nonSurrogateDiagnostic);
 814         return false;
 815     }
 816     return true;
 817 }
 818
 819
 820 int
 821 yf::SRUtoZ3950::Impl::z3950_to_srw_diag(mp::odr &odr_en,
 822                                        Z_SRW_searchRetrieveResponse *sru_res,
 823                                        Z_DefaultDiagFormat *ddf) const
 824 {
 825     int bib1_code = *ddf->condition;
 826     sru_res->num_diagnostics = 1;
 827     sru_res->diagnostics = (Z_SRW_diagnostic *)
 828         odr_malloc(odr_en, sizeof(*sru_res->diagnostics));
 829     yaz_mk_std_diagnostic(odr_en, sru_res->diagnostics,
 830                           yaz_diag_bib1_to_srw(bib1_code),
 831                           ddf->u.v2Addinfo);
 832     return 0;
 833 }
 834
 835
 836
 837 static mp::filter::Base* filter_creator()
 838 {
 839     return new mp::filter::SRUtoZ3950;
 840 }
 841
 842 extern "C" {
 843     struct metaproxy_1_filter_struct metaproxy_1_filter_sru_to_z3950 = {
 844         0,
 845         "sru_z3950",
 846         filter_creator
 847     };
 848 }
 849
 850
 851 /*
 852  * Local variables:
 853  * c-basic-offset: 4
 854  * indent-tabs-mode: nil
 855  * c-file-style: "stroustrup"
 856  * End:
 857  * vim: shiftwidth=4 tabstop=8 expandtab
 858  */