src/mgr/QueryParams.cc

   1 /*
   2  * Copyright (C) 1996-2020 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 16    Cache Manager API */
  10
  11 #include "squid.h"
  12 #include "base/TextException.h"
  13 #include "ipc/TypedMsgHdr.h"
  14 #include "mgr/IntParam.h"
  15 #include "mgr/QueryParams.h"
  16 #include "mgr/StringParam.h"
  17
  18 Mgr::QueryParam::Pointer
  19 Mgr::QueryParams::get(const String& name) const
  20 {
  21     Must(name.size() != 0);
  22     Params::const_iterator pos = find(name);
  23     return (pos == params.end() ? NULL : pos->second);
  24 }
  25
  26 void
  27 Mgr::QueryParams::pack(Ipc::TypedMsgHdr& msg) const
  28 {
  29     msg.putInt(params.size());
  30     for (Params::const_iterator iter = params.begin(); iter != params.end(); ++iter) {
  31         Must(iter->first.size() != 0);
  32         msg.putString(iter->first);
  33         Must(iter->second != NULL);
  34         iter->second->pack(msg);
  35     }
  36 }
  37
  38 void
  39 Mgr::QueryParams::unpack(const Ipc::TypedMsgHdr& msg)
  40 {
  41     int count = msg.getInt();
  42     Must(count >= 0);
  43     params.clear();
  44     for ( ; count > 0; --count) {
  45         String name;
  46         msg.getString(name);
  47         Must(name.size() != 0);
  48         QueryParam::Type type;
  49         msg.getPod(type);
  50         QueryParam::Pointer value = CreateParam(type);
  51         value->unpackValue(msg);
  52         params.push_back(Param(name, value));
  53     }
  54 }
  55
  56 Mgr::QueryParams::Params::const_iterator
  57 Mgr::QueryParams::find(const String& name) const
  58 {
  59     Must(name.size() != 0);
  60     Params::const_iterator iter = params.begin();
  61     for ( ; iter != params.end(); ++iter) {
  62         if (name.caseCmp(iter->first) == 0)
  63             break;
  64     }
  65     return iter;
  66 }
  67
  68 bool
  69 Mgr::QueryParams::ParseParam(const String& paramStr, Param& param)
  70 {
  71     bool parsed = false;
  72     regmatch_t pmatch[3];
  73     regex_t intExpr;
  74     regcomp(&intExpr, "^([a-z][a-z0-9_]*)=([0-9]+((,[0-9]+))*)$", REG_EXTENDED | REG_ICASE);
  75     regex_t stringExpr;
  76     regcomp(&stringExpr, "^([a-z][a-z0-9_]*)=([^&= ]+)$", REG_EXTENDED | REG_ICASE);
  77     if (regexec(&intExpr, paramStr.termedBuf(), 3, pmatch, 0) == 0) {
  78         param.first = paramStr.substr(pmatch[1].rm_so, pmatch[1].rm_eo);
  79         std::vector<int> array;
  80         int n = pmatch[2].rm_so;
  81         for (int i = n; i < pmatch[2].rm_eo; ++i) {
  82             if (paramStr[i] == ',') {
  83                 array.push_back(atoi(paramStr.substr(n, i).termedBuf()));
  84                 n = i + 1;
  85             }
  86         }
  87         if (n < pmatch[2].rm_eo)
  88             array.push_back(atoi(paramStr.substr(n, pmatch[2].rm_eo).termedBuf()));
  89         param.second = new IntParam(array);
  90         parsed = true;
  91     } else if (regexec(&stringExpr, paramStr.termedBuf(), 3, pmatch, 0) == 0) {
  92         param.first = paramStr.substr(pmatch[1].rm_so, pmatch[1].rm_eo);
  93         param.second = new StringParam(paramStr.substr(pmatch[2].rm_so, pmatch[2].rm_eo));
  94         parsed = true;
  95     }
  96     regfree(&stringExpr);
  97     regfree(&intExpr);
  98     return parsed;
  99 }
 100
 101 bool
 102 Mgr::QueryParams::Parse(const String& aParamsStr, QueryParams& aParams)
 103 {
 104     if (aParamsStr.size() != 0) {
 105         Param param;
 106         size_t n = 0;
 107         size_t len = aParamsStr.size();
 108         for (size_t i = n; i < len; ++i) {
 109             if (aParamsStr[i] == '&') {
 110                 if (!ParseParam(aParamsStr.substr(n, i), param))
 111                     return false;
 112                 aParams.params.push_back(param);
 113                 n = i + 1;
 114             }
 115         }
 116         if (n < len) {
 117             if (!ParseParam(aParamsStr.substr(n, len), param))
 118                 return false;
 119             aParams.params.push_back(param);
 120         }
 121     }
 122     return true;
 123 }
 124
 125 Mgr::QueryParam::Pointer
 126 Mgr::QueryParams::CreateParam(QueryParam::Type aType)
 127 {
 128     switch (aType) {
 129     case QueryParam::ptInt:
 130         return new IntParam();
 131
 132     case QueryParam::ptString:
 133         return new StringParam();
 134
 135     default:
 136         throw TexcHere("unknown parameter type");
 137         break;
 138     }
 139     return NULL;
 140 }
 141