a0d4f678d9
Files correlati : Ricompilazione Demo : [ ] Commento : Aggiunta chiamata rpc_DongleYearActivate per permettere l'aggiornamento automatico dell'assistenza sul server di chiavi. Aggiunta possibilità di riferirsri ai campi del report nelle query delle sottosezioni git-svn-id: svn://10.65.10.50/branches/R_10_00@21358 c028cbd2-c16b-5b4b-a496-9718f37d4682
482 lines
11 KiB
C++
Executable File
482 lines
11 KiB
C++
Executable File
#include <xvt.h>
|
|
#include <diction.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(TR("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;
|
|
}
|
|
|
|
int rpc_Timeout(int sec)
|
|
{
|
|
CHECK(_client != NULL, "Client not initialized");
|
|
const int to = _client->Timeout();
|
|
if (sec >= 0)
|
|
_client->SetTimeout(sec);
|
|
return to;
|
|
}
|
|
|
|
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;
|
|
|
|
static bool BoolCall(int timeout = 0)
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
bool yes = false;
|
|
bool ok = false;
|
|
|
|
if (timeout > 0)
|
|
{
|
|
const int to = rpc_Timeout(timeout);
|
|
ok = _client->RequestBool(_connection, _rpc_call, yes);
|
|
rpc_Timeout(to);
|
|
}
|
|
else
|
|
ok = _client->RequestBool(_connection, _rpc_call, yes);
|
|
|
|
if (!ok)
|
|
{
|
|
#ifndef DBG
|
|
yesnofatal_box("RPC call failed: %s", (const char*)_rpc_call);
|
|
#endif
|
|
yes = false;
|
|
}
|
|
return yes;
|
|
}
|
|
|
|
static long IntCall(int timeout = 0)
|
|
{
|
|
CHECK(_connection, "Server not connected");
|
|
long n = 0;
|
|
bool ok = false;
|
|
if (timeout > 0)
|
|
{
|
|
const int to = rpc_Timeout(timeout);
|
|
ok = _client->RequestInteger(_connection, _rpc_call, n) != 0;
|
|
rpc_Timeout(to);
|
|
}
|
|
else
|
|
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;
|
|
}
|
|
|
|
static 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;
|
|
}
|
|
|
|
static bool BoolCallInt(const char* fn, long n)
|
|
{
|
|
_rpc_call.format("%s(%ld)", fn, n);
|
|
return BoolCall();
|
|
}
|
|
|
|
static long IntCallInt(const char* fn, long n)
|
|
{
|
|
_rpc_call.format("%s(%ld)", fn, n);
|
|
return IntCall();
|
|
}
|
|
|
|
static long IntCallIntInt(const char* fn, long n, long k)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld)", fn, n, k);
|
|
return IntCall();
|
|
}
|
|
|
|
static long IntCallIntIntInt(const char* fn, long n, long k, long f)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld,%ld)", fn, n, k, f);
|
|
return IntCall();
|
|
}
|
|
|
|
static 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();
|
|
}
|
|
|
|
static long IntCallIntStr(const char* fn, long n, const char* str)
|
|
{
|
|
_rpc_call.format("%s(%ld,|%s|)", fn, n, str);
|
|
return IntCall();
|
|
}
|
|
|
|
static 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();
|
|
}
|
|
|
|
static 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();
|
|
}
|
|
|
|
static long IntCallStr(const char* fn, const char* str)
|
|
{
|
|
_rpc_call.format("%s(%s)", fn, str);
|
|
return IntCall();
|
|
}
|
|
|
|
static TString& StrCallIntInt(const char* fn, long n, long k)
|
|
{
|
|
_rpc_call.format("%s(%ld,%ld)", fn, n, k);
|
|
return StrCall();
|
|
}
|
|
|
|
static 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(5);
|
|
}
|
|
|
|
unsigned rpc_DongleYear()
|
|
{
|
|
_rpc_call = "DongleYear()";
|
|
return (unsigned)IntCall(5);
|
|
}
|
|
|
|
bool rpc_DongleInfo(word& number, word& year, TBit_array& ba)
|
|
{
|
|
size_t size;
|
|
real time;
|
|
|
|
number = year = 0;
|
|
ba.reset(); ba.set(0, true);
|
|
|
|
const int to = rpc_Timeout(5); // change timeout
|
|
word* buff = (word*)rpc_Request("DongleInfo()", size, time);
|
|
rpc_Timeout(to); // restore timeout
|
|
|
|
if (buff && size > 4)
|
|
{
|
|
number = buff[0];
|
|
year = buff[1];
|
|
const int words = int(size/2);
|
|
int module = 1;
|
|
for (int i = 2; i < words; i++)
|
|
{
|
|
for (int b = 0; b < 16; b++)
|
|
{
|
|
if (buff[i] & (1 << b))
|
|
ba.set(module, true);
|
|
module++;
|
|
}
|
|
}
|
|
}
|
|
return (number >= 0) && (year > 2000);
|
|
}
|
|
|
|
|
|
static unsigned int create_password(TString& pass)
|
|
{
|
|
const int BASE = 19;
|
|
unsigned int num = 0;
|
|
const struct tm* t = xvt_time_now();
|
|
srand(t->tm_hour * 10000 + t->tm_min *100 + t->tm_sec);
|
|
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;
|
|
TString80 name;
|
|
if (local)
|
|
xvt_sys_get_host_name(name.get_buffer(), name.size());
|
|
else
|
|
name = server;
|
|
|
|
if (_connection != 0)
|
|
_client->RemoveConnection(_connection);
|
|
|
|
_connection = _client->QueryConnection("1883", server);
|
|
|
|
TString error;
|
|
if (_connection)
|
|
{
|
|
TString16 password;
|
|
create_password(password);
|
|
|
|
const int session = xvt_sys_get_session_id();
|
|
_rpc_call.format("UserLogin(%s,%s,%s,%d)", user, (const char*)password, application, session);
|
|
|
|
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(FR("La connessione di %s e' stata rifiutata dal Server %s"),
|
|
(const char*)user, (const char*)name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error.format(FR("Impossibile connettersi al Server %s"), (const char*)name);
|
|
}
|
|
|
|
if (!connected)
|
|
{
|
|
_client->RemoveConnection(_connection);
|
|
_connection = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!local)
|
|
error.format(FR("Impossibile connettersi al Server %s"), (const char*)name);
|
|
}
|
|
|
|
if (error.not_empty())
|
|
error_box(error);
|
|
|
|
return _connection != 0;
|
|
}
|
|
|
|
bool rpc_UserLogout(const char* appname)
|
|
{
|
|
if (_connection)
|
|
{
|
|
const int session = xvt_sys_get_session_id();
|
|
_rpc_call.format("UserLogout(%s,%d,%s)", (const char*)user(), session, appname);
|
|
//rpc_Call(_rpc_call); // Richiede il logout senza attendere la risposta
|
|
BoolCall(3); // Aspetta un po' in modo da permettere al server di esaminare la richiesta
|
|
_client->RemoveConnection(_connection); // Chiude la connessione
|
|
_connection = 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool rpc_DongleModuleActivate(word mod, bool on)
|
|
{
|
|
TString16 password;
|
|
create_password(password);
|
|
_rpc_call.format("DongleModuleActivate(%d,%d,%s)", mod, on, (const char*)password);
|
|
return BoolCall();
|
|
}
|
|
|
|
bool rpc_DongleUsersActivate(word users)
|
|
{
|
|
TString16 password;
|
|
create_password(password);
|
|
_rpc_call.format("DongleUsersActivate(%d,%s)", users, (const char*)password);
|
|
return BoolCall();
|
|
}
|
|
|
|
bool rpc_DongleYearActivate(word year)
|
|
{
|
|
TString16 password;
|
|
create_password(password);
|
|
_rpc_call.format("DongleYearActivate(%d,%s)", year, (const char*)password);
|
|
return BoolCall();
|
|
}
|
|
|
|
|
|
bool http_isredirected_server(TString& server,
|
|
TFilename& remote_file,
|
|
const char* authorization)
|
|
{
|
|
TSocketClient client;
|
|
if (!client.IsOk())
|
|
return error_box(TR("Impossibile inizializzare il client HTTP"));
|
|
|
|
CONNID connection = client.QueryConnection("80", server);
|
|
bool ok = connection != 0;
|
|
if (ok)
|
|
{
|
|
ok = client.HttpIsRedirectedServer(connection, server, remote_file, authorization) != 0;
|
|
client.RemoveConnection(connection);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
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(TR("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(TR("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(TR("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(FR("Impossibile spedire il file %s al server %s:\n%s"),
|
|
local_file, server, answer);
|
|
}
|
|
}
|
|
else
|
|
return error_box(FR("Impossibile connettersi al server %s"), server);
|
|
return ok;
|
|
}
|
|
|