/************************************************************************************
* @fn initializeConnection
*
* @brief Initialize some elements of a Connection table entry.
*
* input parameters
* @param pCInfo - pointer to Connection Table entry to initialize. The file
* scope variable holding the next link ID value is also updated.
*
* output parameters
* @param pCInfo - certain elements are set to specific values.
*
*
* @return void
*/
static void initializeConnection(connInfo_t *pCInfo)
{
linkID_t *locLID = &sPersistInfo.nextLinkID;
uint8_t tmp;
/* this element will be populated during the exchange with the peer. */
pCInfo->portTx = 0;
pCInfo->connState = CONNSTATE_CONNECTED;
pCInfo->thisLinkID = *locLID;
/* Generate the next Link ID. This isn't foolproof. If the count wraps
* we can end up with confusing duplicates. We can protect aginst using
* one that is already in use but we can't protect against a stale Link ID
* remembered by an application that doesn't know its connection has been
* torn down. The test for 0 will hopefully never be true (indicating a wrap).
*/
(*locLID)++;
while (!*locLID || (*locLID == SMPL_LINKID_USER_UUD) || map_lid2idx(*locLID, &tmp))
{
(*locLID)++;
}
return;
}
/******************************************************************************
* @fn nwk_getConnInfo
*
* @brief Return the connection info structure to which the input Link ID maps.
*
* input parameters
* @param port - port for which mapping desired
*
* output parameters
*
* @return pointer to connInfo_t structure found. NULL if no mapping
* found or entry not valid.
*/
connInfo_t *nwk_getConnInfo(linkID_t linkID)
{
uint8_t idx, rc;
rc = map_lid2idx(linkID, &idx);
return (rc && sConTable.connStruct[idx].isValid) ? &sConTable.connStruct[idx] : (connInfo_t *)0;
}
/******************************************************************************
* @fn nwk_getConnInfo
*
* @brief Return the connection info structure to which the input Link ID maps.
*
* input parameters
* @param port - port for which mapping desired
*
* output parameters
*
* @return pointer to connInfo_t structure found. NULL if no mapping
* found or entry not valid.
*/
connInfo_t *nwk_getConnInfo(linkID_t linkID)
{
uint8_t idx, rc;
rc = map_lid2idx(linkID, &idx);
return (rc && (CONNSTATE_CONNECTED == sPersistInfo.connStruct[idx].connState)) ? &sPersistInfo.connStruct[idx] : (connInfo_t *)0;
}
void nwkGetRemotePeerAddr(linkID_t sLinkId, addr_t *peerAddr)
{
uint8_t index;
if(map_lid2idx(sLinkId, &index))
{
memcpy(peerAddr->addr, sPersistInfo.connStruct[index].peerAddr, NET_ADDR_SIZE);
}
}
/******************************************************************************
* @fn nwk_getNextConnection
*
* @brief Return the next free connection structure if on is available.
*
* input parameters
*
* output parameters
* The returned structure has the Rx port number populated based on the
* free strucure found. This is the port queried when the app wants to
* do a receive.
*
* @return pointer to the new connInfo_t structure. NULL if there is
* no room in connection structure array.
*/
connInfo_t *nwk_getNextConnection()
{
uint8_t i;
for (i=0; i<SYS_NUM_CONNECTIONS; ++i)
{
if (sConTable.connStruct[i].isValid)
{
continue;
}
break;
}
if (SYS_NUM_CONNECTIONS == i)
{
return (connInfo_t *)0;
}
/* this element will be populated during the exchange with the peer. */
sConTable.connStruct[i].portTx = 0;
sConTable.connStruct[i].isValid = 1;
sConTable.connStruct[i].thisLinkID = sNextLinkID;
/* Generate the next Link ID. This isn't foolproof. If the count wraps
* we can end up wthh confusing duplicates. We can protect aginst using
* one that is already in use but we can't protect against a stale Link ID
* remembered by an application that doesn't know its connection has been
* torn down. The test for 0 will hopefully never be true (indicating a wrap).
*/
sNextLinkID++;
while (!sNextLinkID || (sNextLinkID == SMPL_LINKID_USER_UUD) || map_lid2idx(sNextLinkID, &i))
{
sNextLinkID++;
}
return &sConTable.connStruct[i];
}
