Example #1
0
static inline int SMapInit(IPAddr IP, IPAddr NM, IPAddr GW, int argc, char *argv[])
{
	if(smap_init(argc, argv)!=0)
	{
		return	0;
	}
	dbgprintf("SMapInit: SMap initialized\n");

	netif_add(&NIF,&IP,&NM,&GW,NULL,&SMapIFInit,tcpip_input);
	netif_set_default(&NIF);
	netif_set_up(&NIF);
	dbgprintf("SMapInit: NetIF added to ps2ip\n");

	//Return 1 (true) to indicate success.

	return	1;
}
Example #2
0
/*---------------------------------------------------------------------------*
 * Routine:  IStartup
 *---------------------------------------------------------------------------*
 * Description:
 *      Start up the Redpine module
 * Inputs:
 *      void *aWorkspace -- Workspace
 * Outputs:
 *      T_uezError -- Error code
 *---------------------------------------------------------------------------*/
static T_uezError IStartup(
    T_Network_lwIP_Workspace *p,
    T_uezNetworkSettings *aSettings)
{
    extern err_t ethernetif_init(struct netif *netif);
    T_uezError error = UEZ_ERROR_NONE;
    struct ip_addr xIpAddr, xNetMast, xGateway;

    // Only support infrastructure network types
    if (aSettings->iNetworkType != UEZ_NETWORK_TYPE_INFRASTRUCTURE)
        return UEZ_ERROR_INCORRECT_TYPE;

    tcpip_init(NULL, NULL);

    /* Create and configure the EMAC interface. */
    IP4_ADDR(&xIpAddr, aSettings->iIPAddress.v4[0],
             aSettings->iIPAddress.v4[1], aSettings->iIPAddress.v4[2],
             aSettings->iIPAddress.v4[3]);
    IP4_ADDR(&xNetMast, aSettings->iSubnetMask.v4[0],
             aSettings->iSubnetMask.v4[1], aSettings->iSubnetMask.v4[2],
             aSettings->iSubnetMask.v4[3]);
    IP4_ADDR(&xGateway, aSettings->iGatewayAddress.v4[0],
             aSettings->iGatewayAddress.v4[1], aSettings->iGatewayAddress.v4[2],
             aSettings->iGatewayAddress.v4[3]);

    /* uEZ v2.04 -- The MAC address is now passed into via the Network Settings
     *              instead of using a confusing callback. */
    p->EMAC_if.hwaddr_len_padding = 6;
    p->EMAC_if.hwaddr[0] = aSettings->iMACAddress.v4[0];
    p->EMAC_if.hwaddr[1] = aSettings->iMACAddress.v4[1];
    p->EMAC_if.hwaddr[2] = aSettings->iMACAddress.v4[2];
    p->EMAC_if.hwaddr[3] = aSettings->iMACAddress.v4[3];
    p->EMAC_if.hwaddr[4] = aSettings->iMACAddress.v4[4];
    p->EMAC_if.hwaddr[5] = aSettings->iMACAddress.v4[5];

    netif_add(&p->EMAC_if, &xIpAddr, &xNetMast, &xGateway, NULL,
              ethernetif_init, tcpip_input);

    /* make it the default interface */
    netif_set_default(&p->EMAC_if);

    /* bring it up */
    netif_set_up(&p->EMAC_if);

    return error;
}
Example #3
0
void vBasicWEBServer( void *pvParameters )
{
    struct netconn *pxHTTPListener, *pxNewConnection;
    struct ip_addr  xIpAddr, xNetMast, xGateway;
    static struct netif fec523x_if;
	extern err_t ethernetif_init(struct netif *netif);

    /* Parameters are not used - suppress compiler error. */
    ( void )pvParameters;

	vlwIPInit();

    /* Create and configure the FEC interface. */
    IP4_ADDR( &xIpAddr, configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 );
    IP4_ADDR( &xNetMast, configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 );
    IP4_ADDR( &xGateway, configGW_ADDR0, configGW_ADDR1, configGW_ADDR2, configGW_ADDR3 );
    netif_add( &fec523x_if, &xIpAddr, &xNetMast, &xGateway, NULL, ethernetif_init, tcpip_input );

    /* make it the default interface */
    netif_set_default( &fec523x_if );

    /* bring it up */
    netif_set_up( &fec523x_if );

    /* Create a new tcp connection handle */
    pxHTTPListener = netconn_new( NETCONN_TCP );
    netconn_bind( pxHTTPListener, NULL, webHTTP_PORT );
    netconn_listen( pxHTTPListener );

    /* Loop forever */
    for( ;; )
    {	
        /* Wait for connection. */
        pxNewConnection = netconn_accept( pxHTTPListener );

        if( pxNewConnection != NULL )
        {
            /* Service connection. */
            vProcessConnection( pxNewConnection );
            while( netconn_delete( pxNewConnection ) != ERR_OK )
            {
                vTaskDelay( webSHORT_DELAY );
            }
        }
    }
}
int AT91_EMAC_LWIP_Driver::Open(int index)
{
    /* Network interface variables */
    struct ip_addr ipaddr, subnetmask, gateway;
    struct netif *pNetIF;
    int len;
    const SOCK_NetworkConfiguration *iface;

    /* Apply network configuration */
    iface = &g_NetworkConfig.NetworkInterfaces[index];

    len = g_AT91_EMAC_NetIF.hwaddr_len;
    if(len == 0 || iface->macAddressLen < len)
    {
        len = iface->macAddressLen;
        g_AT91_EMAC_NetIF.hwaddr_len = len;
    }
    memcpy(g_AT91_EMAC_NetIF.hwaddr, iface->macAddressBuffer, len);

    ipaddr.addr = iface->ipaddr;
    gateway.addr = iface->gateway;
    subnetmask.addr = iface->subnetmask;

    // PHY Power Up
    CPU_GPIO_EnableOutputPin(g_AT91_EMAC_LWIP_Config.PHY_PD_GPIO_Pin, FALSE);

    // Enable Interrupt
    CPU_INTC_ActivateInterrupt(AT91C_ID_EMAC, (HAL_CALLBACK_FPN)AT91_EMAC_LWIP_interrupt, &g_AT91_EMAC_NetIF);

    /* Initialize the continuation routine for the driver interrupt and receive */    
    InitContinuations( pNetIF );

    pNetIF = netif_add( &g_AT91_EMAC_NetIF, &ipaddr, &subnetmask, &gateway, NULL, AT91_EMAC_ethhw_init, ethernet_input );

    netif_set_default( pNetIF );

    LwipNetworkStatus = dm9161_lwip_GetLinkStatus( );
    if (LwipNetworkStatus)
    {
        netif_set_up( pNetIF );
    }
    /* Initialize the continuation routine for the driver interrupt and receive */    
    InitContinuations( pNetIF );

    return g_AT91_EMAC_NetIF.num;
}
Example #5
0
static err_t eth_netif_device_init(struct netif *netif)
{
    struct eth_device *ethif;

    ethif = (struct eth_device*)netif->state;
    if (ethif != NULL)
    {
        rt_device_t device;

        /* get device object */
        device = (rt_device_t) ethif;
        if (rt_device_init(device) != RT_EOK)
        {
            return ERR_IF;
        }

        /* copy device flags to netif flags */
        netif->flags = ethif->flags;

        /* set default netif */
        if (netif_default == NULL)
            netif_set_default(ethif->netif);

#if LWIP_DHCP
        if (ethif->flags & NETIF_FLAG_DHCP)
        {
            /* if this interface uses DHCP, start the DHCP client */
            dhcp_start(ethif->netif);
        }
        else
#endif
        {
            /* set interface up */
            netif_set_up(ethif->netif);
        }

#ifdef LWIP_NETIF_LINK_CALLBACK
        netif_set_link_up(ethif->netif);
#endif

        return ERR_OK;
    }

    return ERR_IF;
}
Example #6
0
/* init function */
void MX_LWIP_Init(void)
{
  IP_ADDRESS[0] = 192;
  IP_ADDRESS[1] = 168;
  IP_ADDRESS[2] = 203;
  IP_ADDRESS[3] = 36;
  NETMASK_ADDRESS[0] = 255;
  NETMASK_ADDRESS[1] = 255;
  NETMASK_ADDRESS[2] = 255;
  NETMASK_ADDRESS[3] = 0;
  GATEWAY_ADDRESS[0] = 192;
  GATEWAY_ADDRESS[1] = 168;
  GATEWAY_ADDRESS[2] = 203;
  GATEWAY_ADDRESS[3] = 2;
   
  tcpip_init( NULL, NULL );	
 
  IP4_ADDR(&ipaddr, IP_ADDRESS[0], IP_ADDRESS[1], IP_ADDRESS[2], IP_ADDRESS[3]);
  IP4_ADDR(&netmask, NETMASK_ADDRESS[0], NETMASK_ADDRESS[1] , NETMASK_ADDRESS[2], NETMASK_ADDRESS[3]);
  IP4_ADDR(&gw, GATEWAY_ADDRESS[0], GATEWAY_ADDRESS[1], GATEWAY_ADDRESS[2], GATEWAY_ADDRESS[3]);  
  

  /* add the network interface */
  netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &tcpip_input);
 
 
  /*  Registers the default network interface */
  netif_set_default(&gnetif);

  if (netif_is_link_up(&gnetif))
  {
    /* When the netif is fully configured this function must be called */
    netif_set_up(&gnetif);
  }
  else
  {
    /* When the netif link is down this function must be called */
       netif_set_down(&gnetif);
  }  
  

/* USER CODE BEGIN 3 */

/* USER CODE END 3 */
}
Example #7
0
/**
  * @brief  Initializes the lwIP stack
  * @param  None
  * @retval None
  */
void LwIP_Init(void)
{
  struct ip_addr ipaddr;
  struct ip_addr netmask;
  struct ip_addr gw;

  /* Initializes the dynamic memory heap defined by MEM_SIZE.*/
  mem_init();

  /* Initializes the memory pools defined by MEMP_NUM_x.*/
  memp_init();

#ifdef USE_DHCP
  ipaddr.addr = 0;
  netmask.addr = 0;
  gw.addr = 0;
#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);
  
  /* Deliver static IP complete call */
  LwIP_static_done((IP_ADDR0 << 24) | (IP_ADDR1 << 16) | (IP_ADDR2 << 8) | IP_ADDR3);
#endif

  /* - 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))
    
   Adds your network interface to the netif_list. Allocate a struct
  netif and pass a pointer to this structure as the first argument.
  Give pointers to cleared ip_addr structures when using DHCP,
  or fill them with sane numbers otherwise. The state pointer may be NULL.

  The init function pointer must point to a initialization function for
  your ethernet netif interface. The following code illustrates it's use.*/
  netif_add(&netif, &ipaddr, &netmask, &gw, NULL, &ethernetif_init, &ethernet_input);

  /*  Registers the default network interface.*/
  netif_set_default(&netif);

  /*  When the netif is fully configured this function must be called.*/
  netif_set_up(&netif);
}
Example #8
0
void start_networking(void)
{
  struct ip_addr ipaddr = { htonl(IF_IPADDR) };
  struct ip_addr netmask = { htonl(IF_NETMASK) };
  struct ip_addr gw = { 0 };
  char *ip = NULL;

#ifdef CONFIG_PRINT
  tprintk("Waiting for network.\n");
#endif

  dev = init_netfront(NULL, NULL, rawmac, &ip);

  if (ip) {
    ipaddr.addr = inet_addr(ip);
    if (IN_CLASSA(ntohl(ipaddr.addr)))
      netmask.addr = htonl(IN_CLASSA_NET);
    else if (IN_CLASSB(ntohl(ipaddr.addr)))
      netmask.addr = htonl(IN_CLASSB_NET);
    else if (IN_CLASSC(ntohl(ipaddr.addr)))
      netmask.addr = htonl(IN_CLASSC_NET);
    else
      tprintk("Strange IP %s, leaving netmask to 0.\n", ip);
  }
  tprintk("IP %x netmask %x gateway %x.\n",
          ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr));

#ifdef CONFIG_PRINT
  tprintk("TCP/IP bringup begins.\n");
#endif

  netif = xmalloc(struct netif);
  tcpip_init(tcpip_bringup_finished, netif);

  netif_add(netif, &ipaddr, &netmask, &gw, rawmac,
            netif_netfront_init, ip_input);
  netif_set_default(netif);
  netif_set_up(netif);

  down(&tcpip_is_up);

#ifdef CONFIG_FRONT
    tprintk("Network is ready.\n");
#endif
}
Example #9
0
/* ethernetif APIs */
rt_err_t eth_device_init(struct eth_device* dev, const char* name)
{
	struct netif* pnetif;
	/* allocate memory */
	pnetif = (struct netif*) rt_malloc (sizeof(struct netif));
	if (pnetif == RT_NULL)
	{
		rt_kprintf("malloc netif failed\n");
		return -RT_ERROR;
	}
	rt_memset(pnetif, 0, sizeof(struct netif));


	/* set netif */
	dev->netif = pnetif;
	/* register to rt-thread device manager */
	rt_device_register(&(dev->parent), name, RT_DEVICE_FLAG_RDWR);
	dev->parent.type = RT_Device_Class_NetIf;
	rt_sem_init(&(dev->tx_ack), name, 0, RT_IPC_FLAG_FIFO);


	/* add netif to lwip */
	/* NOTE: eth_init will be called back by netif_add, we should put some initialization
	         code to eth_init(). See include/lwip/netif.h line 97 */
	eth_dev = dev;
	if (netif_add(pnetif, IP_ADDR_ANY, IP_ADDR_BROADCAST, IP_ADDR_ANY, dev,
		ethernetif_init, ethernet_input) == RT_NULL)
	{
		/* failed, unregister device and free netif */
		rt_device_unregister(&(dev->parent));
		rt_free(pnetif);
		eth_dev = RT_NULL;
		return -RT_ERROR;
	}
	eth_dev = RT_NULL;

	netif_set_default(pnetif);

	/* We bring up the netif here cause we still don't have a call back function
	which indicates the ethernet interface status from the ethernet driver. */
	netif_set_up(pnetif);
	netif_set_link_up(pnetif);

	return RT_EOK;
}
Example #10
0
File: main.c Project: cr1901/artiq
static void network_init(void)
{
    struct ip4_addr local_ip;
    struct ip4_addr netmask;
    struct ip4_addr gateway_ip;

    init_macadr();
    fsip_or_default(&local_ip, "ip", 192, 168, 0, 42);
    fsip_or_default(&netmask, "netmask", 255, 255, 255, 0);
    fsip_or_default(&gateway_ip, "gateway", 192, 168, 0, 1);

    lwip_init();

    netif_add(&netif, &local_ip, &netmask, &gateway_ip, 0, liteeth_init, ethernet_input);
    netif_set_default(&netif);
    netif_set_up(&netif);
    netif_set_link_up(&netif);
}
Example #11
0
static void tcpip_init_done(void* arg) {
#if DEBUG
	kprintf(LOG, "[%d] tcpip: initialized in %d MS\n", sys_getpid(), timer_getms() - (uint32_t) arg);
#else
	(void) arg;
#endif


	struct netif* lo = netif_find("lo0");
	if(likely(lo)) {
		netif_set_up(lo);
		netif_set_default(lo);
	} else
		kprintf(WARN, "netif: Loopback interface not found\n");


	lwip_socket_init();
}
Example #12
0
static void
lwip_init(struct netif *nif, void *if_state,
	  uint32_t init_addr, uint32_t init_mask, uint32_t init_gw)
{
	struct ip_addr ipaddr, netmask, gateway;
	ipaddr.addr  = init_addr;
	netmask.addr = init_mask;
	gateway.addr = init_gw;

	if (0 == netif_add(nif, &ipaddr, &netmask, &gateway,
			   if_state,
			   jif_init,
			   ip_input))
		panic("lwip_init: error in netif_add\n");

	netif_set_default(nif);
	netif_set_up(nif);
}
static void ethernet_configure_interface(unsigned char ipAddress[], unsigned char netMask[], unsigned char gateWay[])
{
	struct ip_addr x_ip_addr, x_net_mask, x_gateway;
	extern err_t ethernetif_init(struct netif *netif);

#if defined(DHCP_USED)
	x_ip_addr.addr = 0;
	x_net_mask.addr = 0;
#else
	/* Default ip addr */
	//IP4_ADDR(&x_ip_addr, ETHERNET_CONF_IPADDR0, ETHERNET_CONF_IPADDR1, ETHERNET_CONF_IPADDR2, ETHERNET_CONF_IPADDR3);

	IP4_ADDR(&x_ip_addr, ipAddress[0], ipAddress[1], ipAddress[2], ipAddress[3]);

	/* Default subnet mask */
	//IP4_ADDR(&x_net_mask, ETHERNET_CONF_NET_MASK0, ETHERNET_CONF_NET_MASK1, ETHERNET_CONF_NET_MASK2, ETHERNET_CONF_NET_MASK3);

	IP4_ADDR(&x_net_mask, netMask[0], netMask[1], netMask[2], netMask[3]);

	/* Default gateway addr */
	//IP4_ADDR(&x_gateway, ETHERNET_CONF_GATEWAY_ADDR0, ETHERNET_CONF_GATEWAY_ADDR1, ETHERNET_CONF_GATEWAY_ADDR2, ETHERNET_CONF_GATEWAY_ADDR3);

	IP4_ADDR(&x_gateway, gateWay[0], gateWay[1], gateWay[2], gateWay[3]);
#endif

	/* Add data to netif */
	netif_add(&gs_net_if, &x_ip_addr, &x_net_mask, &x_gateway, NULL,
			ethernetif_init, ethernet_input);

	/* Make it the default interface */
	netif_set_default(&gs_net_if);

	/* Setup callback function for netif status change */
	netif_set_status_callback(&gs_net_if, status_callback);

	/* Bring it up */
#if defined(DHCP_USED)
	printf("LwIP: DHCP Started");
	dhcp_start(&gs_net_if);
#else
//	printf("LwIP: Static IP Address Assigned\r\n");
	netif_set_up(&gs_net_if);
#endif
}
Example #14
0
static err_t eth_netif_device_init(struct netif *netif)
{
    struct eth_device *ethif;

    ethif = (struct eth_device*)netif->state;
    if (ethif != RT_NULL)
    {
        rt_device_t device;

        /* get device object */
        device = (rt_device_t) ethif;
        if (rt_device_init(device) != RT_EOK)
        {
            return ERR_IF;
        }

        /* copy device flags to netif flags */
        netif->flags = (ethif->flags & 0xff);

        /* set default netif */
        if (netif_default == RT_NULL)
            netif_set_default(ethif->netif);

#if LWIP_DHCP
        /* set interface up */
        netif_set_up(ethif->netif);
        /* if this interface uses DHCP, start the DHCP client */
        dhcp_start(ethif->netif);
#else
        /* set interface up */
        netif_set_up(ethif->netif);
#endif

        if (!(ethif->flags & ETHIF_LINK_PHYUP))
        {
            /* set link_up for this netif */
            netif_set_link_up(ethif->netif);
        }

        return ERR_OK;
    }

    return ERR_IF;
}
Example #15
0
void _init(void){
  struct ip_addr ipaddr, netmask, gateway;
  sys_sem_t sem;

  sem = sys_sem_new(0);
  tcpip_init(tcpip_init_done, &sem);
  sys_sem_wait(sem);
  sys_sem_free(sem);
  
 /*
    CHANGE THESE to suit your own network configuration:
  */
  IP4_ADDR(&gateway, 192,168,1,1);
  IP4_ADDR(&ipaddr, 192,168,1,2);
  IP4_ADDR(&netmask, 255,255,255,0);
  
  netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gateway, NULL, tapif_init,
			      tcpip_input));
}
Example #16
0
/*!
 * @brief main function
 */
int main(void)
{
  ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;

  app_low_level_init();
  OSA_Init();
  lwip_init();

  IP4_ADDR(&fsl_netif0_ipaddr, 192,168,2,102);
  IP4_ADDR(&fsl_netif0_netmask, 255,255,255,0);
  IP4_ADDR(&fsl_netif0_gw, 192,168,2,100);
  netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init, ethernet_input);
  netif_set_default(&fsl_netif0);
  netif_set_up(&fsl_netif0);

  ping_init();

  return 0;
}
Example #17
0
/**
 * Remove a network interface from the list of lwIP netifs.
 *
 * @param netif the network interface to remove
 */
void
netif_remove(struct netif *netif)
{
  if (netif == NULL) {
    return;
  }

#if LWIP_IGMP
  /* stop IGMP processing */
  if (netif->flags & NETIF_FLAG_IGMP) {
    igmp_stop(netif);
  }
#endif /* LWIP_IGMP */
  if (netif_is_up(netif)) {
    /* set netif down before removing (call callback function) */
    netif_set_down(netif);
  }

  snmp_delete_ipaddridx_tree(netif);

  /*  is it the first netif? */
  if (netif_list == netif) {
    netif_list = netif->next;
  } else {
    /*  look for netif further down the list */
    struct netif * tmpNetif;
    for (tmpNetif = netif_list; tmpNetif != NULL; tmpNetif = tmpNetif->next) {
      if (tmpNetif->next == netif) {
        tmpNetif->next = netif->next;
        break;
      }
    }
    if (tmpNetif == NULL)
      return; /*  we didn't find any netif today */
  }
  snmp_dec_iflist();
  /* this netif is default? */
  if (netif_default == netif) {
    /* reset default netif */
    netif_set_default(NULL);
  }
  LWIP_DEBUGF( NETIF_DEBUG, ("netif_remove: removed netif\n") );
}
Example #18
0
static void
tcpip_init_done(void *arg)
{
  ip_addr_t ipaddr, netmask, gateway;
  sys_sem_t *sem;
  sem = arg;

  /*
    CHANGE THESE to suit your own network configuration:
  */
  IP4_ADDR(&gateway, 192,168,1,1);
  IP4_ADDR(&ipaddr, 192,168,1,2);
  IP4_ADDR(&netmask, 255,255,255,0);
  
  netif_set_default(netif_add(&netif, &ipaddr, &netmask, &gateway, NULL, tapif_init,
			      tcpip_input));

  sys_sem_signal(sem);
}
Example #19
0
nsapi_error_t LWIP::add_l3ip_interface(L3IP &l3ip, bool default_if, OnboardNetworkStack::Interface **interface_out)
{
#if LWIP_L3IP
    Interface *interface = new (std::nothrow) Interface();
    if (!interface) {
        return NSAPI_ERROR_NO_MEMORY;
    }
    interface->l3ip = &l3ip;
    interface->memory_manager = &memory_manager;
    interface->ppp = false;



    // interface->netif.hwaddr_len = 0; should we set?

    if (!netif_add(&interface->netif,
#if LWIP_IPV4
                   0, 0, 0,
#endif
                   interface, &LWIP::Interface::emac_if_init, ip_input)) {
        return NSAPI_ERROR_DEVICE_ERROR;
    }

    if (default_if) {
        netif_set_default(&interface->netif);
        default_interface = interface;
    }

    netif_set_link_callback(&interface->netif, &LWIP::Interface::netif_link_irq);
    netif_set_status_callback(&interface->netif, &LWIP::Interface::netif_status_irq);

    *interface_out = interface;


    //lwip_add_random_seed(seed); to do?

    return NSAPI_ERROR_OK;

#else
    return NSAPI_ERROR_UNSUPPORTED;

#endif //LWIP_L3IP
}
STATIC void wiznet5k_lwip_init(wiznet5k_obj_t *self) {
    ip_addr_t ipconfig[4];
    ipconfig[0].addr = 0;
    ipconfig[1].addr = 0;
    ipconfig[2].addr = 0;
    ipconfig[3].addr = 0;
    netif_add(&self->netif, &ipconfig[0], &ipconfig[1], &ipconfig[2], self, wiznet5k_netif_init, ethernet_input);
    self->netif.name[0] = 'e';
    self->netif.name[1] = '0';
    netif_set_default(&self->netif);
    dns_setserver(0, &ipconfig[3]);
    dhcp_set_struct(&self->netif, &self->dhcp_struct);
    // Setting NETIF_FLAG_UP then clearing it is a workaround for dhcp_start and the
    // LWIP_DHCP_CHECK_LINK_UP option, so that the DHCP client schedules itself to
    // automatically start when the interface later goes up.
    self->netif.flags |= NETIF_FLAG_UP;
    dhcp_start(&self->netif);
    self->netif.flags &= ~NETIF_FLAG_UP;
}
Example #21
0
int lwip_bringup(void)
{
    // Check if we've already connected
    if (lwip_get_ip_address()) {
        return NSAPI_ERROR_PARAMETER;
    }

    // Check if we've already brought up lwip
    if (!lwip_get_mac_address()) {
        // Set up network
        lwip_set_mac_address();

        sys_sem_new(&lwip_tcpip_inited, 0);
        sys_sem_new(&lwip_netif_linked, 0);
        sys_sem_new(&lwip_netif_up, 0);

        tcpip_init(lwip_tcpip_init_irq, NULL);
        sys_arch_sem_wait(&lwip_tcpip_inited, 0);

        memset(&lwip_netif, 0, sizeof lwip_netif);
        netif_add(&lwip_netif, 0, 0, 0, NULL, eth_arch_enetif_init, tcpip_input);
        netif_set_default(&lwip_netif);

        netif_set_link_callback  (&lwip_netif, lwip_netif_link_irq);
        netif_set_status_callback(&lwip_netif, lwip_netif_status_irq);

        eth_arch_enable_interrupts();
    }

    // Zero out socket set
    lwip_arena_init();

    // Connect to the network
    dhcp_start(&lwip_netif);

    // Wait for an IP Address
    u32_t ret = sys_arch_sem_wait(&lwip_netif_up, 15000);
    if (ret == SYS_ARCH_TIMEOUT) {
        return NSAPI_ERROR_DHCP_FAILURE;
    }

    return 0;
}
void LwipNetInterface::ipStackInitDone(void *pData) {

	LwipNetInterface* lwipInterface;

	lwipInterface = (LwipNetInterface*) pData;

	LWIP_PLATFORM_DIAG(("TCP/IP stack init done\n"));

	LWIP_PLATFORM_DIAG(("netif= %p\n", &lwipInterface->netif));

	netif_set_default(
			netif_add(&lwipInterface->netif, &lwipInterface->ipaddr,
					&lwipInterface->netmask, &lwipInterface->gateway, NULL,
					tapif_init, tcpip_input));

	LWIP_PLATFORM_DIAG(("Signaling semaphore\n"));
	sys_sem_signal(&lwipInterface->syncSem);

}
Example #23
0
int
main(int argc, char **argv)
{
        struct netif netif;

        /* startup defaults (may be overridden by one or more opts). this is
         * hard-coded v4 even in presence of v6, which does auto-discovery and
         * should thus wind up with an address of fe80::12:34ff:fe56:78ab%tap0
         * */
        IP4_ADDR(&gw, 192,168,113,1);
        IP4_ADDR(&ipaddr, 192,168,113,2);
        IP4_ADDR(&netmask, 255,255,255,0);

        lwip_init();

        printf("TCP/IP initialized.\n");

        netif_add(&netif, &ipaddr, &netmask, &gw, NULL, tapif_init, ethernet_input);
        netif.flags |= NETIF_FLAG_ETHARP;
        netif_set_default(&netif);
        netif_set_up(&netif);
#if LWIP_IPV6
        netif_create_ip6_linklocal_address(&netif, 1);
#endif

        /* start applications here */

        server_coap_init();

        printf("Applications started.\n");


        while (1) {
                /* poll netif, pass packet to lwIP */
                tapif_select(&netif);

                sys_check_timeouts();

                server_coap_poll();
        }

        return 0;
}
Example #24
0
/* Init lwIP TCP/IP stack */
void init_lwip_stack (unsigned int IPaddress, unsigned int NETmask, unsigned int GATEaddress, unsigned char EnDHCP, unsigned char EnAutoIP)
{
	struct ip_addr ip_addr, net_mask, gate_addr;

	/* Initialize all lwIP modules */
	lwip_init ();

	/* Setup static IP values */
	ip_addr.addr	= htonl(IPaddress);
	net_mask.addr	= htonl(NETmask);
	gate_addr.addr	= htonl(GATEaddress);

#if (LWIP_AUTOIP || LWIP_DHCP)
	/* If DHCP or AutoIP is enabled clear IP values */
	if (EnDHCP || EnAutoIP) {
		ip_addr.addr	= 0;
		net_mask.addr	= 0;
		gate_addr.addr	= 0;
	}
#endif

	/* Add a network interface to the list of lwIP netifs */
 	/* use ethernet_input() insted of tcpip_input() */
	netif_add(&enc28j60_netif, &ip_addr, &net_mask, &gate_addr, NULL, ethernetif_init, ip_input);

	/* Set a 'enc28j60_netif' interface as the default network interface */
	netif_set_default(&enc28j60_netif);

#if LWIP_DHCP
	/* Start DHCP if it enabled */
	if (EnDHCP)
		dhcp_start (&enc28j60_netif);
#endif

#if LWIP_AUTOIP
	/* Start AutoIP if it enabled */
	if (EnAutoIP)
		autoip_start (&enc28j60_netif);
#endif

	/* Bring an interface up, available for processing traffic */
	netif_set_up (&enc28j60_netif);
}
Example #25
0
void resume_networking(int cancelled)
{
  //struct netif *netif;
  struct ip_addr ipaddr = { htonl(IF_IPADDR) };
  struct ip_addr netmask = { htonl(IF_NETMASK) };
  struct ip_addr gw = { htonl(0xc0a87a01) };
  char *ip = NULL;

#ifdef CONFIG_PRINT
  tprintk("Waiting for network.\n");
#endif

  dev = init_netfront(NULL, NULL, rawmac, &ip);
  if(!cancelled){
    if (ip) {
        ipaddr.addr = inet_addr(ip);
        if (IN_CLASSA(ntohl(ipaddr.addr)))
            netmask.addr = htonl(IN_CLASSA_NET);
        else if (IN_CLASSB(ntohl(ipaddr.addr)))
            netmask.addr = htonl(IN_CLASSB_NET);
        else if (IN_CLASSC(ntohl(ipaddr.addr)))
            netmask.addr = htonl(IN_CLASSC_NET);
        else
            tprintk("Strange IP %s, leaving netmask to 0.\n", ip);
    }
    tprintk("IP %x netmask %x gateway %x.\n",
            ntohl(ipaddr.addr), ntohl(netmask.addr), ntohl(gw.addr));

    netif = xmalloc(struct netif);

    netif_add(netif, &ipaddr, &netmask, &gw, rawmac,
              netif_netfront_init, ip_input);
    netif_set_default(netif);
    netif_set_up(netif);

    down(&tcpip_is_up);
  }

#ifdef CONFIG_SUSPEND
    tprintk("TCP/IP bringup begins.\n");
#endif
}
Example #26
0
static inline int InitLWIPStack(struct ip_addr *IP, struct ip_addr *NM, struct ip_addr *GW){
	static struct NetManNetProtStack stack={
		&LinkStateUp,
		&LinkStateDown,
		&AllocRxPacket,
		&FreeRxPacket,
		&EnQRxPacket,
		&FlushInputQueue
	};

	InitializeLWIP();

	netif_add(&NIF, IP, NM, GW, &NIF, &SMapIFInit, tcpip_input);
	netif_set_default(&NIF);

	NetManRegisterNetworkStack(&stack);
	netif_set_up(&NIF);

	return 0;
}
Example #27
0
int main(void)
#endif
{
  ip_addr_t fsl_netif0_ipaddr, fsl_netif0_netmask, fsl_netif0_gw;
  
  app_low_level_init();
  OSA_Init();
  
  LWIP_DEBUGF(PING_DEBUG,("TCP/IP initializing...\r\n"));  
  tcpip_init(NULL,NULL);
  LWIP_DEBUGF(PING_DEBUG,("TCP/IP initialized.\r\n"));

  IP4_ADDR(&fsl_netif0_ipaddr, 192,168,2,102);
  IP4_ADDR(&fsl_netif0_netmask, 255,255,255,0);
  IP4_ADDR(&fsl_netif0_gw, 192,168,2,100);

  netif_add(&fsl_netif0, &fsl_netif0_ipaddr, &fsl_netif0_netmask, &fsl_netif0_gw, NULL, ethernetif_init, tcpip_input);
  netif_set_default(&fsl_netif0);

  ping_init();
}
Example #28
0
/*********************************************************************************************************
** 函数名称: __rtSetGwCallback
** 功能描述: 设置网络接口的网关(在 TCPIP 上下文中执行)
** 输 入  : pipaddrGw     网关地址
**           uiGwFlags     网关设置属性
**           pcNetifName   网络接口名
** 输 出  : ERROR_NONE
** 全局变量: 
** 调用模块: 
*********************************************************************************************************/
static INT __rtSetGwCallback (ip_addr_t *pipaddrGw, UINT  uiGwFlags, CPCHAR  pcNetifName)
{
#define LW_RT_GW_FLAG_SET       0x1
#define LW_RT_GW_FLAG_DEFAULT   0x2

    struct netif  *pnetif = netif_find((PCHAR)pcNetifName);
    
    if (pnetif) {
        if (uiGwFlags & LW_RT_GW_FLAG_SET) {
            netif_set_gw(pnetif, pipaddrGw);
        }
        if (uiGwFlags & LW_RT_GW_FLAG_DEFAULT) {
            netif_set_default(pnetif);
        }
        return  (ERROR_NONE);
    
    } else {
        _ErrorHandle(ENXIO);
        return  (PX_ERROR);
    }
}
Example #29
0
/********************************************************************************
 * Name:
 *          netif_proto_init
 *
 * Description:
 *          the network card init call low_level_init()
 *
 * Parameter:
 *          netif:struct for network card
 *
 * Return:
 *          the status of init
 ********************************************************************************/
static void tcpip_init_done(void *arg)
{
#if LWIP_IPV4
    ip4_addr_t ipaddr, netmask, gw;
    memset(&ipaddr, 0, sizeof(ipaddr));
    memset(&netmask, 0, sizeof(netmask));
    memset(&gw, 0, sizeof(gw));
    netif_add(&lwip_netif, &ipaddr, &netmask, &gw, NULL, ethernetif_init, tcpip_input);
#endif

#if LWIP_IPV6
#if !LWIP_IPV4
    netif_add(&lwip_netif, NULL, ethernetif_init, tcpip_input);
#endif
    netif_create_ip6_linklocal_address(&lwip_netif, 1);
    lwip_netif.ip6_autoconfig_enabled = 1;
#endif

    netif_set_default(&lwip_netif);
    netif_set_up(&lwip_netif);
}
Example #30
0
void net_init(void) {
	memset(&ipaddr, 0, sizeof(ipaddr));
	memset(&netmask, 0, sizeof(ipaddr));
	memset(&gw, 0, sizeof(ipaddr));

	printf("Initializing network...\n");
	lwip_init();
	printf("lwIP Initialized\n");
	netif_add(&eth, &ipaddr, &netmask, &gw, NULL, gelicif_init, ethernet_input);
	netif_set_default(&eth);
	netif_set_up(&eth);
	printf("Ethernet interface initialized\n");
	printf("Starting DHCP\n");
	dhcp_start(&eth);

	u64 now = gettb();
#if LWIP_TCP
	last_tcp_time = now;
#endif
	last_arp_time = last_dhcp_coarse_time = last_dhcp_fine_time = now;
}