Print this page
7388 Support DHCP Client FQDN. Allow IAID/DUID for all v4.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/libnwam/common/libnwam.h
+++ new/usr/src/lib/libnwam/common/libnwam.h
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 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
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 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23 + * Copyright (c) 2016, Chris Fraire <cfraire@me.com>.
23 24 */
24 25
25 26 /*
26 27 * This file contains data structures and APIs of libnwam.
27 28 * Implementation is MT safe.
28 29 */
29 30 #ifndef _LIBNWAM_H
30 31 #define _LIBNWAM_H
31 32
32 33 #ifdef __cplusplus
33 34 extern "C" {
34 35 #endif
35 36
36 37 #include <bsm/adt.h>
37 38 #include <net/if.h>
38 39 #include <inet/ip.h>
39 40 #include <inet/ip6.h>
40 41 #include <sys/types.h>
41 42 #include <sys/socket.h>
42 43
43 44 /*
44 45 * Note - several interface functions below are not utilized in ON, but are
45 46 * used by the GNOME nwam-manager. One example is nwam_enm_get_name().
46 47 */
47 48
48 49 /*
49 50 * Common definitions
50 51 */
51 52
52 53 /* nwam FMRI and properties */
53 54 #define NWAM_FMRI "svc:/network/physical:nwam"
54 55 #define NWAM_PG "nwamd"
55 56 #define NWAM_PROP_ACTIVE_NCP "active_ncp"
56 57
57 58 /* nwam flags used for read/commit */
58 59 /* Block waiting for commit if necessary */
59 60 #define NWAM_FLAG_BLOCKING 0x00000001
60 61 /* Committed object must be new */
61 62 #define NWAM_FLAG_CREATE 0x00000002
62 63 /* Tell destroy functions not to free handle */
63 64 #define NWAM_FLAG_DO_NOT_FREE 0x00000004
64 65 /* Object is being enabled/disabled */
65 66 #define NWAM_FLAG_ENTITY_ENABLE 0x00000008
66 67 /* Known WLAN being read, committed or destroyed */
67 68 #define NWAM_FLAG_ENTITY_KNOWN_WLAN 0x00000010
68 69
69 70 /* nwam flags used for selecting ncu type for walk */
70 71 #define NWAM_FLAG_NCU_TYPE_LINK 0x00000001ULL << 32
71 72 #define NWAM_FLAG_NCU_TYPE_INTERFACE 0x00000002ULL << 32
72 73 #define NWAM_FLAG_NCU_TYPE_ALL (NWAM_FLAG_NCU_TYPE_LINK | \
73 74 NWAM_FLAG_NCU_TYPE_INTERFACE)
74 75
75 76 /* nwam flags used for selecting ncu class for walk */
76 77 #define NWAM_FLAG_NCU_CLASS_PHYS 0x00000100ULL << 32
77 78 #define NWAM_FLAG_NCU_CLASS_IP 0x00010000ULL << 32
78 79 #define NWAM_FLAG_NCU_CLASS_ALL_LINK NWAM_FLAG_NCU_CLASS_PHYS
79 80 #define NWAM_FLAG_NCU_CLASS_ALL_INTERFACE NWAM_FLAG_NCU_CLASS_IP
80 81 #define NWAM_FLAG_NCU_CLASS_ALL (NWAM_FLAG_NCU_CLASS_ALL_INTERFACE | \
81 82 NWAM_FLAG_NCU_CLASS_ALL_LINK)
82 83 #define NWAM_FLAG_NCU_TYPE_CLASS_ALL (NWAM_FLAG_NCU_CLASS_ALL | \
83 84 NWAM_FLAG_NCU_TYPE_ALL)
84 85
85 86 /* flags used for selecting activation for walk */
86 87 #define NWAM_FLAG_ACTIVATION_MODE_MANUAL 0x000000001ULL << 32
87 88 #define NWAM_FLAG_ACTIVATION_MODE_SYSTEM 0x000000002ULL << 32
88 89 #define NWAM_FLAG_ACTIVATION_MODE_PRIORITIZED 0x000000004ULL << 32
89 90 #define NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ANY 0x000000008ULL << 32
90 91 #define NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ALL 0x000000010ULL << 32
91 92 #define NWAM_FLAG_ACTIVATION_MODE_ALL (NWAM_FLAG_ACTIVATION_MODE_MANUAL |\
92 93 NWAM_FLAG_ACTIVATION_MODE_SYSTEM |\
93 94 NWAM_FLAG_ACTIVATION_MODE_PRIORITIZED |\
94 95 NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ANY |\
95 96 NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ALL)
96 97
97 98 /* Walk known WLANs in order of priority (lowest first) */
98 99 #define NWAM_FLAG_KNOWN_WLAN_WALK_PRIORITY_ORDER 0x000010000ULL << 32
99 100 /* Do not perform priority collision checking for known WLANs */
100 101 #define NWAM_FLAG_KNOWN_WLAN_NO_COLLISION_CHECK 0x000020000ULL << 32
101 102
102 103 /* nwam return codes */
103 104 typedef enum {
104 105 NWAM_SUCCESS, /* No error occured */
105 106 NWAM_LIST_END, /* End of list reached */
106 107 NWAM_INVALID_HANDLE, /* Entity handle is invalid */
107 108 NWAM_HANDLE_UNBOUND, /* Handle not bound to entity */
108 109 NWAM_INVALID_ARG, /* Argument is invalid */
109 110 NWAM_PERMISSION_DENIED, /* Insufficient privileges for action */
110 111 NWAM_NO_MEMORY, /* Out of memory */
111 112 NWAM_ENTITY_EXISTS, /* Entity already exists */
112 113 NWAM_ENTITY_IN_USE, /* Entity in use */
113 114 NWAM_ENTITY_COMMITTED, /* Entity already committed */
114 115 NWAM_ENTITY_NOT_FOUND, /* Entity not found */
115 116 NWAM_ENTITY_TYPE_MISMATCH, /* Entity type mismatch */
116 117 NWAM_ENTITY_INVALID, /* Validation of entity failed */
117 118 NWAM_ENTITY_INVALID_MEMBER, /* Entity member invalid */
118 119 NWAM_ENTITY_INVALID_STATE, /* Entity is not in appropriate state */
119 120 NWAM_ENTITY_INVALID_VALUE, /* Validation of entity value failed */
120 121 NWAM_ENTITY_MISSING_MEMBER, /* Required member is missing */
121 122 NWAM_ENTITY_NO_VALUE, /* No value associated with entity */
122 123 NWAM_ENTITY_MULTIPLE_VALUES, /* Multiple values for entity */
123 124 NWAM_ENTITY_READ_ONLY, /* Entity is marked read only */
124 125 NWAM_ENTITY_NOT_DESTROYABLE, /* Entity cannot be destroyed */
125 126 NWAM_ENTITY_NOT_MANUAL, /* Entity cannot be manually enabled/disabled */
126 127 NWAM_WALK_HALTED, /* Callback function returned nonzero */
127 128 NWAM_ERROR_BIND, /* Could not bind to backend */
128 129 NWAM_ERROR_BACKEND_INIT, /* Could not initialize backend */
129 130 NWAM_ERROR_INTERNAL /* Internal error */
130 131 } nwam_error_t;
131 132
132 133 #define NWAM_MAX_NAME_LEN 128
133 134 #define NWAM_MAX_VALUE_LEN 256
134 135 #define NWAM_MAX_FMRI_LEN NWAM_MAX_VALUE_LEN
135 136 #define NWAM_MAX_NUM_VALUES 32
136 137 #define NWAM_MAX_NUM_PROPERTIES 32
137 138
138 139 /* used for getting and setting of properties */
139 140 typedef enum {
140 141 NWAM_VALUE_TYPE_BOOLEAN,
141 142 NWAM_VALUE_TYPE_INT64,
142 143 NWAM_VALUE_TYPE_UINT64,
143 144 NWAM_VALUE_TYPE_STRING,
144 145 NWAM_VALUE_TYPE_UNKNOWN
145 146 } nwam_value_type_t;
146 147
147 148 /* Holds values of various types for getting and setting of properties */
148 149 /* Forward definition */
149 150 struct nwam_value;
150 151 typedef struct nwam_value *nwam_value_t;
151 152
152 153 /* Value-related functions. */
153 154 extern nwam_error_t nwam_value_create_boolean(boolean_t, nwam_value_t *);
154 155 extern nwam_error_t nwam_value_create_boolean_array(boolean_t *, uint_t,
155 156 nwam_value_t *);
156 157 extern nwam_error_t nwam_value_create_int64(int64_t, nwam_value_t *);
157 158 extern nwam_error_t nwam_value_create_int64_array(int64_t *, uint_t,
158 159 nwam_value_t *);
159 160 extern nwam_error_t nwam_value_create_uint64(uint64_t, nwam_value_t *);
160 161 extern nwam_error_t nwam_value_create_uint64_array(uint64_t *, uint_t,
161 162 nwam_value_t *);
162 163 extern nwam_error_t nwam_value_create_string(char *, nwam_value_t *);
163 164 extern nwam_error_t nwam_value_create_string_array(char **, uint_t,
164 165 nwam_value_t *);
165 166
166 167 extern nwam_error_t nwam_value_get_boolean(nwam_value_t, boolean_t *);
167 168 extern nwam_error_t nwam_value_get_boolean_array(nwam_value_t, boolean_t **,
168 169 uint_t *);
169 170 extern nwam_error_t nwam_value_get_int64(nwam_value_t, int64_t *);
170 171 extern nwam_error_t nwam_value_get_int64_array(nwam_value_t, int64_t **,
171 172 uint_t *);
172 173 extern nwam_error_t nwam_value_get_uint64(nwam_value_t, uint64_t *);
173 174 extern nwam_error_t nwam_value_get_uint64_array(nwam_value_t, uint64_t **,
174 175 uint_t *);
175 176 extern nwam_error_t nwam_value_get_string(nwam_value_t, char **);
176 177 extern nwam_error_t nwam_value_get_string_array(nwam_value_t, char ***,
177 178 uint_t *);
178 179
179 180 extern nwam_error_t nwam_value_get_type(nwam_value_t, nwam_value_type_t *);
180 181 extern nwam_error_t nwam_value_get_numvalues(nwam_value_t, uint_t *);
181 182
182 183 extern void nwam_value_free(nwam_value_t);
183 184 extern nwam_error_t nwam_value_copy(nwam_value_t, nwam_value_t *);
184 185
185 186 extern nwam_error_t nwam_uint64_get_value_string(const char *, uint64_t,
186 187 const char **);
187 188 extern nwam_error_t nwam_value_string_get_uint64(const char *, const char *,
188 189 uint64_t *);
189 190
190 191 /*
191 192 * To retrieve a localized error string
192 193 */
193 194 extern const char *nwam_strerror(nwam_error_t);
194 195
195 196 /*
196 197 * State and auxiliary state describe the state of ENMs, NCUs and locations.
197 198 */
198 199 typedef enum {
199 200 NWAM_STATE_UNINITIALIZED = 0x0,
200 201 NWAM_STATE_INITIALIZED = 0x1,
201 202 NWAM_STATE_OFFLINE = 0x2,
202 203 NWAM_STATE_OFFLINE_TO_ONLINE = 0x4,
203 204 NWAM_STATE_ONLINE_TO_OFFLINE = 0x8,
204 205 NWAM_STATE_ONLINE = 0x10,
205 206 NWAM_STATE_MAINTENANCE = 0x20,
206 207 NWAM_STATE_DEGRADED = 0x40,
207 208 NWAM_STATE_DISABLED = 0x80
208 209 } nwam_state_t;
209 210
210 211 #define NWAM_STATE_ANY (NWAM_STATE_UNINITIALIZED | \
211 212 NWAM_STATE_INITIALIZED | \
212 213 NWAM_STATE_OFFLINE | \
213 214 NWAM_STATE_OFFLINE_TO_ONLINE | \
214 215 NWAM_STATE_ONLINE_TO_OFFLINE | \
215 216 NWAM_STATE_ONLINE | \
216 217 NWAM_STATE_MAINTENANCE | \
217 218 NWAM_STATE_DEGRADED | \
218 219 NWAM_STATE_DISABLED)
219 220
220 221 /*
221 222 * The auxiliary state denotes specific reasons why an object is in a particular
222 223 * state (e.g. "script failed", "disabled by administrator", "waiting for DHCP
223 224 * response").
224 225 */
225 226 typedef enum {
226 227 /* General auxiliary states */
227 228 NWAM_AUX_STATE_UNINITIALIZED,
228 229 NWAM_AUX_STATE_INITIALIZED,
229 230 NWAM_AUX_STATE_CONDITIONS_NOT_MET,
230 231 NWAM_AUX_STATE_MANUAL_DISABLE,
231 232 NWAM_AUX_STATE_METHOD_FAILED,
232 233 NWAM_AUX_STATE_METHOD_MISSING,
233 234 NWAM_AUX_STATE_METHOD_RUNNING,
234 235 NWAM_AUX_STATE_INVALID_CONFIG,
235 236 NWAM_AUX_STATE_ACTIVE,
236 237 /* Link-specific auxiliary states */
237 238 NWAM_AUX_STATE_LINK_WIFI_SCANNING,
238 239 NWAM_AUX_STATE_LINK_WIFI_NEED_SELECTION,
239 240 NWAM_AUX_STATE_LINK_WIFI_NEED_KEY,
240 241 NWAM_AUX_STATE_LINK_WIFI_CONNECTING,
241 242 /* IP interface-specific auxiliary states */
242 243 NWAM_AUX_STATE_IF_WAITING_FOR_ADDR,
243 244 NWAM_AUX_STATE_IF_DHCP_TIMED_OUT,
244 245 NWAM_AUX_STATE_IF_DUPLICATE_ADDR,
245 246 /* Common link/interface auxiliary states */
246 247 NWAM_AUX_STATE_UP,
247 248 NWAM_AUX_STATE_DOWN,
248 249 NWAM_AUX_STATE_NOT_FOUND
249 250 } nwam_aux_state_t;
250 251
251 252 /* Activation modes */
252 253 typedef enum {
253 254 NWAM_ACTIVATION_MODE_MANUAL,
254 255 NWAM_ACTIVATION_MODE_SYSTEM,
255 256 NWAM_ACTIVATION_MODE_CONDITIONAL_ANY,
256 257 NWAM_ACTIVATION_MODE_CONDITIONAL_ALL,
257 258 NWAM_ACTIVATION_MODE_PRIORITIZED
258 259 } nwam_activation_mode_t;
259 260
260 261 /*
261 262 * Conditions are of the form
262 263 *
263 264 * ncu|enm|loc name is|is-not active
264 265 * ip-address is|is-not|is-in-range|is-not-in-range ipaddr[/prefixlen]
265 266 * advertised-domain is|is-not|contains|does-not-contain string
266 267 * system-domain is|is-not|contains|does-not-contain string
267 268 * essid is|is-not|contains|does-not-contain string
268 269 * bssid is|is-not <string>
269 270 */
270 271
271 272 typedef enum {
272 273 NWAM_CONDITION_IS,
273 274 NWAM_CONDITION_IS_NOT,
274 275 NWAM_CONDITION_IS_IN_RANGE,
275 276 NWAM_CONDITION_IS_NOT_IN_RANGE,
276 277 NWAM_CONDITION_CONTAINS,
277 278 NWAM_CONDITION_DOES_NOT_CONTAIN
278 279 } nwam_condition_t;
279 280
280 281 typedef enum {
281 282 NWAM_CONDITION_OBJECT_TYPE_NCP,
282 283 NWAM_CONDITION_OBJECT_TYPE_NCU,
283 284 NWAM_CONDITION_OBJECT_TYPE_ENM,
284 285 NWAM_CONDITION_OBJECT_TYPE_LOC,
285 286 NWAM_CONDITION_OBJECT_TYPE_IP_ADDRESS,
286 287 NWAM_CONDITION_OBJECT_TYPE_ADV_DOMAIN,
287 288 NWAM_CONDITION_OBJECT_TYPE_SYS_DOMAIN,
288 289 NWAM_CONDITION_OBJECT_TYPE_ESSID,
289 290 NWAM_CONDITION_OBJECT_TYPE_BSSID
290 291 } nwam_condition_object_type_t;
291 292
292 293 /*
293 294 * Activation condition-related functions that convert activation
294 295 * values to an appropriate string and back.
295 296 */
296 297 extern nwam_error_t nwam_condition_to_condition_string(
297 298 nwam_condition_object_type_t, nwam_condition_t, const char *, char **);
298 299 extern nwam_error_t nwam_condition_string_to_condition(const char *,
299 300 nwam_condition_object_type_t *, nwam_condition_t *, char **);
300 301
301 302 /*
302 303 * Only one location can be active at one time. As a
303 304 * consequence, if the activation conditions of multiple
304 305 * locations are satisfied, we need to compare activation
305 306 * conditions to see if one is more specific than another.
306 307 *
307 308 * The following heuristics are applied to rate an
308 309 * activation condition:
309 310 * - "is" is the most specific condition
310 311 * - it is followed by "is-in-range" and "contains"
311 312 * - "is-not-in-range" and "does-not-contain" are next
312 313 * - finally "is-not" is least specific
313 314 *
314 315 * Regarding the objects these conditions apply to:
315 316 * - NCU, ENM and locations are most specific
316 317 * - system-domain is next
317 318 * - advertised-domain is next
318 319 * - IP address is next
319 320 * - wireless BSSID is next
320 321 * - wireless ESSID is least specific
321 322 *
322 323 */
323 324 extern nwam_error_t nwam_condition_rate(nwam_condition_object_type_t,
324 325 nwam_condition_t, uint64_t *);
325 326
326 327 /*
327 328 * Location definitions.
328 329 */
329 330
330 331 #define NWAM_LOC_NAME_AUTOMATIC "Automatic"
331 332 #define NWAM_LOC_NAME_NO_NET "NoNet"
332 333 #define NWAM_LOC_NAME_LEGACY "Legacy"
333 334
334 335 #define NWAM_LOC_NAME_PRE_DEFINED(name) \
335 336 (strcasecmp(name, NWAM_LOC_NAME_AUTOMATIC) == 0 || \
336 337 strcasecmp(name, NWAM_LOC_NAME_NO_NET) == 0 || \
337 338 strcasecmp(name, NWAM_LOC_NAME_LEGACY) == 0)
338 339
339 340 /* Forward definition */
340 341 struct nwam_handle;
341 342
342 343 typedef struct nwam_handle *nwam_loc_handle_t;
343 344
344 345 /* Location properties */
345 346
346 347 typedef enum {
347 348 NWAM_NAMESERVICES_DNS,
348 349 NWAM_NAMESERVICES_FILES,
349 350 NWAM_NAMESERVICES_NIS,
350 351 NWAM_NAMESERVICES_LDAP
351 352 } nwam_nameservices_t;
352 353
353 354 typedef enum {
354 355 NWAM_CONFIGSRC_MANUAL,
355 356 NWAM_CONFIGSRC_DHCP
356 357 } nwam_configsrc_t;
357 358
358 359 #define NWAM_LOC_PROP_ACTIVATION_MODE "activation-mode"
359 360 #define NWAM_LOC_PROP_CONDITIONS "conditions"
360 361 #define NWAM_LOC_PROP_ENABLED "enabled"
361 362
362 363 /* Nameservice location properties */
363 364 #define NWAM_LOC_PROP_NAMESERVICES "nameservices"
364 365 #define NWAM_LOC_PROP_NAMESERVICES_CONFIG_FILE "nameservices-config-file"
365 366 #define NWAM_LOC_PROP_DNS_NAMESERVICE_CONFIGSRC "dns-nameservice-configsrc"
366 367 #define NWAM_LOC_PROP_DNS_NAMESERVICE_DOMAIN "dns-nameservice-domain"
367 368 #define NWAM_LOC_PROP_DNS_NAMESERVICE_SERVERS "dns-nameservice-servers"
368 369 #define NWAM_LOC_PROP_DNS_NAMESERVICE_SEARCH "dns-nameservice-search"
369 370 #define NWAM_LOC_PROP_NIS_NAMESERVICE_CONFIGSRC "nis-nameservice-configsrc"
370 371 #define NWAM_LOC_PROP_NIS_NAMESERVICE_SERVERS "nis-nameservice-servers"
371 372 #define NWAM_LOC_PROP_LDAP_NAMESERVICE_CONFIGSRC "ldap-nameservice-configsrc"
372 373 #define NWAM_LOC_PROP_LDAP_NAMESERVICE_SERVERS "ldap-nameservice-servers"
373 374 #define NWAM_LOC_PROP_DEFAULT_DOMAIN "default-domain"
374 375
375 376 /* NFSv4 domain */
376 377 #define NWAM_LOC_PROP_NFSV4_DOMAIN "nfsv4-domain"
377 378
378 379 /* IPfilter configuration */
379 380 #define NWAM_LOC_PROP_IPFILTER_CONFIG_FILE "ipfilter-config-file"
380 381 #define NWAM_LOC_PROP_IPFILTER_V6_CONFIG_FILE "ipfilter-v6-config-file"
381 382 #define NWAM_LOC_PROP_IPNAT_CONFIG_FILE "ipnat-config-file"
382 383 #define NWAM_LOC_PROP_IPPOOL_CONFIG_FILE "ippool-config-file"
383 384
384 385 /* IPsec configuration */
385 386 #define NWAM_LOC_PROP_IKE_CONFIG_FILE "ike-config-file"
386 387 #define NWAM_LOC_PROP_IPSECPOLICY_CONFIG_FILE "ipsecpolicy-config-file"
387 388
388 389 /*
389 390 * NCP/NCU definitions.
390 391 */
391 392
392 393 #define NWAM_NCP_NAME_AUTOMATIC "Automatic"
393 394 #define NWAM_NCP_NAME_USER "User"
394 395
395 396 #define NWAM_NCP_AUTOMATIC(name) \
396 397 (strcasecmp(name, NWAM_NCP_NAME_AUTOMATIC) == 0)
397 398
398 399 typedef struct nwam_handle *nwam_ncp_handle_t;
399 400
400 401 typedef struct nwam_handle *nwam_ncu_handle_t;
401 402
402 403 typedef enum {
403 404 NWAM_NCU_TYPE_UNKNOWN = -1,
404 405 NWAM_NCU_TYPE_LINK,
405 406 NWAM_NCU_TYPE_INTERFACE,
406 407 NWAM_NCU_TYPE_ANY
407 408 } nwam_ncu_type_t;
408 409
409 410 typedef enum {
410 411 NWAM_NCU_CLASS_UNKNOWN = -1,
411 412 NWAM_NCU_CLASS_PHYS,
412 413 NWAM_NCU_CLASS_IP,
413 414 NWAM_NCU_CLASS_ANY
414 415 } nwam_ncu_class_t;
415 416
416 417 typedef enum {
417 418 NWAM_ADDRSRC_DHCP,
418 419 NWAM_ADDRSRC_AUTOCONF,
419 420 NWAM_ADDRSRC_STATIC
420 421 } nwam_addrsrc_t;
421 422
422 423 typedef enum {
423 424 NWAM_PRIORITY_MODE_EXCLUSIVE,
424 425 NWAM_PRIORITY_MODE_SHARED,
425 426 NWAM_PRIORITY_MODE_ALL
426 427 } nwam_priority_mode_t;
427 428
428 429 /* NCU properties common to all type/classes */
429 430 #define NWAM_NCU_PROP_TYPE "type"
430 431 #define NWAM_NCU_PROP_CLASS "class"
431 432 #define NWAM_NCU_PROP_PARENT_NCP "parent"
432 433 #define NWAM_NCU_PROP_ACTIVATION_MODE "activation-mode"
433 434 #define NWAM_NCU_PROP_ENABLED "enabled"
434 435 #define NWAM_NCU_PROP_PRIORITY_GROUP "priority-group"
435 436 #define NWAM_NCU_PROP_PRIORITY_MODE "priority-mode"
436 437
437 438 /* Link NCU properties */
438 439 #define NWAM_NCU_PROP_LINK_MAC_ADDR "link-mac-addr"
439 440 #define NWAM_NCU_PROP_LINK_AUTOPUSH "link-autopush"
|
↓ open down ↓ |
407 lines elided |
↑ open up ↑ |
440 441 #define NWAM_NCU_PROP_LINK_MTU "link-mtu"
441 442
442 443 /* IP NCU properties */
443 444 #define NWAM_NCU_PROP_IP_VERSION "ip-version"
444 445 #define NWAM_NCU_PROP_IPV4_ADDRSRC "ipv4-addrsrc"
445 446 #define NWAM_NCU_PROP_IPV4_ADDR "ipv4-addr"
446 447 #define NWAM_NCU_PROP_IPV4_DEFAULT_ROUTE "ipv4-default-route"
447 448 #define NWAM_NCU_PROP_IPV6_ADDRSRC "ipv6-addrsrc"
448 449 #define NWAM_NCU_PROP_IPV6_ADDR "ipv6-addr"
449 450 #define NWAM_NCU_PROP_IPV6_DEFAULT_ROUTE "ipv6-default-route"
451 +#define NWAM_NCU_PROP_IP_PRIMARY "ip-primary"
452 +#define NWAM_NCU_PROP_IP_REQHOST "ip-reqhost"
450 453
451 454 /* Some properties should only be set on creation */
452 455 #define NWAM_NCU_PROP_SETONCE(prop) \
453 456 (strcmp(prop, NWAM_NCU_PROP_TYPE) == 0 || \
454 457 strcmp(prop, NWAM_NCU_PROP_CLASS) == 0 || \
455 458 strcmp(prop, NWAM_NCU_PROP_PARENT_NCP) == 0)
456 459 /*
457 460 * ENM definitions
458 461 */
459 462
460 463 typedef struct nwam_handle *nwam_enm_handle_t;
461 464
462 465 #define NWAM_ENM_PROP_ACTIVATION_MODE "activation-mode"
463 466 #define NWAM_ENM_PROP_CONDITIONS "conditions"
464 467 #define NWAM_ENM_PROP_ENABLED "enabled"
465 468
466 469 /* FMRI associated with ENM */
467 470 #define NWAM_ENM_PROP_FMRI "fmri"
468 471
469 472 /* Start/stop scripts associated with ENM */
470 473 #define NWAM_ENM_PROP_START "start"
471 474 #define NWAM_ENM_PROP_STOP "stop"
472 475
473 476 /*
474 477 * Known Wireless LAN info (known WLAN) definitions.
475 478 */
476 479
477 480 typedef struct nwam_handle *nwam_known_wlan_handle_t;
478 481
479 482 #define NWAM_KNOWN_WLAN_PROP_BSSIDS "bssids"
480 483 #define NWAM_KNOWN_WLAN_PROP_PRIORITY "priority"
481 484 #define NWAM_KNOWN_WLAN_PROP_KEYNAME "keyname"
482 485 #define NWAM_KNOWN_WLAN_PROP_KEYSLOT "keyslot"
483 486 #define NWAM_KNOWN_WLAN_PROP_SECURITY_MODE "security-mode"
484 487
485 488 /*
486 489 * Location Functions
487 490 */
488 491
489 492 /* Create a location */
490 493 extern nwam_error_t nwam_loc_create(const char *, nwam_loc_handle_t *);
491 494
492 495 /* Copy a location */
493 496 extern nwam_error_t nwam_loc_copy(nwam_loc_handle_t, const char *,
494 497 nwam_loc_handle_t *);
495 498
496 499 /* Read a location from persistent storage */
497 500 extern nwam_error_t nwam_loc_read(const char *, uint64_t,
498 501 nwam_loc_handle_t *);
499 502
500 503 /* Validate in-memory representation of a location */
501 504 extern nwam_error_t nwam_loc_validate(nwam_loc_handle_t, const char **);
502 505
503 506 /* Commit in-memory representation of a location to persistent storage */
504 507 extern nwam_error_t nwam_loc_commit(nwam_loc_handle_t, uint64_t);
505 508
506 509 /* Destroy a location in persistent storage */
507 510 extern nwam_error_t nwam_loc_destroy(nwam_loc_handle_t, uint64_t);
508 511
509 512 /* Free in-memory representation of a location */
510 513 extern void nwam_loc_free(nwam_loc_handle_t);
511 514
512 515 /* read all locs from persistent storage and walk through each at a time */
513 516 extern nwam_error_t nwam_walk_locs(int (*)(nwam_loc_handle_t, void *), void *,
514 517 uint64_t, int *);
515 518
516 519 /* get/set loc name */
517 520 extern nwam_error_t nwam_loc_get_name(nwam_loc_handle_t, char **);
518 521 extern nwam_error_t nwam_loc_set_name(nwam_loc_handle_t, const char *);
519 522 extern boolean_t nwam_loc_can_set_name(nwam_loc_handle_t);
520 523
521 524 /* activate/deactivate loc */
522 525 extern nwam_error_t nwam_loc_enable(nwam_loc_handle_t);
523 526 extern nwam_error_t nwam_loc_disable(nwam_loc_handle_t);
524 527
525 528 /* walk all properties of an in-memory loc */
526 529 extern nwam_error_t nwam_loc_walk_props(nwam_loc_handle_t,
527 530 int (*)(const char *, nwam_value_t, void *),
528 531 void *, uint64_t, int *);
529 532
530 533 /* delete/get/set validate loc property */
531 534 extern nwam_error_t nwam_loc_delete_prop(nwam_loc_handle_t,
532 535 const char *);
533 536 extern nwam_error_t nwam_loc_get_prop_value(nwam_loc_handle_t,
534 537 const char *, nwam_value_t *);
535 538 extern nwam_error_t nwam_loc_set_prop_value(nwam_loc_handle_t,
536 539 const char *, nwam_value_t);
537 540 extern nwam_error_t nwam_loc_validate_prop(nwam_loc_handle_t, const char *,
538 541 nwam_value_t);
539 542
540 543 /* Get the read-only value for a particular loc property */
541 544 extern nwam_error_t nwam_loc_prop_read_only(const char *, boolean_t *);
542 545
543 546 /* Whether the property is multi-valued or not */
544 547 extern nwam_error_t nwam_loc_prop_multivalued(const char *, boolean_t *);
545 548
546 549 /* Retrieve data type */
547 550 extern nwam_error_t nwam_loc_get_prop_type(const char *, nwam_value_type_t *);
548 551
549 552 /* Retrieve description */
550 553 extern nwam_error_t nwam_loc_get_prop_description(const char *, const char **);
551 554
552 555 /* get default loc props */
553 556 extern nwam_error_t nwam_loc_get_default_proplist(const char ***, uint_t *);
554 557
555 558 /* get sstate of loc from nwamd */
556 559 extern nwam_error_t nwam_loc_get_state(nwam_loc_handle_t, nwam_state_t *,
557 560 nwam_aux_state_t *);
558 561
559 562 /* Get whether the loc has manual activation-mode or not */
560 563 extern nwam_error_t nwam_loc_is_manual(nwam_loc_handle_t, boolean_t *);
561 564
562 565 /*
563 566 * NCP/NCU functions
564 567 */
565 568
566 569 /* Create an ncp */
567 570 extern nwam_error_t nwam_ncp_create(const char *, uint64_t,
568 571 nwam_ncp_handle_t *);
569 572
570 573 /* Read an ncp from persistent storage */
571 574 extern nwam_error_t nwam_ncp_read(const char *, uint64_t, nwam_ncp_handle_t *);
572 575
573 576 /* Make a copy of existing ncp */
574 577 extern nwam_error_t nwam_ncp_copy(nwam_ncp_handle_t, const char *,
575 578 nwam_ncp_handle_t *);
576 579
577 580 /* Walk ncps */
578 581 extern nwam_error_t nwam_walk_ncps(int (*)(nwam_ncp_handle_t, void *),
579 582 void *, uint64_t, int *);
580 583
581 584 /* Get ncp name */
582 585 extern nwam_error_t nwam_ncp_get_name(nwam_ncp_handle_t, char **);
583 586
584 587 /* Get the read-only value for this ncp */
585 588 extern nwam_error_t nwam_ncp_get_read_only(nwam_ncp_handle_t, boolean_t *);
586 589
587 590 /* Destroy ncp */
588 591 extern nwam_error_t nwam_ncp_destroy(nwam_ncp_handle_t, uint64_t);
589 592
590 593 /*
591 594 * Walk all ncus associated with ncp. Specific types/classes of ncu can
592 595 * be selected via flags, or all via NWAM_FLAG_ALL.
593 596 */
594 597 extern nwam_error_t nwam_ncp_walk_ncus(nwam_ncp_handle_t,
595 598 int(*)(nwam_ncu_handle_t, void *), void *, uint64_t, int *);
596 599
597 600 /* Activate ncp */
598 601 extern nwam_error_t nwam_ncp_enable(nwam_ncp_handle_t);
599 602
600 603 /* Free in-memory representation of ncp */
601 604 extern void nwam_ncp_free(nwam_ncp_handle_t);
602 605
603 606 /* Get state of NCP from nwamd */
604 607 extern nwam_error_t nwam_ncp_get_state(nwam_ncp_handle_t, nwam_state_t *,
605 608 nwam_aux_state_t *);
606 609
607 610 /* Get the active priority-group */
608 611 extern nwam_error_t nwam_ncp_get_active_priority_group(int64_t *);
609 612
610 613 /* Create an ncu or read it from persistent storage */
611 614 extern nwam_error_t nwam_ncu_create(nwam_ncp_handle_t, const char *,
612 615 nwam_ncu_type_t, nwam_ncu_class_t, nwam_ncu_handle_t *);
613 616 extern nwam_error_t nwam_ncu_read(nwam_ncp_handle_t, const char *,
614 617 nwam_ncu_type_t, uint64_t, nwam_ncu_handle_t *);
615 618
616 619 /* Destroy an ncu in persistent storage or free the in-memory representation */
617 620 extern nwam_error_t nwam_ncu_destroy(nwam_ncu_handle_t, uint64_t);
618 621 extern void nwam_ncu_free(nwam_ncu_handle_t);
619 622
620 623 /* make a copy of existing ncu */
621 624 extern nwam_error_t nwam_ncu_copy(nwam_ncu_handle_t, const char *,
622 625 nwam_ncu_handle_t *);
623 626
624 627 /* Commit ncu changes to persistent storage */
625 628 extern nwam_error_t nwam_ncu_commit(nwam_ncu_handle_t, uint64_t);
626 629
627 630 /* activate/deactivate an individual NCU (must be part of the active NCP) */
628 631 extern nwam_error_t nwam_ncu_enable(nwam_ncu_handle_t);
629 632 extern nwam_error_t nwam_ncu_disable(nwam_ncu_handle_t);
630 633
631 634 /* Get state of NCU from nwamd */
632 635 extern nwam_error_t nwam_ncu_get_state(nwam_ncu_handle_t, nwam_state_t *,
633 636 nwam_aux_state_t *);
634 637
635 638 /* Get NCU type */
636 639 extern nwam_error_t nwam_ncu_get_ncu_type(nwam_ncu_handle_t, nwam_ncu_type_t *);
637 640
638 641 /* Get NCU class */
639 642 extern nwam_error_t nwam_ncu_get_ncu_class(nwam_ncu_handle_t,
640 643 nwam_ncu_class_t *);
641 644
642 645 /* Validate ncu content */
643 646 extern nwam_error_t nwam_ncu_validate(nwam_ncu_handle_t, const char **);
644 647
645 648 /* Walk all properties in in-memory representation of ncu */
646 649 extern nwam_error_t nwam_ncu_walk_props(nwam_ncu_handle_t,
647 650 int (*)(const char *, nwam_value_t, void *),
648 651 void *, uint64_t, int *);
649 652
650 653 /* Get/set name of ncu, get parent ncp */
651 654 extern nwam_error_t nwam_ncu_get_name(nwam_ncu_handle_t, char **);
652 655 extern nwam_error_t nwam_ncu_name_to_typed_name(const char *, nwam_ncu_type_t,
653 656 char **);
654 657 extern nwam_error_t nwam_ncu_typed_name_to_name(const char *, nwam_ncu_type_t *,
655 658 char **);
656 659 extern nwam_error_t nwam_ncu_get_default_proplist(nwam_ncu_type_t,
657 660 nwam_ncu_class_t, const char ***, uint_t *);
658 661 extern nwam_error_t nwam_ncu_get_ncp(nwam_ncu_handle_t, nwam_ncp_handle_t *);
659 662
660 663 /* delete/get/set/validate property from/in in-memory representation of ncu */
661 664 extern nwam_error_t nwam_ncu_delete_prop(nwam_ncu_handle_t,
662 665 const char *);
663 666 extern nwam_error_t nwam_ncu_get_prop_value(nwam_ncu_handle_t,
664 667 const char *, nwam_value_t *);
665 668 extern nwam_error_t nwam_ncu_set_prop_value(nwam_ncu_handle_t,
666 669 const char *, nwam_value_t);
667 670
668 671 extern nwam_error_t nwam_ncu_validate_prop(nwam_ncu_handle_t, const char *,
669 672 nwam_value_t);
670 673
671 674 /* Retrieve data type */
672 675 extern nwam_error_t nwam_ncu_get_prop_type(const char *, nwam_value_type_t *);
673 676 /* Retrieve prop description */
674 677 extern nwam_error_t nwam_ncu_get_prop_description(const char *, const char **);
675 678
676 679 /* Get the read-only value from the handle or parent NCP */
677 680 extern nwam_error_t nwam_ncu_get_read_only(nwam_ncu_handle_t, boolean_t *);
678 681
679 682 /* Get the read-only value for a particular NCU property */
680 683 extern nwam_error_t nwam_ncu_prop_read_only(const char *, boolean_t *);
681 684
682 685 /* Whether the property is multi-valued or not */
683 686 extern nwam_error_t nwam_ncu_prop_multivalued(const char *, boolean_t *);
684 687
685 688 /* Get whether the NCU has manual activation-mode or not */
686 689 extern nwam_error_t nwam_ncu_is_manual(nwam_ncu_handle_t, boolean_t *);
687 690
688 691 /* Get the flag from the given class for walks */
689 692 extern uint64_t nwam_ncu_class_to_flag(nwam_ncu_class_t);
690 693
691 694 /* Get the NCU type from the given class */
692 695 extern nwam_ncu_type_t nwam_ncu_class_to_type(nwam_ncu_class_t);
693 696
694 697 /* ENM functions */
695 698 /*
696 699 * Obtain a specific enm handle, either be creating a new enm
697 700 * or reading an existing one from persistent storage.
698 701 */
699 702 extern nwam_error_t nwam_enm_create(const char *, const char *,
700 703 nwam_enm_handle_t *);
701 704 extern nwam_error_t nwam_enm_read(const char *, uint64_t, nwam_enm_handle_t *);
702 705
703 706 /* Make a copy of existing enm */
704 707 extern nwam_error_t nwam_enm_copy(nwam_enm_handle_t, const char *,
705 708 nwam_enm_handle_t *);
706 709
707 710 /*
708 711 * Obtain handles for all existing enms. Caller-specified callback
709 712 * function will be called once for each enm, passing the handle and
710 713 * the caller-specified arg.
711 714 */
712 715 extern nwam_error_t nwam_walk_enms(int (*)(nwam_enm_handle_t, void *), void *,
713 716 uint64_t, int *);
714 717
715 718 /*
716 719 * Commit an enm to persistent storage. Does not free the handle.
717 720 */
718 721 extern nwam_error_t nwam_enm_commit(nwam_enm_handle_t, uint64_t);
719 722
720 723 /*
721 724 * Remove an enm from persistent storage.
722 725 */
723 726 extern nwam_error_t nwam_enm_destroy(nwam_enm_handle_t, uint64_t);
724 727
725 728 /*
726 729 * Free an enm handle
727 730 */
728 731 extern void nwam_enm_free(nwam_enm_handle_t);
729 732
730 733 /*
731 734 * Validate an enm, or a specific enm property. If validating
732 735 * an entire enm, the invalid property type is returned.
733 736 */
734 737 extern nwam_error_t nwam_enm_validate(nwam_enm_handle_t, const char **);
735 738 extern nwam_error_t nwam_enm_validate_prop(nwam_enm_handle_t, const char *,
736 739 nwam_value_t);
737 740
738 741 /* Retrieve data type */
739 742 extern nwam_error_t nwam_enm_get_prop_type(const char *, nwam_value_type_t *);
740 743 /* Retrieve prop description */
741 744 extern nwam_error_t nwam_enm_get_prop_description(const char *, const char **);
742 745
743 746 /*
744 747 * Delete/get/set enm property values.
745 748 */
746 749 extern nwam_error_t nwam_enm_delete_prop(nwam_enm_handle_t,
747 750 const char *);
748 751 extern nwam_error_t nwam_enm_get_prop_value(nwam_enm_handle_t,
749 752 const char *, nwam_value_t *);
750 753 extern nwam_error_t nwam_enm_set_prop_value(nwam_enm_handle_t,
751 754 const char *, nwam_value_t);
752 755
753 756 extern nwam_error_t nwam_enm_get_default_proplist(const char ***, uint_t *);
754 757
755 758 /* Get the read-only value for a particular ENM property */
756 759 extern nwam_error_t nwam_enm_prop_read_only(const char *, boolean_t *);
757 760
758 761 /* Whether the property is multi-valued or not */
759 762 extern nwam_error_t nwam_enm_prop_multivalued(const char *, boolean_t *);
760 763
761 764 /*
762 765 * Walk all properties of a specific enm. For each property, specified
763 766 * callback function is called. Caller is responsible for freeing memory
764 767 * allocated for each property.
765 768 */
766 769 extern nwam_error_t nwam_enm_walk_props(nwam_enm_handle_t,
767 770 int (*)(const char *, nwam_value_t, void *),
768 771 void *, uint64_t, int *);
769 772
770 773 /*
771 774 * Get/set the name of an enm. When getting the name, the library will
772 775 * allocate a buffer; the caller is responsible for freeing the memory.
773 776 */
774 777 extern nwam_error_t nwam_enm_get_name(nwam_enm_handle_t, char **);
775 778 extern nwam_error_t nwam_enm_set_name(nwam_enm_handle_t, const char *);
776 779 extern boolean_t nwam_enm_can_set_name(nwam_enm_handle_t);
777 780
778 781 /*
779 782 * Start/stop an enm.
780 783 */
781 784 extern nwam_error_t nwam_enm_enable(nwam_enm_handle_t);
782 785 extern nwam_error_t nwam_enm_disable(nwam_enm_handle_t);
783 786
784 787 /*
785 788 * Get state of ENM from nwamd.
786 789 */
787 790 extern nwam_error_t nwam_enm_get_state(nwam_enm_handle_t, nwam_state_t *,
788 791 nwam_aux_state_t *);
789 792
790 793 /*
791 794 * Get whether the ENM has manual activation-mode or not.
792 795 */
793 796 extern nwam_error_t nwam_enm_is_manual(nwam_enm_handle_t, boolean_t *);
794 797
795 798 /*
796 799 * Known Wireless LAN (WLAN) info.
797 800 */
798 801
799 802 /* Create a known WLAN */
800 803 extern nwam_error_t nwam_known_wlan_create(const char *,
801 804 nwam_known_wlan_handle_t *);
802 805
803 806 /* Read a known WLAN from persistent storage */
804 807 extern nwam_error_t nwam_known_wlan_read(const char *, uint64_t,
805 808 nwam_known_wlan_handle_t *);
806 809
807 810 /*
808 811 * Destroy a known WLAN in persistent storage or free the in-memory
809 812 * representation.
810 813 */
811 814 extern nwam_error_t nwam_known_wlan_destroy(nwam_known_wlan_handle_t, uint64_t);
812 815 extern void nwam_known_wlan_free(nwam_known_wlan_handle_t);
813 816
814 817 /* make a copy of existing known WLAN */
815 818 extern nwam_error_t nwam_known_wlan_copy(nwam_known_wlan_handle_t, const char *,
816 819 nwam_known_wlan_handle_t *);
817 820
818 821 /* Commit known WLAN changes to persistent storage */
819 822 extern nwam_error_t nwam_known_wlan_commit(nwam_known_wlan_handle_t, uint64_t);
820 823
821 824 /* Validate known WLAN content */
822 825 extern nwam_error_t nwam_known_wlan_validate(nwam_known_wlan_handle_t,
823 826 const char **);
824 827
825 828 /* Walk known WLANs */
826 829 extern nwam_error_t nwam_walk_known_wlans
827 830 (int(*)(nwam_known_wlan_handle_t, void *), void *, uint64_t, int *);
828 831
829 832 /* get/set known WLAN name */
830 833 extern nwam_error_t nwam_known_wlan_get_name(nwam_known_wlan_handle_t, char **);
831 834 extern nwam_error_t nwam_known_wlan_set_name(nwam_known_wlan_handle_t,
832 835 const char *);
833 836 extern boolean_t nwam_known_wlan_can_set_name(nwam_known_wlan_handle_t);
834 837
835 838 /* walk all properties of an in-memory known WLAN */
836 839 extern nwam_error_t nwam_known_wlan_walk_props(nwam_known_wlan_handle_t,
837 840 int (*)(const char *, nwam_value_t, void *),
838 841 void *, uint64_t, int *);
839 842
840 843 /* delete/get/set/validate known WLAN property */
841 844 extern nwam_error_t nwam_known_wlan_delete_prop(nwam_known_wlan_handle_t,
842 845 const char *);
843 846 extern nwam_error_t nwam_known_wlan_get_prop_value(nwam_known_wlan_handle_t,
844 847 const char *, nwam_value_t *);
845 848 extern nwam_error_t nwam_known_wlan_set_prop_value(nwam_known_wlan_handle_t,
846 849 const char *, nwam_value_t);
847 850 extern nwam_error_t nwam_known_wlan_validate_prop(nwam_known_wlan_handle_t,
848 851 const char *, nwam_value_t);
849 852
850 853 /* Retrieve data type */
851 854 extern nwam_error_t nwam_known_wlan_get_prop_type(const char *,
852 855 nwam_value_type_t *);
853 856 /* Retrieve prop description */
854 857 extern nwam_error_t nwam_known_wlan_get_prop_description(const char *,
855 858 const char **);
856 859
857 860 /* get default known WLAN props */
858 861 extern nwam_error_t nwam_known_wlan_get_default_proplist(const char ***,
859 862 uint_t *);
860 863
861 864 /* Whether the property is multi-valued or not */
862 865 extern nwam_error_t nwam_known_wlan_prop_multivalued(const char *, boolean_t *);
863 866
864 867 /* Add a bssid to the known WLANs */
865 868 extern nwam_error_t nwam_known_wlan_add_to_known_wlans(const char *,
866 869 const char *, uint32_t, uint_t, const char *);
867 870
868 871 /* Remove a bssid from known WLANs */
869 872 extern nwam_error_t nwam_known_wlan_remove_from_known_wlans(const char *,
870 873 const char *, const char *);
871 874
872 875 /*
873 876 * nwam_wlan_t is used for scan/need choice/need key events and by
874 877 * nwam_wlan_get_scan_results(). The following fields are valid:
875 878 *
876 879 * - for scan and need choice event, ESSID, BSSID, signal strength, security
877 880 * mode, speed, channel, bsstype, key index, and if we already have a key
878 881 * (have_key), if the WLAN is the current selection (selected) and
879 882 * if the current WLAN is connected (connected).
880 883 * - for need key events, ESSID, security mode, have_key, selected and connected
881 884 * values are set. The rest of the fields are not set since multiple WLANs
882 885 * may match the ESSID and have different speeds, channels etc. If an
883 886 * ESSID/BSSID selection is specified, the BSSID will be set also.
884 887 *
885 888 */
886 889 typedef struct {
887 890 char nww_essid[NWAM_MAX_NAME_LEN];
888 891 char nww_bssid[NWAM_MAX_NAME_LEN];
889 892 char nww_signal_strength[NWAM_MAX_NAME_LEN];
890 893 uint32_t nww_security_mode; /* a dladm_wlan_secmode_t */
891 894 uint32_t nww_speed; /* a dladm_wlan_speed_t */
892 895 uint32_t nww_channel; /* a dladm_wlan_channel_t */
893 896 uint32_t nww_bsstype; /* a dladm_wlan_bsstype_t */
894 897 uint_t nww_keyindex;
895 898 boolean_t nww_have_key;
896 899 boolean_t nww_selected;
897 900 boolean_t nww_connected;
898 901 } nwam_wlan_t;
899 902
900 903 /*
901 904 * Active WLAN definitions. Used to scan WLANs/choose a WLAN/set a WLAN key.
902 905 */
903 906 extern nwam_error_t nwam_wlan_scan(const char *);
904 907 extern nwam_error_t nwam_wlan_get_scan_results(const char *, uint_t *,
905 908 nwam_wlan_t **);
906 909 extern nwam_error_t nwam_wlan_select(const char *, const char *, const char *,
907 910 uint32_t, boolean_t);
908 911 extern nwam_error_t nwam_wlan_set_key(const char *, const char *, const char *,
909 912 uint32_t, uint_t, const char *);
910 913
911 914 /*
912 915 * Event notification definitions
913 916 */
914 917 #define NWAM_EVENT_TYPE_NOOP 0
915 918 #define NWAM_EVENT_TYPE_INIT 1
916 919 #define NWAM_EVENT_TYPE_SHUTDOWN 2
917 920 #define NWAM_EVENT_TYPE_OBJECT_ACTION 3
918 921 #define NWAM_EVENT_TYPE_OBJECT_STATE 4
919 922 #define NWAM_EVENT_TYPE_PRIORITY_GROUP 5
920 923 #define NWAM_EVENT_TYPE_INFO 6
921 924 #define NWAM_EVENT_TYPE_WLAN_SCAN_REPORT 7
922 925 #define NWAM_EVENT_TYPE_WLAN_NEED_CHOICE 8
923 926 #define NWAM_EVENT_TYPE_WLAN_NEED_KEY 9
924 927 #define NWAM_EVENT_TYPE_WLAN_CONNECTION_REPORT 10
925 928 #define NWAM_EVENT_TYPE_IF_ACTION 11
926 929 #define NWAM_EVENT_TYPE_IF_STATE 12
927 930 #define NWAM_EVENT_TYPE_LINK_ACTION 13
928 931 #define NWAM_EVENT_TYPE_LINK_STATE 14
929 932 #define NWAM_EVENT_MAX NWAM_EVENT_TYPE_LINK_STATE
930 933
931 934 #define NWAM_EVENT_STATUS_OK 0
932 935 #define NWAM_EVENT_STATUS_NOT_HANDLED 1
933 936
934 937 #define NWAM_EVENT_NETWORK_OBJECT_UNDEFINED 0
935 938 #define NWAM_EVENT_NETWORK_OBJECT_LINK 1
936 939 #define NWAM_EVENT_NETWORK_OBJECT_INTERFACE 2
937 940
938 941 #define NWAM_EVENT_REQUEST_UNDEFINED 0
939 942 #define NWAM_EVENT_REQUEST_WLAN 1
940 943 #define NWAM_EVENT_REQUEST_KEY 2
941 944
942 945 /*
943 946 * Actions for nwamd to perform, used in conjunction with
944 947 * nwam_request_type_t in nwam_door_arg_t.
945 948 * Add string representations to nwam_action_to_string() in libnwam_util.c.
946 949 */
947 950 typedef enum {
948 951 NWAM_ACTION_UNKNOWN = -1,
949 952 NWAM_ACTION_ADD,
950 953 NWAM_ACTION_REMOVE,
951 954 NWAM_ACTION_REFRESH,
952 955 NWAM_ACTION_ENABLE,
953 956 NWAM_ACTION_DISABLE,
954 957 NWAM_ACTION_DESTROY
955 958 } nwam_action_t;
956 959
957 960 typedef enum {
958 961 NWAM_OBJECT_TYPE_UNKNOWN = -1,
959 962 NWAM_OBJECT_TYPE_NCP = 0,
960 963 NWAM_OBJECT_TYPE_NCU = 1,
961 964 NWAM_OBJECT_TYPE_LOC = 2,
962 965 NWAM_OBJECT_TYPE_ENM = 3,
963 966 NWAM_OBJECT_TYPE_KNOWN_WLAN = 4
964 967 } nwam_object_type_t;
965 968
966 969 typedef struct nwam_event *nwam_event_t;
967 970 struct nwam_event {
968 971 int nwe_type;
969 972 uint32_t nwe_size;
970 973
971 974 union {
972 975 struct nwam_event_object_action {
973 976 nwam_object_type_t nwe_object_type;
974 977 char nwe_name[NWAM_MAX_NAME_LEN];
975 978 char nwe_parent[NWAM_MAX_NAME_LEN];
976 979 nwam_action_t nwe_action;
977 980 } nwe_object_action;
978 981
979 982 struct nwam_event_object_state {
980 983 nwam_object_type_t nwe_object_type;
981 984 char nwe_name[NWAM_MAX_NAME_LEN];
982 985 char nwe_parent[NWAM_MAX_NAME_LEN];
983 986 nwam_state_t nwe_state;
984 987 nwam_aux_state_t nwe_aux_state;
985 988 } nwe_object_state;
986 989
987 990 struct nwam_event_priority_group_info {
988 991 int64_t nwe_priority;
989 992 } nwe_priority_group_info;
990 993
991 994 struct nwam_event_info {
992 995 char nwe_message[NWAM_MAX_VALUE_LEN];
993 996 } nwe_info;
994 997
995 998 /*
996 999 * wlan_info stores both scan results and the single
997 1000 * WLAN we require a key for in the case of _WLAN_NEED_KEY
998 1001 * events. For _WLAN_CONNECTION_REPORT events, it stores
999 1002 * the WLAN the connection succeeded/failed for, indicating
1000 1003 * success/failure using the 'connected' boolean.
1001 1004 */
1002 1005 struct nwam_event_wlan_info {
1003 1006 char nwe_name[NWAM_MAX_NAME_LEN];
1004 1007 boolean_t nwe_connected;
1005 1008 uint16_t nwe_num_wlans;
1006 1009 nwam_wlan_t nwe_wlans[1];
1007 1010 /*
1008 1011 * space may be allocated by user here for the
1009 1012 * number of wlans
1010 1013 */
1011 1014 } nwe_wlan_info;
1012 1015
1013 1016 struct nwam_event_if_action {
1014 1017 char nwe_name[NWAM_MAX_NAME_LEN];
1015 1018 nwam_action_t nwe_action;
1016 1019 } nwe_if_action;
1017 1020
1018 1021 struct nwam_event_if_state {
1019 1022 char nwe_name[NWAM_MAX_NAME_LEN];
1020 1023 uint32_t nwe_flags;
1021 1024 uint32_t nwe_addr_valid; /* boolean */
1022 1025 uint32_t nwe_addr_added; /* boolean */
1023 1026 struct sockaddr_storage nwe_addr;
1024 1027 struct sockaddr_storage nwe_netmask;
1025 1028 } nwe_if_state;
1026 1029
1027 1030 struct nwam_event_link_state {
1028 1031 char nwe_name[NWAM_MAX_NAME_LEN];
1029 1032 boolean_t nwe_link_up;
1030 1033 /* link_state_t from sys/mac.h */
1031 1034 } nwe_link_state;
1032 1035
1033 1036 struct nwam_event_link_action {
1034 1037 char nwe_name[NWAM_MAX_NAME_LEN];
1035 1038 nwam_action_t nwe_action;
1036 1039 } nwe_link_action;
1037 1040 } nwe_data;
1038 1041 };
1039 1042
1040 1043 /* NWAM client functions, used to register/unregister and receive events */
1041 1044 extern nwam_error_t nwam_events_init(void);
1042 1045 extern void nwam_events_fini(void);
1043 1046 extern nwam_error_t nwam_event_wait(nwam_event_t *);
1044 1047 extern void nwam_event_free(nwam_event_t);
1045 1048
1046 1049 /* Event-related string conversion functions */
1047 1050 extern const char *nwam_action_to_string(nwam_action_t);
1048 1051 extern const char *nwam_event_type_to_string(int);
1049 1052 extern const char *nwam_state_to_string(nwam_state_t);
1050 1053 extern const char *nwam_aux_state_to_string(nwam_aux_state_t);
1051 1054
1052 1055 extern const char *nwam_object_type_to_string(nwam_object_type_t);
1053 1056 extern nwam_object_type_t nwam_string_to_object_type(const char *);
1054 1057
1055 1058 /* Utility strtok_r-like function */
1056 1059 extern char *nwam_tokenize_by_unescaped_delim(char *, char, char **);
1057 1060
1058 1061 #ifdef __cplusplus
1059 1062 }
1060 1063 #endif
1061 1064
1062 1065 #endif /* _LIBNWAM_H */
|
↓ open down ↓ |
603 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX