Some fixes in C-C++ bridge in rlm_stg.

[stg.git] / projects / rlm_stg / stg_client.cpp

diff --git a/projects/rlm_stg/stg_client.cpp b/projects/rlm_stg/stg_client.cpp
index 75d443adfee748a58a4279b78f885308807af6cb..c04f177dea4a043de30d6d59651c6386fc5b5ff1 100644 (file)
--- a/projects/rlm_stg/stg_client.cpp
+++ b/projects/rlm_stg/stg_client.cpp
@@ -32,22 +32,26 @@
 
 #include <cerrno>
 #include <cstring>
 
 #include <cerrno>
 #include <cstring>

+#include <vector>
+#include <utility>

 
 #include <stdexcept>
 
 #include "stg_client.h"
 
 
 #include <stdexcept>
 
 #include "stg_client.h"
 

-using namespace std;
+namespace {
+
+STG_CLIENT* stgClient = NULL;
+
+}

 
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------

-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
+

 STG_CLIENT::STG_CLIENT(const std::string & host, uint16_t port, uint16_t lp, const std::string & pass)
 STG_CLIENT::STG_CLIENT(const std::string & host, uint16_t port, uint16_t lp, const std::string & pass)

-    : localPort(lp),
-      password(pass),
+    : password(pass),

       framedIP(0)
 {
       framedIP(0)
 {

-sock = socket(AF_INET, SOCK_DGRAM, 0);
+/*sock = socket(AF_INET, SOCK_DGRAM, 0);

 if (sock == -1)
     {
     std::string message = strerror(errno);
 if (sock == -1)
     {
     std::string message = strerror(errno);


@@ -66,78 +70,38 @@ outerAddr.sin_family = AF_INET;
 outerAddr.sin_port = htons(port);
 outerAddr.sin_addr.s_addr = *(uint32_t *)he->h_addr;
 
 outerAddr.sin_port = htons(port);
 outerAddr.sin_addr.s_addr = *(uint32_t *)he->h_addr;
 

-InitEncrypt();
+InitEncrypt(&ctx, password);
+
+PrepareNet();*/

 }
 }

-//-----------------------------------------------------------------------------
+

 STG_CLIENT::~STG_CLIENT()
 {
 STG_CLIENT::~STG_CLIENT()
 {

-close(sock);
+/*close(sock);*/

 }
 }

-//-----------------------------------------------------------------------------
-uint32_t STG_CLIENT::GetFramedIP() const
-{
-return framedIP;
-}
-//-----------------------------------------------------------------------------
-inline
-void STG_CLIENT::InitEncrypt()
-{
-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);
-}
-//-----------------------------------------------------------------------------
+

 int STG_CLIENT::PrepareNet()
 {
 int STG_CLIENT::PrepareNet()
 {

-if (localPort != 0)
-    {
-    struct sockaddr_in localAddr;
-    localAddr.sin_family = AF_INET;
-    localAddr.sin_port = htons(localPort);
-    localAddr.sin_addr.s_addr = inet_addr("0.0.0.0");;
-
-    if (bind(sock, (struct sockaddr *)&localAddr, sizeof(localAddr)))
-        {
-        errorStr = "Bind failed";
-        return -1;
-        }
-    }

 return 0;
 }
 return 0;
 }

-//-----------------------------------------------------------------------------
-int STG_CLIENT::Start()
-{
-return PrepareNet();
-}
-//-----------------------------------------------------------------------------
-int STG_CLIENT::Stop()
-{
-return 0;
-}
-//-----------------------------------------------------------------------------
-string STG_CLIENT::GetUserPassword() const
-{
-return userPassword;
-}
-//-----------------------------------------------------------------------------
+

 int STG_CLIENT::Send(const RAD_PACKET & packet)
 {
 int STG_CLIENT::Send(const RAD_PACKET & packet)
 {

-char buf[RAD_MAX_PACKET_LEN];
+/*char buf[RAD_MAX_PACKET_LEN];

     
     

-Encrypt(buf, (char *)&packet, sizeof(RAD_PACKET) / 8);
+Encrypt(&ctx, buf, (char *)&packet, sizeof(RAD_PACKET) / 8);

 
 int res = sendto(sock, buf, sizeof(RAD_PACKET), 0, (struct sockaddr *)&outerAddr, sizeof(outerAddr));
 
 if (res == -1)
     errorStr = "Error sending data";
 
 
 int res = sendto(sock, buf, sizeof(RAD_PACKET), 0, (struct sockaddr *)&outerAddr, sizeof(outerAddr));
 
 if (res == -1)
     errorStr = "Error sending data";
 

-return res;
+return res;*/

 }
 }

-//-----------------------------------------------------------------------------
+

 int STG_CLIENT::RecvData(RAD_PACKET * packet)
 {
 int STG_CLIENT::RecvData(RAD_PACKET * packet)
 {

-char buf[RAD_MAX_PACKET_LEN];
+/*char buf[RAD_MAX_PACKET_LEN];

 int res;
 
 struct sockaddr_in addr;
 int res;
 
 struct sockaddr_in addr;


@@ -150,14 +114,14 @@ if (res == -1)
     return -1;
     }
 
     return -1;
     }
 

-Decrypt((char *)packet, buf, res / 8);
+Decrypt(&ctx, (char *)packet, buf, res / 8);

 
 

-return 0;
+return 0;*/

 }
 }

-//-----------------------------------------------------------------------------
+

 int STG_CLIENT::Request(RAD_PACKET * packet, const std::string & login, const std::string & svc, uint8_t packetType)
 {
 int STG_CLIENT::Request(RAD_PACKET * packet, const std::string & login, const std::string & svc, uint8_t packetType)
 {

-int res;
+/*int res;

 
 memcpy((void *)&packet->magic, (void *)RAD_ID, RAD_MAGIC_LEN);
 packet->protoVer[0] = '0';
 
 memcpy((void *)&packet->magic, (void *)RAD_ID, RAD_MAGIC_LEN);
 packet->protoVer[0] = '0';


@@ -185,12 +149,14 @@ if (strncmp((char *)packet->magic, RAD_ID, RAD_MAGIC_LEN))
     return -1;
     }
 
     return -1;
     }
 

-return 0;
+return 0;*/

 }
 }

+

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-int STG_CLIENT::Authorize(const string & login, const string & svc)
+
+const STG_PAIRS * STG_CLIENT::Authorize(const PAIRS& pairs)

 {
 {

-RAD_PACKET packet;
+/*RAD_PACKET packet;

 
 userPassword = "";
 
 
 userPassword = "";
 


@@ -200,14 +166,17 @@ if (Request(&packet, login, svc, RAD_AUTZ_PACKET))
 if (packet.packetType != RAD_ACCEPT_PACKET)
     return -1;
 
 if (packet.packetType != RAD_ACCEPT_PACKET)
     return -1;
 

-userPassword = (char *)packet.password;
+userPassword = (char *)packet.password;*/

 
 

-return 0;
+PAIRS pairs;
+pairs.push_back(std::make_pair("Cleartext-Password", userPassword));
+
+return ToSTGPairs(pairs);

 }
 }

-//-----------------------------------------------------------------------------
-int STG_CLIENT::Authenticate(const string & login, const string & svc)
+
+const STG_PAIRS * STG_CLIENT::Authenticate(const PAIRS& pairs)

 {
 {

-RAD_PACKET packet;
+/*RAD_PACKET packet;

 
 userPassword = "";
 
 
 userPassword = "";
 


@@ -215,14 +184,16 @@ if (Request(&packet, login, svc, RAD_AUTH_PACKET))
     return -1;
 
 if (packet.packetType != RAD_ACCEPT_PACKET)
     return -1;
 
 if (packet.packetType != RAD_ACCEPT_PACKET)

-    return -1;
+    return -1;*/

 
 

-return 0;
+PAIRS pairs;
+
+return ToSTGPairs(pairs);

 }
 }

-//-----------------------------------------------------------------------------
-int STG_CLIENT::PostAuthenticate(const string & login, const string & svc)
+
+const STG_PAIRS * STG_CLIENT::PostAuth(const PAIRS& pairs)

 {
 {

-RAD_PACKET packet;
+/*RAD_PACKET packet;

 
 userPassword = "";
 
 
 userPassword = "";
 


@@ -235,14 +206,24 @@ if (packet.packetType != RAD_ACCEPT_PACKET)
 if (svc == "Framed-User")
     framedIP = packet.ip;
 else
 if (svc == "Framed-User")
     framedIP = packet.ip;
 else

-    framedIP = 0;
+    framedIP = 0;*/

 
 

-return 0;
+PAIRS pairs;
+pairs.push_back(std::make_pair("Framed-IP-Address", inet_ntostring(framedIP)));
+
+return ToSTGPairs(pairs);

 }
 }

-//-----------------------------------------------------------------------------
-int STG_CLIENT::Account(const std::string & type, const string & login, const string & svc, const string & sessid)
+
+const STG_PAIRS * STG_CLIENT::PreAcct(const PAIRS& pairs)

 {
 {

-RAD_PACKET packet;
+PAIRS pairs;
+
+return ToSTGPairs(pairs);
+}
+
+const STG_PAIRS * STG_CLIENT::Account(const PAIRS& pairs)
+{
+/*RAD_PACKET packet;

 
 userPassword = "";
 strncpy((char *)packet.sessid, sessid.c_str(), RAD_SESSID_LEN);
 
 userPassword = "";
 strncpy((char *)packet.sessid, sessid.c_str(), RAD_SESSID_LEN);


@@ -269,28 +250,47 @@ else
     }
 
 if (packet.packetType != RAD_ACCEPT_PACKET)
     }
 
 if (packet.packetType != RAD_ACCEPT_PACKET)

-    return -1;
+    return -1;*/

 
 

-return 0;
+PAIRS pairs;
+
+return ToSTGPairs(pairs);

 }
 }

+
+//-----------------------------------------------------------------------------
+
+std::string STG_CLIENT_ST::m_host;
+uint16_t STG_CLIENT_ST::m_port(6666);
+std::string STG_CLIENT_ST::m_password;
+

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-void STG_CLIENT::Encrypt(char * dst, const char * src, int len8)         
+
+STG_CLIENT* STG_CLIENT::get()

 {
 {

-// 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));
+    return stgClient;
+}
+
+void STG_CLIENT::configure(const std::string& server, uint16_t port, const std::string& password)
+{
+    if ( stgClient != NULL )
+        delete stgClient;
+    stgClient = new STG_CLIENT(server, port, password);

 }
 }

+

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-void STG_CLIENT::Decrypt(char * dst, const char * src, int len8)
+
+const STG_PAIR * ToSTGPairs(const PAIRS & source)

 {
 {

-// len8 - длина в 8-ми байтовых блоках
-if (dst != src)
-    memcpy(dst, src, len8 * 8);
+    STG_PAIR * pairs = new STG_PAIR[source.size() + 1];
+    for (size_t pos = 0; pos < source.size(); ++pos) {
+        bzero(pairs[pos].key, sizeof(STG_PAIR::key));
+        bzero(pairs[pos].value, sizeof(STG_PAIR::value));
+        strncpy(pairs[pos].key, source[pos].first.c_str(), sizeof(STG_PAIR::key));
+        strncpy(pairs[pos].value, source[pos].second.c_str(), sizeof(STG_PAIR::value));
+        ++pos;
+    }
+    bzero(pairs[sources.size()].key, sizeof(STG_PAIR::key));
+    bzero(pairs[sources.size()].value, sizeof(STG_PAIR::value));

 
 

-for (int i = 0; i < len8; i++)
-    Blowfish_Decrypt(&ctx, (uint32_t *)(dst + i*8), (uint32_t *)(dst + i*8 + 4));
+    return pairs;

 }
 }

-//-----------------------------------------------------------------------------