九游平台/ 对象存储服务 obs/ sdk参考/ / 其他接口(c sdk)/ 使用临时url进行授权访问(c sdk)
更新时间：2025-02-18 gmt 08:00

使用临时url进行授权访问(c sdk)-九游平台

开发过程中，您有任何问题可以在github上，或者在中发帖求助。

功能说明

临时授权访问是指通过访问密钥、请求方法类型、请求参数等信息生成一个临时访问权限的url，这个url中会包含鉴权信息，您可以使用该url进行访问obs服务进行特定操作。在生成url时，您需要指定url的有效期。生成临时授权访问的url是通过设置结构体temp_auth_configure来实现的。

temp_auth_configure结构体存在于obs_options结构体中。该方法适用于每个c sdk接口。

参数

作用

sdk中对应的结构体

expires

生成的临时url的有效期

obs_options. temp_auth_configure

temp_auth_callback

回调函数用于返回生成的临时url

callback_data

回调数据

接口约束

  • obs支持的region与endpoint的对应关系，详细信息请参见。
  • 如果遇到跨域报错、签名不匹配问题，请参考以下步骤排查问题：
    1. 未配置跨域，需要在控制台配置cors规则，请参考。
    2. 签名计算问题，请参考url中携带签名排查签名参数是否正确；比如上传对象功能，后端将content-type参与计算签名生成授权url，但是前端使用授权url时没有设置content-type字段或者传入错误的值，此时会出现跨域错误。九游平台的解决方案为：content-type字段前后端保持一致。

方法定义

void (*temp_auth_callback)(char *temp_auth_url, uint64_t temp_auth_url_len, char *temp_auth_headers,
        uint64_t temp_auth_headers_len, void *callback_data);

通过obs c sdk生成临时url访问obs的步骤如下：

  1. 按照下面的代码示例，调用任意sdk接口生成带签名信息的url和header。
  2. 使用任意http库发送http/https请求，访问obs服务。

以下代码示例展示了如何使用临时url进行授权访问，包括：创建桶、上传对象、下载对象、列举对象、删除对象。

代码示例一：生成用于创建桶的临时授权url

以下示例展示如何生成用于创建桶的临时授权url： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
#include"esdkobs.h"
#include
#define max_temp_url_len 1024
#define max_header_len 1024
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data);
typedefstruct__tempauthresult
{
chartmpauthurl[max_temp_url_len];
charactualheaders[max_header_len];
}tempauthresult;
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata);
intmain()
{
// 以下示例展示如何生成创建桶的url：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
// 填写bucket名称，例如example-bucket-name。
char*bucketname="example-bucket-name";
options.bucket_options.bucket_name=bucketname;
temp_auth_configuretempauth;
tempauthresultptrresult;
memset(&ptrresult,0,sizeof(tempauthresult));
//回调数据
tempauth.callback_data=(void*)(&ptrresult);
// 有效时间    
tempauth.expires=10;
// 回调函数 返回生成的临时url
tempauth.temp_auth_callback=&tempauthcallback_getresult;
options.temp_auth=&tempauth;
// 回调函数赋值  
obs_response_handlerresponse_handler=
{
&response_properties_callback,
&response_complete_callback
};
obs_statusret_status=obs_status_butt;
// 接口调用
create_bucket(&options,obs_canned_acl_private,null,&response_handler,&ret_status);
// 判断请求是否成功
if(ret_status==obs_status_ok){
printf("the temporary signature url of create bucket generated successfully. \n"
"the temporary signature url is %s. \n"
"the actualheaders are %s. \n",ptrresult.tmpauthurl,ptrresult.actualheaders);
}
else
{
printf(" the temporary signature url of create bucket generation failed(%s).\n",obs_get_status_name(ret_status));
}
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#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);
inti;
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);
}
returnobs_status_ok;
}
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data)
{
if(callback_data){
obs_status*ret_status=(obs_status*)callback_data;
*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){
inti;
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){
inti;
for(i=0;i<error->error_headers_count;i){
constchar*errorheader=error->error_headers[i];
printf("error headers(%d):\n    %s\n",i,errorheader==null?"null header":errorheader);
}
}
}
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata)
{
inturllen=0;
tempauthresult*ptrresult=(tempauthresult*)callbackdata;
urllen=strlen(tempauthurl);
strcpy_s(ptrresult->tmpauthurl,max_temp_url_len,tempauthurl);
strcpy_s(ptrresult->actualheaders,max_header_len,tempauthactualheaders);
}

代码示例二：生成用于上传对象的临时授权url

以下示例展示如何生成用于上传对象的临时授权url： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
#include"esdkobs.h"
#include
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data);
typedefstruct__tempauthresult
{
chartmpauthurl[1024];
charactualheaders[1024];
}tempauthresult;
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata);
intmain()
{
// 以下示例展示如何生成上传对象的url：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
// 填写bucket名称，例如example-bucket-name。
char*bucketname="example-bucket-name";
options.bucket_options.bucket_name=bucketname;
temp_auth_configuretempauth;
tempauthresultptrresult;
memset(&ptrresult,0,sizeof(tempauthresult));
//回调数据
tempauth.callback_data=(void*)(&ptrresult);
// 有效时间    
tempauth.expires=10;
// 回调函数 返回生成的临时url
tempauth.temp_auth_callback=&tempauthcallback_getresult;
options.temp_auth=&tempauth;
// 回调函数赋值  
obs_response_handlerresponse_handler=
{
&response_properties_callback,
&response_complete_callback
};
obs_statusret_status=obs_status_butt;
char*key="example-object-key";
obs_put_object_handlerputobjecthandler=
{
response_handler,
null
};
// 初始化结构体put_properties
obs_put_propertiesput_properties;
init_put_properties(&put_properties);
// 接口调用
put_object(&options,key,0,&put_properties,0,&putobjecthandler,&ret_status);
// 判断请求是否成功
if(ret_status==obs_status_ok){
printf("the temporary signature url of put object generated successfully. \n"
"the temporary signature url is %s. \n"
"the actualheaders are %s. \n",ptrresult.tmpauthurl,ptrresult.actualheaders);
}
else
{
printf(" the temporary signature url of put object generation failed(%s).\n",obs_get_status_name(ret_status));
}
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#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);
inti;
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);
}
returnobs_status_ok;
}
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data)
{
if(callback_data){
obs_status*ret_status=(obs_status*)callback_data;
*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){
inti;
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){
inti;
for(i=0;i<error->error_headers_count;i){
constchar*errorheader=error->error_headers[i];
printf("error headers(%d):\n    %s\n",i,errorheader==null?"null header":errorheader);
}
}
}
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata)
{
inturllen=0;
tempauthresult*ptrresult=(tempauthresult*)callbackdata;
urllen=strlen(tempauthurl);
strcpy_s(ptrresult->tmpauthurl,1024,tempauthurl);
strcpy_s(ptrresult->actualheaders,1024,tempauthactualheaders);
}

代码示例三：生成用于下载对象的临时授权url

以下示例展示如何生成用于下载对象的临时授权url： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
#include"esdkobs.h"
#include
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data);
typedefstruct__tempauthresult
{
chartmpauthurl[1024];
charactualheaders[1024];
}tempauthresult;
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata);
intmain()
{
// 以下示例展示如何生成下载对象的url：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
// 填写bucket名称，例如example-bucket-name。
char*bucketname="example-bucket-name";
options.bucket_options.bucket_name=bucketname;
temp_auth_configuretempauth;
tempauthresultptrresult;
memset(&ptrresult,0,sizeof(tempauthresult));
//回调数据
tempauth.callback_data=(void*)(&ptrresult);
// 有效时间    
tempauth.expires=10;
// 回调函数 返回生成的临时url
tempauth.temp_auth_callback=&tempauthcallback_getresult;
options.temp_auth=&tempauth;
// 回调函数赋值  
obs_response_handlerresponse_handler=
{
&response_properties_callback,
&response_complete_callback
};
obs_statusret_status=obs_status_butt;
char*key="example-object-key";
char*versionid=null;
// 下载对象信息
obs_object_infoobject_info;
memset(&object_info,0,sizeof(obs_object_info));
object_info.key=key;
object_info.version_id=versionid;
obs_get_object_handlergetobjecthandler=
{
response_handler,
null
};
// 初始化结构体put_properties
obs_put_propertiesput_properties;
init_put_properties(&put_properties);
// 接口调用
get_object(&options,&object_info,0,0,&getobjecthandler,&ret_status);
// 判断请求是否成功
if(ret_status==obs_status_ok){
printf("the temporary signature url of get object generated successfully. \n"
"the temporary signature url is %s. \n"
"the actualheaders are %s. \n",ptrresult.tmpauthurl,ptrresult.actualheaders);
}
else
{
printf(" the temporary signature url of get object generation failed(%s).\n",obs_get_status_name(ret_status));
}
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#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);
inti;
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);
}
returnobs_status_ok;
}
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data)
{
if(callback_data){
obs_status*ret_status=(obs_status*)callback_data;
*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){
inti;
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){
inti;
for(i=0;i<error->error_headers_count;i){
constchar*errorheader=error->error_headers[i];
printf("error headers(%d):\n    %s\n",i,errorheader==null?"null header":errorheader);
}
}
}
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata)
{
inturllen=0;
tempauthresult*ptrresult=(tempauthresult*)callbackdata;
urllen=strlen(tempauthurl);
strcpy_s(ptrresult->tmpauthurl,1024,tempauthurl);
strcpy_s(ptrresult->actualheaders,1024,tempauthactualheaders);
}

代码示例四：生成用于列举对象的临时授权url

以下示例展示如何生成用于列举对象的临时授权url： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
#include"esdkobs.h"
#include
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data);
typedefstruct__tempauthresult
{
chartmpauthurl[1024];
charactualheaders[1024];
}tempauthresult;
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata);
intmain()
{
// 以下示例展示如何生成列举对象的url：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
// 填写bucket名称，例如example-bucket-name。
char*bucketname="example-bucket-name";
options.bucket_options.bucket_name=bucketname;
temp_auth_configuretempauth;
tempauthresultptrresult;
memset(&ptrresult,0,sizeof(tempauthresult));
//回调数据
tempauth.callback_data=(void*)(&ptrresult);
// 有效时间    
tempauth.expires=10;
// 回调函数 返回生成的临时url
tempauth.temp_auth_callback=&tempauthcallback_getresult;
options.temp_auth=&tempauth;
// 回调函数赋值  
obs_response_handlerresponse_handler=
{
&response_properties_callback,
&response_complete_callback
};
obs_statusret_status=obs_status_butt;
char*prefix="example-prefix";
char*next_marker="example-next-marker";
char*delimiter="/";
//列举对象的最大数目
intmaxkeys=100;
obs_list_objects_handlerlist_bucket_objects_handler=
{
response_handler,
null
};
list_bucket_objects(&options,prefix,next_marker,delimiter,maxkeys,
&list_bucket_objects_handler,&ret_status);
// 判断请求是否成功
if(ret_status==obs_status_ok){
printf("the temporary signature url of list objects generated successfully. \n"
"the temporary signature url is %s. \n"
"the actualheaders are %s. \n",ptrresult.tmpauthurl,ptrresult.actualheaders);
}
else
{
printf(" the temporary signature url of list objects generation failed(%s).\n",obs_get_status_name(ret_status));
}
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#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);
inti;
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);
}
returnobs_status_ok;
}
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data)
{
if(callback_data){
obs_status*ret_status=(obs_status*)callback_data;
*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){
inti;
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){
inti;
for(i=0;i<error->error_headers_count;i){
constchar*errorheader=error->error_headers[i];
printf("error headers(%d):\n    %s\n",i,errorheader==null?"null header":errorheader);
}
}
}
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata)
{
inturllen=0;
tempauthresult*ptrresult=(tempauthresult*)callbackdata;
urllen=strlen(tempauthurl);
strcpy_s(ptrresult->tmpauthurl,1024,tempauthurl);
strcpy_s(ptrresult->actualheaders,1024,tempauthactualheaders);
}

代码示例五：生成用于删除对象的临时授权url

以下示例展示如何生成用于删除对象的临时授权url： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
#include"esdkobs.h"
#include
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data);
typedefstruct__tempauthresult
{
chartmpauthurl[1024];
charactualheaders[1024];
}tempauthresult;
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata);
intmain()
{
// 以下示例展示如何生成删除对象的url：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
// 填写bucket名称，例如example-bucket-name。
char*bucketname="example-bucket-name";
options.bucket_options.bucket_name=bucketname;
temp_auth_configuretempauth;
tempauthresultptrresult;
memset(&ptrresult,0,sizeof(tempauthresult));
//回调数据
tempauth.callback_data=(void*)(&ptrresult);
// 有效时间    
tempauth.expires=10;
// 回调函数 返回生成的临时url
tempauth.temp_auth_callback=&tempauthcallback_getresult;
options.temp_auth=&tempauth;
// 回调函数赋值  
obs_response_handlerresponse_handler=
{
&response_properties_callback,
&response_complete_callback
};
obs_statusret_status=obs_status_butt;
char*key="example-object-key";
char*versionid=null;
// 要删除的对象的信息
obs_object_infoobject_info;
memset(&object_info,0,sizeof(obs_object_info));
object_info.key=key;
object_info.version_id=versionid;
delete_object(&options,&object_info,&response_handler,&ret_status);
// 判断请求是否成功
if(ret_status==obs_status_ok){
printf("the temporary signature url of put object generated successfully. \n"
"the temporary signature url is %s. \n"
"the actualheaders are %s. \n",ptrresult.tmpauthurl,ptrresult.actualheaders);
}
else
{
printf(" the temporary signature url of put object generation failed(%s).\n",obs_get_status_name(ret_status));
}
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#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);
inti;
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);
}
returnobs_status_ok;
}
// 结束回调函数，可以在这个回调中把obs_status和obs_error_details的内容记录到callback_data(用户自定义回调数据)中
voidresponse_complete_callback(obs_statusstatus,constobs_error_details*error,void*callback_data)
{
if(callback_data){
obs_status*ret_status=(obs_status*)callback_data;
*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){
inti;
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){
inti;
for(i=0;i<error->error_headers_count;i){
constchar*errorheader=error->error_headers[i];
printf("error headers(%d):\n    %s\n",i,errorheader==null?"null header":errorheader);
}
}
}
voidtempauthcallback_getresult(char*tempauthurl,uint64_ttempauthurllen,char*tempauthactualheaders,
uint64_ttempauthactualheaderslen,void*callbackdata)
{
inturllen=0;
tempauthresult*ptrresult=(tempauthresult*)callbackdata;
urllen=strlen(tempauthurl);
strcpy_s(ptrresult->tmpauthurl,1024,tempauthurl);
strcpy_s(ptrresult->actualheaders,1024,tempauthactualheaders);
}
父主题： 其他接口(c sdk)

相关文档

网站地图