A small memory footprint AMQP implimentation
Dependents: iothub_client_sample_amqp remote_monitoring simplesample_amqp
Diff: link.c
- Revision:
- 0:6ae2f7bca550
- Child:
- 1:eab586236bfe
diff -r 000000000000 -r 6ae2f7bca550 link.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/link.c Fri Apr 08 12:01:10 2016 -0700 @@ -0,0 +1,989 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +#include <stdlib.h> +#ifdef _CRTDBG_MAP_ALLOC +#include <crtdbg.h> +#endif +#include <string.h> +#include <stdint.h> +#include <stdbool.h> +#include "azure_uamqp_c/link.h" +#include "azure_uamqp_c/session.h" +#include "azure_uamqp_c/amqpvalue.h" +#include "azure_uamqp_c/amqp_definitions.h" +#include "azure_uamqp_c/amqpalloc.h" +#include "azure_uamqp_c/amqp_frame_codec.h" +#include "azure_uamqp_c/consolelogger.h" +#include "azure_c_shared_utility/xlogging.h" +#include "azure_c_shared_utility/list.h" + +#define DEFAULT_LINK_CREDIT 10000 + +typedef struct DELIVERY_INSTANCE_TAG +{ + delivery_number delivery_id; + ON_DELIVERY_SETTLED on_delivery_settled; + void* callback_context; + void* link; +} DELIVERY_INSTANCE; + +typedef struct LINK_INSTANCE_TAG +{ + SESSION_HANDLE session; + LINK_STATE link_state; + LINK_STATE previous_link_state; + AMQP_VALUE source; + AMQP_VALUE target; + handle handle; + LINK_ENDPOINT_HANDLE link_endpoint; + char* name; + LIST_HANDLE pending_deliveries; + sequence_no delivery_count; + role role; + ON_LINK_STATE_CHANGED on_link_state_changed; + ON_LINK_FLOW_ON on_link_flow_on; + ON_TRANSFER_RECEIVED on_transfer_received; + void* callback_context; + sender_settle_mode snd_settle_mode; + receiver_settle_mode rcv_settle_mode; + sequence_no initial_delivery_count; + uint64_t max_message_size; + uint32_t link_credit; + uint32_t available; + fields attach_properties; + unsigned char is_underlying_session_begun : 1; +} LINK_INSTANCE; + +static void set_link_state(LINK_INSTANCE* link_instance, LINK_STATE link_state) +{ + link_instance->previous_link_state = link_instance->link_state; + link_instance->link_state = link_state; + + if (link_instance->on_link_state_changed != NULL) + { + link_instance->on_link_state_changed(link_instance->callback_context, link_state, link_instance->previous_link_state); + } +} + +static int send_flow(LINK_INSTANCE* link) +{ + int result; + FLOW_HANDLE flow = flow_create(0, 0, 0); + + if (flow == NULL) + { + result = __LINE__; + } + else + { + if ((flow_set_link_credit(flow, link->link_credit) != 0) || + (flow_set_handle(flow, link->handle) != 0) || + (flow_set_delivery_count(flow, link->delivery_count) != 0)) + { + result = __LINE__; + } + else + { + if (session_send_flow(link->link_endpoint, flow) != 0) + { + result = __LINE__; + } + else + { + result = 0; + } + } + + flow_destroy(flow); + } + + return result; +} + +static int send_disposition(LINK_INSTANCE* link_instance, delivery_number delivery_number, AMQP_VALUE delivery_state) +{ + int result; + + DISPOSITION_HANDLE disposition = disposition_create(link_instance->role, delivery_number); + if (disposition == NULL) + { + result = __LINE__; + } + else + { + if ((disposition_set_last(disposition, delivery_number) != 0) || + (disposition_set_settled(disposition, true) != 0) || + ((delivery_state != NULL) && (disposition_set_state(disposition, delivery_state) != 0))) + { + result = __LINE__; + } + else + { + if (session_send_disposition(link_instance->link_endpoint, disposition) != 0) + { + result = __LINE__; + } + else + { + result = 0; + } + } + + disposition_destroy(disposition); + } + + return result; +} + +static int send_detach_frame(LINK_INSTANCE* link_instance, ERROR_HANDLE error_handle) +{ + int result; + DETACH_HANDLE detach_performative; + + detach_performative = detach_create(0); + if (detach_performative == NULL) + { + result = __LINE__; + } + else + { + if ((error_handle != NULL) && + (detach_set_error(detach_performative, error_handle) != 0)) + { + result = __LINE__; + } + else + { + if (session_send_detach(link_instance->link_endpoint, detach_performative) != 0) + { + result = __LINE__; + } + else + { + result = 0; + } + } + + detach_destroy(detach_performative); + } + + return result; +} + +static void link_frame_received(void* context, AMQP_VALUE performative, uint32_t payload_size, const unsigned char* payload_bytes) +{ + LINK_INSTANCE* link_instance = (LINK_INSTANCE*)context; + AMQP_VALUE descriptor = amqpvalue_get_inplace_descriptor(performative); + + if (is_attach_type_by_descriptor(descriptor)) + { + ATTACH_HANDLE attach_handle; + if (amqpvalue_get_attach(performative, &attach_handle) == 0) + { + if ((link_instance->role == role_receiver) && + (attach_get_initial_delivery_count(attach_handle, &link_instance->delivery_count) != 0)) + { + /* error */ + set_link_state(link_instance, LINK_STATE_DETACHED); + } + else + { + if (link_instance->link_state == LINK_STATE_HALF_ATTACHED) + { + if (link_instance->role == role_receiver) + { + link_instance->link_credit = DEFAULT_LINK_CREDIT; + send_flow(link_instance); + } + else + { + link_instance->link_credit = 0; + } + + set_link_state(link_instance, LINK_STATE_ATTACHED); + } + } + + attach_destroy(attach_handle); + } + } + else if (is_flow_type_by_descriptor(descriptor)) + { + FLOW_HANDLE flow_handle; + if (amqpvalue_get_flow(performative, &flow_handle) == 0) + { + if (link_instance->role == role_sender) + { + delivery_number rcv_delivery_count; + uint32_t rcv_link_credit; + + if ((flow_get_link_credit(flow_handle, &rcv_link_credit) != 0) || + (flow_get_delivery_count(flow_handle, &rcv_delivery_count) != 0)) + { + /* error */ + set_link_state(link_instance, LINK_STATE_DETACHED); + } + else + { + link_instance->link_credit = rcv_delivery_count + rcv_link_credit - link_instance->delivery_count; + if (link_instance->link_credit > 0) + { + link_instance->on_link_flow_on(link_instance->callback_context); + } + } + } + } + + flow_destroy(flow_handle); + } + else if (is_transfer_type_by_descriptor(descriptor)) + { + if (link_instance->on_transfer_received != NULL) + { + TRANSFER_HANDLE transfer_handle; + if (amqpvalue_get_transfer(performative, &transfer_handle) == 0) + { + AMQP_VALUE delivery_state; + delivery_number received_delivery_id; + + link_instance->link_credit--; + link_instance->delivery_count++; + if (link_instance->link_credit == 0) + { + link_instance->link_credit = DEFAULT_LINK_CREDIT; + send_flow(link_instance); + } + + if (transfer_get_delivery_id(transfer_handle, &received_delivery_id) != 0) + { + /* error */ + } + else + { + delivery_state = link_instance->on_transfer_received(link_instance->callback_context, transfer_handle, payload_size, payload_bytes); + + if (send_disposition(link_instance, received_delivery_id, delivery_state) != 0) + { + /* error */ + } + + if (delivery_state != NULL) + { + amqpvalue_destroy(delivery_state); + } + } + + transfer_destroy(transfer_handle); + } + } + } + else if (is_disposition_type_by_descriptor(descriptor)) + { + DISPOSITION_HANDLE disposition; + if (amqpvalue_get_disposition(performative, &disposition) != 0) + { + /* error */ + } + else + { + delivery_number first; + delivery_number last; + + if (disposition_get_first(disposition, &first) != 0) + { + /* error */ + } + else + { + bool settled; + + if (disposition_get_last(disposition, &last) != 0) + { + last = first; + } + + if (disposition_get_settled(disposition, &settled) != 0) + { + /* Error */ + settled = false; + } + + if (settled) + { + LIST_ITEM_HANDLE pending_delivery = list_get_head_item(link_instance->pending_deliveries); + while (pending_delivery != NULL) + { + LIST_ITEM_HANDLE next_pending_delivery = list_get_next_item(pending_delivery); + DELIVERY_INSTANCE* delivery_instance = (DELIVERY_INSTANCE*)list_item_get_value(pending_delivery); + if (delivery_instance == NULL) + { + /* error */ + break; + } + else + { + if ((delivery_instance->delivery_id >= first) && (delivery_instance->delivery_id <= last)) + { + delivery_instance->on_delivery_settled(delivery_instance->callback_context, delivery_instance->delivery_id); + amqpalloc_free(delivery_instance); + if (list_remove(link_instance->pending_deliveries, pending_delivery) != 0) + { + /* error */ + break; + } + else + { + pending_delivery = next_pending_delivery; + } + } + else + { + pending_delivery = next_pending_delivery; + } + } + } + } + } + + disposition_destroy(disposition); + } + } + else if (is_detach_type_by_descriptor(descriptor)) + { + if (send_detach_frame(link_instance, NULL) != 0) + { + /* error */ + } + } +} + +static int send_attach(LINK_INSTANCE* link, const char* name, handle handle, role role) +{ + int result; + ATTACH_HANDLE attach = attach_create(name, handle, role); + + if (attach == NULL) + { + result = __LINE__; + } + else + { + result = 0; + + link->delivery_count = link->initial_delivery_count; + + attach_set_snd_settle_mode(attach, link->snd_settle_mode); + attach_set_rcv_settle_mode(attach, link->rcv_settle_mode); + attach_set_role(attach, role); + attach_set_source(attach, link->source); + attach_set_target(attach, link->target); + attach_set_properties(attach, link->attach_properties); + + if (role == role_sender) + { + if (attach_set_initial_delivery_count(attach, link->delivery_count) != 0) + { + result = __LINE__; + } + } + + if (result == 0) + { + if ((attach_set_max_message_size(attach, link->max_message_size) != 0) || + (session_send_attach(link->link_endpoint, attach) != 0)) + { + result = __LINE__; + } + else + { + result = 0; + } + } + + attach_destroy(attach); + } + + return result; +} + +static int send_detach(LINK_INSTANCE* link_instance, ERROR_HANDLE error) +{ + int result; + + DETACH_HANDLE detach = detach_create(0); + if (detach == NULL) + { + result = __LINE__; + } + else + { + if (((error != NULL) && (detach_set_error(detach, error) != 0)) || + (session_send_detach(link_instance->link_endpoint, detach) != 0)) + { + result = __LINE__; + } + else + { + result = 0; + } + + detach_destroy(detach); + } + + return result; +} + +static void on_session_state_changed(void* context, SESSION_STATE new_session_state, SESSION_STATE previous_session_state) +{ + LINK_INSTANCE* link_instance = (LINK_INSTANCE*)context; + + if (new_session_state == SESSION_STATE_MAPPED) + { + if (link_instance->link_state == LINK_STATE_DETACHED) + { + if (send_attach(link_instance, link_instance->name, 0, link_instance->role) == 0) + { + set_link_state(link_instance, LINK_STATE_HALF_ATTACHED); + } + } + } + else if (new_session_state == SESSION_STATE_DISCARDING) + { + set_link_state(link_instance, LINK_STATE_DETACHED); + } +} + +static void on_session_flow_on(void* context) +{ + LINK_INSTANCE* link_instance = (LINK_INSTANCE*)context; + if (link_instance->role == role_sender) + { + link_instance->on_link_flow_on(link_instance->callback_context); + } +} + +static void on_send_complete(void* context, IO_SEND_RESULT send_result) +{ + LIST_ITEM_HANDLE delivery_instance_list_item = (LIST_ITEM_HANDLE)context; + DELIVERY_INSTANCE* delivery_instance = (DELIVERY_INSTANCE*)list_item_get_value(delivery_instance_list_item); + LINK_INSTANCE* link_instance = (LINK_INSTANCE*)delivery_instance->link; + if (link_instance->snd_settle_mode == sender_settle_mode_settled) + { + delivery_instance->on_delivery_settled(delivery_instance->callback_context, delivery_instance->delivery_id); + amqpalloc_free(delivery_instance); + (void)list_remove(link_instance->pending_deliveries, delivery_instance_list_item); + } +} + +LINK_HANDLE link_create(SESSION_HANDLE session, const char* name, role role, AMQP_VALUE source, AMQP_VALUE target) +{ + LINK_INSTANCE* result = amqpalloc_malloc(sizeof(LINK_INSTANCE)); + if (result != NULL) + { + result->link_state = LINK_STATE_DETACHED; + result->previous_link_state = LINK_STATE_DETACHED; + result->role = role; + result->source = amqpvalue_clone(source); + result->target = amqpvalue_clone(target); + result->session = session; + result->handle = 0; + result->snd_settle_mode = sender_settle_mode_unsettled; + result->rcv_settle_mode = receiver_settle_mode_first; + result->delivery_count = 0; + result->initial_delivery_count = 0; + result->max_message_size = 0; + result->is_underlying_session_begun = 0; + result->attach_properties = NULL; + + result->pending_deliveries = list_create(); + if (result->pending_deliveries == NULL) + { + amqpalloc_free(result); + result = NULL; + } + else + { + result->name = amqpalloc_malloc(strlen(name) + 1); + if (result->name == NULL) + { + list_destroy(result->pending_deliveries); + amqpalloc_free(result); + result = NULL; + } + else + { + result->on_link_state_changed = NULL; + result->callback_context = NULL; + set_link_state(result, LINK_STATE_DETACHED); + + (void)strcpy(result->name, name); + result->link_endpoint = session_create_link_endpoint(session, name); + if (result->link_endpoint == NULL) + { + list_destroy(result->pending_deliveries); + amqpalloc_free(result->name); + amqpalloc_free(result); + result = NULL; + } + } + } + } + + return result; +} + +LINK_HANDLE link_create_from_endpoint(SESSION_HANDLE session, LINK_ENDPOINT_HANDLE link_endpoint, const char* name, role role, AMQP_VALUE source, AMQP_VALUE target) +{ + LINK_INSTANCE* result = amqpalloc_malloc(sizeof(LINK_INSTANCE)); + if (result != NULL) + { + result->link_state = LINK_STATE_DETACHED; + result->previous_link_state = LINK_STATE_DETACHED; + result->session = session; + result->handle = 0; + result->snd_settle_mode = sender_settle_mode_unsettled; + result->rcv_settle_mode = receiver_settle_mode_first; + result->delivery_count = 0; + result->initial_delivery_count = 0; + result->max_message_size = 0; + result->is_underlying_session_begun = 0; + result->attach_properties = NULL; + result->source = amqpvalue_clone(target); + result->target = amqpvalue_clone(source); + if (role == role_sender) + { + result->role = role_receiver; + } + else + { + result->role = role_sender; + } + + result->pending_deliveries = list_create(); + if (result->pending_deliveries == NULL) + { + amqpalloc_free(result); + result = NULL; + } + else + { + result->name = amqpalloc_malloc(strlen(name) + 1); + if (result->name == NULL) + { + list_destroy(result->pending_deliveries); + amqpalloc_free(result); + result = NULL; + } + else + { + (void)strcpy(result->name, name); + result->on_link_state_changed = NULL; + result->callback_context = NULL; + result->link_endpoint = link_endpoint; + } + } + } + + return result; +} + +void link_destroy(LINK_HANDLE link) +{ + if (link != NULL) + { + link_detach(link); + + session_destroy_link_endpoint(link->link_endpoint); + amqpvalue_destroy(link->source); + amqpvalue_destroy(link->target); + if (link->pending_deliveries != NULL) + { + LIST_ITEM_HANDLE item = list_get_head_item(link->pending_deliveries); + while (item != NULL) + { + LIST_ITEM_HANDLE next_item = list_get_next_item(item); + DELIVERY_INSTANCE* delivery_instance = (DELIVERY_INSTANCE*)list_item_get_value(item); + if (delivery_instance != NULL) + { + amqpalloc_free(delivery_instance); + } + + item = next_item; + } + + list_destroy(link->pending_deliveries); + } + + if (link->name != NULL) + { + amqpalloc_free(link->name); + } + + if (link->attach_properties != NULL) + { + amqpvalue_destroy(link->attach_properties); + } + + amqpalloc_free(link); + } +} + +int link_set_snd_settle_mode(LINK_HANDLE link, sender_settle_mode snd_settle_mode) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + link->snd_settle_mode = snd_settle_mode; + result = 0; + } + + return result; +} + +int link_get_snd_settle_mode(LINK_HANDLE link, sender_settle_mode* snd_settle_mode) +{ + int result; + + if ((link == NULL) || + (snd_settle_mode == NULL)) + { + result = __LINE__; + } + else + { + *snd_settle_mode = link->snd_settle_mode; + + result = 0; + } + + return result; +} + +int link_set_rcv_settle_mode(LINK_HANDLE link, receiver_settle_mode rcv_settle_mode) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + link->rcv_settle_mode = rcv_settle_mode; + result = 0; + } + + return result; +} + +int link_get_rcv_settle_mode(LINK_HANDLE link, receiver_settle_mode* rcv_settle_mode) +{ + int result; + + if ((link == NULL) || + (rcv_settle_mode == NULL)) + { + result = __LINE__; + } + else + { + *rcv_settle_mode = link->rcv_settle_mode; + result = 0; + } + + return result; +} + +int link_set_initial_delivery_count(LINK_HANDLE link, sequence_no initial_delivery_count) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + link->initial_delivery_count = initial_delivery_count; + result = 0; + } + + return result; +} + +int link_get_initial_delivery_count(LINK_HANDLE link, sequence_no* initial_delivery_count) +{ + int result; + + if ((link == NULL) || + (initial_delivery_count == NULL)) + { + result = __LINE__; + } + else + { + *initial_delivery_count = link->initial_delivery_count; + result = 0; + } + + return result; +} + +int link_set_max_message_size(LINK_HANDLE link, uint64_t max_message_size) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + link->max_message_size = max_message_size; + result = 0; + } + + return result; +} + +int link_get_max_message_size(LINK_HANDLE link, uint64_t* max_message_size) +{ + int result; + + if ((link == NULL) || + (max_message_size == NULL)) + { + result = __LINE__; + } + else + { + *max_message_size = link->max_message_size; + result = 0; + } + + return result; +} + +int link_set_attach_properties(LINK_HANDLE link, fields attach_properties) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + link->attach_properties = amqpvalue_clone(attach_properties); + if (link->attach_properties == NULL) + { + result = __LINE__; + } + else + { + result = 0; + } + } + + return result; +} + +int link_attach(LINK_HANDLE link, ON_TRANSFER_RECEIVED on_transfer_received, ON_LINK_STATE_CHANGED on_link_state_changed, ON_LINK_FLOW_ON on_link_flow_on, void* callback_context) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + if (!link->is_underlying_session_begun) + { + link->on_link_state_changed = on_link_state_changed; + link->on_transfer_received = on_transfer_received; + link->on_link_flow_on = on_link_flow_on; + link->callback_context = callback_context; + + if (session_begin(link->session) != 0) + { + result = __LINE__; + } + else + { + link->is_underlying_session_begun = 1; + + if (session_start_link_endpoint(link->link_endpoint, link_frame_received, on_session_state_changed, on_session_flow_on, link) != 0) + { + result = __LINE__; + } + else + { + result = 0; + } + } + } + else + { + result = 0; + } + } + + return result; +} + +int link_detach(LINK_HANDLE link) +{ + int result; + + if (link == NULL) + { + result = __LINE__; + } + else + { + if ((link->link_state == LINK_STATE_HALF_ATTACHED) || + (link->link_state == LINK_STATE_ATTACHED)) + { + link->on_link_state_changed = NULL; + + if (send_detach(link, NULL) != 0) + { + result = __LINE__; + } + else + { + set_link_state(link, LINK_STATE_DETACHED); + result = 0; + } + } + else + { + set_link_state(link, LINK_STATE_DETACHED); + result = 0; + } + } + + return result; +} + +LINK_TRANSFER_RESULT link_transfer(LINK_HANDLE link, message_format message_format, PAYLOAD* payloads, size_t payload_count, ON_DELIVERY_SETTLED on_delivery_settled, void* callback_context) +{ + LINK_TRANSFER_RESULT result; + + if (link == NULL) + { + result = LINK_TRANSFER_ERROR; + } + else + { + if (link->role != role_sender) + { + result = LINK_TRANSFER_ERROR; + } + else if (link->link_credit == 0) + { + result = LINK_TRANSFER_BUSY; + } + else + { + TRANSFER_HANDLE transfer = transfer_create(0); + if (transfer == NULL) + { + result = LINK_TRANSFER_ERROR; + } + else + { + unsigned char delivery_tag_bytes[sizeof(link->delivery_count)]; + delivery_tag delivery_tag; + bool settled; + + (void)memcpy(delivery_tag_bytes, &link->delivery_count, sizeof(link->delivery_count)); + + link->delivery_count++; + + delivery_tag.bytes = &delivery_tag_bytes; + delivery_tag.length = sizeof(delivery_tag_bytes); + + if (link->snd_settle_mode == sender_settle_mode_unsettled) + { + settled = false; + } + else + { + settled = true; + } + + if ((transfer_set_delivery_tag(transfer, delivery_tag) != 0) || + (transfer_set_message_format(transfer, message_format) != 0) || + (transfer_set_settled(transfer, settled) != 0)) + { + result = LINK_TRANSFER_ERROR; + } + else + { + AMQP_VALUE transfer_value = amqpvalue_create_transfer(transfer); + + if (transfer_value == NULL) + { + result = LINK_TRANSFER_ERROR; + } + else + { + DELIVERY_INSTANCE* pending_delivery = amqpalloc_malloc(sizeof(DELIVERY_INSTANCE)); + if (pending_delivery == NULL) + { + result = LINK_TRANSFER_ERROR; + } + else + { + LIST_ITEM_HANDLE delivery_instance_list_item; + pending_delivery->on_delivery_settled = on_delivery_settled; + pending_delivery->callback_context = callback_context; + pending_delivery->link = link; + delivery_instance_list_item = list_add(link->pending_deliveries, pending_delivery); + + if (delivery_instance_list_item == NULL) + { + amqpalloc_free(pending_delivery); + result = LINK_TRANSFER_ERROR; + } + else + { + /* here we should feed data to the transfer frame */ + switch (session_send_transfer(link->link_endpoint, transfer, payloads, payload_count, &pending_delivery->delivery_id, (settled) ? on_send_complete : NULL, delivery_instance_list_item)) + { + default: + case SESSION_SEND_TRANSFER_ERROR: + result = LINK_TRANSFER_ERROR; + break; + + case SESSION_SEND_TRANSFER_BUSY: + result = LINK_TRANSFER_BUSY; + break; + + case SESSION_SEND_TRANSFER_OK: + link->link_credit--; + result = LINK_TRANSFER_OK; + break; + } + } + } + + amqpvalue_destroy(transfer_value); + } + } + + transfer_destroy(transfer); + } + } + } + + return result; +}