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 #ifndef SOFTBUS_EVENT_CONVERTER_H
17 #define SOFTBUS_EVENT_CONVERTER_H
18 
19 #include <securec.h>
20 #include <string.h>
21 
22 #include "comm_log.h"
23 #include "form/softbus_event_form.h"
24 #include "hisysevent_c.h"
25 #include "anonymizer.h"
26 
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30 
31 #define INVALID_INT_VALUE               0
32 #define PARAM_STRING_VALUE_MAX_LEN      256
33 #define PARAM_LONG_STRING_VALUE_MAX_LEN (256 * 1024)
34 
35 typedef struct {
36     char name[MAX_LENGTH_OF_PARAM_NAME];
37     HiSysEventParamType type;
38     bool (*Assign)(const char[], HiSysEventParamType, SoftbusEventForm *, HiSysEventParam *);
39 } HiSysEventParamAssigner;
40 
InitString(char ** str,size_t maxLen)41 static inline bool InitString(char **str, size_t maxLen)
42 {
43     *str = (char *)malloc(maxLen);
44     if (*str == NULL) {
45         COMM_LOGE(COMM_DFX, "malloc param string fail");
46         return false;
47     }
48     if (memset_s(*str, maxLen, 0, maxLen) != EOK) {
49         COMM_LOGE(COMM_DFX, "memset_s param string fail");
50         return false;
51     }
52     return true;
53 }
54 
CopyString(char * destName,const char * srcName,size_t maxLen)55 static inline bool CopyString(char *destName, const char *srcName, size_t maxLen)
56 {
57     if (strcpy_s(destName, maxLen, srcName) != EOK) {
58         COMM_LOGE(COMM_DFX, "strcpy_s fail, srcName=%{public}s, maxLen=%{public}zu", srcName, maxLen);
59         return false;
60     }
61     return true;
62 }
63 
64 /* Used by ASSIGNER macros */
AssignerInt32(int32_t value,HiSysEventParam ** param)65 static inline bool AssignerInt32(int32_t value, HiSysEventParam **param)
66 {
67     if (value <= INVALID_INT_VALUE) {
68         (*param)->v.i32 = INVALID_INT_VALUE;
69         return false;
70     }
71     (*param)->v.i32 = value;
72     return true;
73 }
74 
75 /* Used by ASSIGNER macros */
AssignerString(const char * value,HiSysEventParam ** param)76 static inline bool AssignerString(const char *value, HiSysEventParam **param)
77 {
78     if (value == NULL || value[0] == '\0' || strnlen(value, PARAM_STRING_VALUE_MAX_LEN) == PARAM_STRING_VALUE_MAX_LEN) {
79         (*param)->v.s = NULL;
80         return false;
81     }
82     return InitString(&(*param)->v.s, PARAM_STRING_VALUE_MAX_LEN) &&
83         CopyString((*param)->v.s, value, PARAM_STRING_VALUE_MAX_LEN);
84 }
85 
86 /* Used by ASSIGNER macros */
AssignerLongString(const char * value,HiSysEventParam ** param)87 static inline bool AssignerLongString(const char *value, HiSysEventParam **param)
88 {
89     if (value == NULL || value[0] == '\0' || strnlen(value,
90         PARAM_LONG_STRING_VALUE_MAX_LEN) == PARAM_LONG_STRING_VALUE_MAX_LEN) {
91         (*param)->v.s = NULL;
92         return false;
93     }
94     return InitString(&(*param)->v.s, PARAM_LONG_STRING_VALUE_MAX_LEN) &&
95         CopyString((*param)->v.s, value, PARAM_LONG_STRING_VALUE_MAX_LEN);
96 }
97 
98 /* Used by ASSIGNER macros */
AssignerAnonymizeString(const char * value,HiSysEventParam ** param)99 static inline bool AssignerAnonymizeString(const char *value, HiSysEventParam **param)
100 {
101     if (value == NULL || value[0] == '\0' || strnlen(value, PARAM_STRING_VALUE_MAX_LEN) == PARAM_STRING_VALUE_MAX_LEN) {
102         (*param)->v.s = NULL;
103         return false;
104     }
105     if (!InitString(&(*param)->v.s, PARAM_STRING_VALUE_MAX_LEN)) {
106         return false;
107     }
108     char *anonyStr = NULL;
109     Anonymize(value, &anonyStr);
110     bool status = CopyString((*param)->v.s, anonyStr, PARAM_STRING_VALUE_MAX_LEN);
111     AnonymizeFree(anonyStr);
112     return status;
113 }
114 
115 /* Used by ASSIGNER macros */
AssignerErrcode(int32_t value,HiSysEventParam ** param)116 static inline bool AssignerErrcode(int32_t value, HiSysEventParam **param)
117 {
118     (*param)->v.i32 = (value < 0) ? (-value) : value;
119     return true;
120 }
121 
122 /* Used by ASSIGNER macros */
AssignerUint64(uint64_t value,HiSysEventParam ** param)123 static inline bool AssignerUint64(uint64_t value, HiSysEventParam **param)
124 {
125     (*param)->v.ui64 = value;
126     return true;
127 }
128 
129 /* Used by ASSIGNER macros */
AssignerUint32(uint32_t value,HiSysEventParam ** param)130 static inline bool AssignerUint32(uint32_t value, HiSysEventParam **param)
131 {
132     (*param)->v.ui32 = value;
133     return true;
134 }
135 
136 #define SOFTBUS_ASSIGNER(type, fieldName, field)                                                                   \
137     static inline bool SoftbusAssigner##fieldName(                                                                 \
138         const char *eventName, HiSysEventParamType paramType, SoftbusEventForm *form, HiSysEventParam *param)      \
139     {                                                                                                              \
140         if (Assigner##type(form->field, &param) && CopyString(param->name, eventName, MAX_LENGTH_OF_PARAM_NAME)) { \
141             param->t = paramType;                                                                                  \
142             return true;                                                                                           \
143         }                                                                                                          \
144         return false;                                                                                              \
145     }
146 
147 SOFTBUS_ASSIGNER(Int32, Scene, scene)
148 SOFTBUS_ASSIGNER(Int32, Stage, stage)
149 SOFTBUS_ASSIGNER(String, OrgPkg, orgPkg)
150 SOFTBUS_ASSIGNER(String, Func, func)
151 
152 #define SOFTBUS_ASSIGNER_SIZE 4 // Size of g_softbusAssigners
153 static HiSysEventParamAssigner g_softbusAssigners[] = {
154     { "BIZ_SCENE", HISYSEVENT_INT32,  SoftbusAssignerScene },
155     { "BIZ_STAGE", HISYSEVENT_INT32,  SoftbusAssignerStage },
156     { "ORG_PKG",   HISYSEVENT_STRING, SoftbusAssignerOrgPkg},
157     { "FUNC",      HISYSEVENT_STRING, SoftbusAssignerFunc  },
158     // Modification Note: remember updating SOFTBUS_ASSIGNER_SIZE
159 };
160 
ConvertSoftbusForm2Param(HiSysEventParam params[],size_t size,SoftbusEventForm * form)161 static inline size_t ConvertSoftbusForm2Param(HiSysEventParam params[], size_t size, SoftbusEventForm *form)
162 {
163     size_t validSize = 0;
164     if (form == NULL) {
165         return validSize;
166     }
167     for (size_t i = 0; i < size; ++i) {
168         HiSysEventParamAssigner assigner = g_softbusAssigners[i];
169         if (assigner.Assign(assigner.name, assigner.type, form, &params[validSize])) {
170             ++validSize;
171         }
172     }
173     return validSize;
174 }
175 
176 #ifdef __cplusplus
177 }
178 #endif /* __cplusplus */
179 #endif // SOFTBUS_EVENT_CONVERTER_H
180