void oss_list_multipart_uploads_content_parse(aos_pool_t *p, mxml_node_t *xml_node,
oss_list_multipart_upload_content_t *content)
{
char *key;
char *upload_id;
char *initiated;
char *node_content;
mxml_node_t *node;
node = mxmlFindElement(xml_node, xml_node, "Key",NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
key = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->key, key);
}
node = mxmlFindElement(xml_node, xml_node, "UploadId",NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
upload_id = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->upload_id, upload_id);
}
node = mxmlFindElement(xml_node, xml_node, "Initiated",NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
initiated = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->initiated, initiated);
}
}
void oss_list_objects_content_parse(aos_pool_t *p, xmlNodePtr xml_node, oss_list_object_content_t *content)
{
char *key;
char *last_modified;
char *etag;
char *size;
while (xml_node) {
xmlChar *node_content = xmlNodeGetContent(xml_node);
if (apr_strnatcasecmp((char *)xml_node->name, "Key") == 0) {
key = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->key, key);
} else if (apr_strnatcasecmp((char *)xml_node->name, "LastModified") == 0) {
last_modified = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->last_modified, last_modified);
} else if (apr_strnatcasecmp((char *)xml_node->name, "ETag") == 0) {
etag = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->etag, etag);
} else if (apr_strnatcasecmp((char *)xml_node->name, "Size") == 0) {
size = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->size, size);
} else if (apr_strnatcasecmp((char *)xml_node->name, "Owner") == 0) {
oss_list_objects_owner_parse(p, xml_node, content);
}
xmlFree(node_content);
xml_node = xml_node->next;
}
}
void oss_list_parts_content_parse(aos_pool_t *p, xmlNodePtr xml_node, oss_list_part_content_t *content)
{
char *part_number;
char *last_modified;
char *etag;
char *size;
while (xml_node) {
xmlChar *node_content = xmlNodeGetContent(xml_node);
if (apr_strnatcasecmp((char *)xml_node->name, "PartNumber") == 0) {
part_number = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->part_number, part_number);
} else if (apr_strnatcasecmp((char *)xml_node->name, "LastModified") == 0) {
last_modified = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->last_modified, last_modified);
} else if (apr_strnatcasecmp((char *)xml_node->name, "ETag") == 0) {
etag = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->etag, etag);
} else if (apr_strnatcasecmp((char *)xml_node->name, "Size") == 0) {
size = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->size, size);
}
xmlFree(node_content);
xml_node = xml_node->next;
}
}
int oss_list_multipart_uploads_parse_from_body(aos_pool_t *p, aos_list_t *bc,
aos_list_t *upload_list, aos_string_t *key_marker,
aos_string_t *upload_id_marker, int *truncated)
{
int res;
mxml_node_t *root;
const char next_key_marker_xml_path[] = "NextKeyMarker";
const char next_upload_id_marker_xml_path[] = "NextUploadIdMarker";
const char truncated_xml_path[] = "IsTruncated";
const char uploads_xml_path[] = "Upload";
char *next_key_marker;
char *next_upload_id_marker;
res = get_xmldoc(bc, &root);
if (res == AOSE_OK) {
next_key_marker = get_xmlnode_value(p, root, next_key_marker_xml_path);
if (next_key_marker) {
aos_str_set(key_marker, next_key_marker);
}
next_upload_id_marker = get_xmlnode_value(p, root, next_upload_id_marker_xml_path);
if (next_upload_id_marker) {
aos_str_set(upload_id_marker, next_upload_id_marker);
}
*truncated = get_truncated_from_xml(p, root, truncated_xml_path);
oss_list_multipart_uploads_contents_parse(p, root, uploads_xml_path, upload_list);
mxmlDelete(root);
}
return res;
}
void head_object()
{
aos_pool_t *p = NULL;
aos_string_t bucket;
aos_string_t object;
int is_cname = 0;
oss_request_options_t *options = NULL;
aos_table_t *headers = NULL;
aos_table_t *resp_headers = NULL;
aos_status_t *s = NULL;
aos_pool_create(&p, NULL);
options = oss_request_options_create(p);
init_sample_request_options(options, is_cname);
aos_str_set(&bucket, BUCKET_NAME);
aos_str_set(&object, OBJECT_NAME);
headers = aos_table_make(p, 0);
s = oss_head_object(options, &bucket, &object, headers, &resp_headers);
if (NULL != s && 2 == s->code / 100) {
printf("head object succeeded\n");
} else {
printf("head object failed\n");
}
aos_pool_destroy(p);
}
static void oss_clean(const char *filename) {
aos_pool_t *pool;
oss_request_options_t *opts;
aos_string_t bucket;
aos_string_t key;
aos_status_t *status;
aos_table_t *resp_headers;
aos_pool_create(&pool, NULL);
opts = oss_request_options_create(pool);
opts->config = oss_config_create(pool);
aos_str_set(&opts->config->endpoint, SAMPLE_OSS_ENDPOINT);
aos_str_set(&opts->config->access_key_id, SAMPLE_ACCESS_KEY_ID);
aos_str_set(&opts->config->access_key_secret, SAMPLE_ACCESS_KEY_SECRET);
opts->config->is_cname = 0;
opts->ctl = aos_http_controller_create(pool, 0);
aos_str_set(&bucket, SAMPLE_BUCKET_NAME);
aos_str_set(&key, filename);
status = oss_delete_object(opts, &bucket, &key, &resp_headers);
if (!aos_status_is_ok(status)) {
aos_error_log("clean oss error. [code=%d, message=%s]",
status->code, status->error_code);
aos_error_log("example exit");
aos_pool_destroy(pool);
exit(-1);
}
aos_pool_destroy(pool);
}
void init_test_config(oss_config_t *config, int is_cname)
{
aos_str_set(&config->endpoint, TEST_OSS_ENDPOINT);
aos_str_set(&config->access_key_id, TEST_ACCESS_KEY_ID);
aos_str_set(&config->access_key_secret, TEST_ACCESS_KEY_SECRET);
config->is_cname = is_cname;
}
int oss_list_multipart_uploads_parse_from_body(aos_pool_t *p, aos_list_t *bc,
aos_list_t *upload_list, aos_string_t *key_marker,
aos_string_t *upload_id_marker, int *truncated)
{
int res;
xmlDocPtr doc;
const char next_key_marker_xml_path[] = "/ListMultipartUploadsResult/NextKeyMarker";
const char next_upload_id_marker_xml_path[] = "/ListMultipartUploadsResult/NextUploadIdMarker";
const char truncated_xml_path[] = "/ListMultipartUploadsResult/IsTruncated";
const char uploads_xml_path[] = "/ListMultipartUploadsResult/Upload";
char *next_key_marker;
char *next_upload_id_marker;
res = get_xmldoc(bc, &doc);
if (res == AOSE_OK) {
next_key_marker = get_xmlnode_value(p, doc, next_key_marker_xml_path);
if (next_key_marker) {
aos_str_set(key_marker, next_key_marker);
}
next_upload_id_marker = get_xmlnode_value(p, doc, next_upload_id_marker_xml_path);
if (next_upload_id_marker) {
aos_str_set(upload_id_marker, next_upload_id_marker);
}
*truncated = get_truncated_from_xml(p, doc, truncated_xml_path);
oss_list_multipart_uploads_contents_parse(p, doc, uploads_xml_path, upload_list);
xmlFreeDoc(doc);
}
return res;
}
void init_test_config(oss_config_t *config, int is_oss_domain)
{
aos_str_set(&config->host, TEST_OSS_HOST);
config->port = 80;
aos_str_set(&config->id, TEST_ACCESS_ID);
aos_str_set(&config->key, TEST_ACCESS_KEY);
config->is_oss_domain = is_oss_domain;
}
void append_object_from_buffer()
{
aos_pool_t *p = NULL;
aos_string_t bucket;
aos_string_t object;
char *str = "test oss c sdk";
aos_status_t *s = NULL;
int is_cname = 0;
int64_t position = 0;
aos_table_t *headers1 = NULL;
aos_table_t *headers2 = NULL;
aos_table_t *resp_headers = NULL;
oss_request_options_t *options = NULL;
aos_list_t buffer;
aos_buf_t *content = NULL;
char *next_append_position = NULL;
char *object_type = NULL;
aos_pool_create(&p, NULL);
options = oss_request_options_create(p);
init_sample_request_options(options, is_cname);
headers1 = aos_table_make(p, 0);
aos_str_set(&bucket, BUCKET_NAME);
aos_str_set(&object, OBJECT_NAME);
s = oss_head_object(options, &bucket, &object, headers1, &resp_headers);
if (aos_status_is_ok(s)) {
object_type = (char*)(apr_table_get(resp_headers, OSS_OBJECT_TYPE));
if (0 != strncmp(OSS_OBJECT_TYPE_APPENDABLE, object_type,
strlen(OSS_OBJECT_TYPE_APPENDABLE)))
{
printf("object[%s]'s type[%s] is not Appendable\n", OBJECT_NAME, object_type);
aos_pool_destroy(p);
return;
}
next_append_position = (char*)(apr_table_get(resp_headers, OSS_NEXT_APPEND_POSITION));
position = atoi(next_append_position);
}
headers2 = aos_table_make(p, 0);
aos_list_init(&buffer);
content = aos_buf_pack(p, str, strlen(str));
aos_list_add_tail(&content->node, &buffer);
s = oss_append_object_from_buffer(options, &bucket, &object,
position, &buffer, headers2, &resp_headers);
if (aos_status_is_ok(s))
{
printf("append object from buffer succeeded\n");
} else {
printf("append object from buffer failed\n");
}
aos_pool_destroy(p);
}
oss_lifecycle_rule_content_t *oss_create_lifecycle_rule_content(aos_pool_t *p)
{
oss_lifecycle_rule_content_t *rule;
rule = (oss_lifecycle_rule_content_t *)aos_pcalloc(
p, sizeof(oss_lifecycle_rule_content_t));
aos_str_set(&rule->id, "");
aos_str_set(&rule->prefix, "");
aos_str_set(&rule->status, "");
aos_str_set(&rule->date, "");
rule->days = INT_MAX;
return rule;
}
void append_object_from_file()
{
aos_pool_t *p = NULL;
aos_string_t bucket;
aos_string_t object;
int is_cname = 0;
aos_table_t *headers1 = NULL;
aos_table_t *headers2 = NULL;
aos_table_t *resp_headers = NULL;
oss_request_options_t *options = NULL;
char *filename = __FILE__;
aos_status_t *s = NULL;
aos_string_t file;
int64_t position = 0;
char *next_append_position = NULL;
char *object_type = NULL;
aos_pool_create(&p, NULL);
options = oss_request_options_create(p);
init_sample_request_options(options, is_cname);
headers1 = aos_table_make(options->pool, 0);
headers2 = aos_table_make(options->pool, 0);
aos_str_set(&bucket, BUCKET_NAME);
aos_str_set(&object, OBJECT_NAME);
aos_str_set(&file, filename);
s = oss_head_object(options, &bucket, &object, headers1, &resp_headers);
if(aos_status_is_ok(s)) {
object_type = (char*)(apr_table_get(resp_headers, OSS_OBJECT_TYPE));
if (0 != strncmp(OSS_OBJECT_TYPE_APPENDABLE, object_type,
strlen(OSS_OBJECT_TYPE_APPENDABLE)))
{
printf("object[%s]'s type[%s] is not Appendable\n", OBJECT_NAME, object_type);
aos_pool_destroy(p);
return;
}
next_append_position = (char*)(apr_table_get(resp_headers, OSS_NEXT_APPEND_POSITION));
position = atoi(next_append_position);
}
s = oss_append_object_from_file(options, &bucket, &object,
position, &file, headers2, &resp_headers);
if (aos_status_is_ok(s)) {
printf("append object from file succeeded\n");
} else {
printf("append object from file failed\n");
}
aos_pool_destroy(p);
}
oss_list_multipart_upload_params_t *oss_create_list_multipart_upload_params(aos_pool_t *p)
{
oss_list_multipart_upload_params_t *params;
params = (oss_list_multipart_upload_params_t *)aos_pcalloc(
p, sizeof(oss_list_multipart_upload_params_t));
aos_list_init(¶ms->upload_list);
aos_str_set(¶ms->prefix, "");
aos_str_set(¶ms->key_marker, "");
aos_str_set(¶ms->upload_id_marker, "");
aos_str_set(¶ms->delimiter, "");
params->truncated = 1;
params->max_ret = OSS_PER_RET_NUM;
return params;
}
oss_list_object_params_t *oss_create_list_object_params(aos_pool_t *p)
{
oss_list_object_params_t * params;
params = (oss_list_object_params_t *)aos_pcalloc(
p, sizeof(oss_list_object_params_t));
aos_list_init(¶ms->object_list);
aos_list_init(¶ms->common_prefix_list);
aos_str_set(¶ms->prefix, "");
aos_str_set(¶ms->marker, "");
aos_str_set(¶ms->delimiter, "");
params->truncated = 1;
params->max_ret = OSS_PER_RET_NUM;
return params;
}
char* gen_test_signed_url(const oss_request_options_t *options,
const char *bucket_name,
const char *object_name,
int64_t expires,
aos_http_request_t *req)
{
aos_string_t bucket;
aos_string_t object;
char *signed_url = NULL;
aos_str_set(&bucket, bucket_name);
aos_str_set(&object, object_name);
signed_url = oss_gen_signed_url(options, &bucket, &object, expires, req);
return signed_url;
}
int oss_list_objects_parse_from_body(aos_pool_t *p, aos_list_t *bc,
aos_list_t *object_list, aos_list_t *common_prefix_list, aos_string_t *marker, int *truncated)
{
int res;
xmlDocPtr doc = NULL;
const char next_marker_xml_path[] = "/ListBucketResult/NextMarker";
const char truncated_xml_path[] = "/ListBucketResult/IsTruncated";
const char buckets_xml_path[] = "/ListBucketResult/Contents";
const char common_prefix_xml_path[] = "/ListBucketResult/CommonPrefixes";
char* next_marker;
res = get_xmldoc(bc, &doc);
if (res == AOSE_OK) {
next_marker = get_xmlnode_value(p, doc, next_marker_xml_path);
if (next_marker) {
aos_str_set(marker, next_marker);
}
*truncated = get_truncated_from_xml(p, doc, truncated_xml_path);
oss_list_objects_contents_parse(p, doc, buckets_xml_path, object_list);
oss_list_objects_common_prefix_parse(p, doc, common_prefix_xml_path, common_prefix_list);
xmlFreeDoc(doc);
}
return res;
}
int oss_list_parts_parse_from_body(aos_pool_t *p, aos_list_t *bc,
aos_list_t *part_list, aos_string_t *partnumber_marker, int *truncated)
{
int res;
xmlDocPtr doc;
const char next_partnumber_marker_xml_path[] = "/ListPartsResult/NextPartNumberMarker";
const char truncated_xml_path[] = "/ListPartsResult/IsTruncated";
const char parts_xml_path[] = "/ListPartsResult/Part";
char *next_partnumber_marker;
res = get_xmldoc(bc, &doc);
if (res == AOSE_OK) {
next_partnumber_marker = get_xmlnode_value(p, doc, next_partnumber_marker_xml_path);
if (next_partnumber_marker) {
aos_str_set(partnumber_marker, next_partnumber_marker);
}
*truncated = get_truncated_from_xml(p, doc, truncated_xml_path);
oss_list_parts_contents_parse(p, doc, parts_xml_path, part_list);
xmlFreeDoc(doc);
}
return res;
}
int oss_list_parts_parse_from_body(aos_pool_t *p, aos_list_t *bc,
aos_list_t *part_list, aos_string_t *partnumber_marker, int *truncated)
{
int res;
mxml_node_t *root;
const char next_partnumber_marker_xml_path[] = "NextPartNumberMarker";
const char truncated_xml_path[] = "IsTruncated";
const char parts_xml_path[] = "Part";
char *next_partnumber_marker;
res = get_xmldoc(bc, &root);
if (res == AOSE_OK) {
next_partnumber_marker = get_xmlnode_value(p, root, next_partnumber_marker_xml_path);
if (next_partnumber_marker) {
aos_str_set(partnumber_marker, next_partnumber_marker);
}
*truncated = get_truncated_from_xml(p, root, truncated_xml_path);
oss_list_parts_contents_parse(p, root, parts_xml_path, part_list);
mxmlDelete(root);
}
return res;
}
int oss_list_objects_parse_from_body(aos_pool_t *p, aos_list_t *bc,
aos_list_t *object_list, aos_list_t *common_prefix_list, aos_string_t *marker, int *truncated)
{
int res;
mxml_node_t *root;
const char next_marker_xml_path[] = "NextMarker";
const char truncated_xml_path[] = "IsTruncated";
const char buckets_xml_path[] = "Contents";
const char common_prefix_xml_path[] = "CommonPrefixes";
char* next_marker;
res = get_xmldoc(bc, &root);
if (res == AOSE_OK) {
next_marker = get_xmlnode_value(p, root, next_marker_xml_path);
if (next_marker) {
aos_str_set(marker, next_marker);
}
*truncated = get_truncated_from_xml(p, root, truncated_xml_path);
oss_list_objects_contents_parse(p, root, buckets_xml_path, object_list);
oss_list_objects_common_prefix_parse(p, root, common_prefix_xml_path, common_prefix_list);
mxmlDelete(root);
}
return res;
}
void oss_list_objects_owner_parse(aos_pool_t *p, xmlNodePtr xml_node, oss_list_object_content_t *content)
{
xmlNodePtr owner_node;
char *owner_id;
char *owner_display_name;
for (owner_node = xml_node->xmlChildrenNode; owner_node != NULL; owner_node = owner_node->next) {
xmlChar *node_content = xmlNodeGetContent(owner_node);
if (apr_strnatcasecmp((char *)owner_node->name, "ID") == 0) {
owner_id = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->owner_id, owner_id);
} else if (apr_strnatcasecmp((char *)owner_node->name, "DisplayName") == 0) {
owner_display_name = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->owner_display_name, owner_display_name);
}
xmlFree(node_content);
}
}
void oss_list_objects_content_parse(aos_pool_t *p, mxml_node_t *xml_node, oss_list_object_content_t *content)
{
char *key;
char *last_modified;
char *etag;
char *size;
char *node_content;
mxml_node_t *node;
node = mxmlFindElement(xml_node, xml_node, "Key", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
key = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->key, key);
}
node = mxmlFindElement(xml_node, xml_node, "LastModified", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
last_modified = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->last_modified, last_modified);
}
node = mxmlFindElement(xml_node, xml_node, "ETag", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
etag = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->etag, etag);
}
node = mxmlFindElement(xml_node, xml_node, "Size", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
size = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->size, size);
}
node = mxmlFindElement(xml_node, xml_node, "Owner", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
oss_list_objects_owner_parse(p, node, content);
}
}
void make_rand_string(aos_pool_t *p, int len, aos_string_t *data)
{
char *str = NULL;
int i = 0;
str = (char *)aos_palloc(p, len + 1);
for ( ; i < len; i++) {
str[i] = 'a' + rand() % 32;
}
str[len] = '\0';
aos_str_set(data, str);
}
void delete_file(oss_media_file_t *file) {
aos_pool_t *p;
aos_string_t bucket;
aos_string_t object;
oss_request_options_t *options;
aos_table_t *resp_headers;
aos_pool_create(&p, NULL);
options = oss_request_options_create(p);
options->config = oss_config_create(options->pool);
aos_str_set(&options->config->endpoint, file->endpoint);
aos_str_set(&options->config->access_key_id, file->access_key_id);
aos_str_set(&options->config->access_key_secret, file->access_key_secret);
options->config->is_cname = file->is_cname;
options->ctl = aos_http_controller_create(options->pool, 0);
aos_str_set(&bucket, file->bucket_name);
aos_str_set(&object, file->object_key);
oss_delete_object(options, &bucket, &object, &resp_headers);
}
oss_list_upload_part_params_t *oss_create_list_upload_part_params(aos_pool_t *p)
{
oss_list_upload_part_params_t *params;
params = (oss_list_upload_part_params_t *)aos_pcalloc(
p, sizeof(oss_list_upload_part_params_t));
aos_list_init(¶ms->part_list);
aos_str_set(¶ms->part_number_marker, "");
params->max_ret = OSS_PER_RET_NUM;
params->truncated = 1;
return params;
}
void oss_list_objects_owner_parse(aos_pool_t *p, mxml_node_t *xml_node, oss_list_object_content_t *content)
{
mxml_node_t *node;
char *node_content;
char *owner_id;
char *owner_display_name;
node = mxmlFindElement(xml_node, xml_node, "ID",NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
owner_id = apr_pstrdup(p, node_content);
aos_str_set(&content->owner_id, owner_id);
}
node = mxmlFindElement(xml_node, xml_node, "DisplayName", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
owner_display_name = apr_pstrdup(p, node_content);
aos_str_set(&content->owner_display_name, owner_display_name);
}
}
aos_status_t * create_test_bucket(const oss_request_options_t *options,
const char *bucket_name,
oss_acl_e oss_acl)
{
aos_string_t bucket;
aos_table_t *resp_headers;
aos_status_t * s;
aos_str_set(&bucket, bucket_name);
s = oss_create_bucket(options, &bucket, oss_acl, &resp_headers);
return s;
}
void oss_list_objects_prefix_parse(aos_pool_t *p, xmlNodePtr prefix_node, oss_list_object_common_prefix_t *common_prefix)
{
char *prefix;
for (; prefix_node != NULL; prefix_node = prefix_node->next) {
xmlChar *node_content = xmlNodeGetContent(prefix_node);
if (apr_strnatcasecmp((char *)prefix_node->name, "Prefix") == 0) {
prefix = apr_pstrdup(p, (char *)node_content);
aos_str_set(&common_prefix->prefix, prefix);
}
xmlFree(node_content);
}
}
void oss_list_objects_prefix_parse(aos_pool_t *p, mxml_node_t *xml_node, oss_list_object_common_prefix_t *common_prefix)
{
char *prefix;
mxml_node_t *node;
char *node_content;
node = mxmlFindElement(xml_node, xml_node, "Prefix", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
prefix = apr_pstrdup(p, (char *)node_content);
aos_str_set(&common_prefix->prefix, prefix);
}
}
void oss_list_multipart_uploads_content_parse(aos_pool_t *p, xmlNodePtr xml_node,
oss_list_multipart_upload_content_t *content)
{
char *key;
char *upload_id;
char *initiated;
while (xml_node) {
xmlChar *node_content = xmlNodeGetContent(xml_node);
if (apr_strnatcasecmp((char *)xml_node->name, "Key") == 0) {
key = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->key, key);
} else if (apr_strnatcasecmp((char *)xml_node->name, "UploadId") == 0) {
upload_id = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->upload_id, upload_id);
} else if (apr_strnatcasecmp((char *)xml_node->name, "Initiated") == 0) {
initiated = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->initiated, initiated);
}
xmlFree(node_content);
xml_node = xml_node->next;
}
}
void oss_list_parts_content_parse(aos_pool_t *p, mxml_node_t *xml_node, oss_list_part_content_t *content)
{
char *part_number;
char *last_modified;
char *etag;
char *size;
char *node_content;
mxml_node_t *node;
node = mxmlFindElement(xml_node, xml_node, "PartNumber", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
part_number = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->part_number, part_number);
}
node = mxmlFindElement(xml_node, xml_node, "LastModified", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
last_modified = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->last_modified, last_modified);
}
node = mxmlFindElement(xml_node, xml_node, "ETag", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
etag = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->etag, etag);
}
node = mxmlFindElement(xml_node, xml_node, "Size", NULL, NULL, MXML_DESCEND);
if (NULL != node) {
node_content = node->child->value.opaque;
size = apr_pstrdup(p, (char *)node_content);
aos_str_set(&content->size, size);
}
}
