*/
#include <csignal>
+#include <cerrno>
#include <algorithm>
+#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;
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-class RAD_CREATOR
-{
-private:
- RADIUS * rad;
+void InitEncrypt(BLOWFISH_CTX * ctx, const std::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);
-public:
- RAD_CREATOR()
- : rad(new RADIUS())
- {
- };
- ~RAD_CREATOR()
- {
- delete rad;
- };
-
- RADIUS * GetPlugin()
- {
- return rad;
- };
-};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-RAD_CREATOR radc;
+PLUGIN_CREATOR<RADIUS> radc;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-BASE_PLUGIN * GetPlugin()
+PLUGIN * GetPlugin()
{
return radc.GetPlugin();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-int RAD_SETTINGS::ParseIntInRange(const string & str, int min, int max, int * val)
+int RAD_SETTINGS::ParseServices(const std::vector<std::string> & str, std::list<std::string> * lst)
{
-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<string> & str, list<string> * lst)
-{
- copy(str.begin(), str.end(), back_inserter(*lst));
- list<string>::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<std::string>::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<PARAM_VALUE>::const_iterator pvi;
+
std::vector<PARAM_VALUE>::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.";
port = 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.";
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);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
RADIUS::RADIUS()
- : nonstop(false),
+ : ctx(),
+ errorStr(),
+ radSettings(),
+ settings(),
+ authServices(),
+ acctServices(),
+ sessions(),
+ nonstop(false),
isRunning(false),
users(NULL),
stgSettings(NULL),
store(NULL),
- sock(-1)
-{
-}
-//-----------------------------------------------------------------------------
-void RADIUS::SetUsers(USERS * u)
-{
-users = u;
-}
-//-----------------------------------------------------------------------------
-void RADIUS::SetStgSettings(const SETTINGS * s)
-{
-stgSettings = s;
-}
-//-----------------------------------------------------------------------------
-void RADIUS::SetSettings(const MODULE_SETTINGS & s)
+ thread(),
+ mutex(),
+ sock(-1),
+ packet()
{
-settings = s;
-}
-//-----------------------------------------------------------------------------
-void RADIUS::SetStore(BASE_STORE * s)
-{
-store = s;
+InitEncrypt(&ctx, "");
}
//-----------------------------------------------------------------------------
int RADIUS::ParseSettings()
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;
-}
-//-----------------------------------------------------------------------------
-void RADIUS::SetUserNotifier(user_iter)
-{
-}
-//-----------------------------------------------------------------------------
-void RADIUS::UnSetUserNotifier(user_iter)
-{
-}
-//-----------------------------------------------------------------------------
int RADIUS::PrepareNet()
{
sock = socket(AF_INET, SOCK_DGRAM, 0);
//-----------------------------------------------------------------------------
int RADIUS::Start()
{
-string password(radSettings.GetPassword());
+std::string password(radSettings.GetPassword());
authServices = radSettings.GetAuthServices();
acctServices = radSettings.GetAcctServices();
nonstop = false;
-map<string, RAD_SESSION>::iterator it;
+std::map<std::string, RAD_SESSION>::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());
//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)
{
+sigset_t signalSet;
+sigfillset(&signalSet);
+pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
+
RADIUS * rad = (RADIUS *)d;
RAD_PACKET packet;
while (rad->nonstop)
{
- if (!rad->WaitPackets(rad->sock))
+ if (!WaitPackets(rad->sock))
{
continue;
}
//-----------------------------------------------------------------------------
int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
{
-user_iter ui;
+USER_PTR ui;
if (!CanAcctService((char *)packet->service))
{
//-----------------------------------------------------------------------------
int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
{
-user_iter ui;
+USER_PTR ui;
if (!CanAcctService((char *)packet->service))
{
// 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
//-----------------------------------------------------------------------------
int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
{
-user_iter ui;
+USER_PTR ui;
if (!FindUser(&ui, (char *)packet->login))
{
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;
//-----------------------------------------------------------------------------
int RADIUS::ProcessAcctStopPacket(RAD_PACKET * packet)
{
-map<string, RAD_SESSION>::iterator sid;
+std::map<std::string, RAD_SESSION>::iterator sid;
if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
{
return -1;
}
-user_iter ui;
+USER_PTR ui;
if (!FindUser(&ui, sid->second.userName))
{
sessions.erase(sid);
-ui->Unauthorize(this);
+users->Unauthorize(ui->GetLogin(), this);
packet->packetType = RAD_ACCEPT_PACKET;
return 0;
return 0;
}
//-----------------------------------------------------------------------------
-void RADIUS::InitEncrypt(BLOWFISH_CTX * ctx, const string & password)
+void RADIUS::PrintServices(const std::list<std::string> & svcs)
{
-unsigned char keyL[RAD_PASSWORD_LEN]; // Пароль для шифровки
-memset(keyL, 0, RAD_PASSWORD_LEN);
-strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
-Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
+for_each(svcs.begin(), svcs.end(), Printer());
}
//-----------------------------------------------------------------------------
-void RADIUS::Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int 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));
-}
-//-----------------------------------------------------------------------------
-void RADIUS::Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int 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));
-}
-//-----------------------------------------------------------------------------
-void RADIUS::PrintServices(const list<string> & 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))
{
//-----------------------------------------------------------------------------
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
+inline
+void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password)
{
-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;
- }
+unsigned char keyL[RAD_PASSWORD_LEN]; // Пароль для шифровки
+memset(keyL, 0, RAD_PASSWORD_LEN);
+strncpy((char *)keyL, password.c_str(), RAD_PASSWORD_LEN);
+Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
+}
+//-----------------------------------------------------------------------------
+inline
+void Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
+{
+// len8 - длина в 8-ми байтовых блоках
+if (dst != src)
+ memcpy(dst, src, len8 * 8);
-if (res == 0) // Timeout
- {
- return false;
- }
+for (int i = 0; i < len8; i++)
+ Blowfish_Encrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
+}
+//-----------------------------------------------------------------------------
+inline
+void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
+{
+// len8 - длина в 8-ми байтовых блоках
+if (dst != src)
+ memcpy(dst, src, len8 * 8);
-return true;
+for (int i = 0; i < len8; i++)
+ Blowfish_Decrypt(ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
}
git.stg.codes / stg.git / blobdiff