1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "napi/native_api.h"
16 #include "asset/asset_api.h"
17 #include <bits/alltypes.h>
18 #include <cstring>
19 
20 static const int MAGIC_RET = 9999;
21 static const int BUFF_MAX = 4096;
22 static const char *DEMO_LABEL = "demo_label";
23 
Asset_Add(napi_env env, napi_callback_info info)24 static napi_value Asset_Add(napi_env env, napi_callback_info info)
25 {
26     size_t argc = 2;
27     napi_value args[2] = {nullptr};
28 
29     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
30 
31     char aliasBuffer[BUFF_MAX];
32     size_t bufferSize = BUFF_MAX;
33     size_t copied = 0;
34 
35     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
36 
37     char secretBuffer[BUFF_MAX];
38     bufferSize = BUFF_MAX;
39     copied = 0;
40 
41     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
42 
43     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
44     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
45 
46     Asset_Attr attr[] = {
47         {.tag = ASSET_TAG_ACCESSIBILITY, .value.u32 = ASSET_ACCESSIBILITY_DEVICE_POWERED_ON},
48         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
49         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
50     };
51     int32_t ret = OH_Asset_Add(attr, sizeof(attr) / sizeof(attr[0]));
52     napi_value result;
53     napi_create_uint32(env, ret, &result);
54 
55     return result;
56 }
57 
Asset_AddCE(napi_env env, napi_callback_info info)58 static napi_value Asset_AddCE(napi_env env, napi_callback_info info)
59 {
60     size_t argc = 2;
61     napi_value args[2] = {nullptr};
62 
63     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
64 
65     char aliasBuffer[BUFF_MAX];
66     size_t bufferSize = BUFF_MAX;
67     size_t copied = 0;
68 
69     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
70 
71     char secretBuffer[BUFF_MAX];
72     bufferSize = BUFF_MAX;
73     copied = 0;
74 
75     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
76 
77     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
78     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
79 
80     Asset_Attr attr[] = {
81         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
82         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
83         {.tag = ASSET_TAG_REQUIRE_ATTR_ENCRYPTED, .value.boolean = true},
84     };
85     OH_Asset_Add(attr, sizeof(attr) / sizeof(attr[0]));
86 
87     Asset_Attr attr2[] = {
88         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
89         {.tag = ASSET_TAG_RETURN_TYPE, .value.u32 = ASSET_RETURN_ALL},
90         {.tag = ASSET_TAG_REQUIRE_ATTR_ENCRYPTED, .value.boolean = true},
91     };
92     Asset_ResultSet resultSet = {0};
93     int32_t ret = OH_Asset_Query(attr2, sizeof(attr2) / sizeof(attr2[0]), &resultSet);
94     if (ret == ASSET_SUCCESS) {
95         Asset_Attr *secret = OH_Asset_ParseAttr(resultSet.results + 0, ASSET_TAG_SECRET);
96         if (memcmp(secret->value.blob.data, reinterpret_cast<uint8_t *>(secretBuffer), secret->value.blob.size) == 0) {
97             ret = MAGIC_RET;
98         } else {
99             ret = -1;
100         }
101     } else {
102         ret = -1;
103     }
104     napi_value result;
105     napi_create_int32(env, ret, &result);
106     OH_Asset_FreeResultSet(&resultSet);
107     return result;
108 }
109 
Asset_Add_Auth(napi_env env, napi_callback_info info)110 static napi_value Asset_Add_Auth(napi_env env, napi_callback_info info)
111 {
112     size_t argc = 2;
113     napi_value args[2] = {nullptr};
114 
115     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
116 
117     char aliasBuffer[BUFF_MAX];
118     size_t bufferSize = BUFF_MAX;
119     size_t copied = 0;
120 
121     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
122 
123     char secretBuffer[BUFF_MAX];
124     bufferSize = BUFF_MAX;
125     copied = 0;
126 
127     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
128 
129     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
130     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
131     Asset_Blob label = {static_cast<uint32_t>(strlen(DEMO_LABEL)),
132                         const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(DEMO_LABEL))};
133     Asset_Attr attr[] = {
134         {.tag = ASSET_TAG_ACCESSIBILITY, .value.u32 = ASSET_ACCESSIBILITY_DEVICE_POWERED_ON},
135         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
136         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
137         {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
138         {.tag = ASSET_TAG_AUTH_TYPE, .value.u32 = ASSET_AUTH_TYPE_ANY},
139     };
140     int32_t ret = OH_Asset_Add(attr, sizeof(attr) / sizeof(attr[0]));
141     napi_value result;
142     napi_create_uint32(env, ret, &result);
143 
144     return result;
145 }
146 
AssetPreAndPostQuerySuccess(Asset_Attr *attr, uint32_t attrCnt)147 static int32_t AssetPreAndPostQuerySuccess(Asset_Attr *attr, uint32_t attrCnt)
148 {
149     uint8_t challengeBuffer[32] = "";
150     Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
151     int32_t result = 0;
152     int32_t ret = OH_Asset_PreQuery(attr, attrCnt, &challenge);
153     if (ret == ASSET_SUCCESS) {
154         Asset_Attr attr2[] = {
155             {.tag = ASSET_TAG_AUTH_CHALLENGE, .value.blob = challenge},
156         };
157         int32_t ret2 = OH_Asset_PostQuery(attr2, sizeof(attr2) / sizeof(attr2[0]));
158         if (ret2 == ASSET_SUCCESS) {
159             result = 1;
160         }
161         OH_Asset_FreeBlob(&challenge);
162     }
163     return result;
164 }
165 
AssetPreAndPostQueryNotFound(Asset_Attr *attr, uint32_t attrCnt)166 static int32_t AssetPreAndPostQueryNotFound(Asset_Attr *attr, uint32_t attrCnt)
167 {
168     uint8_t challengeBuffer[32] = "";
169     Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
170     int32_t result = 0;
171     int32_t ret = OH_Asset_PreQuery(attr, attrCnt, &challenge);
172     if (ret == ASSET_NOT_FOUND) {
173         result = 1;
174     }
175     return result;
176 }
177 
Asset_PreAndPostQueryNormal(napi_env env, napi_callback_info info)178 static napi_value Asset_PreAndPostQueryNormal(napi_env env, napi_callback_info info)
179 {
180     size_t argc = 2;
181     napi_value args[2] = {nullptr};
182 
183     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
184 
185     char aliasBuffer[BUFF_MAX];
186     size_t bufferSize = BUFF_MAX;
187     size_t copied = 0;
188 
189     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
190 
191     char aliasBuffer2[BUFF_MAX];
192     bufferSize = BUFF_MAX;
193     copied = 0;
194 
195     napi_get_value_string_utf8(env, args[1], aliasBuffer2, bufferSize, &copied);
196 
197     Asset_Blob alias2 = {static_cast<uint32_t>(strlen(aliasBuffer2)), reinterpret_cast<uint8_t *>(aliasBuffer2)};
198     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
199     int32_t result = 0;
200     Asset_Attr attr[] = {
201         {.tag = ASSET_TAG_AUTH_VALIDITY_PERIOD, .value.u32 = 2 * 60},
202         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
203     };
204     result += AssetPreAndPostQuerySuccess(attr, sizeof(attr) / sizeof(attr[0]));
205 
206     Asset_Attr attr2[] = {
207         {.tag = ASSET_TAG_ALIAS, .value.blob = alias2},
208     };
209     result += AssetPreAndPostQueryNotFound(attr2, sizeof(attr2) / sizeof(attr2[0]));
210 
211     Asset_Attr attr3[] = {};
212     result += AssetPreAndPostQuerySuccess(attr3, sizeof(attr3) / sizeof(attr3[0]));
213 
214     napi_value result_real;
215     napi_create_uint32(env, result, &result_real);
216     return result_real;
217 }
218 
Asset_PreAndPostQueryError(napi_env env, napi_callback_info info)219 static napi_value Asset_PreAndPostQueryError(napi_env env, napi_callback_info info)
220 {
221     size_t argc = 2;
222     napi_value args[2] = {nullptr};
223 
224     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
225 
226     char aliasBuffer[BUFF_MAX];
227     size_t bufferSize = BUFF_MAX;
228     size_t copied = 0;
229 
230     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
231 
232     char secretBuffer[BUFF_MAX];
233     bufferSize = BUFF_MAX;
234     copied = 0;
235 
236     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
237 
238     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
239 
240     uint8_t challengeBuffer[32] = "";
241     Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
242     Asset_Attr attr[] = {
243         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
244     };
245 
246     int32_t ret = OH_Asset_PreQuery(attr, sizeof(attr) / sizeof(attr[0]), &challenge);
247     int32_t result = 0;
248     if (ret == ASSET_INVALID_ARGUMENT) {
249         result += 1;
250     }
251 
252     Asset_Attr attr2[] = {
253         {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
254         {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
255         {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
256     };
257 
258     ret = OH_Asset_PreQuery(attr2, sizeof(attr2) / sizeof(attr2[0]), &challenge);
259     if (ret == ASSET_INVALID_ARGUMENT) {
260         result += 1;
261     }
262     Asset_Attr attr3[] = {};
263     ret = OH_Asset_PostQuery(attr3, sizeof(attr3) / sizeof(attr3[0]));
264     if (ret == ASSET_INVALID_ARGUMENT) {
265         result += 1;
266     }
267     napi_value result_real;
268     napi_create_uint32(env, result, &result_real);
269     return result_real;
270 }
271 
Asset_PreQuery(napi_env env, napi_callback_info info)272 static napi_value Asset_PreQuery(napi_env env, napi_callback_info info)
273 {
274     size_t argc = 1;
275     napi_value args[1] = {nullptr};
276 
277     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
278 
279     char aliasBuffer[BUFF_MAX];
280     size_t bufferSize = BUFF_MAX;
281     size_t copied = 0;
282 
283     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
284 
285     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
286     uint8_t challengeBuffer[32] = "";
287     Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
288     Asset_Attr attr[] = {
289         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
290     };
291 
292     int32_t ret = OH_Asset_PreQuery(attr, sizeof(attr) / sizeof(attr[0]), &challenge);
293     napi_value result;
294     napi_value tmp;
295     if (ret == ASSET_SUCCESS) {
296         napi_create_string_utf8(env, reinterpret_cast<char *>(challenge.data), challenge.size, &tmp);
297         OH_Asset_FreeBlob(&challenge);
298         if (tmp != NULL) {
299             return tmp;
300         } else {
301             ret = -1;
302         }
303     }
304     napi_create_uint32(env, ret, &result);
305     return result;
306 }
307 
Asset_PreAndPostQuery(napi_env env, napi_callback_info info)308 static napi_value Asset_PreAndPostQuery(napi_env env, napi_callback_info info)
309 {
310     size_t argc = 1;
311     napi_value args[1] = {nullptr};
312 
313     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
314 
315     char aliasBuffer[BUFF_MAX];
316     size_t bufferSize = BUFF_MAX;
317     size_t copied = 0;
318 
319     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
320 
321     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
322     uint8_t challengeBuffer[32] = "";
323     Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
324     Asset_Attr attr[] = {
325         {.tag = ASSET_TAG_AUTH_VALIDITY_PERIOD, .value.u32 = 2 * 60},
326         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
327     };
328 
329     int32_t ret = OH_Asset_PreQuery(attr, sizeof(attr) / sizeof(attr[0]), &challenge);
330     napi_value result;
331     napi_value tmp;
332     if (ret == ASSET_SUCCESS) {
333         napi_create_string_utf8(env, reinterpret_cast<char *>(challenge.data), challenge.size, &tmp);
334         if (tmp != NULL) {
335             Asset_Attr attr2[] = {
336                 {.tag = ASSET_TAG_AUTH_CHALLENGE, .value.blob = challenge},
337             };
338             int32_t ret2 = OH_Asset_PostQuery(attr2, sizeof(attr2) / sizeof(attr2[0]));
339             napi_create_uint32(env, ret2, &result);
340             OH_Asset_FreeBlob(&challenge);
341             return result;
342         } else {
343             ret = -1;
344         }
345     }
346 
347     napi_create_uint32(env, ret, &result);
348     return result;
349 }
350 
Asset_PostQuery(napi_env env, napi_callback_info info)351 static napi_value Asset_PostQuery(napi_env env, napi_callback_info info)
352 {
353     size_t argc = 1;
354     napi_value args[1] = {nullptr};
355 
356     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
357 
358     char challengeBuffer[BUFF_MAX];
359     size_t bufferSize = BUFF_MAX;
360     size_t copied = 0;
361 
362     napi_get_value_string_utf8(env, args[0], challengeBuffer, bufferSize, &copied);
363 
364     Asset_Blob challenge = {static_cast<uint32_t>(32), reinterpret_cast<uint8_t *>(challengeBuffer)};
365     napi_value result;
366     Asset_Attr attr[] = {
367         {.tag = ASSET_TAG_AUTH_CHALLENGE, .value.blob = challenge},
368     };
369     int32_t ret = OH_Asset_PostQuery(attr, sizeof(attr) / sizeof(attr[0]));
370     napi_create_uint32(env, ret, &result);
371     return result;
372 }
373 
Asset_RemoveAll(napi_env env, napi_callback_info info)374 static napi_value Asset_RemoveAll(napi_env env, napi_callback_info info)
375 {
376     Asset_Attr attr[] = {
377 
378     };
379     int32_t ret = OH_Asset_Remove(attr, sizeof(attr) / sizeof(attr[0]));
380     napi_value result;
381     napi_create_uint32(env, ret, &result);
382     return result;
383 }
384 
Asset_Remove(napi_env env, napi_callback_info info)385 static napi_value Asset_Remove(napi_env env, napi_callback_info info)
386 {
387     size_t argc = 1;
388     napi_value args[1] = {nullptr};
389 
390     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
391 
392     char aliasBuffer[BUFF_MAX];
393     size_t bufferSize = BUFF_MAX;
394     size_t copied = 0;
395 
396     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
397     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
398 
399     Asset_Attr attr[] = {
400         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
401     };
402     int32_t ret = OH_Asset_Remove(attr, sizeof(attr) / sizeof(attr[0]));
403     napi_value result;
404     napi_create_uint32(env, ret, &result);
405 
406     return result;
407 }
408 
Asset_RemoveLabel(napi_env env, napi_callback_info info)409 static napi_value Asset_RemoveLabel(napi_env env, napi_callback_info info)
410 {
411     size_t argc = 1;
412     napi_value args[1] = {nullptr};
413 
414     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
415 
416     char labelBuffer[BUFF_MAX];
417     size_t bufferSize = BUFF_MAX;
418     size_t copied = 0;
419 
420     napi_get_value_string_utf8(env, args[0], labelBuffer, bufferSize, &copied);
421     Asset_Blob label = {static_cast<uint32_t>(strlen(labelBuffer)), reinterpret_cast<uint8_t *>(labelBuffer)};
422 
423     Asset_Attr attr[] = {
424         {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
425     };
426     int32_t ret = OH_Asset_Remove(attr, sizeof(attr) / sizeof(attr[0]));
427     napi_value result;
428     napi_create_uint32(env, ret, &result);
429 
430     return result;
431 }
432 
AssetRemoveInvalidArg(Asset_Attr *attr, uint32_t attrCnt)433 static int32_t AssetRemoveInvalidArg(Asset_Attr *attr, uint32_t attrCnt)
434 {
435     int32_t result = 0;
436     int32_t ret = OH_Asset_Remove(attr, attrCnt);
437     if (ret == ASSET_INVALID_ARGUMENT) {
438         result = 1;
439     }
440     return result;
441 }
442 
Asset_RemoveError(napi_env env, napi_callback_info info)443 static napi_value Asset_RemoveError(napi_env env, napi_callback_info info)
444 {
445     size_t argc = 2;
446     napi_value args[2] = {nullptr};
447 
448     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
449 
450     char aliasBuffer[BUFF_MAX];
451     size_t bufferSize = BUFF_MAX;
452     size_t copied = 0;
453 
454     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
455 
456     char secretBuffer[BUFF_MAX];
457     bufferSize = BUFF_MAX;
458     copied = 0;
459 
460     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
461 
462     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
463     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
464 
465     Asset_Blob label = {static_cast<uint32_t>(strlen(DEMO_LABEL)),
466                         const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(DEMO_LABEL))};
467 
468     int32_t result = 0;
469     Asset_Attr attr[] = {
470         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
471         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
472     };
473 
474     result += AssetRemoveInvalidArg(attr, sizeof(attr) / sizeof(attr[0]));
475 
476     Asset_Attr attr2[] = {
477         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
478     };
479 
480     result += AssetRemoveInvalidArg(attr2, sizeof(attr2) / sizeof(attr2[0]));
481 
482     Asset_Attr attr3[] = {
483         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
484         {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
485     };
486     result += AssetRemoveInvalidArg(attr3, sizeof(attr3) / sizeof(attr3[0]));
487 
488     Asset_Attr attr4[] = {
489         {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
490         {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
491         {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
492     };
493 
494     result += AssetRemoveInvalidArg(attr4, sizeof(attr4) / sizeof(attr4[0]));
495 
496     napi_value result_real;
497     napi_create_uint32(env, result, &result_real);
498     return result_real;
499 }
500 
Asset_QueryAll(napi_env env, napi_callback_info info)501 static napi_value Asset_QueryAll(napi_env env, napi_callback_info info)
502 {
503     size_t argc = 2;
504     napi_value args[2] = {nullptr};
505 
506     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
507 
508     char aliasBuffer[BUFF_MAX];
509     size_t bufferSize = BUFF_MAX;
510     size_t copied = 0;
511 
512     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
513 
514     char secretBuffer[BUFF_MAX];
515     bufferSize = BUFF_MAX;
516     copied = 0;
517 
518     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
519     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
520     Asset_Attr attr[] = {
521         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
522         {.tag = ASSET_TAG_RETURN_TYPE, .value.u32 = ASSET_RETURN_ALL},
523     };
524     Asset_ResultSet resultSet = {0};
525     int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
526     if (ret == ASSET_SUCCESS) {
527         Asset_Attr *secret = OH_Asset_ParseAttr(resultSet.results + 0, ASSET_TAG_SECRET);
528         if (memcmp(secret->value.blob.data, reinterpret_cast<uint8_t *>(secretBuffer), secret->value.blob.size) == 0) {
529             ret = MAGIC_RET;
530         } else {
531             ret = -1;
532         }
533     } else {
534         ret = -1;
535     }
536     napi_value result;
537     napi_create_int32(env, ret, &result);
538     OH_Asset_FreeResultSet(&resultSet);
539     return result;
540 }
541 
Asset_QueryOption(napi_env env, napi_callback_info info)542 static napi_value Asset_QueryOption(napi_env env, napi_callback_info info)
543 {
544     size_t argc = 4;
545     napi_value args[4] = {nullptr};
546 
547     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
548     uint32_t return_limit;
549     napi_get_value_uint32(env, args[0], &return_limit);
550     uint32_t return_offset;
551     napi_get_value_uint32(env, args[1], &return_offset);
552     uint32_t return_ordered_by;
553     napi_get_value_uint32(env, args[2], &return_ordered_by); // 2 is index
554 
555     uint32_t value0;
556     napi_get_value_uint32(env, args[3], &value0); // 3 is index
557 
558     Asset_Attr attr[] = {
559         {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = return_limit},
560         {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = return_offset},
561         {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = return_ordered_by},
562     };
563     Asset_ResultSet resultSet = {0};
564     int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
565     if (ret == ASSET_SUCCESS) {
566         if (resultSet.count == value0) {
567             ret = MAGIC_RET;
568         }
569     }
570     napi_value result;
571     napi_create_uint32(env, ret, &result);
572     OH_Asset_FreeResultSet(&resultSet);
573     return result;
574 }
575 
AssetQueryInvalidArg(Asset_Attr *attr, uint32_t attrCnt)576 static int32_t AssetQueryInvalidArg(Asset_Attr *attr, uint32_t attrCnt)
577 {
578     int32_t result = 0;
579     Asset_ResultSet resultSet = {0};
580     int32_t ret = OH_Asset_Query(attr, attrCnt, &resultSet);
581     if (ret == ASSET_INVALID_ARGUMENT) {
582         result = 1;
583     }
584     OH_Asset_FreeResultSet(&resultSet);
585     return result;
586 }
587 
Asset_QueryError(napi_env env, napi_callback_info info)588 static napi_value Asset_QueryError(napi_env env, napi_callback_info info)
589 {
590     size_t argc = 2;
591     napi_value args[2] = {nullptr};
592 
593     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
594 
595     char aliasBuffer[BUFF_MAX];
596     size_t bufferSize = BUFF_MAX;
597     size_t copied = 0;
598 
599     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
600 
601     char secretBuffer[BUFF_MAX];
602     bufferSize = BUFF_MAX;
603     copied = 0;
604 
605     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
606 
607     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
608     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
609     Asset_Blob label = {static_cast<uint32_t>(strlen(DEMO_LABEL)),
610                         const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(DEMO_LABEL))};
611 
612     Asset_Attr attr[] = {
613         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
614         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
615     };
616     int32_t result = 0;
617     result += AssetQueryInvalidArg(attr, sizeof(attr) / sizeof(attr[0]));
618 
619     Asset_Attr attr2[] = {
620         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
621     };
622     result += AssetQueryInvalidArg(attr2, sizeof(attr2) / sizeof(attr2[0]));
623 
624     Asset_Attr attr3[] = {
625         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
626         {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label},
627     };
628     result += AssetQueryInvalidArg(attr3, sizeof(attr3) / sizeof(attr3[0]));
629 
630     Asset_Attr attr4[] = {
631         {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
632         {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
633         {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
634     };
635     result += AssetQueryInvalidArg(attr4, sizeof(attr4) / sizeof(attr4[0]));
636 
637     napi_value result_real;
638     napi_create_uint32(env, result, &result_real);
639     return result_real;
640 }
641 
Asset_QueryNum(napi_env env, napi_callback_info info)642 static napi_value Asset_QueryNum(napi_env env, napi_callback_info info)
643 {
644     size_t argc = 1;
645     napi_value args[1] = {nullptr};
646 
647     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
648 
649     int32_t value0;
650     napi_get_value_int32(env, args[0], &value0);
651 
652     Asset_Attr attr[] = {
653 
654     };
655     Asset_ResultSet resultSet = {0};
656     int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
657     if (ret == ASSET_SUCCESS) {
658         if (resultSet.count == value0) {
659             ret = MAGIC_RET;
660         }
661     }
662     napi_value result;
663     napi_create_uint32(env, ret, &result);
664     OH_Asset_FreeResultSet(&resultSet);
665     return result;
666 }
667 
Asset_QueryLabel(napi_env env, napi_callback_info info)668 static napi_value Asset_QueryLabel(napi_env env, napi_callback_info info)
669 {
670     size_t argc = 2;
671     napi_value args[2] = {nullptr};
672 
673     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
674 
675     char labelBuffer[BUFF_MAX];
676     size_t bufferSize = BUFF_MAX;
677     size_t copied = 0;
678 
679     napi_get_value_string_utf8(env, args[0], labelBuffer, bufferSize, &copied);
680 
681     int32_t value0;
682     napi_get_value_int32(env, args[1], &value0);
683 
684     Asset_Blob label = {static_cast<uint32_t>(strlen(labelBuffer)), reinterpret_cast<uint8_t *>(labelBuffer)};
685 
686     Asset_Attr attr[] = {{.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label}};
687     Asset_ResultSet resultSet = {0};
688     int32_t ret = OH_Asset_Query(attr, sizeof(attr) / sizeof(attr[0]), &resultSet);
689     if (ret == ASSET_SUCCESS) {
690         if (resultSet.count == value0) {
691             ret = MAGIC_RET;
692         }
693     }
694     napi_value result;
695     napi_create_uint32(env, ret, &result);
696     OH_Asset_FreeResultSet(&resultSet);
697     return result;
698 }
699 
Asset_UpdateEasy(napi_env env, napi_callback_info info)700 static napi_value Asset_UpdateEasy(napi_env env, napi_callback_info info)
701 {
702     size_t argc = 2;
703     napi_value args[2] = {nullptr};
704 
705     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
706 
707     char aliasBuffer[BUFF_MAX];
708     size_t bufferSize = BUFF_MAX;
709     size_t copied = 0;
710 
711     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
712 
713     char secretBuffer[BUFF_MAX];
714     bufferSize = BUFF_MAX;
715     copied = 0;
716 
717     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
718 
719     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
720     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
721 
722     Asset_Attr query[] = {
723         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
724     };
725     Asset_Attr attributesToUpdate[] = {
726         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
727     };
728 
729     int32_t ret = OH_Asset_Update(query, sizeof(query) / sizeof(query[0]), attributesToUpdate,
730                                   sizeof(attributesToUpdate) / sizeof(attributesToUpdate[0]));
731 
732     napi_value result;
733     napi_create_uint32(env, ret, &result);
734     return result;
735 }
736 
Asset_UpdateLabel(napi_env env, napi_callback_info info)737 static napi_value Asset_UpdateLabel(napi_env env, napi_callback_info info)
738 {
739     size_t argc = 3;
740     napi_value args[3] = {nullptr};
741 
742     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
743 
744     char aliasBuffer[BUFF_MAX];
745     size_t bufferSize = BUFF_MAX;
746     size_t copied = 0;
747 
748     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
749 
750     char secretBuffer[BUFF_MAX];
751     bufferSize = BUFF_MAX;
752     copied = 0;
753 
754     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
755 
756     char labelBuffer[BUFF_MAX];
757     bufferSize = BUFF_MAX;
758     copied = 0;
759 
760     napi_get_value_string_utf8(env, args[2], labelBuffer, bufferSize, &copied); // 2 is index
761 
762     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
763     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
764     Asset_Blob label = {static_cast<uint32_t>(strlen(labelBuffer)), reinterpret_cast<uint8_t *>(labelBuffer)};
765 
766     Asset_Attr query[] = {
767         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
768     };
769     Asset_Attr attributesToUpdate[] = {{.tag = ASSET_TAG_SECRET, .value.blob = secret},
770                                        {.tag = ASSET_TAG_DATA_LABEL_NORMAL_1, .value.blob = label}};
771 
772     int32_t ret = OH_Asset_Update(query, sizeof(query) / sizeof(query[0]), attributesToUpdate,
773                                   sizeof(attributesToUpdate) / sizeof(attributesToUpdate[0]));
774     napi_value result;
775     napi_create_uint32(env, ret, &result);
776     return result;
777 }
778 
AssetUpdateInvalidArg(Asset_Attr *query, uint32_t queryCnt, Asset_Attr *attributesToUpdate, uint32_t updateCnt)779 static int32_t AssetUpdateInvalidArg(Asset_Attr *query, uint32_t queryCnt, Asset_Attr *attributesToUpdate,
780                                      uint32_t updateCnt)
781 {
782     int32_t result = 0;
783     int32_t ret = OH_Asset_Update(query, queryCnt, attributesToUpdate, updateCnt);
784     if (ret == ASSET_INVALID_ARGUMENT) {
785         result = 1;
786     }
787     return result;
788 }
789 
Asset_UpdateError(napi_env env, napi_callback_info info)790 static napi_value Asset_UpdateError(napi_env env, napi_callback_info info)
791 {
792     size_t argc = 2;
793     napi_value args[2] = {nullptr};
794 
795     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
796 
797     char aliasBuffer[BUFF_MAX];
798     size_t bufferSize = BUFF_MAX;
799     size_t copied = 0;
800 
801     napi_get_value_string_utf8(env, args[0], aliasBuffer, bufferSize, &copied);
802 
803     char secretBuffer[BUFF_MAX];
804     bufferSize = BUFF_MAX;
805     copied = 0;
806 
807     napi_get_value_string_utf8(env, args[1], secretBuffer, bufferSize, &copied);
808 
809     Asset_Blob secret = {static_cast<uint32_t>(strlen(secretBuffer)), reinterpret_cast<uint8_t *>(secretBuffer)};
810     Asset_Blob alias = {static_cast<uint32_t>(strlen(aliasBuffer)), reinterpret_cast<uint8_t *>(aliasBuffer)};
811 
812     int32_t result = 0;
813 
814     Asset_Attr query[] = {
815         {.tag = ASSET_TAG_ALIAS, .value.blob = alias},
816     };
817     Asset_Attr attributesToUpdate[] = {};
818     result += AssetUpdateInvalidArg(query, sizeof(query) / sizeof(query[0]), attributesToUpdate,
819                                     sizeof(attributesToUpdate) / sizeof(attributesToUpdate[0]));
820 
821     Asset_Attr attributesToUpdate2[] = {
822         {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
823         {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
824         {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
825     };
826     result += AssetUpdateInvalidArg(query, sizeof(query) / sizeof(query[0]), attributesToUpdate2,
827                                     sizeof(attributesToUpdate2) / sizeof(attributesToUpdate2[0]));
828 
829     Asset_Attr query2[] = {};
830     Asset_Attr attributesToUpdate3[] = {
831         {.tag = ASSET_TAG_SECRET, .value.blob = secret},
832     };
833     result += AssetUpdateInvalidArg(query2, sizeof(query2) / sizeof(query2[0]), attributesToUpdate3,
834                                     sizeof(attributesToUpdate3) / sizeof(attributesToUpdate3[0]));
835 
836     Asset_Attr query3[] = {
837         {.tag = ASSET_TAG_RETURN_LIMIT, .value.u32 = 0},
838         {.tag = ASSET_TAG_RETURN_OFFSET, .value.u32 = 10},
839         {.tag = ASSET_TAG_RETURN_ORDERED_BY, .value.u32 = 0},
840     };
841     result += AssetUpdateInvalidArg(query3, sizeof(query3) / sizeof(query3[0]), attributesToUpdate3,
842                                     sizeof(attributesToUpdate3) / sizeof(attributesToUpdate3[0]));
843 
844     napi_value result_real;
845     napi_create_uint32(env, result, &result_real);
846     return result_real;
847 }
848 
849 EXTERN_C_START
Init(napi_env env, napi_value exports)850 static napi_value Init(napi_env env, napi_value exports)
851 {
852     napi_property_descriptor desc[] = {
853         {"asset_add", nullptr, Asset_Add, nullptr, nullptr, nullptr, napi_default, nullptr},
854         {"asset_addCE", nullptr, Asset_AddCE, nullptr, nullptr, nullptr, napi_default, nullptr},
855         {"asset_queryNum", nullptr, Asset_QueryNum, nullptr, nullptr, nullptr, napi_default, nullptr},
856         {"asset_queryAll", nullptr, Asset_QueryAll, nullptr, nullptr, nullptr, napi_default, nullptr},
857         {"asset_removeAll", nullptr, Asset_RemoveAll, nullptr, nullptr, nullptr, napi_default, nullptr},
858         {"asset_remove", nullptr, Asset_Remove, nullptr, nullptr, nullptr, napi_default, nullptr},
859         {"asset_removeLabel", nullptr, Asset_RemoveLabel, nullptr, nullptr, nullptr, napi_default, nullptr},
860         {"asset_removeError", nullptr, Asset_RemoveError, nullptr, nullptr, nullptr, napi_default, nullptr},
861         {"asset_queryLabel", nullptr, Asset_QueryLabel, nullptr, nullptr, nullptr, napi_default, nullptr},
862         {"asset_queryOption", nullptr, Asset_QueryOption, nullptr, nullptr, nullptr, napi_default, nullptr},
863         {"asset_queryError", nullptr, Asset_QueryError, nullptr, nullptr, nullptr, napi_default, nullptr},
864         {"asset_updateEasy", nullptr, Asset_UpdateEasy, nullptr, nullptr, nullptr, napi_default, nullptr},
865         {"asset_updateLabel", nullptr, Asset_UpdateLabel, nullptr, nullptr, nullptr, napi_default, nullptr},
866         {"asset_updateError", nullptr, Asset_UpdateError, nullptr, nullptr, nullptr, napi_default, nullptr},
867         {"asset_preAndPostQueryNormal", nullptr, Asset_PreAndPostQueryNormal, nullptr, nullptr, nullptr, napi_default,
868          nullptr},
869         {"asset_preAndPostQueryError", nullptr, Asset_PreAndPostQueryError, nullptr, nullptr, nullptr, napi_default,
870          nullptr},
871         {"asset_addAuth", nullptr, Asset_Add_Auth, nullptr, nullptr, nullptr, napi_default, nullptr},
872         {"asset_preQuery", nullptr, Asset_PreQuery, nullptr, nullptr, nullptr, napi_default, nullptr},
873         {"asset_preAndPostQuery", nullptr, Asset_PreAndPostQuery, nullptr, nullptr, nullptr, napi_default, nullptr},
874         {"asset_postQuery", nullptr, Asset_PostQuery, nullptr, nullptr, nullptr, napi_default, nullptr},
875 
876     };
877     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
878     return exports;
879 }
880 EXTERN_C_END
881 
882 /*
883  * module define
884  */
885 static napi_module g_module = {.nm_version = 1,
886                                .nm_flags = 0,
887                                .nm_filename = nullptr,
888                                .nm_register_func = Init,
889                                .nm_modname = "assetNdkTest",
890                                .nm_priv = ((void *)0),
891                                .reserved = {0}};
892 
893 /*
894  * module register
895  */
MyPixelMapRegisterModule(void)896 extern "C" __attribute__((constructor)) void MyPixelMapRegisterModule(void) { napi_module_register(&g_module); }
897