stargazer/plugins/other/radius/radius.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 "radius.h"
  22
  23 #include "stg/store.h"
  24 #include "stg/users.h"
  25 #include "stg/user.h"
  26 #include "stg/common.h"
  27
  28 #include <algorithm>
  29 #include <stdexcept>
  30 #include <csignal>
  31 #include <cerrno>
  32 #include <cstring>
  33
  34 #include <sys/types.h>
  35 #include <sys/socket.h>
  36 #include <sys/un.h> // UNIX
  37 #include <netinet/in.h> // IP
  38 #include <netinet/tcp.h> // TCP
  39 #include <netdb.h>
  40
  41 using STG::Config;
  42 using STG::Conn;
  43
  44 extern "C" STG::Plugin* GetPlugin()
  45 {
  46     static RADIUS plugin;
  47     return &plugin;
  48 }
  49
  50 RADIUS::RADIUS()
  51     : m_running(false),
  52       m_stopped(true),
  53       m_users(NULL),
  54       m_store(NULL),
  55       m_listenSocket(0),
  56       m_logger(STG::PluginLogger::get("radius"))
  57 {
  58 }
  59
  60 int RADIUS::ParseSettings()
  61 {
  62     try {
  63         m_config = STG::Config(m_settings);
  64         return reconnect() ? 0 : -1;
  65     } catch (const std::runtime_error& ex) {
  66         m_logger("Failed to parse settings. %s", ex.what());
  67         return -1;
  68     }
  69 }
  70
  71 int RADIUS::Start()
  72 {
  73     if (m_running)
  74         return 0;
  75
  76     int res = pthread_create(&m_thread, NULL, run, this);
  77     if (res == 0)
  78         return 0;
  79
  80     m_error = strerror(res);
  81     m_logger("Failed to create thread: '" + m_error + "'.");
  82     return -1;
  83 }
  84
  85 int RADIUS::Stop()
  86 {
  87     std::set<std::string>::const_iterator it = m_logins.begin();
  88     for (; it != m_logins.end(); ++it)
  89         m_users->Unauthorize(*it, this, "Stopping RADIUS plugin.");
  90     m_logins.clear();
  91
  92     if (m_stopped)
  93         return 0;
  94
  95     m_running = false;
  96
  97     for (size_t i = 0; i < 25 && !m_stopped; i++) {
  98         struct timespec ts = {0, 200000000};
  99         nanosleep(&ts, NULL);
 100     }
 101
 102     if (m_stopped) {
 103         pthread_join(m_thread, NULL);
 104         return 0;
 105     }
 106
 107     if (m_config.connectionType == Config::UNIX)
 108         unlink(m_config.bindAddress.c_str());
 109
 110     m_error = "Failed to stop thread.";
 111     m_logger(m_error);
 112     return -1;
 113 }
 114 //-----------------------------------------------------------------------------
 115 void* RADIUS::run(void* d)
 116 {
 117     sigset_t signalSet;
 118     sigfillset(&signalSet);
 119     pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 120
 121     static_cast<RADIUS *>(d)->runImpl();
 122
 123     return NULL;
 124 }
 125
 126 bool RADIUS::reconnect()
 127 {
 128     if (!m_conns.empty())
 129     {
 130         std::deque<STG::Conn *>::const_iterator it;
 131         for (it = m_conns.begin(); it != m_conns.end(); ++it)
 132             delete(*it);
 133         m_conns.clear();
 134     }
 135     if (m_listenSocket != 0)
 136     {
 137         shutdown(m_listenSocket, SHUT_RDWR);
 138         close(m_listenSocket);
 139     }
 140     if (m_config.connectionType == Config::UNIX)
 141         m_listenSocket = createUNIX();
 142     else
 143         m_listenSocket = createTCP();
 144     if (m_listenSocket == 0)
 145         return false;
 146     if (listen(m_listenSocket, 100) == -1)
 147     {
 148         m_error = std::string("Error starting to listen socket: ") + strerror(errno);
 149         m_logger(m_error);
 150         return false;
 151     }
 152     return true;
 153 }
 154
 155 int RADIUS::createUNIX() const
 156 {
 157     int fd = socket(AF_UNIX, SOCK_STREAM, 0);
 158     if (fd == -1)
 159     {
 160         m_error = std::string("Error creating UNIX socket: ") + strerror(errno);
 161         m_logger(m_error);
 162         return 0;
 163     }
 164     struct sockaddr_un addr;
 165     memset(&addr, 0, sizeof(addr));
 166     addr.sun_family = AF_UNIX;
 167     strncpy(addr.sun_path, m_config.bindAddress.c_str(), m_config.bindAddress.length());
 168     unlink(m_config.bindAddress.c_str());
 169     if (bind(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) == -1)
 170     {
 171         shutdown(fd, SHUT_RDWR);
 172         close(fd);
 173         m_error = std::string("Error binding UNIX socket: ") + strerror(errno);
 174         m_logger(m_error);
 175         return 0;
 176     }
 177     chown(m_config.bindAddress.c_str(), m_config.sockUID, m_config.sockGID);
 178     if (m_config.sockMode != static_cast<mode_t>(-1))
 179         chmod(m_config.bindAddress.c_str(), m_config.sockMode);
 180     return fd;
 181 }
 182
 183 int RADIUS::createTCP() const
 184 {
 185     addrinfo hints;
 186     memset(&hints, 0, sizeof(addrinfo));
 187
 188     hints.ai_family = AF_INET;       /* Allow IPv4 */
 189     hints.ai_socktype = SOCK_STREAM; /* Stream socket */
 190     hints.ai_flags = AI_PASSIVE;     /* For wildcard IP address */
 191     hints.ai_protocol = 0;           /* Any protocol */
 192     hints.ai_canonname = NULL;
 193     hints.ai_addr = NULL;
 194     hints.ai_next = NULL;
 195
 196     addrinfo* ais = NULL;
 197     int res = getaddrinfo(m_config.bindAddress.c_str(), m_config.portStr.c_str(), &hints, &ais);
 198     if (res != 0)
 199     {
 200         m_error = "Error resolving address '" + m_config.bindAddress + "': " + gai_strerror(res);
 201         m_logger(m_error);
 202         return 0;
 203     }
 204
 205     for (addrinfo* ai = ais; ai != NULL; ai = ai->ai_next)
 206     {
 207         int fd = socket(AF_INET, SOCK_STREAM, 0);
 208         if (fd == -1)
 209         {
 210             m_error = std::string("Error creating TCP socket: ") + strerror(errno);
 211             m_logger(m_error);
 212             freeaddrinfo(ais);
 213             return 0;
 214         }
 215         if (bind(fd, ai->ai_addr, ai->ai_addrlen) == -1)
 216         {
 217             shutdown(fd, SHUT_RDWR);
 218             close(fd);
 219             m_error = std::string("Error binding TCP socket: ") + strerror(errno);
 220             m_logger(m_error);
 221             continue;
 222         }
 223         freeaddrinfo(ais);
 224         return fd;
 225     }
 226
 227     m_error = "Failed to resolve '" + m_config.bindAddress;
 228     m_logger(m_error);
 229
 230     freeaddrinfo(ais);
 231     return 0;
 232 }
 233
 234 void RADIUS::runImpl()
 235 {
 236     m_running = true;
 237     m_stopped = false;
 238
 239     while (m_running) {
 240         fd_set fds;
 241
 242         buildFDSet(fds);
 243
 244         struct timeval tv;
 245         tv.tv_sec = 0;
 246         tv.tv_usec = 500000;
 247
 248         int res = select(maxFD() + 1, &fds, NULL, NULL, &tv);
 249         if (res < 0)
 250         {
 251             if (errno == EINTR)
 252                 continue;
 253             m_error = std::string("'select' is failed: '") + strerror(errno) + "'.";
 254             m_logger(m_error);
 255             break;
 256         }
 257
 258         if (!m_running)
 259             break;
 260
 261         if (res > 0)
 262             handleEvents(fds);
 263         else
 264         {
 265             for (std::deque<Conn*>::iterator it = m_conns.begin(); it != m_conns.end(); ++it)
 266                 (*it)->tick();
 267         }
 268
 269         cleanupConns();
 270     }
 271
 272     m_stopped = true;
 273 }
 274
 275 int RADIUS::maxFD() const
 276 {
 277     int maxFD = m_listenSocket;
 278     std::deque<STG::Conn *>::const_iterator it;
 279     for (it = m_conns.begin(); it != m_conns.end(); ++it)
 280         if (maxFD < (*it)->sock())
 281             maxFD = (*it)->sock();
 282     return maxFD;
 283 }
 284
 285 void RADIUS::buildFDSet(fd_set & fds) const
 286 {
 287     FD_ZERO(&fds);
 288     FD_SET(m_listenSocket, &fds);
 289     std::deque<STG::Conn *>::const_iterator it;
 290     for (it = m_conns.begin(); it != m_conns.end(); ++it)
 291         FD_SET((*it)->sock(), &fds);
 292 }
 293
 294 void RADIUS::cleanupConns()
 295 {
 296     std::deque<STG::Conn *>::iterator pos;
 297     for (pos = m_conns.begin(); pos != m_conns.end(); ++pos)
 298         if (!(*pos)->isOk()) {
 299             delete *pos;
 300             *pos = NULL;
 301         }
 302
 303     pos = std::remove(m_conns.begin(), m_conns.end(), static_cast<STG::Conn *>(NULL));
 304     m_conns.erase(pos, m_conns.end());
 305 }
 306
 307 void RADIUS::handleEvents(const fd_set & fds)
 308 {
 309     if (FD_ISSET(m_listenSocket, &fds))
 310         acceptConnection();
 311     else
 312     {
 313         std::deque<STG::Conn *>::iterator it;
 314         for (it = m_conns.begin(); it != m_conns.end(); ++it)
 315             if (FD_ISSET((*it)->sock(), &fds))
 316                 (*it)->read();
 317             else
 318                 (*it)->tick();
 319     }
 320 }
 321
 322 void RADIUS::acceptConnection()
 323 {
 324     if (m_config.connectionType == Config::UNIX)
 325         acceptUNIX();
 326     else
 327         acceptTCP();
 328 }
 329
 330 void RADIUS::acceptUNIX()
 331 {
 332     struct sockaddr_un addr;
 333     memset(&addr, 0, sizeof(addr));
 334     socklen_t size = sizeof(addr);
 335     int res = accept(m_listenSocket, reinterpret_cast<sockaddr*>(&addr), &size);
 336     if (res == -1)
 337     {
 338         m_error = std::string("Failed to accept UNIX connection: ") + strerror(errno);
 339         m_logger(m_error);
 340         return;
 341     }
 342     printfd(__FILE__, "New UNIX connection: '%s'\n", addr.sun_path);
 343     m_conns.push_back(new Conn(*m_users, m_logger, *this, m_config, res, addr.sun_path));
 344 }
 345
 346 void RADIUS::acceptTCP()
 347 {
 348     struct sockaddr_in addr;
 349     memset(&addr, 0, sizeof(addr));
 350     socklen_t size = sizeof(addr);
 351     int res = accept(m_listenSocket, reinterpret_cast<sockaddr*>(&addr), &size);
 352     if (res == -1)
 353     {
 354         m_error = std::string("Failed to accept TCP connection: ") + strerror(errno);
 355         m_logger(m_error);
 356         return;
 357     }
 358     std::string remote = inet_ntostring(addr.sin_addr.s_addr) + ":" + std::to_string(ntohs(addr.sin_port));
 359     printfd(__FILE__, "New TCP connection: '%s'\n", remote.c_str());
 360     m_conns.push_back(new Conn(*m_users, m_logger, *this, m_config, res, remote));
 361 }
 362
 363 void RADIUS::authorize(const STG::User& user)
 364 {
 365     uint32_t ip = 0;
 366     const std::string& login(user.GetLogin());
 367     if (!m_users->Authorize(login, ip, 0xffFFffFF, this))
 368     {
 369         m_error = "Unable to authorize user '" + login + "' with ip " + inet_ntostring(ip) + ".";
 370         m_logger(m_error);
 371     }
 372     else
 373         m_logins.insert(login);
 374 }
 375
 376 void RADIUS::unauthorize(const std::string& login, const std::string& reason)
 377 {
 378     const std::set<std::string>::const_iterator it = m_logins.find(login);
 379     if (it == m_logins.end())
 380         return;
 381     m_logins.erase(it);
 382     m_users->Unauthorize(login, this, reason);
 383 }