OpenSolaris_b135/lib/libinetutil/common/libinetutil.h
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _LIBINETUTIL_H
#define _LIBINETUTIL_H
/*
* Contains SMI-private API for general Internet functionality
*/
#ifdef __cplusplus
extern "C" {
#endif
#include <netinet/inetutil.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <net/if.h>
#if !defined(_KERNEL) && !defined(_BOOT)
typedef struct {
uint_t ifsp_ppa; /* Physical Point of Attachment */
uint_t ifsp_lun; /* Logical Unit number */
boolean_t ifsp_lunvalid; /* TRUE if lun is valid */
char ifsp_devnm[LIFNAMSIZ]; /* only the device name */
} ifspec_t;
extern boolean_t ifparse_ifspec(const char *, ifspec_t *);
extern void get_netmask4(const struct in_addr *, struct in_addr *);
extern boolean_t sockaddrcmp(const struct sockaddr_storage *,
const struct sockaddr_storage *);
/*
* Extended version of the classic BSD ifaddrlist() interface:
*
* int ifaddrlist(struct ifaddrlist **addrlistp, int af, uint_t flags,
* char *errbuf);
*
* * addrlistp: Upon success, ifaddrlist() sets *addrlistp to a
* dynamically-allocated array of addresses.
*
* * af: Either AF_INET to obtain IPv4 addresses, or AF_INET6 to
* obtain IPv6 addresses.
*
* * flags: LIFC_* flags that control the classes of interfaces that
* will be visible.
*
* * errbuf: A caller-supplied buffer of ERRBUFSIZE. Upon failure,
* provides the reason for the failure.
*
* Upon success, ifaddrlist() returns the number of addresses in the array
* pointed to by `addrlistp'. If the count is 0, then `addrlistp' is NULL.
*/
union any_in_addr {
struct in6_addr addr6;
struct in_addr addr;
};
struct ifaddrlist {
int index; /* interface index */
union any_in_addr addr; /* interface address */
char device[LIFNAMSIZ + 1]; /* interface name */
uint64_t flags; /* interface flags */
};
#define ERRBUFSIZE 128 /* expected size of fourth argument */
extern int ifaddrlist(struct ifaddrlist **, int, uint_t, char *);
/*
* Similar to ifaddrlist(), but returns a linked-list of addresses for a
* *specific* interface name, and allows specific address flags to be matched
* against. A linked list is used rather than an array so that information
* can grow over time without affecting binary compatibility. Also, leaves
* error-handling up to the caller. Returns the number of ifaddrlistx's
* chained through ifaddrp.
*
* int ifaddrlistx(const char *ifname, uint64_t set, uint64_t clear,
* ifaddrlistx_t **ifaddrp);
*
* * ifname: Interface name to match against.
*
* * set: One or more flags that must be set on the address for
* it to be returned.
*
* * clear: Flags that must be clear on the address for it to be
* returned.
*
* * ifaddrp: Upon success, ifaddrlistx() sets *ifaddrp to the head
* of a dynamically-allocated array of ifaddrlistx structures.
*
* Once done, the caller must free `ifaddrp' by calling ifaddrlistx_free().
*/
typedef struct ifaddrlistx {
struct ifaddrlistx *ia_next;
char ia_name[LIFNAMSIZ];
uint64_t ia_flags;
struct sockaddr_storage ia_addr;
} ifaddrlistx_t;
extern int ifaddrlistx(const char *, uint64_t, uint64_t, ifaddrlistx_t **);
extern void ifaddrlistx_free(ifaddrlistx_t *);
/*
* Timer queues
*
* timer queues are a facility for managing timeouts in unix. in the
* event driven model, unix provides us with poll(2)/select(3C), which
* allow us to coordinate waiting on multiple descriptors with an
* optional timeout. however, often (as is the case with the DHCP
* agent), we want to manage multiple independent timeouts (say, one
* for waiting for an OFFER to come back from a server in response to
* a DISCOVER sent out on one interface, and another for waiting for
* the T1 time on another interface). timer queues allow us to do
* this in the event-driven model.
*
* note that timer queues do not in and of themselves provide the
* event driven model (for instance, there is no handle_events()
* routine). they merely provide the hooks to support multiple
* independent timeouts. this is done for both simplicity and
* applicability (for instance, while one approach would be to use
* this timer queue with poll(2), another one would be to use SIGALRM
* to wake up periodically, and then process all the expired timers.)
*/
typedef struct iu_timer_queue iu_tq_t;
/*
* a iu_timer_id_t refers to a given timer. its value should not be
* interpreted by the interface consumer. it is a signed arithmetic
* type, and no valid iu_timer_id_t has the value `-1'.
*/
typedef int iu_timer_id_t;
#define IU_TIMER_ID_MAX 4096 /* max number of concurrent timers */
/*
* a iu_tq_callback_t is a function that is called back in response to a
* timer expiring. it may then carry out any necessary work,
* including rescheduling itself for callback or scheduling /
* cancelling other timers. the `void *' argument is the same value
* that was passed into iu_schedule_timer(), and if it is dynamically
* allocated, it is the callback's responsibility to know that, and to
* free it.
*/
typedef void iu_tq_callback_t(iu_tq_t *, void *);
iu_tq_t *iu_tq_create(void);
void iu_tq_destroy(iu_tq_t *);
iu_timer_id_t iu_schedule_timer(iu_tq_t *, uint32_t, iu_tq_callback_t *,
void *);
iu_timer_id_t iu_schedule_timer_ms(iu_tq_t *, uint64_t, iu_tq_callback_t *,
void *);
int iu_adjust_timer(iu_tq_t *, iu_timer_id_t, uint32_t);
int iu_cancel_timer(iu_tq_t *, iu_timer_id_t, void **);
int iu_expire_timers(iu_tq_t *);
int iu_earliest_timer(iu_tq_t *);
/*
* Event Handler
*
* an event handler is an object-oriented "wrapper" for select(3C) /
* poll(2), aimed to make the event demultiplexing system calls easier
* to use and provide a generic reusable component. instead of
* applications directly using select(3C) / poll(2), they register
* events that should be received with the event handler, providing a
* callback function to call when the event occurs. they then call
* iu_handle_events() to wait and callback the registered functions
* when events occur. also called a `reactor'.
*/
typedef struct iu_event_handler iu_eh_t;
/*
* an iu_event_id_t refers to a given event. its value should not be
* interpreted by the interface consumer. it is a signed arithmetic
* type, and no valid iu_event_id_t has the value `-1'.
*/
typedef int iu_event_id_t;
/*
* an iu_eh_callback_t is a function that is called back in response to
* an event occurring. it may then carry out any work necessary in
* response to the event. it receives the file descriptor upon which
* the event occurred, a bit array of events that occurred (the same
* array used as the revents by poll(2)), and its context through the
* `void *' that was originally passed into iu_register_event().
*
* NOTE: the same descriptor may not be registered multiple times for
* different callbacks. if this behavior is desired, either use dup(2)
* to get a unique descriptor, or demultiplex in the callback function
* based on the events.
*/
typedef void iu_eh_callback_t(iu_eh_t *, int, short, iu_event_id_t, void *);
typedef void iu_eh_sighandler_t(iu_eh_t *, int, void *);
typedef boolean_t iu_eh_shutdown_t(iu_eh_t *, void *);
iu_eh_t *iu_eh_create(void);
void iu_eh_destroy(iu_eh_t *);
iu_event_id_t iu_register_event(iu_eh_t *, int, short, iu_eh_callback_t *,
void *);
int iu_unregister_event(iu_eh_t *, iu_event_id_t, void **);
int iu_handle_events(iu_eh_t *, iu_tq_t *);
void iu_stop_handling_events(iu_eh_t *, unsigned int,
iu_eh_shutdown_t *, void *);
int iu_eh_register_signal(iu_eh_t *, int, iu_eh_sighandler_t *,
void *);
int iu_eh_unregister_signal(iu_eh_t *, int, void **);
#endif /* !defined(_KERNEL) && !defined(_BOOT) */
#ifdef __cplusplus
}
#endif
#endif /* !_LIBINETUTIL_H */