messaging.c

00001 // Copyright (c) Microsoft. All rights reserved.
00002 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
00003 
00004 #include <stdlib.h>
00005 #ifdef _CRTDBG_MAP_ALLOC
00006 #include <crtdbg.h>
00007 #endif
00008 #include <stdbool.h>
00009 #include "azure_uamqp_c/amqpvalue.h"
00010 #include "azure_uamqp_c/amqp_definitions.h"
00011 
00012 AMQP_VALUE messaging_create_source(const char* address)
00013 {
00014     AMQP_VALUE result;
00015     SOURCE_HANDLE source = source_create();
00016     if (source == NULL)
00017     {
00018         result = NULL;
00019     }
00020     else
00021     {
00022         AMQP_VALUE address_value = amqpvalue_create_string(address);
00023         if (address_value == NULL)
00024         {
00025             result = NULL;
00026         }
00027         else
00028         {
00029             if (source_set_address(source, address_value) != 0)
00030             {
00031                 result = NULL;
00032             }
00033             else
00034             {
00035                 result = amqpvalue_create_source(source);
00036             }
00037 
00038             amqpvalue_destroy(address_value);
00039         }
00040 
00041         source_destroy(source);
00042     }
00043 
00044     return result;
00045 }
00046 
00047 AMQP_VALUE messaging_create_target(const char* address)
00048 {
00049     AMQP_VALUE result;
00050     TARGET_HANDLE target = target_create();
00051     if (target == NULL)
00052     {
00053         result = NULL;
00054     }
00055     else
00056     {
00057         AMQP_VALUE address_value = amqpvalue_create_string(address);
00058         if (address_value == NULL)
00059         {
00060             result = NULL;
00061         }
00062         else
00063         {
00064             if (target_set_address(target, address_value) != 0)
00065             {
00066                 result = NULL;
00067             }
00068             else
00069             {
00070                 result = amqpvalue_create_target(target);
00071             }
00072 
00073             amqpvalue_destroy(address_value);
00074         }
00075 
00076         target_destroy(target);
00077     }
00078 
00079     return result;
00080 }
00081 
00082 AMQP_VALUE messaging_delivery_received(uint32_t section_number, uint64_t section_offset)
00083 {
00084     AMQP_VALUE result;
00085     RECEIVED_HANDLE received = received_create(section_number, section_offset);
00086     if (received == NULL)
00087     {
00088         result = NULL;
00089     }
00090     else
00091     {
00092         result = amqpvalue_create_received(received);
00093         received_destroy(received);
00094     }
00095 
00096     return result;
00097 }
00098 
00099 AMQP_VALUE messaging_delivery_accepted(void)
00100 {
00101     AMQP_VALUE result;
00102     ACCEPTED_HANDLE accepted = accepted_create();
00103     if (accepted == NULL)
00104     {
00105         result = NULL;
00106     }
00107     else
00108     {
00109         result = amqpvalue_create_accepted(accepted);
00110         accepted_destroy(accepted);
00111     }
00112 
00113     return result;
00114 }
00115 
00116 AMQP_VALUE messaging_delivery_rejected(const char* error_condition, const char* error_description)
00117 {
00118     AMQP_VALUE result;
00119     REJECTED_HANDLE rejected = rejected_create();
00120     if (rejected == NULL)
00121     {
00122         result = NULL;
00123     }
00124     else
00125     {
00126         ERROR_HANDLE error_handle = NULL;
00127         bool error_constructing = false;
00128 
00129         if (error_condition != NULL)
00130         {
00131             error_handle = error_create(error_condition);
00132             if (error_handle == NULL)
00133             {
00134                 error_constructing = true;
00135             }
00136             else
00137             {
00138                 if ((error_description != NULL) &&
00139                     (error_set_description(error_handle, error_description) != 0))
00140                 {
00141                     error_constructing = true;
00142                 }
00143                 else
00144                 {
00145                     if (rejected_set_error(rejected, error_handle) != 0)
00146                     {
00147                         error_constructing = true;
00148                     }
00149                 }
00150 
00151                 error_destroy(error_handle);
00152             }
00153         }
00154 
00155         if (error_constructing)
00156         {
00157             result = NULL;
00158         }
00159         else
00160         {
00161             result = amqpvalue_create_rejected(rejected);
00162         }
00163 
00164         rejected_destroy(rejected);
00165     }
00166 
00167     return result;
00168 }
00169 
00170 AMQP_VALUE messaging_delivery_released(void)
00171 {
00172     AMQP_VALUE result;
00173     RELEASED_HANDLE released = released_create();
00174     if (released == NULL)
00175     {
00176         result = NULL;
00177     }
00178     else
00179     {
00180         result = amqpvalue_create_released(released);
00181         released_destroy(released);
00182     }
00183 
00184     return result;
00185 }
00186 
00187 AMQP_VALUE messaging_delivery_modified(bool delivery_failed, bool undeliverable_here, fields message_annotations)
00188 {
00189     AMQP_VALUE result;
00190     MODIFIED_HANDLE modified = modified_create();
00191     if (modified == NULL)
00192     {
00193         result = NULL;
00194     }
00195     else
00196     {
00197         if ((modified_set_delivery_failed(modified, delivery_failed) != 0) ||
00198             (modified_set_undeliverable_here(modified, undeliverable_here) != 0) ||
00199             ((message_annotations != NULL) && (modified_set_message_annotations(modified, message_annotations) != 0)))
00200         {
00201             result = NULL;
00202         }
00203         else
00204         {
00205             result = amqpvalue_create_modified(modified);
00206         }
00207 
00208         modified_destroy(modified);
00209     }
00210 
00211     return result;
00212 }