/**
* Configure interface for use with current LL IP-Address
*
* @param netif network interface to configure with current LL IP-Address
*/
static err_t
autoip_bind(struct netif *netif)
{
struct autoip *autoip = netif->autoip;
ip4_addr_t sn_mask, gw_addr;
LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
(void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num,
ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
IP4_ADDR(&sn_mask, 255, 255, 0, 0);
IP4_ADDR(&gw_addr, 0, 0, 0, 0);
netif_set_addr(netif, &autoip->llipaddr, &sn_mask, &gw_addr);
/* interface is used by routing now that an address is set */
return ERR_OK;
}
/**
* @brief This function notify user about link status changement.
* @param netif: the network interface
* @retval None
*/
void ethernetif_notify_conn_changed(struct netif *netif)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
if(netif_is_link_up(netif))
{
#ifdef USE_DHCP
WriteConsole ("The network cable is now connected \n");
/* Update DHCP state machine */
DHCP_state = DHCP_START;
#else
IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
uint8_t iptxt[80];
sprintf((char*)iptxt, "%d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
WriteConsole ("The network cable is now connected \n");
sprintf((char*)iptxt, "Static IP address: %d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
WriteConsole (iptxt);
#endif /* USE_DHCP */
netif_set_addr(netif, &ipaddr , &netmask, &gw);
/* When the netif is fully configured this function must be called.*/
netif_set_up(netif);
}
else
{
#ifdef USE_DHCP
/* Update DHCP state machine */
DHCP_state = DHCP_LINK_DOWN;
#endif /* USE_DHCP */
/* When the netif link is down this function must be called.*/
netif_set_down(netif);
WriteConsole ("The network cable is not connected \n");
}
}
void erase_netif_ipaddr()
{
struct ip_addr ipaddr, netmask, gw;
ipaddr.addr = 0;
netmask.addr = 0;
gw.addr = 0;
//ZOTIPS netif_set_addr( WLanface, &ipaddr, &netmask, &gw);
netif_set_addr( Lanface, &ipaddr, &netmask, &gw); //ZOTIPS
// SetIP(0x0, WLanface);
// SetNetmask(0x0, WLanface);
// SetGateway(0x0, WLanface);
// SetIP(0x0, Lanface);
// SetNetmask(0x0, Lanface);
// SetGateway(0x0, Lanface);
mib_DHCP_p->IPAddr = DWordSwap(Lanface->ip_addr.addr);
mib_DHCP_p->SubnetMask = DWordSwap(Lanface->netmask.addr);
mib_DHCP_p->GwyAddr = DWordSwap(Lanface->gw.addr);
}
/**
* Add a network interface to the list of lwIP netifs.
*
* @param netif a pre-allocated netif structure
* @param ipaddr IP address for the new netif
* @param netmask network mask for the new netif
* @param gw default gateway IP address for the new netif
* @param state opaque data passed to the new netif
* @param init callback function that initializes the interface
* @param input callback function that is called to pass
* ingress packets up in the protocol layer stack.
*
* @return netif, or NULL if failed.
*/
struct netif *
netif_add(struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask,
struct ip_addr *gw,
void *state,
err_t (* init)(struct netif *netif),
err_t (* input)(struct pbuf *p, struct netif *netif))
{
static s16_t netifnum = 0;
#if LWIP_DHCP
/* netif not under DHCP control by default */
netif->dhcp = NULL;
#endif
/* remember netif specific state information data */
netif->state = state;
netif->num = netifnum++;
netif->input = input;
netif_set_addr(netif, ipaddr, netmask, gw);
/* call user specified initialization function for netif */
if (init(netif) != ERR_OK) {
return NULL;
}
/* add this netif to the list */
netif->next = netif_list;
netif_list = netif;
LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP addr ",
netif->name[0], netif->name[1]));
ip_addr_debug_print(NETIF_DEBUG, ipaddr);
LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));
ip_addr_debug_print(NETIF_DEBUG, netmask);
LWIP_DEBUGF(NETIF_DEBUG, (" gw "));
ip_addr_debug_print(NETIF_DEBUG, gw);
LWIP_DEBUGF(NETIF_DEBUG, ("\n"));
return netif;
}
void lwip_dhcp_stop(void *pParameter)
{
struct netif *pNetif = (struct netif *)pParameter;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
if(pNetif->ip_addr.addr != 0)
{
/* Stop DHCP */
dhcp_stop(pNetif);
uprintf(UPRINT_INFO, UPRINT_BLK_NET, "LWIP DHCP get IP addr: 0x%08x\n", pNetif->ip_addr.addr);
}
else
{
/* DHCP timeout */
if (pNetif->dhcp->tries > MAX_DHCP_TRIES)
{
/* Stop DHCP */
dhcp_stop(pNetif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(pNetif, &ipaddr , &netmask, &gw);
uprintf(UPRINT_INFO, UPRINT_BLK_NET, "LWIP DHCP use static IP addr: 0x%08x\n", pNetif->ip_addr.addr);
}
else
{
/* continue to monitor */
sys_timeout(2000, lwip_dhcp_stop, pNetif);
}
}
}
/**
* @brief wifi disconnected will call this callback function. set lwip status in this function
* @param[in] wifi_event_t event: not used.
* @param[in] uint8_t *payload: not used.
* @param[in] uint32_t length: not used.
* @retval None
*/
static int32_t wifi_station_disconnected_event_handler(wifi_event_t event,
uint8_t *payload,
uint32_t length)
{
uint8_t opmode = 0;
wifi_config_get_opmode(&opmode);
if ((WIFI_MODE_AP_ONLY != opmode) && WIFI_EVENT_IOT_DISCONNECTED == event) {
uint8_t link_status = 1;
//should check link status, it will emit this event when sp disconnect with host under repeater mode.
wifi_connection_get_link_status(&link_status);
if (link_status == 0) {
struct netif *sta_if;
sta_if = netif_find_by_type(NETIF_TYPE_STA);
netif_set_link_down(sta_if);
#if USE_DHCP
netif_set_addr(sta_if, IP4_ADDR_ANY, IP4_ADDR_ANY, IP4_ADDR_ANY);
#endif
LOG_I(common, "wifi disconnected");
}
}
return 1;
}
struct netif *
netif_add(struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask,
struct ip_addr *gw,
void *state,
err_t (* init)(struct netif *netif),
err_t (* input)(struct pbuf *p, struct netif *netif))
{
//if (netif_add(netif, IP_ADDR_ANY, IP_ADDR_BROADCAST, IP_ADDR_ANY, dev,
//eth_init, eth_input) == RT_NULL)
// netif->uip_hostaddr = ipaddr;
//netif->uip_draddr = netmask;
// netif->uip_netmask = gw;
// netif_set_addr(netif,ipaddr,netmask,gw);
// call user specified initialization function for netif
if (init(netif) != 0) {
return RT_NULL;
}
netif->input = input;
netif->state = state;
netif_set_addr(netif,ipaddr,netmask,gw);
return netif;
}
/**
* Add a network interface to the list of lwIP netifs.
*
* @param netif a pre-allocated netif structure
* @param ipaddr IP address for the new netif
* @param netmask network mask for the new netif
* @param gw default gateway IP address for the new netif
* @param state opaque data passed to the new netif
* @param init callback function that initializes the interface
* @param input callback function that is called to pass
* ingress packets up in the protocol layer stack.
*
* @return netif, or NULL if failed.
*/
struct netif *
netif_add(struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask,
struct ip_addr *gw,
void *state,
err_t (* init)(struct netif *netif),
err_t (* input)(struct pbuf *p, struct netif *netif))
{
static u8_t netifnum = 0;
/* reset new interface configuration state */
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
// [MS_CHANGE] - Previously the LWIP code
// cleared this field which is used a few
// lines below. Since we set this flag to
// enable multicast we will clear all bits
// except this one
netif->flags &= (NETIF_FLAG_IGMP | NETIF_FLAG_BROADCAST | NETIF_FLAG_DYNAMIC_DNS);
#if LWIP_DHCP
/* netif not under DHCP control by default */
netif->dhcp = NULL;
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
/* netif not under AutoIP control by default */
netif->autoip = NULL;
#endif /* LWIP_AUTOIP */
#if LWIP_NETIF_STATUS_CALLBACK
netif->status_callback = NULL;
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif->link_callback = NULL;
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if LWIP_IGMP
netif->igmp_mac_filter = NULL;
#endif /* LWIP_IGMP */
#if ENABLE_LOOPBACK
netif->loop_first = NULL;
netif->loop_last = NULL;
#endif /* ENABLE_LOOPBACK */
/* remember netif specific state information data */
netif->state = state;
netif->num = netifnum++;
netif->input = input;
#if LWIP_NETIF_HWADDRHINT
netif->addr_hint = NULL;
#endif /* LWIP_NETIF_HWADDRHINT*/
#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS
netif->loop_cnt_current = 0;
#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */
netif_set_addr(netif, ipaddr, netmask, gw);
/* call user specified initialization function for netif */
if (init(netif) != ERR_OK) {
return NULL;
}
/* add this netif to the list */
netif->next = netif_list;
netif_list = netif;
snmp_inc_iflist();
#if LWIP_IGMP
/* start IGMP processing */
if (netif->flags & NETIF_FLAG_IGMP) {
igmp_start( netif);
}
#endif /* LWIP_IGMP */
LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP addr ",
netif->name[0], netif->name[1]));
ip_addr_debug_print(NETIF_DEBUG, ipaddr);
LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));
ip_addr_debug_print(NETIF_DEBUG, netmask);
LWIP_DEBUGF(NETIF_DEBUG, (" gw "));
ip_addr_debug_print(NETIF_DEBUG, gw);
LWIP_DEBUGF(NETIF_DEBUG, ("\n"));
return netif;
}
/**
* @brief This function notify user about link status changement.
* @param netif: the network interface
* @retval None
*/
void ethernetif_notify_conn_changed(struct netif *netif)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
if(netif_is_link_up(netif))
{
#ifdef USE_DHCP
#ifndef USE_LCD
BSP_LED_Off(LED2);
BSP_LED_On(LED1);
#endif /* USE_LCD */
/* Update DHCP state machine */
DHCP_state = DHCP_START;
#else
IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
#ifdef USE_LCD
uint8_t iptxt[20];
sprintf((char*)iptxt, " %d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
BSP_LCD_ClearStringLine(7);
BSP_LCD_ClearStringLine(8);
BSP_LCD_ClearStringLine(9);
BSP_LCD_DisplayStringAtLine(8,(uint8_t *) " Static IP address:");
BSP_LCD_DisplayStringAtLine(9,(uint8_t *) iptxt);
#else
BSP_LED_Off(LED2);
BSP_LED_On(LED1);
#endif /* USE_LCD */
#endif /* USE_DHCP */
netif_set_addr(netif, &ipaddr , &netmask, &gw);
/* When the netif is fully configured this function must be called.*/
netif_set_up(netif);
}
else
{
#ifdef USE_DHCP
/* Update DHCP state machine */
DHCP_state = DHCP_LINK_DOWN;
#endif /* USE_DHCP */
/* When the netif link is down this function must be called.*/
netif_set_down(netif);
#ifdef USE_LCD
BSP_LCD_ClearStringLine(7);
BSP_LCD_ClearStringLine(8);
BSP_LCD_ClearStringLine(9);
BSP_LCD_DisplayStringAtLine(8,(uint8_t *) " The network cable");
BSP_LCD_DisplayStringAtLine(9,(uint8_t *) " is not connected");
#else
BSP_LED_Off(LED1);
BSP_LED_On(LED2);
#endif /* USE_LCD */
}
/* Clear IO Expander Interrupt flag */
BSP_IO_ITClear();
}
/**
* @brief DHCP Process
* @param argument: network interface
* @retval None
*/
void DHCP_thread(void const * argument)
{
struct netif *netif = (struct netif *) argument;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress;
for (;;)
{
switch (DHCP_state)
{
case DHCP_START:
{
_VNCServer_Notify(NOTIFY_SERVER_DHCP_START);
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
IPaddress = 0;
dhcp_start(netif);
DHCP_state = DHCP_WAIT_ADDRESS;
_VNCServer_Notify(NOTIFY_SERVER_DHCP_WAIT_ADDRESS);
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = netif->ip_addr.addr;
if (IPaddress!=0)
{
/* Stop DHCP */
dhcp_stop(netif);
DHCP_state = DHCP_ADDRESS_ASSIGNED;
_VNCServer_GetAssignedAddress(IP_ADDRESS, (uint8_t)(IPaddress), (uint8_t)(IPaddress >> 8), (uint8_t)(IPaddress >> 16), (uint8_t)(IPaddress >> 24));
IPaddress = netif->netmask.addr;
_VNCServer_GetAssignedAddress(SUBNET_MASK, (uint8_t)(IPaddress), (uint8_t)(IPaddress >> 8), (uint8_t)(IPaddress >> 16), (uint8_t)(IPaddress >> 24));
IPaddress = netif->gw.addr;
_VNCServer_GetAssignedAddress(GW_ADDRESS, (uint8_t)(IPaddress), (uint8_t)(IPaddress >> 8), (uint8_t)(IPaddress >> 16), (uint8_t)(IPaddress >> 24));
_VNCServer_Notify(NOTIFY_SERVER_DHCP_ADDRESS_ASSIGNED);
}
else
{
/* DHCP timeout */
if (netif->dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(netif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR3 ,IP_ADDR2 , IP_ADDR1 , IP_ADDR0 );
IP4_ADDR(&netmask, NETMASK_ADDR3, NETMASK_ADDR2, NETMASK_ADDR1, NETMASK_ADDR0);
IP4_ADDR(&gw, GW_ADDR3, GW_ADDR2, GW_ADDR1, GW_ADDR0);
netif_set_addr(netif, &ipaddr , &netmask, &gw);
_VNCServer_GetAssignedAddress(IP_ADDRESS, IP_ADDR3, IP_ADDR2, IP_ADDR1, IP_ADDR0);
_VNCServer_GetAssignedAddress(SUBNET_MASK, NETMASK_ADDR3, NETMASK_ADDR2, NETMASK_ADDR1, NETMASK_ADDR0);
_VNCServer_GetAssignedAddress(GW_ADDRESS, GW_ADDR3, GW_ADDR2, GW_ADDR1, GW_ADDR0);
_VNCServer_Notify(NOTIFY_SERVER_DHCP_TIMEOUT);
}
}
}
break;
default: break;
}
/**
* @brief Link callback function, this function is called on change of link status.
* @param The network interface
* @retval None
*/
void ETH_link_callback(struct netif *netif)
{
__IO uint32_t timeout = 0;
uint32_t tmpreg;
uint16_t RegValue;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
#ifndef USE_DHCP
uint8_t iptab[4] = {0};
uint8_t iptxt[20];
#endif /* USE_DHCP */
/* Clear LCD */
// LCD_ClearLine(Line4);
// LCD_ClearLine(Line5);
// LCD_ClearLine(Line6);
// LCD_ClearLine(Line7);
// LCD_ClearLine(Line8);
// LCD_ClearLine(Line9);
if(netif_is_link_up(netif))
{
/* Restart the auto-negotiation */
if(ETH_InitStructure.ETH_AutoNegotiation != ETH_AutoNegotiation_Disable)
{
/* Reset Timeout counter */
timeout = 0;
/* Enable auto-negotiation */
ETH_WritePHYRegister(DP83848_PHY_ADDRESS, PHY_BCR, PHY_AutoNegotiation);
/* Wait until the auto-negotiation will be completed */
do
{
timeout++;
} while (!(ETH_ReadPHYRegister(DP83848_PHY_ADDRESS, PHY_BSR) & PHY_AutoNego_Complete) && (timeout < (uint32_t)PHY_READ_TO));
/* Reset Timeout counter */
timeout = 0;
/* Read the result of the auto-negotiation */
RegValue = ETH_ReadPHYRegister(DP83848_PHY_ADDRESS, PHY_SR);
/* Configure the MAC with the Duplex Mode fixed by the auto-negotiation process */
if((RegValue & PHY_DUPLEX_STATUS) != (uint16_t)RESET)
{
/* Set Ethernet duplex mode to Full-duplex following the auto-negotiation */
ETH_InitStructure.ETH_Mode = ETH_Mode_FullDuplex;
}
else
{
/* Set Ethernet duplex mode to Half-duplex following the auto-negotiation */
ETH_InitStructure.ETH_Mode = ETH_Mode_HalfDuplex;
}
/* Configure the MAC with the speed fixed by the auto-negotiation process */
if(RegValue & PHY_SPEED_STATUS)
{
/* Set Ethernet speed to 10M following the auto-negotiation */
ETH_InitStructure.ETH_Speed = ETH_Speed_10M;
}
else
{
/* Set Ethernet speed to 100M following the auto-negotiation */
ETH_InitStructure.ETH_Speed = ETH_Speed_100M;
}
/*------------------------ ETHERNET MACCR Re-Configuration --------------------*/
/* Get the ETHERNET MACCR value */
tmpreg = ETH->MACCR;
/* Set the FES bit according to ETH_Speed value */
/* Set the DM bit according to ETH_Mode value */
tmpreg |= (uint32_t)(ETH_InitStructure.ETH_Speed | ETH_InitStructure.ETH_Mode);
/* Write to ETHERNET MACCR */
ETH->MACCR = (uint32_t)tmpreg;
_eth_delay_(ETH_REG_WRITE_DELAY);
tmpreg = ETH->MACCR;
ETH->MACCR = tmpreg;
}
/* Restart MAC interface */
ETH_Start();
#ifdef USE_DHCP
ipaddr.addr = 0;
netmask.addr = 0;
gw.addr = 0;
DHCP_state = DHCP_START;
#else
IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
#endif /* USE_DHCP */
netif_set_addr(&gnetif, &ipaddr , &netmask, &gw);
/* When the netif is fully configured this function must be called.*/
netif_set_up(&gnetif);
#ifdef USE_LCD
/* Set the LCD Text Color */
LCD_SetTextColor(Green);
/* Display message on the LCD */
LCD_DisplayStringLine(Line5, (uint8_t*)" Network Cable is ");
LCD_DisplayStringLine(Line6, (uint8_t*)" now connected ");
/* Set the LCD Text Color */
LCD_SetTextColor(White);
#ifndef USE_DHCP
/* Display static IP address */
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_DisplayStringLine(Line8, (uint8_t*)" Static IP address ");
LCD_DisplayStringLine(Line9, iptxt);
/* Clear LCD */
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
#endif /* USE_DHCP */
#endif /* USE_LCD */
EthLinkStatus = 0;
}
else
{
ETH_Stop();
#ifdef USE_DHCP
DHCP_state = DHCP_LINK_DOWN;
dhcp_stop(netif);
#endif /* USE_DHCP */
/* When the netif link is down this function must be called.*/
netif_set_down(&gnetif);
#ifdef USE_LCD
/* Set the LCD Text Color */
LCD_SetTextColor(Red);
/* Display message on the LCD */
LCD_DisplayStringLine(Line5, (uint8_t*)" Network Cable is ");
LCD_DisplayStringLine(Line6, (uint8_t*)" unplugged ");
/* Set the LCD Text Color */
LCD_SetTextColor(White);
#endif /* USE_LCD */
}
}
/**
* @brief DHCP_Process_Handle
* @param None
* @retval None
*/
void DHCP_Process(struct netif *netif)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress = 0;
switch (DHCP_state)
{
case DHCP_START:
{
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
IPaddress = 0;
DHCP_state = DHCP_WAIT_ADDRESS;
dhcp_start(netif);
#ifdef USE_LCD
LCD_UsrLog (" State: Looking for DHCP sever ...\n");
#endif
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = netif->ip_addr.addr;
if (IPaddress !=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(netif);
#ifdef USE_LCD
uint8_t iptab[4];
uint8_t iptxt[20];
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, "%d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_UsrLog ("IP address assigned by a DHCP server: %s\n", iptxt);
#else
BSP_LED_On(LED1);
#endif
}
else
{
/* DHCP timeout */
if (netif->dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(netif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(netif, &ipaddr , &netmask, &gw);
#ifdef USE_LCD
uint8_t iptxt[20];
sprintf((char*)iptxt, "%d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
LCD_UsrLog ("DHCP timeout !!\n");
LCD_UsrLog ("Static IP address : %s\n", iptxt);
#else
BSP_LED_On(LED1);
#endif
}
}
}
/**
* @brief LwIP_DHCP_Process_Handle
* @param None
* @retval None
*/
void LwIP_DHCP_task(void * pvParameters)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress;
uint8_t iptab[4];
uint8_t iptxt[20];
uint8_t DHCP_state;
DHCP_state = DHCP_START;
for (;;)
{
switch (DHCP_state)
{
case DHCP_START:
{
dhcp_start(&xnetif);
IPaddress = 0;
DHCP_state = DHCP_WAIT_ADDRESS;
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = xnetif.ip_addr.addr;
if (IPaddress!=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(&xnetif);
#ifdef DEBUG
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
#endif
/* end of DHCP process: LED1 stays ON*/
STM_EVAL_LEDOn(LED1);
vTaskDelete(NULL);
}
else
{
/* DHCP timeout */
if (xnetif.dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(&xnetif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(&xnetif, &ipaddr , &netmask, &gw);
#ifdef DEBUG
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
#endif
/* end of DHCP process: LED1 stays ON*/
//vTaskDelete(NULL);
}
}
}
break;
default: break;
}
/**
* Add a network interface to the list of lwIP netifs.
*
* @param netif a pre-allocated netif structure
* @param ipaddr IP address for the new netif
* @param netmask network mask for the new netif
* @param gw default gateway IP address for the new netif
* @param state opaque data passed to the new netif
* @param init callback function that initializes the interface
* @param input callback function that is called to pass
* ingress packets up in the protocol layer stack.
*
* @return netif, or NULL if failed.
*/
struct netif *
netif_add(struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask,
struct ip_addr *gw,
void *state,
err_t (* init)(struct netif *netif),
err_t (* input)(struct pbuf *p, struct netif *netif))
{
static u8_t netifnum = 0;
/* reset new interface configuration state */
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
netif->flags = 0;
#if LWIP_DHCP
/* netif not under DHCP control by default */
netif->dhcp = NULL;
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
/* netif not under AutoIP control by default */
netif->autoip = NULL;
#endif /* LWIP_AUTOIP */
#if LWIP_NETIF_STATUS_CALLBACK
netif->status_callback = NULL;
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif->link_callback = NULL;
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if LWIP_IGMP
netif->igmp_mac_filter = NULL;
#endif /* LWIP_IGMP */
/* remember netif specific state information data */
netif->state = state;
netif->num = netifnum++;
netif->input = input;
#if LWIP_NETIF_HWADDRHINT
netif->addr_hint = NULL;
#endif /* LWIP_NETIF_HWADDRHINT*/
netif_set_addr(netif, ipaddr, netmask, gw);
/* call user specified initialization function for netif */
if (init(netif) != ERR_OK) {
return NULL;
}
/* add this netif to the list */
netif->next = netif_list;
netif_list = netif;
snmp_inc_iflist();
#if LWIP_IGMP
/* start IGMP processing */
if (netif->flags & NETIF_FLAG_IGMP) {
igmp_start( netif);
}
#endif /* LWIP_IGMP */
LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP addr ",
netif->name[0], netif->name[1]));
ip_addr_debug_print(NETIF_DEBUG, ipaddr);
LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));
ip_addr_debug_print(NETIF_DEBUG, netmask);
LWIP_DEBUGF(NETIF_DEBUG, (" gw "));
ip_addr_debug_print(NETIF_DEBUG, gw);
LWIP_DEBUGF(NETIF_DEBUG, ("\n"));
return netif;
}
nsapi_error_t mbed_lwip_bringup(bool dhcp, const char *ip, const char *netmask, const char *gw)
{
// Check if we've already connected
if (lwip_connected) {
return NSAPI_ERROR_PARAMETER;
}
if(mbed_lwip_init(NULL) != NSAPI_ERROR_OK) {
return NSAPI_ERROR_DEVICE_ERROR;
}
// Zero out socket set
mbed_lwip_arena_init();
#if LWIP_IPV6
netif_create_ip6_linklocal_address(&lwip_netif, 1/*from MAC*/);
#if LWIP_IPV6_MLD
/*
* For hardware/netifs that implement MAC filtering.
* All-nodes link-local is handled by default, so we must let the hardware know
* to allow multicast packets in.
* Should set mld_mac_filter previously. */
if (lwip_netif.mld_mac_filter != NULL) {
ip6_addr_t ip6_allnodes_ll;
ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
lwip_netif.mld_mac_filter(&lwip_netif, &ip6_allnodes_ll, MLD6_ADD_MAC_FILTER);
}
#endif /* LWIP_IPV6_MLD */
#if LWIP_IPV6_AUTOCONFIG
/* IPv6 address autoconfiguration not enabled by default */
lwip_netif.ip6_autoconfig_enabled = 1;
#endif /* LWIP_IPV6_AUTOCONFIG */
#endif
u32_t ret;
if (!netif_is_link_up(&lwip_netif)) {
ret = sys_arch_sem_wait(&lwip_netif_linked, 15000);
if (ret == SYS_ARCH_TIMEOUT) {
return NSAPI_ERROR_NO_CONNECTION;
}
}
#if LWIP_IPV4
if (!dhcp) {
ip4_addr_t ip_addr;
ip4_addr_t netmask_addr;
ip4_addr_t gw_addr;
if (!inet_aton(ip, &ip_addr) ||
!inet_aton(netmask, &netmask_addr) ||
!inet_aton(gw, &gw_addr)) {
return NSAPI_ERROR_PARAMETER;
}
netif_set_addr(&lwip_netif, &ip_addr, &netmask_addr, &gw_addr);
}
#endif
netif_set_up(&lwip_netif);
#if LWIP_IPV4
// Connect to the network
lwip_dhcp = dhcp;
if (lwip_dhcp) {
err_t err = dhcp_start(&lwip_netif);
if (err) {
return NSAPI_ERROR_DHCP_FAILURE;
}
}
#endif
// If doesn't have address
if (!mbed_lwip_get_ip_addr(true, &lwip_netif)) {
ret = sys_arch_sem_wait(&lwip_netif_has_addr, 15000);
if (ret == SYS_ARCH_TIMEOUT) {
return NSAPI_ERROR_DHCP_FAILURE;
}
lwip_connected = true;
}
#if ADDR_TIMEOUT
// If address is not for preferred stack waits a while to see
// if preferred stack address is acquired
if (!mbed_lwip_get_ip_addr(false, &lwip_netif)) {
ret = sys_arch_sem_wait(&lwip_netif_has_addr, ADDR_TIMEOUT * 1000);
}
#endif
#if LWIP_IPV6
add_dns_addr(&lwip_netif);
#endif
return 0;
}
HRESULT LWIP_SOCKETS_Driver::UpdateAdapterConfiguration( UINT32 interfaceIndex, UINT32 updateFlags, SOCK_NetworkConfiguration* config )
{
NATIVE_PROFILE_PAL_NETWORK();
if(interfaceIndex >= NETWORK_INTERFACE_COUNT)
{
return CLR_E_INVALID_PARAMETER;
}
BOOL fEnableDhcp = (0 != (config->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DHCP));
BOOL fDynamicDns = (0 != (config->flags & SOCK_NETWORKCONFIGURATION_FLAGS_DYNAMIC_DNS));
BOOL fDhcpStarted;
struct netif *pNetIf = netif_find_interface(g_LWIP_SOCKETS_Driver.m_interfaces[interfaceIndex].m_interfaceNumber);
if (NULL == pNetIf)
{
return CLR_E_FAIL;
}
fDhcpStarted = (0 != (pNetIf->flags & NETIF_FLAG_DHCP));
#if LWIP_DNS
// when using DHCP do not use the static settings
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DNS))
{
if(!fDynamicDns && (config->dnsServer1 != 0 || config->dnsServer2 != 0))
{
// user defined DNS addresses
if(config->dnsServer1 != 0)
{
u8_t idx = 0;
dns_setserver(idx, (struct ip_addr *)&config->dnsServer1);
}
if(config->dnsServer2 != 0)
{
u8_t idx = 1;
dns_setserver(idx, (struct ip_addr *)&config->dnsServer2);
}
}
}
#endif
#if LWIP_DHCP
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DHCP))
{
if(fEnableDhcp)
{
if(!fDhcpStarted)
{
if(ERR_OK != dhcp_start(pNetIf))
{
return CLR_E_FAIL;
}
}
}
else
{
if(fDhcpStarted)
{
dhcp_stop(pNetIf);
}
netif_set_addr(pNetIf, (struct ip_addr *) &config->ipaddr, (struct ip_addr *)&config->subnetmask, (struct ip_addr *)&config->gateway);
Network_PostEvent( NETWORK_EVENT_TYPE_ADDRESS_CHANGED, 0 );
}
}
if(fEnableDhcp && fDhcpStarted)
{
// Try Renew before release since renewing after release will fail
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DHCP_RENEW))
{
//netifapi_netif_common(pNetIf, NULL, dhcp_renew);
dhcp_renew(pNetIf);
}
else if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_DHCP_RELEASE))
{
//netifapi_netif_common(pNetIf, NULL, dhcp_release);
dhcp_release(pNetIf);
}
}
#endif
if(0 != (updateFlags & SOCK_NETWORKCONFIGURATION_UPDATE_MAC))
{
int len = __min(config->macAddressLen, sizeof(pNetIf->hwaddr));
memcpy(pNetIf->hwaddr, config->macAddressBuffer, len);
pNetIf->hwaddr_len = len;
// mac address requires stack re-init
Network_Interface_Close(interfaceIndex);
g_LWIP_SOCKETS_Driver.m_interfaces[interfaceIndex].m_interfaceNumber = Network_Interface_Open(interfaceIndex);
}
return S_OK;
}
nsapi_error_t mbed_lwip_bringup_2(bool dhcp, bool ppp, const char *ip, const char *netmask, const char *gw,
const nsapi_ip_stack_t stack)
{
// Check if we've already connected
if (lwip_connected == NSAPI_STATUS_GLOBAL_UP) {
return NSAPI_ERROR_IS_CONNECTED;
} else if (lwip_connected == NSAPI_STATUS_CONNECTING) {
return NSAPI_ERROR_ALREADY;
}
lwip_connected = NSAPI_STATUS_CONNECTING;
lwip_ppp = ppp;
#if LWIP_DHCP
lwip_dhcp_has_to_be_set = true;
if (stack != IPV6_STACK) {
lwip_dhcp = dhcp;
} else {
lwip_dhcp = false;
}
#endif
mbed_lwip_core_init();
nsapi_error_t ret;
if (netif_inited) {
/* Can't cope with changing mode */
if (netif_is_ppp == ppp) {
ret = NSAPI_ERROR_OK;
} else {
ret = NSAPI_ERROR_PARAMETER;
}
} else {
if (ppp) {
ret = ppp_lwip_if_init(&lwip_netif, stack);
} else {
ret = mbed_lwip_emac_init(NULL);
}
}
if (ret != NSAPI_ERROR_OK) {
lwip_connected = NSAPI_STATUS_DISCONNECTED;
return ret;
}
if (lwip_client_callback) {
lwip_client_callback(lwip_status_cb_handle, NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_CONNECTING);
}
netif_inited = true;
if (ppp) {
netif_is_ppp = ppp;
}
netif_set_default(&lwip_netif);
netif_set_link_callback(&lwip_netif, mbed_lwip_netif_link_irq);
netif_set_status_callback(&lwip_netif, mbed_lwip_netif_status_irq);
#if LWIP_IPV6
if (stack != IPV4_STACK) {
if (lwip_netif.hwaddr_len == ETH_HWADDR_LEN) {
netif_create_ip6_linklocal_address(&lwip_netif, 1/*from MAC*/);
}
#if LWIP_IPV6_MLD
/*
* For hardware/netifs that implement MAC filtering.
* All-nodes link-local is handled by default, so we must let the hardware know
* to allow multicast packets in.
* Should set mld_mac_filter previously. */
if (lwip_netif.mld_mac_filter != NULL) {
ip6_addr_t ip6_allnodes_ll;
ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
lwip_netif.mld_mac_filter(&lwip_netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER);
}
#endif /* LWIP_IPV6_MLD */
#if LWIP_IPV6_AUTOCONFIG
/* IPv6 address autoconfiguration not enabled by default */
lwip_netif.ip6_autoconfig_enabled = 1;
} else {
// Disable router solidifications
lwip_netif.rs_count = 0;
}
#endif /* LWIP_IPV6_AUTOCONFIG */
#endif // LWIP_IPV6
#if LWIP_IPV4
if (stack != IPV6_STACK) {
if (!dhcp && !ppp) {
ip4_addr_t ip_addr;
ip4_addr_t netmask_addr;
ip4_addr_t gw_addr;
if (!inet_aton(ip, &ip_addr) ||
!inet_aton(netmask, &netmask_addr) ||
!inet_aton(gw, &gw_addr)) {
lwip_connected = NSAPI_STATUS_DISCONNECTED;
if (lwip_client_callback) {
lwip_client_callback(lwip_status_cb_handle, NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
return NSAPI_ERROR_PARAMETER;
}
netif_set_addr(&lwip_netif, &ip_addr, &netmask_addr, &gw_addr);
}
}
#endif
if (ppp) {
err_t err = ppp_lwip_connect();
if (err) {
lwip_connected = NSAPI_STATUS_DISCONNECTED;
if (lwip_client_callback) {
lwip_client_callback(lwip_status_cb_handle, NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
return mbed_lwip_err_remap(err);
}
}
if (!netif_is_link_up(&lwip_netif)) {
if (lwip_blocking) {
if (sys_arch_sem_wait(&lwip_netif_linked, 15000) == SYS_ARCH_TIMEOUT) {
if (ppp) {
ppp_lwip_disconnect();
}
return NSAPI_ERROR_NO_CONNECTION;
}
}
} else {
ret = mbed_set_dhcp(&lwip_netif);
if (ret != NSAPI_ERROR_OK) {
return ret;
}
}
if (lwip_blocking) {
// If doesn't have address
if (!mbed_lwip_get_ip_addr(true, &lwip_netif)) {
if (sys_arch_sem_wait(&lwip_netif_has_any_addr, DHCP_TIMEOUT * 1000) == SYS_ARCH_TIMEOUT) {
if (ppp) {
ppp_lwip_disconnect();
}
return NSAPI_ERROR_DHCP_FAILURE;
}
}
} else {
return NSAPI_ERROR_OK;
}
#if PREF_ADDR_TIMEOUT
if (stack != IPV4_STACK && stack != IPV6_STACK) {
// If address is not for preferred stack waits a while to see
// if preferred stack address is acquired
if (!mbed_lwip_get_ip_addr(false, &lwip_netif)) {
sys_arch_sem_wait(&lwip_netif_has_pref_addr, PREF_ADDR_TIMEOUT * 1000);
}
}
#endif
#if BOTH_ADDR_TIMEOUT
if (stack != IPV4_STACK && stack != IPV6_STACK) {
// If addresses for both stacks are not available waits a while to
// see if address for both stacks are acquired
if (!(mbed_lwip_get_ipv4_addr(&lwip_netif) && mbed_lwip_get_ipv6_addr(&lwip_netif))) {
sys_arch_sem_wait(&lwip_netif_has_both_addr, BOTH_ADDR_TIMEOUT * 1000);
}
}
#endif
add_dns_addr(&lwip_netif);
return NSAPI_ERROR_OK;
}
/**
* @brief Link callback function, this function is called on change of link status.
* @param The network interface
* @retval None
*/
void ETH_link_callback(struct netif *netif)
{
__IO uint32_t timeout = 0;
uint32_t tmpreg,RegValue;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
#ifndef USE_DHCP
uint8_t iptab[4] = {0};
uint8_t iptxt[20];
#endif /* USE_DHCP */
if(netif_is_link_up(netif))
{
/* Restart the autonegotiation */
if(ETH_InitStructure.ETH_AutoNegotiation != ETH_AutoNegotiation_Disable)
{
/* Reset Timeout counter */
timeout = 0;
/* Enable Auto-Negotiation */
ETH_WritePHYRegister(BOARD_PHY_ADDRESS, PHY_BCR, PHY_AutoNegotiation);
/* Wait until the auto-negotiation will be completed */
do
{
timeout++;
} while (!(ETH_ReadPHYRegister(BOARD_PHY_ADDRESS, PHY_BSR) & PHY_AutoNego_Complete) && (timeout < (uint32_t)PHY_READ_TO));
/* Reset Timeout counter */
timeout = 0;
/* Read the result of the auto-negotiation */
RegValue = ETH_ReadPHYRegister(BOARD_PHY_ADDRESS, PHY_SR);
/* Configure the MAC with the Duplex Mode fixed by the auto-negotiation process */
if((RegValue & PHY_DUPLEX_STATUS) != (uint32_t)RESET)
{
/* Set Ethernet duplex mode to Full-duplex following the auto-negotiation */
ETH_InitStructure.ETH_Mode = ETH_Mode_FullDuplex;
}
else
{
/* Set Ethernet duplex mode to Half-duplex following the auto-negotiation */
ETH_InitStructure.ETH_Mode = ETH_Mode_HalfDuplex;
}
/* Configure the MAC with the speed fixed by the auto-negotiation process */
if(RegValue & PHY_SPEED_STATUS)
{
/* Set Ethernet speed to 10M following the auto-negotiation */
ETH_InitStructure.ETH_Speed = ETH_Speed_10M;
}
else
{
/* Set Ethernet speed to 100M following the auto-negotiation */
ETH_InitStructure.ETH_Speed = ETH_Speed_100M;
}
/*------------------------ ETHERNET MACCR Re-Configuration --------------------*/
/* Get the ETHERNET MACCR value */
tmpreg = ETH->MACCR;
/* Set the FES bit according to ETH_Speed value */
/* Set the DM bit according to ETH_Mode value */
tmpreg |= (uint32_t)(ETH_InitStructure.ETH_Speed | ETH_InitStructure.ETH_Mode);
/* Write to ETHERNET MACCR */
ETH->MACCR = (uint32_t)tmpreg;
_eth_delay_(ETH_REG_WRITE_DELAY);
tmpreg = ETH->MACCR;
ETH->MACCR = tmpreg;
}
/* Restart MAC interface */
ETH_Start();
#ifdef USE_DHCP
ipaddr.addr = 0;
netmask.addr = 0;
gw.addr = 0;
DHCP_state = DHCP_START;
#else
IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_lastOctet);
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
#endif /* USE_DHCP */
netif_set_addr(&gnetif, &ipaddr , &netmask, &gw);
/* When the netif is fully configured this function must be called.*/
netif_set_up(&gnetif);
}
else
{
ETH_Stop();
#ifdef USE_DHCP
DHCP_state = DHCP_LINK_DOWN;
dhcp_stop(netif);
#endif /* USE_DHCP */
/* When the netif link is down this function must be called.*/
netif_set_down(&gnetif);
}
}
/**
* @brief DHCP Process
* @param argument: network interface
* @retval None
*/
void dhcp_process(void const * argument)
{
struct netif *netif = (struct netif *) argument;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress = 0;
int mscnt =0;
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
dhcp_start(netif);
DHCP_state = DHCP_WAIT_ADDRESS;
// int DHCP_state = DHCP_START;
while( 1 )
{
osDelay(DHCP_FINE_TIMER_MSECS);
dhcp_fine_tmr();
mscnt += DHCP_FINE_TIMER_MSECS;
if (mscnt >= DHCP_COARSE_TIMER_SECS*1000) {
dhcp_coarse_tmr();
mscnt = 0;
}
switch (DHCP_state)
{
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = netif->ip_addr.addr;
if (IPaddress!=0)
{
dhcp_renew(netif);
DHCP_state = DHCP_ADDRESS_ASSIGNED;
#if 1
uint8_t iptab[4];
char iptxt[80];
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf(iptxt, "IP address assigned by a DHCP server: %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
WriteConsole ("address IP affecté\n");
#endif
return;
}
else
{
/* DHCP timeout */
if (netif->dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(netif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(netif, &ipaddr , &netmask, &gw);
return;
#if CONSOLE
char iptxt[80];
sprintf((char*)iptxt, "%Static IP address : d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
WriteConsole("DHCP timeout !!\n");
WriteConsole(iptxt);
#endif
}
else
netif->dhcp->tries++;
}
}
break;
default: break;
}
//*****************************************************************************
//
//! Change the configuration of the lwIP network interface.
//!
//! \param ulIPAddr is the new IP address to be used (static).
//! \param ulNetMask is the new network mask to be used (static).
//! \param ulGWAddr is the new Gateway address to be used (static).
//! \param ulIPMode is the IP Address Mode. \b IPADDR_USE_STATIC 0 will force
//! static IP addressing to be used, \b IPADDR_USE_DHCP will force DHCP with
//! fallback to Link Local (Auto IP), while \b IPADDR_USE_AUTOIP will force
//! Link Local only.
//!
//! This function will evaluate the new configuration data. If necessary, the
//! interface will be brought down, reconfigured, and then brought back up
//! with the new configuration.
//!
//! \return None.
//
//*****************************************************************************
void lwIPNetworkConfigChange(struct netif *netif, IP_CONFIG * ipCfg)
{
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
IP_CONFIG currentIPConfig;
// Check the parameters.
#if LWIP_DHCP && LWIP_AUTOIP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_DHCP) ||
(ipCfg->IPMode == IPADDR_USE_AUTOIP))
#elif LWIP_DHCP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_DHCP))
#elif LWIP_AUTOIP
ASSERT((ipCfg->IPMode == IPADDR_USE_STATIC) ||
(ipCfg->IPMode == IPADDR_USE_AUTOIP))
#else
ASSERT(ipCfg->IPMode == IPADDR_USE_STATIC)
#endif
// Setup the network address values.
if (ipCfg->IPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(ipCfg->IPAddr);
net_mask.addr = htonl(ipCfg->NetMask);
gw_addr.addr = htonl(ipCfg->GWAddr);
}
#if LWIP_DHCP || LWIP_AUTOIP
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
#endif
// Switch on the current IP Address Aquisition mode.
currentIPConfig.IPMode = IPADDR_USE_DHCP;
LWIPServiceTaskIPConfigGet(netif, ¤tIPConfig);
switch (currentIPConfig.IPMode)
{
// Static IP
case IPADDR_USE_STATIC:
{
// Set the new address parameters. This will change the address
// configuration in lwIP, and if necessary, will reset any links
// that are active. This is valid for all three modes.
//
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
// If we are going to DHCP mode, then start the DHCP server now.
#if LWIP_DHCP
if (ipCfg->IPMode == IPADDR_USE_DHCP)
{
dhcp_start(netif);
}
#endif
// If we are going to AutoIP mode, then start the AutoIP process
// now.
#if LWIP_AUTOIP
if (ipCfg->IPMode == IPADDR_USE_AUTOIP)
{
autoip_start(netif);
}
#endif
// And we're done.
break;
}
// DHCP (with AutoIP fallback).
#if LWIP_DHCP
case IPADDR_USE_DHCP:
{
//
// If we are going to static IP addressing, then disable DHCP and
// force the new static IP address.
//
if (ipCfg->IPMode == IPADDR_USE_STATIC)
{
dhcp_stop(netif);
// SEE bug http://savannah.nongnu.org/bugs/?22804
netif->flags &= ~NETIF_FLAG_DHCP;
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
}
// If we are going to AUTO IP addressing, then disable DHCP, set
// the default addresses, and start AutoIP.
#if LWIP_AUTOIP
else if (ipCfg->IPMode == IPADDR_USE_AUTOIP)
{
dhcp_stop(netif);
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
autoip_start(netif);
}
#endif
break;
}
#endif
// AUTOIP
#if LWIP_AUTOIP
case IPADDR_USE_AUTOIP:
{
//
// If we are going to static IP addressing, then disable AutoIP and
// force the new static IP address.
//
if (ulIPMode == IPADDR_USE_STATIC)
{
autoip_stop(netif);
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
}
//
// If we are going to DHCP addressing, then disable AutoIP, set the
// default addresses, and start dhcp.
//
#if LWIP_DHCP
else if (ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_stop(netif);
netif_set_addr(netif, &ip_addr, &net_mask, &gw_addr);
dhcp_start(netif);
}
#endif
break;
}
#endif
}
}
struct netif * ICACHE_FLASH_ATTR
eagle_lwip_if_alloc(struct myif_state *state, u8_t hw[6], struct ip_info * ips)
{
#if 1 // optimize ...
struct netif *myif = state->myif;
if (myif == NULL) {
myif = (void *) pvPortMalloc(sizeof(struct netif)); // pvPortZalloc(60)
state->myif = myif;
}
myif->state = state; // +28
myif->name[0] = 'e'; // +50
myif->name[1] = 'w'; // +51
myif->linkoutput = ieee80211_output_pbuf; // +24
myif->output = etharp_output; // +20
ets_memcpy(myif->hwaddr, hw, 6); // +43
ETSEvent *queue = (void *) pvPortMalloc(sizeof(struct ETSEventTag) * QUEUE_LEN); // pvPortZalloc(80)
if (state->dhcps_if != 0) { // +176
lwip_if_queues[1] = queue;
netif_set_addr(myif, &ips->ip, &ips->netmask, &ips->gw);
ets_task(task_if1, TASK_IF1_PRIO, (ETSEvent *)lwip_if_queues[1], QUEUE_LEN);
netif_add(myif, &ips->ip, &ips->netmask, &ips->gw, state, init_fn, ethernet_input);
if(dhcps_flag) {
dhcps_start(ips);
// os_printf("dhcp server start:(ip:%08x,mask:%08x,gw:%08x)\n", ips->ip.addr, ips->netmask.addr, ips->gw.addr);
}
}
else {
lwip_if_queues[0] = queue;
ets_task(task_if0, TASK_IF0_PRIO, (ETSEvent *)lwip_if_queues[0], QUEUE_LEN);
struct ip_info ipn;
if(wifi_station_dhcpc_status()) {
ipn = *ips;
}
else {
ipn.ip.addr = 0;
ipn.netmask.addr = 0;
ipn.gw.addr = 0;
}
netif_add(myif, &ipn.ip, &ipn.netmask, &ipn.gw, state, init_fn, ethernet_input);
}
return myif;
#else // source
ETSEvent *queue;
ip_addr_t ipaddr;
ip_addr_t netmask;
ip_addr_t gw;
struct netif *myif = state->myif;
if (myif == NULL) {
myif = (void *) pvPortMalloc(sizeof(struct netif)); // pvPortZalloc(60)
state->myif = myif;
}
myif->state = state; // +28
myif->name[0] = 'e'; // +50
myif->name[1] = 'w'; // +51
myif->linkoutput = ieee80211_output_pbuf; // +24
myif->output = etharp_output; // +20
ets_memcpy(myif->hwaddr, hw, 6); // +43
if (state->dhcps_if != 0) { // +176
ipaddr = ips->ip;
netmask = ips->netmask;
gw = ips->gw;
netif_set_addr(myif, &ipaddr, &netmask, &gw);
queue = (void *) pvPortMalloc(sizeof(struct ETSEventTag) * QUEUE_LEN); // pvPortZalloc(80)
lwip_if_queues[1] = queue;
ets_task(task_if1, TASK_IF1_PRIO, (ETSEvent *)queue, QUEUE_LEN);
netif_add(myif, &ipaddr, &netmask, &gw, state, init_fn, ethernet_input);
if(dhcps_flag) {
dhcps_start(ips);
// os_printf("dhcp server start:(ip:%08x,mask:%08x,gw:%08x)\n", ipaddr.addr, netmask.addr, gw.addr);
}
}
else {
if(wifi_station_dhcpc_status()) {
ipaddr = ips->ip;
netmask = ips->netmask;
gw = ips->gw;
}
else {
ipaddr.addr = 0;
netmask.addr = 0;
gw.addr = 0;
}
queue = (void *) pvPortMalloc(sizeof(struct ETSEventTag) * QUEUE_LEN); // pvPortZalloc(80)
lwip_if_queues[0] = queue;
ets_task(task_if0, TASK_IF0_PRIO, (ETSEvent *)queue, QUEUE_LEN);
netif_add(myif, &ipaddr, &netmask, &gw, state, init_fn, ethernet_input);
}
return myif;
#endif
}
nsapi_error_t LWIP::Interface::bringup(bool dhcp, const char *ip, const char *netmask, const char *gw, const nsapi_ip_stack_t stack, bool block)
{
// Check if we've already connected
if (connected == NSAPI_STATUS_GLOBAL_UP) {
return NSAPI_ERROR_IS_CONNECTED;
} else if (connected == NSAPI_STATUS_CONNECTING) {
return NSAPI_ERROR_ALREADY;
}
connected = NSAPI_STATUS_CONNECTING;
blocking = block;
#if LWIP_DHCP
if (stack != IPV6_STACK && dhcp) {
dhcp_has_to_be_set = true;
}
#endif
#if LWIP_IPV6
if (stack != IPV4_STACK) {
if (netif.hwaddr_len == 6) {
netif_create_ip6_linklocal_address(&netif, 1/*from MAC*/);
}
#if LWIP_IPV6_MLD
/*
* For hardware/netifs that implement MAC filtering.
* All-nodes link-local is handled by default, so we must let the hardware know
* to allow multicast packets in.
* Should set mld_mac_filter previously. */
if (netif.mld_mac_filter != NULL) {
ip6_addr_t ip6_allnodes_ll;
ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
netif.mld_mac_filter(&netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER);
}
#endif /* LWIP_IPV6_MLD */
#if LWIP_IPV6_AUTOCONFIG
/* IPv6 address autoconfiguration not enabled by default */
netif.ip6_autoconfig_enabled = 1;
#endif /* LWIP_IPV6_AUTOCONFIG */
} else {
// Disable rourter solicitations
netif.rs_count = 0;
}
#endif /* LWIP_IPV6 */
#if LWIP_IPV4
if (stack != IPV6_STACK) {
if (!dhcp && !ppp) {
ip4_addr_t ip_addr;
ip4_addr_t netmask_addr;
ip4_addr_t gw_addr;
if (!inet_aton(ip, &ip_addr) ||
!inet_aton(netmask, &netmask_addr) ||
!inet_aton(gw, &gw_addr)) {
return NSAPI_ERROR_PARAMETER;
}
netif_set_addr(&netif, &ip_addr, &netmask_addr, &gw_addr);
}
}
#endif
if (client_callback) {
client_callback(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_CONNECTING);
}
if (ppp) {
err_t err = ppp_lwip_connect(hw);
if (err) {
connected = NSAPI_STATUS_DISCONNECTED;
if (client_callback) {
client_callback(NSAPI_EVENT_CONNECTION_STATUS_CHANGE, NSAPI_STATUS_DISCONNECTED);
}
return err_remap(err);
}
}
if (!netif_is_link_up(&netif)) {
if (blocking) {
if (osSemaphoreAcquire(linked, 15000) != osOK) {
if (ppp) {
(void) ppp_lwip_disconnect(hw);
}
return NSAPI_ERROR_NO_CONNECTION;
}
}
} else {
nsapi_error_t ret = set_dhcp();
if (ret != NSAPI_ERROR_OK) {
return ret;
}
}
if (!blocking) {
// Done enough - as addresses are acquired, there will be
// connected callbacks.
// XXX shouldn't this be NSAPI_ERROR_IN_PROGRESS if in CONNECTING state?
return NSAPI_ERROR_OK;
}
// If doesn't have address
if (!LWIP::get_ip_addr(true, &netif)) {
if (osSemaphoreAcquire(has_any_addr, DHCP_TIMEOUT * 1000) != osOK) {
if (ppp) {
(void) ppp_lwip_disconnect(hw);
}
return NSAPI_ERROR_DHCP_FAILURE;
}
}
#if PREF_ADDR_TIMEOUT
if (stack != IPV4_STACK && stack != IPV6_STACK) {
// If address is not for preferred stack waits a while to see
// if preferred stack address is acquired
if (!LWIP::get_ip_addr(false, &netif)) {
osSemaphoreAcquire(has_pref_addr, PREF_ADDR_TIMEOUT * 1000);
}
}
#endif
#if BOTH_ADDR_TIMEOUT
if (stack != IPV4_STACK && stack != IPV6_STACK) {
// If addresses for both stacks are not available waits a while to
// see if address for both stacks are acquired
if (!(LWIP::get_ipv4_addr(&netif) && LWIP::get_ipv6_addr(&netif))) {
osSemaphoreAcquire(has_both_addr, BOTH_ADDR_TIMEOUT * 1000);
}
}
#endif
add_dns_addr(&netif);
return NSAPI_ERROR_OK;
}
/**
* Add a network interface to the list of lwIP netifs.
*
* @param netif a pre-allocated netif structure
* @param ipaddr IP address for the new netif
* @param netmask network mask for the new netif
* @param gw default gateway IP address for the new netif
* @param state opaque data passed to the new netif
* @param init callback function that initializes the interface
* @param input callback function that is called to pass
* ingress packets up in the protocol layer stack.
*
* @return netif, or NULL if failed.
*/
struct netif *
netif_add(struct netif *netif, ip_addr_t *ipaddr, ip_addr_t *netmask,
ip_addr_t *gw, void *state, netif_init_fn init, netif_input_fn input)
{
#if LWIP_IPV6
u32_t i;
#endif
LWIP_ASSERT("No init function given", init != NULL);
/* reset new interface configuration state */
ip_addr_set_zero(&netif->ip_addr);
ip_addr_set_zero(&netif->netmask);
ip_addr_set_zero(&netif->gw);
#if LWIP_IPV6
for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {
ip6_addr_set_zero(&netif->ip6_addr[i]);
netif_ip6_addr_set_state(netif, i, IP6_ADDR_INVALID);
}
netif->output_ip6 = netif_null_output_ip6;
#endif /* LWIP_IPV6 */
netif->flags = 0;
#if LWIP_DHCP
/* netif not under DHCP control by default */
netif->dhcp = NULL;
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
/* netif not under AutoIP control by default */
netif->autoip = NULL;
#endif /* LWIP_AUTOIP */
#if LWIP_IPV6_AUTOCONFIG
/* IPv6 address autoconfiguration not enabled by default */
netif->ip6_autoconfig_enabled = 0;
#endif /* LWIP_IPV6_AUTOCONFIG */
#if LWIP_IPV6_SEND_ROUTER_SOLICIT
netif->rs_count = LWIP_ND6_MAX_MULTICAST_SOLICIT;
#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */
#if LWIP_IPV6_DHCP6
/* netif not under DHCPv6 control by default */
netif->dhcp6 = NULL;
#endif /* LWIP_IPV6_DHCP6 */
#if LWIP_NETIF_STATUS_CALLBACK
netif->status_callback = NULL;
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif->link_callback = NULL;
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if LWIP_IGMP
netif->igmp_mac_filter = NULL;
#endif /* LWIP_IGMP */
#if LWIP_IPV6 && LWIP_IPV6_MLD
netif->mld_mac_filter = NULL;
#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */
#if ENABLE_LOOPBACK
netif->loop_first = NULL;
netif->loop_last = NULL;
#endif /* ENABLE_LOOPBACK */
/* remember netif specific state information data */
netif->state = state;
#ifdef PSIPHON
/* tun2socks as a library, with a multi-run lifetime,
may invoke this multiple times */
netif->num = netif_num;
#else
netif->num = netif_num++;
#endif /* PSIPHON */
netif->input = input;
NETIF_SET_HWADDRHINT(netif, NULL);
#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS
netif->loop_cnt_current = 0;
#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */
netif_set_addr(netif, ipaddr, netmask, gw);
/* call user specified initialization function for netif */
if (init(netif) != ERR_OK) {
return NULL;
}
/* add this netif to the list */
netif->next = netif_list;
netif_list = netif;
snmp_inc_iflist();
#if LWIP_IGMP
/* start IGMP processing */
if (netif->flags & NETIF_FLAG_IGMP) {
igmp_start(netif);
}
#endif /* LWIP_IGMP */
LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP addr ",
netif->name[0], netif->name[1]));
ip_addr_debug_print(NETIF_DEBUG, ipaddr);
LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));
ip_addr_debug_print(NETIF_DEBUG, netmask);
LWIP_DEBUGF(NETIF_DEBUG, (" gw "));
ip_addr_debug_print(NETIF_DEBUG, gw);
LWIP_DEBUGF(NETIF_DEBUG, ("\n"));
return netif;
}
//*****************************************************************************
//
// Completes the network configuration change. This is directly called when
// not using a RTOS and provided as a callback to the TCP/IP thread when using
// a RTOS.
//
//*****************************************************************************
static void
lwIPPrivateNetworkConfigChange(void *pvArg)
{
unsigned long ulIPMode;
struct ip_addr ip_addr;
struct ip_addr net_mask;
struct ip_addr gw_addr;
//
// Get the new address mode.
//
ulIPMode = (unsigned long)pvArg;
//
// Setup the network address values.
//
if(ulIPMode == IPADDR_USE_STATIC)
{
ip_addr.addr = htonl(g_ulIPAddr);
net_mask.addr = htonl(g_ulNetMask);
gw_addr.addr = htonl(g_ulGWAddr);
}
#if LWIP_DHCP || LWIP_AUTOIP
else
{
ip_addr.addr = 0;
net_mask.addr = 0;
gw_addr.addr = 0;
}
#endif
//
// Switch on the current IP Address Aquisition mode.
//
switch(g_ulIPMode)
{
//
// Static IP
//
case IPADDR_USE_STATIC:
{
//
// Set the new address parameters. This will change the address
// configuration in lwIP, and if necessary, will reset any links
// that are active. This is valid for all three modes.
//
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
//
// If we are going to DHCP mode, then start the DHCP server now.
//
#if LWIP_DHCP
if(ulIPMode == IPADDR_USE_DHCP)
{
dhcp_start(&g_sNetIF);
}
#endif
//
// If we are going to AutoIP mode, then start the AutoIP process
// now.
//
#if LWIP_AUTOIP
if(ulIPMode == IPADDR_USE_AUTOIP)
{
autoip_start(&g_sNetIF);
}
#endif
//
// And we're done.
//
break;
}
//
// DHCP (with AutoIP fallback).
//
#if LWIP_DHCP
case IPADDR_USE_DHCP:
{
//
// If we are going to static IP addressing, then disable DHCP and
// force the new static IP address.
//
if(ulIPMode == IPADDR_USE_STATIC)
{
dhcp_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
}
//
// If we are going to AUTO IP addressing, then disable DHCP, set
// the default addresses, and start AutoIP.
//
#if LWIP_AUTOIP
else if(ulIPMode == IPADDR_USE_AUTOIP)
{
dhcp_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
autoip_start(&g_sNetIF);
}
#endif
break;
}
#endif
//
// AUTOIP
//
#if LWIP_AUTOIP
case IPADDR_USE_AUTOIP:
{
//
// If we are going to static IP addressing, then disable AutoIP and
// force the new static IP address.
//
if(ulIPMode == IPADDR_USE_STATIC)
{
autoip_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
}
//
// If we are going to DHCP addressing, then disable AutoIP, set the
// default addresses, and start dhcp.
//
#if LWIP_DHCP
else if(ulIPMode == IPADDR_USE_DHCP)
{
autoip_stop(&g_sNetIF);
netif_set_addr(&g_sNetIF, &ip_addr, &net_mask, &gw_addr);
dhcp_start(&g_sNetIF);
}
#endif
break;
}
#endif
}
//
// Save the new mode.
//
g_ulIPMode = ulIPMode;
}
/**
* @brief LwIP_DHCP_Process_Handle
* @param None
* @retval None
*/
void LwIP_DHCP_Process_Handle()
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint8_t iptab[4] = {0};
uint8_t iptxt[20];
switch (DHCP_state)
{
case DHCP_START:
{
DHCP_state = DHCP_WAIT_ADDRESS;
dhcp_start(&gnetif);
/* IP address should be set to 0
every time we want to assign a new DHCP address */
IPaddress = 0;
#ifdef USE_LCD
LCD_DisplayStringLine(Line4, (uint8_t*)" Looking for ");
LCD_DisplayStringLine(Line5, (uint8_t*)" DHCP server ");
LCD_DisplayStringLine(Line6, (uint8_t*)" please wait... ");
#endif
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = gnetif.ip_addr.addr;
if (IPaddress!=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(&gnetif);
#ifdef USE_LCD
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
/* Display the IP address */
LCD_DisplayStringLine(Line7, (uint8_t*)"IP address assigned ");
LCD_DisplayStringLine(Line8, (uint8_t*)" by a DHCP server ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
STM_EVAL_LEDOn(LED1);
}
else
{
/* DHCP timeout */
if (gnetif.dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(&gnetif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(&gnetif, &ipaddr , &netmask, &gw);
#ifdef USE_LCD
LCD_DisplayStringLine(Line7, (uint8_t*)" DHCP timeout ");
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
LCD_DisplayStringLine(Line8, (uint8_t*)" Static IP address ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
STM_EVAL_LEDOn(LED1);
}
}
}
/**
* Add a network interface to the list of lwIP netifs.
*
* @param netif a pre-allocated netif structure
* @param ipaddr IP address for the new netif
* @param netmask network mask for the new netif
* @param gw default gateway IP address for the new netif
* @param state opaque data passed to the new netif
* @param init callback function that initializes the interface
* @param input callback function that is called to pass
* ingress packets up in the protocol layer stack.
*
* @return netif, or NULL if failed.
*/
struct netif *
netif_add(struct netif *netif, ip_addr_t *ipaddr, ip_addr_t *netmask,
ip_addr_t *gw, void *state, netif_init_fn init, netif_input_fn input)
{
struct netif *temp;
LWIP_ASSERT("No init function given", init != NULL);
/* reset new interface configuration state */
ip_addr_set_zero(&netif->ip_addr);
ip_addr_set_zero(&netif->netmask);
ip_addr_set_zero(&netif->gw);
netif->flags = 0;
#if LWIP_DHCP
/* netif not under DHCP control by default */
netif->dhcp = NULL;
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
/* netif not under AutoIP control by default */
netif->autoip = NULL;
#endif /* LWIP_AUTOIP */
#if LWIP_NETIF_STATUS_CALLBACK
netif->status_callback = NULL;
#endif /* LWIP_NETIF_STATUS_CALLBACK */
#if LWIP_NETIF_LINK_CALLBACK
netif->link_callback = NULL;
#endif /* LWIP_NETIF_LINK_CALLBACK */
#if LWIP_IGMP
netif->igmp_mac_filter = NULL;
#endif /* LWIP_IGMP */
#if ENABLE_LOOPBACK
netif->loop_first = NULL;
netif->loop_last = NULL;
#endif /* ENABLE_LOOPBACK */
/* remember netif specific state information data */
netif->state = state;
netif->num = netif_num++;
netif->input = input;
NETIF_SET_HWADDRHINT(netif, NULL);
#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS
netif->loop_cnt_current = 0;
#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */
netif_set_addr(netif, ipaddr, netmask, gw);
/* call user specified initialization function for netif */
if (init(netif) != ERR_OK) {
return NULL;
}
/* add this netif to the list */
/* 之前采用头部插入法，现在改为尾部插入法 */
// netif->next = netif_list;
// netif_list = netif;
if(netif_list == NULL){
netif_list = netif;
}else{
temp = netif_list;
while(temp->next){
temp = temp->next;
}
temp->next = netif;
netif->next = NULL;
}
snmp_inc_iflist();
#if LWIP_IGMP
/* start IGMP processing */
if (netif->flags & NETIF_FLAG_IGMP) {
igmp_start(netif);
}
#endif /* LWIP_IGMP */
LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP addr ",
netif->name[0], netif->name[1]));
ip_addr_debug_print(NETIF_DEBUG, ipaddr);
LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));
ip_addr_debug_print(NETIF_DEBUG, netmask);
LWIP_DEBUGF(NETIF_DEBUG, (" gw "));
ip_addr_debug_print(NETIF_DEBUG, gw);
LWIP_DEBUGF(NETIF_DEBUG, ("\n"));
return netif;
}
/**
* @brief LwIP_DHCP_Process_Handle
* @param None
* @retval None
*/
void LwIP_DHCP_task(void * pvParameters)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress;
uint8_t iptab[4];
uint8_t iptxt[20];
uint8_t DHCP_state;
DHCP_state = DHCP_START;
for (;;)
{
switch (DHCP_state)
{
case DHCP_START:
{
dhcp_start(&xnetif);
IPaddress = 0;
DHCP_state = DHCP_WAIT_ADDRESS;
#ifdef USE_LCD
LCD_DisplayStringLine(Line4, (uint8_t*)" Looking for ");
LCD_DisplayStringLine(Line5, (uint8_t*)" DHCP server ");
LCD_DisplayStringLine(Line6, (uint8_t*)" please wait... ");
#endif
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = xnetif.ip_addr.addr;
if (IPaddress!=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(&xnetif);
#ifdef USE_LCD
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
/* Display the IP address */
LCD_DisplayStringLine(Line7, (uint8_t*)"IP address assigned ");
LCD_DisplayStringLine(Line8, (uint8_t*)" by a DHCP server ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
/* end of DHCP process: LED1 stays ON*/
STM_EVAL_LEDOn(LED1);
vTaskDelete(NULL);
}
else
{
/* DHCP timeout */
if (xnetif.dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(&xnetif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(&xnetif, &ipaddr , &netmask, &gw);
#ifdef USE_LCD
LCD_DisplayStringLine(Line7, (uint8_t*)" DHCP timeout ");
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
LCD_ClearLine(Line4);
LCD_ClearLine(Line5);
LCD_ClearLine(Line6);
LCD_DisplayStringLine(Line8, (uint8_t*)" Static IP address ");
LCD_DisplayStringLine(Line9, iptxt);
#endif
/* end of DHCP process: LED1 stays ON*/
STM_EVAL_LEDOn(LED1);
vTaskDelete(NULL);
}
}
}
break;
default: break;
}
/**
* @brief DHCP Process
* @param argument: network interface
* @retval None
*/
void DHCP_thread(void const * argument)
{
struct netif *netif = (struct netif *) argument;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress;
for (;;)
{
switch (DHCP_state)
{
case DHCP_START:
{
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
IPaddress = 0;
dhcp_start(netif);
DHCP_state = DHCP_WAIT_ADDRESS;
#ifdef USE_LCD
BSP_LCD_ClearStringLine(7);
BSP_LCD_ClearStringLine(8);
BSP_LCD_ClearStringLine(9);
BSP_LCD_DisplayStringAtLine(8,(uint8_t *) " Looking for");
BSP_LCD_DisplayStringAtLine(9,(uint8_t *) " DHCP sever ...");
#endif
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = netif->ip_addr.addr;
if (IPaddress!=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(netif);
#ifdef USE_LCD
uint8_t iptab[4];
uint8_t iptxt[20];
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
BSP_LCD_ClearStringLine(7);
BSP_LCD_ClearStringLine(8);
BSP_LCD_ClearStringLine(9);
BSP_LCD_DisplayStringAtLine(7,(uint8_t *) " IP address assigned");
BSP_LCD_DisplayStringAtLine(8,(uint8_t *) " by a DHCP server:");
BSP_LCD_DisplayStringAtLine(9,(uint8_t *) iptxt);
#else
BSP_LED_On(LED1);
#endif
}
else
{
/* DHCP timeout */
if (netif->dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(netif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(netif, &ipaddr , &netmask, &gw);
#ifdef USE_LCD
uint8_t iptxt[20];
sprintf((char*)iptxt, " %d.%d.%d.%d", IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
BSP_LCD_ClearStringLine(7);
BSP_LCD_ClearStringLine(8);
BSP_LCD_ClearStringLine(9);
BSP_LCD_DisplayStringAtLine(7,(uint8_t *) " DHCP timeout !!");
BSP_LCD_DisplayStringAtLine(8,(uint8_t *) " Static IP address :");
BSP_LCD_DisplayStringAtLine(9,(uint8_t *) iptxt);
#else
BSP_LED_On(LED1);
#endif
}
}
}
break;
default: break;
}
/**
* @brief LwIP_DHCP_Process_Handle
* @param None
* @retval None
*/
void LwIP_DHCP_task(void * pvParameters)
{
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress;
uint8_t iptab[4];
uint8_t iptxt[20];
uint8_t DHCP_state;
DHCP_state = DHCP_START;
bool terminate=false;
netif_set_status_callback(&xnetif, netif_status_callback);
LwIP_Init();
while (!terminate)
{
switch (DHCP_state)
{
case DHCP_START:
{
dhcp_start(&xnetif);
IPaddress = 0;
DHCP_state = DHCP_WAIT_ADDRESS;
syslog(SYSTEM_LVL,true,"DHCP_START");
}
break;
case DHCP_WAIT_ADDRESS:
{
IPaddress = xnetif.ip_addr.addr; /* Read the new IP address */
if (IPaddress!=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(&xnetif);
iptab[0] = (uint8_t)(IPaddress >> 24);
iptab[1] = (uint8_t)(IPaddress >> 16);
iptab[2] = (uint8_t)(IPaddress >> 8);
iptab[3] = (uint8_t)(IPaddress);
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
syslog(SYSTEM_LVL,true,"DHCP_WAIT_ADDRESS reply %s",iptxt);
}
else
{
/* DHCP timeout */
if (xnetif.dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(&xnetif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(&xnetif, &ipaddr , &netmask, &gw);
syslog(SYSTEM_LVL,true,"DHCP_TIMEOUT");
iptab[0] = IP_ADDR3;
iptab[1] = IP_ADDR2;
iptab[2] = IP_ADDR1;
iptab[3] = IP_ADDR0;
sprintf((char*)iptxt, " %d.%d.%d.%d", iptab[3], iptab[2], iptab[1], iptab[0]);
syslog(SYSTEM_LVL,true,"DHCP_TIMEOUT activating static ip %s",iptxt);
netif_status_callback(&xnetif);
}
}
}
break;
case DHCP_ADDRESS_ASSIGNED:
syslog(SYSTEM_LVL,true,"DHCP_ADDRESS_ASSIGNED");
netif_status_callback(&xnetif);
terminate=true;
break;
default:
break;
}
/**
* @brief DHCP Process
* @param argument: network interface
* @retval None
*/
void DHCP_thread(void const * argument)
{
struct netif *netif = (struct netif *) argument;
struct ip_addr ipaddr;
struct ip_addr netmask;
struct ip_addr gw;
uint32_t IPaddress;
for (;;)
{
switch (DHCP_state)
{
case DHCP_START:
{
netif->ip_addr.addr = 0;
netif->netmask.addr = 0;
netif->gw.addr = 0;
IPaddress = 0;
dhcp_start(netif);
DHCP_state = DHCP_WAIT_ADDRESS;
}
break;
case DHCP_WAIT_ADDRESS:
{
/* Read the new IP address */
IPaddress = netif->ip_addr.addr;
if (IPaddress!=0)
{
DHCP_state = DHCP_ADDRESS_ASSIGNED;
/* Stop DHCP */
dhcp_stop(netif);
}
else
{
/* DHCP timeout */
if (netif->dhcp->tries > MAX_DHCP_TRIES)
{
DHCP_state = DHCP_TIMEOUT;
/* Stop DHCP */
dhcp_stop(netif);
/* Static address used */
IP4_ADDR(&ipaddr, IP_ADDR0 ,IP_ADDR1 , IP_ADDR2 , IP_ADDR3 );
IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1, NETMASK_ADDR2, NETMASK_ADDR3);
IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
netif_set_addr(netif, &ipaddr , &netmask, &gw);
}
}
}
break;
default: break;
}
/* wait 250 ms */
osDelay(250);
}
}
