Patch from SpiderX <spiderx@spiderx.dp.ua> - added installing demo scripts for

[stg.git] / projects / stargazer / plugins / other / radius / radius.cpp

diff --git a/projects/stargazer/plugins/other/radius/radius.cpp b/projects/stargazer/plugins/other/radius/radius.cpp
index 1dfff791afe4eb386a19ee0d34f19aebbdb17611..1c060b7f529be26743fafcee0cf20abb59e29742 100644 (file)
--- a/projects/stargazer/plugins/other/radius/radius.cpp
+++ b/projects/stargazer/plugins/other/radius/radius.cpp
@@ -121,36 +121,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(STORE * s)
-{
-store = s;
-}
-//-----------------------------------------------------------------------------
 int RADIUS::ParseSettings()
 {
 int ret = radSettings.ParseSettings(settings);
@@ -159,27 +150,6 @@ if (ret)
 return ret;
 }
 //-----------------------------------------------------------------------------
-bool RADIUS::IsRunning()
-{
-return isRunning;
-}
-//-----------------------------------------------------------------------------
-const std::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);
@@ -187,6 +157,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;
     }
@@ -199,6 +170,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;
     }
@@ -233,6 +205,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;
         }
@@ -255,7 +228,7 @@ for (it = sessions.begin(); it != sessions.end(); ++it)
     USER_PTR ui;
     if (users->FindByName(it->second.userName, &ui))
         {
-        ui->Unauthorize(this);
+        users->Unauthorize(ui->GetLogin(), this);
         }
     }
 sessions.erase(sessions.begin(), sessions.end());
@@ -267,27 +240,23 @@ 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)
 {
+sigset_t signalSet;
+sigfillset(&signalSet);
+pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
+
 RADIUS * rad = (RADIUS *)d;
 RAD_PACKET packet;
 
@@ -295,7 +264,7 @@ rad->isRunning = true;
 
 while (rad->nonstop)
     {
-    if (!rad->WaitPackets(rad->sock))
+    if (!WaitPackets(rad->sock))
         {
         continue;
         }
@@ -324,14 +293,22 @@ 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<struct sockaddr *>(outerAddr), &outerAddrLen);
-    if (dataLen > 0) {
-        Decrypt(&ctx, (char *)packet, (const char *)buf, dataLen / 8);
-    }
+    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;
 }
 //-----------------------------------------------------------------------------
@@ -341,7 +318,10 @@ size_t len = sizeof(RAD_PACKET);
 char buf[1032];
 
 Encrypt(&ctx, buf, (char *)&packet, len / 8);
-return sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
+int res = sendto(sock, buf, len, 0, reinterpret_cast<struct sockaddr *>(outerAddr), sizeof(struct sockaddr_in));
+if (res < 0)
+    logger("sendto error: %s", strerror(errno));
+return res;
 }
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessData(RAD_PACKET * packet)
@@ -498,7 +478,7 @@ if (CanAcctService((char *)packet->service))
         return -1;
         }
     USER_IPS ips = ui->GetProperty().ips;
-    if (ui->Authorize(ips[0].ip, 0xffFFffFF, this))
+    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;
@@ -539,7 +519,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;
@@ -588,34 +568,6 @@ bool RADIUS::IsAllowedService(const std::string & svc) const
 return CanAuthService(svc) || CanAcctService(svc);
 }
 //-----------------------------------------------------------------------------
-bool RADIUS::WaitPackets(int sd) const
-{
-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 std::string & password)
 {