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