void set_factory_ip()
{
	struct ip_addr ipaddr, netmask, gw;
	
	
	memcpy(EEPROM_Data.BoxIPAddress, DEFAULT_Data.BoxIPAddress , 4);
	memcpy(EEPROM_Data.SubNetMask, DEFAULT_Data.SubNetMask , 4);
	memcpy(EEPROM_Data.GetwayAddress, DEFAULT_Data.GetwayAddress , 4);
	
	ipaddr.addr =  NGET32( EEPROM_Data.BoxIPAddress );
	netmask.addr = NGET32( EEPROM_Data.SubNetMask );
	gw.addr = NGET32( EEPROM_Data.GetwayAddress );

#if defined(WIRELESS_CARD) 
	if(WLanface != NULL){
	netif_set_ipaddr(WLanface, &ipaddr);
	netif_set_netmask(WLanface, &netmask);
	netif_set_gw(WLanface, &gw);
	}
#endif 
	
	netif_set_ipaddr(Lanface, &ipaddr);
	netif_set_netmask(Lanface, &netmask);
	netif_set_gw(Lanface, &gw);
	
	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);

}
void set_factory_ip()
{
	struct ip_addr ipaddr, netmask, gw;
	
	
	memcpy(EEPROM_Data.BoxIPAddress, DEFAULT_Data.BoxIPAddress , 4);
	memcpy(EEPROM_Data.SubNetMask, DEFAULT_Data.SubNetMask , 4);
	memcpy(EEPROM_Data.GetwayAddress, DEFAULT_Data.GetwayAddress , 4);
	
	ipaddr.addr =  get32( EEPROM_Data.BoxIPAddress );
	netmask.addr = get32( EEPROM_Data.SubNetMask );
	gw.addr = get32( EEPROM_Data.GetwayAddress );
		
#if 0	//ZOTIPS		
	netif_set_ipaddr(WLanface, &ipaddr);
	netif_set_netmask(WLanface, &netmask);
	netif_set_gw(WLanface, &gw);
#endif //ZOTIPS
	
	netif_set_ipaddr(Lanface, &ipaddr);
	netif_set_netmask(Lanface, &netmask);
	netif_set_gw(Lanface, &gw);
	
	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);

}
Example #3
0
static err_t dhcp_release(struct dhcp_state *state)
{
  err_t result;
  u16_t msecs;
  DEBUGF(DHCP_DEBUG, ("dhcp_release()\n"));
  // and idle DHCP client
  dhcp_set_state(state, DHCP_OFF);

  // create and initialize the DHCP message header
  result = dhcp_create_request(state);
  if (result == ERR_OK)
  {
    dhcp_option(state, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN);
    dhcp_option_byte(state, DHCP_RELEASE);

    dhcp_option_trailer(state);

    pbuf_realloc(state->p_out, sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + state->options_out_len);

    udp_bind(state->pcb, IP_ADDR_ANY, DHCP_CLIENT_PORT);
    udp_connect(state->pcb, &state->server_ip_addr, DHCP_SERVER_PORT);
    udp_send(state->pcb, state->p_out);
    dhcp_delete_request(state);
  }
  state->tries++;
  msecs = state->tries < 10 ? state->tries * 1000 : 10 * 1000;
  state->request_timeout = (msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS;
  DEBUGF(DHCP_DEBUG, ("dhcp_release(): request timeout %u msecs\n", msecs));
  // remove IP address from interface
  netif_set_ipaddr(state->netif, IP_ADDR_ANY);
  netif_set_gw(state->netif, IP_ADDR_ANY);
  netif_set_netmask(state->netif, IP_ADDR_ANY);
  return result;
}
Example #4
0
// This sets the IP configuration on-the-fly
void ethernet_set_configuration(IPAddress ipAddress, IPAddress netMask, IPAddress gateWay)
{
	if ((gs_net_if.flags & NETIF_FLAG_DHCP) != 0)
	{
		// stop DHCP if it was used before
		dhcp_stop(&gs_net_if);
	}

	struct ip_addr x_ip_addr, x_net_mask, x_gateway;
	x_ip_addr.addr = ipAddress.GetV4LittleEndian();
	x_net_mask.addr = netMask.GetV4LittleEndian();
	x_gateway.addr = gateWay.GetV4LittleEndian();

	if (x_ip_addr.addr == 0)
	{
		// start DHCP and request a dynamic IP address
		dhcp_start(&gs_net_if);
	}
	else
	{
		// use static IP address
		netif_set_ipaddr(&gs_net_if, &x_ip_addr);
		netif_set_netmask(&gs_net_if, &x_net_mask);
		netif_set_gw(&gs_net_if, &x_gateway);

		// don't forget to set it up again
		netif_set_up(&gs_net_if);
	}
}
Example #5
0
int netstack_set_ipmask(u8 *addr)
{
	ip_addr_t netmask;
	IP4_ADDR(&netmask, addr[0],addr[1],addr[2],addr[3]);
	netif_set_netmask(&lns.nif, &netmask);
	return VMM_OK;
}
Example #6
0
// This sets the IP configuration on-the-fly
void ethernet_set_configuration(const uint8_t ipAddress[], const uint8_t netMask[], const uint8_t gateWay[])
{
	if ((gs_net_if.flags & NETIF_FLAG_DHCP) != 0)
	{
		// stop DHCP if it was used before
		dhcp_stop(&gs_net_if);
	}

	struct ip_addr x_ip_addr, x_net_mask, x_gateway;
	IP4_ADDR(&x_ip_addr, ipAddress[0], ipAddress[1], ipAddress[2], ipAddress[3]);
	IP4_ADDR(&x_net_mask, netMask[0], netMask[1], netMask[2], netMask[3]);
	IP4_ADDR(&x_gateway, gateWay[0], gateWay[1], gateWay[2], gateWay[3]);

	if (x_ip_addr.addr == 0)
	{
		// start DHCP and request a dynamic IP address
		dhcp_start(&gs_net_if);
	}
	else
	{
		// use static IP address
		netif_set_ipaddr(&gs_net_if, &x_ip_addr);
		netif_set_netmask(&gs_net_if, &x_net_mask);
		netif_set_gw(&gs_net_if, &x_gateway);

		// don't forget to set it up again
		netif_set_up(&gs_net_if);
	}
}
Example #7
0
cmd_state_t
cmd_set_ip(int argc, char* argv[], void* ctx)
{
        struct net_cfg *ncfg = ctx;
        struct ip_addr lwip_addr;
        struct netif *nif = ncfg->netif;

        if (argc == 2 &&
            (strncmp(argv[1], "none", 4) == 0)) {
                ncfg->dhcp_enabled = 1;

                return CMD_DONE;
        }
        else if (argc != 4 ) {
                printk("usage: ip <ip> <netmask> <gateway-ip>\n");
                printk("  or : ip none (to enable DHCP)\n");
                return CMD_DONE;
        }
        /* IP address */
        lwip_addr = str2ip(argv[1]);
        netif_set_ipaddr(nif, &lwip_addr);
        /* Netmask */
        lwip_addr = str2ip(argv[2]);
        netif_set_netmask(nif, &lwip_addr);
        /* Default Gateway address */
        lwip_addr = str2ip(argv[3]);
        netif_set_gw(nif, &lwip_addr);
        /* Disable DHCP */
        ncfg->dhcp_enabled = 0;

        return CMD_DONE;
}
Example #8
0
void set_if(char* ip_addr, char* gw_addr, char* nm_addr)
{
	struct ip_addr *ip;
	struct in_addr addr;

	ip = (struct ip_addr *)&addr;

	/* set ip address */
	if ((ip_addr != RT_NULL) && inet_aton(ip_addr, &addr))
	{
		netif_set_ipaddr(netif_default, ip);
	}

	/* set gateway address */
	if ((gw_addr != RT_NULL) && inet_aton(gw_addr, &addr))
	{
		netif_set_gw(netif_default, ip);
	}

	/* set netmask address */
	if ((nm_addr != RT_NULL) && inet_aton(nm_addr, &addr))
	{
		netif_set_netmask(netif_default, ip);
	}
}
Example #9
0
/**
 * Change IP address configuration for a network interface (including netmask
 * and default gateway).
 *
 * @param netif the network interface to change
 * @param ipaddr the new IP address
 * @param netmask the new netmask
 * @param gw the new default gateway
 */
void
netif_set_addr(struct netif *netif, ip_addr_t *ipaddr, ip_addr_t *netmask,
    ip_addr_t *gw)
{
  netif_set_ipaddr(netif, ipaddr);
  netif_set_netmask(netif, netmask);
  netif_set_gw(netif, gw);
}
Example #10
0
/**
 * @ingroup netif_ip4
 * Change IP address configuration for a network interface (including netmask
 * and default gateway).
 *
 * @param netif the network interface to change
 * @param ipaddr the new IP address
 * @param netmask the new netmask
 * @param gw the new default gateway
 */
void
netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask,
    const ip4_addr_t *gw)
{
  if (ip4_addr_isany(ipaddr)) {
    /* when removing an address, we have to remove it *before* changing netmask/gw
       to ensure that tcp RST segment can be sent correctly */
    netif_set_ipaddr(netif, ipaddr);
    netif_set_netmask(netif, netmask);
    netif_set_gw(netif, gw);
  } else {
    netif_set_netmask(netif, netmask);
    netif_set_gw(netif, gw);
    /* set ipaddr last to ensure netmask/gw have been set when status callback is called */
    netif_set_ipaddr(netif, ipaddr);
  }
}
Example #11
0
void
netif_set_addr(struct netif *netif,struct ip_addr *ipaddr, struct ip_addr *netmask,
    struct ip_addr *gw)
{
  netif_set_ipaddr(netif, ipaddr);
  netif_set_netmask(netif, netmask);
  netif_set_gw(netif, gw);
}
Example #12
0
/**
 * Change IP address configuration for a network interface (including netmask
 * and default gateway).
 *
 * @param netif the network interface to change
 * @param ipaddr the new IP address
 * @param netmask the new netmask
 * @param gw the new default gateway
 */
void
netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask,
    const ip4_addr_t *gw)
{
  netif_set_netmask(netif, netmask);
  netif_set_gw(netif, gw);
  /* set ipaddr last to ensure netmask/gw have been set when status callback is called */
  netif_set_ipaddr(netif, ipaddr);
}
Example #13
0
void set_if(char* netif_name, char* ip_addr, char* gw_addr, char* nm_addr)
{
	struct ip_addr *ip;
	struct in_addr addr;
	struct netif * netif = netif_list;
	struct ip_param ipcfg;
	int netno;

	if(strlen(netif_name) > sizeof(netif->name)) {
		printf_syn("network interface name too long!\r\n");
		return;
	}

	netno = 0;
	while(netif != RT_NULL) {
		if(strncmp(netif_name, netif->name, sizeof(netif->name)) == 0)
			break;

		++netno;
		netif = netif->next;
		if( netif == RT_NULL ) {
			printf_syn("network interface: %s not found!\n", netif_name);
			return;
		}
	}

	read_syscfgdata_tbl(SYSCFGDATA_TBL_IPCFG, netno, &ipcfg);

	ip = (struct ip_addr *)&addr;

	/* set ip address */
	if ((ip_addr != RT_NULL) && inet_aton(ip_addr, &addr)) {
		netif_set_ipaddr(netif, ip);
		ipcfg.ipaddr.addr = ntohl(addr.s_addr);
	}

	/* set gateway address */
	if ((gw_addr != RT_NULL) && inet_aton(gw_addr, &addr)) {
		netif_set_gw(netif, ip);
		ipcfg.gw.addr = ntohl(addr.s_addr);
	}

	/* set netmask address */
	if ((nm_addr != RT_NULL) && inet_aton(nm_addr, &addr)) {
		netif_set_netmask(netif, ip);
		ipcfg.netmask.addr = ntohl(addr.s_addr);
	}

	write_syscfgdata_tbl(SYSCFGDATA_TBL_IPCFG, netno, &ipcfg);

	return;
}
Example #14
0
/**
 * Bind the interface to the offered IP address.
 *
 */
static void dhcp_bind(struct dhcp_state *state)
{
  struct ip_addr sn_mask, gw_addr;
  dhcp_set_state(state, DHCP_BOUND);

  if (state->offered_t1_renew != 0xffffffffUL)
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_bind(): t1 renewal timer %u secs\n", state->offered_t1_renew));
    state->t1_timeout = (state->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
    if (state->t1_timeout == 0) state->t1_timeout = 1;
    DEBUGF(DHCP_DEBUG, ("dhcp_bind(): request timeout %u msecs\n", state->offered_t1_renew*1000));
  }
  if (state->offered_t2_rebind != 0xffffffffUL)
  {
    DEBUGF(DHCP_DEBUG, ("dhcp_bind(): t2 rebind timer %u secs\n", state->offered_t2_rebind));
    state->t2_timeout = (state->offered_t2_rebind + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS;
    if (state->t2_timeout == 0) state->t2_timeout = 1;
    DEBUGF(DHCP_DEBUG, ("dhcp_bind(): request timeout %u msecs\n", state->offered_t2_rebind*1000));
  }

  ip_addr_set(&sn_mask, &state->offered_sn_mask);
  // subnet mask not given
  if (sn_mask.addr == 0)
  {
    // choose a safe subnet mask given the network class
    u8_t first_octet = ip4_addr1(&sn_mask);
    if (first_octet <= 127) sn_mask.addr = htonl(0xff000000);
    else if (first_octet >= 192) sn_mask.addr = htonl(0xffffff00);
    else sn_mask.addr = htonl(0xffff0000);
  }
  DEBUGF(DHCP_DEBUG, ("dhcp_bind(): SN: 0x%08x\n", sn_mask.addr));
  netif_set_netmask(state->netif, &sn_mask);

  ip_addr_set(&gw_addr, &state->offered_gw_addr);
  // gateway address not given
  if (gw_addr.addr == 0)
  {
    gw_addr.addr &= sn_mask.addr;
    gw_addr.addr |= 0x01000000;
  }
  DEBUGF(DHCP_DEBUG, ("dhcp_bind(): GW: 0x%08x\n", gw_addr.addr));
  netif_set_gw(state->netif, &gw_addr);

  DEBUGF(DHCP_DEBUG, ("dhcp_bind(): IP: 0x%08x\n", state->offered_ip_addr.addr));
  netif_set_ipaddr(state->netif, &state->offered_ip_addr);

  l4e_printf("dhcp: %hd.%hd.%hd.%hd/%hd.%hd.%hd.%hd, gw %hd.%hd.%hd.%hd\n",
      ip_split(&state->offered_ip_addr), ip_split(&sn_mask),
      ip_split(&gw_addr));
}
Example #15
0
void set_if(char* netif_name, char* ip_addr, char* gw_addr, char* nm_addr)
{
    struct ip_addr *ip;
    struct in_addr addr;
    struct netif * netif = netif_list;

    if(strlen(netif_name) > sizeof(netif->name))
    {
        printf("network interface name too long!\r\n");
        return;
    }

    while(netif != NULL)
    {
        if(strncmp(netif_name, netif->name, sizeof(netif->name)) == 0)
            break;

        netif = netif->next;
        if( netif == NULL )
        {
            printf("network interface: %s not found!\r\n", netif_name);
            return;
        }
    }

    ip = (struct ip_addr *)&addr;

    /* set ip address */
    if ((ip_addr != NULL) && inet_aton(ip_addr, &addr))
    {
        netif_set_ipaddr(netif, ip);
    }

    /* set gateway address */
    if ((gw_addr != NULL) && inet_aton(gw_addr, &addr))
    {
        netif_set_gw(netif, ip);
    }

    /* set netmask address */
    if ((nm_addr != NULL) && inet_aton(nm_addr, &addr))
    {
        netif_set_netmask(netif, ip);
    }
}
Example #16
0
int
ps2ip_setconfig(t_ip_info* pInfo)
{
	NetIF*	pNetIF=netif_find(pInfo->netif_name);

	if	(pNetIF==NULL)
	{
		return	0;
	}
	netif_set_ipaddr(pNetIF,(IPAddr*)&pInfo->ipaddr);
	netif_set_netmask(pNetIF,(IPAddr*)&pInfo->netmask);
	netif_set_gw(pNetIF,(IPAddr*)&pInfo->gw);

#if	LWIP_DHCP

	//Enable dhcp here

	if (pInfo->dhcp_enabled)
	{
		if (!pNetIF->dhcp)
		{

			//Start dhcp client

			dhcp_start(pNetIF);
		}
	}
	else
	{
		if (pNetIF->dhcp)
		{

			//Stop dhcp client

			dhcp_stop(pNetIF);
		}
	}

#endif

	return	1;
}
Example #17
0
/**
 * 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;
    struct ip_addr sn_mask, gw_addr;

    LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
                ("autoip_bind(netif=%p) %c%c%"U16_F" 0x%08"X32_F"\n",
                 (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num, autoip->llipaddr.addr));

    IP4_ADDR(&sn_mask, 255, 255, 0, 0);
    IP4_ADDR(&gw_addr, 0, 0, 0, 0);

    netif_set_ipaddr(netif, &autoip->llipaddr);
    netif_set_netmask(netif, &sn_mask);
    netif_set_gw(netif, &gw_addr);

    /* bring the interface up */
    netif_set_up(netif);

    return ERR_OK;
}
Example #18
0
/**
 * Configure interface for use with current LL IP-Address
 *
 * @param netif network interface to configure with current LL IP-Address
 */
static err_t ICACHE_FLASH_ATTR
autoip_bind(struct netif *netif)
{
  struct autoip *autoip = netif->autoip;
  ip_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_ipaddr(netif, &autoip->llipaddr);
  netif_set_netmask(netif, &sn_mask);
  netif_set_gw(netif, &gw_addr);  

  /* bring the interface up */
  netif_set_up(netif);

  return ERR_OK;
}
Example #19
0
static void nic_ioctl_set_conf(__unused struct socket * sock,
				struct nic * nic,
				message * m)
{
	nwio_ipconf_t ipconf;
	int err;

	err = copy_from_user(m->m_source, &ipconf, sizeof(ipconf),
				(cp_grant_id_t) m->IO_GRANT, 0);
	if (err != OK)
		send_reply(m, err);

	if (ipconf.nwic_flags & NWIC_IPADDR_SET)
		netif_set_ipaddr(&nic->netif,
				(ip_addr_t *)&ipconf.nwic_ipaddr);
	if (ipconf.nwic_flags & NWIC_NETMASK_SET)
		netif_set_netmask(&nic->netif,
				(ip_addr_t *)&ipconf.nwic_netmask);
	nic->flags = ipconf.nwic_flags;
	if (nic->flags & NWEO_EN_BROAD)
		nic->netif.flags |= NETIF_FLAG_BROADCAST;
	
	send_reply(m, OK);
}
Example #20
0
int main(int argc, char *argv[])
{
	int c;
	int keep_alive;
	int non_local;
	struct netif *netif;
	int dns_count;
	char *str;
	char *endptr;
	int mtu;
	int fd_in;
	int fd_out;
	ip4_addr_t ipaddr;
	ip4_addr_t netmask;
	ip4_addr_t gateway;
	ip4_addr_t dns;
	struct event_base *base;
	char *pcap_file;
	struct conn_info *local;
	struct conn_info *remote;
	struct conn_info *socks;
	struct conn_info *info;

	ip_addr_set_zero(&ipaddr);
	ip_addr_set_zero(&netmask);
	ip_addr_set_zero(&gateway);

	local = remote = socks = NULL;
	dns_count = 0;
	keep_alive = 0;
	fd_in = 0;
	fd_out = 1;
	mtu = 0;
	pcap_file = NULL;
	non_local = 0;

	signal(SIGPIPE, SIG_IGN);

	base = event_base_new();
	lwip_init();
	libevent_timeouts_init(base);

	if ((str = getenv("INTERNAL_IP4_ADDRESS")))
		ip4addr_aton(str, &ipaddr);

	if ((str = getenv("INTERNAL_IP4_MTU")))
		mtu = strtoul(str, NULL, 0);

	if ((str = getenv("VPNFD")))
		fd_in = fd_out = strtoul(str, NULL, 0);

	if ((str = getenv("CISCO_DEF_DOMAIN"))) {
		endptr = str;
		while ((str = tokenize(endptr, ", ", &endptr)))
			host_add_search(str);
	}

	if ((str = getenv("INTERNAL_IP4_DNS")))	{
		endptr = str;
		while ((str = tokenize(endptr, ", ", &endptr))) {
			ip4addr_aton(str, &dns);
			dns_setserver(dns_count++, &dns);
			free(str);
		}
	}

	while ((c = getopt(argc, argv, "L:D:R:k:m:s:d:i:n:G:p:gh")) != -1) {

		switch (c) {
		case 'L':
			info = parse_conn_info(optarg, 4);
			if (!info)
				print_usage(argv[0]);

			info->next = local;
			local = info;
			break;
		case 'D':
			info = parse_conn_info(optarg, 2);
			if (!info)
				print_usage(argv[0]);

			info->next = socks;
			socks = info;
			break;
		case 'R':
			info = parse_conn_info(optarg, 4);
			if (!info)
				print_usage(argv[0]);

			info->next = remote;
			remote = info;
			break;
		case 'k':
			keep_alive = strtoul(optarg, &endptr, 0);
			if (*endptr)
				print_usage(argv[0]);
			keep_alive *= 1000;
			break;
		case 'm':
			mtu = strtoul(optarg, &endptr, 0);
			if (*endptr)
				print_usage(argv[0]);
			break;
		case 's':
			while ((str = tokenize(optarg, ", ", &optarg)))
				host_add_search(str);
			break;
		case 'd':
			while ((str = tokenize(optarg, ", ", &optarg))) {
				ip4addr_aton(str, &dns);
				dns_setserver(dns_count++, &dns);
				free(str);
			}
			break;
		case 'i':
			ip4addr_aton(optarg, &ipaddr);
			break;
		case 'n':
			ip4addr_aton(optarg, &netmask);
			break;
		case 'G':
			ip4addr_aton(optarg, &gateway);
			break;
#ifdef USE_PCAP
		case 'p':
			pcap_file = strdup(optarg);
			break;
#endif
		case 'g':
			non_local = 1;
			break;
		default:
			print_usage(argv[0]);
		}
	}

	while (local) {
		info = local;
		str = info->bind && info->bind[0] ? info->bind : NULL;
		if (!non_local)
			str = str ? : "localhost";

		if (forward_local(base, str, info->bind_port,
			info->host, info->host_port, keep_alive) < 0)
			return -1;

		local = info->next;
		free_conn_info(info);
	}

	while (socks) {
		info = socks;
		str = info->bind && info->bind[0] ? info->bind : NULL;
		if (!non_local)
			str = str ? : "localhost";
		if (socks_listen(base, str, info->bind_port, keep_alive) < 0)
			return -1;
		socks = socks->next;
		free_conn_info(info);
	}

	while (remote) {
		info = remote;
		if (forward_remote(base, info->bind_port, info->host,
					info->host_port, keep_alive) < 0)
			return -1;
		remote = info->next;
		free_conn_info(info);
	}

	netif = tunif_add(base, fd_in, fd_out, pcap_file);

	netif_set_ipaddr(netif, &ipaddr);
	netif_set_netmask(netif, &netmask);
	netif_set_gw(netif, &gateway);
	if (mtu)
		netif->mtu = mtu;
	netif_set_up(netif);

	event_base_dispatch(base);

	return 0;
}
/*
 * Set the IP, mask and gateway of the IF
 */
void networking_set_addr(struct ip_addr *ipaddr, struct ip_addr *netmask, struct ip_addr *gw)
{
  netif_set_ipaddr(the_interface, ipaddr);
  netif_set_netmask(the_interface, netmask);
  netif_set_gw(the_interface, gw);
}