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