int test_miscellany_net() { unsigned char mac_addr[6]; char ip_addr[100]; #if 0 get_mac((char *)"eth0",mac_addr, sizeof(mac_addr)); print_mac(mac_addr); get_local_ip((char *)"eth0",ip_addr); print_ipaddr(ip_addr); set_local_ip((char *)"eth0","192.168.20.182"); get_local_ip((char *)"eth0",ip_addr); print_ipaddr(ip_addr); dbg_str(DBG_DETAIL,"get local netmask"); get_local_netmask((char *)"eth0",ip_addr); print_ipaddr(ip_addr); dbg_str(DBG_DETAIL,"set local netmask"); set_local_netmask((char *)"eth0",(char *)"255.255.255.0"); get_local_netmask((char *)"eth0",ip_addr); print_ipaddr(ip_addr); dbg_str(DBG_DETAIL,"ip and str convert"); inet_str2num(AF_INET,(char *)"192.168.20.2"); inet_num2str(AF_INET,34908352,ip_addr); #endif #if 0 if(inet_is_in_same_subnet("192.168.2.32","eth0")) { /* *dbg_str(DBG_DETAIL,"this ip addr add local addr is in the same net"); */ } else { dbg_str(DBG_DETAIL,"this ip addr add local addr is not in the same net"); } #endif get_broadcast_addr("eth0", ip_addr); print_ipaddr(ip_addr); /* *char ip_addr2[100]; *set_broadcast_addr("eth0", "192.168.20.255"); *print_ipaddr(ip_addr2); */ return 0; }
int16_t parse_cmd_gw(char *cmd, char *output, uint16_t len) { uip_ipaddr_t gwaddr; while (*cmd == ' ') cmd++; #ifndef DISABLE_IPCONF_SUPPORT #if (!UIP_CONF_IPV6 || IPV6_STATIC_SUPPORT) && !defined(BOOTP_SUPPORT) if (*cmd != '\0') { /* try to parse ip */ if (parse_ip (cmd, &gwaddr)) return ECMD_ERR_PARSE_ERROR; eeprom_save(gateway, &gwaddr, IPADDR_LEN); eeprom_update_chksum(); return ECMD_FINAL_OK; } else #endif /* !UIP_CONF_IPV6 and !BOOTP_SUPPORT */ #endif /* DISABLE_IPCONF_SUPPORT */ { uip_getdraddr(&gwaddr); return ECMD_FINAL(print_ipaddr(&gwaddr, output, len)); } }
int16_t parse_cmd_netmask(char *cmd, char *output, uint16_t len) { uip_ipaddr_t netmask; while (*cmd == ' ') cmd++; #ifndef DISABLE_IPCONF_SUPPORT #if !UIP_CONF_IPV6 && !defined(BOOTP_SUPPORT) if (*cmd != '\0') { /* try to parse ip */ if (parse_ip (cmd, &netmask)) return ECMD_ERR_PARSE_ERROR; eeprom_save(netmask, &netmask, IPADDR_LEN); eeprom_update_chksum(); return ECMD_FINAL_OK; } else #endif /* !UIP_CONF_IPV6 and !BOOTP_SUPPORT */ #endif /* DISABLE_IPCONF_SUPPORT */ { uip_getnetmask(&netmask); return ECMD_FINAL(print_ipaddr(&netmask, output, len)); } }
int16_t parse_cmd_ip(char *cmd, char *output, uint16_t len) { uip_ipaddr_t hostaddr; while (*cmd == ' ') cmd++; #ifndef DISABLE_IPCONF_SUPPORT #if (!defined(IPV6_SUPPORT) && !defined(BOOTP_SUPPORT)) \ || defined(IPV6_STATIC_SUPPORT) if (*cmd != '\0') { /* try to parse ip */ if (parse_ip(cmd, &hostaddr)) return ECMD_ERR_PARSE_ERROR; eeprom_save(ip, &hostaddr, IPADDR_LEN); eeprom_update_chksum(); return ECMD_FINAL_OK; } else #endif /* IPv4-static || IPv6-static || OpenVPN */ #endif /* DISABLE_IPCONF_SUPPORT */ { uip_gethostaddr(&hostaddr); return ECMD_FINAL(print_ipaddr(&hostaddr, output, len)); } }
int16_t parse_cmd_ntp_server(char *cmd, char *output, uint16_t len) { uip_ipaddr_t ntpaddr; while (*cmd == ' ') cmd++; if (*cmd != '\0') { /* try to parse ip */ if (parse_ip(cmd, &ntpaddr) != 0) { #ifdef DNS_SUPPORT uip_ipaddr_t *ip; if (!(ip = resolv_lookup(cmd))) resolv_query(cmd, ntp_dns_query_cb); else ntp_conf(ip); #else return ECMD_ERR_PARSE_ERROR; #endif } else ntp_conf(&ntpaddr); return ECMD_FINAL_OK; } else { return ECMD_FINAL(print_ipaddr(ntp_getserver(), output, len)); } }
int16_t parse_cmd_nslookup (char *cmd, char *output, uint16_t len) { while (*cmd == 32) cmd ++; uip_ipaddr_t *addr = resolv_lookup (cmd); if (addr) { return ECMD_FINAL(print_ipaddr(addr, output, len)); } else { resolv_query (cmd, NULL); return ECMD_FINAL(snprintf_P(output, len, PSTR("nslookup triggered, try again for result."))); } }
static void fs20_dns_query_cb(char *name, uip_ipaddr_t *ipaddr) // Callback for DNS query { #ifdef DEBUG_FS20_SENDER char buf[50]; print_ipaddr(ipaddr, buf, 50); FS20S_DEBUG ("got dns response, connecting %s:%d\n", buf, CONF_FS20_PORT); #endif uip_conn_t *conn = uip_connect(ipaddr, HTONS(CONF_FS20_PORT), fs20_net_main); // create new connection with ipaddr found if (conn) // if connection succesfully created { conn->appstate.fs20.state = FS20_CONNSTATE_NEW; // Set connection state to new, as data still has to be send } else { fs20_sendstate = 2; // if no connection initiated, set state to Retry } }
int16_t parse_cmd_dns_server(char *cmd, char *output, uint16_t len) { uip_ipaddr_t dnsaddr; while (*cmd == ' ') cmd++; if (*cmd != '\0') { /* try to parse ip */ if (parse_ip(cmd, &dnsaddr)) return ECMD_ERR_PARSE_ERROR; resolv_conf(&dnsaddr); eeprom_save(dns_server, &dnsaddr, IPADDR_LEN); eeprom_update_chksum(); return ECMD_FINAL_OK; } else { return ECMD_FINAL(print_ipaddr(resolv_getserver(), output, len)); } }
static int res_cm_id_parse_cb(const struct nlmsghdr *nlh, void *data) { struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {}; struct nlattr *nla_table, *nla_entry; struct rd *rd = data; const char *name; int idx; mnl_attr_parse(nlh, 0, rd_attr_cb, tb); if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_RES_CM_ID]) return MNL_CB_ERROR; name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]); idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); nla_table = tb[RDMA_NLDEV_ATTR_RES_CM_ID]; mnl_attr_for_each_nested(nla_entry, nla_table) { struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {}; char src_addr_str[INET6_ADDRSTRLEN]; char dst_addr_str[INET6_ADDRSTRLEN]; uint16_t src_port, dst_port; uint32_t port = 0, pid = 0; uint8_t type = 0, state; uint32_t lqpn = 0, ps; char *comm = NULL; int err; err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line); if (err != MNL_CB_OK) return -EINVAL; if (!nla_line[RDMA_NLDEV_ATTR_RES_STATE] || !nla_line[RDMA_NLDEV_ATTR_RES_PS] || (!nla_line[RDMA_NLDEV_ATTR_RES_PID] && !nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) { return MNL_CB_ERROR; } if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]) port = mnl_attr_get_u32( nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]); if (port && port != rd->port_idx) continue; if (nla_line[RDMA_NLDEV_ATTR_RES_LQPN]) { lqpn = mnl_attr_get_u32( nla_line[RDMA_NLDEV_ATTR_RES_LQPN]); if (rd_check_is_filtered(rd, "lqpn", lqpn)) continue; } if (nla_line[RDMA_NLDEV_ATTR_RES_TYPE]) { type = mnl_attr_get_u8( nla_line[RDMA_NLDEV_ATTR_RES_TYPE]); if (rd_check_is_string_filtered(rd, "qp-type", qp_types_to_str(type))) continue; } ps = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PS]); if (rd_check_is_string_filtered(rd, "ps", cm_id_ps_to_str(ps))) continue; state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]); if (rd_check_is_string_filtered(rd, "state", cm_id_state_to_str(state))) continue; if (nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR]) { if (ss_ntop(nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR], src_addr_str, &src_port)) continue; if (rd_check_is_string_filtered(rd, "src-addr", src_addr_str)) continue; if (rd_check_is_filtered(rd, "src-port", src_port)) continue; } if (nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR]) { if (ss_ntop(nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR], dst_addr_str, &dst_port)) continue; if (rd_check_is_string_filtered(rd, "dst-addr", dst_addr_str)) continue; if (rd_check_is_filtered(rd, "dst-port", dst_port)) continue; } if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) { pid = mnl_attr_get_u32( nla_line[RDMA_NLDEV_ATTR_RES_PID]); comm = get_task_name(pid); } if (rd_check_is_filtered(rd, "pid", pid)) { free(comm); continue; } if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]) { /* discard const from mnl_attr_get_str */ comm = (char *)mnl_attr_get_str( nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]); } if (rd->json_output) jsonw_start_array(rd->jw); print_link(rd, idx, name, port, nla_line); if (nla_line[RDMA_NLDEV_ATTR_RES_LQPN]) print_lqpn(rd, lqpn); if (nla_line[RDMA_NLDEV_ATTR_RES_TYPE]) print_qp_type(rd, type); print_cm_id_state(rd, state); print_ps(rd, ps); print_pid(rd, pid); print_comm(rd, comm, nla_line); if (nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR]) print_ipaddr(rd, "src-addr", src_addr_str, src_port); if (nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR]) print_ipaddr(rd, "dst-addr", dst_addr_str, dst_port); if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) free(comm); print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]); newline(rd); } return MNL_CB_OK; }
uint8_t generate_address_json(void *table, size_t entry_size, int table_len, char *label, uint8_t *buffer, uint16_t preferred_size, int32_t *offset) { static char print_buf[40]; uint8_t *entry = (uint8_t *) table; size_t strpos = 0; /* position in overall string (which is larger than the buffer) */ size_t bufpos = 0; /* position within buffer (bytes written) */ size_t tmplen = 0; size_t unfinished = 0; uint8_t i; PRINTF("******** OFFSET %ld *************\n", *offset); if (strpos >= *offset && bufpos < preferred_size) { bufpos += snprintf_P((char *)(buffer+bufpos), preferred_size-bufpos+1, "{\"%s\":[", label); PRINTF("OUT %d/%d\n", bufpos, preferred_size); } strpos += strlen(label)+5; for (i = 0; i < table_len && bufpos < preferred_size; ++i) { if (((uip_table_info_t*)entry)->isused) { PRINTF("open @ %d\"\n", strpos); if (strpos >= *offset && bufpos < preferred_size) { buffer[bufpos++] = '"'; PRINTF("OUT %d/%d\n", bufpos, preferred_size); } ++strpos; PRINTF("addr @ %d\"\n", strpos); tmplen = print_ipaddr(print_buf, sizeof(print_buf), &((uip_table_info_t*)entry)->ipaddr); PRINTF(" len %d\"\n", tmplen); if (strpos+tmplen > *offset) { int16_t slice = *offset-(int32_t)strpos; if (slice > 0) { if (tmplen-slice > preferred_size-bufpos) unfinished = tmplen-slice - preferred_size+bufpos; PRINTF(" new %d\"\n", (int32_t)tmplen-slice-unfinished); PRINTF(" %s\n", print_buf + slice); memcpy(buffer+bufpos, print_buf + *offset-strpos, tmplen-slice-unfinished); bufpos += tmplen-slice-unfinished; } else { if (tmplen > preferred_size-bufpos) unfinished = tmplen - preferred_size+bufpos; PRINTF(" new %d\"\n", tmplen-unfinished); PRINTF(" %s\n", print_buf); memcpy(buffer+bufpos, print_buf, tmplen-unfinished); bufpos += tmplen-unfinished; } PRINTF("OUT %d/%d\n", bufpos, preferred_size); } strpos += tmplen; PRINTF("close @ %d\"\n", strpos); if (strpos >= *offset && bufpos < preferred_size) { buffer[bufpos++] = '"'; PRINTF("OUT %d/%d\n", bufpos, preferred_size); } ++strpos; PRINTF("comma @ %d\"\n", strpos); if (strpos >= *offset && bufpos < preferred_size) { buffer[bufpos++] = ','; PRINTF("OUT %d/%d\n", bufpos, preferred_size); } ++strpos; } entry += entry_size; } PRINTF("end @ %d\"\n", strpos); if (strpos >= *offset && bufpos < preferred_size) { if (bufpos==(strlen(label)+5)) ++bufpos; // if no neighbors buffer[bufpos-1] = ']'; buffer[bufpos++] = '}'; PRINTF("OUT %d/%d\n", bufpos, preferred_size); } buffer[bufpos] = '\0'; return (i == UIP_DS6_NBR_NB && unfinished==0); }
int8_t solometer_parse (char* ptr) { char *str,*ptr1,c,*buf; #ifdef DNS_SUPPORT uip_ipaddr_t dnsserver; #endif int n; int16_t *int1_p,*int2_p,*int3_p,*int4_p; //buf=(char*)malloc(24); if(!(buf=(char*)malloc(24))) { //debug_printf("smt_parse: Not enough memory!\n"); return -1; } int1_p = (int16_t*)(buf+16); int2_p = (int16_t*)(buf+18); int3_p = (int16_t*)(buf+20); int4_p = (int16_t*)(buf+22); ptr1 = strchr (ptr, ' '); if (ptr1 == NULL) { //debug_printf ("smt_parse: space after filename not found.\n"); return -1; } /* Make a copy of the parameter string */ c = *ptr1; *ptr1 = 0; if(!(str = malloc(strlen(ptr) + 1))) { //debug_printf("smt_parse: Not enough memory. Exiting.\n"); *ptr1 = c; return -1; } ptr = strcpy(str,ptr); *ptr1 = c; urldecode(ptr); //debug_printf("String to parse: --%s--\n",ptr); if(get_string(ptr,PSTR("WRID="),buf,3)) { WRID[0] = (uint8_t)atoi(buf); eeprom_save(solometer_WRID, &WRID[0], 1); eeprom_update_chksum(); } //debug_printf("Ausgewertet:WRID=--%u--\n",WRID[0]); if(get_string(ptr,PSTR("PVID="),post_cookie,11)) { eeprom_save(solometer_cookie, post_cookie, strlen(post_cookie) + 1); eeprom_update_chksum(); } //debug_printf("Ausgewertet:PVID=--%s--\n",post_cookie); if(get_string(ptr,PSTR("HST="),post_hostname,64)) { eeprom_save(solometer_host, post_hostname, strlen(post_hostname) + 1); eeprom_update_chksum(); } //debug_printf("Ausgewertet:HST=--%s--\n",post_hostname); if(get_string(ptr,PSTR("SCR="),post_scriptname,64)) { eeprom_save(solometer_script, post_scriptname, strlen(post_scriptname) + 1); eeprom_update_chksum(); } //debug_printf("Ausgewertet:SCRPT=--%s--\n",post_scriptname); if(get_string(ptr,PSTR("HIP="),buf,16)) { n = sscanf(buf,"%d.%d.%d.%d",int1_p,int2_p,int3_p,int4_p); if(n == 4) { //debug_printf("Setting Host IP: %d %d %d %d\n",*int1_p,*int2_p,*int3_p,*int4_p); uip_ipaddr(&post_hostip,*int1_p,*int2_p,*int3_p,*int4_p); eeprom_save(solometer_hostip, post_hostip, sizeof(uip_ipaddr_t)); eeprom_update_chksum(); memset(buf,0,16); print_ipaddr(&post_hostip,buf,16); buf[15]=0; } else { //debug_printf("Not setting Host IP (n != 4).\n"); buf[0] = 0; } } else { buf[0] = 0; } //debug_printf("Ausgewertet:HIP=--%s--\n",buf); #ifdef DNS_SUPPORT if(get_string(ptr,PSTR("DNS="),buf,16)) { n = sscanf(buf,"%d.%d.%d.%d",int1_p,int2_p,int3_p,int4_p); if(n == 4) { //debug_printf("Setting DNS server IP\n"); uip_ipaddr(&dnsserver,*int1_p,*int2_p,*int3_p,*int4_p); eeprom_save(dns_server, &dnsserver, sizeof(uip_ipaddr_t)); eeprom_update_chksum(); resolv_conf(&dnsserver); memset(buf,0,16); print_ipaddr(&dnsserver,buf,16); buf[15]=0; } else { //debug_printf("Not setting DNS server IP (n <> 4).\n"); buf[0] = 0; } } else { buf[0] = 0; } //debug_printf("Ausgewertet:DNS=--%s--\n",buf); #endif free(ptr); free(buf); return 0; }