?? dhcpc.c
字號:
if (ZComIOControl(SIOCDELRT, &RouteEntry) < 0)
{
// Ignore the error, perhaps no gateway exist.
}
// add new gateway
pSockAddrIn->sin_family = AF_INET;
pSockAddrIn->sin_addr.s_addr = ulGateway;
RouteEntry.rt_flags = RTF_UP | RTF_GATEWAY;
RouteEntry.rt_dev = (char*)cszIfName;
return ZComIOControl(SIOCADDRT, &RouteEntry)>=0;
}
bool_t DHCPClientSystemDNSet(ipaddr *ip, int Len)
{
struct in_addr addr;
char buff[30] = {0};
static const char cszDNSFormat[] = "nameserver %s\n";
FILE *fp = fopen("/etc/resolv.conf", "w");
char *szDNS = buff;
int i;
if (NULL == fp)
{
return FALSE;
}
for (i=0; i<Len; i++)
{
if (IsValidIP(ip[i]))
{
memset(buff, 0, sizeof(buff));
addr.s_addr = ip[i];
strcpy(szDNS, (char *)inet_ntoa(addr));
fprintf(fp, cszDNSFormat, szDNS);
}
}
fclose(fp);
return TRUE;
}
void DHCPClientUpdateIfStatus(DHCPWAITEvent_t *pEvent)
{
bool_t fIfIsUp = FALSE;
int iIfIndex = -1;
fIfIsUp = IsInterfaceUp(pEvent->pPointToBlock->cszIfName);
if (FALSE == fIfIsUp)
{
pEvent->pPointToBlock->uiIfIndex = -1;
return;
}
iIfIndex = getIndexByIfName(pEvent->pPointToBlock->cszIfName);
if (-1 == pEvent->pPointToBlock->uiIfIndex)
{
//it is first active
pEvent->iIfIndex = iIfIndex;
pEvent->pPointToBlock->uiIfIndex = iIfIndex;
if (TRUE == pEvent->pPointToBlock->bDHCPClientEnabled)
{
//first start then send DHCP Discover to request IP Setting
pEvent->pPointToBlock->CurrentState = DHCP_CLIENT_INITIALIZED;
TimerStart(pEvent,
DEFAULT_DISCOVER_TIMEOUT,
WAIT_DISCOVER);
pEvent->pPointToBlock->CurrentState = DHCP_CLIENT_SELECT;
g_pDHCPClientCurrent = pEvent->pPointToBlock;
DHCPClientSendDHCPDiscover(pEvent->pPointToBlock);
}
}
return;
}
#define MAXDNS_NUM DHCPC_MAX_INTERFACE_NUM*DHCP_CLIENT_MAX_DNS_NUM
static bool_t fDnsIsInArray(IPAddr_t *ulIPArray, IPAddr_t ulIP)
{
int i = 0;
for (i=0; i<MAXDNS_NUM; i++)
{
if (*(ulIPArray+i)==ulIP)
{
return TRUE;
}
}
return FALSE;
}
bool_t DHCPClientDefaultConfig(
const char *cszIfName,
struct DhcpcIPSetting_t *ConfigStruct
)
{
void IntotoStaticNameServerRemoveAll(void);
bool_t IntotoStaticNameServerAdd(in_addr_t ulIP);
bool_t i=FALSE, j=FALSE, l=FALSE, n=FALSE, m=FALSE, k=FALSE;
if ((NULL==cszIfName) || (NULL==ConfigStruct))
{
printf("struct or ifname is null\n");
return FALSE;
}
#ifdef RUNONPC
printf("#######################in pc mode#####################3!\n");
if (FALSE == IsValidIP(ConfigStruct->ulIP))
#else
if (FALSE == IsValidIP(ntohl(ConfigStruct->ulIP)))
#endif
{
// printf("ip address is error: %s\n", inet_ntoa(ntohl(ConfigStruct->ulIP)));
return FALSE;
}
#ifdef RUNONPC
//set ip addr
i = InterfaceSockaddrSet(cszIfName, ConfigStruct->ulIP,
SIOCSIFADDR);
//set network mask
j = InterfaceSockaddrSet(cszIfName, ConfigStruct->ulNetmask,
SIOCSIFNETMASK);
//set gateway (router) only set one gateway!
if (0!=ConfigStruct->ulGateway)
{
m = TRUE;
l = InterfaceGatewaySet(cszIfName,
(in_addr_t)ConfigStruct->ulGateway);
}
//set dns
n = DHCPClientSystemDNSet(ConfigStruct->ulDNS, 2);
k = IntotoStaticNameServerUpdate(ConfigStruct->ulDNS[0],
ConfigStruct->ulDNS[1]);
#else
//set ip addr
i = InterfaceSockaddrSet(cszIfName, ntohl(ConfigStruct->ulIP),
SIOCSIFADDR);
//set network mask
j = InterfaceSockaddrSet(cszIfName, ntohl(ConfigStruct->ulNetmask),
SIOCSIFNETMASK);
//set gateway (router) only set one gateway!
if (0!=ConfigStruct->ulGateway)
{
m = TRUE;
l = InterfaceGatewaySet(cszIfName,
(in_addr_t)ntohl(ConfigStruct->ulGateway));
}
//set dns
ConfigStruct->ulDNS[0] = ntohl(ConfigStruct->ulDNS[0]);
ConfigStruct->ulDNS[1] = ntohl(ConfigStruct->ulDNS[1]);
{
IPAddr_t ulDnsMax[MAXDNS_NUM] = {0};
uint32_t ulDnsNum = 0;
uint32_t iTmp = 0;
DHCPClientBlock_t *pClientBlock = pDHCPClientCtxtBlockHead;
if (NULL==pClientBlock)
{
printf("Block is null\n");
}
while (NULL!=pClientBlock)
{
//printf("Card: %s Current Status: %d\n", pClientBlock->cszIfName, pClientBlock->CurrentState);
switch (pClientBlock->CurrentState)
{
case DHCP_CLIENT_INITIALIZED:
case DHCP_CLIENT_SELECT:
case DHCP_CLIENT_REQUEST:
case DHCP_CLIENT_STOP:
printf("Block's not alloc Dns: %x, %x\n",
pClientBlock->sDefaultConfigStruct.ulDNS[0],pClientBlock->sDefaultConfigStruct.ulDNS[1]);
printf("Card: %s Current Status: %d\n", pClientBlock->cszIfName, pClientBlock->CurrentState);
if (IsValidIP(pClientBlock->sDefaultConfigStruct.ulDNS[0])
&& (!fDnsIsInArray(ulDnsMax, pClientBlock->sDefaultConfigStruct.ulDNS[0]))
)
{
ulDnsMax[ulDnsNum++] = pClientBlock->sDefaultConfigStruct.ulDNS[0];
}
if (IsValidIP(pClientBlock->sDefaultConfigStruct.ulDNS[1])
&& (!fDnsIsInArray(ulDnsMax, pClientBlock->sDefaultConfigStruct.ulDNS[1]))
)
{
ulDnsMax[ulDnsNum++] = pClientBlock->sDefaultConfigStruct.ulDNS[1];
}
break;
case DHCP_CLIENT_BOUND:
case DHCP_CLIENT_ARP_AWAIT:
case DHCP_CLIENT_RENEW:
case DHCP_CLIENT_REBIND:
printf("Block's alloced Dns: %x, %x\n",
pClientBlock->sAllocedStruct.ulDNS[0],pClientBlock->sAllocedStruct.ulDNS[1]);
printf("Card: %s Current Status: %d\n", pClientBlock->cszIfName, pClientBlock->CurrentState);
if (IsValidIP(pClientBlock->sAllocedStruct.ulDNS[0])
&& (!fDnsIsInArray(ulDnsMax, pClientBlock->sAllocedStruct.ulDNS[0]))
)
{
ulDnsMax[ulDnsNum++] = pClientBlock->sAllocedStruct.ulDNS[0];
}
if (IsValidIP(pClientBlock->sAllocedStruct.ulDNS[1])
&& (!fDnsIsInArray(ulDnsMax, pClientBlock->sAllocedStruct.ulDNS[1]))
)
{
ulDnsMax[ulDnsNum++] = pClientBlock->sAllocedStruct.ulDNS[1];
}
break;
default:
break;
}
pClientBlock = pClientBlock->next;
}
n = DHCPClientSystemDNSet(ulDnsMax, ulDnsNum);
IntotoStaticNameServerRemoveAll();
//printf("Dns Num: %d\n", ulDnsNum);
for (iTmp=0; iTmp<ulDnsNum; iTmp++)
{
n = IntotoStaticNameServerAdd(ulDnsMax[iTmp]);
printf("Dns: %x\n", ulDnsMax[iTmp]);
}
k = n = TRUE;
//k = IntotoStaticNameServerUpdate(ntohl(ConfigStruct->ulDNS[0]),
// ntohl(ConfigStruct->ulDNS[1]));
}
#endif
//printf("System Set Result: IP:%d,Netmask:%d,%d, %d\n", i,j,l,m);
return (i & j & n & k & (l == m));
}
int DHCPClientRequestTimeoutProcess(DHCPWAITEvent_t *p)
{
TimerStop(p);
p->iInitSet = FALSE;
if (p->pPointToBlock->CurrentState == DHCP_CLIENT_RENEW)
{
//
p->fWillSend = TRUE;
p->pPointToBlock->ulLeasedTime = p->pPointToBlock->ulLeasedTime / 2;
p->iTimeOutNums++;
if (4 == p->iTimeOutNums)
{
//already 87.5% time, the ulLeaseTime should set to full
p->pPointToBlock->ulLeasedTime =
(p->pPointToBlock->ulRemainingTime * 1/8);
}
if (p->iTimeOutNums>4)
{
//Request not response over three times
p->iTimeOutNums = 0;
p->iInitSet = TRUE;
p->fWillSend = FALSE;
p->pPointToBlock->CurrentState = DHCP_CLIENT_INITIALIZED;
TimerStart(p, DEFAULT_DISCOVER_TIMEOUT, WAIT_DISCOVER);
p->pPointToBlock->CurrentState = DHCP_CLIENT_SELECT;
DHCPClientSendDHCPDiscover(p->pPointToBlock);
}
}
else
{
//
//printf("Request timeout in SELECTING........\n");
p->iSendNums++;
switch (p->iSendNums)
{
case 1:
p->iWaitStartTime += 6;
p->iWaitTimeOutTime = 9;
break;
case 2:
p->iWaitStartTime += 9;
p->iWaitTimeOutTime = 15;
break;
case 3:
p->iWaitStartTime += 15;
p->iWaitTimeOutTime = 30;
break;
default:
break;
}
p->pPointToBlock->CurrentState = DHCP_CLIENT_REQUEST;
if (TRUE == DHCPClientSendDHCPRequest(p->pPointToBlock))
{
TimerStart(p, 0, WAIT_REQUEST);
}
if (p->iSendNums > 3)
{
//Request Timeout 3 times, then change state to init
p->iSendNums = 0;
p->iInitSet = TRUE;
p->pPointToBlock->CurrentState = DHCP_CLIENT_INITIALIZED;
TimerStart(p, DEFAULT_DISCOVER_TIMEOUT, WAIT_DISCOVER);
p->pPointToBlock->CurrentState = DHCP_CLIENT_SELECT;
DHCPClientSendDHCPDiscover(p->pPointToBlock);
}
}
return TRUE;
}
int DHCPClientDiscoverTimeoutProcess(
DHCPWAITEvent_t *p,
DHCPClientBlock_t *pCurCtxtBlock
)
{
//printf("now discover is timeout.... Event = %d StartTime = %d NowTime = %d\n", event.EventType, event.iWaitStartTime, CurrentTime);
TimerStop(p);
p->iInitSet = FALSE;
p->iSendNums++;
//printf("iSendNums = %d\n", iSendNums);
switch (p->iSendNums)
{
case 1:
p->iWaitStartTime += 6;
p->iWaitTimeOutTime = 9;
break;
case 2:
p->iWaitStartTime += 9;
p->iWaitTimeOutTime = 15;
break;
case 3:
p->iWaitStartTime += 15;
p->iWaitTimeOutTime = 30;
break;
default:
break;
}
TimerStart(p, 0, WAIT_DISCOVER);
pCurCtxtBlock->CurrentState = DHCP_CLIENT_SELECT;
if (FALSE == DHCPClientSendDHCPDiscover(pCurCtxtBlock))
{
printf("Send discover error\n");
return FALSE;
}
if (p->iSendNums > 3)
{
//timeout is over three times, then set interface to default
p->iSendNums = 0;
TimerStop(p);
pCurCtxtBlock->CurrentState = DHCP_CLIENT_STOP;
//pCurCtxtBlock->bDHCPClientEnabled = FALSE;
pCurCtxtBlock->bRequestToConnect = TRUE;
time((time_t *)&(pCurCtxtBlock->ulLeaveTime));
if (FALSE == DHCPCFunctionInfo.DHCPNetworkConfig(
pCurCtxtBlock->cszIfName,
&(pCurCtxtBlock->sDefaultConfigStruct)))
{
printf("timeout discover set network error!\n");
return -1;
}
else
{
//pCurCtxtBlock->bDHCPClientEnabled = FALSE;
//exit(0);
// xhema 20050310 inform DNSRD module that dns updated
//IntotoStaticNameServerUpdate(pCurCtxtBlock->sDefaultConfigStruct.ulDNS[0],
// pCurCtxtBlock->sDefaultConfigStruct.ulDNS[1]);
memcpy(&pCurCtxtBlock->sAllocedStruct, &pCurCtxtBlock->sDefaultConfigStruct,
sizeof(pCurCtxtBlock->sDefaultConfigStruct));
}
return TRUE;
}
return TRUE;
}
int DHCPClientSendDHCPDiscover(DHCPClientBlock_t *pCurCtxtBlock)
{
ipaddr srvAddr;
int index = 0, opt = 1;
uint8_t caSendingPkt[DHCP_CLIENT_PACKET_MAXIMUM_LEN];
struct dhcp_packet pkt;
memset(caSendingPkt, 0, sizeof(caSendingPkt));
make_discover(&pkt, pCurCtxtBlock);
//set it
setsockopt(s_iDCSocket, SOL_SOCKET, SO_BROADCAST, (char *)&opt, sizeof(opt));
//xhema
inet_aton("255.255.255.255", (struct in_addr *)&srvAddr);
memcpy(caSendingPkt, (char *)&pkt, sizeof(pkt));
index = sizeof(pkt);
DHCPCAddOptionsToPkt(caSendingPkt, pCurCtxtBlock, &index,
DHCPDISCOVER);
if (-1 == (DHCPCFunctionInfo.SendPacket(pCurCtxtBlock->cszIfName, (char *)&caSendingPkt,
index, 0, srvAddr)))
{
perror("send error");
return FALSE;
}
return TRUE;
}
int DHCPClientSendDHCPDecline(DHCPClientBlock_t *pCurCtxtBlock)
{
uint8_t caSendingPkt[DHCP_CLIENT_PACKET_MAXIMUM_LEN];
uint32_t index=0;
uint8_t *pPading = NULL,*PktPos = NULL;
ipaddr htonlIpAddr=0;
uint8_t ReasonBuf[25]="IT IS ALREADY ASSIGNED";
memset(&DhClientRequestPkt, 0, sizeof(DhClientRequestPkt));
memset(caSendingPkt, 0, sizeof(caSendingPkt));
DhClientRequestPkt.op = BOOTREQUEST;
DhClientRequestPkt.htype = 1;
DhClientRequestPkt.hlen = 6;
DhClientRequestPkt.xid = pCurCtxtBlock->ulTransActionId;
DhClientRequestPkt.ciaddr = pCurCtxtBlock->LeasedIpAddress;
//memcpy(DhClientRequestPkt.chaddr, pCurCtxtBlock->aucHwAddress, 6);
GetHwAddr(DhClientRequestPkt.chaddr, pCurCtxtBlock->cszIfName);
memcpy(caSendingPkt, &DhClientRequestPkt, sizeof(DhClientRequestPkt));
index = sizeof(DhClientRequestPkt);
PktPos = caSendingPkt + index;
memcpy(PktPos,DHCP_OPTIONS_COOKIE, 4);
PktPos = PktPos + 4;
index += 4;
*PktPos++ = DHCP_MESSAGE_TYPE;
*PktPos++ = DHCP_MESSAGE_OPTION_LEN;
*PktPos++ = DHCPDECLINE;
index += 3;
*PktPos++ = DHO_DHCP_CLIENT_IDENTIFIER;
*PktPos++ = 7;
index += 2;
*PktPos += 1;
PktPos++;
GetHwAddr(PktPos, pCurCtxtBlock->cszIfName);
PktPos += 6;
index += 7;
*PktPos++ = DHO_DHCP_REQUESTED_ADDRESS;
*PktPos++ = IPADDR_LEN;
htonlIpAddr = pCurCtxtBlock->LeasedIpAddress;
memcpy(PktPos, &htonlIpAddr, IPADDR_LEN);
PktPos = PktPos + IPADDR_LEN;
index += (IPADDR_LEN+2);
*PktPos++ = DHO_DHCP_SERVER_IDENTIFIER;
*PktPos++ = IPADDR_LEN;
htonlIpAddr = 0;
htonlIpAddr = pCurCtxtBlock->DHCPServerIpAddr;
memcpy(PktPos,&htonlIpAddr,IPADDR_LEN);
PktPos = PktPos + IPADDR_LEN;
index += (2 + IPADDR_LEN);
*PktPos++ = DHO_DHCP_MESSAGE;
*PktPos++ = strlen(ReasonBuf);
index += (strlen(ReasonBuf)+2);
for(pPading = ReasonBuf; *pPading != '\0'; ++pPading)
{
*PktPos++ = *pPading;
}
*PktPos = END_OPTION;
index += 1;
DHCPCIpAddressInfo.ulServerIpAddress = BROADCAST_IP_ADDRESS;
GetHwAddr(pCurCtxtBlock->aucHwAddress, pCurCtxtBlock->cszIfName);
if (DHCPCFunctionInfo.SendPacket(pCurCtxtBlock->cszIfName, (uint8_t *)caSendingPkt,
index, 0, DHCPCIpAddressInfo.ulServerIpAddress)<0)
{
printf("Sending DHCP decline pkt error\n");
return FALSE;
}
return TRUE;
}
int DHCPClientSendDHCPRelease(DHCPClientBlock_t *pCurCtxtBlock)
{
//DhClientRequestPkt.chaddr
uint8_t caSendingPkt[DHCP_CLIENT_PACKET_MAXIMUM_LEN];
uint32_t index=0, uiLen=0;
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -