isc_result_t omapi_unregister_io_object (omapi_object_t *h)
{
omapi_io_object_t *p, *obj, *last, *ph;
if (!h -> outer || h -> outer -> type != omapi_type_io_object)
return ISC_R_INVALIDARG;
obj = (omapi_io_object_t *)h -> outer;
ph = (omapi_io_object_t *)0;
omapi_io_reference (&ph, obj, MDL);
/* remove from the list of I/O states */
last = &omapi_io_states;
for (p = omapi_io_states.next; p; p = p -> next) {
if (p == obj) {
omapi_io_dereference (&last -> next, MDL);
omapi_io_reference (&last -> next, p -> next, MDL);
break;
}
last = p;
}
if (obj -> next)
omapi_io_dereference (&obj -> next, MDL);
if (obj -> outer) {
if (obj -> outer -> inner == (omapi_object_t *)obj)
omapi_object_dereference (&obj -> outer -> inner,
MDL);
omapi_object_dereference (&obj -> outer, MDL);
}
omapi_object_dereference (&obj -> inner, MDL);
omapi_object_dereference (&h -> outer, MDL);
omapi_io_dereference (&ph, MDL);
return ISC_R_SUCCESS;
}
dhcpctl_status dhcpctl_connect (dhcpctl_handle *connection,
const char *server_name, int port,
dhcpctl_handle authinfo)
{
isc_result_t status;
status = omapi_generic_new (connection, MDL);
if (status != ISC_R_SUCCESS) {
return status;
}
status = omapi_protocol_connect (*connection, server_name,
(unsigned)port, authinfo);
if (status == ISC_R_SUCCESS)
return status;
if (status != DHCP_R_INCOMPLETE) {
omapi_object_dereference (connection, MDL);
return status;
}
status = omapi_wait_for_completion (*connection, 0);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (connection, MDL);
return status;
}
return status;
}
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_auth_key_lookup (omapi_object_t **h,
omapi_object_t *id,
omapi_object_t *ref)
{
isc_result_t status;
omapi_value_t *name = (omapi_value_t *)0;
omapi_value_t *algorithm = (omapi_value_t *)0;
if (!auth_key_hash)
return ISC_R_NOTFOUND;
if (!ref)
return ISC_R_NOKEYS;
status = omapi_get_value_str (ref, id, "name", &name);
if (status != ISC_R_SUCCESS)
return status;
if ((name -> value -> type != omapi_datatype_string) &&
(name -> value -> type != omapi_datatype_data)) {
omapi_value_dereference (&name, MDL);
return ISC_R_NOTFOUND;
}
status = omapi_get_value_str (ref, id, "algorithm", &algorithm);
if (status != ISC_R_SUCCESS) {
omapi_value_dereference (&name, MDL);
return status;
}
if ((algorithm -> value -> type != omapi_datatype_string) &&
(algorithm -> value -> type != omapi_datatype_data)) {
omapi_value_dereference (&name, MDL);
omapi_value_dereference (&algorithm, MDL);
return ISC_R_NOTFOUND;
}
if (!omapi_auth_key_hash_lookup ((omapi_auth_key_t **)h, auth_key_hash,
(const char *)
name -> value -> u.buffer.value,
name -> value -> u.buffer.len, MDL)) {
omapi_value_dereference (&name, MDL);
omapi_value_dereference (&algorithm, MDL);
return ISC_R_NOTFOUND;
}
if (omapi_td_strcasecmp (algorithm -> value,
((omapi_auth_key_t *)*h) -> algorithm) != 0) {
omapi_value_dereference (&name, MDL);
omapi_value_dereference (&algorithm, MDL);
omapi_object_dereference (h, MDL);
return ISC_R_NOTFOUND;
}
omapi_value_dereference (&name, MDL);
omapi_value_dereference (&algorithm, MDL);
return ISC_R_SUCCESS;
}
isc_result_t dhcp_control_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;
dhcp_control_object_t *control;
/* First see if we were sent a handle. */
if (ref) {
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_control) {
omapi_object_dereference (lp, MDL);
return ISC_R_INVALIDARG;
}
}
}
/* Otherwise, stop playing coy - there's only one control object,
so we can just return it. */
dhcp_control_reference ((dhcp_control_object_t **)lp,
dhcp_control_object, MDL);
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 DHCP_R_INVALIDARG;
m = (omapi_message_object_t *)mo;
/* Already registered? */
if (m -> prev || m -> next || omapi_registered_messages == m)
return DHCP_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_protocol_destroy (omapi_object_t *h,
const char *file, int line)
{
omapi_protocol_object_t *p;
if (h -> type != omapi_type_protocol)
return ISC_R_INVALIDARG;
p = (omapi_protocol_object_t *)h;
if (p -> message)
omapi_message_dereference (&p -> message, file, line);
/* This will happen if: 1) A default authenticator is supplied to
omapi_protocol_connect(), and 2) something goes wrong before
the authenticator can be opened. */
if (p -> default_auth && !p -> remote_auth_list)
dfree (p -> default_auth, file, line);
while (p -> remote_auth_list) {
omapi_remote_auth_t *r = p -> remote_auth_list -> next;
p -> remote_auth_list = r;
if (r) {
omapi_object_dereference (&r -> a, file, line);
dfree (r, file, line);
}
}
return ISC_R_SUCCESS;
}
dhcpctl_status dhcpctl_object_refresh (dhcpctl_handle connection,
dhcpctl_handle h)
{
isc_result_t status;
omapi_object_t *message = (omapi_object_t *)0;
dhcpctl_remote_object_t *ro;
if (h -> type != dhcpctl_remote_type)
return DHCP_R_INVALIDARG;
ro = (dhcpctl_remote_object_t *)h;
status = omapi_message_new (&message, MDL);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_set_int_value (message, (omapi_object_t *)0,
"op", OMAPI_OP_REFRESH);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_set_int_value (message, (omapi_object_t *)0,
"handle", (int)(ro -> remote_handle));
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
omapi_message_register (message);
status = omapi_protocol_send_message (connection -> outer,
(omapi_object_t *)0,
message, (omapi_object_t *)0);
/* We don't want to send the contents of the object down the
wire, but we do need to reference it so that we know what
to do with the update. */
status = omapi_set_object_value (message, (omapi_object_t *)0,
"object", h);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
omapi_object_dereference (&message, MDL);
return status;
}
dhcpctl_status dhcpctl_object_remove (dhcpctl_handle connection,
dhcpctl_handle h)
{
isc_result_t status;
omapi_object_t *message = (omapi_object_t *)0;
dhcpctl_remote_object_t *ro;
if (h -> type != dhcpctl_remote_type)
return DHCP_R_INVALIDARG;
ro = (dhcpctl_remote_object_t *)h;
status = omapi_message_new (&message, MDL);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_set_int_value (message, (omapi_object_t *)0,
"op", OMAPI_OP_DELETE);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_set_int_value (message, (omapi_object_t *)0, "handle",
(int)(ro -> remote_handle));
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_set_object_value (message, (omapi_object_t *)0,
"notify-object", h);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
omapi_message_register (message);
status = omapi_protocol_send_message (connection -> outer,
(omapi_object_t *)0,
message, (omapi_object_t *)0);
omapi_object_dereference (&message, MDL);
return status;
}
isc_result_t dhcp_shared_network_destroy (omapi_object_t *h,
const char *file, int line)
{
/* In this function h should be a (struct shared_network *) */
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
struct shared_network *shared_network;
#endif
if (h -> type != dhcp_type_shared_network)
return DHCP_R_INVALIDARG;
#if defined (DEBUG_MEMORY_LEAKAGE) || \
defined (DEBUG_MEMORY_LEAKAGE_ON_EXIT)
shared_network = (struct shared_network *)h;
if (shared_network -> next)
shared_network_dereference (&shared_network -> next,
file, line);
if (shared_network -> name) {
dfree (shared_network -> name, file, line);
shared_network -> name = 0;
}
if (shared_network -> subnets)
subnet_dereference (&shared_network -> subnets, file, line);
if (shared_network -> interface)
interface_dereference (&shared_network -> interface,
file, line);
if (shared_network -> pools)
omapi_object_dereference ((omapi_object_t **)
&shared_network -> pools, file, line);
if (shared_network -> group)
group_dereference (&shared_network -> group, file, line);
#if defined (FAILOVER_PROTOCOL)
if (shared_network -> failover_peer)
omapi_object_dereference ((omapi_object_t **)
&shared_network -> failover_peer,
file, line);
#endif
#endif /* DEBUG_MEMORY_LEAKAGE */
return ISC_R_SUCCESS;
}
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 dhcpctl_callback_destroy (omapi_object_t *h,
const char *file, int line)
{
dhcpctl_callback_object_t *p;
if (h -> type != dhcpctl_callback_type)
return ISC_R_INVALIDARG;
p = (dhcpctl_callback_object_t *)h;
if (p -> handle)
omapi_object_dereference ((omapi_object_t **)&p -> handle,
file, line);
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 omapi_message_destroy (omapi_object_t *h,
const char *file, int line)
{
omapi_message_object_t *m;
if (h -> type != omapi_type_message)
return DHCP_R_INVALIDARG;
m = (omapi_message_object_t *)h;
if (m -> authenticator) {
omapi_typed_data_dereference (&m -> authenticator, file, line);
}
if (!m -> prev && omapi_registered_messages != m)
omapi_message_unregister (h);
if (m -> id_object)
omapi_object_dereference (&m -> id_object, file, line);
if (m -> object)
omapi_object_dereference (&m -> object, file, line);
if (m -> notify_object)
omapi_object_dereference (&m -> notify_object, file, line);
if (m -> protocol_object)
omapi_protocol_dereference (&m -> protocol_object, file, line);
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_disconnect (omapi_object_t *h,
int force)
{
omapi_connection_object_t *c;
//ScenSim-Port//#ifdef DEBUG_PROTOCOL
//ScenSim-Port// log_debug ("omapi_disconnect(%s)", force ? "force" : "");
//ScenSim-Port//#endif
c = (omapi_connection_object_t *)h;
if (c -> type != omapi_type_connection)
return DHCP_R_INVALIDARG;
//ScenSim-Port//#if defined (TRACING)
//ScenSim-Port// if (trace_record ()) {
//ScenSim-Port// isc_result_t status;
//ScenSim-Port// int32_t index;
//ScenSim-Port//
//ScenSim-Port// index = htonl (c -> index);
//ScenSim-Port// status = trace_write_packet (trace_disconnect,
//ScenSim-Port// sizeof index, (char *)&index,
//ScenSim-Port// MDL);
//ScenSim-Port// if (status != ISC_R_SUCCESS) {
//ScenSim-Port// trace_stop ();
//ScenSim-Port// log_error ("trace_write_packet: %s",
//ScenSim-Port// isc_result_totext (status));
//ScenSim-Port// }
//ScenSim-Port// }
//ScenSim-Port// if (!trace_playback ()) {
//ScenSim-Port//#endif
if (!force) {
/* If we're already disconnecting, we don't have to do
anything. */
if (c -> state == omapi_connection_disconnecting)
return ISC_R_SUCCESS;
/* Try to shut down the socket - this sends a FIN to
the remote end, so that it won't send us any more
data. If the shutdown succeeds, and we still
have bytes left to write, defer closing the socket
until that's done. */
//ScenSim-Port// if (!shutdown (c -> socket, SHUT_RD)) {
//ScenSim-Port// if (c -> out_bytes > 0) {
//ScenSim-Port// c -> state =
//ScenSim-Port// omapi_connection_disconnecting;
//ScenSim-Port// return ISC_R_SUCCESS;
//ScenSim-Port// }
//ScenSim-Port// }
}
close (c -> socket);
//ScenSim-Port//#if defined (TRACING)
//ScenSim-Port// }
//ScenSim-Port//#endif
c -> state = omapi_connection_closed;
//ScenSim-Port//#if 0
//ScenSim-Port// /*
//ScenSim-Port// * Disconnecting from the I/O object seems incorrect as it doesn't
//ScenSim-Port// * cause the I/O object to be cleaned and released. Previous to
//ScenSim-Port// * using the isc socket library this wouldn't have caused a problem
//ScenSim-Port// * with the socket library we would have a reference to a closed
//ScenSim-Port// * socket. Instead we now do an unregister to properly free the
//ScenSim-Port// * I/O object.
//ScenSim-Port// */
//ScenSim-Port//
//ScenSim-Port// /* Disconnect from I/O object, if any. */
//ScenSim-Port// if (h -> outer) {
//ScenSim-Port// if (h -> outer -> inner)
//ScenSim-Port// omapi_object_dereference (&h -> outer -> inner, MDL);
//ScenSim-Port// omapi_object_dereference (&h -> outer, MDL);
//ScenSim-Port// }
//ScenSim-Port//#else
if (h->outer) {
omapi_unregister_io_object(h);
}
//ScenSim-Port//#endif
/* If whatever created us registered a signal handler, send it
a disconnect signal. */
omapi_signal (h, "disconnect", h);
/* Disconnect from protocol object, if any. */
if (h->inner != NULL) {
if (h->inner->outer != NULL) {
omapi_object_dereference(&h->inner->outer, MDL);
}
omapi_object_dereference(&h->inner, MDL);
}
/* XXX: the code to free buffers should be in the dereference
function, but there is no special-purpose function to
dereference connections, so these just get leaked */
/* Free any buffers */
if (c->inbufs != NULL) {
omapi_buffer_dereference(&c->inbufs, MDL);
}
c->in_bytes = 0;
if (c->outbufs != NULL) {
omapi_buffer_dereference(&c->outbufs, MDL);
}
c->out_bytes = 0;
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 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;
}
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_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_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;
}
dhcpctl_status dhcpctl_open_object (dhcpctl_handle h,
dhcpctl_handle connection,
int flags)
{
isc_result_t status;
omapi_object_t *message = (omapi_object_t *)0;
dhcpctl_remote_object_t *remote;
if (h -> type != dhcpctl_remote_type)
return DHCP_R_INVALIDARG;
remote = (dhcpctl_remote_object_t *)h;
status = omapi_message_new (&message, MDL);
if (status != ISC_R_SUCCESS)
return status;
status = omapi_set_int_value (message, (omapi_object_t *)0,
"op", OMAPI_OP_OPEN);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_set_object_value (message, (omapi_object_t *)0,
"object", h);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
if (flags & DHCPCTL_CREATE) {
status = omapi_set_boolean_value (message, (omapi_object_t *)0,
"create", 1);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
}
if (flags & DHCPCTL_UPDATE) {
status = omapi_set_boolean_value (message, (omapi_object_t *)0,
"update", 1);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
}
if (flags & DHCPCTL_EXCL) {
status = omapi_set_boolean_value (message, (omapi_object_t *)0,
"exclusive", 1);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
}
if (remote -> rtype) {
status = omapi_set_value_str (message, (omapi_object_t *)0,
"type", remote -> rtype);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
}
status = omapi_message_register (message);
if (status != ISC_R_SUCCESS) {
omapi_object_dereference (&message, MDL);
return status;
}
status = omapi_protocol_send_message (connection -> outer,
(omapi_object_t *)0,
message, (omapi_object_t *)0);
if (status != ISC_R_SUCCESS)
omapi_message_unregister (message);
omapi_object_dereference (&message, MDL);
return status;
}