src/yaz-proxy.cpp

   1 /*
   2  * Copyright (c) 1998-2003, Index Data.
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: yaz-proxy.cpp,v 1.40 2003-06-11 08:22:18 adam Exp $
   6  */
   7
   8 #include <assert.h>
   9 #include <time.h>
  10
  11 #include <yaz/log.h>
  12 #include <yaz++/proxy.h>
  13
  14 Yaz_Proxy::Yaz_Proxy(IYaz_PDU_Observable *the_PDU_Observable) :
  15     Yaz_Z_Assoc(the_PDU_Observable)
  16 {
  17     m_PDU_Observable = the_PDU_Observable;
  18     m_client = 0;
  19     m_parent = 0;
  20     m_clientPool = 0;
  21     m_seqno = 1;
  22     m_keepalive = 1;
  23     m_proxyTarget = 0;
  24     m_proxy_authentication = 0;
  25     m_max_clients = 50;
  26     m_seed = time(0);
  27     m_idletime = 600;
  28     m_optimize = xstrdup ("1");
  29 }
  30
  31 Yaz_Proxy::~Yaz_Proxy()
  32 {
  33     xfree (m_proxyTarget);
  34     xfree (m_proxy_authentication);
  35     xfree (m_optimize);
  36 }
  37
  38 void Yaz_Proxy::set_proxy_target(const char *target)
  39 {
  40     xfree (m_proxyTarget);
  41     m_proxyTarget = 0;
  42     if (target)
  43         m_proxyTarget = (char *) xstrdup (target);
  44 }
  45
  46 void Yaz_Proxy::set_proxy_authentication (const char *auth)
  47 {
  48     xfree (m_proxy_authentication);
  49     m_proxy_authentication = 0;
  50     if (auth)
  51         m_proxy_authentication = (char *) xstrdup (auth);
  52 }
  53
  54 IYaz_PDU_Observer *Yaz_Proxy::sessionNotify(IYaz_PDU_Observable
  55                                             *the_PDU_Observable, int fd)
  56 {
  57     Yaz_Proxy *new_proxy = new Yaz_Proxy(the_PDU_Observable);
  58     new_proxy->m_parent = this;
  59     new_proxy->timeout(m_idletime);
  60     new_proxy->set_proxy_target(m_proxyTarget);
  61     new_proxy->set_APDU_log(get_APDU_log());
  62     new_proxy->set_proxy_authentication(m_proxy_authentication);
  63     yaz_log (LOG_LOG, "New session p=%p", new_proxy);
  64     return new_proxy;
  65 }
  66
  67 char *Yaz_Proxy::get_cookie(Z_OtherInformation **otherInfo)
  68 {
  69     int oid[OID_SIZE];
  70     Z_OtherInformationUnit *oi;
  71     struct oident ent;
  72     ent.proto = PROTO_Z3950;
  73     ent.oclass = CLASS_USERINFO;
  74     ent.value = (oid_value) VAL_COOKIE;
  75     assert (oid_ent_to_oid (&ent, oid));
  76
  77     if (oid_ent_to_oid (&ent, oid) &&
  78         (oi = update_otherInformation(otherInfo, 0, oid, 1, 1)) &&
  79         oi->which == Z_OtherInfo_characterInfo)
  80         return oi->information.characterInfo;
  81     return 0;
  82 }
  83
  84 char *Yaz_Proxy::get_proxy(Z_OtherInformation **otherInfo)
  85 {
  86     int oid[OID_SIZE];
  87     Z_OtherInformationUnit *oi;
  88     struct oident ent;
  89     ent.proto = PROTO_Z3950;
  90     ent.oclass = CLASS_USERINFO;
  91     ent.value = (oid_value) VAL_PROXY;
  92     if (oid_ent_to_oid (&ent, oid) &&
  93         (oi = update_otherInformation(otherInfo, 0, oid, 1, 1)) &&
  94         oi->which == Z_OtherInfo_characterInfo)
  95         return oi->information.characterInfo;
  96     return 0;
  97 }
  98
  99 Yaz_ProxyClient *Yaz_Proxy::get_client(Z_APDU *apdu)
 100 {
 101     assert (m_parent);
 102     Yaz_Proxy *parent = m_parent;
 103     Z_OtherInformation **oi;
 104     Yaz_ProxyClient *c = m_client;
 105
 106     get_otherInfoAPDU(apdu, &oi);
 107     char *cookie = get_cookie(oi);
 108
 109     const char *proxy_host = get_proxy(oi);
 110     if (proxy_host)
 111         set_proxy_target(proxy_host);
 112
 113     // no target specified at all?
 114     if (!m_proxyTarget)
 115         return 0;
 116
 117     if (!strcmp(m_proxyTarget, "stop"))
 118         exit (0);
 119     if (cookie && *cookie)
 120     {
 121         Yaz_ProxyClient *cc = 0;
 122
 123         for (c = parent->m_clientPool; c; c = c->m_next)
 124         {
 125             assert (c->m_prev);
 126             assert (*c->m_prev == c);
 127             if (!strcmp(cookie,c->m_cookie) &&
 128                 !strcmp(m_proxyTarget, c->get_hostname()))
 129             {
 130                 cc = c;
 131             }
 132         }
 133         if (cc)
 134         {
 135             // found it in cache
 136             c = cc;
 137             // The following handles "cancel"
 138             // If connection is busy (waiting for PDU) and
 139             // we have an initRequest we can safely do re-open
 140             if (c->m_waiting && apdu->which == Z_APDU_initRequest)
 141             {
 142                 yaz_log (LOG_LOG, "reopen target=%s", c->get_hostname());
 143                 c->close();
 144                 c->client(m_proxyTarget);
 145                 c->m_init_flag = 0;
 146
 147                 c->m_last_ok = 0;
 148                 c->m_last_resultCount = 0;
 149                 c->m_sr_transform = 0;
 150                 c->m_waiting = 0;
 151                 c->timeout(m_idletime);
 152             }
 153             c->m_seqno = parent->m_seqno;
 154             if (c->m_server && c->m_server != this)
 155                 c->m_server->m_client = 0;
 156             c->m_server = this;
 157             (parent->m_seqno)++;
 158             yaz_log (LOG_DEBUG, "get_client 1 %p %p", this, c);
 159             return c;
 160         }
 161     }
 162     else if (!c)
 163     {
 164         Yaz_ProxyClient *cc = 0;
 165
 166         for (c = parent->m_clientPool; c; c = c->m_next)
 167         {
 168             assert (c->m_prev);
 169             assert (*c->m_prev == c);
 170             if (c->m_server == 0 && c->m_cookie[0] == 0 &&
 171                 !strcmp(m_proxyTarget, c->get_hostname()))
 172             {
 173                 cc = c;
 174             }
 175         }
 176         if (cc)
 177         {
 178             // found it in cache
 179             c = cc;
 180
 181             yaz_log (LOG_LOG, "Reuse session %d to %d %s",
 182                      c->m_seqno, parent->m_seqno, c->get_hostname());
 183
 184             c->m_seqno = parent->m_seqno;
 185             assert(c->m_server == 0);
 186             c->m_server = this;
 187
 188             (parent->m_seqno)++;
 189             return c;
 190         }
 191     }
 192     if (!m_client)
 193     {
 194         if (apdu->which != Z_APDU_initRequest)
 195         {
 196             yaz_log (LOG_LOG, "no first INIT!");
 197             return 0;
 198         }
 199         Z_InitRequest *initRequest = apdu->u.initRequest;
 200
 201         if (!initRequest->idAuthentication)
 202         {
 203             if (m_proxy_authentication)
 204             {
 205                 initRequest->idAuthentication =
 206                     (Z_IdAuthentication *)
 207                     odr_malloc (odr_encode(),
 208                                 sizeof(*initRequest->idAuthentication));
 209                 initRequest->idAuthentication->which =
 210                     Z_IdAuthentication_open;
 211                 initRequest->idAuthentication->u.open =
 212                     odr_strdup (odr_encode(), m_proxy_authentication);
 213             }
 214         }
 215
 216         // go through list of clients - and find the lowest/oldest one.
 217         Yaz_ProxyClient *c_min = 0;
 218         int min_seq = -1;
 219         int no_of_clients = 0;
 220         if (parent->m_clientPool)
 221             yaz_log (LOG_LOG, "Existing sessions");
 222         for (c = parent->m_clientPool; c; c = c->m_next)
 223         {
 224             yaz_log (LOG_LOG, " Session %-3d wait=%d %s", c->m_seqno,
 225                                c->m_waiting, c->get_hostname());
 226             no_of_clients++;
 227             if (min_seq < 0 || c->m_seqno < min_seq)
 228             {
 229                 min_seq = c->m_seqno;
 230                 c_min = c;
 231             }
 232         }
 233         if (no_of_clients >= parent->m_max_clients)
 234         {
 235             c = c_min;
 236             if (c->m_waiting || strcmp(m_proxyTarget, c->get_hostname()))
 237             {
 238                 yaz_log (LOG_LOG, "Replace session %d",
 239                       c->m_seqno);
 240                 if (c->m_server && c->m_server != this)
 241                     delete c->m_server;
 242                 c->m_server = 0;
 243             }
 244             else
 245             {
 246                 yaz_log (LOG_LOG, "Move session %d to %d %s",
 247                       c->m_seqno, parent->m_seqno, c->get_hostname());
 248                 if (cookie)
 249                     strcpy (c->m_cookie, cookie);
 250                 else
 251                     c->m_cookie[0] = '\0';
 252                 c->m_seqno = parent->m_seqno;
 253                 if (c->m_server && c->m_server != this)
 254                 {
 255                     c->m_server->m_client = 0;
 256                     delete c->m_server;
 257                 }
 258                 (parent->m_seqno)++;
 259                 yaz_log (LOG_DEBUG, "get_client 2 %p %p", this, c);
 260                 return c;
 261             }
 262         }
 263         else
 264         {
 265             yaz_log (LOG_LOG, "Making session %d %s", parent->m_seqno,
 266                             m_proxyTarget);
 267             c = new Yaz_ProxyClient(m_PDU_Observable->clone());
 268             c->m_next = parent->m_clientPool;
 269             if (c->m_next)
 270                 c->m_next->m_prev = &c->m_next;
 271             parent->m_clientPool = c;
 272             c->m_prev = &parent->m_clientPool;
 273         }
 274         if (cookie)
 275             strcpy (c->m_cookie, cookie);
 276         else
 277             c->m_cookie[0] = '\0';
 278         yaz_log (LOG_LOG, "Connecting to %s", m_proxyTarget);
 279         c->m_seqno = parent->m_seqno;
 280         c->client(m_proxyTarget);
 281         c->m_init_flag = 0;
 282         c->m_last_resultCount = 0;
 283         c->m_last_ok = 0;
 284         c->m_sr_transform = 0;
 285         c->m_waiting = 0;
 286         c->timeout(20);
 287
 288         (parent->m_seqno)++;
 289     }
 290     yaz_log (LOG_DEBUG, "get_client 3 %p %p", this, c);
 291     return c;
 292 }
 293
 294 Z_APDU *Yaz_Proxy::result_set_optimize(Z_APDU *apdu)
 295 {
 296     if (apdu->which != Z_APDU_searchRequest)
 297         return apdu;
 298     if (*m_parent->m_optimize == '0')
 299         return apdu;      // don't optimize result sets..
 300     Z_SearchRequest *sr = apdu->u.searchRequest;
 301     Yaz_Z_Query *this_query = new Yaz_Z_Query;
 302     Yaz_Z_Databases this_databases;
 303
 304     this_databases.set(sr->num_databaseNames, (const char **)
 305                        sr->databaseNames);
 306
 307     this_query->set_Z_Query(sr->query);
 308
 309     if (m_client->m_last_ok && m_client->m_last_query &&
 310         m_client->m_last_query->match(this_query) &&
 311         !strcmp(m_client->m_last_resultSetId, sr->resultSetName) &&
 312         m_client->m_last_databases.match(this_databases))
 313     {
 314         delete this_query;
 315         if (m_client->m_last_resultCount > *sr->smallSetUpperBound &&
 316             m_client->m_last_resultCount < *sr->largeSetLowerBound)
 317         {
 318             // medium Set
 319             // send present request (medium size)
 320             yaz_log (LOG_LOG, "Optimizing search for medium set");
 321             Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentRequest);
 322             Z_PresentRequest *pr = new_apdu->u.presentRequest;
 323             pr->referenceId = sr->referenceId;
 324             pr->resultSetId = sr->resultSetName;
 325             pr->preferredRecordSyntax = sr->preferredRecordSyntax;
 326             if (*sr->mediumSetPresentNumber < m_client->m_last_resultCount)
 327                 *pr->numberOfRecordsRequested = *sr->mediumSetPresentNumber;
 328             else
 329                 *pr->numberOfRecordsRequested = m_client->m_last_resultCount;
 330             if (sr->mediumSetElementSetNames)
 331             {
 332                 pr->recordComposition = (Z_RecordComposition *)
 333                     odr_malloc(odr_encode(), sizeof(Z_RecordComposition));
 334                 pr->recordComposition->which = Z_RecordComp_simple;
 335                 pr->recordComposition->u.simple = sr->mediumSetElementSetNames;
 336             }
 337             m_client->m_sr_transform = 1;
 338             return new_apdu;
 339         }
 340         else if (m_client->m_last_resultCount >= *sr->largeSetLowerBound ||
 341             m_client->m_last_resultCount <= 0)
 342         {
 343             // large set. Return pseudo-search response immediately
 344             yaz_log (LOG_LOG, "Optimizing search for large set");
 345             Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
 346             new_apdu->u.searchResponse->referenceId = sr->referenceId;
 347             new_apdu->u.searchResponse->resultCount =
 348                 &m_client->m_last_resultCount;
 349             send_Z_PDU(new_apdu);
 350             return 0;
 351         }
 352         else
 353         {
 354             // small set
 355             // send a present request (small set)
 356             yaz_log (LOG_LOG, "Optimizing search for small set");
 357             Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentRequest);
 358             Z_PresentRequest *pr = new_apdu->u.presentRequest;
 359             pr->referenceId = sr->referenceId;
 360             pr->resultSetId = sr->resultSetName;
 361             pr->preferredRecordSyntax = sr->preferredRecordSyntax;
 362             *pr->numberOfRecordsRequested = m_client->m_last_resultCount;
 363             if (sr->smallSetElementSetNames)
 364             {
 365                 pr->recordComposition = (Z_RecordComposition *)
 366                     odr_malloc(odr_encode(), sizeof(Z_RecordComposition));
 367                 pr->recordComposition->which = Z_RecordComp_simple;
 368                 pr->recordComposition->u.simple = sr->smallSetElementSetNames;
 369             }
 370             m_client->m_sr_transform = 1;
 371             return new_apdu;
 372         }
 373     }
 374     else
 375     {
 376         delete m_client->m_last_query;
 377         m_client->m_last_query = this_query;
 378         m_client->m_last_ok = 0;
 379
 380         xfree (m_client->m_last_resultSetId);
 381         m_client->m_last_resultSetId = xstrdup (sr->resultSetName);
 382
 383         m_client->m_last_databases.set(sr->num_databaseNames,
 384                                        (const char **) sr->databaseNames);
 385     }
 386     return apdu;
 387 }
 388
 389 static const char *apdu_name(Z_APDU *apdu)
 390 {
 391     switch (apdu->which)
 392     {
 393     case Z_APDU_initRequest:
 394         return "initRequest";
 395     case Z_APDU_initResponse:
 396         return "initResponse";
 397     case Z_APDU_searchRequest:
 398         return "searchRequest";
 399     case Z_APDU_searchResponse:
 400         return "searchResponse";
 401     case Z_APDU_presentRequest:
 402         return "presentRequest";
 403     case Z_APDU_presentResponse:
 404         return "presentResponse";
 405     }
 406     return "other";
 407 }
 408
 409 void Yaz_Proxy::recv_Z_PDU(Z_APDU *apdu)
 410 {
 411     yaz_log (LOG_LOG, "Receiving %s from client", apdu_name(apdu));
 412     // Determine our client.
 413     m_client = get_client(apdu);
 414     if (!m_client)
 415     {
 416         delete this;
 417         return;
 418     }
 419     m_client->m_server = this;
 420
 421     if (apdu->which == Z_APDU_initRequest)
 422     {
 423         if (m_client->m_init_flag)
 424         {
 425             Z_APDU *apdu = m_client->m_initResponse;
 426             apdu->u.initResponse->otherInfo = 0;
 427             if (m_client->m_cookie)
 428                 set_otherInformationString(apdu, VAL_COOKIE, 1,
 429                                            m_client->m_cookie);
 430             send_Z_PDU(apdu);
 431             return;
 432         }
 433         m_client->m_init_flag = 1;
 434     }
 435     apdu = result_set_optimize(apdu);
 436     if (!apdu)
 437         return;
 438
 439     yaz_log (LOG_LOG, "Sending %s to %s",
 440                     apdu_name(apdu), m_client->get_hostname());
 441
 442     // delete other info part from PDU before sending to target
 443     Z_OtherInformation **oi;
 444     get_otherInfoAPDU(apdu, &oi);
 445     if (oi)
 446         *oi = 0;
 447
 448     if (m_client->send_Z_PDU(apdu) < 0)
 449     {
 450         delete m_client;
 451         m_client = 0;
 452         delete this;
 453     }
 454     else
 455         m_client->m_waiting = 1;
 456 }
 457
 458 void Yaz_Proxy::connectNotify()
 459 {
 460 }
 461
 462 void Yaz_Proxy::shutdown()
 463 {
 464     // only keep if keep_alive flag is set...
 465     if (m_keepalive && m_client && m_client->m_waiting == 0)
 466     {
 467         yaz_log (LOG_LOG, "shutdown (client to proxy) keepalive %s",
 468                  m_client->get_hostname());
 469         assert (m_client->m_waiting != 2);
 470         // Tell client (if any) that no server connection is there..
 471         m_client->m_server = 0;
 472     }
 473     else if (m_client)
 474     {
 475         yaz_log (LOG_LOG, "shutdown (client to proxy) close %s",
 476                  m_client->get_hostname());
 477         assert (m_client->m_waiting != 2);
 478         delete m_client;
 479     }
 480     else if (!m_parent)
 481     {
 482         yaz_log (LOG_LOG, "shutdown (client to proxy) bad state");
 483         assert (m_parent);
 484     }
 485     else
 486     {
 487         yaz_log (LOG_LOG, "shutdown (client to proxy)");
 488     }
 489     delete this;
 490 }
 491
 492 void Yaz_ProxyClient::shutdown()
 493 {
 494     yaz_log (LOG_LOG, "shutdown (proxy to server) %s", get_hostname());
 495     delete m_server;
 496     delete this;
 497 }
 498
 499 void Yaz_Proxy::failNotify()
 500 {
 501     yaz_log (LOG_LOG, "Yaz_Proxy connection closed by client");
 502     shutdown();
 503 }
 504
 505 void Yaz_ProxyClient::failNotify()
 506 {
 507     yaz_log (LOG_LOG, "Yaz_ProxyClient connection closed by %s", get_hostname());
 508     shutdown();
 509 }
 510
 511 void Yaz_ProxyClient::connectNotify()
 512 {
 513     yaz_log (LOG_LOG, "Connection accepted by %s", get_hostname());
 514     timeout(600);
 515 }
 516
 517 IYaz_PDU_Observer *Yaz_ProxyClient::sessionNotify(IYaz_PDU_Observable
 518                                                   *the_PDU_Observable, int fd)
 519 {
 520     return new Yaz_ProxyClient(the_PDU_Observable);
 521 }
 522
 523 Yaz_ProxyClient::~Yaz_ProxyClient()
 524 {
 525     if (m_prev)
 526         *m_prev = m_next;
 527     if (m_next)
 528         m_next->m_prev = m_prev;
 529     m_waiting = 2;     // for debugging purposes only.
 530     odr_destroy(m_init_odr);
 531     delete m_last_query;
 532     xfree (m_last_resultSetId);
 533 }
 534
 535 void Yaz_Proxy::timeoutNotify()
 536 {
 537     yaz_log (LOG_LOG, "timeout (client to proxy)");
 538     shutdown();
 539 }
 540
 541 void Yaz_ProxyClient::timeoutNotify()
 542 {
 543     yaz_log (LOG_LOG, "timeout (proxy to target) %s", get_hostname());
 544     shutdown();
 545 }
 546
 547 Yaz_ProxyClient::Yaz_ProxyClient(IYaz_PDU_Observable *the_PDU_Observable) :
 548     Yaz_Z_Assoc (the_PDU_Observable)
 549 {
 550     m_cookie[0] = 0;
 551     m_next = 0;
 552     m_prev = 0;
 553     m_init_flag = 0;
 554     m_last_query = 0;
 555     m_last_resultSetId = 0;
 556     m_last_resultCount = 0;
 557     m_last_ok = 0;
 558     m_sr_transform = 0;
 559     m_waiting = 0;
 560     m_init_odr = odr_createmem (ODR_DECODE);
 561     m_initResponse = 0;
 562 }
 563
 564 const char *Yaz_Proxy::option(const char *name, const char *value)
 565 {
 566     if (!strcmp (name, "optimize")) {
 567         if (value) {
 568             xfree (m_optimize);
 569             m_optimize = xstrdup (value);
 570         }
 571         return m_optimize;
 572     }
 573     return 0;
 574 }
 575
 576 void Yaz_ProxyClient::recv_Z_PDU(Z_APDU *apdu)
 577 {
 578     m_waiting = 0;
 579     yaz_log (LOG_LOG, "Receiving %s from %s", apdu_name(apdu),
 580                      get_hostname());
 581     if (apdu->which == Z_APDU_initResponse)
 582     {
 583         NMEM nmem = odr_extract_mem (odr_decode());
 584         odr_reset (m_init_odr);
 585         nmem_transfer (m_init_odr->mem, nmem);
 586         m_initResponse = apdu;
 587         nmem_destroy (nmem);
 588     }
 589     if (apdu->which == Z_APDU_searchResponse)
 590     {
 591         m_last_resultCount = *apdu->u.searchResponse->resultCount;
 592         int status = *apdu->u.searchResponse->searchStatus;
 593         if (status &&
 594                 (!apdu->u.searchResponse->records ||
 595                  apdu->u.searchResponse->records->which == Z_Records_DBOSD))
 596             m_last_ok = 1;
 597     }
 598     if (apdu->which == Z_APDU_presentResponse && m_sr_transform)
 599     {
 600         m_sr_transform = 0;
 601         Z_PresentResponse *pr = apdu->u.presentResponse;
 602         Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
 603         Z_SearchResponse *sr = new_apdu->u.searchResponse;
 604         sr->referenceId = pr->referenceId;
 605         *sr->resultCount = m_last_resultCount;
 606         sr->records = pr->records;
 607         sr->nextResultSetPosition = pr->nextResultSetPosition;
 608         sr->numberOfRecordsReturned = pr->numberOfRecordsReturned;
 609         apdu = new_apdu;
 610     }
 611     if (m_cookie && *m_cookie)
 612         set_otherInformationString (apdu, VAL_COOKIE, 1, m_cookie);
 613     if (m_server)
 614     {
 615         yaz_log (LOG_LOG, "Sending %s to client", apdu_name(apdu));
 616         m_server->send_Z_PDU(apdu);
 617     }
 618 }