src/filter_virt_db.cpp

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