1 /*
2 * Copyright (c) 2021 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 "lnn_coap_discovery_impl.h"
17
18 #include <securec.h>
19 #include <unistd.h>
20
21 #include "anonymizer.h"
22 #include "auth_interface.h"
23 #include "bus_center_manager.h"
24 #include "lnn_log.h"
25 #include "softbus_adapter_crypto.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_def.h"
28 #include "softbus_error_code.h"
29 #include "softbus_utils.h"
30
31 #define LNN_DISC_CAPABILITY "ddmpCapability"
32 #define LNN_SUBSCRIBE_ID 0
33 #define LNN_PUBLISH_ID 0
34
35 #define LNN_SHORT_HASH_LEN 8
36 #define LNN_SHORT_HASH_HEX_LEN 16
37 #define TYPE_PRINTER 0x09
38
39 static LnnDiscoveryImplCallback g_callback;
40
41 static void DeviceFound(const DeviceInfo *device, const InnerDeviceInfoAddtions *additions);
42
43 static DiscInnerCallback g_discCb = {
44 .OnDeviceFound = DeviceFound,
45 };
46
LnnCheckDiscoveryDeviceInfo(const DeviceInfo * device)47 static int32_t LnnCheckDiscoveryDeviceInfo(const DeviceInfo *device)
48 {
49 if (device->addr[0].type != CONNECTION_ADDR_WLAN && device->addr[0].type != CONNECTION_ADDR_ETH) {
50 LNN_LOGE(LNN_BUILDER, "discovery get invalid addrType=%{public}d", device->addr[0].type);
51 return SOFTBUS_INVALID_PARAM;
52 }
53 if (device->addr[0].info.ip.port == 0) {
54 LNN_LOGD(LNN_BUILDER, "discovery get port is 0!");
55 LnnCoapConnect(device->addr[0].info.ip.ip);
56 return SOFTBUS_INVALID_PARAM;
57 }
58 return SOFTBUS_OK;
59 }
60
GetConnectDeviceInfo(const DeviceInfo * device,ConnectionAddr * addr)61 static int32_t GetConnectDeviceInfo(const DeviceInfo *device, ConnectionAddr *addr)
62 {
63 addr->type = device->addr[0].type;
64 if (strcpy_s(addr->info.ip.ip, IP_STR_MAX_LEN, device->addr[0].info.ip.ip) != EOK) {
65 LNN_LOGE(LNN_BUILDER, "strcpy ip failed");
66 return SOFTBUS_STRCPY_ERR;
67 }
68 if (strcpy_s((char *)addr->info.ip.udidHash, UDID_HASH_LEN, device->devId) != EOK) {
69 LNN_LOGE(LNN_BUILDER, "strcpy udidHash failed");
70 return SOFTBUS_STRCPY_ERR;
71 }
72 addr->info.ip.port = device->addr[0].info.ip.port;
73 if (memcpy_s(addr->peerUid, MAX_ACCOUNT_HASH_LEN, device->accountHash, MAX_ACCOUNT_HASH_LEN) != EOK) {
74 LNN_LOGE(LNN_BUILDER, "memcpy_s peer uid failed");
75 return SOFTBUS_MEM_ERR;
76 }
77 return SOFTBUS_OK;
78 }
79
DeviceFound(const DeviceInfo * device,const InnerDeviceInfoAddtions * additions)80 static void DeviceFound(const DeviceInfo *device, const InnerDeviceInfoAddtions *additions)
81 {
82 ConnectionAddr addr;
83 (void) additions;
84
85 if (device == NULL) {
86 LNN_LOGE(LNN_BUILDER, "device para is null");
87 return;
88 }
89 (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
90 char *anonyDevId = NULL;
91 Anonymize(device->devId, &anonyDevId);
92 char *anonyDevName = NULL;
93 Anonymize(device->devName, &anonyDevName);
94 // devId format is hex hash string here
95 LNN_LOGI(LNN_BUILDER, "DeviceFound devName=%{public}s, devId=%{public}s, devType=%{public}03X, port=%{public}u",
96 AnonymizeWrapper(anonyDevName), AnonymizeWrapper(anonyDevId), device->devType, device->addr[0].info.ip.port);
97 AnonymizeFree(anonyDevName);
98 if (!AuthIsPotentialTrusted(device)) {
99 LNN_LOGW(LNN_BUILDER, "discovery device is not potential trusted, devId=%{public}s, "
100 "accountHash=%{public}02X%{public}02X", AnonymizeWrapper(anonyDevId),
101 device->accountHash[0], device->accountHash[1]);
102 AnonymizeFree(anonyDevId);
103 return;
104 }
105 AnonymizeFree(anonyDevId);
106 if (LnnCheckDiscoveryDeviceInfo(device) != SOFTBUS_OK) {
107 LNN_LOGE(LNN_BUILDER, "get invalid device para");
108 return;
109 }
110 if (GetConnectDeviceInfo(device, &addr) != SOFTBUS_OK) {
111 LNN_LOGE(LNN_BUILDER, "get connect device info fail");
112 return;
113 }
114 LnnDfxDeviceInfoReport info;
115 (void)memset_s(&info, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
116 info.type = device->devType;
117 if ((uint32_t)info.type == TYPE_PRINTER) {
118 LNN_LOGI(LNN_BUILDER, "restrict printer");
119 return;
120 }
121 if (g_callback.onDeviceFound) {
122 g_callback.onDeviceFound(&addr, &info);
123 }
124 }
125
LnnStartCoapPublish(void)126 int32_t LnnStartCoapPublish(void)
127 {
128 PublishInfo publishInfo = {
129 .publishId = LNN_PUBLISH_ID,
130 .mode = DISCOVER_MODE_PASSIVE,
131 .medium = COAP,
132 .freq = HIGH,
133 .capability = LNN_DISC_CAPABILITY,
134 .capabilityData = (unsigned char *)LNN_DISC_CAPABILITY,
135 .dataLen = strlen(LNN_DISC_CAPABILITY),
136 };
137 LNN_LOGD(LNN_BUILDER, "lnn start coap publish");
138 int32_t pid = getpid();
139 return LnnPublishService(NULL, &publishInfo, true, pid);
140 }
141
LnnStopCoapPublish(void)142 int32_t LnnStopCoapPublish(void)
143 {
144 LNN_LOGD(LNN_BUILDER, "lnn stop coap publish");
145 int32_t pid = getpid();
146 return LnnUnPublishService(NULL, LNN_PUBLISH_ID, true, pid);
147 }
148
LnnStopCoapDiscovery(void)149 int32_t LnnStopCoapDiscovery(void)
150 {
151 int32_t pid = getpid();
152 return LnnStopDiscDevice(NULL, LNN_SUBSCRIBE_ID, true, pid);
153 }
154
LnnStartCoapDiscovery(void)155 int32_t LnnStartCoapDiscovery(void)
156 {
157 SubscribeInfo subscribeInfo = {
158 .subscribeId = LNN_SUBSCRIBE_ID,
159 .mode = DISCOVER_MODE_ACTIVE,
160 .medium = COAP,
161 .freq = HIGH,
162 .isSameAccount = false,
163 .isWakeRemote = false,
164 .capability = LNN_DISC_CAPABILITY,
165 .capabilityData = (unsigned char *)LNN_DISC_CAPABILITY,
166 .dataLen = strlen(LNN_DISC_CAPABILITY),
167 };
168 InnerCallback callback = {
169 .innerCb = g_discCb,
170 };
171 LnnDestroyCoapConnectList();
172 int32_t pid = getpid();
173 return LnnStartDiscDevice(NULL, &subscribeInfo, &callback, true, pid);
174 }
175
LnnInitCoapDiscovery(LnnDiscoveryImplCallback * callback)176 int32_t LnnInitCoapDiscovery(LnnDiscoveryImplCallback *callback)
177 {
178 if (callback == NULL) {
179 LNN_LOGE(LNN_BUILDER, "coap discovery callback is null");
180 return SOFTBUS_INVALID_PARAM;
181 }
182 g_callback.onDeviceFound = callback->onDeviceFound;
183 return SOFTBUS_OK;
184 }
185