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);
}
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;
}
// 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);
}
}
int netstack_set_ipaddr(u8 *addr)
{
ip_addr_t ipaddr;
IP4_ADDR(&ipaddr, addr[0],addr[1],addr[2],addr[3]);
netif_set_ipaddr(&lns.nif, &ipaddr);
return VMM_OK;
}
// 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);
}
}
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;
}
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);
}
}
/**
* 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);
}
/**
* @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);
}
}
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);
}
/**
* 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);
}
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;
}
/**
* 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));
}
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);
}
}
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;
}
/**
* 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;
}
/**
* 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;
}
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);
}
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);
}
