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