1 /*
2  * Copyright (c) 2021-2024 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 "trans_auth_manager.h"
17 
18 #include "auth_channel.h"
19 #include "auth_meta_manager.h"
20 #include "bus_center_manager.h"
21 #include "common_list.h"
22 #include "lnn_connection_addr_utils.h"
23 #include "lnn_net_builder.h"
24 #include "securec.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_adapter_thread.h"
27 #include "softbus_def.h"
28 #include "softbus_errcode.h"
29 #include "softbus_feature_config.h"
30 #include "softbus_hisysevt_transreporter.h"
31 #include "softbus_utils.h"
32 #include "trans_auth_message.h"
33 #include "trans_channel_common.h"
34 #include "trans_channel_limit.h"
35 #include "trans_event.h"
36 #include "trans_session_manager.h"
37 #include "trans_channel_manager.h"
38 #include "trans_log.h"
39 #include "trans_lane_manager.h"
40 #include "wifi_direct_manager.h"
41 
42 #define AUTH_CHANNEL_REQ 0
43 #define AUTH_CHANNEL_REPLY 1
44 
45 #define IPV4_TYPE 1
46 #define IPV6_TYPE 2
47 
48 #define AUTH_GROUP_ID "auth group id"
49 #define AUTH_SESSION_KEY "auth session key"
50 #define ISHARE_AUTH_SESSION "IShareAuthSession"
51 
52 const char *g_serviceForAction[] = {
53     "IShareAuthSession",
54 };
55 
56 #define SERVICE_FOR_ACTION_LEN (sizeof(g_serviceForAction) / sizeof(g_serviceForAction[0]))
57 
58 typedef struct {
59     int32_t channelType;
60     int32_t businessType;
61     ConfigType configType;
62 } ConfigTypeMap;
63 
64 static SoftBusList *g_authChannelList = NULL;
65 static IServerChannelCallBack *g_cb = NULL;
66 
67 static void TransPostAuthChannelErrMsg(int32_t authId, int32_t errcode, const char *errMsg);
68 static int32_t TransPostAuthChannelMsg(const AppInfo *appInfo, int32_t authId, int32_t flag);
69 static AuthChannelInfo *CreateAuthChannelInfo(const char *sessionName, bool isClient);
70 static int32_t AddAuthChannelInfo(AuthChannelInfo *info);
71 static void DelAuthChannelInfoByChanId(int32_t channelId);
72 static void DelAuthChannelInfoByAuthId(int32_t authId);
73 
GetAuthChannelListHead(void)74 SoftBusList *GetAuthChannelListHead(void)
75 {
76     return g_authChannelList;
77 }
78 
GetAuthChannelLock(void)79 int32_t GetAuthChannelLock(void)
80 {
81     if (g_authChannelList == NULL) {
82         TRANS_LOGE(TRANS_SVC, "g_authChannelList not init");
83         return SOFTBUS_NO_INIT;
84     }
85     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
86         TRANS_LOGE(TRANS_SVC, "lock failed");
87         return SOFTBUS_LOCK_ERR;
88     }
89     return SOFTBUS_OK;
90 }
91 
ReleaseAuthChannelLock(void)92 void ReleaseAuthChannelLock(void)
93 {
94     if (g_authChannelList == NULL) {
95         TRANS_LOGE(TRANS_SVC, "g_authChannelList not init");
96         return;
97     }
98     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
99 }
100 
GetAuthChannelInfoByChanId(int32_t channelId,AuthChannelInfo * dstInfo)101 static int32_t GetAuthChannelInfoByChanId(int32_t channelId, AuthChannelInfo *dstInfo)
102 {
103     if (g_authChannelList == NULL) {
104         TRANS_LOGE(TRANS_SVC, "invalid param");
105         return SOFTBUS_INVALID_PARAM;
106     }
107 
108     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
109         TRANS_LOGE(TRANS_SVC, "lock failed");
110         return SOFTBUS_LOCK_ERR;
111     }
112     AuthChannelInfo *info = NULL;
113     LIST_FOR_EACH_ENTRY(info, &g_authChannelList->list, AuthChannelInfo, node) {
114         if (info->appInfo.myData.channelId == channelId) {
115             if (memcpy_s(dstInfo, sizeof(AuthChannelInfo), info, sizeof(AuthChannelInfo)) != EOK) {
116                 TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
117                 (void)SoftBusMutexUnlock(&g_authChannelList->lock);
118                 return SOFTBUS_MEM_ERR;
119             }
120             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
121             return SOFTBUS_OK;
122         }
123     }
124     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
125     return SOFTBUS_TRANS_NODE_NOT_FOUND;
126 }
127 
GetAuthIdByChannelId(int32_t channelId)128 static int32_t GetAuthIdByChannelId(int32_t channelId)
129 {
130     if (g_authChannelList == NULL) {
131         return SOFTBUS_NO_INIT;
132     }
133 
134     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
135         TRANS_LOGE(TRANS_SVC, "lock failed");
136         return SOFTBUS_LOCK_ERR;
137     }
138     int32_t authId = AUTH_INVALID_ID;
139     AuthChannelInfo *info = NULL;
140     LIST_FOR_EACH_ENTRY(info, &g_authChannelList->list, AuthChannelInfo, node) {
141         if (info->appInfo.myData.channelId == channelId) {
142             authId = info->authId;
143             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
144             return authId;
145         }
146     }
147     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
148     return authId;
149 }
150 
GetChannelInfoByAuthId(int32_t authId,AuthChannelInfo * dstInfo)151 static int32_t GetChannelInfoByAuthId(int32_t authId, AuthChannelInfo *dstInfo)
152 {
153     if (dstInfo == NULL || g_authChannelList == NULL) {
154         return SOFTBUS_INVALID_PARAM;
155     }
156 
157     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
158         TRANS_LOGE(TRANS_SVC, "lock failed");
159         return SOFTBUS_LOCK_ERR;
160     }
161     AuthChannelInfo *info = NULL;
162     LIST_FOR_EACH_ENTRY(info, &g_authChannelList->list, AuthChannelInfo, node) {
163         if (info->authId == authId) {
164             if (memcpy_s(dstInfo, sizeof(AuthChannelInfo), info, sizeof(AuthChannelInfo)) != EOK) {
165                 (void)SoftBusMutexUnlock(&g_authChannelList->lock);
166                 return SOFTBUS_MEM_ERR;
167             }
168             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
169             return SOFTBUS_OK;
170         }
171     }
172     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
173     return SOFTBUS_TRANS_NODE_NOT_FOUND;
174 }
175 
NotifyOpenAuthChannelSuccess(const AppInfo * appInfo,bool isServer)176 static int32_t NotifyOpenAuthChannelSuccess(const AppInfo *appInfo, bool isServer)
177 {
178     ChannelInfo channelInfo = {0};
179     channelInfo.channelType = CHANNEL_TYPE_AUTH;
180     channelInfo.isServer = isServer;
181     channelInfo.isEnabled = true;
182     channelInfo.channelId = appInfo->myData.channelId;
183     channelInfo.peerDeviceId = strlen(appInfo->peerNetWorkId) == 0 ?
184         (char *)appInfo->peerData.deviceId : (char *)appInfo->peerNetWorkId;
185     channelInfo.peerSessionName = (char *)appInfo->peerData.sessionName;
186     channelInfo.businessType = BUSINESS_TYPE_NOT_CARE;
187     channelInfo.groupId = (char *)AUTH_GROUP_ID;
188     channelInfo.isEncrypt = false;
189     channelInfo.sessionKey = (char *)AUTH_SESSION_KEY;
190     channelInfo.keyLen = strlen(channelInfo.sessionKey) + 1;
191     channelInfo.autoCloseTime = appInfo->autoCloseTime;
192     channelInfo.reqId = (char *)appInfo->reqId;
193     channelInfo.dataConfig = appInfo->myData.dataConfig;
194     channelInfo.timeStart = appInfo->timeStart;
195     channelInfo.connectType = appInfo->connectType;
196     channelInfo.routeType = appInfo->routeType;
197     channelInfo.osType = appInfo->osType;
198     return g_cb->OnChannelOpened(appInfo->myData.pkgName, appInfo->myData.pid,
199         appInfo->myData.sessionName, &channelInfo);
200 }
201 
NotifyOpenAuthChannelFailed(const char * pkgName,int32_t pid,int32_t channelId,int32_t errCode)202 int32_t NotifyOpenAuthChannelFailed(const char *pkgName, int32_t pid, int32_t channelId, int32_t errCode)
203 {
204     return g_cb->OnChannelOpenFailed(pkgName, pid, channelId, CHANNEL_TYPE_AUTH, errCode);
205 }
206 
NofifyCloseAuthChannel(const char * pkgName,int32_t pid,int32_t channelId)207 static int32_t NofifyCloseAuthChannel(const char *pkgName, int32_t pid, int32_t channelId)
208 {
209     return g_cb->OnChannelClosed(pkgName, pid, channelId, CHANNEL_TYPE_AUTH, MESSAGE_TYPE_NOMAL);
210 }
211 
AuthGetUidAndPidBySessionName(const char * sessionName,int32_t * uid,int32_t * pid)212 static int32_t AuthGetUidAndPidBySessionName(const char *sessionName, int32_t *uid, int32_t *pid)
213 {
214     return g_cb->GetUidAndPidBySessionName(sessionName, uid, pid);
215 }
216 
NotifyOnDataReceived(int32_t authId,const void * data,uint32_t len)217 static int32_t NotifyOnDataReceived(int32_t authId, const void *data, uint32_t len)
218 {
219     AuthChannelInfo channel;
220     int32_t ret = GetChannelInfoByAuthId(authId, &channel);
221     if (ret != SOFTBUS_OK) {
222         TRANS_LOGE(TRANS_SVC, "GetChannelInfoByAuthId failed");
223         return ret;
224     }
225     TransReceiveData receiveData;
226     receiveData.data = (void *)data;
227     receiveData.dataLen = len;
228     receiveData.dataType = TRANS_SESSION_BYTES;
229 
230     return g_cb->OnDataReceived(channel.appInfo.myData.pkgName, channel.appInfo.myData.pid,
231         channel.appInfo.myData.channelId, CHANNEL_TYPE_AUTH, &receiveData);
232 }
233 
CopyPeerAppInfo(AppInfo * recvAppInfo,AppInfo * channelAppInfo)234 static int32_t CopyPeerAppInfo(AppInfo *recvAppInfo, AppInfo *channelAppInfo)
235 {
236     if (memcpy_s(channelAppInfo->peerData.deviceId, DEVICE_ID_SIZE_MAX,
237                  recvAppInfo->peerData.deviceId, DEVICE_ID_SIZE_MAX) != EOK ||
238         memcpy_s(recvAppInfo->myData.deviceId, DEVICE_ID_SIZE_MAX,
239                  channelAppInfo->myData.deviceId, DEVICE_ID_SIZE_MAX) != EOK ||
240         memcpy_s(channelAppInfo->peerData.pkgName, PKG_NAME_SIZE_MAX,
241                  recvAppInfo->peerData.pkgName, PKG_NAME_SIZE_MAX) != EOK ||
242         memcpy_s(recvAppInfo->myData.pkgName, PKG_NAME_SIZE_MAX,
243                  channelAppInfo->myData.pkgName, PKG_NAME_SIZE_MAX) != EOK ||
244         memcpy_s(channelAppInfo->peerData.sessionName, SESSION_NAME_SIZE_MAX,
245                  recvAppInfo->peerData.sessionName, SESSION_NAME_SIZE_MAX) != EOK) {
246         return SOFTBUS_MEM_ERR;
247     }
248     return SOFTBUS_OK;
249 }
250 
InitAuthChannelInfo(int32_t authId,AuthChannelInfo ** item,AppInfo * appInfo)251 static int32_t InitAuthChannelInfo(int32_t authId, AuthChannelInfo **item, AppInfo *appInfo)
252 {
253     *item = CreateAuthChannelInfo(appInfo->myData.sessionName, false);
254     if (*item == NULL) {
255         TRANS_LOGE(TRANS_SVC, "CreateAuthChannelInfo failed, authId=%{public}d", authId);
256         return SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND;
257     }
258     (*item)->authId = authId;
259     appInfo->myData.channelId = (*item)->appInfo.myData.channelId;
260     appInfo->myData.dataConfig = (*item)->appInfo.myData.dataConfig;
261     (*item)->connOpt.socketOption.moduleId = AUTH_RAW_P2P_SERVER;
262     if (appInfo->linkType == LANE_HML_RAW) {
263         (*item)->appInfo.linkType = appInfo->linkType;
264         if (memcpy_s((*item)->appInfo.peerData.addr, IP_LEN, appInfo->peerData.addr, IP_LEN) != EOK ||
265             memcpy_s((*item)->appInfo.myData.addr, IP_LEN, appInfo->myData.addr, IP_LEN) != EOK) {
266             TRANS_LOGE(TRANS_SVC, "copy clientIp and serverIp fail, authId=%{public}d", authId);
267             SoftBusFree((*item));
268             *item = NULL;
269             return SOFTBUS_MEM_ERR;
270         }
271     }
272     return SOFTBUS_OK;
273 }
274 
OnRequsetUpdateAuthChannel(int32_t authId,AppInfo * appInfo)275 static int32_t OnRequsetUpdateAuthChannel(int32_t authId, AppInfo *appInfo)
276 {
277     AuthChannelInfo *item = NULL;
278     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
279         TRANS_LOGE(TRANS_SVC, "lock failed, authId=%{public}d", authId);
280         return SOFTBUS_LOCK_ERR;
281     }
282     bool exists = false;
283     LIST_FOR_EACH_ENTRY(item, &g_authChannelList->list, AuthChannelInfo, node) {
284         if (item->authId == authId) {
285             exists = true;
286             break;
287         }
288     }
289     int32_t ret = SOFTBUS_OK;
290     if (!exists) {
291         ret = InitAuthChannelInfo(authId, &item, appInfo);
292         if (item == NULL) {
293             TRANS_LOGE(TRANS_SVC,
294                 "init auth channel info failed, ret=%{public}d, authId=%{public}d", ret, authId);
295             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
296             return ret;
297         }
298 
299         ret = AddAuthChannelInfo(item);
300         if (ret != SOFTBUS_OK) {
301             TRANS_LOGE(TRANS_SVC,
302                 "AddAuthChannelInfo failed, ret=%{public}d, authId=%{public}d, channelId=%{public}" PRId64,
303                 ret, authId, item->appInfo.myData.channelId);
304             SoftBusFree(item);
305             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
306             return ret;
307         }
308     }
309     if (CopyPeerAppInfo(appInfo, &item->appInfo) != SOFTBUS_OK) {
310         ListDelete(&item->node);
311         TRANS_LOGE(TRANS_CTRL, "Copy app failed, authId=%{public}d, channelId=%{public}" PRId64,
312             authId, item->appInfo.myData.channelId);
313         SoftBusFree(item);
314         g_authChannelList->cnt--;
315         (void)SoftBusMutexUnlock(&g_authChannelList->lock);
316         return SOFTBUS_MEM_ERR;
317     }
318     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
319     return SOFTBUS_OK;
320 }
321 
322 static const ConfigTypeMap g_configTypeMap[] = {
323     {CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BYTE, SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH},
324     {CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH},
325 };
326 
FindConfigType(int32_t channelType,int32_t businessType)327 static int32_t FindConfigType(int32_t channelType, int32_t businessType)
328 {
329     uint32_t size = (uint32_t)(sizeof(g_configTypeMap) / sizeof(g_configTypeMap[0]));
330     for (uint32_t i = 0; i < size; i++) {
331         if ((g_configTypeMap[i].channelType == channelType) && (g_configTypeMap[i].businessType == businessType)) {
332             return g_configTypeMap[i].configType;
333         }
334     }
335     return SOFTBUS_CONFIG_TYPE_MAX;
336 }
337 
TransGetLocalConfig(int32_t channelType,int32_t businessType,uint32_t * len)338 static int32_t TransGetLocalConfig(int32_t channelType, int32_t businessType, uint32_t *len)
339 {
340     ConfigType configType = (ConfigType)FindConfigType(channelType, businessType);
341     if (configType == SOFTBUS_CONFIG_TYPE_MAX) {
342         TRANS_LOGE(TRANS_SVC, "Invalid channelType=%{public}d, businessType=%{public}d", channelType, businessType);
343         return SOFTBUS_INVALID_PARAM;
344     }
345     uint32_t maxLen;
346     if (SoftbusGetConfig(configType, (unsigned char *)&maxLen, sizeof(maxLen)) != SOFTBUS_OK) {
347         TRANS_LOGE(TRANS_SVC, "get fail configType=%{public}d", configType);
348         return SOFTBUS_GET_CONFIG_VAL_ERR;
349     }
350     *len = maxLen;
351     TRANS_LOGI(TRANS_SVC, "get appinfo local config len=%{public}d", *len);
352     return SOFTBUS_OK;
353 }
354 
TransAuthFillDataConfig(AppInfo * appInfo)355 static int32_t TransAuthFillDataConfig(AppInfo *appInfo)
356 {
357     if (appInfo == NULL) {
358         TRANS_LOGE(TRANS_SVC, "appInfo is null");
359         return SOFTBUS_INVALID_PARAM;
360     }
361     appInfo->businessType = BUSINESS_TYPE_BYTE;
362     if (appInfo->peerData.dataConfig != 0) {
363         uint32_t localDataConfig = 0;
364         int32_t ret = TransGetLocalConfig(CHANNEL_TYPE_AUTH, appInfo->businessType, &localDataConfig);
365         if (ret != SOFTBUS_OK) {
366             TRANS_LOGE(TRANS_SVC, "get local config failed");
367             return ret;
368         }
369         appInfo->myData.dataConfig = MIN(localDataConfig, appInfo->peerData.dataConfig);
370         TRANS_LOGI(TRANS_SVC, "fill dataConfig succ. dataConfig=%{public}u", appInfo->myData.dataConfig);
371         return SOFTBUS_OK;
372     }
373     ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ?
374         SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH : SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH;
375     if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
376         sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
377         TRANS_LOGE(TRANS_SVC, "get config failed, configType=%{public}d", configType);
378         return SOFTBUS_GET_CONFIG_VAL_ERR;
379     }
380     TRANS_LOGI(TRANS_SVC, "fill dataConfig=%{public}d", appInfo->myData.dataConfig);
381     return SOFTBUS_OK;
382 }
383 
TransAuthCloseChannel(int32_t authId,int32_t linkType,bool isClient)384 static void TransAuthCloseChannel(int32_t authId, int32_t linkType, bool isClient)
385 {
386     TRANS_LOGI(TRANS_SVC, "authId=%{public}d, linkType=%{public}d, isClient=%{public}d", authId, linkType, isClient);
387     if (linkType == LANE_HML_RAW && isClient) {
388         AuthCloseChannel(authId, AUTH_RAW_P2P_CLIENT);
389     } else if (linkType == LANE_HML_RAW && !isClient) {
390         AuthCloseChannel(authId, AUTH_RAW_P2P_SERVER);
391     } else {
392         AuthCloseChannel(authId, AUTH);
393     }
394 }
395 
TransHandleErrorAndCloseChannel(TransEventExtra * extra,int32_t authId,int32_t linkType,bool isClient,int32_t ret)396 static void TransHandleErrorAndCloseChannel(TransEventExtra *extra, int32_t authId, int32_t linkType, bool isClient,
397     int32_t ret)
398 {
399     if (extra != NULL && extra->socketName != NULL) {
400         extra->result = EVENT_STAGE_RESULT_FAILED;
401         extra->errcode = ret;
402         TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, *extra);
403     }
404 
405     DelAuthChannelInfoByAuthId(authId);
406     TransAuthCloseChannel(authId, linkType, isClient);
407 }
408 
TransHandleAuthChannelSetupProcess(TransEventExtra * extra,int32_t authId,AppInfo * appInfo)409 static void TransHandleAuthChannelSetupProcess(TransEventExtra *extra, int32_t authId, AppInfo *appInfo)
410 {
411     int32_t ret = AuthGetUidAndPidBySessionName(
412         appInfo->myData.sessionName, &appInfo->myData.uid, &appInfo->myData.pid);
413     if (ret != SOFTBUS_OK) {
414         TRANS_LOGE(TRANS_SVC, "auth get id by sessionName failed and send msg to peer");
415         TransPostAuthChannelErrMsg(authId, ret, "session not created");
416         TransHandleErrorAndCloseChannel(extra, authId, appInfo->linkType, appInfo->isClient, ret);
417         return;
418     }
419     ret = TransAuthFillDataConfig(appInfo);
420     if (ret != SOFTBUS_OK) {
421         TRANS_LOGE(TRANS_SVC, "TransAuthFillDataConfig failed");
422         TransHandleErrorAndCloseChannel(extra, authId, appInfo->linkType, appInfo->isClient, ret);
423         return;
424     }
425     ret = OnRequsetUpdateAuthChannel(authId, appInfo);
426     if (ret != SOFTBUS_OK) {
427         TRANS_LOGE(TRANS_SVC, "update auth channel failed");
428         TransPostAuthChannelErrMsg(authId, ret, "unpackRequest");
429         TransHandleErrorAndCloseChannel(extra, authId, appInfo->linkType, appInfo->isClient, ret);
430         return;
431     }
432     extra->result = EVENT_STAGE_RESULT_OK;
433     extra->channelId = appInfo->myData.channelId;
434     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_START, *extra);
435     ret = NotifyOpenAuthChannelSuccess(appInfo, true);
436     if (ret != SOFTBUS_OK) {
437         TRANS_LOGE(TRANS_SVC, "NotifyOpenAuthChannelSuccess failed");
438         TransPostAuthChannelErrMsg(authId, ret, "NotifyOpenAuthChannelSuccess failed");
439         TransHandleErrorAndCloseChannel(extra, authId, appInfo->linkType, appInfo->isClient, ret);
440         return;
441     }
442     ret = TransPostAuthChannelMsg(appInfo, authId, AUTH_CHANNEL_REPLY);
443     if (ret != SOFTBUS_OK) {
444         TRANS_LOGE(TRANS_SVC, "send reply failed");
445         TransPostAuthChannelErrMsg(authId, ret, "send reply failed");
446         TransHandleErrorAndCloseChannel(extra, authId, appInfo->linkType, appInfo->isClient, ret);
447         return;
448     }
449     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_REPLY, *extra);
450 }
451 
OnRecvAuthChannelRequest(int32_t authId,const char * data,int32_t len)452 static void OnRecvAuthChannelRequest(int32_t authId, const char *data, int32_t len)
453 {
454     if (data == NULL || len <= 0) {
455         return;
456     }
457 
458     TransEventExtra extra = {
459         .peerNetworkId = NULL,
460         .calleePkg = NULL,
461         .callerPkg = NULL,
462         .socketName = NULL,
463         .channelType = CHANNEL_TYPE_AUTH,
464         .authId = authId
465     };
466     char localUdid[UDID_BUF_LEN] = { 0 };
467     if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN) == SOFTBUS_OK) {
468         extra.localUdid = localUdid;
469     }
470     AppInfo appInfo;
471     int32_t ret = TransAuthChannelMsgUnpack(data, &appInfo, len);
472     if (ret != SOFTBUS_OK) {
473         TRANS_LOGE(TRANS_SVC, "unpackRequest failed");
474         TransPostAuthChannelErrMsg(authId, ret, "unpackRequest");
475         TransHandleErrorAndCloseChannel(&extra, authId, appInfo.linkType, appInfo.isClient, ret);
476         return;
477     }
478     extra.socketName = appInfo.myData.sessionName;
479     extra.peerUdid = appInfo.peerData.deviceId;
480     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_HANDSHAKE_START, extra);
481     if (!CheckSessionNameValidOnAuthChannel(appInfo.myData.sessionName)) {
482         TRANS_LOGE(TRANS_SVC, "check auth channel pkginfo invalid.");
483         TransPostAuthChannelErrMsg(authId, SOFTBUS_TRANS_AUTH_NOTALLOW_OPENED, "check msginfo failed");
484         TransHandleErrorAndCloseChannel(&extra, authId, appInfo.linkType, appInfo.isClient,
485             SOFTBUS_TRANS_INVALID_SESSION_NAME);
486         return;
487     }
488 
489     TransHandleAuthChannelSetupProcess(&extra, authId, &appInfo);
490 }
491 
TransAuthProcessDataConfig(AppInfo * appInfo)492 static int32_t TransAuthProcessDataConfig(AppInfo *appInfo)
493 {
494     if (appInfo == NULL) {
495         TRANS_LOGE(TRANS_SVC, "appInfo is null");
496         return SOFTBUS_INVALID_PARAM;
497     }
498     if (appInfo->businessType != BUSINESS_TYPE_MESSAGE && appInfo->businessType != BUSINESS_TYPE_BYTE) {
499         TRANS_LOGI(TRANS_SVC, "invalid businessType=%{public}d", appInfo->businessType);
500         return SOFTBUS_OK;
501     }
502     if (appInfo->peerData.dataConfig != 0) {
503         appInfo->myData.dataConfig = MIN(appInfo->myData.dataConfig, appInfo->peerData.dataConfig);
504         TRANS_LOGI(TRANS_SVC, "process dataConfig succ. dataConfig=%{public}u", appInfo->myData.dataConfig);
505         return SOFTBUS_OK;
506     }
507     ConfigType configType = appInfo->businessType == BUSINESS_TYPE_BYTE ?
508         SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH : SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH;
509     if (SoftbusGetConfig(configType, (unsigned char *)&appInfo->myData.dataConfig,
510         sizeof(appInfo->myData.dataConfig)) != SOFTBUS_OK) {
511         TRANS_LOGE(TRANS_SVC, "get config failed, configType=%{public}d", configType);
512         return SOFTBUS_GET_CONFIG_VAL_ERR;
513     }
514     TRANS_LOGI(TRANS_SVC, "process dataConfig=%{public}d", appInfo->myData.dataConfig);
515     return SOFTBUS_OK;
516 }
517 
FillExtraByAuthChannelErrorEnd(TransEventExtra * extra,AuthChannelInfo * info,int32_t ret)518 static void FillExtraByAuthChannelErrorEnd(TransEventExtra *extra, AuthChannelInfo *info, int32_t ret)
519 {
520     if (extra == NULL || info == NULL) {
521         TRANS_LOGE(TRANS_SVC, "invalid param.");
522         return;
523     }
524     extra->result = EVENT_STAGE_RESULT_FAILED;
525     extra->errcode = ret;
526     extra->localUdid = info->appInfo.myData.deviceId;
527     if (strlen(info->appInfo.peerVersion) == 0) {
528         TransGetRemoteDeviceVersion(extra->peerUdid, CATEGORY_UDID, info->appInfo.peerVersion,
529             sizeof(info->appInfo.peerVersion));
530     }
531     extra->peerDevVer = info->appInfo.peerVersion;
532 }
533 
InitExtra(TransEventExtra * extra,const AuthChannelInfo * info,int32_t authId)534 static void InitExtra(TransEventExtra *extra, const AuthChannelInfo *info, int32_t authId)
535 {
536     extra->peerNetworkId = NULL;
537     extra->calleePkg = NULL;
538     extra->callerPkg = NULL;
539     extra->socketName = info->appInfo.myData.sessionName;
540     extra->channelId = info->appInfo.myData.channelId;
541     extra->channelType = CHANNEL_TYPE_AUTH;
542     extra->authId = authId;
543     extra->linkType = info->connOpt.type;
544     extra->osType = (info->appInfo.osType < 0) ? UNKNOW_OS_TYPE : info->appInfo.osType;
545 }
546 
ChannelReplyErrProc(TransEventExtra * extra,int32_t errorCode,AuthChannelInfo * info,int32_t authId)547 static void ChannelReplyErrProc(TransEventExtra *extra, int32_t errorCode, AuthChannelInfo *info, int32_t authId)
548 {
549     FillExtraByAuthChannelErrorEnd(extra, info, errorCode);
550     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, *extra);
551     TransAuthCloseChannel(authId, info->appInfo.linkType, info->isClient);
552     (void)TransLaneMgrDelLane(info->appInfo.myData.channelId, CHANNEL_TYPE_AUTH, true);
553     DelAuthChannelInfoByChanId((int32_t)(info->appInfo.myData.channelId));
554     (void)NotifyOpenAuthChannelFailed((const char *)(info->appInfo.myData.pkgName),
555         (int32_t)(info->appInfo.myData.pid), (int32_t)(info->appInfo.myData.channelId), errorCode);
556 }
557 
OnRecvAuthChannelReply(int32_t authId,const char * data,int32_t len)558 static void OnRecvAuthChannelReply(int32_t authId, const char *data, int32_t len)
559 {
560     if (data == NULL || len <= 0) {
561         return;
562     }
563     AuthChannelInfo info;
564     if (GetChannelInfoByAuthId(authId, &info) != SOFTBUS_OK) {
565         TRANS_LOGE(TRANS_SVC, "can not find channel info by auth id");
566         return;
567     }
568     TransEventExtra extra;
569     (void)memset_s(&extra, sizeof(TransEventExtra), 0, sizeof(TransEventExtra));
570     InitExtra(&extra, &info, authId);
571     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_REPLY, extra);
572     int32_t ret = TransAuthChannelMsgUnpack(data, &info.appInfo, len);
573     if (ret != SOFTBUS_OK) {
574         TRANS_LOGE(TRANS_SVC, "unpackReply failed");
575         ChannelReplyErrProc(&extra, ret, &info, authId);
576         return;
577     }
578     extra.peerUdid = strlen(info.appInfo.peerUdid) != 0 ? info.appInfo.peerUdid : info.appInfo.peerData.deviceId;
579     ret = TransAuthProcessDataConfig(&info.appInfo);
580     if (ret != SOFTBUS_OK) {
581         TRANS_LOGE(TRANS_SVC, "ProcessDataConfig failed");
582         ChannelReplyErrProc(&extra, ret, &info, authId);
583         return;
584     }
585     extra.result = EVENT_STAGE_RESULT_OK;
586     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_REPLY, extra);
587 
588     ret = NotifyOpenAuthChannelSuccess(&info.appInfo, false);
589     if (ret != SOFTBUS_OK) {
590         TRANS_LOGE(TRANS_SVC, "NotifyOpenAuthChannelSuccess failed");
591         ChannelReplyErrProc(&extra, ret, &info, authId);
592     }
593 }
594 
OnAuthChannelDataRecv(int32_t authId,const AuthChannelData * data)595 static void OnAuthChannelDataRecv(int32_t authId, const AuthChannelData *data)
596 {
597     if (data == NULL || data->data == NULL || data->len < 1) {
598         TRANS_LOGW(TRANS_SVC, "invalid param.");
599         return;
600     }
601 
602     if (data->flag == AUTH_CHANNEL_REQ) {
603         OnRecvAuthChannelRequest(authId, (const char *)data->data, (int32_t)data->len);
604     } else if (data->flag == AUTH_CHANNEL_REPLY) {
605         OnRecvAuthChannelReply(authId, (const char *)data->data, (int32_t)data->len);
606     } else {
607         TRANS_LOGE(TRANS_SVC, "auth channel flags err, authId=%{public}d", authId);
608     }
609 }
610 
OnAuthMsgDataRecv(int32_t authId,const AuthChannelData * data)611 static void OnAuthMsgDataRecv(int32_t authId, const AuthChannelData *data)
612 {
613     if (data == NULL || data->data == NULL) {
614         return;
615     }
616     if (NotifyOnDataReceived(authId, data->data, data->len) != SOFTBUS_OK) {
617         TRANS_LOGE(TRANS_SVC, "recv MODULE_AUTH_MSG err. authId=%{public}d", authId);
618     }
619 }
620 
OnDisconnect(int32_t authId)621 static void OnDisconnect(int32_t authId)
622 {
623     AuthChannelInfo dstInfo;
624     if (GetChannelInfoByAuthId(authId, &dstInfo) != EOK) {
625         TRANS_LOGE(TRANS_SVC, "channel already removed. authId=%{public}d", authId);
626         return;
627     }
628     TRANS_LOGI(TRANS_SVC, "recv channel disconnect event. authId=%{public}d", authId);
629 
630     // If it is an ishare session, clean up the auth manager
631     if (strcmp(dstInfo.appInfo.myData.sessionName, ISHARE_AUTH_SESSION) == 0) {
632         DelAuthMetaManagerByConnectionId(authId);
633     }
634     TransAuthCloseChannel(authId, dstInfo.appInfo.linkType, dstInfo.isClient);
635     DelAuthChannelInfoByChanId((int32_t)(dstInfo.appInfo.myData.channelId));
636     (void)NofifyCloseAuthChannel((const char *)dstInfo.appInfo.myData.pkgName,
637         (int32_t)dstInfo.appInfo.myData.pid, (int32_t)dstInfo.appInfo.myData.channelId);
638 }
639 
GetAppInfo(const char * sessionName,int32_t channelId,AppInfo * appInfo,bool isClient)640 int32_t GetAppInfo(const char *sessionName, int32_t channelId, AppInfo *appInfo, bool isClient)
641 {
642     if (sessionName == NULL || appInfo == NULL) {
643         return SOFTBUS_INVALID_PARAM;
644     }
645     appInfo->appType = APP_TYPE_NOT_CARE;
646     appInfo->businessType = BUSINESS_TYPE_BYTE;
647     appInfo->channelType = CHANNEL_TYPE_AUTH;
648     appInfo->myData.channelId = channelId;
649     appInfo->myData.apiVersion = API_V2;
650     appInfo->peerData.apiVersion = API_V2;
651     appInfo->autoCloseTime = 0;
652     if (!IsNoPkgNameSession(sessionName) || isClient) {
653         int32_t ret = TransGetUidAndPid(sessionName, &appInfo->myData.uid, &appInfo->myData.pid);
654         if (ret != SOFTBUS_OK) {
655             TRANS_LOGE(TRANS_SVC, "TransGetUidAndPid failed");
656             return ret;
657         }
658         ret = TransGetPkgNameBySessionName(sessionName, appInfo->myData.pkgName, PKG_NAME_SIZE_MAX);
659         if (ret != SOFTBUS_OK) {
660             TRANS_LOGE(TRANS_SVC, "TransGetPkgNameBySessionName failed");
661             return ret;
662         }
663     }
664     int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, appInfo->myData.deviceId, sizeof(appInfo->myData.deviceId));
665     if (ret != SOFTBUS_OK) {
666         TRANS_LOGE(TRANS_SVC, "LnnGetLocalStrInfo failed");
667         return ret;
668     }
669     if (strcpy_s(appInfo->myData.sessionName, sizeof(appInfo->myData.sessionName), sessionName) != EOK) {
670         TRANS_LOGE(TRANS_SVC, "copy sessionName failed");
671         return SOFTBUS_STRCPY_ERR;
672     }
673     appInfo->peerData.apiVersion = API_V2;
674     if (strcpy_s(appInfo->peerData.sessionName, sizeof(appInfo->peerData.sessionName), sessionName) != EOK) {
675         return SOFTBUS_STRCPY_ERR;
676     }
677     ret = TransGetLocalConfig(appInfo->channelType, appInfo->businessType, &appInfo->myData.dataConfig);
678     if (ret != SOFTBUS_OK) {
679         return ret;
680     }
681     return SOFTBUS_OK;
682 }
683 
AddAuthChannelInfo(AuthChannelInfo * info)684 static int32_t AddAuthChannelInfo(AuthChannelInfo *info)
685 {
686     if (g_authChannelList == NULL || info == NULL) {
687         TRANS_LOGE(TRANS_SVC, "invalid param.");
688         return SOFTBUS_INVALID_PARAM;
689     }
690     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
691         TRANS_LOGE(TRANS_SVC, "fail to lock authChannelList.");
692         return SOFTBUS_LOCK_ERR;
693     }
694     AuthChannelInfo *item = NULL;
695     LIST_FOR_EACH_ENTRY(item, &g_authChannelList->list, AuthChannelInfo, node) {
696         if (item->appInfo.myData.channelId == info->appInfo.myData.channelId) {
697             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
698             TRANS_LOGE(TRANS_SVC, "found auth channel, channelId=%{public}" PRId64,
699                 info->appInfo.myData.channelId);
700             return SOFTBUS_TRANS_INVALID_CHANNEL_ID;
701         }
702     }
703     ListAdd(&g_authChannelList->list, &info->node);
704     TRANS_LOGI(TRANS_CTRL, "add channelId=%{public}" PRId64 ", isClient=%{public}d",
705         info->appInfo.myData.channelId, info->appInfo.isClient);
706     g_authChannelList->cnt++;
707     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
708     return SOFTBUS_OK;
709 }
710 
DelAuthChannelInfoByChanId(int32_t channelId)711 static void DelAuthChannelInfoByChanId(int32_t channelId)
712 {
713     if (g_authChannelList == NULL) {
714         return;
715     }
716     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
717         TRANS_LOGE(TRANS_SVC, "lock failed");
718         return;
719     }
720     AuthChannelInfo *item = NULL;
721     AuthChannelInfo *tmp = NULL;
722     LIST_FOR_EACH_ENTRY_SAFE(item, tmp, &g_authChannelList->list, AuthChannelInfo, node) {
723         if (item->appInfo.myData.channelId == channelId) {
724             ListDelete(&item->node);
725             TRANS_LOGI(TRANS_CTRL, "delete channelId=%{public}d", channelId);
726             SoftBusFree(item);
727             g_authChannelList->cnt--;
728             break;
729         }
730     }
731     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
732 }
733 
DelAuthChannelInfoByAuthId(int32_t authId)734 static void DelAuthChannelInfoByAuthId(int32_t authId)
735 {
736     if (g_authChannelList == NULL) {
737         return;
738     }
739     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
740         TRANS_LOGE(TRANS_SVC, "lock failed");
741         return;
742     }
743     AuthChannelInfo *item = NULL;
744     AuthChannelInfo *tmp = NULL;
745     LIST_FOR_EACH_ENTRY_SAFE(item, tmp, &g_authChannelList->list, AuthChannelInfo, node) {
746         if (item->authId == authId) {
747             ListDelete(&item->node);
748             TRANS_LOGI(TRANS_CTRL, "delete authId = %{public}d", item->authId);
749             SoftBusFree(item);
750             g_authChannelList->cnt--;
751             break;
752         }
753     }
754     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
755 }
756 
TransAuthGetNameByChanId(int32_t chanId,char * pkgName,char * sessionName,uint16_t pkgLen,uint16_t sessionLen)757 int32_t TransAuthGetNameByChanId(int32_t chanId, char *pkgName, char *sessionName, uint16_t pkgLen, uint16_t sessionLen)
758 {
759     if (pkgName == NULL || sessionName == NULL) {
760         TRANS_LOGE(TRANS_SVC, "invalid param");
761         return SOFTBUS_INVALID_PARAM;
762     }
763 
764     AuthChannelInfo info;
765     int32_t ret = GetAuthChannelInfoByChanId(chanId, &info);
766     if (ret != SOFTBUS_OK) {
767         TRANS_LOGE(TRANS_SVC, "get channel info by chanId failed. chanId=%{public}d", chanId);
768         return ret;
769     }
770 
771     if (memcpy_s(pkgName, pkgLen, info.appInfo.myData.pkgName, PKG_NAME_SIZE_MAX) != EOK ||
772         memcpy_s(sessionName, sessionLen, info.appInfo.myData.sessionName, SESSION_NAME_SIZE_MAX) != EOK) {
773         TRANS_LOGE(TRANS_SVC, "memcpy_s failed");
774         return SOFTBUS_MEM_ERR;
775     }
776     return SOFTBUS_OK;
777 }
778 
TransAuthInit(IServerChannelCallBack * cb)779 int32_t TransAuthInit(IServerChannelCallBack *cb)
780 {
781     if (cb == NULL) {
782         return SOFTBUS_INVALID_PARAM;
783     }
784     AuthChannelListener channelListener = {
785         .onDataReceived = OnAuthChannelDataRecv,
786         .onDisconnected = OnDisconnect,
787     };
788     AuthChannelListener msgListener = {
789         .onDataReceived = OnAuthMsgDataRecv,
790         .onDisconnected = OnDisconnect,
791     };
792     if (RegAuthChannelListener(MODULE_AUTH_CHANNEL, &channelListener) != SOFTBUS_OK ||
793         RegAuthChannelListener(MODULE_AUTH_MSG, &msgListener) != SOFTBUS_OK) {
794         UnregAuthChannelListener(MODULE_AUTH_CHANNEL);
795         UnregAuthChannelListener(MODULE_AUTH_MSG);
796         return SOFTBUS_TRANS_REG_AUTH_CHANNEL_LISTERNER_FAILED;
797     }
798     if (g_authChannelList == NULL) {
799         g_authChannelList = CreateSoftBusList();
800     }
801     if (g_authChannelList == NULL) {
802         return SOFTBUS_INVALID_PARAM;
803     }
804     if (g_cb == NULL) {
805         g_cb = cb;
806     }
807     return SOFTBUS_OK;
808 }
809 
TransAuthDeinit(void)810 void TransAuthDeinit(void)
811 {
812     UnregAuthChannelListener(MODULE_AUTH_CHANNEL);
813     UnregAuthChannelListener(MODULE_AUTH_MSG);
814     DestroySoftBusList(g_authChannelList);
815     g_authChannelList = NULL;
816     g_cb = NULL;
817 }
818 
TransPostAuthChannelMsg(const AppInfo * appInfo,int32_t authId,int32_t flag)819 static int32_t TransPostAuthChannelMsg(const AppInfo *appInfo, int32_t authId, int32_t flag)
820 {
821     if (appInfo == NULL) {
822         TRANS_LOGW(TRANS_SVC, "invalid param");
823         return SOFTBUS_INVALID_PARAM;
824     }
825     cJSON *msg = cJSON_CreateObject();
826     if (msg == NULL) {
827         TRANS_LOGE(TRANS_SVC, "json failed");
828         return SOFTBUS_MALLOC_ERR;
829     }
830     int32_t ret = TransAuthChannelMsgPack(msg, appInfo);
831     if (ret != SOFTBUS_OK) {
832         cJSON_Delete(msg);
833         TRANS_LOGE(TRANS_SVC, "tran channel msg pack failed");
834         return ret;
835     }
836     char *data = cJSON_PrintUnformatted(msg);
837     cJSON_Delete(msg);
838     if (data == NULL) {
839         TRANS_LOGE(TRANS_SVC, "json failed");
840         return SOFTBUS_PARSE_JSON_ERR;
841     }
842 
843     AuthChannelData channelData = {
844         .module = MODULE_AUTH_CHANNEL,
845         .flag = flag,
846         .seq = 0,
847         .len = strlen(data) + 1,
848         .data = (const uint8_t *)data,
849     };
850     ret = AuthPostChannelData(authId, &channelData);
851     if (ret != SOFTBUS_OK) {
852         TRANS_LOGE(TRANS_SVC, "auth post channel data fail");
853         cJSON_free(data);
854         return ret;
855     }
856     cJSON_free(data);
857     return SOFTBUS_OK;
858 }
859 
TransPostAuthChannelErrMsg(int32_t authId,int32_t errcode,const char * errMsg)860 static void TransPostAuthChannelErrMsg(int32_t authId, int32_t errcode, const char *errMsg)
861 {
862     if (errMsg == NULL) {
863         return;
864     }
865     char cJsonStr[ERR_MSG_MAX_LEN] = {0};
866     int32_t ret = TransAuthChannelErrorPack(errcode, errMsg, cJsonStr, ERR_MSG_MAX_LEN);
867     if (ret != SOFTBUS_OK) {
868         TRANS_LOGE(TRANS_SVC, "TransAuthChannelErrorPack failed");
869         return;
870     }
871     AuthChannelData channelData = {
872         .module = MODULE_AUTH_CHANNEL,
873         .flag = AUTH_CHANNEL_REPLY,
874         .seq = 0,
875         .len = strlen(cJsonStr) + 1,
876         .data = (const uint8_t *)cJsonStr,
877     };
878     if (AuthPostChannelData(authId, &channelData) != SOFTBUS_OK) {
879         TRANS_LOGE(TRANS_SVC, "auth post channel data fail");
880     }
881 }
882 
CreateAuthChannelInfo(const char * sessionName,bool isClient)883 static AuthChannelInfo *CreateAuthChannelInfo(const char *sessionName, bool isClient)
884 {
885     AuthChannelInfo *info = (AuthChannelInfo *)SoftBusCalloc(sizeof(AuthChannelInfo));
886     if (info == NULL) {
887         return NULL;
888     }
889     info->appInfo.myData.channelId = GenerateChannelId(true);
890     if (info->appInfo.myData.channelId < 0) {
891         TRANS_LOGE(TRANS_SVC, "channelId is invalid");
892         goto EXIT_ERR;
893     }
894     if (GetAppInfo(sessionName, info->appInfo.myData.channelId, &info->appInfo, isClient) != SOFTBUS_OK) {
895         goto EXIT_ERR;
896     }
897     info->isClient = isClient;
898     return info;
899 EXIT_ERR:
900     SoftBusFree(info);
901     return NULL;
902 }
903 
FillAndReportEventStart(const char * sessionName,int32_t * channelId,int32_t connType,TransEventExtra * extra,AuthChannelInfo * channel)904 static void FillAndReportEventStart(const char *sessionName, int32_t *channelId, int32_t connType,
905     TransEventExtra *extra, AuthChannelInfo *channel)
906 {
907     extra->peerNetworkId = NULL;
908     extra->calleePkg = NULL;
909     extra->callerPkg = NULL;
910     extra->socketName = sessionName;
911     extra->channelId = *channelId;
912     extra->channelType = CHANNEL_TYPE_AUTH;
913     extra->linkType = connType;
914     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, *extra);
915 }
916 
FillAndReportEventEnd(int32_t authId,TransEventExtra * extra)917 static void FillAndReportEventEnd(int32_t authId, TransEventExtra *extra)
918 {
919     extra->result = EVENT_STAGE_RESULT_OK;
920     extra->authId = authId;
921     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, *extra);
922 }
923 
CheckForAuthWithParam(const char * sessionName,const LaneConnInfo * connInfo,int32_t * channelId)924 static bool CheckForAuthWithParam(const char *sessionName, const LaneConnInfo *connInfo, int32_t *channelId)
925 {
926     if (sessionName == NULL || connInfo == NULL || channelId == NULL) {
927         TRANS_LOGE(TRANS_SVC, "CheckForAuthWithParam invalid param");
928         return false;
929     }
930     if (g_authChannelList == NULL) {
931         TRANS_LOGE(TRANS_SVC, "CheckForAuthWithParam g_authChannelList is null");
932         return false;
933     }
934     if (connInfo->type != LANE_HML_RAW) {
935         TRANS_LOGE(TRANS_SVC, "CheckForAuthWithParam connInfo->type is %{public}d", connInfo->type);
936         return false;
937     }
938     return true;
939 }
940 
TransFillAuthChannelInfo(AuthChannelInfo * channel,const LaneConnInfo * connInfo,int32_t * channelId)941 static int32_t TransFillAuthChannelInfo(AuthChannelInfo *channel, const LaneConnInfo *connInfo, int32_t *channelId)
942 {
943     if (channel == NULL || connInfo == NULL || channelId == NULL) {
944         TRANS_LOGE(TRANS_SVC, "TransFillAuthChannelInfo invalid parm");
945         return SOFTBUS_INVALID_PARAM;
946     }
947 
948     (void)memset_s(channel->appInfo.reqId, REQ_ID_SIZE_MAX, 0, REQ_ID_SIZE_MAX);
949     channel->appInfo.myData.channelId = *channelId;
950     channel->appInfo.timeStart = GetSoftbusRecordTimeMillis();
951     channel->appInfo.linkType = connInfo->type;
952     channel->appInfo.routeType = WIFI_P2P;
953     channel->connOpt.socketOption.moduleId = AUTH_RAW_P2P_CLIENT;
954 
955     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, channel->appInfo.peerNetWorkId,
956         sizeof(channel->appInfo.peerNetWorkId)) != SOFTBUS_OK) {
957         TRANS_LOGW(TRANS_SVC, "LnnGetLocalStrInfo STRING_KEY_NETWORKID failed");
958     }
959 
960     if (strcpy_s(channel->appInfo.myData.addr, IP_LEN, connInfo->connInfo.rawWifiDirect.localIp) != EOK) {
961         TRANS_LOGE(TRANS_SVC, "TransFillAuthChannelInfo strcpy_s localIp failed");
962         return SOFTBUS_STRCPY_ERR;
963     }
964     if (strcpy_s(channel->appInfo.peerData.addr, IP_LEN, connInfo->connInfo.rawWifiDirect.peerIp) != EOK) {
965         TRANS_LOGE(TRANS_SVC, "TransFillAuthChannelInfo strcpy_s perrIp failed");
966         return SOFTBUS_STRCPY_ERR;
967     }
968     return SOFTBUS_OK;
969 }
970 
PostAuthMsg(AuthChannelInfo * channel,TransEventExtra * extra,const LaneConnInfo * connInfo,const int32_t * channelId)971 static int32_t PostAuthMsg(AuthChannelInfo *channel, TransEventExtra *extra, const LaneConnInfo *connInfo,
972     const int32_t *channelId)
973 {
974     int32_t authId = AuthOpenChannelWithAllIp(connInfo->connInfo.rawWifiDirect.localIp,
975         connInfo->connInfo.rawWifiDirect.peerIp, connInfo->connInfo.rawWifiDirect.port);
976     if (authId < 0) {
977         TRANS_LOGE(TRANS_SVC, "AuthOpenChannelWithAllIp failed");
978         SoftBusFree(channel);
979         return SOFTBUS_TRANS_OPEN_AUTH_CHANNEL_FAILED;
980     }
981     extra->result = EVENT_STAGE_RESULT_OK;
982     extra->authId = authId;
983     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, *extra);
984     channel->authId = authId;
985     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
986         TRANS_LOGE(TRANS_SVC, "SoftBusMutexLock failed");
987         TransAuthCloseChannel(channel->authId, LANE_HML_RAW, true);
988         SoftBusFree(channel);
989         return SOFTBUS_LOCK_ERR;
990     }
991     if (AddAuthChannelInfo(channel) != SOFTBUS_OK) {
992         TRANS_LOGE(TRANS_SVC, "AddAuthChannelInfo failed");
993         (void)SoftBusMutexUnlock(&g_authChannelList->lock);
994         TransAuthCloseChannel(channel->authId, LANE_HML_RAW, true);
995         SoftBusFree(channel);
996         return SOFTBUS_TRANS_AUTH_ADD_CHANINFO_FAIL;
997     }
998     extra->result = 0;
999     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_START, *extra);
1000     if (TransPostAuthChannelMsg(&channel->appInfo, authId, AUTH_CHANNEL_REQ) != SOFTBUS_OK) {
1001         TRANS_LOGE(TRANS_SVC, "TransPostAuthRequest failed");
1002         DelAuthChannelInfoByChanId(*channelId);
1003         (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1004         TransAuthCloseChannel(authId, LANE_HML_RAW, true);
1005         return SOFTBUS_TRANS_AUTH_POST_CHANMSG_FAIL;
1006     }
1007     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1008     return SOFTBUS_OK;
1009 }
1010 
TransOpenAuthMsgChannelWithPara(const char * sessionName,const LaneConnInfo * connInfo,int32_t * channelId)1011 int32_t TransOpenAuthMsgChannelWithPara(const char *sessionName, const LaneConnInfo *connInfo, int32_t *channelId)
1012 {
1013     if (!CheckForAuthWithParam(sessionName, connInfo, channelId)) {
1014         TRANS_LOGE(TRANS_SVC, "TransOpenAuthMsgChannelWithPara CheckForAuthWithParam fail");
1015         return SOFTBUS_INVALID_PARAM;
1016     }
1017 
1018     AuthChannelInfo *channel = CreateAuthChannelInfo(sessionName, true);
1019     if (channel == NULL) {
1020         TRANS_LOGE(TRANS_SVC, "TransOpenAuthMsgChannelWithPara CreateAuthChannelInfo fail");
1021         return SOFTBUS_TRANS_AUTH_CREATE_CHANINFO_FAIL;
1022     }
1023     if (TransFillAuthChannelInfo(channel, connInfo, channelId) != SOFTBUS_OK) {
1024         SoftBusFree(channel);
1025         TRANS_LOGE(TRANS_SVC, "TransOpenAuthMsgChannelWithPara TransFillAuthChannelInfo failed");
1026         return SOFTBUS_TRANS_AUTH_FILL_CHANINFO_FAIL;
1027     }
1028 
1029     TransEventExtra extra = {
1030         .peerNetworkId = NULL,
1031         .calleePkg = NULL,
1032         .callerPkg = NULL,
1033         .socketName = sessionName,
1034         .channelId = *channelId,
1035         .channelType = CHANNEL_TYPE_AUTH,
1036         .linkType = CONNECT_HML
1037     };
1038     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_START_CONNECT, extra);
1039 
1040     int32_t ret = PostAuthMsg(channel, &extra, connInfo, channelId);
1041     if (ret != SOFTBUS_OK) {
1042         TRANS_LOGE(TRANS_SVC, "PostAuthMsg failed, ret=%{public}d", ret);
1043         return ret;
1044     }
1045     extra.result = EVENT_STAGE_RESULT_OK;
1046     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_START, extra);
1047     return SOFTBUS_OK;
1048 }
1049 
TransOpenAuthChannelPrepareParam(const char * sessionName,const ConnectOption * connOpt,int32_t * channelId,const char * reqId)1050 static AuthChannelInfo *TransOpenAuthChannelPrepareParam(const char *sessionName, const ConnectOption *connOpt,
1051     int32_t *channelId, const char *reqId)
1052 {
1053     AuthChannelInfo *channel = CreateAuthChannelInfo(sessionName, true);
1054     TRANS_CHECK_AND_RETURN_RET_LOGE(channel != NULL, NULL, TRANS_SVC, "fail to add pid");
1055     if (strcpy_s(channel->appInfo.reqId, REQ_ID_SIZE_MAX, reqId) != EOK ||
1056         memcpy_s(&channel->connOpt, sizeof(ConnectOption), connOpt, sizeof(ConnectOption)) != EOK) {
1057         SoftBusFree(channel);
1058         TRANS_LOGE(TRANS_SVC, "fail to copy appInfo and connOpt.");
1059         return NULL;
1060     }
1061     *channelId = (int32_t)channel->appInfo.myData.channelId;
1062     channel->appInfo.timeStart = GetSoftbusRecordTimeMillis();
1063     channel->appInfo.connectType = connOpt->type;
1064     return channel;
1065 }
1066 
TransOpenAuthMsgChannel(const char * sessionName,const ConnectOption * connOpt,int32_t * channelId,const char * reqId)1067 int32_t TransOpenAuthMsgChannel(const char *sessionName, const ConnectOption *connOpt,
1068     int32_t *channelId, const char *reqId)
1069 {
1070     if (connOpt == NULL || channelId == NULL || connOpt->type != CONNECT_TCP || g_authChannelList == NULL) {
1071         return SOFTBUS_INVALID_PARAM;
1072     }
1073     AuthChannelInfo *channel = TransOpenAuthChannelPrepareParam(sessionName, connOpt, channelId, reqId);
1074     if (channel == NULL) {
1075         TRANS_LOGE(TRANS_SVC, "fail to get auth channel info.");
1076         return SOFTBUS_INVALID_PARAM;
1077     }
1078     TransEventExtra extra;
1079     FillAndReportEventStart(sessionName, channelId, connOpt->type, &extra, channel);
1080     int32_t authId = AuthOpenChannel(connOpt->socketOption.addr, connOpt->socketOption.port);
1081     if (authId < 0) {
1082         TRANS_LOGE(TRANS_SVC, "AuthOpenChannel failed");
1083         SoftBusFree(channel);
1084         return SOFTBUS_TRANS_OPEN_AUTH_CHANNEL_FAILED;
1085     }
1086     FillAndReportEventEnd(authId, &extra);
1087     channel->authId = authId;
1088     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
1089         TRANS_LOGE(TRANS_SVC, "SoftBusMutexLock failed");
1090         TransAuthCloseChannel(channel->authId, LANE_HML_RAW, true);
1091         SoftBusFree(channel);
1092         return SOFTBUS_LOCK_ERR;
1093     }
1094     int32_t ret = AddAuthChannelInfo(channel);
1095     if (ret != SOFTBUS_OK) {
1096         TRANS_LOGE(TRANS_SVC, "AddAuthChannelInfo failed");
1097         TransAuthCloseChannel(channel->authId, LANE_HML_RAW, true);
1098         SoftBusFree(channel);
1099         (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1100         return ret;
1101     }
1102     extra.result = 0;
1103     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_START, extra);
1104     ret = TransPostAuthChannelMsg(&channel->appInfo, authId, AUTH_CHANNEL_REQ);
1105     if (ret != SOFTBUS_OK) {
1106         TRANS_LOGE(TRANS_SVC, "TransPostAuthRequest failed");
1107         TransAuthCloseChannel(channel->authId, LANE_HML_RAW, true);
1108         DelAuthChannelInfoByChanId(*channelId);
1109         (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1110         return ret;
1111     }
1112     extra.result = EVENT_STAGE_RESULT_OK;
1113     TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_HANDSHAKE_START, extra);
1114     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1115     return SOFTBUS_OK;
1116 }
1117 
TransCloseAuthChannel(int32_t channelId)1118 int32_t TransCloseAuthChannel(int32_t channelId)
1119 {
1120     AuthChannelInfo *channel = NULL;
1121     AuthChannelInfo *tmp = NULL;
1122     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
1123         TRANS_LOGE(TRANS_SVC, "lock failed");
1124         return SOFTBUS_LOCK_ERR;
1125     }
1126     LIST_FOR_EACH_ENTRY_SAFE(channel, tmp, &g_authChannelList->list, AuthChannelInfo, node) {
1127         if (channel->appInfo.myData.channelId != channelId) {
1128             continue;
1129         }
1130         ListDelete(&channel->node);
1131         TRANS_LOGI(TRANS_CTRL, "delete channelId=%{public}d, authId=%{public}d", channelId, channel->authId);
1132         g_authChannelList->cnt--;
1133         // If it is an ishare session, clean up the auth manager
1134         if (strcmp(channel->appInfo.myData.sessionName, ISHARE_AUTH_SESSION) == 0) {
1135             DelAuthMetaManagerByConnectionId(channel->authId);
1136         }
1137         TransAuthCloseChannel(channel->authId, channel->appInfo.linkType, channel->isClient);
1138         NofifyCloseAuthChannel(channel->appInfo.myData.pkgName, channel->appInfo.myData.pid, channelId);
1139         SoftBusFree(channel);
1140         (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1141         return SOFTBUS_OK;
1142     }
1143     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1144     return SOFTBUS_TRANS_NODE_NOT_FOUND;
1145 }
1146 
TransSendAuthMsg(int32_t channelId,const char * msg,int32_t len)1147 int32_t TransSendAuthMsg(int32_t channelId, const char *msg, int32_t len)
1148 {
1149     if (msg == NULL || len <= 0) {
1150         return SOFTBUS_INVALID_PARAM;
1151     }
1152 
1153     int32_t authId = GetAuthIdByChannelId(channelId);
1154     if (authId < 0) {
1155         TRANS_LOGE(TRANS_SVC, "Get AuthId failed");
1156         return SOFTBUS_TRANS_AUTH_CHANNEL_NOT_FOUND;
1157     }
1158 
1159     AuthChannelData channelData = {
1160         .module = MODULE_AUTH_MSG,
1161         .flag = 0,
1162         .seq = 0,
1163         .len = (uint32_t)len,
1164         .data = (const uint8_t *)msg,
1165     };
1166     int32_t ret = AuthPostChannelData(authId, &channelData);
1167     if (ret != SOFTBUS_OK) {
1168         TRANS_LOGE(TRANS_SVC, "auth post channel data fail");
1169         return ret;
1170     }
1171     return SOFTBUS_OK;
1172 }
1173 
TransAuthGetConnOptionByChanId(int32_t channelId,ConnectOption * connOpt)1174 int32_t TransAuthGetConnOptionByChanId(int32_t channelId, ConnectOption *connOpt)
1175 {
1176     AuthChannelInfo chanInfo;
1177     int32_t ret = GetAuthChannelInfoByChanId(channelId, &chanInfo);
1178     if (ret != SOFTBUS_OK) {
1179         TRANS_LOGE(TRANS_SVC, "get auth channel info by channelId fail. channelId=%{public}d", channelId);
1180         return ret;
1181     }
1182 
1183     if (!chanInfo.isClient) {
1184         TRANS_LOGE(TRANS_SVC, "auth channel of conn opt invalid");
1185         return SOFTBUS_TRANS_INVALID_CHANNEL_TYPE;
1186     }
1187 
1188     if (memcpy_s(connOpt, sizeof(ConnectOption), &(chanInfo.connOpt), sizeof(ConnectOption)) != EOK) {
1189         TRANS_LOGE(TRANS_SVC, "auth channel connopt memcpy fail");
1190         return SOFTBUS_MEM_ERR;
1191     }
1192     return SOFTBUS_OK;
1193 }
1194 
TransNotifyAuthDataSuccess(int32_t channelId,const ConnectOption * connOpt)1195 int32_t TransNotifyAuthDataSuccess(int32_t channelId, const ConnectOption *connOpt)
1196 {
1197     if (connOpt == NULL) {
1198         TRANS_LOGW(TRANS_SVC, "invalid param.");
1199         return SOFTBUS_INVALID_PARAM;
1200     }
1201     ConnectionAddr addr;
1202     (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
1203     if (!LnnConvertOptionToAddr(&addr, connOpt, CONNECTION_ADDR_WLAN)) {
1204         TRANS_LOGE(TRANS_SVC, "channelId convert addr fail. channelId=%{public}d", channelId);
1205         return SOFTBUS_TRANS_CHANNELID_CONVERT_ADDR_FAILED;
1206     }
1207     LnnDfxDeviceInfoReport infoReport;
1208     (void)memset_s(&infoReport, sizeof(LnnDfxDeviceInfoReport), 0, sizeof(LnnDfxDeviceInfoReport));
1209     return LnnNotifyDiscoveryDevice(&addr, &infoReport, true);
1210 }
1211 
TransAuthGetAppInfoByChanId(int32_t channelId,AppInfo * appInfo)1212 int32_t TransAuthGetAppInfoByChanId(int32_t channelId, AppInfo *appInfo)
1213 {
1214     if (appInfo == NULL || g_authChannelList == NULL) {
1215         return SOFTBUS_INVALID_PARAM;
1216     }
1217 
1218     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
1219         TRANS_LOGE(TRANS_SVC, "lock failed");
1220         return SOFTBUS_LOCK_ERR;
1221     }
1222     AuthChannelInfo *info = NULL;
1223     LIST_FOR_EACH_ENTRY(info, &g_authChannelList->list, AuthChannelInfo, node) {
1224         if (info->appInfo.myData.channelId == channelId) {
1225             if (memcpy_s(appInfo, sizeof(AppInfo), &info->appInfo, sizeof(AppInfo)) != EOK) {
1226                 (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1227                 TRANS_LOGE(TRANS_SVC, "auth channel appinfo memcpy fail");
1228                 return SOFTBUS_MEM_ERR;
1229             }
1230             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1231             return SOFTBUS_OK;
1232         }
1233     }
1234     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1235     TRANS_LOGE(TRANS_CTRL, "Auth channel not find: channelId=%{public}d", channelId);
1236     return SOFTBUS_NOT_FIND;
1237 }
1238 
TransAuthGetConnIdByChanId(int32_t channelId,int32_t * connId)1239 int32_t TransAuthGetConnIdByChanId(int32_t channelId, int32_t *connId)
1240 {
1241     if ((g_authChannelList == NULL) || (connId == NULL)) {
1242         TRANS_LOGE(TRANS_SVC, "invalid param");
1243         return SOFTBUS_INVALID_PARAM;
1244     }
1245 
1246     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
1247         TRANS_LOGE(TRANS_SVC, "get mutex lock failed");
1248         return SOFTBUS_LOCK_ERR;
1249     }
1250 
1251     AuthChannelInfo *item = NULL;
1252     LIST_FOR_EACH_ENTRY(item, &g_authChannelList->list, AuthChannelInfo, node) {
1253         if (item->appInfo.myData.channelId == channelId) {
1254             *connId = item->authId;
1255             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1256             return SOFTBUS_OK;
1257         }
1258     }
1259     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1260     TRANS_LOGE(TRANS_SVC, "get connid failed");
1261     return SOFTBUS_TRANS_NODE_NOT_FOUND;
1262 }
1263 
CheckIsWifiAuthChannel(ConnectOption * connInfo)1264 int32_t CheckIsWifiAuthChannel(ConnectOption *connInfo)
1265 {
1266     if (connInfo == NULL || connInfo->socketOption.moduleId != AUTH) {
1267         TRANS_LOGE(
1268             TRANS_SVC, "invalid param, moduleId=%{public}d", connInfo == NULL ? -1 : connInfo->socketOption.moduleId);
1269         return SOFTBUS_INVALID_PARAM;
1270     }
1271     if (g_authChannelList == NULL) {
1272         TRANS_LOGE(TRANS_SVC, "not init auth channel");
1273         return SOFTBUS_NO_INIT;
1274     }
1275     if (SoftBusMutexLock(&g_authChannelList->lock) != SOFTBUS_OK) {
1276         TRANS_LOGE(TRANS_SVC, "get mutex lock failed");
1277         return SOFTBUS_LOCK_ERR;
1278     }
1279     AuthChannelInfo *info = NULL;
1280     LIST_FOR_EACH_ENTRY(info, &g_authChannelList->list, AuthChannelInfo, node) {
1281         if (info->connOpt.socketOption.port == connInfo->socketOption.port &&
1282             memcmp(info->connOpt.socketOption.addr, connInfo->socketOption.addr,
1283             strlen(connInfo->socketOption.addr)) == 0) {
1284             TRANS_LOGI(TRANS_SVC, "auth channel type is wifi");
1285             (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1286             return SOFTBUS_OK;
1287         }
1288     }
1289     (void)SoftBusMutexUnlock(&g_authChannelList->lock);
1290     TRANS_LOGE(TRANS_SVC, "auth channel is not exit");
1291     return SOFTBUS_TRANS_NODE_NOT_FOUND;
1292 }