1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <ctype.h>
27 #include <errno.h>
28 #include <limits.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <libdladm.h>
33 #include <libdllink.h>
34 #include <libdlwlan.h>
35 #include <libgen.h>
36 #include <libnwam.h>
37
38 #include "events.h"
39 #include "known_wlans.h"
40 #include "ncu.h"
41 #include "objects.h"
42 #include "util.h"
43
44 /*
45 * known_wlans.c - contains routines which handle the known WLAN abstraction.
46 */
47
48 #define KNOWN_WIFI_NETS_FILE "/etc/nwam/known_wifi_nets"
49
50 /* enum for parsing each line of /etc/nwam/known_wifi_nets */
51 typedef enum {
52 ESSID = 0,
53 BSSID,
54 MAX_FIELDS
55 } known_wifi_nets_fields_t;
56
57 /* Structure for one BSSID */
58 typedef struct bssid {
59 struct qelem bssid_links;
60 char *bssid;
61 } bssid_t;
62
63 /* Structure for an ESSID and its BSSIDs */
64 typedef struct kw {
65 struct qelem kw_links;
66 char kw_essid[NWAM_MAX_NAME_LEN];
67 uint32_t kw_num_bssids;
68 struct qelem kw_bssids;
69 } kw_t;
70
71 /* Holds the linked-list of ESSIDs to make Known WLANs out of */
72 static struct qelem kw_list;
73
74 /* Used in walking secobjs looking for an ESSID prefix match. */
75 struct nwamd_secobj_arg {
76 char nsa_essid_prefix[DLADM_WLAN_MAX_KEYNAME_LEN];
77 char nsa_keyname[DLADM_WLAN_MAX_KEYNAME_LEN];
78 dladm_wlan_key_t *nsa_key;
79 uint64_t nsa_secmode;
80 };
81
82 static void
kw_list_init(void)83 kw_list_init(void)
84 {
85 kw_list.q_forw = kw_list.q_back = &kw_list;
86 }
87
88 static void
kw_list_free(void)89 kw_list_free(void)
90 {
91 kw_t *kw;
92 bssid_t *b;
93
94 while (kw_list.q_forw != &kw_list) {
95 kw = (kw_t *)kw_list.q_forw;
96
97 /* free kw_bssids */
98 while (kw->kw_bssids.q_forw != &kw->kw_bssids) {
99 b = (bssid_t *)kw->kw_bssids.q_forw;
100 remque(&b->bssid_links);
101 free(b->bssid);
102 free(b);
103 }
104 remque(&kw->kw_links);
105 free(kw);
106 }
107 }
108
109 /* Returns the entry in kw_list for the given ESSID. NULL if non-existent */
110 static kw_t *
kw_lookup(const char * essid)111 kw_lookup(const char *essid)
112 {
113 kw_t *kw;
114
115 if (essid == NULL)
116 return (NULL);
117
118 for (kw = (kw_t *)kw_list.q_forw;
119 kw != (kw_t *)&kw_list;
120 kw = (kw_t *)kw->kw_links.q_forw) {
121 if (strcmp(essid, kw->kw_essid) == 0)
122 return (kw);
123 }
124 return (NULL);
125 }
126
127 /* Adds an ESSID/BSSID combination to kw_list. Returns B_TRUE on success. */
128 static boolean_t
kw_add(const char * essid,const char * bssid)129 kw_add(const char *essid, const char *bssid)
130 {
131 kw_t *kw;
132 bssid_t *b;
133
134 if ((b = calloc(1, sizeof (bssid_t))) == NULL) {
135 nlog(LOG_ERR, "kw_add: cannot allocate for bssid_t: %m");
136 return (B_FALSE);
137 }
138 if ((kw = calloc(1, sizeof (kw_t))) == NULL) {
139 nlog(LOG_ERR, "kw_add: cannot allocate for kw_t: %m");
140 free(b);
141 return (B_FALSE);
142 }
143 kw->kw_bssids.q_forw = kw->kw_bssids.q_back = &kw->kw_bssids;
144
145 b->bssid = strdup(bssid);
146 (void) strlcpy(kw->kw_essid, essid, sizeof (kw->kw_essid));
147 kw->kw_num_bssids = 1;
148
149 insque(&b->bssid_links, kw->kw_bssids.q_back);
150 insque(&kw->kw_links, kw_list.q_back);
151
152 nlog(LOG_DEBUG, "kw_add: added Known WLAN %s, BSSID %s", essid, bssid);
153 return (B_TRUE);
154 }
155
156 /*
157 * Add the BSSID to the given kw. Since /etc/nwam/known_wifi_nets is
158 * populated such that the wifi networks visited later are towards the end
159 * of the file, remove the give kw from its current position and append it
160 * to the end of kw_list. This ensures that kw_list is in the reverse
161 * order of visited wifi networks. Returns B_TRUE on success.
162 */
163 static boolean_t
kw_update(kw_t * kw,const char * bssid)164 kw_update(kw_t *kw, const char *bssid)
165 {
166 bssid_t *b;
167
168 if ((b = calloc(1, sizeof (bssid_t))) == NULL) {
169 nlog(LOG_ERR, "kw_update: cannot allocate for bssid_t: %m");
170 return (B_FALSE);
171 }
172
173 b->bssid = strdup(bssid);
174 insque(&b->bssid_links, kw->kw_bssids.q_back);
175 kw->kw_num_bssids++;
176
177 /* remove kw from current position */
178 remque(&kw->kw_links);
179 /* and insert at end */
180 insque(&kw->kw_links, kw_list.q_back);
181
182 nlog(LOG_DEBUG, "kw_update: appended BSSID %s to Known WLAN %s",
183 bssid, kw->kw_essid);
184 return (B_TRUE);
185 }
186
187 /*
188 * Parses /etc/nwam/known_wifi_nets and populates kw_list, with the oldest
189 * wifi networks first in the list. Returns the number of unique entries
190 * in kw_list (to use for priority values).
191 */
192 static int
parse_known_wifi_nets(void)193 parse_known_wifi_nets(void)
194 {
195 FILE *fp;
196 char line[LINE_MAX];
197 char *cp, *tok[MAX_FIELDS];
198 int lnum, num_kw = 0;
199 kw_t *kw;
200
201 kw_list_init();
202
203 /*
204 * The file format is:
205 * essid\tbssid (essid followed by tab followed by bssid)
206 */
207 fp = fopen(KNOWN_WIFI_NETS_FILE, "r");
208 if (fp == NULL)
209 return (0);
210 for (lnum = 1; fgets(line, sizeof (line), fp) != NULL; lnum++) {
211
212 cp = line;
213 while (isspace(*cp))
214 cp++;
215 if (*cp == '#' || *cp == '\0')
216 continue;
217
218 if (bufsplit(cp, MAX_FIELDS, tok) != MAX_FIELDS) {
219 syslog(LOG_ERR, "%s:%d: wrong number of tokens; "
220 "ignoring entry", KNOWN_WIFI_NETS_FILE, lnum);
221 continue;
222 }
223
224 if ((kw = kw_lookup(tok[ESSID])) == NULL) {
225 if (!kw_add(tok[ESSID], tok[BSSID])) {
226 nlog(LOG_ERR,
227 "%s:%d: cannot add entry (%s,%s) to list",
228 KNOWN_WIFI_NETS_FILE, lnum,
229 tok[ESSID], tok[BSSID]);
230 } else {
231 num_kw++;
232 }
233 } else {
234 if (!kw_update(kw, tok[BSSID])) {
235 nlog(LOG_ERR,
236 "%s:%d:cannot update entry (%s,%s) to list",
237 KNOWN_WIFI_NETS_FILE, lnum,
238 tok[ESSID], tok[BSSID]);
239 }
240 }
241 /* next line ... */
242 }
243
244 (void) fclose(fp);
245 return (num_kw);
246 }
247
248 /*
249 * Walk security objects looking for one that matches the essid prefix.
250 * Store the key and keyname if a match is found - we use the last match
251 * as the key for the known WLAN, since it is the most recently updated.
252 */
253 /* ARGSUSED0 */
254 static boolean_t
find_secobj_matching_prefix(dladm_handle_t dh,void * arg,const char * secobjname)255 find_secobj_matching_prefix(dladm_handle_t dh, void *arg,
256 const char *secobjname)
257 {
258 struct nwamd_secobj_arg *nsa = arg;
259
260 if (strncmp(nsa->nsa_essid_prefix, secobjname,
261 strlen(nsa->nsa_essid_prefix)) == 0) {
262 nlog(LOG_DEBUG, "find_secobj_matching_prefix: "
263 "found secobj with prefix %s : %s\n",
264 nsa->nsa_essid_prefix, secobjname);
265 /* Free last key found (if any) */
266 if (nsa->nsa_key != NULL)
267 free(nsa->nsa_key);
268 /* Retrive key so we can get security mode */
269 nsa->nsa_key = nwamd_wlan_get_key_named(secobjname, 0);
270 (void) strlcpy(nsa->nsa_keyname, secobjname,
271 sizeof (nsa->nsa_keyname));
272 switch (nsa->nsa_key->wk_class) {
273 case DLADM_SECOBJ_CLASS_WEP:
274 nsa->nsa_secmode = DLADM_WLAN_SECMODE_WEP;
275 nlog(LOG_DEBUG, "find_secobj_matching_prefix: "
276 "got WEP key %s", nsa->nsa_keyname);
277 break;
278 case DLADM_SECOBJ_CLASS_WPA:
279 nsa->nsa_secmode = DLADM_WLAN_SECMODE_WPA;
280 nlog(LOG_DEBUG, "find_secobj_matching_prefix: "
281 "got WPA key %s", nsa->nsa_keyname);
282 break;
283 default:
284 /* shouldn't happen */
285 nsa->nsa_secmode = DLADM_WLAN_SECMODE_NONE;
286 nlog(LOG_ERR, "find_secobj_matching_prefix: "
287 "key class for key %s was invalid",
288 nsa->nsa_keyname);
289 break;
290 }
291 }
292 return (B_TRUE);
293 }
294
295
296 /* Upgrade /etc/nwam/known_wifi_nets file to new libnwam-based config model */
297 void
upgrade_known_wifi_nets_config(void)298 upgrade_known_wifi_nets_config(void)
299 {
300 kw_t *kw;
301 bssid_t *b;
302 nwam_known_wlan_handle_t kwh;
303 char **bssids;
304 nwam_error_t err;
305 uint64_t priority;
306 int i, num_kw;
307 struct nwamd_secobj_arg nsa;
308
309 nlog(LOG_INFO, "Upgrading %s to Known WLANs", KNOWN_WIFI_NETS_FILE);
310
311 /* Parse /etc/nwam/known_wifi_nets */
312 num_kw = parse_known_wifi_nets();
313
314 /* Create Known WLANs for each unique ESSID */
315 for (kw = (kw_t *)kw_list.q_forw, priority = num_kw-1;
316 kw != (kw_t *)&kw_list;
317 kw = (kw_t *)kw->kw_links.q_forw, priority--) {
318 nwam_value_t priorityval = NULL;
319 nwam_value_t bssidsval = NULL;
320 nwam_value_t secmodeval = NULL;
321 nwam_value_t keynameval = NULL;
322
323 nlog(LOG_DEBUG, "Creating Known WLAN %s", kw->kw_essid);
324
325 if ((err = nwam_known_wlan_create(kw->kw_essid, &kwh))
326 != NWAM_SUCCESS) {
327 nlog(LOG_ERR, "upgrade wlan %s: "
328 "could not create known wlan: %s", kw->kw_essid,
329 nwam_strerror(err));
330 continue;
331 }
332
333 /* priority of this ESSID */
334 if ((err = nwam_value_create_uint64(priority, &priorityval))
335 != NWAM_SUCCESS) {
336 nlog(LOG_ERR, "upgrade wlan %s: "
337 "could not create priority value: %s", kw->kw_essid,
338 nwam_strerror(err));
339 nwam_known_wlan_free(kwh);
340 continue;
341 }
342 err = nwam_known_wlan_set_prop_value(kwh,
343 NWAM_KNOWN_WLAN_PROP_PRIORITY, priorityval);
344 nwam_value_free(priorityval);
345 if (err != NWAM_SUCCESS) {
346 nlog(LOG_ERR, "upgrade wlan %s: "
347 "could not set priority value: %s", kw->kw_essid,
348 nwam_strerror(err));
349 nwam_known_wlan_free(kwh);
350 continue;
351 }
352
353 /* loop through kw->kw_bssids and create an array of bssids */
354 bssids = calloc(kw->kw_num_bssids, sizeof (char *));
355 if (bssids == NULL) {
356 nwam_known_wlan_free(kwh);
357 nlog(LOG_ERR, "upgrade wlan %s: "
358 "could not calloc for bssids: %m", kw->kw_essid);
359 continue;
360 }
361 for (b = (bssid_t *)kw->kw_bssids.q_forw, i = 0;
362 b != (bssid_t *)&kw->kw_bssids;
363 b = (bssid_t *)b->bssid_links.q_forw, i++) {
364 bssids[i] = strdup(b->bssid);
365 }
366
367 /* BSSIDs for this ESSID */
368 if ((err = nwam_value_create_string_array(bssids,
369 kw->kw_num_bssids, &bssidsval)) != NWAM_SUCCESS) {
370 nlog(LOG_ERR, "upgrade wlan %s: "
371 "could not create bssids value: %s", kw->kw_essid,
372 nwam_strerror(err));
373 for (i = 0; i < kw->kw_num_bssids; i++)
374 free(bssids[i]);
375 free(bssids);
376 nwam_known_wlan_free(kwh);
377 continue;
378 }
379 err = nwam_known_wlan_set_prop_value(kwh,
380 NWAM_KNOWN_WLAN_PROP_BSSIDS, bssidsval);
381 nwam_value_free(bssidsval);
382 for (i = 0; i < kw->kw_num_bssids; i++)
383 free(bssids[i]);
384 free(bssids);
385 if (err != NWAM_SUCCESS) {
386 nlog(LOG_ERR, "upgrade wlan %s: "
387 "could not set bssids: %s", kw->kw_essid,
388 nwam_strerror(err));
389 nwam_known_wlan_free(kwh);
390 continue;
391 }
392
393 /*
394 * Retrieve last key matching ESSID prefix if any, and set
395 * the retrieved key name and security mode.
396 */
397 nwamd_set_key_name(kw->kw_essid, NULL, nsa.nsa_essid_prefix,
398 sizeof (nsa.nsa_essid_prefix));
399 nsa.nsa_key = NULL;
400 nsa.nsa_secmode = DLADM_WLAN_SECMODE_NONE;
401 (void) dladm_walk_secobj(dld_handle, &nsa,
402 find_secobj_matching_prefix, DLADM_OPT_PERSIST);
403 if (nsa.nsa_key != NULL) {
404 if ((err = nwam_value_create_string(nsa.nsa_keyname,
405 &keynameval)) == NWAM_SUCCESS) {
406 (void) nwam_known_wlan_set_prop_value(kwh,
407 NWAM_KNOWN_WLAN_PROP_KEYNAME, keynameval);
408 }
409 free(nsa.nsa_key);
410 nwam_value_free(keynameval);
411 }
412
413 if ((err = nwam_value_create_uint64(nsa.nsa_secmode,
414 &secmodeval)) != NWAM_SUCCESS ||
415 (err = nwam_known_wlan_set_prop_value(kwh,
416 NWAM_KNOWN_WLAN_PROP_SECURITY_MODE, secmodeval))
417 != NWAM_SUCCESS) {
418 nlog(LOG_ERR, "upgrade wlan %s: "
419 "could not set security mode: %s",
420 kw->kw_essid, nwam_strerror(err));
421 nwam_value_free(secmodeval);
422 nwam_known_wlan_free(kwh);
423 continue;
424 }
425
426 /* commit, no collision checking by libnwam */
427 err = nwam_known_wlan_commit(kwh,
428 NWAM_FLAG_KNOWN_WLAN_NO_COLLISION_CHECK);
429 nwam_known_wlan_free(kwh);
430 if (err != NWAM_SUCCESS) {
431 nlog(LOG_ERR, "upgrade wlan %s: "
432 "could not commit wlan: %s", kw->kw_essid,
433 nwam_strerror(err));
434 }
435 /* next ... */
436 }
437
438 kw_list_free();
439 }
440
441 nwam_error_t
known_wlan_get_keyname(const char * essid,char * name)442 known_wlan_get_keyname(const char *essid, char *name)
443 {
444 nwam_known_wlan_handle_t kwh = NULL;
445 nwam_value_t keynameval = NULL;
446 char *keyname;
447 nwam_error_t err;
448
449 if ((err = nwam_known_wlan_read(essid, 0, &kwh)) != NWAM_SUCCESS)
450 return (err);
451 if ((err = nwam_known_wlan_get_prop_value(kwh,
452 NWAM_KNOWN_WLAN_PROP_KEYNAME, &keynameval)) == NWAM_SUCCESS &&
453 (err = nwam_value_get_string(keynameval, &keyname))
454 == NWAM_SUCCESS) {
455 (void) strlcpy(name, keyname, NWAM_MAX_VALUE_LEN);
456 }
457 if (keynameval != NULL)
458 nwam_value_free(keynameval);
459
460 if (kwh != NULL)
461 nwam_known_wlan_free(kwh);
462
463 return (err);
464 }
465
466 /* Performs a scan on a wifi link NCU */
467 /* ARGSUSED */
468 static int
nwamd_ncu_known_wlan_committed(nwamd_object_t object,void * data)469 nwamd_ncu_known_wlan_committed(nwamd_object_t object, void *data)
470 {
471 nwamd_ncu_t *ncu_data = object->nwamd_object_data;
472
473 if (ncu_data->ncu_type != NWAM_NCU_TYPE_LINK)
474 return (0);
475
476 /* network selection will be done only if possible */
477 if (ncu_data->ncu_link.nwamd_link_media == DL_WIFI)
478 (void) nwamd_wlan_scan(ncu_data->ncu_name);
479 return (0);
480 }
481
482 /* Handle known WLAN initialization/refresh event */
483 /* ARGSUSED */
484 void
nwamd_known_wlan_handle_init_event(nwamd_event_t known_wlan_event)485 nwamd_known_wlan_handle_init_event(nwamd_event_t known_wlan_event)
486 {
487 /*
488 * Since the Known WLAN list has changed, do a rescan so that the
489 * best network is selected.
490 */
491 (void) nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU,
492 nwamd_ncu_known_wlan_committed, NULL);
493 }
494
495 void
nwamd_known_wlan_handle_action_event(nwamd_event_t known_wlan_event)496 nwamd_known_wlan_handle_action_event(nwamd_event_t known_wlan_event)
497 {
498 switch (known_wlan_event->event_msg->nwe_data.nwe_object_action.
499 nwe_action) {
500 case NWAM_ACTION_ADD:
501 case NWAM_ACTION_REFRESH:
502 nwamd_known_wlan_handle_init_event(known_wlan_event);
503 break;
504 case NWAM_ACTION_DESTROY:
505 /* Nothing needs to be done for destroy */
506 break;
507 /* all other events are invalid for known WLANs */
508 case NWAM_ACTION_ENABLE:
509 case NWAM_ACTION_DISABLE:
510 default:
511 nlog(LOG_INFO, "nwam_known_wlan_handle_action_event: "
512 "unexpected action");
513 break;
514 }
515 }
516
517 int
nwamd_known_wlan_action(const char * known_wlan,nwam_action_t action)518 nwamd_known_wlan_action(const char *known_wlan, nwam_action_t action)
519 {
520 nwamd_event_t known_wlan_event = nwamd_event_init_object_action
521 (NWAM_OBJECT_TYPE_KNOWN_WLAN, known_wlan, NULL, action);
522 if (known_wlan_event == NULL)
523 return (1);
524 nwamd_event_enqueue(known_wlan_event);
525 return (0);
526 }
527