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