1 /*
2 * Copyright (c) 2025 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_interface_callback_observer.h"
17
18 #include "connection_exec.h"
19 #include "constant.h"
20 #include "netinterface.h"
21 #include "netmanager_base_log.h"
22
23 namespace OHOS::NetManagerStandard {
OnInterfaceAddressUpdated(const std::string & addr,const std::string & ifName,int32_t flags,int32_t scope)24 int32_t NetInterfaceCallbackObserver::OnInterfaceAddressUpdated(const std::string &addr,
25 const std::string &ifName, int32_t flags, int32_t scope)
26 {
27 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
28 auto netInterface = NET_INTERFACES.find(this);
29 if (netInterface == NET_INTERFACES.end()) {
30 NETMANAGER_BASE_LOGE("can not find netInterface key");
31 return 0;
32 }
33 if (netInterface->second == nullptr) {
34 NETMANAGER_BASE_LOGE("can not find netInterface handle");
35 return 0;
36 }
37 auto manager = netInterface->second->GetEventManager();
38 if (manager == nullptr) {
39 return 0;
40 }
41 if (!manager->HasEventListener(EVENT_IFACE_ADDRESS_UPDATED)) {
42 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_ADDRESS_UPDATED);
43 return 0;
44 }
45
46 auto handler = [addr, ifName, flags, scope, manager](napi_env env) {
47 auto obj = CreateInterfaceAddressUpdateParam(env, addr, ifName, flags, scope);
48 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
49 manager->Emit(EVENT_IFACE_ADDRESS_UPDATED, arg);
50 };
51 manager->EmitByUvWithModuleId(EVENT_IFACE_ADDRESS_UPDATED, handler, netInterface->second->moduleId_);
52 return 0;
53 }
54
OnInterfaceAddressRemoved(const std::string & addr,const std::string & ifName,int32_t flags,int32_t scope)55 int32_t NetInterfaceCallbackObserver::OnInterfaceAddressRemoved(const std::string &addr,
56 const std::string &ifName, int32_t flags, int32_t scope)
57 {
58 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
59 auto netInterface = NET_INTERFACES.find(this);
60 if (netInterface == NET_INTERFACES.end()) {
61 NETMANAGER_BASE_LOGE("can not find netInterface key");
62 return 0;
63 }
64 if (netInterface->second == nullptr) {
65 NETMANAGER_BASE_LOGE("can not find netInterface handle");
66 return 0;
67 }
68 auto manager = netInterface->second->GetEventManager();
69 if (manager == nullptr) {
70 return 0;
71 }
72 if (!manager->HasEventListener(EVENT_IFACE_ADDRESS_REMOVED)) {
73 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_ADDRESS_REMOVED);
74 return 0;
75 }
76
77 auto handler = [addr, ifName, flags, scope, manager](napi_env env) {
78 auto obj = CreateInterfaceAddressUpdateParam(env, addr, ifName, flags, scope);
79 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
80 manager->Emit(EVENT_IFACE_ADDRESS_REMOVED, arg);
81 };
82 manager->EmitByUvWithModuleId(EVENT_IFACE_ADDRESS_REMOVED, handler, netInterface->second->moduleId_);
83 return 0;
84 }
85
OnInterfaceAdded(const std::string & ifName)86 int32_t NetInterfaceCallbackObserver::OnInterfaceAdded(const std::string &ifName)
87 {
88 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
89 auto netInterface = NET_INTERFACES.find(this);
90 if (netInterface == NET_INTERFACES.end()) {
91 NETMANAGER_BASE_LOGE("can not find netInterface key");
92 return 0;
93 }
94 if (netInterface->second == nullptr) {
95 NETMANAGER_BASE_LOGE("can not find netInterface handle");
96 return 0;
97 }
98 auto manager = netInterface->second->GetEventManager();
99 if (manager == nullptr) {
100 return 0;
101 }
102 if (!manager->HasEventListener(EVENT_IFACE_ADDED)) {
103 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_ADDED);
104 return 0;
105 }
106
107 auto handler = [ifName, manager](napi_env env) {
108 auto obj = CreateInterfaceUpdateParam(env, ifName);
109 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
110 manager->Emit(EVENT_IFACE_ADDED, arg);
111 };
112 manager->EmitByUvWithModuleId(EVENT_IFACE_ADDED, handler, netInterface->second->moduleId_);
113 return 0;
114 }
115
OnInterfaceRemoved(const std::string & ifName)116 int32_t NetInterfaceCallbackObserver::OnInterfaceRemoved(const std::string &ifName)
117 {
118 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
119 auto netInterface = NET_INTERFACES.find(this);
120 if (netInterface == NET_INTERFACES.end()) {
121 NETMANAGER_BASE_LOGE("can not find netInterface key");
122 return 0;
123 }
124 if (netInterface->second == nullptr) {
125 NETMANAGER_BASE_LOGE("can not find netInterface handle");
126 return 0;
127 }
128 auto manager = netInterface->second->GetEventManager();
129 if (manager == nullptr) {
130 return 0;
131 }
132 if (!manager->HasEventListener(EVENT_IFACE_REMOVED)) {
133 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_REMOVED);
134 return 0;
135 }
136
137 auto handler = [ifName, manager](napi_env env) {
138 auto obj = CreateInterfaceUpdateParam(env, ifName);
139 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
140 manager->Emit(EVENT_IFACE_REMOVED, arg);
141 };
142 manager->EmitByUvWithModuleId(EVENT_IFACE_REMOVED, handler, netInterface->second->moduleId_);
143 return 0;
144 }
145
OnInterfaceChanged(const std::string & ifName,bool up)146 int32_t NetInterfaceCallbackObserver::OnInterfaceChanged(const std::string &ifName, bool up)
147 {
148 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
149 auto netInterface = NET_INTERFACES.find(this);
150 if (netInterface == NET_INTERFACES.end()) {
151 NETMANAGER_BASE_LOGE("can not find netInterface key");
152 return 0;
153 }
154 if (netInterface->second == nullptr) {
155 NETMANAGER_BASE_LOGE("can not find netInterface handle");
156 return 0;
157 }
158 auto manager = netInterface->second->GetEventManager();
159 if (manager == nullptr) {
160 return 0;
161 }
162 if (!manager->HasEventListener(EVENT_IFACE_CHANGED)) {
163 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_CHANGED);
164 return 0;
165 }
166
167 auto handler = [ifName, up, manager](napi_env env) {
168 auto obj = CreateInterfaceChangedParam(env, ifName, up);
169 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
170 manager->Emit(EVENT_IFACE_CHANGED, arg);
171 };
172 manager->EmitByUvWithModuleId(EVENT_IFACE_CHANGED, handler, netInterface->second->moduleId_);
173 return 0;
174 }
175
OnInterfaceLinkStateChanged(const std::string & ifName,bool up)176 int32_t NetInterfaceCallbackObserver::OnInterfaceLinkStateChanged(const std::string &ifName, bool up)
177 {
178 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
179 auto netInterface = NET_INTERFACES.find(this);
180 if (netInterface == NET_INTERFACES.end()) {
181 NETMANAGER_BASE_LOGE("can not find netInterface key");
182 return 0;
183 }
184 if (netInterface->second == nullptr) {
185 NETMANAGER_BASE_LOGE("can not find netInterface handle");
186 return 0;
187 }
188 auto manager = netInterface->second->GetEventManager();
189 if (manager == nullptr) {
190 return 0;
191 }
192 if (!manager->HasEventListener(EVENT_IFACE_LINK_STATE_CHANGED)) {
193 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_LINK_STATE_CHANGED);
194 return 0;
195 }
196
197 auto handler = [ifName, up, manager](napi_env env) {
198 auto obj = CreateInterfaceChangedParam(env, ifName, up);
199 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
200 manager->Emit(EVENT_IFACE_LINK_STATE_CHANGED, arg);
201 };
202 manager->EmitByUvWithModuleId(EVENT_IFACE_LINK_STATE_CHANGED, handler, netInterface->second->moduleId_);
203 return 0;
204 }
205
OnRouteChanged(bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)206 int32_t NetInterfaceCallbackObserver::OnRouteChanged(bool updated, const std::string &route,
207 const std::string &gateway, const std::string &ifName)
208 {
209 std::shared_lock<std::shared_mutex> lock(g_netInterfacesMutex);
210 auto netInterface = NET_INTERFACES.find(this);
211 if (netInterface == NET_INTERFACES.end()) {
212 NETMANAGER_BASE_LOGE("can not find netInterface key");
213 return 0;
214 }
215 if (netInterface->second == nullptr) {
216 NETMANAGER_BASE_LOGE("can not find netInterface handle");
217 return 0;
218 }
219 auto manager = netInterface->second->GetEventManager();
220 if (manager == nullptr) {
221 return 0;
222 }
223 if (!manager->HasEventListener(EVENT_IFACE_ROUTE_CHANGED)) {
224 NETMANAGER_BASE_LOGE("no %{public}s listener", EVENT_IFACE_ROUTE_CHANGED);
225 return 0;
226 }
227
228 auto handler = [updated, route, gateway, ifName, manager](napi_env env) {
229 auto obj = CreateRouteChangeParam(env, updated, route, gateway, ifName);
230 std::pair<napi_value, napi_value> arg = {NapiUtils::GetUndefined(env), obj};
231 manager->Emit(EVENT_IFACE_ROUTE_CHANGED, arg);
232 };
233 manager->EmitByUvWithModuleId(EVENT_IFACE_ROUTE_CHANGED, handler, netInterface->second->moduleId_);
234 return 0;
235 }
236
CreateInterfaceAddressUpdateParam(napi_env env,const std::string & addr,const std::string & ifName,int32_t flags,int32_t scope)237 napi_value NetInterfaceCallbackObserver::CreateInterfaceAddressUpdateParam(napi_env env,
238 const std::string &addr, const std::string &ifName, int32_t flags, int32_t scope)
239 {
240 napi_value obj = NapiUtils::CreateObject(env);
241 if (NapiUtils::GetValueType(env, obj) != napi_object) {
242 return NapiUtils::GetUndefined(env);
243 }
244 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_INTERFACE_NAME, ifName);
245 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_ADDRESS, addr);
246 NapiUtils::SetInt32Property(env, obj, KEY_FLAGS, flags);
247 NapiUtils::SetInt32Property(env, obj, KEY_SCOPE, scope);
248 return obj;
249 }
250
CreateInterfaceUpdateParam(napi_env env,const std::string & ifName)251 napi_value NetInterfaceCallbackObserver::CreateInterfaceUpdateParam(napi_env env,
252 const std::string &ifName)
253 {
254 napi_value obj = NapiUtils::CreateObject(env);
255 if (NapiUtils::GetValueType(env, obj) != napi_object) {
256 return NapiUtils::GetUndefined(env);
257 }
258 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_INTERFACE_NAME, ifName);
259 return obj;
260 }
261
CreateInterfaceChangedParam(napi_env env,const std::string & ifName,bool up)262 napi_value NetInterfaceCallbackObserver::CreateInterfaceChangedParam(napi_env env,
263 const std::string &ifName, bool up)
264 {
265 napi_value obj = NapiUtils::CreateObject(env);
266 if (NapiUtils::GetValueType(env, obj) != napi_object) {
267 return NapiUtils::GetUndefined(env);
268 }
269 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_INTERFACE_NAME, ifName);
270 NapiUtils::SetBooleanProperty(env, obj, KEY_UP, up);
271 return obj;
272 }
273
CreateRouteChangeParam(napi_env env,bool updated,const std::string & route,const std::string & gateway,const std::string & ifName)274 napi_value NetInterfaceCallbackObserver::CreateRouteChangeParam(napi_env env, bool updated,
275 const std::string &route, const std::string &gateway, const std::string &ifName)
276 {
277 napi_value obj = NapiUtils::CreateObject(env);
278 if (NapiUtils::GetValueType(env, obj) != napi_object) {
279 return NapiUtils::GetUndefined(env);
280 }
281 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_INTERFACE_NAME, ifName);
282 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_ROUTE, route);
283 NapiUtils::SetStringPropertyUtf8(env, obj, KEY_GATE_WAY, gateway);
284 NapiUtils::SetBooleanProperty(env, obj, KEY_UPDATED, updated);
285 return obj;
286 }
287 } // namespace OHOS::NetManagerStandard
288