1 /*
2 * Copyright (c) 2022 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 "fetch_exec.h"
17
18 #include <algorithm>
19 #include <cstring>
20 #include <memory>
21
22 #include "constant.h"
23 #include "netstack_common_utils.h"
24 #include "netstack_log.h"
25 #include "napi_utils.h"
26 #include "securec.h"
27
28 #define NETSTACK_CURL_EASY_SET_OPTION(handle, opt, data, asyncContext) \
29 do { \
30 CURLcode result = curl_easy_setopt(handle, opt, data); \
31 if (result != CURLE_OK) { \
32 const char *err = curl_easy_strerror(result); \
33 NETSTACK_LOGE("Failed to set option: %{public}s, %{public}s %{public}d", #opt, err, result); \
34 (asyncContext)->SetErrorCode(result); \
35 return false; \
36 } \
37 } while (0)
38
39 #define NETSTACK_CURL_EASY_PERFORM(handle, asyncContext) \
40 do { \
41 CURLcode result = curl_easy_perform(handle); \
42 if (result != CURLE_OK) { \
43 NETSTACK_LOGE("request fail, url:%{public}s, %{public}s %{public}d", \
44 (asyncContext)->request.GetUrl().c_str(), curl_easy_strerror(result), result); \
45 (asyncContext)->SetErrorCode(result); \
46 return false; \
47 } \
48 } while (0)
49
50 #define NETSTACK_CURL_EASY_GET_INFO(handle, opt, data, asyncContext) \
51 do { \
52 CURLcode result = curl_easy_getinfo(handle, opt, data); \
53 if (result != CURLE_OK) { \
54 const char *err = curl_easy_strerror(result); \
55 NETSTACK_LOGE("Failed to get info: %{public}s, %{public}s %{public}d", #opt, err, result); \
56 (asyncContext)->SetErrorCode(result); \
57 return false; \
58 } \
59 } while (0)
60
61 static constexpr const int FAIL_CALLBACK_PARAM = 2;
62
63 namespace OHOS::NetStack {
64 std::mutex FetchExec::mutex_;
65
66 bool FetchExec::initialized_ = false;
67
ExecFetch(FetchContext * context)68 bool FetchExec::ExecFetch(FetchContext *context)
69 {
70 if (!initialized_) {
71 NETSTACK_LOGE("curl not init");
72 return false;
73 }
74
75 std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> handle(curl_easy_init(), curl_easy_cleanup);
76
77 if (!handle) {
78 NETSTACK_LOGE("Failed to create fetch task");
79 return false;
80 }
81
82 NETSTACK_LOGI("final url: %{public}s", context->request.GetUrl().c_str());
83
84 std::vector<std::string> vec;
85 std::for_each(context->request.GetHeader().begin(), context->request.GetHeader().end(),
86 [&vec](const std::pair<std::string, std::string> &p) {
87 vec.emplace_back(p.first + FetchConstant::HTTP_HEADER_SEPARATOR + p.second);
88 });
89 std::unique_ptr<struct curl_slist, decltype(&curl_slist_free_all)> header(MakeHeaders(vec), curl_slist_free_all);
90
91 if (!SetOption(handle.get(), context, header.get())) {
92 NETSTACK_LOGE("set option failed");
93 return false;
94 }
95
96 NETSTACK_CURL_EASY_PERFORM(handle.get(), context);
97
98 int32_t responseCode;
99 NETSTACK_CURL_EASY_GET_INFO(handle.get(), CURLINFO_RESPONSE_CODE, &responseCode, context);
100
101 context->response.SetResponseCode(responseCode);
102 context->response.ParseHeaders();
103
104 return true;
105 }
106
FetchCallback(FetchContext * context)107 napi_value FetchExec::FetchCallback(FetchContext *context)
108 {
109 if (context->IsExecOK()) {
110 napi_value success = context->GetSuccessCallback();
111 if (NapiUtils::GetValueType(context->GetEnv(), success) == napi_function) {
112 napi_value response = MakeResponse(context);
113 napi_value undefined = NapiUtils::GetUndefined(context->GetEnv());
114 napi_value argv[1] = {response};
115 (void)NapiUtils::CallFunction(context->GetEnv(), undefined, success, 1, argv);
116 }
117 } else {
118 napi_value fail = context->GetFailCallback();
119 if (NapiUtils::GetValueType(context->GetEnv(), fail) == napi_function) {
120 napi_value errData = NapiUtils::GetUndefined(context->GetEnv());
121 napi_value errCode = NapiUtils::CreateUint32(context->GetEnv(), context->GetErrorCode());
122 napi_value undefined = NapiUtils::GetUndefined(context->GetEnv());
123 napi_value argv[FAIL_CALLBACK_PARAM] = {errData, errCode};
124 (void)NapiUtils::CallFunction(context->GetEnv(), undefined, fail, FAIL_CALLBACK_PARAM, argv);
125 }
126 }
127
128 napi_value complete = context->GetCompleteCallback();
129 if (NapiUtils::GetValueType(context->GetEnv(), complete) == napi_function) {
130 napi_value undefined = NapiUtils::GetUndefined(context->GetEnv());
131 (void)NapiUtils::CallFunction(context->GetEnv(), undefined, complete, 0, nullptr);
132 }
133
134 return NapiUtils::GetUndefined(context->GetEnv());
135 }
136
MakeResponse(FetchContext * context)137 napi_value FetchExec::MakeResponse(FetchContext *context)
138 {
139 napi_value object = NapiUtils::CreateObject(context->GetEnv());
140 if (NapiUtils::GetValueType(context->GetEnv(), object) != napi_object) {
141 return nullptr;
142 }
143
144 NapiUtils::SetUint32Property(context->GetEnv(), object, FetchConstant::RESPONSE_KEY_CODE,
145 context->response.GetResponseCode());
146
147 napi_value header = MakeResponseHeader(context);
148 if (NapiUtils::GetValueType(context->GetEnv(), header) == napi_object) {
149 NapiUtils::SetNamedProperty(context->GetEnv(), object, FetchConstant::RESPONSE_KEY_HEADERS, header);
150 }
151
152 if (CommonUtils::ToLower(context->GetResponseType()) == FetchConstant::HTTP_RESPONSE_TYPE_JSON) {
153 napi_value data = NapiUtils::JsonParse(context->GetEnv(), context->response.GetData());
154 NapiUtils::SetNamedProperty(context->GetEnv(), object, FetchConstant::RESPONSE_KEY_DATA, data);
155 return object;
156 }
157
158 /* now just support utf8 */
159 NapiUtils::SetStringPropertyUtf8(context->GetEnv(), object, FetchConstant::RESPONSE_KEY_DATA,
160 context->response.GetData());
161 return object;
162 }
163
MakeUrl(const std::string & url,std::string param,const std::string & extraParam)164 std::string FetchExec::MakeUrl(const std::string &url, std::string param, const std::string &extraParam)
165 {
166 if (param.empty()) {
167 param += extraParam;
168 } else {
169 param += FetchConstant::HTTP_URL_PARAM_SEPARATOR;
170 param += extraParam;
171 }
172
173 if (param.empty()) {
174 return url;
175 }
176
177 return url + FetchConstant::HTTP_URL_PARAM_START + param;
178 }
179
MethodForGet(const std::string & method)180 bool FetchExec::MethodForGet(const std::string &method)
181 {
182 return (method == FetchConstant::HTTP_METHOD_HEAD || method == FetchConstant::HTTP_METHOD_OPTIONS ||
183 method == FetchConstant::HTTP_METHOD_DELETE || method == FetchConstant::HTTP_METHOD_TRACE ||
184 method == FetchConstant::HTTP_METHOD_GET || method == FetchConstant::HTTP_METHOD_CONNECT);
185 }
186
MethodForPost(const std::string & method)187 bool FetchExec::MethodForPost(const std::string &method)
188 {
189 return (method == FetchConstant::HTTP_METHOD_POST || method == FetchConstant::HTTP_METHOD_PUT);
190 }
191
EncodeUrlParam(std::string & str)192 bool FetchExec::EncodeUrlParam(std::string &str)
193 {
194 char encoded[4];
195 std::string encodeOut;
196 for (size_t i = 0; i < strlen(str.c_str()); ++i) {
197 auto c = static_cast<uint8_t>(str.c_str()[i]);
198 if (IsUnReserved(c)) {
199 encodeOut += static_cast<char>(c);
200 } else {
201 if (sprintf_s(encoded, sizeof(encoded), "%%%02X", c) < 0) {
202 return false;
203 }
204 encodeOut += encoded;
205 }
206 }
207
208 if (str == encodeOut) {
209 return false;
210 }
211 str = encodeOut;
212 return true;
213 }
214
Initialize()215 bool FetchExec::Initialize()
216 {
217 std::lock_guard<std::mutex> lock(mutex_);
218 if (initialized_) {
219 return true;
220 }
221 NETSTACK_LOGI("call curl_global_init");
222 if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
223 NETSTACK_LOGE("Failed to initialize 'curl'");
224 return false;
225 }
226 initialized_ = true;
227 return initialized_;
228 }
229
SetOption(CURL * curl,FetchContext * context,struct curl_slist * requestHeader)230 bool FetchExec::SetOption(CURL *curl, FetchContext *context, struct curl_slist *requestHeader)
231 {
232 const std::string &method = context->request.GetMethod();
233 if (!MethodForGet(method) && !MethodForPost(method)) {
234 NETSTACK_LOGE("method %{public}s not supported", method.c_str());
235 return false;
236 }
237
238 if (context->request.GetMethod() == FetchConstant::HTTP_METHOD_HEAD) {
239 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOBODY, 1L, context);
240 }
241
242 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_URL, context->request.GetUrl().c_str(), context);
243 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_CUSTOMREQUEST, method.c_str(), context);
244
245 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_WRITEFUNCTION, OnWritingMemoryBody, context);
246 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_WRITEDATA, context, context);
247
248 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HEADERFUNCTION, OnWritingMemoryHeader, context);
249 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HEADERDATA, context, context);
250
251 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HTTPHEADER, requestHeader, context);
252
253 // Some servers don't like requests that are made without a user-agent field, so we provide one
254 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_USERAGENT, FetchConstant::HTTP_DEFAULT_USER_AGENT, context);
255
256 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_FOLLOWLOCATION, 1L, context);
257
258 /* first #undef CURL_DISABLE_COOKIES in curl config */
259 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_COOKIEFILE, "", context);
260
261 #if NETSTACK_USE_PROXY
262 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_PROXY, NETSTACK_PROXY_URL_PORT, context);
263 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_PROXYTYPE, NETSTACK_PROXY_TYPE, context);
264 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HTTPPROXYTUNNEL, 1L, context);
265 #ifdef NETSTACK_PROXY_PASS
266 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_PROXYUSERPWD, NETSTACK_PROXY_PASS, context);
267 #endif // NETSTACK_PROXY_PASS
268 #endif // NETSTACK_USE_PROXY
269
270 #if NO_SSL_CERTIFICATION
271 // in real life, you should buy a ssl certification and rename it to /etc/ssl/cert.pem
272 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_SSL_VERIFYHOST, 0L, context);
273 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_SSL_VERIFYPEER, 0L, context);
274 #else
275 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_CAINFO, FetchConstant::HTTP_DEFAULT_CA_PATH, context);
276 #endif // NO_SSL_CERTIFICATION
277
278 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOPROGRESS, 1L, context);
279 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOSIGNAL, 1L, context);
280 #if HTTP_CURL_PRINT_VERBOSE
281 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_VERBOSE, 1L, context);
282 #endif
283
284 if (MethodForPost(method) && !context->request.GetBody().empty()) {
285 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_POST, 1L, context);
286 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_POSTFIELDS, context->request.GetBody().c_str(), context);
287 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_POSTFIELDSIZE, context->request.GetBody().size(), context);
288 }
289
290 return true;
291 }
292
OnWritingMemoryBody(const void * data,size_t size,size_t memBytes,void * userData)293 size_t FetchExec::OnWritingMemoryBody(const void *data, size_t size, size_t memBytes, void *userData)
294 {
295 auto context = static_cast<FetchContext *>(userData);
296 context->response.AppendData(data, size * memBytes);
297 return size * memBytes;
298 }
299
OnWritingMemoryHeader(const void * data,size_t size,size_t memBytes,void * userData)300 size_t FetchExec::OnWritingMemoryHeader(const void *data, size_t size, size_t memBytes, void *userData)
301 {
302 auto context = static_cast<FetchContext *>(userData);
303 context->response.AppendRawHeader(data, size * memBytes);
304 return size * memBytes;
305 }
306
MakeHeaders(const std::vector<std::string> & vec)307 struct curl_slist *FetchExec::MakeHeaders(const std::vector<std::string> &vec)
308 {
309 struct curl_slist *header = nullptr;
310 std::for_each(vec.begin(), vec.end(), [&header](const std::string &s) {
311 if (!s.empty()) {
312 header = curl_slist_append(header, s.c_str());
313 }
314 });
315 return header;
316 }
317
MakeResponseHeader(FetchContext * context)318 napi_value FetchExec::MakeResponseHeader(FetchContext *context)
319 {
320 napi_value header = NapiUtils::CreateObject(context->GetEnv());
321 if (NapiUtils::GetValueType(context->GetEnv(), header) == napi_object) {
322 std::for_each(context->response.GetHeader().begin(), context->response.GetHeader().end(),
323 [context, header](const std::pair<std::string, std::string> &p) {
324 if (!p.first.empty() && !p.second.empty()) {
325 NapiUtils::SetStringPropertyUtf8(context->GetEnv(), header, p.first, p.second);
326 }
327 });
328 }
329 return header;
330 }
331
IsUnReserved(unsigned char in)332 bool FetchExec::IsUnReserved(unsigned char in)
333 {
334 if ((in >= '0' && in <= '9') || (in >= 'a' && in <= 'z') || (in >= 'A' && in <= 'Z')) {
335 return true;
336 }
337 switch (in) {
338 case '-':
339 case '.':
340 case '_':
341 case '~':
342 return true;
343 default:
344 break;
345 }
346 return false;
347 }
348 } // namespace OHOS::NetStack
349