8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libinetutil / common / libinetutil.h
blob2e854f118640bce0dc1e0bb42e449075b9c4e4da
1 /*
2 * CDDL HEADER START
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.
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.
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]
19 * CDDL HEADER END
23 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
26 #ifndef _LIBINETUTIL_H
27 #define _LIBINETUTIL_H
30 * Contains SMI-private API for general Internet functionality
33 #ifdef __cplusplus
34 extern "C" {
35 #endif
37 #include <netinet/inetutil.h>
38 #include <sys/types.h>
39 #include <sys/socket.h>
40 #include <netinet/in.h>
41 #include <net/if.h>
43 #if !defined(_KERNEL) && !defined(_BOOT)
45 typedef struct {
46 uint_t ifsp_ppa; /* Physical Point of Attachment */
47 uint_t ifsp_lun; /* Logical Unit number */
48 boolean_t ifsp_lunvalid; /* TRUE if lun is valid */
49 char ifsp_devnm[LIFNAMSIZ]; /* only the device name */
50 } ifspec_t;
52 extern boolean_t ifparse_ifspec(const char *, ifspec_t *);
53 extern void get_netmask4(const struct in_addr *, struct in_addr *);
54 extern boolean_t sockaddrcmp(const struct sockaddr_storage *,
55 const struct sockaddr_storage *);
56 extern int plen2mask(uint_t, sa_family_t, struct sockaddr *);
57 extern int mask2plen(const struct sockaddr *);
58 extern boolean_t sockaddrunspec(const struct sockaddr *);
61 * Extended version of the classic BSD ifaddrlist() interface:
63 * int ifaddrlist(struct ifaddrlist **addrlistp, int af, uint_t flags,
64 * char *errbuf);
66 * * addrlistp: Upon success, ifaddrlist() sets *addrlistp to a
67 * dynamically-allocated array of addresses.
69 * * af: Either AF_INET to obtain IPv4 addresses, or AF_INET6 to
70 * obtain IPv6 addresses.
72 * * flags: LIFC_* flags that control the classes of interfaces that
73 * will be visible.
75 * * errbuf: A caller-supplied buffer of ERRBUFSIZE. Upon failure,
76 * provides the reason for the failure.
78 * Upon success, ifaddrlist() returns the number of addresses in the array
79 * pointed to by `addrlistp'. If the count is 0, then `addrlistp' is NULL.
81 union any_in_addr {
82 struct in6_addr addr6;
83 struct in_addr addr;
86 struct ifaddrlist {
87 int index; /* interface index */
88 union any_in_addr addr; /* interface address */
89 char device[LIFNAMSIZ + 1]; /* interface name */
90 uint64_t flags; /* interface flags */
93 #define ERRBUFSIZE 128 /* expected size of fourth argument */
95 extern int ifaddrlist(struct ifaddrlist **, int, uint_t, char *);
98 * Similar to ifaddrlist(), but returns a linked-list of addresses for a
99 * *specific* interface name, and allows specific address flags to be matched
100 * against. A linked list is used rather than an array so that information
101 * can grow over time without affecting binary compatibility. Also, leaves
102 * error-handling up to the caller. Returns the number of ifaddrlistx's
103 * chained through ifaddrp.
105 * int ifaddrlistx(const char *ifname, uint64_t set, uint64_t clear,
106 * ifaddrlistx_t **ifaddrp);
108 * * ifname: Interface name to match against.
110 * * set: One or more flags that must be set on the address for
111 * it to be returned.
113 * * clear: Flags that must be clear on the address for it to be
114 * returned.
116 * * ifaddrp: Upon success, ifaddrlistx() sets *ifaddrp to the head
117 * of a dynamically-allocated array of ifaddrlistx structures.
119 * Once done, the caller must free `ifaddrp' by calling ifaddrlistx_free().
121 typedef struct ifaddrlistx {
122 struct ifaddrlistx *ia_next;
123 char ia_name[LIFNAMSIZ];
124 uint64_t ia_flags;
125 struct sockaddr_storage ia_addr;
126 } ifaddrlistx_t;
128 extern int ifaddrlistx(const char *, uint64_t, uint64_t, ifaddrlistx_t **);
129 extern void ifaddrlistx_free(ifaddrlistx_t *);
132 * Timer queues
134 * timer queues are a facility for managing timeouts in unix. in the
135 * event driven model, unix provides us with poll(2)/select(3C), which
136 * allow us to coordinate waiting on multiple descriptors with an
137 * optional timeout. however, often (as is the case with the DHCP
138 * agent), we want to manage multiple independent timeouts (say, one
139 * for waiting for an OFFER to come back from a server in response to
140 * a DISCOVER sent out on one interface, and another for waiting for
141 * the T1 time on another interface). timer queues allow us to do
142 * this in the event-driven model.
144 * note that timer queues do not in and of themselves provide the
145 * event driven model (for instance, there is no handle_events()
146 * routine). they merely provide the hooks to support multiple
147 * independent timeouts. this is done for both simplicity and
148 * applicability (for instance, while one approach would be to use
149 * this timer queue with poll(2), another one would be to use SIGALRM
150 * to wake up periodically, and then process all the expired timers.)
153 typedef struct iu_timer_queue iu_tq_t;
156 * a iu_timer_id_t refers to a given timer. its value should not be
157 * interpreted by the interface consumer. it is a signed arithmetic
158 * type, and no valid iu_timer_id_t has the value `-1'.
161 typedef int iu_timer_id_t;
163 #define IU_TIMER_ID_MAX 4096 /* max number of concurrent timers */
166 * a iu_tq_callback_t is a function that is called back in response to a
167 * timer expiring. it may then carry out any necessary work,
168 * including rescheduling itself for callback or scheduling /
169 * cancelling other timers. the `void *' argument is the same value
170 * that was passed into iu_schedule_timer(), and if it is dynamically
171 * allocated, it is the callback's responsibility to know that, and to
172 * free it.
175 typedef void iu_tq_callback_t(iu_tq_t *, void *);
177 iu_tq_t *iu_tq_create(void);
178 void iu_tq_destroy(iu_tq_t *);
179 iu_timer_id_t iu_schedule_timer(iu_tq_t *, uint32_t, iu_tq_callback_t *,
180 void *);
181 iu_timer_id_t iu_schedule_timer_ms(iu_tq_t *, uint64_t, iu_tq_callback_t *,
182 void *);
183 int iu_adjust_timer(iu_tq_t *, iu_timer_id_t, uint32_t);
184 int iu_cancel_timer(iu_tq_t *, iu_timer_id_t, void **);
185 int iu_expire_timers(iu_tq_t *);
186 int iu_earliest_timer(iu_tq_t *);
189 * Event Handler
191 * an event handler is an object-oriented "wrapper" for select(3C) /
192 * poll(2), aimed to make the event demultiplexing system calls easier
193 * to use and provide a generic reusable component. instead of
194 * applications directly using select(3C) / poll(2), they register
195 * events that should be received with the event handler, providing a
196 * callback function to call when the event occurs. they then call
197 * iu_handle_events() to wait and callback the registered functions
198 * when events occur. also called a `reactor'.
201 typedef struct iu_event_handler iu_eh_t;
204 * an iu_event_id_t refers to a given event. its value should not be
205 * interpreted by the interface consumer. it is a signed arithmetic
206 * type, and no valid iu_event_id_t has the value `-1'.
209 typedef int iu_event_id_t;
212 * an iu_eh_callback_t is a function that is called back in response to
213 * an event occurring. it may then carry out any work necessary in
214 * response to the event. it receives the file descriptor upon which
215 * the event occurred, a bit array of events that occurred (the same
216 * array used as the revents by poll(2)), and its context through the
217 * `void *' that was originally passed into iu_register_event().
219 * NOTE: the same descriptor may not be registered multiple times for
220 * different callbacks. if this behavior is desired, either use dup(2)
221 * to get a unique descriptor, or demultiplex in the callback function
222 * based on the events.
225 typedef void iu_eh_callback_t(iu_eh_t *, int, short, iu_event_id_t, void *);
226 typedef void iu_eh_sighandler_t(iu_eh_t *, int, void *);
227 typedef boolean_t iu_eh_shutdown_t(iu_eh_t *, void *);
229 iu_eh_t *iu_eh_create(void);
230 void iu_eh_destroy(iu_eh_t *);
231 iu_event_id_t iu_register_event(iu_eh_t *, int, short, iu_eh_callback_t *,
232 void *);
233 int iu_unregister_event(iu_eh_t *, iu_event_id_t, void **);
234 int iu_handle_events(iu_eh_t *, iu_tq_t *);
235 void iu_stop_handling_events(iu_eh_t *, unsigned int,
236 iu_eh_shutdown_t *, void *);
237 int iu_eh_register_signal(iu_eh_t *, int, iu_eh_sighandler_t *,
238 void *);
239 int iu_eh_unregister_signal(iu_eh_t *, int, void **);
241 #endif /* !defined(_KERNEL) && !defined(_BOOT) */
243 #ifdef __cplusplus
245 #endif
247 #endif /* !_LIBINETUTIL_H */