projects / project / rpcd.git / blob
? search:


983001ab2359ca04e11770e9e8de98bbd71c9eb4
[project/rpcd.git] / iwinfo.c
1 /*
2 * rpcd - UBUS RPC server
3 *
4 * Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
5 *
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.
9 *
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.
17 */
18
19 #include <sys/types.h>
20 #include <dirent.h>
21 #include <libubus.h>
22 #include <iwinfo.h>
23 #include <iwinfo/utils.h>
24 #include <net/ethernet.h>
25
26 #ifdef linux
27 #include <netinet/ether.h>
28 #endif
29
30 #include <rpcd/plugin.h>
31
32
33 static struct blob_buf buf;
34 static const struct iwinfo_ops *iw;
35 static const char *ifname;
36
37 enum {
38 RPC_D_DEVICE,
39 __RPC_D_MAX,
40 };
41
42 static const struct blobmsg_policy rpc_device_policy[__RPC_D_MAX] = {
43 [RPC_D_DEVICE] = { .name = "device", .type = BLOBMSG_TYPE_STRING },
44 };
45
46 enum {
47 RPC_A_DEVICE,
48 RPC_A_MACADDR,
49 __RPC_A_MAX,
50 };
51
52 static const struct blobmsg_policy rpc_assoclist_policy[__RPC_A_MAX] = {
53 [RPC_A_DEVICE] = { .name = "device", .type = BLOBMSG_TYPE_STRING },
54 [RPC_A_MACADDR] = { .name = "mac", .type = BLOBMSG_TYPE_STRING },
55 };
56
57 enum {
58 RPC_U_SECTION,
59 __RPC_U_MAX
60 };
61
62 static const struct blobmsg_policy rpc_uci_policy[__RPC_U_MAX] = {
63 [RPC_U_SECTION] = { .name = "section", .type = BLOBMSG_TYPE_STRING },
64 };
65
66 static int
67 __rpc_iwinfo_open(struct blob_attr *device)
68 {
69 if (!device)
70 return UBUS_STATUS_INVALID_ARGUMENT;
71
72 ifname = blobmsg_data(device);
73 iw = iwinfo_backend(ifname);
74
75 return iw ? UBUS_STATUS_OK : UBUS_STATUS_NOT_FOUND;
76 }
77
78 static int
79 rpc_iwinfo_open(struct blob_attr *msg)
80 {
81 static struct blob_attr *tb[__RPC_D_MAX];
82
83 blobmsg_parse(rpc_device_policy, __RPC_D_MAX, tb,
84 blob_data(msg), blob_len(msg));
85
86 return __rpc_iwinfo_open(tb[RPC_D_DEVICE]);
87 }
88
89 static void
90 rpc_iwinfo_close(void)
91 {
92 iw = NULL;
93 ifname = NULL;
94 iwinfo_finish();
95 }
96
97 static void
98 rpc_iwinfo_call_int(const char *name, int (*func)(const char *, int *),
99 const char **map)
100 {
101 int rv;
102
103 if (!func(ifname, &rv))
104 {
105 if (!map)
106 blobmsg_add_u32(&buf, name, rv);
107 else
108 blobmsg_add_string(&buf, name, map[rv]);
109 }
110 }
111
112 static void
113 rpc_iwinfo_call_hardware_id(const char *name)
114 {
115 struct iwinfo_hardware_id ids;
116 void *c;
117
118 if (!iw->hardware_id(ifname, (char *)&ids))
119 {
120 c = blobmsg_open_array(&buf, name);
121
122 blobmsg_add_u32(&buf, NULL, ids.vendor_id);
123 blobmsg_add_u32(&buf, NULL, ids.device_id);
124 blobmsg_add_u32(&buf, NULL, ids.subsystem_vendor_id);
125 blobmsg_add_u32(&buf, NULL, ids.subsystem_device_id);
126
127 blobmsg_close_array(&buf, c);
128 }
129 }
130
131 static void
132 rpc_iwinfo_add_encryption(const char *name, struct iwinfo_crypto_entry *e)
133 {
134 int ciph;
135 void *c, *d;
136
137 c = blobmsg_open_table(&buf, name);
138
139 blobmsg_add_u8(&buf, "enabled", e->enabled);
140
141 if (e->enabled)
142 {
143 if (!e->wpa_version)
144 {
145 d = blobmsg_open_array(&buf, "wep");
146
147 if (e->auth_algs & IWINFO_AUTH_OPEN)
148 blobmsg_add_string(&buf, NULL, "open");
149
150 if (e->auth_algs & IWINFO_AUTH_SHARED)
151 blobmsg_add_string(&buf, NULL, "shared");
152
153 blobmsg_close_array(&buf, d);
154 }
155 else
156 {
157 d = blobmsg_open_array(&buf, "wpa");
158
159 if (e->wpa_version > 2)
160 {
161 blobmsg_add_u32(&buf, NULL, 1);
162 blobmsg_add_u32(&buf, NULL, 2);
163 }
164 else
165 {
166 blobmsg_add_u32(&buf, NULL, e->wpa_version);
167 }
168
169 blobmsg_close_array(&buf, d);
170
171
172 d = blobmsg_open_array(&buf, "authentication");
173
174 if (e->auth_suites & IWINFO_KMGMT_PSK)
175 blobmsg_add_string(&buf, NULL, "psk");
176
177 if (e->auth_suites & IWINFO_KMGMT_8021x)
178 blobmsg_add_string(&buf, NULL, "802.1x");
179
180 if (!e->auth_suites ||
181 (e->auth_suites & IWINFO_KMGMT_NONE))
182 blobmsg_add_string(&buf, NULL, "none");
183
184 blobmsg_close_array(&buf, d);
185 }
186
187 d = blobmsg_open_array(&buf, "ciphers");
188 ciph = e->pair_ciphers | e->group_ciphers;
189
190 if (ciph & IWINFO_CIPHER_WEP40)
191 blobmsg_add_string(&buf, NULL, "wep-40");
192
193 if (ciph & IWINFO_CIPHER_WEP104)
194 blobmsg_add_string(&buf, NULL, "wep-104");
195
196 if (ciph & IWINFO_CIPHER_TKIP)
197 blobmsg_add_string(&buf, NULL, "tkip");
198
199 if (ciph & IWINFO_CIPHER_CCMP)
200 blobmsg_add_string(&buf, NULL, "ccmp");
201
202 if (ciph & IWINFO_CIPHER_WRAP)
203 blobmsg_add_string(&buf, NULL, "wrap");
204
205 if (ciph & IWINFO_CIPHER_AESOCB)
206 blobmsg_add_string(&buf, NULL, "aes-ocb");
207
208 if (ciph & IWINFO_CIPHER_CKIP)
209 blobmsg_add_string(&buf, NULL, "ckip");
210
211 if (!ciph || (ciph & IWINFO_CIPHER_NONE))
212 blobmsg_add_string(&buf, NULL, "none");
213
214 blobmsg_close_array(&buf, d);
215 }
216
217 blobmsg_close_table(&buf, c);
218 }
219
220 static void
221 rpc_iwinfo_call_encryption(const char *name)
222 {
223 struct iwinfo_crypto_entry crypto = { 0 };
224
225 if (!iw->encryption(ifname, (char *)&crypto))
226 rpc_iwinfo_add_encryption(name, &crypto);
227 }
228
229 static void
230 rpc_iwinfo_call_htmodes(const char *name)
231 {
232 int modes;
233 void *c;
234
235 if (!iw->htmodelist(ifname, &modes))
236 {
237 c = blobmsg_open_array(&buf, name);
238
239 if (modes & IWINFO_HTMODE_HT20)
240 blobmsg_add_string(&buf, NULL, "HT20");
241
242 if (modes & IWINFO_HTMODE_HT40)
243 blobmsg_add_string(&buf, NULL, "HT40");
244
245 if (modes & IWINFO_HTMODE_VHT20)
246 blobmsg_add_string(&buf, NULL, "VHT20");
247
248 if (modes & IWINFO_HTMODE_VHT40)
249 blobmsg_add_string(&buf, NULL, "VHT40");
250
251 if (modes & IWINFO_HTMODE_VHT80)
252 blobmsg_add_string(&buf, NULL, "VHT80");
253
254 if (modes & IWINFO_HTMODE_VHT80_80)
255 blobmsg_add_string(&buf, NULL, "VHT80+80");
256
257 if (modes & IWINFO_HTMODE_VHT160)
258 blobmsg_add_string(&buf, NULL, "VHT160");
259
260 blobmsg_close_array(&buf, c);
261 }
262 }
263
264 static void
265 rpc_iwinfo_call_hwmodes(const char *name)
266 {
267 int modes;
268 void *c;
269
270 if (!iw->hwmodelist(ifname, &modes))
271 {
272 c = blobmsg_open_array(&buf, name);
273
274 if (modes & IWINFO_80211_AC)
275 blobmsg_add_string(&buf, NULL, "ac");
276
277 if (modes & IWINFO_80211_A)
278 blobmsg_add_string(&buf, NULL, "a");
279
280 if (modes & IWINFO_80211_B)
281 blobmsg_add_string(&buf, NULL, "b");
282
283 if (modes & IWINFO_80211_G)
284 blobmsg_add_string(&buf, NULL, "g");
285
286 if (modes & IWINFO_80211_N)
287 blobmsg_add_string(&buf, NULL, "n");
288
289 blobmsg_close_array(&buf, c);
290 }
291 }
292
293 static void
294 rpc_iwinfo_call_str(const char *name, int (*func)(const char *, char *))
295 {
296 char rv[IWINFO_BUFSIZE] = { 0 };
297
298 if (!func(ifname, rv))
299 blobmsg_add_string(&buf, name, rv);
300 }
301
302 static int
303 rpc_iwinfo_info(struct ubus_context *ctx, struct ubus_object *obj,
304 struct ubus_request_data *req, const char *method,
305 struct blob_attr *msg)
306 {
307 int rv;
308 void *c;
309
310 rv = rpc_iwinfo_open(msg);
311
312 if (rv)
313 return rv;
314
315 blob_buf_init(&buf, 0);
316
317 rpc_iwinfo_call_str("phy", iw->phyname);
318
319 rpc_iwinfo_call_str("ssid", iw->ssid);
320 rpc_iwinfo_call_str("bssid", iw->bssid);
321 rpc_iwinfo_call_str("country", iw->country);
322
323 rpc_iwinfo_call_int("mode", iw->mode, IWINFO_OPMODE_NAMES);
324 rpc_iwinfo_call_int("channel", iw->channel, NULL);
325
326 rpc_iwinfo_call_int("frequency", iw->frequency, NULL);
327 rpc_iwinfo_call_int("frequency_offset", iw->frequency_offset, NULL);
328
329 rpc_iwinfo_call_int("txpower", iw->txpower, NULL);
330 rpc_iwinfo_call_int("txpower_offset", iw->txpower_offset, NULL);
331
332 rpc_iwinfo_call_int("quality", iw->quality, NULL);
333 rpc_iwinfo_call_int("quality_max", iw->quality_max, NULL);
334
335 rpc_iwinfo_call_int("signal", iw->signal, NULL);
336 rpc_iwinfo_call_int("noise", iw->noise, NULL);
337
338 rpc_iwinfo_call_int("bitrate", iw->bitrate, NULL);
339
340 rpc_iwinfo_call_encryption("encryption");
341 rpc_iwinfo_call_htmodes("htmodes");
342 rpc_iwinfo_call_hwmodes("hwmodes");
343
344 c = blobmsg_open_table(&buf, "hardware");
345 rpc_iwinfo_call_hardware_id("id");
346 rpc_iwinfo_call_str("name", iw->hardware_name);
347 blobmsg_close_table(&buf, c);
348
349 ubus_send_reply(ctx, req, buf.head);
350
351 rpc_iwinfo_close();
352
353 return UBUS_STATUS_OK;
354 }
355
356 static int
357 rpc_iwinfo_scan(struct ubus_context *ctx, struct ubus_object *obj,
358 struct ubus_request_data *req, const char *method,
359 struct blob_attr *msg)
360 {
361 int i, rv, len;
362 void *c, *d;
363 char mac[18];
364 char res[IWINFO_BUFSIZE];
365 struct iwinfo_scanlist_entry *e;
366
367 rv = rpc_iwinfo_open(msg);
368
369 if (rv)
370 return rv;
371
372 blob_buf_init(&buf, 0);
373
374 c = blobmsg_open_array(&buf, "results");
375
376 if (!iw->scanlist(ifname, res, &len) && (len > 0))
377 {
378 for (i = 0; i < len; i += sizeof(struct iwinfo_scanlist_entry))
379 {
380 e = (struct iwinfo_scanlist_entry *)&res[i];
381 d = blobmsg_open_table(&buf, NULL);
382
383 if (e->ssid[0])
384 blobmsg_add_string(&buf, "ssid", (const char *)e->ssid);
385
386 snprintf(mac, sizeof(mac), "%02X:%02X:%02X:%02X:%02X:%02X",
387 e->mac[0], e->mac[1], e->mac[2],
388 e->mac[3], e->mac[4], e->mac[5]);
389
390 blobmsg_add_string(&buf, "bssid", mac);
391
392 blobmsg_add_string(&buf, "mode", IWINFO_OPMODE_NAMES[e->mode]);
393
394 blobmsg_add_u32(&buf, "channel", e->channel);
395 blobmsg_add_u32(&buf, "signal", (uint32_t)(e->signal - 0x100));
396
397 blobmsg_add_u32(&buf, "quality", e->quality);
398 blobmsg_add_u32(&buf, "quality_max", e->quality_max);
399
400 rpc_iwinfo_add_encryption("encryption", &e->crypto);
401
402 blobmsg_close_table(&buf, d);
403 }
404 }
405
406 blobmsg_close_array(&buf, c);
407
408 ubus_send_reply(ctx, req, buf.head);
409
410 rpc_iwinfo_close();
411
412 return UBUS_STATUS_OK;
413 }
414
415 static int
416 rpc_iwinfo_assoclist(struct ubus_context *ctx, struct ubus_object *obj,
417 struct ubus_request_data *req, const char *method,
418 struct blob_attr *msg)
419 {
420 int i, rv, len;
421 char mac[18];
422 char res[IWINFO_BUFSIZE];
423 struct iwinfo_assoclist_entry *a;
424 struct ether_addr *macaddr = NULL;
425 void *c, *d, *e;
426 struct blob_attr *tb[__RPC_A_MAX];
427 bool found = false;
428
429 blobmsg_parse(rpc_assoclist_policy, __RPC_A_MAX, tb,
430 blob_data(msg), blob_len(msg));
431
432 rv = __rpc_iwinfo_open(tb[RPC_A_DEVICE]);
433 if (rv)
434 return rv;
435
436 if (tb[RPC_A_MACADDR])
437 macaddr = ether_aton(blobmsg_data(tb[RPC_A_MACADDR]));
438
439 blob_buf_init(&buf, 0);
440
441 if (!macaddr)
442 c = blobmsg_open_array(&buf, "results");
443
444 if (!iw->assoclist(ifname, res, &len) && (len > 0))
445 {
446 for (i = 0; i < len; i += sizeof(struct iwinfo_assoclist_entry))
447 {
448 a = (struct iwinfo_assoclist_entry *)&res[i];
449
450 if (!macaddr)
451 d = blobmsg_open_table(&buf, NULL);
452 else if (memcmp(macaddr, a->mac, ETH_ALEN) != 0)
453 continue;
454
455 snprintf(mac, sizeof(mac), "%02X:%02X:%02X:%02X:%02X:%02X",
456 a->mac[0], a->mac[1], a->mac[2],
457 a->mac[3], a->mac[4], a->mac[5]);
458
459 blobmsg_add_string(&buf, "mac", mac);
460 blobmsg_add_u32(&buf, "signal", a->signal);
461 blobmsg_add_u32(&buf, "signal_avg", a->signal_avg);
462 blobmsg_add_u32(&buf, "noise", a->noise);
463 blobmsg_add_u32(&buf, "inactive", a->inactive);
464 blobmsg_add_u32(&buf, "connected_time", a->connected_time);
465 blobmsg_add_u32(&buf, "thr", a->thr);
466 blobmsg_add_u8(&buf, "authorized", a->is_authorized);
467 blobmsg_add_u8(&buf, "authenticated", a->is_authenticated);
468 blobmsg_add_string(&buf, "preamble", a->is_preamble_short ? "short" : "long");
469 blobmsg_add_u8(&buf, "wme", a->is_wme);
470 blobmsg_add_u8(&buf, "mfp", a->is_mfp);
471 blobmsg_add_u8(&buf, "tdls", a->is_tdls);
472
473 e = blobmsg_open_table(&buf, "rx");
474 blobmsg_add_u64(&buf, "drop_misc", a->rx_drop_misc);
475 blobmsg_add_u32(&buf, "packets", a->rx_packets);
476 blobmsg_add_u32(&buf, "bytes", a->rx_bytes);
477 blobmsg_add_u32(&buf, "rate", a->rx_rate.rate);
478 blobmsg_add_u32(&buf, "mcs", a->rx_rate.mcs);
479 blobmsg_add_u8(&buf, "40mhz", a->rx_rate.is_40mhz);
480 blobmsg_add_u8(&buf, "short_gi", a->rx_rate.is_short_gi);
481 blobmsg_close_table(&buf, e);
482
483 e = blobmsg_open_table(&buf, "tx");
484 blobmsg_add_u32(&buf, "failed", a->tx_failed);
485 blobmsg_add_u32(&buf, "retries", a->tx_retries);
486 blobmsg_add_u32(&buf, "packets", a->tx_packets);
487 blobmsg_add_u32(&buf, "bytes", a->tx_bytes);
488 blobmsg_add_u32(&buf, "rate", a->tx_rate.rate);
489 blobmsg_add_u32(&buf, "mcs", a->tx_rate.mcs);
490 blobmsg_add_u8(&buf, "40mhz", a->tx_rate.is_40mhz);
491 blobmsg_add_u8(&buf, "short_gi", a->tx_rate.is_short_gi);
492 blobmsg_close_table(&buf, e);
493
494 found = true;
495 if (!macaddr)
496 blobmsg_close_table(&buf, d);
497 else
498 break;
499 }
500 }
501
502 if (!macaddr)
503 blobmsg_close_array(&buf, c);
504 else if (!found)
505 return UBUS_STATUS_NOT_FOUND;
506
507 ubus_send_reply(ctx, req, buf.head);
508
509 rpc_iwinfo_close();
510
511 return UBUS_STATUS_OK;
512 }
513
514 static int
515 rpc_iwinfo_survey(struct ubus_context *ctx, struct ubus_object *obj,
516 struct ubus_request_data *req, const char *method,
517 struct blob_attr *msg)
518 {
519 char res[IWINFO_BUFSIZE];
520 struct iwinfo_survey_entry *e;
521 void *c, *d;
522 int i, rv, len;
523
524 blob_buf_init(&buf, 0);
525
526 rv = rpc_iwinfo_open(msg);
527
528 c = blobmsg_open_array(&buf, "results");
529
530 if (rv || iw->survey(ifname, res, &len) || len < 0)
531 return UBUS_STATUS_OK;
532
533 for (i = 0; i < len; i += sizeof(struct iwinfo_survey_entry)) {
534 e = (struct iwinfo_survey_entry *)&res[i];
535
536 d = blobmsg_open_table(&buf, NULL);
537 blobmsg_add_u32(&buf, "mhz", e->mhz);
538 blobmsg_add_u32(&buf, "noise", e->noise);
539 blobmsg_add_u64(&buf, "active_time", e->active_time);
540 blobmsg_add_u64(&buf, "busy_time", e->busy_time);
541 blobmsg_add_u64(&buf, "busy_time_ext", e->busy_time_ext);
542 blobmsg_add_u64(&buf, "rx_time", e->rxtime);
543 blobmsg_add_u64(&buf, "tx_time", e->txtime);
544 blobmsg_close_table(&buf, d);
545 }
546
547 blobmsg_close_array(&buf, c);
548 ubus_send_reply(ctx, req, buf.head);
549 rpc_iwinfo_close();
550 return UBUS_STATUS_OK;
551 }
552
553 static int
554 rpc_iwinfo_freqlist(struct ubus_context *ctx, struct ubus_object *obj,
555 struct ubus_request_data *req, const char *method,
556 struct blob_attr *msg)
557 {
558 int i, rv, len, ch;
559 char res[IWINFO_BUFSIZE];
560 struct iwinfo_freqlist_entry *f;
561 void *c, *d;
562
563 rv = rpc_iwinfo_open(msg);
564
565 if (rv)
566 return rv;
567
568 blob_buf_init(&buf, 0);
569
570 c = blobmsg_open_array(&buf, "results");
571
572 if (!iw->freqlist(ifname, res, &len) && (len > 0))
573 {
574 if (iw->channel(ifname, &ch))
575 ch = -1;
576
577 for (i = 0; i < len; i += sizeof(struct iwinfo_freqlist_entry))
578 {
579 f = (struct iwinfo_freqlist_entry *)&res[i];
580 d = blobmsg_open_table(&buf, NULL);
581
582 blobmsg_add_u32(&buf, "channel", f->channel);
583 blobmsg_add_u32(&buf, "mhz", f->mhz);
584 blobmsg_add_u8(&buf, "restricted", f->restricted);
585
586 if (ch > -1)
587 blobmsg_add_u8(&buf, "active", f->channel == ch);
588
589 blobmsg_close_table(&buf, d);
590 }
591 }
592
593 blobmsg_close_array(&buf, c);
594
595 ubus_send_reply(ctx, req, buf.head);
596
597 rpc_iwinfo_close();
598
599 return UBUS_STATUS_OK;
600 }
601
602 static int
603 rpc_iwinfo_txpowerlist(struct ubus_context *ctx, struct ubus_object *obj,
604 struct ubus_request_data *req, const char *method,
605 struct blob_attr *msg)
606 {
607 int i, rv, len, pwr, off;
608 char res[IWINFO_BUFSIZE];
609 struct iwinfo_txpwrlist_entry *t;
610 void *c, *d;
611
612 rv = rpc_iwinfo_open(msg);
613
614 if (rv)
615 return rv;
616
617 blob_buf_init(&buf, 0);
618
619 c = blobmsg_open_array(&buf, "results");
620
621 if (!iw->txpwrlist(ifname, res, &len) && (len > 0))
622 {
623 if (iw->txpower(ifname, &pwr))
624 pwr = -1;
625
626 if (iw->txpower_offset(ifname, &off))
627 off = 0;
628
629 for (i = 0; i < len; i += sizeof(struct iwinfo_txpwrlist_entry))
630 {
631 t = (struct iwinfo_txpwrlist_entry *)&res[i];
632 d = blobmsg_open_table(&buf, NULL);
633
634 blobmsg_add_u32(&buf, "dbm", t->dbm + off);
635 blobmsg_add_u32(&buf, "mw", iwinfo_dbm2mw(t->dbm + off));
636
637 if (pwr > -1)
638 blobmsg_add_u8(&buf, "active", t->dbm == pwr);
639
640 blobmsg_close_table(&buf, d);
641 }
642 }
643
644 blobmsg_close_array(&buf, c);
645
646 ubus_send_reply(ctx, req, buf.head);
647
648 rpc_iwinfo_close();
649
650 return UBUS_STATUS_OK;
651 }
652
653 static const char *
654 rpc_iwinfo_lookup_country(char *buf, int len, int iso3166)
655 {
656 int i;
657 static char ccode[5];
658 struct iwinfo_country_entry *c;
659
660 for (i = 0; i < len; i += sizeof(struct iwinfo_country_entry))
661 {
662 c = (struct iwinfo_country_entry *)&buf[i];
663
664 if (c->iso3166 == iso3166)
665 {
666 snprintf(ccode, sizeof(ccode), "%s", c->ccode);
667 return ccode;
668 }
669 }
670
671 return NULL;
672 }
673
674 static int
675 rpc_iwinfo_countrylist(struct ubus_context *ctx, struct ubus_object *obj,
676 struct ubus_request_data *req, const char *method,
677 struct blob_attr *msg)
678 {
679 int rv, len;
680 char cur[3];
681 char iso3166[3];
682 char res[IWINFO_BUFSIZE] = {0};
683 const char *ccode;
684 const struct iwinfo_iso3166_label *l;
685 void *c, *d;
686
687 rv = rpc_iwinfo_open(msg);
688
689 if (rv)
690 return rv;
691
692 blob_buf_init(&buf, 0);
693
694 c = blobmsg_open_array(&buf, "results");
695
696 if (!iw->countrylist(ifname, res, &len) && (len > 0))
697 {
698 if (iw->country(ifname, cur))
699 memset(cur, 0, sizeof(cur));
700
701 for (l = IWINFO_ISO3166_NAMES; l->iso3166; l++)
702 {
703 ccode = rpc_iwinfo_lookup_country(res, len, l->iso3166);
704
705 if (!ccode)
706 continue;
707
708 d = blobmsg_open_table(&buf, NULL);
709
710 blobmsg_add_string(&buf, "code", ccode);
711 blobmsg_add_string(&buf, "country", (const char *)l->name);
712
713 snprintf(iso3166, sizeof(iso3166), "%c%c",
714 (l->iso3166 / 256), (l->iso3166 % 256));
715
716 blobmsg_add_string(&buf, "iso3166", iso3166);
717
718 if (cur[0])
719 blobmsg_add_u8(&buf, "active", !strncmp(ccode, cur, 2));
720
721 blobmsg_close_table(&buf, d);
722 }
723 }
724
725 blobmsg_close_array(&buf, c);
726
727 ubus_send_reply(ctx, req, buf.head);
728
729 rpc_iwinfo_close();
730
731 return UBUS_STATUS_OK;
732 }
733
734 static int
735 rpc_iwinfo_phyname(struct ubus_context *ctx, struct ubus_object *obj,
736 struct ubus_request_data *req, const char *method,
737 struct blob_attr *msg)
738 {
739 int i;
740 bool found = false;
741 char res[IWINFO_BUFSIZE];
742 const struct iwinfo_ops *ops;
743 struct blob_attr *tb[__RPC_U_MAX];
744 const char *backends[] = {
745 "nl80211",
746 "madwifi",
747 "wl"
748 };
749
750 blobmsg_parse(rpc_uci_policy, __RPC_U_MAX, tb,
751 blob_data(msg), blob_len(msg));
752
753 if (!tb[RPC_U_SECTION])
754 return UBUS_STATUS_INVALID_ARGUMENT;
755
756 for (i = 0; i < ARRAY_SIZE(backends); i++)
757 {
758 ops = iwinfo_backend_by_name(backends[i]);
759
760 if (!ops || !ops->lookup_phy)
761 continue;
762
763 if (!ops->lookup_phy(blobmsg_get_string(tb[RPC_U_SECTION]), res))
764 {
765 found = true;
766 break;
767 }
768 }
769
770 if (found)
771 {
772 blob_buf_init(&buf, 0);
773 blobmsg_add_string(&buf, "phyname", res);
774
775 ubus_send_reply(ctx, req, buf.head);
776 }
777
778 rpc_iwinfo_close();
779
780 return found ? UBUS_STATUS_OK : UBUS_STATUS_NOT_FOUND;
781 }
782
783 static int
784 rpc_iwinfo_devices(struct ubus_context *ctx, struct ubus_object *obj,
785 struct ubus_request_data *req, const char *method,
786 struct blob_attr *msg)
787 {
788 void *c;
789 struct dirent *e;
790 DIR *d;
791
792 d = opendir("/sys/class/net");
793
794 if (!d)
795 return UBUS_STATUS_UNKNOWN_ERROR;
796
797 blob_buf_init(&buf, 0);
798
799 c = blobmsg_open_array(&buf, "devices");
800
801 while ((e = readdir(d)) != NULL)
802 {
803 if (e->d_type != DT_LNK)
804 continue;
805
806 if (iwinfo_type(e->d_name))
807 blobmsg_add_string(&buf, NULL, e->d_name);
808 }
809
810 blobmsg_close_array(&buf, c);
811
812 closedir(d);
813
814 ubus_send_reply(ctx, req, buf.head);
815
816 rpc_iwinfo_close();
817
818 return UBUS_STATUS_OK;
819 }
820
821
822 static int
823 rpc_iwinfo_api_init(const struct rpc_daemon_ops *o, struct ubus_context *ctx)
824 {
825 static const struct ubus_method iwinfo_methods[] = {
826 UBUS_METHOD_NOARG("devices", rpc_iwinfo_devices),
827 UBUS_METHOD("info", rpc_iwinfo_info, rpc_device_policy),
828 UBUS_METHOD("scan", rpc_iwinfo_scan, rpc_device_policy),
829 UBUS_METHOD("assoclist", rpc_iwinfo_assoclist, rpc_assoclist_policy),
830 UBUS_METHOD("freqlist", rpc_iwinfo_freqlist, rpc_device_policy),
831 UBUS_METHOD("txpowerlist", rpc_iwinfo_txpowerlist, rpc_device_policy),
832 UBUS_METHOD("countrylist", rpc_iwinfo_countrylist, rpc_device_policy),
833 UBUS_METHOD("survey", rpc_iwinfo_survey, rpc_device_policy),
834 UBUS_METHOD("phyname", rpc_iwinfo_phyname, rpc_uci_policy),
835 };
836
837 static struct ubus_object_type iwinfo_type =
838 UBUS_OBJECT_TYPE("luci-rpc-iwinfo", iwinfo_methods);
839
840 static struct ubus_object obj = {
841 .name = "iwinfo",
842 .type = &iwinfo_type,
843 .methods = iwinfo_methods,
844 .n_methods = ARRAY_SIZE(iwinfo_methods),
845 };
846
847 return ubus_add_object(ctx, &obj);
848 }
849
850 struct rpc_plugin rpc_plugin = {
851 .init = rpc_iwinfo_api_init
852 };
OpenWrt ubus RPC daemon