]> git.stg.codes - stg.git/blob - stargazer/plugins/other/radius/conn.cpp
a209409ba95e36f1e490d03217c0211b70ea3733
[stg.git] / stargazer / plugins / other / radius / conn.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 "conn.h"
22
23 #include "radius.h"
24 #include "config.h"
25
26 #include "stg/json_parser.h"
27 #include "stg/json_generator.h"
28 #include "stg/users.h"
29 #include "stg/user.h"
30 #include "stg/logger.h"
31 #include "stg/common.h"
32
33 #include <yajl/yajl_gen.h>
34
35 #include <map>
36 #include <stdexcept>
37 #include <cstring>
38 #include <cerrno>
39
40 #include <unistd.h>
41 #include <sys/types.h>
42 #include <sys/socket.h>
43
44 using STG::Conn;
45 using STG::Config;
46 using STG::JSON::Parser;
47 using STG::JSON::PairsParser;
48 using STG::JSON::EnumParser;
49 using STG::JSON::NodeParser;
50 using STG::JSON::Gen;
51 using STG::JSON::MapGen;
52 using STG::JSON::StringGen;
53
54 namespace
55 {
56
57 double CONN_TIMEOUT = 60;
58 double PING_TIMEOUT = 10;
59
60 enum Packet
61 {
62     PING,
63     PONG,
64     DATA
65 };
66
67 enum Stage
68 {
69     AUTHORIZE,
70     AUTHENTICATE,
71     PREACCT,
72     ACCOUNTING,
73     POSTAUTH
74 };
75
76 std::map<std::string, Packet> packetCodes;
77 std::map<std::string, Stage> stageCodes;
78
79 class PacketParser : public EnumParser<Packet>
80 {
81     public:
82         PacketParser(NodeParser* next, Packet& packet, std::string& packetStr)
83             : EnumParser(next, packet, packetStr, packetCodes)
84         {
85             if (!packetCodes.empty())
86                 return;
87             packetCodes["ping"] = PING;
88             packetCodes["pong"] = PONG;
89             packetCodes["data"] = DATA;
90         }
91 };
92
93 class StageParser : public EnumParser<Stage>
94 {
95     public:
96         StageParser(NodeParser* next, Stage& stage, std::string& stageStr)
97             : EnumParser(next, stage, stageStr, stageCodes)
98         {
99             if (!stageCodes.empty())
100                 return;
101             stageCodes["authorize"] = AUTHORIZE;
102             stageCodes["authenticate"] = AUTHENTICATE;
103             stageCodes["preacct"] = PREACCT;
104             stageCodes["accounting"] = ACCOUNTING;
105             stageCodes["postauth"] = POSTAUTH;
106         }
107 };
108
109 class TopParser : public NodeParser
110 {
111     public:
112         typedef void (*Callback) (void* /*data*/);
113         TopParser(Callback callback, void* data)
114             : m_packetParser(this, m_packet, m_packetStr),
115               m_stageParser(this, m_stage, m_stageStr),
116               m_pairsParser(this, m_data),
117               m_callback(callback), m_callbackData(data)
118         {}
119
120         virtual NodeParser* parseStartMap() { return this; }
121         virtual NodeParser* parseMapKey(const std::string& value)
122         {
123             std::string key = ToLower(value);
124
125             if (key == "packet")
126                 return &m_packetParser;
127             else if (key == "stage")
128                 return &m_stageParser;
129             else if (key == "pairs")
130                 return &m_pairsParser;
131
132             return this;
133         }
134         virtual NodeParser* parseEndMap() { m_callback(m_callbackData); return this; }
135
136         const std::string& packetStr() const { return m_packetStr; }
137         Packet packet() const { return m_packet; }
138         const std::string& stageStr() const { return m_stageStr; }
139         Stage stage() const { return m_stage; }
140         const Config::Pairs& data() const { return m_data; }
141
142     private:
143         std::string m_packetStr;
144         Packet m_packet;
145         std::string m_stageStr;
146         Stage m_stage;
147         Config::Pairs m_data;
148
149         PacketParser m_packetParser;
150         StageParser m_stageParser;
151         PairsParser m_pairsParser;
152
153         Callback m_callback;
154         void* m_callbackData;
155 };
156
157 class ProtoParser : public Parser
158 {
159     public:
160         ProtoParser(TopParser::Callback callback, void* data)
161             : Parser( &m_topParser ),
162               m_topParser(callback, data)
163         {}
164
165         const std::string& packetStr() const { return m_topParser.packetStr(); }
166         Packet packet() const { return m_topParser.packet(); }
167         const std::string& stageStr() const { return m_topParser.stageStr(); }
168         Stage stage() const { return m_topParser.stage(); }
169         const Config::Pairs& data() const { return m_topParser.data(); }
170
171     private:
172         TopParser m_topParser;
173 };
174
175 class PacketGen : public Gen
176 {
177     public:
178         PacketGen(const std::string& type)
179             : m_type(type)
180         {
181             m_gen.add("packet", m_type);
182         }
183         void run(yajl_gen_t* handle) const
184         {
185             m_gen.run(handle);
186         }
187         PacketGen& add(const std::string& key, const std::string& value)
188         {
189             m_gen.add(key, new StringGen(value));
190             return *this;
191         }
192         PacketGen& add(const std::string& key, MapGen* map)
193         {
194             m_gen.add(key, map);
195             return *this;
196         }
197         PacketGen& add(const std::string& key, MapGen& map)
198         {
199             m_gen.add(key, map);
200             return *this;
201         }
202     private:
203         MapGen m_gen;
204         StringGen m_type;
205 };
206
207 std::string toString(Config::ReturnCode code)
208 {
209     switch (code)
210     {
211         case Config::REJECT:   return "reject";
212         case Config::FAIL:     return "fail";
213         case Config::OK:       return "ok";
214         case Config::HANDLED:  return "handled";
215         case Config::INVALID:  return "invalid";
216         case Config::USERLOCK: return "userlock";
217         case Config::NOTFOUND: return "notfound";
218         case Config::NOOP:     return "noop";
219         case Config::UPDATED:  return "noop";
220     }
221     return "reject";
222 }
223
224 }
225
226 class Conn::Impl
227 {
228     public:
229         Impl(USERS& users, PLUGIN_LOGGER& logger, RADIUS& plugin, const Config& config, int fd, const std::string& remote);
230         ~Impl();
231
232         int sock() const { return m_sock; }
233
234         bool read();
235         bool tick();
236
237         bool isOk() const { return m_ok; }
238
239     private:
240         USERS& m_users;
241         PLUGIN_LOGGER& m_logger;
242         RADIUS& m_plugin;
243         const Config& m_config;
244         int m_sock;
245         std::string m_remote;
246         bool m_ok;
247         time_t m_lastPing;
248         time_t m_lastActivity;
249         ProtoParser m_parser;
250         std::set<std::string> m_authorized;
251
252         template <typename T>
253         const T& stageMember(T Config::Section::* member) const
254         {
255             switch (m_parser.stage())
256             {
257                 case AUTHORIZE: return m_config.autz.*member;
258                 case AUTHENTICATE: return m_config.auth.*member;
259                 case POSTAUTH: return m_config.postauth.*member;
260                 case PREACCT: return m_config.preacct.*member;
261                 case ACCOUNTING: return m_config.acct.*member;
262             }
263             throw std::runtime_error("Invalid stage: '" + m_parser.stageStr() + "'.");
264         }
265
266         const Config::Pairs& match() const { return stageMember(&Config::Section::match); }
267         const Config::Pairs& modify() const { return stageMember(&Config::Section::modify); }
268         const Config::Pairs& reply() const { return stageMember(&Config::Section::reply); }
269         Config::ReturnCode returnCode() const { return stageMember(&Config::Section::returnCode); }
270         const Config::Authorize& authorize() const { return stageMember(&Config::Section::authorize); }
271
272         static void process(void* data);
273         void processPing();
274         void processPong();
275         void processData();
276         bool answer(const USER& user);
277         bool answerNo();
278         bool sendPing();
279         bool sendPong();
280
281         static bool write(void* data, const char* buf, size_t size);
282 };
283
284 Conn::Conn(USERS& users, PLUGIN_LOGGER& logger, RADIUS& plugin, const Config& config, int fd, const std::string& remote)
285     : m_impl(new Impl(users, logger, plugin, config, fd, remote))
286 {
287 }
288
289 Conn::~Conn()
290 {
291 }
292
293 int Conn::sock() const
294 {
295     return m_impl->sock();
296 }
297
298 bool Conn::read()
299 {
300     return m_impl->read();
301 }
302
303 bool Conn::tick()
304 {
305     return m_impl->tick();
306 }
307
308 bool Conn::isOk() const
309 {
310     return m_impl->isOk();
311 }
312
313 Conn::Impl::Impl(USERS& users, PLUGIN_LOGGER& logger, RADIUS& plugin, const Config& config, int fd, const std::string& remote)
314     : m_users(users),
315       m_logger(logger),
316       m_plugin(plugin),
317       m_config(config),
318       m_sock(fd),
319       m_remote(remote),
320       m_ok(true),
321       m_lastPing(time(NULL)),
322       m_lastActivity(m_lastPing),
323       m_parser(&Conn::Impl::process, this)
324 {
325 }
326
327 Conn::Impl::~Impl()
328 {
329     close(m_sock);
330
331     std::set<std::string>::const_iterator it = m_authorized.begin();
332     for (; it != m_authorized.end(); ++it)
333         m_plugin.unauthorize(*it, "Lost connection to RADIUS server " + m_remote + ".");
334 }
335
336 bool Conn::Impl::read()
337 {
338     static std::vector<char> buffer(1024);
339     ssize_t res = ::read(m_sock, buffer.data(), buffer.size());
340     if (res < 0)
341     {
342         m_logger("Failed to read data from '" + m_remote + "': " + strerror(errno));
343         m_ok = false;
344         return false;
345     }
346     printfd(__FILE__, "Read %d bytes.\n%s\n", res, std::string(buffer.data(), res).c_str());
347     m_lastActivity = time(NULL);
348     if (res == 0)
349     {
350         m_ok = false;
351         return true;
352     }
353     return m_parser.append(buffer.data(), res);
354 }
355
356 bool Conn::Impl::tick()
357 {
358     time_t now = time(NULL);
359     if (difftime(now, m_lastActivity) > CONN_TIMEOUT)
360     {
361         int delta = difftime(now, m_lastActivity);
362         printfd(__FILE__, "Connection to '%s' timed out: %d sec.\n", m_remote.c_str(), delta);
363         m_logger("Connection to " + m_remote + " timed out.");
364         m_ok = false;
365         return false;
366     }
367     if (difftime(now, m_lastPing) > PING_TIMEOUT)
368     {
369         int delta = difftime(now, m_lastPing);
370         printfd(__FILE__, "Ping timeout: %d sec. Sending ping...\n", delta);
371         sendPing();
372     }
373     return true;
374 }
375
376 void Conn::Impl::process(void* data)
377 {
378     Impl& impl = *static_cast<Impl*>(data);
379     try
380     {
381         switch (impl.m_parser.packet())
382         {
383             case PING:
384                 impl.processPing();
385                 return;
386             case PONG:
387                 impl.processPong();
388                 return;
389             case DATA:
390                 impl.processData();
391                 return;
392         }
393     }
394     catch (const std::exception& ex)
395     {
396         printfd(__FILE__, "Processing error. %s", ex.what());
397         impl.m_logger("Processing error. %s", ex.what());
398     }
399     printfd(__FILE__, "Received invalid packet type: '%s'.\n", impl.m_parser.packetStr().c_str());
400     impl.m_logger("Received invalid packet type: " + impl.m_parser.packetStr());
401 }
402
403 void Conn::Impl::processPing()
404 {
405     printfd(__FILE__, "Got ping. Sending pong...\n");
406     sendPong();
407 }
408
409 void Conn::Impl::processPong()
410 {
411     printfd(__FILE__, "Got pong.\n");
412     m_lastActivity = time(NULL);
413 }
414
415 void Conn::Impl::processData()
416 {
417     printfd(__FILE__, "Got data.\n");
418     int handle = m_users.OpenSearch();
419
420     USER_PTR user = NULL;
421     bool matched = false;
422     while (m_users.SearchNext(handle, &user) == 0)
423     {
424         if (user == NULL)
425             continue;
426
427         matched = true;
428         for (Config::Pairs::const_iterator it = match().begin(); it != match().end(); ++it)
429         {
430             Config::Pairs::const_iterator pos = m_parser.data().find(it->first);
431             if (pos == m_parser.data().end())
432             {
433                 matched = false;
434                 break;
435             }
436             if (user->GetParamValue(it->second) != pos->second)
437             {
438                 matched = false;
439                 break;
440             }
441         }
442         if (!matched)
443             continue;
444         answer(*user);
445         if (authorize().check(*user, m_parser.data()))
446         {
447             m_plugin.authorize(*user);
448             m_authorized.insert(user->GetLogin());
449         }
450         break;
451     }
452
453     if (!matched)
454         answerNo();
455
456     m_users.CloseSearch(handle);
457 }
458
459 bool Conn::Impl::answer(const USER& user)
460 {
461     printfd(__FILE__, "Got match. Sending answer...\n");
462     MapGen replyData;
463     for (Config::Pairs::const_iterator it = reply().begin(); it != reply().end(); ++it)
464         replyData.add(it->first, new StringGen(user.GetParamValue(it->second)));
465
466     MapGen modifyData;
467     for (Config::Pairs::const_iterator it = modify().begin(); it != modify().end(); ++it)
468         modifyData.add(it->first, new StringGen(user.GetParamValue(it->second)));
469
470     PacketGen gen("data");
471     gen.add("result", "ok")
472        .add("reply", replyData)
473        .add("modify", modifyData);
474
475     m_lastPing = time(NULL);
476
477     return generate(gen, &Conn::Impl::write, this);
478 }
479
480 bool Conn::Impl::answerNo()
481 {
482     printfd(__FILE__, "No match. Sending answer...\n");
483     PacketGen gen("data");
484     gen.add("result", "no");
485     gen.add("return_code", toString(returnCode()));
486
487     m_lastPing = time(NULL);
488
489     return generate(gen, &Conn::Impl::write, this);
490 }
491
492 bool Conn::Impl::sendPing()
493 {
494     PacketGen gen("ping");
495
496     m_lastPing = time(NULL);
497
498     return generate(gen, &Conn::Impl::write, this);
499 }
500
501 bool Conn::Impl::sendPong()
502 {
503     PacketGen gen("pong");
504
505     m_lastPing = time(NULL);
506
507     return generate(gen, &Conn::Impl::write, this);
508 }
509
510 bool Conn::Impl::write(void* data, const char* buf, size_t size)
511 {
512     std::string json(buf, size);
513     printfd(__FILE__, "Writing JSON:\n%s\n", json.c_str());
514     Conn::Impl& conn = *static_cast<Conn::Impl*>(data);
515     while (size > 0)
516     {
517         ssize_t res = ::send(conn.m_sock, buf, size, MSG_NOSIGNAL);
518         if (res < 0)
519         {
520             conn.m_logger("Failed to write pong to '" + conn.m_remote + "': " + strerror(errno));
521             conn.m_ok = false;
522             return false;
523         }
524         size -= res;
525     }
526     return true;
527 }