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 <arpa/inet.h>
27 #include <ctype.h>
28 #include <errno.h>
29 #include <inet/ip.h>
30 #include <libdladm.h>
31 #include <libdllink.h>
32 #include <libdlwlan.h>
33 #include <netdb.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37
38 #include <libnwam.h>
39 #include "conditions.h"
40 #include "ncu.h"
41 #include "objects.h"
42 #include "util.h"
43
44 /*
45 * conditions.c - contains routines which check state to see if activation
46 * conditions for NWAM objects are satisfied and rates activation conditions to
47 * help determine which is most specific.
48 *
49 * If the activation-mode is CONDITIONAL_ANY or CONDITIONAL_ALL, the conditions
50 * property is set to a string made up of conditional expressions. Each
51 * expression is made up of a condition that can be assigned a boolean value,
52 * e.g. "system-domain is sun.com" or "ncu ip:bge0 is-not active". If the
53 * activation-mode is CONDITIONAL_ANY, the condition will be satisfied if any
54 * one of the conditions is true; if the activation-mode is CONDITIONAL_ALL,
55 * the condition is satisfied only if all of the conditions are true.
56 */
57
58 uint64_t condition_check_interval = CONDITION_CHECK_INTERVAL_DEFAULT;
59
60 extern int getdomainname(char *, int);
61
62 /* NCP, NCU, ENM and location conditions */
63 static boolean_t test_condition_ncp(nwam_condition_t condition,
64 const char *ncp_name);
65 static boolean_t test_condition_ncu(nwam_condition_t condition,
66 const char *ncu_name);
67 static boolean_t test_condition_enm(nwam_condition_t condition,
68 const char *enm_name);
69 static boolean_t test_condition_loc(nwam_condition_t condition,
70 const char *loc_name);
71
72 /* IP address conditions */
73 static boolean_t test_condition_ip_address(nwam_condition_t condition,
74 const char *ip_address);
75
76 /* domainname conditions */
77 static boolean_t test_condition_sys_domain(nwam_condition_t condition,
78 const char *domainname);
79 static boolean_t test_condition_adv_domain(nwam_condition_t condition,
80 const char *domainname);
81
82 /* WLAN conditions */
83 static boolean_t test_condition_wireless_essid(nwam_condition_t condition,
84 const char *essid);
85 static boolean_t test_condition_wireless_bssid(nwam_condition_t condition,
86 const char *essid);
87
88 struct nwamd_condition_map {
89 nwam_condition_object_type_t object_type;
90 boolean_t (*condition_func)(nwam_condition_t, const char *);
91 } condition_map[] =
92 {
93 { NWAM_CONDITION_OBJECT_TYPE_NCP, test_condition_ncp },
94 { NWAM_CONDITION_OBJECT_TYPE_NCU, test_condition_ncu },
95 { NWAM_CONDITION_OBJECT_TYPE_ENM, test_condition_enm },
96 { NWAM_CONDITION_OBJECT_TYPE_LOC, test_condition_loc },
97 { NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS, test_condition_ip_address },
98 { NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN, test_condition_sys_domain },
99 { NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN, test_condition_adv_domain },
100 { NWAM_CONDITION_OBJECT_TYPE_ESSID, test_condition_wireless_essid },
101 { NWAM_CONDITION_OBJECT_TYPE_BSSID, test_condition_wireless_bssid }
102 };
103
104 /*
105 * This function takes which kind of conditions (is or is not) we are testing
106 * the object against and an object and applies the conditon to the object.
107 */
108 static boolean_t
test_condition_object_state(nwam_condition_t condition,nwam_object_type_t object_type,const char * object_name)109 test_condition_object_state(nwam_condition_t condition,
110 nwam_object_type_t object_type, const char *object_name)
111 {
112 nwamd_object_t object;
113 nwam_state_t state;
114
115 object = nwamd_object_find(object_type, object_name);
116 if (object == NULL)
117 return (B_FALSE);
118
119 state = object->nwamd_object_state;
120 nwamd_object_release(object);
121
122 switch (condition) {
123 case NWAM_CONDITION_IS:
124 return (state == NWAM_STATE_ONLINE);
125 case NWAM_CONDITION_IS_NOT:
126 return (state != NWAM_STATE_ONLINE);
127 default:
128 return (B_FALSE);
129 }
130 }
131
132 static boolean_t
test_condition_ncp(nwam_condition_t condition,const char * name)133 test_condition_ncp(nwam_condition_t condition, const char *name)
134 {
135 boolean_t active;
136
137 (void) pthread_mutex_lock(&active_ncp_mutex);
138 active = (strcasecmp(active_ncp, name) == 0);
139 (void) pthread_mutex_unlock(&active_ncp_mutex);
140
141 switch (condition) {
142 case NWAM_CONDITION_IS:
143 return (active);
144 case NWAM_CONDITION_IS_NOT:
145 return (active != B_TRUE);
146 default:
147 return (B_FALSE);
148 }
149 }
150
151 static boolean_t
test_condition_ncu(nwam_condition_t condition,const char * name)152 test_condition_ncu(nwam_condition_t condition, const char *name)
153 {
154 char *real_name, *ncu_name;
155 nwam_ncu_handle_t ncuh;
156 nwam_ncu_type_t ncu_type;
157 boolean_t rv;
158
159 /* names are case-insensitive, so get real name from libnwam */
160 if (nwam_ncu_read(active_ncph, name, NWAM_NCU_TYPE_INTERFACE, 0, &ncuh)
161 == NWAM_SUCCESS) {
162 ncu_type = NWAM_NCU_TYPE_INTERFACE;
163 } else if (nwam_ncu_read(active_ncph, name, NWAM_NCU_TYPE_LINK, 0,
164 &ncuh) == NWAM_SUCCESS) {
165 ncu_type = NWAM_NCU_TYPE_LINK;
166 } else {
167 return (B_FALSE);
168 }
169 if (nwam_ncu_get_name(ncuh, &real_name) != NWAM_SUCCESS) {
170 nwam_ncu_free(ncuh);
171 return (B_FALSE);
172 }
173 nwam_ncu_free(ncuh);
174
175 /*
176 * Name may be either unqualified or qualified by NCU type
177 * (interface:/link:). Need to translate unqualified names
178 * to qualified, specifying interface:name if an interface
179 * NCU is present, otherwise link:ncu.
180 */
181 if (nwam_ncu_name_to_typed_name(real_name, ncu_type, &ncu_name)
182 != NWAM_SUCCESS) {
183 free(real_name);
184 return (B_FALSE);
185 }
186 free(real_name);
187
188 rv = test_condition_object_state(condition, NWAM_OBJECT_TYPE_NCU,
189 ncu_name);
190 free(ncu_name);
191 return (rv);
192 }
193
194 static boolean_t
test_condition_enm(nwam_condition_t condition,const char * enm_name)195 test_condition_enm(nwam_condition_t condition, const char *enm_name)
196 {
197 nwam_enm_handle_t enmh;
198 char *real_name;
199 boolean_t rv;
200
201 /* names are case-insensitive, so get real name from libnwam */
202 if (nwam_enm_read(enm_name, 0, &enmh) != NWAM_SUCCESS)
203 return (B_FALSE);
204 if (nwam_enm_get_name(enmh, &real_name) != NWAM_SUCCESS) {
205 nwam_enm_free(enmh);
206 return (B_FALSE);
207 }
208 nwam_enm_free(enmh);
209
210 rv = test_condition_object_state(condition, NWAM_OBJECT_TYPE_ENM,
211 real_name);
212 free(real_name);
213 return (rv);
214 }
215
216 static boolean_t
test_condition_loc(nwam_condition_t condition,const char * loc_name)217 test_condition_loc(nwam_condition_t condition, const char *loc_name)
218 {
219 nwam_loc_handle_t loch;
220 char *real_name;
221 boolean_t rv;
222
223 /* names are case-insensitive, so get real name from libnwam */
224 if (nwam_loc_read(loc_name, 0, &loch) != NWAM_SUCCESS)
225 return (B_FALSE);
226 if (nwam_loc_get_name(loch, &real_name) != NWAM_SUCCESS) {
227 nwam_loc_free(loch);
228 return (B_FALSE);
229 }
230 nwam_loc_free(loch);
231
232 rv = test_condition_object_state(condition, NWAM_OBJECT_TYPE_LOC,
233 real_name);
234 free(real_name);
235 return (rv);
236 }
237
238 static boolean_t
test_condition_domain(nwam_condition_t condition,const char * target_domain,const char * found_domain)239 test_condition_domain(nwam_condition_t condition, const char *target_domain,
240 const char *found_domain)
241 {
242 int i, len_t, len_f;
243 char target[MAXHOSTNAMELEN], found[MAXHOSTNAMELEN];
244
245 len_t = target_domain == NULL ? 0 : strlen(target_domain);
246 len_f = found_domain == NULL ? 0 : strlen(found_domain);
247
248 /* convert target_domain and found_domain to lowercase for strstr() */
249 for (i = 0; i < len_t; i++)
250 target[i] = tolower(target_domain[i]);
251 target[len_t] = '\0';
252
253 for (i = 0; i < len_f; i++)
254 found[i] = tolower(found_domain[i]);
255 found[len_f] = '\0';
256
257 switch (condition) {
258 case NWAM_CONDITION_IS:
259 return (found_domain != NULL && strcmp(found, target) == 0);
260 case NWAM_CONDITION_IS_NOT:
261 return (found_domain == NULL || strcmp(found, target) != 0);
262 case NWAM_CONDITION_CONTAINS:
263 return (found_domain != NULL && strstr(found, target) != NULL);
264 case NWAM_CONDITION_DOES_NOT_CONTAIN:
265 return (found_domain == NULL || strstr(found, target) == NULL);
266 default:
267 return (B_FALSE);
268 }
269 }
270
271 struct ncu_adv_domains {
272 struct ncu_adv_domains *next;
273 char *dns_domain;
274 char *nis_domain;
275 };
276
277 static int
get_adv_domains(nwamd_object_t obj,void * arg)278 get_adv_domains(nwamd_object_t obj, void *arg)
279 {
280 nwamd_ncu_t *ncu = (nwamd_ncu_t *)obj->nwamd_object_data;
281 struct ncu_adv_domains **headpp = (struct ncu_adv_domains **)arg;
282 struct ncu_adv_domains *adp;
283 char *dns, *nis;
284
285 if (ncu->ncu_type != NWAM_NCU_TYPE_INTERFACE)
286 return (0);
287
288 dns = nwamd_get_dhcpinfo_data("DNSdmain", ncu->ncu_name);
289 nis = nwamd_get_dhcpinfo_data("NISdmain", ncu->ncu_name);
290
291 if (dns != NULL || nis != NULL) {
292 adp = (struct ncu_adv_domains *)malloc(sizeof (*adp));
293 if (adp == NULL)
294 return (1);
295 adp->dns_domain = dns;
296 adp->nis_domain = nis;
297 adp->next = *headpp;
298 *headpp = adp;
299 }
300
301 return (0);
302 }
303
304 static boolean_t
test_condition_sys_domain(nwam_condition_t condition,const char * domainname)305 test_condition_sys_domain(nwam_condition_t condition, const char *domainname)
306 {
307 char cur_domainname[MAXHOSTNAMELEN];
308
309 if (getdomainname(cur_domainname, MAXHOSTNAMELEN) != 0)
310 return (B_FALSE);
311
312 return (test_condition_domain(condition, domainname, cur_domainname));
313 }
314
315 static boolean_t
test_condition_adv_domain(nwam_condition_t condition,const char * domainname)316 test_condition_adv_domain(nwam_condition_t condition, const char *domainname)
317 {
318 struct ncu_adv_domains *adv_domains = NULL;
319 struct ncu_adv_domains *adp, *prev;
320 boolean_t positive, rtn;
321
322 (void) nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU, get_adv_domains,
323 &adv_domains);
324
325 positive = (condition == NWAM_CONDITION_IS ||
326 condition == NWAM_CONDITION_CONTAINS);
327
328 /*
329 * Walk the advertised domain list. Our test function tests one
330 * single domain, but we're dealing with a list: if our condition
331 * is positive ('is' or 'contains'), the test function for each
332 * domain results are or'd together; if our condition is negative
333 * ('is-not' or 'does-not-contain'), the test function results must
334 * be and'd. Thus our short-circuit exit value depends on our
335 * condition: if the test function returns TRUE it implies immediate
336 * success for a positive condition; if it returns FALSE it implies
337 * immediate failure for a negative condition.
338 */
339 adp = adv_domains;
340 while (adp != NULL) {
341 if ((test_condition_domain(condition, domainname,
342 adp->dns_domain) == positive) ||
343 (test_condition_domain(condition, domainname,
344 adp->nis_domain) == positive)) {
345 rtn = positive;
346 break;
347 }
348 adp = adp->next;
349 }
350 if (adp == NULL) {
351 /*
352 * We did not short-circuit; we therefore failed if our
353 * condition was positive, and succeeded if our condition
354 * was negative.
355 */
356 rtn = !positive;
357 }
358
359 /* now free the domain list */
360 adp = adv_domains;
361 while (adp != NULL) {
362 prev = adp;
363 adp = prev->next;
364 free(prev->dns_domain);
365 free(prev->nis_domain);
366 free(prev);
367 }
368
369 return (rtn);
370 }
371
372 /*
373 * Returns true if prefixlen bits of addr1 match prefixlen bits of addr2.
374 */
375 static boolean_t
prefixmatch(uchar_t * addr1,uchar_t * addr2,int prefixlen)376 prefixmatch(uchar_t *addr1, uchar_t *addr2, int prefixlen)
377 {
378 uchar_t mask[IPV6_ABITS/8];
379 int i, j = 0;
380
381 if (prefixlen == 0)
382 return (B_TRUE);
383
384 while (prefixlen > 0) {
385 if (prefixlen >= 8) {
386 mask[j++] = 0xFF;
387 prefixlen -= 8;
388 } else {
389 mask[j] |= 1 << (8 - prefixlen);
390 prefixlen--;
391 }
392 }
393 /* Ensure at least one byte is tested */
394 if (j == 0) j++;
395
396 for (i = 0; i < j; i++) {
397 if ((addr1[i] & mask[i]) != (addr2[i] & mask[i]))
398 return (B_FALSE);
399 }
400 return (B_TRUE);
401 }
402
403 /*
404 * Given a string representation of an IPv4 or IPv6 address returns the
405 * sockaddr representation. Note that 'sockaddr' should point at the correct
406 * sockaddr structure for the address family (sockaddr_in for AF_INET or
407 * sockaddr_in6 for AF_INET6) or alternatively at a sockaddr_storage
408 * structure.
409 */
410 static struct sockaddr_storage *
nwamd_str2sockaddr(sa_family_t af,const char * straddr,struct sockaddr_storage * addr)411 nwamd_str2sockaddr(sa_family_t af, const char *straddr,
412 struct sockaddr_storage *addr)
413 {
414 struct sockaddr_in *sin;
415 struct sockaddr_in6 *sin6;
416 int err;
417
418 if (af == AF_INET) {
419 sin = (struct sockaddr_in *)addr;
420 sin->sin_family = AF_INET;
421 err = inet_pton(AF_INET, straddr, &sin->sin_addr);
422 } else if (af == AF_INET6) {
423 sin6 = (struct sockaddr_in6 *)addr;
424 sin6->sin6_family = AF_INET6;
425 err = inet_pton(AF_INET6, straddr, &sin6->sin6_addr);
426 } else {
427 errno = EINVAL;
428 return (NULL);
429 }
430 return (err == 1 ? addr : NULL);
431 }
432
433 struct nwamd_ipaddr_condition_walk_arg {
434 nwam_condition_t condition;
435 struct sockaddr_storage sockaddr;
436 int prefixlen;
437 boolean_t res;
438 };
439
440 static int
check_ipaddr(sa_family_t family,struct ifaddrs * ifa,void * arg)441 check_ipaddr(sa_family_t family, struct ifaddrs *ifa, void *arg)
442 {
443 struct nwamd_ipaddr_condition_walk_arg *wa = arg;
444 struct sockaddr_in6 addr6;
445 struct sockaddr_in addr;
446 boolean_t match = B_FALSE;
447 uchar_t *addr1, *addr2;
448
449 if (family == AF_INET) {
450 (void) memcpy(&addr, ifa->ifa_addr, sizeof (addr));
451 addr1 = (uchar_t *)(&addr.sin_addr.s_addr);
452 addr2 = (uchar_t *)&(((struct sockaddr_in *)
453 &(wa->sockaddr))->sin_addr.s_addr);
454 } else {
455 (void) memcpy(&addr6, ifa->ifa_addr, sizeof (addr6));
456 addr1 = (uchar_t *)(&addr6.sin6_addr.s6_addr);
457 addr2 = (uchar_t *)&(((struct sockaddr_in6 *)
458 &(wa->sockaddr))->sin6_addr.s6_addr);
459 }
460
461 match = prefixmatch(addr1, addr2, wa->prefixlen);
462
463 nlog(LOG_DEBUG, "check_ipaddr: match %d\n", match);
464 switch (wa->condition) {
465 case NWAM_CONDITION_IS:
466 case NWAM_CONDITION_IS_IN_RANGE:
467 wa->res = match;
468 if (match)
469 return (1);
470 return (0);
471 case NWAM_CONDITION_IS_NOT:
472 case NWAM_CONDITION_IS_NOT_IN_RANGE:
473 wa->res = !match;
474 return (0);
475 default:
476 return (0);
477 }
478 }
479
480 static boolean_t
test_condition_ip_address(nwam_condition_t condition,const char * ip_address_string)481 test_condition_ip_address(nwam_condition_t condition,
482 const char *ip_address_string)
483 {
484 sa_family_t family;
485 char *copy, *ip_address, *prefixlen_string, *lasts;
486 struct nwamd_ipaddr_condition_walk_arg wa;
487 struct ifaddrs *ifap, *ifa;
488
489 if ((copy = strdup(ip_address_string)) == NULL)
490 return (B_FALSE);
491
492 if ((ip_address = strtok_r(copy, " \t/", &lasts)) == NULL) {
493 free(copy);
494 return (B_FALSE);
495 }
496
497 prefixlen_string = strtok_r(NULL, " \t", &lasts);
498
499 if (nwamd_str2sockaddr(AF_INET, ip_address, &wa.sockaddr) != NULL) {
500 family = AF_INET;
501 wa.prefixlen = IP_ABITS;
502 } else if (nwamd_str2sockaddr(AF_INET6, ip_address, &wa.sockaddr)
503 != NULL) {
504 family = AF_INET6;
505 wa.prefixlen = IPV6_ABITS;
506 } else {
507 nlog(LOG_ERR, "test_condition_ip_address: "
508 "nwamd_str2sockaddr failed for %s: %s", ip_address,
509 strerror(errno));
510 free(copy);
511 return (B_FALSE);
512 }
513
514 if (prefixlen_string != NULL)
515 wa.prefixlen = atoi(prefixlen_string);
516
517 wa.condition = condition;
518
519 switch (condition) {
520 case NWAM_CONDITION_IS:
521 case NWAM_CONDITION_IS_IN_RANGE:
522 wa.res = B_FALSE;
523 break;
524 case NWAM_CONDITION_IS_NOT:
525 case NWAM_CONDITION_IS_NOT_IN_RANGE:
526 wa.res = B_TRUE;
527 break;
528 default:
529 free(copy);
530 return (B_FALSE);
531 }
532 free(copy);
533
534 if (getifaddrs(&ifa) == -1) {
535 nlog(LOG_ERR, "test_condition_ip_address: "
536 "getifaddrs failed: %s", strerror(errno));
537 return (wa.res);
538 }
539 for (ifap = ifa; ifap != NULL; ifap = ifap->ifa_next) {
540 if (ifap->ifa_addr->sa_family != family)
541 continue;
542 if (check_ipaddr(family, ifap, &wa) == 1)
543 break;
544 }
545 freeifaddrs(ifa);
546
547 return (wa.res);
548 }
549
550 struct nwamd_wlan_condition_walk_arg {
551 nwam_condition_t condition;
552 const char *exp_essid;
553 const char *exp_bssid;
554 uint_t num_connected;
555 boolean_t res;
556 };
557
558 static int
check_wlan(const char * linkname,void * arg)559 check_wlan(const char *linkname, void *arg)
560 {
561 struct nwamd_wlan_condition_walk_arg *wa = arg;
562 datalink_id_t linkid;
563 dladm_wlan_linkattr_t attr;
564 dladm_status_t status;
565 char cur_essid[DLADM_STRSIZE];
566 char cur_bssid[DLADM_STRSIZE];
567 char errmsg[DLADM_STRSIZE];
568
569 if ((status = dladm_name2info(dld_handle, linkname, &linkid, NULL, NULL,
570 NULL)) != DLADM_STATUS_OK) {
571 nlog(LOG_DEBUG, "check_wlan: dladm_name2info() for %s "
572 "failed: %s", linkname,
573 dladm_status2str(status, errmsg));
574 return (DLADM_WALK_CONTINUE);
575 }
576
577 status = dladm_wlan_get_linkattr(dld_handle, linkid, &attr);
578 if (status != DLADM_STATUS_OK) {
579 nlog(LOG_DEBUG, "check_wlan: dladm_wlan_get_linkattr() for %s "
580 "failed: %s", linkname,
581 dladm_status2str(status, errmsg));
582 return (DLADM_WALK_CONTINUE);
583 }
584 if (attr.la_status == DLADM_WLAN_LINK_DISCONNECTED)
585 return (DLADM_WALK_TERMINATE);
586
587 wa->num_connected++;
588
589 if (wa->exp_essid != NULL) {
590 /* Is the NIC associated with the expected access point? */
591 (void) dladm_wlan_essid2str(&attr.la_wlan_attr.wa_essid,
592 cur_essid);
593 switch (wa->condition) {
594 case NWAM_CONDITION_IS:
595 wa->res = strcmp(cur_essid, wa->exp_essid) == 0;
596 if (wa->res)
597 return (DLADM_WALK_TERMINATE);
598 break;
599 case NWAM_CONDITION_IS_NOT:
600 wa->res = strcmp(cur_essid, wa->exp_essid) != 0;
601 if (!wa->res)
602 return (DLADM_WALK_TERMINATE);
603 break;
604 case NWAM_CONDITION_CONTAINS:
605 wa->res = strstr(cur_essid, wa->exp_essid) != NULL;
606 if (wa->res)
607 return (DLADM_WALK_TERMINATE);
608 break;
609 case NWAM_CONDITION_DOES_NOT_CONTAIN:
610 wa->res = strstr(cur_essid, wa->exp_essid) == NULL;
611 if (!wa->res)
612 return (DLADM_WALK_TERMINATE);
613 break;
614 default:
615 return (DLADM_WALK_TERMINATE);
616 }
617 return (DLADM_WALK_CONTINUE);
618 }
619 if (wa->exp_bssid != NULL) {
620 /* Is the NIC associated with the expected access point? */
621 (void) dladm_wlan_bssid2str(&attr.la_wlan_attr.wa_bssid,
622 cur_bssid);
623 switch (wa->condition) {
624 case NWAM_CONDITION_IS:
625 wa->res = strcmp(cur_bssid, wa->exp_bssid) == 0;
626 if (wa->res)
627 return (DLADM_WALK_TERMINATE);
628 break;
629 case NWAM_CONDITION_IS_NOT:
630 wa->res = strcmp(cur_bssid, wa->exp_bssid) != 0;
631 if (!wa->res)
632 return (DLADM_WALK_TERMINATE);
633 break;
634 default:
635 return (DLADM_WALK_TERMINATE);
636 }
637 return (DLADM_WALK_CONTINUE);
638 }
639 /*
640 * Neither an ESSID or BSSID match is required - being connected to a
641 * WLAN is enough.
642 */
643 switch (wa->condition) {
644 case NWAM_CONDITION_IS:
645 wa->res = B_TRUE;
646 return (DLADM_WALK_TERMINATE);
647 default:
648 wa->res = B_FALSE;
649 return (DLADM_WALK_TERMINATE);
650 }
651 /*NOTREACHED*/
652 return (DLADM_WALK_CONTINUE);
653 }
654
655 static boolean_t
test_condition_wireless_essid(nwam_condition_t condition,const char * essid)656 test_condition_wireless_essid(nwam_condition_t condition,
657 const char *essid)
658 {
659 struct nwamd_wlan_condition_walk_arg wa;
660
661 wa.condition = condition;
662 wa.exp_essid = essid;
663 wa.exp_bssid = NULL;
664 wa.num_connected = 0;
665 wa.res = B_FALSE;
666
667 (void) dladm_walk(check_wlan, dld_handle, &wa, DATALINK_CLASS_PHYS,
668 DL_WIFI, DLADM_OPT_ACTIVE);
669
670 return (wa.num_connected > 0 && wa.res == B_TRUE);
671 }
672
673 static boolean_t
test_condition_wireless_bssid(nwam_condition_t condition,const char * bssid)674 test_condition_wireless_bssid(nwam_condition_t condition,
675 const char *bssid)
676 {
677 struct nwamd_wlan_condition_walk_arg wa;
678
679 wa.condition = condition;
680 wa.exp_bssid = bssid;
681 wa.exp_essid = NULL;
682 wa.num_connected = 0;
683 wa.res = B_FALSE;
684
685 (void) dladm_walk(check_wlan, dld_handle, &wa, DATALINK_CLASS_PHYS,
686 DL_WIFI, DLADM_OPT_ACTIVE);
687
688 return (wa.num_connected > 0 && wa.res == B_TRUE);
689 }
690
691 /*
692 * This function takes an activation mode and a string representation of a
693 * condition and evaluates it.
694 */
695 boolean_t
nwamd_check_conditions(nwam_activation_mode_t activation_mode,char ** condition_strings,uint_t num_conditions)696 nwamd_check_conditions(nwam_activation_mode_t activation_mode,
697 char **condition_strings, uint_t num_conditions)
698 {
699 boolean_t ret;
700 nwam_condition_t condition;
701 nwam_condition_object_type_t object_type;
702 char *object_name;
703 int i, j;
704
705 for (i = 0; i < num_conditions; i++) {
706
707 if (nwam_condition_string_to_condition(condition_strings[i],
708 &object_type, &condition, &object_name) != NWAM_SUCCESS) {
709 nlog(LOG_ERR, "check_conditions: invalid condition %s",
710 condition_strings[i]);
711 return (B_FALSE);
712 }
713 ret = B_FALSE;
714
715 for (j = 0; j < (sizeof (condition_map) /
716 sizeof (struct nwamd_condition_map)); j++) {
717 if (condition_map[j].object_type == object_type)
718 ret = condition_map[j].condition_func(condition,
719 object_name);
720 }
721
722 free(object_name);
723
724 if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY &&
725 ret) {
726 return (B_TRUE);
727 }
728 if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ALL &&
729 !ret) {
730 return (B_FALSE);
731 }
732 }
733 if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY && ret)
734 return (B_TRUE);
735 if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ALL && ret)
736 return (B_TRUE);
737
738 return (B_FALSE);
739 }
740
741 /*
742 * In rating activation conditions, we take the best-rated CONDITIONAL_ANY
743 * condition, or sum all the CONDITIONAL_ALL condition ratings. This allows
744 * us to compare between location activation conditions to pick the best.
745 */
746 uint64_t
nwamd_rate_conditions(nwam_activation_mode_t activation_mode,char ** conditions,uint_t num_conditions)747 nwamd_rate_conditions(nwam_activation_mode_t activation_mode,
748 char **conditions, uint_t num_conditions)
749 {
750 nwam_condition_t condition;
751 nwam_condition_object_type_t object_type;
752 char *object_name;
753 int i;
754 uint64_t rating = 0, total_rating = 0;
755
756 for (i = 0; i < num_conditions; i++) {
757
758 object_name = NULL;
759 if (nwam_condition_string_to_condition(conditions[i],
760 &object_type, &condition, &object_name) != NWAM_SUCCESS ||
761 nwam_condition_rate(object_type, condition, &rating)
762 != NWAM_SUCCESS) {
763 nlog(LOG_ERR, "nwamd_rate_conditions: could not rate "
764 "condition");
765 free(object_name);
766 return (0);
767 }
768 free(object_name);
769
770 if (activation_mode == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY) {
771 if (rating > total_rating)
772 total_rating = rating;
773 } else if (activation_mode ==
774 NWAM_ACTIVATION_MODE_CONDITIONAL_ALL) {
775 total_rating += rating;
776 }
777 }
778 return (total_rating);
779 }
780
781 /*
782 * Different from nwamd_triggered_check_all_conditions() in that this
783 * function enqueues a timed check event.
784 */
785 void
nwamd_set_timed_check_all_conditions(void)786 nwamd_set_timed_check_all_conditions(void)
787 {
788 nwamd_event_t check_event = nwamd_event_init
789 (NWAM_EVENT_TYPE_TIMED_CHECK_CONDITIONS, NWAM_OBJECT_TYPE_UNKNOWN,
790 0, NULL);
791 if (check_event != NULL) {
792 /* Add another timed event to recheck conditions */
793 nwamd_event_enqueue_timed(check_event,
794 condition_check_interval > CONDITION_CHECK_INTERVAL_MIN ?
795 condition_check_interval : CONDITION_CHECK_INTERVAL_MIN);
796 }
797 }
798
799 /*
800 * Does not enqueue another check event.
801 */
802 void
nwamd_check_all_conditions(void)803 nwamd_check_all_conditions(void)
804 {
805 nwamd_enm_check_conditions();
806 nwamd_loc_check_conditions();
807 }
808
809 void
nwamd_create_timed_condition_check_event(void)810 nwamd_create_timed_condition_check_event(void)
811 {
812 nwamd_event_t check_event = nwamd_event_init
813 (NWAM_EVENT_TYPE_TIMED_CHECK_CONDITIONS, NWAM_OBJECT_TYPE_UNKNOWN,
814 0, NULL);
815 if (check_event != NULL)
816 nwamd_event_enqueue(check_event);
817 }
818
819 void
nwamd_create_triggered_condition_check_event(uint32_t when)820 nwamd_create_triggered_condition_check_event(uint32_t when)
821 {
822 nwamd_event_t check_event;
823
824 if (!nwamd_event_enqueued(NWAM_EVENT_TYPE_TRIGGERED_CHECK_CONDITIONS,
825 NWAM_OBJECT_TYPE_UNKNOWN, NULL)) {
826 check_event = nwamd_event_init
827 (NWAM_EVENT_TYPE_TRIGGERED_CHECK_CONDITIONS,
828 NWAM_OBJECT_TYPE_UNKNOWN, 0, NULL);
829 if (check_event != NULL)
830 nwamd_event_enqueue_timed(check_event, when);
831 }
832 }
833