1 /*
2  * Copyright (c) 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 "event_log_wrapper.h"
17 #include "oh_commonevent_parameters_parse.h"
18 #include "oh_commonevent.h"
19 #include "want.h"
20 #include "int_wrapper.h"
21 #include "double_wrapper.h"
22 #include "string_wrapper.h"
23 #include "bool_wrapper.h"
24 #include "zchar_wrapper.h"
25 #include "long_wrapper.h"
26 #include "array_wrapper.h"
27 #include "want_params_wrapper.h"
28 #include "securec.h"
29 #include <memory>
30 #include <new>
31 
32 namespace OHOS {
33 namespace EventFwk {
34 // WantParameters -> CArrParameters
InnerWrapWantParamsString(AAFwk::WantParams & wantParams,CParameters * p)35 void InnerWrapWantParamsString(AAFwk::WantParams &wantParams, CParameters *p)
36 {
37     auto value = wantParams.GetParam(p->key);
38     AAFwk::IString *ao = AAFwk::IString::Query(value);
39     if (ao == nullptr) {
40         EVENT_LOGE("No value");
41         return;
42     }
43     std::string natValue = AAFwk::String::Unbox(ao);
44     p->value = MallocCString(natValue);
45     p->size = static_cast<int64_t>(natValue.length()) + 1;
46     p->valueType = STR_TYPE;
47 }
48 
49 template <class TBase, class T, class NativeT>
InnerWrapWantParamsT(AAFwk::WantParams & wantParams,CParameters * p)50 void InnerWrapWantParamsT(AAFwk::WantParams &wantParams, CParameters *p)
51 {
52     auto value = wantParams.GetParam(p->key);
53     TBase *ao = TBase::Query(value);
54     if (ao == nullptr) {
55         EVENT_LOGE("No value");
56         return;
57     }
58     NativeT natValue = T::Unbox(ao);
59     NativeT *ptr = static_cast<NativeT *>(malloc(sizeof(NativeT)));
60     if (ptr == nullptr) {
61         return;
62     }
63     *ptr = natValue;
64     p->value = static_cast<void*>(ptr);
65     p->size = sizeof(NativeT);
66 }
67 
InnerWrapWantParamsArrayString(sptr<AAFwk::IArray> & ao,CParameters * p)68 void InnerWrapWantParamsArrayString(sptr<AAFwk::IArray> &ao, CParameters *p)
69 {
70     long size = 0;
71     if (ao->GetLength(size) != COMMONEVENT_ERR_OK) {
72         EVENT_LOGD("fail to get length");
73         return;
74     }
75     char **arrP = static_cast<char **>(malloc(sizeof(char *) * size));
76     if (arrP == nullptr) {
77         return;
78     }
79     for (long i = 0; i < size; i++) {
80         sptr<AAFwk::IInterface> iface = nullptr;
81         if (ao->Get(i, iface) == COMMONEVENT_ERR_OK) {
82             AAFwk::IString *iValue = AAFwk::IString::Query(iface);
83             if (iValue != nullptr) {
84                 auto val = AAFwk::String::Unbox(iValue);
85                 arrP[i] = MallocCString(val);
86             }
87         }
88     }
89     p->size = size;
90     p->value = static_cast<void *>(arrP);
91 }
92 
ClearParametersPtr(CParameters ** ptr,int count,bool isKey)93 void ClearParametersPtr(CParameters **ptr, int count, bool isKey)
94 {
95     CParameters *p = *ptr;
96     for (int i = 0; i < count; i++) {
97         free(p[i].key);
98         free(p[i].value);
99         p[i].key = nullptr;
100         p[i].value = nullptr;
101     }
102     if (!isKey) {
103         free(p[count].key);
104         p[count].key = nullptr;
105     }
106     free(*ptr);
107     *ptr = nullptr;
108 }
109 
110 template <class TBase, class T, class NativeT>
InnerWrapWantParamsArrayT(sptr<AAFwk::IArray> & ao,CParameters * p)111 void InnerWrapWantParamsArrayT(sptr<AAFwk::IArray> &ao, CParameters *p)
112 {
113     long size = 0;
114     if (ao->GetLength(size) != COMMONEVENT_ERR_OK) {
115         EVENT_LOGD("fail to get length");
116         return;
117     }
118     NativeT *arrP = static_cast<NativeT *>(malloc(sizeof(NativeT) * size));
119     if (arrP == nullptr) {
120         return;
121     }
122     for (long i = 0; i < size; i++) {
123         sptr<AAFwk::IInterface> iface = nullptr;
124         if (ao->Get(i, iface) == COMMONEVENT_ERR_OK) {
125             TBase *iValue = TBase::Query(iface);
126             if (iValue != nullptr) {
127                 arrP[i] = T::Unbox(iValue);
128             }
129         }
130     }
131     p->size = size;
132     p->value = static_cast<void *>(arrP);
133 }
134 
InnerWrapWantParamsArray(AAFwk::WantParams & wantParams,sptr<AAFwk::IArray> & ao,CParameters * p)135 void InnerWrapWantParamsArray(AAFwk::WantParams &wantParams, sptr<AAFwk::IArray> &ao, CParameters *p)
136 {
137     if (AAFwk::Array::IsBooleanArray(ao)) {
138         p->valueType = BOOL_PTR_TYPE;
139         return InnerWrapWantParamsArrayT<AAFwk::IBoolean, AAFwk::Boolean, bool>(ao, p);
140     } else if (AAFwk::Array::IsIntegerArray(ao)) {
141         p->valueType = I32_PTR_TYPE;
142         return InnerWrapWantParamsArrayT<AAFwk::IInteger, AAFwk::Integer, int>(ao, p);
143     } else if (AAFwk::Array::IsLongArray(ao)) {
144         p->valueType = I64_PTR_TYPE;
145         return InnerWrapWantParamsArrayT<AAFwk::ILong, AAFwk::Long, int64_t>(ao, p);
146     } else if (AAFwk::Array::IsDoubleArray(ao)) {
147         p->valueType = DOUBLE_PTR_TYPE;
148         return InnerWrapWantParamsArrayT<AAFwk::IDouble, AAFwk::Double, double>(ao, p);
149     } else {
150         return;
151     }
152 }
153 
ParseParameters(AAFwk::Want & want,CArrParameters * parameters,int32_t & code)154 void ParseParameters(AAFwk::Want &want, CArrParameters* parameters, int32_t &code)
155 {
156     if (code != COMMONEVENT_ERR_OK || parameters == nullptr) {
157         return;
158     }
159     AAFwk::WantParams wantP = want.GetParams();
160     std::map<std::string, sptr<AAFwk::IInterface>> paramsMap = wantP.GetParams();
161     int count = 0;
162     auto size = static_cast<int64_t>(paramsMap.size());
163 
164     parameters->head = static_cast<CParameters *>(malloc(sizeof(CParameters) * size));
165     if (parameters->head == nullptr) {
166         return;
167     }
168     parameters->size = size;
169     for (auto iter = paramsMap.begin(); iter != paramsMap.end(); iter++) {
170         auto ptr = parameters->head + count;
171         ptr->key = MallocCString(iter->first);
172         if (ptr->key == nullptr) {
173             code = COMMONEVENT_ERR_ALLOC_MEMORY_FAILED;
174             parameters->size = 0;
175             return ClearParametersPtr(&parameters->head, count, true);
176         }
177         ptr->value = nullptr;
178         if (AAFwk::IString::Query(iter->second) != nullptr) {
179             InnerWrapWantParamsString(wantP, ptr);
180         } else if (AAFwk::IBoolean::Query(iter->second) != nullptr) {
181             ptr->valueType = BOOL_TYPE;
182             InnerWrapWantParamsT<AAFwk::IBoolean, AAFwk::Boolean, bool>(wantP, ptr);
183         } else if (AAFwk::IChar::Query(iter->second) != nullptr) {
184             ptr->valueType = CHAR_TYPE;
185             InnerWrapWantParamsT<AAFwk::IChar, AAFwk::Char, char>(wantP, ptr);
186         } else if (AAFwk::IInteger::Query(iter->second) != nullptr) {
187             ptr->valueType = I32_TYPE;
188             InnerWrapWantParamsT<AAFwk::IInteger, AAFwk::Integer, int>(wantP, ptr);
189         } else if (AAFwk::IDouble::Query(iter->second) != nullptr) {
190             ptr->valueType = DOUBLE_TYPE;
191             InnerWrapWantParamsT<AAFwk::IDouble, AAFwk::Double, double>(wantP, ptr);
192         } else if (AAFwk::ILong::Query(iter->second) != nullptr) {
193             ptr->valueType = I64_TYPE;
194             InnerWrapWantParamsT<AAFwk::ILong, AAFwk::Long, int64_t>(wantP, ptr);
195         } else if (AAFwk::IArray::Query(iter->second) != nullptr) {
196             AAFwk::IArray *ao = AAFwk::IArray::Query(iter->second);
197             sptr<AAFwk::IArray> array(ao);
198             InnerWrapWantParamsArray(wantP, array, ptr);
199         }
200         count++;
201     }
202 }
203 
MallocCString(const std::string & origin)204 char *MallocCString(const std::string &origin)
205 {
206     if (origin.empty()) {
207         return nullptr;
208     }
209     auto len = origin.length() + 1;
210     char *res = static_cast<char *>(malloc(sizeof(char) * len));
211     if (res == nullptr) {
212         return nullptr;
213     }
214     return std::char_traits<char>::copy(res, origin.c_str(), len);
215 }
216 
MallocCString(const std::string & origin,int32_t & code)217 char *MallocCString(const std::string &origin, int32_t &code)
218 {
219     if (origin.empty() || code != COMMONEVENT_ERR_OK) {
220         return nullptr;
221     }
222     auto len = origin.length() + 1;
223     char *res = static_cast<char *>(malloc(sizeof(char) * len));
224     if (res == nullptr) {
225         code = COMMONEVENT_ERR_ALLOC_MEMORY_FAILED;
226         return nullptr;
227     }
228     return std::char_traits<char>::copy(res, origin.c_str(), len);
229 }
230 
FreeCCommonEventDataCharPtr(CommonEvent_RcvData * cData)231 void FreeCCommonEventDataCharPtr(CommonEvent_RcvData *cData)
232 {
233     free(cData->data);
234     free(cData->event);
235     free(cData->bundleName);
236     cData->data = nullptr;
237     cData->event = nullptr;
238     cData->bundleName = nullptr;
239 }
240 
GetCommonEventData(const EventFwk::CommonEventData & data,CommonEvent_RcvData * cData)241 int32_t GetCommonEventData(const EventFwk::CommonEventData &data, CommonEvent_RcvData *cData)
242 {
243     auto want = data.GetWant();
244     cData->code = data.GetCode();
245     int32_t code = COMMONEVENT_ERR_OK;
246     cData->data = MallocCString(data.GetData(), code);
247     cData->event = MallocCString(want.GetAction(), code);
248     cData->bundleName = MallocCString(want.GetBundle(), code);
249     cData->parameters = new (std::nothrow) CArrParameters();
250     ParseParameters(want, cData->parameters, code);
251 
252     if (code != COMMONEVENT_ERR_OK) {
253         EVENT_LOGD("free commonEventData");
254         FreeCCommonEventDataCharPtr(cData);
255         delete cData->parameters;
256         cData->parameters = nullptr;
257     }
258     return code;
259 }
260 
FreeCCommonEventData(CommonEvent_RcvData * cData)261 void FreeCCommonEventData(CommonEvent_RcvData *cData)
262 {
263     EVENT_LOGD("free commonEventData");
264     FreeCCommonEventDataCharPtr(cData);
265     auto parameters = cData->parameters;
266     if (parameters != nullptr && parameters->head != nullptr) {
267         for (int i = 0; i < parameters->size; i++) {
268             auto ptr = parameters->head[i];
269             free(ptr.key);
270             ptr.key = nullptr;
271             free(ptr.value);
272             ptr.value = nullptr;
273         }
274         free(parameters->head);
275         parameters->head = nullptr;
276         parameters->size = 0;
277     }
278     delete cData->parameters;
279     cData->parameters = nullptr;
280 }
281 
HasKeyFromParameters(const CArrParameters * parameters,const char * key)282 bool HasKeyFromParameters(const CArrParameters* parameters, const char* key)
283 {
284     if (parameters->head == nullptr) {
285         EVENT_LOGI("head is null");
286         return false;
287     }
288     for (int i = 0; i < parameters->size; i++) {
289         CParameters *it = parameters->head + i;
290         if (std::strcmp(it->key, key) == 0) {
291             return true;
292         }
293     }
294     return false;
295 }
296 }  // namespace EventFwk
297 }  // namespace OHOS