2 * rpcd - UBUS RPC server
4 * Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 #include <sys/types.h>
24 #include <iwinfo/utils.h>
25 #include <net/ethernet.h>
28 #include <netinet/ether.h>
31 #include <rpcd/plugin.h>
34 static struct blob_buf buf
;
35 static const struct iwinfo_ops
*iw
;
36 static const char *ifname
;
43 static const struct blobmsg_policy rpc_device_policy
[__RPC_D_MAX
] = {
44 [RPC_D_DEVICE
] = { .name
= "device", .type
= BLOBMSG_TYPE_STRING
},
53 static const struct blobmsg_policy rpc_assoclist_policy
[__RPC_A_MAX
] = {
54 [RPC_A_DEVICE
] = { .name
= "device", .type
= BLOBMSG_TYPE_STRING
},
55 [RPC_A_MACADDR
] = { .name
= "mac", .type
= BLOBMSG_TYPE_STRING
},
63 static const struct blobmsg_policy rpc_uci_policy
[__RPC_U_MAX
] = {
64 [RPC_U_SECTION
] = { .name
= "section", .type
= BLOBMSG_TYPE_STRING
},
68 __rpc_iwinfo_open(struct blob_attr
*device
)
71 return UBUS_STATUS_INVALID_ARGUMENT
;
73 ifname
= blobmsg_data(device
);
74 iw
= iwinfo_backend(ifname
);
76 return iw
? UBUS_STATUS_OK
: UBUS_STATUS_NOT_FOUND
;
80 rpc_iwinfo_open(struct blob_attr
*msg
)
82 static struct blob_attr
*tb
[__RPC_D_MAX
];
84 blobmsg_parse(rpc_device_policy
, __RPC_D_MAX
, tb
,
85 blob_data(msg
), blob_len(msg
));
87 return __rpc_iwinfo_open(tb
[RPC_D_DEVICE
]);
91 rpc_iwinfo_close(void)
99 rpc_iwinfo_call_int(const char *name
, int (*func
)(const char *, int *),
100 const char * const *map
)
104 if (!func(ifname
, &rv
))
107 blobmsg_add_u32(&buf
, name
, rv
);
109 blobmsg_add_string(&buf
, name
, map
[rv
]);
114 rpc_iwinfo_call_hardware_id(const char *name
)
116 struct iwinfo_hardware_id ids
;
119 if (!iw
->hardware_id(ifname
, (char *)&ids
))
121 c
= blobmsg_open_array(&buf
, name
);
123 blobmsg_add_u32(&buf
, NULL
, ids
.vendor_id
);
124 blobmsg_add_u32(&buf
, NULL
, ids
.device_id
);
125 blobmsg_add_u32(&buf
, NULL
, ids
.subsystem_vendor_id
);
126 blobmsg_add_u32(&buf
, NULL
, ids
.subsystem_device_id
);
128 blobmsg_close_array(&buf
, c
);
133 rpc_iwinfo_lower(const char *src
, char *dst
, size_t len
)
137 for (i
= 0; *src
&& i
< len
; i
++)
138 *dst
++ = tolower(*src
++);
144 rpc_iwinfo_add_bit_array(const char *name
, uint32_t bits
,
145 const char * const values
[], size_t len
,
146 bool lower
, uint32_t zero
)
156 c
= blobmsg_open_array(&buf
, name
);
158 for (i
= 0; i
< len
; i
++)
165 rpc_iwinfo_lower(v
, l
, strlen(values
[i
]));
169 blobmsg_add_string(&buf
, NULL
, v
);
172 blobmsg_close_array(&buf
, c
);
176 rpc_iwinfo_add_encryption(const char *name
, struct iwinfo_crypto_entry
*e
)
181 c
= blobmsg_open_table(&buf
, name
);
183 blobmsg_add_u8(&buf
, "enabled", e
->enabled
);
189 rpc_iwinfo_add_bit_array("wep", e
->auth_algs
,
196 d
= blobmsg_open_array(&buf
, "wpa");
198 for (wpa_version
= 1; wpa_version
<= 3; wpa_version
++)
199 if (e
->wpa_version
& (1 << (wpa_version
- 1)))
200 blobmsg_add_u32(&buf
, NULL
, wpa_version
);
202 blobmsg_close_array(&buf
, d
);
204 rpc_iwinfo_add_bit_array("authentication",
208 true, IWINFO_KMGMT_NONE
);
212 rpc_iwinfo_add_bit_array("ciphers",
213 e
->pair_ciphers
| e
->group_ciphers
,
216 true, IWINFO_CIPHER_NONE
);
219 blobmsg_close_table(&buf
, c
);
223 rpc_iwinfo_call_encryption(const char *name
)
225 struct iwinfo_crypto_entry crypto
= { 0 };
227 if (!iw
->encryption(ifname
, (char *)&crypto
))
228 rpc_iwinfo_add_encryption(name
, &crypto
);
232 rpc_iwinfo_call_htmodes(const char *name
)
236 if (iw
->htmodelist(ifname
, &modes
))
239 rpc_iwinfo_add_bit_array(name
, modes
& ~IWINFO_HTMODE_NOHT
,
240 IWINFO_HTMODE_NAMES
, IWINFO_HTMODE_COUNT
,
245 rpc_iwinfo_call_hwmodes(const char *name
)
249 if (iw
->hwmodelist(ifname
, &modes
))
252 rpc_iwinfo_add_bit_array(name
, modes
,
253 IWINFO_80211_NAMES
, IWINFO_80211_COUNT
,
259 static void rpc_iwinfo_call_hw_ht_mode(int hwmodelist
)
261 const char *hwmode_str
;
262 const char *htmode_str
;
265 if (hwmodelist
== IWINFO_80211_AD
)
267 blobmsg_add_string(&buf
, "hwmode", "ad");
271 if (iw
->htmode(ifname
, &htmode
))
274 htmode_str
= iwinfo_htmode_name(htmode
);
277 if (iwinfo_htmode_is_ht(htmode
))
279 else if (iwinfo_htmode_is_vht(htmode
))
281 else if (iwinfo_htmode_is_he(htmode
))
286 htmode_str
= hwmode_str
= "unknown";
288 blobmsg_add_string(&buf
, "hwmode", hwmode_str
);
289 blobmsg_add_string(&buf
, "htmode", htmode_str
);
293 rpc_iwinfo_call_str(const char *name
, int (*func
)(const char *, char *))
295 char rv
[IWINFO_BUFSIZE
] = { 0 };
297 if (!func(ifname
, rv
))
298 blobmsg_add_string(&buf
, name
, rv
);
302 rpc_iwinfo_info(struct ubus_context
*ctx
, struct ubus_object
*obj
,
303 struct ubus_request_data
*req
, const char *method
,
304 struct blob_attr
*msg
)
309 rv
= rpc_iwinfo_open(msg
);
314 blob_buf_init(&buf
, 0);
316 rpc_iwinfo_call_str("phy", iw
->phyname
);
318 rpc_iwinfo_call_str("ssid", iw
->ssid
);
319 rpc_iwinfo_call_str("bssid", iw
->bssid
);
320 rpc_iwinfo_call_str("country", iw
->country
);
322 rpc_iwinfo_call_int("mode", iw
->mode
, IWINFO_OPMODE_NAMES
);
323 rpc_iwinfo_call_int("channel", iw
->channel
, NULL
);
324 rpc_iwinfo_call_int("center_chan1", iw
->center_chan1
, NULL
);
325 rpc_iwinfo_call_int("center_chan2", iw
->center_chan2
, NULL
);
327 rpc_iwinfo_call_int("frequency", iw
->frequency
, NULL
);
328 rpc_iwinfo_call_int("frequency_offset", iw
->frequency_offset
, NULL
);
330 rpc_iwinfo_call_int("txpower", iw
->txpower
, NULL
);
331 rpc_iwinfo_call_int("txpower_offset", iw
->txpower_offset
, NULL
);
333 rpc_iwinfo_call_int("quality", iw
->quality
, NULL
);
334 rpc_iwinfo_call_int("quality_max", iw
->quality_max
, NULL
);
336 rpc_iwinfo_call_int("signal", iw
->signal
, NULL
);
337 rpc_iwinfo_call_int("noise", iw
->noise
, NULL
);
339 rpc_iwinfo_call_int("bitrate", iw
->bitrate
, NULL
);
341 rpc_iwinfo_call_encryption("encryption");
342 rpc_iwinfo_call_htmodes("htmodes");
343 hwmodes
= rpc_iwinfo_call_hwmodes("hwmodes");
346 rpc_iwinfo_call_hw_ht_mode(hwmodes
);
348 c
= blobmsg_open_table(&buf
, "hardware");
349 rpc_iwinfo_call_hardware_id("id");
350 rpc_iwinfo_call_str("name", iw
->hardware_name
);
351 blobmsg_close_table(&buf
, c
);
353 ubus_send_reply(ctx
, req
, buf
.head
);
357 return UBUS_STATUS_OK
;
361 rpc_iwinfo_scan(struct ubus_context
*ctx
, struct ubus_object
*obj
,
362 struct ubus_request_data
*req
, const char *method
,
363 struct blob_attr
*msg
)
368 char res
[IWINFO_BUFSIZE
];
369 struct iwinfo_scanlist_entry
*e
;
371 rv
= rpc_iwinfo_open(msg
);
376 blob_buf_init(&buf
, 0);
378 c
= blobmsg_open_array(&buf
, "results");
380 if (!iw
->scanlist(ifname
, res
, &len
) && (len
> 0))
382 for (i
= 0; i
< len
; i
+= sizeof(struct iwinfo_scanlist_entry
))
384 e
= (struct iwinfo_scanlist_entry
*)&res
[i
];
385 d
= blobmsg_open_table(&buf
, NULL
);
388 blobmsg_add_string(&buf
, "ssid", (const char *)e
->ssid
);
390 snprintf(mac
, sizeof(mac
), "%02X:%02X:%02X:%02X:%02X:%02X",
391 e
->mac
[0], e
->mac
[1], e
->mac
[2],
392 e
->mac
[3], e
->mac
[4], e
->mac
[5]);
394 blobmsg_add_string(&buf
, "bssid", mac
);
396 blobmsg_add_string(&buf
, "mode", IWINFO_OPMODE_NAMES
[e
->mode
]);
398 blobmsg_add_u32(&buf
, "channel", e
->channel
);
399 blobmsg_add_u32(&buf
, "signal", (uint32_t)(e
->signal
- 0x100));
401 blobmsg_add_u32(&buf
, "quality", e
->quality
);
402 blobmsg_add_u32(&buf
, "quality_max", e
->quality_max
);
404 if (e
->ht_chan_info
.primary_chan
) {
405 t
= blobmsg_open_table(&buf
, "ht_operation");
406 blobmsg_add_u32(&buf
, "primary_channel", e
->ht_chan_info
.primary_chan
);
407 blobmsg_add_string(&buf
, "secondary_channel_offset", ht_secondary_offset
[e
->ht_chan_info
.secondary_chan_off
]);
408 blobmsg_add_u32(&buf
, "channel_width", ht_chan_width
[e
->ht_chan_info
.chan_width
]);
409 blobmsg_close_table(&buf
, t
);
412 if (e
->vht_chan_info
.center_chan_1
) {
413 t
= blobmsg_open_table(&buf
, "vht_operation");
414 blobmsg_add_u32(&buf
, "channel_width", vht_chan_width
[e
->vht_chan_info
.chan_width
]);
415 blobmsg_add_u32(&buf
, "center_freq_1", e
->vht_chan_info
.center_chan_1
);
416 blobmsg_add_u32(&buf
, "center_freq_2", e
->vht_chan_info
.center_chan_2
);
417 blobmsg_close_table(&buf
, t
);
420 rpc_iwinfo_add_encryption("encryption", &e
->crypto
);
422 blobmsg_close_table(&buf
, d
);
426 blobmsg_close_array(&buf
, c
);
428 ubus_send_reply(ctx
, req
, buf
.head
);
432 return UBUS_STATUS_OK
;
436 rpc_iwinfo_add_rateinfo(struct iwinfo_rate_entry
*r
)
438 blobmsg_add_u8(&buf
, "ht", r
->is_ht
);
439 blobmsg_add_u8(&buf
, "vht", r
->is_vht
);
440 blobmsg_add_u8(&buf
, "he", r
->is_he
);
441 blobmsg_add_u32(&buf
, "mhz", r
->mhz
);
442 blobmsg_add_u32(&buf
, "rate", r
->rate
);
445 blobmsg_add_u32(&buf
, "mcs", r
->mcs
);
446 blobmsg_add_u8(&buf
, "40mhz", r
->is_40mhz
);
447 blobmsg_add_u8(&buf
, "short_gi", r
->is_short_gi
);
449 else if (r
->is_vht
) {
450 blobmsg_add_u32(&buf
, "mcs", r
->mcs
);
451 blobmsg_add_u32(&buf
, "nss", r
->nss
);
452 blobmsg_add_u8(&buf
, "short_gi", r
->is_short_gi
);
455 blobmsg_add_u32(&buf
, "mcs", r
->mcs
);
456 blobmsg_add_u32(&buf
, "nss", r
->nss
);
457 blobmsg_add_u32(&buf
, "he_gi", r
->he_gi
);
458 blobmsg_add_u32(&buf
, "he_dcm", r
->he_dcm
);
463 rpc_iwinfo_assoclist(struct ubus_context
*ctx
, struct ubus_object
*obj
,
464 struct ubus_request_data
*req
, const char *method
,
465 struct blob_attr
*msg
)
469 char res
[IWINFO_BUFSIZE
];
470 struct iwinfo_assoclist_entry
*a
;
471 struct ether_addr
*macaddr
= NULL
;
472 void *c
= NULL
, *d
, *e
;
473 struct blob_attr
*tb
[__RPC_A_MAX
];
476 blobmsg_parse(rpc_assoclist_policy
, __RPC_A_MAX
, tb
,
477 blob_data(msg
), blob_len(msg
));
479 rv
= __rpc_iwinfo_open(tb
[RPC_A_DEVICE
]);
483 if (tb
[RPC_A_MACADDR
])
484 macaddr
= ether_aton(blobmsg_data(tb
[RPC_A_MACADDR
]));
486 blob_buf_init(&buf
, 0);
489 c
= blobmsg_open_array(&buf
, "results");
491 if (!iw
->assoclist(ifname
, res
, &len
) && (len
> 0))
493 for (i
= 0; i
< len
; i
+= sizeof(struct iwinfo_assoclist_entry
))
495 a
= (struct iwinfo_assoclist_entry
*)&res
[i
];
498 d
= blobmsg_open_table(&buf
, NULL
);
499 else if (memcmp(macaddr
, a
->mac
, ETH_ALEN
) != 0)
502 snprintf(mac
, sizeof(mac
), "%02X:%02X:%02X:%02X:%02X:%02X",
503 a
->mac
[0], a
->mac
[1], a
->mac
[2],
504 a
->mac
[3], a
->mac
[4], a
->mac
[5]);
506 blobmsg_add_string(&buf
, "mac", mac
);
507 blobmsg_add_u32(&buf
, "signal", a
->signal
);
508 blobmsg_add_u32(&buf
, "signal_avg", a
->signal_avg
);
509 blobmsg_add_u32(&buf
, "noise", a
->noise
);
510 blobmsg_add_u32(&buf
, "inactive", a
->inactive
);
511 blobmsg_add_u32(&buf
, "connected_time", a
->connected_time
);
512 blobmsg_add_u32(&buf
, "thr", a
->thr
);
513 blobmsg_add_u8(&buf
, "authorized", a
->is_authorized
);
514 blobmsg_add_u8(&buf
, "authenticated", a
->is_authenticated
);
515 blobmsg_add_string(&buf
, "preamble", a
->is_preamble_short
? "short" : "long");
516 blobmsg_add_u8(&buf
, "wme", a
->is_wme
);
517 blobmsg_add_u8(&buf
, "mfp", a
->is_mfp
);
518 blobmsg_add_u8(&buf
, "tdls", a
->is_tdls
);
520 blobmsg_add_u16(&buf
, "mesh llid", a
->llid
);
521 blobmsg_add_u16(&buf
, "mesh plid", a
->plid
);
522 blobmsg_add_string(&buf
, "mesh plink", a
->plink_state
);
523 blobmsg_add_string(&buf
, "mesh local PS", a
->local_ps
);
524 blobmsg_add_string(&buf
, "mesh peer PS", a
->peer_ps
);
525 blobmsg_add_string(&buf
, "mesh non-peer PS", a
->nonpeer_ps
);
527 e
= blobmsg_open_table(&buf
, "rx");
528 blobmsg_add_u64(&buf
, "drop_misc", a
->rx_drop_misc
);
529 blobmsg_add_u32(&buf
, "packets", a
->rx_packets
);
530 blobmsg_add_u32(&buf
, "bytes", a
->rx_bytes
);
531 rpc_iwinfo_add_rateinfo(&a
->rx_rate
);
532 blobmsg_close_table(&buf
, e
);
534 e
= blobmsg_open_table(&buf
, "tx");
535 blobmsg_add_u32(&buf
, "failed", a
->tx_failed
);
536 blobmsg_add_u32(&buf
, "retries", a
->tx_retries
);
537 blobmsg_add_u32(&buf
, "packets", a
->tx_packets
);
538 blobmsg_add_u32(&buf
, "bytes", a
->tx_bytes
);
539 rpc_iwinfo_add_rateinfo(&a
->tx_rate
);
540 blobmsg_close_table(&buf
, e
);
544 blobmsg_close_table(&buf
, d
);
551 blobmsg_close_array(&buf
, c
);
553 return UBUS_STATUS_NOT_FOUND
;
555 ubus_send_reply(ctx
, req
, buf
.head
);
559 return UBUS_STATUS_OK
;
563 rpc_iwinfo_survey(struct ubus_context
*ctx
, struct ubus_object
*obj
,
564 struct ubus_request_data
*req
, const char *method
,
565 struct blob_attr
*msg
)
567 char res
[IWINFO_BUFSIZE
];
568 struct iwinfo_survey_entry
*e
;
572 blob_buf_init(&buf
, 0);
574 rv
= rpc_iwinfo_open(msg
);
576 c
= blobmsg_open_array(&buf
, "results");
578 if (rv
|| iw
->survey(ifname
, res
, &len
) || len
< 0)
579 return UBUS_STATUS_OK
;
581 for (i
= 0; i
< len
; i
+= sizeof(struct iwinfo_survey_entry
)) {
582 e
= (struct iwinfo_survey_entry
*)&res
[i
];
584 d
= blobmsg_open_table(&buf
, NULL
);
585 blobmsg_add_u32(&buf
, "mhz", e
->mhz
);
586 blobmsg_add_u32(&buf
, "noise", e
->noise
);
587 blobmsg_add_u64(&buf
, "active_time", e
->active_time
);
588 blobmsg_add_u64(&buf
, "busy_time", e
->busy_time
);
589 blobmsg_add_u64(&buf
, "busy_time_ext", e
->busy_time_ext
);
590 blobmsg_add_u64(&buf
, "rx_time", e
->rxtime
);
591 blobmsg_add_u64(&buf
, "tx_time", e
->txtime
);
592 blobmsg_close_table(&buf
, d
);
595 blobmsg_close_array(&buf
, c
);
596 ubus_send_reply(ctx
, req
, buf
.head
);
598 return UBUS_STATUS_OK
;
602 rpc_iwinfo_freqlist(struct ubus_context
*ctx
, struct ubus_object
*obj
,
603 struct ubus_request_data
*req
, const char *method
,
604 struct blob_attr
*msg
)
607 char res
[IWINFO_BUFSIZE
];
608 struct iwinfo_freqlist_entry
*f
;
611 rv
= rpc_iwinfo_open(msg
);
616 blob_buf_init(&buf
, 0);
618 c
= blobmsg_open_array(&buf
, "results");
620 if (!iw
->freqlist(ifname
, res
, &len
) && (len
> 0))
622 if (iw
->channel(ifname
, &ch
))
625 for (i
= 0; i
< len
; i
+= sizeof(struct iwinfo_freqlist_entry
))
627 f
= (struct iwinfo_freqlist_entry
*)&res
[i
];
628 d
= blobmsg_open_table(&buf
, NULL
);
630 blobmsg_add_u32(&buf
, "channel", f
->channel
);
631 blobmsg_add_u32(&buf
, "mhz", f
->mhz
);
632 blobmsg_add_u8(&buf
, "restricted", f
->restricted
);
635 blobmsg_add_u8(&buf
, "active", f
->channel
== ch
);
637 blobmsg_close_table(&buf
, d
);
641 blobmsg_close_array(&buf
, c
);
643 ubus_send_reply(ctx
, req
, buf
.head
);
647 return UBUS_STATUS_OK
;
651 rpc_iwinfo_txpowerlist(struct ubus_context
*ctx
, struct ubus_object
*obj
,
652 struct ubus_request_data
*req
, const char *method
,
653 struct blob_attr
*msg
)
655 int i
, rv
, len
, pwr
, off
;
656 char res
[IWINFO_BUFSIZE
];
657 struct iwinfo_txpwrlist_entry
*t
;
660 rv
= rpc_iwinfo_open(msg
);
665 blob_buf_init(&buf
, 0);
667 c
= blobmsg_open_array(&buf
, "results");
669 if (!iw
->txpwrlist(ifname
, res
, &len
) && (len
> 0))
671 if (iw
->txpower(ifname
, &pwr
))
674 if (iw
->txpower_offset(ifname
, &off
))
677 for (i
= 0; i
< len
; i
+= sizeof(struct iwinfo_txpwrlist_entry
))
679 t
= (struct iwinfo_txpwrlist_entry
*)&res
[i
];
680 d
= blobmsg_open_table(&buf
, NULL
);
682 blobmsg_add_u32(&buf
, "dbm", t
->dbm
+ off
);
683 blobmsg_add_u32(&buf
, "mw", iwinfo_dbm2mw(t
->dbm
+ off
));
686 blobmsg_add_u8(&buf
, "active", t
->dbm
== pwr
);
688 blobmsg_close_table(&buf
, d
);
692 blobmsg_close_array(&buf
, c
);
694 ubus_send_reply(ctx
, req
, buf
.head
);
698 return UBUS_STATUS_OK
;
702 rpc_iwinfo_lookup_country(char *buf
, int len
, int iso3166
)
705 static char ccode
[5];
706 struct iwinfo_country_entry
*c
;
708 for (i
= 0; i
< len
; i
+= sizeof(struct iwinfo_country_entry
))
710 c
= (struct iwinfo_country_entry
*)&buf
[i
];
712 if (c
->iso3166
== iso3166
)
714 snprintf(ccode
, sizeof(ccode
), "%s", c
->ccode
);
723 rpc_iwinfo_countrylist(struct ubus_context
*ctx
, struct ubus_object
*obj
,
724 struct ubus_request_data
*req
, const char *method
,
725 struct blob_attr
*msg
)
730 char res
[IWINFO_BUFSIZE
] = {0};
732 const struct iwinfo_iso3166_label
*l
;
735 rv
= rpc_iwinfo_open(msg
);
740 blob_buf_init(&buf
, 0);
742 c
= blobmsg_open_array(&buf
, "results");
744 if (!iw
->countrylist(ifname
, res
, &len
) && (len
> 0))
746 if (iw
->country(ifname
, cur
))
747 memset(cur
, 0, sizeof(cur
));
749 for (l
= IWINFO_ISO3166_NAMES
; l
->iso3166
; l
++)
751 ccode
= rpc_iwinfo_lookup_country(res
, len
, l
->iso3166
);
756 d
= blobmsg_open_table(&buf
, NULL
);
758 blobmsg_add_string(&buf
, "code", ccode
);
759 blobmsg_add_string(&buf
, "country", (const char *)l
->name
);
761 snprintf(iso3166
, sizeof(iso3166
), "%c%c",
762 (l
->iso3166
/ 256), (l
->iso3166
% 256));
764 blobmsg_add_string(&buf
, "iso3166", iso3166
);
767 blobmsg_add_u8(&buf
, "active", !strncmp(ccode
, cur
, 2));
769 blobmsg_close_table(&buf
, d
);
773 blobmsg_close_array(&buf
, c
);
775 ubus_send_reply(ctx
, req
, buf
.head
);
779 return UBUS_STATUS_OK
;
783 rpc_iwinfo_phyname(struct ubus_context
*ctx
, struct ubus_object
*obj
,
784 struct ubus_request_data
*req
, const char *method
,
785 struct blob_attr
*msg
)
789 char res
[IWINFO_BUFSIZE
];
790 const struct iwinfo_ops
*ops
;
791 struct blob_attr
*tb
[__RPC_U_MAX
];
792 const char *backends
[] = {
798 blobmsg_parse(rpc_uci_policy
, __RPC_U_MAX
, tb
,
799 blob_data(msg
), blob_len(msg
));
801 if (!tb
[RPC_U_SECTION
])
802 return UBUS_STATUS_INVALID_ARGUMENT
;
804 for (i
= 0; i
< ARRAY_SIZE(backends
); i
++)
806 ops
= iwinfo_backend_by_name(backends
[i
]);
808 if (!ops
|| !ops
->lookup_phy
)
811 if (!ops
->lookup_phy(blobmsg_get_string(tb
[RPC_U_SECTION
]), res
))
820 blob_buf_init(&buf
, 0);
821 blobmsg_add_string(&buf
, "phyname", res
);
823 ubus_send_reply(ctx
, req
, buf
.head
);
828 return found
? UBUS_STATUS_OK
: UBUS_STATUS_NOT_FOUND
;
832 rpc_iwinfo_devices(struct ubus_context
*ctx
, struct ubus_object
*obj
,
833 struct ubus_request_data
*req
, const char *method
,
834 struct blob_attr
*msg
)
840 d
= opendir("/sys/class/net");
843 return UBUS_STATUS_UNKNOWN_ERROR
;
845 blob_buf_init(&buf
, 0);
847 c
= blobmsg_open_array(&buf
, "devices");
849 while ((e
= readdir(d
)) != NULL
)
851 if (e
->d_type
!= DT_LNK
)
854 if (iwinfo_type(e
->d_name
))
855 blobmsg_add_string(&buf
, NULL
, e
->d_name
);
858 blobmsg_close_array(&buf
, c
);
862 ubus_send_reply(ctx
, req
, buf
.head
);
866 return UBUS_STATUS_OK
;
871 rpc_iwinfo_api_init(const struct rpc_daemon_ops
*o
, struct ubus_context
*ctx
)
873 static const struct ubus_method iwinfo_methods
[] = {
874 UBUS_METHOD_NOARG("devices", rpc_iwinfo_devices
),
875 UBUS_METHOD("info", rpc_iwinfo_info
, rpc_device_policy
),
876 UBUS_METHOD("scan", rpc_iwinfo_scan
, rpc_device_policy
),
877 UBUS_METHOD("assoclist", rpc_iwinfo_assoclist
, rpc_assoclist_policy
),
878 UBUS_METHOD("freqlist", rpc_iwinfo_freqlist
, rpc_device_policy
),
879 UBUS_METHOD("txpowerlist", rpc_iwinfo_txpowerlist
, rpc_device_policy
),
880 UBUS_METHOD("countrylist", rpc_iwinfo_countrylist
, rpc_device_policy
),
881 UBUS_METHOD("survey", rpc_iwinfo_survey
, rpc_device_policy
),
882 UBUS_METHOD("phyname", rpc_iwinfo_phyname
, rpc_uci_policy
),
885 static struct ubus_object_type iwinfo_type
=
886 UBUS_OBJECT_TYPE("rpcd-plugin-iwinfo", iwinfo_methods
);
888 static struct ubus_object obj
= {
890 .type
= &iwinfo_type
,
891 .methods
= iwinfo_methods
,
892 .n_methods
= ARRAY_SIZE(iwinfo_methods
),
895 return ubus_add_object(ctx
, &obj
);
898 struct rpc_plugin rpc_plugin
= {
899 .init
= rpc_iwinfo_api_init