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,EventManager * manager)50 static void *ParseMDnsDiscoveryParams(napi_env env, size_t argc, napi_value *argv, EventManager *manager)
51 {
52 std::unique_ptr<MDnsDiscoveryInstance, decltype(&MDnsDiscoveryInstance::DeleteMDnsDiscovery)> mdnsDiscover(
53 MDnsDiscoveryInstance::MakeMDnsDiscovery(manager), MDnsDiscoveryInstance::DeleteMDnsDiscovery);
54 if (NapiUtils::GetValueType(env, argv[ARG_NUM_0]) == napi_object &&
55 NapiUtils::GetValueType(env, argv[ARG_NUM_1]) == napi_string) {
56 mdnsDiscover->context_ = GetContextIdString(env, argv[ARG_NUM_0]);
57 mdnsDiscover->serviceType_ = NapiUtils::GetStringFromValueUtf8(env, argv[ARG_NUM_1]);
58 return mdnsDiscover.release();
59 }
60 NETMANAGER_EXT_LOGE("constructor params invalid, should be context + serviceType");
61 return nullptr;
62 }
63
CreateDiscoveryService(napi_env env,napi_callback_info info)64 napi_value MDnsModule::CreateDiscoveryService(napi_env env, napi_callback_info info)
65 {
66 return ModuleTemplate::NewInstance(env, info, FUNCTION_DISCOVERY_SERVICE, ParseMDnsDiscoveryParams,
67 [](napi_env, void *data, void *) {
68 NETMANAGER_BASE_LOGI("finalize DiscoveryService");
69 auto manager = static_cast<EventManager *>(data);
70 auto mdnsDiscover = static_cast<MDnsDiscoveryInstance *>(manager->GetData());
71 delete manager;
72 MDnsDiscoveryInstance::DeleteMDnsDiscovery(mdnsDiscover);
73 });
74 }
75
AddLocalService(napi_env env,napi_callback_info info)76 napi_value MDnsModule::AddLocalService(napi_env env, napi_callback_info info)
77 {
78 return ModuleTemplate::Interface<MDnsAddLocalServiceContext>(env, info, FUNCTION_ADDLOCALSERVICE, nullptr,
79 MDnsAsyncWork::ExecAddLocalService,
80 MDnsAsyncWork::AddLocalServiceCallback);
81 }
82
RemoveLocalService(napi_env env,napi_callback_info info)83 napi_value MDnsModule::RemoveLocalService(napi_env env, napi_callback_info info)
84 {
85 return ModuleTemplate::Interface<MDnsRemoveLocalServiceContext>(env, info, FUNCTION_REMOVELOCALSERVICE, nullptr,
86 MDnsAsyncWork::ExecRemoveLocalService,
87 MDnsAsyncWork::RemoveLocalServiceCallback);
88 }
89
ResolveLocalService(napi_env env,napi_callback_info info)90 napi_value MDnsModule::ResolveLocalService(napi_env env, napi_callback_info info)
91 {
92 return ModuleTemplate::Interface<MDnsResolveLocalServiceContext>(env, info, FUNCTION_RESOLVELOCALSERVICE, nullptr,
93 MDnsAsyncWork::ExecResolveLocalService,
94 MDnsAsyncWork::ResolveLocalServiceCallback);
95 }
96
On(napi_env env,napi_callback_info info)97 napi_value MDnsModule::DiscoveryServiceInterface::On(napi_env env, napi_callback_info info)
98 {
99 std::initializer_list<std::string> events = {EVENT_SERVICESTART, EVENT_SERVICESTOP, EVENT_SERVICEFOUND,
100 EVENT_SERVICELOST};
101 return ModuleTemplate::On(env, info, events, false);
102 }
103
Off(napi_env env,napi_callback_info info)104 napi_value MDnsModule::DiscoveryServiceInterface::Off(napi_env env, napi_callback_info info)
105 {
106 std::initializer_list<std::string> events = {EVENT_SERVICESTART, EVENT_SERVICESTOP, EVENT_SERVICEFOUND,
107 EVENT_SERVICELOST};
108 return ModuleTemplate::Off(env, info, events);
109 }
110
StartSearchingMDNS(napi_env env,napi_callback_info info)111 napi_value MDnsModule::DiscoveryServiceInterface::StartSearchingMDNS(napi_env env, napi_callback_info info)
112 {
113 return ModuleTemplate::Interface<MDnsStartSearchingContext>(
114 env, info, FUNCTION_STARTSEARCHINGMDNS, nullptr,
115 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::ExecStartSearchingMDNS,
116 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::StartSearchingMDNSCallback);
117 }
118
StopSearchingMDNS(napi_env env,napi_callback_info info)119 napi_value MDnsModule::DiscoveryServiceInterface::StopSearchingMDNS(napi_env env, napi_callback_info info)
120 {
121 return ModuleTemplate::Interface<MDnsStopSearchingContext>(
122 env, info, FUNCTION_STOPSEARCHINGMDNS, nullptr,
123 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::ExecStopSearchingMDNS,
124 MDnsAsyncWork::MDnsDiscoverInterfaceAsyncWork::StopSearchingMDNSCallback);
125 }
126
InitMDnsModule(napi_env env,napi_value exports)127 napi_value MDnsModule::InitMDnsModule(napi_env env, napi_value exports)
128 {
129 std::initializer_list<napi_property_descriptor> functions = {
130 DECLARE_NAPI_FUNCTION(FUNCTION_CREATE_DISCOVERY, CreateDiscoveryService),
131 DECLARE_NAPI_FUNCTION(FUNCTION_ADDLOCALSERVICE, AddLocalService),
132 DECLARE_NAPI_FUNCTION(FUNCTION_REMOVELOCALSERVICE, RemoveLocalService),
133 DECLARE_NAPI_FUNCTION(FUNCTION_RESOLVELOCALSERVICE, ResolveLocalService)};
134 NapiUtils::DefineProperties(env, exports, functions);
135
136 std::initializer_list<napi_property_descriptor> MDnsDiscoveryFunctions = {
137 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_ON, DiscoveryServiceInterface::On),
138 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_OFF, DiscoveryServiceInterface::Off),
139 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_STARTSEARCHINGMDNS,
140 DiscoveryServiceInterface::StartSearchingMDNS),
141 DECLARE_NAPI_FUNCTION(DiscoveryServiceInterface::FUNCTION_STOPSEARCHINGMDNS,
142 DiscoveryServiceInterface::StopSearchingMDNS),
143 };
144 ModuleTemplate::DefineClass(env, exports, MDnsDiscoveryFunctions, FUNCTION_DISCOVERY_SERVICE);
145
146 std::initializer_list<napi_property_descriptor> mdnsError = {
147 DECLARE_NAPI_STATIC_PROPERTY(INTERNAL_ERROR_NAME,
148 NapiUtils::CreateUint32(env, static_cast<uint32_t>(MDnsErr::INTERNAL_ERROR))),
149 DECLARE_NAPI_STATIC_PROPERTY(ALREADY_ACTIVE_NAME,
150 NapiUtils::CreateUint32(env, static_cast<uint32_t>(MDnsErr::ALREADY_ACTIVE))),
151 DECLARE_NAPI_STATIC_PROPERTY(MAX_LIMIT_NAME,
152 NapiUtils::CreateUint32(env, static_cast<uint32_t>(MDnsErr::MAX_LIMIT))),
153 };
154 napi_value mdnsErrorValue = NapiUtils::CreateObject(env);
155 NapiUtils::DefineProperties(env, mdnsErrorValue, mdnsError);
156 NapiUtils::SetNamedProperty(env, exports, MDNS_ERR, mdnsErrorValue);
157 return exports;
158 }
159
160 static napi_module g_mdnsModule = {
161 .nm_version = 1,
162 .nm_flags = 0,
163 .nm_filename = nullptr,
164 .nm_register_func = MDnsModule::InitMDnsModule,
165 .nm_modname = MDNS_MODULE_NAME,
166 .nm_priv = nullptr,
167 .reserved = {nullptr},
168 };
169
RegisterMDnsModule(void)170 extern "C" __attribute__((constructor)) void RegisterMDnsModule(void)
171 {
172 napi_module_register(&g_mdnsModule);
173 }
174 } // namespace NetManagerStandard
175 } // namespace OHOS
176