ARP_RESULT ARPEntryGet(TCPIP_NET_HANDLE hNet, IP_ADDR* ipAdd, MAC_ADDR* pHwAdd)
{
NET_CONFIG *pIf;
pIf = _TCPIPStackHandleToNet(hNet);
if(pIf)
{
if(ARPIsResolved(pIf, ipAdd, pHwAdd))
{
return ARP_RES_OK;
}
}
return ARP_RES_NO_ENTRY;
}
ARP_RESULT ARPCacheSetThreshold(TCPIP_NET_HANDLE hNet, int purgeThres, int purgeEntries)
{
NET_CONFIG *pIf;
pIf = _TCPIPStackHandleToNet(hNet);
if(!pIf)
{
return ARP_RES_NO_INTERFACE;
}
ARP_CACHE_DCPT *pArpDcpt = arpCache + _TCPIPStackNetIx(pIf);
pArpDcpt->purgeThres = (purgeThres * pArpDcpt->cacheDcpt->hEntries)/100;
pArpDcpt->purgeQuanta = purgeEntries;
return ARP_RES_OK;
}
SNTP_RESULT TCPIP_SNTP_ConnectionParamSet(TCPIP_NET_HANDLE netH, IP_ADDRESS_TYPE ntpConnType)
{
if(!_SntpIsIdle())
{
return SNTP_RES_BUSY;
}
if(netH)
{
pSntpDefIf = _TCPIPStackHandleToNet(netH);
}
if(ntpConnType != IP_ADDRESS_TYPE_ANY)
{
ntpConnection = ntpConnType;
}
return SNTP_RES_OK;
}
ARP_RESULT ARPEntryRemove(TCPIP_NET_HANDLE hNet, IP_ADDR* ipAdd)
{
OA_HASH_ENTRY *hE;
ARP_CACHE_DCPT *pArpDcpt;
SINGLE_LIST *remList;
NET_CONFIG *pIf;
pIf = _TCPIPStackHandleToNet(hNet);
if(!pIf)
{
return ARP_RES_NO_INTERFACE;
}
pArpDcpt = arpCache + _TCPIPStackNetIx(pIf);
hE = OAHashLookUp(pArpDcpt->cacheDcpt, &ipAdd->Val);
if(hE == 0)
{
return ARP_RES_NO_ENTRY;
}
if((hE->flags.value & ARP_FLAG_ENTRY_PERM) != 0 )
{
remList = &pArpDcpt->permList;
}
else if((hE->flags.value & ARP_FLAG_ENTRY_COMPLETE) != 0 )
{
remList = &pArpDcpt->completeList;
}
else
{
remList = &pArpDcpt->incompleteList;
}
SingleListRemoveNode(remList, (SGL_LIST_NODE*)&((ARP_HASH_ENTRY*)hE)->next);
OAHashRemoveEntry(pArpDcpt->cacheDcpt, hE);
return ARP_RES_OK;
}
/*****************************************************************************
Function:
DNS_RESULT DNSBeginUsage(NET_CONFIG* pConfig)
Summary:
Claims access to the DNS module.
Description:
This function acts as a semaphore to obtain usage of the DNS module.
Call this function and ensure that it returns DNS_RES_OK before calling any
other DNS APIs. Call DNSEndUsage when this application no longer
needs the DNS module so that other applications may make use of it.
Precondition:
Stack is initialized.
Parameters:
pConfig - interface to use
If 0, a default interface will be selected
Return Values:
DNS_RES_OK - the calling application has sucessfully taken ownership of the DNS module
DNS_RES_BUSY - The DNS module is currently in use.
Yield to the stack and attempt this call again later.
Remarks:
Ensure that DNSEndUsage is always called once your application has
obtained control of the DNS module. If this is not done, the stack
will hang for all future applications requiring DNS access.
***************************************************************************/
DNS_RESULT DNSBeginUsage(TCPIP_NET_HANDLE netH)
{
NET_CONFIG* pNewIf;
if(Flags.bits.DNSInUse)
return DNS_RES_BUSY;
pNewIf = _TCPIPStackHandleToNet(netH);
if(pNewIf == 0 || !_TCPIPStackIsNetUp(pNewIf))
{ // try a default interface
if(_TCPIPStackIsNetUp(pDNSNet))
{
pNewIf = pDNSNet;
}
else
{
pNewIf = (NET_CONFIG*)TCPIP_STACK_GetDefaultNet();
if(!_TCPIPStackIsNetUp(pNewIf))
{
pNewIf = 0;
}
}
}
// else pNewIf should do just fine
if(pNewIf == 0)
{
return DNS_RES_NO_INTERFACE;
}
pDNSNet = pNewIf;
Flags.bits.DNSInUse = true;
DNSServers[0] = pDNSNet->PrimaryDNSServer;
DNSServers[1] = pDNSNet->SecondaryDNSServer;
smDNS = DNS_IDLE;
return DNS_RES_OK;
}
static int _Command_NetInfo(_CMDIO_DEV_NODE* pCmdIO, int argc, char** argv)
{
int i;
TCPIP_NET_HANDLE netH;
IPV4_ADDR ipAddr;
const TCPIP_MAC_ADDR* pMac;
TCPIP_NET_IF* pNetIf;
TCPIP_STACK_MODULE macID;
const char *hostName, *msgAdd;
const void* cmdIoParam = pCmdIO->cmdIoParam;
#if defined(TCPIP_STACK_USE_IPV6)
IPV6_ADDR_STRUCT currIpv6Add;
IPV6_ADDR_HANDLE prevHandle, nextHandle;
char addrBuff[44];
#else
char addrBuff[20];
#endif // defined(TCPIP_STACK_USE_IPV6)
if (argc > 2)
{
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Usage: netinfo\r\n");
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Ex: netinfo\r\n");
return false;
}
for (i=0; i<initialNetIfs; i++)
{
netH = TCPIP_STACK_IndexToNet(i);
pNetIf = _TCPIPStackHandleToNet(netH);
macID = TCPIP_STACK_NetMACIdGet(pNetIf);
(*pCmdIO->pCmdApi->print)(cmdIoParam, "---------- Interface <%s> ---------- \r\n", TCPIP_STACK_MACIdToString(macID));
if(!TCPIP_STACK_NetIsUp(netH))
{
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "Interface is down\r\n");
continue;
}
hostName = TCPIP_STACK_NetBIOSName(netH);
#if defined(TCPIP_STACK_USE_NBNS)
(*pCmdIO->pCmdApi->print)(cmdIoParam, "Host Name: %s - NBNS enabled\r\n", hostName);
#else
(*pCmdIO->pCmdApi->print)(cmdIoParam, "Host Name: %s - NBNS disabled \r\n", hostName);
#endif // defined(TCPIP_STACK_USE_NBNS)
ipAddr.Val = TCPIP_STACK_NetAddress(netH);
TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, "IPv4 Address: %s\r\n", addrBuff);
ipAddr.Val = TCPIP_STACK_NetMask(netH);
TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, "Mask: %s\r\n", addrBuff);
ipAddr.Val = TCPIP_STACK_NetAddressGateway(netH);
TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, "Gateway: %s\r\n", addrBuff);
ipAddr.Val = TCPIP_STACK_NetAddressDnsPrimary(netH);
TCPIP_Helper_IPAddressToString(&ipAddr, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, "DNS: %s\r\n", addrBuff);
pMac = (const TCPIP_MAC_ADDR*)TCPIP_STACK_NetAddressMac(netH);
TCPIP_Helper_MACAddressToString(pMac, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, "MAC Address: %s\r\n", addrBuff);
// display IPv6 addresses
#if defined(TCPIP_STACK_USE_IPV6)
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "IPv6 Unicast addresses:\r\n");
prevHandle = 0;
do
{
nextHandle = TCPIP_STACK_NetIPv6AddressGet(netH, IPV6_ADDR_TYPE_UNICAST, &currIpv6Add, prevHandle);
if(nextHandle)
{ // have a valid address; display it
TCPIP_Helper_IPv6AddressToString(&currIpv6Add.address, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, " %s\r\n", addrBuff);
prevHandle = nextHandle;
}
}while(nextHandle != 0);
if(prevHandle == 0)
{ // no valid address
(*pCmdIO->pCmdApi->msg)(cmdIoParam, " Unknown\r\n");
}
(*pCmdIO->pCmdApi->msg)(cmdIoParam, "IPv6 Multicast addresses:\r\n");
prevHandle = 0;
do
{
nextHandle = TCPIP_STACK_NetIPv6AddressGet(netH, IPV6_ADDR_TYPE_MULTICAST, &currIpv6Add, prevHandle);
if(nextHandle)
{ // have a valid address; display it
TCPIP_Helper_IPv6AddressToString(&currIpv6Add.address, addrBuff, sizeof(addrBuff));
(*pCmdIO->pCmdApi->print)(cmdIoParam, " %s\r\n", addrBuff);
prevHandle = nextHandle;
}
}while(nextHandle != 0);
if(prevHandle == 0)
{ // no valid address
(*pCmdIO->pCmdApi->msg)(cmdIoParam, " Unknown\r\n");
}
#endif // defined(TCPIP_STACK_USE_IPV6)
if(TCPIP_DHCP_IsEnabled(netH))
{
msgAdd = "dhcp";
}
else if(TCPIP_ZCLL_IsEnabled(netH))
{
msgAdd = "zcll";
}
else if(TCPIP_DHCPS_IsEnabled(netH))
{
msgAdd = "dhcps";
}
else
{
msgAdd = "default IP address";
}
(*pCmdIO->pCmdApi->print)(cmdIoParam, "%s is ON\r\n", msgAdd);
(*pCmdIO->pCmdApi->print)(cmdIoParam, "Link is %s\r\n", TCPIP_STACK_NetIsLinked(netH) ? "UP" : "DOWN");
}
return true;
}
ARP_RESULT ARPEntrySet(TCPIP_NET_HANDLE hNet, IP_ADDR* ipAdd, MAC_ADDR* hwAdd, bool perm)
{
ARP_CACHE_DCPT *pArpDcpt;
ARP_HASH_ENTRY *arpHE;
OA_HASH_ENTRY *hE;
SINGLE_LIST *oldList, *newList;
ARP_ENTRY_FLAGS newFlags;
ARP_RESULT res;
NET_CONFIG *pIf;
if(ipAdd->Val == 0)
{ // do not store 0's in cache
return ARP_RES_BAD_ADDRESS;
}
pIf = _TCPIPStackHandleToNet(hNet);
if(!pIf)
{
return ARP_RES_NO_INTERFACE;
}
pArpDcpt = arpCache + _TCPIPStackNetIx(pIf);
hE = OAHashLookUpInsert(pArpDcpt->cacheDcpt, &ipAdd->Val);
if(hE == 0)
{ // oops!
return ARP_RES_CACHE_FULL;
}
// where to put it
if(perm)
{
newList = &pArpDcpt->permList;
newFlags = ARP_FLAG_ENTRY_PERM;
}
else
{
newList = &pArpDcpt->completeList;
newFlags = ARP_FLAG_ENTRY_COMPLETE; // complete
}
arpHE = (ARP_HASH_ENTRY*)hE;
if(hE->flags.newEntry == 0)
{ // existent entry
if( (hE->flags.value & ARP_FLAG_ENTRY_PERM) != 0 )
{
oldList = &pArpDcpt->permList;
}
else if( (hE->flags.value & ARP_FLAG_ENTRY_COMPLETE) != 0 )
{
oldList = &pArpDcpt->completeList;
}
else
{
oldList = &pArpDcpt->incompleteList;
}
if(newList != oldList)
{ // remove from the old list
SingleListRemoveNode(oldList, (SGL_LIST_NODE*)&arpHE->next);
}
res = ARP_RES_ENTRY_EXIST;
}
else
{
res = ARP_RES_OK;
}
// add it to where it belongs
_ARPSetEntry(arpHE, newFlags, hwAdd, newList);
if(SingleListCount(&pArpDcpt->permList) >= ARP_CACHE_PERMANENT_QUOTA * pArpDcpt->cacheDcpt->fullSlots)
{ // quota exceeded
res = ARP_RES_PERM_QUOTA_EXCEED;
}
return res;
}
