Obtaining the Public Access Status of a Bucket (SDK for C)
If you have any questions during development, post them on the Issues page of GitHub.
Function
This API is used to obtain the public access status of a bucket. The public access status of a bucket is determined based on multiple factors, including the bucket policy, ACL, and BPA configuration. It is used to determine whether the bucket is at risk of public access.
Restrictions
- To obtain the public access status of a bucket, you must be the bucket owner or have the required permission (obs:bucket:GetBucketPublicStatus granted using IAM or GetBucketPublicStatus granted using a bucket policy). For details, see Introduction to OBS Access Control, IAM Custom Policies, and Creating a Custom Bucket Policy.
- The mapping between OBS regions and endpoints must comply with what is listed in Regions and Endpoints.
Method
void get_bucket_public_status(const obs_options *options,
obs_get_bucket_public_status_handler *handler, void *callback_data); Request Parameters
| Parameter | Type | Mandatory (Yes/No) | Description |
|---|---|---|---|
| options | const obs_options* | Yes | Explanation: Context of the requested bucket. You can set the AK, SK, endpoint, bucket, timeout interval, and temporary credentials through obs_options. Restrictions: None Value range: None Default value: None |
| handler | Yes | Explanation: Callback structure, including the response callback, end callback, and callback for obtaining the public access status of a bucket. Restrictions: None Value range: None Default value: None | |
| callback_data | void * | No | Explanation: Custom callback data. Restrictions: None Value range: None Default value: None |
| Parameter | Type | Mandatory (Yes/No) | Description |
|---|---|---|---|
| response_handler | Yes | Explanation: Response callback function structure. Restrictions: None Value range: None Default value: None | |
| get_public_status_callback | Yes | Explanation: Pointer to the callback function for obtaining the public access status of a bucket. You can read the content of obs_bucket_public_status in the callback. Restrictions: None Value range: None Default value: None |
| Parameter | Type | Mandatory (Yes/No) | Description |
|---|---|---|---|
| policy_status | const Table 4* | Yes | Explanation: Bucket public access status structure, including information about whether the bucket is public. Restrictions: The structure and the memory to which the pointer points will be released by the SDK after the callback. Copy them if you need to keep the data. Value range: None Default value: None |
| callback_data | void * | Yes | Explanation: Pointer to the custom callback data. Restrictions: None Value range: None Default value: None |
Sample Code
#include "eSDKOBS.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// The response callback function. In this callback, you can record the content of properties into callback_data (custom callback data).
obs_status response_properties_callback(const obs_response_properties *properties, void *callback_data);
// The completion callback function. In this callback, you can record the content of obs_status and obs_error_details into callback_data (custom callback data).
void response_complete_callback(obs_status status, const obs_error_details *error, void *callback_data);
// Data callback function for obtaining the public access status of a bucket
obs_status get_public_status_callback(const obs_bucket_public_status *public_status, void *callback_data);
// Custom callback data. It is used to transfer the result status and public access status between callbacks.
typedef struct PublicStatusResult
{
bool is_public;
obs_status ret_status;
} PublicStatusResult;
int main()
{
// The following example shows how to obtain the public access status of a bucket:
// Call the obs_initialize method at the program entry to initialize global resources such as the network and memory.
obs_status ret_status = obs_initialize(OBS_INIT_ALL);
if (OBS_STATUS_OK != ret_status)
{
printf("obs_initialize failed(%s).\n", obs_get_status_name(ret_status));
return -1;
}
obs_options options;
// Create and initialize options, including the access domain name (host_name), access keys (access_key_id and access_key_secret), bucket name (bucket_name), and bucket storage class (storage_class).
init_obs_options(&options);
// Enter the endpoint corresponding to the bucket for host_name. CN-Hong Kong is used here as an example. Replace it with the one currently in use.
options.bucket_options.host_name = "obs.ap-southeast-1.myhuaweicloud.com";
// Hard-coded or plaintext AK and SK are risky. For security purposes, encrypt your AK and SK and store them in the configuration file or environment variables.
// In this example, the AK and SK are stored in environment variables for identity authentication. Before running the code in this example, configure local environment variables ACCESS_KEY_ID and SECRET_ACCESS_KEY.
options.bucket_options.access_key = getenv("ACCESS_KEY_ID");
options.bucket_options.secret_access_key = getenv("SECRET_ACCESS_KEY");
// Specify the bucket name, for example, example-bucket-name.
char * bucket_name = "example-bucket-name";
options.bucket_options.bucket_name = bucket_name;
// Set the callback function.
obs_get_bucket_public_status_handler handler;
memset(&handler, 0, sizeof(obs_get_bucket_public_status_handler));
handler.response_handler.properties_callback = &response_properties_callback;
handler.response_handler.complete_callback = &response_complete_callback;
handler.get_bucket_public_status_callback = &get_public_status_callback;
// Initialize the custom callback data.
PublicStatusResult result;
memset(&result, 0, sizeof(PublicStatusResult));
result.ret_status = OBS_STATUS_BUTT;
// Obtain the public access status of the bucket.
get_bucket_public_status(&options, &handler, &result);
// Check whether the request is successful.
if (OBS_STATUS_OK == result.ret_status) {
printf("get bucket public status successfully. \n");
printf("is_public: %s\n", result.is_public ? "true" : "false");
}
else
{
printf("get bucket public status failed(%s).\n", obs_get_status_name(result.ret_status));
}
// Release the allocated global resources.
obs_deinitialize();
}
// Data callback function for obtaining the public access status of a bucket
obs_status get_public_status_callback(const obs_bucket_public_status *public_status, void *callback_data)
{
PublicStatusResult *result = (PublicStatusResult *)callback_data;
if (result && public_status) {
result->is_public = public_status->is_public;
}
return OBS_STATUS_OK;
}
// The response callback function. In this callback, you can record the content of properties into callback_data (custom callback data).
obs_status response_properties_callback(const obs_response_properties *properties, void *callback_data)
{
if (properties == NULL)
{
printf("error! obs_response_properties is null!");
return OBS_STATUS_OK;
}
// Print the response.
#define print_nonnull(name, field) \
do { \
if (properties-> field) { \
printf("%s: %s\n", name, properties->field); \
} \
} while (0)
print_nonnull("request_id", request_id);
print_nonnull("request_id2", request_id2);
print_nonnull("content_type", content_type);
if (properties->content_length) {
printf("content_length: %llu\n", properties->content_length);
}
print_nonnull("server", server);
print_nonnull("ETag", etag);
print_nonnull("expiration", expiration);
print_nonnull("website_redirect_location", website_redirect_location);
print_nonnull("version_id", version_id);
print_nonnull("allow_origin", allow_origin);
print_nonnull("allow_headers", allow_headers);
print_nonnull("max_age", max_age);
print_nonnull("allow_methods", allow_methods);
print_nonnull("expose_headers", expose_headers);
print_nonnull("storage_class", storage_class);
print_nonnull("server_side_encryption", server_side_encryption);
print_nonnull("kms_key_id", kms_key_id);
print_nonnull("customer_algorithm", customer_algorithm);
print_nonnull("customer_key_md5", customer_key_md5);
print_nonnull("bucket_location", bucket_location);
print_nonnull("obs_version", obs_version);
print_nonnull("restore", restore);
print_nonnull("obs_object_type", obs_object_type);
print_nonnull("obs_next_append_position", obs_next_append_position);
print_nonnull("obs_head_epid", obs_head_epid);
print_nonnull("reserved_indicator", reserved_indicator);
int i;
for (i = 0; i < properties->meta_data_count; i++) {
printf("x-obs-meta-%s: %s\n", properties->meta_data[i].name,
properties->meta_data[i].value);
}
return OBS_STATUS_OK;
}
// The completion callback function. In this callback, you can record the content of obs_status and obs_error_details into callback_data (custom callback data).
void response_complete_callback(obs_status status, const obs_error_details *error, void *callback_data)
{
if (callback_data) {
PublicStatusResult *result = (PublicStatusResult *)callback_data;
result->ret_status = status;
} else {
printf("Callback_data is NULL");
}
if (error && error->message) {
printf("Error Message: \n %s\n", error->message);
}
if (error && error->resource) {
printf("Error Resource: \n %s\n", error->resource);
}
if (error && error->further_details) {
printf("Error further_details: \n %s\n", error->further_details);
}
if (error && error->extra_details_count) {
int i;
for (i = 0; i < error->extra_details_count; i++) {
printf("Error Extra Detail(%d):\n %s:%s\n", i, error->extra_details[i].name,
error->extra_details[i].value);
}
}
if (error && error->error_headers_count) {
int i;
for (i = 0; i < error->error_headers_count; i++) {
const char *errorHeader = error->error_headers[i];
printf("Error Headers(%d):\n %s\n", i, errorHeader == NULL ? "NULL Header" : errorHeader);
}
}
} What is your overall rating for this page?
Thank you very much for your feedback. We will continue working to improve the documentation.See the reply and handling status in My Cloud VOC.
For any further questions, feel free to contact us through the chatbot.
Chatbot