src/filter_sru_to_z3950.cpp

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