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 #include <securec.h>
16 #include "netsys_addr_info_parcel.h"
17 #include "netnative_log_wrapper.h"
18 #include "netsys_native_service_proxy.h"
19
20 namespace OHOS {
21 namespace NetsysNative {
22 using namespace std;
23 static constexpr int32_t MAX_DNS_CONFIG_SIZE = 4;
24 static constexpr int32_t MAX_INTERFACE_CONFIG_SIZE = 16;
25
WriteInterfaceToken(MessageParcel & data)26 bool NetsysNativeServiceProxy::WriteInterfaceToken(MessageParcel &data)
27 {
28 if (!data.WriteInterfaceToken(NetsysNativeServiceProxy::GetDescriptor())) {
29 NETNATIVE_LOGI("WriteInterfaceToken failed");
30 return false;
31 }
32 return true;
33 }
34
SetResolverConfigParcel(const DnsresolverParamsParcel & resolvParams)35 int32_t NetsysNativeServiceProxy::SetResolverConfigParcel(const DnsresolverParamsParcel& resolvParams)
36 {
37 NETNATIVE_LOGI("Begin to SetResolverConfig %{public}d", resolvParams.retryCount_);
38 MessageParcel data;
39 if (!WriteInterfaceToken(data)) {
40 return ERR_FLATTEN_OBJECT;
41 }
42 if (!data.WriteParcelable(&resolvParams)) {
43 return ERR_FLATTEN_OBJECT;
44 }
45
46 MessageParcel reply;
47 MessageOption option;
48 Remote()->SendRequest(INetsysService::NETSYS_SET_RESOLVER_CONFIG_PARCEL, data, reply, option);
49
50 return reply.ReadInt32();
51 }
52
SetResolverConfig(const DnsresolverParams & resolvParams)53 int32_t NetsysNativeServiceProxy::SetResolverConfig(const DnsresolverParams &resolvParams)
54 {
55 NETNATIVE_LOGI("Begin to SetResolverConfig %{public}d", resolvParams.retryCount);
56 MessageParcel data;
57 if (!WriteInterfaceToken(data)) {
58 return ERR_FLATTEN_OBJECT;
59 }
60 if (!data.WriteUint16(resolvParams.netId)) {
61 return ERR_FLATTEN_OBJECT;
62 }
63 if (!data.WriteUint16(resolvParams.baseTimeoutMsec)) {
64 return ERR_FLATTEN_OBJECT;
65 }
66 if (!data.WriteUint8(resolvParams.retryCount)) {
67 return ERR_FLATTEN_OBJECT;
68 }
69
70 int32_t vServerSize1 = static_cast<int32_t>(resolvParams.servers.size());
71 if (!data.WriteInt32(vServerSize1)) {
72 return ERR_FLATTEN_OBJECT;
73 }
74 std::vector<std::string> vServers;
75 vServers.assign(resolvParams.servers.begin(), resolvParams.servers.end());
76 NETNATIVE_LOGI("PROXY: SetResolverConfig Write Servers String_SIZE: %{public}d",
77 static_cast<int32_t>(vServers.size()));
78 for (std::vector<std::string>::iterator it = vServers.begin(); it != vServers.end(); ++it) {
79 data.WriteString(*it);
80 }
81
82 int vDomainSize1 = static_cast<int>(resolvParams.domains.size());
83 if (!data.WriteInt32(vDomainSize1)) {
84 return ERR_FLATTEN_OBJECT;
85 }
86
87 std::vector<std::string> vDomains;
88 vDomains.assign(resolvParams.domains.begin(), resolvParams.domains.end());
89 NETNATIVE_LOGI("PROXY: InterfaceSetConfig Write Domains String_SIZE: %{public}d",
90 static_cast<int32_t>(vDomains.size()));
91 for (std::vector<std::string>::iterator it = vDomains.begin(); it != vDomains.end(); ++it) {
92 data.WriteString(*it);
93 }
94
95 MessageParcel reply;
96 MessageOption option;
97 Remote()->SendRequest(INetsysService::NETSYS_SET_RESOLVER_CONFIG, data, reply, option);
98
99 return reply.ReadInt32();
100 }
101
GetResolverConfig(const uint16_t netid,std::vector<std::string> & servers,std::vector<std::string> & domains,nmd::DnsResParams & param)102 int32_t NetsysNativeServiceProxy::GetResolverConfig(const uint16_t netid, std::vector<std::string> &servers,
103 std::vector<std::string> &domains, nmd::DnsResParams ¶m)
104 {
105 NETNATIVE_LOGI("PROXY:Begin to GetResolverConfig %{public}d", netid);
106 MessageParcel data;
107 if (!WriteInterfaceToken(data)) {
108 return ERR_FLATTEN_OBJECT;
109 }
110 if (!data.WriteUint16(netid)) {
111 return ERR_FLATTEN_OBJECT;
112 }
113 MessageParcel reply;
114 MessageOption option;
115 Remote()->SendRequest(INetsysService::NETSYS_GET_RESOLVER_CONFIG, data, reply, option);
116 int result = reply.ReadInt32();
117 reply.ReadUint16(param.baseTimeoutMsec);
118 reply.ReadUint8(param.retryCount);
119 int32_t vServerSize = reply.ReadInt32();
120 vServerSize = vServerSize > MAX_DNS_CONFIG_SIZE ? MAX_DNS_CONFIG_SIZE : vServerSize;
121 std::vector<std::string> vecString;
122 for (int i = 0; i < vServerSize; i++) {
123 vecString.push_back(reply.ReadString());
124 }
125 if (vServerSize > 0) {
126 servers.assign(vecString.begin(), vecString.end());
127 }
128 int32_t vDomainSize = reply.ReadInt32();
129 vDomainSize = vDomainSize > MAX_DNS_CONFIG_SIZE ? MAX_DNS_CONFIG_SIZE : vDomainSize;
130 std::vector<std::string> vecDomain;
131 for (int i = 0; i < vDomainSize; i++) {
132 vecDomain.push_back(reply.ReadString());
133 }
134 if (vDomainSize > 0) {
135 domains.assign(vecDomain.begin(), vecDomain.end());
136 }
137 NETNATIVE_LOGI("Begin to GetResolverConfig %{public}d", result);
138 return result;
139 }
140
CreateNetworkCache(const uint16_t netid)141 int32_t NetsysNativeServiceProxy::CreateNetworkCache(const uint16_t netid)
142 {
143 NETNATIVE_LOGI("Begin to CreateNetworkCache");
144 MessageParcel data;
145 if (!WriteInterfaceToken(data)) {
146 return ERR_FLATTEN_OBJECT;
147 }
148 if (!data.WriteUint16(netid)) {
149 return ERR_FLATTEN_OBJECT;
150 }
151
152 MessageParcel reply;
153 MessageOption option;
154 Remote()->SendRequest(INetsysService::NETSYS_CREATE_NETWORK_CACHE, data, reply, option);
155
156 return reply.ReadInt32();
157 }
158
FlushNetworkCache(const uint16_t netid)159 int32_t NetsysNativeServiceProxy::FlushNetworkCache(const uint16_t netid)
160 {
161 NETNATIVE_LOGI("Begin to FlushNetworkCache");
162 MessageParcel data;
163 if (!WriteInterfaceToken(data)) {
164 return ERR_FLATTEN_OBJECT;
165 }
166 if (!data.WriteUint16(netid)) {
167 return ERR_FLATTEN_OBJECT;
168 }
169
170 MessageParcel reply;
171 MessageOption option;
172 Remote()->SendRequest(INetsysService::NETSYS_FLUSH_NETWORK_CACHE, data, reply, option);
173
174 return reply.ReadInt32();
175 }
176
DestroyNetworkCache(const uint16_t netid)177 int32_t NetsysNativeServiceProxy::DestroyNetworkCache(const uint16_t netid)
178 {
179 NETNATIVE_LOGI("Begin to DestroyNetworkCache");
180 MessageParcel data;
181 if (!WriteInterfaceToken(data)) {
182 return ERR_FLATTEN_OBJECT;
183 }
184 if (!data.WriteUint16(netid)) {
185 return ERR_FLATTEN_OBJECT;
186 }
187
188 MessageParcel reply;
189 MessageOption option;
190 Remote()->SendRequest(INetsysService::NETSYS_DESTROY_NETWORK_CACHE, data, reply, option);
191
192 return reply.ReadInt32();
193 }
194
Getaddrinfo(const char * node,const char * service,const struct addrinfo * hints,struct addrinfo ** result,const uint16_t netid)195 int32_t NetsysNativeServiceProxy::Getaddrinfo(const char* node, const char* service, const struct addrinfo* hints,
196 struct addrinfo** result, const uint16_t netid)
197 {
198 NETNATIVE_LOGI("Begin to Getaddrinfo");
199 #ifdef SYS_FUNC
200 NETNATIVE_LOGI("Begin to sys getaddrinfo");
201 return getaddrinfo(node, service, hints, result);
202 #else
203 MessageParcel data;
204 if (!WriteInterfaceToken(data)) {
205 return ERR_FLATTEN_OBJECT;
206 }
207 NetsysAddrInfoParcel addrParcel(hints, netid, node, service);
208 if (!addrParcel.Marshalling(data)) {
209 NETNATIVE_LOGI("addrinfo marshing fail");
210 }
211 MessageParcel reply;
212 MessageOption option;
213 Remote()->SendRequest(INetsysService::NETSYS_GET_ADDR_INFO, data, reply, option);
214 int ret;
215 sptr<NetsysAddrInfoParcel> ptr=addrParcel.Unmarshalling(reply);
216 if (ptr == nullptr) {
217 return ERR_NO_MEMORY;
218 }
219 *result = ptr->Head;
220 if (ptr->addrSize == 0) {
221 *result=nullptr;
222 }
223 ret=ptr->ret;
224 return ret;
225 #endif
226 }
227
InterfaceSetMtu(const std::string & interfaceName,int32_t mtu)228 int32_t NetsysNativeServiceProxy::InterfaceSetMtu(const std::string &interfaceName, int32_t mtu)
229 {
230 NETNATIVE_LOGI("Begin to InterfaceSetMtu");
231 MessageParcel data;
232 if (!WriteInterfaceToken(data)) {
233 return ERR_FLATTEN_OBJECT;
234 }
235 if (!data.WriteString(interfaceName)) {
236 return ERR_FLATTEN_OBJECT;
237 }
238 if (!data.WriteInt32(mtu)) {
239 return ERR_FLATTEN_OBJECT;
240 }
241
242 MessageParcel reply;
243 MessageOption option;
244 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_SET_MTU, data, reply, option);
245
246 return reply.ReadInt32();
247 }
248
InterfaceGetMtu(const std::string & interfaceName)249 int32_t NetsysNativeServiceProxy::InterfaceGetMtu(const std::string &interfaceName)
250 {
251 NETNATIVE_LOGI("Begin to InterfaceGetMtu");
252 MessageParcel data;
253 if (!WriteInterfaceToken(data)) {
254 return ERR_FLATTEN_OBJECT;
255 }
256 if (!data.WriteString(interfaceName)) {
257 return ERR_FLATTEN_OBJECT;
258 }
259
260 MessageParcel reply;
261 MessageOption option;
262 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_GET_MTU, data, reply, option);
263
264 return reply.ReadInt32();
265 }
266
RegisterNotifyCallback(sptr<INotifyCallback> & callback)267 int32_t NetsysNativeServiceProxy::RegisterNotifyCallback(sptr<INotifyCallback> &callback)
268 {
269 NETNATIVE_LOGI("Begin to RegisterNotifyCallback");
270 MessageParcel data;
271 if (callback == nullptr) {
272 NETNATIVE_LOGE("The parameter of callback is nullptr");
273 return ERR_NULL_OBJECT;
274 }
275
276 if (!WriteInterfaceToken(data)) {
277 return ERR_FLATTEN_OBJECT;
278 }
279 data.WriteRemoteObject(callback->AsObject().GetRefPtr());
280
281 MessageParcel reply;
282 MessageOption option;
283 Remote()->SendRequest(INetsysService::NETSYS_REGISTER_NOTIFY_CALLBACK, data, reply, option);
284
285 return reply.ReadInt32();
286 }
287
NetworkAddRoute(int32_t netId,const std::string & interfaceName,const std::string & destination,const std::string & nextHop)288 int32_t NetsysNativeServiceProxy::NetworkAddRoute(int32_t netId, const std::string &interfaceName,
289 const std::string &destination, const std::string &nextHop)
290 {
291 NETNATIVE_LOGI("Begin to NetworkAddRoute");
292 MessageParcel data;
293 if (!WriteInterfaceToken(data)) {
294 return ERR_FLATTEN_OBJECT;
295 }
296 if (!data.WriteInt32(netId)) {
297 return ERR_FLATTEN_OBJECT;
298 }
299 if (!data.WriteString(interfaceName)) {
300 return ERR_FLATTEN_OBJECT;
301 }
302 if (!data.WriteString(destination)) {
303 return ERR_FLATTEN_OBJECT;
304 }
305 if (!data.WriteString(nextHop)) {
306 return ERR_FLATTEN_OBJECT;
307 }
308
309 MessageParcel reply;
310 MessageOption option;
311 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_ADD_ROUTE, data, reply, option);
312
313 return reply.ReadInt32();
314 }
315
NetworkRemoveRoute(int32_t netId,const std::string & interfaceName,const std::string & destination,const std::string & nextHop)316 int32_t NetsysNativeServiceProxy::NetworkRemoveRoute(int32_t netId, const std::string &interfaceName,
317 const std::string &destination, const std::string &nextHop)
318 {
319 NETNATIVE_LOGI("Begin to NetworkRemoveRoute");
320 MessageParcel data;
321 if (!WriteInterfaceToken(data)) {
322 return ERR_FLATTEN_OBJECT;
323 }
324 if (!data.WriteInt32(netId)) {
325 return ERR_FLATTEN_OBJECT;
326 }
327 if (!data.WriteString(interfaceName)) {
328 return ERR_FLATTEN_OBJECT;
329 }
330 if (!data.WriteString(destination)) {
331 return ERR_FLATTEN_OBJECT;
332 }
333 if (!data.WriteString(nextHop)) {
334 return ERR_FLATTEN_OBJECT;
335 }
336
337 MessageParcel reply;
338 MessageOption option;
339 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_REMOVE_ROUTE, data, reply, option);
340
341 return reply.ReadInt32();
342 }
343
NetworkAddRouteParcel(int32_t netId,const RouteInfoParcel & routeInfo)344 int32_t NetsysNativeServiceProxy::NetworkAddRouteParcel(int32_t netId, const RouteInfoParcel &routeInfo)
345 {
346 NETNATIVE_LOGI("Begin to NetworkAddRouteParcel");
347 MessageParcel data;
348 if (!WriteInterfaceToken(data)) {
349 return ERR_FLATTEN_OBJECT;
350 }
351 if (!data.WriteInt32(netId)) {
352 return ERR_FLATTEN_OBJECT;
353 }
354 if (!data.WriteString(routeInfo.ifName)) {
355 return ERR_FLATTEN_OBJECT;
356 }
357 if (!data.WriteString(routeInfo.destination)) {
358 return ERR_FLATTEN_OBJECT;
359 }
360 if (!data.WriteString(routeInfo.nextHop)) {
361 return ERR_FLATTEN_OBJECT;
362 }
363
364 MessageParcel reply;
365 MessageOption option;
366 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_ADD_ROUTE_PARCEL, data, reply, option);
367
368 return reply.ReadInt32();
369 }
370
NetworkRemoveRouteParcel(int32_t netId,const RouteInfoParcel & routeInfo)371 int32_t NetsysNativeServiceProxy::NetworkRemoveRouteParcel(int32_t netId, const RouteInfoParcel &routeInfo)
372 {
373 NETNATIVE_LOGI("Begin to NetworkRemoveRouteParcel");
374 MessageParcel data;
375 if (!WriteInterfaceToken(data)) {
376 return ERR_FLATTEN_OBJECT;
377 }
378 if (!data.WriteInt32(netId)) {
379 return ERR_FLATTEN_OBJECT;
380 }
381 if (!data.WriteString(routeInfo.ifName)) {
382 return ERR_FLATTEN_OBJECT;
383 }
384 if (!data.WriteString(routeInfo.destination)) {
385 return ERR_FLATTEN_OBJECT;
386 }
387 if (!data.WriteString(routeInfo.nextHop)) {
388 return ERR_FLATTEN_OBJECT;
389 }
390
391 MessageParcel reply;
392 MessageOption option;
393 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_REMOVE_ROUTE_PARCEL, data, reply, option);
394
395 return reply.ReadInt32();
396 }
397
NetworkSetDefault(int32_t netId)398 int32_t NetsysNativeServiceProxy::NetworkSetDefault(int32_t netId)
399 {
400 NETNATIVE_LOGI("Begin to NetworkSetDefault");
401 MessageParcel data;
402 if (!WriteInterfaceToken(data)) {
403 return ERR_FLATTEN_OBJECT;
404 }
405 if (!data.WriteInt32(netId)) {
406 return ERR_FLATTEN_OBJECT;
407 }
408
409 MessageParcel reply;
410 MessageOption option;
411 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_SET_DEFAULT, data, reply, option);
412
413 return reply.ReadInt32();
414 }
415
NetworkGetDefault()416 int32_t NetsysNativeServiceProxy::NetworkGetDefault()
417 {
418 NETNATIVE_LOGI("Begin to NetworkGetDefault");
419 MessageParcel data;
420 if (!WriteInterfaceToken(data)) {
421 return ERR_FLATTEN_OBJECT;
422 }
423
424 MessageParcel reply;
425 MessageOption option;
426 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_GET_DEFAULT, data, reply, option);
427
428 return reply.ReadInt32();
429 }
430
NetworkClearDefault()431 int32_t NetsysNativeServiceProxy::NetworkClearDefault()
432 {
433 NETNATIVE_LOGI("Begin to NetworkClearDefault");
434 MessageParcel data;
435 if (!WriteInterfaceToken(data)) {
436 return ERR_FLATTEN_OBJECT;
437 }
438
439 MessageParcel reply;
440 MessageOption option;
441 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_CLEAR_DEFAULT, data, reply, option);
442
443 return reply.ReadInt32();
444 }
445
GetProcSysNet(int32_t ipversion,int32_t which,const std::string & ifname,const std::string & parameter,std::string & value)446 int32_t NetsysNativeServiceProxy::GetProcSysNet(int32_t ipversion, int32_t which, const std::string &ifname,
447 const std::string ¶meter, std::string &value)
448 {
449 NETNATIVE_LOGI("Begin to GetSysProcNet");
450 MessageParcel data;
451 if (!WriteInterfaceToken(data)) {
452 return ERR_FLATTEN_OBJECT;
453 }
454
455 if (!data.WriteInt32(ipversion)) {
456 return ERR_FLATTEN_OBJECT;
457 }
458 if (!data.WriteInt32(which)) {
459 return ERR_FLATTEN_OBJECT;
460 }
461 if (data.WriteString(ifname)) {
462 return ERR_FLATTEN_OBJECT;
463 }
464 if (!data.WriteString(parameter)) {
465 return ERR_FLATTEN_OBJECT;
466 }
467 MessageParcel reply;
468 MessageOption option;
469 Remote()->SendRequest(INetsysService::NETSYS_GET_PROC_SYS_NET, data, reply, option);
470 int32_t ret = reply.ReadInt32();
471 std::string valueRsl = reply.ReadString();
472 NETNATIVE_LOGE("NETSYS_GET_PROC_SYS_NET value %{public}s", valueRsl.c_str());
473 value = valueRsl;
474 return ret;
475 }
476
SetProcSysNet(int32_t ipversion,int32_t which,const std::string & ifname,const std::string & parameter,std::string & value)477 int32_t NetsysNativeServiceProxy::SetProcSysNet(int32_t ipversion, int32_t which, const std::string &ifname,
478 const std::string ¶meter, std::string &value)
479 {
480 NETNATIVE_LOGI("Begin to SetSysProcNet");
481 MessageParcel data;
482 if (!WriteInterfaceToken(data)) {
483 return ERR_FLATTEN_OBJECT;
484 }
485 if (!data.WriteInt32(ipversion)) {
486 return ERR_FLATTEN_OBJECT;
487 }
488 if (!data.WriteInt32(which)) {
489 return ERR_FLATTEN_OBJECT;
490 }
491 if (data.WriteString(ifname)) {
492 return ERR_FLATTEN_OBJECT;
493 }
494 if (!data.WriteString(parameter)) {
495 return ERR_FLATTEN_OBJECT;
496 }
497 if (!data.WriteString(value)) {
498 return ERR_FLATTEN_OBJECT;
499 }
500 MessageParcel reply;
501 MessageOption option;
502 Remote()->SendRequest(INetsysService::NETSYS_SET_PROC_SYS_NET, data, reply, option);
503
504 return reply.ReadInt32();
505 }
506
NetworkCreatePhysical(int32_t netId,int32_t permission)507 int32_t NetsysNativeServiceProxy::NetworkCreatePhysical(int32_t netId, int32_t permission)
508 {
509 NETNATIVE_LOGI("Begin to NetworkCreatePhysical");
510 MessageParcel data;
511 if (!WriteInterfaceToken(data)) {
512 return ERR_FLATTEN_OBJECT;
513 }
514 if (!data.WriteInt32(netId)) {
515 return ERR_FLATTEN_OBJECT;
516 }
517 if (!data.WriteInt32(permission)) {
518 return ERR_FLATTEN_OBJECT;
519 }
520
521 MessageParcel reply;
522 MessageOption option;
523 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_CREATE_PHYSICAL, data, reply, option);
524
525 return reply.ReadInt32();
526 }
527
InterfaceAddAddress(const std::string & interfaceName,const std::string & addrString,int32_t prefixLength)528 int32_t NetsysNativeServiceProxy::InterfaceAddAddress(const std::string &interfaceName, const std::string &addrString,
529 int32_t prefixLength)
530 {
531 NETNATIVE_LOGI("Begin to InterfaceAddAddress");
532 MessageParcel data;
533 if (!WriteInterfaceToken(data)) {
534 return ERR_FLATTEN_OBJECT;
535 }
536 if (!data.WriteString(interfaceName)) {
537 return ERR_FLATTEN_OBJECT;
538 }
539 if (!data.WriteString(addrString)) {
540 return ERR_FLATTEN_OBJECT;
541 }
542 if (!data.WriteInt32(prefixLength)) {
543 return ERR_FLATTEN_OBJECT;
544 }
545
546 MessageParcel reply;
547 MessageOption option;
548 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_ADD_ADDRESS, data, reply, option);
549
550 return reply.ReadInt32();
551 }
552
InterfaceDelAddress(const std::string & interfaceName,const std::string & addrString,int32_t prefixLength)553 int32_t NetsysNativeServiceProxy::InterfaceDelAddress(const std::string &interfaceName, const std::string &addrString,
554 int32_t prefixLength)
555 {
556 NETNATIVE_LOGI("Begin to InterfaceDelAddress");
557 MessageParcel data;
558 if (!WriteInterfaceToken(data)) {
559 return ERR_FLATTEN_OBJECT;
560 }
561 if (!data.WriteString(interfaceName)) {
562 return ERR_FLATTEN_OBJECT;
563 }
564 if (!data.WriteString(addrString)) {
565 return ERR_FLATTEN_OBJECT;
566 }
567 if (!data.WriteInt32(prefixLength)) {
568 return ERR_FLATTEN_OBJECT;
569 }
570
571 MessageParcel reply;
572 MessageOption option;
573 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_DEL_ADDRESS, data, reply, option);
574
575 return reply.ReadInt32();
576 }
577
NetworkAddInterface(int32_t netId,const std::string & iface)578 int32_t NetsysNativeServiceProxy::NetworkAddInterface(int32_t netId, const std::string &iface)
579 {
580 NETNATIVE_LOGI("Begin to NetworkAddInterface");
581 MessageParcel data;
582 if (!WriteInterfaceToken(data)) {
583 return ERR_FLATTEN_OBJECT;
584 }
585 if (!data.WriteInt32(netId)) {
586 return ERR_FLATTEN_OBJECT;
587 }
588 if (!data.WriteString(iface)) {
589 return ERR_FLATTEN_OBJECT;
590 }
591
592 MessageParcel reply;
593 MessageOption option;
594 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_ADD_INTERFACE, data, reply, option);
595
596 return reply.ReadInt32();
597 }
598
NetworkRemoveInterface(int32_t netId,const std::string & iface)599 int32_t NetsysNativeServiceProxy::NetworkRemoveInterface(int32_t netId, const std::string &iface)
600 {
601 NETNATIVE_LOGI("Begin to NetworkRemoveInterface");
602 MessageParcel data;
603 if (!WriteInterfaceToken(data)) {
604 return ERR_FLATTEN_OBJECT;
605 }
606 if (!data.WriteInt32(netId)) {
607 return ERR_FLATTEN_OBJECT;
608 }
609 if (!data.WriteString(iface)) {
610 return ERR_FLATTEN_OBJECT;
611 }
612
613 MessageParcel reply;
614 MessageOption option;
615 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_REMOVE_INTERFACE, data, reply, option);
616
617 return reply.ReadInt32();
618 }
619
NetworkDestroy(int32_t netId)620 int32_t NetsysNativeServiceProxy::NetworkDestroy(int32_t netId)
621 {
622 NETNATIVE_LOGI("Begin to NetworkDestroy");
623 MessageParcel data;
624 if (!WriteInterfaceToken(data)) {
625 return ERR_FLATTEN_OBJECT;
626 }
627 if (!data.WriteInt32(netId)) {
628 return ERR_FLATTEN_OBJECT;
629 }
630
631 MessageParcel reply;
632 MessageOption option;
633 Remote()->SendRequest(INetsysService::NETSYS_NETWORK_DESTROY, data, reply, option);
634
635 return reply.ReadInt32();
636 }
637
GetFwmarkForNetwork(int32_t netId,MarkMaskParcel & markMaskParcel)638 int32_t NetsysNativeServiceProxy::GetFwmarkForNetwork(int32_t netId, MarkMaskParcel &markMaskParcel)
639 {
640 NETNATIVE_LOGI("Begin to GetFwmarkForNetwork");
641 MessageParcel data;
642 if (!WriteInterfaceToken(data)) {
643 return ERR_FLATTEN_OBJECT;
644 }
645 if (!data.WriteInt32(netId)) {
646 return ERR_FLATTEN_OBJECT;
647 }
648 if (!data.WriteInt32(markMaskParcel.mark)) {
649 return ERR_FLATTEN_OBJECT;
650 }
651 if (!data.WriteInt32(markMaskParcel.mask)) {
652 return ERR_FLATTEN_OBJECT;
653 }
654
655 MessageParcel reply;
656 MessageOption option;
657 Remote()->SendRequest(INetsysService::NETSYS_GET_FWMARK_FOR_NETWORK, data, reply, option);
658
659 return reply.ReadInt32();
660 }
661
InterfaceSetConfig(const InterfaceConfigurationParcel & cfg)662 int32_t NetsysNativeServiceProxy::InterfaceSetConfig(const InterfaceConfigurationParcel &cfg)
663 {
664 NETNATIVE_LOGI("Begin to InterfaceSetConfig");
665 MessageParcel data;
666 if (!WriteInterfaceToken(data)) {
667 return ERR_FLATTEN_OBJECT;
668 }
669 if (!data.WriteString(cfg.ifName)) {
670 return ERR_FLATTEN_OBJECT;
671 }
672 if (!data.WriteString(cfg.hwAddr)) {
673 return ERR_FLATTEN_OBJECT;
674 }
675 if (!data.WriteString(cfg.ipv4Addr)) {
676 return ERR_FLATTEN_OBJECT;
677 }
678 if (!data.WriteInt32(cfg.prefixLength)) {
679 return ERR_FLATTEN_OBJECT;
680 }
681 int32_t vsize = static_cast<int32_t>(cfg.flags.size());
682 if (!data.WriteInt32(vsize)) {
683 return ERR_FLATTEN_OBJECT;
684 }
685 std::vector<std::string> vCflags;
686 vCflags.assign(cfg.flags.begin(), cfg.flags.end());
687 NETNATIVE_LOGI("PROXY: InterfaceSetConfig Write flags String_SIZE: %{public}d",
688 static_cast<int32_t>(vCflags.size()));
689 for (std::vector<std::string>::iterator it = vCflags.begin(); it != vCflags.end(); ++it) {
690 data.WriteString(*it);
691 }
692 MessageParcel reply;
693 MessageOption option;
694 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_SET_CONFIG, data, reply, option);
695
696 return reply.ReadInt32();
697 }
698
InterfaceGetConfig(InterfaceConfigurationParcel & cfg)699 int32_t NetsysNativeServiceProxy::InterfaceGetConfig(InterfaceConfigurationParcel &cfg)
700 {
701 NETNATIVE_LOGI("Begin to InterfaceGetConfig");
702 MessageParcel data;
703 int32_t ret ;
704 int32_t vSize;
705 if (!WriteInterfaceToken(data)) {
706 return ERR_FLATTEN_OBJECT;
707 }
708 if (!data.WriteString(cfg.ifName)) {
709 return ERR_FLATTEN_OBJECT;
710 }
711
712 MessageParcel reply;
713 MessageOption option;
714 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_GET_CONFIG, data, reply, option);
715 ret = reply.ReadInt32();
716 reply.ReadString(cfg.ifName);
717 reply.ReadString(cfg.hwAddr);
718 reply.ReadString(cfg.ipv4Addr);
719 reply.ReadInt32(cfg.prefixLength);
720 vSize = reply.ReadInt32();
721 vSize = vSize > MAX_INTERFACE_CONFIG_SIZE ? MAX_INTERFACE_CONFIG_SIZE : vSize;
722 std::vector<std::string> vecString;
723 for (int i = 0; i < vSize; i++) {
724 vecString.push_back(reply.ReadString());
725 }
726 if (vSize > 0) {
727 cfg.flags.assign(vecString.begin(), vecString.end());
728 }
729 NETNATIVE_LOGI("End to InterfaceGetConfig, ret =%{public}d", ret);
730 return ret;
731 }
732
InterfaceGetList(std::vector<std::string> & ifaces)733 int32_t NetsysNativeServiceProxy::InterfaceGetList(std::vector<std::string> &ifaces)
734 {
735 NETNATIVE_LOGI("NetsysNativeServiceProxy Begin to InterfaceGetList");
736 MessageParcel data;
737 int32_t ret ;
738 int32_t vSize;
739 if (!WriteInterfaceToken(data)) {
740 return ERR_FLATTEN_OBJECT;
741 }
742 MessageParcel reply;
743 MessageOption option;
744 Remote()->SendRequest(INetsysService::NETSYS_INTERFACE_GET_LIST, data, reply, option);
745 ret = reply.ReadInt32();
746 vSize = reply.ReadInt32();
747 std::vector<std::string> vecString;
748 for (int i = 0; i < vSize; i++) {
749 vecString.push_back(reply.ReadString());
750 }
751 if (vSize > 0) {
752 ifaces.assign(vecString.begin(), vecString.end());
753 }
754 NETNATIVE_LOGI("NetsysNativeServiceProxy End to InterfaceGetList, ret =%{public}d", ret);
755 return ret;
756 }
757
StartDhcpClient(const std::string & iface,bool bIpv6)758 int32_t NetsysNativeServiceProxy::StartDhcpClient(const std::string &iface, bool bIpv6)
759 {
760 NETNATIVE_LOGI("Begin to StartDhcpClient");
761 MessageParcel data;
762 int32_t ret;
763 if (!WriteInterfaceToken(data)) {
764 return ERR_FLATTEN_OBJECT;
765 }
766 if (!data.WriteString(iface)) {
767 return ERR_FLATTEN_OBJECT;
768 }
769 if (!data.WriteBool(bIpv6)) {
770 return ERR_FLATTEN_OBJECT;
771 }
772
773 MessageParcel reply;
774 MessageOption option;
775 Remote()->SendRequest(INetsysService::NETSYS_START_DHCP_CLIENT, data, reply, option);
776
777 ret = reply.ReadInt32();
778 NETNATIVE_LOGI("End to StartDhcpClient, ret =%{public}d", ret);
779 return ret;
780 }
781
StopDhcpClient(const std::string & iface,bool bIpv6)782 int32_t NetsysNativeServiceProxy::StopDhcpClient(const std::string &iface, bool bIpv6)
783 {
784 NETNATIVE_LOGI("Begin to StopDhcpClient");
785 MessageParcel data;
786 int32_t ret;
787 if (!WriteInterfaceToken(data)) {
788 return ERR_FLATTEN_OBJECT;
789 }
790 if (!data.WriteString(iface)) {
791 return ERR_FLATTEN_OBJECT;
792 }
793 if (!data.WriteBool(bIpv6)) {
794 return ERR_FLATTEN_OBJECT;
795 }
796
797 MessageParcel reply;
798 MessageOption option;
799 ret = Remote()->SendRequest(INetsysService::NETSYS_STOP_DHCP_CLIENT, data, reply, option);
800 NETNATIVE_LOGI("SendRequest, ret =%{public}d", ret);
801 ret = reply.ReadInt32();
802 NETNATIVE_LOGI("End to StopDhcpClient, ret =%{public}d", ret);
803 return ret;
804 }
805
StartDhcpService(const std::string & iface,const std::string & ipv4addr)806 int32_t NetsysNativeServiceProxy::StartDhcpService(const std::string &iface, const std::string &ipv4addr)
807 {
808 NETNATIVE_LOGI("Begin to StartDhcpService");
809 MessageParcel data;
810
811 if (!WriteInterfaceToken(data)) {
812 return ERR_FLATTEN_OBJECT;
813 }
814 if (!data.WriteString(iface)) {
815 return ERR_FLATTEN_OBJECT;
816 }
817 if (!data.WriteString(ipv4addr)) {
818 return ERR_FLATTEN_OBJECT;
819 }
820
821 MessageParcel reply;
822 MessageOption option;
823 Remote()->SendRequest(INetsysService::NETSYS_START_DHCP_SERVICE, data, reply, option);
824 int32_t ret = reply.ReadInt32();
825 NETNATIVE_LOGI("End to StartDhcpService, ret =%{public}d", ret);
826 return ret;
827 }
828
StopDhcpService(const std::string & iface)829 int32_t NetsysNativeServiceProxy::StopDhcpService(const std::string &iface)
830 {
831 NETNATIVE_LOGI("Begin to StopDhcpService");
832 MessageParcel data;
833 if (!WriteInterfaceToken(data)) {
834 return ERR_FLATTEN_OBJECT;
835 }
836 if (!data.WriteString(iface)) {
837 return ERR_FLATTEN_OBJECT;
838 }
839
840 MessageParcel reply;
841 MessageOption option;
842 Remote()->SendRequest(INetsysService::NETSYS_STOP_DHCP_SERVICE, data, reply, option);
843 int32_t ret = reply.ReadInt32();
844 NETNATIVE_LOGI("End to StopDhcpService, ret =%{public}d", ret);
845 return ret;
846 }
847 } // namespace NetsysNative
848 } // namespace OHOS
849