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 "napi_utils.h"
17 #include "net_manager_constants.h"
18 #include "netmanager_ext_log.h"
19
20 #include "constant.h"
21 #include "mdns_client.h"
22 #include "mdns_exec.h"
23 #include "mdns_instances.h"
24
25 namespace OHOS {
26 namespace NetManagerStandard {
27
ExecAddLocalService(MDnsAddLocalServiceContext * context)28 bool MDnsExec::ExecAddLocalService(MDnsAddLocalServiceContext *context)
29 {
30 auto ret =
31 DelayedSingleton<MDnsClient>::GetInstance()->RegisterService(context->GetServiceInfo(), context->GetObserver());
32 if (ret != NETMANAGER_EXT_SUCCESS) {
33 context->SetErrorCode(ret);
34 NETMANAGER_EXT_LOGE("RegisterService error, errorCode: %{public}d", ret);
35 return false;
36 }
37 return ret == NETMANAGER_EXT_SUCCESS;
38 }
39
ExecRemoveLocalService(MDnsRemoveLocalServiceContext * context)40 bool MDnsExec::ExecRemoveLocalService(MDnsRemoveLocalServiceContext *context)
41 {
42 sptr<IRegistrationCallback> callback = context->GetObserver();
43 auto ret = DelayedSingleton<MDnsClient>::GetInstance()->UnRegisterService(callback);
44 if (ret != NETMANAGER_EXT_SUCCESS) {
45 context->SetErrorCode(ret);
46 NETMANAGER_EXT_LOGE("UnRegisterService error, errorCode: %{public}d", ret);
47 return false;
48 }
49 return ret == NETMANAGER_EXT_SUCCESS;
50 }
51
ExecResolveLocalService(MDnsResolveLocalServiceContext * context)52 bool MDnsExec::ExecResolveLocalService(MDnsResolveLocalServiceContext *context)
53 {
54 auto ret =
55 DelayedSingleton<MDnsClient>::GetInstance()->ResolveService(context->GetServiceInfo(), context->GetObserver());
56 if (ret != NETMANAGER_EXT_SUCCESS) {
57 context->SetErrorCode(ret);
58 NETMANAGER_EXT_LOGE("ResolveService error, errorCode: %{public}d", ret);
59 return false;
60 }
61
62 sptr<IResolveCallback> callback = context->GetObserver();
63 MDnsResolveObserver *observer = static_cast<MDnsResolveObserver *>(callback.GetRefPtr());
64 if (observer == nullptr) {
65 context->SetErrorCode(NET_MDNS_ERR_UNKNOWN);
66 return false;
67 }
68
69 std::unique_lock<std::mutex> lk(observer->mutex_);
70 if (!observer->cv_.wait_for(lk, std::chrono::seconds(SYNC_TIMEOUT), [=]() { return observer->resolved_; })) {
71 context->SetErrorCode(NET_MDNS_ERR_TIMEOUT);
72 return false;
73 }
74
75 context->SetServiceInfo(observer->serviceInfo_);
76 if (observer->retCode_ != NETMANAGER_EXT_SUCCESS) {
77 context->SetErrorCode(observer->retCode_);
78 NETMANAGER_EXT_LOGE("HandleResolveResult error, errorCode: %{public}d", ret);
79 return false;
80 }
81 return observer->retCode_ == NETMANAGER_EXT_SUCCESS;
82 }
83
ExecStartSearchingMDNS(MDnsStartSearchingContext * context)84 bool MDnsExec::ExecStartSearchingMDNS(MDnsStartSearchingContext *context)
85 {
86 auto discover = context->GetDiscover();
87 auto ret =
88 DelayedSingleton<MDnsClient>::GetInstance()->StartDiscoverService(discover.serviceType_, discover.observer_);
89 if (ret != NETMANAGER_EXT_SUCCESS) {
90 context->SetErrorCode(ret);
91 NETMANAGER_EXT_LOGE("StartDiscoverService error, errorCode: %{public}d", ret);
92 }
93 MDnsServiceInfo info;
94 info.type = discover.serviceType_;
95 auto wObserver = context->GetObserver();
96 sptr<MDnsDiscoveryObserver> observer = wObserver.promote();
97 if (observer == nullptr) {
98 NETMANAGER_EXT_LOGE("ExecStartSearchingMDNS GetObserver nullptr");
99 return false;
100 }
101 observer->EmitStartDiscover(info, ret);
102 return ret == NETMANAGER_EXT_SUCCESS;
103 }
104
ExecStopSearchingMDNS(MDnsStopSearchingContext * context)105 bool MDnsExec::ExecStopSearchingMDNS(MDnsStopSearchingContext *context)
106 {
107 auto discover = context->GetDiscover();
108 auto ret = DelayedSingleton<MDnsClient>::GetInstance()->StopDiscoverService(discover.observer_);
109 if (ret != NETMANAGER_EXT_SUCCESS) {
110 context->SetErrorCode(ret);
111 NETMANAGER_EXT_LOGE("StopDiscoverService error, errorCode: %{public}d", ret);
112 }
113 MDnsServiceInfo info;
114 info.type = discover.serviceType_;
115 auto wObserver = context->GetObserver();
116 sptr<MDnsDiscoveryObserver> observer = wObserver.promote();
117 if (observer == nullptr) {
118 NETMANAGER_EXT_LOGE("ExecStopSearchingMDNS GetObserver nullptr");
119 return false;
120 }
121 observer->EmitStopDiscover(info, ret);
122 return ret == NETMANAGER_EXT_SUCCESS;
123 }
124
CreateAttributeObj(napi_env env,MDnsServiceInfo serviceInfo)125 napi_value CreateAttributeObj(napi_env env, MDnsServiceInfo serviceInfo)
126 {
127 TxtRecord attrMap = serviceInfo.GetAttrMap();
128 auto attrArrSize = attrMap.size();
129 size_t index = 0;
130 auto iter = attrMap.begin();
131 napi_value attrArr = NapiUtils::CreateArray(env, attrArrSize);
132 for (; iter != attrMap.end(); iter++, index++) {
133 napi_value attrItem = NapiUtils::CreateObject(env);
134 NapiUtils::SetStringPropertyUtf8(env, attrItem, SERVICEINFO_ATTR_KEY, iter->first);
135 auto valArrSize = iter->second.size();
136 napi_value valArr = NapiUtils::CreateArray(env, valArrSize);
137 auto setIter = iter->second.begin();
138 size_t setIndex = 0;
139 for (; setIter != iter->second.end(); setIter++, setIndex++) {
140 NapiUtils::SetArrayElement(env, valArr, setIndex, NapiUtils::CreateUint32(env, *setIter));
141 }
142 NapiUtils::SetNamedProperty(env, attrItem, SERVICEINFO_ATTR_VALUE, valArr);
143 NapiUtils::SetArrayElement(env, attrArr, index, attrItem);
144 }
145 return attrArr;
146 }
147
CreateCallbackParam(T * context)148 template <class T> napi_value CreateCallbackParam(T *context)
149 {
150 napi_env env = context->GetEnv();
151 MDnsServiceInfo serviceInfo = context->GetServiceInfo();
152 NETMANAGER_EXT_LOGI("CreateCallbackParam [%{public}s][%{public}d]",
153 serviceInfo.type.c_str(), serviceInfo.port);
154
155 napi_value object = NapiUtils::CreateObject(env);
156 NapiUtils::SetStringPropertyUtf8(env, object, SERVICEINFO_TYPE, serviceInfo.type);
157 NapiUtils::SetStringPropertyUtf8(env, object, SERVICEINFO_NAME, serviceInfo.name);
158 NapiUtils::SetInt32Property(env, object, SERVICEINFO_PORT, serviceInfo.port);
159
160 napi_value eleObj = NapiUtils::CreateObject(env);
161 NapiUtils::SetStringPropertyUtf8(env, eleObj, SERVICEINFO_ADDRESS, serviceInfo.addr);
162 NapiUtils::SetInt32Property(env, eleObj, SERVICEINFO_PORT, serviceInfo.port);
163 int32_t family = serviceInfo.family == MDnsServiceInfo::IPV6 ? 0 : 1;
164 NapiUtils::SetInt32Property(env, eleObj, SERVICEINFO_FAMILY, family);
165
166 napi_value attrArrObj = CreateAttributeObj(env, serviceInfo);
167
168 NapiUtils::SetNamedProperty(env, object, SERVICEINFO_HOST, eleObj);
169 NapiUtils::SetNamedProperty(env, object, SERVICEINFO_ATTR, attrArrObj);
170 return object;
171 }
172
AddLocalServiceCallback(MDnsAddLocalServiceContext * context)173 napi_value MDnsExec::AddLocalServiceCallback(MDnsAddLocalServiceContext *context)
174 {
175 return CreateCallbackParam<MDnsAddLocalServiceContext>(context);
176 }
177
RemoveLocalServiceCallback(MDnsRemoveLocalServiceContext * context)178 napi_value MDnsExec::RemoveLocalServiceCallback(MDnsRemoveLocalServiceContext *context)
179 {
180 return CreateCallbackParam<MDnsRemoveLocalServiceContext>(context);
181 }
182
ResolveLocalServiceCallback(MDnsResolveLocalServiceContext * context)183 napi_value MDnsExec::ResolveLocalServiceCallback(MDnsResolveLocalServiceContext *context)
184 {
185 return CreateCallbackParam<MDnsResolveLocalServiceContext>(context);
186 }
187
StartSearchingMDNSCallback(MDnsStartSearchingContext * context)188 napi_value MDnsExec::StartSearchingMDNSCallback(MDnsStartSearchingContext *context)
189 {
190 return NapiUtils::GetUndefined(context->GetEnv());
191 }
192
StopSearchingMDNSCallback(MDnsStopSearchingContext * context)193 napi_value MDnsExec::StopSearchingMDNSCallback(MDnsStopSearchingContext *context)
194 {
195 return NapiUtils::GetUndefined(context->GetEnv());
196 }
197 } // namespace NetManagerStandard
198 } // namespace OHOS
199