src/filter_sru_to_z3950.cpp

   1 /* $Id: filter_sru_to_z3950.cpp,v 1.19 2006-10-02 13:44:48 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
  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             //std::string sru_protocol(const Z_HTTP_Request &http_req) const;
  43             std::string debug_http(const Z_HTTP_Request &http_req) const;
  44             void http_response(mp::Package &package,
  45                                const std::string &content,
  46                                int http_code = 200) const;
  47             bool build_sru_debug_package(mp::Package &package) const;
  48             bool build_simple_explain(mp::Package &package,
  49                                       mp::odr &odr_en,
  50                                       Z_SRW_PDU *sru_pdu_res,
  51                                       Z_SRW_explainRequest const *er_req)
  52                 const;
  53             bool build_sru_response(mp::Package &package,
  54                                     mp::odr &odr_en,
  55                                     Z_SOAP *soap,
  56                                     const Z_SRW_PDU *sru_pdu_res,
  57                                     char *charset,
  58                                     const char *stylesheet) const;
  59             Z_SRW_PDU * decode_sru_request(mp::Package &package,
  60                                            mp::odr &odr_de,
  61                                            mp::odr &odr_en,
  62                                            Z_SRW_PDU *sru_pdu_res,
  63                                            Z_SOAP *&soap,
  64                                            char *charset,
  65                                            char *stylesheet) const;
  66             bool check_sru_query_exists(mp::Package &package,
  67                                        mp::odr &odr_en,
  68                                        Z_SRW_PDU *sru_pdu_res,
  69                                        Z_SRW_searchRetrieveRequest
  70                                        const *sr_req) const;
  71             bool z3950_build_query(mp::odr &odr_en, Z_Query *z_query,
  72                                    const SRW_query &query,
  73                                    SRW_query_type query_type) const;
  74             bool z3950_init_request(mp::Package &package,
  75                                          const std::string
  76                                          &database = "Default") const;
  77             bool z3950_close_request(mp::Package &package) const;
  78             bool z3950_search_request(mp::Package &package,
  79                                       mp::odr &odr_en,
  80                                       Z_SRW_PDU *sru_pdu_res,
  81                                       Z_SRW_searchRetrieveRequest
  82                                           const *sr_req) const;
  83             bool z3950_present_request(mp::Package &package,
  84                                        mp::odr &odr_en,
  85                                        Z_SRW_PDU *sru_pdu_res,
  86                                        Z_SRW_searchRetrieveRequest
  87                                        const *sr_req) const;
  88             bool z3950_scan_request(mp::Package &package,
  89                                     mp::odr &odr_en,
  90                                     Z_SRW_PDU *sru_pdu_res,
  91                                     Z_SRW_scanRequest
  92                                     const *sr_req) const;
  93             Z_ElementSetNames * build_esn_from_schema(mp::odr &odr_en,
  94                                                       const char *schema)
  95                 const;
  96             int z3950_to_srw_diag(mp::odr &odr_en,
  97                                   Z_SRW_searchRetrieveResponse *srw_res,
  98                                   Z_DefaultDiagFormat *ddf) const;
  99         };
 100     }
 101 }
 102
 103 yf::SRUtoZ3950::SRUtoZ3950() : m_p(new Impl)
 104 {
 105 }
 106
 107 yf::SRUtoZ3950::~SRUtoZ3950()
 108 {  // must have a destructor because of boost::scoped_ptr
 109 }
 110
 111 void yf::SRUtoZ3950::configure(const xmlNode *xmlnode)
 112 {
 113     m_p->configure(xmlnode);
 114 }
 115
 116 void yf::SRUtoZ3950::process(mp::Package &package) const
 117 {
 118     m_p->process(package);
 119 }
 120
 121 void yf::SRUtoZ3950::Impl::configure(const xmlNode *xmlnode)
 122 {
 123 }
 124
 125 void yf::SRUtoZ3950::Impl::process(mp::Package &package) const
 126 {
 127     Z_GDU *zgdu_req = package.request().get();
 128
 129     // ignoring all non HTTP_Request packages
 130     if (!zgdu_req || !(zgdu_req->which == Z_GDU_HTTP_Request)){
 131         package.move();
 132         return;
 133     }
 134
 135     // only working on  HTTP_Request packages now
 136
 137
 138     // TODO: Z3950 response parsing and translation to SRU package
 139     bool ok = true;
 140
 141     mp::odr odr_de(ODR_DECODE);
 142     Z_SRW_PDU *sru_pdu_req = 0;
 143
 144     mp::odr odr_en(ODR_ENCODE);
 145     //Z_SRW_PDU *sru_pdu_res = 0;
 146     Z_SRW_PDU *sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 147
 148     Z_SOAP *soap = 0;
 149     char *charset = 0;
 150     char *stylesheet = 0;
 151
 152     if (! (sru_pdu_req = decode_sru_request(package, odr_de, odr_en,
 153                                             sru_pdu_res, soap,
 154                                             charset, stylesheet)))
 155     {
 156         build_simple_explain(package, odr_en, sru_pdu_res, 0);
 157         build_sru_response(package, odr_en, soap,
 158                            sru_pdu_res, charset, stylesheet);
 159         package.session().close();
 160         return;
 161     }
 162
 163
 164     // SRU request package translation to Z3950 package
 165     if (sru_pdu_req)
 166         std::cout << *sru_pdu_req << "\n";
 167     else
 168         std::cout << "SRU empty\n";
 169
 170
 171     // explain
 172     if (sru_pdu_req && sru_pdu_req->which == Z_SRW_explain_request)
 173     {
 174         Z_SRW_explainRequest *er_req = sru_pdu_req->u.explain_request;
 175         //sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 176
 177         build_simple_explain(package, odr_en, sru_pdu_res, er_req);
 178     }
 179
 180     // searchRetrieve
 181     else if (sru_pdu_req
 182         && sru_pdu_req->which == Z_SRW_searchRetrieve_request
 183         && sru_pdu_req->u.request)
 184     {
 185         Z_SRW_searchRetrieveRequest *sr_req = sru_pdu_req->u.request;
 186
 187         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_searchRetrieve_response);
 188
 189         // checking that we have a query
 190         ok = check_sru_query_exists(package, odr_en, sru_pdu_res, sr_req);
 191
 192         if (ok && z3950_init_request(package))
 193         {
 194             {
 195                 ok = z3950_search_request(package, odr_en,
 196                                           sru_pdu_res, sr_req);
 197
 198                 if (ok
 199                     && sru_pdu_res->u.response->numberOfRecords
 200                     && *(sru_pdu_res->u.response->numberOfRecords)
 201                     && sr_req->maximumRecords
 202                     && *(sr_req->maximumRecords))
 203
 204                     ok = z3950_present_request(package, odr_en,
 205                                                sru_pdu_res,
 206                                                sr_req);
 207                 z3950_close_request(package);
 208             }
 209         }
 210     }
 211
 212     // scan
 213     else if (sru_pdu_req
 214              && sru_pdu_req->which == Z_SRW_scan_request
 215              && sru_pdu_req->u.scan_request)
 216     {
 217         Z_SRW_scanRequest  *sr_req = sru_pdu_req->u.scan_request;
 218
 219         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_scan_response);
 220
 221         if (z3950_init_request(package))
 222         {
 223             z3950_scan_request(package, odr_en, sru_pdu_res, sr_req);
 224             z3950_close_request(package);
 225         }
 226     }
 227     else
 228     {
 229         std::cout << "SRU OPERATION NOT SUPPORTED \n";
 230         sru_pdu_res = yaz_srw_get(odr_en, Z_SRW_explain_response);
 231
 232         // TODO: make nice diagnostic return package
 233         package.session().close();
 234         return;
 235     }
 236
 237     //build_sru_debug_package(package);
 238     build_sru_response(package, odr_en, soap,
 239                        sru_pdu_res, charset, stylesheet);
 240     return;
 241 }
 242
 243
 244 bool yf::SRUtoZ3950::Impl::build_simple_explain(mp::Package &package,
 245                                                mp::odr &odr_en,
 246                                                Z_SRW_PDU *sru_pdu_res,
 247                                                Z_SRW_explainRequest
 248                                                const *er_req) const
 249 {
 250     // z3950'fy recordPacking
 251     int record_packing = Z_SRW_recordPacking_XML;
 252     if (er_req && er_req->recordPacking && 's' == *(er_req->recordPacking))
 253         record_packing = Z_SRW_recordPacking_string;
 254
 255     // getting database info
 256     std::string database("Default");
 257     if (er_req && er_req->database)
 258         database = er_req->database;
 259
 260     // getting host and port info
 261     std::string host = package.origin().listen_host();
 262     std::string port = mp_util::to_string(package.origin().listen_port());
 263
 264     // overwriting host and port info if set from HTTP Host header
 265     Z_GDU *zgdu_req = package.request().get();
 266     if  (zgdu_req && zgdu_req->which == Z_GDU_HTTP_Request)
 267     {
 268         Z_HTTP_Request* http_req =  zgdu_req->u.HTTP_Request;
 269         if (http_req)
 270         {
 271             std::string http_host_address
 272                 = mp_util::http_header_value(http_req->headers, "Host");
 273
 274             std::string::size_type i = http_host_address.rfind(":");
 275             if (i != std::string::npos)
 276             {
 277                 host.assign(http_host_address, 0, i);
 278                 port.assign(http_host_address, i + 1, std::string::npos);
 279             }
 280         }
 281     }
 282
 283     // building SRU explain record
 284     std::string explain_xml
 285         = mp_util::to_string(
 286             "<explain>\n"
 287             "  <serverInfo protocol='SRU'>\n"
 288             "  <host>")
 289         + host
 290         + mp_util::to_string("</host>\n"
 291             "  <port>")
 292         + port
 293         + mp_util::to_string("</port>\n"
 294             "  <database>")
 295         + database
 296         + mp_util::to_string("</database>\n"
 297             "  </serverInfo>\n"
 298             "</explain>\n");
 299
 300
 301     // preparing explain record insert
 302     Z_SRW_explainResponse *sru_res = sru_pdu_res->u.explain_response;
 303     //sru_res->record
 304     //    = (Z_SRW_record *) odr_malloc(odr_en, sizeof(Z_SRW_record));
 305
 306     // inserting one and only explain record
 307
 308     sru_res->record.recordPosition = odr_intdup(odr_en, 1);
 309     sru_res->record.recordPacking = record_packing;
 310     sru_res->record.recordSchema = "http://explain.z3950.org/dtd/2.0/";
 311     sru_res->record.recordData_len = 1 + explain_xml.size();
 312     sru_res->record.recordData_buf
 313         = odr_strdupn(odr_en, (const char *)explain_xml.c_str(),
 314                       1 + explain_xml.size());
 315
 316     return true;
 317 };
 318
 319
 320 bool yf::SRUtoZ3950::Impl::build_sru_debug_package(mp::Package &package) const
 321 {
 322     Z_GDU *zgdu_req = package.request().get();
 323     if  (zgdu_req && zgdu_req->which == Z_GDU_HTTP_Request)
 324     {
 325         Z_HTTP_Request* http_req =  zgdu_req->u.HTTP_Request;
 326         std::string content = mp_util::http_headers_debug(*http_req);
 327         int http_code = 400;
 328         http_response(package, content, http_code);
 329         return true;
 330     }
 331     package.session().close();
 332     return false;
 333 }
 334
 335
 336 bool yf::SRUtoZ3950::Impl::build_sru_response(mp::Package &package,
 337                                              mp::odr &odr_en,
 338                                              Z_SOAP *soap,
 339                                              const Z_SRW_PDU *sru_pdu_res,
 340                                              char *charset,
 341                                              const char *stylesheet)
 342     const
 343 {
 344
 345     // SRU request package translation to Z3950 package
 346     if (sru_pdu_res)
 347         std::cout << *(const_cast<Z_SRW_PDU *>(sru_pdu_res)) << "\n";
 348     else
 349         std::cout << "SRU empty\n";
 350
 351
 352     Z_GDU *zgdu_req = package.request().get();
 353     if  (zgdu_req && zgdu_req->which == Z_GDU_HTTP_Request)
 354     {
 355         Z_GDU *zgdu_res //= z_get_HTTP_Response(odr_en, 200);
 356             = odr_en.create_HTTP_Response(package.session(),
 357                                           zgdu_req->u.HTTP_Request,
 358                                           200);
 359
 360         // adding HTTP response code and headers
 361         Z_HTTP_Response * http_res = zgdu_res->u.HTTP_Response;
 362         //http_res->code = http_code;
 363
 364         std::string ctype("text/xml");
 365         if (charset){
 366             ctype += "; charset=";
 367             ctype += charset;
 368         }
 369
 370         z_HTTP_header_add(odr_en,
 371                           &http_res->headers, "Content-Type", ctype.c_str());
 372
 373          // packaging Z_SOAP into HTML response
 374          static Z_SOAP_Handler soap_handlers[4] = {
 375               {"http://www.loc.gov/zing/srw/", 0,
 376                (Z_SOAP_fun) yaz_srw_codec},
 377               {"http://www.loc.gov/zing/srw/v1.0/", 0,
 378                (Z_SOAP_fun) yaz_srw_codec},
 379               {"http://www.loc.gov/zing/srw/update/", 0,
 380                (Z_SOAP_fun) yaz_ucp_codec},
 381               {0, 0, 0}
 382           };
 383
 384
 385          // empty stylesheet means NO stylesheet
 386          if (stylesheet && *stylesheet == '\0')
 387              stylesheet = 0;
 388
 389          // encoding SRU package
 390
 391          soap->u.generic->p  = (void*) sru_pdu_res;
 392          //int ret =
 393          z_soap_codec_enc_xsl(odr_en, &soap,
 394                               &http_res->content_buf, &http_res->content_len,
 395                               soap_handlers, charset, stylesheet);
 396
 397
 398          package.response() = zgdu_res;
 399          return true;
 400     }
 401     package.session().close();
 402     return false;
 403 }
 404
 405
 406
 407  Z_SRW_PDU * yf::SRUtoZ3950::Impl::decode_sru_request(mp::Package &package,
 408                                                      mp::odr &odr_de,
 409                                                      mp::odr &odr_en,
 410                                                      Z_SRW_PDU *sru_pdu_res,
 411                                                      Z_SOAP *&soap,
 412                                                      char *charset,
 413                                                      char *stylesheet)
 414      const
 415 {
 416     Z_GDU *zgdu_req = package.request().get();
 417     Z_SRW_PDU *sru_pdu_req = 0;
 418
 419     assert((zgdu_req->which == Z_GDU_HTTP_Request));
 420
 421     //ignoring all non HTTP_Request packages
 422     //if (!zgdu_req || !(zgdu_req->which == Z_GDU_HTTP_Request)){
 423     //    return 0;
 424     //}
 425
 426     Z_HTTP_Request* http_req =  zgdu_req->u.HTTP_Request;
 427     if (! http_req)
 428         return 0;
 429
 430     //Z_SRW_PDU *sru_pdu_res_exp = yaz_srw_get(odr_en, Z_SRW_explain_response);
 431
 432     if (0 == yaz_sru_decode(http_req, &sru_pdu_req, &soap,
 433                             odr_de, &charset,
 434                             &(sru_pdu_res->u.response->diagnostics),
 435                             &(sru_pdu_res->u.response->num_diagnostics)))
 436     {
 437         if (sru_pdu_res->u.response->num_diagnostics)
 438         {
 439             //sru_pdu_res = sru_pdu_res_exp;
 440             package.session().close();
 441             return 0;
 442         }
 443         return sru_pdu_req;
 444     }
 445     else if (0 == yaz_srw_decode(http_req, &sru_pdu_req, &soap,
 446                                  odr_de, &charset))
 447         return sru_pdu_req;
 448     else
 449     {
 450         //sru_pdu_res = sru_pdu_res_exp;
 451         package.session().close();
 452         return 0;
 453     }
 454     return 0;
 455 }
 456
 457 bool
 458 yf::SRUtoZ3950::Impl::check_sru_query_exists(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     if( (sr_req->query_type == Z_SRW_query_type_cql && !sr_req->query.cql) )
 466     {
 467         yaz_add_srw_diagnostic(odr_en,
 468                                &(sru_pdu_res->u.response->diagnostics),
 469                                &(sru_pdu_res->u.response->num_diagnostics),
 470                                7, "query");
 471         yaz_add_srw_diagnostic(odr_en,
 472                                &(sru_pdu_res->u.response->diagnostics),
 473                                &(sru_pdu_res->u.response->num_diagnostics),
 474                                10, "CQL query is empty");
 475         return false;
 476     }
 477     if( (sr_req->query_type == Z_SRW_query_type_xcql && !sr_req->query.xcql) )
 478     {
 479          yaz_add_srw_diagnostic(odr_en,
 480                                &(sru_pdu_res->u.response->diagnostics),
 481                                &(sru_pdu_res->u.response->num_diagnostics),
 482                                10, "XCQL query is empty");
 483          return false;
 484    }
 485     if( (sr_req->query_type == Z_SRW_query_type_pqf && !sr_req->query.pqf) )
 486     {
 487         yaz_add_srw_diagnostic(odr_en,
 488                                &(sru_pdu_res->u.response->diagnostics),
 489                                &(sru_pdu_res->u.response->num_diagnostics),
 490                                10, "PQF query is empty");
 491         return false;
 492     }
 493     return true;
 494 };
 495
 496
 497
 498 bool
 499 yf::SRUtoZ3950::Impl::z3950_init_request(mp::Package &package,
 500                                              const std::string &database) const
 501 {
 502     // prepare Z3950 package
 503     //Session s;
 504     //Package z3950_package(s, package.origin());
 505     Package z3950_package(package.session(), package.origin());
 506     z3950_package.copy_filter(package);
 507
 508     // set initRequest APDU
 509     mp::odr odr_en(ODR_ENCODE);
 510     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_initRequest);
 511     Z_InitRequest *init_req = apdu->u.initRequest;
 512     //TODO: add user name in apdu
 513     //TODO: add user passwd in apdu
 514     //init_req->idAuthentication = org_init->idAuthentication;
 515     //init_req->implementationId = "IDxyz";
 516     //init_req->implementationName = "NAMExyz";
 517     //init_req->implementationVersion = "VERSIONxyz";
 518
 519     ODR_MASK_SET(init_req->options, Z_Options_search);
 520     ODR_MASK_SET(init_req->options, Z_Options_present);
 521     ODR_MASK_SET(init_req->options, Z_Options_namedResultSets);
 522     ODR_MASK_SET(init_req->options, Z_Options_scan);
 523
 524     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_1);
 525     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_2);
 526     ODR_MASK_SET(init_req->protocolVersion, Z_ProtocolVersion_3);
 527
 528     z3950_package.request() = apdu;
 529
 530     // send Z3950 package
 531     // std::cout << "z3950_init_request " << *apdu <<"\n";
 532     z3950_package.move();
 533
 534     // dead Z3950 backend detection
 535     if (z3950_package.session().is_closed()){
 536         package.session().close();
 537         return false;
 538     }
 539
 540     // check successful initResponse
 541     Z_GDU *z3950_gdu = z3950_package.response().get();
 542
 543     if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 544         && z3950_gdu->u.z3950->which == Z_APDU_initResponse)
 545          return true;
 546
 547     return false;
 548 }
 549
 550 bool
 551 yf::SRUtoZ3950::Impl::z3950_close_request(mp::Package &package) const
 552 {
 553     // close SRU package
 554     package.session().close();
 555
 556     // prepare and close Z3950 package
 557     Package z3950_package(package.session(), package.origin());
 558     z3950_package.copy_filter(package);
 559     z3950_package.session().close();
 560
 561     // set close APDU
 562     //mp::odr odr_en(ODR_ENCODE);
 563     //Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_close);
 564     //z3950_package.request() = apdu;
 565
 566     z3950_package.move();
 567
 568     // check successful close response
 569     //Z_GDU *z3950_gdu = z3950_package.response().get();
 570     //if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 571     //    && z3950_gdu->u.z3950->which == Z_APDU_close)
 572     //    return true;
 573
 574     if (z3950_package.session().is_closed()){
 575         return true;
 576     }
 577     return false;
 578 }
 579
 580 bool
 581 yf::SRUtoZ3950::Impl::z3950_search_request(mp::Package &package,
 582                                           mp::odr &odr_en,
 583                                           Z_SRW_PDU *sru_pdu_res,
 584                                           Z_SRW_searchRetrieveRequest
 585                                           const *sr_req) const
 586 {
 587     Package z3950_package(package.session(), package.origin());
 588     z3950_package.copy_filter(package);
 589
 590     //add stuff in z3950 apdu
 591     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_searchRequest);
 592     Z_SearchRequest *z_searchRequest = apdu->u.searchRequest;
 593
 594     // z3950'fy database
 595     z_searchRequest->num_databaseNames = 1;
 596     z_searchRequest->databaseNames = (char**)
 597         odr_malloc(odr_en, sizeof(char *));
 598
 599     if (sr_req->database)
 600         z_searchRequest->databaseNames[0]
 601             = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 602     else
 603         z_searchRequest->databaseNames[0]
 604             = odr_strdup(odr_en, "Default");
 605
 606
 607     // z3950'fy query
 608     Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 609     z_searchRequest->query = z_query;
 610
 611     if (!z3950_build_query(odr_en, z_query,
 612                            (const SRW_query&)sr_req->query,
 613                            sr_req->query_type))
 614     {
 615         //send_to_srw_client_error(7, "query");
 616         return false;
 617     }
 618
 619     z3950_package.request() = apdu;
 620     //std::cout << "z3950_search_request " << *apdu << "\n";
 621
 622     z3950_package.move();
 623
 624
 625     Z_GDU *z3950_gdu = z3950_package.response().get();
 626     //std::cout << "z3950_search_request " << *z3950_gdu << "\n";
 627
 628     //TODO: check success condition
 629
 630     //int yaz_diag_bib1_to_srw (int bib1_code);
 631     //int yaz_diag_srw_to_bib1(int srw_code);
 632     //Se kode i src/seshigh.c (srw_bend_search, srw_bend_init).
 633
 634     if (z3950_gdu && z3950_gdu->which == Z_GDU_Z3950
 635         && z3950_gdu->u.z3950->which == Z_APDU_searchResponse
 636         && z3950_gdu->u.z3950->u.searchResponse->searchStatus)
 637     {
 638
 639         Z_SearchResponse *sr = z3950_gdu->u.z3950->u.searchResponse;
 640         if (sr)
 641         {
 642             // srw'fy number of records
 643             sru_pdu_res->u.response->numberOfRecords
 644                 = (int *) odr_malloc(odr_en, sizeof(int *));
 645             *(sru_pdu_res->u.response->numberOfRecords) = *(sr->resultCount);
 646
 647             // srw'fy nextRecordPosition
 648             //sru_pdu_res->u.response->nextRecordPosition
 649             //    = (int *) odr_malloc(odr_en, sizeof(int *));
 650             //*(sru_pdu_res->u.response->nextRecordPosition) = 1;
 651
 652         }
 653
 654         return true;
 655     }
 656
 657     return false;
 658 }
 659
 660 bool
 661 yf::SRUtoZ3950::Impl::z3950_present_request(mp::Package &package,
 662                                            mp::odr &odr_en,
 663                                            Z_SRW_PDU *sru_pdu_res,
 664                                            Z_SRW_searchRetrieveRequest
 665                                            const *sr_req)
 666     const
 667 {
 668
 669     if (!sr_req)
 670         return false;
 671
 672
 673     // no need to work if nobody wants record ..
 674     if (!(sr_req->maximumRecords) || 0 == *(sr_req->maximumRecords))
 675         return true;
 676
 677     // creating Z3950 package
 678     Package z3950_package(package.session(), package.origin());
 679     z3950_package.copy_filter(package);
 680     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_presentRequest);
 681
 682     assert(apdu->u.presentRequest);
 683
 684     bool send_z3950_present = true;
 685
 686     // recordXPath unsupported.
 687     if (sr_req->recordXPath)
 688     {
 689         send_z3950_present = false;
 690         yaz_add_srw_diagnostic(odr_en,
 691                                &(sru_pdu_res->u.response->diagnostics),
 692                                &(sru_pdu_res->u.response->num_diagnostics),
 693                                72, 0);
 694     }
 695
 696     // resultSetTTL unsupported.
 697     // resultSetIdleTime in response
 698     if (sr_req->resultSetTTL)
 699     {
 700         send_z3950_present = false;
 701         yaz_add_srw_diagnostic(odr_en,
 702                                &(sru_pdu_res->u.response->diagnostics),
 703                                &(sru_pdu_res->u.response->num_diagnostics),
 704                                50, 0);
 705     }
 706
 707     // sort unsupported
 708     if (sr_req->sort_type != Z_SRW_sort_type_none)
 709     {
 710         send_z3950_present = false;
 711         yaz_add_srw_diagnostic(odr_en,
 712                                &(sru_pdu_res->u.response->diagnostics),
 713                                &(sru_pdu_res->u.response->num_diagnostics),
 714                                80, 0);
 715     }
 716
 717     // start record requested larger than number of records
 718     if (sr_req->startRecord
 719         && sru_pdu_res->u.response->numberOfRecords
 720         && *(sr_req->startRecord) > *(sru_pdu_res->u.response->numberOfRecords))
 721     {
 722         //          = *(sr_req->startRecord);
 723         send_z3950_present = false;
 724         yaz_add_srw_diagnostic(odr_en,
 725                                &(sru_pdu_res->u.response->diagnostics),
 726                                &(sru_pdu_res->u.response->num_diagnostics),
 727                                61, 0);
 728     }
 729
 730     // exit on all these above diagnostics
 731     if (!send_z3950_present)
 732         return false;
 733
 734     // now packaging the z3950 present request
 735
 736     // z3950'fy start record position
 737     if (sr_req->startRecord)
 738         *(apdu->u.presentRequest->resultSetStartPoint)
 739             = *(sr_req->startRecord);
 740     else
 741         *(apdu->u.presentRequest->resultSetStartPoint) = 1;
 742
 743     // z3950'fy number of records requested
 744     if (sr_req->maximumRecords)
 745         *(apdu->u.presentRequest->numberOfRecordsRequested)
 746             = *(sr_req->maximumRecords);
 747
 748     // z3950'fy recordPacking
 749     int record_packing = Z_SRW_recordPacking_XML;
 750     if (sr_req->recordPacking && 's' == *(sr_req->recordPacking))
 751         record_packing = Z_SRW_recordPacking_string;
 752
 753     // RecordSyntax will always be XML
 754     (apdu->u.presentRequest->preferredRecordSyntax)
 755         = yaz_oidval_to_z3950oid (odr_en, CLASS_RECSYN, VAL_TEXT_XML);
 756
 757     // z3950'fy record schema
 758      if (sr_req->recordSchema)
 759      {
 760          apdu->u.presentRequest->recordComposition
 761              = (Z_RecordComposition *) odr_malloc(odr_en, sizeof(Z_RecordComposition));
 762          apdu->u.presentRequest->recordComposition->which
 763              = Z_RecordComp_simple;
 764          apdu->u.presentRequest->recordComposition->u.simple
 765              = build_esn_from_schema(odr_en, (const char *) sr_req->recordSchema);
 766      }
 767
 768     // z3950'fy time to live - flagged as diagnostics above
 769     //if (sr_req->resultSetTTL)
 770
 771     // attaching Z3950 package to filter chain
 772     z3950_package.request() = apdu;
 773
 774     //std::cout << "z3950_present_request " << *apdu << "\n";
 775     z3950_package.move();
 776
 777     //check successful Z3950 present response
 778     Z_GDU *z3950_gdu = z3950_package.response().get();
 779     if (!z3950_gdu || z3950_gdu->which != Z_GDU_Z3950
 780         || z3950_gdu->u.z3950->which != Z_APDU_presentResponse
 781         || !z3950_gdu->u.z3950->u.presentResponse)
 782
 783     {
 784         yaz_add_srw_diagnostic(odr_en,
 785                                &(sru_pdu_res->u.response->diagnostics),
 786                                &(sru_pdu_res->u.response->num_diagnostics),
 787                                2, 0);
 788         package.session().close();
 789         return false;
 790     }
 791
 792
 793     // everything fine, continuing
 794     //std::cout << "z3950_present_request OK\n";
 795
 796     Z_PresentResponse *pr = z3950_gdu->u.z3950->u.presentResponse;
 797     Z_SRW_searchRetrieveResponse *sru_res = sru_pdu_res->u.response;
 798
 799     // checking non surrogate dioagnostics in Z3950 present response package
 800     if (pr->records
 801         && pr->records->which == Z_Records_NSD
 802         && pr->records->u.nonSurrogateDiagnostic)
 803     {
 804         //int http_code =
 805         z3950_to_srw_diag(odr_en, sru_res, pr->records->u.nonSurrogateDiagnostic);
 806         return false;
 807     }
 808
 809     // copy all records if existing
 810     if (pr->records && pr->records->which == Z_Records_DBOSD)
 811     {
 812         // srw'fy number of returned records
 813         sru_res->num_records
 814             = pr->records->u.databaseOrSurDiagnostics->num_records;
 815
 816         sru_res->records
 817             = (Z_SRW_record *) odr_malloc(odr_en,
 818                                           sru_res->num_records *sizeof(Z_SRW_record));
 819
 820         // srw'fy nextRecordPosition
 821         if (pr->nextResultSetPosition)
 822             sru_res->nextRecordPosition
 823                 = odr_intdup(odr_en, *(pr->nextResultSetPosition));
 824
 825         // inserting all records
 826         for (int i = 0; i < sru_res->num_records; i++)
 827         {
 828             Z_NamePlusRecord *npr
 829                 = pr->records->u.databaseOrSurDiagnostics->records[i];
 830
 831             sru_res->records[i].recordPosition
 832                 = odr_intdup(odr_en, i + *(apdu->u.presentRequest->resultSetStartPoint));
 833
 834             sru_res->records[i].recordPacking = record_packing;
 835
 836             if (npr->which != Z_NamePlusRecord_databaseRecord)
 837             {
 838                 sru_res->records[i].recordSchema = "diagnostic";
 839                 sru_res->records[i].recordData_buf = "67";
 840                 sru_res->records[i].recordData_len = 2;
 841             }
 842             else
 843             {
 844                 Z_External *r = npr->u.databaseRecord;
 845                 oident *ent = oid_getentbyoid(r->direct_reference);
 846                 if (r->which == Z_External_octet
 847                     && ent->value == VAL_TEXT_XML)
 848                 {
 849                     sru_res->records[i].recordSchema = "dc";
 850                     sru_res->records[i].recordData_buf
 851                         = odr_strdupn(odr_en,
 852                                       (const char *)r->u.octet_aligned->buf,
 853                                       r->u.octet_aligned->len);
 854                     sru_res->records[i].recordData_len
 855                         = r->u.octet_aligned->len;
 856                 }
 857                 else
 858                 {
 859                     sru_res->records[i].recordSchema = "diagnostic";
 860                     sru_res->records[i].recordData_buf = "67";
 861                     sru_res->records[i].recordData_len = 2;
 862                 }
 863             }
 864         }
 865     }
 866
 867     return true;
 868 }
 869
 870 bool
 871 yf::SRUtoZ3950::Impl::z3950_scan_request(mp::Package &package,
 872                                         mp::odr &odr_en,
 873                                         Z_SRW_PDU *sru_pdu_res,
 874                                         Z_SRW_scanRequest const *sr_req) const
 875 {
 876     Package z3950_package(package.session(), package.origin());
 877     z3950_package.copy_filter(package);
 878     //mp::odr odr_en(ODR_ENCODE);
 879     Z_APDU *apdu = zget_APDU(odr_en, Z_APDU_scanRequest);
 880
 881     //TODO: add stuff in apdu
 882     Z_ScanRequest *z_scanRequest = apdu->u.scanRequest;
 883
 884     // database repackaging
 885     z_scanRequest->num_databaseNames = 1;
 886     z_scanRequest->databaseNames = (char**)
 887         odr_malloc(odr_en, sizeof(char *));
 888     if (sr_req->database)
 889         z_scanRequest->databaseNames[0]
 890             = odr_strdup(odr_en, const_cast<char *>(sr_req->database));
 891     else
 892         z_scanRequest->databaseNames[0]
 893             = odr_strdup(odr_en, "Default");
 894
 895
 896     // query repackaging
 897     // CQL or XCQL scan is not possible in Z3950, flagging a diagnostic
 898     if (sr_req->query_type != Z_SRW_query_type_pqf)
 899     {
 900         //send_to_srw_client_error(7, "query");
 901         return false;
 902     }
 903
 904     // PQF query repackaging
 905     // need to use Z_AttributesPlusTerm structure, not Z_Query
 906     // this can be digget out of a
 907     // Z_query->type1(Z_RPNQuery)->RPNStructure(Z_RPNStructure)
 908     //   ->u.simple(Z_Operand)->u.attributesPlusTerm(Z_AttributesPlusTerm )
 909
 910     //Z_Query *z_query = (Z_Query *) odr_malloc(odr_en, sizeof(Z_Query));
 911     //z_searchRequest->query = z_query;
 912
 913     //if (!z3950_build_query(odr_en, z_query,
 914     //                       (const SRW_query&)sr_req->query,
 915     //                       sr_req->query_type))
 916     //{
 917         //send_to_srw_client_error(7, "query");
 918     //    return false;
 919     //}
 920
 921     // TODO:
 922
 923     z3950_package.request() = apdu;
 924     std::cout << "z3950_scan_request " << *apdu << "\n";
 925
 926     z3950_package.move();
 927     //TODO: check success condition
 928     return true;
 929     return false;
 930 }
 931
 932 bool yf::SRUtoZ3950::Impl::z3950_build_query(mp::odr &odr_en, Z_Query *z_query,
 933                                             const SRW_query &query,
 934                                             SRW_query_type query_type) const
 935 {
 936     if (query_type == Z_SRW_query_type_cql)
 937     {
 938         Z_External *ext = (Z_External *)
 939             odr_malloc(odr_en, sizeof(*ext));
 940         ext->direct_reference =
 941             odr_getoidbystr(odr_en, "1.2.840.10003.16.2");
 942         ext->indirect_reference = 0;
 943         ext->descriptor = 0;
 944         ext->which = Z_External_CQL;
 945         ext->u.cql = const_cast<char *>(query.cql);
 946
 947         z_query->which = Z_Query_type_104;
 948         z_query->u.type_104 =  ext;
 949         return true;
 950     }
 951
 952     if (query_type == Z_SRW_query_type_pqf)
 953     {
 954         Z_RPNQuery *RPNquery;
 955         YAZ_PQF_Parser pqf_parser;
 956
 957         pqf_parser = yaz_pqf_create ();
 958
 959         RPNquery = yaz_pqf_parse (pqf_parser, odr_en, query.pqf);
 960         if (!RPNquery)
 961         {
 962             std::cout << "TODO: Handeling of bad PQF\n";
 963             std::cout << "TODO: Diagnostic to be send\n";
 964         }
 965         z_query->which = Z_Query_type_1;
 966         z_query->u.type_1 =  RPNquery;
 967
 968         yaz_pqf_destroy(pqf_parser);
 969         return true;
 970     }
 971     return false;
 972 }
 973
 974
 975 // std::string
 976 // yf::SRUtoZ3950::Impl::sru_protocol(const Z_HTTP_Request &http_req) const
 977 // {
 978 //     const std::string mime_urlencoded("application/x-www-form-urlencoded");
 979 //     const std::string mime_text_xml("text/xml");
 980 //     const std::string mime_soap_xml("application/soap+xml");
 981
 982 //     const std::string http_method(http_req.method);
 983 //     const std::string http_type
 984 //         =  mp_util::http_header_value(http_req.headers, "Content-Type");
 985
 986 //     if (http_method == "GET")
 987 //         return "SRU GET";
 988
 989 //     if (http_method == "POST"
 990 //               && http_type  == mime_urlencoded)
 991 //         return "SRU POST";
 992
 993 //     if ( http_method == "POST"
 994 //          && (http_type  == mime_text_xml
 995 //              || http_type  == mime_soap_xml))
 996 //         return "SRU SOAP";
 997
 998 //     return "HTTP";
 999 // }
1000
1001 // std::string
1002 // yf::SRUtoZ3950::Impl::debug_http(const Z_HTTP_Request &http_req) const
1003 // {
1004 //     std::string message("<html>\n<body>\n<h1>"
1005 //                         "Metaproxy SRUtoZ3950 filter"
1006 //                         "</h1>\n");
1007
1008 //     message += "<h3>HTTP Info</h3><br/>\n";
1009 //     message += "<p>\n";
1010 //     message += "<b>Method: </b> " + std::string(http_req.method) + "<br/>\n";
1011 //     message += "<b>Version:</b> " + std::string(http_req.version) + "<br/>\n";
1012 //     message += "<b>Path:   </b> " + std::string(http_req.path) + "<br/>\n";
1013
1014 //     message += "<b>Content-Type:</b>"
1015 //         + mp_util::http_header_value(http_req.headers, "Content-Type")
1016 //         + "<br/>\n";
1017 //     message += "<b>Content-Length:</b>"
1018 //         + mp_util::http_header_value(http_req.headers, "Content-Length")
1019 //         + "<br/>\n";
1020 //     message += "</p>\n";
1021
1022 //     message += "<h3>Headers</h3><br/>\n";
1023 //     message += "<p>\n";
1024 //     Z_HTTP_Header* header = http_req.headers;
1025 //     while (header){
1026 //         message += "<b>Header: </b> <i>"
1027 //             + std::string(header->name) + ":</i> "
1028 //             + std::string(header->value) + "<br/>\n";
1029 //         header = header->next;
1030 //     }
1031 //     message += "</p>\n";
1032 //     message += "</body>\n</html>\n";
1033 //     return message;
1034 // }
1035
1036 void yf::SRUtoZ3950::Impl::http_response(metaproxy_1::Package &package,
1037                                         const std::string &content,
1038                                         int http_code) const
1039 {
1040
1041     Z_GDU *zgdu_req = package.request().get();
1042     Z_GDU *zgdu_res = 0;
1043     mp::odr odr;
1044     zgdu_res
1045        = odr.create_HTTP_Response(package.session(),
1046                                   zgdu_req->u.HTTP_Request,
1047                                   http_code);
1048
1049     zgdu_res->u.HTTP_Response->content_len = content.size();
1050     zgdu_res->u.HTTP_Response->content_buf
1051         = (char*) odr_malloc(odr, zgdu_res->u.HTTP_Response->content_len);
1052
1053     strncpy(zgdu_res->u.HTTP_Response->content_buf,
1054             content.c_str(),  zgdu_res->u.HTTP_Response->content_len);
1055
1056     //z_HTTP_header_add(odr, &hres->headers,
1057     //                  "Content-Type", content_type.c_str());
1058     package.response() = zgdu_res;
1059 }
1060
1061
1062 Z_ElementSetNames *
1063 yf::SRUtoZ3950::Impl::build_esn_from_schema(mp::odr &odr_en,
1064                                            const char *schema) const
1065 {
1066   if (!schema)
1067         return 0;
1068
1069     Z_ElementSetNames *esn
1070         = (Z_ElementSetNames *) odr_malloc(odr_en, sizeof(Z_ElementSetNames));
1071     esn->which = Z_ElementSetNames_generic;
1072     esn->u.generic = odr_strdup(odr_en, schema);
1073     return esn;
1074 }
1075
1076 int
1077 yf::SRUtoZ3950::Impl::z3950_to_srw_diag(mp::odr &odr_en,
1078                                        Z_SRW_searchRetrieveResponse *sru_res,
1079                                        Z_DefaultDiagFormat *ddf) const
1080 {
1081     int bib1_code = *ddf->condition;
1082     if (bib1_code == 109)
1083         return 404;
1084     sru_res->num_diagnostics = 1;
1085     sru_res->diagnostics = (Z_SRW_diagnostic *)
1086         odr_malloc(odr_en, sizeof(*sru_res->diagnostics));
1087     yaz_mk_std_diagnostic(odr_en, sru_res->diagnostics,
1088                           yaz_diag_bib1_to_srw(*ddf->condition),
1089                           ddf->u.v2Addinfo);
1090     return 0;
1091 }
1092
1093
1094
1095 static mp::filter::Base* filter_creator()
1096 {
1097     return new mp::filter::SRUtoZ3950;
1098 }
1099
1100 extern "C" {
1101     struct metaproxy_1_filter_struct metaproxy_1_filter_sru_to_z3950 = {
1102         0,
1103         "SRUtoZ3950",
1104         filter_creator
1105     };
1106 }
1107
1108
1109 /*
1110  * Local variables:
1111  * c-basic-offset: 4
1112  * indent-tabs-mode: nil
1113  * c-file-style: "stroustrup"
1114  * End:
1115  * vim: shiftwidth=4 tabstop=8 expandtab
1116  */