static size_t consume_data(amqp_connection_state_t state,
amqp_bytes_t *received_data)
{
/* how much data is available and will fit? */
size_t bytes_consumed = state->target_size - state->inbound_offset;
if (received_data->len < bytes_consumed)
bytes_consumed = received_data->len;
memcpy(amqp_offset(state->inbound_buffer.bytes, state->inbound_offset),
received_data->bytes, bytes_consumed);
state->inbound_offset += bytes_consumed;
received_data->bytes = amqp_offset(received_data->bytes, bytes_consumed);
received_data->len -= bytes_consumed;
return bytes_consumed;
}
int amqp_send_frame(amqp_connection_state_t state,
const amqp_frame_t *frame)
{
void *out_frame = state->outbound_buffer.bytes;
int res;
amqp_e8(out_frame, 0, frame->frame_type);
amqp_e16(out_frame, 1, frame->channel);
if (frame->frame_type == AMQP_FRAME_BODY) {
/* For a body frame, rather than copying data around, we use
writev to compose the frame */
struct iovec iov[3];
uint8_t frame_end_byte = AMQP_FRAME_END;
const amqp_bytes_t *body = &frame->payload.body_fragment;
amqp_e32(out_frame, 3, body->len);
iov[0].iov_base = out_frame;
iov[0].iov_len = HEADER_SIZE;
iov[1].iov_base = body->bytes;
iov[1].iov_len = body->len;
iov[2].iov_base = &frame_end_byte;
iov[2].iov_len = FOOTER_SIZE;
res = amqp_socket_writev(state->socket, iov, 3);
} else {
size_t out_frame_len;
amqp_bytes_t encoded;
switch (frame->frame_type) {
case AMQP_FRAME_METHOD:
amqp_e32(out_frame, HEADER_SIZE, frame->payload.method.id);
encoded.bytes = amqp_offset(out_frame, HEADER_SIZE + 4);
encoded.len = state->outbound_buffer.len - HEADER_SIZE - 4 - FOOTER_SIZE;
res = amqp_encode_method(frame->payload.method.id,
frame->payload.method.decoded, encoded);
if (res < 0) {
return res;
}
out_frame_len = res + 4;
break;
case AMQP_FRAME_HEADER:
amqp_e16(out_frame, HEADER_SIZE, frame->payload.properties.class_id);
amqp_e16(out_frame, HEADER_SIZE+2, 0); /* "weight" */
amqp_e64(out_frame, HEADER_SIZE+4, frame->payload.properties.body_size);
encoded.bytes = amqp_offset(out_frame, HEADER_SIZE + 12);
encoded.len = state->outbound_buffer.len - HEADER_SIZE - 12 - FOOTER_SIZE;
res = amqp_encode_properties(frame->payload.properties.class_id,
frame->payload.properties.decoded, encoded);
if (res < 0) {
return res;
}
out_frame_len = res + 12;
break;
case AMQP_FRAME_HEARTBEAT:
out_frame_len = 0;
break;
default:
return AMQP_STATUS_INVALID_PARAMETER;
}
amqp_e32(out_frame, 3, out_frame_len);
amqp_e8(out_frame, out_frame_len + HEADER_SIZE, AMQP_FRAME_END);
res = amqp_socket_send(state->socket, out_frame,
out_frame_len + HEADER_SIZE + FOOTER_SIZE);
}
if (state->heartbeat > 0) {
uint64_t current_time = amqp_get_monotonic_timestamp();
if (0 == current_time) {
return AMQP_STATUS_TIMER_FAILURE;
}
state->next_send_heartbeat = amqp_calc_next_send_heartbeat(state, current_time);
}
return res;
}
int amqp_handle_input(amqp_connection_state_t state,
amqp_bytes_t received_data,
amqp_frame_t *decoded_frame)
{
size_t bytes_consumed;
void *raw_frame;
/* Returning frame_type of zero indicates either insufficient input,
or a complete, ignored frame was read. */
decoded_frame->frame_type = 0;
if (received_data.len == 0) {
return AMQP_STATUS_OK;
}
if (state->state == CONNECTION_STATE_IDLE) {
state->state = CONNECTION_STATE_HEADER;
}
bytes_consumed = consume_data(state, &received_data);
/* do we have target_size data yet? if not, return with the
expectation that more will arrive */
if (state->inbound_offset < state->target_size) {
return bytes_consumed;
}
raw_frame = state->inbound_buffer.bytes;
switch (state->state) {
case CONNECTION_STATE_INITIAL:
/* check for a protocol header from the server */
if (memcmp(raw_frame, "AMQP", 4) == 0) {
decoded_frame->frame_type = AMQP_PSEUDOFRAME_PROTOCOL_HEADER;
decoded_frame->channel = 0;
decoded_frame->payload.protocol_header.transport_high
= amqp_d8(raw_frame, 4);
decoded_frame->payload.protocol_header.transport_low
= amqp_d8(raw_frame, 5);
decoded_frame->payload.protocol_header.protocol_version_major
= amqp_d8(raw_frame, 6);
decoded_frame->payload.protocol_header.protocol_version_minor
= amqp_d8(raw_frame, 7);
return_to_idle(state);
return bytes_consumed;
}
/* it's not a protocol header; fall through to process it as a
regular frame header */
case CONNECTION_STATE_HEADER: {
amqp_channel_t channel;
amqp_pool_t *channel_pool;
/* frame length is 3 bytes in */
channel = amqp_d16(raw_frame, 1);
state->target_size
= amqp_d32(raw_frame, 3) + HEADER_SIZE + FOOTER_SIZE;
if ((size_t)state->frame_max < state->target_size) {
return AMQP_STATUS_BAD_AMQP_DATA;
}
channel_pool = amqp_get_or_create_channel_pool(state, channel);
if (NULL == channel_pool) {
return AMQP_STATUS_NO_MEMORY;
}
amqp_pool_alloc_bytes(channel_pool, state->target_size, &state->inbound_buffer);
if (NULL == state->inbound_buffer.bytes) {
return AMQP_STATUS_NO_MEMORY;
}
memcpy(state->inbound_buffer.bytes, state->header_buffer, HEADER_SIZE);
raw_frame = state->inbound_buffer.bytes;
state->state = CONNECTION_STATE_BODY;
bytes_consumed += consume_data(state, &received_data);
/* do we have target_size data yet? if not, return with the
expectation that more will arrive */
if (state->inbound_offset < state->target_size) {
return bytes_consumed;
}
}
/* fall through to process body */
case CONNECTION_STATE_BODY: {
amqp_bytes_t encoded;
int res;
amqp_pool_t *channel_pool;
/* Check frame end marker (footer) */
if (amqp_d8(raw_frame, state->target_size - 1) != AMQP_FRAME_END) {
return AMQP_STATUS_BAD_AMQP_DATA;
}
decoded_frame->frame_type = amqp_d8(raw_frame, 0);
decoded_frame->channel = amqp_d16(raw_frame, 1);
channel_pool = amqp_get_or_create_channel_pool(state, decoded_frame->channel);
if (NULL == channel_pool) {
return AMQP_STATUS_NO_MEMORY;
}
switch (decoded_frame->frame_type) {
case AMQP_FRAME_METHOD:
decoded_frame->payload.method.id = amqp_d32(raw_frame, HEADER_SIZE);
encoded.bytes = amqp_offset(raw_frame, HEADER_SIZE + 4);
encoded.len = state->target_size - HEADER_SIZE - 4 - FOOTER_SIZE;
res = amqp_decode_method(decoded_frame->payload.method.id,
channel_pool, encoded,
&decoded_frame->payload.method.decoded);
if (res < 0) {
return res;
}
break;
case AMQP_FRAME_HEADER:
decoded_frame->payload.properties.class_id
= amqp_d16(raw_frame, HEADER_SIZE);
/* unused 2-byte weight field goes here */
decoded_frame->payload.properties.body_size
= amqp_d64(raw_frame, HEADER_SIZE + 4);
encoded.bytes = amqp_offset(raw_frame, HEADER_SIZE + 12);
encoded.len = state->target_size - HEADER_SIZE - 12 - FOOTER_SIZE;
decoded_frame->payload.properties.raw = encoded;
res = amqp_decode_properties(decoded_frame->payload.properties.class_id,
channel_pool, encoded,
&decoded_frame->payload.properties.decoded);
if (res < 0) {
return res;
}
break;
case AMQP_FRAME_BODY:
decoded_frame->payload.body_fragment.len
= state->target_size - HEADER_SIZE - FOOTER_SIZE;
decoded_frame->payload.body_fragment.bytes
= amqp_offset(raw_frame, HEADER_SIZE);
break;
case AMQP_FRAME_HEARTBEAT:
break;
default:
/* Ignore the frame */
decoded_frame->frame_type = 0;
break;
}
return_to_idle(state);
return bytes_consumed;
}
default:
amqp_abort("Internal error: invalid amqp_connection_state_t->state %d", state->state);
return bytes_consumed;
}
}
int amqp_basic_publish(amqp_connection_state_t state,
amqp_channel_t channel,
amqp_bytes_t exchange,
amqp_bytes_t routing_key,
amqp_boolean_t mandatory,
amqp_boolean_t immediate,
amqp_basic_properties_t const *properties,
amqp_bytes_t body)
{
amqp_frame_t f;
size_t body_offset;
size_t usable_body_payload_size = state->frame_max - (HEADER_SIZE + FOOTER_SIZE);
int res;
amqp_basic_publish_t m;
amqp_basic_properties_t default_properties;
m.exchange = exchange;
m.routing_key = routing_key;
m.mandatory = mandatory;
m.immediate = immediate;
m.ticket = 0;
res = amqp_send_method(state, channel, AMQP_BASIC_PUBLISH_METHOD, &m);
if (res < 0) {
return res;
}
if (properties == NULL) {
memset(&default_properties, 0, sizeof(default_properties));
properties = &default_properties;
}
f.frame_type = AMQP_FRAME_HEADER;
f.channel = channel;
f.payload.properties.class_id = AMQP_BASIC_CLASS;
f.payload.properties.body_size = body.len;
f.payload.properties.decoded = (void *) properties;
res = amqp_send_frame(state, &f);
if (res < 0) {
return res;
}
body_offset = 0;
while (body_offset < body.len) {
size_t remaining = body.len - body_offset;
if (remaining == 0) {
break;
}
f.frame_type = AMQP_FRAME_BODY;
f.channel = channel;
f.payload.body_fragment.bytes = amqp_offset(body.bytes, body_offset);
if (remaining >= usable_body_payload_size) {
f.payload.body_fragment.len = usable_body_payload_size;
} else {
f.payload.body_fragment.len = remaining;
}
body_offset += f.payload.body_fragment.len;
res = amqp_send_frame(state, &f);
if (res < 0) {
return res;
}
}
return 0;
}
int amqp_send_frame(amqp_connection_state_t state,
const amqp_frame_t *frame)
{
void *out_frame = state->outbound_buffer.bytes;
int res;
amqp_e8(out_frame, 0, frame->frame_type);
amqp_e16(out_frame, 1, frame->channel);
if (frame->frame_type == AMQP_FRAME_BODY) {
/* For a body frame, rather than copying data around, we use
writev to compose the frame */
struct iovec iov[3];
uint8_t frame_end_byte = AMQP_FRAME_END;
const amqp_bytes_t *body = &frame->payload.body_fragment;
amqp_e32(out_frame, 3, body->len);
iov[0].iov_base = out_frame;
iov[0].iov_len = HEADER_SIZE;
iov[1].iov_base = body->bytes;
iov[1].iov_len = body->len;
iov[2].iov_base = &frame_end_byte;
iov[2].iov_len = FOOTER_SIZE;
res = amqp_socket_writev(state->sockfd, iov, 3);
}
else {
size_t out_frame_len;
amqp_bytes_t encoded;
switch (frame->frame_type) {
case AMQP_FRAME_METHOD:
amqp_e32(out_frame, HEADER_SIZE, frame->payload.method.id);
encoded.bytes = amqp_offset(out_frame, HEADER_SIZE + 4);
encoded.len = state->outbound_buffer.len - HEADER_SIZE - 4 - FOOTER_SIZE;
res = amqp_encode_method(frame->payload.method.id,
frame->payload.method.decoded, encoded);
if (res < 0)
return res;
out_frame_len = res + 4;
break;
case AMQP_FRAME_HEADER:
amqp_e16(out_frame, HEADER_SIZE, frame->payload.properties.class_id);
amqp_e16(out_frame, HEADER_SIZE+2, 0); /* "weight" */
amqp_e64(out_frame, HEADER_SIZE+4, frame->payload.properties.body_size);
encoded.bytes = amqp_offset(out_frame, HEADER_SIZE + 12);
encoded.len = state->outbound_buffer.len - HEADER_SIZE - 12 - FOOTER_SIZE;
res = amqp_encode_properties(frame->payload.properties.class_id,
frame->payload.properties.decoded, encoded);
if (res < 0)
return res;
out_frame_len = res + 12;
break;
case AMQP_FRAME_HEARTBEAT:
out_frame_len = 0;
break;
default:
abort();
}
amqp_e32(out_frame, 3, out_frame_len);
amqp_e8(out_frame, out_frame_len + HEADER_SIZE, AMQP_FRAME_END);
res = send(state->sockfd, out_frame,
out_frame_len + HEADER_SIZE + FOOTER_SIZE, 0);
}
if (res < 0)
return -amqp_socket_error();
else
return 0;
}
int amqp_handle_input(amqp_connection_state_t state,
amqp_bytes_t received_data,
amqp_frame_t *decoded_frame)
{
size_t bytes_consumed;
void *raw_frame;
/* Returning frame_type of zero indicates either insufficient input,
or a complete, ignored frame was read. */
decoded_frame->frame_type = 0;
if (received_data.len == 0)
return 0;
if (state->state == CONNECTION_STATE_IDLE) {
state->inbound_buffer.bytes = amqp_pool_alloc(&state->frame_pool,
state->inbound_buffer.len);
if (state->inbound_buffer.bytes == NULL)
/* state->inbound_buffer.len is always nonzero, because it
corresponds to frame_max, which is not permitted to be less
than AMQP_FRAME_MIN_SIZE (currently 4096 bytes). */
return -ERROR_NO_MEMORY;
state->state = CONNECTION_STATE_HEADER;
}
bytes_consumed = consume_data(state, &received_data);
/* do we have target_size data yet? if not, return with the
expectation that more will arrive */
if (state->inbound_offset < state->target_size)
return bytes_consumed;
raw_frame = state->inbound_buffer.bytes;
switch (state->state) {
case CONNECTION_STATE_INITIAL:
/* check for a protocol header from the server */
if (memcmp(raw_frame, "AMQP", 4) == 0) {
decoded_frame->frame_type = AMQP_PSEUDOFRAME_PROTOCOL_HEADER;
decoded_frame->channel = 0;
decoded_frame->payload.protocol_header.transport_high
= amqp_d8(raw_frame, 4);
decoded_frame->payload.protocol_header.transport_low
= amqp_d8(raw_frame, 5);
decoded_frame->payload.protocol_header.protocol_version_major
= amqp_d8(raw_frame, 6);
decoded_frame->payload.protocol_header.protocol_version_minor
= amqp_d8(raw_frame, 7);
return_to_idle(state);
return bytes_consumed;
}
/* it's not a protocol header; fall through to process it as a
regular frame header */
case CONNECTION_STATE_HEADER:
/* frame length is 3 bytes in */
state->target_size
= amqp_d32(raw_frame, 3) + HEADER_SIZE + FOOTER_SIZE;
state->state = CONNECTION_STATE_BODY;
bytes_consumed += consume_data(state, &received_data);
/* do we have target_size data yet? if not, return with the
expectation that more will arrive */
if (state->inbound_offset < state->target_size)
return bytes_consumed;
/* fall through to process body */
case CONNECTION_STATE_BODY: {
amqp_bytes_t encoded;
int res;
/* Check frame end marker (footer) */
if (amqp_d8(raw_frame, state->target_size - 1) != AMQP_FRAME_END)
return -ERROR_BAD_AMQP_DATA;
decoded_frame->frame_type = amqp_d8(raw_frame, 0);
decoded_frame->channel = amqp_d16(raw_frame, 1);
switch (decoded_frame->frame_type) {
case AMQP_FRAME_METHOD:
decoded_frame->payload.method.id = amqp_d32(raw_frame, HEADER_SIZE);
encoded.bytes = amqp_offset(raw_frame, HEADER_SIZE + 4);
encoded.len = state->target_size - HEADER_SIZE - 4 - FOOTER_SIZE;
res = amqp_decode_method(decoded_frame->payload.method.id,
&state->decoding_pool, encoded,
&decoded_frame->payload.method.decoded);
if (res < 0)
return res;
break;
case AMQP_FRAME_HEADER:
decoded_frame->payload.properties.class_id
= amqp_d16(raw_frame, HEADER_SIZE);
/* unused 2-byte weight field goes here */
decoded_frame->payload.properties.body_size
= amqp_d64(raw_frame, HEADER_SIZE + 4);
encoded.bytes = amqp_offset(raw_frame, HEADER_SIZE + 12);
encoded.len = state->target_size - HEADER_SIZE - 12 - FOOTER_SIZE;
decoded_frame->payload.properties.raw = encoded;
res = amqp_decode_properties(decoded_frame->payload.properties.class_id,
&state->decoding_pool, encoded,
&decoded_frame->payload.properties.decoded);
if (res < 0)
return res;
break;
case AMQP_FRAME_BODY:
decoded_frame->payload.body_fragment.len
= state->target_size - HEADER_SIZE - FOOTER_SIZE;
decoded_frame->payload.body_fragment.bytes
= amqp_offset(raw_frame, HEADER_SIZE);
break;
case AMQP_FRAME_HEARTBEAT:
break;
default:
/* Ignore the frame */
decoded_frame->frame_type = 0;
break;
}
return_to_idle(state);
if (decoded_frame->frame_type == AMQP_FRAME_METHOD) {
if (decoded_frame->payload.method.id == AMQP_BASIC_RETURN_METHOD) {
amqp_basic_return_t *m = decoded_frame->payload.method.decoded;
if(state->basic_return_callback)
state->basic_return_callback(decoded_frame->channel, m,
state->basic_return_callback_data);
}
else if (decoded_frame->payload.method.id == AMQP_CHANNEL_CLOSE_METHOD) {
amqp_channel_close_t *m = decoded_frame->payload.method.decoded;
if (state->channel_close_callback)
state->channel_close_callback(decoded_frame->channel, m,
state->channel_close_callback_data);
}
}
return bytes_consumed;
}
default:
amqp_abort("Internal error: invalid amqp_connection_state_t->state %d", state->state);
return bytes_consumed;
}
}
static int amqp_frame_to_bytes(const amqp_frame_t *frame, amqp_bytes_t buffer,
amqp_bytes_t *encoded) {
void *out_frame = buffer.bytes;
size_t out_frame_len;
int res;
amqp_e8(out_frame, 0, frame->frame_type);
amqp_e16(out_frame, 1, frame->channel);
switch (frame->frame_type) {
case AMQP_FRAME_BODY: {
const amqp_bytes_t *body = &frame->payload.body_fragment;
memcpy(amqp_offset(out_frame, HEADER_SIZE), body->bytes, body->len);
out_frame_len = body->len;
break;
}
case AMQP_FRAME_METHOD: {
amqp_bytes_t method_encoded;
amqp_e32(out_frame, HEADER_SIZE, frame->payload.method.id);
method_encoded.bytes = amqp_offset(out_frame, HEADER_SIZE + 4);
method_encoded.len = buffer.len - HEADER_SIZE - 4 - FOOTER_SIZE;
res = amqp_encode_method(frame->payload.method.id,
frame->payload.method.decoded, method_encoded);
if (res < 0) {
return res;
}
out_frame_len = res + 4;
break;
}
case AMQP_FRAME_HEADER:
amqp_e16(out_frame, HEADER_SIZE, frame->payload.properties.class_id);
amqp_e16(out_frame, HEADER_SIZE + 2, 0); /* "weight" */
amqp_e64(out_frame, HEADER_SIZE + 4, frame->payload.properties.body_size);
encoded->bytes = amqp_offset(out_frame, HEADER_SIZE + 12);
encoded->len = buffer.len - HEADER_SIZE - 12 - FOOTER_SIZE;
res = amqp_encode_properties(frame->payload.properties.class_id,
frame->payload.properties.decoded, *encoded);
if (res < 0) {
return res;
}
out_frame_len = res + 12;
break;
case AMQP_FRAME_HEARTBEAT:
out_frame_len = 0;
break;
default:
return AMQP_STATUS_INVALID_PARAMETER;
}
amqp_e32(out_frame, 3, (uint32_t)out_frame_len);
amqp_e8(out_frame, HEADER_SIZE + out_frame_len, AMQP_FRAME_END);
encoded->bytes = out_frame;
encoded->len = out_frame_len + HEADER_SIZE + FOOTER_SIZE;
return AMQP_STATUS_OK;
}
