void ANNOUNCE_DeInit(const TCPIP_STACK_MODULE_CTRL* const stackData)
{
SGL_LIST_NODE* node;
announceEventPending = false;
if (announceDHCPHandler != NULL)
{
DHCPDeRegisterHandler(announceDHCPHandler);
announceDHCPHandler = NULL;
}
#if defined (TCPIP_STACK_USE_IPV6)
if (announceIPV6Handler != NULL)
{
TCPIP_IPV6_DeRegisterHandler(announceIPV6Handler);
announceIPV6Handler = NULL;
}
#endif
// Free all announce events
while ((node = SingleListRemoveHead(&announceEvents)) != NULL)
{
TCPIP_HEAP_Free (announceMemH, node);
}
announceMemH = 0;
}
static void _ARPCleanupClients(void)
{
SGL_LIST_NODE* aNode;
while( (aNode = SingleListRemoveHead(&arpRegisteredUsers)) != 0 )
{
TCPIP_HEAP_Free(arpMemH, aNode);
}
}
void TCPIP_Notification_RemoveAll(SINGLE_LIST* notifyList, TCPIP_HEAP_HANDLE heapH)
{
SGL_LIST_NODE* dNode;
while( (dNode = TCPIP_Helper_SingleListHeadRemove(notifyList)) != 0 )
{
TCPIP_HEAP_Free(heapH, dNode);
}
}
bool TCPIP_Notification_Remove(SGL_LIST_NODE* node, SINGLE_LIST* notifyList, TCPIP_HEAP_HANDLE heapH)
{
if(TCPIP_Helper_SingleListNodeRemove(notifyList, node))
{
TCPIP_HEAP_Free(heapH, node);
return true;
}
return false;
}
static void _ZCLLCleanup(const TCPIP_STACK_MODULE_CTRL* const stackCtrl)
{
TCPIP_HEAP_Free(stackCtrl->memH, phZCLL); // free the allocated memory
phZCLL = (ZCLL_NET_HANDLE*)0;
if(zcllSignalHandle)
{
_TCPIPStackSignalHandlerDeregister(zcllSignalHandle);
zcllSignalHandle = 0;
}
}
static void _ARPCleanupCache(ARP_CACHE_DCPT* pArpDcpt)
{
if(pArpDcpt->cacheDcpt)
{
_ARPRemoveCacheEntries(pArpDcpt);
TCPIP_HEAP_Free(arpMemH, pArpDcpt->cacheDcpt);
pArpDcpt->cacheDcpt = 0;
}
}
uint8_t SNMPv3AESEncryptResponseScopedPdu(SNMPV3_RESPONSE_WHOLEMSG* plain_text/*uint8_t userDBIndex*/)
{
uint8_t* cryptoKey;
uint8_t* initVector;
uint8_t* plainText;
uint16_t plaintextLen;
uint8_t* encrypted_text;
uint8_t extraMemReqd;
AES_ROUND_KEYS_128_BIT round_keys;
AES_CFB_STATE_DATA current_stream;
SNMPV3_PROCESSING_MEM_INFO_PTRS snmpv3PktProcessingMemPntr;
SNMPV3_STACK_DCPT_STUB * snmpv3EngnDcptMemoryStubPtr=0;
SNMPv3GetPktProcessingDynMemStubPtrs(&snmpv3PktProcessingMemPntr);
snmpv3EngnDcptMemoryStubPtr=snmpv3PktProcessingMemPntr.snmpv3StkProcessingDynMemStubPtr;
//This is a secured request. Compute the AES Encryption IV
SNMPv3UsmAesEncryptDecrptInitVector(SNMP_RESPONSE_PDU);
plaintextLen= (plain_text->scopedPduStructLen);
cryptoKey=snmpv3EngnDcptMemoryStubPtr->UserInfoDataBase[snmpv3EngnDcptMemoryStubPtr->UserInfoDataBaseIndx].userPrivPswdLoclizdKey;
initVector=snmpV3AesEncryptInitVector;
plainText=(plain_text->scopedPduOffset);
extraMemReqd=(16-(plaintextLen%16)); //AES Blocks are in multiples of 16 Bytes
encrypted_text=(uint8_t*)(TCPIP_HEAP_Calloc(snmpv3PktProcessingMemPntr.snmpHeapMemHandler,1,(size_t)plaintextLen+extraMemReqd));
if(encrypted_text != NULL)
{
AESCreateRoundKeys (&round_keys,cryptoKey,AES_KEY_SIZE_128_BIT);
memcpy(current_stream.initial_vector,initVector,16);
AESCFBEncrypt(encrypted_text,plainText, plaintextLen,
&round_keys, ¤t_stream,
AES_STREAM_START | AES_USE_CFB128 );
}
else
return SNMPV3_MSG_PRIV_FAIL;
//Copy decrypted text to already allocated WholeMsg dynamic memory Buffer.
memcpy(plainText,encrypted_text,plaintextLen);
//free this temp buffer used for decryption purpose.
TCPIP_HEAP_Free(snmpv3PktProcessingMemPntr.snmpHeapMemHandler, encrypted_text);
return SNMPV3_MSG_PRIV_PASS;
}
/****************************************************************************
Function:
uint8_t SNMPv3AESDecryptRxedScopedPdu(void)
Summary:
Incoming SNMPv3 scoped PDU decryption using AES decryption protocol.
Description:
This routine decrypts SNMPV3 incoming PDU using AES protocol , but before this
encrypted data length is verified.If the length of the encrypted OCTECT-STRING
is not multiple of 8, then dryption will be halted.
RFC - 3414. ( section 8)
Precondition:
SNMPv3Init() and ProcessVariabels() are called.
Parameters:
None
Return Values:
SNMPV3_MSG_PRIV_FAIL - Failure
SNMPV3_MSG_PRIV_PASS - Success
Remarks:
None
***************************************************************************/
uint8_t SNMPv3AESDecryptRxedScopedPdu(/*uint8_t userDBIndex*/)
{
uint8_t* cryptoKey;
uint8_t* initVector;
uint8_t* snmpv3_cipher_text;
uint16_t cipherTextLen;
uint8_t* decrypted_text;
uint16_t temp;
uint8_t extraMemReqd;
AES_ROUND_KEYS_128_BIT round_keys;
AES_CFB_STATE_DATA current_stream;
SNMPV3_PROCESSING_MEM_INFO_PTRS snmpv3PktProcessingMemPntr;
SNMPV3_STACK_DCPT_STUB * snmpv3EngnDcptMemoryStubPtr=0;
SNMPv3GetPktProcessingDynMemStubPtrs(&snmpv3PktProcessingMemPntr);
snmpv3EngnDcptMemoryStubPtr=snmpv3PktProcessingMemPntr.snmpv3StkProcessingDynMemStubPtr;
cryptoKey=snmpv3EngnDcptMemoryStubPtr->UserInfoDataBase[snmpv3EngnDcptMemoryStubPtr->UserInfoDataBaseIndx].userPrivPswdLoclizdKey;
initVector=snmpV3AesDecryptInitVector;
temp=snmpv3EngnDcptMemoryStubPtr->InPduWholeMsgBuf.scopedPduOffset;
snmpv3_cipher_text=(snmpv3EngnDcptMemoryStubPtr->InPduWholeMsgBuf.snmpMsgHead+temp);
cipherTextLen= snmpv3EngnDcptMemoryStubPtr->InPduWholeMsgBuf.scopedPduStructLen;
extraMemReqd=(16-(cipherTextLen%16)); //AES Blocks are in multiples of 16 Bytes
decrypted_text=(uint8_t*)(TCPIP_HEAP_Calloc(snmpv3PktProcessingMemPntr.snmpHeapMemHandler,1,(size_t)cipherTextLen+extraMemReqd));
if(decrypted_text != NULL)
{
AESCreateRoundKeys (&round_keys,cryptoKey,AES_KEY_SIZE_128_BIT);
memcpy(current_stream.initial_vector,initVector,16);
AESCFBDecrypt(decrypted_text,snmpv3_cipher_text, cipherTextLen,
&round_keys, ¤t_stream,
AES_STREAM_START | AES_USE_CFB128);
}
else
return SNMPV3_MSG_PRIV_FAIL;
//Copy decrypted text to already allocated WholeMsg dynamic memory Buffer.
memcpy(snmpv3_cipher_text,decrypted_text,cipherTextLen);
//free this temp buffer used for decryption purpose.
TCPIP_HEAP_Free(snmpv3PktProcessingMemPntr.snmpHeapMemHandler, decrypted_text);
return SNMPV3_MSG_PRIV_PASS;
}
// deregister the event handler
bool ARPDeRegisterHandler(ARP_HANDLE hArp)
{
if(hArp && arpMemH)
{
if(SingleListRemoveNode(&arpRegisteredUsers, (SGL_LIST_NODE*)hArp))
{
TCPIP_HEAP_Free(arpMemH, hArp);
return true;
}
}
return false;
}
void ANNOUNCE_Send(void)
{
UDP_SOCKET announceSocket;
int netIx;
uint16_t dataLen;
uint16_t minimumDataLen;
uint16_t txLen;
bool truncated;
NET_CONFIG * pNetIf;
ANNOUNCE_LIST_NODE * node = (ANNOUNCE_LIST_NODE *)announceEvents.head;
ANNOUNCE_FIELD_PAYLOAD payloadType;
uint16_t terminatorLen = strlen ((const char *)announceFieldTerminator);
#if defined (TCPIP_STACK_USE_IPV6)
IPV6_ADDR_STRUCT * addressPointer;
#endif
while (node != NULL)
{
pNetIf = (NET_CONFIG *)node->handle;
netIx = TCPIP_STACK_NetIx (pNetIf);
truncated = false;
dataLen = ((terminatorLen + 1) * 4) + sizeof (IPV4_ADDR) + sizeof (MAC_ADDR);
dataLen += strlen(TCPIP_HOSTS_CONFIGURATION[netIx].interface);
dataLen += strlen((char *)pNetIf->NetBIOSName);
minimumDataLen = dataLen + 1 + terminatorLen;
if(!MACIsLinked(_TCPIPStackNetToMac(pNetIf))) // Check for link before blindly opening and transmitting (similar to DHCP case)
{
return;
}
announceSocket = UDPOpenClient(IP_ADDRESS_TYPE_IPV4, ANNOUNCE_PORT, 0);
if (announceSocket == INVALID_UDP_SOCKET)
{
return;
}
UDPSocketSetNet (announceSocket, pNetIf);
#if defined (TCPIP_STACK_USE_IPV6)
addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6UnicastAddresses.head;
while(addressPointer != NULL)
{
dataLen += sizeof (IPV6_ADDR) + 1 + terminatorLen;
addressPointer = addressPointer->next;
}
addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6MulticastAddresses.head;
while(addressPointer != NULL)
{
dataLen += sizeof (IPV6_ADDR) + 1 + terminatorLen;
addressPointer = addressPointer->next;
}
#endif
if (dataLen > ANNOUNCE_MAX_PAYLOAD)
{
dataLen = ANNOUNCE_MAX_PAYLOAD;
}
if ((txLen = UDPIsTxPutReady(announceSocket, dataLen)) < dataLen)
{
truncated = true;
if ((txLen = UDPIsTxPutReady(announceSocket, minimumDataLen)) < minimumDataLen)
{
UDPClose (announceSocket);
return;
}
}
// Put Mac Address
payloadType = ANNOUNCE_FIELD_MAC_ADDR;
UDPPut (announceSocket, payloadType);
UDPPutArray(announceSocket, (const uint8_t *)&pNetIf->MyMACAddr, sizeof (MAC_ADDR));
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
if (truncated)
{
payloadType = ANNOUNCE_FIELD_TRUNCATED;
UDPPut (announceSocket, payloadType);
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
}
// Put Mac Type
payloadType = ANNOUNCE_FIELD_MAC_TYPE;
UDPPut (announceSocket, payloadType);
UDPPutArray(announceSocket, (const uint8_t *)TCPIP_HOSTS_CONFIGURATION[netIx].interface, strlen ((const char *)TCPIP_HOSTS_CONFIGURATION[netIx].interface));
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
// Put Host Name
payloadType = ANNOUNCE_FIELD_HOST_NAME;
UDPPut (announceSocket, payloadType);
UDPPutArray(announceSocket, (const uint8_t *)&pNetIf->NetBIOSName, strlen((char*)pNetIf->NetBIOSName));
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
// Put IPv4 Address
payloadType = ANNOUNCE_FIELD_IPV4_ADDRESS;
UDPPut (announceSocket, payloadType);
UDPPutArray(announceSocket, (const uint8_t *)&pNetIf->MyIPAddr, sizeof (IP_ADDR));
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
#if defined (TCPIP_STACK_USE_IPV6)
// Put IPv6 unicast addresses
minimumDataLen = sizeof (IPV6_ADDR) + 1 + terminatorLen;
addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6UnicastAddresses.head;
payloadType = ANNOUNCE_FIELD_IPV6_UNICAST;
while(addressPointer != NULL && (UDPIsTxPutReady(announceSocket, minimumDataLen) >= minimumDataLen))
{
UDPPut (announceSocket, payloadType);
UDPPutArray(announceSocket, (const uint8_t *)&addressPointer->address, sizeof (IPV6_ADDR));
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
addressPointer = addressPointer->next;
}
// Put IPv6 multicast listeners
addressPointer = (IPV6_ADDR_STRUCT *)ipv6Config[netIx].listIpv6MulticastAddresses.head;
payloadType = ANNOUNCE_FIELD_IPV6_MULTICAST;
while(addressPointer != NULL && (UDPIsTxPutReady(announceSocket, minimumDataLen) >= minimumDataLen))
{
UDPPut (announceSocket, payloadType);
UDPPutArray(announceSocket, (const uint8_t *)&addressPointer->address, sizeof (IPV6_ADDR));
UDPPutArray (announceSocket, announceFieldTerminator, terminatorLen);
addressPointer = addressPointer->next;
}
#endif
UDPFlush (announceSocket);
UDPClose (announceSocket);
SingleListRemoveHead(&announceEvents);
TCPIP_HEAP_Free (announceMemH, node);
node = (ANNOUNCE_LIST_NODE *)announceEvents.head;
if (node == NULL)
{
announceEventPending = false;
}
}
}
