src/filter_sru_to_z3950.cpp

   1 /* $Id: filter_sru_to_z3950.cpp,v 1.32 2007-03-20 07:20:16 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         if (soap)
 183         {
 184             mp_util::build_sru_explain(package, odr_en, sru_pdu_res,
 185                                        sruinfo, explainnode);
 186             mp_util::build_sru_response(package, odr_en, soap,
 187                                         sru_pdu_res, charset, stylesheet);
 188         }
 189         else
 190         {
 191             metaproxy_1::odr odr;
 192             Z_GDU *zgdu_res =
 193                 odr.create_HTTP_Response(package.session(),
 194                                          zgdu_req->u.HTTP_Request, 400);
 195             package.response() = zgdu_res;
 196         }
 197         return;
 198     }
 199
 200     // filter acts as sink for SRU explain requests
 201     if (sru_pdu_req && sru_pdu_req->which == Z_SRW_explain_request)
 202     {
 203         Z_SRW_explainRequest *er_req = sru_pdu_req->u.explain_request;
 204         //mp_util::build_simple_explain(package, odr_en, sru_pdu_res,
 205         //                           sruinfo, er_req);
 206         mp_util::build_sru_explain(package, odr_en, sru_pdu_res,
 207                                    sruinfo, explainnode, er_req);
 208     }
 209     else if (sru_pdu_req
 210         && sru_pdu_req->which == Z_SRW_searchRetrieve_request
 211         && sru_pdu_req->u.request)
 212     {   // searchRetrieve
 213         Z_SRW_searchRetrieveRequest *sr_req = sru_pdu_req->u.request;
 214
 215         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_searchRetrieve_response);
 216
 217         // checking that we have a query
 218         ok = mp_util::check_sru_query_exists(package, odr_en,
 219                                              sru_pdu_res, sr_req);
 220
 221         if (ok && z3950_init_request(package, odr_en, sru_pdu_res))
 222         {
 223             {
 224                 ok = z3950_search_request(package, odr_en,
 225                                           sru_pdu_res, sr_req);
 226
 227                 if (ok
 228                     && sru_pdu_res->u.response->numberOfRecords
 229                     && *(sru_pdu_res->u.response->numberOfRecords)
 230                     && sr_req->maximumRecords
 231                     && *(sr_req->maximumRecords))
 232
 233                     ok = z3950_present_request(package, odr_en,
 234                                                sru_pdu_res,
 235                                                sr_req);
 236                 z3950_close_request(package);
 237             }
 238         }
 239     }
 240
 241     // scan
 242     else if (sru_pdu_req
 243              && sru_pdu_req->which == Z_SRW_scan_request
 244              && sru_pdu_req->u.scan_request)
 245     {
 246         Z_SRW_scanRequest  *sr_req = sru_pdu_req->u.scan_request;
 247
 248         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_scan_response);
 249
 250         // we do not do scan at the moment, therefore issuing a diagnostic
 251         yaz_add_srw_diagnostic(odr_en,
 252                                &(sru_pdu_res->u.scan_response->diagnostics),
 253                                &(sru_pdu_res->u.scan_response->num_diagnostics),
 254                                4, "scan");
 255
 256         // to be used when we do scan
 257         if (false && z3950_init_request(package, odr_en, sru_pdu_res))
 258         {
 259             z3950_scan_request(package, odr_en, sru_pdu_res, sr_req);
 260             z3950_close_request(package);
 261         }
 262     }
 263     else
 264     {
 265         //std::cout << "SRU OPERATION NOT SUPPORTED \n";
 266         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 267
 268         // TODO: make nice diagnostic return package
 269         return;
 270     }
 271
 272     // build and send SRU response
 273     mp_util::build_sru_response(package, odr_en, soap,
 274                                 sru_pdu_res, charset, stylesheet);
 275 }
 276
 277
 278
 279 bool
 280 yf::SRUtoZ3950::Impl::z3950_init_request(mp::Package &package,
 281                                          mp::odr &odr_en,
 282                                          Z_SRW_PDU *sru_pdu_res,
 283                                          const std::string &database) const
 284 {
 285     // prepare Z3950 package
 286     Package z3950_package(package.session(), package.origin());
 287     z3950_package.copy_filter(package);
 288
 289     // set initRequest APDU
 290     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_initRequest);
 291     Z_InitRequest *init_req = apdu->u.initRequest;
 292     //TODO: add user name in apdu
 293     //TODO: add user passwd in apdu
 294     //init_req->idAuthentication = org_init->idAuthentication;
 295     //init_req->implementationId = "IDxyz";
 296     //init_req->implementationName = "NAMExyz";
 297     //init_req->implementationVersion = "VERSIONxyz";
 298
 299     ODR_MASK_SET(init_req->options, Z_Options_search);
 300     ODR_MASK_SET(init_req->options, Z_Options_present);
 301     ODR_MASK_SET(init_req->options, Z_Options_namedResultSets);
 302     ODR_MASK_SET(init_req->options, Z_Options_scan);
 303
 304     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_1);
 305     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_2);
 306     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_3);
 307
 308     z3950_package.request() = apdu;
 309
 310     // send Z3950 package
 311     z3950_package.move();
 312
 313     // dead Z3950 backend detection
 314     if (z3950_package.session().is_closed()){
 315         yaz_add_srw_diagnostic(odr_en,
 316                                &(sru_pdu_res->u.response->diagnostics),
 317                                &(sru_pdu_res->u.response->num_diagnostics),
 318                                2, 0);
 319         return false;
 320     }
 321
 322     // check successful initResponse
 323     Z_GDU *z3950_gdu = z3950_package.response().get();
 324
 325     if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 326         && z3950_gdu->u.z3950->which == Z_APDU_initResponse
 327         && *z3950_gdu->u.z3950->u.initResponse->result)
 328          return true;
 329
 330     yaz_add_srw_diagnostic(odr_en,
 331                            &(sru_pdu_res->u.response->diagnostics),
 332                            &(sru_pdu_res->u.response->num_diagnostics),
 333                            2, 0);
 334     return false;
 335 }
 336
 337 bool
 338 yf::SRUtoZ3950::Impl::z3950_close_request(mp::Package &package) const
 339 {
 340     // prepare and close Z3950 package
 341     Package z3950_package(package.session(), package.origin());
 342     z3950_package.copy_filter(package);
 343     z3950_package.session().close();
 344
 345     // set close APDU
 346     //mp::odr odr_en(ODR_ENCODE);
 347     //Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_close);
 348     //z3950_package.request() = apdu;
 349
 350     z3950_package.move();
 351
 352     // check successful close response
 353     //Z_GDU *z3950_gdu = z3950_package.response().get();
 354     //if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 355     //    && z3950_gdu->u.z3950->which == Z_APDU_close)
 356     //    return true;
 357
 358     if (z3950_package.session().is_closed()){
 359         return true;
 360     }
 361     return false;
 362 }
 363
 364 bool yf::SRUtoZ3950::Impl::z3950_search_request(mp::Package &package,
 365                                                 mp::odr &odr_en,
 366                                                 Z_SRW_PDU *sru_pdu_res,
 367                                                 Z_SRW_searchRetrieveRequest
 368                                                 const *sr_req) const
 369 {
 370
 371     assert(sru_pdu_res->u.response);
 372
 373     Package z3950_package(package.session(), package.origin());
 374     z3950_package.copy_filter(package);
 375
 376     //add stuff in z3950 apdu
 377     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_searchRequest);
 378     Z_SearchRequest *z_searchRequest = apdu->u.searchRequest;
 379
 380     // z3950'fy database
 381     z_searchRequest->num_databaseNames = 1;
 382     z_searchRequest->databaseNames = (char**)
 383         odr_malloc(odr_en, sizeof(char *));
 384
 385     if (sr_req->database)
 386         z_searchRequest->databaseNames[0]
 387             = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 388     else
 389         z_searchRequest->databaseNames[0]
 390             = odr_strdup(odr_en, "Default");
 391
 392
 393     // z3950'fy query
 394     Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 395     z_searchRequest->query = z_query;
 396
 397     if (!z3950_build_query(odr_en, z_query,
 398                            (const SRW_query&)sr_req->query,
 399                            sr_req->query_type))
 400     {
 401         yaz_add_srw_diagnostic(odr_en,
 402                                &(sru_pdu_res->u.response->diagnostics),
 403                                &(sru_pdu_res->u.response->num_diagnostics),
 404                                7, "query");
 405         return false;
 406     }
 407
 408     z3950_package.request() = apdu;
 409
 410     // send Z39.50 package off to backend
 411     z3950_package.move();
 412
 413
 414     Z_GDU *z3950_gdu = z3950_package.response().get();
 415
 416     //TODO: check success condition
 417     //int yaz_diag_bib1_to_srw (int bib1_code);
 418     //int yaz_diag_srw_to_bib1(int srw_code);
 419     //Se kode i src/seshigh.c (srw_bend_search, srw_bend_init).
 420
 421     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 422         || z3950_gdu->u.z3950->which != Z_APDU_searchResponse
 423         || !z3950_gdu->u.z3950->u.searchResponse
 424         || !z3950_gdu->u.z3950->u.searchResponse->searchStatus)
 425     {
 426         yaz_add_srw_diagnostic(odr_en,
 427                                &(sru_pdu_res->u.response->diagnostics),
 428                                &(sru_pdu_res->u.response->num_diagnostics),
 429                                2, 0);
 430         return false;
 431     }
 432
 433     // everything fine, continuing
 434     Z_SearchResponse *sr = z3950_gdu->u.z3950->u.searchResponse;
 435
 436     // checking non surrogate diagnostics in Z3950 search response package
 437     if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 438                                      sr->records))
 439     {
 440         return false;
 441     }
 442
 443     // Finally, roll on and srw'fy number of records
 444     sru_pdu_res->u.response->numberOfRecords
 445         = (int *) odr_malloc(odr_en, sizeof(int *));
 446     *(sru_pdu_res->u.response->numberOfRecords) = *(sr->resultCount);
 447
 448     // srw'fy nextRecordPosition
 449     //sru_pdu_res->u.response->nextRecordPosition
 450     //    = (int *) odr_malloc(odr_en, sizeof(int *));
 451     //*(sru_pdu_res->u.response->nextRecordPosition) = 1;
 452
 453     return true;
 454 }
 455
 456 bool
 457 yf::SRUtoZ3950::Impl::z3950_present_request(mp::Package &package,
 458                                            mp::odr &odr_en,
 459                                            Z_SRW_PDU *sru_pdu_res,
 460                                            Z_SRW_searchRetrieveRequest
 461                                            const *sr_req)
 462     const
 463 {
 464     assert(sru_pdu_res->u.response);
 465
 466     if (!sr_req)
 467         return false;
 468
 469
 470     // no need to work if nobody wants record ..
 471     if (!(sr_req->maximumRecords) || 0 == *(sr_req->maximumRecords))
 472         return true;
 473
 474     bool send_z3950_present = true;
 475
 476     // recordXPath unsupported.
 477     if (sr_req->recordXPath)
 478     {
 479         send_z3950_present = false;
 480         yaz_add_srw_diagnostic(odr_en,
 481                                &(sru_pdu_res->u.response->diagnostics),
 482                                &(sru_pdu_res->u.response->num_diagnostics),
 483                                72, 0);
 484     }
 485
 486     // resultSetTTL unsupported.
 487     // resultSetIdleTime in response
 488     if (sr_req->resultSetTTL)
 489     {
 490         send_z3950_present = false;
 491         yaz_add_srw_diagnostic(odr_en,
 492                                &(sru_pdu_res->u.response->diagnostics),
 493                                &(sru_pdu_res->u.response->num_diagnostics),
 494                                50, 0);
 495     }
 496
 497     // sort unsupported
 498     if (sr_req->sort_type != Z_SRW_sort_type_none)
 499     {
 500         send_z3950_present = false;
 501         yaz_add_srw_diagnostic(odr_en,
 502                                &(sru_pdu_res->u.response->diagnostics),
 503                                &(sru_pdu_res->u.response->num_diagnostics),
 504                                80, 0);
 505     }
 506
 507     // start record requested negative, or larger than number of records
 508     if (sr_req->startRecord
 509         &&
 510         ((*(sr_req->startRecord) < 0)       // negative
 511          ||
 512          (sru_pdu_res->u.response->numberOfRecords  //out of range
 513           && *(sr_req->startRecord)
 514           > *(sru_pdu_res->u.response->numberOfRecords))
 515         ))
 516     {
 517         send_z3950_present = false;
 518         yaz_add_srw_diagnostic(odr_en,
 519                                &(sru_pdu_res->u.response->diagnostics),
 520                                &(sru_pdu_res->u.response->num_diagnostics),
 521                                61, 0);
 522     }
 523
 524     // maximumRecords requested negative
 525     if (sr_req->maximumRecords
 526         && *(sr_req->maximumRecords) < 0)
 527
 528     {
 529         send_z3950_present = false;
 530         yaz_add_srw_diagnostic(odr_en,
 531                                &(sru_pdu_res->u.response->diagnostics),
 532                                &(sru_pdu_res->u.response->num_diagnostics),
 533                                6, "maximumRecords");
 534     }
 535
 536     // exit on all these above diagnostics
 537     if (!send_z3950_present)
 538         return false;
 539
 540     // now packaging the z3950 present request
 541     Package z3950_package(package.session(), package.origin());
 542     z3950_package.copy_filter(package);
 543     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_presentRequest);
 544
 545     assert(apdu->u.presentRequest);
 546
 547     // z3950'fy start record position
 548     if (sr_req->startRecord)
 549         *(apdu->u.presentRequest->resultSetStartPoint)
 550             = *(sr_req->startRecord);
 551     else
 552         *(apdu->u.presentRequest->resultSetStartPoint) = 1;
 553
 554     // z3950'fy number of records requested
 555     // protect against requesting records out of range
 556     if (sr_req->maximumRecords)
 557         *(apdu->u.presentRequest->numberOfRecordsRequested)
 558             = std::min(*(sr_req->maximumRecords),
 559                   *(sru_pdu_res->u.response->numberOfRecords)
 560                   - *(apdu->u.presentRequest->resultSetStartPoint)
 561                   + 1);
 562
 563     // z3950'fy recordPacking
 564     int record_packing = Z_SRW_recordPacking_XML;
 565     if (sr_req->recordPacking && 's' == *(sr_req->recordPacking))
 566         record_packing = Z_SRW_recordPacking_string;
 567
 568     // RecordSyntax will always be XML
 569     (apdu->u.presentRequest->preferredRecordSyntax)
 570         = yaz_oidval_to_z3950oid (odr_en, CLASS_RECSYN, VAL_TEXT_XML);
 571
 572     // z3950'fy record schema
 573      if (sr_req->recordSchema)
 574      {
 575          apdu->u.presentRequest->recordComposition
 576              = (Z_RecordComposition *)
 577                odr_malloc(odr_en, sizeof(Z_RecordComposition));
 578          apdu->u.presentRequest->recordComposition->which
 579              = Z_RecordComp_simple;
 580          apdu->u.presentRequest->recordComposition->u.simple
 581              = mp_util::build_esn_from_schema(odr_en,
 582                                       (const char *) sr_req->recordSchema);
 583      }
 584
 585     // z3950'fy time to live - flagged as diagnostics above
 586     //if (sr_req->resultSetTTL)
 587
 588     // attaching Z3950 package to filter chain
 589     z3950_package.request() = apdu;
 590
 591     // sending Z30.50 present request
 592     z3950_package.move();
 593
 594     //check successful Z3950 present response
 595     Z_GDU *z3950_gdu = z3950_package.response().get();
 596     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 597         || z3950_gdu->u.z3950->which != Z_APDU_presentResponse
 598         || !z3950_gdu->u.z3950->u.presentResponse)
 599
 600     {
 601         yaz_add_srw_diagnostic(odr_en,
 602                                &(sru_pdu_res->u.response->diagnostics),
 603                                &(sru_pdu_res->u.response->num_diagnostics),
 604                                2, 0);
 605         return false;
 606     }
 607
 608
 609     // everything fine, continuing
 610
 611     Z_PresentResponse *pr = z3950_gdu->u.z3950->u.presentResponse;
 612     Z_SRW_searchRetrieveResponse *sru_res = sru_pdu_res->u.response;
 613
 614
 615     // checking non surrogate diagnostics in Z3950 present response package
 616     if (!z3950_to_srw_diagnostics_ok(odr_en, sru_pdu_res->u.response,
 617                                      pr->records))
 618         return false;
 619
 620
 621
 622     // copy all records if existing
 623     if (pr->records && pr->records->which == Z_Records_DBOSD)
 624     {
 625         // srw'fy number of returned records
 626         sru_res->num_records
 627             = pr->records->u.databaseOrSurDiagnostics->num_records;
 628
 629         sru_res->records
 630             = (Z_SRW_record *) odr_malloc(odr_en,
 631                                           sru_res->num_records
 632                                              * sizeof(Z_SRW_record));
 633
 634
 635         // srw'fy nextRecordPosition
 636         // next position never zero or behind the last z3950 record
 637         if (pr->nextResultSetPosition
 638             && *(pr->nextResultSetPosition) > 0
 639             && *(pr->nextResultSetPosition)
 640                <= *(sru_pdu_res->u.response->numberOfRecords))
 641             sru_res->nextRecordPosition
 642                 = odr_intdup(odr_en, *(pr->nextResultSetPosition));
 643
 644         // inserting all records
 645         for (int i = 0; i < sru_res->num_records; i++)
 646         {
 647             Z_NamePlusRecord *npr
 648                 = pr->records->u.databaseOrSurDiagnostics->records[i];
 649
 650             sru_res->records[i].recordPosition
 651                 = odr_intdup(odr_en,
 652                            i + *(apdu->u.presentRequest->resultSetStartPoint));
 653
 654             sru_res->records[i].recordPacking = record_packing;
 655
 656             if (npr->which != Z_NamePlusRecord_databaseRecord)
 657             {
 658                 sru_res->records[i].recordSchema = "diagnostic";
 659                 sru_res->records[i].recordData_buf = "67";
 660                 sru_res->records[i].recordData_len = 2;
 661             }
 662             else
 663             {
 664                 Z_External *r = npr->u.databaseRecord;
 665                 oident *ent = oid_getentbyoid(r->direct_reference);
 666                 if (r->which == Z_External_octet
 667                     && ent->value == VAL_TEXT_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  */