// 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);
}
void blobmsg_format_std_indent(const struct blob_attr *data, int indent)
{
struct blob_attr *attr;
const struct blob_attr *head = blobmsg_data(data);
int len = blobmsg_data_len(data);
__blob_for_each_attr(attr, head, len) {
int type = blobmsg_type(attr);
if (blobmsg_type(data) != BLOBMSG_TYPE_ARRAY
&& blobmsg_name(attr)[0])
indent_printf(indent, "%s: ", blobmsg_name(attr));
else
indent_printf(indent, "%s", "");
if (type == BLOBMSG_TYPE_TABLE)
printf("{\n");
else if (type == BLOBMSG_TYPE_ARRAY)
printf("[\n");
blobmsg_format_element(attr, indent + 1);
if (type == BLOBMSG_TYPE_TABLE)
indent_printf(indent, "}\n");
else if (type == BLOBMSG_TYPE_ARRAY)
indent_printf(indent, "]\n");
}
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++;
}
}
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;
}
}
static void
service_instance_add(struct service *s, struct blob_attr *attr)
{
struct service_instance *in;
if (blobmsg_type(attr) != BLOBMSG_TYPE_TABLE)
return;
in = calloc(1, sizeof(*in));
if (!in)
return;
instance_init(in, s, attr);
vlist_add(&s->instances, &in->node, (void *) in->name);
}
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 bool
menu_files(struct blob_attr *files)
{
int rem;
bool empty = true;
struct stat s;
struct blob_attr *file;
blobmsg_for_each_attr(file, files, rem)
{
empty = false;
if (blobmsg_type(file) != BLOBMSG_TYPE_STRING)
continue;
if (stat(blobmsg_get_string(file), &s) || !S_ISREG(s.st_mode))
continue;
return true;
}
static int
parse_static_address_option(struct interface *iface, struct blob_attr *attr,
bool v6, int netmask, bool ext, uint32_t broadcast)
{
struct blob_attr *cur;
int n_addr = 0;
int rem;
blobmsg_for_each_attr(cur, attr, rem) {
if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
return -1;
n_addr++;
if (!parse_addr(iface, blobmsg_data(cur), v6, netmask, ext,
broadcast))
return -1;
}
return n_addr;
}
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;
}
