src/filter_virt_db.cpp

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