store by value

TingDaoK · TingDaoK · commit 7cf67cee1e52 · 2025-07-03T16:54:50.000-07:00
diff --git a/include/aws/s3/private/s3_checksum_context.h b/include/aws/s3/private/s3_checksum_context.h
@@ -22,7 +22,6 @@ AWS_EXTERN_C_BEGIN
  */
 struct aws_s3_upload_request_checksum_context {
     struct aws_allocator *allocator;
-    struct aws_ref_count ref_count;
 
     /* Configuration */
     enum aws_s3_checksum_algorithm algorithm;
@@ -37,56 +36,45 @@ struct aws_s3_upload_request_checksum_context {
 };
 
 /**
- * Create a new upload request checksum context from configuration and buffer parameters.
+ * Initialize an upload request checksum context from configuration and buffer parameters.
  * This function encapsulates all the complex logic for determining buffer state.
- * Returns with reference count of 1.
  *
+ * @param context Pointer to the checksum context to initialize
  * @param allocator Memory allocator
  * @param checksum_config Meta request level checksum configuration (can be NULL)
- * @return New checksum context or NULL on error
+ * @return AWS_OP_SUCCESS or AWS_OP_ERR
  */
 AWS_S3_API
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new(
+int aws_s3_upload_request_checksum_context_init(
     struct aws_allocator *allocator,
+    struct aws_s3_upload_request_checksum_context *context,
     const struct aws_s3_meta_request_checksum_config_storage *checksum_config);
 
 /**
- * Create a new upload request checksum context with an existing checksum value.
+ * Initialize an upload request checksum context with an existing checksum value.
  * This is useful when resuming uploads or when the checksum is pre-calculated.
- * Returns with reference count of 1.
  *
+ * @param context Pointer to the checksum context to initialize
  * @param allocator Memory allocator
  * @param checksum_config Meta request level checksum configuration (can be NULL)
  * @param existing_checksum Pre-calculated checksum value as a byte cursor
- * @return New checksum context or NULL on error (e.g., if checksum size doesn't match algorithm)
+ * @return AWS_OP_SUCCESS or AWS_OP_ERR (e.g., if checksum size doesn't match algorithm)
  */
 AWS_S3_API
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new_with_existing_checksum(
+int aws_s3_upload_request_checksum_context_init_with_existing_checksum(
     struct aws_allocator *allocator,
+    struct aws_s3_upload_request_checksum_context *context,
     const struct aws_s3_meta_request_checksum_config_storage *checksum_config,
     struct aws_byte_cursor existing_checksum);
 
 /**
- * Acquire a reference to the upload request checksum context.
- * Use this when transferring ownership to another function/structure.
+ * Clean up resources associated with an upload request checksum context.
+ * This does not free the context itself, just its internal resources.
  *
- * @param context The checksum context to acquire
- * @return The same context pointer (for convenience)
+ * @param context Pointer to the checksum context to clean up
  */
 AWS_S3_API
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_acquire(
-    struct aws_s3_upload_request_checksum_context *context);
-
-/**
- * Release a reference to the upload request checksum context.
- * When the reference count reaches zero, the context will be destroyed.
- * Always returns NULL.
- *
- * @param context The checksum context to release
- */
-AWS_S3_API
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_release(
-    struct aws_s3_upload_request_checksum_context *context);
+void aws_s3_upload_request_checksum_context_clean_up(struct aws_s3_upload_request_checksum_context *context);
 
 /**
  * Check if checksum calculation is needed based on context state.
diff --git a/include/aws/s3/private/s3_meta_request_impl.h b/include/aws/s3/private/s3_meta_request_impl.h
@@ -14,6 +14,7 @@
 #include <aws/common/task_scheduler.h>
 #include <aws/http/request_response.h>
 
+#include "aws/s3/private/s3_checksum_context.h"
 #include "aws/s3/private/s3_checksums.h"
 #include "aws/s3/private/s3_client_impl.h"
 #include "aws/s3/private/s3_request.h"
@@ -25,7 +26,6 @@ struct aws_s3_request;
 struct aws_http_headers;
 struct aws_http_make_request_options;
 struct aws_retry_strategy;
-struct aws_s3_upload_request_checksum_context;
 enum aws_s3_meta_request_state {
     AWS_S3_META_REQUEST_STATE_ACTIVE,
     AWS_S3_META_REQUEST_STATE_FINISHED,
@@ -294,7 +294,7 @@ struct aws_s3_meta_request {
 struct aws_s3_mpu_part_info {
     uint64_t size;
     struct aws_string *etag;
-    struct aws_s3_upload_request_checksum_context *checksum_context;
+    struct aws_s3_upload_request_checksum_context checksum_context;
     bool was_previously_uploaded;
 };
 
diff --git a/source/s3_auto_ranged_put.c b/source/s3_auto_ranged_put.c
@@ -154,16 +154,22 @@ static int s_process_part_info_synced(const struct aws_s3_part_info *info, void
     }
 
     if ((checksum_cur != NULL) && (checksum_cur->len > 0)) {
-        /* Create checksum context with pre-calculated checksum */
-        part->checksum_context = aws_s3_upload_request_checksum_context_new_with_existing_checksum(
-            auto_ranged_put->base.allocator, &auto_ranged_put->base.checksum_config, *checksum_cur);
+        /* Initialize checksum context with pre-calculated checksum */
+        if (aws_s3_upload_request_checksum_context_init_with_existing_checksum(
+                auto_ranged_put->base.allocator,
+                &part->checksum_context,
+                &auto_ranged_put->base.checksum_config,
+                *checksum_cur)) {
+            aws_mem_release(meta_request->allocator, part);
+            return AWS_OP_ERR;
+        }
     } else {
-        part->checksum_context = aws_s3_upload_request_checksum_context_new(
-            auto_ranged_put->base.allocator, &auto_ranged_put->base.checksum_config);
-    }
-    if (!part->checksum_context) {
-        aws_mem_release(meta_request->allocator, part);
-        return AWS_OP_ERR;
+        /* Initialize checksum context */
+        if (aws_s3_upload_request_checksum_context_init(
+                auto_ranged_put->base.allocator, &part->checksum_context, &auto_ranged_put->base.checksum_config)) {
+            aws_mem_release(meta_request->allocator, part);
+            return AWS_OP_ERR;
+        }
     }
     /* Parts might be out of order or have gaps in them.
      * Resize array-list to be long enough to hold this part,
@@ -415,7 +421,7 @@ static void s_s3_meta_request_auto_ranged_put_destroy(struct aws_s3_meta_request
         struct aws_s3_mpu_part_info *part;
         aws_array_list_get_at(&auto_ranged_put->synced_data.part_list, &part, part_index);
         if (part != NULL) {
-            aws_s3_upload_request_checksum_context_release(part->checksum_context);
+            aws_s3_upload_request_checksum_context_clean_up(&part->checksum_context);
             aws_string_destroy(part->etag);
             aws_mem_release(auto_ranged_put->base.allocator, part);
         }
@@ -1076,8 +1082,13 @@ static void s_s3_prepare_upload_part_on_read_done(void *user_data) {
         /* Add part to array-list */
         struct aws_s3_mpu_part_info *part =
             aws_mem_calloc(meta_request->allocator, 1, sizeof(struct aws_s3_mpu_part_info));
-        part->checksum_context =
-            aws_s3_upload_request_checksum_context_new(meta_request->allocator, &meta_request->checksum_config);
+        if (aws_s3_upload_request_checksum_context_init(
+                meta_request->allocator, &part->checksum_context, &meta_request->checksum_config)) {
+            aws_s3_meta_request_unlock_synced_data(meta_request);
+            aws_mem_release(meta_request->allocator, part);
+            error_code = aws_last_error_or_unknown();
+            goto on_done;
+        }
         part->size = request->request_body.len;
         aws_array_list_set_at(&auto_ranged_put->synced_data.part_list, &part, request->part_number - 1);
     }
@@ -1098,14 +1109,13 @@ static void s_s3_prepare_upload_part_on_read_done(void *user_data) {
                 (void *)meta_request);
             goto on_done;
         }
-        struct aws_s3_upload_request_checksum_context *context = previously_uploaded_info->checksum_context;
         /* if previously uploaded part had a checksum, compare it to what we just skipped */
-        if (context != NULL && context->checksum_calculated == true &&
+        if (previously_uploaded_info->checksum_context.checksum_calculated == true &&
             s_verify_part_matches_checksum(
                 meta_request->allocator,
                 aws_byte_cursor_from_buf(&request->request_body),
                 meta_request->checksum_config.checksum_algorithm,
-                aws_byte_cursor_from_buf(&context->base64_checksum))) {
+                aws_byte_cursor_from_buf(&previously_uploaded_info->checksum_context.base64_checksum))) {
             error_code = aws_last_error_or_unknown();
             goto on_done;
         }
@@ -1152,9 +1162,9 @@ static void s_s3_prepare_upload_part_finish(struct aws_s3_prepare_upload_part_jo
             aws_s3_meta_request_lock_synced_data(meta_request);
             struct aws_s3_mpu_part_info *part = NULL;
             aws_array_list_get_at(&auto_ranged_put->synced_data.part_list, &part, request->part_number - 1);
-            AWS_ASSERT(part != NULL && part->checksum_context != NULL);
+            AWS_ASSERT(part != NULL);
             /* Use checksum context if available, otherwise NULL for new parts */
-            checksum_context = part->checksum_context;
+            checksum_context = &part->checksum_context;
             /* If checksum already calculated, it means either the part being retried or the part resumed from list
              * parts. Keep reusing the old checksum in case of the request body in memory mangled */
             AWS_ASSERT(
@@ -1229,12 +1239,7 @@ static int s_s3_review_multipart_upload(struct aws_s3_request *request) {
 
             struct aws_s3_upload_part_review *part_review = &review.part_array[part_index];
             part_review->size = part->size;
-            if (part->checksum_context != NULL) {
-                part_review->checksum =
-                    aws_s3_upload_request_checksum_context_get_checksum_cursor(part->checksum_context);
-            } else {
-                part_review->checksum = (struct aws_byte_cursor){.ptr = NULL, .len = 0};
-            }
+            part_review->checksum = aws_s3_upload_request_checksum_context_get_checksum_cursor(&part->checksum_context);
         }
     }
 
diff --git a/source/s3_checksum_context.c b/source/s3_checksum_context.c
@@ -8,27 +8,19 @@
 #include <aws/common/encoding.h>
 #include <aws/common/logging.h>
 
-static void s_aws_s3_upload_request_checksum_context_destroy(void *context) {
-    struct aws_s3_upload_request_checksum_context *checksum_context = context;
-    aws_byte_buf_clean_up(&checksum_context->base64_checksum);
-    aws_mem_release(checksum_context->allocator, checksum_context);
-}
-
-static struct aws_s3_upload_request_checksum_context *s_s3_upload_request_checksum_context_new_base(
+static int s_s3_upload_request_checksum_context_init_base(
     struct aws_allocator *allocator,
+    struct aws_s3_upload_request_checksum_context *context,
     const struct aws_s3_meta_request_checksum_config_storage *checksum_config) {
     AWS_PRECONDITION(allocator);
+    AWS_ZERO_STRUCT(*context);
 
-    struct aws_s3_upload_request_checksum_context *context =
-        aws_mem_calloc(allocator, 1, sizeof(struct aws_s3_upload_request_checksum_context));
-
-    aws_ref_count_init(&context->ref_count, context, s_aws_s3_upload_request_checksum_context_destroy);
     context->allocator = allocator;
     /* Handle case where no checksum config is provided */
     if (!checksum_config || checksum_config->checksum_algorithm == AWS_SCA_NONE) {
         context->algorithm = AWS_SCA_NONE;
         context->encoded_checksum_size = 0;
-        return context;
+        return AWS_OP_SUCCESS;
     }
 
     /* Extract configuration */
@@ -40,65 +32,60 @@ static struct aws_s3_upload_request_checksum_context *s_s3_upload_request_checks
     size_t encoded_size = 0;
     if (aws_base64_compute_encoded_len(context->encoded_checksum_size, &encoded_size)) {
         AWS_LOGF_ERROR(AWS_LS_S3_GENERAL, "Failed to compute base64 encoded length for checksum");
-        aws_s3_upload_request_checksum_context_release(context);
-        return NULL;
+        aws_s3_upload_request_checksum_context_clean_up(context);
+        return AWS_OP_ERR;
     }
     context->encoded_checksum_size = encoded_size;
-    return context;
+    return AWS_OP_SUCCESS;
 }
 
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new(
+int aws_s3_upload_request_checksum_context_init(
     struct aws_allocator *allocator,
+    struct aws_s3_upload_request_checksum_context *context,
     const struct aws_s3_meta_request_checksum_config_storage *checksum_config) {
-    struct aws_s3_upload_request_checksum_context *context =
-        s_s3_upload_request_checksum_context_new_base(allocator, checksum_config);
-    if (context && context->encoded_checksum_size > 0) {
-        /* Initial the buffer for checksum */
+    AWS_PRECONDITION(context);
+    AWS_PRECONDITION(allocator);
+    if (s_s3_upload_request_checksum_context_init_base(allocator, context, checksum_config) != AWS_OP_SUCCESS) {
+        return AWS_OP_ERR;
+    }
+    if (context->encoded_checksum_size > 0) {
+        /* Initialize the buffer for checksum */
         aws_byte_buf_init(&context->base64_checksum, allocator, context->encoded_checksum_size);
     }
-    return context;
+
+    return AWS_OP_SUCCESS;
 }
 
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new_with_existing_checksum(
+int aws_s3_upload_request_checksum_context_init_with_existing_checksum(
     struct aws_allocator *allocator,
+    struct aws_s3_upload_request_checksum_context *context,
     const struct aws_s3_meta_request_checksum_config_storage *checksum_config,
     struct aws_byte_cursor existing_checksum) {
-    struct aws_s3_upload_request_checksum_context *context =
-        s_s3_upload_request_checksum_context_new_base(allocator, checksum_config);
-    if (context) {
-        /* Initial the buffer for checksum from the exist checksum */
-        if (context->encoded_checksum_size != existing_checksum.len) {
-            struct aws_byte_cursor algo_name = aws_get_checksum_algorithm_name(context->algorithm);
-            AWS_LOGF_ERROR(
-                AWS_LS_S3_GENERAL,
-                "Encoded checksum size mismatch during creating the context for algorithm " PRInSTR
-                ": expected %zu bytes, got %zu bytes",
-                AWS_BYTE_CURSOR_PRI(algo_name),
-                context->encoded_checksum_size,
-                existing_checksum.len);
-            aws_s3_upload_request_checksum_context_release(context);
-            return NULL;
-        }
-        aws_byte_buf_init_copy_from_cursor(&context->base64_checksum, allocator, existing_checksum);
-        context->checksum_calculated = true;
+    AWS_PRECONDITION(context);
+    AWS_PRECONDITION(allocator);
+    if (s_s3_upload_request_checksum_context_init_base(allocator, context, checksum_config) != AWS_OP_SUCCESS) {
+        return AWS_OP_ERR;
     }
-    return context;
-}
 
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_acquire(
-    struct aws_s3_upload_request_checksum_context *context) {
-    if (context) {
-        aws_ref_count_acquire(&context->ref_count);
+    /* Check for size mismatch */
+    if (context->encoded_checksum_size != existing_checksum.len) {
+        struct aws_byte_cursor algo_name = aws_get_checksum_algorithm_name(context->algorithm);
+        AWS_LOGF_ERROR(
+            AWS_LS_S3_GENERAL,
+            "Encoded checksum size mismatch during initializing the context for algorithm " PRInSTR
+            ": expected %zu bytes, got %zu bytes",
+            AWS_BYTE_CURSOR_PRI(algo_name),
+            context->encoded_checksum_size,
+            existing_checksum.len);
+        aws_s3_upload_request_checksum_context_clean_up(context);
+        return AWS_OP_ERR;
     }
-    return context;
-}
-
-struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_release(
-    struct aws_s3_upload_request_checksum_context *context) {
-    if (context) {
-        aws_ref_count_release(&context->ref_count);
+    if (aws_byte_buf_init_copy_from_cursor(&context->base64_checksum, allocator, existing_checksum)) {
+        return AWS_OP_ERR;
     }
-    return NULL;
+    context->checksum_calculated = true;
+
+    return AWS_OP_SUCCESS;
 }
 
 bool aws_s3_upload_request_checksum_context_should_calculate(
@@ -145,3 +132,11 @@ struct aws_byte_cursor aws_s3_upload_request_checksum_context_get_checksum_curso
     }
     return aws_byte_cursor_from_buf(&context->base64_checksum);
 }
+
+void aws_s3_upload_request_checksum_context_clean_up(struct aws_s3_upload_request_checksum_context *context) {
+    if (!context) {
+        return;
+    }
+
+    aws_byte_buf_clean_up(&context->base64_checksum);
+}
diff --git a/source/s3_chunk_stream.c b/source/s3_chunk_stream.c
@@ -167,7 +167,6 @@ static void s_aws_input_chunk_stream_destroy(struct aws_chunk_stream *impl) {
         }
         aws_byte_buf_clean_up(&impl->pre_chunk_buffer);
         aws_byte_buf_clean_up(&impl->post_chunk_buffer);
-        aws_s3_upload_request_checksum_context_release(impl->checksum_context);
         aws_mem_release(impl->allocator, impl);
     }
 }
@@ -196,7 +195,7 @@ struct aws_input_stream *aws_chunk_stream_new(
     enum aws_s3_checksum_algorithm algorithm = AWS_SCA_NONE;
     struct aws_byte_buf *checksum_buffer = NULL;
 
-    impl->checksum_context = aws_s3_upload_request_checksum_context_acquire(checksum_context);
+    impl->checksum_context = checksum_context;
 
     algorithm = checksum_context->algorithm;
     checksum_buffer = &checksum_context->base64_checksum;
diff --git a/source/s3_copy_object.c b/source/s3_copy_object.c
@@ -125,7 +125,7 @@ static void s_s3_meta_request_copy_object_destroy(struct aws_s3_meta_request *me
         struct aws_s3_mpu_part_info *part = NULL;
         aws_array_list_get_at(&copy_object->synced_data.part_list, &part, part_index);
         aws_string_destroy(part->etag);
-        aws_s3_upload_request_checksum_context_release(part->checksum_context);
+        aws_s3_upload_request_checksum_context_clean_up(&part->checksum_context);
         aws_mem_release(meta_request->allocator, part);
     }
 
diff --git a/source/s3_default_meta_request.c b/source/s3_default_meta_request.c
@@ -354,13 +354,15 @@ static void s_s3_default_prepare_request_finish(
         /* Only PUT Object and Upload part support trailing checksum, that needs the special encoding even if the body
          * has 0 length. */
         /* Create checksum context from config if needed */
-        struct aws_s3_upload_request_checksum_context *checksum_context =
-            aws_s3_upload_request_checksum_context_new(meta_request->allocator, &meta_request->checksum_config);
+        struct aws_s3_upload_request_checksum_context checksum_context;
 
-        aws_s3_message_util_assign_body(meta_request->allocator, &request->request_body, message, checksum_context);
+        aws_s3_upload_request_checksum_context_init(
+            meta_request->allocator, &checksum_context, &meta_request->checksum_config);
+
+        aws_s3_message_util_assign_body(meta_request->allocator, &request->request_body, message, &checksum_context);
 
         /* Release the context reference */
-        aws_s3_upload_request_checksum_context_release(checksum_context);
+        aws_s3_upload_request_checksum_context_clean_up(&checksum_context);
     }
     aws_s3_request_setup_send_data(request, message);
 
diff --git a/source/s3_request_messages.c b/source/s3_request_messages.c
diff --git a/tests/s3_checksum_context_test.c b/tests/s3_checksum_context_test.c
diff --git a/tests/s3_checksum_stream_test.c b/tests/s3_checksum_stream_test.c

Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,6 @@ static void s_aws_input_chunk_stream_destroy(struct aws_chunk_stream *impl) {`
`167`	`167`	`}`
`168`	`168`	`aws_byte_buf_clean_up(&impl->pre_chunk_buffer);`
`169`	`169`	`aws_byte_buf_clean_up(&impl->post_chunk_buffer);`
`170`		`- aws_s3_upload_request_checksum_context_release(impl->checksum_context);`
`171`	`170`	`aws_mem_release(impl->allocator, impl);`
`172`	`171`	`}`
`173`	`172`	`}`
`@@ -196,7 +195,7 @@ struct aws_input_stream *aws_chunk_stream_new(`
`196`	`195`	`enum aws_s3_checksum_algorithm algorithm = AWS_SCA_NONE;`
`197`	`196`	`struct aws_byte_buf *checksum_buffer = NULL;`
`198`	`197`
`199`		`- impl->checksum_context = aws_s3_upload_request_checksum_context_acquire(checksum_context);`
	`198`	`+ impl->checksum_context = checksum_context;`
`200`	`199`
`201`	`200`	`algorithm = checksum_context->algorithm;`
`202`	`201`	`checksum_buffer = &checksum_context->base64_checksum;`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ static void s_s3_meta_request_copy_object_destroy(struct aws_s3_meta_request *me`
`125`	`125`	`struct aws_s3_mpu_part_info *part = NULL;`
`126`	`126`	`aws_array_list_get_at(&copy_object->synced_data.part_list, &part, part_index);`
`127`	`127`	`aws_string_destroy(part->etag);`
`128`		`- aws_s3_upload_request_checksum_context_release(part->checksum_context);`
	`128`	`+ aws_s3_upload_request_checksum_context_clean_up(&part->checksum_context);`
`129`	`129`	`aws_mem_release(meta_request->allocator, part);`
`130`	`130`	`}`
`131`	`131`