EgtGeneral/GeyKeyData.cpp

//----------------------------------------------------------------------------
//  EgalTech 2023-2023
//----------------------------------------------------------------------------
// File : GetKeyData.cpp       Data : 29.05.23        Versione : 2.5e3
// Contenuto : Funzione che restituisce i dati della chiave di protezione.
//
//
//
// Modifiche : 29.05.23 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "DllMain.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGnGetKeyData.h"
#include "/EgtDev/Include/SELkKeyProc.h"
#include "/EgtDev/Include/SELkLockId.h"

using namespace std ;

//-----------------------------------------------------------------------------
static int s_nKeyLevRet = - 1;
static int s_nKeyLev = 0 ;
static int s_nKeyExpDays = 0 ;
static int s_nKeyOptRet = - 1;
static int s_nKeyOpt1 = 0 ;
static int s_nKeyOpt2 = 0 ;
static int s_nKeyOptExpDays = 0 ;

//-----------------------------------------------------------------------------
bool
SetEGnKeyLevel( int nRet, int nKeyLev, int nKeyExpDays)
{
   s_nKeyLevRet = nRet ;
   s_nKeyLev = nKeyLev ;
   s_nKeyExpDays = nKeyExpDays ;
   return true ;
}

//-----------------------------------------------------------------------------
int
GetEGnKeyLevel( int nProd, int nVer, int nLev, int& nKeyLev, int& nKeyExpDays)
{
  // Chiave di rete
   if ( GetEGnNetHwKey()) {
      int nCurrDay = GetCurrDay() ;
      int nMinDay = GetMinDay() ;
      if ( nCurrDay < nMinDay)
         return KEY_ERR_WRONG_TIME ;
   }
   // chiave Hw locale
   else {
      int nMyKeyLev, nMyKeyExpDays ;
      int nRet = GetKeyLevel( GetEGnKey(), nProd, nVer, nLev, nMyKeyLev, nMyKeyExpDays) ;
      s_nKeyLevRet = nRet ;
      s_nKeyLev = nMyKeyLev ;
      s_nKeyExpDays = nMyKeyExpDays ;
   }
  // restituzione dati
   nKeyLev = s_nKeyLev ;
   nKeyExpDays = s_nKeyExpDays ;
   return s_nKeyLevRet ;
}

//-----------------------------------------------------------------------------
bool
SetEGnKeyOptions( int nRet, int nKeyOpt1, int nKeyOpt2, int nKeyOptExpDays)
{
   s_nKeyOptRet = nRet ;
   s_nKeyOpt1 = nKeyOpt1 ;
   s_nKeyOpt2 = nKeyOpt2 ;
   s_nKeyOptExpDays = nKeyOptExpDays ;
   return true ;
}

//-----------------------------------------------------------------------------
int
GetEGnKeyOptions( int nProd, int nVer, int nLev, unsigned int& nKeyOpt1, unsigned int& nKeyOpt2, int& nKeyOptExpDays)
{
  // Chiave di rete
   if ( GetEGnNetHwKey()) {
      int nCurrDay = GetCurrDay() ;
      int nMinDay = GetMinDay() ;
      if ( nCurrDay < nMinDay)
         return KEY_ERR_WRONG_TIME ;
   }
   // chiave Hw locale
   else {
      unsigned int nMyKeyOpt1, nMyKeyOpt2 ;
      int nMyKeyOptExpDays ;
      int nRet = GetKeyOptions( GetEGnKey(), nProd, nVer, nLev, nMyKeyOpt1, nMyKeyOpt2, nMyKeyOptExpDays) ;
      s_nKeyOptRet = nRet ;
      s_nKeyOpt1 = nMyKeyOpt1 ;
      s_nKeyOpt2 = nMyKeyOpt2 ;
      s_nKeyOptExpDays = nMyKeyOptExpDays ;
   }
  // restituzione dati
   nKeyOpt1 = s_nKeyOpt1 ;
   nKeyOpt2 = s_nKeyOpt2 ;
   nKeyOptExpDays = s_nKeyOptExpDays ;
   return s_nKeyOptRet ;
}

//-----------------------------------------------------------------------------
bool
GetLockIdStringInfo( const string& sLockId, int& nKeyType, bool& bNetKey, int& nUserId)
{
  // se chiave software
   if ( sLockId.find( KEY_LOCK_HW_START) != 0) {
      nKeyType = KEY_LOCK_TYPE_SW ;
      bNetKey = false ;
      nUserId = 0 ;
      return true ;
   }

  // le chiavi hardware sono divise in tre parti XXX-NNN-WWW di cui la intermedia numerica
   STRVECTOR vsTok ;
   Tokenize( sLockId, "-", vsTok) ;
   int nKey ;
   if ( vsTok.size() != 3  ||  ! FromString( vsTok[1], nKey)) {
      nKeyType = KEY_LOCK_TYPE_ANY ;
      bNetKey = false ;
      nUserId = 0 ;
      return false ;
   }
  // se chiave locale
   if ( vsTok[1].front() != '1') {
      nKeyType = KEY_LOCK_TYPE_HW ;
      bNetKey = false ;
      nUserId = 0 ;
      return true ;
   }
  // altrimenti chiave di rete
   nKeyType = KEY_LOCK_TYPE_HW ;
   bNetKey = true ;
   nUserId = ( nKey % 10) ;
   if ( nKey < 100110)
      nUserId = 0 ;
   return true ;
}

//-----------------------------------------------------------------------------
bool
GetLockIdStringNetData( const string& sLockId, string& sAddrPort)
{
  // default niente
   sAddrPort = "" ;

  // se chiave software
   if ( sLockId.find( KEY_LOCK_HW_START) != 0)
      return true ;

  // le chiavi hardware possono avere una stringa con indirizzo e porta dopo il carattere '@'
   STRVECTOR vsTok ;
   Tokenize( sLockId, "@", vsTok) ;
   if ( vsTok.size() == 2) {
      sAddrPort = vsTok[1] ;
      Trim( sAddrPort) ;
   }

   return true ;
}