src/adaptation/icap/ServiceRep.cc

   1 /*
   2  * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
   3  *
   4  * Squid software is distributed under GPLv2+ license and includes
   5  * contributions from numerous individuals and organizations.
   6  * Please see the COPYING and CONTRIBUTORS files for details.
   7  */
   8
   9 /* DEBUG: section 93    ICAP (RFC 3507) Client */
  10
  11 #include "squid.h"
  12 #include "adaptation/Answer.h"
  13 #include "adaptation/icap/Config.h"
  14 #include "adaptation/icap/ModXact.h"
  15 #include "adaptation/icap/Options.h"
  16 #include "adaptation/icap/OptXact.h"
  17 #include "adaptation/icap/ServiceRep.h"
  18 #include "base/TextException.h"
  19 #include "comm/Connection.h"
  20 #include "ConfigParser.h"
  21 #include "debug/Stream.h"
  22 #include "fde.h"
  23 #include "globals.h"
  24 #include "HttpReply.h"
  25 #include "ip/tools.h"
  26 #include "SquidConfig.h"
  27
  28 #define DEFAULT_ICAP_PORT   1344
  29 #define DEFAULT_ICAPS_PORT 11344
  30
  31 CBDATA_NAMESPACED_CLASS_INIT(Adaptation::Icap, ServiceRep);
  32
  33 Adaptation::Icap::ServiceRep::ServiceRep(const ServiceConfigPointer &svcCfg):
  34     AsyncJob("Adaptation::Icap::ServiceRep"), Adaptation::Service(svcCfg),
  35     theOptions(nullptr), theOptionsFetcher(nullptr), theLastUpdate(0),
  36     theBusyConns(0),
  37     theAllWaiters(0),
  38     connOverloadReported(false),
  39     theIdleConns(nullptr),
  40     isSuspended(nullptr), notifying(false),
  41     updateScheduled(false),
  42     wasAnnouncedUp(true), // do not announce an "up" service at startup
  43     isDetached(false)
  44 {
  45     setMaxConnections();
  46     theIdleConns = new IdleConnList("ICAP Service", nullptr);
  47 }
  48
  49 Adaptation::Icap::ServiceRep::~ServiceRep()
  50 {
  51     SWALLOW_EXCEPTIONS({
  52         delete theIdleConns;
  53         Must(!theOptionsFetcher);
  54         delete theOptions;
  55     });
  56 }
  57
  58 void
  59 Adaptation::Icap::ServiceRep::finalize()
  60 {
  61     Adaptation::Service::finalize();
  62
  63     // use /etc/services or default port if needed
  64     const bool have_port = cfg().port >= 0;
  65     if (!have_port) {
  66         struct servent *serv;
  67         if (cfg().protocol.caseCmp("icaps") == 0)
  68             serv = getservbyname("icaps", "tcp");
  69         else
  70             serv = getservbyname("icap", "tcp");
  71
  72         if (serv) {
  73             writeableCfg().port = htons(serv->s_port);
  74         } else {
  75             writeableCfg().port = cfg().protocol.caseCmp("icaps") == 0 ? DEFAULT_ICAPS_PORT : DEFAULT_ICAP_PORT;
  76         }
  77     }
  78
  79     if (cfg().protocol.caseCmp("icaps") == 0)
  80         writeableCfg().secure.encryptTransport = true;
  81
  82     if (cfg().secure.encryptTransport) {
  83         debugs(3, DBG_IMPORTANT, "Initializing service " << cfg().resource << " SSL context");
  84         sslContext = writeableCfg().secure.createClientContext(true);
  85     }
  86
  87     if (!cfg().connectionEncryption.configured())
  88         writeableCfg().connectionEncryption.defaultTo(cfg().secure.encryptTransport);
  89
  90     theSessionFailures.configure(TheConfig.oldest_service_failure > 0 ?
  91                                  TheConfig.oldest_service_failure : -1);
  92 }
  93
  94 void Adaptation::Icap::ServiceRep::noteFailure()
  95 {
  96     const int failures = theSessionFailures.count(1);
  97     debugs(93,4, " failure " << failures << " out of " <<
  98            TheConfig.service_failure_limit << " allowed in " <<
  99            TheConfig.oldest_service_failure << "sec " << status());
 100
 101     if (isSuspended)
 102         return;
 103
 104     if (TheConfig.service_failure_limit >= 0 &&
 105             failures > TheConfig.service_failure_limit)
 106         suspend("too many failures");
 107
 108     // TODO: Should bypass setting affect how much Squid tries to talk to
 109     // the ICAP service that is currently unusable and is likely to remain
 110     // so for some time? The current code says "no". Perhaps the answer
 111     // should be configurable.
 112 }
 113
 114 // TODO: getIdleConnection() and putConnection()/noteConnectionFailed() manage a
 115 // "used connection slot" resource. Automate that resource tracking (RAII/etc.).
 116 Comm::ConnectionPointer
 117 Adaptation::Icap::ServiceRep::getIdleConnection(const bool retriableXact)
 118 {
 119     Comm::ConnectionPointer connection;
 120
 121     /* 2011-06-17: rousskov:
 122      *  There are two things that happen at the same time in pop(). Both are important.
 123      *    1) Ensure that we can use a pconn for this transaction.
 124      *    2) Ensure that the number of idle pconns does not grow without bounds.
 125      *
 126      * Both happen in the beginning of the transaction. Both are dictated by real-world problems.
 127      * retriable means you can repeat the request if you suspect the first try failed due to a pconn race.
 128      * HTTP and ICAP rules prohibit the use of pconns for non-retriable requests.
 129      *
 130      * If there are zero idle connections, (2) is irrelevant. (2) is only relevant when there are many
 131      * idle connections and we should not open more connections without closing some idle ones,
 132      * or instead of just opening a new connection and leaving idle connections as is.
 133      * In other words, (2) tells us to close one FD for each new one we open due to retriable.
 134      */
 135     if (retriableXact)
 136         connection = theIdleConns->pop();
 137     else
 138         theIdleConns->closeN(1);
 139
 140     ++theBusyConns;
 141     debugs(93,3, "got connection: " << connection);
 142     return connection;
 143 }
 144
 145 // pools connection if it is reusable or closes it
 146 void Adaptation::Icap::ServiceRep::putConnection(const Comm::ConnectionPointer &conn, bool isReusable, bool sendReset, const char *comment)
 147 {
 148     Must(Comm::IsConnOpen(conn));
 149     // do not pool an idle connection if we owe connections
 150     if (isReusable && excessConnections() == 0) {
 151         debugs(93, 3, "pushing pconn" << comment);
 152         theIdleConns->push(conn);
 153     } else {
 154         debugs(93, 3, (sendReset ? "RST" : "FIN") << "-closing " <<
 155                comment);
 156         // comm_close called from Connection::close will clear timeout
 157         // TODO: add "bool sendReset = false" to Connection::close()?
 158         if (sendReset)
 159             comm_reset_close(conn);
 160         else
 161             conn->close();
 162     }
 163
 164     Must(theBusyConns > 0);
 165     --theBusyConns;
 166     // a connection slot released. Check if there are waiters....
 167     busyCheckpoint();
 168 }
 169
 170 // a wrapper to avoid exposing theIdleConns
 171 void Adaptation::Icap::ServiceRep::noteConnectionUse(const Comm::ConnectionPointer &conn)
 172 {
 173     Must(Comm::IsConnOpen(conn));
 174     fd_table[conn->fd].noteUse(); // pconn re-use, albeit not via PconnPool API
 175 }
 176
 177 void Adaptation::Icap::ServiceRep::noteConnectionFailed(const char *comment)
 178 {
 179     debugs(93, 3, "Connection failed: " << comment);
 180     --theBusyConns;
 181 }
 182
 183 void Adaptation::Icap::ServiceRep::setMaxConnections()
 184 {
 185     if (cfg().maxConn >= 0)
 186         theMaxConnections = cfg().maxConn;
 187     else if (theOptions && theOptions->max_connections >= 0)
 188         theMaxConnections = theOptions->max_connections;
 189     else {
 190         theMaxConnections = -1;
 191         return;
 192     }
 193
 194     if (::Config.workers > 1 )
 195         theMaxConnections /= ::Config.workers;
 196 }
 197
 198 int Adaptation::Icap::ServiceRep::availableConnections() const
 199 {
 200     if (theMaxConnections < 0)
 201         return -1;
 202
 203     // we are available if we can open or reuse connections
 204     // in other words, if we will not create debt
 205     int available = max(0, theMaxConnections - theBusyConns);
 206
 207     if (!available && !connOverloadReported) {
 208         debugs(93, DBG_IMPORTANT, "WARNING: ICAP Max-Connections limit " <<
 209                "exceeded for service " << cfg().uri << ". Open connections now: " <<
 210                theBusyConns + theIdleConns->count() << ", including " <<
 211                theIdleConns->count() << " idle persistent connections.");
 212         connOverloadReported = true;
 213     }
 214
 215     if (cfg().onOverload == srvForce)
 216         return -1;
 217
 218     return available;
 219 }
 220
 221 // The number of connections which excess the Max-Connections limit
 222 int Adaptation::Icap::ServiceRep::excessConnections() const
 223 {
 224     if (theMaxConnections < 0)
 225         return 0;
 226
 227     // Waiters affect the number of needed connections but a needed
 228     // connection may still be excessive from Max-Connections p.o.v.
 229     // so we should not account for waiting transaction needs here.
 230     const int debt =  theBusyConns + theIdleConns->count() - theMaxConnections;
 231     if (debt > 0)
 232         return debt;
 233     else
 234         return 0;
 235 }
 236
 237 void Adaptation::Icap::ServiceRep::noteGoneWaiter()
 238 {
 239     --theAllWaiters;
 240
 241     // in case the notified transaction did not take the connection slot
 242     busyCheckpoint();
 243 }
 244
 245 // called when a connection slot may become available
 246 void Adaptation::Icap::ServiceRep::busyCheckpoint()
 247 {
 248     if (theNotificationWaiters.empty()) // nobody is waiting for a slot
 249         return;
 250
 251     int freed = 0;
 252     int available = availableConnections();
 253
 254     if (available < 0) {
 255         // It is possible to have waiters when no limit on connections exist in
 256         // case of reconfigure or because new Options received.
 257         // In this case, notify all waiting transactions.
 258         freed  = theNotificationWaiters.size();
 259     } else {
 260         // avoid notifying more waiters than there will be available slots
 261         const int notifiedWaiters = theAllWaiters - theNotificationWaiters.size();
 262         freed = available - notifiedWaiters;
 263     }
 264
 265     debugs(93,7, "Available connections: " << available <<
 266            " freed slots: " << freed <<
 267            " waiting in queue: " << theNotificationWaiters.size());
 268
 269     while (freed > 0 && !theNotificationWaiters.empty()) {
 270         Client i = theNotificationWaiters.front();
 271         theNotificationWaiters.pop_front();
 272         ScheduleCallHere(i.callback);
 273         i.callback = nullptr;
 274         --freed;
 275     }
 276 }
 277
 278 void Adaptation::Icap::ServiceRep::suspend(const char *reason)
 279 {
 280     if (isSuspended) {
 281         debugs(93,4, "keeping suspended, also for " << reason);
 282     } else {
 283         isSuspended = reason;
 284         debugs(93, DBG_IMPORTANT, "suspending ICAP service for " << reason);
 285         scheduleUpdate(squid_curtime + TheConfig.service_revival_delay);
 286         announceStatusChange("suspended", true);
 287     }
 288 }
 289
 290 bool Adaptation::Icap::ServiceRep::probed() const
 291 {
 292     return theLastUpdate != 0;
 293 }
 294
 295 bool Adaptation::Icap::ServiceRep::hasOptions() const
 296 {
 297     return theOptions && theOptions->valid() && theOptions->fresh();
 298 }
 299
 300 bool Adaptation::Icap::ServiceRep::up() const
 301 {
 302     return !isSuspended && hasOptions();
 303 }
 304
 305 bool Adaptation::Icap::ServiceRep::availableForNew() const
 306 {
 307     Must(up());
 308     int available = availableConnections();
 309     if (available < 0)
 310         return true;
 311     else
 312         return (available - theAllWaiters > 0);
 313 }
 314
 315 bool Adaptation::Icap::ServiceRep::availableForOld() const
 316 {
 317     Must(up());
 318
 319     int available = availableConnections();
 320     return (available != 0); // it is -1 (no limit) or has available slots
 321 }
 322
 323 bool Adaptation::Icap::ServiceRep::wantsUrl(const SBuf &urlPath) const
 324 {
 325     Must(hasOptions());
 326     return theOptions->transferKind(urlPath) != Adaptation::Icap::Options::xferIgnore;
 327 }
 328
 329 bool Adaptation::Icap::ServiceRep::wantsPreview(const SBuf &urlPath, size_t &wantedSize) const
 330 {
 331     Must(hasOptions());
 332
 333     if (theOptions->preview < 0)
 334         return false;
 335
 336     if (theOptions->transferKind(urlPath) != Adaptation::Icap::Options::xferPreview)
 337         return false;
 338
 339     wantedSize = theOptions->preview;
 340
 341     return true;
 342 }
 343
 344 bool Adaptation::Icap::ServiceRep::allows204() const
 345 {
 346     Must(hasOptions());
 347     return true; // in the future, we may have ACLs to prevent 204s
 348 }
 349
 350 bool Adaptation::Icap::ServiceRep::allows206() const
 351 {
 352     Must(hasOptions());
 353     if (theOptions->allow206)
 354         return true; // in the future, we may have ACLs to prevent 206s
 355     return false;
 356 }
 357
 358 static
 359 void ServiceRep_noteTimeToUpdate(void *data)
 360 {
 361     Adaptation::Icap::ServiceRep *service = static_cast<Adaptation::Icap::ServiceRep*>(data);
 362     Must(service);
 363     service->noteTimeToUpdate();
 364 }
 365
 366 void Adaptation::Icap::ServiceRep::noteTimeToUpdate()
 367 {
 368     if (!detached())
 369         updateScheduled = false;
 370
 371     if (detached() || theOptionsFetcher.set()) {
 372         debugs(93,5, "ignores options update " << status());
 373         return;
 374     }
 375
 376     debugs(93,5, "performs a regular options update " << status());
 377     startGettingOptions();
 378 }
 379
 380 void Adaptation::Icap::ServiceRep::noteTimeToNotify()
 381 {
 382     Must(!notifying);
 383     notifying = true;
 384     debugs(93,7, "notifies " << theClients.size() << " clients " <<
 385            status());
 386
 387     // note: we must notify even if we are invalidated
 388
 389     Pointer us = nullptr;
 390
 391     while (!theClients.empty()) {
 392         Client i = theClients.back();
 393         theClients.pop_back();
 394         ScheduleCallHere(i.callback);
 395         i.callback = nullptr;
 396     }
 397
 398     notifying = false;
 399 }
 400
 401 void Adaptation::Icap::ServiceRep::callWhenAvailable(AsyncCall::Pointer &cb, bool priority)
 402 {
 403     debugs(93,8, "ICAPServiceRep::callWhenAvailable");
 404     Must(cb!=nullptr);
 405     Must(up());
 406     Must(!theIdleConns->count()); // or we should not be waiting
 407
 408     Client i;
 409     i.service = Pointer(this);
 410     i.callback = cb;
 411     if (priority)
 412         theNotificationWaiters.push_front(i);
 413     else
 414         theNotificationWaiters.push_back(i);
 415
 416     busyCheckpoint();
 417 }
 418
 419 void Adaptation::Icap::ServiceRep::callWhenReady(AsyncCall::Pointer &cb)
 420 {
 421     Must(cb!=nullptr);
 422
 423     debugs(93,5, "Adaptation::Icap::Service is asked to call " << *cb <<
 424            " when ready " << status());
 425
 426     Must(!broken()); // we do not wait for a broken service
 427
 428     Client i;
 429     i.service = Pointer(this); // TODO: is this really needed?
 430     i.callback = cb;
 431     theClients.push_back(i);
 432
 433     if (theOptionsFetcher.set() || notifying)
 434         return; // do nothing, we will be picked up in noteTimeToNotify()
 435
 436     if (needNewOptions())
 437         startGettingOptions();
 438     else
 439         scheduleNotification();
 440 }
 441
 442 void Adaptation::Icap::ServiceRep::scheduleNotification()
 443 {
 444     debugs(93,7, "will notify " << theClients.size() << " clients");
 445     CallJobHere(93, 5, this, Adaptation::Icap::ServiceRep, noteTimeToNotify);
 446 }
 447
 448 bool Adaptation::Icap::ServiceRep::needNewOptions() const
 449 {
 450     return !detached() && !up();
 451 }
 452
 453 void Adaptation::Icap::ServiceRep::changeOptions(Adaptation::Icap::Options *newOptions)
 454 {
 455     debugs(93,8, "changes options from " << theOptions << " to " <<
 456            newOptions << ' ' << status());
 457
 458     delete theOptions;
 459     theOptions = newOptions;
 460     theSessionFailures.clear();
 461     isSuspended = nullptr;
 462     theLastUpdate = squid_curtime;
 463
 464     checkOptions();
 465     announceStatusChange("down after an options fetch failure", true);
 466 }
 467
 468 void Adaptation::Icap::ServiceRep::checkOptions()
 469 {
 470     if (theOptions == nullptr)
 471         return;
 472
 473     if (!theOptions->valid()) {
 474         debugs(93, DBG_IMPORTANT, "WARNING: Squid got an invalid ICAP OPTIONS response " <<
 475                "from service " << cfg().uri << "; error: " << theOptions->error);
 476         return;
 477     }
 478
 479     /*
 480      * Issue a warning if the ICAP server returned methods in the
 481      * options response that don't match the method from squid.conf.
 482      */
 483
 484     if (!theOptions->methods.empty()) {
 485         bool method_found = false;
 486         String method_list;
 487         std::vector <ICAP::Method>::iterator iter = theOptions->methods.begin();
 488
 489         while (iter != theOptions->methods.end()) {
 490
 491             if (*iter == cfg().method) {
 492                 method_found = true;
 493                 break;
 494             }
 495
 496             method_list.append(ICAP::methodStr(*iter));
 497             method_list.append(" ", 1);
 498             ++iter;
 499         }
 500
 501         if (!method_found) {
 502             debugs(93, DBG_IMPORTANT, "WARNING: Squid is configured to use ICAP method " <<
 503                    cfg().methodStr() <<
 504                    " for service " << cfg().uri <<
 505                    " but OPTIONS response declares the methods are " << method_list);
 506         }
 507     }
 508
 509     /*
 510      *  Check the ICAP server's date header for clock skew
 511      */
 512     const int skew = (int)(theOptions->timestamp() - squid_curtime);
 513     if (abs(skew) > theOptions->ttl()) {
 514         // TODO: If skew is negative, the option will be considered down
 515         // because of stale options. We should probably change this.
 516         debugs(93, DBG_IMPORTANT, "ICAP service's clock is skewed by " << skew <<
 517                " seconds: " << cfg().uri);
 518     }
 519 }
 520
 521 void Adaptation::Icap::ServiceRep::announceStatusChange(const char *downPhrase, bool important) const
 522 {
 523     if (wasAnnouncedUp == up()) // no significant changes to announce
 524         return;
 525
 526     const char *what = cfg().bypass ? "optional" : "essential";
 527     const char *state = wasAnnouncedUp ? downPhrase : "up";
 528     const int level = important ? 1 :2;
 529     debugs(93,level, what << " ICAP service is " << state << ": " <<
 530            cfg().uri << ' ' << status());
 531
 532     wasAnnouncedUp = !wasAnnouncedUp;
 533 }
 534
 535 // we are receiving ICAP OPTIONS response headers here or NULL on failures
 536 void Adaptation::Icap::ServiceRep::noteAdaptationAnswer(const Answer &answer)
 537 {
 538     Must(initiated(theOptionsFetcher));
 539     clearAdaptation(theOptionsFetcher);
 540
 541     if (answer.kind == Answer::akError) {
 542         debugs(93,3, "failed to fetch options " << status());
 543         handleNewOptions(nullptr);
 544         return;
 545     }
 546
 547     Must(answer.kind == Answer::akForward); // no akBlock for OPTIONS requests
 548     const Http::Message *msg = answer.message.getRaw();
 549     Must(msg);
 550
 551     debugs(93,5, "is interpreting new options " << status());
 552
 553     Adaptation::Icap::Options *newOptions = nullptr;
 554     if (const HttpReply *r = dynamic_cast<const HttpReply*>(msg)) {
 555         newOptions = new Adaptation::Icap::Options;
 556         newOptions->configure(r);
 557     } else {
 558         debugs(93, DBG_IMPORTANT, "ICAP service got wrong options message " << status());
 559     }
 560
 561     handleNewOptions(newOptions);
 562 }
 563
 564 // we (a) must keep trying to get OPTIONS and (b) are RefCounted so we
 565 // must keep our job alive (XXX: until nobody needs us)
 566 void Adaptation::Icap::ServiceRep::callException(const std::exception &e)
 567 {
 568     clearAdaptation(theOptionsFetcher);
 569     debugs(93,2, "ICAP probably failed to fetch options (" << e.what() <<
 570            ")" << status());
 571     handleNewOptions(nullptr);
 572 }
 573
 574 void Adaptation::Icap::ServiceRep::handleNewOptions(Adaptation::Icap::Options *newOptions)
 575 {
 576     // new options may be NULL
 577     changeOptions(newOptions);
 578
 579     debugs(93,3, "got new options and is now " << status());
 580
 581     scheduleUpdate(optionsFetchTime());
 582
 583     // XXX: this whole feature bases on the false assumption a service only has one IP
 584     setMaxConnections();
 585     const int excess = excessConnections();
 586     // if we owe connections and have idle pconns, close the latter
 587     if (excess && theIdleConns->count() > 0) {
 588         const int n = min(excess, theIdleConns->count());
 589         debugs(93,5, "closing " << n << " pconns to relief debt");
 590         theIdleConns->closeN(n);
 591     }
 592
 593     scheduleNotification();
 594 }
 595
 596 void Adaptation::Icap::ServiceRep::startGettingOptions()
 597 {
 598     Must(!theOptionsFetcher);
 599     debugs(93,6, "will get new options " << status());
 600
 601     // XXX: "this" here is "self"; works until refcounting API changes
 602     theOptionsFetcher = initiateAdaptation(
 603                             new Adaptation::Icap::OptXactLauncher(this));
 604     // TODO: timeout in case Adaptation::Icap::OptXact never calls us back?
 605     // Such a timeout should probably be a generic AsyncStart feature.
 606 }
 607
 608 void Adaptation::Icap::ServiceRep::scheduleUpdate(time_t when)
 609 {
 610     if (updateScheduled) {
 611         debugs(93,7, "reschedules update");
 612         // XXX: check whether the event is there because AR saw
 613         // an unreproducible eventDelete assertion on 2007/06/18
 614         if (eventFind(&ServiceRep_noteTimeToUpdate, this))
 615             eventDelete(&ServiceRep_noteTimeToUpdate, this);
 616         else
 617             debugs(93, DBG_IMPORTANT, "ERROR: Squid BUG: ICAP service lost an update event.");
 618         updateScheduled = false;
 619     }
 620
 621     debugs(93,7, "raw OPTIONS fetch at " << when << " or in " <<
 622            (when - squid_curtime) << " sec");
 623     debugs(93,9, "last fetched at " << theLastUpdate << " or " <<
 624            (squid_curtime - theLastUpdate) << " sec ago");
 625
 626     /* adjust update time to prevent too-frequent updates */
 627
 628     if (when < squid_curtime)
 629         when = squid_curtime;
 630
 631     // XXX: move hard-coded constants from here to Adaptation::Icap::TheConfig
 632     const int minUpdateGap = 30; // seconds
 633     if (when < theLastUpdate + minUpdateGap)
 634         when = theLastUpdate + minUpdateGap;
 635
 636     const int delay = when - squid_curtime;
 637     debugs(93,5, "will fetch OPTIONS in " << delay << " sec");
 638
 639     eventAdd("Adaptation::Icap::ServiceRep::noteTimeToUpdate",
 640              &ServiceRep_noteTimeToUpdate, this, delay, 0, true);
 641     updateScheduled = true;
 642 }
 643
 644 // returns absolute time when OPTIONS should be fetched
 645 time_t
 646 Adaptation::Icap::ServiceRep::optionsFetchTime() const
 647 {
 648     if (theOptions && theOptions->valid()) {
 649         const time_t expire = theOptions->expire();
 650         debugs(93,7, "options expire on " << expire << " >= " << squid_curtime);
 651
 652         // conservative estimate of how long the OPTIONS transaction will take
 653         // XXX: move hard-coded constants from here to Adaptation::Icap::TheConfig
 654         const int expectedWait = 20; // seconds
 655
 656         // Unknown or invalid (too small) expiration times should not happen.
 657         // Adaptation::Icap::Options should use the default TTL, and ICAP servers should not
 658         // send invalid TTLs, but bugs and attacks happen.
 659         if (expire < expectedWait)
 660             return squid_curtime;
 661         else
 662             return expire - expectedWait; // before the current options expire
 663     }
 664
 665     // use revival delay as "expiration" time for a service w/o valid options
 666     return squid_curtime + TheConfig.service_revival_delay;
 667 }
 668
 669 Adaptation::Initiate *
 670 Adaptation::Icap::ServiceRep::makeXactLauncher(Http::Message *virgin,
 671         HttpRequest *cause, AccessLogEntry::Pointer &alp)
 672 {
 673     return new Adaptation::Icap::ModXactLauncher(virgin, cause, alp, this);
 674 }
 675
 676 // returns a temporary string depicting service status, for debugging
 677 const char *Adaptation::Icap::ServiceRep::status() const
 678 {
 679     static MemBuf buf;
 680
 681     buf.reset();
 682     buf.append("[", 1);
 683
 684     if (up())
 685         buf.append("up", 2);
 686     else {
 687         buf.append("down", 4);
 688         if (isSuspended)
 689             buf.append(",susp", 5);
 690
 691         if (!theOptions)
 692             buf.append(",!opt", 5);
 693         else if (!theOptions->valid())
 694             buf.append(",!valid", 7);
 695         else if (!theOptions->fresh())
 696             buf.append(",stale", 6);
 697     }
 698
 699     if (detached())
 700         buf.append(",detached", 9);
 701
 702     if (theOptionsFetcher.set())
 703         buf.append(",fetch", 6);
 704
 705     if (notifying)
 706         buf.append(",notif", 6);
 707
 708     if (const int failures = theSessionFailures.remembered())
 709         buf.appendf(",fail%d", failures);
 710
 711     buf.append("]", 1);
 712     buf.terminate();
 713
 714     return buf.content();
 715 }
 716
 717 void Adaptation::Icap::ServiceRep::detach()
 718 {
 719     debugs(93,3, "detaching ICAP service: " << cfg().uri <<
 720            ' ' << status());
 721     isDetached = true;
 722 }
 723
 724 bool Adaptation::Icap::ServiceRep::detached() const
 725 {
 726     return isDetached;
 727 }
 728
 729 Adaptation::Icap::ConnWaiterDialer::ConnWaiterDialer(const CbcPointer<Adaptation::Icap::ModXact> &xact,
 730         Adaptation::Icap::ConnWaiterDialer::Parent::Method aHandler):
 731     Parent(xact, aHandler)
 732 {
 733     theService = &xact->service();
 734     theService->noteNewWaiter();
 735 }
 736
 737 Adaptation::Icap::ConnWaiterDialer::ConnWaiterDialer(const Adaptation::Icap::ConnWaiterDialer &aConnWaiter): Parent(aConnWaiter)
 738 {
 739     theService = aConnWaiter.theService;
 740     theService->noteNewWaiter();
 741 }
 742
 743 Adaptation::Icap::ConnWaiterDialer::~ConnWaiterDialer()
 744 {
 745     theService->noteGoneWaiter();
 746 }
 747