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.45 2003-07-25 08:57:01 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_cache.clear();
 149                 c->m_last_resultCount = 0;
 150                 c->m_sr_transform = 0;
 151                 c->m_waiting = 0;
 152                 c->m_resultSetStartPoint = 0;
 153                 c->timeout(m_idletime);
 154             }
 155             c->m_seqno = parent->m_seqno;
 156             if (c->m_server && c->m_server != this)
 157                 c->m_server->m_client = 0;
 158             c->m_server = this;
 159             (parent->m_seqno)++;
 160             yaz_log (LOG_DEBUG, "get_client 1 %p %p", this, c);
 161             return c;
 162         }
 163     }
 164     else if (!c)
 165     {
 166         Yaz_ProxyClient *cc = 0;
 167
 168         for (c = parent->m_clientPool; c; c = c->m_next)
 169         {
 170             assert (c->m_prev);
 171             assert (*c->m_prev == c);
 172             if (c->m_server == 0 && c->m_cookie[0] == 0 &&
 173                 !strcmp(m_proxyTarget, c->get_hostname()))
 174             {
 175                 cc = c;
 176             }
 177         }
 178         if (cc)
 179         {
 180             // found it in cache
 181             c = cc;
 182
 183             yaz_log (LOG_LOG, "Reuse session %d to %d %s",
 184                      c->m_seqno, parent->m_seqno, c->get_hostname());
 185
 186             c->m_seqno = parent->m_seqno;
 187             assert(c->m_server == 0);
 188             c->m_server = this;
 189
 190             (parent->m_seqno)++;
 191             return c;
 192         }
 193     }
 194     if (!m_client)
 195     {
 196         if (apdu->which != Z_APDU_initRequest)
 197         {
 198             yaz_log (LOG_LOG, "no first INIT!");
 199             return 0;
 200         }
 201         Z_InitRequest *initRequest = apdu->u.initRequest;
 202
 203         if (!initRequest->idAuthentication)
 204         {
 205             if (m_proxy_authentication)
 206             {
 207                 initRequest->idAuthentication =
 208                     (Z_IdAuthentication *)
 209                     odr_malloc (odr_encode(),
 210                                 sizeof(*initRequest->idAuthentication));
 211                 initRequest->idAuthentication->which =
 212                     Z_IdAuthentication_open;
 213                 initRequest->idAuthentication->u.open =
 214                     odr_strdup (odr_encode(), m_proxy_authentication);
 215             }
 216         }
 217
 218         // go through list of clients - and find the lowest/oldest one.
 219         Yaz_ProxyClient *c_min = 0;
 220         int min_seq = -1;
 221         int no_of_clients = 0;
 222         if (parent->m_clientPool)
 223             yaz_log (LOG_LOG, "Existing sessions");
 224         for (c = parent->m_clientPool; c; c = c->m_next)
 225         {
 226             yaz_log (LOG_LOG, " Session %-3d wait=%d %s", c->m_seqno,
 227                                c->m_waiting, c->get_hostname());
 228             no_of_clients++;
 229             if (min_seq < 0 || c->m_seqno < min_seq)
 230             {
 231                 min_seq = c->m_seqno;
 232                 c_min = c;
 233             }
 234         }
 235         if (no_of_clients >= parent->m_max_clients)
 236         {
 237             c = c_min;
 238             if (c->m_waiting || strcmp(m_proxyTarget, c->get_hostname()))
 239             {
 240                 yaz_log (LOG_LOG, "Replace session %d",
 241                       c->m_seqno);
 242                 if (c->m_server && c->m_server != this)
 243                     delete c->m_server;
 244                 c->m_server = 0;
 245             }
 246             else
 247             {
 248                 yaz_log (LOG_LOG, "Move session %d to %d %s",
 249                       c->m_seqno, parent->m_seqno, c->get_hostname());
 250                 if (cookie)
 251                     strcpy (c->m_cookie, cookie);
 252                 else
 253                     c->m_cookie[0] = '\0';
 254                 c->m_seqno = parent->m_seqno;
 255                 if (c->m_server && c->m_server != this)
 256                 {
 257                     c->m_server->m_client = 0;
 258                     delete c->m_server;
 259                 }
 260                 (parent->m_seqno)++;
 261                 yaz_log (LOG_DEBUG, "get_client 2 %p %p", this, c);
 262                 return c;
 263             }
 264         }
 265         else
 266         {
 267             yaz_log (LOG_LOG, "Making session %d %s", parent->m_seqno,
 268                             m_proxyTarget);
 269             c = new Yaz_ProxyClient(m_PDU_Observable->clone());
 270             c->m_next = parent->m_clientPool;
 271             if (c->m_next)
 272                 c->m_next->m_prev = &c->m_next;
 273             parent->m_clientPool = c;
 274             c->m_prev = &parent->m_clientPool;
 275         }
 276         if (cookie)
 277             strcpy (c->m_cookie, cookie);
 278         else
 279             c->m_cookie[0] = '\0';
 280         yaz_log (LOG_LOG, "Connecting to %s", m_proxyTarget);
 281         c->m_seqno = parent->m_seqno;
 282         c->client(m_proxyTarget);
 283         c->m_init_flag = 0;
 284         c->m_last_resultCount = 0;
 285         c->m_last_ok = 0;
 286         c->m_cache.clear();
 287         c->m_sr_transform = 0;
 288         c->m_waiting = 0;
 289         c->m_resultSetStartPoint = 0;
 290         c->timeout(20);
 291
 292         (parent->m_seqno)++;
 293     }
 294     yaz_log (LOG_DEBUG, "get_client 3 %p %p", this, c);
 295     return c;
 296 }
 297
 298 Z_APDU *Yaz_Proxy::result_set_optimize(Z_APDU *apdu)
 299 {
 300     if (*m_parent->m_optimize == '0')
 301         return apdu;      // don't optimize result sets..
 302     if (apdu->which == Z_APDU_presentRequest)
 303     {
 304         Z_PresentRequest *pr = apdu->u.presentRequest;
 305         Z_NamePlusRecordList *npr;
 306         int toget = *pr->numberOfRecordsRequested;
 307         int start = *pr->resultSetStartPoint;
 308
 309         if (m_client->m_last_resultSetId &&
 310             !strcmp(m_client->m_last_resultSetId, pr->resultSetId))
 311         {
 312             if (m_client->m_cache.lookup (odr_encode(), &npr, start, toget,
 313                                           pr->preferredRecordSyntax,
 314                                           pr->recordComposition))
 315             {
 316                 yaz_log (LOG_LOG, "Returned cache records for present request");
 317                 Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentResponse);
 318                 new_apdu->u.presentResponse->referenceId = pr->referenceId;
 319
 320                 new_apdu->u.presentResponse->numberOfRecordsReturned
 321                     = odr_intdup(odr_encode(), toget);
 322
 323                 new_apdu->u.presentResponse->records = (Z_Records*)
 324                     odr_malloc(odr_encode(), sizeof(Z_Records));
 325                 new_apdu->u.presentResponse->records->which = Z_Records_DBOSD;
 326                 new_apdu->u.presentResponse->records->u.databaseOrSurDiagnostics = npr;
 327                 new_apdu->u.presentResponse->nextResultSetPosition =
 328                     odr_intdup(odr_encode(), start+toget);
 329                 send_Z_PDU(new_apdu);
 330                 return 0;
 331             }
 332         }
 333     }
 334
 335     if (apdu->which != Z_APDU_searchRequest)
 336         return apdu;
 337     Z_SearchRequest *sr = apdu->u.searchRequest;
 338     Yaz_Z_Query *this_query = new Yaz_Z_Query;
 339     Yaz_Z_Databases this_databases;
 340
 341     this_databases.set(sr->num_databaseNames, (const char **)
 342                        sr->databaseNames);
 343
 344     this_query->set_Z_Query(sr->query);
 345
 346     if (m_client->m_last_ok && m_client->m_last_query &&
 347         m_client->m_last_query->match(this_query) &&
 348         !strcmp(m_client->m_last_resultSetId, sr->resultSetName) &&
 349         m_client->m_last_databases.match(this_databases))
 350     {
 351         delete this_query;
 352         if (m_client->m_last_resultCount > *sr->smallSetUpperBound &&
 353             m_client->m_last_resultCount < *sr->largeSetLowerBound)
 354         {
 355             Z_NamePlusRecordList *npr;
 356             int toget = *sr->mediumSetPresentNumber;
 357             Z_RecordComposition *comp = 0;
 358
 359             if (toget > m_client->m_last_resultCount)
 360                 toget = m_client->m_last_resultCount;
 361
 362             if (sr->mediumSetElementSetNames)
 363             {
 364                 comp = (Z_RecordComposition *)
 365                     odr_malloc(odr_encode(), sizeof(Z_RecordComposition));
 366                 comp->which = Z_RecordComp_simple;
 367                 comp->u.simple = sr->mediumSetElementSetNames;
 368             }
 369
 370             if (m_client->m_cache.lookup (odr_encode(), &npr, 1, toget,
 371                                           sr->preferredRecordSyntax, comp))
 372             {
 373                 yaz_log (LOG_LOG, "Returned cache records for medium set");
 374                 Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
 375                 new_apdu->u.searchResponse->referenceId = sr->referenceId;
 376                 new_apdu->u.searchResponse->resultCount =
 377                     &m_client->m_last_resultCount;
 378
 379                 new_apdu->u.searchResponse->numberOfRecordsReturned
 380                     = odr_intdup(odr_encode(), toget);
 381
 382                 new_apdu->u.searchResponse->presentStatus =
 383                     odr_intdup(odr_encode(), Z_PresentStatus_success);
 384                 new_apdu->u.searchResponse->records = (Z_Records*)
 385                     odr_malloc(odr_encode(), sizeof(Z_Records));
 386                 new_apdu->u.searchResponse->records->which = Z_Records_DBOSD;
 387                 new_apdu->u.searchResponse->records->u.databaseOrSurDiagnostics = npr;
 388                 new_apdu->u.searchResponse->nextResultSetPosition =
 389                     odr_intdup(odr_encode(), toget+1);
 390                 send_Z_PDU(new_apdu);
 391                 return 0;
 392             }
 393             else
 394             {
 395                 // medium Set
 396                 // send present request (medium size)
 397                 yaz_log (LOG_LOG, "Optimizing search for medium set");
 398
 399                 Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentRequest);
 400                 Z_PresentRequest *pr = new_apdu->u.presentRequest;
 401                 pr->referenceId = sr->referenceId;
 402                 pr->resultSetId = sr->resultSetName;
 403                 pr->preferredRecordSyntax = sr->preferredRecordSyntax;
 404                 *pr->numberOfRecordsRequested = toget;
 405                 pr->recordComposition = comp;
 406                 m_client->m_sr_transform = 1;
 407                 return new_apdu;
 408             }
 409         }
 410         else if (m_client->m_last_resultCount >= *sr->largeSetLowerBound ||
 411             m_client->m_last_resultCount <= 0)
 412         {
 413             // large set. Return pseudo-search response immediately
 414             yaz_log (LOG_LOG, "Optimizing search for large set");
 415             Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
 416             new_apdu->u.searchResponse->referenceId = sr->referenceId;
 417             new_apdu->u.searchResponse->resultCount =
 418                 &m_client->m_last_resultCount;
 419             send_Z_PDU(new_apdu);
 420             return 0;
 421         }
 422         else
 423         {
 424             Z_NamePlusRecordList *npr;
 425             int toget = m_client->m_last_resultCount;
 426             Z_RecordComposition *comp = 0;
 427             // small set
 428             // send a present request (small set)
 429
 430             if (sr->smallSetElementSetNames)
 431             {
 432                 comp = (Z_RecordComposition *)
 433                     odr_malloc(odr_encode(), sizeof(Z_RecordComposition));
 434                 comp->which = Z_RecordComp_simple;
 435                 comp->u.simple = sr->smallSetElementSetNames;
 436             }
 437
 438             if (m_client->m_cache.lookup (odr_encode(), &npr, 1, toget,
 439                                           sr->preferredRecordSyntax, comp))
 440             {
 441                 yaz_log (LOG_LOG, "Returned cache records for small set");
 442                 Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
 443                 new_apdu->u.searchResponse->referenceId = sr->referenceId;
 444                 new_apdu->u.searchResponse->resultCount =
 445                     &m_client->m_last_resultCount;
 446
 447                 new_apdu->u.searchResponse->numberOfRecordsReturned
 448                     = odr_intdup(odr_encode(), toget);
 449
 450                 new_apdu->u.searchResponse->presentStatus =
 451                     odr_intdup(odr_encode(), Z_PresentStatus_success);
 452                 new_apdu->u.searchResponse->records = (Z_Records*)
 453                     odr_malloc(odr_encode(), sizeof(Z_Records));
 454                 new_apdu->u.searchResponse->records->which = Z_Records_DBOSD;
 455                 new_apdu->u.searchResponse->records->u.databaseOrSurDiagnostics = npr;
 456                 new_apdu->u.searchResponse->nextResultSetPosition =
 457                     odr_intdup(odr_encode(), toget+1);
 458                 send_Z_PDU(new_apdu);
 459                 return 0;
 460             }
 461             else
 462             {
 463                 yaz_log (LOG_LOG, "Optimizing search for small set");
 464                 Z_APDU *new_apdu = create_Z_PDU(Z_APDU_presentRequest);
 465                 Z_PresentRequest *pr = new_apdu->u.presentRequest;
 466                 pr->referenceId = sr->referenceId;
 467                 pr->resultSetId = sr->resultSetName;
 468                 pr->preferredRecordSyntax = sr->preferredRecordSyntax;
 469                 *pr->numberOfRecordsRequested = toget;
 470                 pr->recordComposition = comp;
 471                 m_client->m_sr_transform = 1;
 472                 return new_apdu;
 473             }
 474         }
 475     }
 476     else
 477     {
 478         delete m_client->m_last_query;
 479         m_client->m_last_query = this_query;
 480         m_client->m_last_ok = 0;
 481         m_client->m_cache.clear();
 482         m_client->m_resultSetStartPoint = 0;
 483
 484         xfree (m_client->m_last_resultSetId);
 485         m_client->m_last_resultSetId = xstrdup (sr->resultSetName);
 486
 487         m_client->m_last_databases.set(sr->num_databaseNames,
 488                                        (const char **) sr->databaseNames);
 489     }
 490     return apdu;
 491 }
 492
 493 static const char *apdu_name(Z_APDU *apdu)
 494 {
 495     switch (apdu->which)
 496     {
 497     case Z_APDU_initRequest:
 498         return "initRequest";
 499     case Z_APDU_initResponse:
 500         return "initResponse";
 501     case Z_APDU_searchRequest:
 502         return "searchRequest";
 503     case Z_APDU_searchResponse:
 504         return "searchResponse";
 505     case Z_APDU_presentRequest:
 506         return "presentRequest";
 507     case Z_APDU_presentResponse:
 508         return "presentResponse";
 509     case Z_APDU_deleteResultSetRequest:
 510         return "deleteResultSetRequest";
 511     case Z_APDU_deleteResultSetResponse:
 512         return "deleteResultSetResponse";
 513     case Z_APDU_scanRequest:
 514         return "scanRequest";
 515     case Z_APDU_scanResponse:
 516         return "scanResponse";
 517     case Z_APDU_sortRequest:
 518         return "sortRequest";
 519     case Z_APDU_sortResponse:
 520         return "sortResponse";
 521     case Z_APDU_extendedServicesRequest:
 522         return "extendedServicesRequest";
 523     case Z_APDU_extendedServicesResponse:
 524         return "extendedServicesResponse";
 525     case Z_APDU_close:
 526         return "close";
 527     }
 528     return "other";
 529 }
 530
 531 void Yaz_Proxy::recv_Z_PDU(Z_APDU *apdu)
 532 {
 533     yaz_log (LOG_LOG, "Receiving %s from client", apdu_name(apdu));
 534     // Determine our client.
 535     m_client = get_client(apdu);
 536     if (!m_client)
 537     {
 538         delete this;
 539         return;
 540     }
 541     m_client->m_server = this;
 542
 543     if (apdu->which == Z_APDU_initRequest)
 544     {
 545         if (m_client->m_init_flag)
 546         {
 547             Z_APDU *apdu = m_client->m_initResponse;
 548             apdu->u.initResponse->otherInfo = 0;
 549             if (m_client->m_cookie && *m_client->m_cookie)
 550                 set_otherInformationString(apdu, VAL_COOKIE, 1,
 551                                            m_client->m_cookie);
 552             send_Z_PDU(apdu);
 553             return;
 554         }
 555         m_client->m_init_flag = 1;
 556     }
 557     apdu = result_set_optimize(apdu);
 558     if (!apdu)
 559         return;
 560
 561     yaz_log (LOG_LOG, "Sending %s to %s",
 562                     apdu_name(apdu), m_client->get_hostname());
 563
 564     // delete other info part from PDU before sending to target
 565     Z_OtherInformation **oi;
 566     get_otherInfoAPDU(apdu, &oi);
 567     if (oi)
 568         *oi = 0;
 569
 570     if (apdu->which == Z_APDU_presentRequest &&
 571         m_client->m_resultSetStartPoint == 0)
 572     {
 573         Z_PresentRequest *pr = apdu->u.presentRequest;
 574         m_client->m_resultSetStartPoint = *pr->resultSetStartPoint;
 575         m_client->m_cache.copy_presentRequest(apdu->u.presentRequest);
 576     } else {
 577         m_client->m_resultSetStartPoint = 0;
 578     }
 579     if (m_client->send_Z_PDU(apdu) < 0)
 580     {
 581         delete m_client;
 582         m_client = 0;
 583         delete this;
 584     }
 585     else
 586         m_client->m_waiting = 1;
 587 }
 588
 589 void Yaz_Proxy::connectNotify()
 590 {
 591 }
 592
 593 void Yaz_Proxy::shutdown()
 594 {
 595     // only keep if keep_alive flag is set...
 596     if (m_keepalive && m_client && m_client->m_waiting == 0)
 597     {
 598         yaz_log (LOG_LOG, "shutdown (client to proxy) keepalive %s",
 599                  m_client->get_hostname());
 600         assert (m_client->m_waiting != 2);
 601         // Tell client (if any) that no server connection is there..
 602         m_client->m_server = 0;
 603     }
 604     else if (m_client)
 605     {
 606         yaz_log (LOG_LOG, "shutdown (client to proxy) close %s",
 607                  m_client->get_hostname());
 608         assert (m_client->m_waiting != 2);
 609         delete m_client;
 610     }
 611     else if (!m_parent)
 612     {
 613         yaz_log (LOG_LOG, "shutdown (client to proxy) bad state");
 614         assert (m_parent);
 615     }
 616     else
 617     {
 618         yaz_log (LOG_LOG, "shutdown (client to proxy)");
 619     }
 620     delete this;
 621 }
 622
 623 void Yaz_ProxyClient::shutdown()
 624 {
 625     yaz_log (LOG_LOG, "shutdown (proxy to server) %s", get_hostname());
 626     delete m_server;
 627     delete this;
 628 }
 629
 630 void Yaz_Proxy::failNotify()
 631 {
 632     yaz_log (LOG_LOG, "Yaz_Proxy connection closed by client");
 633     shutdown();
 634 }
 635
 636 void Yaz_ProxyClient::failNotify()
 637 {
 638     yaz_log (LOG_LOG, "Yaz_ProxyClient connection closed by %s", get_hostname());
 639     shutdown();
 640 }
 641
 642 void Yaz_ProxyClient::connectNotify()
 643 {
 644     yaz_log (LOG_LOG, "Connection accepted by %s", get_hostname());
 645     timeout(600);
 646 }
 647
 648 IYaz_PDU_Observer *Yaz_ProxyClient::sessionNotify(IYaz_PDU_Observable
 649                                                   *the_PDU_Observable, int fd)
 650 {
 651     return new Yaz_ProxyClient(the_PDU_Observable);
 652 }
 653
 654 Yaz_ProxyClient::~Yaz_ProxyClient()
 655 {
 656     if (m_prev)
 657         *m_prev = m_next;
 658     if (m_next)
 659         m_next->m_prev = m_prev;
 660     m_waiting = 2;     // for debugging purposes only.
 661     odr_destroy(m_init_odr);
 662     delete m_last_query;
 663     xfree (m_last_resultSetId);
 664 }
 665
 666 void Yaz_Proxy::timeoutNotify()
 667 {
 668     yaz_log (LOG_LOG, "timeout (client to proxy)");
 669     shutdown();
 670 }
 671
 672 void Yaz_ProxyClient::timeoutNotify()
 673 {
 674     yaz_log (LOG_LOG, "timeout (proxy to target) %s", get_hostname());
 675     shutdown();
 676 }
 677
 678 Yaz_ProxyClient::Yaz_ProxyClient(IYaz_PDU_Observable *the_PDU_Observable) :
 679     Yaz_Z_Assoc (the_PDU_Observable)
 680 {
 681     m_cookie[0] = 0;
 682     m_next = 0;
 683     m_prev = 0;
 684     m_init_flag = 0;
 685     m_last_query = 0;
 686     m_last_resultSetId = 0;
 687     m_last_resultCount = 0;
 688     m_last_ok = 0;
 689     m_sr_transform = 0;
 690     m_waiting = 0;
 691     m_init_odr = odr_createmem (ODR_DECODE);
 692     m_initResponse = 0;
 693     m_resultSetStartPoint = 0;
 694 }
 695
 696 const char *Yaz_Proxy::option(const char *name, const char *value)
 697 {
 698     if (!strcmp (name, "optimize")) {
 699         if (value) {
 700             xfree (m_optimize);
 701             m_optimize = xstrdup (value);
 702         }
 703         return m_optimize;
 704     }
 705     return 0;
 706 }
 707
 708 void Yaz_ProxyClient::recv_Z_PDU(Z_APDU *apdu)
 709 {
 710     m_waiting = 0;
 711     yaz_log (LOG_LOG, "Receiving %s from %s", apdu_name(apdu),
 712                      get_hostname());
 713     if (apdu->which == Z_APDU_initResponse)
 714     {
 715         NMEM nmem = odr_extract_mem (odr_decode());
 716         odr_reset (m_init_odr);
 717         nmem_transfer (m_init_odr->mem, nmem);
 718         m_initResponse = apdu;
 719         nmem_destroy (nmem);
 720     }
 721     if (apdu->which == Z_APDU_searchResponse)
 722     {
 723         Z_SearchResponse *sr = apdu->u.searchResponse;
 724         m_last_resultCount = *sr->resultCount;
 725         int status = *sr->searchStatus;
 726         if (status && (!sr->records || sr->records->which == Z_Records_DBOSD))
 727         {
 728             m_last_ok = 1;
 729
 730             if (sr->records && sr->records->which == Z_Records_DBOSD)
 731             {
 732                 m_cache.add(odr_decode(),
 733                             sr->records->u.databaseOrSurDiagnostics, 1,
 734                             *sr->resultCount);
 735             }
 736         }
 737     }
 738     if (apdu->which == Z_APDU_presentResponse)
 739     {
 740         Z_PresentResponse *pr = apdu->u.presentResponse;
 741         if (m_sr_transform)
 742         {
 743             m_sr_transform = 0;
 744             Z_APDU *new_apdu = create_Z_PDU(Z_APDU_searchResponse);
 745             Z_SearchResponse *sr = new_apdu->u.searchResponse;
 746             sr->referenceId = pr->referenceId;
 747             *sr->resultCount = m_last_resultCount;
 748             sr->records = pr->records;
 749             sr->nextResultSetPosition = pr->nextResultSetPosition;
 750             sr->numberOfRecordsReturned = pr->numberOfRecordsReturned;
 751             apdu = new_apdu;
 752         }
 753         if (pr->records->which == Z_Records_DBOSD && m_resultSetStartPoint)
 754         {
 755             m_cache.add(odr_decode(),
 756                         pr->records->u.databaseOrSurDiagnostics,
 757                         m_resultSetStartPoint, -1);
 758             m_resultSetStartPoint = 0;
 759         }
 760     }
 761     if (m_cookie && *m_cookie)
 762         set_otherInformationString (apdu, VAL_COOKIE, 1, m_cookie);
 763     if (m_server)
 764     {
 765         yaz_log (LOG_LOG, "Sending %s to client", apdu_name(apdu));
 766         m_server->send_Z_PDU(apdu);
 767     }
 768     if (apdu->which == Z_APDU_close)
 769     {
 770         shutdown();
 771     }
 772 }