src/mgr/QueryParams.cc

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