void vJIPserver_GroupMibCompressedAddressToIn6(struct in6_addr *psAddress, uint8_t *pau8Buffer, uint8_t u8BufferLength)
{
int i;
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s ", __FUNCTION__);
for (i = 0; i < u8BufferLength; i++)
{
DBG_vPrintf(DBG_FUNCTION_CALLS, "0x%02x ", pau8Buffer[i]);
}
DBG_vPrintf(DBG_FUNCTION_CALLS, "\n");
memset(psAddress, 0, sizeof(struct in6_addr));
psAddress->s6_addr[0] = 0xFF;
psAddress->s6_addr[1] = pau8Buffer[0];
for (i = 15; u8BufferLength > 1; u8BufferLength--, i--)
{
psAddress->s6_addr[i] = pau8Buffer[u8BufferLength-1];
}
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s Result: ", __FUNCTION__);
DBG_vPrintf_IPv6Address(DBG_FUNCTION_CALLS, *psAddress);
return;
}
teJIP_Status eGroups_GroupClearSet(tsVar *psVar, tsJIPAddress *psDstAddress)
{
tsMib *psMib = psVar->psOwnerMib;
tsNode *psNode = psMib->psOwnerNode;
tsNode_Private *psNode_Private = (tsNode_Private *)psNode->pvPriv;
int iGroupAddressSlot;
struct in6_addr sBlankAddress;
char acAddr[INET6_ADDRSTRLEN] = "Could not determine address\n";
memset(&sBlankAddress, 0, sizeof(struct in6_addr));
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s\n", __FUNCTION__);
/* Iterate over all groups */
for (iGroupAddressSlot = 0;
iGroupAddressSlot < JIP_DEVICE_MAX_GROUPS;
iGroupAddressSlot++)
{
if (memcmp(&psNode_Private->asGroupAddresses[iGroupAddressSlot], &sBlankAddress, sizeof(struct in6_addr)))
{
DBG_vPrintf(DBG_GROUPS, "%s: Leave group ", __FUNCTION__);
DBG_vPrintf_IPv6Address(DBG_GROUPS, psNode_Private->asGroupAddresses[iGroupAddressSlot]);
inet_ntop(AF_INET6, &psNode_Private->asGroupAddresses[iGroupAddressSlot], acAddr, INET6_ADDRSTRLEN);
eJIPserver_NodeGroupLeave(psNode, acAddr);
}
}
return E_JIP_OK;
}
static int iGroups_in6_to_compressed(struct in6_addr *psAddress, uint8_t *pau8Buffer)
{
int iInPosition, iOutPosition;
struct in6_addr sBlankAddress;
memset(&sBlankAddress, 0, sizeof(struct in6_addr));
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s ", __FUNCTION__);
DBG_vPrintf_IPv6Address(DBG_FUNCTION_CALLS, *psAddress);
if (memcmp(psAddress, &sBlankAddress, sizeof(struct in6_addr)) == 0)
{
// Blank address
return 0;
}
iInPosition = 1; /* Start at the scope byte */
iOutPosition = 0; /* Start at the start of the buffer */
pau8Buffer[iOutPosition] = psAddress->s6_addr[iInPosition];
for(iOutPosition = 1, iInPosition = 2;
((psAddress->s6_addr[iInPosition] == 0) && (iInPosition < 16));
iInPosition++);
for(; iInPosition < 16; iOutPosition++, iInPosition++)
{
pau8Buffer[iOutPosition] = psAddress->s6_addr[iInPosition];
}
return iOutPosition;
}
tsNode *psJIP_NetAllocateNode(tsNetwork *psNet, tsJIPAddress *psAddress, uint32_t u32DeviceId)
{
tsNode *psNewNode;
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s to Net at %p\n", __FUNCTION__, psNet);
psNewNode = malloc(sizeof(tsNode));
if (!psNewNode)
{
DBG_vPrintf(DBG_NODES, "Error allocating space for Node\n");
return NULL;
}
memset(psNewNode, 0, sizeof(tsNode));
psNewNode->psOwnerNetwork = psNet;
if (psAddress)
{
psNewNode->sNode_Address = *psAddress;
}
psNewNode->u32DeviceId = u32DeviceId;
eLockCreate(&psNewNode->sLock);
eJIPLockLock(&psNewNode->sLock);
DBG_vPrintf(DBG_NODES, "New Node allocated at %p\n", psNewNode);
DBG_vPrintf_IPv6Address(DBG_NODES, psNewNode->sNode_Address.sin6_addr);
return psNewNode;
}
tsNode *psJIP_LookupNode(tsJIP_Context *psJIP_Context, tsJIPAddress *psAddress)
{
tsNode *psNode;
tsNetwork *psNet;
uint32_t u32Attempts = 0;
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s\n", __FUNCTION__);
DBG_vPrintf(DBG_NODES, "Looking for ");
DBG_vPrintf_IPv6Address(DBG_NODES, psAddress->sin6_addr);
start:
eJIP_Lock(psJIP_Context);
psNet = &psJIP_Context->sNetwork;
psNode = psNet->psNodes;
while (psNode)
{
DBG_vPrintf(DBG_NODES, "Looking at ");
DBG_vPrintf_IPv6Address(DBG_NODES, psNode->sNode_Address.sin6_addr);
if (memcmp(&psNode->sNode_Address, psAddress, sizeof(tsJIPAddress)) == 0)
{
if (eJIP_LockNode(psNode, False) == E_JIP_ERROR_WOULD_BLOCK)
{
DBG_vPrintf(DBG_NODES, "Locking node %p would block\n", psNode);
eJIP_Unlock(psJIP_Context);
if (++u32Attempts > 10)
{
DBG_vPrintf(DBG_NODES, "Error locking node:");
DBG_vPrintf_IPv6Address(DBG_NODES, psNode->sNode_Address.sin6_addr);
sleep(1);
u32Attempts = 0;
}
eThreadYield();
goto start;
}
eJIP_Unlock(psJIP_Context);
return psNode;
}
psNode = psNode->psNext;
}
eJIP_Unlock(psJIP_Context);
return NULL;
}
teJIP_Status eJIP_GetNodeAddressList(tsJIP_Context *psJIP_Context, const uint32_t u32DeviceIdFilter, tsJIPAddress **ppsAddresses, uint32_t *pu32NumAddresses)
{
tsNode *psNode;
teJIP_Status eStatus = E_JIP_OK;
tsJIPAddress *psAddresses = NULL;
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s\n", __FUNCTION__);
eJIP_Lock(psJIP_Context);
*pu32NumAddresses = 0;
DBG_vPrintf(DBG_NODES, "Currently %d nodes in network\n", psJIP_Context->sNetwork.u32NumNodes);
// Malloc enough space to hold every device, if we had to return everything.
psAddresses = malloc(sizeof(tsJIPAddress) * (psJIP_Context->sNetwork.u32NumNodes));
if (psAddresses)
{
uint32_t i = 0;
psNode = psJIP_Context->sNetwork.psNodes;
while (psNode)
{
if ((u32DeviceIdFilter == JIP_DEVICEID_ALL) || (psNode->u32DeviceId == u32DeviceIdFilter))
{
memcpy(&psAddresses[i], &psNode->sNode_Address, sizeof(tsJIPAddress));
DBG_vPrintf(DBG_NODES, "Adding node ");
DBG_vPrintf_IPv6Address(DBG_NODES, psNode->sNode_Address.sin6_addr);
i++;
(*pu32NumAddresses)++;
}
psNode = psNode->psNext;
}
*ppsAddresses = psAddresses;
}
else
{
DBG_vPrintf(DBG_NODES, "Could not malloc space for node list\n");
eStatus = E_JIP_ERROR_NO_MEM;
}
eJIP_Unlock(psJIP_Context);
return eStatus;
}
teJIP_Status eJIP_PrintNetworkContent(tsJIP_Context *psJIP_Context)
{
//PRIVATE_CONTEXT(psJIP_Context);
tsNode *psNode;
tsMib *psMib;
tsVar *psVar;
DBG_vPrintf(DBG_FUNCTION_CALLS, "%s\n", __FUNCTION__);
printf("Network: \n");
eJIP_Lock(psJIP_Context);
psNode = psJIP_Context->sNetwork.psNodes;
while (psNode)
{
printf(" Node: ");
DBG_vPrintf_IPv6Address(1, psNode->sNode_Address.sin6_addr);
printf(" Device ID: 0x%08x\n", psNode->u32DeviceId);
psMib = psNode->psMibs;
while (psMib)
{
printf(" Mib: 0x%08x, %s\n", psMib->u32MibId, psMib->pcName);
psVar = psMib->psVars;
while (psVar)
{
printf(" Var: %s%s\n", psVar->pcName, psVar->eEnable == E_JIP_VAR_DISABLED ? " (disabled)": "");
//DBG_vPrintf_IPv6Address(1, psNode->sNode_Address);
printf(" ");
switch (psVar->eVarType)
{
#define TEST(a) case (a): printf(#a); break
TEST(E_JIP_VAR_TYPE_INT8);
TEST(E_JIP_VAR_TYPE_UINT8);
TEST(E_JIP_VAR_TYPE_INT16);
TEST(E_JIP_VAR_TYPE_UINT16);
TEST(E_JIP_VAR_TYPE_INT32);
TEST(E_JIP_VAR_TYPE_UINT32);
TEST(E_JIP_VAR_TYPE_INT64);
TEST(E_JIP_VAR_TYPE_UINT64);
TEST(E_JIP_VAR_TYPE_FLT);
TEST(E_JIP_VAR_TYPE_DBL);
TEST(E_JIP_VAR_TYPE_STR);
TEST(E_JIP_VAR_TYPE_BLOB);
TEST(E_JIP_VAR_TYPE_TABLE_BLOB);
default: printf("Unknown Type");
#undef TEST
}
printf(", ");
switch (psVar->eAccessType)
{
#define TEST(a) case (a): printf(#a); break
TEST(E_JIP_ACCESS_TYPE_CONST);
TEST(E_JIP_ACCESS_TYPE_READ_ONLY);
TEST(E_JIP_ACCESS_TYPE_READ_WRITE);
default: printf("Unknown Access Type");
#undef TEST
}
printf(", ");
switch (psVar->eSecurity)
{
#define TEST(a) case (a): printf(#a); break
TEST(E_JIP_SECURITY_NONE);
default: printf("Unknown Security Type");
#undef TEST
}
printf("\n");
printf(" Value: ");
if (psVar->pvData)
{
switch (psVar->eVarType)
{
#define TEST(a, b, c) case (a): printf(b, *psVar->c); break
TEST(E_JIP_VAR_TYPE_INT8, "%d\n\r", pi8Data);
TEST(E_JIP_VAR_TYPE_UINT8, "%u\n\r", pu8Data);
TEST(E_JIP_VAR_TYPE_INT16, "%d\n\r", pi16Data);
TEST(E_JIP_VAR_TYPE_UINT16, "%u\n\r", pu16Data);
TEST(E_JIP_VAR_TYPE_INT32, "%d\n\r", pi32Data);
TEST(E_JIP_VAR_TYPE_UINT32, "%u\n\r", pu32Data);
TEST(E_JIP_VAR_TYPE_INT64, "%lld\n\r", pi64Data);
TEST(E_JIP_VAR_TYPE_UINT64, "%llu\n\r", pu64Data);
TEST(E_JIP_VAR_TYPE_FLT, "%f\n\r", pfData);
TEST(E_JIP_VAR_TYPE_DBL, "%f\n\r", pdData);
case (E_JIP_VAR_TYPE_STR):
printf("%s\n", psVar->pcData);
break;
case (E_JIP_VAR_TYPE_BLOB):
{
uint32_t i;
printf("{");
for (i = 0; i < psVar->u8Size; i++)
{
printf(" 0x%02x", psVar->pbData[i]);
}
printf(" }\n");
break;
}
case (E_JIP_VAR_TYPE_TABLE_BLOB):
{
tsTableRow *psTableRow;
int i;
printf("\n");
for (i = 0; i < psVar->ptData->u32NumRows; i++)
{
psTableRow = &psVar->ptData->psRows[i];
if (psTableRow->pvData)
{
uint32_t j;
printf(" %03d {", i);
for (j = 0; j < psTableRow->u32Length; j++)
{
printf(" 0x%02x", psTableRow->pbData[j]);
}
printf(" }\n");
}
}
break;
}
default: printf("Unknown Type\n");
#undef TEST
}
}
else
{
printf("?\n");
}
printf("\n");
psVar = psVar->psNext;
}
psMib = psMib->psNext;
}
psNode = psNode->psNext;
}
eJIP_Unlock(psJIP_Context);
return E_JIP_OK;
}
