| /** |
| * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. |
| * SPDX-License-Identifier: Apache-2.0. |
| */ |
| #include "aws_signing.h" |
| #include "credentials.h" |
| #include "crt.h" |
| #include "http_request_utils.h" |
| #include "java_class_ids.h" |
| #include "retry_utils.h" |
| #include <aws/common/string.h> |
| #include <aws/http/connection.h> |
| #include <aws/http/proxy.h> |
| #include <aws/http/request_response.h> |
| #include <aws/io/channel_bootstrap.h> |
| #include <aws/io/retry_strategy.h> |
| #include <aws/io/stream.h> |
| #include <aws/io/tls_channel_handler.h> |
| #include <aws/io/uri.h> |
| #include <aws/s3/s3_client.h> |
| #include <aws/s3/s3express_credentials_provider.h> |
| #include <http_proxy_options.h> |
| #include <http_proxy_options_environment_variable.h> |
| #include <jni.h> |
| |
| /* on 32-bit platforms, casting pointers to longs throws a warning we don't need */ |
| #if UINTPTR_MAX == 0xffffffff |
| # if defined(_MSC_VER) |
| # pragma warning(push) |
| # pragma warning(disable : 4305) /* 'type cast': truncation from 'jlong' to 'jni_tls_ctx_options *' */ |
| # pragma warning(disable : 4221) |
| # else |
| # pragma GCC diagnostic push |
| # pragma GCC diagnostic ignored "-Wpointer-to-int-cast" |
| # pragma GCC diagnostic ignored "-Wint-to-pointer-cast" |
| # endif |
| #endif |
| |
| struct s3_client_callback_data { |
| JavaVM *jvm; |
| jobject java_s3_client; |
| struct aws_signing_config_data signing_config_data; |
| jobject java_s3express_provider_factory; |
| }; |
| |
| struct s3_client_make_meta_request_callback_data { |
| JavaVM *jvm; |
| jobject java_s3_meta_request; |
| jobject java_s3_meta_request_response_handler_native_adapter; |
| struct aws_input_stream *input_stream; |
| struct aws_signing_config_data signing_config_data; |
| jthrowable java_exception; |
| }; |
| |
| static void s_on_s3_client_shutdown_complete_callback(void *user_data); |
| static void s_on_s3_meta_request_shutdown_complete_callback(void *user_data); |
| |
| int aws_s3_tcp_keep_alive_options_from_java( |
| JNIEnv *env, |
| jobject jni_s3_tcp_keep_alive_options, |
| struct aws_s3_tcp_keep_alive_options *s3_tcp_keep_alive_options) { |
| |
| uint16_t jni_keep_alive_interval_sec = (*env)->GetShortField( |
| env, jni_s3_tcp_keep_alive_options, s3_tcp_keep_alive_options_properties.keep_alive_interval_sec_field_id); |
| |
| uint16_t jni_keep_alive_timeout_sec = (*env)->GetShortField( |
| env, jni_s3_tcp_keep_alive_options, s3_tcp_keep_alive_options_properties.keep_alive_timeout_sec_field_id); |
| |
| uint16_t jni_keep_alive_max_failed_probes = (*env)->GetShortField( |
| env, jni_s3_tcp_keep_alive_options, s3_tcp_keep_alive_options_properties.keep_alive_max_failed_probes_field_id); |
| |
| AWS_ZERO_STRUCT(*s3_tcp_keep_alive_options); |
| |
| s3_tcp_keep_alive_options->keep_alive_interval_sec = jni_keep_alive_interval_sec; |
| s3_tcp_keep_alive_options->keep_alive_timeout_sec = jni_keep_alive_timeout_sec; |
| s3_tcp_keep_alive_options->keep_alive_max_failed_probes = jni_keep_alive_max_failed_probes; |
| |
| return AWS_OP_SUCCESS; |
| } |
| |
| struct s3_client_s3express_provider_java_impl { |
| JavaVM *jvm; |
| jobject java_s3express_provider; |
| }; |
| |
| struct s3_client_s3express_provider_callback_data { |
| void *log_id; |
| aws_on_get_credentials_callback_fn *get_cred_callback; |
| void *get_cred_user_data; |
| }; |
| |
| JNIEXPORT void JNICALL |
| Java_software_amazon_awssdk_crt_s3_S3ExpressCredentialsProvider_s3expressCredentialsProviderGetCredentialsCompleted( |
| JNIEnv *env, |
| jclass jni_class, |
| jlong nativeHandler, |
| jobject java_credentials) { |
| |
| (void)jni_class; |
| struct s3_client_s3express_provider_callback_data *callback_data = (void *)nativeHandler; |
| struct aws_credentials *native_credentials = NULL; |
| int error_code = AWS_ERROR_SUCCESS; |
| |
| if (!java_credentials || aws_jni_check_and_clear_exception(env)) { |
| /* TODO: a separate error code?? */ |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Failed to get S3Express credentials from Java", |
| (void *)callback_data->log_id); |
| error_code = AWS_ERROR_HTTP_CALLBACK_FAILURE; |
| goto done; |
| } |
| |
| native_credentials = aws_credentials_new_from_java_credentials(env, java_credentials); |
| if (!native_credentials) { |
| aws_jni_throw_runtime_exception(env, "Failed to create native credentials"); |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Failed to create native credentials from Java", |
| (void *)callback_data->log_id); |
| goto done; |
| } |
| struct aws_byte_cursor session_token = aws_credentials_get_session_token(native_credentials); |
| |
| if (session_token.len == 0) { |
| aws_jni_throw_runtime_exception(env, "S3ExpressCredentialsProvider - sessionToken must be non-null"); |
| error_code = AWS_ERROR_HTTP_CALLBACK_FAILURE; |
| aws_credentials_release(native_credentials); |
| native_credentials = NULL; |
| goto done; |
| } |
| |
| done: |
| callback_data->get_cred_callback(native_credentials, error_code, callback_data->get_cred_user_data); |
| aws_credentials_release(native_credentials); |
| aws_mem_release(aws_jni_get_allocator(), callback_data); |
| } |
| |
| static int s_s3express_get_creds_java( |
| struct aws_s3express_credentials_provider *provider, |
| const struct aws_credentials *original_credentials, |
| const struct aws_credentials_properties_s3express *s3express_properties, |
| aws_on_get_credentials_callback_fn callback, |
| void *user_data) { |
| |
| struct s3_client_s3express_provider_java_impl *impl = provider->impl; |
| int result = AWS_OP_ERR; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(impl->jvm); |
| if (!env) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return AWS_OP_SUCCESS; |
| } |
| jobject properties_object = NULL; |
| jobject original_credentials_object = NULL; |
| |
| properties_object = (*env)->NewObject( |
| env, |
| s3express_credentials_properties_properties.s3express_credentials_properties_class, |
| s3express_credentials_properties_properties.constructor_method_id); |
| if ((*env)->ExceptionCheck(env) || properties_object == NULL) { |
| aws_jni_throw_runtime_exception( |
| env, |
| "S3ExpressCredentialsProvider.getS3ExpressCredentials: Failed to create S3ExpressCredentialsProperties " |
| "object."); |
| goto done; |
| } |
| original_credentials_object = aws_java_credentials_from_native_new(env, original_credentials); |
| if ((*env)->ExceptionCheck(env) || original_credentials_object == NULL) { |
| aws_jni_throw_runtime_exception( |
| env, "S3ExpressCredentialsProvider.getS3ExpressCredentials: Failed to create Credentials object."); |
| goto done; |
| } |
| |
| jstring jni_host = aws_jni_string_from_cursor(env, &s3express_properties->host); |
| jstring jni_region = aws_jni_string_from_cursor(env, &s3express_properties->region); |
| (*env)->SetObjectField(env, properties_object, s3express_credentials_properties_properties.host_field_id, jni_host); |
| (*env)->SetObjectField( |
| env, properties_object, s3express_credentials_properties_properties.region_field_id, jni_region); |
| (*env)->DeleteLocalRef(env, jni_host); |
| (*env)->DeleteLocalRef(env, jni_region); |
| |
| struct s3_client_s3express_provider_callback_data *callback_data = |
| aws_mem_calloc(aws_jni_get_allocator(), 1, sizeof(struct s3_client_s3express_provider_callback_data)); |
| |
| callback_data->get_cred_callback = callback; |
| callback_data->get_cred_user_data = user_data; |
| callback_data->log_id = impl->java_s3express_provider; |
| |
| /* Invoke the java call */ |
| (*env)->CallVoidMethod( |
| env, |
| impl->java_s3express_provider, |
| s3express_credentials_provider_properties.getS3ExpressCredentials, |
| properties_object, |
| original_credentials_object, |
| (jlong)callback_data); |
| |
| if (aws_jni_check_and_clear_exception(env)) { |
| /* Check if any exception raised */ |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: S3ExpressCredentialsProvider.getS3ExpressCredentials failed", |
| (void *)impl->java_s3express_provider); |
| aws_mem_release(aws_jni_get_allocator(), callback_data); |
| goto done; |
| } |
| result = AWS_OP_SUCCESS; |
| done: |
| if (properties_object) { |
| (*env)->DeleteLocalRef(env, properties_object); |
| } |
| if (original_credentials_object) { |
| (*env)->DeleteLocalRef(env, original_credentials_object); |
| } |
| aws_jni_release_thread_env(impl->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| return result; |
| } |
| |
| static void s_s3express_destroy_java(struct aws_s3express_credentials_provider *provider) { |
| struct s3_client_s3express_provider_java_impl *impl = provider->impl; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(impl->jvm); |
| if (!env) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return; |
| } |
| /* Invoke the java call */ |
| (*env)->CallVoidMethod( |
| env, impl->java_s3express_provider, s3express_credentials_provider_properties.destroyProvider); |
| |
| (*env)->DeleteGlobalRef(env, impl->java_s3express_provider); |
| |
| aws_jni_release_thread_env(impl->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| /* Once the java call returns, the java resource should be cleaned up already. We can finish up the shutdown |
| * process. Clean up the native part. */ |
| aws_simple_completion_callback *callback = provider->shutdown_complete_callback; |
| void *user_data = provider->shutdown_user_data; |
| aws_mem_release(provider->allocator, provider); |
| callback(user_data); |
| } |
| |
| static struct aws_s3express_credentials_provider_vtable s_java_s3express_vtable = { |
| .get_credentials = s_s3express_get_creds_java, |
| .destroy = s_s3express_destroy_java, |
| }; |
| |
| struct aws_s3express_credentials_provider *s_s3express_provider_jni_factory( |
| struct aws_allocator *allocator, |
| struct aws_s3_client *client, |
| aws_simple_completion_callback shutdown_complete_callback, |
| void *shutdown_user_data, |
| void *factory_user_data) { |
| |
| (void)client; |
| struct s3_client_callback_data *client_data = factory_user_data; |
| |
| struct aws_s3express_credentials_provider *provider = NULL; |
| struct s3_client_s3express_provider_java_impl *impl = NULL; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(client_data->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return NULL; |
| } |
| |
| aws_mem_acquire_many( |
| allocator, |
| 2, |
| &provider, |
| sizeof(struct aws_s3express_credentials_provider), |
| &impl, |
| sizeof(struct s3_client_s3express_provider_java_impl)); |
| /* Call into the java factory to create the java impl */ |
| AWS_FATAL_ASSERT(client_data->java_s3express_provider_factory != NULL); |
| jobject java_s3express_provider = (*env)->CallObjectMethod( |
| env, |
| client_data->java_s3express_provider_factory, |
| s3express_credentials_provider_factory_properties.createS3ExpressCredentialsProvider, |
| client_data->java_s3_client); |
| |
| if (aws_jni_check_and_clear_exception(env)) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Failed to create Java S3Express Provider", |
| (void *)client_data->java_s3express_provider_factory); |
| aws_mem_release(allocator, provider); |
| provider = NULL; |
| goto done; |
| } |
| impl->java_s3express_provider = (*env)->NewGlobalRef(env, java_s3express_provider); |
| |
| jint jvmresult = (*env)->GetJavaVM(env, &impl->jvm); |
| (void)jvmresult; |
| AWS_FATAL_ASSERT(jvmresult == 0); |
| |
| aws_s3express_credentials_provider_init_base(provider, allocator, &s_java_s3express_vtable, impl); |
| provider->shutdown_complete_callback = shutdown_complete_callback; |
| provider->shutdown_user_data = shutdown_user_data; |
| |
| /* We are done using the factory, when succeed, clean it up. TODO: we don't have to clean it up here */ |
| (*env)->DeleteGlobalRef(env, client_data->java_s3express_provider_factory); |
| client_data->java_s3express_provider_factory = NULL; |
| |
| done: |
| aws_jni_release_thread_env(client_data->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| return provider; |
| } |
| |
| JNIEXPORT jlong JNICALL Java_software_amazon_awssdk_crt_s3_S3Client_s3ClientNew( |
| JNIEnv *env, |
| jclass jni_class, |
| jobject s3_client_jobject, |
| jbyteArray jni_region, |
| jlong jni_client_bootstrap, |
| jlong jni_tls_ctx, |
| jobject java_signing_config, |
| jlong part_size_jlong, |
| jlong multipart_upload_threshold_jlong, |
| jdouble throughput_target_gbps, |
| jboolean enable_read_backpressure, |
| jlong initial_read_window_jlong, |
| int max_connections, |
| jobject jni_standard_retry_options, |
| jboolean compute_content_md5, |
| jint jni_proxy_connection_type, |
| jbyteArray jni_proxy_host, |
| jint jni_proxy_port, |
| jlong jni_proxy_tls_context, |
| jint jni_proxy_authorization_type, |
| jbyteArray jni_proxy_authorization_username, |
| jbyteArray jni_proxy_authorization_password, |
| jint jni_environment_variable_proxy_connection_type, |
| jlong jni_environment_variable_proxy_tls_connection_options, |
| jint jni_environment_variable_type, |
| int connect_timeout_ms, |
| jobject jni_s3_tcp_keep_alive_options, |
| jlong jni_monitoring_throughput_threshold_in_bytes_per_second, |
| jint jni_monitoring_failure_interval_in_seconds, |
| jboolean enable_s3express, |
| jobject java_s3express_provider_factory, |
| jlong jni_memory_limit_bytes_jlong) { |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_allocator *allocator = aws_jni_get_allocator(); |
| |
| struct aws_client_bootstrap *client_bootstrap = (struct aws_client_bootstrap *)jni_client_bootstrap; |
| |
| if (!client_bootstrap) { |
| aws_jni_throw_illegal_argument_exception(env, "Invalid Client Bootstrap"); |
| return (jlong)NULL; |
| } |
| |
| uint64_t part_size = (uint64_t)part_size_jlong; |
| uint64_t multipart_upload_threshold = (uint64_t)multipart_upload_threshold_jlong; |
| uint64_t memory_limit_in_bytes = (uint64_t)jni_memory_limit_bytes_jlong; |
| |
| size_t initial_read_window; |
| if (aws_size_t_from_java(env, &initial_read_window, initial_read_window_jlong, "Initial read window")) { |
| return (jlong)NULL; |
| } |
| |
| struct aws_retry_strategy *retry_strategy = NULL; |
| |
| if (jni_standard_retry_options != NULL) { |
| struct aws_standard_retry_options retry_options; |
| |
| if (aws_standard_retry_options_from_java(env, jni_standard_retry_options, &retry_options)) { |
| return (jlong)NULL; |
| } |
| |
| if (retry_options.backoff_retry_options.el_group == NULL) { |
| retry_options.backoff_retry_options.el_group = client_bootstrap->event_loop_group; |
| } |
| |
| retry_strategy = aws_retry_strategy_new_standard(allocator, &retry_options); |
| |
| if (retry_strategy == NULL) { |
| aws_jni_throw_runtime_exception(env, "Could not create retry strategy with standard-retry-options"); |
| return (jlong)NULL; |
| } |
| } |
| struct aws_s3_tcp_keep_alive_options *s3_tcp_keep_alive_options = NULL; |
| |
| if (jni_s3_tcp_keep_alive_options != NULL) { |
| s3_tcp_keep_alive_options = aws_mem_calloc(allocator, 1, sizeof(struct aws_s3_tcp_keep_alive_options)); |
| if (aws_s3_tcp_keep_alive_options_from_java(env, jni_s3_tcp_keep_alive_options, s3_tcp_keep_alive_options)) { |
| aws_jni_throw_runtime_exception(env, "Could not create s3_tcp_keep_alive_options"); |
| return (jlong)NULL; |
| } |
| } |
| |
| struct aws_byte_cursor region = aws_jni_byte_cursor_from_jbyteArray_acquire(env, jni_region); |
| |
| struct s3_client_callback_data *callback_data = |
| aws_mem_calloc(allocator, 1, sizeof(struct s3_client_callback_data)); |
| |
| struct aws_signing_config_aws signing_config; |
| struct aws_credentials *anonymous_credentials = NULL; |
| AWS_ZERO_STRUCT(signing_config); |
| if (java_signing_config != NULL) { |
| if (aws_build_signing_config(env, java_signing_config, &callback_data->signing_config_data, &signing_config)) { |
| aws_jni_throw_runtime_exception(env, "Invalid signingConfig"); |
| aws_mem_release(allocator, callback_data); |
| return (jlong)NULL; |
| } |
| } else { |
| anonymous_credentials = aws_credentials_new_anonymous(allocator); |
| signing_config.credentials = anonymous_credentials; |
| } |
| |
| if (java_s3express_provider_factory != NULL && enable_s3express) { |
| /* Create a JNI factory */ |
| callback_data->java_s3express_provider_factory = (*env)->NewGlobalRef(env, java_s3express_provider_factory); |
| } |
| |
| AWS_FATAL_ASSERT(callback_data); |
| callback_data->java_s3_client = (*env)->NewGlobalRef(env, s3_client_jobject); |
| |
| jint jvmresult = (*env)->GetJavaVM(env, &callback_data->jvm); |
| (void)jvmresult; |
| AWS_FATAL_ASSERT(jvmresult == 0); |
| |
| struct aws_tls_connection_options *tls_options = NULL; |
| struct aws_tls_connection_options tls_options_storage; |
| AWS_ZERO_STRUCT(tls_options_storage); |
| if (jni_tls_ctx) { |
| struct aws_tls_ctx *tls_ctx = (void *)jni_tls_ctx; |
| tls_options = &tls_options_storage; |
| aws_tls_connection_options_init_from_ctx(tls_options, tls_ctx); |
| } |
| |
| struct aws_s3_client_config client_config = { |
| .max_active_connections_override = max_connections, |
| .region = region, |
| .client_bootstrap = client_bootstrap, |
| .tls_connection_options = tls_options, |
| .signing_config = &signing_config, |
| .part_size = part_size, |
| .multipart_upload_threshold = multipart_upload_threshold, |
| .throughput_target_gbps = throughput_target_gbps, |
| .enable_read_backpressure = enable_read_backpressure, |
| .initial_read_window = initial_read_window, |
| .retry_strategy = retry_strategy, |
| .shutdown_callback = s_on_s3_client_shutdown_complete_callback, |
| .shutdown_callback_user_data = callback_data, |
| .compute_content_md5 = compute_content_md5 ? AWS_MR_CONTENT_MD5_ENABLED : AWS_MR_CONTENT_MD5_DISABLED, |
| .connect_timeout_ms = connect_timeout_ms, |
| .tcp_keep_alive_options = s3_tcp_keep_alive_options, |
| .enable_s3express = enable_s3express, |
| .s3express_provider_override_factory = |
| java_s3express_provider_factory ? s_s3express_provider_jni_factory : NULL, |
| .factory_user_data = callback_data, |
| .memory_limit_in_bytes = memory_limit_in_bytes, |
| }; |
| |
| struct aws_http_connection_monitoring_options monitoring_options; |
| AWS_ZERO_STRUCT(monitoring_options); |
| if (jni_monitoring_throughput_threshold_in_bytes_per_second >= 0 && |
| jni_monitoring_failure_interval_in_seconds >= 2) { |
| monitoring_options.minimum_throughput_bytes_per_second = |
| jni_monitoring_throughput_threshold_in_bytes_per_second; |
| monitoring_options.allowable_throughput_failure_interval_seconds = jni_monitoring_failure_interval_in_seconds; |
| client_config.monitoring_options = &monitoring_options; |
| } |
| |
| struct aws_http_proxy_options proxy_options; |
| AWS_ZERO_STRUCT(proxy_options); |
| |
| struct aws_tls_connection_options proxy_tls_conn_options; |
| AWS_ZERO_STRUCT(proxy_tls_conn_options); |
| |
| aws_http_proxy_options_jni_init( |
| env, |
| &proxy_options, |
| jni_proxy_connection_type, |
| &proxy_tls_conn_options, |
| jni_proxy_host, |
| jni_proxy_port, |
| jni_proxy_authorization_username, |
| jni_proxy_authorization_password, |
| jni_proxy_authorization_type, |
| (struct aws_tls_ctx *)jni_proxy_tls_context); |
| |
| if (jni_proxy_host != NULL) { |
| client_config.proxy_options = &proxy_options; |
| } |
| |
| struct proxy_env_var_settings proxy_ev_settings; |
| AWS_ZERO_STRUCT(proxy_ev_settings); |
| |
| aws_http_proxy_environment_variable_setting_jni_init( |
| &proxy_ev_settings, |
| jni_environment_variable_proxy_connection_type, |
| jni_environment_variable_type, |
| (struct aws_tls_connection_options *)jni_environment_variable_proxy_tls_connection_options); |
| |
| client_config.proxy_ev_settings = &proxy_ev_settings; |
| |
| struct aws_s3_client *client = aws_s3_client_new(allocator, &client_config); |
| if (!client) { |
| aws_jni_throw_runtime_exception(env, "S3Client.aws_s3_client_new: creating aws_s3_client failed"); |
| /* Clean up stuff */ |
| aws_signing_config_data_clean_up(&callback_data->signing_config_data, env); |
| aws_mem_release(allocator, callback_data); |
| } |
| aws_credentials_release(anonymous_credentials); |
| |
| aws_retry_strategy_release(retry_strategy); |
| |
| aws_jni_byte_cursor_from_jbyteArray_release(env, jni_region, region); |
| |
| aws_http_proxy_options_jni_clean_up( |
| env, &proxy_options, jni_proxy_host, jni_proxy_authorization_username, jni_proxy_authorization_password); |
| |
| aws_mem_release(aws_jni_get_allocator(), s3_tcp_keep_alive_options); |
| |
| return (jlong)client; |
| } |
| |
| JNIEXPORT void JNICALL |
| Java_software_amazon_awssdk_crt_s3_S3Client_s3ClientDestroy(JNIEnv *env, jclass jni_class, jlong jni_s3_client) { |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_s3_client *client = (struct aws_s3_client *)jni_s3_client; |
| if (!client) { |
| aws_jni_throw_runtime_exception(env, "S3Client.s3_client_clean_up: Invalid/null client"); |
| return; |
| } |
| |
| aws_s3_client_release(client); |
| } |
| |
| static void s_on_s3_client_shutdown_complete_callback(void *user_data) { |
| struct s3_client_callback_data *callback = (struct s3_client_callback_data *)user_data; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(callback->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return; |
| } |
| |
| AWS_LOGF_DEBUG(AWS_LS_S3_CLIENT, "S3 Client Shutdown Complete"); |
| if (callback->java_s3_client != NULL) { |
| (*env)->CallVoidMethod(env, callback->java_s3_client, s3_client_properties.onShutdownComplete); |
| |
| if (aws_jni_check_and_clear_exception(env)) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Ignored Exception from S3Client.onShutdownCompete callback", |
| (void *)callback->java_s3_client); |
| } |
| } |
| |
| // We're done with this callback data, free it. |
| if (callback->java_s3express_provider_factory) { |
| /* Clean up factory data if still exist */ |
| (*env)->DeleteGlobalRef(env, callback->java_s3express_provider_factory); |
| callback->java_s3express_provider_factory = NULL; |
| } |
| (*env)->DeleteGlobalRef(env, callback->java_s3_client); |
| |
| aws_signing_config_data_clean_up(&callback->signing_config_data, env); |
| |
| aws_jni_release_thread_env(callback->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| |
| aws_mem_release(aws_jni_get_allocator(), user_data); |
| } |
| |
| static int s_on_s3_meta_request_body_callback( |
| struct aws_s3_meta_request *meta_request, |
| const struct aws_byte_cursor *body, |
| uint64_t range_start, |
| void *user_data) { |
| (void)body; |
| (void)range_start; |
| int return_value = AWS_OP_ERR; |
| |
| uint64_t range_end = range_start + body->len; |
| |
| struct s3_client_make_meta_request_callback_data *callback_data = |
| (struct s3_client_make_meta_request_callback_data *)user_data; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(callback_data->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return AWS_OP_ERR; |
| } |
| |
| jobject jni_payload = aws_jni_byte_array_from_cursor(env, body); |
| if (jni_payload == NULL) { |
| /* JVM is out of memory, but native code can still have memory available, handle it and don't crash. */ |
| aws_jni_check_and_clear_exception(env); |
| aws_jni_release_thread_env(callback_data->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| return aws_raise_error(AWS_ERROR_JAVA_CRT_JVM_OUT_OF_MEMORY); |
| } |
| |
| jint body_response_result = 0; |
| |
| if (callback_data->java_s3_meta_request_response_handler_native_adapter != NULL) { |
| body_response_result = (*env)->CallIntMethod( |
| env, |
| callback_data->java_s3_meta_request_response_handler_native_adapter, |
| s3_meta_request_response_handler_native_adapter_properties.onResponseBody, |
| jni_payload, |
| range_start, |
| range_end); |
| |
| if (aws_jni_get_and_clear_exception(env, &(callback_data->java_exception))) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Received exception from S3MetaRequest.onResponseBody callback", |
| (void *)meta_request); |
| aws_raise_error(AWS_ERROR_HTTP_CALLBACK_FAILURE); |
| goto cleanup; |
| } |
| |
| /* The Java onResponseBody API lets users return a size for auto-incrementing the read window */ |
| if (body_response_result > 0) { |
| aws_s3_meta_request_increment_read_window(meta_request, (uint64_t)body_response_result); |
| } |
| } |
| return_value = AWS_OP_SUCCESS; |
| |
| cleanup: |
| (*env)->DeleteLocalRef(env, jni_payload); |
| |
| aws_jni_release_thread_env(callback_data->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| |
| return return_value; |
| } |
| |
| static int s_marshal_http_headers_to_buf(const struct aws_http_headers *headers, struct aws_byte_buf *out_headers_buf) { |
| /* calculate initial header capacity */ |
| size_t headers_initial_capacity = 0; |
| for (size_t header_index = 0; header_index < aws_http_headers_count(headers); ++header_index) { |
| struct aws_http_header header; |
| aws_http_headers_get_index(headers, header_index, &header); |
| /* aws_marshal_http_headers_array_to_dynamic_buffer() impl drives this calculation */ |
| headers_initial_capacity += header.name.len + header.value.len + 8; |
| } |
| |
| struct aws_allocator *allocator = aws_jni_get_allocator(); |
| |
| if (aws_byte_buf_init(out_headers_buf, allocator, headers_initial_capacity)) { |
| return AWS_OP_ERR; |
| } |
| |
| if (aws_marshal_http_headers_to_dynamic_buffer(out_headers_buf, headers)) { |
| aws_byte_buf_clean_up(out_headers_buf); |
| return AWS_OP_ERR; |
| } |
| |
| return AWS_OP_SUCCESS; |
| } |
| |
| static int s_on_s3_meta_request_headers_callback( |
| struct aws_s3_meta_request *meta_request, |
| const struct aws_http_headers *headers, |
| int response_status, |
| void *user_data) { |
| int return_value = AWS_OP_ERR; |
| struct s3_client_make_meta_request_callback_data *callback_data = |
| (struct s3_client_make_meta_request_callback_data *)user_data; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(callback_data->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return AWS_OP_ERR; |
| } |
| |
| jobject java_headers_buffer = NULL; |
| struct aws_byte_buf headers_buf; |
| AWS_ZERO_STRUCT(headers_buf); |
| |
| if (s_marshal_http_headers_to_buf(headers, &headers_buf)) { |
| goto cleanup; |
| } |
| |
| java_headers_buffer = aws_jni_direct_byte_buffer_from_raw_ptr(env, headers_buf.buffer, headers_buf.len); |
| if (java_headers_buffer == NULL) { |
| aws_jni_check_and_clear_exception(env); |
| aws_raise_error(AWS_ERROR_JAVA_CRT_JVM_OUT_OF_MEMORY); |
| goto cleanup; |
| } |
| |
| if (callback_data->java_s3_meta_request_response_handler_native_adapter != NULL) { |
| (*env)->CallVoidMethod( |
| env, |
| callback_data->java_s3_meta_request_response_handler_native_adapter, |
| s3_meta_request_response_handler_native_adapter_properties.onResponseHeaders, |
| response_status, |
| java_headers_buffer); |
| |
| if (aws_jni_get_and_clear_exception(env, &(callback_data->java_exception))) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Exception thrown from S3MetaRequest.onResponseHeaders callback", |
| (void *)meta_request); |
| |
| aws_raise_error(AWS_ERROR_HTTP_CALLBACK_FAILURE); |
| goto cleanup; |
| } |
| } |
| return_value = AWS_OP_SUCCESS; |
| |
| cleanup: |
| aws_byte_buf_clean_up(&headers_buf); |
| if (java_headers_buffer) { |
| (*env)->DeleteLocalRef(env, java_headers_buffer); |
| } |
| |
| aws_jni_release_thread_env(callback_data->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| |
| return return_value; |
| } |
| |
| static void s_on_s3_meta_request_finish_callback( |
| struct aws_s3_meta_request *meta_request, |
| const struct aws_s3_meta_request_result *meta_request_result, |
| void *user_data) { |
| |
| (void)meta_request; |
| |
| struct s3_client_make_meta_request_callback_data *callback_data = |
| (struct s3_client_make_meta_request_callback_data *)user_data; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(callback_data->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return; |
| } |
| |
| if (callback_data->java_s3_meta_request_response_handler_native_adapter != NULL) { |
| struct aws_byte_buf *error_response_body = meta_request_result->error_response_body; |
| struct aws_byte_cursor error_response_cursor; |
| AWS_ZERO_STRUCT(error_response_cursor); |
| if (error_response_body) { |
| error_response_cursor = aws_byte_cursor_from_buf(error_response_body); |
| } |
| jbyteArray jni_payload = aws_jni_byte_array_from_cursor(env, &error_response_cursor); |
| /* Only propagate java_exception if crt error code is callback failure */ |
| jthrowable java_exception = |
| meta_request_result->error_code == AWS_ERROR_HTTP_CALLBACK_FAILURE ? callback_data->java_exception : NULL; |
| |
| jobject java_error_headers_buffer = NULL; |
| struct aws_byte_buf headers_buf; |
| AWS_ZERO_STRUCT(headers_buf); |
| if (meta_request_result->error_response_headers) { |
| /* Ignore any errors and just report the original error without headers */ |
| if (s_marshal_http_headers_to_buf(meta_request_result->error_response_headers, &headers_buf) == |
| AWS_OP_SUCCESS) { |
| java_error_headers_buffer = |
| aws_jni_direct_byte_buffer_from_raw_ptr(env, headers_buf.buffer, headers_buf.len); |
| if (java_error_headers_buffer == NULL) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Ignored Exception from " |
| "S3MetaRequest.onFinished.aws_jni_direct_byte_buffer_from_raw_ptr", |
| (void *)meta_request); |
| aws_jni_check_and_clear_exception(env); |
| } |
| } else { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Ignored Exception from S3MetaRequest.onFinished.s_marshal_http_headers_to_buf", |
| (void *)meta_request); |
| } |
| } |
| |
| (*env)->CallVoidMethod( |
| env, |
| callback_data->java_s3_meta_request_response_handler_native_adapter, |
| s3_meta_request_response_handler_native_adapter_properties.onFinished, |
| meta_request_result->error_code, |
| meta_request_result->response_status, |
| jni_payload, |
| meta_request_result->validation_algorithm, |
| meta_request_result->did_validate, |
| java_exception, |
| java_error_headers_buffer); |
| |
| if (aws_jni_check_and_clear_exception(env)) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Ignored Exception from S3MetaRequest.onFinished callback", |
| (void *)meta_request); |
| } |
| if (jni_payload) { |
| (*env)->DeleteLocalRef(env, jni_payload); |
| } |
| |
| aws_byte_buf_clean_up(&headers_buf); |
| if (java_error_headers_buffer) { |
| (*env)->DeleteLocalRef(env, java_error_headers_buffer); |
| } |
| } |
| |
| aws_jni_release_thread_env(callback_data->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| } |
| |
| static void s_on_s3_meta_request_progress_callback( |
| struct aws_s3_meta_request *meta_request, |
| const struct aws_s3_meta_request_progress *progress, |
| void *user_data) { |
| |
| (void)meta_request; |
| |
| struct s3_client_make_meta_request_callback_data *callback_data = |
| (struct s3_client_make_meta_request_callback_data *)user_data; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(callback_data->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return; |
| } |
| |
| jobject progress_object = (*env)->NewObject( |
| env, |
| s3_meta_request_progress_properties.s3_meta_request_progress_class, |
| s3_meta_request_progress_properties.s3_meta_request_progress_constructor_method_id); |
| if ((*env)->ExceptionCheck(env) || progress_object == NULL) { |
| aws_jni_throw_runtime_exception( |
| env, "S3MetaRequestResponseHandler.onProgress: Failed to create S3MetaRequestProgress object."); |
| goto done; |
| } |
| |
| (*env)->SetLongField( |
| env, |
| progress_object, |
| s3_meta_request_progress_properties.bytes_transferred_field_id, |
| progress->bytes_transferred); |
| (*env)->SetLongField( |
| env, progress_object, s3_meta_request_progress_properties.content_length_field_id, progress->content_length); |
| |
| if (callback_data->java_s3_meta_request_response_handler_native_adapter != NULL) { |
| |
| (*env)->CallVoidMethod( |
| env, |
| callback_data->java_s3_meta_request_response_handler_native_adapter, |
| s3_meta_request_response_handler_native_adapter_properties.onProgress, |
| progress_object); |
| |
| if (aws_jni_check_and_clear_exception(env)) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Ignored Exception from S3MetaRequest.onProgress callback", |
| (void *)meta_request); |
| } |
| } |
| |
| (*env)->DeleteLocalRef(env, progress_object); |
| |
| done: |
| |
| aws_jni_release_thread_env(callback_data->jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| } |
| |
| static void s_s3_meta_request_callback_cleanup( |
| JNIEnv *env, |
| struct s3_client_make_meta_request_callback_data *callback_data) { |
| if (callback_data) { |
| (*env)->DeleteGlobalRef(env, callback_data->java_s3_meta_request); |
| (*env)->DeleteGlobalRef(env, callback_data->java_s3_meta_request_response_handler_native_adapter); |
| (*env)->DeleteGlobalRef(env, callback_data->java_exception); |
| aws_signing_config_data_clean_up(&callback_data->signing_config_data, env); |
| aws_mem_release(aws_jni_get_allocator(), callback_data); |
| } |
| } |
| |
| static struct aws_s3_meta_request_resume_token *s_native_resume_token_from_java_new( |
| JNIEnv *env, |
| jobject resume_token_jni) { |
| |
| if (resume_token_jni == NULL) { |
| return NULL; |
| } |
| |
| struct aws_allocator *allocator = aws_jni_get_allocator(); |
| |
| jint native_type = |
| (*env)->GetIntField(env, resume_token_jni, s3_meta_request_resume_token_properties.native_type_field_id); |
| |
| if (native_type != AWS_S3_META_REQUEST_TYPE_PUT_OBJECT) { |
| aws_jni_throw_illegal_argument_exception( |
| env, "ResumeToken: Operations other than PutObject are not supported for resume."); |
| return NULL; |
| } |
| |
| jlong part_size_jni = |
| (*env)->GetLongField(env, resume_token_jni, s3_meta_request_resume_token_properties.part_size_field_id); |
| jlong total_num_parts_jni = |
| (*env)->GetLongField(env, resume_token_jni, s3_meta_request_resume_token_properties.total_num_parts_field_id); |
| jlong num_parts_completed_jni = (*env)->GetLongField( |
| env, resume_token_jni, s3_meta_request_resume_token_properties.num_parts_completed_field_id); |
| |
| jstring upload_id_jni = |
| (*env)->GetObjectField(env, resume_token_jni, s3_meta_request_resume_token_properties.upload_id_field_id); |
| if (upload_id_jni == NULL) { |
| aws_jni_throw_illegal_argument_exception(env, "ResumeToken: UploadId must not be NULL."); |
| return NULL; |
| } |
| |
| struct aws_string *upload_id = aws_jni_new_string_from_jstring(env, upload_id_jni); |
| |
| struct aws_s3_upload_resume_token_options upload_options = { |
| .part_size = (uint64_t)part_size_jni, |
| .total_num_parts = (size_t)total_num_parts_jni, |
| .num_parts_completed = (size_t)num_parts_completed_jni, |
| .upload_id = aws_byte_cursor_from_string(upload_id), |
| }; |
| |
| struct aws_s3_meta_request_resume_token *resume_token = |
| aws_s3_meta_request_resume_token_new_upload(allocator, &upload_options); |
| aws_string_destroy(upload_id); |
| |
| return resume_token; |
| } |
| |
| JNIEXPORT jlong JNICALL Java_software_amazon_awssdk_crt_s3_S3Client_s3ClientMakeMetaRequest( |
| JNIEnv *env, |
| jclass jni_class, |
| jlong jni_s3_client, |
| jobject java_s3_meta_request_jobject, |
| jbyteArray jni_region, |
| jint meta_request_type, |
| jint checksum_location, |
| jint checksum_algorithm, |
| jboolean validate_response, |
| jintArray jni_marshalled_validate_algorithms, |
| jbyteArray jni_marshalled_message_data, |
| jobject jni_http_request_body_stream, |
| jbyteArray jni_request_filepath, |
| jobject java_signing_config, |
| jobject java_response_handler_jobject, |
| jbyteArray jni_endpoint, |
| jobject java_resume_token_jobject) { |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_allocator *allocator = aws_jni_get_allocator(); |
| struct aws_s3_client *client = (struct aws_s3_client *)jni_s3_client; |
| struct aws_byte_cursor request_filepath; |
| AWS_ZERO_STRUCT(request_filepath); |
| struct aws_s3_meta_request_resume_token *resume_token = |
| s_native_resume_token_from_java_new(env, java_resume_token_jobject); |
| struct aws_s3_meta_request *meta_request = NULL; |
| bool success = false; |
| struct aws_byte_cursor region = aws_jni_byte_cursor_from_jbyteArray_acquire(env, jni_region); |
| struct aws_http_message *request_message = NULL; |
| |
| struct s3_client_make_meta_request_callback_data *callback_data = |
| aws_mem_calloc(allocator, 1, sizeof(struct s3_client_make_meta_request_callback_data)); |
| AWS_FATAL_ASSERT(callback_data); |
| struct aws_signing_config_aws signing_config; |
| AWS_ZERO_STRUCT(signing_config); |
| if (java_signing_config != NULL) { |
| if (aws_build_signing_config(env, java_signing_config, &callback_data->signing_config_data, &signing_config)) { |
| goto done; |
| } |
| } |
| |
| jint jvmresult = (*env)->GetJavaVM(env, &callback_data->jvm); |
| (void)jvmresult; |
| AWS_FATAL_ASSERT(jvmresult == 0); |
| |
| callback_data->java_s3_meta_request = (*env)->NewGlobalRef(env, java_s3_meta_request_jobject); |
| AWS_FATAL_ASSERT(callback_data->java_s3_meta_request != NULL); |
| |
| callback_data->java_s3_meta_request_response_handler_native_adapter = |
| (*env)->NewGlobalRef(env, java_response_handler_jobject); |
| AWS_FATAL_ASSERT(callback_data->java_s3_meta_request_response_handler_native_adapter != NULL); |
| |
| request_message = aws_http_message_new_request(allocator); |
| AWS_FATAL_ASSERT(request_message); |
| |
| AWS_FATAL_ASSERT( |
| AWS_OP_SUCCESS == aws_apply_java_http_request_changes_to_native_request( |
| env, jni_marshalled_message_data, jni_http_request_body_stream, request_message)); |
| |
| if (jni_request_filepath) { |
| request_filepath = aws_jni_byte_cursor_from_jbyteArray_acquire(env, jni_request_filepath); |
| if (request_filepath.ptr == NULL) { |
| goto done; |
| } |
| if (request_filepath.len == 0) { |
| aws_jni_throw_illegal_argument_exception(env, "Request file path cannot be empty"); |
| goto done; |
| } |
| } |
| |
| struct aws_uri endpoint; |
| AWS_ZERO_STRUCT(endpoint); |
| if (jni_endpoint != NULL) { |
| struct aws_byte_cursor endpoint_str = aws_jni_byte_cursor_from_jbyteArray_acquire(env, jni_endpoint); |
| int uri_parse = aws_uri_init_parse(&endpoint, allocator, &endpoint_str); |
| aws_jni_byte_cursor_from_jbyteArray_release(env, jni_endpoint, endpoint_str); |
| if (uri_parse) { |
| aws_jni_throw_runtime_exception(env, "S3Client.aws_s3_client_make_meta_request: failed to parse endpoint"); |
| goto done; |
| } |
| } |
| |
| struct aws_s3_checksum_config checksum_config = { |
| .location = checksum_location, |
| .checksum_algorithm = checksum_algorithm, |
| .validate_response_checksum = validate_response, |
| }; |
| |
| struct aws_array_list response_checksum_list; |
| AWS_ZERO_STRUCT(response_checksum_list); |
| if (jni_marshalled_validate_algorithms != NULL) { |
| jint *marshalled_algorithms = (*env)->GetIntArrayElements(env, jni_marshalled_validate_algorithms, NULL); |
| const size_t marshalled_len = (*env)->GetArrayLength(env, jni_marshalled_validate_algorithms); |
| aws_array_list_init_dynamic(&response_checksum_list, allocator, marshalled_len, sizeof(int)); |
| for (size_t i = 0; i < marshalled_len; ++i) { |
| enum aws_s3_checksum_algorithm algorithm = (int)marshalled_algorithms[i]; |
| aws_array_list_push_back(&response_checksum_list, &algorithm); |
| } |
| checksum_config.validate_checksum_algorithms = &response_checksum_list; |
| } |
| |
| struct aws_s3_meta_request_options meta_request_options = { |
| .type = meta_request_type, |
| .checksum_config = &checksum_config, |
| .message = request_message, |
| .send_filepath = request_filepath, |
| .user_data = callback_data, |
| .signing_config = java_signing_config ? &signing_config : NULL, |
| .headers_callback = s_on_s3_meta_request_headers_callback, |
| .body_callback = s_on_s3_meta_request_body_callback, |
| .finish_callback = s_on_s3_meta_request_finish_callback, |
| .progress_callback = s_on_s3_meta_request_progress_callback, |
| .shutdown_callback = s_on_s3_meta_request_shutdown_complete_callback, |
| .endpoint = jni_endpoint != NULL ? &endpoint : NULL, |
| .resume_token = resume_token, |
| }; |
| |
| meta_request = aws_s3_client_make_meta_request(client, &meta_request_options); |
| /* We are done using the list, it can be safely cleaned up now. */ |
| aws_array_list_clean_up(&response_checksum_list); |
| if (!meta_request) { |
| aws_jni_throw_runtime_exception( |
| env, "S3Client.aws_s3_client_make_meta_request: creating aws_s3_meta_request failed"); |
| goto done; |
| } |
| |
| success = true; |
| |
| done: |
| aws_s3_meta_request_resume_token_release(resume_token); |
| aws_jni_byte_cursor_from_jbyteArray_release(env, jni_region, region); |
| aws_http_message_release(request_message); |
| aws_jni_byte_cursor_from_jbyteArray_release(env, jni_request_filepath, request_filepath); |
| aws_uri_clean_up(&endpoint); |
| if (success) { |
| return (jlong)meta_request; |
| } |
| s_s3_meta_request_callback_cleanup(env, callback_data); |
| return (jlong)0; |
| } |
| |
| static void s_on_s3_meta_request_shutdown_complete_callback(void *user_data) { |
| struct s3_client_make_meta_request_callback_data *callback_data = |
| (struct s3_client_make_meta_request_callback_data *)user_data; |
| |
| /********** JNI ENV ACQUIRE **********/ |
| JNIEnv *env = aws_jni_acquire_thread_env(callback_data->jvm); |
| if (env == NULL) { |
| /* If we can't get an environment, then the JVM is probably shutting down. Don't crash. */ |
| return; |
| } |
| |
| if (callback_data->java_s3_meta_request != NULL) { |
| (*env)->CallVoidMethod(env, callback_data->java_s3_meta_request, s3_meta_request_properties.onShutdownComplete); |
| |
| if (aws_jni_check_and_clear_exception(env)) { |
| AWS_LOGF_ERROR( |
| AWS_LS_S3_META_REQUEST, |
| "id=%p: Ignored Exception from S3MetaRequest.onShutdownCompete callback", |
| (void *)callback_data->java_s3_meta_request); |
| } |
| } |
| |
| // We're done with this callback data, free it. |
| JavaVM *jvm = callback_data->jvm; |
| s_s3_meta_request_callback_cleanup(env, callback_data); |
| |
| aws_jni_release_thread_env(jvm, env); |
| /********** JNI ENV RELEASE **********/ |
| } |
| |
| JNIEXPORT void JNICALL Java_software_amazon_awssdk_crt_s3_S3MetaRequest_s3MetaRequestDestroy( |
| JNIEnv *env, |
| jclass jni_class, |
| jlong jni_s3_meta_request) { |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_s3_meta_request *meta_request = (struct aws_s3_meta_request *)jni_s3_meta_request; |
| if (!meta_request) { |
| aws_raise_error(AWS_ERROR_INVALID_ARGUMENT); |
| aws_jni_throw_runtime_exception(env, "S3MetaRequest.s3MetaRequestDestroy: Invalid/null meta request"); |
| return; |
| } |
| |
| aws_s3_meta_request_release(meta_request); |
| } |
| |
| JNIEXPORT void JNICALL Java_software_amazon_awssdk_crt_s3_S3MetaRequest_s3MetaRequestCancel( |
| JNIEnv *env, |
| jclass jni_class, |
| jlong jni_s3_meta_request) { |
| |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_s3_meta_request *meta_request = (struct aws_s3_meta_request *)jni_s3_meta_request; |
| if (!meta_request) { |
| /* It's fine if this particular function does nothing when it's called |
| * after CrtResource is closed and the handle is NULL */ |
| return; |
| } |
| |
| aws_s3_meta_request_cancel(meta_request); |
| } |
| |
| JNIEXPORT jobject JNICALL Java_software_amazon_awssdk_crt_s3_S3MetaRequest_s3MetaRequestPause( |
| JNIEnv *env, |
| jclass jni_class, |
| jlong jni_s3_meta_request) { |
| |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_s3_meta_request *meta_request = (struct aws_s3_meta_request *)jni_s3_meta_request; |
| if (!meta_request) { |
| aws_raise_error(AWS_ERROR_INVALID_ARGUMENT); |
| aws_jni_throw_illegal_argument_exception(env, "S3MetaRequest.s3MetaRequestPause: Invalid/null meta request"); |
| return NULL; |
| } |
| |
| struct aws_s3_meta_request_resume_token *resume_token = NULL; |
| |
| if (aws_s3_meta_request_pause(meta_request, &resume_token)) { |
| aws_jni_throw_runtime_exception(env, "S3MetaRequest.s3MetaRequestPause: Failed to pause request"); |
| return NULL; |
| } |
| |
| jobject resume_token_jni = NULL; |
| if (resume_token != NULL) { |
| resume_token_jni = (*env)->NewObject( |
| env, |
| s3_meta_request_resume_token_properties.s3_meta_request_resume_token_class, |
| s3_meta_request_resume_token_properties.s3_meta_request_resume_token_constructor_method_id); |
| if ((*env)->ExceptionCheck(env) || resume_token_jni == NULL) { |
| aws_jni_throw_runtime_exception(env, "S3MetaRequest.s3MetaRequestPause: Failed to create ResumeToken."); |
| goto on_done; |
| } |
| |
| enum aws_s3_meta_request_type type = aws_s3_meta_request_resume_token_type(resume_token); |
| if (type != AWS_S3_META_REQUEST_TYPE_PUT_OBJECT) { |
| aws_jni_throw_runtime_exception(env, "S3MetaRequest.s3MetaRequestPause: Failed to convert resume token."); |
| goto on_done; |
| } |
| |
| (*env)->SetIntField(env, resume_token_jni, s3_meta_request_resume_token_properties.native_type_field_id, type); |
| (*env)->SetLongField( |
| env, |
| resume_token_jni, |
| s3_meta_request_resume_token_properties.part_size_field_id, |
| aws_s3_meta_request_resume_token_part_size(resume_token)); |
| (*env)->SetLongField( |
| env, |
| resume_token_jni, |
| s3_meta_request_resume_token_properties.total_num_parts_field_id, |
| aws_s3_meta_request_resume_token_total_num_parts(resume_token)); |
| (*env)->SetLongField( |
| env, |
| resume_token_jni, |
| s3_meta_request_resume_token_properties.num_parts_completed_field_id, |
| aws_s3_meta_request_resume_token_num_parts_completed(resume_token)); |
| |
| struct aws_byte_cursor upload_id_cur = aws_s3_meta_request_resume_token_upload_id(resume_token); |
| jstring upload_id_jni = aws_jni_string_from_cursor(env, &upload_id_cur); |
| (*env)->SetObjectField( |
| env, resume_token_jni, s3_meta_request_resume_token_properties.upload_id_field_id, upload_id_jni); |
| |
| (*env)->DeleteLocalRef(env, upload_id_jni); |
| } |
| |
| on_done: |
| aws_s3_meta_request_resume_token_release(resume_token); |
| return resume_token_jni; |
| } |
| |
| JNIEXPORT void JNICALL Java_software_amazon_awssdk_crt_s3_S3MetaRequest_s3MetaRequestIncrementReadWindow( |
| JNIEnv *env, |
| jclass jni_class, |
| jlong jni_s3_meta_request, |
| jlong increment) { |
| |
| (void)jni_class; |
| aws_cache_jni_ids(env); |
| |
| struct aws_s3_meta_request *meta_request = (struct aws_s3_meta_request *)jni_s3_meta_request; |
| if (!meta_request) { |
| /* It's fine if this particular function does nothing when it's called |
| * after CrtResource is closed and the handle is NULL */ |
| return; |
| } |
| |
| if (increment < 0) { |
| aws_jni_throw_illegal_argument_exception( |
| env, "S3MetaRequest.s3MetaRequestIncrementReadWindow: Number cannot be negative"); |
| return; |
| } |
| |
| aws_s3_meta_request_increment_read_window(meta_request, (uint64_t)increment); |
| } |
| |
| #if UINTPTR_MAX == 0xffffffff |
| # if defined(_MSC_VER) |
| # pragma warning(pop) |
| # else |
| # pragma GCC diagnostic pop |
| # endif |
| #endif |
