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 "mdns_service.h"
17
18 #include <sys/time.h>
19
20 #include "errorcode_convertor.h"
21 #include "hisysevent.h"
22 #include "netmgr_ext_log_wrapper.h"
23 #include "system_ability_definition.h"
24
25 namespace OHOS {
26 namespace NetManagerStandard {
27
28 namespace {
29 constexpr const char *NET_MDNS_REQUEST_FAULT = "NET_MDNS_REQUEST_FAULT";
30 constexpr const char *NET_MDNS_REQUEST_BEHAVIOR = "NET_MDNS_REQUEST_BEHAVIOR";
31
32 constexpr const char *EVENT_KEY_REQUEST_TYPE = "TYPE";
33 constexpr const char *EVENT_KEY_REQUEST_DATA = "DATA";
34 constexpr const char *EVENT_KEY_ERROR_TYPE = "ERROR_TYPE";
35 constexpr const char *EVENT_KEY_ERROR_MSG = "ERROR_MSG";
36
37 constexpr const char *EVENT_DATA_CALLBACK = "callback";
38
39 using HiSysEvent = OHOS::HiviewDFX::HiSysEvent;
40
41 struct EventInfo {
42 int32_t type = 0;
43 std::string data;
44 int32_t errorType = 0;
45 };
46
SendRequestEvent(const EventInfo & eventInfo)47 void SendRequestEvent(const EventInfo &eventInfo)
48 {
49 static NetBaseErrorCodeConvertor convertor;
50 auto code = eventInfo.errorType;
51 if (code == NETMANAGER_EXT_SUCCESS) {
52 HiSysEventWrite(HiSysEvent::Domain::NETMANAGER_STANDARD, NET_MDNS_REQUEST_BEHAVIOR,
53 HiSysEvent::EventType::BEHAVIOR, EVENT_KEY_REQUEST_TYPE, eventInfo.type, EVENT_KEY_REQUEST_DATA,
54 eventInfo.data);
55 } else {
56 HiSysEventWrite(HiSysEvent::Domain::NETMANAGER_STANDARD, NET_MDNS_REQUEST_FAULT, HiSysEvent::EventType::FAULT,
57 EVENT_KEY_REQUEST_TYPE, eventInfo.type, EVENT_KEY_REQUEST_DATA, eventInfo.data,
58 EVENT_KEY_ERROR_TYPE, eventInfo.errorType, EVENT_KEY_ERROR_MSG,
59 convertor.ConvertErrorCode(code));
60 }
61 }
62
63 } // namespace
64
65 const bool REGISTER_LOCAL_RESULT_MDNS =
66 SystemAbility::MakeAndRegisterAbility(DelayedSingleton<MDnsService>::GetInstance().get());
67
MDnsService()68 MDnsService::MDnsService()
69 : SystemAbility(COMM_MDNS_MANAGER_SYS_ABILITY_ID, true), isRegistered_(false), state_(STATE_STOPPED)
70 {
71 }
72
73 MDnsService::~MDnsService() = default;
74
OnStart()75 void MDnsService::OnStart()
76 {
77 NETMGR_EXT_LOG_D("MDnsService::OnStart begin");
78 if (state_ == STATE_RUNNING) {
79 NETMGR_EXT_LOG_D("MDnsService the state is already running");
80 return;
81 }
82 if (!Init()) {
83 NETMGR_EXT_LOG_E("MDnsService init failed");
84 return;
85 }
86 state_ = STATE_RUNNING;
87 NETMGR_EXT_LOG_D("MDnsService::OnStart end");
88 }
89
OnStop()90 void MDnsService::OnStop()
91 {
92 state_ = STATE_STOPPED;
93 isRegistered_ = false;
94 }
95
Init()96 bool MDnsService::Init()
97 {
98 if (!REGISTER_LOCAL_RESULT_MDNS) {
99 NETMGR_EXT_LOG_E("MDnsService Register to local sa manager failed");
100 return false;
101 }
102 if (!isRegistered_) {
103 if (!Publish(DelayedSingleton<MDnsService>::GetInstance().get())) {
104 NETMGR_EXT_LOG_E("MDnsService Register to sa manager failed");
105 return false;
106 }
107 isRegistered_ = true;
108 }
109 NETMGR_EXT_LOG_D("Init mdns service OK");
110 return true;
111 }
112
RegisterService(const MDnsServiceInfo & serviceInfo,const sptr<IRegistrationCallback> & cb)113 int32_t MDnsService::RegisterService(const MDnsServiceInfo &serviceInfo, const sptr<IRegistrationCallback> &cb)
114 {
115 int32_t err = manager_.RegisterService(serviceInfo, cb);
116 if (err != NETMANAGER_EXT_SUCCESS) {
117 NETMGR_EXT_LOG_E("manager call failed, error code: [%{public}d]", err);
118 }
119 EventInfo eventInfo;
120 eventInfo.type = CMD_REGISTER;
121 eventInfo.data = serviceInfo.name + MDNS_DOMAIN_SPLITER_STR + serviceInfo.type + MDNS_HOSTPORT_SPLITER_STR +
122 std::to_string(serviceInfo.port);
123 eventInfo.errorType = err;
124 SendRequestEvent(eventInfo);
125 return err;
126 }
127
UnRegisterService(const sptr<IRegistrationCallback> & cb)128 int32_t MDnsService::UnRegisterService(const sptr<IRegistrationCallback> &cb)
129 {
130 int32_t err = manager_.UnRegisterService(cb);
131 if (err != NETMANAGER_EXT_SUCCESS) {
132 NETMGR_EXT_LOG_E("manager call failed, error code: [%{public}d]", err);
133 }
134 EventInfo eventInfo;
135 eventInfo.type = CMD_STOP_REGISTER;
136 eventInfo.data = EVENT_DATA_CALLBACK;
137 eventInfo.errorType = err;
138 SendRequestEvent(eventInfo);
139 return err;
140 }
141
StartDiscoverService(const std::string & serviceType,const sptr<IDiscoveryCallback> & cb)142 int32_t MDnsService::StartDiscoverService(const std::string &serviceType, const sptr<IDiscoveryCallback> &cb)
143 {
144 int32_t err = manager_.StartDiscoverService(serviceType, cb);
145 if (err != NETMANAGER_EXT_SUCCESS) {
146 NETMGR_EXT_LOG_E("manager call failed, error code: [%{public}d]", err);
147 }
148 EventInfo eventInfo;
149 eventInfo.type = CMD_DISCOVER;
150 eventInfo.data = serviceType;
151 eventInfo.errorType = err;
152 SendRequestEvent(eventInfo);
153 return err;
154 }
155
StopDiscoverService(const sptr<IDiscoveryCallback> & cb)156 int32_t MDnsService::StopDiscoverService(const sptr<IDiscoveryCallback> &cb)
157 {
158 int32_t err = manager_.StopDiscoverService(cb);
159 if (err != NETMANAGER_EXT_SUCCESS) {
160 NETMGR_EXT_LOG_E("manager call failed, error code: [%{public}d]", err);
161 }
162 EventInfo eventInfo;
163 eventInfo.type = CMD_STOP_DISCOVER;
164 eventInfo.data = EVENT_DATA_CALLBACK;
165 eventInfo.errorType = err;
166 SendRequestEvent(eventInfo);
167 return err;
168 }
169
ResolveService(const MDnsServiceInfo & serviceInfo,const sptr<IResolveCallback> & cb)170 int32_t MDnsService::ResolveService(const MDnsServiceInfo &serviceInfo, const sptr<IResolveCallback> &cb)
171 {
172 int32_t err = manager_.ResolveService(serviceInfo, cb);
173 if (err != NETMANAGER_EXT_SUCCESS) {
174 NETMGR_EXT_LOG_E("manager call failed, error code: [%{public}d]", err);
175 }
176 EventInfo eventInfo;
177 eventInfo.type = CMD_RESOLVE;
178 eventInfo.data = serviceInfo.name + MDNS_DOMAIN_SPLITER_STR + serviceInfo.type;
179 eventInfo.errorType = err;
180 SendRequestEvent(eventInfo);
181 return err;
182 }
183
Dump(int32_t fd,const std::vector<std::u16string> & args)184 int32_t MDnsService::Dump(int32_t fd, const std::vector<std::u16string> &args)
185 {
186 NETMGR_EXT_LOG_D("Start Dump, fd: %{public}d", fd);
187 std::string result;
188 manager_.GetDumpMessage(result);
189 int32_t ret = dprintf(fd, "%s\n", result.c_str());
190 return ret < 0 ? NET_MDNS_ERR_WRITE_DUMP : NETMANAGER_EXT_SUCCESS;
191 }
192
193 } // namespace NetManagerStandard
194 } // namespace OHOS