/****************************************************************************/
/**                                                                        **/
/**                           Hardlock API-Calls                           **/
/**                                                                        **/
/**   This program is just an example for some functions to access the     **/
/**   application programing interface (API) for Hardlock. Feel free to    **/
/**   define your own functions.                                           **/
/**                                                                        **/
/**                ///FAST Software Security - Group Aladdin               **/
/**                                                                        **/
/**              Computer: IBM PC or compatible                            **/
/**                   OS : MS-PC/DOS 2.0 or higher and MS Windows 3.x      **/
/**              Language: C                                               **/
/**                                                                        **/
/**  Revision history                                                      **/
/**  ----------------                                                      **/
/**  (related to API version)                                              **/
/**  3.18  -- Get the TaskID from API function.                            **/
/**        -- HL_MEMINF strategy changed                                   **/
/**        -- New function: HL_HLSVERS: return HL-Server version           **/
/**  3.19  -- ifdef for Symantec C included (DOS386)                       **/
/**        -- CENTRY-DLL_USE combination (for Windows NT/32s) by Chris     **/
/**  3.22  -- Search order added to HL_LOGIN, call to function (33).       **/
/**  3.23  -- Search order removed, handeled internal by LowAPI.           **/
/**        -- HL_LOGOUT, HL_LOGIN optimized (call API_LOGIN and API_LOGOUT **/
/**           only for remote access).                                     **/
/**        -- Environment search string not yet supported for FlashTek.    **/
/**           Must be compiled with /dNO_ENVCHK                            **/
/**        -- release                                                      **/
/**  3.24  -- API_Function defined                                         **/
/**  3.25  -- Bugfix for HL-Server licenced to one user.                   **/
/**        -- No further checks on HL_LOGIN on specific errors.            **/
/**                                                                        **/
/**  (related to VCS version)
***  $Log: not supported by cvs2svn $
***  Revision 1.5  1996/10/02 20:34:09  HENRI
***  Added GETSTRUC define because of wrong pointer init by old Power Fortran linker.
***  
***  Revision 1.4  1996/09/18 11:52:14  henri
***  Support for multi API strutures.
***
***  Revision 1.3  1996/08/08 14:47:01  henri
***  Added VCS log.
***
**/
/****************************************************************************/

#include "StdAfx.h"

#ifdef  _MSC_VER
  #pragma warning (disable:4103)                /* no #pragma pack warnings */
#endif

#define GETSTRUC if (!api_struc) api_struc = &hl_struc

#include "hlapi_c.h"

static HL_API hl_struc = {{0}};                 /* Hardlock API structure   */
static HL_API DATAFAR_ *api_struc=0;            /* Pointer to API structure */

static Word CALL_API (HL_API DATAFAR_ *api_struc);

#ifdef __cplusplus
  extern "C" {
#endif

#ifdef M_UNIX
  #define CENTRY
#endif

#ifdef LINUX
  #define CENTRY
#endif

#ifdef WINNT
  #define CENTRY
  #ifdef __WATCOMC__
    #pragma aux cdecl "_*" parm caller [] value struct routine [eax] modify [eax ebx ecx edx]
    #pragma aux (cdecl) API_HL_CSTACK;
  #endif
#endif

#ifdef SALFORD
  #include <dbos\lib.h>
  #define CENTRY
#endif

#ifdef CENTRY
  #ifdef DLL_USE
    #ifdef WINNT
      extern Word __stdcall _API_DLL(HL_API DATAFAR_ *api_struc);
      #define API_Function _API_DLL
    #endif
  #else
    #ifdef WINNT
      extern Word FAR_ __cdecl API_HL_CSTACK(HL_API DATAFAR_ *api_struc);
    #else
      extern Word FAR_ API_HL_CSTACK(HL_API DATAFAR_ *api_struc);
    #endif
    #define API_Function API_HL_CSTACK
  #endif
#else
  #ifdef DLL_USE
    extern Word FAR_ pascal _API_DLL(HL_API DATAFAR_ *api_struc);
    #define API_Function _API_DLL
  #else
    #ifdef __HIGHC__
      extern Word _API_HL_CSTACK(HL_API DATAFAR_ *api_struc);
      #define API_Function _API_HL_CSTACK
    #else
      extern Word FAR_ pascal _API_HL_STACK(HL_API DATAFAR_ *api_struc);
      #define API_Function _API_HL_STACK
    #endif
  #endif
#endif

#ifdef __cplusplus
  }
#endif

/****************************************************************************/
static Word CALL_API(HL_API DATAFAR_ *api_struc)
/****************************************************************************/
{
Word result;

/* ----------------- */
/* We call the API : */
/* ----------------- */

#ifdef SALFORD
  set_io_permission(1);
#endif

result = API_Function(api_struc);

#ifdef SALFORD
  set_io_permission(0);
#endif

return result;
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_SELECT(HL_API DATAFAR_ *hl_ptr)
/****************************************************************************/
{
if (!hl_ptr)
  api_struc = &hl_struc;
 else
  api_struc = hl_ptr;

return (STATUS_OK);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_LOGOUT(void)
/****************************************************************************/
{
GETSTRUC;
if (api_struc->Remote == NET_DEVICE)
  {
  api_struc->Function = API_LOGOUT;
  CALL_API(api_struc);
  }

api_struc->Function = API_DOWN;
CALL_API(api_struc);
if (api_struc->Status)
  {
  api_struc->Function = API_FORCE_DOWN;
  CALL_API(api_struc);
  }

api_struc->Task_ID = 0;
return (api_struc->Status);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_PORTINF(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function = API_AVAIL;
CALL_API(api_struc);

if (api_struc->Status) return (0xffff);
return (api_struc->Port);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_USERINF(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function    = API_INFO;
api_struc->Application = 0;
CALL_API(api_struc);

if (api_struc->Status) return (0xffff);
return (api_struc->NetUsers);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_MAXUSER(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function = API_INFO;
CALL_API(api_struc);

if (api_struc->Status) return (0xffff);
return (api_struc->MaxUsers);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_ACCINF(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function = API_AVAIL;
CALL_API(api_struc);

if (api_struc->Status) return (0xffff);
return (api_struc->Remote);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_VERSION(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function = API_AVAIL;
CALL_API(api_struc);

if (api_struc->Status) return (0xffff);
return ((api_struc->API_Version_ID[0] * 100) + api_struc->API_Version_ID[1]);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_HLSVERS(void)
/****************************************************************************/
{
Word result;

GETSTRUC;
if (api_struc->Remote == NET_DEVICE)
  {
  api_struc->Function  = API_AVAIL;
  result               = CALL_API(api_struc);
  if (result == STATUS_OK)
    return (api_struc->ShortLife);
  }
return 0;
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_AVAIL(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function = API_AVAIL;
CALL_API(api_struc);

if ((api_struc->Status == NO_DONGLE) && (api_struc->ShortLife == 1) && (api_struc->Remote == LOCAL_DEVICE))
  return(SELECT_DOWN);

return (api_struc->Status);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_CODE(void DATAFAR_ *Data, Word Cnt)
/****************************************************************************/
{
GETSTRUC;
api_struc->Data     = Data;
api_struc->Bcnt     = Cnt;
api_struc->Function = API_KEYE;
CALL_API(api_struc);
api_struc->Bcnt     = 0;

return (api_struc->Status);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_LOGIN(Word ModAd, Word Access, Byte DATAFAR_ * RefKey, Byte DATAFAR_ * VerKey)
/****************************************************************************/
{
Word  result;
Long  OldTimerID;
Word  OldRemote, OldPort;
short i;

GETSTRUC;
OldRemote  = api_struc->Remote;
OldTimerID = api_struc->Task_ID;
OldPort    = api_struc->Port;

api_struc->ModID            = EYE_DONGLE;
api_struc->Remote           = Access;
api_struc->Module.Eye.ModAd = ModAd;

/* --------------------- */
/* Get TaskID from API : */
/* --------------------- */
#ifndef DOS386
if (api_struc->Task_ID == 0)
  {
  api_struc->Function = API_GET_TASKID;
  CALL_API(api_struc);
  }
#endif

api_struc->Protocol = 0;
api_struc->Port     = 0;
api_struc->Timeout  = 0;
api_struc->PM_Host  = API_XTD_DETECT;

/* -------------------------------------------- */
/* We generated a verify key with TESTAPI.EXE : */
/* -------------------------------------------- */
for (i = 0; i < 8; i++)
  {
  api_struc->ID_Ref[i]    = RefKey[i];
  api_struc->ID_Verify[i] = VerKey[i];
  }

/* ------------------------- */
/* Don't check for HL_SEARCH */
/* ------------------------- */
#ifdef NO_ENVCHK
api_struc->EnvMask |= IGNORE_ENVIRONMENT;
#endif

/* --------------------------------------------- */
/* Call the INIT (search for Hardlock) function :*/
/* --------------------------------------------- */
api_struc->Function = API_INIT;
result             = CALL_API(api_struc);
if (result == ALREADY_INIT)
  {
  api_struc->Remote  = OldRemote;
  api_struc->Task_ID = OldTimerID;
  api_struc->Port    = OldPort;
  return result;
  }

/* ----------------------------- */
/* No further checks necessary : */
/* ----------------------------- */
if ((result == INVALID_ENV) || (result == CANNOT_OPEN_DRIVER))
  return (result);

/* ----------------------------- */
/* Check, if HL-Server is full : */
/* ----------------------------- */
if (result != STATUS_OK)
  {
  if ((Access & NET_DEVICE) == NET_DEVICE)
    {
    api_struc->Function = API_LOGIN_INFO;
    if (CALL_API(api_struc) == HLS_FULL)
      result = TOO_MANY_USERS;
    }
  return (result);
  }

/* ------------------------------------------ */
/* Login to HL-Server if Hardlock is remote : */
/* ------------------------------------------ */
if (api_struc->Remote == NET_DEVICE)
  {
  api_struc->Function = API_LOGIN;
  result              = CALL_API(api_struc);
  if(result)
    {
    api_struc->Function = API_DOWN;
    CALL_API(api_struc);
    }
  }

return result;
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_READ(Word Reg, Word DATAFAR_ *Value)
/****************************************************************************/
{
GETSTRUC;
if(Reg <= 63)
  {
  api_struc->Module.Eye.Reg = Reg;
  api_struc->Function       = API_READ;
  CALL_API(api_struc);
  if(api_struc->Status) return (api_struc->Status);
   *Value = api_struc->Module.Eye.Value;
  return (STATUS_OK);
  }

return (INVALID_PARAM);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_READBL(Byte DATAFAR_ * Eeprom)
/****************************************************************************/
{
GETSTRUC;
api_struc->Bcnt     = 16;
api_struc->Data     = Eeprom;
api_struc->Function = API_READ_BLOCK;
CALL_API(api_struc);
api_struc->Bcnt     = 0;

return (api_struc->Status);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_WRITEBL(Byte DATAFAR_ * Eeprom)
/****************************************************************************/
{
GETSTRUC;
api_struc->Bcnt     = 4;
api_struc->Data     = Eeprom;
api_struc->Function = API_WRITE_BLOCK;
CALL_API(api_struc);
api_struc->Bcnt     = 0;

return (api_struc->Status);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_ABORT(void)
/****************************************************************************/
{
GETSTRUC;
api_struc->Function = API_LOGOUT;
CALL_API(api_struc);
api_struc->Function = API_ABORT;
CALL_API(api_struc);

return (api_struc->Status);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_WRITE(Word Reg, Word Value)
/****************************************************************************/
{
GETSTRUC;
if(Reg >= 48 && Reg <= 63)
  {
  api_struc->Module.Eye.Reg   = Reg;
  api_struc->Module.Eye.Value = Value;
  api_struc->Function         = API_WRITE;
  CALL_API(api_struc);
  return (api_struc->Status);
  }

return (INVALID_PARAM);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_MEMINF(void)
/****************************************************************************/
{
Word newvalue, oldvalue;
Word TestMem = 0;
Byte Memory[128];
int i;

/* -------------------------- */
/* Read memory in one block : */
/* -------------------------- */
GETSTRUC;
api_struc->Bcnt     = 16;
api_struc->Data     = Memory;
api_struc->Function = API_READ_BLOCK;
CALL_API(api_struc);
api_struc->Bcnt     = 0;
if (api_struc->Status != STATUS_OK)
  return (NO_ACCESS);

/* -------------------------------------- */
/* Check, if every value is zero or one : */
/* -------------------------------------- */
for (i = 0; i < 128; i++)
  TestMem |= Memory[i];
if (TestMem != 0)
  {
  for (i = 0; i < 128; i++)
    {
    if (Memory[i] != 0xff)
      return (STATUS_OK);
    }
  }

/* ---------------------- */
/* Save memory contents : */
/* ---------------------- */
api_struc->Module.Eye.Reg = 48;
api_struc->Function       = API_READ;
CALL_API(api_struc);
if(api_struc->Status) return (NO_ACCESS);
oldvalue                 = api_struc->Module.Eye.Value;

/* ---------------------------------------------------------------- */
/* XOR of the read value to exclude random returns from interface : */
/* ---------------------------------------------------------------- */
newvalue = oldvalue ^ 0x0d0e;

/* ------------------------ */
/* Write new memory value : */
/* ------------------------ */
api_struc->Module.Eye.Value = newvalue;
api_struc->Function         = API_WRITE;
CALL_API(api_struc);
if(api_struc->Status)
 {
 api_struc->Module.Eye.Value = oldvalue;
 api_struc->Function         = API_WRITE;
 CALL_API(api_struc);
 return(NO_ACCESS);
 }

/* ------------------------- */
/* Read and compare memory : */
/* ------------------------- */
api_struc->Function = API_READ;
CALL_API(api_struc);
if(api_struc->Status)
 {
 api_struc->Module.Eye.Value = oldvalue;
 api_struc->Function         = API_WRITE;
 CALL_API(api_struc);
 return(NO_ACCESS);
 }
if (api_struc->Module.Eye.Value != newvalue)
 {
 api_struc->Module.Eye.Value = oldvalue;
 api_struc->Function         = API_WRITE;
 CALL_API(api_struc);
 return(NO_ACCESS);
 }

/* ------------------ */
/* Write old memory : */
/* ------------------ */
api_struc->Module.Eye.Value = oldvalue;
api_struc->Function         = API_WRITE;
CALL_API(api_struc);
if(api_struc->Status)
 {
 api_struc->Module.Eye.Value = oldvalue;
 api_struc->Function         = API_WRITE;
 CALL_API(api_struc);
 return(NO_ACCESS);
 }

return (STATUS_OK);
}

/****************************************************************************/
/****************************************************************************/
/* The following functions map the old Hardlock Calls on the new API. These */
/* functions are defined only for compatibility reasons.                    */
/* !!! Don't mix old and new functions. Don't use if it is not necessary.!!!*/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
void FAR_ CALL_ INT_ON (void)
/****************************************************************************/
{return;}

/****************************************************************************/
void FAR_ CALL_ INT_OFF (void)
/****************************************************************************/
{return;}

/****************************************************************************/
void FAR_ CALL_ HL_ON (Word Port, Word ModAd)
/****************************************************************************/
{
GETSTRUC;
api_struc->ModID            = EYE_DONGLE;
api_struc->Remote           = LOCAL_DEVICE;
api_struc->Module.Eye.ModAd = ModAd;
api_struc->Port             = Port;
api_struc->Function         = API_INIT;
CALL_API(api_struc);
if(api_struc->Status) return;

api_struc->Function = API_LOGIN;
CALL_API(api_struc);
if(api_struc->Status)
 {
 api_struc->Function = API_DOWN;
 CALL_API(api_struc);
 }

return;
}

/****************************************************************************/
void FAR_ CALL_ HL_OFF (Word Port)
/****************************************************************************/
{
GETSTRUC;
api_struc->Port     = Port;
api_struc->Function = API_LOGOUT;
CALL_API(api_struc);

api_struc->Function = API_DOWN;
CALL_API(api_struc);
if (api_struc->Status)
  {
  api_struc->Function = API_FORCE_DOWN;
  CALL_API(api_struc);
  }
return;
}

/****************************************************************************/
Word FAR_ CALL_ K_EYE (Word Port, char  DATAFAR_ *Inp, Word BlkCnt)
/****************************************************************************/
{
GETSTRUC;
api_struc->Port     = Port;
api_struc->Data     = Inp;
api_struc->Bcnt     = BlkCnt;
api_struc->Function = API_KEYE;
CALL_API(api_struc);
api_struc->Bcnt     = 0;

if (api_struc->Status)
  return (0);
return (1);
}

/****************************************************************************/
void FAR_ CALL_ HL_WR (Word Port, Word Reg, Word Val)
/****************************************************************************/
{
GETSTRUC;
if(Reg >= 48 && Reg <= 63)
  {
  api_struc->Port             = Port;
  api_struc->Module.Eye.Reg   = Reg;
  api_struc->Module.Eye.Value = Val;
  api_struc->Function         = API_WRITE;
  CALL_API(api_struc);
  }
return;
}

/****************************************************************************/
Word FAR_ CALL_ HL_RD (Word Port, Word Reg)
/****************************************************************************/
{
GETSTRUC;
if(Reg <= 63)
  {
  api_struc->Port           = Port;
  api_struc->Module.Eye.Reg = Reg;
  api_struc->Function       = API_READ;
  CALL_API(api_struc);
  if (api_struc->Status == STATUS_OK)
    return (api_struc->Module.Eye.Value);
  }

return (0);
}

/****************************************************************************/
RET_ FAR_ CALL_ HL_CALC (Word i1, Word i2, Word i3, Word i4)
/****************************************************************************/
{
unsigned short Shift1, Shift2;

GETSTRUC;
api_struc->Function = 16;   /* Function: query Hardlock in compatible mode */

Shift1 = i1 | (i2 << 8);
Shift2 = i3 | (i4 << 8);
api_struc->Timeout = (Long) Shift1 | (Long) (Shift2 * 0x10000L);

CALL_API(api_struc);
if(api_struc->Status)
  return 0;
 else
  return api_struc->ShortLife;
}