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;
}
