1 /*
2 * Copyright (c) 2022 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 "buffer.h"
17 #include "securec.h"
18 #include "face_auth_log_wrapper.h"
19
20 namespace OHOS {
21 namespace UserIAM {
22 namespace FaceAuth {
23 const int MAX_BUFFER_SIZE = 512000;
24
IsBufferValid(const Buffer * buffer)25 bool IsBufferValid(const Buffer *buffer)
26 {
27 if ((buffer == nullptr) || (buffer->buf == nullptr) ||
28 (buffer->maxSize == 0) || (buffer->maxSize > MAX_BUFFER_SIZE) ||
29 (buffer->contentSize > buffer->maxSize)) {
30 return false;
31 }
32
33 return true;
34 }
35
CheckBufferWithSize(const Buffer * buffer,const uint32_t size)36 bool CheckBufferWithSize(const Buffer *buffer, const uint32_t size)
37 {
38 if ((!IsBufferValid(buffer)) || (buffer->contentSize != size)) {
39 return false;
40 }
41
42 return true;
43 }
44
CreateBuffer(const uint32_t size)45 Buffer *CreateBuffer(const uint32_t size)
46 {
47 if ((size == 0) || (size > MAX_BUFFER_SIZE)) {
48 FACEAUTH_HILOGE(MODULE_SERVICE, "Bad param size:%{public}u", size);
49 return nullptr;
50 }
51
52 Buffer *buffer = (Buffer *)malloc(sizeof(Buffer));
53 if (buffer == nullptr) {
54 FACEAUTH_HILOGE(MODULE_SERVICE, "malloc buffer fail");
55 return nullptr;
56 }
57
58 buffer->buf = (uint8_t *)malloc(size);
59 if (buffer->buf == nullptr) {
60 FACEAUTH_HILOGE(MODULE_SERVICE, "malloc buffer content fail");
61 free(buffer);
62 return nullptr;
63 }
64
65 if (memset_s(buffer->buf, size, 0, size) != EOK) {
66 FACEAUTH_HILOGE(MODULE_SERVICE, "clear buffer content fail");
67 free(buffer->buf);
68 free(buffer);
69 return nullptr;
70 }
71 buffer->maxSize = size;
72 buffer->contentSize = 0;
73
74 return buffer;
75 }
76
InitBuffer(Buffer * buffer,const uint8_t * buf,const uint32_t bufSize)77 ResultCode InitBuffer(Buffer *buffer, const uint8_t *buf, const uint32_t bufSize)
78 {
79 if (!IsBufferValid(buffer) || (buf == nullptr) || (bufSize == 0)) {
80 FACEAUTH_HILOGE(MODULE_SERVICE, "Bad param");
81 return RESULT_BAD_PARAM;
82 }
83
84 if (memcpy_s(buffer->buf, buffer->maxSize, buf, bufSize) != EOK) {
85 FACEAUTH_HILOGE(MODULE_SERVICE, "Copy buffer fail");
86 return RESULT_BAD_COPY;
87 }
88 buffer->contentSize = bufSize;
89
90 return RESULT_SUCCESS;
91 }
92
DestoryBuffer(Buffer * buffer)93 void DestoryBuffer(Buffer *buffer)
94 {
95 if (buffer != nullptr) {
96 if (buffer->buf != nullptr) {
97 if (memset_s(buffer->buf, buffer->contentSize, 0, buffer->contentSize) != EOK) {
98 FACEAUTH_HILOGE(MODULE_SERVICE, "memset fail");
99 }
100 free(buffer->buf);
101 buffer->buf = nullptr;
102 buffer->contentSize = 0;
103 buffer->maxSize = 0;
104 }
105 free(buffer);
106 }
107 }
108
CopyBuffer(const Buffer * buffer)109 Buffer *CopyBuffer(const Buffer *buffer)
110 {
111 if (!IsBufferValid(buffer)) {
112 FACEAUTH_HILOGE(MODULE_SERVICE, "Invalid buffer");
113 return nullptr;
114 }
115
116 Buffer *copyBuffer = CreateBuffer(buffer->maxSize);
117 if (copyBuffer == nullptr) {
118 FACEAUTH_HILOGE(MODULE_SERVICE, "create buffer fail");
119 return nullptr;
120 }
121
122 if (memcpy_s(copyBuffer->buf, copyBuffer->maxSize, buffer->buf, buffer->contentSize) != EOK) {
123 FACEAUTH_HILOGE(MODULE_SERVICE, "Copy buffer content fail");
124 DestoryBuffer(copyBuffer);
125 return nullptr;
126 }
127 copyBuffer->contentSize = buffer->contentSize;
128
129 return copyBuffer;
130 }
131
CompareBuffer(const Buffer * buffer1,const Buffer * buffer2)132 bool CompareBuffer(const Buffer *buffer1, const Buffer *buffer2)
133 {
134 if (!IsBufferValid(buffer1) || !IsBufferValid(buffer2) || (buffer1->contentSize != buffer2->contentSize)) {
135 return false;
136 }
137
138 if (memcmp(buffer1->buf, buffer2->buf, buffer1->contentSize) == 0) {
139 return true;
140 }
141
142 return false;
143 }
144
GetBufferData(const Buffer * buffer,uint8_t * data,uint32_t * dataSize)145 ResultCode GetBufferData(const Buffer *buffer, uint8_t *data, uint32_t *dataSize)
146 {
147 if (!IsBufferValid(buffer) || (data == nullptr) || (dataSize == nullptr)) {
148 FACEAUTH_HILOGE(MODULE_SERVICE, "Bad param");
149 return RESULT_BAD_PARAM;
150 }
151 if (memcpy_s(data, *dataSize, buffer->buf, buffer->contentSize) != EOK) {
152 FACEAUTH_HILOGE(MODULE_SERVICE, "Copy buffer fail");
153 return RESULT_BAD_COPY;
154 }
155 *dataSize = buffer->contentSize;
156 return RESULT_SUCCESS;
157 }
158 } // namespace FaceAuth
159 } // namespace UserIAM
160 } // namespace OHOS
161