]> git.stg.codes - stg.git/blob - projects/rlm_stg/stg_client.cpp
399b971d8a7f76b6fc84103db6c4d5b815bc75f0
[stg.git] / projects / rlm_stg / stg_client.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 "stg_client.h"
22
23 #include "stg/json_parser.h"
24 #include "stg/json_generator.h"
25 #include "stg/common.h"
26
27 #include <map>
28 #include <utility>
29 #include <cerrno>
30 #include <cstring>
31
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <sys/un.h> // UNIX
35 #include <netinet/in.h> // IP
36 #include <netinet/tcp.h> // TCP
37 #include <netdb.h>
38
39 using STG::JSON::Parser;
40 using STG::JSON::PairsParser;
41 using STG::JSON::EnumParser;
42 using STG::JSON::NodeParser;
43 using STG::JSON::Gen;
44 using STG::JSON::MapGen;
45 using STG::JSON::StringGen;
46
47 namespace {
48
49 double CONN_TIMEOUT = 5;
50 double PING_TIMEOUT = 1;
51
52 STG_CLIENT* stgClient = NULL;
53
54 std::string toStage(STG_CLIENT::TYPE type)
55 {
56     switch (type)
57     {
58         case STG_CLIENT::AUTHORIZE: return "authorize";
59         case STG_CLIENT::AUTHENTICATE: return "authenticate";
60         case STG_CLIENT::POST_AUTH: return "postauth";
61         case STG_CLIENT::PRE_ACCT: return "preacct";
62         case STG_CLIENT::ACCOUNT: return "accounting";
63     }
64     return "";
65 }
66
67 enum Packet
68 {
69     PING,
70     PONG,
71     DATA
72 };
73
74 std::map<std::string, Packet> packetCodes;
75 std::map<std::string, bool> resultCodes;
76
77 class PacketParser : public EnumParser<Packet>
78 {
79     public:
80         PacketParser(NodeParser* next, Packet& packet, std::string& packetStr)
81             : EnumParser(next, packet, packetStr, packetCodes)
82         {
83             if (!packetCodes.empty())
84                 return;
85             packetCodes["ping"] = PING;
86             packetCodes["pong"] = PONG;
87             packetCodes["data"] = DATA;
88         }
89 };
90
91 class ResultParser : public EnumParser<bool>
92 {
93     public:
94         ResultParser(NodeParser* next, bool& result, std::string& resultStr)
95             : EnumParser(next, result, resultStr, resultCodes)
96         {
97             if (!resultCodes.empty())
98                 return;
99             resultCodes["no"] = false;
100             resultCodes["ok"] = true;
101         }
102 };
103
104 class TopParser : public NodeParser
105 {
106     public:
107         TopParser()
108             : m_packetParser(this, m_packet, m_packetStr),
109               m_resultParser(this, m_result, m_resultStr),
110               m_replyParser(this, m_reply),
111               m_modifyParser(this, m_modify)
112         {}
113
114         virtual NodeParser* parseStartMap() { return this; }
115         virtual NodeParser* parseMapKey(const std::string& value)
116         {
117             std::string key = ToLower(value);
118
119             if (key == "packet")
120                 return &m_packetParser;
121             else if (key == "result")
122                 return &m_resultParser;
123             else if (key == "reply")
124                 return &m_replyParser;
125             else if (key == "modify")
126                 return &m_modifyParser;
127
128             return this;
129         }
130         virtual NodeParser* parseEndMap() { return this; }
131
132         const std::string& packetStr() const { return m_packetStr; }
133         Packet packet() const { return m_packet; }
134         const std::string& resultStr() const { return m_resultStr; }
135         bool result() const { return m_result; }
136         const PairsParser::Pairs& reply() const { return m_reply; }
137         const PairsParser::Pairs& modify() const { return m_modify; }
138
139     private:
140         std::string m_packetStr;
141         Packet m_packet;
142         std::string m_resultStr;
143         bool m_result;
144         PairsParser::Pairs m_reply;
145         PairsParser::Pairs m_modify;
146
147         PacketParser m_packetParser;
148         ResultParser m_resultParser;
149         PairsParser m_replyParser;
150         PairsParser m_modifyParser;
151 };
152
153 class ProtoParser : public Parser
154 {
155     public:
156         ProtoParser() : Parser( &m_topParser ) {}
157
158         const std::string& packetStr() const { return m_topParser.packetStr(); }
159         Packet packet() const { return m_topParser.packet(); }
160         const std::string& resultStr() const { return m_topParser.resultStr(); }
161         bool result() const { return m_topParser.result(); }
162         const PairsParser::Pairs& reply() const { return m_topParser.reply(); }
163         const PairsParser::Pairs& modify() const { return m_topParser.modify(); }
164
165     private:
166         TopParser m_topParser;
167 };
168
169 class PacketGen : public Gen
170 {
171     public:
172         PacketGen(const std::string& type)
173             : m_type(type)
174         {
175             m_gen.add("packet", m_type);
176         }
177         void run(yajl_gen_t* handle) const
178         {
179             m_gen.run(handle);
180         }
181         PacketGen& add(const std::string& key, const std::string& value)
182         {
183             m_gen.add(key, new StringGen(value));
184             return *this;
185         }
186         PacketGen& add(const std::string& key, MapGen* map)
187         {
188             m_gen.add(key, map);
189             return *this;
190         }
191     private:
192         MapGen m_gen;
193         StringGen m_type;
194 };
195
196 }
197
198 class STG_CLIENT::Impl
199 {
200 public:
201     Impl(const std::string& address, Callback callback, void* data);
202     ~Impl();
203
204     bool stop();
205
206     bool request(TYPE type, const std::string& userName, const std::string& password, const PAIRS& pairs);
207
208 private:
209     ChannelConfig m_config;
210
211     int m_sock;
212
213     bool m_running;
214     bool m_stopped;
215
216     time_t m_lastPing;
217     time_t m_lastActivity;
218
219     pthread_t m_thread;
220     pthread_mutex_t m_mutex;
221
222     Callback m_callback;
223     void* m_data;
224
225     ProtoParser m_parser;
226
227     void m_writeHeader(TYPE type, const std::string& userName, const std::string& password);
228     void m_writePairBlock(const PAIRS& source);
229     PAIRS m_readPairBlock();
230
231     static void* run(void* );
232
233     void runImpl();
234
235     int connect();
236     int connectTCP();
237     int connectUNIX();
238
239     bool read();
240     bool tick();
241
242     bool process();
243     bool processPing();
244     bool processPong();
245     bool processData();
246     bool sendPing();
247     bool sendPong();
248
249     static bool write(void* data, const char* buf, size_t size);
250 };
251
252 ChannelConfig::ChannelConfig(std::string addr)
253 {
254     // unix:pass@/var/run/stg.sock
255     // tcp:secret@192.168.0.1:12345
256     // udp:key@isp.com.ua:54321
257
258     size_t pos = addr.find_first_of(':');
259     if (pos == std::string::npos)
260         throw Error("Missing transport name.");
261     transport = ToLower(addr.substr(0, pos));
262     addr = addr.substr(pos + 1);
263     if (addr.empty())
264         throw Error("Missing address to connect to.");
265     pos = addr.find_first_of('@');
266     if (pos != std::string::npos) {
267         key = addr.substr(0, pos);
268         addr = addr.substr(pos + 1);
269         if (addr.empty())
270             throw Error("Missing address to connect to.");
271     }
272     if (transport == "unix")
273     {
274         address = addr;
275         return;
276     }
277     pos = addr.find_first_of(':');
278     if (pos == std::string::npos)
279         throw Error("Missing port.");
280     address = addr.substr(0, pos);
281     portStr = addr.substr(pos + 1);
282     if (str2x(portStr, port))
283         throw Error("Invalid port value.");
284 }
285
286 STG_CLIENT::STG_CLIENT(const std::string& address, Callback callback, void* data)
287     : m_impl(new Impl(address, callback, data))
288 {
289 }
290
291 STG_CLIENT::~STG_CLIENT()
292 {
293 }
294
295 bool STG_CLIENT::stop()
296 {
297     return m_impl->stop();
298 }
299
300 bool STG_CLIENT::request(TYPE type, const std::string& userName, const std::string& password, const PAIRS& pairs)
301 {
302     return m_impl->request(type, userName, password, pairs);
303 }
304
305 STG_CLIENT* STG_CLIENT::get()
306 {
307     return stgClient;
308 }
309
310 bool STG_CLIENT::configure(const std::string& address, Callback callback, void* data)
311 {
312     if ( stgClient != NULL && stgClient->stop() )
313         delete stgClient;
314     try {
315         stgClient = new STG_CLIENT(address, callback, data);
316         return true;
317     } catch (const ChannelConfig::Error& ex) {
318         // TODO: Log it
319     }
320     return false;
321 }
322
323 STG_CLIENT::Impl::Impl(const std::string& address, Callback callback, void* data)
324     : m_config(address),
325       m_sock(connect()),
326       m_running(false),
327       m_stopped(true),
328       m_lastPing(time(NULL)),
329       m_lastActivity(m_lastPing),
330       m_callback(callback),
331       m_data(data)
332 {
333     int res = pthread_create(&m_thread, NULL, run, this);
334     if (res != 0)
335         throw Error("Failed to create thread: " + std::string(strerror(errno)));
336 }
337
338 STG_CLIENT::Impl::~Impl()
339 {
340     stop();
341     shutdown(m_sock, SHUT_RDWR);
342     close(m_sock);
343 }
344
345 bool STG_CLIENT::Impl::stop()
346 {
347     if (m_stopped)
348         return true;
349
350     m_running = false;
351
352     for (size_t i = 0; i < 25 && !m_stopped; i++) {
353         struct timespec ts = {0, 200000000};
354         nanosleep(&ts, NULL);
355     }
356
357     if (m_stopped) {
358         pthread_join(m_thread, NULL);
359         return true;
360     }
361
362     return false;
363 }
364
365 bool STG_CLIENT::Impl::request(TYPE type, const std::string& userName, const std::string& password, const PAIRS& pairs)
366 {
367     boost::scoped_ptr<MapGen> map(new MapGen);
368     for (PAIRS::const_iterator it = pairs.begin(); it != pairs.end(); ++it)
369         map->add(it->first, new StringGen(it->second));
370     map->add("Radius-Username", new StringGen(userName));
371     map->add("Radius-Userpass", new StringGen(password));
372
373     PacketGen gen("data");
374     gen.add("stage", toStage(type))
375        .add("pairs", map.get());
376
377     m_lastPing = time(NULL);
378
379     return generate(gen, &STG_CLIENT::Impl::write, this);
380 }
381
382 void STG_CLIENT::Impl::runImpl()
383 {
384     m_running = true;
385
386     while (m_running) {
387         fd_set fds;
388
389         FD_ZERO(&fds);
390         FD_SET(m_sock, &fds);
391
392         struct timeval tv;
393         tv.tv_sec = 0;
394         tv.tv_usec = 500000;
395
396         int res = select(m_sock + 1, &fds, NULL, NULL, &tv);
397         if (res < 0)
398         {
399             //m_error = std::string("'select' is failed: '") + strerror(errno) + "'.";
400             //m_logger(m_error);
401             break;
402         }
403
404         if (!m_running)
405             break;
406
407         if (res > 0)
408         {
409             if (FD_ISSET(m_sock, &fds))
410                 m_running = read();
411         }
412         else
413             m_running = tick();
414     }
415
416     m_stopped = true;
417 }
418
419 int STG_CLIENT::Impl::connect()
420 {
421     if (m_config.transport == "tcp")
422         return connectTCP();
423     else if (m_config.transport == "unix")
424         return connectUNIX();
425     throw Error("Invalid transport type: '" + m_config.transport + "'. Should be 'tcp' or 'unix'.");
426 }
427
428 int STG_CLIENT::Impl::connectTCP()
429 {
430     addrinfo hints;
431     memset(&hints, 0, sizeof(addrinfo));
432
433     hints.ai_family = AF_INET;       /* Allow IPv4 */
434     hints.ai_socktype = SOCK_STREAM; /* Stream socket */
435     hints.ai_flags = 0;     /* For wildcard IP address */
436     hints.ai_protocol = 0;           /* Any protocol */
437     hints.ai_canonname = NULL;
438     hints.ai_addr = NULL;
439     hints.ai_next = NULL;
440
441     addrinfo* ais = NULL;
442     int res = getaddrinfo(m_config.address.c_str(), m_config.portStr.c_str(), &hints, &ais);
443     if (res != 0)
444         throw Error("Error resolvin address '" + m_config.address + "': " + gai_strerror(res));
445
446     for (addrinfo* ai = ais; ai != NULL; ai = ai->ai_next)
447     {
448         int fd = socket(AF_INET, SOCK_STREAM, 0);
449         if (fd == -1)
450         {
451             Error error(std::string("Error creating TCP socket: ") + strerror(errno));
452             freeaddrinfo(ais);
453             throw error;
454         }
455         if (::connect(fd, ai->ai_addr, ai->ai_addrlen) == -1)
456         {
457             shutdown(fd, SHUT_RDWR);
458             close(fd);
459             // TODO: log it.
460             continue;
461         }
462         freeaddrinfo(ais);
463         return fd;
464     }
465
466     freeaddrinfo(ais);
467
468     throw Error("Failed to resolve '" + m_config.address);
469 };
470
471 int STG_CLIENT::Impl::connectUNIX()
472 {
473     int fd = socket(AF_UNIX, SOCK_STREAM, 0);
474     if (fd == -1)
475         throw Error(std::string("Error creating UNIX socket: ") + strerror(errno));
476     struct sockaddr_un addr;
477     memset(&addr, 0, sizeof(addr));
478     addr.sun_family = AF_UNIX;
479     strncpy(addr.sun_path, m_config.address.c_str(), m_config.address.length());
480     if (::connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) == -1)
481     {
482         Error error(std::string("Error binding UNIX socket: ") + strerror(errno));
483         shutdown(fd, SHUT_RDWR);
484         close(fd);
485         throw error;
486     }
487     return fd;
488 }
489
490 bool STG_CLIENT::Impl::read()
491 {
492     static std::vector<char> buffer(1024);
493     ssize_t res = ::read(m_sock, buffer.data(), buffer.size());
494     if (res < 0)
495     {
496         //m_logger("Failed to read data from '" + m_remote + "': " + strerror(errno));
497         return false;
498     }
499     m_lastActivity = time(NULL);
500     if (res == 0)
501     {
502         if (!m_parser.done())
503         {
504             //m_logger("Failed to read data from '" + m_remote + "': " + strerror(errno));
505             return false;
506         }
507         return process();
508     }
509     return m_parser.append(buffer.data(), res);
510 }
511
512 bool STG_CLIENT::Impl::tick()
513 {
514     time_t now = time(NULL);
515     if (difftime(now, m_lastActivity) > CONN_TIMEOUT)
516     {
517         //m_logger("Connection to " + m_remote + " timed out.");
518         return false;
519     }
520     if (difftime(now, m_lastPing) > PING_TIMEOUT)
521         sendPing();
522     return true;
523 }
524
525 bool STG_CLIENT::Impl::process()
526 {
527     switch (m_parser.packet())
528     {
529         case PING:
530             return processPing();
531         case PONG:
532             return processPong();
533         case DATA:
534             return processData();
535     }
536     //m_logger("Received invalid packet type: " + m_parser.packetStr());
537     return false;
538 }
539
540 bool STG_CLIENT::Impl::processPing()
541 {
542     return sendPong();
543 }
544
545 bool STG_CLIENT::Impl::processPong()
546 {
547     m_lastActivity = time(NULL);
548     return true;
549 }
550
551 bool STG_CLIENT::Impl::processData()
552 {
553     RESULT result;
554     for (PairsParser::Pairs::const_iterator it = m_parser.reply().begin(); it != m_parser.reply().end(); ++it)
555         result.reply.push_back(std::make_pair(it->first, it->second));
556     for (PairsParser::Pairs::const_iterator it = m_parser.modify().begin(); it != m_parser.modify().end(); ++it)
557         result.modify.push_back(std::make_pair(it->first, it->second));
558     return m_callback(m_data, result);
559 }
560
561 bool STG_CLIENT::Impl::sendPing()
562 {
563     PacketGen gen("ping");
564
565     m_lastPing = time(NULL);
566
567     return generate(gen, &STG_CLIENT::Impl::write, this);
568 }
569
570 bool STG_CLIENT::Impl::sendPong()
571 {
572     PacketGen gen("pong");
573
574     m_lastPing = time(NULL);
575
576     return generate(gen, &STG_CLIENT::Impl::write, this);
577 }
578
579 bool STG_CLIENT::Impl::write(void* data, const char* buf, size_t size)
580 {
581     STG_CLIENT::Impl& impl = *static_cast<STG_CLIENT::Impl*>(data);
582     while (size > 0)
583     {
584         ssize_t res = ::write(impl.m_sock, buf, size);
585         if (res < 0)
586         {
587             //conn.m_logger("Failed to write pong to '" + conn.m_remote + "': " + strerror(errno));
588             return false;
589         }
590         size -= res;
591     }
592     return true;
593 }
594
595 void* STG_CLIENT::Impl::run(void* data)
596 {
597     Impl& impl = *static_cast<Impl*>(data);
598     impl.runImpl();
599     return NULL;
600 }