Revert "[C] Add _HEADER_LENGTH constants for all frame types."

This reverts commit 6004e36

Author: vyazelenko

aeron-client/src/main/c/aeron_fragment_assembler.c

@@ -30,7 +30,7 @@ int aeron_buffer_builder_create(aeron_buffer_builder_t **buffer_builder)
     aeron_data_header_t *_frame;
 
     if (aeron_alloc((void **)&_buffer_builder, sizeof(aeron_buffer_builder_t)) < 0 ||
-        aeron_alloc((void **)&_frame, AERON_DATA_HEADER_LENGTH) < 0)
+        aeron_alloc((void **)&_frame, sizeof(aeron_data_header_t)) < 0)
     {
         AERON_APPEND_ERR("%s", "Failed to allocate buffer_builder");
         return -1;

aeron-client/src/main/c/aeron_fragment_assembler.h

@@ -100,7 +100,7 @@ inline void aeron_buffer_builder_capture_header(aeron_buffer_builder_t *buffer_b
 {
     buffer_builder->header.initial_term_id = header->initial_term_id;
     buffer_builder->header.position_bits_to_shift = header->position_bits_to_shift;
-    memcpy(buffer_builder->header.frame, header->frame, AERON_DATA_HEADER_LENGTH);
+    memcpy(buffer_builder->header.frame, header->frame, sizeof(aeron_data_header_t));
 }
 
 inline aeron_header_t* aeron_buffer_builder_complete_header(aeron_buffer_builder_t *buffer_builder, aeron_header_t *header)

aeron-client/src/main/c/protocol/aeron_udp_protocol.c

@@ -29,7 +29,7 @@ _Static_assert(
 
 int aeron_udp_protocol_group_tag(aeron_status_message_header_t *sm, int64_t *group_tag)
 {
-    const size_t group_tag_offset = AERON_SM_HEADER_LENGTH +
+    const size_t group_tag_offset = sizeof(aeron_status_message_header_t) +
         offsetof(aeron_status_message_optional_header_t, group_tag);
     const size_t group_tag_size = sizeof(*group_tag);
     const size_t frame_length_with_group_tag = group_tag_offset + group_tag_size;
@@ -55,17 +55,17 @@ extern size_t aeron_compute_max_message_length(size_t term_length);
 
 size_t aeron_res_header_entry_length_ipv4(aeron_resolution_header_ipv4_t *header)
 {
-    return AERON_ALIGN(AERON_RES_IPV4_HEADER_LENGTH + header->name_length, sizeof(int64_t));
+    return AERON_ALIGN(sizeof(aeron_resolution_header_ipv4_t) + header->name_length, sizeof(int64_t));
 }
 
 size_t aeron_res_header_entry_length_ipv6(aeron_resolution_header_ipv6_t *header)
 {
-    return AERON_ALIGN(AERON_RES_IPV6_HEADER_LENGTH + header->name_length, sizeof(int64_t));
+    return AERON_ALIGN(sizeof(aeron_resolution_header_ipv6_t) + header->name_length, sizeof(int64_t));
 }
 
 int aeron_res_header_entry_length(void *res, size_t remaining)
 {
-    if (remaining < AERON_RES_HEADER_LENGTH)
+    if (remaining < sizeof(aeron_resolution_header_t))
     {
         return -1;
     }
@@ -77,7 +77,7 @@ int aeron_res_header_entry_length(void *res, size_t remaining)
     {
         case AERON_RES_HEADER_TYPE_NAME_TO_IP6_MD:
         {
-            if (AERON_RES_IPV6_HEADER_LENGTH <= remaining)
+            if (sizeof(aeron_resolution_header_ipv6_t) <= remaining)
             {
                 aeron_resolution_header_ipv6_t *res_ipv6 = (aeron_resolution_header_ipv6_t *)res_header;
                 size_t entry_length = aeron_res_header_entry_length_ipv6(res_ipv6);
@@ -88,7 +88,7 @@ int aeron_res_header_entry_length(void *res, size_t remaining)
 
         case AERON_RES_HEADER_TYPE_NAME_TO_IP4_MD:
         {
-            if (AERON_RES_IPV4_HEADER_LENGTH <= remaining)
+            if (sizeof(aeron_resolution_header_ipv4_t) <= remaining)
             {
                 aeron_resolution_header_ipv4_t *res_ipv4 = (aeron_resolution_header_ipv4_t *)res_header;
                 size_t entry_length = aeron_res_header_entry_length_ipv4(res_ipv4);

aeron-client/src/main/c/protocol/aeron_udp_protocol.h

@@ -32,17 +32,6 @@ typedef struct aeron_frame_header_stct
 }
 aeron_frame_header_t;
 
-typedef struct aeron_data_header_stct
-{
-    aeron_frame_header_t frame_header;
-    int32_t term_offset;
-    int32_t session_id;
-    int32_t stream_id;
-    int32_t term_id;
-    int64_t reserved_value;
-}
-aeron_data_header_t;
-
 typedef struct aeron_data_header_as_longs_stct
 {
     uint64_t hdr[4];
@@ -63,6 +52,17 @@ typedef struct aeron_setup_header_stct
 }
 aeron_setup_header_t;
 
+typedef struct aeron_data_header_stct
+{
+    aeron_frame_header_t frame_header;
+    int32_t term_offset;
+    int32_t session_id;
+    int32_t stream_id;
+    int32_t term_id;
+    int64_t reserved_value;
+}
+aeron_data_header_t;
+
 typedef struct aeron_nak_header_stct
 {
     aeron_frame_header_t frame_header;
@@ -86,6 +86,12 @@ typedef struct aeron_status_message_header_stct
 }
 aeron_status_message_header_t;
 
+typedef struct aeron_status_message_optional_header_stct
+{
+    int64_t group_tag;
+}
+aeron_status_message_optional_header_t;
+
 struct aeron_error_stct
 {
     aeron_frame_header_t frame_header;
@@ -98,12 +104,6 @@ struct aeron_error_stct
 };
 typedef struct aeron_error_stct aeron_error_t;
 
-typedef struct aeron_status_message_optional_header_stct
-{
-    int64_t group_tag;
-}
-aeron_status_message_optional_header_t;
-
 typedef struct aeron_rttm_header_stct
 {
     aeron_frame_header_t frame_header;
@@ -184,16 +184,6 @@ int aeron_udp_protocol_group_tag(aeron_status_message_header_t *sm, int64_t *gro
 
 #define AERON_FRAME_HEADER_LENGTH (sizeof(aeron_frame_header_t))
 #define AERON_DATA_HEADER_LENGTH (sizeof(aeron_data_header_t))
-#define AERON_NAK_HEADER_LENGTH (sizeof(aeron_nak_header_t))
-#define AERON_SM_HEADER_LENGTH (sizeof(aeron_status_message_header_t))
-#define AERON_SM_OPTIONAL_HEADER_LENGTH (sizeof(aeron_status_message_optional_header_t))
-#define AERON_ERROR_HEADER_LENGTH (sizeof(aeron_error_t))
-#define AERON_SETUP_HEADER_LENGTH (sizeof(aeron_setup_header_t))
-#define AERON_RTTM_HEADER_LENGTH (sizeof(aeron_rttm_header_t))
-#define AERON_RES_HEADER_LENGTH (sizeof(aeron_resolution_header_t))
-#define AERON_RES_IPV4_HEADER_LENGTH (sizeof(aeron_resolution_header_ipv4_t))
-#define AERON_RES_IPV6_HEADER_LENGTH (sizeof(aeron_resolution_header_ipv6_t))
-#define AERON_RSP_SETUP_HEADER_LENGTH (sizeof(aeron_response_setup_header_t))
 
 #define AERON_DATA_HEADER_BEGIN_FLAG (UINT8_C(0x80))
 #define AERON_DATA_HEADER_END_FLAG (UINT8_C(0x40))
@@ -231,7 +221,7 @@ int aeron_udp_protocol_group_tag(aeron_status_message_header_t *sm, int64_t *gro
 #define AERON_OPT_HDR_ALIGNMENT (4u)
 
 #define AERON_ERROR_MAX_TEXT_LENGTH (1023)
-#define AERON_ERROR_MAX_FRAME_LENGTH (AERON_ERROR_HEADER_LENGTH + AERON_ERROR_MAX_TEXT_LENGTH)
+#define AERON_ERROR_MAX_FRAME_LENGTH (sizeof(aeron_error_t) + AERON_ERROR_MAX_TEXT_LENGTH)
 #define AERON_ERROR_HAS_GROUP_TAG_FLAG (0x08)
 
 inline bool aeron_is_frame_valid(const aeron_frame_header_t *header, const size_t frame_length)

aeron-driver/src/main/c/aeron_driver_name_resolver.c

@@ -608,12 +608,12 @@ void aeron_driver_name_resolver_receive(
         return;
     }
 
-    remaining -= AERON_FRAME_HEADER_LENGTH;
+    remaining -= sizeof(aeron_frame_header_t);
 
     while (0 < remaining)
     {
         const size_t offset = length - remaining;
-        if (AERON_HDR_TYPE_RES != frame_header->type || remaining < AERON_RES_HEADER_LENGTH)
+        if (AERON_HDR_TYPE_RES != frame_header->type || remaining < sizeof(aeron_resolution_header_t))
         {
             aeron_counter_increment(resolver->invalid_packets_counter);
             return;
@@ -631,7 +631,7 @@ void aeron_driver_name_resolver_receive(
         if (AERON_RES_HEADER_TYPE_NAME_TO_IP4_MD == resolution_header->res_type)
         {
             aeron_resolution_header_ipv4_t *ip4_hdr = (aeron_resolution_header_ipv4_t *)resolution_header;
-            if (length < AERON_RES_IPV4_HEADER_LENGTH ||
+            if (length < sizeof(aeron_resolution_header_ipv4_t) ||
                 length < (entry_length = aeron_res_header_entry_length_ipv4(ip4_hdr)))
             {
                 aeron_counter_increment(resolver->invalid_packets_counter);
@@ -645,7 +645,7 @@ void aeron_driver_name_resolver_receive(
         else if (AERON_RES_HEADER_TYPE_NAME_TO_IP6_MD == resolution_header->res_type)
         {
             aeron_resolution_header_ipv6_t *ip6_hdr = (aeron_resolution_header_ipv6_t *)resolution_header;
-            if (length < AERON_RES_IPV6_HEADER_LENGTH ||
+            if (length < sizeof(aeron_resolution_header_ipv6_t) ||
                 length < (entry_length = aeron_res_header_entry_length_ipv6(ip6_hdr)))
             {
                 aeron_counter_increment(resolver->invalid_packets_counter);
@@ -792,7 +792,7 @@ static int aeron_driver_name_resolver_send_self_resolutions(
         return 0;
     }
 
-    const size_t entry_offset = AERON_FRAME_HEADER_LENGTH;
+    const size_t entry_offset = sizeof(aeron_frame_header_t);
     uint8_t *aligned_buffer = driver_resolver->aligned_buffer;
     aeron_frame_header_t *frame_header = (aeron_frame_header_t *)&aligned_buffer[0];
     aeron_resolution_header_t *resolution_header = (aeron_resolution_header_t *)&aligned_buffer[entry_offset];
@@ -809,7 +809,7 @@ static int aeron_driver_name_resolver_send_self_resolutions(
 
     assert(0 <= entry_length || "local_cache_addr should of been correctly constructed during init");
 
-    size_t frame_length = AERON_FRAME_HEADER_LENGTH + (size_t)entry_length;
+    size_t frame_length = sizeof(aeron_frame_header_t) + (size_t)entry_length;
 
     frame_header->type = AERON_HDR_TYPE_RES;
     frame_header->flags = UINT8_C(0);
@@ -915,7 +915,7 @@ static int aeron_driver_name_resolver_send_neighbor_resolutions(aeron_driver_nam
     int work_count = 0;
     for (i = 0; i < resolver->cache.entries.length;)
     {
-        size_t entry_offset = AERON_FRAME_HEADER_LENGTH;
+        size_t entry_offset = sizeof(aeron_frame_header_t);
 
         for (j = i; j < resolver->cache.entries.length;)
         {
@@ -1026,7 +1026,7 @@ int aeron_driver_name_resolver_set_resolution_header(
     switch (cache_addr->res_type)
     {
         case AERON_RES_HEADER_TYPE_NAME_TO_IP4_MD:
-            entry_length = AERON_ALIGN(AERON_RES_IPV4_HEADER_LENGTH + name_length, sizeof(int64_t));
+            entry_length = AERON_ALIGN(sizeof(aeron_resolution_header_ipv4_t) + name_length, sizeof(int64_t));
             if (capacity < entry_length)
             {
                 return 0;
@@ -1035,12 +1035,12 @@ int aeron_driver_name_resolver_set_resolution_header(
             aeron_resolution_header_ipv4_t *hdr_ipv4 = (aeron_resolution_header_ipv4_t *)resolution_header;
             memcpy(hdr_ipv4->addr, cache_addr->address, sizeof(hdr_ipv4->addr));
             hdr_ipv4->name_length = (int16_t)name_length;
-            name_offset = AERON_RES_IPV4_HEADER_LENGTH;
+            name_offset = sizeof(aeron_resolution_header_ipv4_t);
 
             break;
 
         case AERON_RES_HEADER_TYPE_NAME_TO_IP6_MD:
-            entry_length = AERON_ALIGN(AERON_RES_IPV6_HEADER_LENGTH + name_length, sizeof(int64_t));
+            entry_length = AERON_ALIGN(sizeof(aeron_resolution_header_ipv6_t) + name_length, sizeof(int64_t));
             if (capacity < entry_length)
             {
                 return 0;
@@ -1050,7 +1050,7 @@ int aeron_driver_name_resolver_set_resolution_header(
 
             memcpy(hdr_ipv6->addr, cache_addr->address, sizeof(hdr_ipv6->addr));
             hdr_ipv6->name_length = (int16_t)name_length;
-            name_offset = AERON_RES_IPV6_HEADER_LENGTH;
+            name_offset = sizeof(aeron_resolution_header_ipv6_t);
 
             break;
 

aeron-driver/src/main/c/aeron_network_publication.c

@@ -441,15 +441,15 @@ int aeron_network_publication_setup_message_check(
 
     if (now_ns > (publication->time_of_last_setup_ns + AERON_NETWORK_PUBLICATION_SETUP_TIMEOUT_NS))
     {
-        uint8_t setup_buffer[AERON_SETUP_HEADER_LENGTH];
+        uint8_t setup_buffer[sizeof(aeron_setup_header_t)];
         aeron_setup_header_t *setup_header = (aeron_setup_header_t *)setup_buffer;
         struct iovec iov;
 
         uint8_t send_response_flag = (!publication->is_response && AERON_NULL_VALUE != publication->response_correlation_id) ?
             AERON_SETUP_HEADER_SEND_RESPONSE_FLAG : 0;
         uint8_t group_flag = publication->retransmit_handler.has_group_semantics ? AERON_SETUP_HEADER_GROUP_FLAG : 0;
 
-        setup_header->frame_header.frame_length = AERON_SETUP_HEADER_LENGTH;
+        setup_header->frame_header.frame_length = sizeof(aeron_setup_header_t);
         setup_header->frame_header.version = AERON_FRAME_HEADER_VERSION;
         setup_header->frame_header.flags = 0;
         setup_header->frame_header.type = AERON_HDR_TYPE_SETUP;
@@ -464,14 +464,14 @@ int aeron_network_publication_setup_message_check(
         setup_header->ttl = publication->endpoint->conductor_fields.udp_channel->multicast_ttl;
 
         iov.iov_base = setup_buffer;
-        iov.iov_len = AERON_SETUP_HEADER_LENGTH;
+        iov.iov_len = sizeof(aeron_setup_header_t);
 
         if (publication->is_setup_elicited)
         {
             publication->flow_control->on_setup(
                 publication->flow_control->state,
                 setup_buffer,
-                AERON_SETUP_HEADER_LENGTH,
+                sizeof(aeron_setup_header_t),
                 now_ns,
                 *publication->snd_lmt_position.value_addr,
                 publication->position_bits_to_shift,
@@ -524,7 +524,7 @@ int aeron_network_publication_heartbeat_message_check(
             flags |= AERON_DATA_HEADER_EOS_FLAG;
         }
 
-        uint8_t heartbeat_buffer[AERON_DATA_HEADER_LENGTH];
+        uint8_t heartbeat_buffer[sizeof(aeron_data_header_t)];
         aeron_data_header_t *data_header = (aeron_data_header_t *)heartbeat_buffer;
         struct iovec iov;
 
@@ -539,7 +539,7 @@ int aeron_network_publication_heartbeat_message_check(
         data_header->reserved_value = 0l;
 
         iov.iov_base = heartbeat_buffer;
-        iov.iov_len = AERON_DATA_HEADER_LENGTH;
+        iov.iov_len = sizeof(aeron_data_header_t);
 
         if (0 <= (result = aeron_network_publication_do_send(publication, &iov, 1, &bytes_sent)))
         {
@@ -926,12 +926,12 @@ void aeron_network_publication_on_rttm(
 
     if (rttm_in_header->frame_header.flags & AERON_RTTM_HEADER_REPLY_FLAG)
     {
-        uint8_t rttm_reply_buffer[AERON_RTTM_HEADER_LENGTH];
+        uint8_t rttm_reply_buffer[sizeof(aeron_rttm_header_t)];
         aeron_rttm_header_t *rttm_out_header = (aeron_rttm_header_t *)rttm_reply_buffer;
         struct iovec iov;
         int64_t bytes_sent;
 
-        rttm_out_header->frame_header.frame_length = AERON_RTTM_HEADER_LENGTH;
+        rttm_out_header->frame_header.frame_length = sizeof(aeron_rttm_header_t);
         rttm_out_header->frame_header.version = AERON_FRAME_HEADER_VERSION;
         rttm_out_header->frame_header.flags = 0;
         rttm_out_header->frame_header.type = AERON_HDR_TYPE_RTTM;
@@ -942,7 +942,7 @@ void aeron_network_publication_on_rttm(
         rttm_out_header->receiver_id = rttm_in_header->receiver_id;
 
         iov.iov_base = rttm_reply_buffer;
-        iov.iov_len = AERON_RTTM_HEADER_LENGTH;
+        iov.iov_len = sizeof(aeron_rttm_header_t);
 
         if (0 <= aeron_network_publication_do_send(publication, &iov, 1, &bytes_sent))
         {

aeron-driver/src/main/c/agent/aeron_driver_agent.c

@@ -2027,7 +2027,7 @@ const char *aeron_driver_agent_dissect_frame(const void *message, size_t length)
         case AERON_HDR_TYPE_ERR:
         {
             aeron_error_t *err = (aeron_error_t *)message;
-            const char *error_msg = (const char *)message + AERON_ERROR_HEADER_LENGTH;
+            const char *error_msg = (const char *)message + sizeof(aeron_error_t);
 
             snprintf(
                 buffer,
@@ -2123,7 +2123,7 @@ const char *aeron_driver_agent_dissect_frame(const void *message, size_t length)
                 (int)sizeof(dissected_flags),
                 dissect_flags(hdr->flags, dissected_flags),
                 hdr->frame_length);
-            size_t message_offset = AERON_FRAME_HEADER_LENGTH;
+            size_t message_offset = sizeof(aeron_frame_header_t);
 
             while (message_offset < length && buffer_used < buffer_available)
             {
@@ -2145,7 +2145,7 @@ const char *aeron_driver_agent_dissect_frame(const void *message, size_t length)
                         aeron_resolution_header_ipv6_t *res_ipv6 = (aeron_resolution_header_ipv6_t *)res;
                         address = res_ipv6->addr;
                         name_length = res_ipv6->name_length;
-                        name = &message_bytes[message_offset + AERON_RES_IPV6_HEADER_LENGTH];
+                        name = &message_bytes[message_offset + sizeof(aeron_resolution_header_ipv6_t)];
                         break;
                     }
 
@@ -2154,7 +2154,7 @@ const char *aeron_driver_agent_dissect_frame(const void *message, size_t length)
                         aeron_resolution_header_ipv4_t *res_ipv4 = (aeron_resolution_header_ipv4_t *)res;
                         address = res_ipv4->addr;
                         name_length = res_ipv4->name_length;
-                        name = &message_bytes[message_offset + AERON_RES_IPV4_HEADER_LENGTH];
+                        name = &message_bytes[message_offset + sizeof(aeron_resolution_header_ipv4_t)];
                         break;
                     }
                 }