384 lines
8.4 KiB
C++
Executable File
384 lines
8.4 KiB
C++
Executable File
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
#include <xvt.h>
|
|
#include <checks.h>
|
|
#include <isamrpc.h>
|
|
|
|
#include <netsock.h>
|
|
|
|
static TSocketClient* _client = NULL;
|
|
|
|
static CONNID _connection = 0;
|
|
|
|
bool rpc_Start()
|
|
{
|
|
bool ok = TRUE;
|
|
if (_client == NULL)
|
|
{
|
|
srand(clock());
|
|
_client = new TSocketClient;
|
|
if (!_client->IsOk())
|
|
{
|
|
delete _client;
|
|
_client = NULL;
|
|
ok = error_box("Errore di inizializzazione del socket client.");
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool rpc_Stop()
|
|
{
|
|
if (_client)
|
|
{
|
|
delete _client;
|
|
_client = NULL;
|
|
_connection = 0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
bool rpc_Call(const char* cmd)
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
bool ok = _client->Execute(_connection, cmd) != 0;
|
|
return ok;
|
|
}
|
|
|
|
char* rpc_Request(const char* cmd, size_t& size, real& total)
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
const clock_t start = clock();
|
|
_client->Request(_connection, cmd);
|
|
total = (clock() - start) / double(CLOCKS_PER_SEC);
|
|
char* buff = (char*)_client->GetBuffer(size);
|
|
return buff;
|
|
}
|
|
|
|
static TString _rpc_call(256);
|
|
static TString _rpc_string;
|
|
|
|
inline bool BoolCall()
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
bool yes;
|
|
bool ok = _client->RequestBool(_connection, _rpc_call, yes) != 0;
|
|
if (!ok)
|
|
{
|
|
#ifndef DBG
|
|
yesnofatal_box("RPC call failed: %s", (const char*)_rpc_call);
|
|
#endif
|
|
yes = FALSE;
|
|
}
|
|
return yes ? TRUE : FALSE;
|
|
}
|
|
|
|
inline long IntCall()
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
long n;
|
|
bool ok = _client->RequestInteger(_connection, _rpc_call, n) != 0;
|
|
if (!ok)
|
|
{
|
|
#ifndef DBG
|
|
yesnofatal_box("RPC call failed: %s", (const char*)_rpc_call);
|
|
#endif
|
|
n = 0;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
inline TString& StrCall()
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
bool ok = _client->RequestString(_connection, _rpc_call, _rpc_string) != 0;
|
|
if (!ok)
|
|
{
|
|
#ifndef DBG
|
|
yesnofatal_box("RPC call failed: %s", (const char*)_rpc_call);
|
|
#endif
|
|
_rpc_string.cut(0);
|
|
}
|
|
return _rpc_string;
|
|
}
|
|
|
|
inline bool BoolCallInt(const char* fn, long n)
|
|
{
|
|
_rpc_call.format("%s(%ld)", fn, n);
|
|
return BoolCall();
|
|
}
|
|
|
|
inline long IntCallInt(const char* fn, long n)
|
|
{
|
|
_rpc_call.format("%s(%ld)", fn, n);
|
|
return IntCall();
|
|
}
|
|
|
|
inline long IntCallIntInt(const char* fn, long n, long k)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld)", fn, n, k);
|
|
return IntCall();
|
|
}
|
|
|
|
inline long IntCallIntIntInt(const char* fn, long n, long k, long f)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld,%ld)", fn, n, k, f);
|
|
return IntCall();
|
|
}
|
|
|
|
|
|
inline long IntCallIntIntStr(const char* fn, long n, long k, const char* str)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld,|%s|)", fn, n, k, str);
|
|
return IntCall();
|
|
}
|
|
|
|
inline long IntCallIntStr(const char* fn, long n, const char* str)
|
|
{
|
|
_rpc_call.format("%s(%ld,|%s|)", fn, n, str);
|
|
return IntCall();
|
|
}
|
|
|
|
inline int IntCallIntStrInt(const char* fn, long n, const char* s, long f)
|
|
{
|
|
_rpc_call.format("%s(%ld,|%s|,%ld)", fn, n, s, f);
|
|
return (int)IntCall();
|
|
}
|
|
|
|
inline long IntCallIntStrStr(const char* fn, long n, const char* str, const char* val)
|
|
{
|
|
_rpc_call.format("%s(%ld,|%s|,|%s|)", fn, n, str, val);
|
|
return IntCall();
|
|
}
|
|
|
|
inline long IntCallStr(const char* fn, const char* str)
|
|
{
|
|
_rpc_call.format("%s(%s)", fn, str);
|
|
return IntCall();
|
|
}
|
|
|
|
|
|
inline TString& StrCallIntInt(const char* fn, long n, long k)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld)", fn, n, k);
|
|
return StrCall();
|
|
}
|
|
|
|
inline TString& StrCallIntStr(const char* fn, long n, const char* str)
|
|
{
|
|
_rpc_call.format("%s(%ld,|%s|)", fn, n, str);
|
|
return StrCall();
|
|
}
|
|
|
|
bool rpc_DongleHasModule(word af)
|
|
{
|
|
return BoolCallInt("DongleHasModule", af);
|
|
}
|
|
|
|
bool rpc_DongleModules(TBit_array& ba)
|
|
{
|
|
size_t size;
|
|
real time;
|
|
|
|
word* buff = (word*)rpc_Request("DongleModules()", size, time);
|
|
if (buff && size > 0)
|
|
{
|
|
ba.reset(); ba.set(0, TRUE);
|
|
const int words = int(size/2);
|
|
int module = 1;
|
|
for (int i = 0; i < words; i++)
|
|
{
|
|
for (int b = 0; b < 16; b++)
|
|
{
|
|
if (buff[i] & (1 << b))
|
|
ba.set(module, TRUE);
|
|
module++;
|
|
}
|
|
}
|
|
}
|
|
return size > 0;
|
|
}
|
|
|
|
unsigned rpc_DongleNumber()
|
|
{
|
|
_rpc_call = "DongleNumber()";
|
|
return (unsigned)IntCall();
|
|
}
|
|
|
|
unsigned rpc_DongleYear()
|
|
{
|
|
_rpc_call = "DongleYear()";
|
|
return (unsigned)IntCall();
|
|
}
|
|
|
|
static unsigned int CreatePassword(TString& pass)
|
|
{
|
|
const int BASE = 19;
|
|
unsigned int num = 0;
|
|
do
|
|
{
|
|
num = 883*rand();
|
|
while (num % 883 != 0) // Possible overflow
|
|
num++;
|
|
pass.cut(0);
|
|
char str[2] = { '\0', '\0' };
|
|
while (num > 0)
|
|
{
|
|
unsigned int k = num % BASE;
|
|
if (k < 10)
|
|
str[0] = '0'+k;
|
|
else
|
|
str[0] = 'A'+k-10;
|
|
num /= BASE;
|
|
pass.insert(str);
|
|
}
|
|
} while (pass.len() < 5);
|
|
return num;
|
|
}
|
|
|
|
bool rpc_UserLogin(const char* server, const char* user,
|
|
const char* dummy_password, const char* application)
|
|
{
|
|
if (_client == NULL)
|
|
{
|
|
if (!rpc_Start())
|
|
return FALSE;
|
|
}
|
|
|
|
const bool local = server == NULL || *server == '\0' ||
|
|
xvt_str_compare_ignoring_case(server, "127.0.0.1") == 0 ||
|
|
xvt_str_compare_ignoring_case(server, "localhost") == 0;
|
|
const TString name = local ? "locale" : server;
|
|
|
|
if (_connection != 0)
|
|
_client->RemoveConnection(_connection);
|
|
|
|
_connection = _client->QueryConnection("1883", server);
|
|
|
|
TString error;
|
|
if (_connection)
|
|
{
|
|
TString16 password;
|
|
CreatePassword(password);
|
|
|
|
_rpc_call.format("UserLogin(%s,%s,%s)", user, (const char*)password, application);
|
|
long answer = 0;
|
|
bool connected = _client->RequestInteger(_connection, _rpc_call, answer) != 0;
|
|
if (connected)
|
|
{
|
|
const bool logged = (answer == 1) || ((answer % 883 == 0) && (answer != 0));
|
|
if (!logged)
|
|
{
|
|
connected = FALSE;
|
|
error.format("La connessione di %s e' stata rifiutata dal Server %s",
|
|
(const char*)user, (const char*)name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.format("Impossibile connettersi al Server %s", (const char*)name);
|
|
}
|
|
|
|
if (!connected)
|
|
{
|
|
_client->RemoveConnection(_connection);
|
|
_connection = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!local)
|
|
error.format("Impossibile connettersi al Server %s", (const char*)name);
|
|
}
|
|
|
|
if (error.not_empty())
|
|
error_box(error);
|
|
|
|
return _connection != 0;
|
|
}
|
|
|
|
bool rpc_UserLogout()
|
|
{
|
|
if (_connection)
|
|
{
|
|
_rpc_call.format("UserLogout(%s)", (const char*)user());
|
|
rpc_Call(_rpc_call);
|
|
_client->RemoveConnection(_connection);
|
|
_connection = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
bool http_get(const char* server,
|
|
const char* remote_file,
|
|
const char* local_file,
|
|
const char* authorization)
|
|
{
|
|
TSocketClient client;
|
|
if (!client.IsOk())
|
|
return error_box("Impossibile inizializzare il client HTTP");
|
|
|
|
CONNID connection = client.QueryConnection("80", server);
|
|
bool ok = connection != 0;
|
|
if (ok)
|
|
{
|
|
ok = client.HttpGetFile(connection, remote_file, local_file, authorization) != 0;
|
|
|
|
client.RemoveConnection(connection);
|
|
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool http_dir(const char* server, const char* remote_dir, TString_array& list)
|
|
{
|
|
TSocketClient client;
|
|
if (!client.IsOk())
|
|
return error_box("Impossibile inizializzare il client HTTP");
|
|
|
|
unsigned long connection = client.QueryConnection("80", server);
|
|
bool ok = connection != 0;
|
|
if (ok)
|
|
{
|
|
ok = client.HttpGetDir(connection, remote_dir, list) != 0;
|
|
client.RemoveConnection(connection);
|
|
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
bool http_post(const char* server, const char* remote_file,
|
|
const char* local_file, const char* authorization,
|
|
byte*& answer, size_t& length)
|
|
|
|
{
|
|
TSocketClient client;
|
|
if (!client.IsOk())
|
|
return error_box("Impossibile inizializzare il client HTTP");
|
|
|
|
unsigned long connection = client.QueryConnection("80", server);
|
|
bool ok = connection != 0;
|
|
if (ok)
|
|
{
|
|
ok = client.HttpPostFile(connection, remote_file, local_file, authorization) != 0;
|
|
client.RemoveConnection(connection);
|
|
answer = client.GetBuffer(length);
|
|
|
|
if (!ok)
|
|
{
|
|
error_box("Impossibile spedire il file %s al server %s:\n%s",
|
|
local_file, server, answer);
|
|
}
|
|
}
|
|
else
|
|
return error_box("Impossibile connettersi al server %s", server);
|
|
return ok;
|
|
}
|
|
|