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 <cstdint>
17 #include <string_view>
18
19 #include "module_template.h"
20 #include "napi/native_api.h"
21 #include "napi/native_common.h"
22 #include "napi_utils.h"
23 #include "netmanager_ext_log.h"
24
25 #include "constant.h"
26 #include "mdns_addlocalservice_context.h"
27 #include "mdns_async_work.h"
28 #include "mdns_instances.h"
29 #include "mdns_module.h"
30 #include "mdns_removelocalservice_context.h"
31 #include "mdns_resolvelocalservice_context.h"
32 #include "mdns_startsearching_context.h"
33
34 namespace OHOS {
35 namespace NetManagerStandard {
36
37 constexpr const char *MDNS_MODULE_NAME = "net.mdns";
38
GetContextIdString(napi_env env,napi_value obj)39 static std::string GetContextIdString(napi_env env, napi_value obj)
40 {
41 if (NapiUtils::HasNamedProperty(env, obj, CONTEXT_ATTR_APPINFO)) {
42 napi_value info = NapiUtils::GetNamedProperty(env, obj, CONTEXT_ATTR_APPINFO);
43 if (NapiUtils::HasNamedProperty(env, info, APPINFO_ATTR_NAME)) {
44 return NapiUtils::GetStringPropertyUtf8(env, info, APPINFO_ATTR_NAME);
45 }
46 }
47 return std::string();
48 }
49
ParseMDnsDiscoveryParams(napi_env env,size_t argc,napi_value * argv,std::shared_ptr<EventManager> & manager)50 static void *ParseMDnsDiscoveryParams(napi_env env, size_t argc, napi_value *argv,
51 std::shared_ptr<EventManager>& manager)
52 {
53 std::unique_ptr<MDnsDiscoveryInstance, decltype(&MDnsDiscoveryInstance::DeleteMDnsDiscovery)> mdnsDiscover(
54 MDnsDiscoveryInstance::MakeMDnsDiscovery(manager), MDnsDiscoveryInstance::DeleteMDnsDiscovery);
55 if (!mdnsDiscover) {
56 NETMANAGER_EXT_LOGE("mdnsDiscover failed!");
57 return nullptr;
58 }
59 if (NapiUtils::GetValueType(env, argv[ARG_NUM_0]) == napi_object &&
60 NapiUtils::GetValueType(env, argv[ARG_NUM_1]) == napi_string) {
61 mdnsDiscover->context_ = GetContextIdString(env, argv[ARG_NUM_0]);
62 mdnsDiscover->serviceType_ = NapiUtils::GetStringFromValueUtf8(env, argv[ARG_NUM_1]);
63 return mdnsDiscover.release();
64 }
65 NETMANAGER_EXT_LOGE("constructor params invalid, should be context + serviceType");
66 return nullptr;
67 }
68
CreateDiscoveryService(napi_env env,napi_callback_info info)69 napi_value MDnsModule::CreateDiscoveryService(napi_env env, napi_callback_info info)
70 {
71 return ModuleTemplate::NewInstance(env, info, FUNCTION_DISCOVERY_SERVICE, ParseMDnsDiscoveryParams,
72 [](napi_env, void *data, void *) {
73 NETMANAGER_BASE_LOGI("finalize DiscoveryService");
74 auto sharedManager = static_cast<std::shared_ptr<EventManager> *>(data);
75 if (sharedManager == nullptr || *sharedManager == nullptr) {
76 return;
77 }
78 auto manager = *sharedManager;
79 auto mdnsDiscover = static_cast<MDnsDiscoveryInstance *>(manager->GetData());
80 delete sharedManager;
81 MDnsDiscoveryInstance::DeleteMDnsDiscovery(mdnsDiscover);
82 });
83 }
84
AddLocalService(napi_env env,napi_callback_info info)85 napi_value MDnsModule::AddLocalService(napi_env env, napi_callback_info info)
86 {
87 return ModuleTemplate::Interface<MDnsAddLocalServiceContext>(env, info, FUNCTION_ADDLOCALSERVICE, nullptr,
88 MDnsAsyncWork::ExecAddLocalService,
89 MDnsAsyncWork::AddLocalServiceCallback);
90 }
91
RemoveLocalService(napi_env env,napi_callback_info info)92 napi_value MDnsModule::RemoveLocalService(napi_env env, napi_callback_info info)
93 {
94 return ModuleTemplate::Interface<MDnsRemoveLocalServiceContext>(env, info, FUNCTION_REMOVELOCALSERVICE, nullptr,
95 MDnsAsyncWork::ExecRemoveLocalService,
96 MDnsAsyncWork::RemoveLocalServiceCallback);
97 }
98
ResolveLocalService(napi_env env,napi_callback_info info)99 napi_value MDnsModule::ResolveLocalService(napi_env env, napi_callback_info info)
100 {
101 return ModuleTemplate::Interface<MDnsResolveLocalServiceContext>(env, info, FUNCTION_RESOLVELOCALSERVICE, nullptr,
102 MDnsAsyncWork::ExecResolveLocalService,
103 MDnsAsyncWork::ResolveLocalServiceCallback);
104 }
105
On(napi_env env,napi_callback_info info)106 napi_value MDnsModule::DiscoveryServiceInterface::On(napi_env env, napi_callback_info info)
107 {
108 std::initializer_list<std::string> events = {EVENT_SERVICESTART, EVENT_SERVICESTOP, EVENT_SERVICEFOUND,
109 EVENT_SERVICELOST};
110 return ModuleTemplate::On(env, info, events, false);
111 }
112
Off(napi_env env,napi_callback_info info)113 napi_value MDnsModule::DiscoveryServiceInterface::Off(napi_env env, napi_callback_info info)
114 {
115 std::initializer_list<std::string> events = {EVENT_SERVICESTART, EVENT_SERVICESTOP, EVENT_SERVICEFOUND,
116 EVENT_SERVICELOST};
117 return ModuleTemplate::Off(env, info, events);
118 }
119
StartSearchingMDNS(napi_env env,napi_callback_info info)120 napi_value MDnsModule::DiscoveryServiceInterface::StartSearchingMDNS(napi_env env, napi_callback_info info)
121 {
122 return ModuleTemplate::Interface<MDnsStartSearchingContext>(
123 env, info, FUNCTION_STARTSEARCHINGMDNS, nullptr,
124 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::ExecStartSearchingMDNS,
125 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::StartSearchingMDNSCallback);
126 }
127
StopSearchingMDNS(napi_env env,napi_callback_info info)128 napi_value MDnsModule::DiscoveryServiceInterface::StopSearchingMDNS(napi_env env, napi_callback_info info)
129 {
130 return ModuleTemplate::Interface<MDnsStopSearchingContext>(
131 env, info, FUNCTION_STOPSEARCHINGMDNS, nullptr,
132 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::ExecStopSearchingMDNS,
133 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::StopSearchingMDNSCallback);
134 }
135
InitMDnsModule(napi_env env,napi_value exports)136 napi_value MDnsModule::InitMDnsModule(napi_env env, napi_value exports)
137 {
138 std::initializer_list<napi_property_descriptor> functions = {
139 DECLARE_NAPI_FUNCTION(FUNCTION_CREATE_DISCOVERY, CreateDiscoveryService),
140 DECLARE_NAPI_FUNCTION(FUNCTION_ADDLOCALSERVICE, AddLocalService),
141 DECLARE_NAPI_FUNCTION(FUNCTION_REMOVELOCALSERVICE, RemoveLocalService),
142 DECLARE_NAPI_FUNCTION(FUNCTION_RESOLVELOCALSERVICE, ResolveLocalService)};
143 NapiUtils::DefineProperties(env, exports, functions);
144
145 std::initializer_list<napi_property_descriptor> MDnsDiscoveryFunctions = {
146 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_ON, DiscoveryServiceInterface::On),
147 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_OFF, DiscoveryServiceInterface::Off),
148 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_STARTSEARCHINGMDNS,
149 DiscoveryServiceInterface::StartSearchingMDNS),
150 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_STOPSEARCHINGMDNS,
151 DiscoveryServiceInterface::StopSearchingMDNS),
152 };
153 ModuleTemplate::DefineClass(env, exports, MDnsDiscoveryFunctions, FUNCTION_DISCOVERY_SERVICE);
154
155 std::initializer_list<napi_property_descriptor> mdnsError = {
156 DECLARE_NAPI_STATIC_PROPERTY(INTERNAL_ERROR_NAME,
157 NapiUtils::CreateUint32(env, static_cast<uint32_t>(MDnsErr::INTERNAL_ERROR))),
158 DECLARE_NAPI_STATIC_PROPERTY(ALREADY_ACTIVE_NAME,
159 NapiUtils::CreateUint32(env, static_cast<uint32_t>(MDnsErr::ALREADY_ACTIVE))),
160 DECLARE_NAPI_STATIC_PROPERTY(MAX_LIMIT_NAME,
161 NapiUtils::CreateUint32(env, static_cast<uint32_t>(MDnsErr::MAX_LIMIT))),
162 };
163 napi_value mdnsErrorValue = NapiUtils::CreateObject(env);
164 NapiUtils::DefineProperties(env, mdnsErrorValue, mdnsError);
165 NapiUtils::SetNamedProperty(env, exports, MDNS_ERR, mdnsErrorValue);
166 NapiUtils::SetEnvValid(env);
167 napi_add_env_cleanup_hook(env, NapiUtils::HookForEnvCleanup, env);
168 return exports;
169 }
170
171 static napi_module g_mdnsModule = {
172 .nm_version = 1,
173 .nm_flags = 0,
174 .nm_filename = nullptr,
175 .nm_register_func = MDnsModule::InitMDnsModule,
176 .nm_modname = MDNS_MODULE_NAME,
177 .nm_priv = nullptr,
178 .reserved = {nullptr},
179 };
180
RegisterMDnsModule(void)181 extern "C" __attribute__((constructor)) void RegisterMDnsModule(void)
182 {
183 napi_module_register(&g_mdnsModule);
184 }
185 } // namespace NetManagerStandard
186 } // namespace OHOS
187