1 /*
2 * Copyright (c) 2021 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 "properties.h"
17
18 #include "napi/native_api.h"
19 #include "napi/native_node_api.h"
20 #include "../../common/napi/n_func_arg.h"
21 #include "../../common/napi/n_class.h"
22 #include "hilog/log.h"
23 #include "hilog/log_c.h"
24 #include "securec.h"
25 #include "../include/context/hilog_napi_base.h"
26
27 #ifdef __cplusplus
28 extern "C" {
29 #endif
30 namespace OHOS {
31 namespace HiviewDFX {
32 using namespace std;
33 #define DEFAULT_LOG_TYPE LOG_CORE
34 const HiLogLabel LABEL = { LOG_CORE, 0xD002D00, "Hilog_JS" };
35 static constexpr int MIN_NUMBER = 3;
36 static constexpr int MAX_NUMBER = 100;
37 static constexpr int PUBLIC_LEN = 6;
38 static constexpr int PRIVATE_LEN = 7;
39 static constexpr int PROPERTY_POS = 2;
40
ParseLogContent(string & formatStr,vector<string> & params,string & logContent)41 void ParseLogContent(string& formatStr, vector<string>& params, string& logContent)
42 {
43 string& ret = logContent;
44 if (params.empty()) {
45 ret += formatStr;
46 return;
47 }
48 auto size = params.size();
49 auto len = formatStr.size();
50 uint32_t pos = 0;
51 uint32_t count = 0;
52 bool debug = IsDebugOn();
53 bool priv = (!debug) && IsPrivateSwitchOn();
54
55 for (; pos < len; ++pos) {
56 bool showPriv = false;
57 if (count > size) {
58 break;
59 }
60 if (formatStr[pos] == '%') {
61 if (formatStr[pos + 1] == '{') {
62 if (formatStr.substr(pos + PROPERTY_POS, PUBLIC_LEN) == "public") {
63 pos += (PUBLIC_LEN + PROPERTY_POS);
64 }
65 if (formatStr.substr(pos + PROPERTY_POS, PRIVATE_LEN) == "private") {
66 pos += (PRIVATE_LEN + PROPERTY_POS);
67 if (priv) {
68 showPriv = true ;
69 }
70 }
71 }
72 if (pos + 1 >= len) {
73 break;
74 }
75 string privStr = "<private>";
76 switch (formatStr[pos + 1]) {
77 case 's':
78 case 'j':
79 case 'd':
80 case 'O':
81 case 'o':
82 case 'i':
83 case 'f':
84 case 'c':
85 ret += showPriv ? privStr : params[count];
86 count++;
87 ++pos;
88 break;
89 case '%':
90 ret += formatStr[pos];
91 ++pos;
92 break;
93 default:
94 ret += formatStr[pos];
95 break;
96 }
97 } else {
98 ret += formatStr[pos];
99 }
100 }
101 if (pos < len) {
102 ret += formatStr.substr(pos, len - pos);
103 }
104 return;
105 }
106
isLoggable(napi_env env,napi_callback_info info)107 napi_value HilogNapiBase::isLoggable(napi_env env, napi_callback_info info)
108 {
109 NFuncArg funcArg(env, info);
110
111 if (!funcArg.InitArgs(NARG_CNT::THREE)) {
112 return nullptr;
113 }
114 bool succ = false;
115 int32_t domain;
116 tie(succ, domain) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
117 if (!succ) {
118 return nullptr;
119 }
120 int32_t level;
121 tie(succ, level) = NVal(env, funcArg[NARG_POS::THIRD]).ToInt32();
122 if (!succ) {
123 return nullptr;
124 }
125 unique_ptr<char[]> tag;
126 tie(succ, tag, ignore) = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
127 if (!succ) {
128 return nullptr;
129 }
130 bool res = HiLogIsLoggable(domain, tag.get(), static_cast<LogLevel>(level));
131 return NVal::CreateBool(env, res).val_;
132 }
133
debug(napi_env env,napi_callback_info info)134 napi_value HilogNapiBase::debug(napi_env env, napi_callback_info info)
135 {
136 return HilogImpl(env, info, LOG_DEBUG);
137 }
138
info(napi_env env,napi_callback_info info)139 napi_value HilogNapiBase::info(napi_env env, napi_callback_info info)
140 {
141 return HilogImpl(env, info, LOG_INFO);
142 }
143
warn(napi_env env,napi_callback_info info)144 napi_value HilogNapiBase::warn(napi_env env, napi_callback_info info)
145 {
146 return HilogImpl(env, info, LOG_WARN);
147 }
148
error(napi_env env,napi_callback_info info)149 napi_value HilogNapiBase::error(napi_env env, napi_callback_info info)
150 {
151 return HilogImpl(env, info, LOG_ERROR);
152 }
153
fatal(napi_env env,napi_callback_info info)154 napi_value HilogNapiBase::fatal(napi_env env, napi_callback_info info)
155 {
156 return HilogImpl(env, info, LOG_FATAL);
157 }
158
parseNapiValue(napi_env env,napi_callback_info info,napi_value element,vector<string> & params)159 napi_value HilogNapiBase::parseNapiValue(napi_env env, napi_callback_info info,
160 napi_value element, vector<string>& params)
161 {
162 bool succ = false;
163 napi_valuetype type;
164 napi_status typeStatus = napi_typeof(env, element, &type);
165 if (typeStatus != napi_ok) {
166 return nullptr;
167 }
168 if (type == napi_number) {
169 napi_value elmString;
170 napi_status objectStatus = napi_coerce_to_string(env, element, &elmString);
171 if (objectStatus != napi_ok) {
172 return nullptr;
173 }
174 unique_ptr<char[]> name;
175 tie(succ, name, ignore) = NVal(env, elmString).ToUTF8String();
176 if (!succ) {
177 return nullptr;
178 }
179 params.emplace_back(name.get());
180 } else if (type == napi_string) {
181 unique_ptr<char[]> name;
182 tie(succ, name, ignore) = NVal(env, element).ToUTF8String();
183 if (!succ) {
184 return nullptr;
185 }
186 params.emplace_back(name.get());
187 } else if (type == napi_object) {
188 napi_value elmString;
189 napi_status objectStatus = napi_coerce_to_string(env, element, &elmString);
190 if (objectStatus != napi_ok) {
191 return nullptr;
192 }
193 unique_ptr<char[]> name;
194 tie(succ, name, ignore) = NVal(env, elmString).ToUTF8String();
195 if (!succ) {
196 return nullptr;
197 }
198 params.emplace_back(name.get());
199 } else {
200 NAPI_ASSERT(env, false, "type mismatch");
201 }
202 return nullptr;
203 }
204
HilogImpl(napi_env env,napi_callback_info info,int level)205 napi_value HilogNapiBase::HilogImpl(napi_env env, napi_callback_info info, int level)
206 {
207 NFuncArg funcArg(env, info);
208 funcArg.InitArgs(MIN_NUMBER, MAX_NUMBER);
209 bool succ = false;
210 int32_t domain;
211 tie(succ, domain) = NVal(env, funcArg[NARG_POS::FIRST]).ToInt32();
212 if (!succ) {
213 HiLog::Info(LABEL, "%{public}s", "domain mismatch");
214 return nullptr;
215 }
216 unique_ptr<char[]> tag;
217 tie(succ, tag, ignore) = NVal(env, funcArg[NARG_POS::SECOND]).ToUTF8String();
218 if (!succ) {
219 HiLog::Info(LABEL, "%{public}s", "tag mismatch");
220 return nullptr;
221 }
222 unique_ptr<char[]> fmt;
223 tie(succ, fmt, ignore) = NVal(env, funcArg[NARG_POS::THIRD]).ToUTF8String();
224 if (!succ) {
225 HiLog::Info(LABEL, "%{public}s", "Format mismatch");
226 return nullptr;
227 }
228 string fmtString = fmt.get();
229 bool res = false;
230 napi_value array = funcArg[NARG_POS::FOURTH];
231 napi_is_array(env, array, &res);
232 string logContent;
233 vector<string> params;
234 if (!res) {
235 for (size_t i = MIN_NUMBER; i < funcArg.GetArgc(); i++) {
236 napi_value argsVal = funcArg[i];
237 parseNapiValue(env, info, argsVal, params);
238 }
239 } else {
240 if (funcArg.GetArgc() != MIN_NUMBER + 1) {
241 NAPI_ASSERT(env, false, "Argc mismatch");
242 HiLog::Info(LABEL, "%{public}s", "Argc mismatch");
243 return nullptr;
244 }
245 uint32_t length;
246 napi_status lengthStatus = napi_get_array_length(env, array, &length);
247 if (lengthStatus != napi_ok) {
248 return nullptr;
249 }
250 uint32_t i;
251 for (i = 0; i < length; i++) {
252 napi_value element;
253 napi_status eleStatus = napi_get_element(env, array, i, &element);
254 if (eleStatus != napi_ok) {
255 return nullptr;
256 }
257 parseNapiValue(env, info, element, params);
258 }
259 }
260 ParseLogContent(fmtString, params, logContent);
261 HiLogPrint(DEFAULT_LOG_TYPE, static_cast<LogLevel>(level), domain, tag.get(),
262 logContent.c_str(), "");
263 return nullptr;
264 }
265 } // namespace HiviewDFX
266 } // namespace OHOS
267
268 #ifdef __cplusplus
269 }
270 #endif