message.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 <string.h>
00009 #include "azure_uamqp_c/message.h"
00010 #include "azure_uamqp_c/amqpvalue.h"
00011 #include "azure_uamqp_c/amqpalloc.h"
00012 
00013 typedef struct BODY_AMQP_DATA_TAG
00014 {
00015     unsigned char* body_data_section_bytes;
00016     size_t body_data_section_length;
00017 } BODY_AMQP_DATA;
00018 
00019 typedef struct MESSAGE_INSTANCE_TAG
00020 {
00021     BODY_AMQP_DATA* body_amqp_data_items;
00022     size_t body_amqp_data_count;
00023     AMQP_VALUE* body_amqp_sequence_items;
00024     size_t body_amqp_sequence_count;
00025     AMQP_VALUE body_amqp_value;
00026     HEADER_HANDLE header;
00027     annotations delivery_annotations;
00028     annotations message_annotations;
00029     PROPERTIES_HANDLE properties;
00030     application_properties application_properties;
00031     annotations footer;
00032     uint32_t message_format;
00033 } MESSAGE_INSTANCE;
00034 
00035 static void free_all_body_data_items(MESSAGE_INSTANCE* message_instance)
00036 {
00037     size_t i;
00038 
00039     for (i = 0; i < message_instance->body_amqp_data_count; i++)
00040     {
00041         if (message_instance->body_amqp_data_items[i].body_data_section_bytes != NULL)
00042         {
00043             amqpalloc_free(message_instance->body_amqp_data_items[i].body_data_section_bytes);
00044         }
00045     }
00046 
00047     amqpalloc_free(message_instance->body_amqp_data_items);
00048     message_instance->body_amqp_data_count = 0;
00049     message_instance->body_amqp_data_items = NULL;
00050 }
00051 
00052 static void free_all_body_sequence_items(MESSAGE_INSTANCE* message_instance)
00053 {
00054     size_t i;
00055 
00056     for (i = 0; i < message_instance->body_amqp_sequence_count; i++)
00057     {
00058         if (message_instance->body_amqp_sequence_items[i] != NULL)
00059         {
00060             amqpvalue_destroy(message_instance->body_amqp_sequence_items[i]);
00061         }
00062     }
00063 
00064     amqpalloc_free(message_instance->body_amqp_sequence_items);
00065     message_instance->body_amqp_sequence_count = 0;
00066     message_instance->body_amqp_sequence_items = NULL;
00067 }
00068 
00069 MESSAGE_HANDLE message_create(void)
00070 {
00071     MESSAGE_INSTANCE* result = (MESSAGE_INSTANCE*)amqpalloc_malloc(sizeof(MESSAGE_INSTANCE));
00072     /* Codes_SRS_MESSAGE_01_002: [If allocating memory for the message fails, message_create shall fail and return NULL.] */
00073     if (result != NULL)
00074     {
00075         result->header = NULL;
00076         result->delivery_annotations = NULL;
00077         result->message_annotations = NULL;
00078         result->properties = NULL;
00079         result->application_properties = NULL;
00080         result->footer = NULL;
00081         result->body_amqp_data_items = NULL;
00082         result->body_amqp_data_count = 0;
00083         result->body_amqp_value = NULL;
00084         result->body_amqp_sequence_items = NULL;
00085         result->body_amqp_sequence_count = 0;
00086         result->message_format = 0;
00087     }
00088 
00089     /* Codes_SRS_MESSAGE_01_001: [message_create shall create a new AMQP message instance and on success it shall return a non-NULL handle for the newly created message instance.] */
00090     return result;
00091 }
00092 
00093 MESSAGE_HANDLE message_clone(MESSAGE_HANDLE source_message)
00094 {
00095     MESSAGE_INSTANCE* result;
00096 
00097     /* Codes_SRS_MESSAGE_01_062: [If source_message is NULL, message_clone shall fail and return NULL.] */
00098     if (source_message == NULL)
00099     {
00100         result = NULL;
00101     }
00102     else
00103     {
00104         MESSAGE_INSTANCE* source_message_instance = (MESSAGE_INSTANCE*)source_message;
00105         result = (MESSAGE_INSTANCE*)message_create();
00106 
00107         /* Codes_SRS_MESSAGE_01_003: [message_clone shall clone a message entirely and on success return a non-NULL handle to the cloned message.] */
00108         /* Codes_SRS_MESSAGE_01_004: [If allocating memory for the new cloned message fails, message_clone shall fail and return NULL.] */
00109         if (result != NULL)
00110         {
00111             result->message_format = source_message_instance->message_format;
00112 
00113             if (source_message_instance->header != NULL)
00114             {
00115                 /* Codes_SRS_MESSAGE_01_005: [If a header exists on the source message it shall be cloned by using header_clone.] */
00116                 result->header = header_clone(source_message_instance->header);
00117                 if (result->header == NULL)
00118                 {
00119                     message_destroy(result);
00120                     result = NULL;
00121                 }
00122             }
00123 
00124             if ((result != NULL) && (source_message_instance->delivery_annotations != NULL))
00125             {
00126                 /* Codes_SRS_MESSAGE_01_006: [If delivery annotations exist on the source message they shall be cloned by using annotations_clone.] */
00127                 result->delivery_annotations = annotations_clone(source_message_instance->delivery_annotations);
00128                 if (result->delivery_annotations == NULL)
00129                 {
00130                     message_destroy(result);
00131                     result = NULL;
00132                 }
00133             }
00134 
00135             if ((result != NULL) && (source_message_instance->message_annotations != NULL))
00136             {
00137                 /* Codes_SRS_MESSAGE_01_007: [If message annotations exist on the source message they shall be cloned by using annotations_clone.] */
00138                 result->message_annotations = annotations_clone(source_message_instance->message_annotations);
00139                 if (result->message_annotations == NULL)
00140                 {
00141                     message_destroy(result);
00142                     result = NULL;
00143                 }
00144             }
00145 
00146             if ((result != NULL) && (source_message_instance->properties != NULL))
00147             {
00148                 /* Codes_SRS_MESSAGE_01_008: [If message properties exist on the source message they shall be cloned by using properties_clone.] */
00149                 result->properties = properties_clone(source_message_instance->properties);
00150                 if (result->properties == NULL)
00151                 {
00152                     message_destroy(result);
00153                     result = NULL;
00154                 }
00155             }
00156 
00157             if ((result != NULL) && (source_message_instance->application_properties != NULL))
00158             {
00159                 /* Codes_SRS_MESSAGE_01_009: [If application properties exist on the source message they shall be cloned by using amqpvalue_clone.] */
00160                 result->application_properties = amqpvalue_clone(source_message_instance->application_properties);
00161                 if (result->application_properties == NULL)
00162                 {
00163                     message_destroy(result);
00164                     result = NULL;
00165                 }
00166             }
00167 
00168             if ((result != NULL) && (source_message_instance->footer != NULL))
00169             {
00170                 /* Codes_SRS_MESSAGE_01_010: [If a footer exists on the source message it shall be cloned by using annotations_clone.] */
00171                 result->footer = amqpvalue_clone(source_message_instance->footer);
00172                 if (result->footer == NULL)
00173                 {
00174                     message_destroy(result);
00175                     result = NULL;
00176                 }
00177             }
00178 
00179             if ((result != NULL) && (source_message_instance->body_amqp_data_count > 0))
00180             {
00181                 size_t i;
00182 
00183                 result->body_amqp_data_items = (BODY_AMQP_DATA*)amqpalloc_malloc(source_message_instance->body_amqp_data_count * sizeof(BODY_AMQP_DATA));
00184                 if (result->body_amqp_data_items == NULL)
00185                 {
00186                     message_destroy(result);
00187                     result = NULL;
00188                 }
00189                 else
00190                 {
00191                     for (i = 0; i < source_message_instance->body_amqp_data_count; i++)
00192                     {
00193                         result->body_amqp_data_items[i].body_data_section_length = source_message_instance->body_amqp_data_items[i].body_data_section_length;
00194 
00195                         /* Codes_SRS_MESSAGE_01_011: [If an AMQP data has been set as message body on the source message it shall be cloned by allocating memory for the binary payload.] */
00196                         result->body_amqp_data_items[i].body_data_section_bytes = amqpalloc_malloc(source_message_instance->body_amqp_data_items[i].body_data_section_length);
00197                         if (result->body_amqp_data_items[i].body_data_section_bytes == NULL)
00198                         {
00199                             break;
00200                         }
00201                         else
00202                         {
00203                             (void)memcpy(result->body_amqp_data_items[i].body_data_section_bytes, source_message_instance->body_amqp_data_items[i].body_data_section_bytes, result->body_amqp_data_items[i].body_data_section_length);
00204                         }
00205                     }
00206 
00207                     result->body_amqp_data_count = i;
00208                     if (i < source_message_instance->body_amqp_data_count)
00209                     {
00210                         message_destroy(result);
00211                         result = NULL;
00212                     }
00213                 }
00214             }
00215 
00216             if ((result != NULL) && (source_message_instance->body_amqp_sequence_count > 0))
00217             {
00218                 size_t i;
00219 
00220                 result->body_amqp_sequence_items = (AMQP_VALUE*)amqpalloc_malloc(source_message_instance->body_amqp_sequence_count * sizeof(AMQP_VALUE));
00221                 if (result->body_amqp_sequence_items == NULL)
00222                 {
00223                     message_destroy(result);
00224                     result = NULL;
00225                 }
00226                 else
00227                 {
00228                     for (i = 0; i < source_message_instance->body_amqp_sequence_count; i++)
00229                     {
00230                         /* Codes_SRS_MESSAGE_01_011: [If an AMQP data has been set as message body on the source message it shall be cloned by allocating memory for the binary payload.] */
00231                         result->body_amqp_sequence_items[i] = amqpvalue_clone(source_message_instance->body_amqp_sequence_items[i]);
00232                         if (result->body_amqp_sequence_items[i] == NULL)
00233                         {
00234                             break;
00235                         }
00236                     }
00237 
00238                     result->body_amqp_sequence_count = i;
00239                     if (i < source_message_instance->body_amqp_sequence_count)
00240                     {
00241                         message_destroy(result);
00242                         result = NULL;
00243                     }
00244                 }
00245             }
00246 
00247             if ((result != NULL) && (source_message_instance->body_amqp_value != NULL))
00248             {
00249                 result->body_amqp_value = amqpvalue_clone(source_message_instance->body_amqp_value);
00250                 if (result->body_amqp_value == NULL)
00251                 {
00252                     message_destroy(result);
00253                     result = NULL;
00254                 }
00255             }
00256         }
00257     }
00258 
00259     return result;
00260 }
00261 
00262 void message_destroy(MESSAGE_HANDLE message)
00263 {
00264     if (message != NULL)
00265     {
00266         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00267 
00268         if (message_instance->header != NULL)
00269         {
00270             header_destroy(message_instance->header);
00271         }
00272         if (message_instance->properties != NULL)
00273         {
00274             properties_destroy(message_instance->properties);
00275         }
00276         if (message_instance->application_properties != NULL)
00277         {
00278             application_properties_destroy(message_instance->application_properties);
00279         }
00280         if (message_instance->footer != NULL)
00281         {
00282             annotations_destroy(message_instance->footer);
00283         }
00284         if (message_instance->body_amqp_value != NULL)
00285         {
00286             amqpvalue_destroy(message_instance->body_amqp_value);
00287         }
00288         if (message_instance->message_annotations != NULL)
00289         {
00290             application_properties_destroy(message_instance->message_annotations);
00291         }
00292 
00293         free_all_body_data_items(message_instance);
00294         free_all_body_sequence_items(message_instance);
00295         amqpalloc_free(message_instance);
00296     }
00297 }
00298 
00299 int message_set_header(MESSAGE_HANDLE message, HEADER_HANDLE header)
00300 {
00301     int result;
00302 
00303     if ((message == NULL) ||
00304         (header == NULL))
00305     {
00306         result = __LINE__;
00307     }
00308     else
00309     {
00310         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00311         HEADER_HANDLE new_header;
00312 
00313         new_header = header_clone(header);
00314         if (new_header == NULL)
00315         {
00316             result = __LINE__;
00317         }
00318         else
00319         {
00320             if (message_instance->header != NULL)
00321             {
00322                 header_destroy(message_instance->header);
00323             }
00324 
00325             message_instance->header = new_header;
00326             result = 0;
00327         }
00328     }
00329 
00330     return result;
00331 }
00332 
00333 int message_get_header(MESSAGE_HANDLE message, HEADER_HANDLE* header)
00334 {
00335     int result;
00336 
00337     if ((message == NULL) ||
00338         (header == NULL))
00339     {
00340         result = __LINE__;
00341     }
00342     else
00343     {
00344         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00345 
00346         if (message_instance->header == NULL)
00347         {
00348             *header = NULL;
00349             result = 0;
00350         }
00351         else
00352         {
00353             *header = header_clone(message_instance->header);
00354             if (*header == NULL)
00355             {
00356                 result = __LINE__;
00357             }
00358             else
00359             {
00360                 result = 0;
00361             }
00362         }
00363     }
00364 
00365     return result;
00366 }
00367 
00368 int message_set_delivery_annotations(MESSAGE_HANDLE message, annotations delivery_annotations)
00369 {
00370     int result;
00371 
00372     if ((message == NULL) ||
00373         (delivery_annotations == NULL))
00374     {
00375         result = __LINE__;
00376     }
00377     else
00378     {
00379         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00380         annotations new_delivery_annotations;
00381 
00382         new_delivery_annotations = annotations_clone(delivery_annotations);
00383         if (new_delivery_annotations == NULL)
00384         {
00385             result = __LINE__;
00386         }
00387         else
00388         {
00389             if (message_instance->delivery_annotations != NULL)
00390             {
00391                 annotations_destroy(message_instance->delivery_annotations);
00392             }
00393             message_instance->delivery_annotations = new_delivery_annotations;
00394             result = 0;
00395         }
00396     }
00397 
00398     return result;
00399 }
00400 
00401 int message_get_delivery_annotations(MESSAGE_HANDLE message, annotations* delivery_annotations)
00402 {
00403     int result;
00404 
00405     if ((message == NULL) ||
00406         (delivery_annotations == NULL))
00407     {
00408         result = __LINE__;
00409     }
00410     else
00411     {
00412         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00413 
00414         if (message_instance->delivery_annotations == NULL)
00415         {
00416             *delivery_annotations = NULL;
00417             result = 0;
00418         }
00419         else
00420         {
00421             *delivery_annotations = annotations_clone(message_instance->delivery_annotations);
00422             if (*delivery_annotations == NULL)
00423             {
00424                 result = __LINE__;
00425             }
00426             else
00427             {
00428                 result = 0;
00429             }
00430         }
00431     }
00432 
00433     return result;
00434 }
00435 
00436 int message_set_message_annotations(MESSAGE_HANDLE message, annotations message_annotations)
00437 {
00438     int result;
00439 
00440     if ((message == NULL) ||
00441         (message_annotations == NULL))
00442     {
00443         result = __LINE__;
00444     }
00445     else
00446     {
00447         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00448         annotations new_message_annotations;
00449 
00450         new_message_annotations = annotations_clone(message_annotations);
00451         if (new_message_annotations == NULL)
00452         {
00453             result = __LINE__;
00454         }
00455         else
00456         {
00457             if (message_instance->message_annotations != NULL)
00458             {
00459                 annotations_destroy(message_instance->message_annotations);
00460             }
00461 
00462             message_instance->message_annotations = new_message_annotations;
00463             result = 0;
00464         }
00465     }
00466 
00467     return result;
00468 }
00469 
00470 int message_get_message_annotations(MESSAGE_HANDLE message, annotations* message_annotations)
00471 {
00472     int result;
00473 
00474     if ((message == NULL) ||
00475         (message_annotations == NULL))
00476     {
00477         result = __LINE__;
00478     }
00479     else
00480     {
00481         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00482 
00483         if (message_instance->message_annotations == NULL)
00484         {
00485             *message_annotations = NULL;
00486             result = 0;
00487         }
00488         else
00489         {
00490             *message_annotations = annotations_clone(message_instance->message_annotations);
00491             if (*message_annotations == NULL)
00492             {
00493                 result = __LINE__;
00494             }
00495             else
00496             {
00497                 result = 0;
00498             }
00499         }
00500     }
00501 
00502     return result;
00503 }
00504 
00505 int message_set_properties(MESSAGE_HANDLE message, PROPERTIES_HANDLE properties)
00506 {
00507     int result;
00508 
00509     if ((message == NULL) ||
00510         (properties == NULL))
00511     {
00512         result = __LINE__;
00513     }
00514     else
00515     {
00516         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00517         PROPERTIES_HANDLE new_properties;
00518 
00519         new_properties = properties_clone(properties);
00520         if (new_properties == NULL)
00521         {
00522             result = __LINE__;
00523         }
00524         else
00525         {
00526             if (message_instance->properties != NULL)
00527             {
00528                 properties_destroy(message_instance->properties);
00529             }
00530 
00531             message_instance->properties = new_properties;
00532             result = 0;
00533         }
00534     }
00535 
00536     return result;
00537 }
00538 
00539 int message_get_properties(MESSAGE_HANDLE message, PROPERTIES_HANDLE* properties)
00540 {
00541     int result;
00542 
00543     if ((message == NULL) ||
00544         (properties == NULL))
00545     {
00546         result = __LINE__;
00547     }
00548     else
00549     {
00550         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00551 
00552         if (message_instance->properties == NULL)
00553         {
00554             *properties = NULL;
00555             result = 0;
00556         }
00557         else
00558         {
00559             *properties = properties_clone(message_instance->properties);
00560             if (*properties == NULL)
00561             {
00562                 result = __LINE__;
00563             }
00564             else
00565             {
00566                 result = 0;
00567             }
00568         }
00569     }
00570 
00571     return result;
00572 }
00573 
00574 int message_set_application_properties(MESSAGE_HANDLE message, AMQP_VALUE application_properties)
00575 {
00576     int result;
00577 
00578     if ((message == NULL) ||
00579         (application_properties == NULL))
00580     {
00581         result = __LINE__;
00582     }
00583     else
00584     {
00585         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00586         AMQP_VALUE new_application_properties;
00587 
00588         new_application_properties = application_properties_clone(application_properties);
00589         if (new_application_properties == NULL)
00590         {
00591             result = __LINE__;
00592         }
00593         else
00594         {
00595             if (message_instance->application_properties != NULL)
00596             {
00597                 amqpvalue_destroy(message_instance->application_properties);
00598             }
00599 
00600             message_instance->application_properties = new_application_properties;
00601             result = 0;
00602         }
00603     }
00604 
00605     return result;
00606 }
00607 
00608 int message_get_application_properties(MESSAGE_HANDLE message, AMQP_VALUE* application_properties)
00609 {
00610     int result;
00611 
00612     if ((message == NULL) ||
00613         (application_properties == NULL))
00614     {
00615         result = __LINE__;
00616     }
00617     else
00618     {
00619         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00620 
00621         if (message_instance->application_properties == NULL)
00622         {
00623             *application_properties = NULL;
00624             result = 0;
00625         }
00626         else
00627         {
00628             *application_properties = application_properties_clone(message_instance->application_properties);
00629             if (*application_properties == NULL)
00630             {
00631                 result = __LINE__;
00632             }
00633             else
00634             {
00635                 result = 0;
00636             }
00637         }
00638     }
00639 
00640     return result;
00641 }
00642 
00643 int message_set_footer(MESSAGE_HANDLE message, annotations footer)
00644 {
00645     int result;
00646 
00647     if ((message == NULL) ||
00648         (footer == NULL))
00649     {
00650         result = __LINE__;
00651     }
00652     else
00653     {
00654         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00655         AMQP_VALUE new_footer;
00656 
00657         new_footer = annotations_clone(footer);
00658         if (new_footer == NULL)
00659         {
00660             result = __LINE__;
00661         }
00662         else
00663         {
00664             if (message_instance->footer != NULL)
00665             {
00666                 annotations_destroy(message_instance->footer);
00667             }
00668 
00669             message_instance->footer = new_footer;
00670             result = 0;
00671         }
00672     }
00673 
00674     return result;
00675 }
00676 
00677 int message_get_footer(MESSAGE_HANDLE message, annotations* footer)
00678 {
00679     int result;
00680 
00681     if ((message == NULL) ||
00682         (footer == NULL))
00683     {
00684         result = __LINE__;
00685     }
00686     else
00687     {
00688         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00689 
00690         if (message_instance->footer == NULL)
00691         {
00692             *footer = NULL;
00693             result = 0;
00694         }
00695         else
00696         {
00697             *footer = annotations_clone(message_instance->footer);
00698             if (*footer == NULL)
00699             {
00700                 result = __LINE__;
00701             }
00702             else
00703             {
00704                 result = 0;
00705             }
00706         }
00707     }
00708 
00709     return result;
00710 }
00711 
00712 int message_add_body_amqp_data(MESSAGE_HANDLE message, BINARY_DATA binary_data)
00713 {
00714     int result;
00715 
00716     MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00717     if ((message == NULL) ||
00718         (binary_data.bytes == NULL) &&
00719         (binary_data.length != 0))
00720     {
00721         result = __LINE__;
00722     }
00723     else
00724     {
00725         BODY_AMQP_DATA* new_body_amqp_data_items = (BODY_AMQP_DATA*)amqpalloc_realloc(message_instance->body_amqp_data_items, sizeof(BODY_AMQP_DATA) * (message_instance->body_amqp_data_count + 1));
00726         if (new_body_amqp_data_items == NULL)
00727         {
00728             result = __LINE__;
00729         }
00730         else
00731         {
00732             message_instance->body_amqp_data_items = new_body_amqp_data_items;
00733 
00734             message_instance->body_amqp_data_items[message_instance->body_amqp_data_count].body_data_section_bytes = (unsigned char*)amqpalloc_malloc(binary_data.length);
00735             if (message_instance->body_amqp_data_items[message_instance->body_amqp_data_count].body_data_section_bytes == NULL)
00736             {
00737                 result = __LINE__;
00738             }
00739             else
00740             {
00741                 message_instance->body_amqp_data_items[message_instance->body_amqp_data_count].body_data_section_length = binary_data.length;
00742                 (void)memcpy(message_instance->body_amqp_data_items[message_instance->body_amqp_data_count].body_data_section_bytes, binary_data.bytes, binary_data.length);
00743 
00744                 if (message_instance->body_amqp_value != NULL)
00745                 {
00746                     amqpvalue_destroy(message_instance->body_amqp_value);
00747                     message_instance->body_amqp_value = NULL;
00748                 }
00749                 free_all_body_sequence_items(message_instance);
00750 
00751                 message_instance->body_amqp_data_count++;
00752                 result = 0;
00753             }
00754         }
00755     }
00756 
00757     return result;
00758 }
00759 
00760 int message_get_body_amqp_data(MESSAGE_HANDLE message, size_t index, BINARY_DATA* binary_data)
00761 {
00762     int result;
00763 
00764     if ((message == NULL) ||
00765         (binary_data == NULL))
00766     {
00767         result = __LINE__;
00768     }
00769     else
00770     {
00771         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00772 
00773         if (index >= message_instance->body_amqp_data_count)
00774         {
00775             result = __LINE__;
00776         }
00777         else
00778         {
00779             binary_data->bytes = message_instance->body_amqp_data_items[index].body_data_section_bytes;
00780             binary_data->length = message_instance->body_amqp_data_items[index].body_data_section_length;
00781 
00782             result = 0;
00783         }
00784     }
00785 
00786     return result;
00787 }
00788 
00789 int message_get_body_amqp_data_count(MESSAGE_HANDLE message, size_t* count)
00790 {
00791     int result;
00792 
00793     MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00794     if ((message == NULL) ||
00795         (count == NULL))
00796     {
00797         result = __LINE__;
00798     }
00799     else
00800     {
00801         *count = message_instance->body_amqp_data_count;
00802         result = 0;
00803     }
00804 
00805     return result;
00806 }
00807 
00808 int message_add_body_amqp_sequence(MESSAGE_HANDLE message, AMQP_VALUE sequence_list)
00809 {
00810     int result;
00811     size_t item_count;
00812 
00813     MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00814     if ((message == NULL) ||
00815         (sequence_list == NULL) ||
00816         (amqpvalue_get_list_item_count(sequence_list, (uint32_t*)&item_count) != 0))
00817     {
00818         result = __LINE__;
00819     }
00820     else
00821     {
00822         AMQP_VALUE* new_body_amqp_sequence_items = (AMQP_VALUE*)amqpalloc_realloc(message_instance->body_amqp_sequence_items, sizeof(AMQP_VALUE) * (message_instance->body_amqp_sequence_count + 1));
00823         if (new_body_amqp_sequence_items == NULL)
00824         {
00825             result = __LINE__;
00826         }
00827         else
00828         {
00829             message_instance->body_amqp_sequence_items = new_body_amqp_sequence_items;
00830 
00831             message_instance->body_amqp_sequence_items[message_instance->body_amqp_sequence_count] = amqpvalue_clone(sequence_list);
00832             if (message_instance->body_amqp_sequence_items[message_instance->body_amqp_sequence_count] == NULL)
00833             {
00834                 result = __LINE__;
00835             }
00836             else
00837             {
00838                 if (message_instance->body_amqp_value != NULL)
00839                 {
00840                     amqpvalue_destroy(message_instance->body_amqp_value);
00841                     message_instance->body_amqp_value = NULL;
00842                 }
00843                 free_all_body_data_items(message_instance);
00844 
00845                 message_instance->body_amqp_sequence_count++;
00846                 result = 0;
00847             }
00848         }
00849     }
00850 
00851     return result;
00852 }
00853 
00854 int message_get_body_amqp_sequence(MESSAGE_HANDLE message, size_t index, AMQP_VALUE* sequence_list)
00855 {
00856     int result;
00857 
00858     if ((message == NULL) ||
00859         (sequence_list == NULL))
00860     {
00861         result = __LINE__;
00862     }
00863     else
00864     {
00865         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00866 
00867         if (index >= message_instance->body_amqp_sequence_count)
00868         {
00869             result = __LINE__;
00870         }
00871         else
00872         {
00873             *sequence_list = amqpvalue_clone(message_instance->body_amqp_sequence_items[index]);
00874             if (*sequence_list == NULL)
00875             {
00876                 result = __LINE__;
00877             }
00878             else
00879             {
00880                 result = 0;
00881             }
00882         }
00883     }
00884 
00885     return result;
00886 }
00887 
00888 int message_get_body_amqp_sequence_count(MESSAGE_HANDLE message, size_t* count)
00889 {
00890     int result;
00891 
00892     MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00893     if ((message == NULL) ||
00894         (count == NULL))
00895     {
00896         result = __LINE__;
00897     }
00898     else
00899     {
00900         *count = message_instance->body_amqp_sequence_count;
00901         result = 0;
00902     }
00903 
00904     return result;
00905 }
00906 
00907 int message_set_body_amqp_value(MESSAGE_HANDLE message, AMQP_VALUE body_amqp_value)
00908 {
00909     int result;
00910 
00911     MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00912     if ((message == NULL) ||
00913         (body_amqp_value == NULL))
00914     {
00915         result = __LINE__;
00916     }
00917     else
00918     {
00919         message_instance->body_amqp_value = amqpvalue_clone(body_amqp_value);
00920 
00921         free_all_body_data_items(message_instance);
00922         free_all_body_sequence_items(message_instance);
00923         result = 0;
00924     }
00925 
00926     return result;
00927 }
00928 
00929 int message_get_inplace_body_amqp_value(MESSAGE_HANDLE message, AMQP_VALUE* body_amqp_value)
00930 {
00931     int result;
00932 
00933     if ((message == NULL) ||
00934         (body_amqp_value == NULL))
00935     {
00936         result = __LINE__;
00937     }
00938     else
00939     {
00940         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00941 
00942         *body_amqp_value = message_instance->body_amqp_value;
00943 
00944         result = 0;
00945     }
00946 
00947     return result;
00948 }
00949 
00950 int message_get_body_type(MESSAGE_HANDLE message, MESSAGE_BODY_TYPE* body_type)
00951 {
00952     int result;
00953 
00954     if ((message == NULL) ||
00955         (body_type == NULL))
00956     {
00957         result = __LINE__;
00958     }
00959     else
00960     {
00961         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00962 
00963         if (message_instance->body_amqp_value != NULL)
00964         {
00965             *body_type = MESSAGE_BODY_TYPE_VALUE;
00966         }
00967         else if (message_instance->body_amqp_data_count > 0)
00968         {
00969             *body_type = MESSAGE_BODY_TYPE_DATA;
00970         }
00971         else if (message_instance->body_amqp_sequence_count > 0)
00972         {
00973             *body_type = MESSAGE_BODY_TYPE_SEQUENCE;
00974         }
00975         else
00976         {
00977             *body_type = MESSAGE_BODY_TYPE_NONE;
00978         }
00979 
00980         result = 0;
00981     }
00982 
00983     return result;
00984 }
00985 
00986 int message_set_message_format(MESSAGE_HANDLE message, uint32_t message_format)
00987 {
00988     int result;
00989 
00990     if (message == NULL)
00991     {
00992         result = __LINE__;
00993     }
00994     else
00995     {
00996         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
00997         message_instance->message_format = message_format;
00998         result = 0;
00999     }
01000 
01001     return result;
01002 }
01003 
01004 int message_get_message_format(MESSAGE_HANDLE message, uint32_t *message_format)
01005 {
01006     int result;
01007 
01008     if ((message == NULL) ||
01009         (message_format == NULL))
01010     {
01011         result = __LINE__;
01012     }
01013     else
01014     {
01015         MESSAGE_INSTANCE* message_instance = (MESSAGE_INSTANCE*)message;
01016         *message_format = message_instance->message_format;
01017         result = 0;
01018     }
01019 
01020     return result;
01021 }