Revert "store by value"

TingDaoK · TingDaoK · commit 32ddbd3a449d · 2025-07-03T17:00:33.000-07:00
This reverts commit 7cf67ce.
diff --git a/include/aws/s3/private/s3_checksum_context.h b/include/aws/s3/private/s3_checksum_context.h
@@ -22,6 +22,7 @@ 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;
@@ -36,45 +37,56 @@ struct aws_s3_upload_request_checksum_context {
 };
 
 /**
- * Initialize an upload request checksum context from configuration and buffer parameters.
+ * Create a new 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 AWS_OP_SUCCESS or AWS_OP_ERR
+ * @return New checksum context or NULL on error
  */
 AWS_S3_API
-int aws_s3_upload_request_checksum_context_init(
+struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new(
     struct aws_allocator *allocator,
-    struct aws_s3_upload_request_checksum_context *context,
     const struct aws_s3_meta_request_checksum_config_storage *checksum_config);
 
 /**
- * Initialize an upload request checksum context with an existing checksum value.
+ * Create a new 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 AWS_OP_SUCCESS or AWS_OP_ERR (e.g., if checksum size doesn't match algorithm)
+ * @return New checksum context or NULL on error (e.g., if checksum size doesn't match algorithm)
  */
 AWS_S3_API
-int aws_s3_upload_request_checksum_context_init_with_existing_checksum(
+struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new_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);
 
 /**
- * Clean up resources associated with an upload request checksum context.
- * This does not free the context itself, just its internal resources.
+ * Acquire a reference to the upload request checksum context.
+ * Use this when transferring ownership to another function/structure.
  *
- * @param context Pointer to the checksum context to clean up
+ * @param context The checksum context to acquire
+ * @return The same context pointer (for convenience)
  */
 AWS_S3_API
-void aws_s3_upload_request_checksum_context_clean_up(struct aws_s3_upload_request_checksum_context *context);
+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);
 
 /**
  * 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,7 +14,6 @@
 #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"
@@ -26,6 +25,7 @@ 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,22 +154,16 @@ static int s_process_part_info_synced(const struct aws_s3_part_info *info, void
     }
 
     if ((checksum_cur != NULL) && (checksum_cur->len > 0)) {
-        /* 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;
-        }
+        /* 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);
     } else {
-        /* 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;
-        }
+        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;
     }
     /* Parts might be out of order or have gaps in them.
      * Resize array-list to be long enough to hold this part,
@@ -421,7 +415,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_clean_up(&part->checksum_context);
+            aws_s3_upload_request_checksum_context_release(part->checksum_context);
             aws_string_destroy(part->etag);
             aws_mem_release(auto_ranged_put->base.allocator, part);
         }
@@ -1082,13 +1076,8 @@ 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));
-        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->checksum_context =
+            aws_s3_upload_request_checksum_context_new(meta_request->allocator, &meta_request->checksum_config);
         part->size = request->request_body.len;
         aws_array_list_set_at(&auto_ranged_put->synced_data.part_list, &part, request->part_number - 1);
     }
@@ -1109,13 +1098,14 @@ 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 (previously_uploaded_info->checksum_context.checksum_calculated == true &&
+        if (context != NULL && 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(&previously_uploaded_info->checksum_context.base64_checksum))) {
+                aws_byte_cursor_from_buf(&context->base64_checksum))) {
             error_code = aws_last_error_or_unknown();
             goto on_done;
         }
@@ -1162,9 +1152,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);
+            AWS_ASSERT(part != NULL && part->checksum_context != 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(
@@ -1239,7 +1229,12 @@ 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;
-            part_review->checksum = aws_s3_upload_request_checksum_context_get_checksum_cursor(&part->checksum_context);
+            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};
+            }
         }
     }
 
diff --git a/source/s3_checksum_context.c b/source/s3_checksum_context.c
@@ -8,19 +8,27 @@
 #include <aws/common/encoding.h>
 #include <aws/common/logging.h>
 
-static int s_s3_upload_request_checksum_context_init_base(
+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(
     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 AWS_OP_SUCCESS;
+        return context;
     }
 
     /* Extract configuration */
@@ -32,60 +40,65 @@ static int s_s3_upload_request_checksum_context_init_base(
     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_clean_up(context);
-        return AWS_OP_ERR;
+        aws_s3_upload_request_checksum_context_release(context);
+        return NULL;
     }
     context->encoded_checksum_size = encoded_size;
-    return AWS_OP_SUCCESS;
+    return context;
 }
 
-int aws_s3_upload_request_checksum_context_init(
+struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new(
     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(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 */
+    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_byte_buf_init(&context->base64_checksum, allocator, context->encoded_checksum_size);
     }
-
-    return AWS_OP_SUCCESS;
+    return context;
 }
 
-int aws_s3_upload_request_checksum_context_init_with_existing_checksum(
+struct aws_s3_upload_request_checksum_context *aws_s3_upload_request_checksum_context_new_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) {
-    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;
+    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;
     }
+    return context;
+}
 
-    /* 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;
-    }
-    if (aws_byte_buf_init_copy_from_cursor(&context->base64_checksum, allocator, existing_checksum)) {
-        return AWS_OP_ERR;
+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);
     }
-    context->checksum_calculated = true;
+    return context;
+}
 
-    return AWS_OP_SUCCESS;
+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);
+    }
+    return NULL;
 }
 
 bool aws_s3_upload_request_checksum_context_should_calculate(
@@ -132,11 +145,3 @@ 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,6 +167,7 @@ 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);
     }
 }
@@ -195,7 +196,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 = checksum_context;
+    impl->checksum_context = aws_s3_upload_request_checksum_context_acquire(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_clean_up(&part->checksum_context);
+        aws_s3_upload_request_checksum_context_release(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,15 +354,13 @@ 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;
+        struct aws_s3_upload_request_checksum_context *checksum_context =
+            aws_s3_upload_request_checksum_context_new(meta_request->allocator, &meta_request->checksum_config);
 
-        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);
+        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_clean_up(&checksum_context);
+        aws_s3_upload_request_checksum_context_release(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,6 +167,7 @@ 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);`
`170`	`171`	`aws_mem_release(impl->allocator, impl);`
`171`	`172`	`}`
`172`	`173`	`}`
`@@ -195,7 +196,7 @@ struct aws_input_stream *aws_chunk_stream_new(`
`195`	`196`	`enum aws_s3_checksum_algorithm algorithm = AWS_SCA_NONE;`
`196`	`197`	`struct aws_byte_buf *checksum_buffer = NULL;`
`197`	`198`
`198`		`- impl->checksum_context = checksum_context;`
	`199`	`+ impl->checksum_context = aws_s3_upload_request_checksum_context_acquire(checksum_context);`
`199`	`200`
`200`	`201`	`algorithm = checksum_context->algorithm;`
`201`	`202`	`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_clean_up(&part->checksum_context);`
	`128`	`+ aws_s3_upload_request_checksum_context_release(part->checksum_context);`
`129`	`129`	`aws_mem_release(meta_request->allocator, part);`
`130`	`130`	`}`
`131`	`131`