src/filter_virt_db.cpp

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