/**************************************************************************************************
 
  Phyplus Microelectronics Limited confidential and proprietary. 
  All rights reserved.

  IMPORTANT: All rights of this software belong to Phyplus Microelectronics 
  Limited ("Phyplus"). Your use of this Software is limited to those 
  specific rights granted under  the terms of the business contract, the 
  confidential agreement, the non-disclosure agreement and any other forms 
  of agreements as a customer or a partner of Phyplus. You may not use this 
  Software unless you agree to abide by the terms of these agreements. 
  You acknowledge that the Software may not be modified, copied, 
  distributed or disclosed unless embedded on a Phyplus Bluetooth Low Energy 
  (BLE) integrated circuit, either as a product or is integrated into your 
  products.  Other than for the aforementioned purposes, you may not use, 
  reproduce, copy, prepare derivative works of, modify, distribute, perform, 
  display or sell this Software and/or its documentation for any purposes.

  YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE
  PROVIDED AS IS WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,
  INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE,
  NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL
  PHYPLUS OR ITS SUBSIDIARIES BE LIABLE OR OBLIGATED UNDER CONTRACT,
  NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER
  LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES
  INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE
  OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT
  OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES
  (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS.
  
**************************************************************************************************/

/**************************************************************************************************
**************************************************************************************************/

#ifndef SM_INTERNAL_H
#define SM_INTERNAL_H

#ifdef __cplusplus
extern "C"
{
#endif

/*********************************************************************
 * INCLUDES
 */
#include "bcomdef.h"
#include "l2cap.h"
#include "smp.h"
#include "linkdb.h"

/*********************************************************************
 * MACROS
 */
  
/*********************************************************************
 * CONSTANTS
 */
  
// Security Manager Task Events
#define SM_TIMEOUT_EVT            0x0001    // Message timeout event
#define SM_PAIRING_STATE_EVT      0x0002    // Event used to progress to the next pairing state
  
// Pairing states
#define SM_PAIRING_STATE_INITIALIZE                       0  // Pairing has started
#define SM_PAIRING_STATE_PAIRING_REQ_SENT                 1  // Initiator: Pairing Request has been sent, Responder: waiting for Pairing Request.
#define SM_PAIRING_STATE_WAIT_CONFIRM                     2  // Waiting for Confirm message
#define SM_PAIRING_STATE_WAIT_PASSKEY                     3  // Waiting for Passkey from app/profile
#define SM_PAIRING_STATE_WAIT_CONFIRM_PASSKEY             4  // Received Initiator Confirm message and waiting for Passkey from app/profile (responder only)
#define SM_PAIRING_STATE_WAIT_RANDOM                      5  // Waiting for Random message
#define SM_PAIRING_STATE_WAIT_STK                         6  // Waiting for STK process to finish
#define SM_PAIRING_STATE_WAIT_SLAVE_ENCRYPTION_INFO       7  // Waiting for Slave Encryption Info to be sent
#define SM_PAIRING_STATE_WAIT_SLAVE_MASTER_INFO           8  // Waiting for Slave Master Info to be sent
#define SM_PAIRING_STATE_WAIT_SLAVE_IDENTITY_INFO         9  // Waiting for Slave Identity Info to be sent
#define SM_PAIRING_STATE_WAIT_SLAVE_IDENTITY_ADDR_INFO    10 // Waiting for Slave Identity Addr Info to be sent
#define SM_PAIRING_STATE_WAIT_SLAVE_SIGNING_INFO          11 // Waiting for Slave Signing Info to be sent
#define SM_PAIRING_STATE_WAIT_MASTER_ENCRYPTION_INFO      12 // Waiting for Master Encryption Info to be sent
#define SM_PAIRING_STATE_WAIT_MASTER_MASTER_INFO          13 // Waiting for Master Master Info to be sent
#define SM_PAIRING_STATE_WAIT_MASTER_IDENTITY_INFO        14 // Waiting for Master Identity Info to be sent
#define SM_PAIRING_STATE_WAIT_MASTER_IDENTITY_ADDR_INFO   15 // Waiting for Master Identity Addr Info to be sent
#define SM_PAIRING_STATE_WAIT_MASTER_SIGNING_INFO         16 // Waiting for Master Signing Info to be sent
#define SM_PAIRING_STATE_WAIT_ENCRYPT                     17 // Waiting for LTK process to finish
#define SM_PAIRING_STATE_DONE                             18 // Closing out the pairing process
  
#if defined ( TESTMODES )
  // SM TestModes
  #define SM_TESTMODE_OFF                           0   // No Test mode
  #define SM_TESTMODE_NO_RESPONSE                   1   // Don't respond to any SM message
  #define SM_TESTMODE_SEND_BAD_CONFIRM              2   // Force a bad confirm value in the Confirm Message
  #define SM_TESTMODE_BAD_CONFIRM_VERIFY            3   // Force a bad confirm check of the received Confirm Message
  #define SM_TESTMODE_SEND_CONFIRM                  4   // Force a SMP Confirm message
#endif  // TESTMODES

// Pairing Types
#define SM_PAIRING_TYPE_INIT                        0 // Pairing has been started but the type hasn't been determined yet
#define SM_PAIRING_TYPE_JUST_WORKS                  1 // Pairing is Just Works
#define SM_PAIRING_TYPE_PASSKEY_INITIATOR_INPUTS    2 // Pairing is MITM Passkey with initiator inputs passkey
#define SM_PAIRING_TYPE_PASSKEY_RESPONDER_INPUTS    3 // Pairing is MITM Passkey with responder inputs passkey
#define SM_PAIRING_TYPE_PASSKEY_BOTH_INPUTS         4 // Pairing is MITM Passkey with both initiator and responder input passkey
#define SM_PAIRING_TYPE_OOB                         5 // Pairing is MITM OOB

#define SM_PAIRING_STATE_WAIT                       500 // The default wait time between key distribution messages.

/*********************************************************************
 * TYPEDEFS
 */

typedef struct
{
  uint8  confirm[KEYLEN];       // calculated confirm value
  uint8  rand[SMP_RANDOM_LEN];  // First MRand or Srand, then RAND
} devPairing_t;

typedef struct
{
  // From the start
  uint8                initiator;        // TRUE if initiator
  uint8                state;            // Pairing state
  uint8                taskID;           // Task ID of the app/profile that requested the pairing
  uint16               connectionHandle; // Connection Handle from controller,
  smLinkSecurityReq_t  *pSecReqs;        // Pairing Control info
  uint8                tk[KEYLEN];       // Holds tk from app
  uint8                authState;        // uses SM_AUTH_STATE_AUTHENTICATED & SM_AUTH_STATE_BONDING
  
  // During pairing
  smpPairingReq_t      *pPairDev;        // Info of paired device.
  uint8                type;             // ie. SM_PAIRING_TYPE_JUST_WORKS
  
  // device information
  devPairing_t         myComp;          // This device's pairing components
  devPairing_t         devComp;         // The other device's components
  
  // Encrypt Params
  smSecurityInfo_t     *pEncParams;     // Your (device's) encryption parameters
  smSecurityInfo_t     *pDevEncParams;  // Connected device's encryption parameters
  smIdentityInfo_t     *pIdInfo;        // Connected device's identity parameters
  smSigningInfo_t      *pSigningInfo;    // Connected device's signing parameters
  
} smPairingParams_t;

// Callback when an SMP message has been received on the Initiator or Responder.
typedef uint8 (*smProcessMsg_t)( linkDBItem_t *pLinkItem, uint8 cmdID, smpMsgs_t *pParsedMsg );

// Callback to send next key message, and sets state for next event on the Initiator or Responder.
typedef void (*smSendNextKeyInfo_t)( void );

// Callback to send Start Encrypt through HCI on the Initiator.
typedef bStatus_t (*smStartEncryption_t)( uint16 connHandle, uint8 *pLTK, uint16 div,
                                          uint8 *pRandNum, uint8 keyLen );

// Callback when an HCI BLE LTK Request has been received on the Responder.
typedef uint8 (*smProcessLTKReq_t)( uint16 connectionHandle, uint8 *pRandom, uint16 encDiv );

// Initiator callback structure - must be setup by the Initiator.
typedef struct
{
  smProcessMsg_t      pfnProcessMsg;      // When SMP message received
  smSendNextKeyInfo_t pfnSendNextKeyInfo; // When need to send next key message
  smStartEncryption_t pfnStartEncryption; // When Start Encrypt requested
} smInitiatorCBs_t;

// Responder callback structure - must be setup by the Initiator.
typedef struct
{
  smProcessMsg_t      pfnProcessMsg;      // When SMP message received
  smSendNextKeyInfo_t pfnSendNextKeyInfo; // When need to send next key message
  smProcessLTKReq_t   pfnProcessLTKReq;   // When HCI BLE LTK Request received
} smResponderCBs_t;

/*********************************************************************
 * GLOBAL VARIABLES
 */
  
// Security Manager's OSAL task ID
extern uint8 smTaskID;

extern smPairingParams_t *pPairingParams;

extern smResponderCBs_t *pfnResponderCBs;

/*********************************************************************
 * FUNCTIONS - API
 */

/*********************************************************************
 * Application Level Functions
 */

  /*
   * smLinkCheck - link database callback function.
   */
  extern void smLinkCheck( uint16 connectionHandle, uint8 changeType );
  
  /*
   * smProcessRandComplete - Process the HCI Random Complete Event.
   */
  extern uint8 smProcessRandComplete( uint8 status, uint8 *rand );

  /*
   * smTimedOut - Process the SM timeout.
   */
  extern void smTimedOut( void );
  
  /*
   * smStartRspTimer - Start the SM Response Timer.
   */
  extern void smStartRspTimer( void );
  
  /*
   * smStopRspTimer - Stop the SM Response Timer.
   */
  extern void smStopRspTimer( void );
  
  /*
   * smProcessDataMsg - Process incoming L2CAP messages.
   */
  extern void smProcessDataMsg( l2capDataEvent_t *pMsg );
  
  /*
   * smProcessEncryptChange - Process the HCI BLE Encrypt Change Event.
   */
  extern uint8 smProcessEncryptChange( uint16 connectionHandle, uint8 reason );
  
  /*
   * smInProcess - Is SM already processing something?
   */
  extern uint8 smInProcess( void );

  /*
   * sm_d1 - SM diversifying function d1
   */
  extern bStatus_t sm_d1( uint8 *pK, uint16 d, uint8 *pD1 );

  /*
   * sm_ah - Random address hash function
   */
  extern bStatus_t sm_ah( uint8 *pK, uint8 *pR, uint8 *pAh );

  /*
   * sm_dm - SM DIV Maxk generation function dm
   */
  extern bStatus_t sm_dm( uint8 *pK, uint8 *pR, uint16 *pDm );

  /*
   * sm_c1 - SM Confirm value generation function c1
   */
  extern bStatus_t sm_c1( uint8 *pK, uint8 *pR, uint8 *pC1 );

  /*
   * sm_c1new - SM Confirm value generation function c1
   */
  extern bStatus_t sm_c1new( uint8 *pK, uint8 *pR, uint8 *pRes, uint8 *pReq, 
                   uint8 iat, uint8 *pIA, uint8 rat, uint8 *pRA, uint8 *pC1 );
  /*
   * sm_s1 - SM key generation function s1
   */
  extern bStatus_t sm_s1( uint8 *pK, uint8 *pR1, uint8 *pR2, uint8 *pS1 );
  
  /*
   * smGenerateRandBuf - generate a buffer of random numbers
   */
  extern void smGenerateRandBuf( uint8 *pRandNum, uint8 len );

  /*
   * smEncLTK - start LTK Encryption
   */
  extern void smEncLTK( void );

  /*
   * smNextPairingState - trigger next state machine
   */
  extern void smNextPairingState( void );
  
  /*
   * smAuthReqToUint8 - conversion function
   */
  extern uint8 smAuthReqToUint8( authReq_t *pAuthReq );

  /*
   * smUint8ToAuthReq - conversion function
   */
  extern void smUint8ToAuthReq( authReq_t *pAuthReq, uint8 authReqUint8 );
  
  /*
   * smpResponderProcessPairingReq - Process an incoming Pairing Request message
   */
  extern uint8 smpResponderProcessPairingReq( smpPairingReq_t *pParsedMsg );
  
  /*
   * smSendFailAndEnd - Send the pairing failed message and end existing pairing
   */
  extern bStatus_t smSendFailAndEnd( uint16 connHandle, smpPairingFailed_t *pFailedMsg );

  /*
   * generateRandMsg - Generate a Pairing Random
   */
  extern bStatus_t smGenerateRandMsg( void );

  /*
   * smSavePairInfo - Save the Pairing Req or Rsp information
   */
  extern bStatus_t smSavePairInfo( smpPairingReq_t *pPair );

  /*
   * generateConfirm - Generate a Pairing Confirm
   */
  extern bStatus_t smGenerateConfirm( void );

  /*
   * smEndPairing - Pairing mode has ended.  Yeah. Notify the GAP and free
   *                up the memory used.
   */
  extern void smEndPairing( uint8 status );

  /*
   * determineKeySize - Determine the maximum encryption key size
   */
  extern uint8 smDetermineKeySize( void );

  /*
   * smGeneratePairingReqRsp - Generate a pairing req or response
   */
  extern bStatus_t smGeneratePairingReqRsp( void );

  /*
   * smPairingSendEncInfo - Send SM Encryption Information message
   */
  extern void smPairingSendEncInfo( uint16 connHandle, uint8 *pLTK );

  /*
   * smPairingSendMasterID - Send SM Master Identification message
   */
  extern void smPairingSendMasterID( uint16 connHandle, uint16 ediv, uint8 *pRand );

  /*
   * smPairingSendIdentityInfo - Send SM Identity Information message
   */
  extern void smPairingSendIdentityInfo( uint16 connHandle, uint8 *pIRK );

  /*
   * smPairingSendIdentityAddrInfo - Send SM Identity Addr Information message
   */
  extern void smPairingSendIdentityAddrInfo( uint16 connHandle, uint8 addrType, uint8 *pMACAddr );

  /*
   * smPairingSendSingingInfo - Send SM Signing Information message
   */
  extern void smPairingSendSingingInfo( uint16 connHandle, uint8 *pSRK );

  /*
   * smPairingSendEncInfo - Send SM Encryption Information message
   */
  extern void smPairingSendEncInfo( uint16 connHandle, uint8 *pLTK );

  /*
   * smProcessPairingReq - Process Pairing Request
   */
  extern void smProcessPairingReq( linkDBItem_t *pLinkItem, gapPairingReq_t *pPairReq );

  /*
   * smStartEncryption - Perform Encrypt through HCI
   */
  extern bStatus_t smStartEncryption( uint16 connHandle, uint8 *pLTK, uint16 div,
                                      uint8 *pRandNum, uint8 keyLen );

  /*
   * smRegisterInitiator - egister Initiator's processing function with SM task
   */
  extern void smRegisterInitiator( smInitiatorCBs_t *pfnCBs );

  /*
   * smRegisterResponder - Register Responder's processing function with SM task
   */
  extern void smRegisterResponder( smResponderCBs_t *pfnCBs );


/*********************************************************************
*********************************************************************/

#ifdef __cplusplus
}
#endif

#endif /* SM_INTERNAL_H */
