src/filter_sru_to_z3950.cpp

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