1 /*
2 * Copyright (c) 2022-2024 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_manager_center.h"
17 #include "net_manager_constants.h"
18 #include "net_manager_ext_constants.h"
19 #include "netmgr_ext_log_wrapper.h"
20 #include "netsys_controller.h"
21 #include "networkshare_sub_statemachine.h"
22 #include "networkshare_tracker.h"
23 #include "route_utils.h"
24 #include <ifaddrs.h>
25 #include <random>
26 #include <regex>
27 #include <sys/types.h>
28
29 namespace OHOS {
30 namespace NetManagerStandard {
31 namespace {
32 constexpr const char *NEXT_HOT = "0.0.0.0";
33 constexpr const char *IPV6_NEXT_HOT = "";
34 const std::regex REGEX_MAC(std::string(R"(^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$)"));
35
36 /** https://www.rfc-editor.org/rfc/rfc4291
37 * The type of an IPv6 address is identified by the high-order bits of
38 * the address, as follows:
39 *
40 * Address type Binary prefix IPv6 notation Section
41 * ------------ ------------- ------------- -------
42 * Unspecified 00...0 (128 bits) ::/128 2.5.2
43 * Loopback 00...1 (128 bits) ::1/128 2.5.3
44 * Multicast 11111111 FF00::/8 2.7
45 * Link-Local unicast 1111111010 FE80::/10 2.5.6
46 * Global Unicast (everything else)
47 **/
48 constexpr const char *DEFAULT_LINK_STR = "fe80";
49 constexpr const char *DEFAULT_LINK_ROUTE = "fe80::/64";
50 constexpr const char *DEFAULT_PREFIX = "/64";
51 constexpr const char *ERROR_MSG_CONFIG_FORWARD = "Config Forward failed";
52 constexpr const char *ERROR_MSG_ADD_ROUTE_STRATEGY = "Add Route Strategy failed";
53 constexpr const char *ERROR_MSG_ADD_ROUTE_RULE = "Add Route Rule failed";
54 constexpr const char *ERROR_MSG_REMOVE_ROUTE_RULE = "Remove Route Rule failed";
55 constexpr const char *EMPTY_UPSTREAM_IFACENAME = "";
56 constexpr int32_t IP_V4 = 0;
57 constexpr uint8_t BYTE_BIT = 8;
58 constexpr int32_t PREFIX_LEN = 64;
59 constexpr int32_t MAC_BLOCK = 2;
60 constexpr int32_t HEX_BASE = 16;
61 constexpr int32_t HALF_IN6ADDR = 8;
62 constexpr int32_t INTF_ID_LEN = 64;
63 constexpr int32_t MAX_IPV6_PREFIX_LENGTH = 128;
64 constexpr int32_t BYTE_ZERO = 0;
65 constexpr int32_t BYTE_ONE = 1;
66 constexpr int32_t BYTE_TWO = 2;
67 constexpr int32_t BYTE_THREE = 3;
68 constexpr int32_t BYTE_FOUR = 4;
69 constexpr int32_t BYTE_FIVE = 5;
70 constexpr int32_t BYTE_SIX = 6;
71 constexpr int32_t BYTE_SEVEN = 7;
72 constexpr int32_t EUI64_INVERT = 0x02;
73 constexpr int32_t EUI64_FF = 0xFF;
74 constexpr int32_t EUI64_FE = 0xFE;
75 constexpr uint8_t NET_FAMILY_IPV4 = 1;
76 constexpr uint8_t NET_FAMILY_IPV6 = 2;
77 } // namespace
78
NetworkShareSubStateMachine( const std::string &ifaceName, const SharingIfaceType &interfaceType, const std::shared_ptr<NetworkShareConfiguration> &configuration)79 NetworkShareSubStateMachine::NetworkShareSubStateMachine(
80 const std::string &ifaceName, const SharingIfaceType &interfaceType,
81 const std::shared_ptr<NetworkShareConfiguration> &configuration)
82 : ifaceName_(ifaceName), netShareType_(interfaceType), configuration_(configuration)
83 {
84 CreateInitStateTable();
85 CreateSharedStateTable();
86 }
87
~NetworkShareSubStateMachine()88 __attribute__((no_sanitize("cfi"))) NetworkShareSubStateMachine::~NetworkShareSubStateMachine() {}
89
CreateInitStateTable()90 void NetworkShareSubStateMachine::CreateInitStateTable()
91 {
92 SubSmStateTable temp;
93 temp.event_ = CMD_NETSHARE_REQUESTED;
94 temp.curState_ = SUBSTATE_INIT;
95 temp.func_ = &NetworkShareSubStateMachine::HandleInitSharingRequest;
96 temp.nextState_ = SUBSTATE_SHARED;
97 stateTable_.push_back(temp);
98
99 temp.event_ = CMD_INTERFACE_DOWN;
100 temp.curState_ = SUBSTATE_INIT;
101 temp.func_ = &NetworkShareSubStateMachine::HandleInitInterfaceDown;
102 temp.nextState_ = SUBSTATE_UNAVAILABLE;
103 stateTable_.push_back(temp);
104 }
105
CreateSharedStateTable()106 void NetworkShareSubStateMachine::CreateSharedStateTable()
107 {
108 SubSmStateTable temp;
109 temp.event_ = CMD_NETSHARE_UNREQUESTED;
110 temp.curState_ = SUBSTATE_SHARED;
111 temp.func_ = &NetworkShareSubStateMachine::HandleSharedUnrequest;
112 temp.nextState_ = SUBSTATE_INIT;
113 stateTable_.push_back(temp);
114
115 temp.event_ = CMD_INTERFACE_DOWN;
116 temp.curState_ = SUBSTATE_SHARED;
117 temp.func_ = &NetworkShareSubStateMachine::HandleSharedInterfaceDown;
118 temp.nextState_ = SUBSTATE_UNAVAILABLE;
119 stateTable_.push_back(temp);
120
121 temp.event_ = CMD_NETSHARE_CONNECTION_CHANGED;
122 temp.curState_ = SUBSTATE_SHARED;
123 temp.func_ = &NetworkShareSubStateMachine::HandleSharedConnectionChange;
124 temp.nextState_ = NO_NEXT_STATE;
125 stateTable_.push_back(temp);
126
127 temp.event_ = CMD_IP_FORWARDING_ENABLE_ERROR;
128 temp.curState_ = SUBSTATE_SHARED;
129 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
130 temp.nextState_ = SUBSTATE_INIT;
131 stateTable_.push_back(temp);
132
133 temp.event_ = CMD_IP_FORWARDING_DISABLE_ERROR;
134 temp.curState_ = SUBSTATE_SHARED;
135 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
136 temp.nextState_ = SUBSTATE_INIT;
137 stateTable_.push_back(temp);
138
139 temp.event_ = CMD_START_SHARING_ERROR;
140 temp.curState_ = SUBSTATE_SHARED;
141 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
142 temp.nextState_ = SUBSTATE_INIT;
143 stateTable_.push_back(temp);
144
145 temp.event_ = CMD_STOP_SHARING_ERROR;
146 temp.curState_ = SUBSTATE_SHARED;
147 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
148 temp.nextState_ = SUBSTATE_INIT;
149 stateTable_.push_back(temp);
150
151 temp.event_ = CMD_SET_DNS_FORWARDERS_ERROR;
152 temp.curState_ = SUBSTATE_SHARED;
153 temp.func_ = &NetworkShareSubStateMachine::HandleSharedErrors;
154 temp.nextState_ = SUBSTATE_INIT;
155 stateTable_.push_back(temp);
156 }
157
SubSmStateSwitch(int newState)158 void NetworkShareSubStateMachine::SubSmStateSwitch(int newState)
159 {
160 int oldState = curState_;
161 curState_ = newState;
162 NETMGR_EXT_LOG_I("Sub SM from[%{public}d] to[%{public}d].", oldState, newState);
163
164 if (oldState == SUBSTATE_INIT) {
165 InitStateExit();
166 } else if (oldState == SUBSTATE_SHARED) {
167 SharedStateExit();
168 } else if (oldState == SUBSTATE_UNAVAILABLE) {
169 UnavailableStateExit();
170 } else {
171 NETMGR_EXT_LOG_E("oldState is unknow type value.");
172 }
173
174 if (newState == SUBSTATE_INIT) {
175 InitStateEnter();
176 } else if (newState == SUBSTATE_SHARED) {
177 SharedStateEnter();
178 } else if (newState == SUBSTATE_UNAVAILABLE) {
179 UnavailableStateEnter();
180 } else {
181 NETMGR_EXT_LOG_E("newState is unknow type value.");
182 }
183 }
184
getUsefulMutex()185 ffrt::recursive_mutex &NetworkShareSubStateMachine::getUsefulMutex()
186 {
187 auto mainStateMachinePtr = NetworkShareTracker::GetInstance().GetMainStateMachine();
188 if (!mainStateMachinePtr) {
189 NETMGR_EXT_LOG_W("The point of NetworkShareMainStateMachine is nullptr, use mutex in this category.");
190 return mutex_;
191 }
192 return mainStateMachinePtr->GetEventMutex();
193 }
194
SubSmEventHandle(int eventId, const std::any &messageObj)195 void NetworkShareSubStateMachine::SubSmEventHandle(int eventId, const std::any &messageObj)
196 {
197 std::lock_guard<ffrt::recursive_mutex> lock(getUsefulMutex());
198 int nextState = NO_NEXT_STATE;
199 int (NetworkShareSubStateMachine::*eventFunc)(const std::any &messageObj) = nullptr;
200 for (const auto &iterState : stateTable_) {
201 if ((eventId == iterState.event_) && (curState_ == iterState.curState_)) {
202 eventFunc = iterState.func_;
203 nextState = iterState.nextState_;
204 break;
205 }
206 }
207 if (eventFunc == nullptr) {
208 NETMGR_EXT_LOG_W("SubSM currentstate[%{public}d] eventId[%{public}d] is not matched.", curState_, eventId);
209 return;
210 }
211 (this->*eventFunc)(messageObj);
212 if (nextState >= SUBSTATE_INIT && nextState < SUBSTATE_MAX) {
213 SubSmStateSwitch(nextState);
214 }
215
216 NETMGR_EXT_LOG_I("SubSM eventId[%{public}d] handle successfull.", eventId);
217 }
218
GetDownIfaceName(std::string &downIface)219 void NetworkShareSubStateMachine::GetDownIfaceName(std::string &downIface)
220 {
221 downIface = ifaceName_;
222 }
223
GetUpIfaceName(std::string &upIface)224 void NetworkShareSubStateMachine::GetUpIfaceName(std::string &upIface)
225 {
226 upIface = upstreamIfaceName_;
227 }
228
InitStateEnter()229 void NetworkShareSubStateMachine::InitStateEnter()
230 {
231 if (trackerCallback_ == nullptr) {
232 NETMGR_EXT_LOG_E("Enter Sub StateMachine Init State error, trackerCallback_ is null.");
233 return;
234 }
235 NETMGR_EXT_LOG_I("Enter Sub StateMachine[%{public}s] Init State.", ifaceName_.c_str());
236 trackerCallback_->OnUpdateInterfaceState(shared_from_this(), SUB_SM_STATE_AVAILABLE, lastError_);
237 }
238
InitStateExit()239 void NetworkShareSubStateMachine::InitStateExit()
240 {
241 NETMGR_EXT_LOG_I("Exit Sub StateMachine[%{public}s] Init State.", ifaceName_.c_str());
242 }
243
HandleInitSharingRequest(const std::any &messageObj)244 int NetworkShareSubStateMachine::HandleInitSharingRequest(const std::any &messageObj)
245 {
246 (void)messageObj;
247 lastError_ = NETMANAGER_EXT_SUCCESS;
248 return NETMANAGER_EXT_SUCCESS;
249 }
250
HandleInitInterfaceDown(const std::any &messageObj)251 int NetworkShareSubStateMachine::HandleInitInterfaceDown(const std::any &messageObj)
252 {
253 (void)messageObj;
254 return NETMANAGER_EXT_SUCCESS;
255 }
256
GetShareIpv6Prefix(const std::string &iface)257 bool NetworkShareSubStateMachine::GetShareIpv6Prefix(const std::string &iface)
258 {
259 ifaddrs *ifaddr = nullptr;
260 char ipv6Addr[INET6_ADDRSTRLEN] = {};
261 if (getifaddrs(&ifaddr)) {
262 NETMGR_EXT_LOG_E("getifaddrs err!");
263 return false;
264 }
265 for (auto ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
266 if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_INET6 || std::string(ifa->ifa_name) != iface) {
267 continue;
268 }
269 if (getnameinfo(ifa->ifa_addr, sizeof(sockaddr_in6), ipv6Addr, NI_MAXHOST, nullptr, 0, NI_NUMERICHOST) != 0) {
270 NETMGR_EXT_LOG_E("getnameinfo err!");
271 break;
272 }
273 if (strstr(ipv6Addr, DEFAULT_LINK_STR) != nullptr) {
274 continue;
275 }
276 IpPrefix ipPrefix;
277 inet_pton(AF_INET6, ipv6Addr, &ipPrefix.address);
278 inet_pton(AF_INET6, ipv6Addr, &ipPrefix.prefix);
279 if (memset_s(ipPrefix.prefix.s6_addr + HALF_IN6ADDR, HALF_IN6ADDR, 0, HALF_IN6ADDR) != EOK) {
280 NETMGR_EXT_LOG_E("Failed memset_s");
281 break;
282 }
283 ipPrefix.prefixesLength = PREFIX_LEN;
284 lastRaParams_.prefixes_.emplace_back(ipPrefix);
285 }
286 freeifaddrs(ifaddr);
287 return true;
288 }
289
MacToEui64Addr(std::string &mac)290 std::string NetworkShareSubStateMachine::MacToEui64Addr(std::string &mac)
291 {
292 sockaddr macSockaddr = {};
293 for (size_t i = 0; i < mac.length(); i += MAC_SSCANF_SPACE) {
294 std::string byte = mac.substr(i, MAC_BLOCK);
295 macSockaddr.sa_data[i / MAC_SSCANF_SPACE] = static_cast<char>(strtol(byte.c_str(), nullptr, HEX_BASE));
296 }
297 unsigned char eui64Sa[HALF_IN6ADDR] = {0};
298 char eui64Addr[INTF_ID_LEN] = {0};
299 eui64Sa[BYTE_ZERO] =
300 macSockaddr.sa_data[BYTE_ZERO] | ((macSockaddr.sa_data[BYTE_ZERO] & EUI64_INVERT) ^ EUI64_INVERT);
301 eui64Sa[BYTE_ONE] = macSockaddr.sa_data[BYTE_ONE];
302 eui64Sa[BYTE_TWO] = macSockaddr.sa_data[BYTE_TWO];
303 eui64Sa[BYTE_THREE] = EUI64_FF;
304 eui64Sa[BYTE_FOUR] = EUI64_FE;
305 eui64Sa[BYTE_FIVE] = macSockaddr.sa_data[BYTE_THREE];
306 eui64Sa[BYTE_SIX] = macSockaddr.sa_data[BYTE_FOUR];
307 eui64Sa[BYTE_SEVEN] = macSockaddr.sa_data[BYTE_FIVE];
308 if (snprintf_s(eui64Addr, sizeof(eui64Addr), sizeof(eui64Addr) - 1, "%02x%02x:%02x%02x:%02x%02x:%02x%02x",
309 eui64Sa[BYTE_ZERO], eui64Sa[BYTE_ONE], eui64Sa[BYTE_TWO], eui64Sa[BYTE_THREE], eui64Sa[BYTE_FOUR],
310 eui64Sa[BYTE_FIVE], eui64Sa[BYTE_SIX], eui64Sa[BYTE_SEVEN]) < 0) {
311 return std::string{};
312 }
313 return std::string(eui64Addr);
314 }
315
GenerateIpv6(const std::string &iface)316 int32_t NetworkShareSubStateMachine::GenerateIpv6(const std::string &iface)
317 {
318 std::string eui64Addr = std::string("::") + MacToEui64Addr(lastRaParams_.macAddr_);
319 in6_addr eui64 = IN6ADDR_ANY_INIT;
320 inet_pton(AF_INET6, eui64Addr.c_str(), &eui64);
321 for (IpPrefix &prefix : lastRaParams_.prefixes_) {
322 for (int32_t index = HALF_IN6ADDR; index < MAX_IPV6_PREFIX_LENGTH / BYTE_BIT; ++index) {
323 prefix.address.s6_addr[index] = eui64.s6_addr[index];
324 }
325 prefix.address.s6_addr[HALF_IN6ADDR - 1]++;
326 prefix.prefix.s6_addr[HALF_IN6ADDR - 1]++;
327 }
328 return NETMANAGER_EXT_SUCCESS;
329 }
330
StartIpv6()331 void NetworkShareSubStateMachine::StartIpv6()
332 {
333 NETMGR_EXT_LOG_I("Start ipv6 for iface: %{public}s", ifaceName_.c_str());
334 if (lastRaParams_.prefixes_.size() == 0) {
335 NETMGR_EXT_LOG_I("have nothing ipv6 address!");
336 return;
337 }
338 if (raDaemon_ == nullptr) {
339 raDaemon_ = std::make_shared<RouterAdvertisementDaemon>();
340 }
341 if (raDaemon_->Init(ifaceName_) != NETMANAGER_EXT_SUCCESS) {
342 NETMGR_EXT_LOG_E("Init ipv6 share failed");
343 return;
344 }
345 int32_t mtu = NetsysController::GetInstance().GetInterfaceMtu(ifaceName_);
346 lastRaParams_.mtu_ = mtu > IPV6_MIN_MTU ? mtu : IPV6_MIN_MTU;
347 raDaemon_->BuildNewRa(lastRaParams_);
348 if (raDaemon_->StartRa() != NETMANAGER_EXT_SUCCESS) {
349 NETMGR_EXT_LOG_E("StartRa failed");
350 StopIpv6();
351 }
352 }
353
StopIpv6()354 void NetworkShareSubStateMachine::StopIpv6()
355 {
356 NETMGR_EXT_LOG_I("Stop ipv6 for iface: %{public}s", ifaceName_.c_str());
357 if (raDaemon_ != nullptr) {
358 raDaemon_->StopRa();
359 lastRaParams_.Clear();
360 raDaemon_ = nullptr;
361 }
362 }
SharedStateEnter()363 void NetworkShareSubStateMachine::SharedStateEnter()
364 {
365 NETMGR_EXT_LOG_I("Enter Sub StateMachine[%{public}s] Shared State.", ifaceName_.c_str());
366 if (trackerCallback_ == nullptr) {
367 NETMGR_EXT_LOG_E("Enter Sub StateMachine Shared State error, trackerCallback_ is null.");
368 return;
369 }
370 trackerCallback_->OnUpdateInterfaceState(shared_from_this(), SUB_SM_STATE_SHARED, lastError_);
371 }
372
SharedStateExit()373 void NetworkShareSubStateMachine::SharedStateExit()
374 {
375 NETMGR_EXT_LOG_I("Exit Sub StateMachine[%{public}s] Shared State.", ifaceName_.c_str());
376 CleanupUpstreamInterface();
377 ConfigureShareDhcp(false);
378 StopIpv6();
379 }
380
HandleSharedUnrequest(const std::any &messageObj)381 int NetworkShareSubStateMachine::HandleSharedUnrequest(const std::any &messageObj)
382 {
383 (void)messageObj;
384 return NETMANAGER_EXT_SUCCESS;
385 }
386
HandleSharedInterfaceDown(const std::any &messageObj)387 int NetworkShareSubStateMachine::HandleSharedInterfaceDown(const std::any &messageObj)
388 {
389 (void)messageObj;
390 return NETMANAGER_EXT_SUCCESS;
391 }
392
HandleSharedConnectionChange(const std::any &messageObj)393 int NetworkShareSubStateMachine::HandleSharedConnectionChange(const std::any &messageObj)
394 {
395 std::shared_ptr<UpstreamNetworkInfo> upstreamNetInfo =
396 std::any_cast<std::shared_ptr<UpstreamNetworkInfo>>(messageObj);
397 if (upstreamNetInfo == nullptr) {
398 NETMGR_EXT_LOG_I("Sub StateMachine[%{public}s] upstreamNetInfo is null, need clean.", ifaceName_.c_str());
399 CleanupUpstreamInterface();
400 upstreamIfaceName_ = EMPTY_UPSTREAM_IFACENAME;
401 return NETMANAGER_EXT_SUCCESS;
402 }
403 HandleConnectionChanged(upstreamNetInfo);
404 return NETMANAGER_EXT_SUCCESS;
405 }
406
HandleSharedErrors(const std::any &messageObj)407 int NetworkShareSubStateMachine::HandleSharedErrors(const std::any &messageObj)
408 {
409 (void)messageObj;
410 NETMGR_EXT_LOG_I("Sub StateMachine[%{public}s] SharedState has ERROR.", ifaceName_.c_str());
411 lastError_ = NETWORKSHARE_ERROR_INTERNAL_ERROR;
412 return NETMANAGER_EXT_SUCCESS;
413 }
414
UnavailableStateEnter()415 void NetworkShareSubStateMachine::UnavailableStateEnter()
416 {
417 NETMGR_EXT_LOG_I("Enter Sub StateMachine[%{public}s] Unavailable State.", ifaceName_.c_str());
418 lastError_ = NETMANAGER_EXT_SUCCESS;
419 if (trackerCallback_ == nullptr) {
420 NETMGR_EXT_LOG_E("Enter Sub StateMachine Unavailable State error, trackerCallback_ is null.");
421 return;
422 }
423 trackerCallback_->OnUpdateInterfaceState(shared_from_this(), SUB_SM_STATE_UNAVAILABLE, NETMANAGER_EXT_SUCCESS);
424 }
425
UnavailableStateExit()426 void NetworkShareSubStateMachine::UnavailableStateExit()
427 {
428 NETMGR_EXT_LOG_I("Exit Sub StateMachine[%{public}s] Unavailable State.", ifaceName_.c_str());
429 }
430
HandleConnectionChanged(const std::shared_ptr<UpstreamNetworkInfo> &upstreamNetInfo)431 void NetworkShareSubStateMachine::HandleConnectionChanged(const std::shared_ptr<UpstreamNetworkInfo> &upstreamNetInfo)
432 {
433 if (upstreamNetInfo == nullptr) {
434 return;
435 }
436 if (upstreamNetInfo->netLinkPro_ == nullptr) {
437 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] HandleConnectionChanged netLinkPro_ is null.",
438 ifaceName_.c_str());
439 return;
440 }
441 if (HasChangeUpstreamIfaceSet(upstreamNetInfo->netLinkPro_->ifaceName_)) {
442 NETMGR_EXT_LOG_I("Sub StateMachine[%{public}s] HandleConnectionChanged Upstream Ifacechange.",
443 ifaceName_.c_str());
444 CleanupUpstreamInterface();
445 upstreamIfaceName_ = upstreamNetInfo->netLinkPro_->ifaceName_;
446 HandleConnection();
447 }
448 ConfigureShareIpv4(upstreamNetInfo->netLinkPro_);
449 ConfigureShareIpv6(upstreamNetInfo->netLinkPro_);
450 }
451
ConfigureShareIpv4(const sptr<NetLinkInfo> &upstreamLinkInfo)452 void NetworkShareSubStateMachine::ConfigureShareIpv4(const sptr<NetLinkInfo> &upstreamLinkInfo)
453 {
454 bool hasIpv4 = false;
455 for (const auto &inetAddr : upstreamLinkInfo->netAddrList_) {
456 auto family = inetAddr.family_;
457 if (family == NET_FAMILY_IPV4) {
458 hasIpv4 = true;
459 NETMGR_EXT_LOG_I("family:%{public}d", family);
460 break;
461 }
462 }
463 if (hasIpv4) {
464 AddRoutesToLocalNetwork();
465 ConfigureShareDhcp(true);
466 }
467 }
468
ConfigureShareIpv6(const sptr<NetLinkInfo> &upstreamLinkInfo)469 void NetworkShareSubStateMachine::ConfigureShareIpv6(const sptr<NetLinkInfo> &upstreamLinkInfo)
470 {
471 lastRaParams_.Clear();
472 for (const auto &inetAddr : upstreamLinkInfo->netAddrList_) {
473 auto family = inetAddr.family_;
474 if (family != NET_FAMILY_IPV6) {
475 continue;
476 }
477 IpPrefix ipPrefix;
478 inet_pton(AF_INET6, inetAddr.address_.c_str(), &ipPrefix.address);
479 inet_pton(AF_INET6, inetAddr.address_.c_str(), &ipPrefix.prefix);
480 if (memset_s(ipPrefix.prefix.s6_addr + HALF_IN6ADDR, HALF_IN6ADDR, 0, HALF_IN6ADDR) != EOK) {
481 NETMGR_EXT_LOG_I("Failed memset_s");
482 continue;
483 }
484 ipPrefix.prefixesLength = PREFIX_LEN;
485 lastRaParams_.prefixes_.emplace_back(ipPrefix);
486 NETMGR_EXT_LOG_I("family:%{public}d", family);
487 }
488 if (lastRaParams_.prefixes_.size() == 0) {
489 NETMGR_EXT_LOG_E("have nothing ipv6 address for iface[%{public}s!", upstreamLinkInfo->ifaceName_.c_str());
490 return;
491 }
492 if (raDaemon_ == nullptr) {
493 AddIpv6InfoToLocalNetwork();
494 StartIpv6();
495 }
496 }
HandleConnection()497 void NetworkShareSubStateMachine::HandleConnection()
498 {
499 int32_t result = NetsysController::GetInstance().IpfwdAddInterfaceForward(ifaceName_, upstreamIfaceName_);
500 if (result != NETSYS_SUCCESS) {
501 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
502 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
503 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_CONFIG_FORWARD,
504 NetworkShareEventType::SETUP_EVENT);
505 NETMGR_EXT_LOG_E(
506 "Sub StateMachine[%{public}s] IpfwdAddInterfaceForward newIface[%{public}s] error[%{public}d].",
507 ifaceName_.c_str(), upstreamIfaceName_.c_str(), result);
508 lastError_ = NETWORKSHARE_ERROR_ENABLE_FORWARDING_ERROR;
509 SubSmStateSwitch(SUBSTATE_INIT);
510 return;
511 }
512
513 result = NetsysController::GetInstance().NetworkAddInterface(LOCAL_NET_ID, ifaceName_);
514 if (result != NETMANAGER_SUCCESS) {
515 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
516 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
517 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_STRATEGY,
518 NetworkShareEventType::SETUP_EVENT);
519 NETMGR_EXT_LOG_E(
520 "Sub StateMachine[%{public}s] SharedState NetworkAddInterface newIface[%{public}s] error[%{public}d].",
521 ifaceName_.c_str(), upstreamIfaceName_.c_str(), result);
522 NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ifaceName_, upstreamIfaceName_);
523 lastError_ = NETWORKSHARE_ERROR_ENABLE_FORWARDING_ERROR;
524 SubSmStateSwitch(SUBSTATE_INIT);
525 return;
526 }
527 }
528
RemoveRoutesToLocalNetwork()529 void NetworkShareSubStateMachine::RemoveRoutesToLocalNetwork()
530 {
531 std::string destination;
532 if (!FindDestinationAddr(destination)) {
533 NETMGR_EXT_LOG_E("Get Destination fail");
534 return;
535 }
536 int32_t result =
537 NetsysController::GetInstance().NetworkRemoveRoute(LOCAL_NET_ID, ifaceName_, destination, NEXT_HOT);
538 if (result != NETSYS_SUCCESS) {
539 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
540 netShareType_, NetworkShareEventOperator::OPERATION_CANCEL_FORWARD,
541 NetworkShareEventErrorType::ERROR_CANCEL_FORWARD, ERROR_MSG_REMOVE_ROUTE_RULE,
542 NetworkShareEventType::CANCEL_EVENT);
543 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Remove Route error[%{public}d].", ifaceName_.c_str(), result);
544 } else {
545 destination_ = "";
546 }
547 }
548
AddRoutesToLocalNetwork()549 void NetworkShareSubStateMachine::AddRoutesToLocalNetwork()
550 {
551 std::string destination;
552 if (!FindDestinationAddr(destination)) {
553 NETMGR_EXT_LOG_E("Get Destination fail");
554 return;
555 }
556 if (destination_ == destination) {
557 NETMGR_EXT_LOG_I("ipv4 route already Set!");
558 return;
559 }
560 int32_t result = NetsysController::GetInstance().NetworkAddRoute(LOCAL_NET_ID, ifaceName_, destination, NEXT_HOT);
561 if (result != NETSYS_SUCCESS) {
562 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
563 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
564 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_RULE,
565 NetworkShareEventType::SETUP_EVENT);
566 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route error[%{public}d].", ifaceName_.c_str(), result);
567 } else {
568 destination_ = destination;
569 }
570 }
571
AddIpv6AddrToLocalNetwork()572 void NetworkShareSubStateMachine::AddIpv6AddrToLocalNetwork()
573 {
574 char address[INET6_ADDRSTRLEN] = {0};
575 char addressPrefix[INET6_ADDRSTRLEN] = {0};
576 std::string destination;
577 int32_t result = NETSYS_SUCCESS;
578 for (const auto &prefix : lastRaParams_.prefixes_) {
579 inet_ntop(AF_INET6, &(prefix.address), address, sizeof(address));
580 if (NetsysController::GetInstance().AddInterfaceAddress(ifaceName_, address, PREFIX_LEN) != 0) {
581 NETMGR_EXT_LOG_E("Failed setting ipv6 address");
582 return;
583 }
584 inet_ntop(AF_INET6, &(prefix.prefix), addressPrefix, sizeof(addressPrefix));
585 destination = std::string(addressPrefix) + DEFAULT_PREFIX;
586 result = NetsysController::GetInstance().NetworkAddRoute(LOCAL_NET_ID, ifaceName_, destination, IPV6_NEXT_HOT);
587 if (result != NETSYS_SUCCESS) {
588 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
589 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
590 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_RULE,
591 NetworkShareEventType::SETUP_EVENT);
592 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route error[%{public}d].", ifaceName_.c_str(), result);
593 }
594 }
595 destination = std::string(DEFAULT_LINK_ROUTE);
596 result = NetsysController::GetInstance().NetworkAddRoute(LOCAL_NET_ID, ifaceName_, destination, IPV6_NEXT_HOT);
597 if (result != NETSYS_SUCCESS) {
598 NetworkShareHisysEvent::GetInstance().SendFaultEvent(
599 netShareType_, NetworkShareEventOperator::OPERATION_CONFIG_FORWARD,
600 NetworkShareEventErrorType::ERROR_CONFIG_FORWARD, ERROR_MSG_ADD_ROUTE_RULE,
601 NetworkShareEventType::SETUP_EVENT);
602 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route error[%{public}d].", ifaceName_.c_str(), result);
603 }
604 }
605
AddIpv6InfoToLocalNetwork()606 void NetworkShareSubStateMachine::AddIpv6InfoToLocalNetwork()
607 {
608 if (!GetWifiApDstIpv6Addr()) {
609 NETMGR_EXT_LOG_E("have nothing ipv6 params!");
610 return;
611 }
612 AddIpv6AddrToLocalNetwork();
613 }
614
FindDestinationAddr(std::string &destination)615 bool NetworkShareSubStateMachine::FindDestinationAddr(std::string &destination)
616 {
617 if (netShareType_ == SharingIfaceType::SHARING_BLUETOOTH) {
618 if (!GetBtDestinationAddr(destination)) {
619 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route Get btpan Destination Addr failed.",
620 ifaceName_.c_str());
621 return false;
622 }
623 return true;
624 }
625 if (netShareType_ == SharingIfaceType::SHARING_WIFI) {
626 if (!GetWifiApDestinationAddr(destination)) {
627 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route Get wifi Destination Addr failed.",
628 ifaceName_.c_str());
629 return false;
630 }
631 return true;
632 }
633 if (netShareType_ == SharingIfaceType::SHARING_USB) {
634 if (!GetUsbDestinationAddr(destination)) {
635 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route Get usb Destination Addr failed.",
636 ifaceName_.c_str());
637 return false;
638 }
639 return true;
640 }
641 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] Add Route sharetype is unknown.", ifaceName_.c_str());
642 return false;
643 }
644
GetWifiHotspotDhcpFlag()645 bool NetworkShareSubStateMachine::GetWifiHotspotDhcpFlag()
646 {
647 if (configuration_ == nullptr) {
648 return false;
649 }
650 return configuration_->GetWifiHotspotSetDhcpFlag();
651 }
652
GetBtDestinationAddr(std::string &addrStr)653 bool NetworkShareSubStateMachine::GetBtDestinationAddr(std::string &addrStr)
654 {
655 if (configuration_ == nullptr) {
656 NETMGR_EXT_LOG_E("GetBtDestinationAddr configuration is null.");
657 return false;
658 }
659 std::string btpanIpv4Addr = configuration_->GetBtpanIpv4Addr();
660 if (btpanIpv4Addr.empty()) {
661 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get btpan ipv4 addr failed.", ifaceName_.c_str());
662 return false;
663 }
664 std::string::size_type dotPos = btpanIpv4Addr.rfind(".");
665 if (dotPos == std::string::npos) {
666 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] btpan ipv4 addr error.", ifaceName_.c_str());
667 return false;
668 }
669 std::string routeSuffix = configuration_->GetRouteSuffix();
670 if (routeSuffix.empty()) {
671 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get route suffix failed.", ifaceName_.c_str());
672 return false;
673 }
674
675 addrStr = btpanIpv4Addr.substr(0, dotPos) + routeSuffix;
676 return true;
677 }
678
GetWifiApDestinationAddr(std::string &addrStr)679 bool NetworkShareSubStateMachine::GetWifiApDestinationAddr(std::string &addrStr)
680 {
681 if (configuration_ == nullptr) {
682 NETMGR_EXT_LOG_E("GetWifiApDestinationAddr configuration is null.");
683 return false;
684 }
685 std::string wifiIpv4Addr = configuration_->GetWifiHotspotIpv4Addr();
686 if (wifiIpv4Addr.empty()) {
687 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get wifi ipv4 addr failed.", ifaceName_.c_str());
688 return false;
689 }
690 std::string::size_type dotPos = wifiIpv4Addr.rfind(".");
691 if (dotPos == std::string::npos) {
692 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] wifi ipv4 addr error.", ifaceName_.c_str());
693 return false;
694 }
695 std::string routeSuffix = configuration_->GetRouteSuffix();
696 if (routeSuffix.empty()) {
697 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get route suffix failed.", ifaceName_.c_str());
698 return false;
699 }
700 addrStr = wifiIpv4Addr.substr(0, dotPos) + routeSuffix;
701 return true;
702 }
703
GetWifiApDstIpv6Addr()704 bool NetworkShareSubStateMachine::GetWifiApDstIpv6Addr()
705 {
706 OHOS::nmd::InterfaceConfigurationParcel config;
707 config.ifName = ifaceName_;
708 if (NetsysController::GetInstance().GetInterfaceConfig(config) != ERR_NONE) {
709 NETMGR_EXT_LOG_E("Get interface mac err!");
710 return false;
711 }
712 if (!std::regex_match(config.hwAddr, REGEX_MAC)) {
713 NETMGR_EXT_LOG_E("Get interface mac format err!");
714 return false;
715 }
716 lastRaParams_.macAddr_ = config.hwAddr;
717 if (lastRaParams_.prefixes_.size() == 0) {
718 NETMGR_EXT_LOG_E("have nothing ipv6 address for iface[%{public}s!", upstreamIfaceName_.c_str());
719 return false;
720 }
721 if (GenerateIpv6(upstreamIfaceName_) != NETMANAGER_EXT_SUCCESS) {
722 NETMGR_EXT_LOG_E("Generate ipv6 adress Fail %{public}s", upstreamIfaceName_.c_str());
723 return false;
724 }
725 return true;
726 }
727
GetUsbDestinationAddr(std::string &addrStr)728 bool NetworkShareSubStateMachine::GetUsbDestinationAddr(std::string &addrStr)
729 {
730 if (configuration_ == nullptr) {
731 NETMGR_EXT_LOG_E("GetUsbDestinationAddr configuration is null.");
732 return false;
733 }
734 std::string usbIpv4Addr = configuration_->GetUsbRndisIpv4Addr();
735 if (usbIpv4Addr.empty()) {
736 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get usb ipv4 addr failed.", ifaceName_.c_str());
737 return false;
738 }
739 std::string::size_type dotPos = usbIpv4Addr.rfind(".");
740 if (dotPos == std::string::npos) {
741 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] usb ipv4 addr error.", ifaceName_.c_str());
742 return false;
743 }
744 std::string routeSuffix = configuration_->GetRouteSuffix();
745 if (routeSuffix.empty()) {
746 NETMGR_EXT_LOG_E("Sub StateMachine[%{public}s] get route suffix failed.", ifaceName_.c_str());
747 return false;
748 }
749 addrStr = usbIpv4Addr.substr(0, dotPos) + routeSuffix;
750 return true;
751 }
752
StartDhcp(const std::shared_ptr<INetAddr> &netAddr)753 bool NetworkShareSubStateMachine::StartDhcp(const std::shared_ptr<INetAddr> &netAddr)
754 {
755 if (netAddr == nullptr) {
756 NETMGR_EXT_LOG_E("StartDhcp netAddr is null.");
757 return false;
758 }
759 std::string endIp;
760 std::string mask;
761 if (!CheckConfig(endIp, mask)) {
762 NETMGR_EXT_LOG_E("StartDhcp Get necessary config failed.");
763 return false;
764 }
765
766 std::string ipAddr = netAddr->address_;
767 std::string::size_type pos = ipAddr.rfind(".");
768 if (pos == std::string::npos) {
769 NETMGR_EXT_LOG_E("StartDhcp addr is error.");
770 return false;
771 }
772 std::string ipHead = ipAddr.substr(0, pos);
773 std::string ipEnd = ipAddr.substr(pos + 1);
774 std::string startIp = std::to_string(atoi(ipEnd.c_str()) + 1);
775
776 std::string strStartip = ipHead + "." + startIp;
777 std::string strEndip = ipHead + "." + endIp;
778
779 DhcpRange range;
780 range.iptype = IP_V4;
781 if (!SetRange(range, ipHead, strStartip, strEndip, mask)) {
782 return false;
783 }
784
785 if (SetDhcpRange(ifaceName_.c_str(), &range) != DHCP_SUCCESS) {
786 NETMGR_EXT_LOG_E("StartDhcp SetDhcpRange failed.");
787 return false;
788 }
789
790 if (StartDhcpServer(ifaceName_.c_str()) != DHCP_SUCCESS) {
791 NETMGR_EXT_LOG_E("StartDhcp StartDhcpServer failed.");
792 return false;
793 }
794 NETMGR_EXT_LOG_I("StartDhcp StartDhcpServer successful.");
795 return true;
796 }
797
SetRange(DhcpRange &range, const std::string &ipHead, const std::string &strStartip, const std::string &strEndip, const std::string &mask)798 bool NetworkShareSubStateMachine::SetRange(DhcpRange &range, const std::string &ipHead, const std::string &strStartip,
799 const std::string &strEndip, const std::string &mask)
800 {
801 if (strcpy_s(range.strTagName, DHCP_MAX_FILE_BYTES, ifaceName_.c_str()) != 0) {
802 NETMGR_EXT_LOG_E("strcpy_s strTagName failed!");
803 return false;
804 }
805
806 if (strcpy_s(range.strStartip, INET_ADDRSTRLEN, strStartip.c_str()) != 0) {
807 NETMGR_EXT_LOG_E("strcpy_s strStartip failed!");
808 return false;
809 }
810
811 if (strcpy_s(range.strEndip, INET_ADDRSTRLEN, strEndip.c_str()) != 0) {
812 NETMGR_EXT_LOG_E("strcpy_s strEndip failed!");
813 return false;
814 }
815
816 if (strcpy_s(range.strSubnet, INET_ADDRSTRLEN, mask.c_str()) != 0) {
817 NETMGR_EXT_LOG_E("strcpy_s strSubnet failed!");
818 return false;
819 }
820 NETMGR_EXT_LOG_I(
821 "Set dhcp range : ifaceName[%{public}s] TagName[%{public}s] start ip[%{private}s] end ip[%{private}s]",
822 ifaceName_.c_str(), range.strTagName, range.strStartip, range.strEndip);
823
824 return true;
825 }
826
CheckConfig(std::string &endIp, std::string &mask)827 bool NetworkShareSubStateMachine::CheckConfig(std::string &endIp, std::string &mask)
828 {
829 if (configuration_ == nullptr) {
830 NETMGR_EXT_LOG_E("StartDhcp configuration is null.");
831 return false;
832 }
833 endIp = configuration_->GetDhcpEndIP();
834 if (endIp.empty()) {
835 NETMGR_EXT_LOG_E("StartDhcp GetDhcpEndIP is null.");
836 return false;
837 }
838 mask = configuration_->GetDefaultMask();
839 if (mask.empty()) {
840 NETMGR_EXT_LOG_E("StartDhcp GetDefaultMask is null.");
841 return false;
842 }
843 return true;
844 }
845
StopDhcp()846 bool NetworkShareSubStateMachine::StopDhcp()
847 {
848 if (netShareType_ == SharingIfaceType::SHARING_WIFI) {
849 NETMGR_EXT_LOG_W("StopDhcp wifi hotspot not need stop.");
850 return true;
851 }
852
853 int ret = StopDhcpServer(ifaceName_.c_str());
854 if (ret != 0) {
855 NETMGR_EXT_LOG_E("StopDhcpServer failed, error[%{public}d].", ret);
856 return false;
857 }
858 NETMGR_EXT_LOG_I("StopDhcpServer successful.");
859 return true;
860 }
861
ConfigureShareDhcp(bool enabled)862 bool NetworkShareSubStateMachine::ConfigureShareDhcp(bool enabled)
863 {
864 std::shared_ptr<INetAddr> ipv4Address = nullptr;
865 if (enabled) {
866 bool ret = RequestIpv4Address(ipv4Address);
867 if (ipv4Address == nullptr || !ret) {
868 NETMGR_EXT_LOG_E("ConfigureShareDhcp no available ipv4 address.");
869 return false;
870 }
871 if (netShareType_ == SharingIfaceType::SHARING_WIFI && !GetWifiHotspotDhcpFlag()) {
872 NETMGR_EXT_LOG_W("StartDhcp wifi hotspot not need start.");
873 return true;
874 }
875 return StartDhcp(ipv4Address);
876 }
877 return StopDhcp();
878 }
879
RequestIpv4Address(std::shared_ptr<INetAddr> &netAddr)880 bool NetworkShareSubStateMachine::RequestIpv4Address(std::shared_ptr<INetAddr> &netAddr)
881 {
882 if (configuration_ == nullptr) {
883 NETMGR_EXT_LOG_E("RequestIpv4Address get configuration failed.");
884 return false;
885 }
886
887 netAddr = std::make_shared<INetAddr>();
888 netAddr->type_ = INetAddr::IPV4;
889 netAddr->prefixlen_ = PREFIX_LENGTH_24;
890 netAddr->netMask_ = configuration_->GetDefaultMask();
891 if (netAddr->netMask_.empty()) {
892 NETMGR_EXT_LOG_E("RequestIpv4Address get default mask failed.");
893 return false;
894 }
895 switch (netShareType_) {
896 case SharingIfaceType::SHARING_BLUETOOTH: {
897 netAddr->address_ = configuration_->GetBtpanIpv4Addr();
898 netAddr->hostName_ = configuration_->GetBtpanDhcpServerName();
899 break;
900 }
901 case SharingIfaceType::SHARING_WIFI: {
902 netAddr->address_ = configuration_->GetWifiHotspotIpv4Addr();
903 netAddr->hostName_ = configuration_->GetWifiHotspotDhcpServerName();
904 break;
905 }
906 case SharingIfaceType::SHARING_USB: {
907 netAddr->address_ = configuration_->GetUsbRndisIpv4Addr();
908 netAddr->hostName_ = configuration_->GetUsbRndisDhcpServerName();
909 break;
910 }
911 default:
912 NETMGR_EXT_LOG_E("Unknown share type");
913 return false;
914 }
915
916 if (netAddr->address_.empty() || netAddr->hostName_.empty()) {
917 NETMGR_EXT_LOG_E("Failed to get ipv4 Address or dhcp server name.");
918 return false;
919 }
920 return true;
921 }
922
CleanupUpstreamInterface()923 void NetworkShareSubStateMachine::CleanupUpstreamInterface()
924 {
925 NETMGR_EXT_LOG_I("Clearn Forward, downstream Iface[%{public}s], upstream iface[%{public}s].", ifaceName_.c_str(),
926 upstreamIfaceName_.c_str());
927 RemoveRoutesToLocalNetwork();
928 NetsysController::GetInstance().NetworkRemoveInterface(LOCAL_NET_ID, ifaceName_);
929 NetsysController::GetInstance().IpfwdRemoveInterfaceForward(ifaceName_, upstreamIfaceName_);
930 }
931
HasChangeUpstreamIfaceSet(const std::string &newUpstreamIface)932 bool NetworkShareSubStateMachine::HasChangeUpstreamIfaceSet(const std::string &newUpstreamIface)
933 {
934 if ((upstreamIfaceName_.empty()) && (newUpstreamIface.empty())) {
935 return false;
936 }
937 if ((!upstreamIfaceName_.empty()) && (!newUpstreamIface.empty())) {
938 return upstreamIfaceName_ != newUpstreamIface;
939 }
940 return true;
941 }
942
RegisterSubSMCallback(const std::shared_ptr<SubStateMachineCallback> &callback)943 void NetworkShareSubStateMachine::RegisterSubSMCallback(const std::shared_ptr<SubStateMachineCallback> &callback)
944 {
945 trackerCallback_ = callback;
946 }
947
GetNetShareType() const948 SharingIfaceType NetworkShareSubStateMachine::GetNetShareType() const
949 {
950 return netShareType_;
951 }
952
GetInterfaceName() const953 const std::string &NetworkShareSubStateMachine::GetInterfaceName() const
954 {
955 return ifaceName_;
956 }
957 } // namespace NetManagerStandard
958 } // namespace OHOS
959