static void NetInitLoop(void) { NetOurIP = string_to_ip("10.0.0.179"); NetOurGatewayIP = string_to_ip("10.0.0.254"); NetOurSubnetMask = string_to_ip("255.255.255.0"); NetServerIP = string_to_ip("10.0.0.128"); memcpy(NetOurEther, eth_get_dev()->enetaddr, 6); }
int do_sntp (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *toff; if (argc < 2) { NetNtpServerIP = getenv_IPaddr ("ntpserverip"); if (NetNtpServerIP == 0) { printf ("ntpserverip not set\n"); return (1); } } else { NetNtpServerIP = string_to_ip(argv[1]); if (NetNtpServerIP == 0) { printf ("Bad NTP server IP address\n"); return (1); } } toff = getenv ("timeoffset"); if (toff == NULL) NetTimeOffset = 0; else NetTimeOffset = simple_strtol (toff, NULL, 10); if (NetLoop(SNTP) < 0) { printf("SNTP failed: host %pI4 not responding\n", &NetNtpServerIP); return 1; } return 0; }
static int sb_with_async_ping_handler(struct udevice *dev, void *packet, unsigned int len) { struct eth_sandbox_priv *priv = dev_get_priv(dev); struct ethernet_hdr *eth = packet; struct arp_hdr *arp = packet + ETHER_HDR_SIZE; int ret; /* * If we are about to generate a reply to ARP, first inject a request * from another host */ if (ntohs(eth->et_protlen) == PROT_ARP && ntohs(arp->ar_op) == ARPOP_REQUEST) { /* Make sure sandbox_eth_recv_arp_req() knows who is asking */ priv->fake_host_ipaddr = string_to_ip("1.1.2.4"); ret = sandbox_eth_recv_ping_req(dev); if (ret) return ret; } sandbox_eth_arp_req_to_reply(dev, packet, len); sandbox_eth_ping_req_to_reply(dev, packet, len); return sb_check_ping_reply(dev, packet, len); }
IPaddr_t resolv(char *host) { IPaddr_t ip; const char *ns; if (!string_to_ip(host, &ip)) return ip; dns_ip = 0; dns_state = STATE_INIT; ns = getenv("net.nameserver"); if (!ns || !*ns) { printk("%s: no nameserver specified in $net.nameserver\n", __func__); return 0; } if (string_to_ip(ns, &ip)) return 0; debug("resolving host %s via nameserver %s\n", host, ip_to_string(ip)); dns_con = net_udp_new(ip, DNS_PORT, dns_handler, NULL); if (IS_ERR(dns_con)) return PTR_ERR(dns_con); dns_timer_start = get_time_ns(); dns_send(host); while (dns_state != STATE_DONE) { if (ctrlc()) { break; } net_poll(); if (is_timeout(dns_timer_start, SECOND)) { dns_timer_start = get_time_ns(); printf("T "); dns_send(host); } } net_unregister(dns_con); return dns_ip; }
int main(void) { int t = string_to_ip (temp); printf ("%x\n", t); printf ("%x\n", result); if (t != result) __builtin_abort (); printf ("WORKS.\n"); return 0; }
/* add_nameserver() * * input - either an IPV4 address in dotted quad * or an IPV6 address in : format * output - NONE * side effects - entry in irc_nsaddr_list is filled in as needed */ static void add_nameserver(const char *arg) { /* Done max number of nameservers? */ if (irc_nscount >= IRCD_MAXNS) return; string_to_ip(arg, 53, &irc_nsaddr_list[irc_nscount]); irc_nscount++; }
static int on_dnsip(const char *name, const char *value, enum env_op op, int flags) { if (flags & H_PROGRAMMATIC) return 0; net_dns_server = string_to_ip(value); return 0; }
static int on_netmask(const char *name, const char *value, enum env_op op, int flags) { if (flags & H_PROGRAMMATIC) return 0; net_netmask = string_to_ip(value); return 0; }
void ICACHE_FLASH_ATTR wifi_init() { /*** Connect to WiFi ***/ wifi_set_opmode(STATION_MODE); wifi_station_disconnect(); char ssid[32] = WIFI_SSID; char pass[64] = WIFI_PASS; struct station_config sta_conf; sta_conf.bssid_set = 0; os_memcpy(&sta_conf.ssid, ssid, 32); os_memcpy(&sta_conf.password, pass, 64); wifi_station_set_config(&sta_conf); wifi_station_connect(); /*** Network configuration ***/ wifi_station_dhcpc_stop(); struct ip_info ip_conf; ip_conf.ip.addr = string_to_ip(IP_ADDR); ip_conf.netmask.addr = string_to_ip(IP_SUBNET); wifi_set_ip_info(STATION_IF, &ip_conf); }
static int dm_test_net_retry(struct unit_test_state *uts) { int retval; net_ping_ip = string_to_ip("1.1.2.2"); retval = _dm_test_net_retry(uts); /* Restore the env */ env_set("netretry", NULL); sandbox_eth_disable_response(1, false); return retval; }
static int dm_test_eth_async_ping_reply(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); sandbox_eth_set_tx_handler(0, sb_with_async_ping_handler); /* Used by all of the ut_assert macros in the tx_handler */ sandbox_eth_set_priv(0, uts); env_set("ethact", "eth@10002000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); sandbox_eth_set_tx_handler(0, NULL); return 0; }
static int sb_eth_raw_start(struct udevice *dev) { struct eth_sandbox_raw_priv *priv = dev_get_priv(dev); struct eth_pdata *pdata = dev_get_platdata(dev); int ret; debug("eth_sandbox_raw: Start\n"); ret = sandbox_eth_raw_os_start(priv, pdata->enetaddr); if (priv->local) { env_set("ipaddr", "127.0.0.1"); env_set("serverip", "127.0.0.1"); net_ip = string_to_ip("127.0.0.1"); net_server_ip = net_ip; } return ret; }
/** * This test case is trying to test the following scenario: * - All ethernet devices are not probed * - "ethaddr" for all ethernet devices are not set * - "ethact" is set to a valid ethernet device name * * With Sandbox default test configuration, all ethernet devices are * probed after power-up, so we have to manually create such scenario: * - Remove all ethernet devices * - Remove all "ethaddr" environment variables * - Set "ethact" to the first ethernet device * * Do a ping test to see if anything goes wrong. */ static int dm_test_eth_act(struct unit_test_state *uts) { struct udevice *dev[DM_TEST_ETH_NUM]; const char *ethname[DM_TEST_ETH_NUM] = {"eth@10002000", "eth@10003000", "sbe5", "eth@10004000"}; const char *addrname[DM_TEST_ETH_NUM] = {"ethaddr", "eth5addr", "eth3addr", "eth1addr"}; char ethaddr[DM_TEST_ETH_NUM][18]; int i; memset(ethaddr, '\0', sizeof(ethaddr)); net_ping_ip = string_to_ip("1.1.2.2"); /* Prepare the test scenario */ for (i = 0; i < DM_TEST_ETH_NUM; i++) { ut_assertok(uclass_find_device_by_name(UCLASS_ETH, ethname[i], &dev[i])); ut_assertok(device_remove(dev[i], DM_REMOVE_NORMAL)); /* Invalidate MAC address */ strncpy(ethaddr[i], env_get(addrname[i]), 17); /* Must disable access protection for ethaddr before clearing */ env_set(".flags", addrname[i]); env_set(addrname[i], NULL); } /* Set ethact to "eth@10002000" */ env_set("ethact", ethname[0]); /* Segment fault might happen if something is wrong */ ut_asserteq(-ENODEV, net_loop(PING)); for (i = 0; i < DM_TEST_ETH_NUM; i++) { /* Restore the env */ env_set(".flags", addrname[i]); env_set(addrname[i], ethaddr[i]); /* Probe the device again */ ut_assertok(device_probe(dev[i])); } env_set(".flags", NULL); env_set("ethact", NULL); return 0; }
static int dm_test_eth(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); env_set("ethact", "eth@10002000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); env_set("ethact", "eth@10003000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10003000", env_get("ethact")); env_set("ethact", "eth@10004000"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); return 0; }
int do_ping (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { if (argc < 2) return -1; NetPingIP = string_to_ip(argv[1]); if (NetPingIP == 0) return cmd_usage(cmdtp); if (NetLoop(PING) < 0) { printf("ping failed; host %s is not alive\n", argv[1]); return 1; } printf("host %s is alive\n", argv[1]); return 0; }
int do_radio (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { IPaddr_t ser_ip; unsigned short ser_port; if (argc != 3) { printf("Wrong arguments!\n"); return -1; } ser_ip = string_to_ip(argv[1]); ser_port = (unsigned short)simple_strtoul(argv[2], NULL, 10); printf("Reading data from %s:%d\n", argv[1], ser_port); printf("Radio...\n"); return 0; }
static int dm_test_eth_prime(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); /* Expected to be "eth@10003000" because of ethprime variable */ env_set("ethact", NULL); env_set("ethprime", "eth5"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10003000", env_get("ethact")); /* Expected to be "eth@10002000" because it is first */ env_set("ethact", NULL); env_set("ethprime", NULL); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); return 0; }
/* * Write backplane ip-address... */ int do_get_bpip(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *buf; ulong crc; char str[32]; char *ptr; IPaddr_t ipaddr; buf = malloc(CONFIG_ENV_SIZE_2); if (eeprom_read(CONFIG_SYS_I2C_EEPROM_ADDR_2, 0, (uchar *)buf, CONFIG_ENV_SIZE_2)) puts("\nError reading backplane EEPROM!\n"); else { crc = crc32(0, (uchar *)(buf+4), CONFIG_ENV_SIZE_2 - 4); if (crc != *(ulong *)buf) { printf("ERROR: crc mismatch %08lx %08lx\n", crc, *(ulong *)buf); return -1; } /* * Find bp_ip */ ptr = strstr(buf+4, "bp_ip="); if (ptr == NULL) { printf("ERROR: bp_ip not found!\n"); return -1; } ptr += 6; ipaddr = string_to_ip(ptr); /* * Update whole ip-addr */ sprintf(str, "%pI4", &ipaddr); setenv("ipaddr", str); printf("Updated ip_addr from bp_eeprom to %s!\n", str); } free(buf); return 0; }
int do_ping (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { if (argc < 2) return -1; #ifdef UIP_CONF_IPV6 if (strcmp(argv[1], "-6") == 0) { uip_ipaddr_t DestIpv6; if (argc < 3) return -1; if (!inet_pton6(argv[2], (unsigned char*)&DestIpv6)) { printf("Invalid host address \n"); return -1; } if (!ping6(&DestIpv6)) { printf("ping failed; host %s is not alive\n", argv[2]); return 1; } printf("host %s is alive\n", argv[2]); return 0; } else { #endif NetPingIP = string_to_ip(argv[1]); if (NetPingIP == 0) { printf ("Usage:\n%s\n", cmdtp->usage); return -1; } if (NetLoop(PING) < 0) { printf("ping failed; host %s is not alive\n", argv[1]); return 1; } printf("host %s is alive\n", argv[1]); return 0; #ifdef UIP_CONF_IPV6 } #endif }
int do_ping(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { if(argc < 2) { #ifdef CFG_LONGHELP if(cmdtp->help != NULL) { printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->help); } else { printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage); } #else printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage); #endif return(-1); } NetPingIP = string_to_ip(argv[1]); if (NetPingIP == 0) { #ifdef CFG_LONGHELP if(cmdtp->help != NULL) { printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->help); } else { printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage); } #else printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage); #endif return(-1); } if(NetLoop(PING) < 0) { printf("\n## Error: ping failed, host %s is not alive!\n\n", argv[1]); return(1); } printf("\nPing OK, host %s is alive!\n\n", argv[1]); return(0); }
static int dm_test_eth_alias(struct unit_test_state *uts) { net_ping_ip = string_to_ip("1.1.2.2"); env_set("ethact", "eth0"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); env_set("ethact", "eth1"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10004000", env_get("ethact")); /* Expected to fail since eth2 is not defined in the device tree */ env_set("ethact", "eth2"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10002000", env_get("ethact")); env_set("ethact", "eth5"); ut_assertok(net_loop(PING)); ut_asserteq_str("eth@10003000", env_get("ethact")); return 0; }
static int nc_remoteip_set(struct device_d *dev, struct param_d *param, const char *val) { struct nc_priv *priv = g_priv; IPaddr_t ip; int ret; if (!val) dev_param_set_generic(dev, param, NULL); if (string_to_ip(val, &ip)) return -EINVAL; priv->ip = ip; ret = nc_init(); if (ret) return ret; dev_param_set_generic(dev, param, val); return 0; }
static int dm_test_eth_rotate(struct unit_test_state *uts) { char ethaddr[18]; int retval; /* Set target IP to mock ping */ net_ping_ip = string_to_ip("1.1.2.2"); /* Invalidate eth1's MAC address */ memset(ethaddr, '\0', sizeof(ethaddr)); strncpy(ethaddr, env_get("eth1addr"), 17); /* Must disable access protection for eth1addr before clearing */ env_set(".flags", "eth1addr"); env_set("eth1addr", NULL); retval = _dm_test_eth_rotate1(uts); /* Restore the env */ env_set("eth1addr", ethaddr); env_set("ethrotate", NULL); if (!retval) { /* Invalidate eth0's MAC address */ strncpy(ethaddr, env_get("ethaddr"), 17); /* Must disable access protection for ethaddr before clearing */ env_set(".flags", "ethaddr"); env_set("ethaddr", NULL); retval = _dm_test_eth_rotate2(uts); /* Restore the env */ env_set("ethaddr", ethaddr); } /* Restore the env */ env_set(".flags", NULL); return retval; }
int do_sntp(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { char *toff; if(argc < 2) { #ifdef CFG_LONGHELP if(cmdtp->help != NULL) { printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->help); } else { printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage); } #else printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage); #endif return(-1); } else { NetNtpServerIP = string_to_ip(argv[1]); if(NetNtpServerIP == 0) { printf("## Error: bad SNTP server IP address\n"); return(1); } } toff = getenv("timeoffset"); if(toff == NULL) { NetTimeOffset = 0; } else { NetTimeOffset = simple_strtol(toff, NULL, 10); } if(NetLoop(SNTP) < 0) { printf("## Error: SNTP host %s not responding\n", argv[1]); return(1); } return(0); }
static int sb_check_arp_reply(struct udevice *dev, void *packet, unsigned int len) { struct eth_sandbox_priv *priv = dev_get_priv(dev); struct ethernet_hdr *eth = packet; struct arp_hdr *arp; /* Used by all of the ut_assert macros */ struct unit_test_state *uts = priv->priv; if (ntohs(eth->et_protlen) != PROT_ARP) return 0; arp = packet + ETHER_HDR_SIZE; if (ntohs(arp->ar_op) != ARPOP_REPLY) return 0; /* This test would be worthless if we are not waiting */ ut_assert(arp_is_waiting()); /* Validate response */ ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0); ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0); ut_assert(eth->et_protlen == htons(PROT_ARP)); ut_assert(arp->ar_hrd == htons(ARP_ETHER)); ut_assert(arp->ar_pro == htons(PROT_IP)); ut_assert(arp->ar_hln == ARP_HLEN); ut_assert(arp->ar_pln == ARP_PLEN); ut_assert(memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) == 0); ut_assert(net_read_ip(&arp->ar_spa).s_addr == net_ip.s_addr); ut_assert(memcmp(&arp->ar_tha, priv->fake_host_hwaddr, ARP_HLEN) == 0); ut_assert(net_read_ip(&arp->ar_tpa).s_addr == string_to_ip("1.1.2.4").s_addr); return 0; }
static int sb_check_ping_reply(struct udevice *dev, void *packet, unsigned int len) { struct eth_sandbox_priv *priv = dev_get_priv(dev); struct ethernet_hdr *eth = packet; struct ip_udp_hdr *ip; struct icmp_hdr *icmp; /* Used by all of the ut_assert macros */ struct unit_test_state *uts = priv->priv; if (ntohs(eth->et_protlen) != PROT_IP) return 0; ip = packet + ETHER_HDR_SIZE; if (ip->ip_p != IPPROTO_ICMP) return 0; icmp = (struct icmp_hdr *)&ip->udp_src; if (icmp->type != ICMP_ECHO_REPLY) return 0; /* This test would be worthless if we are not waiting */ ut_assert(arp_is_waiting()); /* Validate response */ ut_assert(memcmp(eth->et_src, net_ethaddr, ARP_HLEN) == 0); ut_assert(memcmp(eth->et_dest, priv->fake_host_hwaddr, ARP_HLEN) == 0); ut_assert(eth->et_protlen == htons(PROT_IP)); ut_assert(net_read_ip(&ip->ip_src).s_addr == net_ip.s_addr); ut_assert(net_read_ip(&ip->ip_dst).s_addr == string_to_ip("1.1.2.4").s_addr); return 0; }
/* * Adds or deletes an IP address on an interface. * * Action is one of: * - RTM_NEWADDR (to add a new address) * - RTM_DELADDR (to delete an existing address) * * Returns zero on success and negative errno on failure. */ int ifc_act_on_address(int action, const char *name, const char *address, int prefixlen) { int ifindex, s, len, ret; struct sockaddr_storage ss; void *addr; size_t addrlen; struct { struct nlmsghdr n; struct ifaddrmsg r; // Allow for IPv6 address, headers, and padding. char attrbuf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) + NLMSG_ALIGN(sizeof(struct rtattr)) + NLMSG_ALIGN(INET6_ADDRLEN)]; } req; struct rtattr *rta; struct nlmsghdr *nh; struct nlmsgerr *err; char buf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) + NLMSG_ALIGN(sizeof(struct nlmsgerr)) + NLMSG_ALIGN(sizeof(struct nlmsghdr))]; // Get interface ID. ifindex = if_nametoindex(name); if (ifindex == 0) { return -errno; } // Convert string representation to sockaddr_storage. ret = string_to_ip(address, &ss); if (ret) { return ret; } // Determine address type and length. if (ss.ss_family == AF_INET) { struct sockaddr_in *sin = (struct sockaddr_in *) &ss; addr = &sin->sin_addr; addrlen = INET_ADDRLEN; } else if (ss.ss_family == AF_INET6) { struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss; addr = &sin6->sin6_addr; addrlen = INET6_ADDRLEN; } else { return -EAFNOSUPPORT; } // Fill in netlink structures. memset(&req, 0, sizeof(req)); // Netlink message header. req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.r)); req.n.nlmsg_type = action; req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK; req.n.nlmsg_pid = getpid(); // Interface address message header. req.r.ifa_family = ss.ss_family; req.r.ifa_prefixlen = prefixlen; req.r.ifa_index = ifindex; // Routing attribute. Contains the actual IP address. rta = (struct rtattr *) (((char *) &req) + NLMSG_ALIGN(req.n.nlmsg_len)); rta->rta_type = IFA_LOCAL; rta->rta_len = RTA_LENGTH(addrlen); req.n.nlmsg_len = NLMSG_ALIGN(req.n.nlmsg_len) + RTA_LENGTH(addrlen); memcpy(RTA_DATA(rta), addr, addrlen); s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (send(s, &req, req.n.nlmsg_len, 0) < 0) { close(s); return -errno; } len = recv(s, buf, sizeof(buf), 0); close(s); if (len < 0) { return -errno; } // Parse the acknowledgement to find the return code. nh = (struct nlmsghdr *) buf; if (!NLMSG_OK(nh, (unsigned) len) || nh->nlmsg_type != NLMSG_ERROR) { return -EINVAL; } err = NLMSG_DATA(nh); // Return code is negative errno. return err->error; }
void env_relocate(bd_t *bd) { char *s, *e; int reg; bd->bi_env = malloc(sizeof(env_t)); if (board_env_copy(bd, bd->bi_env, sizeof(env_t)) < 0) { printf("*** Using default environment\n"); memcpy(bd->bi_env_data, default_environment, sizeof(default_environment)); bd->bi_env_crc = crc32(0, bd->bi_env_data, sizeof(bd->bi_env_data)); } /* now initialise some variables */ /* MAC address */ s = getenv(bd, "ethaddr"); for (reg=0; reg<6; reg++) { bd->bi_enetaddr[reg] = s ? simple_strtoul(s, &e, 16) : 0; if (s) s = (*e) ? e+1 : e; } #if (CONFIG_COMMANDS & CFG_CMD_NET) /* IP address */ s = getenv(bd, "ipaddr"); bd->bi_ip_addr = string_to_ip(s); #endif if ((s = getenv(bd, "loadaddr")) != NULL) { load_addr = simple_strtoul(s, NULL, 16); } if ((s = getenv(bd, "pagelength")) != NULL) { pagelength = simple_strtoul(s, NULL, 10); } #if (CONFIG_COMMANDS & CFG_CMD_NET) if ((s = getenv(bd, "bootfile")) != NULL) { copy_filename (BootFile, s, sizeof(BootFile)); } #endif /* CFG_CMD_NET */ #ifdef CONFIG_KEYBOARD if ((s = getenv(bd, "keymap")) != NULL) { kbd_mapping (s); } #endif /* CONFIG_KEYBOARD */ #ifdef CONFIG_ADJUST_LCD if ((s = getenv(bd, "contrast")) != NULL) { lcd_contrast(simple_strtoul(s, NULL, 10)); } if ((s = getenv(bd, "brightness")) != NULL) { lcd_brightness(simple_strtoul(s, NULL, 10)); } #endif /* CONFIG_ADJUST_LCD */ }
int _do_setenv (bd_t *bd, int flag, int argc, char *argv[]) { int i, len, oldval; uchar *env, *nxt = 0; uchar *name; /* need writable copy in RAM */ if (!bd->bi_env_data) return 1; name = argv[1]; /* * search if variable with this name already exists */ oldval = -1; for (env = bd->bi_env_data; *env; env = nxt+1) { for (nxt = env; *nxt; ++nxt) ; if ((oldval = envmatch(bd, name, (ulong)env - (ulong)bd->bi_env_data)) >= 0) break; } /* * Delete any existing definition */ if (oldval >= 0) { #ifndef CONFIG_ENV_OVERWRITE /* * Ethernet Address and serial# can be set only once */ if ( (strcmp (name, "serial#") == 0) || ((strcmp (name, "ethaddr") == 0) # if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR) && (strcmp (get_env_addr(bd, oldval),MK_STR(CONFIG_ETHADDR)) != 0) # endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */ ) ) { printf ("Can't overwrite \"%s\"\n", name); return 1; } #endif /* * Switch to new baudrate if new baudrate is supported */ if (strcmp(argv[1],"baudrate") == 0) { int baudrate = simple_strtoul(argv[2], NULL, 10); int i; for (i=0; i<N_BAUDRATES; ++i) { if (baudrate == baudrate_table[i]) break; } if (i == N_BAUDRATES) { printf ("## Baudrate %d bps not supported\n", baudrate); return 1; } printf ("## Switch baudrate to %d bps and press ENTER ...\n", baudrate); udelay(50000); serial_setbrg (bd, baudrate); udelay(50000); for (;;) { if (getc() == '\r') break; } bd->bi_baudrate = baudrate; } if (*++nxt == '\0') { if ((ulong)env > (ulong)bd->bi_env_data) { env--; } else { *env = '\0'; } } else { for (;;) { *env = *nxt++; if ((*env == '\0') && (*nxt == '\0')) break; ++env; } } *++env = '\0'; } /* Delete only ? */ if ((argc < 3) || argv[2] == NULL) { /* Update CRC */ bd->bi_env_crc = crc32(0, bd->bi_env_data, sizeof(bd->bi_env_data)); return 0; } /* * Append new definition at the end */ for (env = bd->bi_env_data; *env || *(env+1); ++env) ; if ((ulong)env > (ulong)bd->bi_env_data) ++env; /* * Overflow when: * "name" + "=" + "val" +"\0\0" > * sizeof(bd->bi_env_data) - (env-bd->bi_env_data) */ len = strlen(name) + 2; /* add '=' for first arg, ' ' for all others */ for (i=2; i<argc; ++i) { len += strlen(argv[i]) + 1; } if (len > sizeof(bd->bi_env_data)) { printf ("## Error: environment overflow, \"%s\" deleted\n", name); return 1; } while ((*env = *name++) != '\0') env++; for (i=2; i<argc; ++i) { char *val = argv[i]; *env = (i==2) ? '=' : ' '; while ((*++env = *val++) != '\0') ; } /* end is marked with double '\0' */ *++env = '\0'; /* Update CRC */ bd->bi_env_crc = crc32(0, bd->bi_env_data, sizeof(bd->bi_env_data)); /* * Some variables should be updated when the corresponding * entry in the enviornment is changed */ if (strcmp(argv[1],"ethaddr") == 0) { char *s = argv[2]; /* always use only one arg */ char *e; for (i=0; i<6; ++i) { bd->bi_enetaddr[i] = s ? simple_strtoul(s, &e, 16) : 0; if (s) s = (*e) ? e+1 : e; } return 0; } #if (CONFIG_COMMANDS & CFG_CMD_NET) if (strcmp(argv[1],"ipaddr") == 0) { char *s = argv[2]; /* always use only one arg */ bd->bi_ip_addr = string_to_ip(s); return 0; } #endif if (strcmp(argv[1],"loadaddr") == 0) { load_addr = simple_strtoul(argv[2], NULL, 16); return 0; } if (strcmp(argv[1],"pagelength") == 0) { pagelength = simple_strtoul(argv[2], NULL, 10); return 0; } #if (CONFIG_COMMANDS & CFG_CMD_NET) if (strcmp(argv[1],"bootfile") == 0) { copy_filename (BootFile, argv[2], sizeof(BootFile)); return 0; } #endif /* CFG_CMD_NET */ #ifdef CONFIG_KEYBOARD if (strcmp(argv[1],"keymap") == 0) { kbd_mapping (argv[2]); return 0; } #endif /* CONFIG_KEYBOARD */ #ifdef CONFIG_ADJUST_LCD if (strcmp(argv[1],"contrast") == 0) { lcd_contrast(simple_strtoul(argv[2], NULL, 10)); return 0; } if (strcmp(argv[1],"brightness") == 0) { lcd_brightness(simple_strtoul(argv[2], NULL, 10)); return 0; } #endif /* CONFIG_ADJUST_LCD */ return 0; }
/* * mr_webirc * parv[0] = sender prefix * parv[1] = password * parv[2] = fake username (we ignore this) * parv[3] = fake hostname * parv[4] = fake ip */ static void mr_webirc(struct Client *client_p, struct Client *source_p, int parc, char *parv[]) { struct AccessItem *aconf = NULL; struct ConfItem *conf = NULL; char original_sockhost[HOSTIPLEN + 1]; assert(source_p == client_p); if (invalid_hostname(parv[4])) return; aconf = find_address_conf(source_p->host, IsGotId(source_p) ? source_p->username : "******", &source_p->ip, source_p->ip.ss_family, parv[1], source_p->certfp); if (aconf == NULL || !IsConfClient(aconf)) return; conf = unmap_conf_item(aconf); if (!IsConfDoSpoofIp(aconf) || irccmp(conf->name, "webirc.")) { sendto_realops_flags(UMODE_UNAUTH, L_ALL, "Not a CGI:IRC auth block: %s", source_p->sockhost); return; } if (EmptyString(aconf->passwd)) { sendto_realops_flags(UMODE_UNAUTH, L_ALL, "CGI:IRC auth blocks must have a password"); return; } if (!match_conf_password(parv[1], NULL, aconf)) { sendto_realops_flags(UMODE_UNAUTH, L_ALL, "CGI:IRC password incorrect"); return; } string_to_ip(parv[4], 0, &source_p->ip); strlcpy(original_sockhost, source_p->sockhost, sizeof(original_sockhost)); strlcpy(source_p->sockhost, parv[4], sizeof(source_p->sockhost)); if (strlen(parv[3]) <= HOSTLEN) strlcpy(source_p->host, parv[3], sizeof(source_p->host)); else strlcpy(source_p->host, source_p->sockhost, sizeof(source_p->host)); /* Check dlines now, klines will be checked on registration */ if ((aconf = find_dline_conf(&client_p->ip, client_p->ip.ss_family))) { if (!(aconf->status & CONF_EXEMPTDLINE)) { exit_client(client_p, &me, "D-lined"); return; } } sendto_realops_flags(UMODE_CCONN, L_ALL, "CGI:IRC host/IP set %s to %s (%s)", original_sockhost, parv[3], parv[4]); }