dhcp_client.c

wimax bs模拟器

		hashKey = hash_func((char *)pBinding->cid.id,pBinding->cid.idlen);
		pBinding->hashKey_cid = DHCP_BIND_CID_HASHKEY(hashKey);
		pList = &gDhcpClientBindCidList[pBinding->hashKey_cid];
		TAILQ_INSERT_TAIL(pList, pBinding,cidNode);
		DHCP_NODE_HASH_SET(pBinding, DHCP_NODE_HASH_CID);
	}

	/* 2> set binding's haddr and hash*/
	if(pBinding->haddr.hlen) {
		hashKey = hash_func((char *)pBinding->haddr.haddr,pBinding->haddr.hlen);
		pBinding->hashKey_haddr = DHCP_BIND_HADDR_HASHKEY(hashKey);
		pList = &gDhcpClientBindHaddrList[pBinding->hashKey_haddr];
		TAILQ_INSERT_TAIL(pList,pBinding,haddrNode);
		DHCP_NODE_HASH_SET(pBinding,DHCP_NODE_HASH_HADDR);
	}
	
	return OK;
	
}


St_DhcpBinding* dhcp_client_lookup_by_cid_haddr(struct client_id *pCid,struct chaddr *pHaddr,unsigned int cidFlag)
{
	int hashKey;
	St_DhcpBinding *pBinding = NULL;
	St_DhcpBinding_List *pList = NULL;

	/* 1> lookup cid hash table */
	if(cidFlag) {
		hashKey = DHCP_BIND_CID_HASHKEY(hash_func((char *)pCid->id,pCid->idlen));
		pList = &gDhcpClientBindCidList[hashKey];

		TAILQ_FOREACH(pBinding, pList, cidNode) {
			if (pBinding->state && pBinding->hashKey_cid == hashKey && bindcidcmp(pCid,pBinding)) {
				return pBinding;
			}
		}
		return NULL;
	} else {
		/* 2> lookup haddr hash table */
		hashKey = DHCP_BIND_HADDR_HASHKEY(hash_func((char *)pHaddr->haddr,pHaddr->hlen));
		pList = &gDhcpClientBindHaddrList[hashKey];
		TAILQ_FOREACH(pBinding, pList, haddrNode) {
			if (pBinding->state && pBinding->hashKey_haddr == hashKey && bindhaddrcmp(pHaddr,pBinding)) {
				return pBinding;
			}
		}
	}
	return NULL;
}


St_DhcpBinding* dhcp_client_alloc_binding()
{
	St_DhcpBinding *pBinding = NULL;
	St_DhcpBinding_List *pBindingList = NULL;
	
	if (NULL != (pBinding  = TAILQ_FIRST(&gDhcpClientBindFreeList))){
		TAILQ_REMOVE(&gDhcpClientBindFreeList, pBinding, listNode);
	} else {
		TRACE3("no free binding\n");
		return NULL;
	}

	if(!DHCP_BINDING_GOOD(pBinding)) {
		TRACE3("binding context damaged\n");
		return NULL;
	}

	/* clear some member */
	pBinding->hashed = 0;
	pBinding->hashKey_cid = 0;
	pBinding->hashKey_r1 = 0;
	pBinding->hashKey_mon = 0;
	pBinding->hashKey_haddr = 0;
	pBinding->hashKey_ip = 0;
	pBinding->hashKey_xid = 0;

	pBinding->xid = 0;
	pBinding->expire_epoch = 0;
	pBinding->renew_epoch = 0;
	pBinding->temp_epoch = 0;

	pBinding->renew_to_times = 0;
	pBinding->temp_epoch_reason = 0;
	
	pBinding->state = ADFS_W4_INIT_DISCOVER;

	/* set hash at the same time */
	dhcp_client_set_hash(pBinding);

	if(gDhcpClientGlobalConfig.cidFlag == 0 && gDhcpClientGlobalConfig.haddrFlag == 0) {
		TRACE3("must use either cid or haddr\n");
		gDhcpClientGlobalConfig.cidFlag = 1;
	}
	if(gDhcpClientGlobalConfig.cidFlag) {
		pBinding->cidFlag = 1;
	}

	if(gDhcpClientGlobalConfig.haddrFlag) {
		pBinding->haddrFlag = 1;
	}
	
	return pBinding;
}


int dhcp_client_free_binding(St_DhcpBinding *pBinding)
{
	if(!DHCP_BINDING_GOOD(pBinding)) {
		TRACE("binding context damaged\n");
		return ERROR;
	}

	/* remove from hash list if needed */
	if(DHCP_NODE_HASH_IS_SET(pBinding, DHCP_NODE_HASH_CID)) {
		TAILQ_REMOVE(&gDhcpClientBindCidList[pBinding->hashKey_cid], pBinding, cidNode);
	}

	if(DHCP_NODE_HASH_IS_SET(pBinding, DHCP_NODE_HASH_HADDR)) {
		TAILQ_REMOVE(&gDhcpClientBindHaddrList[pBinding->hashKey_haddr], pBinding, haddrNode);
	}

	/* release timer */

	/* insert to binding free list */
	TAILQ_INSERT_TAIL(&gDhcpClientBindFreeList,pBinding, listNode);

	return OK;
}



int dhcp_client_get_msg_option(DHCP_MSG *pDhcp, int msgLen,St_DhcpBinding *pBinding)
{
	unsigned int msgType;
	char *option = NULL;

	if(!pDhcp || !pBinding || msgLen == 0 || !pBinding->pRes) {
		TRACE3("input null or 0 len\n");
		return ERROR;
	}

	option = pickup_opt(pDhcp,msgLen,_DHCP_MSGTYPE_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_MSGTYPE_TAG");
		return ERROR;
	} else {
		msgType = (int) *OPTBODY(option);
	}

	/* my ip addr */
	pBinding->pRes->ip_addr.s_addr = pDhcp->yiaddr.s_addr;

	/* server id */
	option = pickup_opt(pDhcp,msgLen,_DHCP_SERVER_ID_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_SERVER_ID_TAG");
		return ERROR;
	} else {
		pBinding->pRes->siaddr.s_addr = htonl(GETHL(OPTBODY(option)));
		DHCP_SETBIT(pBinding->pRes->valid,S_SIADDR);
	}

	option = pickup_opt(pDhcp,msgLen,_DHCP_SUBNET_MASK_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_SUBNET_MASK_TAG");
		/*return ERROR;*/
	} else {
		pBinding->pRes->subnet_mask.s_addr = htonl(GETHL(OPTBODY(option)));
		DHCP_SETBIT(pBinding->pRes->valid,S_SUBNET_MASK);
	}

	/* lease time */
	option = pickup_opt(pDhcp,msgLen,_DHCP_LEASE_TIME_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_LEASE_TIME_TAG");
		return ERROR;
	} else {
		pBinding->pRes->offer_lease= htonl(GETHL(OPTBODY(option)));
	}

	/* t1 and t2 */
	option = pickup_opt(pDhcp,msgLen,_DHCP_T1_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_T1_TAG");
		/*return ERROR;*/
	} else {
		pBinding->pRes->dhcp_t1 = htonl(GETHL(OPTBODY(option)));
		DHCP_SETBIT(pBinding->pRes->valid,S_DHCP_T1);
	}

	option = pickup_opt(pDhcp,msgLen,_DHCP_T2_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_T2_TAG");
		/*return ERROR;*/
	} else {
		pBinding->pRes->dhcp_t2 = htonl(GETHL(OPTBODY(option)));
		DHCP_SETBIT(pBinding->pRes->valid,S_DHCP_T2);
	}

	if (!DHCP_ISSET(pBinding->pRes->valid, S_DHCP_T1)) {
		pBinding->pRes->dhcp_t1 = pBinding->pRes->offer_lease/ 2;
		DHCP_SETBIT(pBinding->pRes->valid, S_DHCP_T1);
	}
	
	if (!DHCP_ISSET(pBinding->pRes->valid, S_DHCP_T2)){
		pBinding->pRes->dhcp_t2 = pBinding->pRes->offer_lease*7/8;
		DHCP_SETBIT(pBinding->pRes->valid, S_DHCP_T2);
	}

	/* dns domain name */
	option = pickup_opt(pDhcp,msgLen,_DHCP_DNS_DOMAIN_TAG);
	if(NULL == option) {
		TRACE3("no tag %s\n","_DHCP_DNS_DOMAIN_TAG");
		/*return ERROR;*/
	} else {
		DHCP_SETBIT(pBinding->pRes->valid,S_DNS_DOMAIN);
		if(DHCPOPTLEN(option) < 128) {
			bcopy((char *)OPTBODY(option),gDhcpClientGlobalConfig.domainName,DHCPOPTLEN(option));
		} else {
			bcopy((char *)OPTBODY(option),gDhcpClientGlobalConfig.domainName,DHCP_DOMAIN_NAME_MAX_LEN);
		}
	}


	return OK;
}


int dhcp_client_have_option_room(int offset, int optLen)
{
	if ((offset+2+optLen) < DFLTOPTLEN) {
		return 1;
	} else {
		return 0;
	}
}


int dhcp_client_merge_config(St_DhcpBinding *pOld,St_DhcpBinding *pNew)
{
	/* not used temp */
#if 0
	if (pOld == NULL || pNew == NULL)
		return ERROR;

	if (pNew->pRes->sname == NULL && pOld->pRes->sname != NULL)
		pNew->pRes->sname = pOld->pRes->sname;

	if (pNew->pRes->file == NULL && pOld->pRes->file != NULL)
		pNew->pRes->file = pOld->pRes->file;

	if (pNew->pRes->hostname == NULL && pOld->pRes->hostname != NULL)
		pNew->pRes->hostname = pOld->pRes->hostname;

	if (pNew->pRes->merit_dump == NULL && pOld->pRes->merit_dump != NULL)
		pNew->pRes->merit_dump = pOld->pRes->merit_dump;

	if (pNew->pRes->dns_domain == NULL && pOld->pRes->dns_domain != NULL)
		pNew->pRes->dns_domain = pOld->pRes->dns_domain;

	if (pNew->pRes->root_path == NULL && pOld->pRes->root_path != NULL)
		pNew->pRes->root_path = pOld->pRes->root_path;

	if (pNew->pRes->extensions_path == NULL && pOld->pRes->extensions_path != NULL)
		pNew->pRes->extensions_path = pOld->pRes->extensions_path;

	if (pNew->pRes->nis_domain == NULL && pOld->pRes->nis_domain != NULL)
		pNew->pRes->nis_domain = pOld->pRes->nis_domain;

	if (pNew->pRes->nb_scope == NULL && pOld->pRes->nb_scope != NULL)
		pNew->pRes->nb_scope = pOld->pRes->nb_scope;

	if (pNew->pRes->errmsg == NULL && pOld->pRes->errmsg != NULL)
		pNew->pRes->errmsg = pOld->pRes->errmsg;

	if (pNew->pRes->nisp_domain == NULL && pOld->pRes->nisp_domain != NULL)
		pNew->pRes->nisp_domain = pOld->pRes->nisp_domain;

	if (pNew->pRes->mtu_plateau_table == NULL && pOld->pRes->mtu_plateau_table != NULL)
	{
		pNew->pRes->mtu_plateau_table = pOld->pRes->mtu_plateau_table;
	}

	if (pNew->pRes->subnet_mask.s_addr == 0 && pOld->pRes->subnet_mask.s_addr != 0)
		pNew->pRes->subnet_mask = pOld->pRes->subnet_mask;


	if (pNew->pRes->swap_server == NULL && pOld->pRes->swap_server != NULL)
		pNew->pRes->swap_server = pOld->pRes->swap_server;

	if (pNew->pRes->brdcast_addr == NULL && pOld->pRes->brdcast_addr != NULL)
		pNew->pRes->brdcast_addr = pOld->pRes->brdcast_addr;

	if (pNew->pRes->router_solicit == NULL && pOld->pRes->router_solicit != NULL)
		pNew->pRes->router_solicit = pOld->pRes->router_solicit;

	if (pNew->pRes->router == NULL && pOld->pRes->router != NULL)
	{
		pNew->pRes->router = pOld->pRes->router;
	}

	if (pNew->pRes->time_server == NULL && pOld->pRes->time_server != NULL)
	{
		pNew->pRes->time_server = pOld->pRes->time_server;
	}

	if (pNew->pRes->name_server == NULL && pOld->pRes->name_server != NULL)
	{
		pNew->pRes->name_server = pOld->pRes->name_server;
	}

	if (pNew->pRes->dns_server == NULL && pOld->pRes->dns_server != NULL)
	{
		pNew->pRes->dns_server = pOld->pRes->dns_server;
	}

	if (pNew->pRes->log_server == NULL && pOld->pRes->log_server != NULL)
	{
		pNew->pRes->log_server = pOld->pRes->log_server;
	}


	if (pNew->pRes->cookie_server == NULL && pOld->pRes->cookie_server != NULL)
	{
		pNew->pRes->cookie_server = pOld->pRes->cookie_server;
	}


	if (pNew->pRes->lpr_server == NULL && pOld->pRes->lpr_server != NULL)
	{
		pNew->pRes->lpr_server = pOld->pRes->lpr_server;
	}

	if (pNew->pRes->impress_server == NULL && pOld->pRes->impress_server != NULL)
	{
		pNew->pRes->impress_server = pOld->pRes->impress_server;
	}


	if (pNew->pRes->rls_server == NULL && pOld->pRes->rls_server != NULL)
	{
		pNew->pRes->rls_server = pOld->pRes->rls_server;
	}


	if (pNew->pRes->policy_filter == NULL && pOld->pRes->policy_filter != NULL)
	{
		pNew->pRes->policy_filter = pOld->pRes->policy_filter;
	}

	if (pNew->pRes->static_route == NULL && pOld->pRes->static_route != NULL)
	{
		pNew->pRes->static_route = pOld->pRes->static_route;
	}

	if (pNew->pRes->nis_server == NULL && pOld->pRes->nis_server != NULL)
	{
		pNew->pRes->nis_server = pOld->pRes->nis_server;
	}

	if (pNew->pRes->ntp_server == NULL && pOld->pRes->ntp_server != NULL)
	{
		pNew->pRes->ntp_server = pOld->pRes->ntp_server;
	}

	if (pNew->pRes->pRes->nbn_server == NULL && pOld->pRes->nbn_server != NULL)
	{
		pNew->pRes->nbn_server = pOld->pRes->nbn_server;
	}

	if (pNew->pRes->nbdd_server == NULL && pOld->pRes->nbdd_server != NULL)
	{
		pNew->pRes->nbdd_server = pOld->pRes->nbdd_server;
	}

	if (pNew->pRes->xfont_server == NULL && pOld->pRes->xfont_server != NULL)
	{
		pNew->pRes->xfont_server = pOld->pRes->xfont_server;
	}

	if (pNew->pRes->xdisplay_manager == NULL && pOld->pRes->xdisplay_manager != NULL)
	{
		pNew->pRes->xdisplay_manager = pOld->pRes->xdisplay_manager;
	}

	if (pNew->pRes->nisp_server == NULL && pOld->pRes->nisp_server != NULL)
	{
		pNew->pRes->nisp_server = pOld->pRes->nisp_server;
	}

	if (pNew->pRes->mobileip_ha == NULL && pOld->pRes->mobileip_ha != NULL)
	{
		pNew->pRes->mobileip_ha = pOld->pRes->mobileip_ha;
	}

	if (pNew->pRes->smtp_server == NULL && pOld->pRes->smtp_server != NULL)
	{
		pNew->pRes->smtp_server = pOld->pRes->smtp_server;
	}

	if (pNew->pRes->pop3_server == NULL && pOld->pRes->pop3_server != NULL)
	{
		pNew->pRes->pop3_server = pOld->pRes->pop3_server;
	}

	if (pNew->pRes->nntp_server == NULL && pOld->pRes->nntp_server != NULL)
	{
		pNew->pRes->nntp_server = pOld->pRes->nntp_server;
	}

	if (pNew->pRes->dflt_www_server == NULL && pOld->pRes->dflt_www_server != NULL)
	{
		pNew->pRes->dflt_www_server = pOld->pRes->dflt_www_server;
	}

	if (pNew->pRes->dflt_finger_server == NULL &&
		pOld->pRes->dflt_finger_server != NULL)
	{
		pNew->pRes->dflt_finger_server = pOld->pRes->dflt_finger_server;
	}

	if (pNew->pRes->dflt_irc_server == NULL &&
		pOld->pRes->dflt_irc_server != NULL)
	{
		pNew->pRes->dflt_irc_server = pOld->pRes->dflt_irc_server;
	}

	if (pNew->pRes->streettalk_server == NULL &&
		pOld->pRes->streettalk_server != NULL)
	{
		pNew->pRes->streettalk_server = pOld->pRes->streettalk_server;
	}

	if (pNew->pRes->stda_server == NULL && pOld->pRes->stda_server != NULL)
	{
		pNew->pRes->stda_server = pOld->pRes->stda_server;
	}

#endif

	return OK;

}

int make_discover(St_DhcpBinding *pBinding)
{
	int offset = 0;    /* offset in options field */
	int optLen;
	unsigned long ulTemp;
	unsigned short usTemp;
	struct dhcp *pDhcp = pDhcpcOut;

	DHCP_ASSERT(DHCP_BINDING_GOOD(pBinding));

	bzero((char *)pDhcp,sizeof(struct dhcp));
	
	TRACE0("pDhcp 0x%x\n",(unsigned int)pDhcp);
	DEBUG_UT_DHCP("begin\n",pDhcp,offset);
	
	pDhcp->op = BOOTREQUEST;
	pDhcp->htype = pBinding->haddr.htype;
	pDhcp->hlen = pBinding->haddr.hlen;
	pDhcp->xid = *((unsigned int*)&pBinding->cid.id[2]);
	pDhcp->hops = 0;
	pDhcp->secs = 0;
	if(gDhcpClientGlobalConfig.discoverWithBroadcast) {
		SETBRDCST(pDhcp->flags);
	} else {
		
	}
	pDhcp->ciaddr.s_addr = 0;
	pDhcp->yiaddr.s_addr = 0;
	pDhcp->siaddr.s_addr = 0;
	pDhcp->giaddr.s_addr = 0;
	bcopy(pBinding->haddr.haddr,(char *)pDhcp->chaddr,pBinding->haddr.hlen);
	bzero((char *)pDhcp->sname,MAX_SNAME);
	bzero((char *)pDhcp->file,MAX_FILE);

	/* insert magic cookie */
	bcopy ((char *)dhcpCookie, pDhcp->options, MAGIC_LEN);