src/filter_session_shared.cpp

   1 /* This file is part of Metaproxy.
   2    Copyright (C) 2005-2013 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 <metaproxy/filter.hpp>
  22 #include <metaproxy/package.hpp>
  23
  24 #include <boost/thread/mutex.hpp>
  25 #include <boost/thread/condition.hpp>
  26 #include <boost/thread/thread.hpp>
  27 #include <boost/thread/xtime.hpp>
  28 #include <boost/shared_ptr.hpp>
  29 #include <boost/format.hpp>
  30
  31 #include <metaproxy/util.hpp>
  32 #include "filter_session_shared.hpp"
  33
  34 #include <yaz/copy_types.h>
  35 #include <yaz/log.h>
  36 #include <yaz/zgdu.h>
  37 #include <yaz/otherinfo.h>
  38 #include <yaz/diagbib1.h>
  39 #include <yazpp/z-query.h>
  40 #include <yazpp/record-cache.h>
  41 #include <map>
  42 #include <iostream>
  43 #include <time.h>
  44
  45 namespace mp = metaproxy_1;
  46 namespace yf = metaproxy_1::filter;
  47
  48 namespace metaproxy_1 {
  49
  50     namespace filter {
  51         // key for session.. We'll only share sessions with same InitKey
  52         class SessionShared::InitKey {
  53         public:
  54             bool operator < (const SessionShared::InitKey &k) const;
  55             InitKey(Z_InitRequest *req);
  56             InitKey(const InitKey &);
  57             ~InitKey();
  58         private:
  59             char *m_idAuthentication_buf;
  60             int m_idAuthentication_size;
  61             char *m_otherInfo_buf;
  62             int m_otherInfo_size;
  63             ODR m_odr;
  64         };
  65         // worker thread .. for expiry of sessions
  66         class SessionShared::Worker {
  67         public:
  68             Worker(SessionShared::Rep *rep);
  69             void operator() (void);
  70         private:
  71             SessionShared::Rep *m_p;
  72         };
  73         // backend result set
  74         class SessionShared::BackendSet {
  75         public:
  76             std::string m_result_set_id;
  77             Databases m_databases;
  78             Odr_int m_result_set_size;
  79             yazpp_1::Yaz_Z_Query m_query;
  80             time_t m_time_last_use;
  81             void timestamp();
  82             yazpp_1::RecordCache m_record_cache;
  83
  84             Z_OtherInformation *additionalSearchInfoRequest;
  85             Z_OtherInformation *additionalSearchInfoResponse;
  86             NMEM mem_additionalSearchInfo;
  87             BackendSet(
  88                 const std::string &result_set_id,
  89                 const Databases &databases,
  90                 const yazpp_1::Yaz_Z_Query &query,
  91                 Z_OtherInformation *additionalSearchInfoRequest);
  92             ~BackendSet();
  93             bool search(
  94                 Package &frontend_package,
  95                 Package &search_package,
  96                 const Z_APDU *apdu_req,
  97                 const BackendInstancePtr bp,
  98                 Z_Records **z_records);
  99         };
 100         // backend connection instance
 101         class SessionShared::BackendInstance {
 102             friend class Rep;
 103             friend class BackendClass;
 104             friend class BackendSet;
 105         public:
 106             mp::Session m_session;
 107             BackendSetList m_sets;
 108             bool m_in_use;
 109             int m_sequence_this;
 110             int m_result_set_sequence;
 111             time_t m_time_last_use;
 112             mp::Package * m_close_package;
 113             ~BackendInstance();
 114             void timestamp();
 115         };
 116         // backends of some class (all with same InitKey)
 117         class SessionShared::BackendClass : boost::noncopyable {
 118             friend class Rep;
 119             friend struct Frontend;
 120             bool m_named_result_sets;
 121             BackendInstanceList m_backend_list;
 122             BackendInstancePtr create_backend(const Package &package);
 123             void remove_backend(BackendInstancePtr b);
 124             BackendInstancePtr get_backend(const Package &package);
 125             void use_backend(BackendInstancePtr b);
 126             void release_backend(BackendInstancePtr b);
 127             bool expire_instances();
 128             yazpp_1::GDU m_init_request;
 129             yazpp_1::GDU m_init_response;
 130             boost::mutex m_mutex_backend_class;
 131             int m_sequence_top;
 132             time_t m_backend_set_ttl;
 133             time_t m_backend_expiry_ttl;
 134             size_t m_backend_set_max;
 135             Odr_int m_preferredMessageSize;
 136             Odr_int m_maximumRecordSize;
 137         public:
 138             BackendClass(const yazpp_1::GDU &init_request,
 139                          int resultset_ttl,
 140                          int resultset_max,
 141                          int session_ttl,
 142                          Odr_int preferredRecordSize,
 143                          Odr_int maximumRecordSize);
 144             ~BackendClass();
 145         };
 146         // frontend result set
 147         class SessionShared::FrontendSet {
 148             Databases m_databases;
 149             yazpp_1::Yaz_Z_Query m_query;
 150         public:
 151             const Databases &get_databases();
 152             const yazpp_1::Yaz_Z_Query &get_query();
 153             FrontendSet(
 154                 const Databases &databases,
 155                 const yazpp_1::Yaz_Z_Query &query);
 156             FrontendSet();
 157         };
 158         // frontend session
 159         struct SessionShared::Frontend {
 160             Frontend(Rep *rep);
 161             ~Frontend();
 162             bool m_is_virtual;
 163             bool m_in_use;
 164             Z_Options m_init_options;
 165             void search(Package &package, Z_APDU *apdu);
 166             void present(Package &package, Z_APDU *apdu);
 167             void scan(Package &package, Z_APDU *apdu);
 168
 169             int result_set_ref(ODR o,
 170                                const Databases &databases,
 171                                Z_RPNStructure *s, std::string &rset);
 172             void get_set(mp::Package &package,
 173                          const Z_APDU *apdu_req,
 174                          const Databases &databases,
 175                          yazpp_1::Yaz_Z_Query &query,
 176                          BackendInstancePtr &found_backend,
 177                          BackendSetPtr &found_set);
 178             void override_set(BackendInstancePtr &found_backend,
 179                               std::string &result_set_id,
 180                               const Databases &databases,
 181                               bool out_of_sessions);
 182
 183             Rep *m_p;
 184             BackendClassPtr m_backend_class;
 185             FrontendSets m_frontend_sets;
 186         };
 187         // representation
 188         class SessionShared::Rep {
 189             friend class SessionShared;
 190             friend struct Frontend;
 191
 192             FrontendPtr get_frontend(Package &package);
 193             void release_frontend(Package &package);
 194             Rep();
 195         public:
 196             void expire();
 197         private:
 198             void expire_classes();
 199             void stat();
 200             void init(Package &package, const Z_GDU *gdu,
 201                       FrontendPtr frontend);
 202             void start();
 203             boost::mutex m_mutex;
 204             boost::condition m_cond_session_ready;
 205             std::map<mp::Session, FrontendPtr> m_clients;
 206
 207             BackendClassMap m_backend_map;
 208             boost::mutex m_mutex_backend_map;
 209             boost::thread_group m_thrds;
 210             int m_resultset_ttl;
 211             int m_resultset_max;
 212             int m_session_ttl;
 213             bool m_optimize_search;
 214             bool m_restart;
 215             int m_session_max;
 216             Odr_int m_preferredMessageSize;
 217             Odr_int m_maximumRecordSize;
 218         };
 219     }
 220 }
 221
 222 yf::SessionShared::FrontendSet::FrontendSet(
 223     const Databases &databases,
 224     const yazpp_1::Yaz_Z_Query &query)
 225     : m_databases(databases), m_query(query)
 226 {
 227 }
 228
 229 const yf::SessionShared::Databases &
 230 yf::SessionShared::FrontendSet::get_databases()
 231 {
 232     return m_databases;
 233 }
 234
 235 const yazpp_1::Yaz_Z_Query& yf::SessionShared::FrontendSet::get_query()
 236 {
 237     return m_query;
 238 }
 239
 240 yf::SessionShared::InitKey::InitKey(const InitKey &k)
 241 {
 242     m_odr = odr_createmem(ODR_ENCODE);
 243
 244     m_idAuthentication_size =  k.m_idAuthentication_size;
 245     m_idAuthentication_buf = (char*)odr_malloc(m_odr, m_idAuthentication_size);
 246     memcpy(m_idAuthentication_buf, k.m_idAuthentication_buf,
 247            m_idAuthentication_size);
 248
 249     m_otherInfo_size =  k.m_otherInfo_size;
 250     m_otherInfo_buf = (char*)odr_malloc(m_odr, m_otherInfo_size);
 251     memcpy(m_otherInfo_buf, k.m_otherInfo_buf,
 252            m_otherInfo_size);
 253 }
 254
 255 yf::SessionShared::InitKey::InitKey(Z_InitRequest *req)
 256 {
 257     m_odr = odr_createmem(ODR_ENCODE);
 258
 259     Z_IdAuthentication *t = req->idAuthentication;
 260     z_IdAuthentication(m_odr, &t, 1, 0);
 261     m_idAuthentication_buf =
 262         odr_getbuf(m_odr, &m_idAuthentication_size, 0);
 263
 264     Z_OtherInformation *o = req->otherInfo;
 265     z_OtherInformation(m_odr, &o, 1, 0);
 266     m_otherInfo_buf = odr_getbuf(m_odr, &m_otherInfo_size, 0);
 267 }
 268
 269 yf::SessionShared::InitKey::~InitKey()
 270 {
 271     odr_destroy(m_odr);
 272 }
 273
 274 bool yf::SessionShared::InitKey::operator < (const SessionShared::InitKey &k)
 275     const
 276 {
 277     int c;
 278     c = mp::util::memcmp2(
 279         (void*) m_idAuthentication_buf, m_idAuthentication_size,
 280         (void*) k.m_idAuthentication_buf, k.m_idAuthentication_size);
 281     if (c < 0)
 282         return true;
 283     else if (c > 0)
 284         return false;
 285
 286     c = mp::util::memcmp2((void*) m_otherInfo_buf, m_otherInfo_size,
 287                           (void*) k.m_otherInfo_buf, k.m_otherInfo_size);
 288     if (c < 0)
 289         return true;
 290     else if (c > 0)
 291         return false;
 292     return false;
 293 }
 294
 295 void yf::SessionShared::BackendClass::release_backend(BackendInstancePtr b)
 296 {
 297     boost::mutex::scoped_lock lock(m_mutex_backend_class);
 298     b->m_in_use = false;
 299 }
 300
 301
 302 void yf::SessionShared::BackendClass::remove_backend(BackendInstancePtr b)
 303 {
 304     BackendInstanceList::iterator it = m_backend_list.begin();
 305
 306     while (it != m_backend_list.end())
 307     {
 308         if (*it == b)
 309         {
 310              mp::odr odr;
 311             (*it)->m_close_package->response() = odr.create_close(
 312                 0, Z_Close_lackOfActivity, 0);
 313             (*it)->m_close_package->session().close();
 314             (*it)->m_close_package->move();
 315
 316             it = m_backend_list.erase(it);
 317         }
 318         else
 319             it++;
 320     }
 321 }
 322
 323
 324
 325 yf::SessionShared::BackendInstancePtr
 326 yf::SessionShared::BackendClass::get_backend(
 327     const mp::Package &frontend_package)
 328 {
 329     {
 330         boost::mutex::scoped_lock lock(m_mutex_backend_class);
 331
 332         BackendInstanceList::const_iterator it = m_backend_list.begin();
 333
 334         BackendInstancePtr backend1; // null
 335
 336         for (; it != m_backend_list.end(); it++)
 337         {
 338             if (!(*it)->m_in_use)
 339             {
 340                 if (!backend1
 341                     || (*it)->m_sequence_this < backend1->m_sequence_this)
 342                     backend1 = *it;
 343             }
 344         }
 345         if (backend1)
 346         {
 347             use_backend(backend1);
 348             return backend1;
 349         }
 350     }
 351     return create_backend(frontend_package);
 352 }
 353
 354 void yf::SessionShared::BackendClass::use_backend(BackendInstancePtr backend)
 355 {
 356     backend->m_in_use = true;
 357     backend->m_sequence_this = m_sequence_top++;
 358 }
 359
 360 void yf::SessionShared::BackendInstance::timestamp()
 361 {
 362     assert(m_in_use);
 363     time(&m_time_last_use);
 364 }
 365
 366 yf::SessionShared::BackendInstance::~BackendInstance()
 367 {
 368     delete m_close_package;
 369 }
 370
 371 yf::SessionShared::BackendInstancePtr yf::SessionShared::BackendClass::create_backend(
 372     const mp::Package &frontend_package)
 373 {
 374     BackendInstancePtr bp(new BackendInstance);
 375     BackendInstancePtr null;
 376
 377     bp->m_close_package =
 378         new mp::Package(bp->m_session, frontend_package.origin());
 379     bp->m_close_package->copy_filter(frontend_package);
 380
 381     Package init_package(bp->m_session, frontend_package.origin());
 382
 383     init_package.copy_filter(frontend_package);
 384
 385     yazpp_1::GDU actual_init_request = m_init_request;
 386     Z_GDU *init_pdu = actual_init_request.get();
 387
 388     assert(init_pdu->which == Z_GDU_Z3950);
 389     assert(init_pdu->u.z3950->which == Z_APDU_initRequest);
 390
 391     Z_InitRequest *req = init_pdu->u.z3950->u.initRequest;
 392     ODR_MASK_ZERO(req->options);
 393
 394     ODR_MASK_SET(req->options, Z_Options_search);
 395     ODR_MASK_SET(req->options, Z_Options_present);
 396     ODR_MASK_SET(req->options, Z_Options_namedResultSets);
 397     ODR_MASK_SET(req->options, Z_Options_scan);
 398
 399     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_1);
 400     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_2);
 401     ODR_MASK_SET(req->protocolVersion, Z_ProtocolVersion_3);
 402
 403     if (m_preferredMessageSize)
 404         *req->preferredMessageSize = m_preferredMessageSize;
 405     if (m_maximumRecordSize)
 406         *req->maximumRecordSize = m_maximumRecordSize;
 407
 408     init_package.request() = init_pdu;
 409
 410     init_package.move();
 411
 412     boost::mutex::scoped_lock lock(m_mutex_backend_class);
 413
 414     m_named_result_sets = false;
 415     Z_GDU *gdu = init_package.response().get();
 416
 417     if (gdu && gdu->which == Z_GDU_Z3950
 418         && gdu->u.z3950->which == Z_APDU_initResponse)
 419     {
 420         Z_InitResponse *res = gdu->u.z3950->u.initResponse;
 421         m_init_response = gdu->u.z3950;
 422         if (ODR_MASK_GET(res->options, Z_Options_namedResultSets))
 423         {
 424             m_named_result_sets = true;
 425         }
 426         if (*gdu->u.z3950->u.initResponse->result
 427             && !init_package.session().is_closed())
 428         {
 429             bp->m_in_use = true;
 430             time(&bp->m_time_last_use);
 431             bp->m_sequence_this = 0;
 432             bp->m_result_set_sequence = 0;
 433             m_backend_list.push_back(bp);
 434             return bp;
 435         }
 436     }
 437     else
 438     {
 439         yazpp_1::GDU empty_gdu;
 440         m_init_response = empty_gdu;
 441     }
 442
 443     if (!init_package.session().is_closed())
 444     {
 445         init_package.copy_filter(frontend_package);
 446         init_package.session().close();
 447         init_package.move();
 448     }
 449     return null;
 450 }
 451
 452
 453 yf::SessionShared::BackendClass::BackendClass(const yazpp_1::GDU &init_request,
 454                                               int resultset_ttl,
 455                                               int resultset_max,
 456                                               int session_ttl,
 457                                               Odr_int preferredMessageSize,
 458                                               Odr_int maximumRecordSize)
 459     : m_named_result_sets(false), m_init_request(init_request),
 460       m_sequence_top(0), m_backend_set_ttl(resultset_ttl),
 461       m_backend_expiry_ttl(session_ttl), m_backend_set_max(resultset_max),
 462       m_preferredMessageSize(preferredMessageSize),
 463       m_maximumRecordSize(maximumRecordSize)
 464 {}
 465
 466 yf::SessionShared::BackendClass::~BackendClass()
 467 {}
 468
 469 void yf::SessionShared::Rep::stat()
 470 {
 471     int no_classes = 0;
 472     int no_instances = 0;
 473     BackendClassMap::const_iterator it;
 474     {
 475         boost::mutex::scoped_lock lock(m_mutex_backend_map);
 476         for (it = m_backend_map.begin(); it != m_backend_map.end(); it++)
 477         {
 478             BackendClassPtr bc = it->second;
 479             no_classes++;
 480             BackendInstanceList::iterator bit = bc->m_backend_list.begin();
 481             for (; bit != bc->m_backend_list.end(); bit++)
 482                 no_instances++;
 483         }
 484     }
 485     yaz_log(YLOG_LOG, "backend classes=%d instances=%d", no_classes,
 486         no_instances);
 487 }
 488
 489 void yf::SessionShared::Rep::init(mp::Package &package, const Z_GDU *gdu,
 490                                   FrontendPtr frontend)
 491 {
 492     Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 493
 494     frontend->m_is_virtual = true;
 495     frontend->m_init_options = *req->options;
 496     InitKey k(req);
 497     {
 498         boost::mutex::scoped_lock lock(m_mutex_backend_map);
 499         BackendClassMap::const_iterator it;
 500         it = m_backend_map.find(k);
 501         if (it == m_backend_map.end())
 502         {
 503             BackendClassPtr b(new BackendClass(gdu->u.z3950,
 504                                                m_resultset_ttl,
 505                                                m_resultset_max,
 506                                                m_session_ttl,
 507                                                m_preferredMessageSize,
 508                                                m_maximumRecordSize));
 509             m_backend_map[k] = b;
 510             frontend->m_backend_class = b;
 511         }
 512         else
 513         {
 514             frontend->m_backend_class = it->second;
 515         }
 516     }
 517     BackendClassPtr bc = frontend->m_backend_class;
 518     mp::odr odr;
 519
 520     // we only need to get init response from "first" target in
 521     // backend class - the assumption being that init response is
 522     // same for all
 523     if (bc->m_backend_list.size() == 0)
 524     {
 525         BackendInstancePtr backend = bc->create_backend(package);
 526         if (backend)
 527             bc->release_backend(backend);
 528     }
 529
 530     yazpp_1::GDU init_response;
 531     {
 532         boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 533
 534         init_response = bc->m_init_response;
 535     }
 536
 537     if (init_response.get())
 538     {
 539         Z_GDU *response_gdu = init_response.get();
 540         mp::util::transfer_referenceId(odr, gdu->u.z3950,
 541                                        response_gdu->u.z3950);
 542         Z_InitResponse *init_res = response_gdu->u.z3950->u.initResponse;
 543         Z_Options *server_options = init_res->options;
 544         Z_Options *client_options = &frontend->m_init_options;
 545         int i;
 546         for (i = 0; i < 30; i++)
 547             if (!ODR_MASK_GET(client_options, i))
 548                 ODR_MASK_CLEAR(server_options, i);
 549
 550         if (!m_preferredMessageSize ||
 551             *init_res->preferredMessageSize > *req->preferredMessageSize)
 552             *init_res->preferredMessageSize = *req->preferredMessageSize;
 553
 554         if (!m_maximumRecordSize ||
 555             *init_res->maximumRecordSize > *req->maximumRecordSize)
 556             *init_res->maximumRecordSize = *req->maximumRecordSize;
 557
 558         package.response() = init_response;
 559         if (!*response_gdu->u.z3950->u.initResponse->result)
 560             package.session().close();
 561     }
 562     else
 563     {
 564         Z_APDU *apdu =
 565             odr.create_initResponse(
 566                 gdu->u.z3950, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
 567                 "session_shared: target closed connection during init");
 568         *apdu->u.initResponse->result = 0;
 569         package.response() = apdu;
 570         package.session().close();
 571     }
 572 }
 573
 574 void yf::SessionShared::BackendSet::timestamp()
 575 {
 576     time(&m_time_last_use);
 577 }
 578
 579 yf::SessionShared::BackendSet::BackendSet(
 580     const std::string &result_set_id,
 581     const Databases &databases,
 582     const yazpp_1::Yaz_Z_Query &query,
 583     Z_OtherInformation *additionalSearchInfo) :
 584     m_result_set_id(result_set_id),
 585     m_databases(databases), m_result_set_size(0), m_query(query)
 586 {
 587     timestamp();
 588     mem_additionalSearchInfo = nmem_create();
 589     additionalSearchInfoResponse = 0;
 590     additionalSearchInfoRequest =
 591         yaz_clone_z_OtherInformation(additionalSearchInfo,
 592                                      mem_additionalSearchInfo);
 593 }
 594
 595 yf::SessionShared::BackendSet::~BackendSet()
 596 {
 597     nmem_destroy(mem_additionalSearchInfo);
 598 }
 599
 600 static int get_diagnostic(Z_DefaultDiagFormat *r)
 601 {
 602     return *r->condition;
 603 }
 604
 605 bool yf::SessionShared::BackendSet::search(
 606     mp::Package &frontend_package,
 607     mp::Package &search_package,
 608     const Z_APDU *frontend_apdu,
 609     const BackendInstancePtr bp,
 610     Z_Records **z_records)
 611 {
 612     mp::odr odr;
 613     Z_APDU *apdu_req = zget_APDU(odr, Z_APDU_searchRequest);
 614     Z_SearchRequest *req = apdu_req->u.searchRequest;
 615
 616     req->additionalSearchInfo = additionalSearchInfoRequest;
 617     req->resultSetName = odr_strdup(odr, m_result_set_id.c_str());
 618     req->query = m_query.get_Z_Query();
 619
 620     req->num_databaseNames = m_databases.size();
 621     req->databaseNames = (char**)
 622         odr_malloc(odr, req->num_databaseNames * sizeof(char *));
 623     Databases::const_iterator it = m_databases.begin();
 624     size_t i = 0;
 625     for (; it != m_databases.end(); it++)
 626         req->databaseNames[i++] = odr_strdup(odr, it->c_str());
 627
 628     if (frontend_apdu->which == Z_APDU_searchRequest)
 629         req->preferredRecordSyntax =
 630             frontend_apdu->u.searchRequest->preferredRecordSyntax;
 631
 632     search_package.request() = apdu_req;
 633
 634     search_package.move();
 635
 636     Z_GDU *gdu = search_package.response().get();
 637     if (!search_package.session().is_closed()
 638         && gdu && gdu->which == Z_GDU_Z3950
 639         && gdu->u.z3950->which == Z_APDU_searchResponse)
 640     {
 641         Z_SearchResponse *b_resp = gdu->u.z3950->u.searchResponse;
 642         *z_records = b_resp->records;
 643         m_result_set_size = *b_resp->resultCount;
 644
 645         additionalSearchInfoResponse = yaz_clone_z_OtherInformation(
 646             b_resp->additionalSearchInfo, mem_additionalSearchInfo);
 647         return true;
 648     }
 649     Z_APDU *f_apdu = 0;
 650     const char *addinfo = "session_shared: "
 651         "target closed connection during search";
 652     if (frontend_apdu->which == Z_APDU_searchRequest)
 653         f_apdu = odr.create_searchResponse(
 654             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 655     else if (frontend_apdu->which == Z_APDU_presentRequest)
 656         f_apdu = odr.create_presentResponse(
 657             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 658     else
 659         f_apdu = odr.create_close(
 660             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 661     frontend_package.response() = f_apdu;
 662     return false;
 663 }
 664
 665 void yf::SessionShared::Frontend::override_set(
 666     BackendInstancePtr &found_backend,
 667     std::string &result_set_id,
 668     const Databases &databases,
 669     bool out_of_sessions)
 670 {
 671     BackendClassPtr bc = m_backend_class;
 672     BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
 673     time_t now;
 674     time(&now);
 675
 676     size_t max_sets = bc->m_named_result_sets ? bc->m_backend_set_max : 1;
 677     for (; it != bc->m_backend_list.end(); it++)
 678     {
 679         if (!(*it)->m_in_use)
 680         {
 681             BackendSetList::iterator set_it = (*it)->m_sets.begin();
 682             for (; set_it != (*it)->m_sets.end(); set_it++)
 683             {
 684                 if ((max_sets > 1 || (*set_it)->m_databases == databases)
 685                     &&
 686                     (out_of_sessions ||
 687                      now < (*set_it)->m_time_last_use ||
 688                      now - (*set_it)->m_time_last_use >= bc->m_backend_set_ttl))
 689                 {
 690                     found_backend = *it;
 691                     result_set_id = (*set_it)->m_result_set_id;
 692                     found_backend->m_sets.erase(set_it);
 693                     return;
 694                 }
 695             }
 696         }
 697     }
 698     for (it = bc->m_backend_list.begin(); it != bc->m_backend_list.end(); it++)
 699     {
 700         if (!(*it)->m_in_use && (*it)->m_sets.size() < max_sets)
 701         {
 702             found_backend = *it;
 703             if (bc->m_named_result_sets)
 704             {
 705                 result_set_id = boost::io::str(
 706                     boost::format("%1%") %
 707                     found_backend->m_result_set_sequence);
 708                 found_backend->m_result_set_sequence++;
 709             }
 710             else
 711                 result_set_id = "default";
 712             return;
 713         }
 714     }
 715 }
 716
 717 void yf::SessionShared::Frontend::get_set(mp::Package &package,
 718                                           const Z_APDU *apdu_req,
 719                                           const Databases &databases,
 720                                           yazpp_1::Yaz_Z_Query &query,
 721                                           BackendInstancePtr &found_backend,
 722                                           BackendSetPtr &found_set)
 723 {
 724     bool session_restarted = false;
 725     Z_OtherInformation *additionalSearchInfo = 0;
 726
 727     if (apdu_req->which == Z_APDU_searchRequest)
 728         additionalSearchInfo = apdu_req->u.searchRequest->additionalSearchInfo;
 729
 730 restart:
 731     std::string result_set_id;
 732     bool out_of_sessions = false;
 733     BackendClassPtr bc = m_backend_class;
 734     {
 735         boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 736
 737         if ((int) bc->m_backend_list.size() >= m_p->m_session_max)
 738             out_of_sessions = true;
 739
 740         if (m_p->m_optimize_search)
 741         {
 742             // look at each backend and see if we have a similar search
 743             BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
 744             for (; it != bc->m_backend_list.end(); it++)
 745             {
 746                 if (!(*it)->m_in_use)
 747                 {
 748                     BackendSetList::const_iterator set_it = (*it)->m_sets.begin();
 749                     for (; set_it != (*it)->m_sets.end(); set_it++)
 750                     {
 751                         // for real present request we don't care
 752                         // if additionalSearchInfo matches: same records
 753                         if ((*set_it)->m_databases == databases
 754                             && query.match(&(*set_it)->m_query)
 755                             && (apdu_req->which != Z_APDU_searchRequest ||
 756                                 yaz_compare_z_OtherInformation(
 757                                     additionalSearchInfo,
 758                                 (*set_it)->additionalSearchInfoRequest)))
 759                         {
 760                             found_set = *set_it;
 761                             found_backend = *it;
 762                             bc->use_backend(found_backend);
 763                             // found matching set. No need to search again
 764                             return;
 765                         }
 766                     }
 767                 }
 768             }
 769         }
 770         override_set(found_backend, result_set_id, databases, out_of_sessions);
 771         if (found_backend)
 772             bc->use_backend(found_backend);
 773     }
 774     if (!found_backend)
 775     {
 776         // create a new backend set (and new set) if we're not out of sessions
 777         if (!out_of_sessions)
 778             found_backend = bc->create_backend(package);
 779
 780         if (!found_backend)
 781         {
 782             Z_APDU *f_apdu = 0;
 783             mp::odr odr;
 784             const char *addinfo = 0;
 785
 786             if (out_of_sessions)
 787                 addinfo = "session_shared: all sessions in use";
 788             else
 789                 addinfo = "session_shared: could not create backend";
 790             if (apdu_req->which == Z_APDU_searchRequest)
 791             {
 792                 f_apdu = odr.create_searchResponse(
 793                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 794             }
 795             else if (apdu_req->which == Z_APDU_presentRequest)
 796             {
 797                 f_apdu = odr.create_presentResponse(
 798                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 799             }
 800             else
 801             {
 802                 f_apdu = odr.create_close(
 803                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 804             }
 805             package.response() = f_apdu;
 806             return;
 807         }
 808         if (bc->m_named_result_sets)
 809         {
 810             result_set_id = boost::io::str(
 811                 boost::format("%1%") % found_backend->m_result_set_sequence);
 812             found_backend->m_result_set_sequence++;
 813         }
 814         else
 815             result_set_id = "default";
 816     }
 817     found_backend->timestamp();
 818
 819     // we must search ...
 820     BackendSetPtr new_set(new BackendSet(result_set_id,
 821                                          databases, query,
 822                                          additionalSearchInfo));
 823     Z_Records *z_records = 0;
 824
 825     Package search_package(found_backend->m_session, package.origin());
 826     search_package.copy_filter(package);
 827
 828     if (!new_set->search(package, search_package,
 829                          apdu_req, found_backend, &z_records))
 830     {
 831         bc->remove_backend(found_backend);
 832         return; // search error
 833     }
 834
 835     if (z_records)
 836     {
 837         int condition = 0;
 838         if (z_records->which == Z_Records_NSD)
 839         {
 840             condition =
 841                 get_diagnostic(z_records->u.nonSurrogateDiagnostic);
 842         }
 843         else if (z_records->which == Z_Records_multipleNSD)
 844         {
 845             if (z_records->u.multipleNonSurDiagnostics->num_diagRecs >= 1
 846                 &&
 847
 848                 z_records->u.multipleNonSurDiagnostics->diagRecs[0]->which ==
 849                 Z_DiagRec_defaultFormat)
 850             {
 851                 condition = get_diagnostic(
 852                     z_records->u.multipleNonSurDiagnostics->diagRecs[0]->u.defaultFormat);
 853
 854             }
 855         }
 856         if (m_p->m_restart && !session_restarted &&
 857             condition == YAZ_BIB1_TEMPORARY_SYSTEM_ERROR)
 858         {
 859             package.log("session_shared", YLOG_LOG, "restart");
 860             bc->remove_backend(found_backend);
 861             session_restarted = true;
 862             found_backend.reset();
 863             goto restart;
 864
 865         }
 866
 867         if (condition)
 868         {
 869             mp::odr odr;
 870             if (apdu_req->which == Z_APDU_searchRequest)
 871             {
 872                 Z_APDU *f_apdu = odr.create_searchResponse(apdu_req,
 873                                                            0, 0);
 874                 Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
 875                 *f_resp->searchStatus = Z_SearchResponse_none;
 876                 f_resp->records = z_records;
 877                 package.response() = f_apdu;
 878             }
 879             if (apdu_req->which == Z_APDU_presentRequest)
 880             {
 881                 Z_APDU *f_apdu = odr.create_presentResponse(apdu_req,
 882                                                             0, 0);
 883                 Z_PresentResponse *f_resp = f_apdu->u.presentResponse;
 884                 f_resp->records = z_records;
 885                 package.response() = f_apdu;
 886             }
 887             bc->release_backend(found_backend);
 888             return; // search error
 889         }
 890     }
 891     if (m_p->m_restart && !session_restarted && new_set->m_result_set_size < 0)
 892     {
 893         package.log("session_shared", YLOG_LOG, "restart");
 894         bc->remove_backend(found_backend);
 895         session_restarted = true;
 896         found_backend.reset();
 897         goto restart;
 898     }
 899
 900     found_set = new_set;
 901     found_set->timestamp();
 902     found_backend->m_sets.push_back(found_set);
 903 }
 904
 905 int yf::SessionShared::Frontend::result_set_ref(ODR o,
 906                                                 const Databases &databases,
 907                                                 Z_RPNStructure *s,
 908                                                 std::string &rset)
 909 {
 910     int ret = 0;
 911     switch (s->which)
 912     {
 913     case Z_RPNStructure_simple:
 914         if (s->u.simple->which == Z_Operand_resultSetId)
 915         {
 916             const char *id = s->u.simple->u.resultSetId;
 917             rset = id;
 918
 919             FrontendSets::iterator fset_it = m_frontend_sets.find(id);
 920             if (fset_it == m_frontend_sets.end())
 921             {
 922                 ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 923             }
 924             else if (fset_it->second->get_databases() != databases)
 925             {
 926                 ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 927             }
 928             else
 929             {
 930                 yazpp_1::Yaz_Z_Query query = fset_it->second->get_query();
 931                 Z_Query *q = yaz_copy_Z_Query(query.get_Z_Query(), o);
 932                 if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
 933                 {
 934                     s->which = q->u.type_1->RPNStructure->which;
 935                     s->u.simple = q->u.type_1->RPNStructure->u.simple;
 936                 }
 937                 else
 938                 {
 939                     ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 940                 }
 941             }
 942         }
 943         break;
 944     case Z_RPNStructure_complex:
 945         ret = result_set_ref(o, databases, s->u.complex->s1, rset);
 946         if (!ret)
 947             ret = result_set_ref(o, databases, s->u.complex->s2, rset);
 948         break;
 949     }
 950     return ret;
 951 }
 952
 953 void yf::SessionShared::Frontend::search(mp::Package &package,
 954                                          Z_APDU *apdu_req)
 955 {
 956     Z_SearchRequest *req = apdu_req->u.searchRequest;
 957     FrontendSets::iterator fset_it =
 958         m_frontend_sets.find(req->resultSetName);
 959     if (fset_it != m_frontend_sets.end())
 960     {
 961         // result set already exist
 962         // if replace indicator is off: we return diagnostic if
 963         // result set already exist.
 964         if (*req->replaceIndicator == 0)
 965         {
 966             mp::odr odr;
 967             Z_APDU *apdu =
 968                 odr.create_searchResponse(
 969                     apdu_req,
 970                     YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 971                     0);
 972             package.response() = apdu;
 973             return;
 974         }
 975         m_frontend_sets.erase(fset_it);
 976     }
 977
 978     Databases databases;
 979     int i;
 980     for (i = 0; i < req->num_databaseNames; i++)
 981         databases.push_back(req->databaseNames[i]);
 982
 983
 984     yazpp_1::Yaz_Z_Query query;
 985     query.set_Z_Query(req->query);
 986
 987     Z_Query *q = query.get_Z_Query();
 988     if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
 989     {
 990         mp::odr odr;
 991         std::string rset;
 992         int diag = result_set_ref(odr, databases, q->u.type_1->RPNStructure,
 993                                   rset);
 994         if (diag)
 995         {
 996             Z_APDU *apdu =
 997                 odr.create_searchResponse(
 998                     apdu_req,
 999                     diag,
1000                     rset.c_str());
1001             package.response() = apdu;
1002             return;
1003         }
1004         query.set_Z_Query(q);
1005     }
1006
1007     BackendSetPtr found_set; // null
1008     BackendInstancePtr found_backend; // null
1009
1010     get_set(package, apdu_req, databases, query, found_backend, found_set);
1011     if (!found_set)
1012         return;
1013
1014     mp::odr odr;
1015     Z_APDU *f_apdu = odr.create_searchResponse(apdu_req, 0, 0);
1016     Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
1017     *f_resp->resultCount = found_set->m_result_set_size;
1018     f_resp->additionalSearchInfo = found_set->additionalSearchInfoResponse;
1019     package.response() = f_apdu;
1020
1021     FrontendSetPtr fset(new FrontendSet(databases, query));
1022     m_frontend_sets[req->resultSetName] = fset;
1023
1024     m_backend_class->release_backend(found_backend);
1025 }
1026
1027 void yf::SessionShared::Frontend::present(mp::Package &package,
1028                                           Z_APDU *apdu_req)
1029 {
1030     mp::odr odr;
1031     Z_PresentRequest *req = apdu_req->u.presentRequest;
1032
1033     FrontendSets::iterator fset_it =
1034         m_frontend_sets.find(req->resultSetId);
1035
1036     if (fset_it == m_frontend_sets.end())
1037     {
1038         Z_APDU *apdu =
1039             odr.create_presentResponse(
1040                 apdu_req,
1041                 YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
1042                 req->resultSetId);
1043         package.response() = apdu;
1044         return;
1045     }
1046     FrontendSetPtr fset = fset_it->second;
1047
1048     Databases databases = fset->get_databases();
1049     yazpp_1::Yaz_Z_Query query = fset->get_query();
1050
1051     BackendClassPtr bc = m_backend_class;
1052     BackendSetPtr found_set; // null
1053     BackendInstancePtr found_backend;
1054
1055     get_set(package, apdu_req, databases, query, found_backend, found_set);
1056     if (!found_set)
1057         return;
1058
1059     Z_NamePlusRecordList *npr_res = 0;
1060     if (found_set->m_record_cache.lookup(odr, &npr_res,
1061                                          *req->resultSetStartPoint,
1062                                          *req->numberOfRecordsRequested,
1063                                          req->preferredRecordSyntax,
1064                                          req->recordComposition))
1065     {
1066         Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
1067         Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
1068
1069         yaz_log(YLOG_LOG, "Found " ODR_INT_PRINTF "+" ODR_INT_PRINTF
1070                 " records in cache %p",
1071                 *req->resultSetStartPoint,
1072                 *req->numberOfRecordsRequested,
1073                 &found_set->m_record_cache);
1074
1075         *f_resp->numberOfRecordsReturned = *req->numberOfRecordsRequested;
1076         *f_resp->nextResultSetPosition =
1077             *req->resultSetStartPoint + *req->numberOfRecordsRequested;
1078         // f_resp->presentStatus assumed OK.
1079         f_resp->records = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
1080         f_resp->records->which = Z_Records_DBOSD;
1081         f_resp->records->u.databaseOrSurDiagnostics = npr_res;
1082         package.response() = f_apdu_res;
1083         bc->release_backend(found_backend);
1084         return;
1085     }
1086
1087     found_backend->timestamp();
1088
1089     Z_APDU *p_apdu = zget_APDU(odr, Z_APDU_presentRequest);
1090     Z_PresentRequest *p_req = p_apdu->u.presentRequest;
1091     p_req->preferredRecordSyntax = req->preferredRecordSyntax;
1092     p_req->resultSetId = odr_strdup(odr, found_set->m_result_set_id.c_str());
1093     *p_req->resultSetStartPoint = *req->resultSetStartPoint;
1094     *p_req->numberOfRecordsRequested = *req->numberOfRecordsRequested;
1095     p_req->preferredRecordSyntax = req->preferredRecordSyntax;
1096     p_req->recordComposition = req->recordComposition;
1097
1098     Package present_package(found_backend->m_session, package.origin());
1099     present_package.copy_filter(package);
1100
1101     present_package.request() = p_apdu;
1102
1103     present_package.move();
1104
1105     Z_GDU *gdu = present_package.response().get();
1106     if (!present_package.session().is_closed()
1107         && gdu && gdu->which == Z_GDU_Z3950
1108         && gdu->u.z3950->which == Z_APDU_presentResponse)
1109     {
1110         Z_PresentResponse *b_resp = gdu->u.z3950->u.presentResponse;
1111         Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
1112         Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
1113
1114         f_resp->numberOfRecordsReturned = b_resp->numberOfRecordsReturned;
1115         f_resp->nextResultSetPosition = b_resp->nextResultSetPosition;
1116         f_resp->presentStatus= b_resp->presentStatus;
1117         f_resp->records = b_resp->records;
1118         f_resp->otherInfo = b_resp->otherInfo;
1119         package.response() = f_apdu_res;
1120
1121         if (b_resp->records && b_resp->records->which ==  Z_Records_DBOSD)
1122         {
1123 #if 0
1124             yaz_log(YLOG_LOG, "Adding " ODR_INT_PRINTF "+" ODR_INT_PRINTF
1125                     " records to cache %p",
1126                     *req->resultSetStartPoint,
1127                     *f_resp->numberOfRecordsReturned,
1128                     &found_set->m_record_cache);
1129 #endif
1130             found_set->m_record_cache.add(
1131                 odr,
1132                 b_resp->records->u.databaseOrSurDiagnostics,
1133                 *req->resultSetStartPoint,
1134                 *f_resp->numberOfRecordsReturned);
1135         }
1136         bc->release_backend(found_backend);
1137     }
1138     else
1139     {
1140         bc->remove_backend(found_backend);
1141         Z_APDU *f_apdu_res =
1142             odr.create_presentResponse(
1143                 apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
1144                 "session_shared: target closed connection during present");
1145         package.response() = f_apdu_res;
1146     }
1147 }
1148
1149 void yf::SessionShared::Frontend::scan(mp::Package &frontend_package,
1150                                        Z_APDU *apdu_req)
1151 {
1152     BackendClassPtr bc = m_backend_class;
1153     BackendInstancePtr backend = bc->get_backend(frontend_package);
1154     if (!backend)
1155     {
1156         mp::odr odr;
1157         Z_APDU *apdu = odr.create_scanResponse(
1158             apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
1159             "session_shared: could not create backend");
1160         frontend_package.response() = apdu;
1161     }
1162     else
1163     {
1164         Package scan_package(backend->m_session, frontend_package.origin());
1165         backend->timestamp();
1166         scan_package.copy_filter(frontend_package);
1167         scan_package.request() = apdu_req;
1168         scan_package.move();
1169         frontend_package.response() = scan_package.response();
1170         if (scan_package.session().is_closed())
1171         {
1172             frontend_package.session().close();
1173             bc->remove_backend(backend);
1174         }
1175         else
1176             bc->release_backend(backend);
1177     }
1178 }
1179
1180 yf::SessionShared::Worker::Worker(SessionShared::Rep *rep) : m_p(rep)
1181 {
1182 }
1183
1184 void yf::SessionShared::Worker::operator() (void)
1185 {
1186     m_p->expire();
1187 }
1188
1189 bool yf::SessionShared::BackendClass::expire_instances()
1190 {
1191     time_t now;
1192     time(&now);
1193     boost::mutex::scoped_lock lock(m_mutex_backend_class);
1194     BackendInstanceList::iterator bit = m_backend_list.begin();
1195     while (bit != m_backend_list.end())
1196     {
1197         time_t last_use = (*bit)->m_time_last_use;
1198
1199         if ((*bit)->m_in_use)
1200         {
1201             bit++;
1202         }
1203         else if (now < last_use || now - last_use > m_backend_expiry_ttl)
1204         {
1205             mp::odr odr;
1206             (*bit)->m_close_package->response() = odr.create_close(
1207                 0, Z_Close_lackOfActivity, 0);
1208             (*bit)->m_close_package->session().close();
1209             (*bit)->m_close_package->move();
1210
1211             bit = m_backend_list.erase(bit);
1212         }
1213         else
1214         {
1215             bit++;
1216         }
1217     }
1218     if (m_backend_list.empty())
1219         return true;
1220     return false;
1221 }
1222
1223 void yf::SessionShared::Rep::expire_classes()
1224 {
1225     boost::mutex::scoped_lock lock(m_mutex_backend_map);
1226     BackendClassMap::iterator b_it = m_backend_map.begin();
1227     while (b_it != m_backend_map.end())
1228     {
1229         if (b_it->second->expire_instances())
1230         {
1231             m_backend_map.erase(b_it);
1232             b_it = m_backend_map.begin();
1233         }
1234         else
1235             b_it++;
1236     }
1237 }
1238
1239 void yf::SessionShared::Rep::expire()
1240 {
1241     while (true)
1242     {
1243         boost::xtime xt;
1244         boost::xtime_get(&xt,
1245 #if BOOST_VERSION >= 105000
1246                 boost::TIME_UTC_
1247 #else
1248                 boost::TIME_UTC
1249 #endif
1250                   );
1251         xt.sec += m_session_ttl / 3;
1252         boost::thread::sleep(xt);
1253
1254         stat();
1255         expire_classes();
1256     }
1257 }
1258
1259 yf::SessionShared::Rep::Rep()
1260 {
1261     m_resultset_ttl = 30;
1262     m_resultset_max = 10;
1263     m_session_ttl = 90;
1264     m_optimize_search = true;
1265     m_restart = false;
1266     m_session_max = 100;
1267     m_preferredMessageSize = 0;
1268     m_maximumRecordSize = 0;
1269 }
1270
1271 void yf::SessionShared::Rep::start()
1272 {
1273     yf::SessionShared::Worker w(this);
1274     m_thrds.add_thread(new boost::thread(w));
1275 }
1276
1277 yf::SessionShared::SessionShared() : m_p(new SessionShared::Rep)
1278 {
1279 }
1280
1281 yf::SessionShared::~SessionShared() {
1282 }
1283
1284 void yf::SessionShared::start() const
1285 {
1286     m_p->start();
1287 }
1288
1289 yf::SessionShared::Frontend::Frontend(Rep *rep) : m_is_virtual(false), m_p(rep)
1290 {
1291 }
1292
1293 yf::SessionShared::Frontend::~Frontend()
1294 {
1295 }
1296
1297 yf::SessionShared::FrontendPtr yf::SessionShared::Rep::get_frontend(mp::Package &package)
1298 {
1299     boost::mutex::scoped_lock lock(m_mutex);
1300
1301     std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
1302
1303     while(true)
1304     {
1305         it = m_clients.find(package.session());
1306         if (it == m_clients.end())
1307             break;
1308
1309         if (!it->second->m_in_use)
1310         {
1311             it->second->m_in_use = true;
1312             return it->second;
1313         }
1314         m_cond_session_ready.wait(lock);
1315     }
1316     FrontendPtr f(new Frontend(this));
1317     m_clients[package.session()] = f;
1318     f->m_in_use = true;
1319     return f;
1320 }
1321
1322 void yf::SessionShared::Rep::release_frontend(mp::Package &package)
1323 {
1324     boost::mutex::scoped_lock lock(m_mutex);
1325     std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
1326
1327     it = m_clients.find(package.session());
1328     if (it != m_clients.end())
1329     {
1330         if (package.session().is_closed())
1331         {
1332             m_clients.erase(it);
1333         }
1334         else
1335         {
1336             it->second->m_in_use = false;
1337         }
1338         m_cond_session_ready.notify_all();
1339     }
1340 }
1341
1342
1343 void yf::SessionShared::process(mp::Package &package) const
1344 {
1345     FrontendPtr f = m_p->get_frontend(package);
1346
1347     Z_GDU *gdu = package.request().get();
1348
1349     if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
1350         Z_APDU_initRequest && !f->m_is_virtual)
1351     {
1352         m_p->init(package, gdu, f);
1353     }
1354     else if (!f->m_is_virtual)
1355         package.move();
1356     else if (gdu && gdu->which == Z_GDU_Z3950)
1357     {
1358         Z_APDU *apdu = gdu->u.z3950;
1359         if (apdu->which == Z_APDU_initRequest)
1360         {
1361             mp::odr odr;
1362
1363             package.response() = odr.create_close(
1364                 apdu,
1365                 Z_Close_protocolError,
1366                 "double init");
1367
1368             package.session().close();
1369         }
1370         else if (apdu->which == Z_APDU_close)
1371         {
1372             mp::odr odr;
1373
1374             package.response() = odr.create_close(
1375                 apdu,
1376                 Z_Close_peerAbort, "received close from client");
1377             package.session().close();
1378         }
1379         else if (apdu->which == Z_APDU_searchRequest)
1380         {
1381             f->search(package, apdu);
1382         }
1383         else if (apdu->which == Z_APDU_presentRequest)
1384         {
1385             f->present(package, apdu);
1386         }
1387         else if (apdu->which == Z_APDU_scanRequest)
1388         {
1389             f->scan(package, apdu);
1390         }
1391         else
1392         {
1393             mp::odr odr;
1394
1395             package.response() = odr.create_close(
1396                 apdu, Z_Close_protocolError,
1397                 "unsupported APDU in filter_session_shared");
1398
1399             package.session().close();
1400         }
1401     }
1402     m_p->release_frontend(package);
1403 }
1404
1405 void yf::SessionShared::configure(const xmlNode *ptr, bool test_only,
1406                                   const char *path)
1407 {
1408     for (ptr = ptr->children; ptr; ptr = ptr->next)
1409     {
1410         if (ptr->type != XML_ELEMENT_NODE)
1411             continue;
1412         if (!strcmp((const char *) ptr->name, "resultset"))
1413         {
1414             const struct _xmlAttr *attr;
1415             for (attr = ptr->properties; attr; attr = attr->next)
1416             {
1417                 if (!strcmp((const char *) attr->name, "ttl"))
1418                     m_p->m_resultset_ttl =
1419                         mp::xml::get_int(attr->children, 30);
1420                 else if (!strcmp((const char *) attr->name, "max"))
1421                 {
1422                     m_p->m_resultset_max =
1423                         mp::xml::get_int(attr->children, 10);
1424                 }
1425                 else if (!strcmp((const char *) attr->name, "optimizesearch"))
1426                 {
1427                     m_p->m_optimize_search =
1428                         mp::xml::get_bool(attr->children, true);
1429                 }
1430                 else if (!strcmp((const char *) attr->name, "restart"))
1431                 {
1432                     m_p->m_restart = mp::xml::get_bool(attr->children, true);
1433                 }
1434                 else
1435                     throw mp::filter::FilterException(
1436                         "Bad attribute " + std::string((const char *)
1437                                                        attr->name));
1438             }
1439         }
1440         else if (!strcmp((const char *) ptr->name, "session"))
1441         {
1442             const struct _xmlAttr *attr;
1443             for (attr = ptr->properties; attr; attr = attr->next)
1444             {
1445                 if (!strcmp((const char *) attr->name, "ttl"))
1446                     m_p->m_session_ttl =
1447                         mp::xml::get_int(attr->children, 90);
1448                 else if (!strcmp((const char *) attr->name, "max"))
1449                     m_p->m_session_max =
1450                         mp::xml::get_int(attr->children, 100);
1451                 else
1452                     throw mp::filter::FilterException(
1453                         "Bad attribute " + std::string((const char *)
1454                                                        attr->name));
1455             }
1456         }
1457         else if (!strcmp((const char *) ptr->name, "init"))
1458         {
1459             const struct _xmlAttr *attr;
1460             for (attr = ptr->properties; attr; attr = attr->next)
1461             {
1462                 if (!strcmp((const char *) attr->name, "maximum-record-size"))
1463                     m_p->m_maximumRecordSize =
1464                         mp::xml::get_int(attr->children, 0);
1465                 else if (!strcmp((const char *) attr->name,
1466                                  "preferred-message-size"))
1467                     m_p->m_preferredMessageSize =
1468                         mp::xml::get_int(attr->children, 0);
1469                 else
1470                     throw mp::filter::FilterException(
1471                         "Bad attribute " + std::string((const char *)
1472                                                        attr->name));
1473             }
1474         }
1475         else
1476         {
1477             throw mp::filter::FilterException("Bad element "
1478                                                + std::string((const char *)
1479                                                              ptr->name));
1480         }
1481     }
1482 }
1483
1484 static mp::filter::Base* filter_creator()
1485 {
1486     return new mp::filter::SessionShared;
1487 }
1488
1489 extern "C" {
1490     struct metaproxy_1_filter_struct metaproxy_1_filter_session_shared = {
1491         0,
1492         "session_shared",
1493         filter_creator
1494     };
1495 }
1496
1497 /*
1498  * Local variables:
1499  * c-basic-offset: 4
1500  * c-file-style: "Stroustrup"
1501  * indent-tabs-mode: nil
1502  * End:
1503  * vim: shiftwidth=4 tabstop=8 expandtab
1504  */
1505