]> git.stg.codes - stg.git/blob - stargazer/plugins/other/radius/config.cpp
Remove useles cast.
[stg.git] / stargazer / plugins / other / radius / config.cpp
1 /*
2  *    This program is free software; you can redistribute it and/or modify
3  *    it under the terms of the GNU General Public License as published by
4  *    the Free Software Foundation; either version 2 of the License, or
5  *    (at your option) any later version.
6  *
7  *    This program is distributed in the hope that it will be useful,
8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  *    GNU General Public License for more details.
11  *
12  *    You should have received a copy of the GNU General Public License
13  *    along with this program; if not, write to the Free Software
14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
15  */
16
17 /*
18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
19  */
20
21 #include "config.h"
22
23 #include "stg/user.h"
24 #include "stg/common.h"
25
26 #include <vector>
27 #include <stdexcept>
28
29 #include <strings.h> // strncasecmp
30
31 using STG::Config;
32
33 namespace
34 {
35
36 struct ParserError : public std::runtime_error
37 {
38     ParserError(const std::string& message)
39         : runtime_error("Config is not valid. " + message),
40           position(0),
41           error(message)
42     {}
43     ParserError(size_t pos, const std::string& message)
44         : runtime_error("Parsing error at position " + std::to_string(pos) + ". " + message),
45           position(pos),
46           error(message)
47     {}
48
49     size_t position;
50     std::string error;
51 };
52
53 size_t skipSpaces(const std::string& value, size_t start)
54 {
55     while (start < value.length() && std::isspace(value[start]))
56         ++start;
57     return start;
58 }
59
60 size_t checkChar(const std::string& value, size_t start, char ch)
61 {
62     if (start >= value.length())
63         throw ParserError(start, "Unexpected end of string. Expected '" + std::string(1, ch) + "'.");
64     if (value[start] != ch)
65         throw ParserError(start, "Expected '" + std::string(1, ch) + "', got '" + std::string(1, value[start]) + "'.");
66     return start + 1;
67 }
68
69 std::pair<size_t, std::string> readString(const std::string& value, size_t start)
70 {
71     std::string dest;
72     while (start < value.length() && !std::isspace(value[start]) &&
73            value[start] != ',' && value[start] != '(' && value[start] != ')')
74         dest.push_back(value[start++]);
75     if (dest.empty()) {
76         if (start == value.length())
77             throw ParserError(start, "Unexpected end of string. Expected string.");
78         else
79             throw ParserError(start, "Unexpected whitespace. Expected string.");
80     }
81     return std::make_pair(start, dest);
82 }
83
84 Config::Pairs toPairs(const std::vector<std::string>& values)
85 {
86     if (values.empty())
87         return Config::Pairs();
88     std::string value(values[0]);
89     Config::Pairs res;
90     size_t start = 0;
91     while (start < value.size()) {
92         Config::Pair pair;
93         start = skipSpaces(value, start);
94         if (!res.empty())
95         {
96             start = checkChar(value, start, ',');
97             start = skipSpaces(value, start);
98         }
99         size_t pairStart = start;
100         start = checkChar(value, start, '(');
101         const std::pair<size_t, std::string> key = readString(value, start);
102         start = key.first;
103         pair.first = key.second;
104         start = skipSpaces(value, start);
105         start = checkChar(value, start, ',');
106         start = skipSpaces(value, start);
107         const std::pair<size_t, std::string> val = readString(value, start);
108         start = val.first;
109         pair.second = val.second;
110         start = skipSpaces(value, start);
111         start = checkChar(value, start, ')');
112         if (res.find(pair.first) != res.end())
113             throw ParserError(pairStart, "Duplicate field.");
114         res.insert(pair);
115     }
116     return res;
117 }
118
119 bool toBool(const std::vector<std::string>& values)
120 {
121     if (values.empty())
122         return false;
123     std::string value(values[0]);
124     return strncasecmp(value.c_str(), "yes", 3) == 0;
125 }
126
127 std::string toString(const std::vector<std::string>& values)
128 {
129     if (values.empty())
130         return "";
131     return values[0];
132 }
133
134 uid_t toUID(const std::vector<std::string>& values)
135 {
136     if (values.empty())
137         return -1;
138     uid_t res = str2uid(values[0]);
139     if (res == static_cast<uid_t>(-1))
140         throw ParserError("Invalid user name: '" + values[0] + "'");
141     return res;
142 }
143
144 gid_t toGID(const std::vector<std::string>& values)
145 {
146     if (values.empty())
147         return -1;
148     gid_t res = str2gid(values[0]);
149     if (res == static_cast<gid_t>(-1))
150         throw ParserError("Invalid group name: '" + values[0] + "'");
151     return res;
152 }
153
154 mode_t toMode(const std::vector<std::string>& values)
155 {
156     if (values.empty())
157         return -1;
158     mode_t res = str2mode(values[0]);
159     if (res == static_cast<mode_t>(-1))
160         throw ParserError("Invalid mode: '" + values[0] + "'");
161     return res;
162 }
163
164 template <typename T>
165 T toInt(const std::vector<std::string>& values)
166 {
167     if (values.empty())
168         return 0;
169     T res = 0;
170     if (str2x(values[0], res) == 0)
171         return res;
172     return 0;
173 }
174
175 uint16_t toPort(const std::string& value)
176 {
177     if (value.empty())
178         return 0;
179     uint16_t res = 0;
180     if (str2x(value, res) == 0)
181         return res;
182     throw ParserError("'" + value + "' is not a valid port number.");
183 }
184
185 typedef std::map<std::string, Config::ReturnCode> Codes;
186
187 // One-time call to initialize the list of codes.
188 Codes getCodes()
189 {
190     Codes res;
191     res["reject"]   = Config::REJECT;
192     res["fail"]     = Config::FAIL;
193     res["ok"]       = Config::OK;
194     res["handled"]  = Config::HANDLED;
195     res["invalid"]  = Config::INVALID;
196     res["userlock"] = Config::USERLOCK;
197     res["notfound"] = Config::NOTFOUND;
198     res["noop"]     = Config::NOOP;
199     res["updated"]  = Config::UPDATED;
200     return res;
201 }
202
203 Config::ReturnCode toReturnCode(const std::vector<std::string>& values)
204 {
205     static Codes codes(getCodes());
206     if (values.empty())
207         return Config::REJECT;
208     std::string code = ToLower(values[0]);
209     const Codes::const_iterator it = codes.find(code);
210     if (it == codes.end())
211         return Config::REJECT;
212     return it->second;
213 }
214
215 Config::Pairs parseVector(const std::string& paramName, const std::vector<STG::ParamValue>& params)
216 {
217     for (size_t i = 0; i < params.size(); ++i)
218         if (params[i].param == paramName)
219             return toPairs(params[i].value);
220     return Config::Pairs();
221 }
222
223 Config::Authorize parseAuthorize(const std::string& paramName, const std::vector<STG::ParamValue>& params)
224 {
225     for (size_t i = 0; i < params.size(); ++i)
226         if (params[i].param == paramName)
227             return Config::Authorize(toPairs(params[i].value));
228     return Config::Authorize();
229 }
230
231 Config::ReturnCode parseReturnCode(const std::string& paramName, const std::vector<STG::ParamValue>& params)
232 {
233     for (size_t i = 0; i < params.size(); ++i)
234         if (params[i].param == paramName)
235             return toReturnCode(params[i].value);
236     return Config::REJECT;
237 }
238
239 bool parseBool(const std::string& paramName, const std::vector<STG::ParamValue>& params)
240 {
241     for (size_t i = 0; i < params.size(); ++i)
242         if (params[i].param == paramName)
243             return toBool(params[i].value);
244     return false;
245 }
246
247 std::string parseString(const std::string& paramName, const std::vector<STG::ParamValue>& params)
248 {
249     for (size_t i = 0; i < params.size(); ++i)
250         if (params[i].param == paramName)
251             return toString(params[i].value);
252     return "";
253 }
254
255 std::string parseAddress(Config::Type connectionType, const std::string& value)
256 {
257     size_t pos = value.find_first_of(':');
258     if (pos == std::string::npos)
259         throw ParserError("Connection type is not specified. Should be either 'unix' or 'tcp'.");
260     if (connectionType == Config::UNIX)
261         return value.substr(pos + 1);
262     std::string address(value.substr(pos + 1));
263     pos = address.find_first_of(':', pos + 1);
264     if (pos == std::string::npos)
265         throw ParserError("Port is not specified.");
266     return address.substr(0, pos - 1);
267 }
268
269 std::string parsePort(Config::Type connectionType, const std::string& value)
270 {
271     size_t pos = value.find_first_of(':');
272     if (pos == std::string::npos)
273         throw ParserError("Connection type is not specified. Should be either 'unix' or 'tcp'.");
274     if (connectionType == Config::UNIX)
275         return "";
276     std::string address(value.substr(pos + 1));
277     pos = address.find_first_of(':', pos + 1);
278     if (pos == std::string::npos)
279         throw ParserError("Port is not specified.");
280     return address.substr(pos + 1);
281 }
282
283 Config::Type parseConnectionType(const std::string& address)
284 {
285     size_t pos = address.find_first_of(':');
286     if (pos == std::string::npos)
287         throw ParserError("Connection type is not specified. Should be either 'unix' or 'tcp'.");
288     std::string type = ToLower(address.substr(0, pos));
289     if (type == "unix")
290         return Config::UNIX;
291     else if (type == "tcp")
292         return Config::TCP;
293     throw ParserError("Invalid connection type. Should be either 'unix' or 'tcp', got '" + type + "'");
294 }
295
296 Config::Section parseSection(const std::string& paramName, const std::vector<STG::ParamValue>& params)
297 {
298     for (size_t i = 0; i < params.size(); ++i)
299         if (params[i].param == paramName)
300             return Config::Section(parseVector("match", params[i].sections),
301                                    parseVector("modify", params[i].sections),
302                                    parseVector("reply", params[i].sections),
303                                    parseReturnCode("no_match", params[i].sections),
304                                    parseAuthorize("authorize", params[i].sections));
305     return Config::Section();
306 }
307
308 uid_t parseUID(const std::string& paramName, const std::vector<STG::ParamValue>& params)
309 {
310     for (size_t i = 0; i < params.size(); ++i)
311         if (params[i].param == paramName)
312             return toUID(params[i].value);
313     return -1;
314 }
315
316 gid_t parseGID(const std::string& paramName, const std::vector<STG::ParamValue>& params)
317 {
318     for (size_t i = 0; i < params.size(); ++i)
319         if (params[i].param == paramName)
320             return toGID(params[i].value);
321     return -1;
322 }
323
324 mode_t parseMode(const std::string& paramName, const std::vector<STG::ParamValue>& params)
325 {
326     for (size_t i = 0; i < params.size(); ++i)
327         if (params[i].param == paramName)
328             return toMode(params[i].value);
329     return -1;
330 }
331
332 } // namespace anonymous
333
334 bool Config::Authorize::check(const User& user, const Config::Pairs& radiusData) const
335 {
336     if (!m_auth)
337         return false; // No flag - no authorization.
338
339     if (m_cond.empty())
340         return true; // Empty parameter - always authorize.
341
342     Config::Pairs::const_iterator it = m_cond.begin();
343     for (; it != m_cond.end(); ++it)
344     {
345         const Config::Pairs::const_iterator pos = radiusData.find(it->first);
346         if (pos == radiusData.end())
347             return false; // No required Radius parameter.
348         if (user.GetParamValue(it->second) != pos->second)
349             return false; // No match with the user.
350     }
351
352     return true;
353 }
354
355 Config::Config(const ModuleSettings& settings)
356     : autz(parseSection("autz", settings.moduleParams)),
357       auth(parseSection("auth", settings.moduleParams)),
358       postauth(parseSection("postauth", settings.moduleParams)),
359       preacct(parseSection("preacct", settings.moduleParams)),
360       acct(parseSection("acct", settings.moduleParams)),
361       verbose(parseBool("verbose", settings.moduleParams)),
362       address(parseString("bind_address", settings.moduleParams)),
363       connectionType(parseConnectionType(address)),
364       bindAddress(parseAddress(connectionType, address)),
365       portStr(parsePort(connectionType, address)),
366       port(toPort(portStr)),
367       key(parseString("key", settings.moduleParams)),
368       sockUID(parseUID("sock_owner", settings.moduleParams)),
369       sockGID(parseGID("sock_group", settings.moduleParams)),
370       sockMode(parseMode("sock_mode", settings.moduleParams))
371 {
372     size_t count = 0;
373     if (autz.authorize.exists())
374         ++count;
375     if (auth.authorize.exists())
376         ++count;
377     if (postauth.authorize.exists())
378         ++count;
379     if (preacct.authorize.exists())
380         ++count;
381     if (acct.authorize.exists())
382         ++count;
383     if (count > 0)
384         throw ParserError("Authorization flag is specified in more than one section.");
385 }