dhcpctl_status dhcpctl_set_callback (dhcpctl_handle h, void *data,
void (*func) (dhcpctl_handle,
dhcpctl_status, void *))
{
dhcpctl_callback_object_t *callback;
omapi_object_t *inner;
isc_result_t status;
callback = dmalloc (sizeof *callback, MDL);
if (!callback)
return ISC_R_NOMEMORY;
/* Tie the callback object to the innermost object in the chain. */
for (inner = h; inner -> inner; inner = inner -> inner)
;
omapi_object_reference (&inner -> inner,
(omapi_object_t *)callback, MDL);
omapi_object_reference ((omapi_object_t **)&callback -> outer,
inner, MDL);
/* Save the actual handle pointer we were passed for the callback. */
omapi_object_reference (&callback -> object, h, MDL);
callback -> data = data;
callback -> callback = func;
return ISC_R_SUCCESS;
}
isc_result_t omapi_message_register (omapi_object_t *mo)
{
omapi_message_object_t *m;
if (mo -> type != omapi_type_message)
return ISC_R_INVALIDARG;
m = (omapi_message_object_t *)mo;
/* Already registered? */
if (m -> prev || m -> next || omapi_registered_messages == m)
return ISC_R_INVALIDARG;
if (omapi_registered_messages) {
omapi_object_reference
((omapi_object_t **)&m -> next,
(omapi_object_t *)omapi_registered_messages, MDL);
omapi_object_reference
((omapi_object_t **)&omapi_registered_messages -> prev,
(omapi_object_t *)m, MDL);
omapi_object_dereference
((omapi_object_t **)&omapi_registered_messages, MDL);
}
omapi_object_reference
((omapi_object_t **)&omapi_registered_messages,
(omapi_object_t *)m, MDL);
return ISC_R_SUCCESS;;
}
isc_result_t omapi_register_io_object (omapi_object_t *h,
int (*readfd) (omapi_object_t *),
int (*writefd) (omapi_object_t *),
isc_result_t (*reader)
(omapi_object_t *),
isc_result_t (*writer)
(omapi_object_t *),
isc_result_t (*reaper)
(omapi_object_t *))
{
isc_result_t status;
omapi_io_object_t *obj, *p;
/* omapi_io_states is a static object. If its reference count
is zero, this is the first I/O handle to be registered, so
we need to initialize it. Because there is no inner or outer
pointer on this object, and we're setting its refcnt to 1, it
will never be freed. */
if (!omapi_io_states.refcnt) {
omapi_io_states.refcnt = 1;
omapi_io_states.type = omapi_type_io_object;
}
obj = (omapi_io_object_t *)0;
status = omapi_io_allocate (&obj, MDL);
if (status != ISC_R_SUCCESS)
return status;
status = omapi_object_reference (&obj -> inner, h, MDL);
if (status != ISC_R_SUCCESS) {
omapi_io_dereference (&obj, MDL);
return status;
}
status = omapi_object_reference (&h -> outer,
(omapi_object_t *)obj, MDL);
if (status != ISC_R_SUCCESS) {
omapi_io_dereference (&obj, MDL);
return status;
}
/* Find the last I/O state, if there are any. */
for (p = omapi_io_states.next;
p && p -> next; p = p -> next)
;
if (p)
omapi_io_reference (&p -> next, obj, MDL);
else
omapi_io_reference (&omapi_io_states.next, obj, MDL);
obj -> readfd = readfd;
obj -> writefd = writefd;
obj -> reader = reader;
obj -> writer = writer;
obj -> reaper = reaper;
omapi_io_dereference(&obj, MDL);
return ISC_R_SUCCESS;
}
isc_result_t omapi_wait_for_completion (omapi_object_t *object,
struct timeval *t)
{
isc_result_t status;
omapi_waiter_object_t *waiter;
omapi_object_t *inner;
if (object) {
waiter = (omapi_waiter_object_t *)0;
status = omapi_waiter_allocate (&waiter, MDL);
if (status != ISC_R_SUCCESS)
return status;
/* Paste the waiter object onto the inner object we're
waiting on. */
for (inner = object; inner -> inner; inner = inner -> inner)
;
status = omapi_object_reference (&waiter -> outer, inner, MDL);
if (status != ISC_R_SUCCESS) {
omapi_waiter_dereference (&waiter, MDL);
return status;
}
status = omapi_object_reference (&inner -> inner,
(omapi_object_t *)waiter,
MDL);
if (status != ISC_R_SUCCESS) {
omapi_waiter_dereference (&waiter, MDL);
return status;
}
} else
waiter = (omapi_waiter_object_t *)0;
do {
status = omapi_one_dispatch ((omapi_object_t *)waiter, t);
if (status != ISC_R_SUCCESS)
return status;
} while (!waiter || !waiter -> ready);
if (waiter -> outer) {
if (waiter -> outer -> inner) {
omapi_object_dereference (&waiter -> outer -> inner,
MDL);
if (waiter -> inner)
omapi_object_reference
(&waiter -> outer -> inner,
waiter -> inner, MDL);
}
omapi_object_dereference (&waiter -> outer, MDL);
}
if (waiter -> inner)
omapi_object_dereference (&waiter -> inner, MDL);
status = waiter -> waitstatus;
omapi_waiter_dereference (&waiter, MDL);
return status;
}
isc_result_t omapi_protocol_listener_signal (omapi_object_t *o,
const char *name, va_list ap)
{
isc_result_t status;
omapi_object_t *c;
omapi_protocol_object_t *obj;
omapi_protocol_listener_object_t *p;
if (!o || o -> type != omapi_type_protocol_listener)
return ISC_R_INVALIDARG;
p = (omapi_protocol_listener_object_t *)o;
/* Not a signal we recognize? */
if (strcmp (name, "connect")) {
if (p -> inner && p -> inner -> type -> signal_handler)
return (*(p -> inner -> type -> signal_handler))
(p -> inner, name, ap);
return ISC_R_NOTFOUND;
}
c = va_arg (ap, omapi_object_t *);
if (!c || c -> type != omapi_type_connection)
return ISC_R_INVALIDARG;
obj = (omapi_protocol_object_t *)0;
status = omapi_protocol_allocate (&obj, MDL);
if (status != ISC_R_SUCCESS)
return status;
obj -> verify_auth = p -> verify_auth;
obj -> insecure = p -> insecure;
status = omapi_object_reference (&obj -> outer, c, MDL);
if (status != ISC_R_SUCCESS) {
lose:
omapi_protocol_dereference (&obj, MDL);
omapi_disconnect (c, 1);
return status;
}
status = omapi_object_reference (&c -> inner,
(omapi_object_t *)obj, MDL);
if (status != ISC_R_SUCCESS)
goto lose;
/* Send the introductory message. */
status = omapi_protocol_send_intro ((omapi_object_t *)obj,
OMAPI_PROTOCOL_VERSION,
sizeof (omapi_protocol_header_t));
if (status != ISC_R_SUCCESS)
goto lose;
omapi_protocol_dereference (&obj, MDL);
return status;
}
dhcpctl_status dhcpctl_new_object (dhcpctl_handle *h,
dhcpctl_handle connection,
const char *object_type)
{
dhcpctl_remote_object_t *m;
omapi_object_t *g;
isc_result_t status;
m = (dhcpctl_remote_object_t *)0;
status = omapi_object_allocate((omapi_object_t **)&m,
dhcpctl_remote_type, 0, MDL);
if (status != ISC_R_SUCCESS)
return status;
g = (omapi_object_t *)0;
status = omapi_generic_new (&g, MDL);
if (status != ISC_R_SUCCESS) {
dfree (m, MDL);
return status;
}
status = omapi_object_reference (&m -> inner, g, MDL);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference ((omapi_object_t **)&m, MDL);
omapi_object_dereference (&g, MDL);
return status;
}
status = omapi_object_reference (&g -> outer,
(omapi_object_t *)m, MDL);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference ((omapi_object_t **)&m, MDL);
omapi_object_dereference (&g, MDL);
return status;
}
status = omapi_typed_data_new (MDL, &m -> rtype,
omapi_datatype_string,
object_type);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference ((omapi_object_t **)&m, MDL);
omapi_object_dereference (&g, MDL);
return status;
}
status = omapi_object_reference (h, (omapi_object_t *)m, MDL);
omapi_object_dereference ((omapi_object_t **)&m, MDL);
omapi_object_dereference (&g, MDL);
if (status != ISC_R_SUCCESS)
return status;
return status;
}
isc_result_t omapi_protocol_add_auth (omapi_object_t *po,
omapi_object_t *ao,
omapi_handle_t handle)
{
omapi_protocol_object_t *p;
omapi_remote_auth_t *r;
isc_result_t status;
if (ao -> type != omapi_type_auth_key &&
(!ao -> inner || ao -> inner -> type != omapi_type_auth_key))
return ISC_R_INVALIDARG;
if (po -> type != omapi_type_protocol)
return ISC_R_INVALIDARG;
p = (omapi_protocol_object_t *)po;
#ifdef DEBUG_PROTOCOL
log_debug ("omapi_protocol_add_auth(name=%s)",
((omapi_auth_key_t *)ao) -> name);
#endif
if (p -> verify_auth) {
status = (p -> verify_auth) (po, (omapi_auth_key_t *)ao);
if (status != ISC_R_SUCCESS)
return status;
}
/* If omapi_protocol_connect() was called with a default
authenticator, p -> default_auth will already be set,
but p -> remote_auth_list will not yet be initialized. */
if (p -> default_auth && !p -> remote_auth_list) {
if (p -> default_auth -> a != ao) {
/* Something just went horribly wrong. */
omapi_disconnect (p -> outer, 1);
return ISC_R_UNEXPECTED;
}
p -> remote_auth_list = p -> default_auth;
p -> default_auth -> remote_handle = handle;
return omapi_signal_in (p -> inner, "ready");
}
r = dmalloc (sizeof(*r), MDL);
if (!r)
return ISC_R_NOMEMORY;
status = omapi_object_reference (&r -> a, ao, MDL);
if (status != ISC_R_SUCCESS) {
dfree (r, MDL);
return status;
}
r -> remote_handle = handle;
r -> next = p -> remote_auth_list;
p -> remote_auth_list = r;
return ISC_R_SUCCESS;
}
isc_result_t omapi_message_unregister (omapi_object_t *mo)
{
omapi_message_object_t *m;
omapi_message_object_t *n;
if (mo -> type != omapi_type_message)
return DHCP_R_INVALIDARG;
m = (omapi_message_object_t *)mo;
/* Not registered? */
if (!m -> prev && omapi_registered_messages != m)
return DHCP_R_INVALIDARG;
n = (omapi_message_object_t *)0;
if (m -> next) {
omapi_object_reference ((omapi_object_t **)&n,
(omapi_object_t *)m -> next, MDL);
omapi_object_dereference ((omapi_object_t **)&m -> next, MDL);
omapi_object_dereference ((omapi_object_t **)&n -> prev, MDL);
}
if (m -> prev) {
omapi_message_object_t *tmp = (omapi_message_object_t *)0;
omapi_object_reference ((omapi_object_t **)&tmp,
(omapi_object_t *)m -> prev, MDL);
omapi_object_dereference ((omapi_object_t **)&m -> prev, MDL);
if (tmp -> next)
omapi_object_dereference
((omapi_object_t **)&tmp -> next, MDL);
if (n)
omapi_object_reference
((omapi_object_t **)&tmp -> next,
(omapi_object_t *)n, MDL);
omapi_object_dereference ((omapi_object_t **)&tmp, MDL);
} else {
omapi_object_dereference
((omapi_object_t **)&omapi_registered_messages, MDL);
if (n)
omapi_object_reference
((omapi_object_t **)&omapi_registered_messages,
(omapi_object_t *)n, MDL);
}
if (n)
omapi_object_dereference ((omapi_object_t **)&n, MDL);
return ISC_R_SUCCESS;
}
isc_result_t omapi_message_new (omapi_object_t **o, const char *file, int line)
{
omapi_message_object_t *m;
omapi_object_t *g;
isc_result_t status;
m = (omapi_message_object_t *)0;
status = omapi_message_allocate (&m, file, line);
if (status != ISC_R_SUCCESS)
return status;
g = (omapi_object_t *)0;
status = omapi_generic_new (&g, file, line);
if (status != ISC_R_SUCCESS) {
dfree (m, file, line);
return status;
}
status = omapi_object_reference (&m -> inner, g, file, line);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference ((omapi_object_t **)&m, file, line);
omapi_object_dereference (&g, file, line);
return status;
}
status = omapi_object_reference (&g -> outer,
(omapi_object_t *)m, file, line);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference ((omapi_object_t **)&m, file, line);
omapi_object_dereference (&g, file, line);
return status;
}
status = omapi_object_reference (o, (omapi_object_t *)m, file, line);
omapi_message_dereference (&m, file, line);
omapi_object_dereference (&g, file, line);
if (status != ISC_R_SUCCESS)
return status;
return status;
}
isc_result_t dhcp_group_create (omapi_object_t **lp,
omapi_object_t *id)
{
struct group_object *group;
isc_result_t status;
group = (struct group_object *)0;
status = group_object_allocate (&group, MDL);
if (status != ISC_R_SUCCESS)
return status;
group -> flags = GROUP_OBJECT_DYNAMIC;
status = omapi_object_reference (lp, (omapi_object_t *)group, MDL);
group_object_dereference (&group, MDL);
return status;
}
isc_result_t omapi_protocol_lookup_auth (omapi_object_t **a,
omapi_object_t *po,
omapi_handle_t handle)
{
omapi_protocol_object_t *p;
omapi_remote_auth_t *r;
if (po -> type != omapi_type_protocol)
return ISC_R_INVALIDARG;
p = (omapi_protocol_object_t *)po;
for (r = p -> remote_auth_list; r; r = r -> next)
if (r -> remote_handle == handle)
return omapi_object_reference (a, r -> a, MDL);
return ISC_R_KEY_UNKNOWN;
}
isc_result_t omapi_protocol_send_message (omapi_object_t *po,
omapi_object_t *id,
omapi_object_t *mo,
omapi_object_t *omo)
{
omapi_protocol_object_t *p;
omapi_object_t *c;
omapi_message_object_t *m, *om;
omapi_remote_auth_t *ra;
omapi_value_t *signature;
isc_result_t status;
u_int32_t foo;
unsigned auth_len;
if (po -> type != omapi_type_protocol ||
!po -> outer || po -> outer -> type != omapi_type_connection ||
mo -> type != omapi_type_message)
return ISC_R_INVALIDARG;
if (omo && omo -> type != omapi_type_message)
return ISC_R_INVALIDARG;
p = (omapi_protocol_object_t *)po;
c = (omapi_object_t *)(po -> outer);
m = (omapi_message_object_t *)mo;
om = (omapi_message_object_t *)omo;
#ifdef DEBUG_PROTOCOL
log_debug ("omapi_protocol_send_message()"
"op=%ld handle=%#lx id=%#lx rid=%#lx",
(long)m -> op,
(long)(m -> object ? m -> object -> handle : m -> handle),
(long)p -> next_xid, (long)m -> rid);
#endif
/* Find the authid to use for this message. */
if (id) {
for (ra = p -> remote_auth_list; ra; ra = ra -> next) {
if (ra -> a == id) {
break;
}
}
if (!ra)
return ISC_R_KEY_UNKNOWN;
} else if (p -> remote_auth_list) {
ra = p -> default_auth;
} else {
ra = (omapi_remote_auth_t *)0;
}
if (ra) {
m -> authid = ra -> remote_handle;
status = omapi_object_reference (&m -> id_object,
ra -> a, MDL);
if (status != ISC_R_SUCCESS)
return status;
}
/* Write the ID of the authentication key we're using. */
status = omapi_connection_put_uint32 (c, ra ? ra -> remote_handle : 0);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Activate the authentication key on the connection. */
auth_len = 0;
if (ra) {
status = omapi_set_object_value (c, (omapi_object_t *)0,
"output-authenticator",
ra -> a);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
status = omapi_connection_output_auth_length (c, &auth_len);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
}
/* Write the authenticator length */
status = omapi_connection_put_uint32 (c, auth_len);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Write the opcode. */
status = omapi_connection_put_uint32 (c, m -> op);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Write the handle. If we've been given an explicit handle, use
that. Otherwise, use the handle of the object we're sending.
The caller is responsible for arranging for one of these handles
to be set (or not). */
status = omapi_connection_put_uint32 (c, (m -> h
? m -> h
: (m -> object
? m -> object -> handle
: 0)));
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Set and write the transaction ID. */
m -> id = p -> next_xid++;
status = omapi_connection_put_uint32 (c, m -> id);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Write the transaction ID of the message to which this is a
response, if there is such a message. */
status = omapi_connection_put_uint32 (c, om ? om -> id : m -> rid);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Stuff out the name/value pairs specific to this message. */
status = omapi_stuff_values (c, id, (omapi_object_t *)m);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Write the zero-length name that terminates the list of name/value
pairs specific to the message. */
status = omapi_connection_put_uint16 (c, 0);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Stuff out all the published name/value pairs in the object that's
being sent in the message, if there is one. */
if (m -> object) {
status = omapi_stuff_values (c, id, m -> object);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
}
/* Write the zero-length name that terminates the list of name/value
pairs for the associated object. */
status = omapi_connection_put_uint16 (c, 0);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
if (ra) {
/* Calculate the message signature. */
signature = (omapi_value_t *)0;
status = omapi_get_value_str (c, (omapi_object_t *)0,
"output-signature", &signature);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Write the authenticator... */
status = (omapi_connection_copyin
(c, signature -> value -> u.buffer.value,
signature -> value -> u.buffer.len));
omapi_value_dereference (&signature, MDL);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Dectivate the authentication key on the connection. */
status = omapi_set_value_str (c, (omapi_object_t *)0,
"output-authenticator",
(omapi_typed_data_t *)0);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
}
if (!omo) {
omapi_protocol_reference (&m -> protocol_object, p, MDL);
}
return ISC_R_SUCCESS;
}
isc_result_t dhcp_group_lookup (omapi_object_t **lp,
omapi_object_t *id, omapi_object_t *ref)
{
omapi_value_t *tv = (omapi_value_t *)0;
isc_result_t status;
struct group_object *group;
if (!ref)
return ISC_R_NOKEYS;
/* First see if we were sent a handle. */
status = omapi_get_value_str (ref, id, "handle", &tv);
if (status == ISC_R_SUCCESS) {
status = omapi_handle_td_lookup (lp, tv -> value);
omapi_value_dereference (&tv, MDL);
if (status != ISC_R_SUCCESS)
return status;
/* Don't return the object if the type is wrong. */
if ((*lp) -> type != dhcp_type_group) {
omapi_object_dereference (lp, MDL);
return ISC_R_INVALIDARG;
}
}
/* Now look for a name. */
status = omapi_get_value_str (ref, id, "name", &tv);
if (status == ISC_R_SUCCESS) {
group = (struct group_object *)0;
if (group_name_hash &&
group_hash_lookup (&group, group_name_hash,
(const char *)
tv -> value -> u.buffer.value,
tv -> value -> u.buffer.len, MDL)) {
omapi_value_dereference (&tv, MDL);
if (*lp && *lp != (omapi_object_t *)group) {
group_object_dereference (&group, MDL);
omapi_object_dereference (lp, MDL);
return ISC_R_KEYCONFLICT;
} else if (!*lp) {
/* XXX fix so that hash lookup itself creates
XXX the reference. */
omapi_object_reference (lp,
(omapi_object_t *)group,
MDL);
group_object_dereference (&group, MDL);
}
} else if (!*lp)
return ISC_R_NOTFOUND;
}
/* If we get to here without finding a group, no valid key was
specified. */
if (!*lp)
return ISC_R_NOKEYS;
if (((struct group_object *)(*lp)) -> flags & GROUP_OBJECT_DELETED) {
omapi_object_dereference (lp, MDL);
return ISC_R_NOTFOUND;
}
return ISC_R_SUCCESS;
}
isc_result_t omapi_one_dispatch (omapi_object_t *wo,
struct timeval *t)
{
fd_set r, w, x, rr, ww, xx;
int max = 0;
int count;
int desc;
struct timeval now, to;
omapi_io_object_t *io, *prev, *next;
omapi_waiter_object_t *waiter;
omapi_object_t *tmp = (omapi_object_t *)0;
isc_result_t status;
if (!wo || wo -> type != omapi_type_waiter)
waiter = (omapi_waiter_object_t *)0;
else
waiter = (omapi_waiter_object_t *)wo;
FD_ZERO (&x);
/* First, see if the timeout has expired, and if so return. */
if (t) {
gettimeofday (&now, (struct timezone *)0);
cur_tv.tv_sec = now.tv_sec;
cur_tv.tv_usec = now.tv_usec;
if (now.tv_sec > t -> tv_sec ||
(now.tv_sec == t -> tv_sec && now.tv_usec >= t -> tv_usec))
return ISC_R_TIMEDOUT;
/* We didn't time out, so figure out how long until
we do. */
to.tv_sec = t -> tv_sec - now.tv_sec;
to.tv_usec = t -> tv_usec - now.tv_usec;
if (to.tv_usec < 0) {
to.tv_usec += 1000000;
to.tv_sec--;
}
/* It is possible for the timeout to get set larger than
the largest time select() is willing to accept.
Restricting the timeout to a maximum of one day should
work around this. -DPN. (Ref: Bug #416) */
if (to.tv_sec > (60 * 60 * 24))
to.tv_sec = 60 * 60 * 24;
}
/* If the object we're waiting on has reached completion,
return now. */
if (waiter && waiter -> ready)
return ISC_R_SUCCESS;
again:
/* If we have no I/O state, we can't proceed. */
if (!(io = omapi_io_states.next))
return ISC_R_NOMORE;
/* Set up the read and write masks. */
FD_ZERO (&r);
FD_ZERO (&w);
for (; io; io = io -> next) {
/* Check for a read socket. If we shouldn't be
trying to read for this I/O object, either there
won't be a readfd function, or it'll return -1. */
if (io -> readfd && io -> inner &&
(desc = (*(io -> readfd)) (io -> inner)) >= 0) {
FD_SET (desc, &r);
if (desc > max)
max = desc;
}
/* Same deal for write fdets. */
if (io -> writefd && io -> inner &&
(desc = (*(io -> writefd)) (io -> inner)) >= 0) {
FD_SET (desc, &w);
if (desc > max)
max = desc;
}
}
/* poll if all reader are dry */
now.tv_sec = 0;
now.tv_usec = 0;
rr=r;
ww=w;
xx=x;
/* poll once */
count = select(max + 1, &r, &w, &x, &now);
if (!count) {
/* We are dry now */
trigger_event(&rw_queue_empty);
/* Wait for a packet or a timeout... XXX */
r = rr;
w = ww;
x = xx;
count = select(max + 1, &r, &w, &x, t ? &to : NULL);
}
/* Get the current time... */
gettimeofday (&cur_tv, (struct timezone *)0);
/* We probably have a bad file descriptor. Figure out which one.
When we find it, call the reaper function on it, which will
maybe make it go away, and then try again. */
if (count < 0) {
struct timeval t0;
omapi_io_object_t *prev = (omapi_io_object_t *)0;
io = (omapi_io_object_t *)0;
if (omapi_io_states.next)
omapi_io_reference (&io, omapi_io_states.next, MDL);
while (io) {
omapi_object_t *obj;
FD_ZERO (&r);
FD_ZERO (&w);
t0.tv_sec = t0.tv_usec = 0;
if (io -> readfd && io -> inner &&
(desc = (*(io -> readfd)) (io -> inner)) >= 0) {
FD_SET (desc, &r);
count = select (desc + 1, &r, &w, &x, &t0);
bogon:
if (count < 0) {
log_error ("Bad descriptor %d.", desc);
for (obj = (omapi_object_t *)io;
obj -> outer;
obj = obj -> outer)
;
for (; obj; obj = obj -> inner) {
omapi_value_t *ov;
int len;
const char *s;
ov = (omapi_value_t *)0;
status = omapi_get_value_str (obj,
(omapi_object_t *)0,
"name", &ov);
if(status!=ISC_R_SUCCESS){
log_error("omapi_get_value_str failed!\n");
}
if (ov && ov -> value &&
(ov -> value -> type ==
omapi_datatype_string)) {
s = (char *)
ov -> value -> u.buffer.value;
len = ov -> value -> u.buffer.len;
} else {
s = "";
len = 0;
}
log_error ("Object %lx %s%s%.*s",
(unsigned long)obj,
obj -> type -> name,
len ? " " : "",
len, s);
if (len)
omapi_value_dereference (&ov, MDL);
}
(*(io -> reaper)) (io -> inner);
if (prev) {
omapi_io_dereference (&prev -> next, MDL);
if (io -> next)
omapi_io_reference (&prev -> next,
io -> next, MDL);
} else {
omapi_io_dereference
(&omapi_io_states.next, MDL);
if (io -> next)
omapi_io_reference
(&omapi_io_states.next,
io -> next, MDL);
}
omapi_io_dereference (&io, MDL);
goto again;
}
}
FD_ZERO (&r);
FD_ZERO (&w);
t0.tv_sec = t0.tv_usec = 0;
/* Same deal for write fdets. */
if (io -> writefd && io -> inner &&
(desc = (*(io -> writefd)) (io -> inner)) >= 0) {
FD_SET (desc, &w);
count = select (desc + 1, &r, &w, &x, &t0);
if (count < 0)
goto bogon;
}
if (prev)
omapi_io_dereference (&prev, MDL);
omapi_io_reference (&prev, io, MDL);
omapi_io_dereference (&io, MDL);
if (prev -> next)
omapi_io_reference (&io, prev -> next, MDL);
}
if (prev)
omapi_io_dereference (&prev, MDL);
}
for (io = omapi_io_states.next; io; io = io -> next) {
if (!io -> inner)
continue;
omapi_object_reference (&tmp, io -> inner, MDL);
/* Check for a read descriptor, and if there is one,
see if we got input on that socket. */
if (io -> readfd &&
(desc = (*(io -> readfd)) (tmp)) >= 0) {
if (FD_ISSET (desc, &r))
((*(io -> reader)) (tmp));
}
/* Same deal for write descriptors. */
if (io -> writefd &&
(desc = (*(io -> writefd)) (tmp)) >= 0)
{
if (FD_ISSET (desc, &w))
((*(io -> writer)) (tmp));
}
omapi_object_dereference (&tmp, MDL);
}
/* Now check for I/O handles that are no longer valid,
and remove them from the list. */
prev = NULL;
io = NULL;
if (omapi_io_states.next != NULL) {
omapi_io_reference(&io, omapi_io_states.next, MDL);
}
while (io != NULL) {
if ((io->inner == NULL) ||
((io->reaper != NULL) &&
((io->reaper)(io->inner) != ISC_R_SUCCESS)))
{
omapi_io_object_t *tmp = NULL;
/* Save a reference to the next
pointer, if there is one. */
if (io->next != NULL) {
omapi_io_reference(&tmp, io->next, MDL);
omapi_io_dereference(&io->next, MDL);
}
if (prev != NULL) {
omapi_io_dereference(&prev->next, MDL);
if (tmp != NULL)
omapi_io_reference(&prev->next,
tmp, MDL);
} else {
omapi_io_dereference(&omapi_io_states.next,
MDL);
if (tmp != NULL)
omapi_io_reference
(&omapi_io_states.next,
tmp, MDL);
else
omapi_signal_in(
(omapi_object_t *)
&omapi_io_states,
"ready");
}
if (tmp != NULL)
omapi_io_dereference(&tmp, MDL);
} else {
if (prev != NULL) {
omapi_io_dereference(&prev, MDL);
}
omapi_io_reference(&prev, io, MDL);
}
/*
* Equivalent to:
* io = io->next
* But using our reference counting voodoo.
*/
next = NULL;
if (io->next != NULL) {
omapi_io_reference(&next, io->next, MDL);
}
omapi_io_dereference(&io, MDL);
if (next != NULL) {
omapi_io_reference(&io, next, MDL);
omapi_io_dereference(&next, MDL);
}
}
if (prev != NULL) {
omapi_io_dereference(&prev, MDL);
}
return ISC_R_SUCCESS;
}
static isc_result_t
omapi_message_process_internal (omapi_object_t *mo, omapi_object_t *po)
{
omapi_message_object_t *message, *m;
omapi_object_t *object = (omapi_object_t *)0;
omapi_value_t *tv = (omapi_value_t *)0;
unsigned long create, update, exclusive;
unsigned long wsi;
isc_result_t status, waitstatus;
omapi_object_type_t *type;
if (mo -> type != omapi_type_message)
return DHCP_R_INVALIDARG;
message = (omapi_message_object_t *)mo;
#ifdef DEBUG_PROTOCOL
log_debug ("omapi_message_process(): "
"op=%s handle=%#x id=%#x rid=%#x",
omapi_message_op_name (message -> op),
message -> h, message -> id, message -> rid);
#endif
if (message -> rid) {
for (m = omapi_registered_messages; m; m = m -> next)
if (m -> id == message -> rid)
break;
/* If we don't have a real message corresponding to
the message ID to which this message claims it is a
response, something's fishy. */
if (!m)
return ISC_R_NOTFOUND;
/* The authenticator on responses must match the initial
message. */
if (message -> authid != m -> authid)
return ISC_R_NOTFOUND;
} else {
m = (omapi_message_object_t *)0;
/* All messages must have an authenticator, with the exception
of messages that are opening a new authenticator. */
if (omapi_protocol_authenticated(po) &&
!message->id_object &&
message->op != OMAPI_OP_OPEN) {
return omapi_protocol_send_status
(po, message->id_object, DHCP_R_NOKEYS,
message->id, "No authenticator on message");
}
}
switch (message -> op) {
case OMAPI_OP_OPEN:
if (m) {
return omapi_protocol_send_status
(po, message->id_object, DHCP_R_INVALIDARG,
message->id, "OPEN can't be a response");
}
/* Get the type of the requested object, if one was
specified. */
status = omapi_get_value_str (mo, message -> id_object,
"type", &tv);
if (status == ISC_R_SUCCESS &&
(tv -> value -> type == omapi_datatype_data ||
tv -> value -> type == omapi_datatype_string)) {
for (type = omapi_object_types;
type; type = type -> next)
if (!omapi_td_strcmp (tv -> value,
type -> name))
break;
} else
type = (omapi_object_type_t *)0;
if (tv)
omapi_value_dereference (&tv, MDL);
/* If this object had no authenticator, the requested object
must be an authenticator object. */
if (omapi_protocol_authenticated(po) &&
!message->id_object &&
type != omapi_type_auth_key) {
return omapi_protocol_send_status
(po, message->id_object, DHCP_R_NOKEYS,
message->id, "No authenticator on message");
}
/* Get the create flag. */
status = omapi_get_value_str (mo, message -> id_object,
"create", &tv);
if (status == ISC_R_SUCCESS) {
status = omapi_get_int_value (&create, tv -> value);
omapi_value_dereference (&tv, MDL);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"invalid create flag value");
}
} else
create = 0;
/* Get the update flag. */
status = omapi_get_value_str (mo, message -> id_object,
"update", &tv);
if (status == ISC_R_SUCCESS) {
status = omapi_get_int_value (&update, tv -> value);
omapi_value_dereference (&tv, MDL);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"invalid update flag value");
}
} else
update = 0;
/* Get the exclusive flag. */
status = omapi_get_value_str (mo, message -> id_object,
"exclusive", &tv);
if (status == ISC_R_SUCCESS) {
status = omapi_get_int_value (&exclusive, tv -> value);
omapi_value_dereference (&tv, MDL);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"invalid exclusive flag value");
}
} else
exclusive = 0;
/* If we weren't given a type, look the object up with
the handle. */
if (!type) {
if (create) {
return omapi_protocol_send_status
(po, message->id_object,
DHCP_R_INVALIDARG,
message->id,
"type required on create");
}
goto refresh;
}
/* If the type doesn't provide a lookup method, we can't
look up the object. */
if (!type -> lookup) {
return omapi_protocol_send_status
(po, message -> id_object,
ISC_R_NOTIMPLEMENTED, message -> id,
"unsearchable object type");
}
status = (*(type -> lookup)) (&object, message -> id_object,
message -> object);
if (status != ISC_R_SUCCESS &&
status != ISC_R_NOTFOUND &&
status != DHCP_R_NOKEYS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"object lookup failed");
}
/* If we didn't find the object and we aren't supposed to
create it, return an error. */
if (status == ISC_R_NOTFOUND && !create) {
return omapi_protocol_send_status
(po, message -> id_object,
ISC_R_NOTFOUND, message -> id,
"no object matches specification");
}
/* If we found an object, we're supposed to be creating an
object, and we're not supposed to have found an object,
return an error. */
if (status == ISC_R_SUCCESS && create && exclusive) {
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status
(po, message -> id_object,
ISC_R_EXISTS, message -> id,
"specified object already exists");
}
/* If we're creating the object, do it now. */
if (!object) {
status = omapi_object_create (&object,
message -> id_object,
type);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"can't create new object");
}
}
/* If we're updating it, do so now. */
if (create || update) {
/* This check does not belong here. */
if (object -> type == omapi_type_auth_key) {
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"can't update object");
}
status = omapi_object_update (object,
message -> id_object,
message -> object,
message -> h);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"can't update object");
}
}
/* If this is an authenticator object, add it to the active
set for the connection. */
if (object -> type == omapi_type_auth_key) {
omapi_handle_t handle;
status = omapi_object_handle (&handle, object);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"can't select authenticator");
}
status = omapi_protocol_add_auth (po, object, handle);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"can't select authenticator");
}
}
/* Now send the new contents of the object back in
response. */
goto send;
case OMAPI_OP_REFRESH:
refresh:
status = omapi_handle_lookup (&object, message -> h);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"no matching handle");
}
send:
status = omapi_protocol_send_update (po, message -> id_object,
message -> id, object);
omapi_object_dereference (&object, MDL);
return status;
case OMAPI_OP_UPDATE:
if (m && m -> object) {
status = omapi_object_reference (&object, m -> object,
MDL);
} else {
status = omapi_handle_lookup (&object, message -> h);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"no matching handle");
}
}
if (object -> type == omapi_type_auth_key ||
(object -> inner &&
object -> inner -> type == omapi_type_auth_key)) {
if (!m) {
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"cannot update authenticator");
}
status = omapi_protocol_add_auth (po, object,
message -> h);
} else {
status = omapi_object_update (object,
message -> id_object,
message -> object,
message -> h);
}
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&object, MDL);
if (!message -> rid)
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"can't update object");
if (m)
omapi_signal ((omapi_object_t *)m,
"status", status,
(omapi_typed_data_t *)0);
return ISC_R_SUCCESS;
}
if (!message -> rid)
status = omapi_protocol_send_status
(po, message -> id_object, ISC_R_SUCCESS,
message -> id, (char *)0);
if (m) {
omapi_signal ((omapi_object_t *)m,
"status", ISC_R_SUCCESS,
(omapi_typed_data_t *)0);
omapi_message_unregister ((omapi_object_t *)m);
}
omapi_object_dereference (&object, MDL);
return status;
case OMAPI_OP_NOTIFY:
return omapi_protocol_send_status
(po, message -> id_object, ISC_R_NOTIMPLEMENTED,
message -> id, "notify not implemented yet");
case OMAPI_OP_STATUS:
/* The return status of a request. */
if (!m)
return ISC_R_UNEXPECTED;
/* Get the wait status. */
status = omapi_get_value_str (mo, message -> id_object,
"result", &tv);
if (status == ISC_R_SUCCESS) {
status = omapi_get_int_value (&wsi, tv -> value);
waitstatus = wsi;
omapi_value_dereference (&tv, MDL);
if (status != ISC_R_SUCCESS)
waitstatus = ISC_R_UNEXPECTED;
} else
waitstatus = ISC_R_UNEXPECTED;
status = omapi_get_value_str (mo, message -> id_object,
"message", &tv);
omapi_signal ((omapi_object_t *)m, "status", waitstatus, tv);
if (status == ISC_R_SUCCESS)
omapi_value_dereference (&tv, MDL);
omapi_message_unregister((omapi_object_t *)m);
return ISC_R_SUCCESS;
case OMAPI_OP_DELETE:
status = omapi_handle_lookup (&object, message -> h);
if (status != ISC_R_SUCCESS) {
return omapi_protocol_send_status
(po, message -> id_object,
status, message -> id,
"no matching handle");
}
if (!object -> type -> remove)
return omapi_protocol_send_status
(po, message -> id_object,
ISC_R_NOTIMPLEMENTED, message -> id,
"no remove method for object");
status = (*(object -> type -> remove)) (object,
message -> id_object);
omapi_object_dereference (&object, MDL);
return omapi_protocol_send_status (po, message -> id_object,
status, message -> id,
(char *)0);
}
return ISC_R_NOTIMPLEMENTED;
}
isc_result_t omapi_message_set_value (omapi_object_t *h,
omapi_object_t *id,
omapi_data_string_t *name,
omapi_typed_data_t *value)
{
omapi_message_object_t *m;
isc_result_t status;
if (h -> type != omapi_type_message)
return DHCP_R_INVALIDARG;
m = (omapi_message_object_t *)h;
/* Can't set authlen. */
/* Can set authenticator, but the value must be typed data. */
if (!omapi_ds_strcmp (name, "authenticator")) {
if (m -> authenticator)
omapi_typed_data_dereference (&m -> authenticator,
MDL);
omapi_typed_data_reference (&m -> authenticator, value, MDL);
return ISC_R_SUCCESS;
} else if (!omapi_ds_strcmp (name, "object")) {
if (value -> type != omapi_datatype_object)
return DHCP_R_INVALIDARG;
if (m -> object)
omapi_object_dereference (&m -> object, MDL);
omapi_object_reference (&m -> object, value -> u.object, MDL);
return ISC_R_SUCCESS;
} else if (!omapi_ds_strcmp (name, "notify-object")) {
if (value -> type != omapi_datatype_object)
return DHCP_R_INVALIDARG;
if (m -> notify_object)
omapi_object_dereference (&m -> notify_object, MDL);
omapi_object_reference (&m -> notify_object,
value -> u.object, MDL);
return ISC_R_SUCCESS;
/* Can set authid, but it has to be an integer. */
} else if (!omapi_ds_strcmp (name, "authid")) {
if (value -> type != omapi_datatype_int)
return DHCP_R_INVALIDARG;
m -> authid = value -> u.integer;
return ISC_R_SUCCESS;
/* Can set op, but it has to be an integer. */
} else if (!omapi_ds_strcmp (name, "op")) {
if (value -> type != omapi_datatype_int)
return DHCP_R_INVALIDARG;
m -> op = value -> u.integer;
return ISC_R_SUCCESS;
/* Handle also has to be an integer. */
} else if (!omapi_ds_strcmp (name, "handle")) {
if (value -> type != omapi_datatype_int)
return DHCP_R_INVALIDARG;
m -> h = value -> u.integer;
return ISC_R_SUCCESS;
/* Transaction ID has to be an integer. */
} else if (!omapi_ds_strcmp (name, "id")) {
if (value -> type != omapi_datatype_int)
return DHCP_R_INVALIDARG;
m -> id = value -> u.integer;
return ISC_R_SUCCESS;
/* Remote transaction ID has to be an integer. */
} else if (!omapi_ds_strcmp (name, "rid")) {
if (value -> type != omapi_datatype_int)
return DHCP_R_INVALIDARG;
m -> rid = value -> u.integer;
return ISC_R_SUCCESS;
}
/* Try to find some inner object that can take the value. */
if (h -> inner && h -> inner -> type -> set_value) {
status = ((*(h -> inner -> type -> set_value))
(h -> inner, id, name, value));
if (status == ISC_R_SUCCESS)
return status;
}
return ISC_R_NOTFOUND;
}
isc_result_t omapi_connect_list (omapi_object_t *c,
omapi_addr_list_t *remote_addrs,
omapi_addr_t *local_addr)
{
isc_result_t status;
omapi_connection_object_t *obj;
int flag;
struct sockaddr_in local_sin;
obj = (omapi_connection_object_t *)0;
status = omapi_connection_allocate (&obj, MDL);
if (status != ISC_R_SUCCESS)
return status;
status = omapi_object_reference (&c -> outer, (omapi_object_t *)obj,
MDL);
if (status != ISC_R_SUCCESS) {
omapi_connection_dereference (&obj, MDL);
return status;
}
status = omapi_object_reference (&obj -> inner, c, MDL);
if (status != ISC_R_SUCCESS) {
omapi_connection_dereference (&obj, MDL);
return status;
}
/* Store the address list on the object. */
omapi_addr_list_reference (&obj -> connect_list, remote_addrs, MDL);
obj -> cptr = 0;
obj -> state = omapi_connection_unconnected;
#if defined (TRACING)
/* If we're playing back, don't actually try to connect - just leave
the object available for a subsequent connect or disconnect. */
if (!trace_playback ()) {
#endif
/* Create a socket on which to communicate. */
obj -> socket =
socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (obj -> socket < 0) {
omapi_connection_dereference (&obj, MDL);
if (errno == EMFILE || errno == ENFILE
|| errno == ENOBUFS)
return ISC_R_NORESOURCES;
return ISC_R_UNEXPECTED;
}
/* Set up the local address, if any. */
if (local_addr) {
/* Only do TCPv4 so far. */
if (local_addr -> addrtype != AF_INET) {
omapi_connection_dereference (&obj, MDL);
return DHCP_R_INVALIDARG;
}
local_sin.sin_port = htons (local_addr -> port);
memcpy (&local_sin.sin_addr,
local_addr -> address,
local_addr -> addrlen);
#if defined (HAVE_SA_LEN)
local_sin.sin_len = sizeof local_addr;
#endif
local_sin.sin_family = AF_INET;
memset (&local_sin.sin_zero, 0,
sizeof local_sin.sin_zero);
if (bind (obj -> socket, (struct sockaddr *)&local_sin,
sizeof local_sin) < 0) {
omapi_connection_object_t **objp = &obj;
omapi_object_t **o = (omapi_object_t **)objp;
omapi_object_dereference(o, MDL);
if (errno == EADDRINUSE)
return ISC_R_ADDRINUSE;
if (errno == EADDRNOTAVAIL)
return ISC_R_ADDRNOTAVAIL;
if (errno == EACCES)
return ISC_R_NOPERM;
return ISC_R_UNEXPECTED;
}
obj -> local_addr = local_sin;
}
#if defined(F_SETFD)
if (fcntl (obj -> socket, F_SETFD, 1) < 0) {
close (obj -> socket);
omapi_connection_dereference (&obj, MDL);
return ISC_R_UNEXPECTED;
}
#endif
/* Set the SO_REUSEADDR flag (this should not fail). */
flag = 1;
if (setsockopt (obj -> socket, SOL_SOCKET, SO_REUSEADDR,
(char *)&flag, sizeof flag) < 0) {
omapi_connection_dereference (&obj, MDL);
return ISC_R_UNEXPECTED;
}
/* Set the file to nonblocking mode. */
if (fcntl (obj -> socket, F_SETFL, O_NONBLOCK) < 0) {
omapi_connection_dereference (&obj, MDL);
return ISC_R_UNEXPECTED;
}
status = (omapi_register_io_object
((omapi_object_t *)obj,
0, omapi_connection_writefd,
0, omapi_connection_connect,
omapi_connection_reaper));
if (status != ISC_R_SUCCESS)
goto out;
status = omapi_connection_connect_internal ((omapi_object_t *)
obj);
#if defined (TRACING)
}
omapi_connection_register (obj, MDL);
#endif
out:
omapi_connection_dereference (&obj, MDL);
return status;
}
isc_result_t omapi_listen_addr (omapi_object_t *h,
omapi_addr_t *addr,
int max)
{
isc_result_t status;
omapi_listener_object_t *obj;
int i;
/* Currently only support IPv4 addresses. */
if (addr->addrtype != AF_INET)
return ISC_R_INVALIDARG;
/* Get the handle. */
obj = (omapi_listener_object_t *)0;
status = omapi_listener_allocate (&obj, MDL);
if (status != ISC_R_SUCCESS)
return status;
obj->socket = -1;
/* Connect this object to the inner object. */
status = omapi_object_reference (&h -> outer,
(omapi_object_t *)obj, MDL);
if (status != ISC_R_SUCCESS)
goto error_exit;
status = omapi_object_reference (&obj -> inner, h, MDL);
if (status != ISC_R_SUCCESS)
goto error_exit;
/* Set up the address on which we will listen... */
obj -> address.sin_port = htons (addr -> port);
memcpy (&obj -> address.sin_addr,
addr -> address, sizeof obj -> address.sin_addr);
#if defined (HAVE_SA_LEN)
obj -> address.sin_len =
sizeof (struct sockaddr_in);
#endif
obj -> address.sin_family = AF_INET;
memset (&(obj -> address.sin_zero), 0,
sizeof obj -> address.sin_zero);
#if defined (TRACING)
/* If we're playing back a trace file, we remember the object
on the trace listener queue. */
if (trace_playback ()) {
trace_listener_remember (obj, MDL);
} else {
#endif
/* Create a socket on which to listen. */
obj -> socket = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (obj->socket == -1) {
if (errno == EMFILE
|| errno == ENFILE || errno == ENOBUFS)
status = ISC_R_NORESOURCES;
else
status = ISC_R_UNEXPECTED;
goto error_exit;
}
#if defined (HAVE_SETFD)
if (fcntl (obj -> socket, F_SETFD, 1) < 0) {
status = ISC_R_UNEXPECTED;
goto error_exit;
}
#endif
/* Set the REUSEADDR option so that we don't fail to start if
we're being restarted. */
i = 1;
if (setsockopt (obj -> socket, SOL_SOCKET, SO_REUSEADDR,
(char *)&i, sizeof i) < 0) {
status = ISC_R_UNEXPECTED;
goto error_exit;
}
/* Try to bind to the wildcard address using the port number
we were given. */
i = bind (obj -> socket,
(struct sockaddr *)&obj -> address,
sizeof obj -> address);
if (i < 0) {
if (errno == EADDRINUSE)
status = ISC_R_ADDRNOTAVAIL;
else if (errno == EPERM)
status = ISC_R_NOPERM;
else
status = ISC_R_UNEXPECTED;
goto error_exit;
}
/* Now tell the kernel to listen for connections. */
if (listen (obj -> socket, max)) {
status = ISC_R_UNEXPECTED;
goto error_exit;
}
if (fcntl (obj -> socket, F_SETFL, O_NONBLOCK) < 0) {
status = ISC_R_UNEXPECTED;
goto error_exit;
}
status = omapi_register_io_object ((omapi_object_t *)obj,
omapi_listener_readfd, 0,
omapi_accept, 0, 0);
#if defined (TRACING)
}
#endif
omapi_listener_dereference (&obj, MDL);
return status;
error_exit:
if (obj != NULL) {
if (h->outer == (omapi_object_t *)obj) {
omapi_object_dereference((omapi_object_t **)&h->outer,
MDL);
}
if (obj->inner == h) {
omapi_object_dereference((omapi_object_t **)&obj->inner,
MDL);
}
if (obj->socket != -1) {
close(obj->socket);
}
omapi_listener_dereference(&obj, MDL);
}
return status;
}
isc_result_t omapi_protocol_connect (omapi_object_t *h,
const char *server_name,
unsigned port,
omapi_object_t *a)
{
isc_result_t rstatus, status;
omapi_protocol_object_t *obj;
#ifdef DEBUG_PROTOCOL
log_debug ("omapi_protocol_connect(%s port=%d)", server_name, port);
#endif
obj = (omapi_protocol_object_t *)0;
status = omapi_protocol_allocate (&obj, MDL);
if (status != ISC_R_SUCCESS)
return status;
rstatus = omapi_connect ((omapi_object_t *)obj, server_name, port);
if (rstatus != ISC_R_SUCCESS && rstatus != ISC_R_INCOMPLETE) {
omapi_protocol_dereference (&obj, MDL);
return rstatus;
}
status = omapi_object_reference (&h -> outer,
(omapi_object_t *)obj, MDL);
if (status != ISC_R_SUCCESS) {
omapi_protocol_dereference (&obj, MDL);
return status;
}
status = omapi_object_reference (&obj -> inner, h, MDL);
if (status != ISC_R_SUCCESS) {
omapi_protocol_dereference (&obj, MDL);
return status;
}
/* If we were passed a default authenticator, store it now. We'll
open it once we're connected. */
if (a) {
obj -> default_auth =
dmalloc (sizeof(omapi_remote_auth_t), MDL);
if (!obj -> default_auth) {
omapi_protocol_dereference (&obj, MDL);
return ISC_R_NOMEMORY;
}
obj -> default_auth -> next = (omapi_remote_auth_t *)0;
status = omapi_object_reference (&obj -> default_auth -> a,
a, MDL);
if (status != ISC_R_SUCCESS) {
dfree (obj -> default_auth, MDL);
omapi_protocol_dereference (&obj, MDL);
return status;
}
obj -> insecure = 0;
rstatus = ISC_R_INCOMPLETE;
} else {
obj -> insecure = 1;
#if 0
status = ISC_R_SUCCESS;
#endif
}
omapi_protocol_dereference (&obj, MDL);
return rstatus;
}
