diff options
Diffstat (limited to 'libdhcp')
| -rw-r--r-- | libdhcp/dhcp.c | 500 | ||||
| -rw-r--r-- | libdhcp/include/libdhcp/dhcp.h | 12 |
2 files changed, 237 insertions, 275 deletions
diff --git a/libdhcp/dhcp.c b/libdhcp/dhcp.c index 48e5207..f55d224 100644 --- a/libdhcp/dhcp.c +++ b/libdhcp/dhcp.c @@ -64,7 +64,7 @@ * SPDX-Licence-Identifier: MIT */ -#include <string.h> +#include <string.h> /* for strlen(), memcpy(), memset() */ #include <libmisc/endian.h> #include <libdhcp/dhcp.h> @@ -211,12 +211,14 @@ static_assert(offsetof(struct dhcp_msg, options) == 236); #define DHCP_OP_BOOTREQUEST 1 #define DHCP_OP_BOOTREPLY 2 -/* DHCP hardware type; - * https://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml#arp-parameters-2 */ +/** + * DHCP hardware type; + * https://www.iana.org/assignments/arp-parameters/arp-parameters.xhtml#arp-parameters-2 + */ #define DHCP_HTYPE_ETHERNET 1 -uint8_t DHCP_SIP[4]; // DHCP Server IP address -uint8_t DHCP_REAL_SIP[4]; // For extract my DHCP server in a few DHCP server +struct net_ip4_addr DHCP_SIP; // DHCP Server IP address +struct net_ip4_addr DHCP_REAL_SIP; // For extract my DHCP server in a few DHCP server // Network information from DHCP Server @@ -251,8 +253,22 @@ void reset_DHCP_timeout(void); /* Parse message as OFFER and ACK and NACK from DHCP server.*/ int8_t parseDHCPCMSG(void); +#define mem_encode(dst, obj) ({ \ + typeof(obj) _obj = obj; \ + memcpy(dst, &_obj, sizeof(_obj)); \ + sizeof(_obj); \ +}) + +static inline size_t str_encode(void *dst, char *str) { + size_t len = strlen(str); + memcpy(dst, str, len); + return len; +} + /* make the common DHCP message */ void dhcp_msg_init(struct dhcp_msg *msg, size_t *optlen) { + size_t tmp; + msg->op = DHCP_OP_BOOTREQUEST; msg->htype = DHCP_HTYPE_ETHERNET; msg->hlen = sizeof(global_eth_addr); @@ -266,8 +282,8 @@ void dhcp_msg_init(struct dhcp_msg *msg, size_t *optlen) { msg->siaddr = (struct net_ip4_addr){0}; msg->giaddr = (struct net_ip4_addr){0}; - memset(msg->chaddr, 0, sizeof(msg->chaddr)); - memcpy(msg->chaddr, global_eth_addr.octets, sizeof(global_eth_addr)); + tmp = mem_encode(msg->chaddr, global_eth_addr); + memset(&msg->chaddr[tmp], 0, sizeof(msg->chaddr)-tmp); memset(msg->sname, 0, sizeof(msg->sname)); memset(msg->file, 0, sizeof(msg->file)); @@ -281,14 +297,8 @@ void send_DHCP_DISCOVER(implements_net_udpsock *sock) { size_t k; dhcp_msg_init(pDHCPMSG, &k); - DHCP_SIP[0]=0; - DHCP_SIP[1]=0; - DHCP_SIP[2]=0; - DHCP_SIP[3]=0; - DHCP_REAL_SIP[0]=0; - DHCP_REAL_SIP[1]=0; - DHCP_REAL_SIP[2]=0; - DHCP_REAL_SIP[3]=0; + DHCP_SIP = (struct net_ip4_addr){0}; + DHCP_REAL_SIP = (struct net_ip4_addr){0}; /* Message type. */ pDHCPMSG->options[k++] = DHCP_OPT_DHCP_MSG_TYPE; @@ -299,123 +309,112 @@ void send_DHCP_DISCOVER(implements_net_udpsock *sock) { pDHCPMSG->options[k++] = DHCP_OPT_CLIENT_ID; pDHCPMSG->options[k++] = 1+sizeof(global_eth_addr); pDHCPMSG->options[k++] = DHCP_HTYPE_ETHERNET; - memcpy(&pDHCPMSG->options[k], global_eth_addr.octets, sizeof(global_eth_addr)); - k += sizeof(global_eth_addr); + k += mem_encode(&pDHCPMSG->options[k], global_eth_addr); /* Our requested hostname. */ pDHCPMSG->options[k++] = DHCP_OPT_HOSTNAME; pDHCPMSG->options[k++] = strlen(global_hostname); - strcpy((char *)&pDHCPMSG->options[k], global_hostname); - k += strlen(global_hostname); + k += str_encode(&pDHCPMSG->options[k], global_hostname); /* Which parameters we want back. */ pDHCPMSG->options[k++] = DHCP_OPT_PARAMETER_LIST; pDHCPMSG->options[k++] = 6; - pDHCPMSG->options[k++] = DHCP_OPT_SUBNET_MASK; - pDHCPMSG->options[k++] = DHCP_OPT_ROUTER; - pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_SERVER; - pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_NAME; - pDHCPMSG->options[k++] = DHCP_OPT_RENEWAL_TIME; - pDHCPMSG->options[k++] = DHCP_OPT_REBINDING_TIME; + pDHCPMSG->options[k++] = DHCP_OPT_SUBNET_MASK; /* 1 */ + pDHCPMSG->options[k++] = DHCP_OPT_ROUTER; /* 2 */ + pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_SERVER; /* 3 */ + pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_NAME; /* 4 */ + pDHCPMSG->options[k++] = DHCP_OPT_RENEWAL_TIME; /* 5 */ + pDHCPMSG->options[k++] = DHCP_OPT_REBINDING_TIME; /* 6 */ /* End. */ pDHCPMSG->options[k++] = DHCP_OPT_END; debugf("> Send DHCP_DISCOVER"); - sendto(sock, pDHCPMSG, DHCP_MSG_BASE_SIZE + k, net_ip4_broadcast_addr, DHCP_SERVER_PORT); + assert(k <= CONFIG_DHCP_OPT_SIZE); + sendto(sock, pDHCPMSG, DHCP_MSG_BASE_SIZE + k, net_ip4_addr_broadcast, DHCP_SERVER_PORT); } /* SEND DHCP REQUEST */ void send_DHCP_REQUEST(implements_net_udpsock *sock) { - int i; struct net_ip4_addr ip; - size_t k = 0; + size_t k; dhcp_msg_init(pDHCPMSG, &k); - if(dhcp_state == STATE_DHCP_LEASED || dhcp_state == STATE_DHCP_REREQUEST) { + switch (dhcp_state) { + case STATE_DHCP_LEASED: + case STATE_DHCP_REREQUEST: pDHCPMSG->flags = uint16be_marshal(DHCP_FLAGSUNICAST); pDHCPMSG->ciaddr = global_lease.addr; ip = DHCP_SIP; - } else { - ip = net_ip4_broadcast_addr; + break; + default: + ip = net_ip4_addr_broadcast; } /* Message type. */ pDHCPMSG->options[k++] = DHCP_OPT_DHCP_MSG_TYPE; pDHCPMSG->options[k++] = 1; - pDHCPMSG->options[k++] = DHCP_REQUEST; + pDHCPMSG->options[k++] = DHCP_MSGTYP_REQUEST; /* Our Client ID. */ pDHCPMSG->options[k++] = DHCP_OPT_CLIENT_ID; pDHCPMSG->options[k++] = 1+sizeof(global_eth_addr); pDHCPMSG->options[k++] = DHCP_HTYPE_ETHERNET; - memcpy(&pDHCPMSG->options[k], global_eth_addr.octets, sizeof(global_eth_addr)); - k += sizeof(global_eth_addr); - - if(ip.octets[3] == 255) { // if(dchp_state == STATE_DHCP_LEASED || dchp_state == DHCP_REREQUEST_STATE) - pDHCPMSG->options[k++] = dhcpRequestedIPaddr; - pDHCPMSG->options[k++] = 0x04; - pDHCPMSG->options[k++] = global_lease.addr.octets[0]; - pDHCPMSG->options[k++] = global_lease.addr.octets[1]; - pDHCPMSG->options[k++] = global_lease.addr.octets[2]; - pDHCPMSG->options[k++] = global_lease.addr.octets[3]; - - pDHCPMSG->options[k++] = dhcpServerIdentifier; - pDHCPMSG->options[k++] = 0x04; - pDHCPMSG->options[k++] = DHCP_SIP[0]; - pDHCPMSG->options[k++] = DHCP_SIP[1]; - pDHCPMSG->options[k++] = DHCP_SIP[2]; - pDHCPMSG->options[k++] = DHCP_SIP[3]; + k += mem_encode(&pDHCPMSG->options[k], global_eth_addr); + + switch (dhcp_state) { + case STATE_DHCP_LEASED: + case STATE_DHCP_REREQUEST: + /* Our current IP address. */ + pDHCPMSG->options[k++] = DHCP_OPT_ADDRESS_REQUEST; + pDHCPMSG->options[k++] = sizeof(global_lease.addr); + k += mem_encode(&pDHCPMSG->options[k], global_lease.addr); + + /* The server we got it from. */ + pDHCPMSG->options[k++] = DHCP_OPT_DHCP_SERVER_ID; + pDHCPMSG->options[k++] = sizeof(DHCP_SIP); + k += mem_encode(&pDHCPMSG->options[k], DHCP_SIP); } - // host name - pDHCPMSG->options[k++] = hostName; - pDHCPMSG->options[k++] = 0; // length of hostname - for(i = 0 ; HOST_NAME[i] != 0; i++) - pDHCPMSG->options[k++] = HOST_NAME[i]; - pDHCPMSG->options[k++] = hexdig(global_eth_addr[3] >> 4); - pDHCPMSG->options[k++] = hexdig(global_eth_addr[3]); - pDHCPMSG->options[k++] = hexdig(global_eth_addr[4] >> 4); - pDHCPMSG->options[k++] = hexdig(global_eth_addr[4]); - pDHCPMSG->options[k++] = hexdig(global_eth_addr[5] >> 4); - pDHCPMSG->options[k++] = hexdig(global_eth_addr[5]); - pDHCPMSG->options[k - (i+6+1)] = i+6; // length of hostname - - pDHCPMSG->options[k++] = dhcpParamRequest; - pDHCPMSG->options[k++] = 0x08; - pDHCPMSG->options[k++] = DHCP_OPT_SUBNET_MASK; - pDHCPMSG->options[k++] = DHCP_OPT_ROUTER; - pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_SERVER; - pDHCPMSG->options[k++] = domainName; - pDHCPMSG->options[k++] = dhcpT1value; - pDHCPMSG->options[k++] = dhcpT2value; - pDHCPMSG->options[k++] = performRouterDiscovery; - pDHCPMSG->options[k++] = staticRoute; + /* Our requested hostname. */ + pDHCPMSG->options[k++] = DHCP_OPT_HOSTNAME; + pDHCPMSG->options[k++] = strlen(global_hostname); + k += str_encode(&pDHCPMSG->options[k], global_hostname); + + /* Which parameters we want back. */ + pDHCPMSG->options[k++] = DHCP_OPT_PARAMETER_LIST; + pDHCPMSG->options[k++] = 8; + pDHCPMSG->options[k++] = DHCP_OPT_SUBNET_MASK; /* 1 */ + pDHCPMSG->options[k++] = DHCP_OPT_ROUTER; /* 2 */ + pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_SERVER; /* 3 */ + pDHCPMSG->options[k++] = DHCP_OPT_DOMAIN_NAME; /* 4 */ + pDHCPMSG->options[k++] = DHCP_OPT_RENEWAL_TIME; /* 5 */ + pDHCPMSG->options[k++] = DHCP_OPT_REBINDING_TIME; /* 6 */ + pDHCPMSG->options[k++] = DHCP_OPT_ROUTER_DISCOVERY; /* 7 */ + pDHCPMSG->options[k++] = DHCP_OPT_STATIC_ROUTE; /* 8 */ + + /* End. */ pDHCPMSG->options[k++] = DHCP_OPT_END; debugf("> Send DHCP_REQUEST"); - + assert(k <= CONFIG_DHCP_OPT_SIZE); sendto(sock, pDHCPMSG, DHCP_MSG_BASE_SIZE + k, ip, DHCP_SERVER_PORT); } /* SEND DHCP DHCPDECLINE */ void send_DHCP_DECLINE(implements_net_udpsock *sock) { - int i; - struct net_ip4_addr ip; - uint16_t k = 0; - - makeDHCPMSG(); + size_t k; - k = 4; // because MAGIC_COOKIE already made by makeDHCPMSG() + dhcp_msg_init(pDHCPMSG, &k); *((uint8_t*)(&pDHCPMSG->flags)) = ((DHCP_FLAGSUNICAST & 0xFF00)>> 8); *((uint8_t*)(&pDHCPMSG->flags)+1) = (DHCP_FLAGSUNICAST & 0x00FF); // Option Request Param. pDHCPMSG->options[k++] = DHCP_OPT_DHCP_MSG_TYPE; - pDHCPMSG->options[k++] = 0x01; - pDHCPMSG->options[k++] = DHCP_DECLINE; + pDHCPMSG->options[k++] = 1; + pDHCPMSG->options[k++] = DHCP_MSGTYP_DECLINE; /* Our Client ID. */ pDHCPMSG->options[k++] = DHCP_OPT_CLIENT_ID; @@ -424,181 +423,151 @@ void send_DHCP_DECLINE(implements_net_udpsock *sock) { memcpy(&pDHCPMSG->options[k], global_eth_addr.octets, sizeof(global_eth_addr)); k += sizeof(global_eth_addr); - pDHCPMSG->options[k++] = dhcpRequestedIPaddr; - pDHCPMSG->options[k++] = 0x04; - pDHCPMSG->options[k++] = global_lease.addr.octets[0]; - pDHCPMSG->options[k++] = global_lease.addr.octets[1]; - pDHCPMSG->options[k++] = global_lease.addr.octets[2]; - pDHCPMSG->options[k++] = global_lease.addr.octets[3]; + /* Our current IP address. */ + pDHCPMSG->options[k++] = DHCP_OPT_ADDRESS_REQUEST; + pDHCPMSG->options[k++] = sizeof(global_lease.addr); + k += mem_encode(&pDHCPMSG->options[k], global_lease.addr); - pDHCPMSG->options[k++] = dhcpServerIdentifier; - pDHCPMSG->options[k++] = 0x04; - pDHCPMSG->options[k++] = DHCP_SIP[0]; - pDHCPMSG->options[k++] = DHCP_SIP[1]; - pDHCPMSG->options[k++] = DHCP_SIP[2]; - pDHCPMSG->options[k++] = DHCP_SIP[3]; + /* The server we got it from. */ + pDHCPMSG->options[k++] = DHCP_OPT_DHCP_SERVER_ID; + pDHCPMSG->options[k++] = sizeof(DHCP_SIP); + k += mem_encode(&pDHCPMSG->options[k], DHCP_SIP); + /* End. */ pDHCPMSG->options[k++] = DHCP_OPT_END; - for (i = k; i < options_SIZE; i++) - pDHCPMSG->options[i] = 0; - - //send broadcasting packet - ip.octets[0] = 0xFF; - ip.octets[1] = 0xFF; - ip.octets[2] = 0xFF; - ip.octets[3] = 0xFF; - debugf("> Send DHCP_DECLINE"); - - sendto(sock, pDHCPMSG, RIP_MSG_SIZE, ip, DHCP_SERVER_PORT); + assert(k <= CONFIG_DHCP_OPT_SIZE); + sendto(sock, pDHCPMSG, DHCP_MSG_BASE_SIZE + k, net_ip4_addr_broadcast, DHCP_SERVER_PORT); } /* PARSE REPLY pDHCPMSG */ -int8_t parseDHCPMSG(implements_net_udpsock *sock) { +int8_t dhcp_msg_parse(implements_net_udpsock *sock) { struct net_ip4_addr srv_addr; - uint16_t srv_port; - size_t len; - - uint8_t * p; - uint8_t * e; - uint8_t type = 0; - uint8_t opt_len; - - len = recvfrom(sock, pDHCPMSG, len, &srv_addr, &srv_port); + uint16_t srv_port; + size_t msg_len; + msg_len = recvfrom(sock, pDHCPMSG, sizeof(*pDHCPMSG), &srv_addr, &srv_port); debugf("DHCP message : %d.%d.%d.%d(%d) %d received.", srv_addr.octets[0], srv_addr.octets[1], srv_addr.octets[2], srv_addr.octets[3], srv_port, len); - if (srv_port == DHCP_SERVER_PORT) { - // compare mac address - if ( (pDHCPMSG->chaddr[0] != global_eth_addr[0]) || (pDHCPMSG->chaddr[1] != global_eth_addr[1]) || - (pDHCPMSG->chaddr[2] != global_eth_addr[2]) || (pDHCPMSG->chaddr[3] != global_eth_addr[3]) || - (pDHCPMSG->chaddr[4] != global_eth_addr[4]) || (pDHCPMSG->chaddr[5] != global_eth_addr[5]) ) { - debugf("No My DHCP Message. This message is ignored."); + /* Compare server port. */ + if (srv_port != DHCP_SERVER_PORT) { + return 0; + } + /* Compare our MAC address. */ + if (memcmp(pDHCPMSG->chaddr, global_eth_addr.octets, sizeof(global_eth_addr))) { + debugf("Not my DHCP Message. This message is ignored."); + return 0; + } + /* Compare server IP address. */ + if (memcmp(DHCP_SIP.octets, ((struct net_ip4_addr){0}).octets, sizeof(struct net_ip4_addr))) { + if ( memcmp(srv_addr.octets, DHCP_SIP.octets, sizeof(srv_addr)) && + memcmp(srv_addr.octets, DHCP_REAL_SIP.octets, sizeof(srv_addr)) ) { + debugf("Another DHCP sever send a response message. This is ignored."); return 0; } - //compare DHCP server ip address - if ((DHCP_SIP[0]!=0) || (DHCP_SIP[1]!=0) || (DHCP_SIP[2]!=0) || (DHCP_SIP[3]!=0)) { - if ( ((srv_addr.octets[0]!=DHCP_SIP[0])|| (srv_addr.octets[1]!=DHCP_SIP[1])|| (srv_addr.octets[2]!=DHCP_SIP[2])|| (srv_addr.octets[3]!=DHCP_SIP[3])) && - ((srv_addr.octets[0]!=DHCP_REAL_SIP[0])|| (srv_addr.octets[1]!=DHCP_REAL_SIP[1])|| (srv_addr.octets[2]!=DHCP_REAL_SIP[2])|| (srv_addr.octets[3]!=DHCP_REAL_SIP[3])) ) { - debugf("Another DHCP sever send a response message. This is ignored."); - return 0; - } + } + + uint8_t msg_type = 0; + for (size_t k = 4, k_max = msg_len - DHCP_MSG_BASE_SIZE, opt_len; k < k_max; k += opt_len) { + uint8_t opt_typ; + opt_typ = pDHCPMSG->options[k++]; + switch (opt_typ) { + case DHCP_OPT_END: + opt_len = k_max - k; + break; + case DHCP_OPT_PAD: + opt_len = 0; + break; + default: + opt_len = pDHCPMSG->options[k++]; } - p = (uint8_t *)(&pDHCPMSG->op); - p = p + 240; // 240 = sizeof(RIP_MSG) + MAGIC_COOKIE size in RIP_MSG.opt - sizeof(RIP_MSG.opt) - e = p + (len - 240); - - while ( p < e ) { - switch ( *p ) { - case DHCP_OPT_END : - p = e; // for break while(p < e) - break; - case DHCP_OPT_PAD : - p++; - break; - case DHCP_OPT_DHCP_MSG_TYPE : - p++; - p++; - type = *p++; - break; - case DHCP_OPT_SUBNET_MASK : - p++; - p++; - global_lease.subnet_mask.octets[0] = *p++; - global_lease.subnet_mask.octets[1] = *p++; - global_lease.subnet_mask.octets[2] = *p++; - global_lease.subnet_mask.octets[3] = *p++; - break; - case DHCP_OPT_ROUTER : - p++; - opt_len = *p++; - global_lease.gateway.octets[0] = *p++; - global_lease.gateway.octets[1] = *p++; - global_lease.gateway.octets[2] = *p++; - global_lease.gateway.octets[3] = *p++; - p = p + (opt_len - 4); - break; - case DHCP_OPT_DOMAIN_SERVER : - p++; - opt_len = *p++; - global_lease.dns.octets[0] = *p++; - global_lease.dns.octets[1] = *p++; - global_lease.dns.octets[2] = *p++; - global_lease.dns.octets[3] = *p++; - p = p + (opt_len - 4); - break; - case dhcpIPaddrLeaseTime : - p++; - opt_len = *p++; - global_lease.lifetime = *p++; - global_lease.lifetime = (global_lease.lifetime << 8) + *p++; - global_lease.lifetime = (global_lease.lifetime << 8) + *p++; - global_lease.lifetime = (global_lease.lifetime << 8) + *p++; + switch (opt_typ) { + case DHCP_OPT_DHCP_MSG_TYPE: + if (opt_len != 1) + continue; + msg_type = pDHCPMSG->options[k]; + break; + case DHCP_OPT_SUBNET_MASK: + if (opt_len != 4) + continue; + global_lease.subnet_mask.octets[0] = pDHCPMSG->options[k+0]; + global_lease.subnet_mask.octets[1] = pDHCPMSG->options[k+1]; + global_lease.subnet_mask.octets[2] = pDHCPMSG->options[k+2]; + global_lease.subnet_mask.octets[3] = pDHCPMSG->options[k+3]; + break; + case DHCP_OPT_ROUTER : + if (opt_len < 4) + continue; + global_lease.gateway.octets[0] = pDHCPMSG->options[k+0]; + global_lease.gateway.octets[1] = pDHCPMSG->options[k+1]; + global_lease.gateway.octets[2] = pDHCPMSG->options[k+2]; + global_lease.gateway.octets[3] = pDHCPMSG->options[k+3]; + break; + case DHCP_OPT_DOMAIN_SERVER : + if (opt_len < 4) + continue; + global_lease.dns.octets[0] = pDHCPMSG->options[k+0]; + global_lease.dns.octets[1] = pDHCPMSG->options[k+1]; + global_lease.dns.octets[2] = pDHCPMSG->options[k+2]; + global_lease.dns.octets[3] = pDHCPMSG->options[k+3]; + break; + case DHCP_OPT_ADDRESS_TIME: + if (opt_len != 4) + continue; + global_lease.lifetime = uint32be_decode(&pDHCPMSG->options[k]); #ifdef _DHCP_DEBUG_ - global_lease.lifetime = 10; + global_lease.lifetime = 10; #endif - break; - case dhcpServerIdentifier : - p++; - opt_len = *p++; - DHCP_SIP[0] = *p++; - DHCP_SIP[1] = *p++; - DHCP_SIP[2] = *p++; - DHCP_SIP[3] = *p++; - DHCP_REAL_SIP[0]=srv_addr.octets[0]; - DHCP_REAL_SIP[1]=srv_addr.octets[1]; - DHCP_REAL_SIP[2]=srv_addr.octets[2]; - DHCP_REAL_SIP[3]=srv_addr.octets[3]; - break; - default : - p++; - opt_len = *p++; - p += opt_len; - break; - } // switch - } // while - } // if - return type; + break; + case DHCP_OPT_DHCP_SERVER_ID: + if (opt_len != 4) + continue; + DHCP_SIP.octets[0] = pDHCPMSG->options[k+0]; + DHCP_SIP.octets[1] = pDHCPMSG->options[k+1]; + DHCP_SIP.octets[2] = pDHCPMSG->options[k+2]; + DHCP_SIP.octets[3] = pDHCPMSG->options[k+3]; + DHCP_REAL_SIP = srv_addr; + break; + } + } + return msg_type; } uint8_t DHCP_run(implements_net_udpsock *sock, dhcp_callback_t cb) { - uint8_t type; + uint8_t msg_type; uint8_t ret; - if(dhcp_state == STATE_DHCP_STOP) - return DHCP_STOPPED; + if (dhcp_state == STATE_DHCP_STOP) + return DHCP_RET_STOPPED; - if(getSn_SR(sock) != SOCK_UDP) - socket(sock, Sn_MR_UDP, DHCP_CLIENT_PORT, 0x00); + if (getSn_SR(sock) != SOCK_UDP) + socket(sock, Sn_MR_UDP, DHCP_CLIENT_PORT, 0); - ret = DHCP_RUNNING; - type = parseDHCPMSG(); + ret = DHCP_RET_RUNNING; + msg_type = dhcp_msg_parse(sock); switch ( dhcp_state ) { - case STATE_DHCP_INIT : + case STATE_DHCP_INIT: global_lease.addr.octets[0] = 0; global_lease.addr.octets[1] = 0; global_lease.addr.octets[2] = 0; global_lease.addr.octets[3] = 0; - send_DHCP_DISCOVER(); + send_DHCP_DISCOVER(sock); dhcp_state = STATE_DHCP_DISCOVER; break; case STATE_DHCP_DISCOVER : - if (type == DHCP_OFFER){ + if (msg_type == DHCP_MSGTYP_OFFER){ debugf("> Receive DHCP_OFFER"); - global_lease.addr.octets[0] = pDHCPMSG->yiaddr[0]; - global_lease.addr.octets[1] = pDHCPMSG->yiaddr[1]; - global_lease.addr.octets[2] = pDHCPMSG->yiaddr[2]; - global_lease.addr.octets[3] = pDHCPMSG->yiaddr[3]; + global_lease.addr = pDHCPMSG->yiaddr; - send_DHCP_REQUEST(); + send_DHCP_REQUEST(sock); dhcp_state = STATE_DHCP_REQUEST; } else ret = check_DHCP_timeout(); break; case STATE_DHCP_REQUEST : - if (type == DHCP_ACK) { + if (msg_type == DHCP_MSGTYP_ACK) { debugf("> Receive DHCP_ACK"); if (check_DHCP_leasedIP()) { // Network info assignment from DHCP @@ -612,7 +581,7 @@ uint8_t DHCP_run(implements_net_udpsock *sock, dhcp_callback_t cb) { cb(DHCP_CONFLICT, global_lease); dhcp_state = STATE_DHCP_INIT; } - } else if (type == DHCP_NAK) { + } else if (msg_type == DHCP_MSGTYP_NAK) { debugf("> Receive DHCP_NACK"); reset_DHCP_timeout(); @@ -623,19 +592,16 @@ uint8_t DHCP_run(implements_net_udpsock *sock, dhcp_callback_t cb) { break; case STATE_DHCP_LEASED : - ret = DHCP_IP_LEASED; + ret = DHCP_RET_IP_LEASED; if ((global_lease.lifetime != INFINITE_LEASETIME) && ((global_lease.lifetime/2) < dhcp_tick_1s)) { debugf("> Maintains the IP address"); - type = 0; - OLD_allocated_ip[0] = global_lease.addr.octets[0]; - OLD_allocated_ip[1] = global_lease.addr.octets[1]; - OLD_allocated_ip[2] = global_lease.addr.octets[2]; - OLD_allocated_ip[3] = global_lease.addr.octets[3]; + msg_type = 0; + OLD_allocated_ip = global_lease.addr; global_xid++; - send_DHCP_REQUEST(); + send_DHCP_REQUEST(sock); reset_DHCP_timeout(); @@ -644,14 +610,11 @@ uint8_t DHCP_run(implements_net_udpsock *sock, dhcp_callback_t cb) { break; case STATE_DHCP_REREQUEST : - ret = DHCP_IP_LEASED; - if (type == DHCP_ACK) { + ret = DHCP_RET_IP_LEASED; + if (msg_type == DHCP_MSGTYP_ACK) { dhcp_retry_count = 0; - if (OLD_allocated_ip[0] != global_lease.addr.octets[0] || - OLD_allocated_ip[1] != global_lease.addr.octets[1] || - OLD_allocated_ip[2] != global_lease.addr.octets[2] || - OLD_allocated_ip[3] != global_lease.addr.octets[3]) { - ret = DHCP_IP_CHANGED; + if (memcmp(OLD_allocated_ip.octets, global_lease.addr.octets, sizeof(global_lease.addr))) { + ret = DHCP_RET_IP_CHANGED; cb(DHCP_UPDATE, global_lease); debugf(">IP changed."); } else { @@ -659,7 +622,7 @@ uint8_t DHCP_run(implements_net_udpsock *sock, dhcp_callback_t cb) { } reset_DHCP_timeout(); dhcp_state = STATE_DHCP_LEASED; - } else if (type == DHCP_NAK) { + } else if (msg_type == DHCP_MSGTYP_NAK) { debugf("> Receive DHCP_NACK, Failed to maintain ip"); reset_DHCP_timeout(); @@ -674,13 +637,13 @@ uint8_t DHCP_run(implements_net_udpsock *sock, dhcp_callback_t cb) { return ret; } -void DHCP_stop(void) { - close(DHCP_SOCKET); +void DHCP_stop(implements_net_udpsock *sock) { + VCALL(sock, close); dhcp_state = STATE_DHCP_STOP; } -uint8_t check_DHCP_timeout(void) { - uint8_t ret = DHCP_RUNNING; +uint8_t check_DHCP_timeout(implements_net_udpsock *sock) { + uint8_t ret = DHCP_RET_RUNNING; if (dhcp_retry_count < MAX_DHCP_RETRY) { if (dhcp_tick_next < dhcp_tick_1s) { @@ -693,14 +656,12 @@ uint8_t check_DHCP_timeout(void) { case STATE_DHCP_REQUEST : //debugf("<<timeout>> state : STATE_DHCP_REQUEST"); - - send_DHCP_REQUEST(); + send_DHCP_REQUEST(sock); break; case STATE_DHCP_REREQUEST : //debugf("<<timeout>> state : STATE_DHCP_REREQUEST"); - - send_DHCP_REQUEST(); + send_DHCP_REQUEST(sock); break; default : @@ -716,7 +677,7 @@ uint8_t check_DHCP_timeout(void) { switch(dhcp_state) { case STATE_DHCP_DISCOVER: dhcp_state = STATE_DHCP_INIT; - ret = DHCP_FAILED; + ret = DHCP_RET_FAILED; break; case STATE_DHCP_REQUEST: case STATE_DHCP_REREQUEST: @@ -731,7 +692,7 @@ uint8_t check_DHCP_timeout(void) { return ret; } -int8_t check_DHCP_leasedIP(void) { +int8_t check_DHCP_leasedIP(implements_net_udpsock *sock) { uint8_t tmp; int32_t ret; @@ -741,7 +702,7 @@ int8_t check_DHCP_leasedIP(void) { // IP conflict detection : ARP request - ARP reply // Broadcasting ARP Request for check the IP conflict using UDP sendto() function - ret = sendto(DHCP_SOCKET, "CHECK_IP_CONFLICT", 17, global_lease.addr, 5000); + ret = sendto(sock, "CHECK_IP_CONFLICT", 17, global_lease.addr, 5000); // RCR value restore setRCR(tmp); @@ -763,26 +724,26 @@ int8_t check_DHCP_leasedIP(void) { } } -void DHCP_init(uint8_t s, uint8_t * buf) { - uint8_t zeroip[4] = {0,0,0,0}; +void DHCP_init(void *buf) { getSHAR(global_eth_addr); - if ((global_eth_addr[0] | global_eth_addr[1] | global_eth_addr[2] | global_eth_addr[3] | global_eth_addr[4] | global_eth_addr[5]) == 0x00) { - // assigning temporary mac address, you should be set SHAR before call this function. - global_eth_addr[0] = 0x00; - global_eth_addr[1] = 0x08; - global_eth_addr[2] = 0xdc; - global_eth_addr[3] = 0x00; - global_eth_addr[4] = 0x00; - global_eth_addr[5] = 0x00; + if (memcmp(global_eth_addr.octets, ((struct net_eth_addr){0}).octets, sizeof(struct net_eth_addr)) == 0) { + /* assigning temporary mac address, you should be set + * SHAR before call this function. */ + global_eth_addr.octets[0] = 0x00; + global_eth_addr.octets[1] = 0x08; + global_eth_addr.octets[2] = 0xdc; + global_eth_addr.octets[3] = 0x00; + global_eth_addr.octets[4] = 0x00; + global_eth_addr.octets[5] = 0x00; setSHAR(global_eth_addr); } - global_hostname[0] = "W"; - global_hostname[1] = "I"; - global_hostname[2] = "Z"; - global_hostname[3] = "n"; - global_hostname[4] = "e"; - global_hostname[5] = "t"; + global_hostname[0] = 'W'; + global_hostname[1] = 'I'; + global_hostname[2] = 'Z'; + global_hostname[3] = 'n'; + global_hostname[4] = 'e'; + global_hostname[5] = 't'; global_hostname[6] = "0123456789ABCDEF"[(global_eth_addr.octets[3] >> 4)&0xF]; global_hostname[7] = "0123456789ABCDEF"[(global_eth_addr.octets[3] >> 0)&0xF]; global_hostname[8] = "0123456789ABCDEF"[(global_eth_addr.octets[4] >> 4)&0xF]; @@ -791,18 +752,19 @@ void DHCP_init(uint8_t s, uint8_t * buf) { global_hostname[11] = "0123456789ABCDEF"[(global_eth_addr.octets[5] >> 0)&0xF]; global_hostname[12] = '\0'; - DHCP_SOCKET = s; // SOCK_DHCP - pDHCPMSG = (RIP_MSG*)buf; + pDHCPMSG = buf; + global_xid = 0x12345678; - { - global_xid += global_eth_addr[3]; - global_xid += global_eth_addr[4]; - global_xid += global_eth_addr[5]; - global_xid += (global_eth_addr[3] ^ global_eth_addr[4] ^ global_eth_addr[5]); - } + global_xid += global_eth_addr.octets[3]; + global_xid += global_eth_addr.octets[4]; + global_xid += global_eth_addr.octets[5]; + global_xid += (global_eth_addr.octets[3] ^ + global_eth_addr.octets[4] ^ + global_eth_addr.octets[5]); + // WIZchip Netinfo Clear - setSIPR(zeroip); - setGAR(zeroip); + setSIPR(net_ip4_addr_zero); + setGAR(net_ip4_addr_zero); reset_DHCP_timeout(); dhcp_state = STATE_DHCP_INIT; diff --git a/libdhcp/include/libdhcp/dhcp.h b/libdhcp/include/libdhcp/dhcp.h index 6970748..4cdd2e2 100644 --- a/libdhcp/include/libdhcp/dhcp.h +++ b/libdhcp/include/libdhcp/dhcp.h @@ -112,12 +112,12 @@ typedef void (*dhcp_callback_t)(enum dhcp_event, struct dhcp_lease); * @brief return value of @ref DHCP_run() */ enum { - DHCP_FAILED = 0, ///< Processing Fail - DHCP_RUNNING, ///< Processing DHCP protocol - DHCP_IP_ASSIGN, ///< First Occupy IP from DHPC server (if cbfunc == null, act as default default_ip_assign) - DHCP_IP_CHANGED, ///< Change IP address by new ip from DHCP (if cbfunc == null, act as default default_ip_update) - DHCP_IP_LEASED, ///< Stand by - DHCP_STOPPED ///< Stop processing DHCP protocol + DHCP_RET_FAILED = 0, ///< Processing Fail + DHCP_RET_RUNNING, ///< Processing DHCP protocol + DHCP_RET_IP_ASSIGN, ///< First Occupy IP from DHPC server (if cbfunc == null, act as default default_ip_assign) + DHCP_RET_IP_CHANGED, ///< Change IP address by new ip from DHCP (if cbfunc == null, act as default default_ip_update) + DHCP_RET_IP_LEASED, ///< Stand by + DHCP_RET_STOPPED ///< Stop processing DHCP protocol }; /* |