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 }
 486
 487 void yf::SessionShared::Rep::init(mp::Package &package, const Z_GDU *gdu,
 488                                   FrontendPtr frontend)
 489 {
 490     Z_InitRequest *req = gdu->u.z3950->u.initRequest;
 491
 492     frontend->m_is_virtual = true;
 493     frontend->m_init_options = *req->options;
 494     InitKey k(req);
 495     {
 496         boost::mutex::scoped_lock lock(m_mutex_backend_map);
 497         BackendClassMap::const_iterator it;
 498         it = m_backend_map.find(k);
 499         if (it == m_backend_map.end())
 500         {
 501             BackendClassPtr b(new BackendClass(gdu->u.z3950,
 502                                                m_resultset_ttl,
 503                                                m_resultset_max,
 504                                                m_session_ttl,
 505                                                m_preferredMessageSize,
 506                                                m_maximumRecordSize));
 507             m_backend_map[k] = b;
 508             frontend->m_backend_class = b;
 509         }
 510         else
 511         {
 512             frontend->m_backend_class = it->second;
 513         }
 514     }
 515     BackendClassPtr bc = frontend->m_backend_class;
 516     mp::odr odr;
 517
 518     // we only need to get init response from "first" target in
 519     // backend class - the assumption being that init response is
 520     // same for all
 521     if (bc->m_backend_list.size() == 0)
 522     {
 523         BackendInstancePtr backend = bc->create_backend(package);
 524         if (backend)
 525             bc->release_backend(backend);
 526     }
 527
 528     yazpp_1::GDU init_response;
 529     {
 530         boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 531
 532         init_response = bc->m_init_response;
 533     }
 534
 535     if (init_response.get())
 536     {
 537         Z_GDU *response_gdu = init_response.get();
 538         mp::util::transfer_referenceId(odr, gdu->u.z3950,
 539                                        response_gdu->u.z3950);
 540         Z_InitResponse *init_res = response_gdu->u.z3950->u.initResponse;
 541         Z_Options *server_options = init_res->options;
 542         Z_Options *client_options = &frontend->m_init_options;
 543         int i;
 544         for (i = 0; i < 30; i++)
 545             if (!ODR_MASK_GET(client_options, i))
 546                 ODR_MASK_CLEAR(server_options, i);
 547
 548         if (!m_preferredMessageSize ||
 549             *init_res->preferredMessageSize > *req->preferredMessageSize)
 550             *init_res->preferredMessageSize = *req->preferredMessageSize;
 551
 552         if (!m_maximumRecordSize ||
 553             *init_res->maximumRecordSize > *req->maximumRecordSize)
 554             *init_res->maximumRecordSize = *req->maximumRecordSize;
 555
 556         package.response() = init_response;
 557         if (!*response_gdu->u.z3950->u.initResponse->result)
 558             package.session().close();
 559     }
 560     else
 561     {
 562         Z_APDU *apdu =
 563             odr.create_initResponse(
 564                 gdu->u.z3950, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
 565                 "session_shared: target closed connection during init");
 566         *apdu->u.initResponse->result = 0;
 567         package.response() = apdu;
 568         package.session().close();
 569     }
 570 }
 571
 572 void yf::SessionShared::BackendSet::timestamp()
 573 {
 574     time(&m_time_last_use);
 575 }
 576
 577 yf::SessionShared::BackendSet::BackendSet(
 578     const std::string &result_set_id,
 579     const Databases &databases,
 580     const yazpp_1::Yaz_Z_Query &query,
 581     Z_OtherInformation *additionalSearchInfo) :
 582     m_result_set_id(result_set_id),
 583     m_databases(databases), m_result_set_size(0), m_query(query)
 584 {
 585     timestamp();
 586     mem_additionalSearchInfo = nmem_create();
 587     additionalSearchInfoResponse = 0;
 588     additionalSearchInfoRequest =
 589         yaz_clone_z_OtherInformation(additionalSearchInfo,
 590                                      mem_additionalSearchInfo);
 591 }
 592
 593 yf::SessionShared::BackendSet::~BackendSet()
 594 {
 595     nmem_destroy(mem_additionalSearchInfo);
 596 }
 597
 598 static int get_diagnostic(Z_DefaultDiagFormat *r)
 599 {
 600     return *r->condition;
 601 }
 602
 603 bool yf::SessionShared::BackendSet::search(
 604     mp::Package &frontend_package,
 605     mp::Package &search_package,
 606     const Z_APDU *frontend_apdu,
 607     const BackendInstancePtr bp,
 608     Z_Records **z_records)
 609 {
 610     mp::odr odr;
 611     Z_APDU *apdu_req = zget_APDU(odr, Z_APDU_searchRequest);
 612     Z_SearchRequest *req = apdu_req->u.searchRequest;
 613
 614     req->additionalSearchInfo = additionalSearchInfoRequest;
 615     req->resultSetName = odr_strdup(odr, m_result_set_id.c_str());
 616     req->query = m_query.get_Z_Query();
 617
 618     req->num_databaseNames = m_databases.size();
 619     req->databaseNames = (char**)
 620         odr_malloc(odr, req->num_databaseNames * sizeof(char *));
 621     Databases::const_iterator it = m_databases.begin();
 622     size_t i = 0;
 623     for (; it != m_databases.end(); it++)
 624         req->databaseNames[i++] = odr_strdup(odr, it->c_str());
 625
 626     if (frontend_apdu->which == Z_APDU_searchRequest)
 627         req->preferredRecordSyntax =
 628             frontend_apdu->u.searchRequest->preferredRecordSyntax;
 629
 630     search_package.request() = apdu_req;
 631
 632     search_package.move();
 633
 634     Z_GDU *gdu = search_package.response().get();
 635     if (!search_package.session().is_closed()
 636         && gdu && gdu->which == Z_GDU_Z3950
 637         && gdu->u.z3950->which == Z_APDU_searchResponse)
 638     {
 639         Z_SearchResponse *b_resp = gdu->u.z3950->u.searchResponse;
 640         *z_records = b_resp->records;
 641         m_result_set_size = *b_resp->resultCount;
 642
 643         additionalSearchInfoResponse = yaz_clone_z_OtherInformation(
 644             b_resp->additionalSearchInfo, mem_additionalSearchInfo);
 645         return true;
 646     }
 647     Z_APDU *f_apdu = 0;
 648     const char *addinfo = "session_shared: "
 649         "target closed connection during search";
 650     if (frontend_apdu->which == Z_APDU_searchRequest)
 651         f_apdu = odr.create_searchResponse(
 652             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 653     else if (frontend_apdu->which == Z_APDU_presentRequest)
 654         f_apdu = odr.create_presentResponse(
 655             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 656     else
 657         f_apdu = odr.create_close(
 658             frontend_apdu, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 659     frontend_package.response() = f_apdu;
 660     return false;
 661 }
 662
 663 void yf::SessionShared::Frontend::override_set(
 664     BackendInstancePtr &found_backend,
 665     std::string &result_set_id,
 666     const Databases &databases,
 667     bool out_of_sessions)
 668 {
 669     BackendClassPtr bc = m_backend_class;
 670     BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
 671     time_t now;
 672     time(&now);
 673
 674     size_t max_sets = bc->m_named_result_sets ? bc->m_backend_set_max : 1;
 675     for (; it != bc->m_backend_list.end(); it++)
 676     {
 677         if (!(*it)->m_in_use)
 678         {
 679             BackendSetList::iterator set_it = (*it)->m_sets.begin();
 680             for (; set_it != (*it)->m_sets.end(); set_it++)
 681             {
 682                 if ((max_sets > 1 || (*set_it)->m_databases == databases)
 683                     &&
 684                     (out_of_sessions ||
 685                      now < (*set_it)->m_time_last_use ||
 686                      now - (*set_it)->m_time_last_use >= bc->m_backend_set_ttl))
 687                 {
 688                     found_backend = *it;
 689                     result_set_id = (*set_it)->m_result_set_id;
 690                     found_backend->m_sets.erase(set_it);
 691                     return;
 692                 }
 693             }
 694         }
 695     }
 696     for (it = bc->m_backend_list.begin(); it != bc->m_backend_list.end(); it++)
 697     {
 698         if (!(*it)->m_in_use && (*it)->m_sets.size() < max_sets)
 699         {
 700             found_backend = *it;
 701             if (bc->m_named_result_sets)
 702             {
 703                 result_set_id = boost::io::str(
 704                     boost::format("%1%") %
 705                     found_backend->m_result_set_sequence);
 706                 found_backend->m_result_set_sequence++;
 707             }
 708             else
 709                 result_set_id = "default";
 710             return;
 711         }
 712     }
 713 }
 714
 715 void yf::SessionShared::Frontend::get_set(mp::Package &package,
 716                                           const Z_APDU *apdu_req,
 717                                           const Databases &databases,
 718                                           yazpp_1::Yaz_Z_Query &query,
 719                                           BackendInstancePtr &found_backend,
 720                                           BackendSetPtr &found_set)
 721 {
 722     bool session_restarted = false;
 723     Z_OtherInformation *additionalSearchInfo = 0;
 724
 725     if (apdu_req->which == Z_APDU_searchRequest)
 726         additionalSearchInfo = apdu_req->u.searchRequest->additionalSearchInfo;
 727
 728 restart:
 729     std::string result_set_id;
 730     bool out_of_sessions = false;
 731     BackendClassPtr bc = m_backend_class;
 732     {
 733         boost::mutex::scoped_lock lock(bc->m_mutex_backend_class);
 734
 735         if ((int) bc->m_backend_list.size() >= m_p->m_session_max)
 736             out_of_sessions = true;
 737
 738         if (m_p->m_optimize_search)
 739         {
 740             // look at each backend and see if we have a similar search
 741             BackendInstanceList::const_iterator it = bc->m_backend_list.begin();
 742             for (; it != bc->m_backend_list.end(); it++)
 743             {
 744                 if (!(*it)->m_in_use)
 745                 {
 746                     BackendSetList::const_iterator set_it = (*it)->m_sets.begin();
 747                     for (; set_it != (*it)->m_sets.end(); set_it++)
 748                     {
 749                         // for real present request we don't care
 750                         // if additionalSearchInfo matches: same records
 751                         if ((*set_it)->m_databases == databases
 752                             && query.match(&(*set_it)->m_query)
 753                             && (apdu_req->which != Z_APDU_searchRequest ||
 754                                 yaz_compare_z_OtherInformation(
 755                                     additionalSearchInfo,
 756                                 (*set_it)->additionalSearchInfoRequest)))
 757                         {
 758                             found_set = *set_it;
 759                             found_backend = *it;
 760                             bc->use_backend(found_backend);
 761                             // found matching set. No need to search again
 762                             return;
 763                         }
 764                     }
 765                 }
 766             }
 767         }
 768         override_set(found_backend, result_set_id, databases, out_of_sessions);
 769         if (found_backend)
 770             bc->use_backend(found_backend);
 771     }
 772     if (!found_backend)
 773     {
 774         // create a new backend set (and new set) if we're not out of sessions
 775         if (!out_of_sessions)
 776             found_backend = bc->create_backend(package);
 777
 778         if (!found_backend)
 779         {
 780             Z_APDU *f_apdu = 0;
 781             mp::odr odr;
 782             const char *addinfo = 0;
 783
 784             if (out_of_sessions)
 785                 addinfo = "session_shared: all sessions in use";
 786             else
 787                 addinfo = "session_shared: could not create backend";
 788             if (apdu_req->which == Z_APDU_searchRequest)
 789             {
 790                 f_apdu = odr.create_searchResponse(
 791                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 792             }
 793             else if (apdu_req->which == Z_APDU_presentRequest)
 794             {
 795                 f_apdu = odr.create_presentResponse(
 796                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 797             }
 798             else
 799             {
 800                 f_apdu = odr.create_close(
 801                     apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR, addinfo);
 802             }
 803             package.response() = f_apdu;
 804             return;
 805         }
 806         if (bc->m_named_result_sets)
 807         {
 808             result_set_id = boost::io::str(
 809                 boost::format("%1%") % found_backend->m_result_set_sequence);
 810             found_backend->m_result_set_sequence++;
 811         }
 812         else
 813             result_set_id = "default";
 814     }
 815     found_backend->timestamp();
 816
 817     // we must search ...
 818     BackendSetPtr new_set(new BackendSet(result_set_id,
 819                                          databases, query,
 820                                          additionalSearchInfo));
 821     Z_Records *z_records = 0;
 822
 823     Package search_package(found_backend->m_session, package.origin());
 824     search_package.copy_filter(package);
 825
 826     if (!new_set->search(package, search_package,
 827                          apdu_req, found_backend, &z_records))
 828     {
 829         bc->remove_backend(found_backend);
 830         return; // search error
 831     }
 832
 833     if (z_records)
 834     {
 835         int condition = 0;
 836         if (z_records->which == Z_Records_NSD)
 837         {
 838             condition =
 839                 get_diagnostic(z_records->u.nonSurrogateDiagnostic);
 840         }
 841         else if (z_records->which == Z_Records_multipleNSD)
 842         {
 843             if (z_records->u.multipleNonSurDiagnostics->num_diagRecs >= 1
 844                 &&
 845
 846                 z_records->u.multipleNonSurDiagnostics->diagRecs[0]->which ==
 847                 Z_DiagRec_defaultFormat)
 848             {
 849                 condition = get_diagnostic(
 850                     z_records->u.multipleNonSurDiagnostics->diagRecs[0]->u.defaultFormat);
 851
 852             }
 853         }
 854         if (m_p->m_restart && !session_restarted &&
 855             condition == YAZ_BIB1_TEMPORARY_SYSTEM_ERROR)
 856         {
 857             package.log("session_shared", YLOG_LOG, "restart");
 858             bc->remove_backend(found_backend);
 859             session_restarted = true;
 860             found_backend.reset();
 861             goto restart;
 862
 863         }
 864
 865         if (condition)
 866         {
 867             mp::odr odr;
 868             if (apdu_req->which == Z_APDU_searchRequest)
 869             {
 870                 Z_APDU *f_apdu = odr.create_searchResponse(apdu_req,
 871                                                            0, 0);
 872                 Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
 873                 *f_resp->searchStatus = Z_SearchResponse_none;
 874                 f_resp->records = z_records;
 875                 package.response() = f_apdu;
 876             }
 877             if (apdu_req->which == Z_APDU_presentRequest)
 878             {
 879                 Z_APDU *f_apdu = odr.create_presentResponse(apdu_req,
 880                                                             0, 0);
 881                 Z_PresentResponse *f_resp = f_apdu->u.presentResponse;
 882                 f_resp->records = z_records;
 883                 package.response() = f_apdu;
 884             }
 885             bc->release_backend(found_backend);
 886             return; // search error
 887         }
 888     }
 889     if (m_p->m_restart && !session_restarted && new_set->m_result_set_size < 0)
 890     {
 891         package.log("session_shared", YLOG_LOG, "restart");
 892         bc->remove_backend(found_backend);
 893         session_restarted = true;
 894         found_backend.reset();
 895         goto restart;
 896     }
 897
 898     found_set = new_set;
 899     found_set->timestamp();
 900     found_backend->m_sets.push_back(found_set);
 901 }
 902
 903 int yf::SessionShared::Frontend::result_set_ref(ODR o,
 904                                                 const Databases &databases,
 905                                                 Z_RPNStructure *s,
 906                                                 std::string &rset)
 907 {
 908     int ret = 0;
 909     switch (s->which)
 910     {
 911     case Z_RPNStructure_simple:
 912         if (s->u.simple->which == Z_Operand_resultSetId)
 913         {
 914             const char *id = s->u.simple->u.resultSetId;
 915             rset = id;
 916
 917             FrontendSets::iterator fset_it = m_frontend_sets.find(id);
 918             if (fset_it == m_frontend_sets.end())
 919             {
 920                 ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 921             }
 922             else if (fset_it->second->get_databases() != databases)
 923             {
 924                 ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 925             }
 926             else
 927             {
 928                 yazpp_1::Yaz_Z_Query query = fset_it->second->get_query();
 929                 Z_Query *q = yaz_copy_Z_Query(query.get_Z_Query(), o);
 930                 if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
 931                 {
 932                     s->which = q->u.type_1->RPNStructure->which;
 933                     s->u.simple = q->u.type_1->RPNStructure->u.simple;
 934                 }
 935                 else
 936                 {
 937                     ret = YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST;
 938                 }
 939             }
 940         }
 941         break;
 942     case Z_RPNStructure_complex:
 943         ret = result_set_ref(o, databases, s->u.complex->s1, rset);
 944         if (!ret)
 945             ret = result_set_ref(o, databases, s->u.complex->s2, rset);
 946         break;
 947     }
 948     return ret;
 949 }
 950
 951 void yf::SessionShared::Frontend::search(mp::Package &package,
 952                                          Z_APDU *apdu_req)
 953 {
 954     Z_SearchRequest *req = apdu_req->u.searchRequest;
 955     FrontendSets::iterator fset_it =
 956         m_frontend_sets.find(req->resultSetName);
 957     if (fset_it != m_frontend_sets.end())
 958     {
 959         // result set already exist
 960         // if replace indicator is off: we return diagnostic if
 961         // result set already exist.
 962         if (*req->replaceIndicator == 0)
 963         {
 964             mp::odr odr;
 965             Z_APDU *apdu =
 966                 odr.create_searchResponse(
 967                     apdu_req,
 968                     YAZ_BIB1_RESULT_SET_EXISTS_AND_REPLACE_INDICATOR_OFF,
 969                     0);
 970             package.response() = apdu;
 971             return;
 972         }
 973         m_frontend_sets.erase(fset_it);
 974     }
 975
 976     Databases databases;
 977     int i;
 978     for (i = 0; i < req->num_databaseNames; i++)
 979         databases.push_back(req->databaseNames[i]);
 980
 981
 982     yazpp_1::Yaz_Z_Query query;
 983     query.set_Z_Query(req->query);
 984
 985     Z_Query *q = query.get_Z_Query();
 986     if (q->which == Z_Query_type_1 || q->which == Z_Query_type_101)
 987     {
 988         mp::odr odr;
 989         std::string rset;
 990         int diag = result_set_ref(odr, databases, q->u.type_1->RPNStructure,
 991                                   rset);
 992         if (diag)
 993         {
 994             Z_APDU *apdu =
 995                 odr.create_searchResponse(
 996                     apdu_req,
 997                     diag,
 998                     rset.c_str());
 999             package.response() = apdu;
1000             return;
1001         }
1002         query.set_Z_Query(q);
1003     }
1004
1005     BackendSetPtr found_set; // null
1006     BackendInstancePtr found_backend; // null
1007
1008     get_set(package, apdu_req, databases, query, found_backend, found_set);
1009     if (!found_set)
1010         return;
1011
1012     mp::odr odr;
1013     Z_APDU *f_apdu = odr.create_searchResponse(apdu_req, 0, 0);
1014     Z_SearchResponse *f_resp = f_apdu->u.searchResponse;
1015     *f_resp->resultCount = found_set->m_result_set_size;
1016     f_resp->additionalSearchInfo = found_set->additionalSearchInfoResponse;
1017     package.response() = f_apdu;
1018
1019     FrontendSetPtr fset(new FrontendSet(databases, query));
1020     m_frontend_sets[req->resultSetName] = fset;
1021
1022     m_backend_class->release_backend(found_backend);
1023 }
1024
1025 void yf::SessionShared::Frontend::present(mp::Package &package,
1026                                           Z_APDU *apdu_req)
1027 {
1028     mp::odr odr;
1029     Z_PresentRequest *req = apdu_req->u.presentRequest;
1030
1031     FrontendSets::iterator fset_it =
1032         m_frontend_sets.find(req->resultSetId);
1033
1034     if (fset_it == m_frontend_sets.end())
1035     {
1036         Z_APDU *apdu =
1037             odr.create_presentResponse(
1038                 apdu_req,
1039                 YAZ_BIB1_SPECIFIED_RESULT_SET_DOES_NOT_EXIST,
1040                 req->resultSetId);
1041         package.response() = apdu;
1042         return;
1043     }
1044     FrontendSetPtr fset = fset_it->second;
1045
1046     Databases databases = fset->get_databases();
1047     yazpp_1::Yaz_Z_Query query = fset->get_query();
1048
1049     BackendClassPtr bc = m_backend_class;
1050     BackendSetPtr found_set; // null
1051     BackendInstancePtr found_backend;
1052
1053     get_set(package, apdu_req, databases, query, found_backend, found_set);
1054     if (!found_set)
1055         return;
1056
1057     Z_NamePlusRecordList *npr_res = 0;
1058     if (found_set->m_record_cache.lookup(odr, &npr_res,
1059                                          *req->resultSetStartPoint,
1060                                          *req->numberOfRecordsRequested,
1061                                          req->preferredRecordSyntax,
1062                                          req->recordComposition))
1063     {
1064         Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
1065         Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
1066
1067         yaz_log(YLOG_LOG, "Found " ODR_INT_PRINTF "+" ODR_INT_PRINTF
1068                 " records in cache %p",
1069                 *req->resultSetStartPoint,
1070                 *req->numberOfRecordsRequested,
1071                 &found_set->m_record_cache);
1072
1073         *f_resp->numberOfRecordsReturned = *req->numberOfRecordsRequested;
1074         *f_resp->nextResultSetPosition =
1075             *req->resultSetStartPoint + *req->numberOfRecordsRequested;
1076         // f_resp->presentStatus assumed OK.
1077         f_resp->records = (Z_Records *) odr_malloc(odr, sizeof(Z_Records));
1078         f_resp->records->which = Z_Records_DBOSD;
1079         f_resp->records->u.databaseOrSurDiagnostics = npr_res;
1080         package.response() = f_apdu_res;
1081         bc->release_backend(found_backend);
1082         return;
1083     }
1084
1085     found_backend->timestamp();
1086
1087     Z_APDU *p_apdu = zget_APDU(odr, Z_APDU_presentRequest);
1088     Z_PresentRequest *p_req = p_apdu->u.presentRequest;
1089     p_req->preferredRecordSyntax = req->preferredRecordSyntax;
1090     p_req->resultSetId = odr_strdup(odr, found_set->m_result_set_id.c_str());
1091     *p_req->resultSetStartPoint = *req->resultSetStartPoint;
1092     *p_req->numberOfRecordsRequested = *req->numberOfRecordsRequested;
1093     p_req->preferredRecordSyntax = req->preferredRecordSyntax;
1094     p_req->recordComposition = req->recordComposition;
1095
1096     Package present_package(found_backend->m_session, package.origin());
1097     present_package.copy_filter(package);
1098
1099     present_package.request() = p_apdu;
1100
1101     present_package.move();
1102
1103     Z_GDU *gdu = present_package.response().get();
1104     if (!present_package.session().is_closed()
1105         && gdu && gdu->which == Z_GDU_Z3950
1106         && gdu->u.z3950->which == Z_APDU_presentResponse)
1107     {
1108         Z_PresentResponse *b_resp = gdu->u.z3950->u.presentResponse;
1109         Z_APDU *f_apdu_res = odr.create_presentResponse(apdu_req, 0, 0);
1110         Z_PresentResponse *f_resp = f_apdu_res->u.presentResponse;
1111
1112         f_resp->numberOfRecordsReturned = b_resp->numberOfRecordsReturned;
1113         f_resp->nextResultSetPosition = b_resp->nextResultSetPosition;
1114         f_resp->presentStatus= b_resp->presentStatus;
1115         f_resp->records = b_resp->records;
1116         f_resp->otherInfo = b_resp->otherInfo;
1117         package.response() = f_apdu_res;
1118
1119         if (b_resp->records && b_resp->records->which ==  Z_Records_DBOSD)
1120         {
1121 #if 0
1122             yaz_log(YLOG_LOG, "Adding " ODR_INT_PRINTF "+" ODR_INT_PRINTF
1123                     " records to cache %p",
1124                     *req->resultSetStartPoint,
1125                     *f_resp->numberOfRecordsReturned,
1126                     &found_set->m_record_cache);
1127 #endif
1128             found_set->m_record_cache.add(
1129                 odr,
1130                 b_resp->records->u.databaseOrSurDiagnostics,
1131                 *req->resultSetStartPoint,
1132                 *f_resp->numberOfRecordsReturned);
1133         }
1134         bc->release_backend(found_backend);
1135     }
1136     else
1137     {
1138         bc->remove_backend(found_backend);
1139         Z_APDU *f_apdu_res =
1140             odr.create_presentResponse(
1141                 apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
1142                 "session_shared: target closed connection during present");
1143         package.response() = f_apdu_res;
1144     }
1145 }
1146
1147 void yf::SessionShared::Frontend::scan(mp::Package &frontend_package,
1148                                        Z_APDU *apdu_req)
1149 {
1150     BackendClassPtr bc = m_backend_class;
1151     BackendInstancePtr backend = bc->get_backend(frontend_package);
1152     if (!backend)
1153     {
1154         mp::odr odr;
1155         Z_APDU *apdu = odr.create_scanResponse(
1156             apdu_req, YAZ_BIB1_TEMPORARY_SYSTEM_ERROR,
1157             "session_shared: could not create backend");
1158         frontend_package.response() = apdu;
1159     }
1160     else
1161     {
1162         Package scan_package(backend->m_session, frontend_package.origin());
1163         backend->timestamp();
1164         scan_package.copy_filter(frontend_package);
1165         scan_package.request() = apdu_req;
1166         scan_package.move();
1167         frontend_package.response() = scan_package.response();
1168         if (scan_package.session().is_closed())
1169         {
1170             frontend_package.session().close();
1171             bc->remove_backend(backend);
1172         }
1173         else
1174             bc->release_backend(backend);
1175     }
1176 }
1177
1178 yf::SessionShared::Worker::Worker(SessionShared::Rep *rep) : m_p(rep)
1179 {
1180 }
1181
1182 void yf::SessionShared::Worker::operator() (void)
1183 {
1184     m_p->expire();
1185 }
1186
1187 bool yf::SessionShared::BackendClass::expire_instances()
1188 {
1189     time_t now;
1190     time(&now);
1191     boost::mutex::scoped_lock lock(m_mutex_backend_class);
1192     BackendInstanceList::iterator bit = m_backend_list.begin();
1193     while (bit != m_backend_list.end())
1194     {
1195         time_t last_use = (*bit)->m_time_last_use;
1196
1197         if ((*bit)->m_in_use)
1198         {
1199             bit++;
1200         }
1201         else if (now < last_use || now - last_use > m_backend_expiry_ttl)
1202         {
1203             mp::odr odr;
1204             (*bit)->m_close_package->response() = odr.create_close(
1205                 0, Z_Close_lackOfActivity, 0);
1206             (*bit)->m_close_package->session().close();
1207             (*bit)->m_close_package->move();
1208
1209             bit = m_backend_list.erase(bit);
1210         }
1211         else
1212         {
1213             bit++;
1214         }
1215     }
1216     if (m_backend_list.empty())
1217         return true;
1218     return false;
1219 }
1220
1221 void yf::SessionShared::Rep::expire_classes()
1222 {
1223     boost::mutex::scoped_lock lock(m_mutex_backend_map);
1224     BackendClassMap::iterator b_it = m_backend_map.begin();
1225     while (b_it != m_backend_map.end())
1226     {
1227         if (b_it->second->expire_instances())
1228         {
1229             m_backend_map.erase(b_it);
1230             b_it = m_backend_map.begin();
1231         }
1232         else
1233             b_it++;
1234     }
1235 }
1236
1237 void yf::SessionShared::Rep::expire()
1238 {
1239     while (true)
1240     {
1241         boost::xtime xt;
1242         boost::xtime_get(&xt,
1243 #if BOOST_VERSION >= 105000
1244                 boost::TIME_UTC_
1245 #else
1246                 boost::TIME_UTC
1247 #endif
1248                   );
1249         xt.sec += m_session_ttl / 3;
1250         boost::thread::sleep(xt);
1251
1252         stat();
1253         expire_classes();
1254     }
1255 }
1256
1257 yf::SessionShared::Rep::Rep()
1258 {
1259     m_resultset_ttl = 30;
1260     m_resultset_max = 10;
1261     m_session_ttl = 90;
1262     m_optimize_search = true;
1263     m_restart = false;
1264     m_session_max = 100;
1265     m_preferredMessageSize = 0;
1266     m_maximumRecordSize = 0;
1267 }
1268
1269 void yf::SessionShared::Rep::start()
1270 {
1271     yf::SessionShared::Worker w(this);
1272     m_thrds.add_thread(new boost::thread(w));
1273 }
1274
1275 yf::SessionShared::SessionShared() : m_p(new SessionShared::Rep)
1276 {
1277 }
1278
1279 yf::SessionShared::~SessionShared() {
1280 }
1281
1282 void yf::SessionShared::start() const
1283 {
1284     m_p->start();
1285 }
1286
1287 yf::SessionShared::Frontend::Frontend(Rep *rep) : m_is_virtual(false), m_p(rep)
1288 {
1289 }
1290
1291 yf::SessionShared::Frontend::~Frontend()
1292 {
1293 }
1294
1295 yf::SessionShared::FrontendPtr yf::SessionShared::Rep::get_frontend(mp::Package &package)
1296 {
1297     boost::mutex::scoped_lock lock(m_mutex);
1298
1299     std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
1300
1301     while(true)
1302     {
1303         it = m_clients.find(package.session());
1304         if (it == m_clients.end())
1305             break;
1306
1307         if (!it->second->m_in_use)
1308         {
1309             it->second->m_in_use = true;
1310             return it->second;
1311         }
1312         m_cond_session_ready.wait(lock);
1313     }
1314     FrontendPtr f(new Frontend(this));
1315     m_clients[package.session()] = f;
1316     f->m_in_use = true;
1317     return f;
1318 }
1319
1320 void yf::SessionShared::Rep::release_frontend(mp::Package &package)
1321 {
1322     boost::mutex::scoped_lock lock(m_mutex);
1323     std::map<mp::Session,yf::SessionShared::FrontendPtr>::iterator it;
1324
1325     it = m_clients.find(package.session());
1326     if (it != m_clients.end())
1327     {
1328         if (package.session().is_closed())
1329         {
1330             m_clients.erase(it);
1331         }
1332         else
1333         {
1334             it->second->m_in_use = false;
1335         }
1336         m_cond_session_ready.notify_all();
1337     }
1338 }
1339
1340
1341 void yf::SessionShared::process(mp::Package &package) const
1342 {
1343     FrontendPtr f = m_p->get_frontend(package);
1344
1345     Z_GDU *gdu = package.request().get();
1346
1347     if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
1348         Z_APDU_initRequest && !f->m_is_virtual)
1349     {
1350         m_p->init(package, gdu, f);
1351     }
1352     else if (!f->m_is_virtual)
1353         package.move();
1354     else if (gdu && gdu->which == Z_GDU_Z3950)
1355     {
1356         Z_APDU *apdu = gdu->u.z3950;
1357         if (apdu->which == Z_APDU_initRequest)
1358         {
1359             mp::odr odr;
1360
1361             package.response() = odr.create_close(
1362                 apdu,
1363                 Z_Close_protocolError,
1364                 "double init");
1365
1366             package.session().close();
1367         }
1368         else if (apdu->which == Z_APDU_close)
1369         {
1370             mp::odr odr;
1371
1372             package.response() = odr.create_close(
1373                 apdu,
1374                 Z_Close_peerAbort, "received close from client");
1375             package.session().close();
1376         }
1377         else if (apdu->which == Z_APDU_searchRequest)
1378         {
1379             f->search(package, apdu);
1380         }
1381         else if (apdu->which == Z_APDU_presentRequest)
1382         {
1383             f->present(package, apdu);
1384         }
1385         else if (apdu->which == Z_APDU_scanRequest)
1386         {
1387             f->scan(package, apdu);
1388         }
1389         else
1390         {
1391             mp::odr odr;
1392
1393             package.response() = odr.create_close(
1394                 apdu, Z_Close_protocolError,
1395                 "unsupported APDU in filter_session_shared");
1396
1397             package.session().close();
1398         }
1399     }
1400     m_p->release_frontend(package);
1401 }
1402
1403 void yf::SessionShared::configure(const xmlNode *ptr, bool test_only,
1404                                   const char *path)
1405 {
1406     for (ptr = ptr->children; ptr; ptr = ptr->next)
1407     {
1408         if (ptr->type != XML_ELEMENT_NODE)
1409             continue;
1410         if (!strcmp((const char *) ptr->name, "resultset"))
1411         {
1412             const struct _xmlAttr *attr;
1413             for (attr = ptr->properties; attr; attr = attr->next)
1414             {
1415                 if (!strcmp((const char *) attr->name, "ttl"))
1416                     m_p->m_resultset_ttl =
1417                         mp::xml::get_int(attr->children, 30);
1418                 else if (!strcmp((const char *) attr->name, "max"))
1419                 {
1420                     m_p->m_resultset_max =
1421                         mp::xml::get_int(attr->children, 10);
1422                 }
1423                 else if (!strcmp((const char *) attr->name, "optimizesearch"))
1424                 {
1425                     m_p->m_optimize_search =
1426                         mp::xml::get_bool(attr->children, true);
1427                 }
1428                 else if (!strcmp((const char *) attr->name, "restart"))
1429                 {
1430                     m_p->m_restart = mp::xml::get_bool(attr->children, true);
1431                 }
1432                 else
1433                     throw mp::filter::FilterException(
1434                         "Bad attribute " + std::string((const char *)
1435                                                        attr->name));
1436             }
1437         }
1438         else if (!strcmp((const char *) ptr->name, "session"))
1439         {
1440             const struct _xmlAttr *attr;
1441             for (attr = ptr->properties; attr; attr = attr->next)
1442             {
1443                 if (!strcmp((const char *) attr->name, "ttl"))
1444                     m_p->m_session_ttl =
1445                         mp::xml::get_int(attr->children, 90);
1446                 else if (!strcmp((const char *) attr->name, "max"))
1447                     m_p->m_session_max =
1448                         mp::xml::get_int(attr->children, 100);
1449                 else
1450                     throw mp::filter::FilterException(
1451                         "Bad attribute " + std::string((const char *)
1452                                                        attr->name));
1453             }
1454         }
1455         else if (!strcmp((const char *) ptr->name, "init"))
1456         {
1457             const struct _xmlAttr *attr;
1458             for (attr = ptr->properties; attr; attr = attr->next)
1459             {
1460                 if (!strcmp((const char *) attr->name, "maximum-record-size"))
1461                     m_p->m_maximumRecordSize =
1462                         mp::xml::get_int(attr->children, 0);
1463                 else if (!strcmp((const char *) attr->name,
1464                                  "preferred-message-size"))
1465                     m_p->m_preferredMessageSize =
1466                         mp::xml::get_int(attr->children, 0);
1467                 else
1468                     throw mp::filter::FilterException(
1469                         "Bad attribute " + std::string((const char *)
1470                                                        attr->name));
1471             }
1472         }
1473         else
1474         {
1475             throw mp::filter::FilterException("Bad element "
1476                                                + std::string((const char *)
1477                                                              ptr->name));
1478         }
1479     }
1480 }
1481
1482 static mp::filter::Base* filter_creator()
1483 {
1484     return new mp::filter::SessionShared;
1485 }
1486
1487 extern "C" {
1488     struct metaproxy_1_filter_struct metaproxy_1_filter_session_shared = {
1489         0,
1490         "session_shared",
1491         filter_creator
1492     };
1493 }
1494
1495 /*
1496  * Local variables:
1497  * c-basic-offset: 4
1498  * c-file-style: "Stroustrup"
1499  * indent-tabs-mode: nil
1500  * End:
1501  * vim: shiftwidth=4 tabstop=8 expandtab
1502  */
1503