isc_result_t dhcp_control_stuff_values (omapi_object_t *c,
omapi_object_t *id,
omapi_object_t *h)
{
dhcp_control_object_t *control;
isc_result_t status;
if (h -> type != dhcp_type_control)
return ISC_R_INVALIDARG;
control = (dhcp_control_object_t *)h;
/* Write out all the values. */
status = omapi_connection_put_name (c, "state");
if (status != ISC_R_SUCCESS)
return status;
status = omapi_connection_put_uint32 (c, sizeof (u_int32_t));
if (status != ISC_R_SUCCESS)
return status;
status = omapi_connection_put_uint32 (c, control -> state);
if (status != ISC_R_SUCCESS)
return status;
/* Write out the inner object, if any. */
if (h -> inner && h -> inner -> type -> stuff_values) {
status = ((*(h -> inner -> type -> stuff_values))
(c, id, h -> inner));
if (status == ISC_R_SUCCESS)
return status;
}
return ISC_R_SUCCESS;
}
isc_result_t omapi_connection_put_handle (omapi_object_t *c, omapi_object_t *h)
{
isc_result_t status;
omapi_handle_t handle;
if (h) {
status = omapi_object_handle (&handle, h);
if (status != ISC_R_SUCCESS)
return status;
} else
handle = 0; /* The null handle. */
status = omapi_connection_put_uint32 (c, sizeof handle);
if (status != ISC_R_SUCCESS)
return status;
return omapi_connection_put_uint32 (c, handle);
}
isc_result_t omapi_connection_put_named_uint32 (omapi_object_t *c,
const char *name,
u_int32_t value)
{
isc_result_t status;
status = omapi_connection_put_name(c, name);
if (status != ISC_R_SUCCESS)
return (status);
status = omapi_connection_put_uint32(c, sizeof(u_int32_t));
if (status != ISC_R_SUCCESS)
return (status);
status = omapi_connection_put_uint32(c, value);
return (status);
}
/* Send the protocol introduction message. */
isc_result_t omapi_protocol_send_intro (omapi_object_t *h,
unsigned ver,
unsigned hsize)
{
isc_result_t status;
omapi_protocol_object_t *p;
#ifdef DEBUG_PROTOCOL
log_debug ("omapi_protocol_send_intro()");
#endif
if (h -> type != omapi_type_protocol)
return ISC_R_INVALIDARG;
p = (omapi_protocol_object_t *)h;
if (!h -> outer || h -> outer -> type != omapi_type_connection)
return ISC_R_NOTCONNECTED;
status = omapi_connection_put_uint32 (h -> outer, ver);
if (status != ISC_R_SUCCESS)
return status;
status = omapi_connection_put_uint32 (h -> outer, hsize);
if (status != ISC_R_SUCCESS)
return status;
/* Require the other end to send an intro - this kicks off the
protocol input state machine. */
p -> state = omapi_protocol_intro_wait;
status = omapi_connection_require (h -> outer, 8);
if (status != ISC_R_SUCCESS && status != ISC_R_NOTYET)
return status;
/* Make up an initial transaction ID for this connection. */
p -> next_xid = random ();
return ISC_R_SUCCESS;
}
isc_result_t omapi_connection_put_string (omapi_object_t *c,
const char *string)
{
isc_result_t status;
unsigned len;
if (string)
len = strlen (string);
else
len = 0;
status = omapi_connection_put_uint32 (c, len);
if (status != ISC_R_SUCCESS)
return status;
if (len)
return omapi_connection_copyin
(c, (const unsigned char *)string, len);
return ISC_R_SUCCESS;
}
isc_result_t omapi_connection_write_typed_data (omapi_object_t *c,
omapi_typed_data_t *data)
{
isc_result_t status;
omapi_handle_t handle;
/* Null data is valid. */
if (!data)
return omapi_connection_put_uint32 (c, 0);
switch (data -> type) {
case omapi_datatype_int:
status = omapi_connection_put_uint32 (c, sizeof (u_int32_t));
if (status != ISC_R_SUCCESS)
return status;
return omapi_connection_put_uint32 (c, ((u_int32_t)
(data -> u.integer)));
case omapi_datatype_string:
case omapi_datatype_data:
status = omapi_connection_put_uint32 (c, data -> u.buffer.len);
if (status != ISC_R_SUCCESS)
return status;
if (data -> u.buffer.len)
return omapi_connection_copyin
(c, data -> u.buffer.value,
data -> u.buffer.len);
return ISC_R_SUCCESS;
case omapi_datatype_object:
if (data -> u.object) {
status = omapi_object_handle (&handle,
data -> u.object);
if (status != ISC_R_SUCCESS)
return status;
} else
handle = 0;
status = omapi_connection_put_uint32 (c, sizeof handle);
if (status != ISC_R_SUCCESS)
return status;
return omapi_connection_put_uint32 (c, handle);
}
return ISC_R_INVALIDARG;
}
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;
}