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
18 #include "securec.h"
19
20 #include "adaptor_log.h"
21 #include "adaptor_memory.h"
22
23 #define MAX_BUFFER_SIZE 512000
24
IsBufferValid(const Buffer * buffer)25 bool IsBufferValid(const Buffer *buffer)
26 {
27 if ((buffer == NULL) || (buffer->buf == NULL) ||
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
CreateBufferBySize(const uint32_t size)45 Buffer *CreateBufferBySize(const uint32_t size)
46 {
47 if ((size == 0) || (size > MAX_BUFFER_SIZE)) {
48 LOG_ERROR("invalid param, size: %u", size);
49 return NULL;
50 }
51
52 Buffer *buffer = (Buffer *)Malloc(sizeof(Buffer));
53 if (buffer == NULL) {
54 LOG_ERROR("malloc buffer struct failed");
55 return NULL;
56 }
57
58 buffer->buf = (uint8_t *)Malloc(size);
59 if (buffer->buf == NULL) {
60 LOG_ERROR("malloc buffer data failed");
61 Free(buffer);
62 return NULL;
63 }
64
65 if (memset_s(buffer->buf, size, 0, size) != EOK) {
66 Free(buffer->buf);
67 Free(buffer);
68 return NULL;
69 }
70 buffer->maxSize = size;
71 buffer->contentSize = 0;
72
73 return buffer;
74 }
75
CreateBufferByData(const uint8_t * data,const uint32_t dataSize)76 Buffer *CreateBufferByData(const uint8_t *data, const uint32_t dataSize)
77 {
78 if ((data == NULL) || (dataSize == 0) || (dataSize > MAX_BUFFER_SIZE)) {
79 LOG_ERROR("invalid param, dataSize: %u", dataSize);
80 return NULL;
81 }
82
83 Buffer *buffer = (Buffer *)Malloc(sizeof(Buffer));
84 if (buffer == NULL) {
85 LOG_ERROR("malloc buffer struct failed");
86 return NULL;
87 }
88
89 buffer->buf = (uint8_t *)Malloc(dataSize);
90 if (buffer->buf == NULL) {
91 LOG_ERROR("malloc buffer data failed");
92 Free(buffer);
93 return NULL;
94 }
95
96 if (memcpy_s(buffer->buf, dataSize, data, dataSize) != EOK) {
97 LOG_ERROR("copy buffer failed");
98 DestoryBuffer(buffer);
99 return NULL;
100 }
101 buffer->maxSize = dataSize;
102 buffer->contentSize = dataSize;
103
104 return buffer;
105 }
106
DestoryBuffer(Buffer * buffer)107 void DestoryBuffer(Buffer *buffer)
108 {
109 if (buffer != NULL) {
110 if (buffer->buf != NULL) {
111 if (memset_s(buffer->buf, buffer->maxSize, 0, buffer->maxSize) != EOK) {
112 LOG_ERROR("memset_s failed");
113 }
114 Free(buffer->buf);
115 buffer->buf = NULL;
116 buffer->contentSize = 0;
117 buffer->maxSize = 0;
118 }
119 Free(buffer);
120 }
121 }
122
CopyBuffer(const Buffer * buffer)123 Buffer *CopyBuffer(const Buffer *buffer)
124 {
125 if (!IsBufferValid(buffer)) {
126 LOG_ERROR("invalid buffer");
127 return NULL;
128 }
129
130 Buffer *copyBuffer = CreateBufferBySize(buffer->maxSize);
131 if (copyBuffer == NULL) {
132 LOG_ERROR("create buffer failed");
133 return NULL;
134 }
135
136 if (memcpy_s(copyBuffer->buf, copyBuffer->maxSize, buffer->buf, buffer->contentSize) != EOK) {
137 LOG_ERROR("copy buffer failed");
138 goto FAIL;
139 }
140 copyBuffer->contentSize = buffer->contentSize;
141
142 return copyBuffer;
143
144 FAIL:
145 DestoryBuffer(copyBuffer);
146 return NULL;
147 }
148
CompareBuffer(const Buffer * buffer1,const Buffer * buffer2)149 bool CompareBuffer(const Buffer *buffer1, const Buffer *buffer2)
150 {
151 if (!IsBufferValid(buffer1) || !IsBufferValid(buffer2) || (buffer1->contentSize != buffer2->contentSize)) {
152 return false;
153 }
154
155 if (memcmp(buffer1->buf, buffer2->buf, buffer1->contentSize) == 0) {
156 return true;
157 }
158
159 return false;
160 }
161
GetBufferData(const Buffer * buffer,uint8_t * data,uint32_t * dataSize)162 ResultCode GetBufferData(const Buffer *buffer, uint8_t *data, uint32_t *dataSize)
163 {
164 if (!IsBufferValid(buffer) || (data == NULL) || (dataSize == NULL)) {
165 LOG_ERROR("invalid params");
166 return RESULT_BAD_PARAM;
167 }
168 if (memcpy_s(data, *dataSize, buffer->buf, buffer->contentSize) != EOK) {
169 LOG_ERROR("copy buffer failed");
170 return RESULT_BAD_COPY;
171 }
172 *dataSize = buffer->contentSize;
173 return RESULT_SUCCESS;
174 }