/**
 * Copyright(c) 2011 Trusted Logic.   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Trusted Logic nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
* File            : ssdi.h
*
* Original-Author : Trusted Logic S.A.
*
* Created         : May 31, 2006
*/

/**
 * SSDI specification 3.0 header file.
 */

#ifndef __SSDI_H__
#define __SSDI_H__

#include "s_type.h"
#include "s_error.h"

#ifndef SSDI_EXPORT
#ifdef SMODULE_IMPLEMENTATION
#define SSDI_EXPORT S_DLL_EXPORT
#else
#define SSDI_EXPORT S_DLL_IMPORT
#endif
#endif

#ifndef SRVX_EXPORT
#define SRVX_EXPORT S_DLL_EXPORT
#endif

/*------------------------------------------------------------------------------
         SSDI Types
------------------------------------------------------------------------------*/

typedef struct S_PROPERTY
{
   char* pName;
   char* pValue ;
} S_PROPERTY;

typedef struct S_TIME_LIMIT
{
   uint32_t nTime1;
   uint32_t nTime2;
} S_TIME_LIMIT;

typedef struct S_CALENDAR
{
   int32_t nYear;
   int32_t nMonth;
   int32_t nDayOfWeek;
   int32_t nDay;
   int32_t nHour;
   int32_t nMinute;
   int32_t nSecond;
} S_CALENDAR;

typedef enum
{
   S_FILE_SEEK_SET = 0,
   S_FILE_SEEK_CUR,
   S_FILE_SEEK_END
} S_WHENCE;

typedef struct S_FILE_INFO
{
   char*    pName;
   uint32_t nSize;
   uint32_t nNameLength;
}S_FILE_INFO;

typedef struct
{
   void* pBuffer;
   uint32_t nSize;
}
S_PARAM_MEMREF;

typedef struct
{
   uint32_t a;
   uint32_t b;
}
S_PARAM_VALUE;

typedef union
{
   S_PARAM_MEMREF  memref;
   S_PARAM_VALUE   value;
}
S_PARAM;


/*------------------------------------------------------------------------------
         Constants
------------------------------------------------------------------------------*/
#define S_TIMEOUT_INFINITE                         0xFFFFFFFF

/* storage private to the service */
#define S_FILE_STORAGE_PRIVATE                     0x00000001

#ifdef SUPPORT_RPMB_PARTITION
/* storage on rpmb */
#define S_FILE_STORAGE_RPMB                        0x00000002
#endif

/* Cryptoki slotID constants */
#define S_CRYPTOKI_KEYSTORE_PRIVATE                0x00000001
#define S_CRYPTOKI_KEYSTORE_PRIVATE_USER           0x00004004

/* SFile constants */
#define S_FILE_FLAG_ACCESS_READ                    0x0001
#define S_FILE_FLAG_ACCESS_WRITE                   0x0002
#define S_FILE_FLAG_ACCESS_WRITE_META              0x0004

#define S_FILE_FLAG_SHARE_READ                     0x0010
#define S_FILE_FLAG_SHARE_WRITE                    0x0020

#define S_FILE_FLAG_CREATE                         0x0200
#define S_FILE_FLAG_EXCLUSIVE                      0x0400

#define S_FILE_NAME_MAX                            0x40
#define S_FILE_MAX_POSITION                        0xFFFFFFFF

/* SDate constants */
#define S_DATE_STATUS_NOT_SET                      0xFFFF5000
#define S_DATE_STATUS_NEEDS_RESET                  0xFFFF5001
#define S_DATE_STATUS_SET                          0x00000000

/* Login types */
#define S_LOGIN_PUBLIC                             0x00000000
#define S_LOGIN_USER                               0x00000001
#define S_LOGIN_GROUP                              0x00000002
#define S_LOGIN_APPLICATION                        0x00000004
#define S_LOGIN_APPLICATION_USER                   0x00000005
#define S_LOGIN_APPLICATION_GROUP                  0x00000006
#define S_LOGIN_AUTHENTICATION                     0x80000000
#define S_LOGIN_PRIVILEGED                         0x80000002
#define S_LOGIN_CLIENT_IS_SERVICE                  0xF0000000
#define S_LOGIN_SYSTEM                             0xF0000001

/* Parameter types */
#define S_PARAM_TYPE_NONE          0x0
#define S_PARAM_TYPE_VALUE_INPUT   0x1
#define S_PARAM_TYPE_VALUE_OUTPUT  0x2
#define S_PARAM_TYPE_VALUE_INOUT   0x3
#define S_PARAM_TYPE_MEMREF_INPUT  0x5
#define S_PARAM_TYPE_MEMREF_OUTPUT 0x6
#define S_PARAM_TYPE_MEMREF_INOUT  0x7

#define S_PARAM_TYPE_INPUT_FLAG    0x1
#define S_PARAM_TYPE_OUTPUT_FLAG   0x2
#define S_PARAM_TYPE_MEMREF_FLAG   0x4

#define S_PARAM_TYPES(t0,t1,t2,t3)  ((t0) | ((t1) << 4) | ((t2) << 8) | ((t3) << 12))
#define S_PARAM_TYPE_GET(t, i) (((t) >> (i*4)) & 0xF)

#define S_ORIGIN_API         1
#define S_ORIGIN_COMMS       2
#define S_ORIGIN_TEE         3
#define S_ORIGIN_TRUSTED_APP 4

/*------------------------------------------------------------------------------
         Implementation Functions
------------------------------------------------------------------------------*/

S_RESULT SSDI_EXPORT SImplementationGetAllProperties(
                                 S_PROPERTY** ppProperties,
                                 uint32_t* pnPropertiesCount);

S_RESULT SSDI_EXPORT SImplementationGetProperty(const char* pName,
                                                char** ppValue);

S_RESULT SSDI_EXPORT SImplementationGetPropertyAsInt(const char* pName,
                                                     uint32_t* pnValue);

S_RESULT SSDI_EXPORT SImplementationGetPropertyAsBool(const char* pName,
                                                      bool* pbValue);

/*------------------------------------------------------------------------------
         Service Functions
------------------------------------------------------------------------------*/

S_RESULT SSDI_EXPORT SServiceGetAllProperties(
                                 OUT S_PROPERTY** ppProperties,
                                 OUT uint32_t* pnPropertiesCount);

S_RESULT SSDI_EXPORT SServiceGetProperty (
                             IN const char* pName,
                             OUT char** ppValue);

S_RESULT SSDI_EXPORT SServiceGetPropertyAsInt (
                                  IN const char* pName,
                                  OUT uint32_t* pnValue);

S_RESULT SSDI_EXPORT SServiceGetPropertyAsBool(
                                  IN const char* pName,
                                  OUT bool* pbValue);

/*------------------------------------------------------------------------------
         Instance Functions
------------------------------------------------------------------------------*/

void SSDI_EXPORT SInstanceSetData(
                      void* pInstanceData);

void SSDI_EXPORT *SInstanceGetData(void);

/*------------------------------------------------------------------------------
         Session Functions
------------------------------------------------------------------------------*/

void SSDI_EXPORT SSessionGetClientID(
                         S_UUID* pClientID);

S_RESULT SSDI_EXPORT SSessionGetAllClientProperties(
                                    OUT uint32_t* pnPropertyCount,
                                    OUT S_PROPERTY** ppPropertyArray);

S_RESULT SSDI_EXPORT SSessionGetClientProperty(
                                  IN const char* pName,
                                  OUT char** ppValue);

S_RESULT SSDI_EXPORT SSessionGetClientPropertyAsInt (
                                        IN const char* pName,
                                        OUT uint32_t* pnValue);

S_RESULT SSDI_EXPORT SSessionGetClientPropertyAsBool (
                                         IN const char* pName,
                                         OUT bool* pnValue);

/*------------------------------------------------------------------------------
         Memory Management Functions
------------------------------------------------------------------------------*/

void SSDI_EXPORT *SMemAlloc(uint32_t size);

void SSDI_EXPORT *SMemRealloc(void* ptr, uint32_t newSize);

void SSDI_EXPORT SMemFree(void *ptr);

void SSDI_EXPORT *SMemMove(void *dest, const void *src, uint32_t n);

int32_t SSDI_EXPORT SMemCompare(const void *s1, const void *s2, uint32_t n);

void SSDI_EXPORT *SMemFill(void *s, uint32_t c, uint32_t n);

void SSDI_EXPORT *SMemAllocEx(uint32_t nPoolID, uint32_t nSize);

S_RESULT SMemDup(void *src, uint32_t n, void **dest);

/*------------------------------------------------------------------------------
         Trace & Debug Functions
------------------------------------------------------------------------------*/
void SSDI_EXPORT _SLogTrace(
               const char *message,
               ... /* arguments */);
void SSDI_EXPORT _SLogWarning(
               const char *message,
               ... /* arguments */);
void SSDI_EXPORT _SLogError(
               const char *message,
               ... /* arguments */);

#ifdef __SSDI_USE_TRACE_EX
#include "ssdi_trace_ex.h"
#else

#ifndef SSDI_NO_TRACE

#define SLogTrace _SLogTrace
#define SLogWarning _SLogWarning
#define SLogError _SLogError

#else /* defined(SSDI_NO_TRACE) */

/* Note that the following code depends on the compiler's supporting variadic macros */
#define SLogTrace(...)   do ; while(false)
#define SLogWarning(...) do ; while(false)
#define SLogError(...)   do ; while(false)

#endif /* !defined(SSDI_NO_TRACE) */

#endif /* __SSDI_USE_TRACE_EX */

void SSDI_EXPORT _SAssertionFailed(
      const char* pFileName,
      uint32_t nLine,
      const char* pExpression);

#ifdef SSDI_DEBUG
#define SAssert(test)                                     \
   do                                                       \
   {                                                        \
      if (!(test))                                          \
      {                                                     \
         _SAssertionFailed(__FILE__, __LINE__, #test);   \
      }                                                     \
   }                                                        \
   while (0)
#else /* !defined(SSDI_DEBUG) */
#define SAssert(test)
#endif /* defined(SSDI_DEBUG) */

#define S_VAR_NOT_USED(variable) do{(void)(variable);}while(0);

/*------------------------------------------------------------------------------
         Time Utility
------------------------------------------------------------------------------*/
void SSDI_EXPORT STimeGetLimit(
           uint32_t      nTimeout,
       OUT S_TIME_LIMIT* pTimeLimit );


/*------------------------------------------------------------------------------
         Thread Functions
------------------------------------------------------------------------------*/
S_RESULT SSDI_EXPORT SThreadCreate(
                      OUT S_HANDLE* phThread,
                      uint32_t      stackSize,
                      uint32_t     (*pEntryPoint)(void*),
                      IN void*      pThreadArg);

S_RESULT SSDI_EXPORT SThreadJoin(
                    S_HANDLE        hThread,
                    uint32_t*       pnExitCode,
                    const S_TIME_LIMIT*   pTimeLimit);

void SSDI_EXPORT SThreadYield(void);

S_RESULT SSDI_EXPORT SThreadSleep(const S_TIME_LIMIT* pTimeLimit);

void SSDI_EXPORT SThreadCancel(S_HANDLE hThread, uint32_t nReserved);

bool SSDI_EXPORT SThreadIsCancelled (void* pReserved);

void SSDI_EXPORT SThreadResetCancel(void);

void SSDI_EXPORT SThreadMaskCancellation ( bool bMask );

/*------------------------------------------------------------------------------
         Semaphore Functions
------------------------------------------------------------------------------*/

S_RESULT SSDI_EXPORT SSemaphoreCreate (
                          uint32_t  initialCount,
                          S_HANDLE* phSemaphore);

S_RESULT SSDI_EXPORT SSemaphoreAcquire(S_HANDLE hSemaphore, const S_TIME_LIMIT* pTimeLimit);

void SSDI_EXPORT SSemaphoreRelease(S_HANDLE hSemaphore);

/*------------------------------------------------------------------------------
         File System Functions
------------------------------------------------------------------------------*/

S_RESULT SSDI_EXPORT SFileOpen(
                  uint32_t  nStorageID,
                  const char     *pFilename,
                  uint32_t  nFlags,
                  uint32_t  nReserved,
                  S_HANDLE *phFile);

S_RESULT SSDI_EXPORT SFileRead(S_HANDLE         hFile,
                  uint8_t*         pBuffer,
                  uint32_t         nSize,
                  uint32_t*        pnCount);

S_RESULT SSDI_EXPORT SFileWrite (S_HANDLE         hFile,
                    const uint8_t*         pBuffer,
                    uint32_t         nSize);

S_RESULT SSDI_EXPORT SFileTruncate(S_HANDLE      hFile,
                      uint32_t       nSize);

S_RESULT SSDI_EXPORT SFileSeek(S_HANDLE     hFile,
                  int32_t      nOffset,
                  S_WHENCE     eWhence);

uint32_t SSDI_EXPORT SFileTell(S_HANDLE        hFile);

bool SSDI_EXPORT SFileEOF(S_HANDLE   hFile);

S_RESULT SSDI_EXPORT SFileCloseAndDelete(S_HANDLE hFile);

S_RESULT SSDI_EXPORT SFileRename(S_HANDLE hFile, const char* pNewFilename);

S_RESULT SSDI_EXPORT SFileGetSize(uint32_t     nStorageID,
                     const char*        pFilename,
                     uint32_t*    pnFileSize);

S_RESULT SSDI_EXPORT SFileEnumerationStart (
                               uint32_t  nStorageID,
                               const char*     pFilenamePattern,
                               uint32_t  nReserved1,
                               uint32_t  nReserved2,
                               S_HANDLE* phFileEnumeration);

S_RESULT SSDI_EXPORT SFileEnumerationGetNext (
                                 S_HANDLE           hFileEnumeration,
                                 OUT S_FILE_INFO**  ppFileInfo);

/*------------------------------------------------------------------------------
         Date Functions
------------------------------------------------------------------------------*/

S_RESULT SSDI_EXPORT SDateSet (
           int32_t  nSeconds,
           uint32_t nReserved);

S_RESULT SSDI_EXPORT SDateGet(
       OUT int32_t*  pnSeconds,
       OUT uint32_t* pnDateStatus,
       uint32_t      nReserved );

int32_t SSDI_EXPORT SClockGet(void);

S_RESULT SSDI_EXPORT SDateConvertSecondsToCalendar(
        IN int32_t     nSeconds,
        IN const S_CALENDAR* pOrigin,
       OUT S_CALENDAR* pDate );

S_RESULT SSDI_EXPORT SDateConvertCalendarToSeconds(
        IN const S_CALENDAR* pOrigin,
        IN const S_CALENDAR* pDate,
       OUT int32_t*    pnSeconds);

/*------------------------------------------------------------------------------
         Handle Functions
------------------------------------------------------------------------------*/
void SSDI_EXPORT SHandleClose ( S_HANDLE hHandle);

/*------------------------------------------------------------------------------
         Crypto API
------------------------------------------------------------------------------*/

#define PKCS11_EXPORT SSDI_EXPORT

#include "pkcs11.h"

/*------------------------------------------------------------------------------
         Cryptoki Update Shortcut
------------------------------------------------------------------------------*/

#define S_UPDATE_SHORTCUT_FLAG_AGGRESSIVE 0x00000001

CK_RV SSDI_EXPORT CV_ActivateUpdateShortcut2(
   CK_SESSION_HANDLE hCryptokiSession,
   uint32_t nCommandID,
   uint32_t nFlags,
   uint32_t nReserved);

void SSDI_EXPORT CV_DeactivateUpdateShortcut(
  CK_SESSION_HANDLE hCryptokiSession);


/*------------------------------------------------------------------------------
         Panic Function
------------------------------------------------------------------------------*/

void SSDI_EXPORT SPanic(uint32_t nReserved);

/*------------------------------------------------------------------------------
         SXControl functions
------------------------------------------------------------------------------*/
S_RESULT SSDI_EXPORT SXControlOpenClientSession (
           const S_UUID* pDestination,
           S_TIME_LIMIT* pDeadline,
           uint32_t nParamTypes,
           S_PARAM pParams[4],
           OUT S_HANDLE* phSessionHandle,
           uint32_t* pnReturnOrigin);

S_RESULT SSDI_EXPORT SXControlInvokeCommand (
           S_HANDLE hSessionHandle,
           S_TIME_LIMIT* pDeadline,
           uint32_t nCommandID,
           uint32_t nParamTypes,
           S_PARAM pParams[4],
           uint32_t* pnReturnOrigin);

/*------------------------------------------------------------------------------
         SRVX Entry Points
------------------------------------------------------------------------------*/

extern S_RESULT SRVX_EXPORT SRVXCreate(void);
extern void     SRVX_EXPORT SRVXDestroy(void);
extern S_RESULT SRVX_EXPORT SRVXOpenClientSession(uint32_t nParamTypes,
                                           IN OUT S_PARAM pParams[4],
                                           OUT void** ppSessionContext);
extern S_RESULT SRVX_EXPORT SRVXInvokeCommand(IN OUT void* pSessionContext,
                                       uint32_t nCommandID,
                                       uint32_t nParamTypes,
                                       IN OUT S_PARAM pParams[4]);
extern void SRVX_EXPORT SRVXCloseClientSession(IN OUT void* pSessionContext);

#include "ssdi_v2_compat.h"

#endif /* __SSDI_H__ */