src/filter_sru_to_z3950.cpp

   1 /* $Id: filter_sru_to_z3950.cpp,v 1.34 2007-04-16 21:54:52 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         = odr_oiddup(odr_en, yaz_oid_recsyn_xml);
 572
 573     // z3950'fy record schema
 574      if (sr_req->recordSchema)
 575      {
 576          apdu->u.presentRequest->recordComposition
 577              = (Z_RecordComposition *)
 578                odr_malloc(odr_en, sizeof(Z_RecordComposition));
 579          apdu->u.presentRequest->recordComposition->which
 580              = Z_RecordComp_simple;
 581          apdu->u.presentRequest->recordComposition->u.simple
 582              = mp_util::build_esn_from_schema(odr_en,
 583                                       (const char *) sr_req->recordSchema);
 584      }
 585
 586     // z3950'fy time to live - flagged as diagnostics above
 587     //if (sr_req->resultSetTTL)
 588
 589     // attaching Z3950 package to filter chain
 590     z3950_package.request() = apdu;
 591
 592     // sending Z30.50 present request
 593     z3950_package.move();
 594
 595     //check successful Z3950 present response
 596     Z_GDU *z3950_gdu = z3950_package.response().get();
 597     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 598         || z3950_gdu->u.z3950->which != Z_APDU_presentResponse
 599         || !z3950_gdu->u.z3950->u.presentResponse)
 600
 601     {
 602         yaz_add_srw_diagnostic(odr_en,
 603                                &(sru_pdu_res->u.response->diagnostics),
 604                                &(sru_pdu_res->u.response->num_diagnostics),
 605                                2, 0);
 606         return false;
 607     }
 608
 609
 610     // everything fine, continuing
 611
 612     Z_PresentResponse *pr = z3950_gdu->u.z3950->u.presentResponse;
 613     Z_SRW_searchRetrieveResponse *sru_res = sru_pdu_res->u.response;
 614
 615
 616     // checking non surrogate diagnostics in Z3950 present response package
 617     if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 618                                      pr->records))
 619         return false;
 620
 621
 622
 623     // copy all records if existing
 624     if (pr->records && pr->records->which == Z_Records_DBOSD)
 625     {
 626         // srw'fy number of returned records
 627         sru_res->num_records
 628             = pr->records->u.databaseOrSurDiagnostics->num_records;
 629
 630         sru_res->records
 631             = (Z_SRW_record *) odr_malloc(odr_en,
 632                                           sru_res->num_records
 633                                              * sizeof(Z_SRW_record));
 634
 635
 636         // srw'fy nextRecordPosition
 637         // next position never zero or behind the last z3950 record
 638         if (pr->nextResultSetPosition
 639             && *(pr->nextResultSetPosition) > 0
 640             && *(pr->nextResultSetPosition)
 641                <= *(sru_pdu_res->u.response->numberOfRecords))
 642             sru_res->nextRecordPosition
 643                 = odr_intdup(odr_en, *(pr->nextResultSetPosition));
 644
 645         // inserting all records
 646         for (int i = 0; i < sru_res->num_records; i++)
 647         {
 648             Z_NamePlusRecord *npr
 649                 = pr->records->u.databaseOrSurDiagnostics->records[i];
 650
 651             sru_res->records[i].recordPosition
 652                 = odr_intdup(odr_en,
 653                            i + *(apdu->u.presentRequest->resultSetStartPoint));
 654
 655             sru_res->records[i].recordPacking = record_packing;
 656
 657             if (npr->which != Z_NamePlusRecord_databaseRecord)
 658             {
 659                 sru_res->records[i].recordSchema = "diagnostic";
 660                 sru_res->records[i].recordData_buf = "67";
 661                 sru_res->records[i].recordData_len = 2;
 662             }
 663             else
 664             {
 665                 Z_External *r = npr->u.databaseRecord;
 666                 if (r->direct_reference
 667                     && !oid_oidcmp(r->direct_reference, yaz_oid_recsyn_xml))
 668                 {
 669                     sru_res->records[i].recordSchema = "dc";
 670                     sru_res->records[i].recordData_buf
 671                         = odr_strdupn(odr_en,
 672                                       (const char *)r->u.octet_aligned->buf,
 673                                       r->u.octet_aligned->len);
 674                     sru_res->records[i].recordData_len
 675                         = r->u.octet_aligned->len;
 676                 }
 677                 else
 678                 {
 679                     sru_res->records[i].recordSchema = "diagnostic";
 680                     sru_res->records[i].recordData_buf = "67";
 681                     sru_res->records[i].recordData_len = 2;
 682                 }
 683             }
 684         }
 685     }
 686
 687     return true;
 688 }
 689
 690 bool
 691 yf::SRUtoZ3950::Impl::z3950_scan_request(mp::Package &package,
 692                                         mp::odr &odr_en,
 693                                         Z_SRW_PDU *sru_pdu_res,
 694                                         Z_SRW_scanRequest const *sr_req) const
 695 {
 696     assert(sru_pdu_res->u.scan_response);
 697
 698     Package z3950_package(package.session(), package.origin());
 699     z3950_package.copy_filter(package);
 700     //mp::odr odr_en(ODR_ENCODE);
 701     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_scanRequest);
 702
 703     //TODO: add stuff in apdu
 704     Z_ScanRequest *z_scanRequest = apdu->u.scanRequest;
 705
 706     // database repackaging
 707     z_scanRequest->num_databaseNames = 1;
 708     z_scanRequest->databaseNames = (char**)
 709         odr_malloc(odr_en, sizeof(char *));
 710     if (sr_req->database)
 711         z_scanRequest->databaseNames[0]
 712             = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 713     else
 714         z_scanRequest->databaseNames[0]
 715             = odr_strdup(odr_en, "Default");
 716
 717
 718     // query repackaging
 719     // CQL or XCQL scan is not possible in Z3950, flagging a diagnostic
 720     if (sr_req->query_type != Z_SRW_query_type_pqf)
 721     {
 722         //send_to_srw_client_error(7, "query");
 723         return false;
 724     }
 725
 726     // PQF query repackaging
 727     // need to use Z_AttributesPlusTerm structure, not Z_Query
 728     // this can be digget out of a
 729     // Z_query->type1(Z_RPNQuery)->RPNStructure(Z_RPNStructure)
 730     //   ->u.simple(Z_Operand)->u.attributesPlusTerm(Z_AttributesPlusTerm )
 731
 732     //Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 733     //z_searchRequest->query = z_query;
 734
 735     //if (!z3950_build_query(odr_en, z_query,
 736     //                       (const SRW_query&)sr_req->query,
 737     //                       sr_req->query_type))
 738     //{
 739         //send_to_srw_client_error(7, "query");
 740     //    return false;
 741     //}
 742
 743     // TODO:
 744
 745     z3950_package.request() = apdu;
 746     std::cout << "z3950_scan_request " << *apdu << "\n";
 747
 748     z3950_package.move();
 749     //TODO: check success condition
 750     return true;
 751     return false;
 752 }
 753
 754 bool yf::SRUtoZ3950::Impl::z3950_build_query(mp::odr &odr_en, Z_Query *z_query,
 755                                             const SRW_query &query,
 756                                             SRW_query_type query_type) const
 757 {
 758     if (query_type == Z_SRW_query_type_cql)
 759     {
 760         Z_External *ext = (Z_External *)
 761             odr_malloc(odr_en, sizeof(*ext));
 762         ext->direct_reference =
 763             odr_getoidbystr(odr_en, "1.2.840.10003.16.2");
 764         ext->indirect_reference = 0;
 765         ext->descriptor = 0;
 766         ext->which = Z_External_CQL;
 767         ext->u.cql = const_cast<char *>(query.cql);
 768
 769         z_query->which = Z_Query_type_104;
 770         z_query->u.type_104 =  ext;
 771         return true;
 772     }
 773
 774     if (query_type == Z_SRW_query_type_pqf)
 775     {
 776         Z_RPNQuery *RPNquery;
 777         YAZ_PQF_Parser pqf_parser;
 778
 779         pqf_parser = yaz_pqf_create ();
 780
 781         RPNquery = yaz_pqf_parse (pqf_parser, odr_en, query.pqf);
 782         if (!RPNquery)
 783         {
 784             std::cout << "TODO: Handeling of bad PQF\n";
 785             std::cout << "TODO: Diagnostic to be send\n";
 786         }
 787         z_query->which = Z_Query_type_1;
 788         z_query->u.type_1 =  RPNquery;
 789
 790         yaz_pqf_destroy(pqf_parser);
 791         return true;
 792     }
 793     return false;
 794 }
 795
 796
 797 bool
 798 yf::SRUtoZ3950::Impl::z3950_to_srw_diagnostics_ok(mp::odr &odr_en,
 799                                                   Z_SRW_searchRetrieveResponse
 800                                                   *sru_res,
 801                                                   Z_Records *records) const
 802 {
 803     // checking non surrogate diagnostics in Z3950 present response package
 804     if (records
 805         && records->which == Z_Records_NSD
 806         && records->u.nonSurrogateDiagnostic)
 807     {
 808         z3950_to_srw_diag(odr_en, sru_res,
 809                           records->u.nonSurrogateDiagnostic);
 810         return false;
 811     }
 812     return true;
 813 }
 814
 815
 816 int
 817 yf::SRUtoZ3950::Impl::z3950_to_srw_diag(mp::odr &odr_en,
 818                                        Z_SRW_searchRetrieveResponse *sru_res,
 819                                        Z_DefaultDiagFormat *ddf) const
 820 {
 821     int bib1_code = *ddf->condition;
 822     sru_res->num_diagnostics = 1;
 823     sru_res->diagnostics = (Z_SRW_diagnostic *)
 824         odr_malloc(odr_en, sizeof(*sru_res->diagnostics));
 825     yaz_mk_std_diagnostic(odr_en, sru_res->diagnostics,
 826                           yaz_diag_bib1_to_srw(bib1_code),
 827                           ddf->u.v2Addinfo);
 828     return 0;
 829 }
 830
 831
 832
 833 static mp::filter::Base* filter_creator()
 834 {
 835     return new mp::filter::SRUtoZ3950;
 836 }
 837
 838 extern "C" {
 839     struct metaproxy_1_filter_struct metaproxy_1_filter_sru_to_z3950 = {
 840         0,
 841         "sru_z3950",
 842         filter_creator
 843     };
 844 }
 845
 846
 847 /*
 848  * Local variables:
 849  * c-basic-offset: 4
 850  * indent-tabs-mode: nil
 851  * c-file-style: "stroustrup"
 852  * End:
 853  * vim: shiftwidth=4 tabstop=8 expandtab
 854  */