src/filter_virt_db.cpp

   1 /* $Id: filter_virt_db.cpp,v 1.21 2006-01-12 14:09:08 adam Exp $
   2    Copyright (c) 2005, Index Data.
   3
   4 %LICENSE%
   5  */
   6
   7 #include "config.hpp"
   8
   9 #include "filter.hpp"
  10 #include "package.hpp"
  11
  12 #include <boost/thread/mutex.hpp>
  13 #include <boost/thread/condition.hpp>
  14
  15 #include "util.hpp"
  16 #include "filter_virt_db.hpp"
  17
  18 #include <yaz/zgdu.h>
  19 #include <yaz/otherinfo.h>
  20 #include <yaz/diagbib1.h>
  21
  22 #include <map>
  23 #include <iostream>
  24
  25 namespace yf = yp2::filter;
  26
  27 namespace yp2 {
  28     namespace filter {
  29         struct Virt_db_set {
  30             Virt_db_set(yp2::Session &id, std::string setname,
  31                         std::string vhost, std::string route,
  32                         bool named_result_sets);
  33             Virt_db_set();            ~Virt_db_set();
  34
  35             yp2::Session m_backend_session;
  36             std::string m_backend_setname;
  37             std::string m_vhost;
  38             std::string m_route;
  39             bool m_named_result_sets;
  40         };
  41         struct Virt_db_session {
  42             Virt_db_session(yp2::Session &id, bool use_vhost);
  43             Virt_db_session();
  44             yp2::Session m_session;
  45             bool m_use_vhost;
  46             std::map<std::string,Virt_db_set> m_sets;
  47         };
  48         struct Virt_db_map {
  49             Virt_db_map(std::string vhost, std::string route);
  50             Virt_db_map();
  51             std::string m_vhost;
  52             std::string m_route;
  53         };
  54         struct Frontend {
  55             Frontend();
  56             ~Frontend();
  57             yp2::Session m_session;
  58             bool m_is_virtual;
  59             bool m_in_use;
  60             std::map<std::string,Virt_db_set> m_sets;
  61             void search(Package &package, Z_APDU *apdu,
  62                         const std::map<std::string, Virt_db_map> &maps);
  63             void present(Package &package, Z_APDU *apdu);
  64             void close(Package &package);
  65             typedef std::map<std::string,Virt_db_set>::iterator Sets_it;
  66         };
  67         class Virt_db::Rep {
  68             friend class Virt_db;
  69
  70             void release_session(Package &package);
  71             void init(Package &package, Z_APDU *apdu, bool &move_later);
  72             void search(Package &package, Z_APDU *apdu, bool &move_later);
  73             void present(Package &package, Z_APDU *apdu, bool &move_later);
  74
  75             Frontend *get_frontend(Package &package);
  76             void release_frontend(Package &package);
  77         private:
  78             boost::mutex m_sessions_mutex;
  79             std::map<yp2::Session,Virt_db_session>m_sessions;
  80             std::map<std::string, Virt_db_map>m_maps;
  81
  82             typedef std::map<yp2::Session,Virt_db_session>::iterator Ses_it;
  83             typedef std::map<std::string,Virt_db_set>::iterator Sets_it;
  84
  85             boost::mutex m_mutex;
  86             boost::condition m_cond_session_ready;
  87             std::map<yp2::Session,Frontend *> m_clients;
  88         };
  89     }
  90 }
  91
  92 using namespace yp2;
  93
  94 yf::Frontend::Frontend()
  95 {
  96     m_is_virtual = false;
  97 }
  98
  99 void yf::Frontend::close(Package &package)
 100 {
 101     Sets_it sit = m_sets.begin();
 102     for (; sit != m_sets.end(); sit++)
 103     {
 104         sit->second.m_backend_session.close();
 105         Package close_package(sit->second.m_backend_session, package.origin());
 106         close_package.copy_filter(package);
 107
 108         close_package.move(sit->second.m_route);
 109     }
 110 }
 111
 112 yf::Frontend::~Frontend()
 113 {
 114 }
 115
 116 yf::Frontend *yf::Virt_db::Rep::get_frontend(Package &package)
 117 {
 118     boost::mutex::scoped_lock lock(m_mutex);
 119
 120     std::map<yp2::Session,yf::Frontend *>::iterator it;
 121
 122     while(true)
 123     {
 124         it = m_clients.find(package.session());
 125         if (it == m_clients.end())
 126             break;
 127
 128         if (!it->second->m_in_use)
 129         {
 130             it->second->m_in_use = true;
 131             return it->second;
 132         }
 133         m_cond_session_ready.wait(lock);
 134     }
 135     Frontend *f = new Frontend;
 136     m_clients[package.session()] = f;
 137     f->m_in_use = true;
 138     return f;
 139 }
 140
 141
 142 void yf::Virt_db::Rep::release_frontend(Package &package)
 143 {
 144     boost::mutex::scoped_lock lock(m_mutex);
 145     std::map<yp2::Session,yf::Frontend *>::iterator it;
 146
 147     it = m_clients.find(package.session());
 148     if (it != m_clients.end())
 149     {
 150         if (package.session().is_closed())
 151         {
 152             it->second->close(package);
 153             delete it->second;
 154             m_clients.erase(it);
 155         }
 156         else
 157         {
 158             it->second->m_in_use = false;
 159         }
 160         m_cond_session_ready.notify_all();
 161     }
 162 }
 163
 164 yf::Virt_db_set::Virt_db_set(yp2::Session &id, std::string setname,
 165                              std::string vhost, std::string route,
 166                              bool named_result_sets)
 167     :   m_backend_session(id), m_backend_setname(setname), m_vhost(vhost),
 168         m_route(route), m_named_result_sets(named_result_sets)
 169 {
 170 }
 171
 172
 173 yf::Virt_db_set::Virt_db_set()
 174 {
 175 }
 176
 177
 178 yf::Virt_db_set::~Virt_db_set()
 179 {
 180 }
 181
 182 yf::Virt_db_map::Virt_db_map(std::string vhost, std::string route)
 183     : m_vhost(vhost), m_route(route)
 184 {
 185 }
 186
 187 yf::Virt_db_map::Virt_db_map()
 188 {
 189 }
 190
 191 yf::Virt_db_session::Virt_db_session()
 192     : m_use_vhost(false)
 193 {
 194
 195 }
 196
 197 yf::Virt_db_session::Virt_db_session(yp2::Session &id,
 198                                      bool use_vhost) :
 199     m_session(id) , m_use_vhost(use_vhost)
 200 {
 201
 202 }
 203
 204 yf::Virt_db::Virt_db() : m_p(new Virt_db::Rep)
 205 {
 206 }
 207
 208 yf::Virt_db::~Virt_db() {
 209 }
 210
 211 void yf::Virt_db::Rep::release_session(Package &package)
 212 {
 213     boost::mutex::scoped_lock lock(m_sessions_mutex);
 214
 215     Ses_it it = m_sessions.find(package.session());
 216
 217     if (it != m_sessions.end())
 218     {
 219         Sets_it sit = it->second.m_sets.begin();
 220         for (; sit != it->second.m_sets.end(); sit++)
 221         {
 222             sit->second.m_backend_session.close();
 223             Package close_package(sit->second.m_backend_session, package.origin());
 224             close_package.copy_filter(package);
 225
 226             close_package.move(sit->second.m_route);
 227         }
 228     }
 229     m_sessions.erase(package.session());
 230 }
 231
 232 void yf::Virt_db::Rep::present(Package &package, Z_APDU *apdu, bool &move_later){
 233     Session *id = 0;
 234     Z_PresentRequest *req = apdu->u.presentRequest;
 235     std::string resultSetId = req->resultSetId;
 236     yp2::odr odr;
 237     {
 238         boost::mutex::scoped_lock lock(m_sessions_mutex);
 239
 240         Ses_it it = m_sessions.find(package.session());
 241         if (it == m_sessions.end())
 242         {
 243             package.response() = odr.create_close(
 244                 Z_Close_protocolError,
 245                 "no session for present request");
 246             package.session().close();
 247             return;
 248         }
 249         if (it->second.m_use_vhost)
 250         {
 251             move_later = true;
 252             return;
 253         }
 254         Sets_it sets_it = it->second.m_sets.find(resultSetId);
 255         if (sets_it == it->second.m_sets.end())
 256         {
 257             Z_APDU *apdu = zget_APDU(odr, Z_APDU_presentResponse);
 258
 259             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 260             apdu->u.presentResponse->records = rec;
 261             rec->which = Z_Records_NSD;
 262             rec->u.nonSurrogateDiagnostic =
 263                 zget_DefaultDiagFormat(
 264                     odr,
 265                     YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 266                     resultSetId.c_str());
 267             package.response() = apdu;
 268
 269             return;
 270         }
 271         id = new yp2::Session(sets_it->second.m_backend_session);
 272     }
 273
 274     // sending present to backend
 275     Package present_package(*id, package.origin());
 276     present_package.copy_filter(package);
 277
 278     req->resultSetId = odr_strdup(odr, "default");
 279     present_package.request() = yazpp_1::GDU(apdu);
 280
 281     present_package.move();
 282
 283     if (present_package.session().is_closed())
 284     {
 285         Z_APDU *apdu = zget_APDU(odr, Z_APDU_presentResponse);
 286
 287         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 288         apdu->u.presentResponse->records = rec;
 289         rec->which = Z_Records_NSD;
 290         rec->u.nonSurrogateDiagnostic =
 291             zget_DefaultDiagFormat(
 292                 odr,
 293                 YAZ_BIB1_RESULT_SET_NO_LONGER_EXISTS_UNILATERALLY_DELETED_BY_,
 294                 resultSetId.c_str());
 295         package.response() = apdu;
 296
 297         boost::mutex::scoped_lock lock(m_sessions_mutex);
 298         Ses_it it = m_sessions.find(package.session());
 299         if (it != m_sessions.end())
 300             it->second.m_sets.erase(resultSetId);
 301     }
 302     else
 303     {
 304         package.response() = present_package.response();
 305     }
 306     delete id;
 307 }
 308
 309 void yf::Frontend::present(Package &package, Z_APDU *apdu)
 310 {
 311     Session *id = 0;
 312     Z_PresentRequest *req = apdu->u.presentRequest;
 313     std::string resultSetId = req->resultSetId;
 314     yp2::odr odr;
 315
 316     Sets_it sets_it = m_sets.find(resultSetId);
 317     if (sets_it == m_sets.end())
 318     {
 319         Z_APDU *apdu = zget_APDU(odr, Z_APDU_presentResponse);
 320
 321         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 322         apdu->u.presentResponse->records = rec;
 323         rec->which = Z_Records_NSD;
 324         rec->u.nonSurrogateDiagnostic =
 325             zget_DefaultDiagFormat(
 326                 odr,
 327                 YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 328                 resultSetId.c_str());
 329         package.response() = apdu;
 330
 331         return;
 332     }
 333     id = new yp2::Session(sets_it->second.m_backend_session);
 334
 335     // sending present to backend
 336     Package present_package(*id, package.origin());
 337     present_package.copy_filter(package);
 338
 339     req->resultSetId = odr_strdup(odr, "default");
 340     present_package.request() = yazpp_1::GDU(apdu);
 341
 342     present_package.move();
 343
 344     if (present_package.session().is_closed())
 345     {
 346         Z_APDU *apdu = zget_APDU(odr, Z_APDU_presentResponse);
 347
 348         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 349         apdu->u.presentResponse->records = rec;
 350         rec->which = Z_Records_NSD;
 351         rec->u.nonSurrogateDiagnostic =
 352             zget_DefaultDiagFormat(
 353                 odr,
 354                 YAZ_BIB1_RESULT_SET_NO_LONGER_EXISTS_UNILATERALLY_DELETED_BY_,
 355                 resultSetId.c_str());
 356         package.response() = apdu;
 357
 358         m_sets.erase(resultSetId);
 359     }
 360     else
 361     {
 362         package.response() = present_package.response();
 363     }
 364     delete id;
 365 }
 366
 367 void yf::Virt_db::Rep::search(Package &package, Z_APDU *apdu, bool &move_later)
 368 {
 369     Z_SearchRequest *req = apdu->u.searchRequest;
 370     std::string vhost;
 371     std::string database;
 372     std::string resultSetId = req->resultSetName;
 373     std::string route;
 374     bool support_named_result_sets = false;  // whether backend supports it
 375     yp2::odr odr;
 376     {
 377         boost::mutex::scoped_lock lock(m_sessions_mutex);
 378
 379         Ses_it it = m_sessions.find(package.session());
 380         if (it == m_sessions.end())
 381         {
 382             package.response() = odr.create_close(
 383                 Z_Close_protocolError,
 384                 "no session for search request");
 385             package.session().close();
 386
 387             return;
 388         }
 389         if (it->second.m_use_vhost)
 390         {
 391             move_later = true;
 392             return;
 393         }
 394         if (req->num_databaseNames != 1)
 395         {   // exactly one database must be specified
 396             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 397
 398             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 399             apdu->u.searchResponse->records = rec;
 400             rec->which = Z_Records_NSD;
 401             rec->u.nonSurrogateDiagnostic =
 402                 zget_DefaultDiagFormat(
 403                     odr, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
 404             package.response() = apdu;
 405
 406             return;
 407         }
 408         database = req->databaseNames[0];
 409         std::map<std::string, Virt_db_map>::iterator map_it;
 410         map_it = m_maps.find(database);
 411         if (map_it == m_maps.end())
 412         {   // no map for database: return diagnostic
 413             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 414
 415             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 416             apdu->u.searchResponse->records = rec;
 417             rec->which = Z_Records_NSD;
 418             rec->u.nonSurrogateDiagnostic =
 419                 zget_DefaultDiagFormat(
 420                     odr, YAZ_BIB1_DATABASE_DOES_NOT_EXIST, database.c_str());
 421             package.response() = apdu;
 422
 423             return;
 424         }
 425         if (*req->replaceIndicator == 0)
 426         {
 427             Sets_it sets_it = it->second.m_sets.find(req->resultSetName);
 428             if (sets_it != it->second.m_sets.end())
 429             {
 430                 Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 431
 432                 Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 433                 apdu->u.searchResponse->records = rec;
 434                 rec->which = Z_Records_NSD;
 435                 rec->u.nonSurrogateDiagnostic =
 436                     zget_DefaultDiagFormat(
 437                         odr,
 438                         YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 439                         0);
 440                 package.response() = apdu;
 441
 442                 return;
 443             }
 444         }
 445         it->second.m_sets.erase(req->resultSetName);
 446         vhost = map_it->second.m_vhost;
 447         route = map_it->second.m_route;
 448     }
 449     // we might look for an existing session with same vhost
 450     Session id;
 451     const char *vhost_cstr = vhost.c_str();
 452     if (true)
 453     {  // sending init to backend
 454         Package init_package(id, package.origin());
 455         init_package.copy_filter(package);
 456
 457         Z_APDU *init_apdu = zget_APDU(odr, Z_APDU_initRequest);
 458
 459         yaz_oi_set_string_oidval(&init_apdu->u.initRequest->otherInfo, odr,
 460                                  VAL_PROXY, 1, vhost_cstr);
 461
 462         init_package.request() = init_apdu;
 463
 464         init_package.move(route);  // sending init
 465
 466         if (init_package.session().is_closed())
 467         {
 468             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 469
 470             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 471             apdu->u.searchResponse->records = rec;
 472             rec->which = Z_Records_NSD;
 473             rec->u.nonSurrogateDiagnostic =
 474                 zget_DefaultDiagFormat(
 475                     odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 476             package.response() = apdu;
 477         }
 478         Z_GDU *gdu = init_package.response().get();
 479         // we hope to get an init response
 480         if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 481             Z_APDU_initResponse)
 482         {
 483             if (ODR_MASK_GET(gdu->u.z3950->u.initResponse->options,
 484                              Z_Options_namedResultSets))
 485                 support_named_result_sets = true;
 486         }
 487         else
 488         {
 489             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 490
 491             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 492             apdu->u.searchResponse->records = rec;
 493             rec->which = Z_Records_NSD;
 494             rec->u.nonSurrogateDiagnostic =
 495                 zget_DefaultDiagFormat(
 496                     odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 497             package.response() = apdu;
 498
 499             return;
 500         }
 501     }
 502     // sending search to backend
 503     Package search_package(id, package.origin());
 504
 505     search_package.copy_filter(package);
 506     const char *sep = strchr(vhost_cstr, '/');
 507     if (sep)
 508         req->databaseNames[0] = odr_strdup(odr, sep+1);
 509
 510     *req->replaceIndicator = 1;
 511
 512     std::string backend_resultSetId = "default";
 513     req->resultSetName = odr_strdup(odr, backend_resultSetId.c_str());
 514     search_package.request() = yazpp_1::GDU(apdu);
 515
 516     search_package.move(route);
 517
 518     if (search_package.session().is_closed())
 519     {
 520         Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 521
 522         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 523         apdu->u.searchResponse->records = rec;
 524         rec->which = Z_Records_NSD;
 525         rec->u.nonSurrogateDiagnostic =
 526             zget_DefaultDiagFormat(
 527                 odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 528         package.response() = apdu;
 529
 530         return;
 531     }
 532     package.response() = search_package.response();
 533
 534     boost::mutex::scoped_lock lock(m_sessions_mutex);
 535     Ses_it it = m_sessions.find(package.session());
 536     if (it != m_sessions.end())
 537         it->second.m_sets[resultSetId] =
 538             Virt_db_set(id, backend_resultSetId, vhost, route,
 539                         support_named_result_sets);
 540 }
 541
 542 void yf::Frontend::search(Package &package, Z_APDU *apdu,
 543                           const std::map<std::string, Virt_db_map> &maps)
 544 {
 545     Z_SearchRequest *req = apdu->u.searchRequest;
 546     std::string vhost;
 547     std::string database;
 548     std::string resultSetId = req->resultSetName;
 549     bool support_named_result_sets = false;  // whether backend supports it
 550     yp2::odr odr;
 551
 552     if (req->num_databaseNames != 1)
 553     {   // exactly one database must be specified
 554         Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 555
 556         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 557         apdu->u.searchResponse->records = rec;
 558         rec->which = Z_Records_NSD;
 559         rec->u.nonSurrogateDiagnostic =
 560             zget_DefaultDiagFormat(
 561                 odr, YAZ_BIB1_TOO_MANY_DATABASES_SPECIFIED, 0);
 562         package.response() = apdu;
 563
 564         return;
 565     }
 566     database = req->databaseNames[0];
 567     std::map<std::string, Virt_db_map>::const_iterator map_it;
 568     map_it = maps.find(database);
 569     if (map_it == maps.end())
 570     {   // no map for database: return diagnostic
 571         Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 572
 573         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 574         apdu->u.searchResponse->records = rec;
 575         rec->which = Z_Records_NSD;
 576         rec->u.nonSurrogateDiagnostic =
 577             zget_DefaultDiagFormat(
 578                 odr, YAZ_BIB1_DATABASE_DOES_NOT_EXIST, database.c_str());
 579         package.response() = apdu;
 580
 581         return;
 582     }
 583     if (*req->replaceIndicator == 0)
 584     {
 585         Sets_it sets_it = m_sets.find(req->resultSetName);
 586         if (sets_it != m_sets.end())
 587         {
 588             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 589
 590             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 591             apdu->u.searchResponse->records = rec;
 592             rec->which = Z_Records_NSD;
 593             rec->u.nonSurrogateDiagnostic =
 594                 zget_DefaultDiagFormat(
 595                     odr,
 596                     YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 597                     0);
 598             package.response() = apdu;
 599
 600             return;
 601         }
 602     }
 603     m_sets.erase(req->resultSetName);
 604     vhost = map_it->second.m_vhost;
 605     std::string route = map_it->second.m_route;
 606     // we might look for an existing session with same vhost
 607     Session id;
 608     const char *vhost_cstr = vhost.c_str();
 609     if (true)
 610     {  // sending init to backend
 611         Package init_package(id, package.origin());
 612         init_package.copy_filter(package);
 613
 614         Z_APDU *init_apdu = zget_APDU(odr, Z_APDU_initRequest);
 615
 616         yaz_oi_set_string_oidval(&init_apdu->u.initRequest->otherInfo, odr,
 617                                  VAL_PROXY, 1, vhost_cstr);
 618
 619         init_package.request() = init_apdu;
 620
 621         init_package.move(route);  // sending init
 622
 623         if (init_package.session().is_closed())
 624         {
 625             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 626
 627             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 628             apdu->u.searchResponse->records = rec;
 629             rec->which = Z_Records_NSD;
 630             rec->u.nonSurrogateDiagnostic =
 631                 zget_DefaultDiagFormat(
 632                     odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 633             package.response() = apdu;
 634         }
 635         Z_GDU *gdu = init_package.response().get();
 636         // we hope to get an init response
 637         if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 638             Z_APDU_initResponse)
 639         {
 640             if (ODR_MASK_GET(gdu->u.z3950->u.initResponse->options,
 641                              Z_Options_namedResultSets))
 642                 support_named_result_sets = true;
 643         }
 644         else
 645         {
 646             Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 647
 648             Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 649             apdu->u.searchResponse->records = rec;
 650             rec->which = Z_Records_NSD;
 651             rec->u.nonSurrogateDiagnostic =
 652                 zget_DefaultDiagFormat(
 653                     odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 654             package.response() = apdu;
 655
 656             return;
 657         }
 658     }
 659     // sending search to backend
 660     Package search_package(id, package.origin());
 661
 662     search_package.copy_filter(package);
 663     const char *sep = strchr(vhost_cstr, '/');
 664     if (sep)
 665         req->databaseNames[0] = odr_strdup(odr, sep+1);
 666
 667     *req->replaceIndicator = 1;
 668
 669     std::string backend_resultSetId = "default";
 670     req->resultSetName = odr_strdup(odr, backend_resultSetId.c_str());
 671     search_package.request() = yazpp_1::GDU(apdu);
 672
 673     search_package.move(route);
 674
 675     if (search_package.session().is_closed())
 676     {
 677         Z_APDU *apdu = zget_APDU(odr, Z_APDU_searchResponse);
 678
 679         Z_Records *rec = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
 680         apdu->u.searchResponse->records = rec;
 681         rec->which = Z_Records_NSD;
 682         rec->u.nonSurrogateDiagnostic =
 683             zget_DefaultDiagFormat(
 684                 odr, YAZ_BIB1_DATABASE_UNAVAILABLE, database.c_str());
 685         package.response() = apdu;
 686
 687         return;
 688     }
 689     package.response() = search_package.response();
 690
 691     m_sets[resultSetId] =
 692         Virt_db_set(id, backend_resultSetId, vhost, route,
 693                     support_named_result_sets);
 694 }
 695
 696 void yf::Virt_db::Rep::init(Package &package, Z_APDU *apdu, bool &move_later)
 697 {
 698     release_session(package);
 699     boost::mutex::scoped_lock lock(m_sessions_mutex);
 700
 701     Z_InitRequest *req = apdu->u.initRequest;
 702
 703     const char *vhost =
 704         yaz_oi_get_string_oidval(&req->otherInfo, VAL_PROXY, 1, 0);
 705     if (!vhost)
 706     {
 707         yp2::odr odr;
 708         Z_APDU *apdu = zget_APDU(odr, Z_APDU_initResponse);
 709         Z_InitResponse *resp = apdu->u.initResponse;
 710
 711         int i;
 712         static const int masks[] = {
 713             Z_Options_search, Z_Options_present, Z_Options_namedResultSets, -1
 714         };
 715         for (i = 0; masks[i] != -1; i++)
 716             if (ODR_MASK_GET(req->options, masks[i]))
 717                 ODR_MASK_SET(resp->options, masks[i]);
 718
 719         static const int versions[] = {
 720             Z_ProtocolVersion_1,
 721             Z_ProtocolVersion_2,
 722             Z_ProtocolVersion_3,
 723             -1
 724         };
 725         for (i = 0; versions[i] != -1; i++)
 726             if (ODR_MASK_GET(req->protocolVersion, versions[i]))
 727                 ODR_MASK_SET(resp->protocolVersion, versions[i]);
 728             else
 729                 break;
 730
 731         package.response() = apdu;
 732
 733         m_sessions[package.session()] = Virt_db_session(package.session(), false);
 734     }
 735     else
 736     {
 737         m_sessions[package.session()] = Virt_db_session(package.session(), true);
 738         package.move();
 739     }
 740 }
 741
 742 void yf::Virt_db::add_map_db2vhost(std::string db, std::string vhost,
 743                                    std::string route)
 744 {
 745     m_p->m_maps[db] = Virt_db_map(vhost, route);
 746 }
 747
 748 #if 0
 749 void yf::Virt_db::process(Package &package) const
 750 {
 751     yf::Frontend *f = m_p->get_frontend(package);
 752     if (f)
 753     {
 754         Z_GDU *gdu = package.request().get();
 755
 756         if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 757             Z_APDU_initRequest)
 758         {
 759             Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 760
 761             const char *vhost =
 762                 yaz_oi_get_string_oidval(&req->otherInfo, VAL_PROXY, 1, 0);
 763             if (!vhost)
 764             {
 765                 yp2::odr odr;
 766                 Z_APDU *apdu = zget_APDU(odr, Z_APDU_initResponse);
 767                 Z_InitResponse *resp = apdu->u.initResponse;
 768
 769                 int i;
 770                 static const int masks[] = {
 771                     Z_Options_search,
 772                     Z_Options_present,
 773                     Z_Options_namedResultSets,
 774                     -1
 775                 };
 776                 for (i = 0; masks[i] != -1; i++)
 777                     if (ODR_MASK_GET(req->options, masks[i]))
 778                         ODR_MASK_SET(resp->options, masks[i]);
 779
 780                 static const int versions[] = {
 781                     Z_ProtocolVersion_1,
 782                     Z_ProtocolVersion_2,
 783                     Z_ProtocolVersion_3,
 784                     -1
 785                 };
 786                 for (i = 0; versions[i] != -1; i++)
 787                     if (ODR_MASK_GET(req->protocolVersion, versions[i]))
 788                         ODR_MASK_SET(resp->protocolVersion, versions[i]);
 789                     else
 790                         break;
 791
 792                 package.response() = apdu;
 793                 f->m_is_virtual = true;
 794             }
 795             else
 796                 package.move();
 797         }
 798         else if (!f->m_is_virtual)
 799             package.move();
 800         else if (gdu && gdu->which == Z_GDU_Z3950)
 801         {
 802             Z_APDU *apdu = gdu->u.z3950;
 803             if (apdu->which == Z_APDU_initRequest)
 804             {
 805             }
 806             else if (apdu->which == Z_APDU_searchRequest)
 807             {
 808                 f->search(package, apdu, m_p->m_maps);
 809             }
 810             else if (apdu->which == Z_APDU_presentRequest)
 811             {
 812                 f->present(package, apdu);
 813             }
 814             else
 815             {
 816                 yp2::odr odr;
 817
 818                 package.response() = odr.create_close(
 819                     Z_Close_protocolError,
 820                     "unsupported APDU in filter_virt_db");
 821
 822                 package.session().close();
 823             }
 824         }
 825     }
 826     m_p->release_frontend(package);
 827 }
 828
 829 #else
 830 void yf::Virt_db::process(Package &package) const
 831 {
 832     Z_GDU *gdu = package.request().get();
 833
 834     if (package.session().is_closed())
 835         m_p->release_session(package);
 836     else if (!gdu || gdu->which != Z_GDU_Z3950)
 837         package.move();
 838     else
 839     {
 840         bool move_later = false;
 841         Z_APDU *apdu = gdu->u.z3950;
 842         if (apdu->which == Z_APDU_initRequest)
 843         {
 844             m_p->init(package, apdu, move_later);
 845         }
 846         else if (apdu->which == Z_APDU_searchRequest)
 847         {
 848             m_p->search(package, apdu, move_later);
 849         }
 850         else if (apdu->which == Z_APDU_presentRequest)
 851         {
 852             m_p->present(package, apdu, move_later);
 853         }
 854         else if (apdu->which == Z_APDU_close)
 855         {
 856             package.session().close();
 857             m_p->release_session(package);
 858         }
 859         else
 860         {
 861             yp2::odr odr;
 862
 863             package.response() = odr.create_close(
 864                 Z_Close_protocolError,
 865                 "unsupported APDU in filter_virt_db");
 866
 867             package.session().close();
 868             m_p->release_session(package);
 869         }
 870         if (move_later)
 871             package.move();
 872     }
 873 }
 874 #endif
 875
 876 void yp2::filter::Virt_db::configure(const xmlNode * ptr)
 877 {
 878     for (ptr = ptr->children; ptr; ptr = ptr->next)
 879     {
 880         if (ptr->type != XML_ELEMENT_NODE)
 881             continue;
 882         if (!strcmp((const char *) ptr->name, "virtual"))
 883         {
 884             std::string database;
 885             std::string target;
 886             xmlNode *v_node = ptr->children;
 887             for (; v_node; v_node = v_node->next)
 888             {
 889                 if (v_node->type != XML_ELEMENT_NODE)
 890                     continue;
 891
 892                 if (yp2::xml::is_element_yp2(v_node, "database"))
 893                     database = yp2::xml::get_text(v_node);
 894                 else if (yp2::xml::is_element_yp2(v_node, "target"))
 895                     target = yp2::xml::get_text(v_node);
 896                 else
 897                     throw yp2::filter::FilterException
 898                         ("Bad element "
 899                          + std::string((const char *) v_node->name)
 900                          + " in virtual section"
 901                             );
 902             }
 903             std::string route = yp2::xml::get_route(ptr);
 904             add_map_db2vhost(database, target, route);
 905             std::cout << "Add " << database << "->" << target
 906                       << "," << route << "\n";
 907         }
 908         else
 909         {
 910             throw yp2::filter::FilterException
 911                 ("Bad element "
 912                  + std::string((const char *) ptr->name)
 913                  + " in virt_db filter");
 914         }
 915     }
 916 }
 917
 918 static yp2::filter::Base* filter_creator()
 919 {
 920     return new yp2::filter::Virt_db;
 921 }
 922
 923 extern "C" {
 924     struct yp2_filter_struct yp2_filter_virt_db = {
 925         0,
 926         "virt_db",
 927         filter_creator
 928     };
 929 }
 930
 931
 932 /*
 933  * Local variables:
 934  * c-basic-offset: 4
 935  * indent-tabs-mode: nil
 936  * c-file-style: "stroustrup"
 937  * End:
 938  * vim: shiftwidth=4 tabstop=8 expandtab
 939  */