src/adaptation/Config.cc

   1 /*
   2  * Copyright (C) 1996-2018 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 #include "squid.h"
  10 #include "acl/FilledChecklist.h"
  11 #include "acl/Gadgets.h"
  12 #include "adaptation/AccessRule.h"
  13 #include "adaptation/Config.h"
  14 #include "adaptation/History.h"
  15 #include "adaptation/Service.h"
  16 #include "adaptation/ServiceGroups.h"
  17 #include "ConfigParser.h"
  18 #include "globals.h"
  19 #include "HttpReply.h"
  20 #include "HttpRequest.h"
  21 #include "Store.h"
  22
  23 #include <algorithm>
  24
  25 bool Adaptation::Config::Enabled = false;
  26 char *Adaptation::Config::masterx_shared_name = NULL;
  27 int Adaptation::Config::service_iteration_limit = 16;
  28 int Adaptation::Config::send_client_ip = false;
  29 int Adaptation::Config::send_username = false;
  30 int Adaptation::Config::use_indirect_client = true;
  31 const char *metasBlacklist[] = {
  32     "Methods",
  33     "Service",
  34     "ISTag",
  35     "Encapsulated",
  36     "Opt-body-type",
  37     "Max-Connections",
  38     "Options-TTL",
  39     "Date",
  40     "Service-ID",
  41     "Allow",
  42     "Preview",
  43     "Transfer-Preview",
  44     "Transfer-Ignore",
  45     "Transfer-Complete",
  46     NULL
  47 };
  48 Notes Adaptation::Config::metaHeaders("ICAP header", metasBlacklist);
  49 bool Adaptation::Config::needHistory = false;
  50
  51 Adaptation::ServiceConfig*
  52 Adaptation::Config::newServiceConfig() const
  53 {
  54     return new ServiceConfig();
  55 }
  56
  57 void
  58 Adaptation::Config::removeService(const String& service)
  59 {
  60     removeRule(service);
  61     const Groups& groups = AllGroups();
  62     for (unsigned int i = 0; i < groups.size(); ) {
  63         const ServiceGroupPointer group = groups[i];
  64         const ServiceGroup::Store& services = group->services;
  65         typedef ServiceGroup::Store::const_iterator SGSI;
  66         for (SGSI it = services.begin(); it != services.end(); ++it) {
  67             if (*it == service) {
  68                 group->removedServices.push_back(service);
  69                 ServiceGroup::Store::iterator newend;
  70                 newend = std::remove(group->services.begin(), group->services.end(), service);
  71                 group->services.resize(newend-group->services.begin());
  72                 debugs(93, 5, "adaptation service " << service <<
  73                        " removed from group " << group->id);
  74                 break;
  75             }
  76         }
  77         if (services.empty()) {
  78             removeRule(group->id);
  79             Groups::iterator newend;
  80             newend = std::remove(AllGroups().begin(), AllGroups().end(), group);
  81             AllGroups().resize(newend-AllGroups().begin());
  82         } else {
  83             ++i;
  84         }
  85     }
  86 }
  87
  88 Adaptation::ServiceConfigPointer
  89 Adaptation::Config::findServiceConfig(const String &service)
  90 {
  91     typedef ServiceConfigs::const_iterator SCI;
  92     const ServiceConfigs& configs = serviceConfigs;
  93     for (SCI cfg = configs.begin(); cfg != configs.end(); ++cfg) {
  94         if ((*cfg)->key == service)
  95             return *cfg;
  96     }
  97     return NULL;
  98 }
  99
 100 void
 101 Adaptation::Config::removeRule(const String& id)
 102 {
 103     typedef AccessRules::const_iterator ARI;
 104     const AccessRules& rules = AllRules();
 105     for (ARI it = rules.begin(); it != rules.end(); ++it) {
 106         AccessRule* rule = *it;
 107         if (rule->groupId == id) {
 108             debugs(93, 5, "removing access rules for:" << id);
 109             AccessRules::iterator newend;
 110             newend = std::remove(AllRules().begin(), AllRules().end(), rule);
 111             AllRules().resize(newend-AllRules().begin());
 112             delete (rule);
 113             break;
 114         }
 115     }
 116 }
 117
 118 void
 119 Adaptation::Config::clear()
 120 {
 121     debugs(93, 3, HERE << "rules: " << AllRules().size() << ", groups: " <<
 122            AllGroups().size() << ", services: " << serviceConfigs.size());
 123     typedef ServiceConfigs::const_iterator SCI;
 124     const ServiceConfigs& configs = serviceConfigs;
 125     for (SCI cfg = configs.begin(); cfg != configs.end(); ++cfg)
 126         removeService((*cfg)->key);
 127     serviceConfigs.clear();
 128     debugs(93, 3, HERE << "rules: " << AllRules().size() << ", groups: " <<
 129            AllGroups().size() << ", services: " << serviceConfigs.size());
 130 }
 131
 132 void
 133 Adaptation::Config::parseService()
 134 {
 135     ServiceConfigPointer cfg = newServiceConfig();
 136     if (!cfg->parse()) {
 137         fatalf("%s:%d: malformed adaptation service configuration",
 138                cfg_filename, config_lineno);
 139     }
 140     serviceConfigs.push_back(cfg);
 141 }
 142
 143 void
 144 Adaptation::Config::freeService()
 145 {
 146     FreeAccess();
 147     FreeServiceGroups();
 148
 149     DetachServices();
 150
 151     serviceConfigs.clear();
 152 }
 153
 154 void
 155 Adaptation::Config::dumpService(StoreEntry *entry, const char *name) const
 156 {
 157     typedef Services::iterator SCI;
 158     for (SCI i = AllServices().begin(); i != AllServices().end(); ++i) {
 159         const ServiceConfig &cfg = (*i)->cfg();
 160         bool isEcap = cfg.protocol.caseCmp("ecap") == 0;
 161         bool isIcap = !isEcap;
 162         const char *optConnectionEncryption = "";
 163         // Print connections_encrypted option if no default value is used
 164         if (cfg.secure.encryptTransport && !cfg.connectionEncryption)
 165             optConnectionEncryption = " connection-encryption=off";
 166         else if (isEcap && !cfg.connectionEncryption)
 167             optConnectionEncryption = " connection-encryption=off";
 168         else if (isIcap && !cfg.secure.encryptTransport && cfg.connectionEncryption)
 169             optConnectionEncryption = " connection-encryption=on";
 170
 171         storeAppendPrintf(entry, "%s " SQUIDSTRINGPH " %s_%s %d " SQUIDSTRINGPH "%s\n",
 172                           name,
 173                           SQUIDSTRINGPRINT(cfg.key),
 174                           cfg.methodStr(), cfg.vectPointStr(), cfg.bypass,
 175                           SQUIDSTRINGPRINT(cfg.uri),
 176
 177                           optConnectionEncryption);
 178     }
 179 }
 180
 181 bool
 182 Adaptation::Config::finalize()
 183 {
 184     if (!onoff) {
 185         clear();
 186         return false;
 187     }
 188
 189     // create service reps from service configs
 190     int created = 0;
 191
 192     typedef ServiceConfigs::const_iterator VISCI;
 193     const ServiceConfigs &configs = serviceConfigs;
 194     for (VISCI i = configs.begin(); i != configs.end(); ++i) {
 195         const ServiceConfigPointer cfg = *i;
 196         if (FindService(cfg->key) != NULL) {
 197             debugs(93, DBG_CRITICAL, "ERROR: Duplicate adaptation service name: " <<
 198                    cfg->key);
 199             continue; // TODO: make fatal
 200         }
 201         ServicePointer s = createService(cfg);
 202         if (s != NULL) {
 203             AllServices().push_back(s);
 204             ++created;
 205         }
 206     }
 207
 208     debugs(93,3, HERE << "Created " << created << " adaptation services");
 209
 210     // services remember their configs; we do not have to
 211     serviceConfigs.clear();
 212     return true;
 213 }
 214
 215 // poor man for_each
 216 template <class Collection>
 217 static void
 218 FinalizeEach(Collection &collection, const char *label)
 219 {
 220     typedef typename Collection::iterator CI;
 221     for (CI i = collection.begin(); i != collection.end(); ++i)
 222         (*i)->finalize();
 223
 224     debugs(93,2, HERE << "Initialized " << collection.size() << ' ' << label);
 225 }
 226
 227 void
 228 Adaptation::Config::Finalize(bool enabled)
 229 {
 230     Enabled = enabled;
 231     debugs(93, DBG_IMPORTANT, "Adaptation support is " << (Enabled ? "on" : "off."));
 232
 233     FinalizeEach(AllServices(), "message adaptation services");
 234     FinalizeEach(AllGroups(), "message adaptation service groups");
 235     FinalizeEach(AllRules(), "message adaptation access rules");
 236 }
 237
 238 void
 239 Adaptation::Config::ParseServiceSet()
 240 {
 241     Adaptation::Config::ParseServiceGroup(new ServiceSet);
 242 }
 243
 244 void
 245 Adaptation::Config::ParseServiceChain()
 246 {
 247     Adaptation::Config::ParseServiceGroup(new ServiceChain);
 248 }
 249
 250 void
 251 Adaptation::Config::ParseServiceGroup(ServiceGroupPointer g)
 252 {
 253     assert(g != NULL);
 254     g->parse();
 255     AllGroups().push_back(g);
 256 }
 257
 258 void
 259 Adaptation::Config::FreeServiceGroups()
 260 {
 261     while (!AllGroups().empty()) {
 262         // groups are refcounted so we do not explicitly delete them
 263         AllGroups().pop_back();
 264     }
 265 }
 266
 267 void
 268 Adaptation::Config::DumpServiceGroups(StoreEntry *entry, const char *name)
 269 {
 270     typedef Groups::iterator GI;
 271     for (GI i = AllGroups().begin(); i != AllGroups().end(); ++i)
 272         storeAppendPrintf(entry, "%s " SQUIDSTRINGPH "\n", name, SQUIDSTRINGPRINT((*i)->id));
 273 }
 274
 275 void
 276 Adaptation::Config::ParseAccess(ConfigParser &parser)
 277 {
 278     String groupId = ConfigParser::NextToken();
 279     AccessRule *r;
 280     if (!(r=FindRuleByGroupId(groupId))) {
 281         r = new AccessRule(groupId);
 282         AllRules().push_back(r);
 283     }
 284     r->parse(parser);
 285 }
 286
 287 void
 288 Adaptation::Config::FreeAccess()
 289 {
 290     while (!AllRules().empty()) {
 291         delete AllRules().back();
 292         AllRules().pop_back();
 293     }
 294 }
 295
 296 void
 297 Adaptation::Config::DumpAccess(StoreEntry *entry, const char *name)
 298 {
 299     LOCAL_ARRAY(char, nom, 64);
 300
 301     typedef AccessRules::iterator CI;
 302     for (CI i = AllRules().begin(); i != AllRules().end(); ++i) {
 303         snprintf(nom, 64, "%s " SQUIDSTRINGPH, name, SQUIDSTRINGPRINT((*i)->groupId));
 304         dump_acl_access(entry, nom, (*i)->acl);
 305     }
 306 }
 307
 308 Adaptation::Config::Config() :
 309     onoff(0), service_failure_limit(0), oldest_service_failure(0),
 310     service_revival_delay(0)
 311 {}
 312
 313 // XXX: this is called for ICAP and eCAP configs, but deals mostly
 314 // with global arrays shared by those individual configs
 315 Adaptation::Config::~Config()
 316 {
 317     freeService();
 318 }
 319