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(
154 context->GetEnv(), NapiUtils::CreateStringUtf8(context->GetEnv(), context->response.GetData()));
155 NapiUtils::SetNamedProperty(context->GetEnv(), object, FetchConstant::RESPONSE_KEY_DATA, data);
156 return object;
157 }
158
159 /* now just support utf8 */
160 NapiUtils::SetStringPropertyUtf8(context->GetEnv(), object, FetchConstant::RESPONSE_KEY_DATA,
161 context->response.GetData());
162 return object;
163 }
164
MakeUrl(const std::string & url,std::string param,const std::string & extraParam)165 std::string FetchExec::MakeUrl(const std::string &url, std::string param, const std::string &extraParam)
166 {
167 if (param.empty()) {
168 param += extraParam;
169 } else {
170 param += FetchConstant::HTTP_URL_PARAM_SEPARATOR;
171 param += extraParam;
172 }
173
174 if (param.empty()) {
175 return url;
176 }
177
178 return url + FetchConstant::HTTP_URL_PARAM_START + param;
179 }
180
MethodForGet(const std::string & method)181 bool FetchExec::MethodForGet(const std::string &method)
182 {
183 return (method == FetchConstant::HTTP_METHOD_HEAD || method == FetchConstant::HTTP_METHOD_OPTIONS ||
184 method == FetchConstant::HTTP_METHOD_DELETE || method == FetchConstant::HTTP_METHOD_TRACE ||
185 method == FetchConstant::HTTP_METHOD_GET || method == FetchConstant::HTTP_METHOD_CONNECT);
186 }
187
MethodForPost(const std::string & method)188 bool FetchExec::MethodForPost(const std::string &method)
189 {
190 return (method == FetchConstant::HTTP_METHOD_POST || method == FetchConstant::HTTP_METHOD_PUT);
191 }
192
EncodeUrlParam(std::string & str)193 bool FetchExec::EncodeUrlParam(std::string &str)
194 {
195 char encoded[4];
196 std::string encodeOut;
197 for (size_t i = 0; i < strlen(str.c_str()); ++i) {
198 auto c = static_cast<uint8_t>(str.c_str()[i]);
199 if (IsUnReserved(c)) {
200 encodeOut += static_cast<char>(c);
201 } else {
202 if (sprintf_s(encoded, sizeof(encoded), "%%%02X", c) < 0) {
203 return false;
204 }
205 encodeOut += encoded;
206 }
207 }
208
209 if (str == encodeOut) {
210 return false;
211 }
212 str = encodeOut;
213 return true;
214 }
215
Initialize()216 bool FetchExec::Initialize()
217 {
218 std::lock_guard<std::mutex> lock(mutex_);
219 if (initialized_) {
220 return true;
221 }
222 NETSTACK_LOGI("call curl_global_init");
223 if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
224 NETSTACK_LOGE("Failed to initialize 'curl'");
225 return false;
226 }
227 initialized_ = true;
228 return initialized_;
229 }
230
SetOption(CURL * curl,FetchContext * context,struct curl_slist * requestHeader)231 bool FetchExec::SetOption(CURL *curl, FetchContext *context, struct curl_slist *requestHeader)
232 {
233 const std::string &method = context->request.GetMethod();
234 if (!MethodForGet(method) && !MethodForPost(method)) {
235 NETSTACK_LOGE("method %{public}s not supported", method.c_str());
236 return false;
237 }
238
239 if (context->request.GetMethod() == FetchConstant::HTTP_METHOD_HEAD) {
240 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOBODY, 1L, context);
241 }
242
243 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_URL, context->request.GetUrl().c_str(), context);
244 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_CUSTOMREQUEST, method.c_str(), context);
245
246 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_WRITEFUNCTION, OnWritingMemoryBody, context);
247 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_WRITEDATA, context, context);
248
249 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HEADERFUNCTION, OnWritingMemoryHeader, context);
250 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HEADERDATA, context, context);
251
252 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HTTPHEADER, requestHeader, context);
253
254 // Some servers don't like requests that are made without a user-agent field, so we provide one
255 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_USERAGENT, FetchConstant::HTTP_DEFAULT_USER_AGENT, context);
256
257 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_FOLLOWLOCATION, 1L, context);
258
259 /* first #undef CURL_DISABLE_COOKIES in curl config */
260 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_COOKIEFILE, "", context);
261
262 #if NETSTACK_USE_PROXY
263 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_PROXY, NETSTACK_PROXY_URL_PORT, context);
264 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_PROXYTYPE, NETSTACK_PROXY_TYPE, context);
265 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_HTTPPROXYTUNNEL, 1L, context);
266 #ifdef NETSTACK_PROXY_PASS
267 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_PROXYUSERPWD, NETSTACK_PROXY_PASS, context);
268 #endif // NETSTACK_PROXY_PASS
269 #endif // NETSTACK_USE_PROXY
270
271 #if NO_SSL_CERTIFICATION
272 // in real life, you should buy a ssl certification and rename it to /etc/ssl/cert.pem
273 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_SSL_VERIFYHOST, 0L, context);
274 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_SSL_VERIFYPEER, 0L, context);
275 #else
276 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_CAINFO, FetchConstant::HTTP_DEFAULT_CA_PATH, context);
277 #endif // NO_SSL_CERTIFICATION
278
279 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOPROGRESS, 1L, context);
280 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_NOSIGNAL, 1L, context);
281 #if HTTP_CURL_PRINT_VERBOSE
282 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_VERBOSE, 1L, context);
283 #endif
284
285 if (MethodForPost(method) && !context->request.GetBody().empty()) {
286 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_POST, 1L, context);
287 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_POSTFIELDS, context->request.GetBody().c_str(), context);
288 NETSTACK_CURL_EASY_SET_OPTION(curl, CURLOPT_POSTFIELDSIZE, context->request.GetBody().size(), context);
289 }
290
291 return true;
292 }
293
OnWritingMemoryBody(const void * data,size_t size,size_t memBytes,void * userData)294 size_t FetchExec::OnWritingMemoryBody(const void *data, size_t size, size_t memBytes, void *userData)
295 {
296 auto context = static_cast<FetchContext *>(userData);
297 context->response.AppendData(data, size * memBytes);
298 return size * memBytes;
299 }
300
OnWritingMemoryHeader(const void * data,size_t size,size_t memBytes,void * userData)301 size_t FetchExec::OnWritingMemoryHeader(const void *data, size_t size, size_t memBytes, void *userData)
302 {
303 auto context = static_cast<FetchContext *>(userData);
304 context->response.AppendRawHeader(data, size * memBytes);
305 return size * memBytes;
306 }
307
MakeHeaders(const std::vector<std::string> & vec)308 struct curl_slist *FetchExec::MakeHeaders(const std::vector<std::string> &vec)
309 {
310 struct curl_slist *header = nullptr;
311 std::for_each(vec.begin(), vec.end(), [&header](const std::string &s) {
312 if (!s.empty()) {
313 header = curl_slist_append(header, s.c_str());
314 }
315 });
316 return header;
317 }
318
MakeResponseHeader(FetchContext * context)319 napi_value FetchExec::MakeResponseHeader(FetchContext *context)
320 {
321 napi_value header = NapiUtils::CreateObject(context->GetEnv());
322 if (NapiUtils::GetValueType(context->GetEnv(), header) == napi_object) {
323 std::for_each(context->response.GetHeader().begin(), context->response.GetHeader().end(),
324 [context, header](const std::pair<std::string, std::string> &p) {
325 if (!p.first.empty() && !p.second.empty()) {
326 NapiUtils::SetStringPropertyUtf8(context->GetEnv(), header, p.first, p.second);
327 }
328 });
329 }
330 return header;
331 }
332
IsUnReserved(unsigned char in)333 bool FetchExec::IsUnReserved(unsigned char in)
334 {
335 if ((in >= '0' && in <= '9') || (in >= 'a' && in <= 'z') || (in >= 'A' && in <= 'Z')) {
336 return true;
337 }
338 switch (in) {
339 case '-':
340 case '.':
341 case '_':
342 case '~':
343 return true;
344 default:
345 break;
346 }
347 return false;
348 }
349 } // namespace OHOS::NetStack
350