Merge branch 'master' of gitorious.org:stg/stg

[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 c0b70e725d91c9eebe7d6ab2654cd23048499b8f..90ec1891ea7c0602f9dfa24b9f568a259cc3afe3 100644 (file)
--- a/projects/stargazer/plugins/other/radius/radius.cpp
+++ b/projects/stargazer/plugins/other/radius/radius.cpp
@@ -27,89 +27,60 @@
  */
 
 #include <csignal>
  */
 
 #include <csignal>

+#include <cerrno>

 #include <algorithm>
 
 #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 "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<RADIUS> 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();
 }
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 {
 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<string> & str, list<string> * lst)
+int RAD_SETTINGS::ParseServices(const std::vector<std::string> & str, std::list<std::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;
 }
 //-----------------------------------------------------------------------------
 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";
 ///////////////////////////
 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.";
 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;
     }
     printfd(__FILE__, "Cannot parse parameter 'Port'\n");
     return -1;
     }

-port = p;
+port = static_cast<uint16_t>(p);

 ///////////////////////////
 pv.param = "Password";
 ///////////////////////////
 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.";
 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";
 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";
 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);
 if (pvi != s.moduleParams.end())
     {
     ParseServices(pvi->value, &acctServices);


@@ -154,33 +125,25 @@ return 0;
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 RADIUS::RADIUS()
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 RADIUS::RADIUS()

-    : nonstop(false),
+    : ctx(),
+      errorStr(),
+      radSettings(),
+      settings(),
+      authServices(),
+      acctServices(),
+      sessions(),
+      nonstop(false),

       isRunning(false),
       users(NULL),
       stgSettings(NULL),
       store(NULL),
       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)
-{
-settings = s;
-}
-//-----------------------------------------------------------------------------
-void RADIUS::SetStore(BASE_STORE * s)
+      thread(),
+      mutex(),
+      sock(-1),
+      packet(),
+      logger(GetPluginLogger(GetStgLogger(), "radius"))

 {
 {

-store = s;
+InitEncrypt(&ctx, "");

 }
 //-----------------------------------------------------------------------------
 int RADIUS::ParseSettings()
 }
 //-----------------------------------------------------------------------------
 int RADIUS::ParseSettings()


@@ -191,27 +154,6 @@ if (ret)
 return 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);
 int RADIUS::PrepareNet()
 {
 sock = socket(AF_INET, SOCK_DGRAM, 0);


@@ -219,6 +161,7 @@ sock = socket(AF_INET, SOCK_DGRAM, 0);
 if (sock < 0)
     {
     errorStr = "Cannot create socket.";
 if (sock < 0)
     {
     errorStr = "Cannot create socket.";

+    logger("Cannot create a socket: %s", strerror(errno));

     printfd(__FILE__, "Cannot create socket\n");
     return -1;
     }
     printfd(__FILE__, "Cannot create socket\n");
     return -1;
     }


@@ -231,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.";
 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;
     }
     printfd(__FILE__, "Cannot bind socket\n");
     return -1;
     }


@@ -246,7 +190,7 @@ return 0;
 //-----------------------------------------------------------------------------
 int RADIUS::Start()
 {
 //-----------------------------------------------------------------------------
 int RADIUS::Start()
 {

-string password(radSettings.GetPassword());
+std::string password(radSettings.GetPassword());

 
 authServices = radSettings.GetAuthServices();
 acctServices = radSettings.GetAcctServices();
 
 authServices = radSettings.GetAuthServices();
 acctServices = radSettings.GetAcctServices();


@@ -265,6 +209,7 @@ if (!isRunning)
     if (pthread_create(&thread, NULL, Run, this))
         {
         errorStr = "Cannot create thread.";
     if (pthread_create(&thread, NULL, Run, this))
         {
         errorStr = "Cannot create thread.";

+       logger("Cannot create thread.");

         printfd(__FILE__, "Cannot create thread\n");
         return -1;
         }
         printfd(__FILE__, "Cannot create thread\n");
         return -1;
         }


@@ -281,13 +226,13 @@ if (!IsRunning())
 
 nonstop = false;
 
 
 nonstop = false;
 

-map<string, RAD_SESSION>::iterator it;
+std::map<std::string, RAD_SESSION>::iterator it;

 for (it = sessions.begin(); it != sessions.end(); ++it)
     {
 for (it = sessions.begin(); it != sessions.end(); ++it)
     {

-    user_iter ui;
+    USER_PTR ui;

     if (users->FindByName(it->second.userName, &ui))
         {
     if (users->FindByName(it->second.userName, &ui))
         {

-        ui->Unauthorize(this);
+        users->Unauthorize(ui->GetLogin(), this);

         }
     }
 sessions.erase(sessions.begin(), sessions.end());
         }
     }
 sessions.erase(sessions.begin(), sessions.end());


@@ -299,27 +244,23 @@ if (isRunning)
     //5 seconds to thread stops itself
     for (int i = 0; i < 25 && isRunning; i++)
         {
     //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)
 {
 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;
 
 RADIUS * rad = (RADIUS *)d;
 RAD_PACKET packet;
 


@@ -327,7 +268,7 @@ rad->isRunning = true;
 
 while (rad->nonstop)
     {
 
 while (rad->nonstop)
     {

-    if (!rad->WaitPackets(rad->sock))
+    if (!WaitPackets(rad->sock))

         {
         continue;
         }
         {
         continue;
         }


@@ -355,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);
 {
     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);
-    }
+    ssize_t dataLen = recvfrom(sock, buf, RAD_MAX_PACKET_LEN, 0, reinterpret_cast<struct sockaddr *>(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;
         }
     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;
 }
 //-----------------------------------------------------------------------------
     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);
 {
 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));
+ssize_t 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)
 }
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessData(RAD_PACKET * packet)


@@ -403,7 +355,6 @@ switch (packet->packetType)
         printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType);
         return -1;
     };
         printfd(__FILE__, "RADIUS::ProcessData Unsupported packet type: %d\n", packet->packetType);
         return -1;
     };

-return 0;

 }
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAutzPacket(RAD_PACKET * packet)
 }
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAutzPacket(RAD_PACKET * packet)


@@ -435,7 +386,7 @@ return 0;
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
 {
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAuthPacket(RAD_PACKET * packet)
 {

-user_iter ui;
+USER_PTR ui;

 
 if (!CanAcctService((char *)packet->service))
     {
 
 if (!CanAcctService((char *)packet->service))
     {


@@ -473,7 +424,7 @@ return 0;
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
 {
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessPostAuthPacket(RAD_PACKET * packet)
 {

-user_iter ui;
+USER_PTR ui;

 
 if (!CanAcctService((char *)packet->service))
     {
 
 if (!CanAcctService((char *)packet->service))
     {


@@ -495,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
 
 // 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
 packet->packetType = RAD_ACCEPT_PACKET;
 
 // Additional checking for Framed-User service


@@ -510,7 +461,7 @@ return 0;
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
 {
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAcctStartPacket(RAD_PACKET * packet)
 {

-user_iter ui;
+USER_PTR ui;

 
 if (!FindUser(&ui, (char *)packet->login))
     {
 
 if (!FindUser(&ui, (char *)packet->login))
     {


@@ -529,8 +480,8 @@ if (CanAcctService((char *)packet->service))
         packet->packetType = RAD_REJECT_PACKET;
         return -1;
         }
         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;
         {
         printfd(__FILE__, "RADIUS::ProcessAcctStartPacket cannot authorize user '%s'\n", packet->login);
         packet->packetType = RAD_REJECT_PACKET;


@@ -551,7 +502,7 @@ return 0;
 //-----------------------------------------------------------------------------
 int RADIUS::ProcessAcctStopPacket(RAD_PACKET * 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())
     {
 
 if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
     {


@@ -560,7 +511,7 @@ if ((sid = sessions.find((const char *)packet->sessid)) == sessions.end())
     return -1;
     }
 
     return -1;
     }
 

-user_iter ui;
+USER_PTR ui;

 
 if (!FindUser(&ui, sid->second.userName))
     {
 
 if (!FindUser(&ui, sid->second.userName))
     {


@@ -571,7 +522,7 @@ if (!FindUser(&ui, sid->second.userName))
 
 sessions.erase(sid);
 
 
 sessions.erase(sid);
 

-ui->Unauthorize(this);
+users->Unauthorize(ui->GetLogin(), this);

 
 packet->packetType = RAD_ACCEPT_PACKET;
 return 0;
 
 packet->packetType = RAD_ACCEPT_PACKET;
 return 0;


@@ -591,12 +542,12 @@ packet->packetType = RAD_ACCEPT_PACKET;
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-void RADIUS::PrintServices(const list<string> & svcs)
+void RADIUS::PrintServices(const std::list<std::string> & svcs)

 {
 {

-    for_each(svcs.begin(), svcs.end(), Printer());
+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))
     {
 {
 if (users->FindByName(login, ui))
     {


@@ -607,49 +558,24 @@ return true;
 //-----------------------------------------------------------------------------
 bool RADIUS::CanAuthService(const std::string & svc) const
 {
 //-----------------------------------------------------------------------------
 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
 {
 }
 //-----------------------------------------------------------------------------
 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
 {
 }
 //-----------------------------------------------------------------------------
 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
 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);
 {
 unsigned char keyL[RAD_PASSWORD_LEN];  // Пароль для шифровки
 memset(keyL, 0, RAD_PASSWORD_LEN);


@@ -658,23 +584,25 @@ Blowfish_Init(ctx, keyL, RAD_PASSWORD_LEN);
 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 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);
 
 {
 // 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<uint32_t *>(dst) + i * 2, static_cast<uint32_t *>(dst) + i * 2 + 1);

 }
 //-----------------------------------------------------------------------------
 inline
 }
 //-----------------------------------------------------------------------------
 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);
 
 {
 // 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<uint32_t *>(dst) + i * 2, static_cast<uint32_t *>(dst) + i * 2 + 1);

 }
 }

+
+} // namespace anonymous