1 /*
2 * Copyright (c) 2022-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
16 #include "buffer.h"
17 #include "adaptor_log.h"
18 #include "adaptor_memory.h"
19 #include "securec.h"
20
21 #define MAX_BUFFER_SIZE 512000
22
IsBufferValid(const Buffer * buffer)23 bool IsBufferValid(const Buffer *buffer)
24 {
25 if ((buffer == NULL) || (buffer->buf == NULL) ||
26 (buffer->maxSize == 0) || (buffer->maxSize > MAX_BUFFER_SIZE) ||
27 (buffer->contentSize > buffer->maxSize)) {
28 return false;
29 }
30
31 return true;
32 }
33
GetTmpBuffer(uint8_t * buf,uint32_t contentSize,uint32_t maxSize)34 Buffer GetTmpBuffer(uint8_t *buf, uint32_t contentSize, uint32_t maxSize)
35 {
36 Buffer ret = {
37 .buf = buf,
38 .contentSize = contentSize,
39 .maxSize = maxSize,
40 };
41 return ret;
42 }
43
CheckBufferWithSize(const Buffer * buffer,const uint32_t size)44 bool CheckBufferWithSize(const Buffer *buffer, const uint32_t size)
45 {
46 if ((!IsBufferValid(buffer)) || (buffer->contentSize != size)) {
47 return false;
48 }
49
50 return true;
51 }
52
CreateBufferBySize(const uint32_t size)53 Buffer *CreateBufferBySize(const uint32_t size)
54 {
55 if ((size == 0) || (size > MAX_BUFFER_SIZE)) {
56 LOG_ERROR("Bad param size:%u", size);
57 return NULL;
58 }
59
60 Buffer *buffer = (Buffer *)Malloc(sizeof(Buffer));
61 if (buffer == NULL) {
62 LOG_ERROR("Get buffer struct error");
63 return NULL;
64 }
65
66 buffer->buf = (uint8_t *)Malloc(size);
67 if (buffer->buf == NULL) {
68 LOG_ERROR("Get buffer error");
69 Free(buffer);
70 return NULL;
71 }
72
73 if (memset_s(buffer->buf, size, 0, size) != EOK) {
74 Free(buffer->buf);
75 Free(buffer);
76 return NULL;
77 }
78 buffer->maxSize = size;
79 buffer->contentSize = 0;
80
81 return buffer;
82 }
83
CreateBufferByData(const uint8_t * data,const uint32_t dataSize)84 Buffer *CreateBufferByData(const uint8_t *data, const uint32_t dataSize)
85 {
86 if ((data == NULL) || (dataSize == 0) || (dataSize > MAX_BUFFER_SIZE)) {
87 LOG_ERROR("Bad param size:%u", dataSize);
88 return NULL;
89 }
90
91 Buffer *buffer = (Buffer *)Malloc(sizeof(Buffer));
92 if (buffer == NULL) {
93 LOG_ERROR("Get buffer struct error");
94 return NULL;
95 }
96
97 buffer->buf = (uint8_t *)Malloc(dataSize);
98 if (buffer->buf == NULL) {
99 LOG_ERROR("Get buffer error");
100 Free(buffer);
101 return NULL;
102 }
103
104 if (memcpy_s(buffer->buf, dataSize, data, dataSize) != EOK) {
105 LOG_ERROR("Cpy buffer error");
106 DestroyBuffer(buffer);
107 return NULL;
108 }
109 buffer->maxSize = dataSize;
110 buffer->contentSize = dataSize;
111
112 return buffer;
113 }
114
InitBuffer(Buffer * buffer,const uint8_t * buf,const uint32_t bufSize)115 ResultCode InitBuffer(Buffer *buffer, const uint8_t *buf, const uint32_t bufSize)
116 {
117 if (!IsBufferValid(buffer) || (buf == NULL) || (bufSize == 0)) {
118 LOG_ERROR("Bad param");
119 return RESULT_BAD_PARAM;
120 }
121
122 if (memcpy_s(buffer->buf, buffer->maxSize, buf, bufSize) != EOK) {
123 LOG_ERROR("Copy buffer fail");
124 return RESULT_BAD_COPY;
125 }
126 buffer->contentSize = bufSize;
127
128 return RESULT_SUCCESS;
129 }
130
DestroyBuffer(Buffer * buffer)131 void DestroyBuffer(Buffer *buffer)
132 {
133 if (buffer != NULL) {
134 if (buffer->buf != NULL) {
135 if (memset_s(buffer->buf, buffer->maxSize, 0, buffer->maxSize) != EOK) {
136 LOG_ERROR("DestroyBuffer memset fail!");
137 }
138 Free(buffer->buf);
139 buffer->buf = NULL;
140 buffer->contentSize = 0;
141 buffer->maxSize = 0;
142 }
143 Free(buffer);
144 }
145 }
146
CopyBuffer(const Buffer * buffer)147 Buffer *CopyBuffer(const Buffer *buffer)
148 {
149 if (!IsBufferValid(buffer)) {
150 LOG_ERROR("Invalid buffer");
151 return NULL;
152 }
153
154 Buffer *copyBuffer = CreateBufferBySize(buffer->maxSize);
155 if (copyBuffer == NULL) {
156 LOG_ERROR("Invalid buffer");
157 return NULL;
158 }
159
160 if (memcpy_s(copyBuffer->buf, copyBuffer->maxSize, buffer->buf, buffer->contentSize) != EOK) {
161 LOG_ERROR("Copy buffer fail");
162 goto FAIL;
163 }
164 copyBuffer->contentSize = buffer->contentSize;
165
166 return copyBuffer;
167
168 FAIL:
169 DestroyBuffer(copyBuffer);
170
171 return NULL;
172 }
173
CompareBuffer(const Buffer * buffer1,const Buffer * buffer2)174 bool CompareBuffer(const Buffer *buffer1, const Buffer *buffer2)
175 {
176 if (!IsBufferValid(buffer1) || !IsBufferValid(buffer2) || (buffer1->contentSize != buffer2->contentSize)) {
177 return false;
178 }
179
180 if (memcmp(buffer1->buf, buffer2->buf, buffer1->contentSize) == 0) {
181 return true;
182 }
183
184 return false;
185 }
186
GetBufferData(const Buffer * buffer,uint8_t * data,uint32_t * dataSize)187 ResultCode GetBufferData(const Buffer *buffer, uint8_t *data, uint32_t *dataSize)
188 {
189 if (!IsBufferValid(buffer) || (data == NULL) || (dataSize == NULL)) {
190 LOG_ERROR("Bad param");
191 return RESULT_BAD_PARAM;
192 }
193 if (memcpy_s(data, *dataSize, buffer->buf, buffer->contentSize) != EOK) {
194 LOG_ERROR("Copy buffer fail");
195 return RESULT_BAD_COPY;
196 }
197 *dataSize = buffer->contentSize;
198 return RESULT_SUCCESS;
199 }