1 /*
2  * Copyright (C) 2023 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 
16 #include "uint8buff_utils.h"
17 
18 #include "securec.h"
19 #include "clib_error.h"
20 #include "hc_types.h"
21 #include "ctype.h"
22 
InitUint8Buff(Uint8Buff * buff,uint32_t buffLen)23 int32_t InitUint8Buff(Uint8Buff *buff, uint32_t buffLen)
24 {
25     if (buff == NULL) {
26         return CLIB_ERR_NULL_PTR;
27     }
28     if (buffLen == 0) {
29         return CLIB_ERR_INVALID_LEN;
30     }
31     buff->val = (uint8_t *)HcMalloc(buffLen, 0);
32     if (buff->val == NULL) {
33         return CLIB_ERR_BAD_ALLOC;
34     }
35     buff->length = buffLen;
36     return CLIB_SUCCESS;
37 }
38 
DeepCopyUint8Buff(const Uint8Buff * buff,Uint8Buff * newBuff)39 int32_t DeepCopyUint8Buff(const Uint8Buff *buff, Uint8Buff *newBuff)
40 {
41     if (buff == NULL || buff->val == NULL || newBuff == NULL) {
42         return CLIB_ERR_NULL_PTR;
43     }
44     if (buff->length == 0) {
45         return CLIB_ERR_INVALID_LEN;
46     }
47     uint8_t *val = (uint8_t *)HcMalloc(buff->length, 0);
48     if (val == NULL) {
49         return CLIB_ERR_BAD_ALLOC;
50     }
51     (void)memcpy_s(val, buff->length, buff->val, buff->length);
52     newBuff->val = val;
53     newBuff->length = buff->length;
54     return CLIB_SUCCESS;
55 }
56 
FreeUint8Buff(Uint8Buff * buff)57 void FreeUint8Buff(Uint8Buff *buff)
58 {
59     if (buff == NULL || buff->val == NULL || buff->length == 0) {
60         return;
61     }
62     HcFree(buff->val);
63     buff->val = NULL;
64     buff->length = 0;
65 }
66 
ClearFreeUint8Buff(Uint8Buff * buff)67 void ClearFreeUint8Buff(Uint8Buff *buff)
68 {
69     if (buff == NULL || buff->val == NULL || buff->length == 0) {
70         return;
71     }
72     (void)memset_s(buff->val, buff->length, 0, buff->length);
73     HcFree(buff->val);
74     buff->val = NULL;
75     buff->length = 0;
76 }
77 
IsUint8BuffValid(const Uint8Buff * buff,uint32_t maxLen)78 bool IsUint8BuffValid(const Uint8Buff *buff, uint32_t maxLen)
79 {
80     return ((buff != NULL) && (buff->val != NULL) && (0 < buff->length) && (buff->length <= maxLen));
81 }
82 
ToLowerCase(Uint8Buff * buff)83 int32_t ToLowerCase(Uint8Buff *buff)
84 {
85     uint32_t buffLen = buff->length;
86     char *buffStr = (char *)HcMalloc(buffLen + 1, 0);
87     if (buffStr == NULL) {
88         return CLIB_ERR_BAD_ALLOC;
89     }
90     if (memcpy_s(buffStr, buffLen + 1, buff->val, buffLen) != EOK) {
91         HcFree(buffStr);
92         return CLIB_FAILED;
93     }
94     for (uint32_t i = 0; i < buffLen; i++) {
95         buffStr[i] = tolower(buffStr[i]);
96     }
97     if (memcpy_s(buff->val, buffLen, buffStr, buffLen) != EOK) {
98         HcFree(buffStr);
99         return CLIB_FAILED;
100     }
101     HcFree(buffStr);
102     return CLIB_SUCCESS;
103 }
104