isc_result_t omapi_object_update (omapi_object_t *obj, omapi_object_t *id,
omapi_object_t *src, omapi_handle_t handle)
{
omapi_generic_object_t *gsrc;
isc_result_t status;
int i;
if (!src)
return DHCP_R_INVALIDARG;
if (src -> type != omapi_type_generic)
return ISC_R_NOTIMPLEMENTED;
gsrc = (omapi_generic_object_t *)src;
for (i = 0; i < gsrc -> nvalues; i++) {
status = omapi_set_value (obj, id,
gsrc -> values [i] -> name,
gsrc -> values [i] -> value);
if (status != ISC_R_SUCCESS && status != DHCP_R_UNCHANGED)
return status;
}
/*
* For now ignore the return value. I'm not sure if we want to
* generate an error if we can't set the handle value. If we
* do add a check we probably should allow unchanged and notfound
*/
if (handle)
(void) omapi_set_int_value (obj, id, "remote-handle", (int)handle);
status = omapi_signal (obj, "updated");
if (status != ISC_R_NOTFOUND)
return status;
return ISC_R_SUCCESS;
}
isc_result_t omapi_object_update (omapi_object_t *obj, omapi_object_t *id,
omapi_object_t *src, omapi_handle_t handle)
{
omapi_generic_object_t *gsrc;
isc_result_t status=ISC_R_INVALIDARG;
int i;
if (!src)
return ISC_R_INVALIDARG;
if (src -> type != omapi_type_generic)
return ISC_R_NOTIMPLEMENTED;
gsrc = (omapi_generic_object_t *)src;
for (i = 0; i < gsrc -> nvalues; i++) {
status = omapi_set_value (obj, id,
gsrc -> values [i] -> name,
gsrc -> values [i] -> value);
if (status != ISC_R_SUCCESS && status != ISC_R_UNCHANGED)
return status;
}
if (handle)
status=omapi_set_int_value (obj, id, "remote-handle", (int)handle);
if(status!=ISC_R_SUCCESS){
log_error("omapi_set_int_value failed!\n");
}
status = omapi_signal (obj, "updated");
if (status != ISC_R_NOTFOUND)
return status;
return ISC_R_SUCCESS;
}
isc_result_t omapi_listener_connect (omapi_connection_object_t **obj,
omapi_listener_object_t *listener,
int socket,
struct sockaddr_in *remote_addr)
{
isc_result_t status;
omapi_object_t *h = (omapi_object_t *)listener;
omapi_addr_t addr;
#ifdef DEBUG_PROTOCOL
log_debug ("omapi_accept()");
#endif
/* Get the handle. */
status = omapi_connection_allocate (obj, MDL);
if (status != ISC_R_SUCCESS)
return status;
(*obj) -> state = omapi_connection_connected;
(*obj) -> remote_addr = *remote_addr;
(*obj) -> socket = socket;
/* Verify that this host is allowed to connect. */
if (listener -> verify_addr) {
addr.addrtype = AF_INET;
addr.addrlen = sizeof (remote_addr -> sin_addr);
memcpy (addr.address, &remote_addr -> sin_addr,
sizeof (remote_addr -> sin_addr));
addr.port = ntohs(remote_addr -> sin_port);
status = (listener -> verify_addr) (h, &addr);
if (status != ISC_R_SUCCESS) {
omapi_disconnect ((omapi_object_t *)(*obj), 1);
omapi_connection_dereference (obj, MDL);
return status;
}
}
omapi_listener_reference (&(*obj) -> listener, listener, MDL);
#if defined (TRACING)
omapi_connection_register (*obj, MDL);
#endif
status = omapi_signal (h, "connect", (*obj));
return status;
}
isc_result_t omapi_connection_connect (omapi_object_t *h)
{
isc_result_t status;
/*
* We use the INPROGRESS status to indicate that
* we want more from the socket. In this case we
* have now connected and are trying to write to
* the socket for the first time. For the signaling
* code this is the same as a SUCCESS so we don't
* pass it on as a signal.
*/
status = omapi_connection_connect_internal (h);
if (status == ISC_R_INPROGRESS)
return ISC_R_INPROGRESS;
if (status != ISC_R_SUCCESS)
omapi_signal (h, "status", status);
return ISC_R_SUCCESS;
}
static isc_result_t omapi_connection_reader_trace (omapi_object_t *h,
unsigned stuff_len,
char *stuff_buf,
unsigned *stuff_taken)
{
#endif
omapi_buffer_t *buffer;
isc_result_t status;
unsigned read_len;
int read_status;
omapi_connection_object_t *c;
unsigned bytes_to_read;
if (!h || h -> type != omapi_type_connection)
return ISC_R_INVALIDARG;
c = (omapi_connection_object_t *)h;
/* See if there are enough bytes. */
if (c -> in_bytes >= OMAPI_BUF_SIZE - 1 &&
c -> in_bytes > c -> bytes_needed)
return ISC_R_SUCCESS;
if (c -> inbufs) {
for (buffer = c -> inbufs; buffer -> next;
buffer = buffer -> next)
;
if (!BUFFER_BYTES_FREE (buffer)) {
status = omapi_buffer_new (&buffer -> next, MDL);
if (status != ISC_R_SUCCESS)
return status;
buffer = buffer -> next;
}
} else {
status = omapi_buffer_new (&c -> inbufs, MDL);
if (status != ISC_R_SUCCESS)
return status;
buffer = c -> inbufs;
}
bytes_to_read = BUFFER_BYTES_FREE (buffer);
while (bytes_to_read) {
if (buffer -> tail > buffer -> head)
read_len = sizeof (buffer -> buf) - buffer -> tail;
else
read_len = buffer -> head - buffer -> tail;
#if defined (TRACING)
if (trace_playback()) {
if (stuff_len) {
if (read_len > stuff_len)
read_len = stuff_len;
if (stuff_taken)
*stuff_taken += read_len;
memcpy (&buffer -> buf [buffer -> tail],
stuff_buf, read_len);
stuff_len -= read_len;
stuff_buf += read_len;
read_status = read_len;
} else {
break;
}
} else
#endif
{
read_status = read (c -> socket,
&buffer -> buf [buffer -> tail],
read_len);
}
if (read_status < 0) {
if (errno == EWOULDBLOCK)
break;
else if (errno == EIO)
return ISC_R_IOERROR;
else if (errno == EINVAL)
return ISC_R_INVALIDARG;
else if (errno == ECONNRESET) {
omapi_disconnect (h, 1);
return ISC_R_SHUTTINGDOWN;
} else
return ISC_R_UNEXPECTED;
}
/* If we got a zero-length read, as opposed to EWOULDBLOCK,
the remote end closed the connection. */
if (read_status == 0) {
omapi_disconnect (h, 0);
return ISC_R_SHUTTINGDOWN;
}
#if defined (TRACING)
if (trace_record ()) {
trace_iov_t iov [2];
int32_t connect_index;
connect_index = htonl (c -> index);
iov [0].buf = (char *)&connect_index;
iov [0].len = sizeof connect_index;
iov [1].buf = &buffer -> buf [buffer -> tail];
iov [1].len = read_status;
status = (trace_write_packet_iov
(trace_connection_input, 2, iov, MDL));
if (status != ISC_R_SUCCESS) {
trace_stop ();
log_error ("trace connection input: %s",
isc_result_totext (status));
}
}
#endif
buffer -> tail += read_status;
c -> in_bytes += read_status;
if (buffer -> tail == sizeof buffer -> buf)
buffer -> tail = 0;
if (read_status < read_len)
break;
bytes_to_read -= read_status;
}
if (c -> bytes_needed <= c -> in_bytes) {
omapi_signal (h, "ready", c);
}
return ISC_R_SUCCESS;
}
isc_result_t omapi_protocol_signal_handler (omapi_object_t *h,
const char *name, va_list ap)
{
isc_result_t status;
omapi_protocol_object_t *p;
omapi_object_t *c;
omapi_message_object_t *m;
omapi_value_t *signature;
u_int16_t nlen;
u_int32_t vlen;
u_int32_t th;
#if defined (DEBUG_MEMORY_LEAKAGE)
unsigned long previous_outstanding = 0xDEADBEEF;
unsigned long connect_outstanding = 0xDEADBEEF;
#endif
if (h -> type != omapi_type_protocol) {
/* XXX shouldn't happen. Put an assert here? */
return ISC_R_UNEXPECTED;
}
p = (omapi_protocol_object_t *)h;
if (!strcmp (name, "connect")) {
#if defined (DEBUG_MEMORY_LEAKAGE)
connect_outstanding = dmalloc_outstanding;
#endif
/* Send the introductory message. */
status = omapi_protocol_send_intro
(h, OMAPI_PROTOCOL_VERSION,
sizeof (omapi_protocol_header_t));
if (status != ISC_R_SUCCESS) {
omapi_disconnect (p -> outer, 1);
return status;
}
return ISC_R_SUCCESS;
}
/* Should only receive these when opening the initial authenticator. */
if (!strcmp (name, "status")) {
status = va_arg (ap, isc_result_t);
if (status != ISC_R_SUCCESS) {
omapi_signal_in (h -> inner, "status", status,
(omapi_object_t *)0);
omapi_disconnect (p -> outer, 1);
return status;
} else {
return omapi_signal_in (h -> inner, "ready");
}
}
/* If we get a disconnect, dump memory usage. */
if (!strcmp (name, "disconnect")) {
#if defined (DEBUG_MEMORY_LEAKAGE)
if (connect_outstanding != 0xDEADBEEF) {
log_info ("generation %ld: %ld new, %ld outstanding, %ld%s",
dmalloc_generation,
dmalloc_outstanding - previous_outstanding,
dmalloc_outstanding, dmalloc_longterm, " long-term");
}
#endif
#if defined (DEBUG_MEMORY_LEAKAGE)
dmalloc_dump_outstanding ();
#endif
#if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
dump_rc_history ();
#endif
for (m = omapi_registered_messages; m; m = m -> next) {
if (m -> protocol_object == p) {
if (m -> object)
omapi_signal (m -> object, "disconnect");
}
}
}
/* Not a signal we recognize? */
if (strcmp (name, "ready")) {
if (p -> inner && p -> inner -> type -> signal_handler)
return (*(p -> inner -> type -> signal_handler)) (h,
name,
ap);
return ISC_R_NOTFOUND;
}
if (!p -> outer || p -> outer -> type != omapi_type_connection)
return ISC_R_INVALIDARG;
c = p -> outer;
/* We get here because we requested that we be woken up after
some number of bytes were read, and that number of bytes
has in fact been read. */
switch (p -> state) {
case omapi_protocol_intro_wait:
/* Get protocol version and header size in network
byte order. */
omapi_connection_get_uint32 (c, &p -> protocol_version);
omapi_connection_get_uint32 (c, &p -> header_size);
/* We currently only support the current protocol version. */
if (p -> protocol_version != OMAPI_PROTOCOL_VERSION) {
omapi_disconnect (c, 1);
return ISC_R_VERSIONMISMATCH;
}
if (p -> header_size < sizeof (omapi_protocol_header_t)) {
omapi_disconnect (c, 1);
return ISC_R_PROTOCOLERROR;
}
if (p -> default_auth) {
status = omapi_protocol_send_open
(h, (omapi_object_t *)0, "authenticator",
p -> default_auth -> a,
OMAPI_NOTIFY_PROTOCOL);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
} else {
status = omapi_signal_in (h -> inner, "ready");
}
to_header_wait:
/* The next thing we're expecting is a message header. */
p -> state = omapi_protocol_header_wait;
/* Register a need for the number of bytes in a
header, and if we already have that many, process
them immediately. */
if ((omapi_connection_require (c, p -> header_size)) !=
ISC_R_SUCCESS)
break;
/* If we already have the data, fall through. */
case omapi_protocol_header_wait:
#if defined (DEBUG_MEMORY_LEAKAGE)
if (previous_outstanding != 0xDEADBEEF) {
log_info ("%s %ld: %ld new, %ld outstanding, %ld%s",
"generation", dmalloc_generation,
dmalloc_outstanding - previous_outstanding,
dmalloc_outstanding, dmalloc_longterm,
" long-term");
#endif
#if (defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL))
dmalloc_dump_outstanding ();
#endif
#if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
dump_rc_history ();
#endif
#if defined (DEBUG_MEMORY_LEAKAGE)
}
previous_outstanding = dmalloc_outstanding;
#endif
status = omapi_message_new ((omapi_object_t **)&p -> message,
MDL);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
p -> verify_result = ISC_R_SUCCESS;
/* Swap in the header... */
omapi_connection_get_uint32 (c, &p -> message -> authid);
/* Bind the authenticator to the message object. */
if (p -> message -> authid) {
status = (omapi_protocol_lookup_auth
(&p -> message -> id_object, h,
p -> message -> authid));
if (status != ISC_R_SUCCESS)
p -> verify_result = status;
/* Activate the authentication key. */
status = omapi_set_object_value
(c, (omapi_object_t *)0, "input-authenticator",
p -> message -> id_object);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
}
omapi_connection_get_uint32 (c, &p -> message -> authlen);
omapi_connection_get_uint32 (c, &p -> message -> op);
omapi_connection_get_uint32 (c, &th);
p -> message -> h = th;
omapi_connection_get_uint32 (c, &p -> message -> id);
omapi_connection_get_uint32 (c, &p -> message -> rid);
/* If there was any extra header data, skip over it. */
if (p -> header_size > sizeof (omapi_protocol_header_t)) {
omapi_connection_copyout
(0, c, (p -> header_size -
sizeof (omapi_protocol_header_t)));
}
/* XXX must compute partial signature across the
XXX preceding bytes. Also, if authenticator
specifies encryption as well as signing, we may
have to decrypt the data on the way in. */
/* First we read in message-specific values, then object
values. */
p -> reading_message_values = 1;
need_name_length:
/* The next thing we're expecting is length of the
first name. */
p -> state = omapi_protocol_name_length_wait;
/* Wait for a 16-bit length. */
if ((omapi_connection_require (c, 2)) != ISC_R_SUCCESS)
break;
/* If it's already here, fall through. */
case omapi_protocol_name_length_wait:
omapi_connection_get_uint16 (c, &nlen);
/* A zero-length name means that we're done reading name+value
pairs. */
if (nlen == 0) {
/* If we've already read in the object, we are
done reading the message, but if we've just
finished reading in the values associated
with the message, we need to read the
object. */
if (p -> reading_message_values) {
p -> reading_message_values = 0;
goto need_name_length;
}
/* If the authenticator length is zero, there's no
signature to read in, so go straight to processing
the message. */
if (p -> message -> authlen == 0)
goto message_done;
/* The next thing we're expecting is the
message signature. */
p -> state = omapi_protocol_signature_wait;
/* Wait for the number of bytes specified for
the authenticator. If we already have it,
go read it in. */
if (omapi_connection_require
(c, p -> message -> authlen) == ISC_R_SUCCESS)
goto signature_wait;
break;
}
/* Allocate a buffer for the name. */
status = (omapi_data_string_new (&p -> name, nlen, MDL));
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return ISC_R_NOMEMORY;
}
p -> state = omapi_protocol_name_wait;
if (omapi_connection_require (c, nlen) != ISC_R_SUCCESS)
break;
/* If it's already here, fall through. */
case omapi_protocol_name_wait:
omapi_connection_copyout (p -> name -> value, c,
p -> name -> len);
/* Wait for a 32-bit length. */
p -> state = omapi_protocol_value_length_wait;
if ((omapi_connection_require (c, 4)) != ISC_R_SUCCESS)
break;
/* If it's already here, fall through. */
case omapi_protocol_value_length_wait:
omapi_connection_get_uint32 (c, &vlen);
/* Zero-length values are allowed - if we get one, we
don't have to read any data for the value - just
get the next one, if there is a next one. */
if (!vlen)
goto insert_new_value;
status = omapi_typed_data_new (MDL, &p -> value,
omapi_datatype_data,
vlen);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return ISC_R_NOMEMORY;
}
p -> state = omapi_protocol_value_wait;
if (omapi_connection_require (c, vlen) != ISC_R_SUCCESS)
break;
/* If it's already here, fall through. */
case omapi_protocol_value_wait:
omapi_connection_copyout (p -> value -> u.buffer.value, c,
p -> value -> u.buffer.len);
insert_new_value:
if (p -> reading_message_values) {
status = (omapi_set_value
((omapi_object_t *)p -> message,
p -> message -> id_object,
p -> name, p -> value));
} else {
if (!p -> message -> object) {
/* We need a generic object to hang off of the
incoming message. */
status = (omapi_generic_new
(&p -> message -> object, MDL));
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
}
status = (omapi_set_value
((omapi_object_t *)p -> message -> object,
p -> message -> id_object,
p -> name, p -> value));
}
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
omapi_data_string_dereference (&p -> name, MDL);
if (p -> value)
omapi_typed_data_dereference (&p -> value, MDL);
goto need_name_length;
signature_wait:
case omapi_protocol_signature_wait:
if (p -> message -> id_object) {
/* Compute the signature of the message. */
signature = (omapi_value_t *)0;
status = omapi_get_value_str (c, (omapi_object_t *)0,
"input-signature",
&signature);
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return status;
}
/* Disable the authentication key on the connection. */
status = omapi_set_value_str (c, (omapi_object_t *)0,
"input-authenticator",
(omapi_typed_data_t *)0);
if (status != ISC_R_SUCCESS) {
omapi_value_dereference (&signature, MDL);
omapi_disconnect (c, 1);
return status;
}
}
/* Read the authenticator. */
status = omapi_typed_data_new (MDL,
&p -> message -> authenticator,
omapi_datatype_data,
p -> message -> authlen);
if (status != ISC_R_SUCCESS) {
omapi_value_dereference (&signature, MDL);
omapi_disconnect (c, 1);
return ISC_R_NOMEMORY;
}
omapi_connection_copyout
(p -> message -> authenticator -> u.buffer.value, c,
p -> message -> authlen);
/* Verify the signature. */
if (p -> message -> id_object &&
((signature -> value -> u.buffer.len !=
p -> message -> authlen) ||
(memcmp (signature -> value -> u.buffer.value,
p -> message -> authenticator -> u.buffer.value,
p -> message -> authlen) != 0))) {
/* Invalid signature. */
p -> verify_result = ISC_R_INVALIDKEY;
}
omapi_value_dereference (&signature, MDL);
/* Process the message. */
message_done:
if (p -> verify_result != ISC_R_SUCCESS) {
status = omapi_protocol_send_status
(h, (omapi_object_t *)0, p -> verify_result,
p -> message -> id, (char *)0);
} else {
status = omapi_message_process
((omapi_object_t *)p -> message, h);
}
if (status != ISC_R_SUCCESS) {
omapi_disconnect (c, 1);
return ISC_R_NOMEMORY;
}
omapi_message_dereference (&p -> message, MDL);
#if defined (DEBUG_MEMORY_LEAKAGE)
log_info ("generation %ld: %ld new, %ld outstanding, %ld%s",
dmalloc_generation,
dmalloc_outstanding - previous_outstanding,
dmalloc_outstanding, dmalloc_longterm, " long-term");
#endif
#if (defined (DEBUG_MEMORY_LEAKAGE) || defined (DEBUG_MALLOC_POOL))
dmalloc_dump_outstanding ();
#endif
#if defined (DEBUG_RC_HISTORY_EXHAUSTIVELY)
dump_rc_history ();
#endif
#if defined (DEBUG_MEMORY_LEAKAGE)
previous_outstanding = 0xDEADBEEF;
#endif
/* Now wait for the next message. */
goto to_header_wait;
default:
/* XXX should never get here. Assertion? */
break;
}
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_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;
}