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 #include "netnative_log_wrapper.h"
17 #include "netsys_net_diag_data.h"
18 
19 namespace OHOS {
20 namespace NetsysNative {
21 namespace {
22 constexpr uint32_t SOCKET_INFO_LIST_MAX_SIZE = 1024;
23 constexpr uint32_t ICMP_SEQ_LIST_MAX_SIZE = 1024;
24 constexpr uint32_t IFCONFIG_MAX_IPV6_ADDR_NUM = 64;
25 } // namespace
26 
Marshalling(Parcel & parcel) const27 bool NetDiagPingOption::Marshalling(Parcel &parcel) const
28 {
29     if (!parcel.WriteUint8(forceType_)) {
30         return false;
31     }
32     if (!parcel.WriteString(destination_)) {
33         return false;
34     }
35     if (!parcel.WriteString(source_)) {
36         return false;
37     }
38     if (!parcel.WriteUint32(interval_)) {
39         return false;
40     }
41     if (!parcel.WriteUint16(count_)) {
42         return false;
43     }
44     if (!parcel.WriteUint16(dataSize_)) {
45         return false;
46     }
47     if (!parcel.WriteUint16(mark_)) {
48         return false;
49     }
50     if (!parcel.WriteUint16(ttl_)) {
51         return false;
52     }
53     if (!parcel.WriteUint16(timeOut_)) {
54         return false;
55     }
56     if (!parcel.WriteUint16(duration_)) {
57         return false;
58     }
59     if (!parcel.WriteBool(flood_)) {
60         return false;
61     }
62     return true;
63 }
64 
Unmarshalling(Parcel & parcel,NetDiagPingOption & pingOption)65 bool NetDiagPingOption::Unmarshalling(Parcel &parcel, NetDiagPingOption &pingOption)
66 {
67     uint8_t forceType = FORCE_TYPE_IPV4;
68     if (!parcel.ReadUint8(forceType)) {
69         return false;
70     }
71     pingOption.forceType_ = static_cast<NetDiagForceType>(forceType);
72     if (!parcel.ReadString(pingOption.destination_)) {
73         return false;
74     }
75     if (!parcel.ReadString(pingOption.source_)) {
76         return false;
77     }
78     if (!parcel.ReadUint32(pingOption.interval_)) {
79         return false;
80     }
81     if (!parcel.ReadUint16(pingOption.count_)) {
82         return false;
83     }
84     if (!parcel.ReadUint16(pingOption.dataSize_)) {
85         return false;
86     }
87     if (!parcel.ReadUint16(pingOption.mark_)) {
88         return false;
89     }
90     if (!parcel.ReadUint16(pingOption.ttl_)) {
91         return false;
92     }
93     if (!parcel.ReadUint16(pingOption.timeOut_)) {
94         return false;
95     }
96     if (!parcel.ReadUint16(pingOption.duration_)) {
97         return false;
98     }
99     if (!parcel.ReadBool(pingOption.flood_)) {
100         return false;
101     }
102     return true;
103 }
104 
Marshalling(Parcel & parcel) const105 bool PingIcmpResponseInfo::Marshalling(Parcel &parcel) const
106 {
107     if (!parcel.WriteUint16(bytes_)) {
108         return false;
109     }
110     if (!parcel.WriteUint16(icmpSeq_)) {
111         return false;
112     }
113     if (!parcel.WriteUint16(ttl_)) {
114         return false;
115     }
116     if (!parcel.WriteUint32(costTime_)) {
117         return false;
118     }
119     if (!parcel.WriteString(from_)) {
120         return false;
121     }
122     return true;
123 }
124 
Unmarshalling(Parcel & parcel,PingIcmpResponseInfo & icmpSeq)125 bool PingIcmpResponseInfo::Unmarshalling(Parcel &parcel, PingIcmpResponseInfo &icmpSeq)
126 {
127     if (!parcel.ReadUint16(icmpSeq.bytes_)) {
128         return false;
129     }
130     if (!parcel.ReadUint16(icmpSeq.icmpSeq_)) {
131         return false;
132     }
133     if (!parcel.ReadUint16(icmpSeq.ttl_)) {
134         return false;
135     }
136     if (!parcel.ReadUint32(icmpSeq.costTime_)) {
137         return false;
138     }
139     if (!parcel.ReadString(icmpSeq.from_)) {
140         return false;
141     }
142     return true;
143 }
144 
Marshalling(Parcel & parcel) const145 bool NetDiagPingResult::Marshalling(Parcel &parcel) const
146 {
147     if (!parcel.WriteString(host_)) {
148         return false;
149     }
150     if (!parcel.WriteString(ipAddr_)) {
151         return false;
152     }
153     if (!parcel.WriteUint16(dateSize_)) {
154         return false;
155     }
156     if (!parcel.WriteUint16(payloadSize_)) {
157         return false;
158     }
159     if (!parcel.WriteUint16(transCount_)) {
160         return false;
161     }
162     if (!parcel.WriteUint16(recvCount_)) {
163         return false;
164     }
165     if (!parcel.WriteUint32(
166         static_cast<uint32_t>(std::min(ICMP_SEQ_LIST_MAX_SIZE, static_cast<uint32_t>(icmpRespList_.size()))))) {
167         return false;
168     }
169     uint32_t count = 0;
170     for (const auto &icmpSeq : icmpRespList_) {
171         if (!icmpSeq.Marshalling(parcel)) {
172             return false;
173         }
174         if (++count >= ICMP_SEQ_LIST_MAX_SIZE) {
175             break;
176         }
177     }
178     return true;
179 }
180 
Unmarshalling(Parcel & parcel,NetDiagPingResult & pingResult)181 bool NetDiagPingResult::Unmarshalling(Parcel &parcel, NetDiagPingResult &pingResult)
182 {
183     if (!parcel.ReadString(pingResult.host_)) {
184         return false;
185     }
186     if (!parcel.ReadString(pingResult.ipAddr_)) {
187         return false;
188     }
189     if (!parcel.ReadUint16(pingResult.dateSize_)) {
190         return false;
191     }
192     if (!parcel.ReadUint16(pingResult.payloadSize_)) {
193         return false;
194     }
195     if (!parcel.ReadUint16(pingResult.transCount_)) {
196         return false;
197     }
198     if (!parcel.ReadUint16(pingResult.recvCount_)) {
199         return false;
200     }
201     uint32_t size = 0;
202     if (!parcel.ReadUint32(size)) {
203         return false;
204     }
205     size = (size > ICMP_SEQ_LIST_MAX_SIZE) ? ICMP_SEQ_LIST_MAX_SIZE : size;
206     for (uint32_t i = 0; i < size; ++i) {
207         PingIcmpResponseInfo icmpResponse;
208         if (!PingIcmpResponseInfo::Unmarshalling(parcel, icmpResponse)) {
209             return false;
210         }
211         pingResult.icmpRespList_.push_back(icmpResponse);
212     }
213     return true;
214 }
215 
Marshalling(Parcel & parcel) const216 bool NetDiagRouteTable::Marshalling(Parcel &parcel) const
217 {
218     if (!parcel.WriteString(destination_)) {
219         return false;
220     }
221     if (!parcel.WriteString(gateway_)) {
222         return false;
223     }
224     if (!parcel.WriteString(mask_)) {
225         return false;
226     }
227     if (!parcel.WriteString(iface_)) {
228         return false;
229     }
230     if (!parcel.WriteString(flags_)) {
231         return false;
232     }
233     if (!parcel.WriteUint32(metric_)) {
234         return false;
235     }
236     if (!parcel.WriteUint32(ref_)) {
237         return false;
238     }
239     if (!parcel.WriteUint32(use_)) {
240         return false;
241     }
242     return true;
243 }
244 
Unmarshalling(Parcel & parcel,NetDiagRouteTable & routeTable)245 bool NetDiagRouteTable::Unmarshalling(Parcel &parcel, NetDiagRouteTable &routeTable)
246 {
247     if (!parcel.ReadString(routeTable.destination_)) {
248         return false;
249     }
250     if (!parcel.ReadString(routeTable.gateway_)) {
251         return false;
252     }
253     if (!parcel.ReadString(routeTable.mask_)) {
254         return false;
255     }
256     if (!parcel.ReadString(routeTable.iface_)) {
257         return false;
258     }
259     if (!parcel.ReadString(routeTable.flags_)) {
260         return false;
261     }
262     if (!parcel.ReadUint32(routeTable.metric_)) {
263         return false;
264     }
265     if (!parcel.ReadUint32(routeTable.ref_)) {
266         return false;
267     }
268     if (!parcel.ReadUint32(routeTable.use_)) {
269         return false;
270     }
271     return true;
272 }
273 
Marshalling(Parcel & parcel) const274 bool NetDiagUnixSocketInfo::Marshalling(Parcel &parcel) const
275 {
276     if (!parcel.WriteUint16(refCnt_)) {
277         return false;
278     }
279     if (!parcel.WriteUint32(inode_)) {
280         return false;
281     }
282     if (!parcel.WriteString(protocol_)) {
283         return false;
284     }
285     if (!parcel.WriteString(flags_)) {
286         return false;
287     }
288     if (!parcel.WriteString(type_)) {
289         return false;
290     }
291     if (!parcel.WriteString(state_)) {
292         return false;
293     }
294     if (!parcel.WriteString(path_)) {
295         return false;
296     }
297     return true;
298 }
299 
Unmarshalling(Parcel & parcel,NetDiagUnixSocketInfo & socketInfo)300 bool NetDiagUnixSocketInfo::Unmarshalling(Parcel &parcel, NetDiagUnixSocketInfo &socketInfo)
301 {
302     if (!parcel.ReadUint16(socketInfo.refCnt_)) {
303         return false;
304     }
305     if (!parcel.ReadUint32(socketInfo.inode_)) {
306         return false;
307     }
308     if (!parcel.ReadString(socketInfo.protocol_)) {
309         return false;
310     }
311     if (!parcel.ReadString(socketInfo.flags_)) {
312         return false;
313     }
314     if (!parcel.ReadString(socketInfo.type_)) {
315         return false;
316     }
317     if (!parcel.ReadString(socketInfo.state_)) {
318         return false;
319     }
320     if (!parcel.ReadString(socketInfo.path_)) {
321         return false;
322     }
323     return true;
324 }
325 
Marshalling(Parcel & parcel) const326 bool NeyDiagNetProtoSocketInfo::Marshalling(Parcel &parcel) const
327 {
328     if (!parcel.WriteString(protocol_)) {
329         return false;
330     }
331     if (!parcel.WriteString(localAddr_)) {
332         return false;
333     }
334     if (!parcel.WriteString(foreignAddr_)) {
335         return false;
336     }
337     if (!parcel.WriteString(state_)) {
338         return false;
339     }
340     if (!parcel.WriteString(user_)) {
341         return false;
342     }
343     if (!parcel.WriteString(programName_)) {
344         return false;
345     }
346     if (!parcel.WriteUint16(recvQueue_)) {
347         return false;
348     }
349     if (!parcel.WriteUint16(sendQueue_)) {
350         return false;
351     }
352     if (!parcel.WriteUint32(inode_)) {
353         return false;
354     }
355     return true;
356 }
357 
Unmarshalling(Parcel & parcel,NeyDiagNetProtoSocketInfo & socketInfo)358 bool NeyDiagNetProtoSocketInfo::Unmarshalling(Parcel &parcel, NeyDiagNetProtoSocketInfo &socketInfo)
359 {
360     if (!parcel.ReadString(socketInfo.protocol_)) {
361         return false;
362     }
363     if (!parcel.ReadString(socketInfo.localAddr_)) {
364         return false;
365     }
366     if (!parcel.ReadString(socketInfo.foreignAddr_)) {
367         return false;
368     }
369     if (!parcel.ReadString(socketInfo.state_)) {
370         return false;
371     }
372     if (!parcel.ReadString(socketInfo.user_)) {
373         return false;
374     }
375     if (!parcel.ReadString(socketInfo.programName_)) {
376         return false;
377     }
378     if (!parcel.ReadUint16(socketInfo.recvQueue_)) {
379         return false;
380     }
381     if (!parcel.ReadUint16(socketInfo.sendQueue_)) {
382         return false;
383     }
384     if (!parcel.ReadUint32(socketInfo.inode_)) {
385         return false;
386     }
387     return true;
388 }
389 
Marshalling(Parcel & parcel) const390 bool NetDiagSocketsInfo::Marshalling(Parcel &parcel) const
391 {
392     if (!parcel.WriteUint32(
393         static_cast<uint32_t>(std::min(SOCKET_INFO_LIST_MAX_SIZE, static_cast<uint32_t>(unixSocketsInfo_.size()))))) {
394         return false;
395     }
396     uint32_t count = 0;
397     for (const auto &socketInfo : unixSocketsInfo_) {
398         if (!socketInfo.Marshalling(parcel)) {
399             return false;
400         }
401         if (++count >= SOCKET_INFO_LIST_MAX_SIZE) {
402             break;
403         }
404     }
405 
406     if (!parcel.WriteUint32(static_cast<uint32_t>(
407             std::min(SOCKET_INFO_LIST_MAX_SIZE, static_cast<uint32_t>(netProtoSocketsInfo_.size()))))) {
408         return false;
409     }
410     count = 0;
411     for (const auto &socketInfo : netProtoSocketsInfo_) {
412         if (!socketInfo.Marshalling(parcel)) {
413             return false;
414         }
415         if (++count >= SOCKET_INFO_LIST_MAX_SIZE) {
416             break;
417         }
418     }
419     return true;
420 }
421 
Unmarshalling(Parcel & parcel,NetDiagSocketsInfo & socketsInfo)422 bool NetDiagSocketsInfo::Unmarshalling(Parcel &parcel, NetDiagSocketsInfo &socketsInfo)
423 {
424     std::list<NetDiagUnixSocketInfo>().swap(socketsInfo.unixSocketsInfo_);
425     std::list<NeyDiagNetProtoSocketInfo>().swap(socketsInfo.netProtoSocketsInfo_);
426 
427     uint32_t size = 0;
428     if (!parcel.ReadUint32(size)) {
429         return false;
430     }
431     size = (size > SOCKET_INFO_LIST_MAX_SIZE) ? SOCKET_INFO_LIST_MAX_SIZE : size;
432     for (uint32_t i = 0; i < size; ++i) {
433         NetDiagUnixSocketInfo socketInfo;
434         if (!NetDiagUnixSocketInfo::Unmarshalling(parcel, socketInfo)) {
435             return false;
436         }
437         socketsInfo.unixSocketsInfo_.push_back(socketInfo);
438     }
439 
440     size = 0;
441     if (!parcel.ReadUint32(size)) {
442         return false;
443     }
444     size = (size > SOCKET_INFO_LIST_MAX_SIZE) ? SOCKET_INFO_LIST_MAX_SIZE : size;
445     for (uint32_t i = 0; i < size; ++i) {
446         NeyDiagNetProtoSocketInfo socketInfo;
447         if (!NeyDiagNetProtoSocketInfo::Unmarshalling(parcel, socketInfo)) {
448             return false;
449         }
450         socketsInfo.netProtoSocketsInfo_.push_back(socketInfo);
451     }
452     return true;
453 }
454 
Initialize()455 void NetDiagIfaceConfig::Initialize()
456 {
457     ifaceName_ = "";
458     linkEncap_ = "";
459     macAddr_ = "";
460     macAddr_ = "";
461     ipv4Addr_ = "";
462     ipv4Bcast_ = "";
463     ipv4Mask_ = "";
464     ipv4Mask_ = "";
465     ipv4Mask_ = "";
466     mtu_ = 0;
467     txQueueLen_ = 0;
468     rxBytes_ = 0;
469     txBytes_ = 0;
470     isUp_ = false;
471     std::list<std::pair<std::string, std::string>>().swap(ipv6Addrs_);
472 }
473 
Marshalling(Parcel & parcel) const474 bool NetDiagIfaceConfig::Marshalling(Parcel &parcel) const
475 {
476     if (!parcel.WriteString(ifaceName_) || !parcel.WriteString(linkEncap_) || !parcel.WriteString(macAddr_) ||
477         !parcel.WriteString(ipv4Addr_) || !parcel.WriteString(ipv4Bcast_) || !parcel.WriteString(ipv4Mask_)) {
478         return false;
479     }
480     if (!parcel.WriteUint32(static_cast<uint32_t>(
481         std::min(IFCONFIG_MAX_IPV6_ADDR_NUM, static_cast<uint32_t>(ipv6Addrs_.size()))))) {
482         return false;
483     }
484     uint32_t count = 0;
485     for (const auto &addr : ipv6Addrs_) {
486         if (!parcel.WriteString(addr.first)) {
487             return false;
488         }
489         if (!parcel.WriteString(addr.second)) {
490             return false;
491         }
492         if (++count >= IFCONFIG_MAX_IPV6_ADDR_NUM) {
493             break;
494         }
495     }
496     if (!parcel.WriteUint32(mtu_) || !parcel.WriteUint32(txQueueLen_) || !parcel.WriteUint32(rxBytes_) ||
497         !parcel.WriteUint32(txBytes_)) {
498         return false;
499     }
500     if (!parcel.WriteBool(isUp_)) {
501         return false;
502     }
503     return true;
504 }
505 
Unmarshalling(Parcel & parcel,NetDiagIfaceConfig & ifaceConfig)506 bool NetDiagIfaceConfig::Unmarshalling(Parcel &parcel, NetDiagIfaceConfig &ifaceConfig)
507 {
508     if (!parcel.ReadString(ifaceConfig.ifaceName_) || !parcel.ReadString(ifaceConfig.linkEncap_) ||
509         !parcel.ReadString(ifaceConfig.macAddr_) || !parcel.ReadString(ifaceConfig.ipv4Addr_) ||
510         !parcel.ReadString(ifaceConfig.ipv4Bcast_) || !parcel.ReadString(ifaceConfig.ipv4Mask_)) {
511         return false;
512     }
513 
514     uint32_t size = 0;
515     if (!parcel.ReadUint32(size)) {
516         return false;
517     }
518     size = (size > IFCONFIG_MAX_IPV6_ADDR_NUM) ? IFCONFIG_MAX_IPV6_ADDR_NUM : size;
519     for (uint32_t i = 0; i < size; ++i) {
520         std::string ipv6Addr;
521         std::string scope;
522         if (!parcel.ReadString(ipv6Addr)) {
523             return false;
524         }
525         if (!parcel.ReadString(scope)) {
526             return false;
527         }
528         ifaceConfig.ipv6Addrs_.push_back(std::make_pair(ipv6Addr, scope));
529     }
530     if (!parcel.ReadUint32(ifaceConfig.mtu_) || !parcel.ReadUint32(ifaceConfig.txQueueLen_) ||
531         !parcel.ReadUint32(ifaceConfig.rxBytes_) || !parcel.ReadUint32(ifaceConfig.txBytes_)) {
532         return false;
533     }
534     if (!parcel.ReadBool(ifaceConfig.isUp_)) {
535         return false;
536     }
537     return true;
538 }
539 } // namespace NetsysNative
540 } // namespace OHOS
541