src/filter_virt_db.cpp

   1 /* This file is part of Metaproxy.
   2    Copyright (C) 2005-2008 Index Data
   3
   4 Metaproxy is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Metaproxy is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 */
  18 /* $Id: filter_virt_db.cpp,v 1.54 2008-02-20 15:07:52 adam Exp $
  19    Copyright (c) 2005-2007, Index Data.
  20
  21    See the LICENSE file for details
  22  */
  23
  24 #include "config.hpp"
  25
  26 #include "filter.hpp"
  27 #include "package.hpp"
  28
  29 #include <boost/thread/mutex.hpp>
  30 #include <boost/thread/condition.hpp>
  31 #include <boost/shared_ptr.hpp>
  32
  33 #include "util.hpp"
  34 #include "filter_virt_db.hpp"
  35
  36 #include <yaz/zgdu.h>
  37 #include <yaz/otherinfo.h>
  38 #include <yaz/diagbib1.h>
  39
  40 #include <map>
  41 #include <iostream>
  42
  43 namespace mp = metaproxy_1;
  44 namespace yf = mp::filter;
  45
  46 namespace metaproxy_1 {
  47     namespace filter {
  48
  49         struct VirtualDB::Set {
  50             Set(BackendPtr b, std::string setname);
  51             Set();
  52             ~Set();
  53
  54             BackendPtr m_backend;
  55             std::string m_setname;
  56         };
  57         struct VirtualDB::Map {
  58             Map(std::list<std::string> targets, std::string route);
  59             Map();
  60             std::list<std::string> m_targets;
  61             std::string m_route;
  62         };
  63         struct VirtualDB::Backend {
  64             mp::Session m_backend_session;
  65             std::list<std::string> m_frontend_databases;
  66             std::list<std::string> m_targets;
  67             std::string m_route;
  68             bool m_named_result_sets;
  69             int m_number_of_sets;
  70         };
  71         struct VirtualDB::Frontend {
  72             Frontend(Rep *rep);
  73             ~Frontend();
  74             mp::Session m_session;
  75             bool m_is_virtual;
  76             bool m_in_use;
  77             yazpp_1::GDU m_init_gdu;
  78             std::list<BackendPtr> m_backend_list;
  79             std::map<std::string,VirtualDB::Set> m_sets;
  80
  81             void search(Package &package, Z_APDU *apdu);
  82             void present(Package &package, Z_APDU *apdu);
  83             void scan(Package &package, Z_APDU *apdu);
  84
  85             void close(Package &package);
  86             typedef std::map<std::string,VirtualDB::Set>::iterator Sets_it;
  87
  88             void fixup_package(Package &p, BackendPtr b);
  89             void fixup_npr_record(ODR odr, Z_NamePlusRecord *npr,
  90                                   BackendPtr b);
  91             void fixup_npr_records(ODR odr, Z_Records *records,
  92                                    BackendPtr b);
  93
  94             BackendPtr lookup_backend_from_databases(
  95                 std::list<std::string> databases);
  96             BackendPtr create_backend_from_databases(
  97                 std::list<std::string> databases,
  98                 int &error_code,
  99                 std::string &failing_database);
 100
 101             BackendPtr init_backend(std::list<std::string> database,
 102                                     Package &package,
 103                                     int &error_code, std::string &addinfo);
 104             Rep *m_p;
 105         };
 106         class VirtualDB::Rep {
 107             friend class VirtualDB;
 108             friend struct Frontend;
 109
 110             FrontendPtr get_frontend(Package &package);
 111             void release_frontend(Package &package);
 112         private:
 113             std::map<std::string, VirtualDB::Map>m_maps;
 114             typedef std::map<std::string,VirtualDB::Set>::iterator Sets_it;
 115             boost::mutex m_mutex;
 116             boost::condition m_cond_session_ready;
 117             std::map<mp::Session, FrontendPtr> m_clients;
 118         };
 119     }
 120 }
 121
 122 yf::VirtualDB::BackendPtr yf::VirtualDB::Frontend::lookup_backend_from_databases(
 123     std::list<std::string> databases)
 124 {
 125     std::list<BackendPtr>::const_iterator map_it;
 126     map_it = m_backend_list.begin();
 127     for (; map_it != m_backend_list.end(); map_it++)
 128         if ((*map_it)->m_frontend_databases == databases)
 129             return *map_it;
 130     BackendPtr null;
 131     return null;
 132 }
 133
 134 yf::VirtualDB::BackendPtr yf::VirtualDB::Frontend::create_backend_from_databases(
 135     std::list<std::string> databases, int &error_code, std::string &addinfo)
 136 {
 137     BackendPtr b(new Backend);
 138     std::list<std::string>::const_iterator db_it = databases.begin();
 139
 140     b->m_number_of_sets = 0;
 141     b->m_frontend_databases = databases;
 142     b->m_named_result_sets = false;
 143
 144     bool first_route = true;
 145
 146     std::map<std::string,bool> targets_dedup;
 147     for (; db_it != databases.end(); db_it++)
 148     {
 149         std::map<std::string, VirtualDB::Map>::iterator map_it;
 150         map_it = m_p->m_maps.find(mp::util::database_name_normalize(*db_it));
 151         if (map_it == m_p->m_maps.end())  // database not found
 152         {
 153             error_code = YAZ_BIB1_DATABASE_DOES_NOT_EXIST;
 154             addinfo = *db_it;
 155             BackendPtr ptr;
 156             return ptr;
 157         }
 158         std::list<std::string>::const_iterator t_it =
 159             map_it->second.m_targets.begin();
 160         for (; t_it != map_it->second.m_targets.end(); t_it++) {
 161             if (!targets_dedup[*t_it])
 162             {
 163                 targets_dedup[*t_it] = true;
 164                 b->m_targets.push_back(*t_it);
 165             }
 166         }
 167
 168         // see if we have a route conflict.
 169         if (!first_route && b->m_route != map_it->second.m_route)
 170         {
 171             // we have a conflict..
 172             error_code =  YAZ_BIB1_COMBI_OF_SPECIFIED_DATABASES_UNSUPP;
 173             BackendPtr ptr;
 174             return ptr;
 175         }
 176         b->m_route = map_it->second.m_route;
 177         first_route = false;
 178     }
 179     return b;
 180 }
 181
 182 yf::VirtualDB::BackendPtr yf::VirtualDB::Frontend::init_backend(
 183     std::list<std::string> databases, mp::Package &package,
 184     int &error_code, std::string &addinfo)
 185 {
 186     BackendPtr b = create_backend_from_databases(databases, error_code,
 187                                                  addinfo);
 188     if (!b)
 189         return b;
 190     Package init_package(b->m_backend_session, package.origin());
 191     init_package.copy_filter(package);
 192
 193     mp::odr odr;
 194
 195     Z_APDU *init_apdu = zget_APDU(odr, Z_APDU_initRequest);
 196
 197     mp::util::set_vhost_otherinfo(&init_apdu->u.initRequest->otherInfo, odr,
 198                                    b->m_targets);
 199     Z_InitRequest *req = init_apdu->u.initRequest;
 200
 201     // copy stuff from Frontend Init Request
 202     Z_GDU *org_gdu = m_init_gdu.get();
 203     Z_InitRequest *org_init = org_gdu->u.z3950->u.initRequest;
 204
 205     req->idAuthentication = org_init->idAuthentication;
 206     req->implementationId = org_init->implementationId;
 207     req->implementationName = org_init->implementationName;
 208     req->implementationVersion = org_init->implementationVersion;
 209
 210     ODR_MASK_SET(req->options, Z_Options_search);
 211     ODR_MASK_SET(req->options, Z_Options_present);
 212     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
 213     ODR_MASK_SET(req->options, Z_Options_scan);
 214
 215     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
 216     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
 217     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
 218
 219     init_package.request() = init_apdu;
 220
 221     init_package.move(b->m_route);  // sending init
 222
 223     Z_GDU *gdu = init_package.response().get();
 224     // we hope to get an init response
 225     if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 226         Z_APDU_initResponse)
 227     {
 228         Z_InitResponse *res = gdu->u.z3950->u.initResponse;
 229         if (ODR_MASK_GET(res->options, Z_Options_namedResultSets))
 230         {
 231             b->m_named_result_sets = true;
 232         }
 233         if (!*res->result)
 234         {
 235             error_code = YAZ_BIB1_DATABASE_UNAVAILABLE;
 236             mp::util::get_init_diagnostics(res, error_code, addinfo);
 237             BackendPtr null;
 238             return null;
 239         }
 240     }
 241     else
 242     {
 243         error_code = YAZ_BIB1_DATABASE_UNAVAILABLE;
 244         // addinfo = database;
 245         BackendPtr null;
 246         return null;
 247     }
 248     if (init_package.session().is_closed())
 249     {
 250         error_code = YAZ_BIB1_DATABASE_UNAVAILABLE;
 251         // addinfo = database;
 252         BackendPtr null;
 253         return null;
 254     }
 255
 256     m_backend_list.push_back(b);
 257     return b;
 258 }
 259
 260 void yf::VirtualDB::Frontend::search(mp::Package &package, Z_APDU *apdu_req)
 261 {
 262     Z_SearchRequest *req = apdu_req->u.searchRequest;
 263     std::string vhost;
 264     std::string resultSetId = req->resultSetName;
 265     mp::odr odr;
 266
 267     std::list<std::string> databases;
 268     int i;
 269     for (i = 0; i<req->num_databaseNames; i++)
 270         databases.push_back(req->databaseNames[i]);
 271
 272     BackendPtr b; // null for now
 273     Sets_it sets_it = m_sets.find(req->resultSetName);
 274     if (sets_it != m_sets.end())
 275     {
 276         // result set already exist
 277         // if replace indicator is off: we return diagnostic if
 278         // result set already exist.
 279         if (*req->replaceIndicator == 0)
 280         {
 281             Z_APDU *apdu =
 282                 odr.create_searchResponse(
 283                     apdu_req,
 284                     YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 285                     0);
 286             package.response() = apdu;
 287
 288             return;
 289         }
 290         sets_it->second.m_backend->m_number_of_sets--;
 291
 292         // pick up any existing backend with a database match
 293         std::list<BackendPtr>::const_iterator map_it;
 294         map_it = m_backend_list.begin();
 295         for (; map_it != m_backend_list.end(); map_it++)
 296         {
 297             BackendPtr tmp = *map_it;
 298             if (tmp->m_frontend_databases == databases)
 299                 break;
 300         }
 301         if (map_it != m_backend_list.end())
 302             b = *map_it;
 303     }
 304     else
 305     {
 306         // new result set.
 307
 308         // pick up any existing database with named result sets ..
 309         // or one which has no result sets.. yet.
 310         std::list<BackendPtr>::const_iterator map_it;
 311         map_it = m_backend_list.begin();
 312         for (; map_it != m_backend_list.end(); map_it++)
 313         {
 314             BackendPtr tmp = *map_it;
 315             if (tmp->m_frontend_databases == databases &&
 316                 (tmp->m_named_result_sets ||
 317                  tmp->m_number_of_sets == 0))
 318                 break;
 319         }
 320         if (map_it != m_backend_list.end())
 321             b = *map_it;
 322     }
 323     if (!b)  // no backend yet. Must create a new one
 324     {
 325         int error_code;
 326         std::string addinfo;
 327         b = init_backend(databases, package, error_code, addinfo);
 328         if (!b)
 329         {
 330             // did not get a backend (unavailable somehow?)
 331
 332             Z_APDU *apdu =
 333                 odr.create_searchResponse(
 334                     apdu_req, error_code, addinfo.c_str());
 335             package.response() = apdu;
 336             return;
 337         }
 338     }
 339     m_sets.erase(req->resultSetName);
 340     // sending search to backend
 341     Package search_package(b->m_backend_session, package.origin());
 342
 343     search_package.copy_filter(package);
 344
 345     std::string backend_setname;
 346     if (b->m_named_result_sets)
 347     {
 348         backend_setname = std::string(req->resultSetName);
 349     }
 350     else
 351     {
 352         backend_setname = "default";
 353         req->resultSetName = odr_strdup(odr, backend_setname.c_str());
 354     }
 355
 356     // pick first targets spec and move the databases from it ..
 357     std::list<std::string>::const_iterator t_it = b->m_targets.begin();
 358     if (t_it != b->m_targets.end())
 359     {
 360         mp::util::set_databases_from_zurl(odr, *t_it,
 361                                                 &req->num_databaseNames,
 362                                                 &req->databaseNames);
 363     }
 364
 365     *req->replaceIndicator = 1;
 366
 367     search_package.request() = yazpp_1::GDU(apdu_req);
 368
 369     search_package.move(b->m_route);
 370
 371     if (search_package.session().is_closed())
 372     {
 373         package.response() = search_package.response();
 374         package.session().close();
 375         return;
 376     }
 377     b->m_number_of_sets++;
 378
 379     m_sets[resultSetId] = VirtualDB::Set(b, backend_setname);
 380     fixup_package(search_package, b);
 381     package.response() = search_package.response();
 382 }
 383
 384 yf::VirtualDB::Frontend::Frontend(Rep *rep)
 385 {
 386     m_p = rep;
 387     m_is_virtual = false;
 388 }
 389
 390 void yf::VirtualDB::Frontend::close(mp::Package &package)
 391 {
 392     std::list<BackendPtr>::const_iterator b_it;
 393
 394     for (b_it = m_backend_list.begin(); b_it != m_backend_list.end(); b_it++)
 395     {
 396         (*b_it)->m_backend_session.close();
 397         Package close_package((*b_it)->m_backend_session, package.origin());
 398         close_package.copy_filter(package);
 399         close_package.move((*b_it)->m_route);
 400     }
 401     m_backend_list.clear();
 402 }
 403
 404 yf::VirtualDB::Frontend::~Frontend()
 405 {
 406 }
 407
 408 yf::VirtualDB::FrontendPtr yf::VirtualDB::Rep::get_frontend(mp::Package &package)
 409 {
 410     boost::mutex::scoped_lock lock(m_mutex);
 411
 412     std::map<mp::Session,yf::VirtualDB::FrontendPtr>::iterator it;
 413
 414     while(true)
 415     {
 416         it = m_clients.find(package.session());
 417         if (it == m_clients.end())
 418             break;
 419
 420         if (!it->second->m_in_use)
 421         {
 422             it->second->m_in_use = true;
 423             return it->second;
 424         }
 425         m_cond_session_ready.wait(lock);
 426     }
 427     FrontendPtr f(new Frontend(this));
 428     m_clients[package.session()] = f;
 429     f->m_in_use = true;
 430     return f;
 431 }
 432
 433 void yf::VirtualDB::Rep::release_frontend(mp::Package &package)
 434 {
 435     boost::mutex::scoped_lock lock(m_mutex);
 436     std::map<mp::Session,yf::VirtualDB::FrontendPtr>::iterator it;
 437
 438     it = m_clients.find(package.session());
 439     if (it != m_clients.end())
 440     {
 441         if (package.session().is_closed())
 442         {
 443             it->second->close(package);
 444             m_clients.erase(it);
 445         }
 446         else
 447         {
 448             it->second->m_in_use = false;
 449         }
 450         m_cond_session_ready.notify_all();
 451     }
 452 }
 453
 454 yf::VirtualDB::Set::Set(BackendPtr b, std::string setname)
 455     :  m_backend(b), m_setname(setname)
 456 {
 457 }
 458
 459
 460 yf::VirtualDB::Set::Set()
 461 {
 462 }
 463
 464
 465 yf::VirtualDB::Set::~Set()
 466 {
 467 }
 468
 469 yf::VirtualDB::Map::Map(std::list<std::string> targets, std::string route)
 470     : m_targets(targets), m_route(route)
 471 {
 472 }
 473
 474 yf::VirtualDB::Map::Map()
 475 {
 476 }
 477
 478 yf::VirtualDB::VirtualDB() : m_p(new VirtualDB::Rep)
 479 {
 480 }
 481
 482 yf::VirtualDB::~VirtualDB() {
 483 }
 484
 485 void yf::VirtualDB::Frontend::fixup_npr_record(ODR odr, Z_NamePlusRecord *npr,
 486                                              BackendPtr b)
 487 {
 488     if (npr->databaseName)
 489     {
 490         std::string b_database = std::string(npr->databaseName);
 491
 492         // consider each of the frontend databases..
 493         std::list<std::string>::const_iterator db_it;
 494         for (db_it = b->m_frontend_databases.begin();
 495              db_it != b->m_frontend_databases.end(); db_it++)
 496         {
 497             // see which target it corresponds to.. (if any)
 498             std::map<std::string,VirtualDB::Map>::const_iterator map_it;
 499
 500             map_it = m_p->m_maps.find(mp::util::database_name_normalize(*db_it));
 501             if (map_it != m_p->m_maps.end())
 502             {
 503                 VirtualDB::Map m = map_it->second;
 504
 505                 std::list<std::string>::const_iterator t;
 506                 for (t = m.m_targets.begin(); t != m.m_targets.end(); t++)
 507                 {
 508                     if (*t == b_database)
 509                     {
 510                         npr->databaseName = odr_strdup(odr, (*db_it).c_str());
 511                         return;
 512                     }
 513                 }
 514             }
 515
 516         }
 517         db_it = b->m_frontend_databases.begin();
 518         if (db_it != b->m_frontend_databases.end())
 519         {
 520             std::string database = *db_it;
 521             npr->databaseName = odr_strdup(odr, database.c_str());
 522         }
 523     }
 524 }
 525
 526 void yf::VirtualDB::Frontend::fixup_npr_records(ODR odr, Z_Records *records,
 527                                               BackendPtr b)
 528 {
 529     if (records && records->which == Z_Records_DBOSD)
 530     {
 531         Z_NamePlusRecordList *nprlist = records->u.databaseOrSurDiagnostics;
 532         int i;
 533         for (i = 0; i < nprlist->num_records; i++)
 534         {
 535             fixup_npr_record(odr, nprlist->records[i], b);
 536         }
 537     }
 538 }
 539
 540 void yf::VirtualDB::Frontend::fixup_package(mp::Package &p, BackendPtr b)
 541 {
 542     Z_GDU *gdu = p.response().get();
 543     mp::odr odr;
 544
 545     if (gdu && gdu->which == Z_GDU_Z3950)
 546     {
 547         Z_APDU *apdu = gdu->u.z3950;
 548         if (apdu->which == Z_APDU_presentResponse)
 549         {
 550             fixup_npr_records(odr, apdu->u.presentResponse->records, b);
 551             p.response() = gdu;
 552         }
 553         else if (apdu->which == Z_APDU_searchResponse)
 554         {
 555             fixup_npr_records(odr,  apdu->u.searchResponse->records, b);
 556             p.response() = gdu;
 557         }
 558     }
 559 }
 560
 561 void yf::VirtualDB::Frontend::present(mp::Package &package, Z_APDU *apdu_req)
 562 {
 563     Z_PresentRequest *req = apdu_req->u.presentRequest;
 564     std::string resultSetId = req->resultSetId;
 565     mp::odr odr;
 566
 567     Sets_it sets_it = m_sets.find(resultSetId);
 568     if (sets_it == m_sets.end())
 569     {
 570         Z_APDU *apdu =
 571             odr.create_presentResponse(
 572                 apdu_req,
 573                 YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
 574                 resultSetId.c_str());
 575         package.response() = apdu;
 576         return;
 577     }
 578     Session *id =
 579         new mp::Session(sets_it->second.m_backend->m_backend_session);
 580
 581     // sending present to backend
 582     Package present_package(*id, package.origin());
 583     present_package.copy_filter(package);
 584
 585     req->resultSetId = odr_strdup(odr, sets_it->second.m_setname.c_str());
 586
 587     present_package.request() = yazpp_1::GDU(apdu_req);
 588
 589     present_package.move(sets_it->second.m_backend->m_route);
 590
 591     fixup_package(present_package, sets_it->second.m_backend);
 592
 593     if (present_package.session().is_closed())
 594     {
 595         package.response() = present_package.response();
 596         package.session().close();
 597         return;
 598     }
 599     else
 600     {
 601         package.response() = present_package.response();
 602     }
 603     delete id;
 604 }
 605
 606 void yf::VirtualDB::Frontend::scan(mp::Package &package, Z_APDU *apdu_req)
 607 {
 608     Z_ScanRequest *req = apdu_req->u.scanRequest;
 609     std::string vhost;
 610     mp::odr odr;
 611
 612     std::list<std::string> databases;
 613     int i;
 614     for (i = 0; i<req->num_databaseNames; i++)
 615         databases.push_back(req->databaseNames[i]);
 616
 617     BackendPtr b;
 618     // pick up any existing backend with a database match
 619     std::list<BackendPtr>::const_iterator map_it;
 620     map_it = m_backend_list.begin();
 621     for (; map_it != m_backend_list.end(); map_it++)
 622     {
 623         BackendPtr tmp = *map_it;
 624         if (tmp->m_frontend_databases == databases)
 625             break;
 626     }
 627     if (map_it != m_backend_list.end())
 628         b = *map_it;
 629     if (!b)  // no backend yet. Must create a new one
 630     {
 631         int error_code;
 632         std::string addinfo;
 633         b = init_backend(databases, package, error_code, addinfo);
 634         if (!b)
 635         {
 636             // did not get a backend (unavailable somehow?)
 637             Z_APDU *apdu =
 638                 odr.create_scanResponse(
 639                     apdu_req, error_code, addinfo.c_str());
 640             package.response() = apdu;
 641
 642             return;
 643         }
 644     }
 645     // sending scan to backend
 646     Package scan_package(b->m_backend_session, package.origin());
 647
 648     scan_package.copy_filter(package);
 649
 650     // pick first targets spec and move the databases from it ..
 651     std::list<std::string>::const_iterator t_it = b->m_targets.begin();
 652     if (t_it != b->m_targets.end())
 653     {
 654         mp::util::set_databases_from_zurl(odr, *t_it,
 655                                                 &req->num_databaseNames,
 656                                                 &req->databaseNames);
 657     }
 658     scan_package.request() = yazpp_1::GDU(apdu_req);
 659
 660     scan_package.move(b->m_route);
 661
 662     if (scan_package.session().is_closed())
 663     {
 664         package.response() = scan_package.response();
 665         package.session().close();
 666         return;
 667     }
 668     package.response() = scan_package.response();
 669 }
 670
 671
 672 void yf::VirtualDB::add_map_db2targets(std::string db,
 673                                      std::list<std::string> targets,
 674                                      std::string route)
 675 {
 676     m_p->m_maps[mp::util::database_name_normalize(db)]
 677         = VirtualDB::Map(targets, route);
 678 }
 679
 680
 681 void yf::VirtualDB::add_map_db2target(std::string db,
 682                                     std::string target,
 683                                     std::string route)
 684 {
 685     std::list<std::string> targets;
 686     targets.push_back(target);
 687
 688     m_p->m_maps[mp::util::database_name_normalize(db)]
 689         = VirtualDB::Map(targets, route);
 690 }
 691
 692 void yf::VirtualDB::process(mp::Package &package) const
 693 {
 694     FrontendPtr f = m_p->get_frontend(package);
 695
 696     Z_GDU *gdu = package.request().get();
 697
 698     if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
 699         Z_APDU_initRequest && !f->m_is_virtual)
 700     {
 701         Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 702
 703         std::list<std::string> vhosts;
 704         mp::util::get_vhost_otherinfo(req->otherInfo, vhosts);
 705         if (vhosts.size() == 0)
 706         {
 707             f->m_init_gdu = gdu;
 708
 709             mp::odr odr;
 710             Z_APDU *apdu = odr.create_initResponse(gdu->u.z3950, 0, 0);
 711             Z_InitResponse *resp = apdu->u.initResponse;
 712
 713             int i;
 714             static const int masks[] = {
 715                 Z_Options_search,
 716                 Z_Options_present,
 717                 Z_Options_namedResultSets,
 718                 Z_Options_scan,
 719                 -1
 720             };
 721             for (i = 0; masks[i] != -1; i++)
 722                 if (ODR_MASK_GET(req->options, masks[i]))
 723                     ODR_MASK_SET(resp->options, masks[i]);
 724
 725             static const int versions[] = {
 726                 Z_ProtocolVersion_1,
 727                 Z_ProtocolVersion_2,
 728                 Z_ProtocolVersion_3,
 729                 -1
 730             };
 731             for (i = 0; versions[i] != -1; i++)
 732                 if (ODR_MASK_GET(req->protocolVersion, versions[i]))
 733                     ODR_MASK_SET(resp->protocolVersion, versions[i]);
 734                 else
 735                     break;
 736
 737             package.response() = apdu;
 738             f->m_is_virtual = true;
 739         }
 740         else
 741             package.move();
 742     }
 743     else if (!f->m_is_virtual)
 744         package.move();
 745     else if (gdu && gdu->which == Z_GDU_Z3950)
 746     {
 747         Z_APDU *apdu = gdu->u.z3950;
 748         if (apdu->which == Z_APDU_initRequest)
 749         {
 750             mp::odr odr;
 751
 752             package.response() = odr.create_close(
 753                 apdu,
 754                 Z_Close_protocolError,
 755                 "double init");
 756
 757             package.session().close();
 758         }
 759         else if (apdu->which == Z_APDU_searchRequest)
 760         {
 761             f->search(package, apdu);
 762         }
 763         else if (apdu->which == Z_APDU_presentRequest)
 764         {
 765             f->present(package, apdu);
 766         }
 767         else if (apdu->which == Z_APDU_scanRequest)
 768         {
 769             f->scan(package, apdu);
 770         }
 771         else if (apdu->which == Z_APDU_close)
 772         {
 773             package.session().close();
 774         }
 775         else
 776         {
 777             mp::odr odr;
 778
 779             package.response() = odr.create_close(
 780                 apdu, Z_Close_protocolError,
 781                 "unsupported APDU in filter_virt_db");
 782
 783             package.session().close();
 784         }
 785     }
 786     m_p->release_frontend(package);
 787 }
 788
 789
 790 void mp::filter::VirtualDB::configure(const xmlNode * ptr, bool test_only)
 791 {
 792     for (ptr = ptr->children; ptr; ptr = ptr->next)
 793     {
 794         if (ptr->type != XML_ELEMENT_NODE)
 795             continue;
 796         if (!strcmp((const char *) ptr->name, "virtual"))
 797         {
 798             std::string database;
 799             std::list<std::string> targets;
 800             xmlNode *v_node = ptr->children;
 801             for (; v_node; v_node = v_node->next)
 802             {
 803                 if (v_node->type != XML_ELEMENT_NODE)
 804                     continue;
 805
 806                 if (mp::xml::is_element_mp(v_node, "database"))
 807                     database = mp::xml::get_text(v_node);
 808                 else if (mp::xml::is_element_mp(v_node, "target"))
 809                     targets.push_back(mp::xml::get_text(v_node));
 810                 else
 811                     throw mp::filter::FilterException
 812                         ("Bad element "
 813                          + std::string((const char *) v_node->name)
 814                          + " in virtual section"
 815                             );
 816             }
 817             std::string route = mp::xml::get_route(ptr);
 818             add_map_db2targets(database, targets, route);
 819         }
 820         else
 821         {
 822             throw mp::filter::FilterException
 823                 ("Bad element "
 824                  + std::string((const char *) ptr->name)
 825                  + " in virt_db filter");
 826         }
 827     }
 828 }
 829
 830 static mp::filter::Base* filter_creator()
 831 {
 832     return new mp::filter::VirtualDB;
 833 }
 834
 835 extern "C" {
 836     struct metaproxy_1_filter_struct metaproxy_1_filter_virt_db = {
 837         0,
 838         "virt_db",
 839         filter_creator
 840     };
 841 }
 842
 843
 844 /*
 845  * Local variables:
 846  * c-basic-offset: 4
 847  * indent-tabs-mode: nil
 848  * c-file-style: "stroustrup"
 849  * End:
 850  * vim: shiftwidth=4 tabstop=8 expandtab
 851  */