// ubus call test_ubus helloworld '{"id":1,"msg":"hello","array":["a","b"]}' static int test_hello(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct blob_attr *tb[__HELLO_MAX]; int tmp_id; char *tmp_msg = NULL; int len; struct blob_attr *attr; void *arr; blobmsg_parse(hello_policy, __HELLO_MAX, tb, blob_data(msg), blob_len(msg)); blob_buf_init(&b, 0); if(tb[HELLO_ID]) { tmp_id = blobmsg_get_u32(tb[HELLO_ID]); blobmsg_add_u32(&b, "id", tmp_id); } if(tb[HELLO_MSG]) { tmp_msg = blobmsg_get_string(tb[HELLO_MSG]); blobmsg_add_string(&b, "msg", tmp_msg); } if(tb[HELLO_ARRAY] && blobmsg_type(tb[HELLO_ARRAY]) == BLOBMSG_TYPE_ARRAY) { arr = blobmsg_open_array(&b, "array"); len = blobmsg_data_len(tb[HELLO_ARRAY]); __blob_for_each_attr(attr, blobmsg_data(tb[HELLO_ARRAY]), len) { if (blobmsg_type(attr) == BLOBMSG_TYPE_STRING) { char *tmp = blobmsg_get_string(attr); blobmsg_add_blob(&b, attr); printf("array=%s\n", tmp); } } blobmsg_close_array(&b, arr); }
static struct fw3_address * parse_subnet(enum fw3_family family, struct blob_attr *dict, int rem) { struct blob_attr *cur; struct fw3_address *addr; addr = calloc(1, sizeof(*addr)); if (!addr) return NULL; addr->set = true; addr->family = family; __blob_for_each_attr(cur, dict, rem) { if (!strcmp(blobmsg_name(cur), "address")) inet_pton(family == FW3_FAMILY_V4 ? AF_INET : AF_INET6, blobmsg_get_string(cur), &addr->address.v6); else if (!strcmp(blobmsg_name(cur), "mask")) fw3_bitlen2netmask(family, blobmsg_get_u32(cur), &addr->mask.v6); } return addr; }
static void blobmsg_format_element(struct blob_attr *data, int next_indent) { switch (blobmsg_type(data)) { case BLOBMSG_TYPE_UNSPEC: printf("null\n"); break; case BLOBMSG_TYPE_STRING: printf("%s\n", blobmsg_get_string(data)); break; case BLOBMSG_TYPE_BOOL: printf("%s\n", blobmsg_get_u8(data) ? "true" : "false"); break; case BLOBMSG_TYPE_INT16: printf("%d\n", blobmsg_get_u16(data)); break; case BLOBMSG_TYPE_INT32: printf("%d\n", blobmsg_get_u32(data)); break; case BLOBMSG_TYPE_INT64: printf("%"PRIu64"\n", blobmsg_get_u64(data)); break; case BLOBMSG_TYPE_TABLE: case BLOBMSG_TYPE_ARRAY: blobmsg_format_std_indent(data, next_indent); break; } }
/* * add ports to aggregation group. * msg : {"aggid":xxx, * "ports": [ * {"portNumber":x}, * {"portNumber":x}, * {"portNumber":x} * ] * } * */ static int aggregation_add_port(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct blob_attr *tb[__AGGREGATION_ADD_PORT_MAX]; //struct blob_attr *tbPortList[__AGGREGATION_ADD_PORT_LIST_MAX]; char *dev = NULL; int aggID; struct blob_attr *cur; int portCnt = 0; int rem; struct portAttr port; //TODO: blobmsg_parse(aggregation_add_port_policy, ARRAY_SIZE(aggregation_add_port_policy), tb, blob_data(msg), blob_len(msg)); if(!tb[AGGREGATION_ADD_PORT_GROUP_ID] || !tb[AGGREGATION_ADD_PORT_PORTS]) return UBUS_STATUS_INVALID_ARGUMENT; aggID = blobmsg_get_u32(tb[AGGREGATION_ADD_PORT_GROUP_ID]); if(tb[AGGREGATION_ADD_PORT_DEVICE]) dev = blobmsg_get_string(tb[AGGREGATION_ADD_PORT_DEVICE]); cur = tb[AGGREGATION_ADD_PORT_GROUP_ID]; blobmsg_for_each_attr(cur,tb[AGGREGATION_ADD_PORT_PORTS], rem) { //get port number get_port_attr(&port, cur); // printf("%s, port = %x\n",__func__, port.number); // TODO: add port to aggid }
static int proc_signal(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct blob_attr *tb[__SIGNAL_MAX]; if (!msg) return UBUS_STATUS_INVALID_ARGUMENT; blobmsg_parse(signal_policy, __SIGNAL_MAX, tb, blob_data(msg), blob_len(msg)); if (!tb[SIGNAL_PID || !tb[SIGNAL_NUM]]) return UBUS_STATUS_INVALID_ARGUMENT; kill(blobmsg_get_u32(tb[SIGNAL_PID]), blobmsg_get_u32(tb[SIGNAL_NUM])); return 0; }
static bool rpc_plugin_parse_signature(struct blob_attr *sig, struct ubus_method *method) { int rem, n_attr; enum blobmsg_type type; struct blob_attr *attr; struct blobmsg_policy *policy = NULL; if (!sig || blobmsg_type(sig) != BLOBMSG_TYPE_TABLE) return false; n_attr = 0; blobmsg_for_each_attr(attr, sig, rem) n_attr++; if (n_attr) { policy = calloc(n_attr, sizeof(*policy)); if (!policy) return false; n_attr = 0; blobmsg_for_each_attr(attr, sig, rem) { type = blobmsg_type(attr); if (type == BLOBMSG_TYPE_INT32) { switch (blobmsg_get_u32(attr)) { case 8: type = BLOBMSG_TYPE_INT8; break; case 16: type = BLOBMSG_TYPE_INT16; break; case 64: type = BLOBMSG_TYPE_INT64; break; default: type = BLOBMSG_TYPE_INT32; break; } } policy[n_attr].name = strdup(blobmsg_name(attr)); policy[n_attr].type = type; n_attr++; } }
void get_port_attr(struct portAttr *port, struct blob_attr *msg) { struct blob_attr *tb[__PORT_MAX]; int portNum; blobmsg_parse(port_policy, ARRAY_SIZE(port_policy), tb, blobmsg_data(msg), blobmsg_len(msg)); if(tb[AGG_PORT_NUMBER]) port->number = blobmsg_get_u32(tb[AGG_PORT_NUMBER]); if(tb[AGG_PORT_ALIAS]) port->alias = blobmsg_get_string(tb[AGG_PORT_ALIAS]); return; }
static int aggregation_create_group(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct blob_attr *tb[__AGGREGATION_GROUP_MAX]; char *dev = NULL; int aggID; char *aggType = NULL; char *aggDesc = NULL; blobmsg_parse(aggregation_group_policy, ARRAY_SIZE(aggregation_group_policy), tb, blob_data(msg), blob_len(msg)); if(!tb[AGGREGATION_GROUP_ID]) return UBUS_STATUS_INVALID_ARGUMENT; aggID = blobmsg_get_u32(tb[AGGREGATION_GROUP_ID]); if(tb[AGGREGATION_GROUP_DEVICE]) dev = blobmsg_get_string(tb[AGGREGATION_GROUP_DEVICE]); if(tb[AGGREGATION_GROUP_TYPE]) aggType = blobmsg_get_string(tb[AGGREGATION_GROUP_TYPE]); if(tb[AGGREGATION_GROUP_DESC]) aggDesc = blobmsg_get_string(tb[AGGREGATION_GROUP_DESC]); // TODO:do create new aggregation group. // dev used when system have more 1 VxBOX device. DPRINTF("%s received create aggregation group message: \ dev = %s, aggid = %d, aggType=%s, aggDesc=%s \n", obj->name, dev, aggID,aggType, aggDesc); blob_buf_init(&b, 0); blobmsg_add_u16(&b, "aggregation id",aggID); if (aggType) blobmsg_add_string(&b, "aggregation type",aggType); if (aggDesc) blobmsg_add_string(&b, "aggregation description",aggDesc); // TODO: add other attr req->deferred = false; ubus_send_reply(ctx, req, b.head); return 0; }
static void uqmi_print_result(struct blob_attr *data) { struct blob_attr *cur; int rem; blob_for_each_attr(cur, data, rem) { switch (blobmsg_type(cur)) { case BLOBMSG_TYPE_STRING: printf("%s=%s\n", blobmsg_name(cur), (char *) blobmsg_data(cur)); break; case BLOBMSG_TYPE_INT32: printf("%s=%d\n", blobmsg_name(cur), (int32_t) blobmsg_get_u32(cur)); break; case BLOBMSG_TYPE_INT8: printf("%s=%s\n", blobmsg_name(cur), blobmsg_get_u8(cur) ? "true" : "false"); break; } } }
static int aggregation_set_sys_pri(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct blob_attr *tb[__AGGREGATION_PRI_MAX]; char *dev = NULL; int sysPri; int fds[2]; blobmsg_parse(aggregation_sys_pri_policy, ARRAY_SIZE(aggregation_sys_pri_policy), tb, blob_data(msg), blob_len(msg)); if(!tb[AGGREGATION_SYS_PRI]) return UBUS_STATUS_INVALID_ARGUMENT; if(tb[AGGREGATION_DEVICE]) dev = blobmsg_get_string(tb[AGGREGATION_DEVICE]); sysPri = blobmsg_get_u32(tb[AGGREGATION_SYS_PRI]); // TODO:do set aggregation system priority. // dev used when system have more 1 VxBOX device. DPRINTF("%s received set aggregation system priority message: \ dev = %s, system Priority = %d \n", obj->name, dev, sysPri); // ubus_defer_request(ctx, req, &hreq->req); blob_buf_init(&b, 0); // blobmsg_add_string(&b, "device",dev); blobmsg_add_u16(&b, "system priority",sysPri); // TODO: add other attr req->deferred = false; ubus_send_reply(ctx, req, b.head); return 0; }
static int conf_proxy_mod(conf conf, char *data, size_t len, __unused struct blob_buf *reply, bool del) { struct blob_attr* tb[CONF_PROXY_MAX]; int iport; const char* saddr; struct in6_addr addr; if (blobmsg_parse(conf_proxy_attrs, CONF_PROXY_MAX, tb, data, len)) return -1; if(!tb[CONF_PROXY_ADDR] || !tb[CONF_PROXY_PORT] || !(saddr = blobmsg_get_string(tb[CONF_PROXY_ADDR])) || !(iport = blobmsg_get_u32(tb[CONF_PROXY_PORT]))) return -EINVAL; if(!(addr_pton(&addr, saddr)) || iport >= 65535 || iport <= 0) return -EINVAL; if(del) { pim_ctl_del_proxy(conf->pim, &addr, (in_port_t) iport); } else { pim_ctl_add_proxy(conf->pim, &addr, (in_port_t) iport); } return 0; }
static struct device_addr * parse_address_item(struct blob_attr *attr, bool v6, bool ext) { struct device_addr *addr; struct blob_attr *tb[__ADDR_MAX]; struct blob_attr *cur; if (blobmsg_type(attr) != BLOBMSG_TYPE_TABLE) return NULL; addr = alloc_device_addr(v6, ext); if (!addr) return NULL; blobmsg_parse(proto_ip_addr, __ADDR_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr)); addr->mask = v6 ? 128 : 32; if ((cur = tb[ADDR_MASK])) { unsigned int new_mask; new_mask = parse_netmask_string(blobmsg_data(cur), v6); if (new_mask > addr->mask) goto error; addr->mask = new_mask; } cur = tb[ADDR_IPADDR]; if (!cur) goto error; if (!inet_pton(v6 ? AF_INET6 : AF_INET, blobmsg_data(cur), &addr->addr)) goto error; if ((cur = tb[ADDR_OFFLINK]) && blobmsg_get_bool(cur)) addr->flags |= DEVADDR_OFFLINK; if (!v6) { if ((cur = tb[ADDR_BROADCAST]) && !inet_pton(AF_INET, blobmsg_data(cur), &addr->broadcast)) goto error; if ((cur = tb[ADDR_PTP]) && !inet_pton(AF_INET, blobmsg_data(cur), &addr->point_to_point)) goto error; } else { time_t now = system_get_rtime(); if ((cur = tb[ADDR_PREFERRED])) { int64_t preferred = blobmsg_get_u32(cur); int64_t preferred_until = preferred + (int64_t)now; if (preferred_until <= LONG_MAX && preferred != 0xffffffffLL) addr->preferred_until = preferred_until; } if ((cur = tb[ADDR_VALID])) { int64_t valid = blobmsg_get_u32(cur); int64_t valid_until = valid + (int64_t)now; if (valid_until <= LONG_MAX && valid != 0xffffffffLL) addr->valid_until = valid_until; } if (addr->valid_until) { if (!addr->preferred_until) addr->preferred_until = addr->valid_until; else if (addr->preferred_until > addr->valid_until) goto error; } if ((cur = tb[ADDR_CLASS])) addr->pclass = strdup(blobmsg_get_string(cur)); } return addr; error: free(addr); return NULL; }
static int rpc_rrdns_lookup(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { int port = 53, limit = RRDNS_DEF_LIMIT, timeout = RRDNS_DEF_TIMEOUT; struct blob_attr *tb[__RPC_L_MAX]; struct rrdns_context *rctx; const char *server = NULL; blobmsg_parse(rpc_lookup_policy, __RPC_L_MAX, tb, blob_data(msg), blob_len(msg)); if (tb[RPC_L_PORT]) port = blobmsg_get_u16(tb[RPC_L_PORT]); if (tb[RPC_L_LIMIT]) limit = blobmsg_get_u32(tb[RPC_L_LIMIT]); if (tb[RPC_L_TIMEOUT]) timeout = blobmsg_get_u32(tb[RPC_L_TIMEOUT]); if (tb[RPC_L_SERVER]) server = blobmsg_get_string(tb[RPC_L_SERVER]); if (!tb[RPC_L_ADDRS]) return UBUS_STATUS_INVALID_ARGUMENT; if (port <= 0) return UBUS_STATUS_INVALID_ARGUMENT; if (limit <= 0 || limit > RRDNS_MAX_LIMIT) return UBUS_STATUS_INVALID_ARGUMENT; if (timeout <= 0 || timeout > RRDNS_MAX_TIMEOUT) return UBUS_STATUS_INVALID_ARGUMENT; if (!server || !*server) server = rrdns_find_nameserver(); if (!server) return UBUS_STATUS_NOT_FOUND; rctx = calloc(1, sizeof(*rctx)); if (!rctx) return UBUS_STATUS_UNKNOWN_ERROR; rctx->socket.fd = usock(USOCK_UDP, server, usock_port(port)); if (rctx->socket.fd < 0) { free(rctx); return UBUS_STATUS_UNKNOWN_ERROR; } rctx->context = ctx; rctx->addr_cur = blobmsg_data(tb[RPC_L_ADDRS]); rctx->addr_rem = blobmsg_data_len(tb[RPC_L_ADDRS]); avl_init(&rctx->request_ids, rrdns_cmp_id, false, NULL); avl_init(&rctx->request_addrs, rrdns_cmp_addr, false, NULL); rctx->timeout.cb = rrdns_handle_timeout; uloop_timeout_set(&rctx->timeout, timeout); rctx->socket.cb = rrdns_handle_response; uloop_fd_add(&rctx->socket, ULOOP_READ); blob_buf_init(&rctx->blob, 0); while (limit--) rrdns_next_query(rctx); ubus_defer_request(ctx, req, &rctx->request); return UBUS_STATUS_OK; }
static int log_notify(struct blob_attr *msg) { struct blob_attr *tb[__LOG_MAX]; struct stat s; char buf[512]; uint32_t p; char *str; time_t t; char *c, *m; int ret = 0; if (sender.fd < 0) return 0; blobmsg_parse(log_policy, ARRAY_SIZE(log_policy), tb, blob_data(msg), blob_len(msg)); if (!tb[LOG_ID] || !tb[LOG_PRIO] || !tb[LOG_SOURCE] || !tb[LOG_TIME] || !tb[LOG_MSG]) return 1; if ((log_type == LOG_FILE) && log_size && (!stat(log_file, &s)) && (s.st_size > log_size)) { char *old = malloc(strlen(log_file) + 5); close(sender.fd); if (old) { sprintf(old, "%s.old", log_file); rename(log_file, old); free(old); } sender.fd = open(log_file, O_CREAT | O_WRONLY | O_APPEND, 0600); if (sender.fd < 0) { fprintf(stderr, "failed to open %s: %s\n", log_file, strerror(errno)); exit(-1); } } m = blobmsg_get_string(tb[LOG_MSG]); t = blobmsg_get_u64(tb[LOG_TIME]) / 1000; c = ctime(&t); p = blobmsg_get_u32(tb[LOG_PRIO]); c[strlen(c) - 1] = '\0'; str = blobmsg_format_json(msg, true); if (log_type == LOG_NET) { int err; snprintf(buf, sizeof(buf), "<%u>", p); strncat(buf, c + 4, 16); if (hostname) { strncat(buf, hostname, sizeof(buf) - strlen(buf) - 1); strncat(buf, " ", sizeof(buf) - strlen(buf) - 1); } if (log_prefix) { strncat(buf, log_prefix, sizeof(buf) - strlen(buf) - 1); strncat(buf, ": ", sizeof(buf) - strlen(buf) - 1); } if (blobmsg_get_u32(tb[LOG_SOURCE]) == SOURCE_KLOG) strncat(buf, "kernel: ", sizeof(buf) - strlen(buf) - 1); strncat(buf, m, sizeof(buf) - strlen(buf) - 1); if (log_udp) err = write(sender.fd, buf, strlen(buf)); else { size_t buflen = strlen(buf); if (!log_trailer_null) buf[buflen] = '\n'; err = send(sender.fd, buf, buflen + 1, 0); } if (err < 0) { syslog(LOG_INFO, "failed to send log data to %s:%s via %s\n", log_ip, log_port, (log_udp) ? ("udp") : ("tcp")); uloop_fd_delete(&sender); close(sender.fd); sender.fd = -1; uloop_timeout_set(&retry, 1000); } } else { snprintf(buf, sizeof(buf), "%s %s.%s%s %s\n", c, getcodetext(LOG_FAC(p) << 3, facilitynames), getcodetext(LOG_PRI(p), prioritynames), (blobmsg_get_u32(tb[LOG_SOURCE])) ? ("") : (" kernel:"), m); ret = write(sender.fd, buf, strlen(buf)); } free(str); if (log_type == LOG_FILE) fsync(sender.fd); return ret; }
void iprule_add(struct blob_attr *attr, bool v6) { struct interface *iif = NULL, *oif = NULL; struct blob_attr *tb[__RULE_MAX], *cur; struct interface *iface; struct iprule *rule; int af = v6 ? AF_INET6 : AF_INET; blobmsg_parse(rule_attr, __RULE_MAX, tb, blobmsg_data(attr), blobmsg_data_len(attr)); rule = calloc(1, sizeof(*rule)); if (!rule) return; rule->flags = v6 ? IPRULE_INET6 : IPRULE_INET4; rule->order = iprules_counter[rule->flags]++; if ((cur = tb[RULE_INVERT]) != NULL) rule->invert = blobmsg_get_bool(cur); if ((cur = tb[RULE_INTERFACE_IN]) != NULL) { iif = vlist_find(&interfaces, blobmsg_data(cur), iface, node); if (!iif || !iif->l3_dev.dev) { DPRINTF("Failed to resolve device of network: %s\n", (char *) blobmsg_data(cur)); goto error; } memcpy(rule->in_dev, iif->l3_dev.dev->ifname, sizeof(rule->in_dev)); rule->flags |= IPRULE_IN; } if ((cur = tb[RULE_INTERFACE_OUT]) != NULL) { oif = vlist_find(&interfaces, blobmsg_data(cur), iface, node); if (!oif || !oif->l3_dev.dev) { DPRINTF("Failed to resolve device of network: %s\n", (char *) blobmsg_data(cur)); goto error; } memcpy(rule->out_dev, oif->l3_dev.dev->ifname, sizeof(rule->out_dev)); rule->flags |= IPRULE_OUT; } if ((cur = tb[RULE_SRC]) != NULL) { if (!parse_ip_and_netmask(af, blobmsg_data(cur), &rule->src_addr, &rule->src_mask)) { DPRINTF("Failed to parse rule source: %s\n", (char *) blobmsg_data(cur)); goto error; } rule->flags |= IPRULE_SRC; } if ((cur = tb[RULE_DEST]) != NULL) { if (!parse_ip_and_netmask(af, blobmsg_data(cur), &rule->dest_addr, &rule->dest_mask)) { DPRINTF("Failed to parse rule destination: %s\n", (char *) blobmsg_data(cur)); goto error; } rule->flags |= IPRULE_DEST; } if ((cur = tb[RULE_PRIORITY]) != NULL) { rule->priority = blobmsg_get_u32(cur); rule->flags |= IPRULE_PRIORITY; } if ((cur = tb[RULE_TOS]) != NULL) { if ((rule->tos = blobmsg_get_u32(cur)) > 255) { DPRINTF("Invalid TOS value: %u\n", blobmsg_get_u32(cur)); goto error; } rule->flags |= IPRULE_TOS; } if ((cur = tb[RULE_FWMARK]) != NULL) { if (!iprule_parse_mark(blobmsg_data(cur), rule)) { DPRINTF("Failed to parse rule fwmark: %s\n", (char *) blobmsg_data(cur)); goto error; } /* flags set by iprule_parse_mark() */ } if ((cur = tb[RULE_LOOKUP]) != NULL) { if (!system_resolve_rt_table(blobmsg_data(cur), &rule->lookup)) { DPRINTF("Failed to parse rule lookup table: %s\n", (char *) blobmsg_data(cur)); goto error; } rule->flags |= IPRULE_LOOKUP; } if ((cur = tb[RULE_ACTION]) != NULL) { if (!system_resolve_iprule_action(blobmsg_data(cur), &rule->action)) { DPRINTF("Failed to parse rule action: %s\n", (char *) blobmsg_data(cur)); goto error; } rule->flags |= IPRULE_ACTION; } if ((cur = tb[RULE_GOTO]) != NULL) { rule->gotoid = blobmsg_get_u32(cur); rule->flags |= IPRULE_GOTO; } vlist_add(&iprules, &rule->node, &rule->flags); return; error: free(rule); }
static int conf_link_set(struct ipc_user *u, char *data, size_t len, __unused struct blob_buf *reply) { conf conf = container_of(u, conf_s, ipc_users[CONF_IPC_LINK_SET]); struct blob_attr *tb[CONF_LINK_MAX]; iface_flags flags = 0, flags_mod = 0; iface i; int ret = 0; if(blobmsg_parse(conf_link_attrs, CONF_LINK_MAX, tb, data, len) || !tb[CONF_LINK_DEV]) return -EINVAL; if(tb[CONF_LINK_LLQC] || tb[CONF_LINK_ROBUSTNESS]) { return -EOPNOTSUPP; } if(!(i = iface_get_byname(conf->igs, blobmsg_get_string(tb[CONF_LINK_DEV]), 1))) return -ENOMEM; iface_ref(i); #define _(attr, flag) \ if(attr) { \ flags_mod |= flag; \ if(blobmsg_get_bool(attr)) { \ flags |= flag; \ } else { \ flags &= ~(flag); \ } \ }\ _(tb[CONF_LINK_PIM], IFACE_FLAG_PIM); _(tb[CONF_LINK_SSBIDIR], IFACE_FLAG_SSBIDIR); _(tb[CONF_LINK_MLD], IFACE_FLAG_MLD_QUERIER); _(tb[CONF_LINK_IGMP], IFACE_FLAG_IGMP_QUERIER); #undef _ if(tb[CONF_LINK_PROXY]) { char *s = NULL; char *port = NULL; struct in6_addr addr; if(!(s = blobmsg_get_string(tb[CONF_LINK_PROXY]))) return -EINVAL; if(!strcmp(s, "off")) { flags_mod |= IFACE_FLAG_PROXY; flags &= ~(IFACE_FLAG_PROXY); } else if(!(port = strchr(s, ' ')) || strchr(port + 1, ' ')) { return -EINVAL; } else { *port = '\0'; port++; int p; if((sscanf(port, "%d", &p) != 1) || p >= 65536 || p<=0 || !addr_pton(&addr, s)) return -EINVAL; if(i->proxy_port != p || addr_cmp(&i->proxy_addr, &addr)) { addr_cpy(&i->proxy_addr, &addr); i->proxy_port = (in_port_t) p; flags_mod |= IFACE_FLAG_PROXY; flags |= IFACE_FLAG_PROXY; } } } conf_set_iface_flags(i, flags, flags_mod); if(tb[CONF_LINK_HELLO]) { int hello = blobmsg_get_u32(tb[CONF_LINK_HELLO]); conf_set_ifvalue(i, CIFV_PIM_HELLO_PERIOD_MS, (hello>0)?hello:INT_MIN); } if(tb[CONF_LINK_JOIN]) { int join = blobmsg_get_u32(tb[CONF_LINK_JOIN]); conf_set_ifvalue(i, CIFV_PIM_US_T_PERIODIC_MS, (join>0)?join:INT_MIN); } iface_unref(i); return ret; }
static int watchdog_set(struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg) { struct blob_attr *tb[__WDT_MAX]; const char *status; if (!msg) return UBUS_STATUS_INVALID_ARGUMENT; blobmsg_parse(watchdog_policy, __WDT_MAX, tb, blob_data(msg), blob_len(msg)); if (tb[WDT_FREQUENCY]) { unsigned int timeout = watchdog_timeout(0); unsigned int freq = blobmsg_get_u32(tb[WDT_FREQUENCY]); if (freq) { if (freq > timeout / 2) freq = timeout / 2; watchdog_frequency(freq); } } if (tb[WDT_TIMEOUT]) { unsigned int timeout = blobmsg_get_u32(tb[WDT_TIMEOUT]); unsigned int frequency = watchdog_frequency(0); if (timeout <= frequency) timeout = frequency * 2; watchdog_timeout(timeout); } if (tb[WDT_STOP]) watchdog_set_stopped(blobmsg_get_bool(tb[WDT_STOP])); if (watchdog_fd() == NULL) status = "offline"; else if (watchdog_get_stopped()) status = "stopped"; else status = "running"; blob_buf_init(&b, 0); blobmsg_add_string(&b, "status", status); blobmsg_add_u32(&b, "timeout", watchdog_timeout(0)); blobmsg_add_u32(&b, "frequency", watchdog_frequency(0)); ubus_send_reply(ctx, req, b.head); return 0; }