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
23bool 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
34Buffer 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
44bool 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
53Buffer *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
84Buffer *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
115ResultCode 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
131void 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
147Buffer *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
168FAIL:
169    DestroyBuffer(copyBuffer);
170
171    return NULL;
172}
173
174bool 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
187ResultCode 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}