Print this page
patch tsoome-feedback
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libnwam/common/libnwam_values.c
+++ new/usr/src/lib/libnwam/common/libnwam_values.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
24 24 * Copyright 2012 Milan Jurik. All rights reserved.
25 25 */
26 26
27 27 #include <assert.h>
28 28 #include <stdio.h>
29 29 #include <stdlib.h>
30 30 #include <string.h>
31 31 #include <sys/types.h>
32 32 #include <libdlwlan.h>
33 33 #include <libnvpair.h>
34 34
35 35 #include "libnwam_impl.h"
36 36 #include <libnwam_priv.h>
37 37 #include <libnwam.h>
38 38
39 39 /*
40 40 * Internal implementation of libnwam in-memory objects and values. Objects
41 41 * are nvlists.
42 42 */
43 43
44 44 void
45 45 nwam_value_free(nwam_value_t value)
46 46 {
47 47 uint_t i;
48 48
49 49 if (value == NULL)
50 50 return;
51 51
52 52 switch (value->nwv_value_type) {
53 53 case NWAM_VALUE_TYPE_BOOLEAN:
54 54 free(value->nwv_values.nwv_boolean);
55 55 break;
56 56 case NWAM_VALUE_TYPE_INT64:
57 57 free(value->nwv_values.nwv_int64);
58 58 break;
59 59 case NWAM_VALUE_TYPE_UINT64:
60 60 free(value->nwv_values.nwv_uint64);
61 61 break;
62 62 case NWAM_VALUE_TYPE_STRING:
63 63 for (i = 0; i < value->nwv_value_numvalues; i++)
64 64 free(value->nwv_values.nwv_string[i]);
65 65 free(value->nwv_values.nwv_string);
66 66 break;
67 67 }
68 68 free(value);
69 69 }
70 70
71 71 nwam_error_t
72 72 nwam_value_create(nwam_value_type_t value_type, void *values, uint_t numvalues,
73 73 nwam_value_t *valuep)
74 74 {
75 75 nwam_value_t newvalue;
76 76 boolean_t *values_boolean;
77 77 int64_t *values_int64;
78 78 uint64_t *values_uint64;
79 79 char **values_string;
80 80 int i, j;
81 81 nwam_error_t err = NWAM_SUCCESS;
82 82
83 83 *valuep = NULL;
84 84
85 85 if ((newvalue = calloc(1, sizeof (struct nwam_value))) == NULL)
86 86 return (NWAM_NO_MEMORY);
87 87
88 88 newvalue->nwv_value_type = value_type;
89 89 newvalue->nwv_value_numvalues = numvalues;
90 90
91 91 switch (value_type) {
92 92 case NWAM_VALUE_TYPE_BOOLEAN:
93 93 values_boolean = values;
94 94 if ((newvalue->nwv_values.nwv_boolean =
95 95 calloc(numvalues, sizeof (boolean_t))) == NULL) {
96 96 free(newvalue);
97 97 return (NWAM_NO_MEMORY);
98 98 }
99 99 for (i = 0; i < numvalues; i++)
100 100 newvalue->nwv_values.nwv_boolean[i] = values_boolean[i];
101 101 break;
102 102 case NWAM_VALUE_TYPE_INT64:
103 103 values_int64 = values;
104 104 if ((newvalue->nwv_values.nwv_int64 =
105 105 calloc(numvalues, sizeof (int64_t))) == NULL) {
106 106 free(newvalue);
107 107 return (NWAM_NO_MEMORY);
108 108 }
109 109 for (i = 0; i < numvalues; i++)
110 110 newvalue->nwv_values.nwv_int64[i] = values_int64[i];
111 111 break;
112 112 case NWAM_VALUE_TYPE_UINT64:
113 113 values_uint64 = values;
114 114 if ((newvalue->nwv_values.nwv_uint64 =
115 115 calloc(numvalues, sizeof (uint64_t))) == NULL) {
116 116 free(newvalue);
117 117 return (NWAM_NO_MEMORY);
118 118 }
119 119 for (i = 0; i < numvalues; i++)
120 120 newvalue->nwv_values.nwv_uint64[i] = values_uint64[i];
121 121 break;
122 122 case NWAM_VALUE_TYPE_STRING:
123 123 values_string = values;
124 124 if ((newvalue->nwv_values.nwv_string =
125 125 calloc(numvalues, sizeof (char *))) == NULL) {
126 126 free(newvalue);
127 127 return (NWAM_NO_MEMORY);
128 128 }
129 129 for (i = 0; i < numvalues; i++) {
130 130 if (strnlen(values_string[i], NWAM_MAX_VALUE_LEN) ==
131 131 NWAM_MAX_VALUE_LEN) {
132 132 err = NWAM_ENTITY_INVALID_VALUE;
133 133 } else if ((newvalue->nwv_values.nwv_string[i] =
134 134 strdup(values_string[i])) == NULL) {
135 135 err = NWAM_NO_MEMORY;
136 136 }
137 137 if (err != NWAM_SUCCESS) {
138 138 for (j = 0; j < i; j++)
139 139 free(
140 140 newvalue->nwv_values.nwv_string[i]);
141 141 free(newvalue->nwv_values.nwv_string);
142 142 free(newvalue);
143 143 return (err);
144 144 }
145 145 }
146 146 break;
147 147 default:
148 148 break;
149 149 }
150 150
151 151 *valuep = newvalue;
152 152 return (NWAM_SUCCESS);
153 153 }
154 154
155 155 nwam_error_t
156 156 nwam_value_copy(nwam_value_t old, nwam_value_t *newp)
157 157 {
158 158 void *values;
159 159
160 160 assert(old != NULL && newp != NULL);
161 161
162 162 switch (old->nwv_value_type) {
163 163 case NWAM_VALUE_TYPE_BOOLEAN:
164 164 values = old->nwv_values.nwv_boolean;
165 165 break;
166 166 case NWAM_VALUE_TYPE_INT64:
167 167 values = old->nwv_values.nwv_int64;
168 168 break;
169 169 case NWAM_VALUE_TYPE_UINT64:
170 170 values = old->nwv_values.nwv_uint64;
171 171 break;
172 172 case NWAM_VALUE_TYPE_STRING:
173 173 values = old->nwv_values.nwv_string;
174 174 break;
175 175 default:
176 176 return (NWAM_INVALID_ARG);
177 177 }
178 178 return (nwam_value_create(old->nwv_value_type, values,
179 179 old->nwv_value_numvalues, newp));
180 180 }
181 181 nwam_error_t
182 182 nwam_value_create_boolean_array(boolean_t *values, uint_t numvalues,
183 183 nwam_value_t *valuep)
184 184 {
185 185 return (nwam_value_create(NWAM_VALUE_TYPE_BOOLEAN, values, numvalues,
186 186 valuep));
187 187 }
188 188
189 189 nwam_error_t
190 190 nwam_value_create_boolean(boolean_t value, nwam_value_t *valuep)
191 191 {
192 192 return (nwam_value_create_boolean_array(&value, 1, valuep));
193 193 }
194 194
195 195 nwam_error_t
196 196 nwam_value_create_int64_array(int64_t *values, uint_t numvalues,
197 197 nwam_value_t *valuep)
198 198 {
199 199 return (nwam_value_create(NWAM_VALUE_TYPE_INT64, values, numvalues,
200 200 valuep));
201 201 }
202 202
203 203 nwam_error_t
204 204 nwam_value_create_int64(int64_t value, nwam_value_t *valuep)
205 205 {
206 206 return (nwam_value_create_int64_array(&value, 1, valuep));
207 207 }
208 208
209 209 nwam_error_t
210 210 nwam_value_create_uint64_array(uint64_t *values, uint_t numvalues,
211 211 nwam_value_t *valuep)
212 212 {
213 213 return (nwam_value_create(NWAM_VALUE_TYPE_UINT64, values, numvalues,
214 214 valuep));
215 215 }
216 216
217 217 nwam_error_t
218 218 nwam_value_create_uint64(uint64_t value, nwam_value_t *valuep)
219 219 {
220 220 return (nwam_value_create_uint64_array(&value, 1, valuep));
221 221 }
222 222
223 223 nwam_error_t
224 224 nwam_value_create_string_array(char **values, uint_t numvalues,
225 225 nwam_value_t *valuep)
226 226 {
227 227 return (nwam_value_create(NWAM_VALUE_TYPE_STRING, values, numvalues,
228 228 valuep));
229 229 }
230 230
231 231 nwam_error_t
232 232 nwam_value_create_string(char *value, nwam_value_t *valuep)
233 233 {
234 234 return (nwam_value_create_string_array(&value, 1, valuep));
235 235 }
236 236
237 237 nwam_error_t
238 238 nwam_value_get_boolean_array(nwam_value_t value, boolean_t **valuesp,
239 239 uint_t *numvaluesp)
240 240 {
241 241 assert(value != NULL && numvaluesp != NULL && valuesp != NULL);
242 242
243 243 *numvaluesp = value->nwv_value_numvalues;
244 244 *valuesp = value->nwv_values.nwv_boolean;
245 245 return (NWAM_SUCCESS);
246 246 }
247 247
248 248 nwam_error_t
249 249 nwam_value_get_boolean(nwam_value_t value, boolean_t *valuep)
250 250 {
251 251 uint_t numvalues;
252 252 boolean_t *myvaluesp;
253 253 nwam_error_t err;
254 254
255 255 err = nwam_value_get_boolean_array(value, &myvaluesp, &numvalues);
256 256 if (err != NWAM_SUCCESS)
257 257 return (err);
258 258 if (numvalues != 1)
259 259 return (NWAM_ENTITY_MULTIPLE_VALUES);
260 260
261 261 *valuep = myvaluesp[0];
262 262 return (NWAM_SUCCESS);
263 263 }
264 264
265 265 nwam_error_t
266 266 nwam_value_get_int64_array(nwam_value_t value, int64_t **valuesp,
267 267 uint_t *numvaluesp)
268 268 {
269 269 assert(value != NULL && numvaluesp != NULL && valuesp != NULL);
270 270
271 271 *numvaluesp = value->nwv_value_numvalues;
272 272 *valuesp = value->nwv_values.nwv_int64;
273 273 return (NWAM_SUCCESS);
274 274 }
275 275
276 276 nwam_error_t
277 277 nwam_value_get_int64(nwam_value_t value, int64_t *valuep)
278 278 {
279 279 uint_t numvalues;
280 280 int64_t *myvaluesp;
281 281 nwam_error_t err;
282 282
283 283 err = nwam_value_get_int64_array(value, &myvaluesp, &numvalues);
284 284 if (err != NWAM_SUCCESS)
285 285 return (err);
286 286 if (numvalues != 1)
287 287 return (NWAM_ENTITY_MULTIPLE_VALUES);
288 288
289 289 *valuep = myvaluesp[0];
290 290 return (NWAM_SUCCESS);
291 291 }
292 292
293 293 nwam_error_t
294 294 nwam_value_get_uint64_array(nwam_value_t value, uint64_t **valuesp,
295 295 uint_t *numvaluesp)
296 296 {
297 297 assert(value != NULL && numvaluesp != NULL && valuesp != NULL);
298 298
299 299 *numvaluesp = value->nwv_value_numvalues;
300 300 *valuesp = value->nwv_values.nwv_uint64;
301 301 return (NWAM_SUCCESS);
302 302 }
303 303
304 304 nwam_error_t
305 305 nwam_value_get_uint64(nwam_value_t value, uint64_t *valuep)
306 306 {
307 307 uint_t numvalues;
308 308 uint64_t *myvaluesp;
309 309 nwam_error_t err;
310 310
311 311 err = nwam_value_get_uint64_array(value, &myvaluesp, &numvalues);
312 312 if (err != NWAM_SUCCESS)
313 313 return (err);
314 314 if (numvalues != 1)
315 315 return (NWAM_ENTITY_MULTIPLE_VALUES);
316 316
317 317 *valuep = myvaluesp[0];
318 318 return (NWAM_SUCCESS);
319 319 }
320 320
321 321 nwam_error_t
322 322 nwam_value_get_string_array(nwam_value_t value, char ***valuesp,
323 323 uint_t *numvaluesp)
324 324 {
325 325 assert(value != NULL && numvaluesp != NULL && valuesp != NULL);
326 326
327 327 *numvaluesp = value->nwv_value_numvalues;
328 328 *valuesp = value->nwv_values.nwv_string;
329 329 return (NWAM_SUCCESS);
330 330 }
331 331
332 332 nwam_error_t
333 333 nwam_value_get_string(nwam_value_t value, char **valuep)
334 334 {
335 335 uint_t numvalues;
336 336 char **myvaluesp;
337 337 nwam_error_t err;
338 338
339 339 err = nwam_value_get_string_array(value, &myvaluesp, &numvalues);
340 340 if (err != NWAM_SUCCESS)
341 341 return (err);
342 342 if (numvalues != 1)
343 343 return (NWAM_ENTITY_MULTIPLE_VALUES);
344 344
345 345 *valuep = myvaluesp[0];
346 346 return (NWAM_SUCCESS);
347 347 }
348 348
349 349 nwam_error_t
350 350 nwam_value_get_type(nwam_value_t value, nwam_value_type_t *typep)
351 351 {
352 352 *typep = value->nwv_value_type;
353 353 return (NWAM_SUCCESS);
354 354 }
355 355
356 356 nwam_error_t
357 357 nwam_value_get_numvalues(nwam_value_t value, uint_t *numvaluesp)
358 358 {
359 359 *numvaluesp = value->nwv_value_numvalues;
360 360 return (NWAM_SUCCESS);
361 361 }
362 362
363 363 /*
364 364 * Generic object data functions. We hide nvlist implementation
365 365 * from NCP, ENM and location implementations.
366 366 */
367 367 nwam_error_t
368 368 nwam_alloc_object_list(void *list)
369 369 {
370 370 int nverr;
371 371
372 372 assert(list != NULL);
|
↓ open down ↓ |
372 lines elided |
↑ open up ↑ |
373 373
374 374 if ((nverr = nvlist_alloc((nvlist_t **)list, NV_UNIQUE_NAME, 0)) != 0)
375 375 return (nwam_errno_to_nwam_error(nverr));
376 376
377 377 return (NWAM_SUCCESS);
378 378 }
379 379
380 380 void
381 381 nwam_free_object_list(void *list)
382 382 {
383 - if (list != NULL)
384 - nvlist_free(list);
383 + nvlist_free(list);
385 384 }
386 385
387 386 nwam_error_t
388 387 nwam_dup_object_list(void *oldlist, void *newlist)
389 388 {
390 389 int nverr;
391 390
392 391 assert(oldlist != NULL && newlist != NULL);
393 392
394 393 if ((nverr = nvlist_dup(oldlist, newlist, 0)) != 0)
395 394 return (nwam_errno_to_nwam_error(nverr));
396 395
397 396 return (NWAM_SUCCESS);
398 397 }
399 398
400 399 /* Add child object list to parent object list using property name childname */
401 400 nwam_error_t
402 401 nwam_object_list_add_object_list(void *parentlist, char *childname,
403 402 void *childlist)
404 403 {
405 404 return (nwam_errno_to_nwam_error(nvlist_add_nvlist(parentlist,
406 405 childname, childlist)));
407 406 }
408 407
409 408 /* Remove object list from parent object list */
410 409 nwam_error_t
411 410 nwam_object_list_remove_object_list(void *parentlist, char *childname)
412 411 {
413 412 return (nwam_errno_to_nwam_error(nvlist_remove_all(parentlist,
414 413 childname)));
415 414 }
416 415
417 416 /*
418 417 * Get next object list (nvlist) after lastname. Used to walk NCUs, ENMs and
419 418 * locations, each of which is internally represented as an nvlist.
420 419 */
421 420 nwam_error_t
422 421 nwam_next_object_list(void *parentlist, char *lastname, char **childnamep,
423 422 void *childlistp)
424 423 {
425 424 nvpair_t *last = NULL, *next;
426 425 int nverr;
427 426
428 427 if (lastname != NULL) {
429 428 if ((nverr = nvlist_lookup_nvpair(parentlist, lastname, &last))
430 429 != 0)
431 430 return (nwam_errno_to_nwam_error(nverr));
432 431 }
433 432 if ((next = nvlist_next_nvpair(parentlist, last)) == NULL)
434 433 return (NWAM_LIST_END);
435 434
436 435 *childnamep = nvpair_name(next);
437 436
438 437 if (nvpair_type(next) != DATA_TYPE_NVLIST)
439 438 return (NWAM_ERROR_INTERNAL);
440 439
441 440 if ((nverr = nvpair_value_nvlist(next, childlistp)) != NWAM_SUCCESS)
442 441 return (nwam_errno_to_nwam_error(nverr));
443 442
444 443 return (NWAM_SUCCESS);
445 444 }
446 445
447 446 /*
448 447 * Pack nvlist into contiguous memory. If packed_listp is NULL, we just
449 448 * return the size of the memory needed to do so.
450 449 */
451 450 nwam_error_t
452 451 nwam_pack_object_list(void *list, char **packed_listp, size_t *packed_sizep)
453 452 {
454 453 int nverr;
455 454
456 455 assert(list != NULL && packed_sizep != NULL);
457 456
458 457 if (packed_listp == NULL) {
459 458 nverr = nvlist_size(list, packed_sizep, NV_ENCODE_XDR);
460 459 } else {
461 460 nverr = nvlist_pack(list, packed_listp, packed_sizep,
462 461 NV_ENCODE_XDR, 0);
463 462 }
464 463
465 464 if (nverr != 0)
466 465 return (nwam_errno_to_nwam_error(nverr));
467 466
468 467 return (NWAM_SUCCESS);
469 468 }
470 469
471 470 nwam_error_t
472 471 nwam_unpack_object_list(char *packed_list, size_t packed_size,
473 472 void *list)
474 473 {
475 474 int nverr;
476 475
477 476 assert(packed_list != NULL && list != NULL);
478 477
479 478 *((nvlist_t **)list) = NULL;
480 479
481 480 nverr = nvlist_unpack(packed_list, packed_size, (nvlist_t **)list, 0);
482 481
483 482 if (nverr != 0)
484 483 return (nwam_errno_to_nwam_error(nverr));
485 484
486 485 return (NWAM_SUCCESS);
487 486 }
488 487
489 488 /*
490 489 * Functions to walk, set and get properties in nvlist, translating
491 490 * between nwam_value_t and nvlist/nvpair representations.
492 491 */
493 492 nwam_error_t
494 493 nwam_next_object_prop(void *list, char *lastname, char **namep,
495 494 nwam_value_t *valuep)
496 495 {
497 496 nvpair_t *last = NULL, *next;
498 497 int nverr;
499 498
500 499 if (lastname != NULL) {
501 500 if ((nverr = nvlist_lookup_nvpair(list, lastname, &last)) != 0)
502 501 return (nwam_errno_to_nwam_error(nverr));
503 502 }
504 503 if ((next = nvlist_next_nvpair(list, last)) == NULL)
505 504 return (NWAM_LIST_END);
506 505
507 506 *namep = nvpair_name(next);
508 507
509 508 return (nwam_get_prop_value(list, (const char *)*namep, valuep));
510 509 }
511 510
512 511 nwam_error_t
513 512 nwam_get_prop_value(void *list, const char *name, nwam_value_t *valuep)
514 513 {
515 514 nvpair_t *prop;
516 515 nwam_error_t err;
517 516 int nverr;
518 517 boolean_t *valbool;
519 518 int64_t *valint64;
520 519 uint64_t *valuint64;
521 520 char **valstr;
522 521 uint_t numvalues;
523 522
524 523 assert(valuep != NULL);
525 524
526 525 *valuep = NULL;
527 526
528 527 if ((nverr = nvlist_lookup_nvpair(list, name, &prop)) != 0) {
529 528 /* convert EINVAL to NOT_FOUND */
530 529 if (nverr == EINVAL)
531 530 return (NWAM_ENTITY_NOT_FOUND);
532 531 return (nwam_errno_to_nwam_error(nverr));
533 532 }
534 533
535 534 switch (nvpair_type(prop)) {
536 535 case DATA_TYPE_BOOLEAN_ARRAY:
537 536 if ((nverr = nvpair_value_boolean_array(prop,
538 537 &valbool, &numvalues)) != 0)
539 538 return (nwam_errno_to_nwam_error(nverr));
540 539 if ((err = nwam_value_create_boolean_array(valbool, numvalues,
541 540 valuep)) != NWAM_SUCCESS)
542 541 return (err);
543 542 break;
544 543 case DATA_TYPE_INT64_ARRAY:
545 544 if ((nverr = nvpair_value_int64_array(prop,
546 545 &valint64, &numvalues)) != 0)
547 546 return (nwam_errno_to_nwam_error(nverr));
548 547 if ((err = nwam_value_create_int64_array(valint64, numvalues,
549 548 valuep)) != NWAM_SUCCESS)
550 549 return (err);
551 550 break;
552 551 case DATA_TYPE_UINT64_ARRAY:
553 552 if ((nverr = nvpair_value_uint64_array(prop,
554 553 &valuint64, &numvalues)) != 0)
555 554 return (nwam_errno_to_nwam_error(nverr));
556 555 if ((err = nwam_value_create_uint64_array(valuint64, numvalues,
557 556 valuep)) != NWAM_SUCCESS)
558 557 return (err);
559 558 break;
560 559 case DATA_TYPE_STRING_ARRAY:
561 560 if ((nverr = nvpair_value_string_array(prop,
562 561 &valstr, &numvalues)) != 0)
563 562 return (nwam_errno_to_nwam_error(nverr));
564 563 if ((err = nwam_value_create_string_array(valstr, numvalues,
565 564 valuep)) != NWAM_SUCCESS)
566 565 return (err);
567 566 break;
568 567 default:
569 568 /* Should not happen */
570 569 return (NWAM_ERROR_INTERNAL);
571 570 }
572 571 return (NWAM_SUCCESS);
573 572 }
574 573
575 574 nwam_error_t
576 575 nwam_delete_prop(void *list, const char *name)
577 576 {
578 577 int nverr;
579 578
580 579 if ((nverr = nvlist_remove_all(list, name)) != 0)
581 580 return (nwam_errno_to_nwam_error(nverr));
582 581 return (NWAM_SUCCESS);
583 582 }
584 583
585 584 nwam_error_t
586 585 nwam_set_prop_value(void *list, const char *propname, nwam_value_t value)
587 586 {
588 587 int nverr;
589 588 nwam_error_t err;
590 589 nwam_value_type_t type;
591 590 uint_t numvalues;
592 591 boolean_t *valbool;
593 592 int64_t *valint64;
594 593 uint64_t *valuint64;
595 594 char **valstr;
596 595
597 596 assert(list != NULL && value != NULL);
598 597
599 598 if ((err = nwam_value_get_type(value, &type)) != NWAM_SUCCESS)
600 599 return (err);
601 600
602 601 switch (type) {
603 602 case NWAM_VALUE_TYPE_BOOLEAN:
604 603 if ((err = nwam_value_get_boolean_array(value, &valbool,
605 604 &numvalues)) != NWAM_SUCCESS)
606 605 return (err);
607 606 if ((nverr = nvlist_add_boolean_array(list, propname,
608 607 valbool, numvalues)) != 0)
609 608 return (nwam_errno_to_nwam_error(nverr));
610 609 break;
611 610 case NWAM_VALUE_TYPE_INT64:
612 611 if ((err = nwam_value_get_int64_array(value, &valint64,
613 612 &numvalues)) != NWAM_SUCCESS)
614 613 return (err);
615 614 if ((nverr = nvlist_add_int64_array(list, propname,
616 615 valint64, numvalues)) != 0)
617 616 return (nwam_errno_to_nwam_error(nverr));
618 617 break;
619 618 case NWAM_VALUE_TYPE_UINT64:
620 619 if ((err = nwam_value_get_uint64_array(value, &valuint64,
621 620 &numvalues)) != NWAM_SUCCESS)
622 621 return (err);
623 622 if ((nverr = nvlist_add_uint64_array(list, propname,
624 623 valuint64, numvalues)) != 0)
625 624 return (nwam_errno_to_nwam_error(nverr));
626 625 break;
627 626 case NWAM_VALUE_TYPE_STRING:
628 627 if ((err = nwam_value_get_string_array(value, &valstr,
629 628 &numvalues)) != NWAM_SUCCESS)
630 629 return (err);
631 630 if ((nverr = nvlist_add_string_array(list, propname,
632 631 valstr, numvalues)) != 0)
633 632 return (nwam_errno_to_nwam_error(nverr));
634 633 break;
635 634 default:
636 635 return (NWAM_INVALID_ARG);
637 636 }
638 637
639 638 return (NWAM_SUCCESS);
640 639 }
641 640
642 641 /* Map uint64 values to their string counterparts */
643 642
644 643 struct nwam_value_entry {
645 644 const char *value_string;
646 645 uint64_t value;
647 646 };
648 647
649 648 struct nwam_value_entry prop_activation_mode_value_entries[] =
650 649 {
651 650 { NWAM_ACTIVATION_MODE_MANUAL_STRING, NWAM_ACTIVATION_MODE_MANUAL },
652 651 { NWAM_ACTIVATION_MODE_SYSTEM_STRING, NWAM_ACTIVATION_MODE_SYSTEM },
653 652 { NWAM_ACTIVATION_MODE_CONDITIONAL_ANY_STRING,
654 653 NWAM_ACTIVATION_MODE_CONDITIONAL_ANY },
655 654 { NWAM_ACTIVATION_MODE_CONDITIONAL_ALL_STRING,
656 655 NWAM_ACTIVATION_MODE_CONDITIONAL_ALL },
657 656 { NWAM_ACTIVATION_MODE_PRIORITIZED_STRING,
658 657 NWAM_ACTIVATION_MODE_PRIORITIZED },
659 658 { NULL, 0 }
660 659 };
661 660
662 661 struct nwam_value_entry ncu_prop_type_entries[] =
663 662 {
664 663 { NWAM_NCU_TYPE_LINK_STRING, NWAM_NCU_TYPE_LINK },
665 664 { NWAM_NCU_TYPE_INTERFACE_STRING, NWAM_NCU_TYPE_INTERFACE },
666 665 { NULL, 0 }
667 666 };
668 667
669 668 struct nwam_value_entry ncu_prop_class_entries[] =
670 669 {
671 670 { NWAM_NCU_CLASS_PHYS_STRING, NWAM_NCU_CLASS_PHYS },
672 671 { NWAM_NCU_CLASS_IP_STRING, NWAM_NCU_CLASS_IP },
673 672 { NULL, 0 }
674 673 };
675 674
676 675 struct nwam_value_entry ncu_prop_ip_version_entries[] =
677 676 {
678 677 { NWAM_IP_VERSION_IPV4_STRING, IPV4_VERSION },
679 678 { NWAM_IP_VERSION_IPV6_STRING, IPV6_VERSION },
680 679 { NULL, 0 }
681 680 };
682 681
683 682 struct nwam_value_entry ncu_prop_ipv4_addrsrc_entries[] =
684 683 {
685 684 { NWAM_ADDRSRC_DHCP_STRING, NWAM_ADDRSRC_DHCP },
686 685 { NWAM_ADDRSRC_STATIC_STRING, NWAM_ADDRSRC_STATIC },
687 686 { NULL, 0 }
688 687 };
689 688
690 689 struct nwam_value_entry ncu_prop_ipv6_addrsrc_entries[] =
691 690 {
692 691 { NWAM_ADDRSRC_DHCP_STRING, NWAM_ADDRSRC_DHCP },
693 692 { NWAM_ADDRSRC_STATIC_STRING, NWAM_ADDRSRC_STATIC },
694 693 { NWAM_ADDRSRC_AUTOCONF_STRING, NWAM_ADDRSRC_AUTOCONF },
695 694 { NULL, 0 }
696 695 };
697 696
698 697 struct nwam_value_entry ncu_prop_priority_mode_entries[] =
699 698 {
700 699 { NWAM_PRIORITY_MODE_EXCLUSIVE_STRING, NWAM_PRIORITY_MODE_EXCLUSIVE },
701 700 { NWAM_PRIORITY_MODE_SHARED_STRING, NWAM_PRIORITY_MODE_SHARED },
702 701 { NWAM_PRIORITY_MODE_ALL_STRING, NWAM_PRIORITY_MODE_ALL },
703 702 { NULL, 0 }
704 703 };
705 704
706 705 struct nwam_value_entry loc_prop_nameservices_entries[] =
707 706 {
708 707 { NWAM_NAMESERVICES_DNS_STRING, NWAM_NAMESERVICES_DNS },
709 708 { NWAM_NAMESERVICES_FILES_STRING, NWAM_NAMESERVICES_FILES },
710 709 { NWAM_NAMESERVICES_NIS_STRING, NWAM_NAMESERVICES_NIS },
711 710 { NWAM_NAMESERVICES_LDAP_STRING, NWAM_NAMESERVICES_LDAP },
712 711 { NULL, 0 }
713 712 };
714 713
715 714 struct nwam_value_entry loc_prop_nameservice_configsrc_entries[] =
716 715 {
717 716 { NWAM_CONFIGSRC_MANUAL_STRING, NWAM_CONFIGSRC_MANUAL },
718 717 { NWAM_CONFIGSRC_DHCP_STRING, NWAM_CONFIGSRC_DHCP },
719 718 { NULL, 0 }
720 719 };
721 720
722 721 struct nwam_value_entry known_wlan_prop_security_mode_entries[] =
723 722 {
724 723 { "none", DLADM_WLAN_SECMODE_NONE },
725 724 { "wep", DLADM_WLAN_SECMODE_WEP },
726 725 { "wpa", DLADM_WLAN_SECMODE_WPA },
727 726 { NULL, 0 }
728 727 };
729 728
730 729 struct nwam_prop_value_entry {
731 730 const char *prop_name;
732 731 struct nwam_value_entry *value_entries;
733 732 } prop_value_entry_table[] =
734 733 {
735 734 { NWAM_NCU_PROP_ACTIVATION_MODE, prop_activation_mode_value_entries },
736 735 { NWAM_NCU_PROP_TYPE, ncu_prop_type_entries },
737 736 { NWAM_NCU_PROP_CLASS, ncu_prop_class_entries },
738 737 { NWAM_NCU_PROP_IP_VERSION, ncu_prop_ip_version_entries },
739 738 { NWAM_NCU_PROP_IPV4_ADDRSRC, ncu_prop_ipv4_addrsrc_entries },
740 739 { NWAM_NCU_PROP_IPV6_ADDRSRC, ncu_prop_ipv6_addrsrc_entries },
741 740 { NWAM_NCU_PROP_PRIORITY_MODE, ncu_prop_priority_mode_entries },
742 741 { NWAM_ENM_PROP_ACTIVATION_MODE, prop_activation_mode_value_entries },
743 742 { NWAM_LOC_PROP_ACTIVATION_MODE, prop_activation_mode_value_entries },
744 743 { NWAM_LOC_PROP_NAMESERVICES, loc_prop_nameservices_entries },
745 744 { NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC,
746 745 loc_prop_nameservice_configsrc_entries },
747 746 { NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC,
748 747 loc_prop_nameservice_configsrc_entries },
749 748 { NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC,
750 749 loc_prop_nameservice_configsrc_entries },
751 750 { NWAM_KNOWN_WLAN_PROP_SECURITY_MODE,
752 751 known_wlan_prop_security_mode_entries },
753 752 { NULL, NULL }
754 753 };
755 754
756 755 /*
757 756 * Convert uint64 values for property propname into a string representing
758 757 * that value. Used by enum values.
759 758 */
760 759 nwam_error_t
761 760 nwam_uint64_get_value_string(const char *propname, uint64_t val,
762 761 const char **valstrp)
763 762 {
764 763 int i, j;
765 764 int max = 0; /* largest enum value seen so far */
766 765 struct nwam_value_entry *value_entries;
767 766
768 767 assert(propname != NULL && valstrp != NULL);
769 768
770 769 for (i = 0; prop_value_entry_table[i].prop_name != NULL; i++) {
771 770 if (strcmp(prop_value_entry_table[i].prop_name, propname) != 0)
772 771 continue;
773 772
774 773 value_entries = prop_value_entry_table[i].value_entries;
775 774
776 775 for (j = 0; value_entries[j].value_string != NULL; j++) {
777 776 if (value_entries[j].value == val) {
778 777 *valstrp = value_entries[j].value_string;
779 778 return (NWAM_SUCCESS);
780 779 }
781 780 max = value_entries[j].value > max ?
782 781 value_entries[j].value : max;
783 782 }
784 783 /*
785 784 * If trying to get the string for an enum value that doesn't
786 785 * exist, return NWAM_LIST_END. Otherwise, the input enum
787 786 * value doesn't exist for the given property.
788 787 */
789 788 if (val > max)
790 789 return (NWAM_LIST_END);
791 790 else
792 791 return (NWAM_ENTITY_INVALID_VALUE);
793 792 }
794 793 return (NWAM_INVALID_ARG);
795 794 }
796 795
797 796 /*
798 797 * Convert string to appropriate uint64 value.
799 798 */
800 799 nwam_error_t
801 800 nwam_value_string_get_uint64(const char *propname, const char *valstr,
802 801 uint64_t *valp)
803 802 {
804 803 int i, j;
805 804 struct nwam_value_entry *value_entries;
806 805
807 806 assert(propname != NULL && valstr != NULL && valp != NULL);
808 807
809 808 for (i = 0; prop_value_entry_table[i].prop_name != NULL; i++) {
810 809 if (strcmp(prop_value_entry_table[i].prop_name, propname) != 0)
811 810 continue;
812 811
813 812 value_entries = prop_value_entry_table[i].value_entries;
814 813
815 814 for (j = 0; value_entries[j].value_string != NULL; j++) {
816 815 if (strcasecmp(value_entries[j].value_string, valstr)
817 816 == 0) {
818 817 *valp = value_entries[j].value;
819 818 return (NWAM_SUCCESS);
820 819 }
821 820 }
822 821 return (NWAM_ENTITY_INVALID_VALUE);
823 822 }
824 823 return (NWAM_INVALID_ARG);
825 824 }
826 825
827 826 /* Conditional activation functions */
828 827
829 828 nwam_error_t
830 829 nwam_condition_to_condition_string(nwam_condition_object_type_t object_type,
831 830 nwam_condition_t condition, const char *object_name, char **stringp)
832 831 {
833 832 char *object_type_string, *condition_string;
834 833 char *string;
835 834
836 835 assert(stringp != NULL);
837 836
838 837 *stringp = NULL;
839 838
840 839 switch (object_type) {
841 840 case NWAM_CONDITION_OBJECT_TYPE_NCP:
842 841 object_type_string = NWAM_CONDITION_OBJECT_TYPE_NCP_STRING;
843 842 break;
844 843 case NWAM_CONDITION_OBJECT_TYPE_NCU:
845 844 object_type_string = NWAM_CONDITION_OBJECT_TYPE_NCU_STRING;
846 845 break;
847 846 case NWAM_CONDITION_OBJECT_TYPE_ENM:
848 847 object_type_string = NWAM_CONDITION_OBJECT_TYPE_ENM_STRING;
849 848 break;
850 849 case NWAM_CONDITION_OBJECT_TYPE_LOC:
851 850 object_type_string = NWAM_CONDITION_OBJECT_TYPE_LOC_STRING;
852 851 break;
853 852 case NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS:
854 853 object_type_string =
855 854 NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS_STRING;
856 855 break;
857 856 case NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN:
858 857 object_type_string =
859 858 NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN_STRING;
860 859 break;
861 860 case NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN:
862 861 object_type_string =
863 862 NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN_STRING;
864 863 break;
865 864 case NWAM_CONDITION_OBJECT_TYPE_ESSID:
866 865 object_type_string = NWAM_CONDITION_OBJECT_TYPE_ESSID_STRING;
867 866 break;
868 867 case NWAM_CONDITION_OBJECT_TYPE_BSSID:
869 868 object_type_string = NWAM_CONDITION_OBJECT_TYPE_BSSID_STRING;
870 869 break;
871 870 default:
872 871 return (NWAM_INVALID_ARG);
873 872
874 873 }
875 874 switch (condition) {
876 875 case NWAM_CONDITION_IS:
877 876 condition_string = NWAM_CONDITION_IS_STRING;
878 877 break;
879 878 case NWAM_CONDITION_IS_NOT:
880 879 condition_string = NWAM_CONDITION_IS_NOT_STRING;
881 880 break;
882 881 case NWAM_CONDITION_CONTAINS:
883 882 if (object_type != NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN &&
884 883 object_type != NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN &&
885 884 object_type != NWAM_CONDITION_OBJECT_TYPE_ESSID)
886 885 return (NWAM_INVALID_ARG);
887 886 condition_string = NWAM_CONDITION_CONTAINS_STRING;
888 887 break;
889 888 case NWAM_CONDITION_DOES_NOT_CONTAIN:
890 889 if (object_type != NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN &&
891 890 object_type != NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN &&
892 891 object_type != NWAM_CONDITION_OBJECT_TYPE_ESSID)
893 892 return (NWAM_INVALID_ARG);
894 893
895 894 condition_string = NWAM_CONDITION_DOES_NOT_CONTAIN_STRING;
896 895 break;
897 896 case NWAM_CONDITION_IS_IN_RANGE:
898 897 if (object_type != NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS)
899 898 return (NWAM_INVALID_ARG);
900 899 condition_string = NWAM_CONDITION_IS_IN_RANGE_STRING;
901 900 break;
902 901 case NWAM_CONDITION_IS_NOT_IN_RANGE:
903 902 if (object_type != NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS)
904 903 return (NWAM_INVALID_ARG);
905 904 condition_string = NWAM_CONDITION_IS_NOT_IN_RANGE_STRING;
906 905 break;
907 906 default:
908 907 return (NWAM_INVALID_ARG);
909 908 }
910 909 if ((string = malloc(NWAM_MAX_VALUE_LEN)) == NULL)
911 910 return (NWAM_NO_MEMORY);
912 911 switch (object_type) {
913 912 case NWAM_CONDITION_OBJECT_TYPE_NCP:
914 913 case NWAM_CONDITION_OBJECT_TYPE_NCU:
915 914 case NWAM_CONDITION_OBJECT_TYPE_ENM:
916 915 case NWAM_CONDITION_OBJECT_TYPE_LOC:
917 916 (void) snprintf(string, NWAM_MAX_VALUE_LEN,
918 917 "%s %s %s active", object_type_string,
919 918 object_name, condition_string);
920 919 *stringp = string;
921 920 break;
922 921
923 922 case NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS:
924 923 case NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN:
925 924 case NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN:
926 925 case NWAM_CONDITION_OBJECT_TYPE_ESSID:
927 926 case NWAM_CONDITION_OBJECT_TYPE_BSSID:
928 927 (void) snprintf(string, NWAM_MAX_VALUE_LEN,
929 928 "%s %s %s", object_type_string,
930 929 condition_string, object_name);
931 930 *stringp = string;
932 931 break;
933 932
934 933 default:
935 934 free(string);
936 935 return (NWAM_INVALID_ARG);
937 936
938 937 }
939 938 return (NWAM_SUCCESS);
940 939 }
941 940
942 941 nwam_error_t
943 942 nwam_condition_string_to_condition(const char *string,
944 943 nwam_condition_object_type_t *object_typep,
945 944 nwam_condition_t *conditionp, char **object_namep)
946 945 {
947 946 char *copy, *lasts;
948 947 char *object_type_string, *object_name;
949 948 char *condition_string, *active_string;
950 949
951 950 assert(string != NULL && object_typep != NULL && conditionp != NULL &&
952 951 object_namep != NULL);
953 952
954 953 if ((copy = strdup(string)) == NULL)
955 954 return (NWAM_NO_MEMORY);
956 955
957 956 if ((object_type_string = strtok_r(copy, " \t", &lasts)) == NULL) {
958 957 free(copy);
959 958 return (NWAM_INVALID_ARG);
960 959 }
961 960
962 961 if (strcmp(object_type_string, NWAM_CONDITION_OBJECT_TYPE_NCP_STRING)
963 962 == 0)
964 963 *object_typep = NWAM_CONDITION_OBJECT_TYPE_NCP;
965 964 else if (strcmp(object_type_string,
966 965 NWAM_CONDITION_OBJECT_TYPE_NCU_STRING) == 0)
967 966 *object_typep = NWAM_CONDITION_OBJECT_TYPE_NCU;
968 967 else if (strcmp(object_type_string,
969 968 NWAM_CONDITION_OBJECT_TYPE_ENM_STRING) == 0)
970 969 *object_typep = NWAM_CONDITION_OBJECT_TYPE_ENM;
971 970 else if (strcmp(object_type_string,
972 971 NWAM_CONDITION_OBJECT_TYPE_LOC_STRING) == 0)
973 972 *object_typep = NWAM_CONDITION_OBJECT_TYPE_LOC;
974 973 else if (strcmp(object_type_string,
975 974 NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS_STRING) == 0)
976 975 *object_typep = NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS;
977 976 else if (strcmp(object_type_string,
978 977 NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN_STRING) == 0)
979 978 *object_typep = NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN;
980 979 else if (strcmp(object_type_string,
981 980 NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN_STRING) == 0)
982 981 *object_typep = NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN;
983 982 else if (strcmp(object_type_string,
984 983 NWAM_CONDITION_OBJECT_TYPE_ESSID_STRING) == 0)
985 984 *object_typep = NWAM_CONDITION_OBJECT_TYPE_ESSID;
986 985 else if (strcmp(object_type_string,
987 986 NWAM_CONDITION_OBJECT_TYPE_BSSID_STRING) == 0)
988 987 *object_typep = NWAM_CONDITION_OBJECT_TYPE_BSSID;
989 988 else {
990 989 free(copy);
991 990 return (NWAM_INVALID_ARG);
992 991 }
993 992
994 993 if (*object_typep == NWAM_CONDITION_OBJECT_TYPE_NCP ||
995 994 *object_typep == NWAM_CONDITION_OBJECT_TYPE_NCU ||
996 995 *object_typep == NWAM_CONDITION_OBJECT_TYPE_ENM ||
997 996 *object_typep == NWAM_CONDITION_OBJECT_TYPE_LOC) {
998 997 if ((object_name = strtok_r(NULL, " \t", &lasts)) == NULL) {
999 998 free(copy);
1000 999 return (NWAM_INVALID_ARG);
1001 1000 }
1002 1001 if ((*object_namep = strdup(object_name)) == NULL) {
1003 1002 free(copy);
1004 1003 return (NWAM_NO_MEMORY);
1005 1004 }
1006 1005
1007 1006 }
1008 1007
1009 1008 if ((condition_string = strtok_r(NULL, " \t", &lasts)) == NULL) {
1010 1009 free(copy);
1011 1010 if (*object_namep != NULL)
1012 1011 free(*object_namep);
1013 1012 return (NWAM_INVALID_ARG);
1014 1013 }
1015 1014 if (strcmp(condition_string, NWAM_CONDITION_IS_STRING) == 0)
1016 1015 *conditionp = NWAM_CONDITION_IS;
1017 1016 else if (strcmp(condition_string, NWAM_CONDITION_IS_NOT_STRING) == 0)
1018 1017 *conditionp = NWAM_CONDITION_IS_NOT;
1019 1018 else if (strcmp(condition_string, NWAM_CONDITION_CONTAINS_STRING) == 0)
1020 1019 *conditionp = NWAM_CONDITION_CONTAINS;
1021 1020 else if (strcmp(condition_string,
1022 1021 NWAM_CONDITION_DOES_NOT_CONTAIN_STRING) == 0)
1023 1022 *conditionp = NWAM_CONDITION_DOES_NOT_CONTAIN;
1024 1023 else if (strcmp(condition_string,
1025 1024 NWAM_CONDITION_IS_IN_RANGE_STRING) == 0)
1026 1025 *conditionp = NWAM_CONDITION_IS_IN_RANGE;
1027 1026 else if (strcmp(condition_string,
1028 1027 NWAM_CONDITION_IS_NOT_IN_RANGE_STRING) == 0)
1029 1028 *conditionp = NWAM_CONDITION_IS_NOT_IN_RANGE;
1030 1029 else {
1031 1030 free(copy);
1032 1031 if (*object_namep != NULL)
1033 1032 free(*object_namep);
1034 1033 return (NWAM_INVALID_ARG);
1035 1034 }
1036 1035
1037 1036 if (*object_typep == NWAM_CONDITION_OBJECT_TYPE_NCP ||
1038 1037 *object_typep == NWAM_CONDITION_OBJECT_TYPE_NCU ||
1039 1038 *object_typep == NWAM_CONDITION_OBJECT_TYPE_ENM ||
1040 1039 *object_typep == NWAM_CONDITION_OBJECT_TYPE_LOC) {
1041 1040 if ((*conditionp != NWAM_CONDITION_IS &&
1042 1041 *conditionp != NWAM_CONDITION_IS_NOT) ||
1043 1042 (active_string = strtok_r(NULL, " \t", &lasts)) == NULL ||
1044 1043 strcmp(active_string, NWAM_CONDITION_ACTIVE_STRING) != 0) {
1045 1044 free(copy);
1046 1045 free(*object_namep);
1047 1046 return (NWAM_INVALID_ARG);
1048 1047 }
1049 1048 } else {
1050 1049 switch (*conditionp) {
1051 1050 case NWAM_CONDITION_CONTAINS:
1052 1051 case NWAM_CONDITION_DOES_NOT_CONTAIN:
1053 1052 if (*object_typep !=
1054 1053 NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN &&
1055 1054 *object_typep !=
1056 1055 NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN &&
1057 1056 *object_typep != NWAM_CONDITION_OBJECT_TYPE_ESSID) {
1058 1057 free(copy);
1059 1058 free(*object_namep);
1060 1059 return (NWAM_INVALID_ARG);
1061 1060 }
1062 1061 break;
1063 1062 case NWAM_CONDITION_IS_IN_RANGE:
1064 1063 case NWAM_CONDITION_IS_NOT_IN_RANGE:
1065 1064 if (*object_typep !=
1066 1065 NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS) {
1067 1066 free(copy);
1068 1067 free(*object_namep);
1069 1068 return (NWAM_INVALID_ARG);
1070 1069 }
1071 1070 break;
1072 1071 }
1073 1072
1074 1073 if ((object_name = strtok_r(NULL, " \t", &lasts)) == NULL) {
1075 1074 free(copy);
1076 1075 free(*object_namep);
1077 1076 return (NWAM_INVALID_ARG);
1078 1077 }
1079 1078 if ((*object_namep = strdup(object_name)) == NULL) {
1080 1079 free(copy);
1081 1080 free(*object_namep);
1082 1081 return (NWAM_NO_MEMORY);
1083 1082 }
1084 1083 }
1085 1084
1086 1085 free(copy);
1087 1086 return (NWAM_SUCCESS);
1088 1087 }
1089 1088
1090 1089 nwam_error_t
1091 1090 nwam_condition_rate(nwam_condition_object_type_t object_type,
1092 1091 nwam_condition_t condition, uint64_t *ratep)
1093 1092 {
1094 1093 assert(ratep != NULL);
1095 1094
1096 1095 *ratep = 0;
1097 1096
1098 1097 switch (object_type) {
1099 1098 case NWAM_CONDITION_OBJECT_TYPE_NCP:
1100 1099 case NWAM_CONDITION_OBJECT_TYPE_NCU:
1101 1100 case NWAM_CONDITION_OBJECT_TYPE_ENM:
1102 1101 case NWAM_CONDITION_OBJECT_TYPE_LOC:
1103 1102 (*ratep)++;
1104 1103 /* FALLTHRU */
1105 1104 case NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN:
1106 1105 (*ratep)++;
1107 1106 /* FALLTHRU */
1108 1107 case NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN:
1109 1108 (*ratep)++;
1110 1109 /* FALLTHRU */
1111 1110 case NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS:
1112 1111 (*ratep)++;
1113 1112 /* FALLTHRU */
1114 1113 case NWAM_CONDITION_OBJECT_TYPE_BSSID:
1115 1114 (*ratep)++;
1116 1115 /* FALLTHRU */
1117 1116 case NWAM_CONDITION_OBJECT_TYPE_ESSID:
1118 1117 (*ratep)++;
1119 1118 break;
1120 1119 default:
1121 1120 return (NWAM_INVALID_ARG);
1122 1121 }
1123 1122
1124 1123 switch (condition) {
1125 1124 case NWAM_CONDITION_IS:
1126 1125 (*ratep)++;
1127 1126 /* FALLTHRU */
1128 1127 case NWAM_CONDITION_CONTAINS:
1129 1128 case NWAM_CONDITION_IS_IN_RANGE:
1130 1129 (*ratep)++;
1131 1130 /* FALLTHRU */
1132 1131 case NWAM_CONDITION_DOES_NOT_CONTAIN:
1133 1132 case NWAM_CONDITION_IS_NOT_IN_RANGE:
1134 1133 (*ratep)++;
1135 1134 /* FALLTHRU */
1136 1135 case NWAM_CONDITION_IS_NOT:
1137 1136 (*ratep)++;
1138 1137 break;
1139 1138 default:
1140 1139 return (NWAM_INVALID_ARG);
1141 1140 }
1142 1141 return (NWAM_SUCCESS);
1143 1142 }
|
↓ open down ↓ |
749 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX