]> git.stg.codes - stg.git/blob - stargazer/plugins/other/radius/radius.cpp
dcfb4e690e50f5076e9a229e2971e540aefe0927
[stg.git] / 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 }