X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/46447728e6265aa56dedf146f0150a970ce347c9..ce23bada2111a637074629161268ce1039d28a58:/projects/stargazer/plugins/other/radius/radius.cpp?ds=inline diff --git a/projects/stargazer/plugins/other/radius/radius.cpp b/projects/stargazer/plugins/other/radius/radius.cpp index 9b8c67d1..8e52cdb4 100644 --- a/projects/stargazer/plugins/other/radius/radius.cpp +++ b/projects/stargazer/plugins/other/radius/radius.cpp @@ -27,89 +27,60 @@ */ #include +#include #include +#include "stg/store.h" +#include "stg/common.h" +#include "stg/user_conf.h" +#include "stg/user_property.h" +#include "stg/plugin_creator.h" #include "radius.h" -#include "common.h" -extern volatile const time_t stgTime; - -void InitEncrypt(BLOWFISH_CTX * ctx, const string & password); -void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8); -void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8); +extern volatile time_t stgTime; //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- -class RAD_CREATOR +namespace { -private: - RADIUS * rad; +PLUGIN_CREATOR radc; -public: - RAD_CREATOR() - : rad(new RADIUS()) - { - }; - ~RAD_CREATOR() - { - delete rad; - }; - - RADIUS * GetPlugin() - { - return rad; - }; -}; -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- -RAD_CREATOR radc; +void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password); +void Decrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, unsigned long len8); +void Encrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, unsigned long len8); +} +extern "C" PLUGIN * GetPlugin(); //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- -BASE_PLUGIN * GetPlugin() +PLUGIN * GetPlugin() { return radc.GetPlugin(); } //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- -int RAD_SETTINGS::ParseIntInRange(const string & str, int min, int max, int * val) -{ -if (str2x(str.c_str(), *val)) - { - errorStr = "Incorrect value \'" + str + "\'."; - return -1; - } -if (*val < min || *val > max) - { - errorStr = "Value \'" + str + "\' out of range."; - return -1; - } -return 0; -} -//----------------------------------------------------------------------------- -int RAD_SETTINGS::ParseServices(const vector & str, list * lst) +int RAD_SETTINGS::ParseServices(const std::vector & str, std::list * lst) { - copy(str.begin(), str.end(), back_inserter(*lst)); - list::iterator it(find(lst->begin(), - lst->end(), - "empty")); - if (it != lst->end()) - *it = ""; +std::copy(str.begin(), str.end(), std::back_inserter(*lst)); +std::list::iterator it(std::find(lst->begin(), + lst->end(), + "empty")); +if (it != lst->end()) + *it = ""; - return 0; +return 0; } //----------------------------------------------------------------------------- int RAD_SETTINGS::ParseSettings(const MODULE_SETTINGS & s) { int p; PARAM_VALUE pv; -vector::const_iterator pvi; +std::vector::const_iterator pvi; /////////////////////////// pv.param = "Port"; -pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv); +pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv); if (pvi == s.moduleParams.end()) { errorStr = "Parameter \'Port\' not found."; @@ -122,10 +93,10 @@ if (ParseIntInRange(pvi->value[0], 2, 65535, &p)) printfd(__FILE__, "Cannot parse parameter 'Port'\n"); return -1; } -port = p; +port = static_cast(p); /////////////////////////// pv.param = "Password"; -pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv); +pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv); if (pvi == s.moduleParams.end()) { errorStr = "Parameter \'Password\' not found."; @@ -135,14 +106,14 @@ if (pvi == s.moduleParams.end()) password = pvi->value[0]; /////////////////////////// pv.param = "AuthServices"; -pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv); +pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv); if (pvi != s.moduleParams.end()) { ParseServices(pvi->value, &authServices); } /////////////////////////// pv.param = "AcctServices"; -pvi = find(s.moduleParams.begin(), s.moduleParams.end(), pv); +pvi = std::find(s.moduleParams.begin(), s.moduleParams.end(), pv); if (pvi != s.moduleParams.end()) { ParseServices(pvi->value, &acctServices); @@ -154,36 +125,27 @@ return 0; //----------------------------------------------------------------------------- //----------------------------------------------------------------------------- RADIUS::RADIUS() - : nonstop(false), + : ctx(), + errorStr(), + radSettings(), + settings(), + authServices(), + acctServices(), + sessions(), + nonstop(false), isRunning(false), users(NULL), stgSettings(NULL), store(NULL), - sock(-1) + thread(), + mutex(), + sock(-1), + packet(), + logger(GetPluginLogger(GetStgLogger(), "radius")) { InitEncrypt(&ctx, ""); } //----------------------------------------------------------------------------- -void RADIUS::SetUsers(USERS * u) -{ -users = u; -} -//----------------------------------------------------------------------------- -void RADIUS::SetStgSettings(const SETTINGS * s) -{ -stgSettings = s; -} -//----------------------------------------------------------------------------- -void RADIUS::SetSettings(const MODULE_SETTINGS & s) -{ -settings = s; -} -//----------------------------------------------------------------------------- -void RADIUS::SetStore(BASE_STORE * s) -{ -store = s; -} -//----------------------------------------------------------------------------- int RADIUS::ParseSettings() { int ret = radSettings.ParseSettings(settings); @@ -192,27 +154,6 @@ if (ret) return ret; } //----------------------------------------------------------------------------- -bool RADIUS::IsRunning() -{ -return isRunning; -} -//----------------------------------------------------------------------------- -const string RADIUS::GetVersion() const -{ -return "RADIUS data access plugin v 0.6"; -} -//----------------------------------------------------------------------------- -uint16_t RADIUS::GetStartPosition() const -{ -// Start before any authorizers!!! -return 20; -} -//----------------------------------------------------------------------------- -uint16_t RADIUS::GetStopPosition() const -{ -return 20; -} -//----------------------------------------------------------------------------- int RADIUS::PrepareNet() { sock = socket(AF_INET, SOCK_DGRAM, 0); @@ -220,6 +161,7 @@ sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock < 0) { errorStr = "Cannot create socket."; + logger("Cannot create a socket: %s", strerror(errno)); printfd(__FILE__, "Cannot create socket\n"); return -1; } @@ -232,6 +174,7 @@ inAddr.sin_addr.s_addr = inet_addr("0.0.0.0"); if (bind(sock, (struct sockaddr*)&inAddr, sizeof(inAddr)) < 0) { errorStr = "RADIUS: Bind failed."; + logger("Cannot bind the socket: %s", strerror(errno)); printfd(__FILE__, "Cannot bind socket\n"); return -1; } @@ -247,7 +190,7 @@ return 0; //----------------------------------------------------------------------------- int RADIUS::Start() { -string password(radSettings.GetPassword()); +std::string password(radSettings.GetPassword()); authServices = radSettings.GetAuthServices(); acctServices = radSettings.GetAcctServices(); @@ -266,6 +209,7 @@ if (!isRunning) if (pthread_create(&thread, NULL, Run, this)) { errorStr = "Cannot create thread."; + logger("Cannot create thread."); printfd(__FILE__, "Cannot create thread\n"); return -1; } @@ -282,13 +226,13 @@ if (!IsRunning()) nonstop = false; -map::iterator it; +std::map::iterator it; for (it = sessions.begin(); it != sessions.end(); ++it) { - user_iter ui; + USER_PTR ui; if (users->FindByName(it->second.userName, &ui)) { - ui->Unauthorize(this); + users->Unauthorize(ui->GetLogin(), this); } } sessions.erase(sessions.begin(), sessions.end()); @@ -300,35 +244,31 @@ if (isRunning) //5 seconds to thread stops itself for (int i = 0; i < 25 && isRunning; i++) { - usleep(200000); - } - - //after 5 seconds waiting thread still running. now killing it - if (isRunning) - { - if (pthread_kill(thread, SIGINT)) - { - errorStr = "Cannot kill thread."; - printfd(__FILE__, "Cannot kill thread\n"); - return -1; - } - printfd(__FILE__, "RADIUS::Stop killed Run\n"); + struct timespec ts = {0, 200000000}; + nanosleep(&ts, NULL); } } +if (isRunning) + return -1; + return 0; } //----------------------------------------------------------------------------- void * RADIUS::Run(void * d) { -RADIUS * rad = (RADIUS *)d; +sigset_t signalSet; +sigfillset(&signalSet); +pthread_sigmask(SIG_BLOCK, &signalSet, NULL); + +RADIUS * rad = static_cast(d); RAD_PACKET packet; rad->isRunning = true; while (rad->nonstop) { - if (!rad->WaitPackets(rad->sock)) + if (!WaitPackets(rad->sock)) { continue; } @@ -356,25 +296,36 @@ int RADIUS::RecvData(RAD_PACKET * packet, struct sockaddr_in * outerAddr) { int8_t buf[RAD_MAX_PACKET_LEN]; socklen_t outerAddrLen = sizeof(struct sockaddr_in); - int dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast(outerAddr), &outerAddrLen); - if (dataLen > 0) { - Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8); - } + ssize_t dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast(outerAddr), &outerAddrLen); + if (dataLen < 0) + { + logger("recvfrom error: %s", strerror(errno)); + return -1; + } + if (dataLen == 0) + return -1; + + Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8); + if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN)) { printfd(__FILE__, "RADIUS::RecvData Error magic. Wanted: '%s', got: '%s'\n", RAD_ID, packet->magic); return -1; } + return 0; } //----------------------------------------------------------------------------- -int RADIUS::Send(const RAD_PACKET & packet, struct sockaddr_in * outerAddr) +ssize_t RADIUS::Send(const RAD_PACKET & packet, struct sockaddr_in * outerAddr) { size_t len = sizeof(RAD_PACKET); char buf[1032]; Encrypt(&ctx, buf, (char *)&packet, len / 8); -return sendto(sock, buf, len, 0, reinterpret_cast(outerAddr), sizeof(struct sockaddr_in)); +ssize_t res = sendto(sock, buf, len, 0, reinterpret_cast(outerAddr), sizeof(struct sockaddr_in)); +if (res < 0) + logger("sendto error: %s", strerror(errno)); +return res; } //----------------------------------------------------------------------------- int RADIUS::ProcessData(RAD_PACKET * packet) @@ -404,7 +355,6 @@ switch (packet->packetType) printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType); return -1; }; -return 0; } //----------------------------------------------------------------------------- int RADIUS::ProcessAutzPacket(RAD_PACKET * packet) @@ -436,7 +386,7 @@ return 0; //----------------------------------------------------------------------------- int RADIUS::ProcessAuthPacket(RAD_PACKET * packet) { -user_iter ui; +USER_PTR ui; if (!CanAcctService((char *)packet->service)) { @@ -474,7 +424,7 @@ return 0; //----------------------------------------------------------------------------- int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet) { -user_iter ui; +USER_PTR ui; if (!CanAcctService((char *)packet->service)) { @@ -496,7 +446,7 @@ if (!FindUser(&ui, (char *)packet->login)) // I think that only Framed-User services has sense to be accountable // So we have to supply a Framed-IP -USER_IPS ips = ui->property.ips; +USER_IPS ips = ui->GetProperty().ips; packet->packetType = RAD_ACCEPT_PACKET; // Additional checking for Framed-User service @@ -511,7 +461,7 @@ return 0; //----------------------------------------------------------------------------- int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet) { -user_iter ui; +USER_PTR ui; if (!FindUser(&ui, (char *)packet->login)) { @@ -530,8 +480,8 @@ if (CanAcctService((char *)packet->service)) packet->packetType = RAD_REJECT_PACKET; return -1; } - USER_IPS ips = ui->property.ips; - if (ui->Authorize(ips[0].ip, "", 0xffFFffFF, this)) + USER_IPS ips = ui->GetProperty().ips; + if (!users->Authorize(ui->GetLogin(), ips[0].ip, 0xffFFffFF, this)) { printfd(__FILE__, "RADIUS::ProcessAcctStartPacket cannot authorize user '%s'\n", packet->login); packet->packetType = RAD_REJECT_PACKET; @@ -552,7 +502,7 @@ return 0; //----------------------------------------------------------------------------- int RADIUS::ProcessAcctStopPacket(RAD_PACKET * packet) { -map::iterator sid; +std::map::iterator sid; if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end()) { @@ -561,7 +511,7 @@ if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end()) return -1; } -user_iter ui; +USER_PTR ui; if (!FindUser(&ui, sid->second.userName)) { @@ -572,7 +522,7 @@ if (!FindUser(&ui, sid->second.userName)) sessions.erase(sid); -ui->Unauthorize(this); +users->Unauthorize(ui->GetLogin(), this); packet->packetType = RAD_ACCEPT_PACKET; return 0; @@ -592,12 +542,7 @@ packet->packetType = RAD_ACCEPT_PACKET; return 0; } //----------------------------------------------------------------------------- -void RADIUS::PrintServices(const list & svcs) -{ - for_each(svcs.begin(), svcs.end(), Printer()); -} -//----------------------------------------------------------------------------- -bool RADIUS::FindUser(user_iter * ui, const std::string & login) const +bool RADIUS::FindUser(USER_PTR * ui, const std::string & login) const { if (users->FindByName(login, ui)) { @@ -608,49 +553,24 @@ return true; //----------------------------------------------------------------------------- bool RADIUS::CanAuthService(const std::string & svc) const { - return find(authServices.begin(), authServices.end(), svc) != authServices.end(); +return find(authServices.begin(), authServices.end(), svc) != authServices.end(); } //----------------------------------------------------------------------------- bool RADIUS::CanAcctService(const std::string & svc) const { - return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end(); +return find(acctServices.begin(), acctServices.end(), svc) != acctServices.end(); } //----------------------------------------------------------------------------- bool RADIUS::IsAllowedService(const std::string & svc) const { - return CanAuthService(svc) || CanAcctService(svc); +return CanAuthService(svc) || CanAcctService(svc); } //----------------------------------------------------------------------------- -bool RADIUS::WaitPackets(int sd) const +namespace { -fd_set rfds; -FD_ZERO(&rfds); -FD_SET(sd, &rfds); - -struct timeval tv; -tv.tv_sec = 0; -tv.tv_usec = 500000; -int res = select(sd + 1, &rfds, NULL, NULL, &tv); -if (res == -1) // Error - { - if (errno != EINTR) - { - printfd(__FILE__, "Error on select: '%s'\n", strerror(errno)); - } - return false; - } - -if (res == 0) // Timeout - { - return false; - } - -return true; -} -//----------------------------------------------------------------------------- inline -void InitEncrypt(BLOWFISH_CTX * ctx, const string & password) +void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password) { unsigned char keyL[RAD_PASSWORD_LEN]; // Пароль для шифровки memset(keyL, 0, RAD_PASSWORD_LEN); @@ -659,23 +579,25 @@ Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN); } //----------------------------------------------------------------------------- inline -void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8) +void Encrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, unsigned long len8) { // len8 - длина в 8-ми байтовых блоках if (dst != src) memcpy(dst, src, len8 * 8); -for (int i = 0; i < len8; i++) - Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4)); +for (size_t i = 0; i < len8; i++) + Blowfish_Encrypt(ctx, static_cast(dst) + i * 2, static_cast(dst) + i * 2 + 1); } //----------------------------------------------------------------------------- inline -void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8) +void Decrypt(BLOWFISH_CTX * ctx, void * dst, const void * src, unsigned long len8) { // len8 - длина в 8-ми байтовых блоках if (dst != src) memcpy(dst, src, len8 * 8); -for (int i = 0; i < len8; i++) - Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4)); +for (size_t i = 0; i < len8; i++) + Blowfish_Decrypt(ctx, static_cast(dst) + i * 2, static_cast(dst) + i * 2 + 1); } + +} // namespace anonymous