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 "net_link_info.h" 17 #include "net_mgr_log_wrapper.h" 18 19 namespace OHOS { 20 namespace NetManagerStandard { 21 static constexpr uint32_t MAX_ADDR_SIZE = 16; 22 static constexpr uint32_t MAX_ROUTE_SIZE = 32; 23 Marshalling(Parcel & parcel) const24bool NetLinkInfo::Marshalling(Parcel &parcel) const 25 { 26 if (!parcel.WriteString(ifaceName_)) { 27 return false; 28 } 29 if (!parcel.WriteString(domain_)) { 30 return false; 31 } 32 if (!parcel.WriteUint32(netAddrList_.size())) { 33 return false; 34 } 35 for (auto it = netAddrList_.begin(); it != netAddrList_.end(); it++) { 36 if (!it->Marshalling(parcel)) { 37 NETMGR_LOG_E("write net address to parcel failed"); 38 return false; 39 } 40 } 41 if (!parcel.WriteUint32(dnsList_.size())) { 42 return false; 43 } 44 for (auto it = dnsList_.begin(); it != dnsList_.end(); it++) { 45 if (!it->Marshalling(parcel)) { 46 NETMGR_LOG_E("write dns to parcel failed"); 47 return false; 48 } 49 } 50 if (!parcel.WriteUint32(routeList_.size())) { 51 return false; 52 } 53 for (auto it = routeList_.begin(); it != routeList_.end(); it++) { 54 if (!it->Marshalling(parcel)) { 55 NETMGR_LOG_E("write route to parcel failed"); 56 return false; 57 } 58 } 59 if (!parcel.WriteUint16(mtu_)) { 60 return false; 61 } 62 if (!parcel.WriteString(tcpBufferSizes_)) { 63 return false; 64 } 65 return true; 66 } 67 Unmarshalling(Parcel & parcel)68sptr<NetLinkInfo> NetLinkInfo::Unmarshalling(Parcel &parcel) 69 { 70 sptr<NetLinkInfo> ptr = (std::make_unique<NetLinkInfo>()).release(); 71 if (ptr == nullptr) { 72 return nullptr; 73 } 74 uint32_t size = 0; 75 if (!parcel.ReadString(ptr->ifaceName_) || !parcel.ReadString(ptr->domain_) || !parcel.ReadUint32(size)) { 76 return nullptr; 77 } 78 size = size > MAX_ADDR_SIZE ? MAX_ADDR_SIZE : size; 79 sptr<INetAddr> netAddr; 80 for (uint32_t i = 0; i < size; i++) { 81 netAddr = INetAddr::Unmarshalling(parcel); 82 if (netAddr == nullptr) { 83 NETMGR_LOG_E("INetAddr::Unmarshalling(parcel) is null"); 84 return nullptr; 85 } 86 ptr->netAddrList_.push_back(*netAddr); 87 } 88 if (!parcel.ReadUint32(size)) { 89 return nullptr; 90 } 91 size = size > MAX_ADDR_SIZE ? MAX_ADDR_SIZE : size; 92 for (uint32_t i = 0; i < size; i++) { 93 netAddr = INetAddr::Unmarshalling(parcel); 94 if (netAddr == nullptr) { 95 NETMGR_LOG_E("INetAddr::Unmarshalling(parcel) is null"); 96 return nullptr; 97 } 98 ptr->dnsList_.push_back(*netAddr); 99 } 100 if (!parcel.ReadUint32(size)) { 101 return nullptr; 102 } 103 size = size > MAX_ROUTE_SIZE ? MAX_ROUTE_SIZE : size; 104 sptr<Route> route; 105 for (uint32_t i = 0; i < size; i++) { 106 route = Route::Unmarshalling(parcel); 107 if (route == nullptr) { 108 NETMGR_LOG_E("Route::Unmarshalling(parcel) is null"); 109 return nullptr; 110 } 111 ptr->routeList_.push_back(*route); 112 } 113 if (!parcel.ReadUint16(ptr->mtu_) || !parcel.ReadString(ptr->tcpBufferSizes_)) { 114 return nullptr; 115 } 116 return ptr; 117 } 118 Marshalling(Parcel & parcel,const sptr<NetLinkInfo> & object)119bool NetLinkInfo::Marshalling(Parcel &parcel, const sptr<NetLinkInfo> &object) 120 { 121 if (object == nullptr) { 122 NETMGR_LOG_E("NetLinkInfo object ptr is nullptr"); 123 return false; 124 } 125 if (!parcel.WriteString(object->ifaceName_)) { 126 return false; 127 } 128 if (!parcel.WriteString(object->domain_)) { 129 return false; 130 } 131 if (!parcel.WriteUint32(object->netAddrList_.size())) { 132 return false; 133 } 134 for (auto it = object->netAddrList_.begin(); it != object->netAddrList_.end(); it++) { 135 if (!it->Marshalling(parcel)) { 136 NETMGR_LOG_E("write objects net address to parcel failed"); 137 return false; 138 } 139 } 140 if (!parcel.WriteUint32(object->dnsList_.size())) { 141 return false; 142 } 143 for (auto it = object->dnsList_.begin(); it != object->dnsList_.end(); it++) { 144 if (!it->Marshalling(parcel)) { 145 NETMGR_LOG_E("write objects dns to parcel failed"); 146 return false; 147 } 148 } 149 if (!parcel.WriteUint32(object->routeList_.size())) { 150 return false; 151 } 152 for (auto it = object->routeList_.begin(); it != object->routeList_.end(); it++) { 153 if (!it->Marshalling(parcel)) { 154 NETMGR_LOG_E("write objects route to parcel failed"); 155 return false; 156 } 157 } 158 if (!parcel.WriteUint16(object->mtu_)) { 159 return false; 160 } 161 if (!parcel.WriteString(object->tcpBufferSizes_)) { 162 return false; 163 } 164 return true; 165 } 166 Initialize()167void NetLinkInfo::Initialize() 168 { 169 ifaceName_ = ""; 170 domain_ = ""; 171 std::list<INetAddr>().swap(netAddrList_); 172 std::list<INetAddr>().swap(dnsList_); 173 std::list<Route>().swap(routeList_); 174 mtu_ = 0; 175 tcpBufferSizes_ = ""; 176 } 177 ToString(const std::string & tab) const178std::string NetLinkInfo::ToString(const std::string &tab) const 179 { 180 std::string str; 181 str.append("\n"); 182 str.append(tab); 183 str.append("[NetLinkInfo]"); 184 185 str.append("\n"); 186 str.append(tab); 187 str.append("ifaceName_ = "); 188 str.append(ifaceName_); 189 190 str.append("\n"); 191 str.append(tab); 192 str.append("domain_ = "); 193 str.append(domain_); 194 195 str.append("\n"); 196 str.append(tab); 197 str.append("netAddrList_ = "); 198 for (auto it = netAddrList_.begin(); it != netAddrList_.end(); it++) { 199 str.append(it->ToString(tab + " ")); 200 } 201 202 str.append("\n"); 203 str.append(tab); 204 str.append("dnsList_ = "); 205 for (auto it = dnsList_.begin(); it != dnsList_.end(); it++) { 206 str.append(it->ToString(tab + " ")); 207 } 208 209 str.append("\n"); 210 str.append(tab); 211 str.append("routeList_ = "); 212 for (auto it = routeList_.begin(); it != routeList_.end(); it++) { 213 str.append(it->ToString(tab + " ")); 214 } 215 216 str.append("\n"); 217 str.append(tab); 218 str.append("mtu_ = "); 219 str.append(std::to_string(mtu_)); 220 221 str.append("\n"); 222 str.append(tab); 223 str.append("tcpBufferSizes_ = "); 224 str.append(tcpBufferSizes_); 225 return str; 226 } 227 ToStringBase(const std::string & tab) const228std::string NetLinkInfo::ToStringBase(const std::string &tab) const 229 { 230 std::string str; 231 str.append("\n"); 232 str.append(tab); 233 str.append("[NetLinkInfo]"); 234 235 str.append("\n"); 236 str.append(tab); 237 str.append("ifaceName_ = "); 238 str.append(ifaceName_); 239 240 str.append("\n"); 241 str.append(tab); 242 str.append("domain_ = "); 243 str.append(domain_); 244 245 str.append("\n"); 246 str.append(tab); 247 str.append("mtu_ = "); 248 str.append(std::to_string(mtu_)); 249 250 str.append("\n"); 251 str.append(tab); 252 str.append("tcpBufferSizes_ = "); 253 str.append(tcpBufferSizes_); 254 255 str.append("\n"); 256 str.append(tab); 257 str.append("End"); 258 return str; 259 } 260 ToStringAddr(const std::string & tab) const261std::string NetLinkInfo::ToStringAddr(const std::string &tab) const 262 { 263 std::string str; 264 str.append("\n"); 265 str.append(tab); 266 str.append("netAddrList_ = "); 267 for (auto it = netAddrList_.begin(); it != netAddrList_.end(); it++) { 268 str.append(it->ToString(tab + " ")); 269 } 270 str.append("\n"); 271 str.append(tab); 272 str.append("End"); 273 return str; 274 } 275 ToStringDns(const std::string & tab) const276std::string NetLinkInfo::ToStringDns(const std::string &tab) const 277 { 278 std::string str; 279 str.append("\n"); 280 str.append(tab); 281 str.append("dnsList_ = "); 282 for (auto it = dnsList_.begin(); it != dnsList_.end(); it++) { 283 str.append(it->ToString(tab + " ")); 284 } 285 str.append("\n"); 286 str.append(tab); 287 str.append("End"); 288 return str; 289 } 290 ToStringRoute(const std::string & tab) const291std::string NetLinkInfo::ToStringRoute(const std::string &tab) const 292 { 293 std::string str; 294 str.append("\n"); 295 str.append(tab); 296 str.append("routeList_ = "); 297 for (auto it = routeList_.begin(); it != routeList_.end(); it++) { 298 str.append(it->ToString(tab + " ")); 299 } 300 str.append("\n"); 301 str.append(tab); 302 str.append("End"); 303 return str; 304 } 305 } // namespace NetManagerStandard 306 } // namespace OHOS