src/ssl/ErrorDetailManager.cc

   1 /*
   2  * Copyright (C) 1996-2021 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 "ErrorDetail.h"
  11 #include "ErrorDetailManager.h"
  12 #include "errorpage.h"
  13 #include "http/ContentLengthInterpreter.h"
  14 #include "mime_header.h"
  15
  16 void Ssl::errorDetailInitialize()
  17 {
  18     Ssl::ErrorDetailsManager::GetInstance();
  19 }
  20
  21 void Ssl::errorDetailClean()
  22 {
  23     Ssl::ErrorDetailsManager::Shutdown();
  24 }
  25
  26 namespace Ssl
  27 {
  28
  29 /// manages error detail templates
  30 class ErrorDetailFile : public TemplateFile
  31 {
  32 public:
  33     explicit ErrorDetailFile(ErrorDetailsList::Pointer const details): TemplateFile("error-details.txt", ERR_NONE) {
  34         theDetails = details;
  35     }
  36
  37 private:
  38     ErrorDetailsList::Pointer  theDetails;
  39     virtual bool parse() override;
  40 };
  41 }// namespace Ssl
  42
  43 /******************/
  44 bool
  45 Ssl::ErrorDetailsList::getRecord(Security::ErrorCode value, ErrorDetailEntry &entry)
  46 {
  47     const ErrorDetails::const_iterator it = theList.find(value);
  48     if (it != theList.end()) {
  49         entry.error_no =  it->second.error_no;
  50         entry.name =  it->second.name;
  51         entry.detail =  it->second.detail;
  52         entry.descr =  it->second.descr;
  53         return true;
  54     }
  55     return false;
  56 }
  57
  58 const char *
  59 Ssl::ErrorDetailsList::getErrorDescr(Security::ErrorCode value)
  60 {
  61     const ErrorDetails::const_iterator it = theList.find(value);
  62     if (it != theList.end()) {
  63         return it->second.descr.termedBuf();
  64     }
  65
  66     return NULL;
  67 }
  68
  69 const char *
  70 Ssl::ErrorDetailsList::getErrorDetail(Security::ErrorCode value)
  71 {
  72     const ErrorDetails::const_iterator it = theList.find(value);
  73     if (it != theList.end()) {
  74         return it->second.detail.termedBuf();
  75     }
  76
  77     return NULL;
  78 }
  79
  80 Ssl::ErrorDetailsManager *Ssl::ErrorDetailsManager::TheDetailsManager = NULL;
  81
  82 Ssl::ErrorDetailsManager &Ssl::ErrorDetailsManager::GetInstance()
  83 {
  84     if (!TheDetailsManager)
  85         TheDetailsManager = new Ssl::ErrorDetailsManager;
  86
  87     assert(TheDetailsManager);
  88     return *TheDetailsManager;
  89 }
  90
  91 void Ssl::ErrorDetailsManager::Shutdown()
  92 {
  93     delete TheDetailsManager;
  94     TheDetailsManager = NULL;
  95 }
  96
  97 Ssl::ErrorDetailsManager::ErrorDetailsManager()
  98 {
  99     theDefaultErrorDetails = new ErrorDetailsList();
 100     ErrorDetailFile detailTmpl(theDefaultErrorDetails);
 101     detailTmpl.loadDefault();
 102 }
 103
 104 Ssl::ErrorDetailsList::Pointer Ssl::ErrorDetailsManager::getCachedDetails(const char *lang)
 105 {
 106     Cache::iterator it;
 107     it = cache.find(lang);
 108     if (it != cache.end()) {
 109         debugs(83, 8, HERE << "Found template details in cache for language: " << lang);
 110         return it->second;
 111     }
 112
 113     return NULL;
 114 }
 115
 116 void Ssl::ErrorDetailsManager::cacheDetails(ErrorDetailsList::Pointer &errorDetails)
 117 {
 118     const char *lang = errorDetails->errLanguage.termedBuf();
 119     assert(lang);
 120     if (cache.find(lang) == cache.end())
 121         cache[lang] = errorDetails;
 122 }
 123
 124 bool
 125 Ssl::ErrorDetailsManager::getErrorDetail(Security::ErrorCode value, const HttpRequest::Pointer &request, ErrorDetailEntry &entry)
 126 {
 127 #if USE_ERR_LOCALES
 128     String hdr;
 129     if (request != NULL && request->header.getList(Http::HdrType::ACCEPT_LANGUAGE, &hdr)) {
 130         ErrorDetailsList::Pointer errDetails = NULL;
 131         //Try to retrieve from cache
 132         size_t pos = 0;
 133         char lang[256];
 134         // Get the first ellement of the Accept-Language header
 135         strHdrAcptLangGetItem(hdr, lang, 256, pos);
 136         errDetails = getCachedDetails(lang); // search in cache
 137
 138         if (!errDetails) { // Else try to load from disk
 139             debugs(83, 8, HERE << "Creating new ErrDetailList to read from disk");
 140             errDetails = new ErrorDetailsList();
 141             ErrorDetailFile detailTmpl(errDetails);
 142             if (detailTmpl.loadFor(request.getRaw())) {
 143                 if (detailTmpl.language()) {
 144                     debugs(83, 8, HERE << "Found details on disk for language " << detailTmpl.language());
 145                     errDetails->errLanguage = detailTmpl.language();
 146                     cacheDetails(errDetails);
 147                 }
 148             }
 149         }
 150
 151         if (errDetails != NULL && errDetails->getRecord(value, entry))
 152             return true;
 153     }
 154 #endif
 155
 156     // else try the default
 157     if (theDefaultErrorDetails->getRecord(value, entry)) {
 158         debugs(83, 8, HERE << "Found default details record for error: " << GetErrorName(value));
 159         return true;
 160     }
 161
 162     return false;
 163 }
 164
 165 const char *
 166 Ssl::ErrorDetailsManager::getDefaultErrorDescr(Security::ErrorCode value)
 167 {
 168     return theDefaultErrorDetails->getErrorDescr(value);
 169 }
 170
 171 const char *
 172 Ssl::ErrorDetailsManager::getDefaultErrorDetail(Security::ErrorCode value)
 173 {
 174     return theDefaultErrorDetails->getErrorDetail(value);
 175 }
 176
 177 // Use HttpHeaders parser to parse error-details.txt files
 178 class DetailEntryParser: public HttpHeader
 179 {
 180 public:
 181     DetailEntryParser():HttpHeader(hoErrorDetail) {}
 182 };
 183
 184 //The end of an error detrail entry is a double "\n". The headersEnd
 185 // functions can detect it
 186 inline size_t detailEntryEnd(const char *s, size_t len) {return headersEnd(s, len);}
 187
 188 bool
 189 Ssl::ErrorDetailFile::parse()
 190 {
 191     if (!theDetails)
 192         return false;
 193
 194     auto buf = template_;
 195     buf.append("\n\n"); // ensure detailEntryEnd() finds the last entry
 196
 197     while (const auto size = detailEntryEnd(buf.rawContent(), buf.length())) {
 198         auto *s = buf.c_str();
 199         const auto e = s + size;
 200
 201         //ignore spaces, new lines and comment lines (starting with #) at the beginning
 202         for (; (*s == '\n' || *s == ' '  || *s == '\t' || *s == '#')  && s < e; ++s) {
 203             if (*s == '#')
 204                 while (s<e &&  *s != '\n')
 205                     ++s; // skip until the end of line
 206         }
 207
 208         if ( s != e) {
 209             DetailEntryParser parser;
 210             Http::ContentLengthInterpreter interpreter;
 211             // no applyStatusCodeRules() -- error templates lack HTTP status code
 212             if (!parser.parse(s, e - s, interpreter)) {
 213                 debugs(83, DBG_IMPORTANT, HERE <<
 214                        "WARNING! parse error on:" << s);
 215                 return false;
 216             }
 217
 218             const String errorName = parser.getByName("name");
 219             if (!errorName.size()) {
 220                 debugs(83, DBG_IMPORTANT, HERE <<
 221                        "WARNING! invalid or no error detail name on:" << s);
 222                 return false;
 223             }
 224
 225             Security::ErrorCode ssl_error = Ssl::GetErrorCode(errorName.termedBuf());
 226             if (ssl_error != SSL_ERROR_NONE) {
 227
 228                 if (theDetails->getErrorDetail(ssl_error)) {
 229                     debugs(83, DBG_IMPORTANT, HERE <<
 230                            "WARNING! duplicate entry: " << errorName);
 231                     return false;
 232                 }
 233
 234                 ErrorDetailEntry &entry = theDetails->theList[ssl_error];
 235                 entry.error_no = ssl_error;
 236                 entry.name = errorName;
 237                 String tmp = parser.getByName("detail");
 238                 const int detailsParseOk = httpHeaderParseQuotedString(tmp.termedBuf(), tmp.size(), &entry.detail);
 239                 tmp = parser.getByName("descr");
 240                 const int descrParseOk = httpHeaderParseQuotedString(tmp.termedBuf(), tmp.size(), &entry.descr);
 241                 // TODO: Validate "descr" and "detail" field values.
 242
 243                 if (!detailsParseOk || !descrParseOk) {
 244                     debugs(83, DBG_IMPORTANT, HERE <<
 245                            "WARNING! missing important field for detail error: " <<  errorName);
 246                     return false;
 247                 }
 248
 249             } else if (!Ssl::ErrorIsOptional(errorName.termedBuf())) {
 250                 debugs(83, DBG_IMPORTANT, HERE <<
 251                        "WARNING! invalid error detail name: " << errorName);
 252                 return false;
 253             }
 254
 255         }// else {only spaces and black lines; just ignore}
 256
 257         buf.consume(size);
 258     }
 259     debugs(83, 9, Raw("unparsed data", buf.rawContent(), buf.length()));
 260     return true;
 261 }
 262