336 lines
6.6 KiB
C++
Executable File
336 lines
6.6 KiB
C++
Executable File
#include "StdAfx.h"
|
||
|
||
#include "hlapi_c.h"
|
||
#define EYECAST (Word DATAFAR_ *)
|
||
|
||
extern "C"
|
||
{
|
||
#include "skeytsr.h"
|
||
}
|
||
static KEY_NET _Eutron;
|
||
|
||
#pragma pack(1)
|
||
struct TEutronHeader
|
||
{
|
||
char _serno[8];
|
||
unsigned short _year_assist;
|
||
unsigned short _max_users;
|
||
unsigned long _last_date;
|
||
unsigned long _scad_date;
|
||
unsigned long _checksum; // Must be the last item!
|
||
};
|
||
#pragma pack()
|
||
|
||
#include "connect.h"
|
||
#include "server.h"
|
||
#include "tracing.h"
|
||
|
||
#ifdef _DEBUG
|
||
#define new DEBUG_NEW
|
||
#undef THIS_FILE
|
||
static char THIS_FILE[] = __FILE__;
|
||
#endif
|
||
|
||
|
||
|
||
// @doc INTERNAL
|
||
|
||
// @rdesc Ritorna il valore corrispondente alla chiave appartenente
|
||
// ad una sezione del file di configurazione
|
||
|
||
static CString GetIniString(LPCSTR sec, // @parm Sezione
|
||
LPCSTR key, // @parm Chiave
|
||
LPCSTR def) // @parm Valore di default
|
||
{
|
||
// Nome del file .ini
|
||
static CString m_strIniFile;
|
||
|
||
// Lunghezza massima di un nome di directory
|
||
// o di un valore del file .ini
|
||
const DWORD dwSize = _MAX_DIR + 1;
|
||
|
||
// Costruisce il nome del file .ini se necessario
|
||
if (m_strIniFile.IsEmpty())
|
||
{
|
||
GetCurrentDirectory(dwSize, m_strIniFile.GetBuffer(dwSize));
|
||
m_strIniFile.ReleaseBuffer();
|
||
m_strIniFile += "\\prawin.ini";
|
||
}
|
||
|
||
// Legge il valore della chiave nella sezione specificata
|
||
CString tmp;
|
||
char* buf = tmp.GetBuffer(dwSize);
|
||
GetPrivateProfileString(sec, key, def, buf, dwSize, m_strIniFile);
|
||
tmp.ReleaseBuffer();
|
||
return tmp;
|
||
}
|
||
|
||
// @doc EXTERNAL
|
||
|
||
// @func Permette di criptare una parola
|
||
//
|
||
// @rdesc Ritorna la stringa criptata
|
||
const char* Encode(
|
||
const char* strin, // @parm Stringa da criptare
|
||
char* strout) // @parm Stringa criptata
|
||
|
||
// @xref <f decode>
|
||
{
|
||
const char * const encryption_key = "QSECOFR-";
|
||
for (int i = 0; strin[i]; i++)
|
||
strout[i] = strin[i] + (i < 8 ? encryption_key[i] : strin[i-8]);
|
||
strout[i] = '\0';
|
||
return strout;
|
||
}
|
||
|
||
|
||
BOOL TDongleServer::ReadEutronWords(unsigned short reg,
|
||
unsigned short num,
|
||
unsigned short* data)
|
||
{
|
||
ASSERT(num > 0 && num <= 16);
|
||
_Eutron.net_command = NET_KEY_ACCESS;
|
||
memcpy(&_Eutron.command, BLOCK_READING_MODE, 2);
|
||
unsigned short* pointer = (unsigned short*)(&_Eutron.data[0]);
|
||
unsigned short* number = (unsigned short*)(&_Eutron.data[2]);
|
||
*pointer = reg;
|
||
*number = num;
|
||
smartlink(&_Eutron);
|
||
BOOL ok = _Eutron.status == ST_OK;
|
||
if (ok)
|
||
memcpy(data, &_Eutron.data[4], num*2);
|
||
return ok;
|
||
}
|
||
|
||
BOOL TDongleServer::ReadHardlockWords(unsigned short reg,
|
||
unsigned short num,
|
||
unsigned short* data)
|
||
{
|
||
BOOL ok = HL_AVAIL() == STATUS_OK;
|
||
if (ok)
|
||
{
|
||
for (unsigned short n = 0; n < num; n++)
|
||
HL_READ(reg+n, EYECAST &data[n]);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
|
||
BOOL TDongleServer::HardlockLogin()
|
||
{
|
||
const char* const REFKEY = "CAMPOKEY";
|
||
const char* const VERKEY = "<EFBFBD>pو<EFBFBD>c<EFBFBD><";
|
||
|
||
unsigned char ref[9]; strcpy((char*)ref, REFKEY);
|
||
unsigned char ver[9]; strcpy((char*)ver, VERKEY);
|
||
|
||
const int status = HL_LOGIN(26952, LOCAL_DEVICE, ref, ver);
|
||
|
||
Trace(-1, "Login Hardlock %s: %d",
|
||
status == STATUS_OK ? "OK" : "FALLITO", status);
|
||
|
||
_SerNo = 0xFFFF;
|
||
if (status == STATUS_OK)
|
||
{
|
||
Word Val[4] = { 0, 0, 0, 0 };
|
||
ReadHardlockWords(0, 4, Val);
|
||
HL_CODE(EYECAST Val, 1);
|
||
if (Val[0] == 0xFAE8)
|
||
_SerNo = Val[1];
|
||
else
|
||
_SerNo = 0;
|
||
|
||
if (_SerNo != 0)
|
||
{
|
||
ReadHardlockWords(60, 4, Val);
|
||
HL_CODE(EYECAST Val, 1);
|
||
_AssistanceYear = Val[0];
|
||
_Users = Val[1];
|
||
|
||
int index = 0;
|
||
for (unsigned short reg = 48; reg < 60; reg += 4)
|
||
{
|
||
ReadHardlockWords(reg, 4, Val);
|
||
HL_CODE(EYECAST Val, 1);
|
||
memcpy(&_int_tab[index], Val, 3);
|
||
index += 3;
|
||
}
|
||
}
|
||
}
|
||
|
||
return status == STATUS_OK;
|
||
}
|
||
|
||
BOOL TDongleServer::EutronLogin()
|
||
{
|
||
BOOL ok = FALSE;
|
||
memset(&_Eutron, 0, sizeof(_Eutron));
|
||
_Eutron.net_command = NET_KEY_OPEN;
|
||
|
||
const char* labels[2] = { "AGA.CAMPO", "2699DP" };
|
||
for (int k = 0; k < 2; k++)
|
||
{
|
||
memset(_Eutron.label, 0, LABEL_LENGTH);
|
||
memcpy(_Eutron.label, labels[k], strlen(labels[k]));
|
||
memset(_Eutron.password, 0, PASSWORD_LENGTH);
|
||
if (k == 0)
|
||
{
|
||
char pwd[PASSWORD_LENGTH];
|
||
Encode(labels[k], pwd);
|
||
memcpy(_Eutron.password, pwd, strlen(pwd));
|
||
}
|
||
smartlink(&_Eutron);
|
||
ok = _Eutron.status == ST_OK;
|
||
if (ok)
|
||
{
|
||
if (k == 1)
|
||
_SerNo = 0;
|
||
break;
|
||
}
|
||
}
|
||
Trace(-1, "Login Eutron %s: %d",
|
||
ok ? "OK" : "FALLITO", _Eutron.status);
|
||
|
||
if (ok && _SerNo != 0)
|
||
{
|
||
TEutronHeader eh;
|
||
if (ReadEutronWords(0, sizeof(TEutronHeader)/2, (unsigned short*)&eh))
|
||
{
|
||
char serno[16];
|
||
strncpy(serno, eh._serno, 8);
|
||
serno[8] = '\0';
|
||
_SerNo = (unsigned long)atol(serno);
|
||
if (eh._max_users > 0)
|
||
{
|
||
_Users = eh._max_users;
|
||
_AssistanceYear = eh._year_assist;
|
||
ReadEutronWords(16, 16, _int_tab);
|
||
}
|
||
}
|
||
}
|
||
|
||
return _Eutron.status == ST_OK;
|
||
}
|
||
|
||
|
||
BOOL TDongleServer::Login()
|
||
{
|
||
BOOL ok = HardlockLogin() || EutronLogin();
|
||
if (ok)
|
||
{
|
||
if (_SerNo == 0 || _Users == 0)
|
||
{
|
||
const CTime tNow = CTime::GetCurrentTime();
|
||
_AssistanceYear = tNow.GetYear();
|
||
if (_SerNo == 0)
|
||
{
|
||
_Users = 4;
|
||
memset(_int_tab, 0xFF, sizeof(_int_tab));
|
||
}
|
||
else
|
||
{
|
||
_Users = 1;
|
||
memset(_int_tab, 0x00, sizeof(_int_tab));
|
||
}
|
||
}
|
||
|
||
Trace(-1, "Numero di serie %u", _SerNo);
|
||
Trace(-1, "Anno assistenza %u", _AssistanceYear);
|
||
Trace(-1, "Numero utenti %u", _Users);
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
void TDongleServer::Logout()
|
||
{
|
||
if (_Eutron.label[0])
|
||
{
|
||
_Eutron.net_command = NET_KEY_CLOSE;
|
||
smartlink(&_Eutron);
|
||
}
|
||
else
|
||
{
|
||
HL_LOGOUT();
|
||
}
|
||
_SerNo = 0xFFFF;
|
||
_Users = 0;
|
||
_AssistanceYear = 0;
|
||
memset(_int_tab, 0, sizeof(_int_tab));
|
||
}
|
||
|
||
BOOL TDongleServer::OnConnect(const CString& topic)
|
||
{
|
||
BOOL ok = Connections() <= MaxUsers();
|
||
if (!ok)
|
||
Trace(0, "Refusing Topic %s", (const char*)topic);
|
||
return ok;
|
||
}
|
||
|
||
|
||
TConnection* TDongleServer::OnCreateConnection(DWORD id)
|
||
{
|
||
TConnection* c = NULL;
|
||
if (Connections() <= MaxUsers())
|
||
{
|
||
Trace(0, "Connecting %lu", id);
|
||
c = new TPrassiConnection(this, id);
|
||
}
|
||
else
|
||
Trace(0, "Refusing Connection %lu", id);
|
||
return c;
|
||
}
|
||
|
||
BOOL TDongleServer::OnRemoveConnection(DWORD id)
|
||
{
|
||
Trace(0, "Disconnecting %lu", id);
|
||
return BASE_SERVER::OnRemoveConnection(id);
|
||
}
|
||
|
||
TDongleServer::TDongleServer()
|
||
: BASE_SERVER("DONGLE")
|
||
{
|
||
_SerNo = 0xFFFF;
|
||
_Users = 0;
|
||
_AssistanceYear = 0;
|
||
memset(_int_tab, 0, sizeof(_int_tab));
|
||
Login();
|
||
}
|
||
|
||
TDongleServer::~TDongleServer()
|
||
{
|
||
if (_SerNo != 0xFFFF)
|
||
Logout();
|
||
}
|
||
|
||
|
||
///////////////////////////////////////////////////////////
|
||
// Start/Stop server
|
||
|
||
static TDongleServer* pDDE = NULL;
|
||
|
||
BOOL StopServer()
|
||
{
|
||
BOOL ok = pDDE != NULL;
|
||
if (ok)
|
||
{
|
||
delete pDDE;
|
||
pDDE = NULL;
|
||
}
|
||
return ok;
|
||
}
|
||
|
||
TDongleServer& GetServer()
|
||
{
|
||
ASSERT(pDDE);
|
||
return *pDDE;
|
||
}
|
||
|
||
BOOL StartServer()
|
||
{
|
||
BOOL ok = pDDE == NULL;
|
||
if (ok)
|
||
pDDE = new TDongleServer;
|
||
return ok;
|
||
}
|
||
|