1 /*
2 * Copyright (c) 2023 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 "raw_data.h"
17
18 #include <new>
19
20 #include "hilog/log.h"
21 #include "securec.h"
22
23 #undef LOG_DOMAIN
24 #define LOG_DOMAIN 0xD002D08
25
26 #undef LOG_TAG
27 #define LOG_TAG "HISYSEVENT_RAW_DATA"
28
29 namespace OHOS {
30 namespace HiviewDFX {
31 namespace Encoded {
32 namespace {
33 constexpr size_t EXPAND_BUF_SIZE = 128;
34 }
35
RawData()36 RawData::RawData()
37 {
38 data_ = new(std::nothrow) uint8_t[EXPAND_BUF_SIZE];
39 if (data_ == nullptr) {
40 return;
41 }
42 capacity_ = EXPAND_BUF_SIZE;
43 len_ = 0;
44 }
45
RawData(uint8_t * data,size_t dataLen)46 RawData::RawData(uint8_t* data, size_t dataLen)
47 {
48 if (data == nullptr || dataLen == 0) {
49 data_ = new(std::nothrow) uint8_t[EXPAND_BUF_SIZE];
50 if (data_ == nullptr) {
51 return;
52 }
53 capacity_ = EXPAND_BUF_SIZE;
54 len_ = 0;
55 return;
56 }
57 data_ = new(std::nothrow) uint8_t[dataLen];
58 if (data_ == nullptr) {
59 return;
60 }
61 auto ret = memcpy_s(data_, dataLen, data, dataLen);
62 if (ret != EOK) {
63 HILOG_ERROR(LOG_CORE, "Failed to copy RawData in constructor, ret is %{public}d.", ret);
64 return;
65 }
66 capacity_ = dataLen;
67 len_ = dataLen;
68 }
69
RawData(const RawData & data)70 RawData::RawData(const RawData& data)
71 {
72 auto dataLen = data.GetDataLength();
73 auto rawData = data.GetData();
74 if (dataLen == 0 || rawData == nullptr) {
75 data_ = new(std::nothrow) uint8_t[EXPAND_BUF_SIZE];
76 if (data_ == nullptr) {
77 return;
78 }
79 capacity_ = EXPAND_BUF_SIZE;
80 len_ = 0;
81 return;
82 }
83 data_ = new(std::nothrow) uint8_t[dataLen];
84 if (data_ == nullptr) {
85 return;
86 }
87 auto ret = memcpy_s(data_, dataLen, rawData, dataLen);
88 if (ret != EOK) {
89 HILOG_ERROR(LOG_CORE, "Failed to copy RawData in constructor, ret is %{public}d.", ret);
90 return;
91 }
92 capacity_ = dataLen;
93 len_ = dataLen;
94 }
95
operator =(const RawData & data)96 RawData& RawData::operator=(const RawData& data)
97 {
98 if (this == &data) {
99 return *this;
100 }
101 auto dataLen = data.GetDataLength();
102 auto rawData = data.GetData();
103 if (dataLen == 0 || rawData == nullptr) {
104 return *this;
105 }
106 uint8_t* tmpData = new(std::nothrow) uint8_t[dataLen];
107 if (tmpData == nullptr) {
108 return *this;
109 }
110 auto ret = memcpy_s(tmpData, dataLen, rawData, dataLen);
111 if (ret != EOK) {
112 HILOG_ERROR(LOG_CORE, "Failed to copy RawData in constructor, ret is %{public}d.", ret);
113 delete[] tmpData;
114 return *this;
115 }
116 if (data_ != nullptr) {
117 delete[] data_;
118 }
119 data_ = tmpData;
120 capacity_ = dataLen;
121 len_ = dataLen;
122 return *this;
123 }
124
~RawData()125 RawData::~RawData()
126 {
127 if (data_ != nullptr) {
128 delete[] data_;
129 data_ = nullptr;
130 }
131 }
132
Append(uint8_t * data,size_t len)133 bool RawData::Append(uint8_t* data, size_t len)
134 {
135 if (len == 0) {
136 return true;
137 }
138 return Update(data, len, len_);
139 }
140
IsEmpty()141 bool RawData::IsEmpty()
142 {
143 return len_ == 0 || data_ == nullptr;
144 }
145
Update(uint8_t * data,size_t len,size_t pos)146 bool RawData::Update(uint8_t* data, size_t len, size_t pos)
147 {
148 if (data == nullptr || pos > len_) {
149 HILOG_ERROR(LOG_CORE, "Invalid memory operation: length is %{public}zu, pos is %{public}zu, "
150 "len_ is %{public}zu", len, pos, len_);
151 return false;
152 }
153 auto ret = EOK;
154 if ((pos + len) > capacity_) {
155 size_t expandedSize = (len > EXPAND_BUF_SIZE) ? len : EXPAND_BUF_SIZE;
156 uint8_t* resizedData = new(std::nothrow) uint8_t[capacity_ + expandedSize];
157 if (resizedData == nullptr) {
158 return false;
159 }
160 ret = memcpy_s(resizedData, len_, data_, len_);
161 if (ret != EOK) {
162 HILOG_ERROR(LOG_CORE, "Failed to expand capacity of raw data, ret is %{public}d.", ret);
163 delete[] resizedData;
164 return false;
165 }
166 capacity_ += expandedSize;
167 if (data_ != nullptr) {
168 delete[] data_;
169 }
170 data_ = resizedData;
171 }
172 // append new data
173 ret = memcpy_s(data_ + pos, len, data, len);
174 if (ret != EOK) {
175 HILOG_ERROR(LOG_CORE, "Failed to append new data, ret is %{public}d.", ret);
176 return false;
177 }
178 if ((pos + len) > len_) {
179 len_ = pos + len;
180 }
181 return true;
182 }
183
GetData() const184 uint8_t* RawData::GetData() const
185 {
186 return data_;
187 }
188
GetDataLength() const189 size_t RawData::GetDataLength() const
190 {
191 return len_;
192 }
193 } // namespace Encoded
194 } // namespace HiviewDFX
195 } // namespace OHOS