From 825be9f09e0759d7746a98adbf53dac9ef419572 Mon Sep 17 00:00:00 2001 From: gouwenbo Date: Fri, 12 Apr 2024 00:31:34 +0800 Subject: [PATCH] feat:trans bind support cancel Signed-off-by: gouwenbo --- core/frame/small/init/src/trans_server_stub.c | 8 +- .../standard/init/include/if_softbus_server.h | 2 +- .../standard/init/include/softbus_server.h | 2 +- .../standard/init/src/softbus_server.cpp | 4 +- .../standard/init/src/softbus_server_stub.cpp | 23 +- .../ipc/standard/src/trans_client_proxy.cpp | 2 +- .../common/include/trans_channel_common.h | 17 +- .../common/include/trans_lane_pending_ctl.h | 4 +- .../common/src/trans_channel_common.c | 197 ++++++-- .../common/src/trans_lane_pending_ctl.c | 411 ++++++++-------- .../manager/include/trans_channel_manager.h | 4 +- .../manager/include/trans_lane_manager.h | 39 ++ .../manager/src/trans_channel_callback.c | 31 +- .../manager/src/trans_channel_manager.c | 142 +++--- .../manager/src/trans_lane_manager.c | 449 +++++++++++++++++- interfaces/kits/common/softbus_error_code.h | 1 + .../bus_center_server_proxy_standard.h | 2 +- .../src/bus_center_server_proxy_standard.cpp | 3 +- .../include/disc_server_proxy_standard.h | 2 +- .../src/disc_server_proxy_standard.cpp | 3 +- .../include/softbus_server_proxy_standard.h | 2 +- .../src/softbus_server_proxy_standard.cpp | 3 +- sdk/libsoftbus_client_map | 2 + .../ipc/include/trans_server_proxy.h | 2 +- .../ipc/mini/trans_server_proxy.c | 4 +- .../ipc/small/trans_server_proxy.c | 6 +- .../include/trans_server_proxy_standard.h | 2 +- .../ipc/standard/src/trans_server_proxy.cpp | 4 +- .../src/trans_server_proxy_standard.cpp | 11 +- .../include/client_trans_session_manager.h | 14 + .../src/client_trans_session_callback.c | 10 +- .../src/client_trans_session_manager.c | 77 ++- .../src/client_trans_session_service.c | 59 ++- .../auth/src/client_trans_auth_manager.c | 2 +- .../proxy/src/client_trans_proxy_manager.c | 2 +- .../src/client_trans_tcp_direct_manager.c | 2 +- .../udp/common/src/client_trans_udp_manager.c | 2 +- .../trans_channel/common/trans_lane_test.cpp | 4 +- .../trans_channel_manager_test.cpp | 16 +- .../trans_lane_manager_test.cpp | 53 +++ .../transserverproxyextern_fuzzer.cpp | 2 +- tests/sdk/transmission/ipc/trans_ipc_test.cpp | 8 +- .../client_trans_session_manager_test.cpp | 12 +- .../session/client_trans_session_test.cpp | 6 +- 44 files changed, 1249 insertions(+), 402 deletions(-) diff --git a/core/frame/small/init/src/trans_server_stub.c b/core/frame/small/init/src/trans_server_stub.c index 0bfbd8c2d4..0afeffe289 100644 --- a/core/frame/small/init/src/trans_server_stub.c +++ b/core/frame/small/init/src/trans_server_stub.c @@ -271,10 +271,14 @@ int32_t ServerCloseChannel(IpcIo *req, IpcIo *reply) int32_t ret; int32_t channelId = 0; int32_t channelType = 0; + const char *sessionName = NULL; + uint32_t size; ReadInt32(req, &channelId); ReadInt32(req, &channelType); - - ret = TransCloseChannel(channelId, channelType); + if (channelType == CHANNEL_TYPE_UNDEFINED) { + sessionName = (const char*)ReadString(req, &size); + } + ret = TransCloseChannel(sessionName, channelId, channelType); WriteInt32(reply, ret); return ret; diff --git a/core/frame/standard/init/include/if_softbus_server.h b/core/frame/standard/init/include/if_softbus_server.h index def68a22a8..62a1936e3c 100644 --- a/core/frame/standard/init/include/if_softbus_server.h +++ b/core/frame/standard/init/include/if_softbus_server.h @@ -40,7 +40,7 @@ public: virtual int32_t OpenSession(const SessionParam *param, TransInfo *info) = 0; virtual int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) = 0; virtual int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) = 0; - virtual int32_t CloseChannel(int32_t channelId, int32_t channelType) = 0; + virtual int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) = 0; virtual int32_t ReleaseResources(int32_t channelId) = 0; virtual int32_t SendMessage(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType) = 0; diff --git a/core/frame/standard/init/include/softbus_server.h b/core/frame/standard/init/include/softbus_server.h index 35b7c58e30..583561e353 100644 --- a/core/frame/standard/init/include/softbus_server.h +++ b/core/frame/standard/init/include/softbus_server.h @@ -40,7 +40,7 @@ public: int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) override; int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) override; int32_t ReleaseResources(int32_t channelId) override; - int32_t CloseChannel(int32_t channelId, int32_t channelType) override; + int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) override; int32_t SendMessage(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType) override; int32_t GetSoftbusSpecObject(sptr &object) override; diff --git a/core/frame/standard/init/src/softbus_server.cpp b/core/frame/standard/init/src/softbus_server.cpp index 6bae5106ad..b2827114c0 100644 --- a/core/frame/standard/init/src/softbus_server.cpp +++ b/core/frame/standard/init/src/softbus_server.cpp @@ -187,9 +187,9 @@ int32_t SoftBusServer::ReleaseResources(int32_t channelId) return TransReleaseUdpResources(channelId); } -int32_t SoftBusServer::CloseChannel(int32_t channelId, int32_t channelType) +int32_t SoftBusServer::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { - return TransCloseChannel(channelId, channelType); + return TransCloseChannel(sessionName, channelId, channelType); } int32_t SoftBusServer::SendMessage(int32_t channelId, int32_t channelType, const void *data, diff --git a/core/frame/standard/init/src/softbus_server_stub.cpp b/core/frame/standard/init/src/softbus_server_stub.cpp index 4e64abb292..1225aa9384 100644 --- a/core/frame/standard/init/src/softbus_server_stub.cpp +++ b/core/frame/standard/init/src/softbus_server_stub.cpp @@ -771,15 +771,26 @@ int32_t SoftBusServerStub::CloseChannelInner(MessageParcel &data, MessageParcel COMM_LOGE(COMM_SVC, "CloseChannelInner read channel channel type failed!"); return SOFTBUS_ERR; } + const char *sessionName = nullptr; pid_t callingPid = OHOS::IPCSkeleton::GetCallingPid(); - int32_t ret = TransGetAndComparePid(callingPid, channelId, channelType); - if (ret != SOFTBUS_OK) { - COMM_LOGE(COMM_SVC, "Pid can not close channel, pid = %{public}d, channelId = %{public}d, ret = %{public}d", - callingPid, channelId, ret); - return ret; + if (channelType == CHANNEL_TYPE_UNDEFINED) { + sessionName = data.ReadCString(); + int32_t ret = TransGetAndComparePidBySession(callingPid, sessionName, channelId); + if (ret != SOFTBUS_OK) { + COMM_LOGE(COMM_SVC, "Pid can not close channel, pid = %{public}d, sessionId = %{public}d, ret = %{public}d", + callingPid, channelId, ret); + return ret; + } + } else { + int32_t ret = TransGetAndComparePid(callingPid, channelId, channelType); + if (ret != SOFTBUS_OK) { + COMM_LOGE(COMM_SVC, "Pid can not close channel, pid = %{public}d, channelId = %{public}d, ret = %{public}d", + callingPid, channelId, ret); + return ret; + } } - int32_t retReply = CloseChannel(channelId, channelType); + int32_t retReply = CloseChannel(sessionName, channelId, channelType); if (!reply.WriteInt32(retReply)) { COMM_LOGE(COMM_SVC, "CloseChannelInner write reply failed!"); return SOFTBUS_ERR; diff --git a/core/transmission/ipc/standard/src/trans_client_proxy.cpp b/core/transmission/ipc/standard/src/trans_client_proxy.cpp index 7467f45bce..90d2e7d073 100644 --- a/core/transmission/ipc/standard/src/trans_client_proxy.cpp +++ b/core/transmission/ipc/standard/src/trans_client_proxy.cpp @@ -152,7 +152,7 @@ int32_t ClientIpcSetChannelInfo( CallProxySetChannelInfo(clientProxy, sessionName, sessionId, transInfo); }); if (task.wait_for(std::chrono::seconds(IPC_OPT_TIMEOUT_S)) != std::future_status::ready) { - char *tmpName = NULL; + char *tmpName = nullptr; Anonymize(sessionName, &tmpName); TRANS_LOGE(TRANS_SDK, "ClientIpcSetChannelInfo timeout!, pkgName=%{public}s sessionName=%{public}s", pkgName, tmpName); diff --git a/core/transmission/trans_channel/common/include/trans_channel_common.h b/core/transmission/trans_channel/common/include/trans_channel_common.h index fb6b2ec56c..553cf03c1e 100644 --- a/core/transmission/trans_channel/common/include/trans_channel_common.h +++ b/core/transmission/trans_channel/common/include/trans_channel_common.h @@ -21,6 +21,7 @@ #include #include "lnn_lane_interface.h" +#include "lnn_node_info.h" #include "softbus_app_info.h" #include "softbus_conn_interface.h" #include "softbus_trans_def.h" @@ -37,19 +38,29 @@ AppInfo *TransCommonGetAppInfo(const SessionParam *param); void TransOpenChannelSetModule(int32_t channelType, ConnectOption *connOpt); -void ReportTransOpenChannelEndEvent(TransEventExtra extra, TransInfo *transInfo, int64_t timeStart, int32_t ret); +void TransBuildTransOpenChannelStartEvent( + TransEventExtra *extra, AppInfo *appInfo, NodeInfo *nodeInfo, int32_t peerRet); -void ReportTransAlarmEvent(AppInfo *appInfo, int32_t ret); +void TransBuildTransOpenChannelEndEvent(TransEventExtra *extra, TransInfo *transInfo, int64_t timeStart, int32_t ret); + +void TransBuildTransOpenChannelCancelEvent( + TransEventExtra *extra, TransInfo *transInfo, int64_t timeStart, int32_t ret); + +void TransBuildTransAlarmEvent(TransAlarmExtra *extraAlarm, AppInfo *appInfo, int32_t ret); LaneTransType TransGetLaneTransTypeBySession(const SessionParam *param); int32_t TransOpenChannelProc(ChannelType type, AppInfo *appInfo, const ConnectOption *connOpt, int32_t *channelId); -int32_t TransCommonCloseChannel(int32_t channelId, int32_t channelType); +int32_t TransCommonCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType); int32_t TransCommonGetLocalConfig(int32_t channelType, int32_t businessType, uint32_t *len); +void TransFreeAppInfo(AppInfo *appInfo); + +void TransFreeLane(uint32_t laneHandle, bool isQosLane); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/core/transmission/trans_channel/common/include/trans_lane_pending_ctl.h b/core/transmission/trans_channel/common/include/trans_lane_pending_ctl.h index f88cdedc4c..6e6e949469 100644 --- a/core/transmission/trans_channel/common/include/trans_lane_pending_ctl.h +++ b/core/transmission/trans_channel/common/include/trans_lane_pending_ctl.h @@ -29,6 +29,8 @@ extern "C" { int32_t TransReqLanePendingInit(void); void TransReqLanePendingDeinit(void); +int32_t TransAsyncReqLanePendingInit(void); +void TransAsyncReqLanePendingDeinit(void); int32_t TransGetConnectOptByConnInfo(const LaneConnInfo *info, ConnectOption *connOpt); int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint32_t *laneHandle, bool *isQosLane); @@ -36,7 +38,7 @@ int32_t TransAsyncGetLaneInfo(const SessionParam *param, uint32_t *laneHandle, u int32_t TransGetLaneInfoByOption(const LaneRequestOption *requestOption, LaneConnInfo *connInfo, uint32_t *laneHandle); int32_t TransGetLaneInfoByQos(const LaneAllocInfo *allocInfo, LaneConnInfo *connInfo, uint32_t *laneHandle); bool TransGetAuthTypeByNetWorkId(const char *peerNetWorkId); - +int32_t TransCancelLaneItemCondByLaneHandle(uint32_t laneHandle, bool bSucc, bool isAsync, int32_t errCode); #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/core/transmission/trans_channel/common/src/trans_channel_common.c b/core/transmission/trans_channel/common/src/trans_channel_common.c index 208503b6b4..22784227aa 100644 --- a/core/transmission/trans_channel/common/src/trans_channel_common.c +++ b/core/transmission/trans_channel/common/src/trans_channel_common.c @@ -29,6 +29,7 @@ #include "trans_auth_manager.h" #include "trans_event.h" #include "trans_lane_manager.h" +#include "trans_lane_pending_ctl.h" #include "trans_log.h" #include "trans_session_manager.h" #include "trans_tcp_direct_manager.h" @@ -43,7 +44,7 @@ typedef struct { ConfigType configType; } ConfigTypeMap; -static const ConfigTypeMap G_CONFIG_TYPE_MAP[] = { +static const ConfigTypeMap g_configTypeMap[] = { { CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BYTE, SOFTBUS_INT_AUTH_MAX_BYTES_LENGTH }, { CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, SOFTBUS_INT_AUTH_MAX_MESSAGE_LENGTH}, { CHANNEL_TYPE_PROXY, BUSINESS_TYPE_BYTE, SOFTBUS_INT_MAX_BYTES_NEW_LENGTH }, @@ -54,9 +55,10 @@ static const ConfigTypeMap G_CONFIG_TYPE_MAP[] = { static int32_t FindConfigType(int32_t channelType, int32_t businessType) { - for (uint32_t i = 0; i < sizeof(G_CONFIG_TYPE_MAP) / sizeof(ConfigTypeMap); i++) { - if ((G_CONFIG_TYPE_MAP[i].channelType == channelType) && (G_CONFIG_TYPE_MAP[i].businessType == businessType)) { - return G_CONFIG_TYPE_MAP[i].configType; + const int32_t configTypeMapLength = sizeof(g_configTypeMap) / sizeof(ConfigTypeMap); + for (uint32_t i = 0; i < configTypeMapLength; i++) { + if ((g_configTypeMap[i].channelType == channelType) && (g_configTypeMap[i].businessType == businessType)) { + return g_configTypeMap[i].configType; } } return SOFTBUS_CONFIG_TYPE_MAX; @@ -77,6 +79,19 @@ static LaneTransType GetStreamLaneType(int32_t streamType) return LANE_T_BUTT; } +static void BuildTransCloseChannelEventExtra( + TransEventExtra *extra, int32_t channelId, int32_t channelType, int32_t ret) +{ + extra->socketName = NULL; + extra->peerNetworkId = NULL; + extra->calleePkg = NULL; + extra->callerPkg = NULL; + extra->channelId = channelId; + extra->channelType = channelType; + extra->errcode = ret; + extra->result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED; +} + LaneTransType TransGetLaneTransTypeBySession(const SessionParam *param) { if (param == NULL || param->attr == NULL) { @@ -317,60 +332,146 @@ int32_t TransOpenChannelProc(ChannelType type, AppInfo *appInfo, const ConnectOp return SOFTBUS_OK; } -int32_t TransCommonCloseChannel(int32_t channelId, int32_t channelType) +static int32_t CancelWaitLaneState(const char *sessionName, int32_t sessionId) +{ + uint32_t laneHandle = 0; + bool isAsync = true; + bool isQosLane = false; + int32_t ret = TransGetSocketChannelLaneInfoBySession(sessionName, sessionId, &laneHandle, &isQosLane, &isAsync); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, TRANS_CTRL, ret, "get socket channel lane info failed, ret=%{public}d", ret); + TRANS_LOGI(TRANS_CTRL, "wait lane state, sessionId=%{public}d, laneHandle=%{public}u", sessionId, laneHandle); + if (isQosLane && laneHandle != 0) { + GetLaneManager()->lnnCancelLane(laneHandle); + } + if (!isAsync && laneHandle != 0) { + TransCancelLaneItemCondByLaneHandle(laneHandle, false, false, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL); + } + TransFreeLane(laneHandle, isQosLane); + (void)TransDeleteSocketChannelInfoBySession(sessionName, sessionId); + return SOFTBUS_OK; +} + +int32_t TransCommonCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { TRANS_LOGI(TRANS_CTRL, "close channel: channelId=%{public}d, channelType=%{public}d", channelId, channelType); int32_t ret = SOFTBUS_ERR; - switch (channelType) { - case CHANNEL_TYPE_PROXY: - (void)TransLaneMgrDelLane(channelId, channelType); - ret = TransProxyCloseProxyChannel(channelId); - break; - case CHANNEL_TYPE_TCP_DIRECT: - (void)TransLaneMgrDelLane(channelId, channelType); - ret = SOFTBUS_OK; - break; - case CHANNEL_TYPE_UDP: - (void)NotifyQosChannelClosed(channelId, channelType); - (void)TransLaneMgrDelLane(channelId, channelType); - ret = TransCloseUdpChannel(channelId); - break; - case CHANNEL_TYPE_AUTH: - ret = TransCloseAuthChannel(channelId); - break; - default: - break; + if (channelType == CHANNEL_TYPE_UNDEFINED) { + CoreSessionState state = CORE_SESSION_STATE_INIT; + ret = TransGetSocketChannelStateBySession(sessionName, channelId, &state); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, TRANS_CTRL, ret, "get socket channel info failed, ret=%{public}d", ret); + (void)TransSetSocketChannelStateBySession(sessionName, channelId, CORE_SESSION_STATE_CANCELLING); + if (state == CORE_SESSION_STATE_WAIT_LANE) { + ret = CancelWaitLaneState(sessionName, channelId); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, TRANS_CTRL, ret, "cancel wait lane failed, ret=%{public}d", ret); + } + } else { + (void)TransSetSocketChannelStateByChannel(channelId, channelType, CORE_SESSION_STATE_CANCELLING); + switch (channelType) { + case CHANNEL_TYPE_PROXY: + (void)TransLaneMgrDelLane(channelId, channelType); + ret = TransProxyCloseProxyChannel(channelId); + break; + case CHANNEL_TYPE_TCP_DIRECT: + (void)TransLaneMgrDelLane(channelId, channelType); + ret = SOFTBUS_OK; + break; + case CHANNEL_TYPE_UDP: + (void)NotifyQosChannelClosed(channelId, channelType); + (void)TransLaneMgrDelLane(channelId, channelType); + ret = TransCloseUdpChannel(channelId); + break; + case CHANNEL_TYPE_AUTH: + ret = TransCloseAuthChannel(channelId); + break; + default: + TRANS_LOGE(TRANS_CTRL, "Unknow channel type, type=%{public}d", channelType); + break; + } + (void)TransDeleteSocketChannelInfoByChannel(channelId, channelType); } - TransEventExtra extra = { .socketName = NULL, - .peerNetworkId = NULL, - .calleePkg = NULL, - .callerPkg = NULL, - .channelId = channelId, - .channelType = channelType, - .errcode = ret, - .result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED }; + TransEventExtra extra; + BuildTransCloseChannelEventExtra(&extra, channelId, channelType, ret); TRANS_EVENT(EVENT_SCENE_CLOSE_CHANNEL_ACTIVE, EVENT_STAGE_CLOSE_CHANNEL, extra); return ret; } -void ReportTransOpenChannelEndEvent(TransEventExtra extra, TransInfo *transInfo, int64_t timeStart, int32_t ret) +void TransBuildTransOpenChannelStartEvent(TransEventExtra *extra, AppInfo *appInfo, NodeInfo *nodeInfo, int32_t peerRet) +{ + if (extra == NULL || appInfo == NULL || nodeInfo == NULL) { + TRANS_LOGE(TRANS_CTRL, "invalid param."); + return; + } + extra->calleePkg = NULL; + extra->callerPkg = appInfo->myData.pkgName; + extra->socketName = appInfo->myData.sessionName; + extra->dataType = appInfo->businessType; + extra->peerNetworkId = appInfo->peerNetWorkId; + extra->peerUdid = peerRet == SOFTBUS_OK ? nodeInfo->deviceInfo.deviceUdid : NULL, + extra->peerDevVer = peerRet == SOFTBUS_OK ? nodeInfo->deviceInfo.deviceVersion : NULL, + extra->result = EVENT_STAGE_RESULT_OK; +} + +void TransBuildTransOpenChannelEndEvent(TransEventExtra *extra, TransInfo *transInfo, int64_t timeStart, int32_t ret) +{ + if (extra == NULL || transInfo == NULL) { + TRANS_LOGE(TRANS_CTRL, "invalid param."); + return; + } + extra->channelId = transInfo->channelId; + extra->errcode = ret; + extra->costTime = GetSoftbusRecordTimeMillis() - timeStart; + extra->result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED; +} + +void TransBuildTransOpenChannelCancelEvent(TransEventExtra *extra, TransInfo *transInfo, int64_t timeStart, int32_t ret) +{ + if (extra == NULL || transInfo == NULL) { + TRANS_LOGE(TRANS_CTRL, "invalid param."); + return; + } + extra->channelId = transInfo->channelId; + extra->errcode = ret; + extra->costTime = GetSoftbusRecordTimeMillis() - timeStart; + extra->result = EVENT_STAGE_RESULT_CANCELED; +} + +void TransBuildTransAlarmEvent(TransAlarmExtra *extraAlarm, AppInfo *appInfo, int32_t ret) { - extra.channelId = transInfo->channelId; - extra.errcode = ret; - extra.costTime = GetSoftbusRecordTimeMillis() - timeStart; - extra.result = EVENT_STAGE_RESULT_FAILED; - TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra); + if (extraAlarm == NULL || appInfo == NULL) { + TRANS_LOGE(TRANS_CTRL, "invalid param."); + return; + } + extraAlarm->conflictName = NULL; + extraAlarm->conflictedName = NULL; + extraAlarm->occupyedName = NULL; + extraAlarm->permissionName = NULL; + extraAlarm->errcode = ret; + extraAlarm->sessionName = appInfo->myData.sessionName; } -void ReportTransAlarmEvent(AppInfo *appInfo, int32_t ret) +void TransFreeAppInfo(AppInfo *appInfo) { - TransAlarmExtra extraAlarm = { - .conflictName = NULL, - .conflictedName = NULL, - .occupyedName = NULL, - .permissionName = NULL, - .errcode = ret, - .sessionName = appInfo->myData.sessionName, - }; - TRANS_ALARM(OPEN_SESSION_FAIL_ALARM, CONTROL_ALARM_TYPE, extraAlarm); + if (appInfo == NULL) { + TRANS_LOGE(TRANS_CTRL, "invalid param."); + return; + } + if (appInfo->fastTransData != NULL) { + SoftBusFree((void *)(appInfo->fastTransData)); + } + SoftBusFree(appInfo); +} + +void TransFreeLane(uint32_t laneHandle, bool isQosLane) +{ + TRANS_LOGI(TRANS_CTRL, "Trans free lane laneHandle=%{public}u, isQosLane=%{public}d", laneHandle, isQosLane); + if (laneHandle != 0) { + if (isQosLane) { + GetLaneManager()->lnnFreeLane(laneHandle); + return; + } + LnnFreeLane(laneHandle); + } } \ No newline at end of file diff --git a/core/transmission/trans_channel/common/src/trans_lane_pending_ctl.c b/core/transmission/trans_channel/common/src/trans_lane_pending_ctl.c index f4ab1dd1cb..13b057fecc 100644 --- a/core/transmission/trans_channel/common/src/trans_lane_pending_ctl.c +++ b/core/transmission/trans_channel/common/src/trans_lane_pending_ctl.c @@ -69,36 +69,39 @@ int32_t TransReqLanePendingInit(void) TRANS_LOGE(TRANS_INIT, "g_reqLanePendingList is null."); return SOFTBUS_ERR; } + return SOFTBUS_OK; +} +int32_t TransAsyncReqLanePendingInit(void) +{ g_asyncReqLanePendingList = CreateSoftBusList(); if (g_asyncReqLanePendingList == NULL) { TRANS_LOGE(TRANS_INIT, "g_asyncReqLanePendingList is null."); return SOFTBUS_ERR; } - return SOFTBUS_OK; } static void DestroyAsyncReqItemParam(SessionParam *param) { if (param->sessionName != NULL) { - SoftBusFree((void*)(param->sessionName)); + SoftBusFree((void *)(param->sessionName)); param->sessionName = NULL; } if (param->peerSessionName != NULL) { - SoftBusFree((void*)(param->peerSessionName)); + SoftBusFree((void *)(param->peerSessionName)); param->peerSessionName = NULL; } if (param->peerDeviceId != NULL) { - SoftBusFree((void*)(param->peerDeviceId)); + SoftBusFree((void *)(param->peerDeviceId)); param->peerDeviceId = NULL; } if (param->groupId != NULL) { - SoftBusFree((void*)(param->groupId)); + SoftBusFree((void *)(param->groupId)); param->groupId = NULL; } if (param->attr != NULL) { - SoftBusFree((void*)(param->attr)); + SoftBusFree((void *)(param->attr)); param->attr = NULL; } } @@ -126,7 +129,11 @@ void TransReqLanePendingDeinit(void) (void)SoftBusMutexUnlock(&g_reqLanePendingList->lock); DestroySoftBusList(g_reqLanePendingList); g_reqLanePendingList = NULL; +} +void TransAsyncReqLanePendingDeinit(void) +{ + TRANS_LOGI(TRANS_SVC, "enter."); if (g_asyncReqLanePendingList == NULL) { TRANS_LOGE(TRANS_INIT, "g_asyncReqLanePendingList is null."); return; @@ -137,8 +144,8 @@ void TransReqLanePendingDeinit(void) return; } - item = NULL; - next = NULL; + TransReqLaneItem *item = NULL; + TransReqLaneItem *next = NULL; LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_asyncReqLanePendingList->list, TransReqLaneItem, node) { ListDelete(&item->node); DestroyAsyncReqItemParam(&(item->param)); @@ -223,36 +230,18 @@ static int32_t TransAddLaneReqFromPendingList(uint32_t laneHandle) return SOFTBUS_OK; } -static void ReportTransEventExtra(const SessionParam *param, const LaneConnInfo *connInfo, const uint32_t *laneHandle, - LaneRequestOption requestOption, int32_t ret) +static void BuildTransEventExtra( + TransEventExtra *extra, const SessionParam *param, uint32_t laneHandle, LaneTransType transType, int32_t ret) { - TransEventExtra extra = { - .calleePkg = NULL, - .callerPkg = NULL, - .socketName = param->sessionName, - .laneId = (int32_t)*laneHandle, - .peerNetworkId = param->peerDeviceId, - .laneTransType = requestOption.requestInfo.trans.transType, - .linkType = connInfo->type, - .errcode = ret, - .result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED }; - TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); -} - -static void ReportTransEventExtraWithAllocInfo(const SessionParam *param, const LaneConnInfo *connInfo, - const uint32_t *laneHandle, LaneAllocInfo allocInfo, int32_t ret) -{ - TransEventExtra extra = { - .calleePkg = NULL, - .callerPkg = NULL, - .socketName = param->sessionName, - .laneId = (int32_t)*laneHandle, - .peerNetworkId = param->peerDeviceId, - .laneTransType = allocInfo.transType, - .linkType = connInfo->type, - .errcode = ret, - .result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED }; - TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); + extra->calleePkg = NULL; + extra->callerPkg = NULL; + extra->socketName = param->sessionName; + extra->laneId = (int32_t)laneHandle; + extra->peerNetworkId = param->peerDeviceId; + extra->laneTransType = transType; + extra->errcode = ret; + extra->result = (ret == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED; + extra->result = (ret == SOFTBUS_TRANS_STOP_BIND_BY_CANCEL) ? EVENT_STAGE_RESULT_CANCELED : extra->result; } static void CallBackOpenChannelFailed(const SessionParam *param, const AppInfo *appInfo, int32_t errCode) @@ -474,85 +463,90 @@ static int32_t TransUpdateLaneConnInfoByLaneHandle(uint32_t laneHandle, bool bSu static void TransOnLaneRequestSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo) { - TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u", laneHandle); + TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u, laneId=%{public}" PRIu64, + laneHandle, connInfo->laneId); int32_t ret = TransUpdateLaneConnInfoByLaneHandle(laneHandle, true, connInfo, false, SOFTBUS_OK); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SVC, "update lane connInfo failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret); } } -static void TransOnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo) +static void RecordFailOpenSessionKpi(AppInfo *appInfo, LaneConnInfo *connInfo, int64_t timeStart) { - TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u, laneId=%{public}" PRIu64 "", - laneHandle, connInfo->laneId); - int32_t ret = TransUpdateLaneConnInfoByLaneHandle(laneHandle, true, connInfo, false, SOFTBUS_OK); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SVC, "update lane connInfo failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret); - } + SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, connInfo->type, SOFTBUS_EVT_OPEN_SESSION_FAIL, + GetSoftbusRecordTimeMillis() - timeStart); } static void TransAsyncOpenChannelProc(uint32_t laneHandle, SessionParam *param, AppInfo *appInfo, - TransEventExtra extra, LaneConnInfo *connInnerInfo) + TransEventExtra *extra, LaneConnInfo *connInnerInfo) { int64_t timeStart = GetSoftbusRecordTimeMillis(); TransInfo transInfo = { .channelId = INVALID_CHANNEL_ID, .channelType = CHANNEL_TYPE_BUTT}; ConnectOption connOpt; (void)memset_s(&connOpt, sizeof(ConnectOption), 0, sizeof(ConnectOption)); - int32_t errCode = TransGetConnectOptByConnInfo(connInnerInfo, &connOpt); - if (errCode != SOFTBUS_OK) { - SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, connInnerInfo->type, SOFTBUS_EVT_OPEN_SESSION_FAIL, - GetSoftbusRecordTimeMillis() - timeStart); - CallBackOpenChannelFailed(param, appInfo, errCode); + CoreSessionState state = CORE_SESSION_STATE_INIT; + int32_t ret = TransGetConnectOptByConnInfo(connInnerInfo, &connOpt); + if (ret != SOFTBUS_OK) { + RecordFailOpenSessionKpi(appInfo, connInnerInfo, timeStart); goto EXIT_ERR; } appInfo->connectType = connOpt.type; - extra.linkType = connOpt.type; + extra->linkType = connOpt.type; FillAppInfo(appInfo, param, &transInfo, connInnerInfo); TransOpenChannelSetModule(transInfo.channelType, &connOpt); - TRANS_LOGI(TRANS_SVC, "laneHandle=%{public}u, , channelType=%{public}u", laneHandle, transInfo.channelType); - errCode = TransOpenChannelProc((ChannelType)transInfo.channelType, appInfo, &connOpt, &(transInfo.channelId)); - if (errCode != SOFTBUS_OK) { + TRANS_LOGI(TRANS_SVC, "laneHandle=%{public}u, channelType=%{public}u", laneHandle, transInfo.channelType); + ret = TransOpenChannelProc((ChannelType)transInfo.channelType, appInfo, &connOpt, &(transInfo.channelId)); + if (ret != SOFTBUS_OK) { SoftbusReportTransErrorEvt(SOFTBUS_TRANS_CREATE_CHANNEL_ERR); - SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, appInfo->linkType, SOFTBUS_EVT_OPEN_SESSION_FAIL, - GetSoftbusRecordTimeMillis() - timeStart); - CallBackOpenChannelFailed(param, appInfo, errCode); + RecordFailOpenSessionKpi(appInfo, connInnerInfo, timeStart); goto EXIT_ERR; } - if (param->isAsync && ClientIpcSetChannelInfo(appInfo->myData.pkgName, param->sessionName, - param->sessionId, &transInfo, appInfo->myData.pid) != SOFTBUS_OK) { - CallBackOpenChannelFailed(param, appInfo, errCode); - TransCommonCloseChannel(transInfo.channelId, transInfo.channelType); + TransUpdateSocketChannelInfoBySession( + param->sessionName, param->sessionId, transInfo.channelId, transInfo.channelType); + ret = ClientIpcSetChannelInfo( + appInfo->myData.pkgName, param->sessionName, param->sessionId, &transInfo, appInfo->myData.pid); + if (ret != SOFTBUS_OK) { + RecordFailOpenSessionKpi(appInfo, connInnerInfo, timeStart); + TransCommonCloseChannel(NULL, transInfo.channelId, transInfo.channelType); goto EXIT_ERR; } + TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + TRANS_LOGI(TRANS_SVC, "Cancel state laneHandle=%{public}u, close channel.", laneHandle); + TransCommonCloseChannel(NULL, transInfo.channelId, transInfo.channelType); + goto EXIT_CANCEL; + } + TransSetSocketChannelStateByChannel(transInfo.channelId, transInfo.channelType, CORE_SESSION_STATE_CHANNEL_OPENED); if (((ChannelType)transInfo.channelType == CHANNEL_TYPE_TCP_DIRECT) && (connOpt.type != CONNECT_P2P)) { - if (param->isQosLane) { - GetLaneManager()->lnnFreeLane(laneHandle); - return; - } - LnnFreeLane(laneHandle); + TransFreeLane(laneHandle, param->isQosLane); } else if (TransLaneMgrAddLane(transInfo.channelId, transInfo.channelType, connInnerInfo, laneHandle, param->isQosLane, &(appInfo->myData)) != SOFTBUS_OK) { - SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, appInfo->linkType, SOFTBUS_EVT_OPEN_SESSION_FAIL, - GetSoftbusRecordTimeMillis() - timeStart); - TransCommonCloseChannel(transInfo.channelId, transInfo.channelType); + RecordFailOpenSessionKpi(appInfo, connInnerInfo, timeStart); + TransCommonCloseChannel(NULL, transInfo.channelId, transInfo.channelType); goto EXIT_ERR; } return; EXIT_ERR: - ReportTransOpenChannelEndEvent(extra, &transInfo, timeStart, errCode); - ReportTransAlarmEvent(appInfo, errCode); - if (laneHandle != 0) { - if (param->isQosLane) { - GetLaneManager()->lnnFreeLane(laneHandle); - } else { - LnnFreeLane(laneHandle); - } - } - TRANS_LOGE(TRANS_SVC, "server TransOpenChannel err, ret=%{public}d", errCode); + TransBuildTransOpenChannelEndEvent(extra, &transInfo, timeStart, ret); + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, *extra); + TransAlarmExtra extraAlarm; + TransBuildTransAlarmEvent(&extraAlarm, appInfo, ret); + TRANS_ALARM(OPEN_SESSION_FAIL_ALARM, CONTROL_ALARM_TYPE, extraAlarm); + CallBackOpenChannelFailed(param, appInfo, ret); + TransFreeLane(laneHandle, param->isQosLane); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); + TRANS_LOGE(TRANS_SVC, "server TransOpenChannel err, ret=%{public}d", ret); + return; +EXIT_CANCEL: + TransBuildTransOpenChannelCancelEvent(extra, &transInfo, timeStart, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL); + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, *extra); + TransFreeLane(laneHandle, param->isQosLane); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); + TRANS_LOGE(TRANS_SVC, "server open channel cancel"); return; } -static void TransOnAsyncLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo) +static void TransOnAsyncLaneSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo) { TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u, laneId=%{public}" PRIu64 "", laneHandle, connInfo->laneId); @@ -570,71 +564,40 @@ static void TransOnAsyncLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo return; } LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(¶m); - LaneAllocInfo laneAllocInfo = { - .transType = transType, - }; - ReportTransEventExtraWithAllocInfo(¶m, &tmpConnInfo, &laneHandle, laneAllocInfo, SOFTBUS_OK); - AppInfo *appInfo = TransCommonGetAppInfo(¶m); - TRANS_CHECK_AND_RETURN_LOGW(!(appInfo == NULL), TRANS_SVC, "GetAppInfo is null."); - appInfo->firstTokenId = firstTokenId; - char peerUdid[UDID_BUF_LEN] = {0}; - int32_t udidRet = LnnGetRemoteStrInfo(appInfo->peerNetWorkId, STRING_KEY_DEV_UDID, peerUdid, sizeof(peerUdid)); - TransEventExtra extra = { - .calleePkg = NULL, - .callerPkg = appInfo->myData.pkgName, - .socketName = appInfo->myData.sessionName, - .dataType = appInfo->businessType, - .peerNetworkId = appInfo->peerNetWorkId, - .peerUdid = udidRet == SOFTBUS_OK ? peerUdid : NULL, - .result = EVENT_STAGE_RESULT_OK - }; - TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra); - TransAsyncOpenChannelProc(laneHandle, ¶m, appInfo, extra, &tmpConnInfo); - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)(appInfo->fastTransData)); - } - SoftBusFree(appInfo); - (void)TransDelLaneReqFromPendingList(laneHandle, true); -} - -static void TransOnAsyncLaneAllocFail(uint32_t laneHandle, int32_t reason) -{ - TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason); - SessionParam param; - uint32_t firstTokenId = 0; - int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, ¶m, &firstTokenId); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret); + TransEventExtra extra; + BuildTransEventExtra(&extra, ¶m, laneHandle, transType, SOFTBUS_OK); + extra.linkType = tmpConnInfo.type; + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); + CoreSessionState state = CORE_SESSION_STATE_INIT; + TransGetSocketChannelStateBySession(param.sessionName, param.sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + TRANS_LOGI( + TRANS_SVC, "cancel state laneHandle=%{public}u, laneId=%{public}" PRId64, laneHandle, connInfo->laneId); + TransFreeLane(laneHandle, param.isQosLane); + BuildTransEventExtra(&extra, ¶m, laneHandle, transType, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL); + extra.linkType = tmpConnInfo.type; + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); (void)TransDelLaneReqFromPendingList(laneHandle, true); + (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId); return; } - LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(¶m); - LaneAllocInfo laneAllocInfo = { - .transType = transType, - }; - LaneConnInfo connInfo = { - .type = LANE_LINK_TYPE_BUTT, // failed case unknow type - }; - ReportTransEventExtraWithAllocInfo(¶m, &connInfo, &laneHandle, laneAllocInfo, SOFTBUS_ERR); + TransSetSocketChannelStateBySession(param.sessionName, param.sessionId, CORE_SESSION_STATE_LAN_COMPLETE); AppInfo *appInfo = TransCommonGetAppInfo(¶m); TRANS_CHECK_AND_RETURN_LOGW(!(appInfo == NULL), TRANS_SVC, "GetAppInfo is null."); appInfo->firstTokenId = firstTokenId; - CallBackOpenChannelFailed(¶m, appInfo, reason); + NodeInfo nodeInfo; + (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo)); + int32_t peerRet = LnnGetRemoteNodeInfoById(appInfo->peerNetWorkId, CATEGORY_NETWORK_ID, &nodeInfo); + TransBuildTransOpenChannelStartEvent(&extra, appInfo, &nodeInfo, peerRet); + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra); + TransAsyncOpenChannelProc(laneHandle, ¶m, appInfo, &extra, &tmpConnInfo); + TransFreeAppInfo(appInfo); (void)TransDelLaneReqFromPendingList(laneHandle, true); - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)appInfo->fastTransData); - } - SoftBusFree(appInfo); } -static void TransOnAsyncLaneRequestSuccess(uint32_t laneHandle, const LaneConnInfo *connInfo) +static void TransOnAsyncLaneFail(uint32_t laneHandle, int32_t reason) { - TRANS_LOGI(TRANS_SVC, "request success. laneHandle=%{public}u", laneHandle); - LaneConnInfo tmpConnInfo; - if (memcpy_s(&tmpConnInfo, sizeof(LaneConnInfo), connInfo, sizeof(LaneConnInfo)) != EOK) { - TRANS_LOGE(TRANS_SVC, "memcpy tmpConnInfo failed"); - return; - } + TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason); SessionParam param; uint32_t firstTokenId = 0; int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, ¶m, &firstTokenId); @@ -644,31 +607,17 @@ static void TransOnAsyncLaneRequestSuccess(uint32_t laneHandle, const LaneConnIn return; } LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(¶m); - LaneRequestOption requestOption = { - .requestInfo.trans.transType = transType, - }; - ReportTransEventExtra(¶m, &tmpConnInfo, &laneHandle, requestOption, SOFTBUS_OK); + TransEventExtra extra; + BuildTransEventExtra(&extra, ¶m, laneHandle, transType, SOFTBUS_ERR); + extra.linkType = LANE_LINK_TYPE_BUTT; + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); AppInfo *appInfo = TransCommonGetAppInfo(¶m); TRANS_CHECK_AND_RETURN_LOGW(!(appInfo == NULL), TRANS_SVC, "GetAppInfo is null."); appInfo->firstTokenId = firstTokenId; - char peerUdid[UDID_BUF_LEN] = {0}; - int32_t udidRet = LnnGetRemoteStrInfo(appInfo->peerNetWorkId, STRING_KEY_DEV_UDID, peerUdid, sizeof(peerUdid)); - TransEventExtra extra = { - .calleePkg = NULL, - .callerPkg = appInfo->myData.pkgName, - .socketName = appInfo->myData.sessionName, - .dataType = appInfo->businessType, - .peerNetworkId = appInfo->peerNetWorkId, - .peerUdid = udidRet == SOFTBUS_OK ? peerUdid : NULL, - .result = EVENT_STAGE_RESULT_OK - }; - TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra); - TransAsyncOpenChannelProc(laneHandle, ¶m, appInfo, extra, &tmpConnInfo); - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)(appInfo->fastTransData)); - } - SoftBusFree(appInfo); + CallBackOpenChannelFailed(¶m, appInfo, reason); (void)TransDelLaneReqFromPendingList(laneHandle, true); + TransFreeAppInfo(appInfo); + (void)TransDeleteSocketChannelInfoBySession(param.sessionName, param.sessionId); } static void TransOnLaneRequestFail(uint32_t laneHandle, int32_t reason) @@ -680,45 +629,6 @@ static void TransOnLaneRequestFail(uint32_t laneHandle, int32_t reason) } } -static void TransOnLaneAllocFail(uint32_t laneHandle, int32_t reason) -{ - TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason); - int32_t ret = TransUpdateLaneConnInfoByLaneHandle(laneHandle, false, NULL, false, reason); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SVC, "update lane connInfo failed, laneHandle=%{public}u, ret=%{public}d", laneHandle, ret); - } -} - -static void TransOnAsyncLaneRequestFail(uint32_t laneHandle, int32_t reason) -{ - TRANS_LOGI(TRANS_SVC, "request failed, laneHandle=%{public}u, reason=%{public}d", laneHandle, reason); - SessionParam param; - uint32_t firstTokenId = 0; - int32_t ret = TransGetLaneReqItemParamByLaneHandle(laneHandle, ¶m, &firstTokenId); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SVC, "get lane req item failed. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret); - (void)TransDelLaneReqFromPendingList(laneHandle, true); - return; - } - LaneTransType transType = (LaneTransType)TransGetLaneTransTypeBySession(¶m); - LaneRequestOption requestOption = { - .requestInfo.trans.transType = transType, - }; - LaneConnInfo connInfo = { - .type = LANE_LINK_TYPE_BUTT, // failed case unknow type - }; - ReportTransEventExtra(¶m, &connInfo, &laneHandle, requestOption, SOFTBUS_ERR); - AppInfo *appInfo = TransCommonGetAppInfo(¶m); - TRANS_CHECK_AND_RETURN_LOGW(!(appInfo == NULL), TRANS_SVC, "GetAppInfo is null."); - appInfo->firstTokenId = firstTokenId; - CallBackOpenChannelFailed(¶m, appInfo, reason); - (void)TransDelLaneReqFromPendingList(laneHandle, true); - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)appInfo->fastTransData); - } - SoftBusFree(appInfo); -} - static const LaneLinkType g_laneMap[LINK_TYPE_MAX + 1] = { LANE_LINK_TYPE_BUTT, LANE_WLAN_5G, @@ -1043,8 +953,8 @@ static int32_t TransAddLaneAllocToPendingAndWaiting(uint32_t laneHandle, const L return ret; } LaneAllocListener allocListener; - allocListener.OnLaneAllocSuccess = TransOnLaneAllocSuccess; - allocListener.OnLaneAllocFail = TransOnLaneAllocFail; + allocListener.OnLaneAllocSuccess = TransOnLaneRequestSuccess; + allocListener.OnLaneAllocFail = TransOnLaneRequestFail; ret = GetLaneManager()->lnnAllocLane(laneHandle, allocInfo, &allocListener); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SVC, "trans request lane failed, ret=%{public}d", ret); @@ -1059,6 +969,19 @@ static int32_t TransAddLaneAllocToPendingAndWaiting(uint32_t laneHandle, const L return SOFTBUS_OK; } +static void CancelLaneOnWaitLaneState(uint32_t laneHandle, bool isQosLane) +{ + TRANS_LOGI(TRANS_SVC, "Cancel lane, laneHandle=%{public}u, isQosLane=%{public}d", laneHandle, isQosLane); + if (isQosLane && laneHandle != 0) { + int32_t ret = GetLaneManager()->lnnCancelLane(laneHandle); + if (ret != SOFTBUS_OK) { + TRANS_LOGE( + TRANS_SVC, "Cancel lane failed, free lane. laneHandle=%{public}u, ret=%{public}d", laneHandle, ret); + TransFreeLane(laneHandle, isQosLane); + } + } +} + int32_t TransGetLaneInfoByOption(const LaneRequestOption *requestOption, LaneConnInfo *connInfo, uint32_t *laneHandle) { if ((requestOption == NULL) || (connInfo == NULL) || (laneHandle == NULL)) { @@ -1091,7 +1014,6 @@ int32_t TransGetLaneInfoByQos(const LaneAllocInfo *allocInfo, LaneConnInfo *conn TRANS_LOGE(TRANS_SVC, "get lane info param error."); return SOFTBUS_INVALID_PARAM; } - *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS); if (TransAddLaneAllocToPendingAndWaiting(*laneHandle, allocInfo) != SOFTBUS_OK) { TRANS_LOGE(TRANS_SVC, "trans add lane to pending list failed."); return SOFTBUS_ERR; @@ -1117,6 +1039,13 @@ int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint TRANS_LOGE(TRANS_SVC, "get lane info param error."); return SOFTBUS_INVALID_PARAM; } + CoreSessionState state = CORE_SESSION_STATE_INIT; + TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + TRANS_LOGI(TRANS_SVC, "cancel state, return cancel code."); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; + } + TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_WAIT_LANE); *isQosLane = param->isQosLane; LaneRequestOption requestOption; (void)memset_s(&requestOption, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption)); @@ -1125,13 +1054,16 @@ int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint TRANS_LOGE(TRANS_SVC, "get request option failed. laneHandle=%{public}u, ret=%{public}d", *laneHandle, ret); return ret; } + TransEventExtra extra; if (!(*isQosLane)) { ret = TransGetLaneInfoByOption(&requestOption, connInfo, laneHandle); - ReportTransEventExtra(param, connInfo, laneHandle, requestOption, ret); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SVC, "get lane info by option failed, ret=%{public}d", ret); - return ret; - } + BuildTransEventExtra(&extra, param, *laneHandle, requestOption.requestInfo.trans.transType, ret); + extra.linkType = connInfo->type; + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, ret, TRANS_SVC, "get lane info by option failed, ret=%{public}d", ret); + TransUpdateSocketChannelLaneInfoBySession( + param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync); } else { LaneAllocInfo allocInfo; (void)memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)); @@ -1140,12 +1072,15 @@ int32_t TransGetLaneInfo(const SessionParam *param, LaneConnInfo *connInfo, uint TRANS_LOGE(TRANS_SVC, "get alloc Info failed. laneHandle=%{public}u, ret=%{public}d", *laneHandle, ret); return ret; } + *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS); + TransUpdateSocketChannelLaneInfoBySession( + param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync); ret = TransGetLaneInfoByQos(&allocInfo, connInfo, laneHandle); - ReportTransEventExtraWithAllocInfo(param, connInfo, laneHandle, allocInfo, ret); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SVC, "get lane info by allocInfo failed, ret=%{public}d", ret); - return ret; - } + BuildTransEventExtra(&extra, param, *laneHandle, allocInfo.transType, ret); + extra.linkType = connInfo->type; + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_SELECT_LANE, extra); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, ret, TRANS_SVC, "get lane info by allocInfo failed, ret=%{public}d", ret); } return SOFTBUS_OK; } @@ -1158,6 +1093,8 @@ int32_t TransAsyncGetLaneInfoByOption(const SessionParam *param, const LaneReque return SOFTBUS_INVALID_PARAM; } *laneHandle = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_TRANS); + TransUpdateSocketChannelLaneInfoBySession( + param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync); int32_t ret = TransAddAsyncLaneReqFromPendingList(*laneHandle, param, firstTokenId); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SVC, "add laneHandle to pending failed. laneHandle=%{public}u, ret=%{public}d", @@ -1165,14 +1102,22 @@ int32_t TransAsyncGetLaneInfoByOption(const SessionParam *param, const LaneReque return ret; } ILaneListener listener; - listener.OnLaneRequestSuccess = TransOnAsyncLaneRequestSuccess; - listener.OnLaneRequestFail = TransOnAsyncLaneRequestFail; + listener.OnLaneRequestSuccess = TransOnAsyncLaneSuccess; + listener.OnLaneRequestFail = TransOnAsyncLaneFail; ret = LnnRequestLane(*laneHandle, requestOption, &listener); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SVC, "trans request lane failed, ret=%{public}d", ret); (void)TransDelLaneReqFromPendingList(*laneHandle, true); return ret; } + CoreSessionState state = CORE_SESSION_STATE_INIT; + TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + CancelLaneOnWaitLaneState(*laneHandle, param->isQosLane); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; + } + TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_WAIT_LANE); return SOFTBUS_OK; } @@ -1190,15 +1135,25 @@ int32_t TransAsyncGetLaneInfoByQos(const SessionParam *param, const LaneAllocInf *laneHandle, ret); return ret; } + TransUpdateSocketChannelLaneInfoBySession( + param->sessionName, param->sessionId, *laneHandle, param->isQosLane, param->isAsync); LaneAllocListener allocListener; - allocListener.OnLaneAllocSuccess = TransOnAsyncLaneAllocSuccess; - allocListener.OnLaneAllocFail = TransOnAsyncLaneAllocFail; + allocListener.OnLaneAllocSuccess = TransOnAsyncLaneSuccess; + allocListener.OnLaneAllocFail = TransOnAsyncLaneFail; ret = GetLaneManager()->lnnAllocLane(*laneHandle, allocInfo, &allocListener); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SVC, "trans request lane failed, ret=%{public}d", ret); (void)TransDelLaneReqFromPendingList(*laneHandle, true); return ret; } + CoreSessionState state = CORE_SESSION_STATE_INIT; + TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + CancelLaneOnWaitLaneState(*laneHandle, param->isQosLane); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; + } + TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_WAIT_LANE); return SOFTBUS_OK; } @@ -1363,4 +1318,34 @@ bool TransGetAuthTypeByNetWorkId(const char *peerNetWorkId) return false; } return ((uint32_t)value == (1 << ONLINE_METANODE)) ? true : false; +} + +int32_t TransCancelLaneItemCondByLaneHandle(uint32_t laneHandle, bool bSucc, bool isAsync, int32_t errCode) +{ + SoftBusList *pendingList = isAsync ? g_asyncReqLanePendingList : g_reqLanePendingList; + if (pendingList == NULL) { + TRANS_LOGE(TRANS_SVC, "lane pending list no init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(pendingList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed."); + return SOFTBUS_LOCK_ERR; + } + + TransReqLaneItem *item = NULL; + LIST_FOR_EACH_ENTRY(item, &(pendingList->list), TransReqLaneItem, node) { + if (item->laneHandle == laneHandle) { + item->bSucc = bSucc; + item->errCode = errCode; + item->isFinished = true; + if (!isAsync) { + (void)SoftBusCondSignal(&item->cond); + } + (void)SoftBusMutexUnlock(&(pendingList->lock)); + return SOFTBUS_OK; + } + } + (void)SoftBusMutexUnlock(&(pendingList->lock)); + TRANS_LOGE(TRANS_SVC, "trans lane request not found. laneHandle=%{public}u", laneHandle); + return SOFTBUS_NOT_FIND; } \ No newline at end of file diff --git a/core/transmission/trans_channel/manager/include/trans_channel_manager.h b/core/transmission/trans_channel/manager/include/trans_channel_manager.h index 584bae56fd..f81ebd1137 100644 --- a/core/transmission/trans_channel/manager/include/trans_channel_manager.h +++ b/core/transmission/trans_channel/manager/include/trans_channel_manager.h @@ -46,7 +46,7 @@ int32_t TransNotifyAuthSuccess(int32_t channelId, int32_t channelType); int32_t TransReleaseUdpResources(int32_t channelId); -int32_t TransCloseChannel(int32_t channelId, int32_t channelType); +int32_t TransCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType); int32_t TransSendMsg(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType); @@ -57,6 +57,8 @@ int32_t TransGetNameByChanId(const TransInfo *info, char *pkgName, char *session int32_t TransGetAndComparePid(pid_t pid, int32_t channelId, int32_t channelType); +int32_t TransGetAndComparePidBySession(pid_t pid, const char *sessionName, int32_t sessionId); + int32_t TransGetAppInfoByChanId(int32_t channelId, int32_t channelType, AppInfo* appInfo); int32_t TransGetConnByChanId(int32_t channelId, int32_t channelType, int32_t* connId); diff --git a/core/transmission/trans_channel/manager/include/trans_lane_manager.h b/core/transmission/trans_channel/manager/include/trans_lane_manager.h index 54d943afea..c7819f6488 100644 --- a/core/transmission/trans_channel/manager/include/trans_lane_manager.h +++ b/core/transmission/trans_channel/manager/include/trans_lane_manager.h @@ -24,10 +24,23 @@ extern "C" { #endif /* __cplusplus */ +typedef enum { + CORE_SESSION_STATE_INIT, + CORE_SESSION_STATE_WAIT_LANE, + CORE_SESSION_STATE_LAN_COMPLETE, + CORE_SESSION_STATE_CHANNEL_OPENED, + CORE_SESSION_STATE_CANCELLING, + CORE_SESSION_STATE_BUTT, +} CoreSessionState; + int32_t TransLaneMgrInit(void); +int32_t TransSocketLaneMgrInit(void); + void TransLaneMgrDeinit(void); +void TransSocketLaneMgrDeinit(void); + int32_t TransLaneMgrAddLane(int32_t channelId, int32_t channelType, LaneConnInfo *connInfo, uint32_t laneHandle, bool isQosLane, AppInfoData *myData); @@ -39,6 +52,32 @@ int32_t TransGetLaneHandleByChannelId(int32_t channelId, uint32_t *laneHandle); int32_t TransGetChannelInfoByLaneHandle(uint32_t laneHandle, int32_t *channelId, int32_t *channelType); +int32_t TransAddSocketChannelInfo( + const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType, CoreSessionState state); + +int32_t TransUpdateSocketChannelInfoBySession( + const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType); + +int32_t TransUpdateSocketChannelLaneInfoBySession( + const char *sessionName, int32_t sessionId, uint32_t laneHandle, bool isQosLane, bool isAsync); + +int32_t TransDeleteSocketChannelInfoBySession(const char *sessionName, int32_t sessionId); + +int32_t TransDeleteSocketChannelInfoByChannel(int32_t channelId, int32_t channelType); + +int32_t TransSetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState state); + +int32_t TransSetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState state); + +int32_t TransGetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState *state); + +int32_t TransGetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState *state); + +int32_t TransGetSocketChannelLaneInfoBySession( + const char *sessionName, int32_t sessionId, uint32_t *laneHandle, bool *isQosLane, bool *isAsync); + +int32_t TransGetPidFromSocketChannelInfoBySession(const char *sessionName, int32_t sessionId, int32_t *pid); + #ifdef __cplusplus } #endif /* __cplusplus */ diff --git a/core/transmission/trans_channel/manager/src/trans_channel_callback.c b/core/transmission/trans_channel/manager/src/trans_channel_callback.c index 805319c364..034efb402b 100644 --- a/core/transmission/trans_channel/manager/src/trans_channel_callback.c +++ b/core/transmission/trans_channel/manager/src/trans_channel_callback.c @@ -19,12 +19,13 @@ #include "softbus_def.h" #include "softbus_errcode.h" #include "softbus_hisysevt_transreporter.h" +#include "softbus_qos.h" +#include "trans_channel_common.h" #include "trans_client_proxy.h" +#include "trans_event.h" #include "trans_lane_manager.h" #include "trans_log.h" #include "trans_session_manager.h" -#include "softbus_qos.h" -#include "trans_event.h" static IServerChannelCallBack g_channelCallBack; @@ -34,12 +35,6 @@ static int32_t TransServerOnChannelOpened(const char *pkgName, int32_t pid, cons if (pkgName == NULL || sessionName == NULL || channel == NULL) { return SOFTBUS_INVALID_PARAM; } - - if (!channel->isServer && channel->channelType == CHANNEL_TYPE_UDP && - NotifyQosChannelOpened(channel) != SOFTBUS_OK) { - TRANS_LOGE(TRANS_QOS, "NotifyQosChannelOpened failed."); - return SOFTBUS_ERR; - } int64_t timeStart = channel->timeStart; int64_t timediff = GetSoftbusRecordTimeMillis() - timeStart; TransEventExtra extra = { @@ -52,6 +47,23 @@ static int32_t TransServerOnChannelOpened(const char *pkgName, int32_t pid, cons .callerPkg = pkgName, .socketName = sessionName }; + CoreSessionState state = CORE_SESSION_STATE_INIT; + TransGetSocketChannelStateByChannel(channel->channelId, channel->channelType, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + char *tmpSessionName = NULL; + Anonymize(sessionName, &tmpSessionName); + TRANS_LOGW(TRANS_CTRL, + "Cancel bind process, sesssionName=%{public}s, channelId=%{public}d", tmpSessionName, channel->channelId); + AnonymizeFree(tmpSessionName); + extra.result = EVENT_STAGE_RESULT_CANCELED; + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_OPEN_CHANNEL_END, extra); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; + } + if (!channel->isServer && channel->channelType == CHANNEL_TYPE_UDP && + NotifyQosChannelOpened(channel) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_QOS, "NotifyQosChannelOpened failed."); + return SOFTBUS_ERR; + } if (channel->isServer) { TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL_SERVER, EVENT_STAGE_OPEN_CHANNEL_END, extra); } else { @@ -59,6 +71,7 @@ static int32_t TransServerOnChannelOpened(const char *pkgName, int32_t pid, cons } SoftbusRecordOpenSessionKpi(pkgName, channel->linkType, SOFTBUS_EVT_OPEN_SESSION_SUCC, timediff); SoftbusHitraceStop(); + TransSetSocketChannelStateByChannel(channel->channelId, channel->channelType, CORE_SESSION_STATE_CHANNEL_OPENED); return ClientIpcOnChannelOpened(pkgName, sessionName, channel, pid); } @@ -80,6 +93,7 @@ static int32_t TransServerOnChannelClosed(const char *pkgName, int32_t pid, int3 .msgUuid = NULL, .msgUdid = NULL }; + TransDeleteSocketChannelInfoByChannel(channelId, channelType); if (ClientIpcOnChannelClosed(&data) != SOFTBUS_OK) { TRANS_LOGE(TRANS_CTRL, "client ipc on channel close fail"); return SOFTBUS_ERR; @@ -105,6 +119,7 @@ static int32_t TransServerOnChannelOpenFailed(const char *pkgName, int32_t pid, .msgUuid = NULL, .msgUdid = NULL }; + TransDeleteSocketChannelInfoByChannel(channelId, channelType); if (ClientIpcOnChannelOpenFailed(&data, errCode) != SOFTBUS_OK) { TRANS_LOGE(TRANS_CTRL, "client ipc on channel open fail"); return SOFTBUS_ERR; diff --git a/core/transmission/trans_channel/manager/src/trans_channel_manager.c b/core/transmission/trans_channel/manager/src/trans_channel_manager.c index 0788a86374..4b4dcef32c 100644 --- a/core/transmission/trans_channel/manager/src/trans_channel_manager.c +++ b/core/transmission/trans_channel/manager/src/trans_channel_manager.c @@ -147,6 +147,11 @@ int32_t TransChannelInit(void) return SOFTBUS_ERR; } + if (TransSocketLaneMgrInit() != SOFTBUS_OK) { + TRANS_LOGE(TRANS_INIT, "trans socket lane manager init failed."); + return SOFTBUS_ERR; + } + if (TransAuthInit(cb) != SOFTBUS_OK) { TRANS_LOGE(TRANS_INIT, "trans auth init failed."); return SOFTBUS_ERR; @@ -172,6 +177,11 @@ int32_t TransChannelInit(void) return SOFTBUS_ERR; } + if (TransAsyncReqLanePendingInit() != SOFTBUS_OK) { + TRANS_LOGE(TRANS_INIT, "trans async req lane pending init failed."); + return SOFTBUS_ERR; + } + ReqLinkListener(); if (SoftBusMutexInit(&g_myIdLock, NULL) != SOFTBUS_OK) { @@ -185,11 +195,13 @@ int32_t TransChannelInit(void) void TransChannelDeinit(void) { TransLaneMgrDeinit(); + TransSocketLaneMgrDeinit(); TransAuthDeinit(); TransProxyManagerDeinit(); TransTcpDirectDeinit(); TransUdpChannelDeinit(); TransReqLanePendingDeinit(); + TransAsyncReqLanePendingDeinit(); SoftBusMutexDestroy(&g_myIdLock); } @@ -203,7 +215,10 @@ int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo) int32_t ret = INVALID_CHANNEL_ID; uint32_t laneHandle = INVALID_LANE_REQ_ID; bool isQosLane = false; - // async bind will back after request choose lane + CoreSessionState state = CORE_SESSION_STATE_INIT; + ret = TransAddSocketChannelInfo( + param->sessionName, param->sessionId, INVALID_CHANNEL_ID, CHANNEL_TYPE_UNDEFINED, CORE_SESSION_STATE_INIT); + TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "Add socket channel record failed."); if (param->isAsync) { uint32_t firstTokenId = TransACLGetFirstTokenID(); ret = TransAsyncGetLaneInfo(param, &laneHandle, firstTokenId, &isQosLane); @@ -213,10 +228,10 @@ int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo) TRANS_LOGE(TRANS_CTRL, "Async get Lane failed, sessionName=%{public}s, sessionId=%{public}d", tmpSessionName, param->sessionId); AnonymizeFree(tmpSessionName); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); } return ret; } - int32_t errCode = INVALID_CHANNEL_ID; int64_t timeStart = GetSoftbusRecordTimeMillis(); transInfo->channelId = INVALID_CHANNEL_ID; transInfo->channelType = CHANNEL_TYPE_BUTT; @@ -228,42 +243,22 @@ int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo) NodeInfo nodeInfo; (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo)); int32_t peerRet = LnnGetRemoteNodeInfoById(appInfo->peerNetWorkId, CATEGORY_NETWORK_ID, &nodeInfo); - TransEventExtra extra = { - .calleePkg = NULL, - .callerPkg = appInfo->myData.pkgName, - .socketName = appInfo->myData.sessionName, - .dataType = appInfo->businessType, - .peerNetworkId = appInfo->peerNetWorkId, - .peerUdid = peerRet == SOFTBUS_OK ? nodeInfo.deviceInfo.deviceUdid : NULL, - .peerDevVer = peerRet == SOFTBUS_OK ? nodeInfo.deviceInfo.deviceVersion : NULL, - .result = EVENT_STAGE_RESULT_OK - }; + TransEventExtra extra; + TransBuildTransOpenChannelStartEvent(&extra, appInfo, &nodeInfo, peerRet); TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_START, extra); - errCode = TransGetLaneInfo(param, &connInfo, &laneHandle, &isQosLane); + ret = TransGetLaneInfo(param, &connInfo, &laneHandle, &isQosLane); char *tmpName = NULL; - if (errCode != SOFTBUS_OK) { + if (ret != SOFTBUS_OK) { SoftbusReportTransErrorEvt(SOFTBUS_TRANS_GET_LANE_INFO_ERR); - if (!isQosLane) { - goto EXIT_ERR; - } - ReportTransOpenChannelEndEvent(extra, transInfo, timeStart, ret); - ReportTransAlarmEvent(appInfo, ret); - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)appInfo->fastTransData); - } - SoftBusFree(appInfo); - ret = errCode; - TRANS_LOGE(TRANS_CTRL, "server TransOpenChannel err, ret=%{public}d", ret); - return ret; + goto EXIT_ERR; } Anonymize(param->sessionName, &tmpName); TRANS_LOGI(TRANS_CTRL, "sessionName=%{public}s, laneHandle=%{public}u, linkType=%{public}u.", tmpName, laneHandle, connInfo.type); AnonymizeFree(tmpName); - errCode = TransGetConnectOptByConnInfo(&connInfo, &connOpt); - if (errCode != SOFTBUS_OK) { - ret = errCode; + ret = TransGetConnectOptByConnInfo(&connInfo, &connOpt); + if (ret != SOFTBUS_OK) { SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, connInfo.type, SOFTBUS_EVT_OPEN_SESSION_FAIL, GetSoftbusRecordTimeMillis() - timeStart); goto EXIT_ERR; @@ -273,52 +268,60 @@ int32_t TransOpenChannel(const SessionParam *param, TransInfo *transInfo) FillAppInfo(appInfo, param, transInfo, &connInfo); TransOpenChannelSetModule(transInfo->channelType, &connOpt); TRANS_LOGI(TRANS_CTRL, "laneHandle=%{public}u, channelType=%{public}u", laneHandle, transInfo->channelType); - errCode = TransOpenChannelProc((ChannelType)transInfo->channelType, appInfo, &connOpt, + TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + goto EXIT_CANCEL; + } + TransSetSocketChannelStateBySession(param->sessionName, param->sessionId, CORE_SESSION_STATE_LAN_COMPLETE); + ret = TransOpenChannelProc((ChannelType)transInfo->channelType, appInfo, &connOpt, &(transInfo->channelId)); - if (errCode != SOFTBUS_OK) { - ret = errCode; + if (ret != SOFTBUS_OK) { SoftbusReportTransErrorEvt(SOFTBUS_TRANS_CREATE_CHANNEL_ERR); SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, appInfo->linkType, SOFTBUS_EVT_OPEN_SESSION_FAIL, GetSoftbusRecordTimeMillis() - timeStart); goto EXIT_ERR; } + TransUpdateSocketChannelInfoBySession( + param->sessionName, param->sessionId, transInfo->channelId, transInfo->channelType); + TransGetSocketChannelStateBySession(param->sessionName, param->sessionId, &state); + if (state == CORE_SESSION_STATE_CANCELLING) { + TransCloseChannel(NULL, transInfo->channelId, transInfo->channelType); + goto EXIT_CANCEL; + } + TransSetSocketChannelStateByChannel( + transInfo->channelId, transInfo->channelType, CORE_SESSION_STATE_CHANNEL_OPENED); if (((ChannelType)transInfo->channelType == CHANNEL_TYPE_TCP_DIRECT) && (connOpt.type != CONNECT_P2P)) { - if (isQosLane) { - GetLaneManager()->lnnFreeLane(laneHandle); - } else { - LnnFreeLane(laneHandle); - } + TransFreeLane(laneHandle, param->isQosLane); } else if (TransLaneMgrAddLane(transInfo->channelId, transInfo->channelType, &connInfo, laneHandle, isQosLane, &appInfo->myData) != SOFTBUS_OK) { SoftbusRecordOpenSessionKpi(appInfo->myData.pkgName, appInfo->linkType, SOFTBUS_EVT_OPEN_SESSION_FAIL, GetSoftbusRecordTimeMillis() - timeStart); - TransCloseChannel(transInfo->channelId, transInfo->channelType); + TransCloseChannel(NULL, transInfo->channelId, transInfo->channelType); goto EXIT_ERR; } - - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)appInfo->fastTransData); - } - SoftBusFree(appInfo); + TransFreeAppInfo(appInfo); TRANS_LOGI(TRANS_CTRL, "server TransOpenChannel ok: channelId=%{public}d, channelType=%{public}d", transInfo->channelId, transInfo->channelType); return SOFTBUS_OK; EXIT_ERR: - ReportTransOpenChannelEndEvent(extra, transInfo, timeStart, ret); - ReportTransAlarmEvent(appInfo, ret); - if (appInfo->fastTransData != NULL) { - SoftBusFree((void*)appInfo->fastTransData); - } - SoftBusFree(appInfo); - if (laneHandle != 0) { - if (isQosLane) { - GetLaneManager()->lnnFreeLane(laneHandle); - } else { - LnnFreeLane(laneHandle); - } - } - TRANS_LOGE(TRANS_CTRL, "server TransOpenChannel err"); + TransBuildTransOpenChannelEndEvent(&extra, transInfo, timeStart, ret); + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra); + TransAlarmExtra extraAlarm; + TransBuildTransAlarmEvent(&extraAlarm, appInfo, ret); + TRANS_ALARM(OPEN_SESSION_FAIL_ALARM, CONTROL_ALARM_TYPE, extraAlarm); + TransFreeAppInfo(appInfo); + TransFreeLane(laneHandle, param->isQosLane); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); + TRANS_LOGE(TRANS_SVC, "server TransOpenChannel err, ret=%{public}d", ret); return ret; +EXIT_CANCEL: + TransBuildTransOpenChannelCancelEvent(&extra, transInfo, timeStart, SOFTBUS_TRANS_STOP_BIND_BY_CANCEL); + TRANS_EVENT(EVENT_SCENE_OPEN_CHANNEL, EVENT_STAGE_OPEN_CHANNEL_END, extra); + TransFreeAppInfo(appInfo); + TransFreeLane(laneHandle, param->isQosLane); + (void)TransDeleteSocketChannelInfoBySession(param->sessionName, param->sessionId); + TRANS_LOGE(TRANS_SVC, "server open channel cancel"); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; } static AppInfo *GetAuthAppInfo(const char *mySessionName) @@ -514,8 +517,8 @@ int32_t TransRippleStats(int32_t channelId, int32_t channelType, const TrafficSt uint32_t laneHandle; int32_t ret = TransGetLaneHandleByChannelId(channelId, &laneHandle); if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_CTRL, "get laneHandle fail, streamStatsInfo cannot be processed"); - return SOFTBUS_ERR; + TRANS_LOGE(TRANS_CTRL, "get laneHandle fail, streamStatsInfo cannot be processed, ret=%{public}d", ret); + return ret; } TRANS_LOGI(TRANS_CTRL, "transRippleStats channelId=%{public}d, laneHandle=0x%{public}x", channelId, laneHandle); LnnRippleData rptdata; @@ -562,9 +565,9 @@ int32_t TransReleaseUdpResources(int32_t channelId) return SOFTBUS_OK; } -int32_t TransCloseChannel(int32_t channelId, int32_t channelType) +int32_t TransCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { - return TransCommonCloseChannel(channelId, channelType); + return TransCommonCloseChannel(sessionName, channelId, channelType); } int32_t TransSendMsg(int32_t channelId, int32_t channelType, const void *data, uint32_t len, @@ -637,6 +640,23 @@ int32_t TransGetAndComparePid(pid_t pid, int32_t channelId, int32_t channelType) return SOFTBUS_OK; } +int32_t TransGetAndComparePidBySession(pid_t pid, const char *sessionName, int32_t sessionlId) +{ + pid_t curSessionPid; + int32_t ret = TransGetPidFromSocketChannelInfoBySession(sessionName, sessionlId, &curSessionPid); + if (ret != SOFTBUS_OK) { + TRANS_LOGE(TRANS_CTRL, "get pid by session failed, ret = %{public}d", ret); + return ret; + } + if (pid != curSessionPid) { + TRANS_LOGE(TRANS_CTRL, "callingPid not equal curSessionPid, callingPid=%{public}d, pid=%{public}d", + pid, curSessionPid); + return SOFTBUS_TRANS_CHECK_PID_ERROR; + } + TRANS_LOGI(TRANS_CTRL, "callingPid check success. callingPid=%{public}d !", pid); + return SOFTBUS_OK; +} + int32_t TransGetAppInfoByChanId(int32_t channelId, int32_t channelType, AppInfo* appInfo) { if (appInfo == NULL) { diff --git a/core/transmission/trans_channel/manager/src/trans_lane_manager.c b/core/transmission/trans_channel/manager/src/trans_lane_manager.c index 4b6ec5d83c..410f37c4e0 100644 --- a/core/transmission/trans_channel/manager/src/trans_lane_manager.c +++ b/core/transmission/trans_channel/manager/src/trans_lane_manager.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * Copyright (c) 2021-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -16,6 +16,7 @@ #include "trans_lane_manager.h" #include + #include "common_list.h" #include "softbus_adapter_mem.h" #include "softbus_adapter_thread.h" @@ -25,6 +26,7 @@ #include "trans_channel_manager.h" #include "trans_log.h" #include "softbus_hidumper_trans.h" +#include "trans_session_manager.h" #define CMD_CONCURRENT_SESSION_LIST "concurrent_sessionlist" typedef struct { @@ -38,8 +40,23 @@ typedef struct { bool isQosLane; } TransLaneInfo; +typedef struct { + ListNode node; + char sessionName[SESSION_NAME_SIZE_MAX]; + pid_t pid; + int32_t sessionId; + int32_t channelId; + int32_t channelType; + uint32_t laneHandle; + CoreSessionState state; + bool isAsync; + bool isQosLane; +} SocketWithChannelInfo; + static SoftBusList *g_channelLaneList = NULL; +static SoftBusList *g_socketChannelList = NULL; + static void GetTransSessionInfoByLane(TransLaneInfo * laneItem, AppInfo *appInfo) { if (TransGetAppInfoByChanId(laneItem->channelId, laneItem->channelType, appInfo) != SOFTBUS_OK) { @@ -112,6 +129,20 @@ int32_t TransLaneMgrInit(void) return SoftBusRegTransVarDump(CMD_CONCURRENT_SESSION_LIST, TransLaneChannelForEachShowInfo); } +int32_t TransSocketLaneMgrInit(void) +{ + if (g_socketChannelList != NULL) { + TRANS_LOGI(TRANS_INIT, "trans lane info manager has init."); + return SOFTBUS_OK; + } + g_socketChannelList = CreateSoftBusList(); + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "trans lane info manager init failed."); + return SOFTBUS_MALLOC_ERR; + } + return SOFTBUS_OK; +} + void TransLaneMgrDeinit(void) { TRANS_LOGI(TRANS_CTRL, "enter."); @@ -140,6 +171,28 @@ void TransLaneMgrDeinit(void) g_channelLaneList = NULL; } +void TransSocketLaneMgrDeinit(void) +{ + TRANS_LOGI(TRANS_CTRL, "enter."); + if (g_socketChannelList == NULL) { + return; + } + if (SoftBusMutexLock(&g_socketChannelList->lock) != 0) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return; + } + SocketWithChannelInfo *socketItem = NULL; + SocketWithChannelInfo *nextSocketItem = NULL; + LIST_FOR_EACH_ENTRY_SAFE(socketItem, nextSocketItem, &g_socketChannelList->list, SocketWithChannelInfo, node) { + ListDelete(&(socketItem->node)); + SoftBusFree(socketItem); + } + g_socketChannelList->cnt = 0; + (void)SoftBusMutexUnlock(&g_socketChannelList->lock); + DestroySoftBusList(g_socketChannelList); + g_socketChannelList = NULL; +} + int32_t TransLaneMgrAddLane(int32_t channelId, int32_t channelType, LaneConnInfo *connInfo, uint32_t laneHandle, bool isQosLane, AppInfoData *myData) { @@ -297,4 +350,398 @@ int32_t TransGetChannelInfoByLaneHandle(uint32_t laneHandle, int32_t *channelId, } (void)SoftBusMutexUnlock(&(g_channelLaneList->lock)); return SOFTBUS_ERR; +} + +static SocketWithChannelInfo *GetSocketWithChannelInfoBySession(const char *sessionName, int32_t sessionId) +{ + // need get lock before + SocketWithChannelInfo *socketItem = NULL; + LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) { + if (strcmp(socketItem->sessionName, sessionName) == 0 && socketItem->sessionId == sessionId) { + return socketItem; + } + } + return NULL; +} + +static void AnonymizeLogSessionNameWhenNotFound(const char *sessionName, int32_t sessionId) +{ + char *tmpName = NULL; + Anonymize(sessionName, &tmpName); + TRANS_LOGE( + TRANS_SVC, "socket info not found. sessionName=%{public}s, sessionId=%{public}d", tmpName, sessionId); + AnonymizeFree(tmpName); +} + +int32_t TransAddSocketChannelInfo( + const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType, CoreSessionState state) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + TRANS_CHECK_AND_RETURN_RET_LOGE( + g_socketChannelList != NULL, SOFTBUS_NO_INIT, TRANS_INIT, "socket info manager hasn't init."); + + SocketWithChannelInfo *newSocket = (SocketWithChannelInfo *)SoftBusCalloc(sizeof(SocketWithChannelInfo)); + TRANS_CHECK_AND_RETURN_RET_LOGE(newSocket != NULL, SOFTBUS_MALLOC_ERR, TRANS_SVC, "socket info calloc failed."); + if (strcpy_s(newSocket->sessionName, SESSION_NAME_SIZE_MAX, sessionName) != EOK) { + SoftBusFree(newSocket); + return SOFTBUS_STRCPY_ERR; + } + newSocket->sessionId = sessionId; + newSocket->channelId = channelId; + newSocket->channelType = channelType; + newSocket->state = state; + newSocket->laneHandle = INVALID_LANE_REQ_ID; + newSocket->isQosLane = false; + newSocket->isAsync = false; + int32_t tmpUid; + TransGetUidAndPid(sessionName, &tmpUid, &(newSocket->pid)); + + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + SoftBusFree(newSocket); + return SOFTBUS_LOCK_ERR; + } + + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + char *tmpName = NULL; + Anonymize(sessionName, &tmpName); + TRANS_LOGI( + TRANS_SVC, "socket lane info has existed. socketId=%{public}d, sessionName=%{public}s", sessionId, tmpName); + AnonymizeFree(tmpName); + SoftBusFree(newSocket); + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + + ListInit(&(newSocket->node)); + ListAdd(&(g_socketChannelList->list), &(newSocket->node)); + g_socketChannelList->cnt++; + TRANS_LOGI(TRANS_SVC, "socket lane count is cnt=%{public}d", g_socketChannelList->cnt); + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; +} + +int32_t TransUpdateSocketChannelInfoBySession( + const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + socketItem->channelId = channelId; + socketItem->channelType = channelType; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; +} + +int32_t TransUpdateSocketChannelLaneInfoBySession( + const char *sessionName, int32_t sessionId, uint32_t laneHandle, bool isQosLane, bool isAsync) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + socketItem->laneHandle = laneHandle; + socketItem->isQosLane = isQosLane; + socketItem->isAsync = isAsync; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; +} + +int32_t TransDeleteSocketChannelInfoBySession(const char *sessionName, int32_t sessionId) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = NULL; + SocketWithChannelInfo *next = NULL; + LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) { + if (strcmp(socketItem->sessionName, sessionName) == 0 && socketItem->sessionId == sessionId) { + ListDelete(&(socketItem->node)); + char *tmpName = NULL; + Anonymize(sessionName, &tmpName); + TRANS_LOGI(TRANS_CTRL, "delete socket channel info, sessionName=%{public}s, sessionId=%{public}d", + tmpName, socketItem->sessionId); + AnonymizeFree(tmpName); + g_socketChannelList->cnt--; + SoftBusFree(socketItem); + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; +} + +int32_t TransDeleteSocketChannelInfoByChannel(int32_t channelId, int32_t channelType) +{ + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = NULL; + SocketWithChannelInfo *next = NULL; + LIST_FOR_EACH_ENTRY_SAFE(socketItem, next, &(g_socketChannelList->list), SocketWithChannelInfo, node) { + if (socketItem->channelId == channelId && socketItem->channelType == channelType) { + ListDelete(&(socketItem->node)); + TRANS_LOGI(TRANS_CTRL, "delete socket channel info, channelId=%{public}d, channelType=%{public}d", + channelId, channelType); + g_socketChannelList->cnt--; + SoftBusFree(socketItem); + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + TRANS_LOGD( + TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType); + return SOFTBUS_NOT_FIND; +} + +int32_t TransSetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState state) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + socketItem->state = state; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; +} + +int32_t TransSetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState state) +{ + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = NULL; + LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) { + if (socketItem->channelId == channelId && socketItem->channelType == channelType) { + socketItem->state = state; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + TRANS_LOGE( + TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType); + return SOFTBUS_NOT_FIND; +} + +int32_t TransGetSocketChannelStateBySession(const char *sessionName, int32_t sessionId, CoreSessionState *state) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (state == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, state is null"); + return SOFTBUS_INVALID_PARAM; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + *state = socketItem->state; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; +} + +int32_t TransGetSocketChannelLaneInfoBySession( + const char *sessionName, int32_t sessionId, uint32_t *laneHandle, bool *isQosLane, bool *isAsync) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + if (laneHandle != NULL) { + *laneHandle = socketItem->laneHandle; + } + if (isQosLane != NULL) { + *isQosLane = socketItem->isQosLane; + } + if (isAsync != NULL) { + *isAsync = socketItem->isAsync; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; +} + +int32_t TransGetSocketChannelStateByChannel(int32_t channelId, int32_t channelType, CoreSessionState *state) +{ + if (state == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param"); + return SOFTBUS_INVALID_PARAM; + } + + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = NULL; + LIST_FOR_EACH_ENTRY(socketItem, &(g_socketChannelList->list), SocketWithChannelInfo, node) { + if (socketItem->channelId == channelId && socketItem->channelType == channelType) { + *state = socketItem->state; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + TRANS_LOGE( + TRANS_SVC, "socket info not found. channelId=%{public}d, channelType=%{public}d", channelId, channelType); + return SOFTBUS_NOT_FIND; +} + +int32_t TransGetPidFromSocketChannelInfoBySession(const char *sessionName, int32_t sessionId, int32_t *pid) +{ + if (sessionName == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionName is null"); + return SOFTBUS_TRANS_INVALID_SESSION_NAME; + } + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SVC, "Invaild param, sessionId=%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (pid == NULL) { + TRANS_LOGE(TRANS_SVC, "Invaild param, pid is null"); + return SOFTBUS_INVALID_PARAM; + } + if (g_socketChannelList == NULL) { + TRANS_LOGE(TRANS_INIT, "socket info manager hasn't init."); + return SOFTBUS_NO_INIT; + } + if (SoftBusMutexLock(&(g_socketChannelList->lock)) != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SVC, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + SocketWithChannelInfo *socketItem = GetSocketWithChannelInfoBySession(sessionName, sessionId); + if (socketItem != NULL) { + *pid = socketItem->pid; + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + return SOFTBUS_OK; + } + (void)SoftBusMutexUnlock(&(g_socketChannelList->lock)); + AnonymizeLogSessionNameWhenNotFound(sessionName, sessionId); + return SOFTBUS_NOT_FIND; } \ No newline at end of file diff --git a/interfaces/kits/common/softbus_error_code.h b/interfaces/kits/common/softbus_error_code.h index d89918319a..4feabee79f 100644 --- a/interfaces/kits/common/softbus_error_code.h +++ b/interfaces/kits/common/softbus_error_code.h @@ -241,6 +241,7 @@ enum SoftBusErrNo { SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, SOFTBUS_TRANS_TDC_CHANNEL_ALREADY_EXIST, // receive repeat tdc channel open request SOFTBUS_TRANS_UDP_SET_CHANNEL_FAILED, + SOFTBUS_TRANS_STOP_BIND_BY_CANCEL, /* errno begin: -((203 << 21) | (3 << 16) | 0xFFFF) */ SOFTBUS_AUTH_ERR_BASE = SOFTBUS_ERRNO(AUTH_SUB_MODULE_CODE), diff --git a/sdk/bus_center/ipc/standard/include/bus_center_server_proxy_standard.h b/sdk/bus_center/ipc/standard/include/bus_center_server_proxy_standard.h index 493745a43e..01b4a06110 100644 --- a/sdk/bus_center/ipc/standard/include/bus_center_server_proxy_standard.h +++ b/sdk/bus_center/ipc/standard/include/bus_center_server_proxy_standard.h @@ -38,7 +38,7 @@ public: int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) override; int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) override; int32_t ReleaseResources(int32_t channelId) override; - int32_t CloseChannel(int32_t channelId, int32_t channelType) override; + int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) override; int32_t SendMessage(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType) override; diff --git a/sdk/bus_center/ipc/standard/src/bus_center_server_proxy_standard.cpp b/sdk/bus_center/ipc/standard/src/bus_center_server_proxy_standard.cpp index d7dfb4d193..8f0b514c58 100644 --- a/sdk/bus_center/ipc/standard/src/bus_center_server_proxy_standard.cpp +++ b/sdk/bus_center/ipc/standard/src/bus_center_server_proxy_standard.cpp @@ -158,8 +158,9 @@ int32_t BusCenterServerProxy::ReleaseResources(int32_t channelId) return SOFTBUS_OK; } -int32_t BusCenterServerProxy::CloseChannel(int32_t channelId, int32_t channelType) +int32_t BusCenterServerProxy::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { + (void)sessionName; (void)channelId; (void)channelType; return SOFTBUS_OK; diff --git a/sdk/discovery/ipc/standard/include/disc_server_proxy_standard.h b/sdk/discovery/ipc/standard/include/disc_server_proxy_standard.h index 2e9c329c2c..b9af44beec 100644 --- a/sdk/discovery/ipc/standard/include/disc_server_proxy_standard.h +++ b/sdk/discovery/ipc/standard/include/disc_server_proxy_standard.h @@ -39,7 +39,7 @@ public: int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) override; int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) override; int32_t ReleaseResources(int32_t channelId) override; - int32_t CloseChannel(int32_t channelId, int32_t channelType) override; + int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) override; int32_t SendMessage(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType) override; diff --git a/sdk/discovery/ipc/standard/src/disc_server_proxy_standard.cpp b/sdk/discovery/ipc/standard/src/disc_server_proxy_standard.cpp index 5f84abb54e..d27473b266 100644 --- a/sdk/discovery/ipc/standard/src/disc_server_proxy_standard.cpp +++ b/sdk/discovery/ipc/standard/src/disc_server_proxy_standard.cpp @@ -307,8 +307,9 @@ int32_t DiscServerProxy::ReleaseResources(int32_t channelId) return SOFTBUS_OK; } -int32_t DiscServerProxy::CloseChannel(int32_t channelId, int32_t channelType) +int32_t DiscServerProxy::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { + (void)sessionName; (void)channelId; (void)channelType; return SOFTBUS_OK; diff --git a/sdk/frame/standard/include/softbus_server_proxy_standard.h b/sdk/frame/standard/include/softbus_server_proxy_standard.h index 4e6a976bfd..f9e439bc62 100644 --- a/sdk/frame/standard/include/softbus_server_proxy_standard.h +++ b/sdk/frame/standard/include/softbus_server_proxy_standard.h @@ -41,7 +41,7 @@ public: int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) override; int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) override; int32_t ReleaseResources(int32_t channelId) override; - int32_t CloseChannel(int32_t channelId, int32_t channelType) override; + int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) override; int32_t SendMessage(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType) override; diff --git a/sdk/frame/standard/src/softbus_server_proxy_standard.cpp b/sdk/frame/standard/src/softbus_server_proxy_standard.cpp index 34a029bc99..a74af693e8 100644 --- a/sdk/frame/standard/src/softbus_server_proxy_standard.cpp +++ b/sdk/frame/standard/src/softbus_server_proxy_standard.cpp @@ -147,8 +147,9 @@ int32_t SoftBusServerProxyFrame::ReleaseResources(int32_t channelId) return SOFTBUS_OK; } -int32_t SoftBusServerProxyFrame::CloseChannel(int32_t channelId, int32_t channelType) +int32_t SoftBusServerProxyFrame::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { + (void)sessionName; (void)channelId; (void)channelType; return SOFTBUS_OK; diff --git a/sdk/libsoftbus_client_map b/sdk/libsoftbus_client_map index 10273c033c..010ac21053 100644 --- a/sdk/libsoftbus_client_map +++ b/sdk/libsoftbus_client_map @@ -389,6 +389,8 @@ "TransSetChannelInfo"; "ClientTransSetChannelInfo"; "ClientGetSessionIsAsyncBySessionId"; + "GetSessionStateAndSessionNameBySessionId"; + "SetSessionStateBySessionId"; "EvaluateQos"; "GetMtuSize"; "DBinderGrantPermission"; diff --git a/sdk/transmission/ipc/include/trans_server_proxy.h b/sdk/transmission/ipc/include/trans_server_proxy.h index d657d5c00d..223beff45f 100644 --- a/sdk/transmission/ipc/include/trans_server_proxy.h +++ b/sdk/transmission/ipc/include/trans_server_proxy.h @@ -31,7 +31,7 @@ int32_t ServerIpcRemoveSessionServer(const char *pkgName, const char *sessionNam int32_t ServerIpcOpenSession(const SessionParam *param, TransInfo *info); int32_t ServerIpcOpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo); int32_t ServerIpcNotifyAuthSuccess(int32_t channelId, int32_t channelType); -int32_t ServerIpcCloseChannel(int32_t channelId, int32_t channelType); +int32_t ServerIpcCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType); int32_t ServerIpcSendMessage(int32_t channelId, int32_t channelType, const void *data, uint32_t len, int32_t msgType); int32_t ServerIpcQosReport(int32_t channelId, int32_t chanType, int32_t appType, int32_t quality); int32_t ServerIpcGrantPermission(int uid, int pid, const char *sessionName); diff --git a/sdk/transmission/ipc/mini/trans_server_proxy.c b/sdk/transmission/ipc/mini/trans_server_proxy.c index 0985371e30..948c0594d1 100644 --- a/sdk/transmission/ipc/mini/trans_server_proxy.c +++ b/sdk/transmission/ipc/mini/trans_server_proxy.c @@ -65,9 +65,9 @@ int32_t ServerIpcNotifyAuthSuccess(int32_t channelId, int32_t channelType) return TransNotifyAuthSuccess(channelId, channelType); } -int32_t ServerIpcCloseChannel(int32_t channelId, int32_t channelType) +int32_t ServerIpcCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { - return TransCloseChannel(channelId, channelType); + return TransCloseChannel(sessionName, channelId, channelType); } int32_t ServerIpcReleaseResources(int32_t channelId) diff --git a/sdk/transmission/ipc/small/trans_server_proxy.c b/sdk/transmission/ipc/small/trans_server_proxy.c index 85aa5a27b0..8ed18dd734 100644 --- a/sdk/transmission/ipc/small/trans_server_proxy.c +++ b/sdk/transmission/ipc/small/trans_server_proxy.c @@ -304,7 +304,7 @@ int32_t ServerIpcReleaseResources(int32_t channelId) return ret; } -int32_t ServerIpcCloseChannel(int32_t channelId, int32_t channelType) +int32_t ServerIpcCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { TRANS_LOGD(TRANS_SDK, "enter."); uint8_t data[MAX_SOFT_BUS_IPC_LEN] = {0}; @@ -312,7 +312,9 @@ int32_t ServerIpcCloseChannel(int32_t channelId, int32_t channelType) IpcIoInit(&request, data, MAX_SOFT_BUS_IPC_LEN, 0); WriteInt32(&request, channelId); WriteInt32(&request, channelType); - + if (channelType == CHANNEL_TYPE_UNDEFINED) { + WriteString(&request, sessionName); + } int32_t ret = SOFTBUS_ERR; /* sync */ if (g_serverProxy == NULL) { diff --git a/sdk/transmission/ipc/standard/include/trans_server_proxy_standard.h b/sdk/transmission/ipc/standard/include/trans_server_proxy_standard.h index f6397b18ba..c824e6027e 100644 --- a/sdk/transmission/ipc/standard/include/trans_server_proxy_standard.h +++ b/sdk/transmission/ipc/standard/include/trans_server_proxy_standard.h @@ -38,7 +38,7 @@ public: int32_t OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo) override; int32_t NotifyAuthSuccess(int32_t channelId, int32_t channelType) override; int32_t ReleaseResources(int32_t channelId) override; - int32_t CloseChannel(int32_t channelId, int32_t channelType) override; + int32_t CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) override; int32_t SendMessage(int32_t channelId, int32_t channelType, const void *dataInfo, uint32_t len, int32_t msgType) override; diff --git a/sdk/transmission/ipc/standard/src/trans_server_proxy.cpp b/sdk/transmission/ipc/standard/src/trans_server_proxy.cpp index 3703f884b8..13d4d1b222 100644 --- a/sdk/transmission/ipc/standard/src/trans_server_proxy.cpp +++ b/sdk/transmission/ipc/standard/src/trans_server_proxy.cpp @@ -155,7 +155,7 @@ int32_t ServerIpcNotifyAuthSuccess(int32_t channelId, int32_t channelType) return g_serverProxy->NotifyAuthSuccess(channelId, channelType); } -int32_t ServerIpcCloseChannel(int32_t channelId, int32_t channelType) +int32_t ServerIpcCloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { if (g_serverProxy == nullptr) { TRANS_LOGE(TRANS_SDK, "softbus server g_serverProxy is nullptr!"); @@ -165,7 +165,7 @@ int32_t ServerIpcCloseChannel(int32_t channelId, int32_t channelType) TRANS_LOGE(TRANS_SDK, "invalid channel Id!"); return SOFTBUS_ERR; } - return g_serverProxy->CloseChannel(channelId, channelType); + return g_serverProxy->CloseChannel(sessionName, channelId, channelType); } int32_t ServerIpcReleaseResources(int32_t channelId) diff --git a/sdk/transmission/ipc/standard/src/trans_server_proxy_standard.cpp b/sdk/transmission/ipc/standard/src/trans_server_proxy_standard.cpp index 703d06724c..040e2a2c03 100644 --- a/sdk/transmission/ipc/standard/src/trans_server_proxy_standard.cpp +++ b/sdk/transmission/ipc/standard/src/trans_server_proxy_standard.cpp @@ -31,6 +31,8 @@ } \ } while (false) +#define CHANNEL_TYPE_UNDEFINED (-1) + namespace OHOS { static uint32_t g_getSystemAbilityId = 2; const std::u16string SAMANAGER_INTERFACE_TOKEN = u"ohos.samgr.accessToken"; @@ -413,7 +415,7 @@ int32_t TransServerProxy::NotifyAuthSuccess(int32_t channelId, int32_t channelTy return serverRet; } -int32_t TransServerProxy::CloseChannel(int32_t channelId, int32_t channelType) +int32_t TransServerProxy::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType) { sptr remote = GetSystemAbility(); if (remote == nullptr) { @@ -433,7 +435,12 @@ int32_t TransServerProxy::CloseChannel(int32_t channelId, int32_t channelType) TRANS_LOGE(TRANS_SDK, "CloseChannel write channel type failed!"); return SOFTBUS_ERR; } - + if (channelType == CHANNEL_TYPE_UNDEFINED) { + if (!data.WriteCString(sessionName)) { + TRANS_LOGE(TRANS_SDK, "CloseChannel write session name failed!"); + return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED; + } + } MessageParcel reply; MessageOption option; int32_t ret = remote->SendRequest(SERVER_CLOSE_CHANNEL, data, reply, option); diff --git a/sdk/transmission/session/include/client_trans_session_manager.h b/sdk/transmission/session/include/client_trans_session_manager.h index 92b65a5949..1c70bb57b9 100644 --- a/sdk/transmission/session/include/client_trans_session_manager.h +++ b/sdk/transmission/session/include/client_trans_session_manager.h @@ -44,6 +44,15 @@ typedef enum { SESSION_ROLE_BUTT, } SessionRole; +typedef enum { + SESSION_STATE_INIT, + SESSION_STATE_OPENING, + SESSION_STATE_OPENED, + SESSION_STATE_CALLBACK_FINISHED, + SESSION_STATE_CANCELLING, + SESSION_STATE_BUTT, +} SessionState; + typedef struct { ListNode node; int32_t sessionId; @@ -67,6 +76,7 @@ typedef struct { uint32_t dataConfig; bool isEncyptedRawStream; bool isAsync; + SessionState sessionState; } SessionInfo; typedef struct { @@ -196,6 +206,10 @@ int32_t SetSessionIsAsyncById(int32_t sessionId, bool isAsync); int32_t ClientTransSetChannelInfo(const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType); +int32_t GetSessionStateAndSessionNameBySessionId(int32_t sessionId, char *sessionName, SessionState *sessionState); + +int32_t SetSessionStateBySessionId(int32_t sessionId, SessionState sessionState); + #ifdef __cplusplus } #endif diff --git a/sdk/transmission/session/src/client_trans_session_callback.c b/sdk/transmission/session/src/client_trans_session_callback.c index 0015a65902..e52abec335 100644 --- a/sdk/transmission/session/src/client_trans_session_callback.c +++ b/sdk/transmission/session/src/client_trans_session_callback.c @@ -52,6 +52,7 @@ static int32_t AcceptSessionAsServer(const char *sessionName, const ChannelInfo session->crc = channel->crc; session->dataConfig = channel->dataConfig; session->isAsync = false; + session->sessionState = SESSION_STATE_OPENED; if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, channel->peerSessionName) != EOK || strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, channel->peerDeviceId) != EOK || strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, channel->groupId) != EOK) { @@ -201,7 +202,14 @@ NO_SANITIZE("cfi") int32_t TransOnSessionOpened(const char *sessionName, const C TRANS_LOGE(TRANS_SDK, "accept session failed, ret=%{public}d", ret); return ret; } - + SessionState sessionState = SESSION_STATE_INIT; + GetSessionStateAndSessionNameBySessionId(sessionId, NULL, &sessionState); + if (sessionState == SESSION_STATE_CANCELLING) { + TRANS_LOGI(TRANS_SDK, "session is cancelling, no need call back"); + (void)ClientDeleteSession(sessionId); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; + } + SetSessionStateBySessionId(sessionId, SESSION_STATE_CALLBACK_FINISHED); if (sessionCallback.isSocketListener) { return handelOnBindSuccess(sessionId, sessionCallback, channel->isServer); } diff --git a/sdk/transmission/session/src/client_trans_session_manager.c b/sdk/transmission/session/src/client_trans_session_manager.c index 41f573ea46..38726dd233 100644 --- a/sdk/transmission/session/src/client_trans_session_manager.c +++ b/sdk/transmission/session/src/client_trans_session_manager.c @@ -425,6 +425,7 @@ static SessionInfo *CreateNewSession(const SessionParam *param) session->info.flag = param->attr->dataType; session->isEncrypt = true; session->isAsync = false; + session->sessionState = SESSION_STATE_INIT; return session; } @@ -1826,6 +1827,7 @@ static SessionInfo *CreateNewSocketSession(const SessionParam *param) session->info.streamType = param->attr->attr.streamAttr.streamType; session->isEncrypt = true; session->isAsync = false; + session->sessionState = SESSION_STATE_INIT; return session; } @@ -2010,6 +2012,9 @@ int32_t ClientIpcOpenSession(int32_t sessionId, const QosTV *qos, uint32_t qosCo } param.isAsync = isAsync; param.sessionId = sessionId; + ret = SetSessionStateBySessionId(param.sessionId, SESSION_STATE_OPENING); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, ret, TRANS_SDK, "set session state failed, maybe cancel, ret=%{public}d", ret); ret = ServerIpcOpenSession(¶m, transInfo); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SDK, "open session ipc err: ret=%{public}d", ret); @@ -2428,7 +2433,7 @@ int32_t SetSessionIsAsyncById(int32_t sessionId, bool isAsync) } } (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); - return SOFTBUS_ERR; + return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND; } int32_t ClientTransSetChannelInfo(const char *sessionName, int32_t sessionId, int32_t channelId, int32_t channelType) @@ -2460,6 +2465,7 @@ int32_t ClientTransSetChannelInfo(const char *sessionName, int32_t sessionId, in if (sessionNode->sessionId == sessionId) { sessionNode->channelId = channelId; sessionNode->channelType = (ChannelType)channelType; + sessionNode->sessionState = SESSION_STATE_OPENED; (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); return SOFTBUS_OK; } @@ -2468,5 +2474,72 @@ int32_t ClientTransSetChannelInfo(const char *sessionName, int32_t sessionId, in (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); TRANS_LOGE(TRANS_MSG, "not found session info with sessionId=%{public}d", sessionId); - return SOFTBUS_ERR; + return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND; +} + +int32_t GetSessionStateAndSessionNameBySessionId(int32_t sessionId, char *sessionName, SessionState *sessionState) +{ + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SDK, "invalid param session id =%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + if (sessionState == NULL) { + TRANS_LOGE(TRANS_SDK, "invalid param state is null."); + return SOFTBUS_INVALID_PARAM; + } + if (g_clientSessionServerList == NULL) { + TRANS_LOGE(TRANS_INIT, "entry list not init"); + return SOFTBUS_TRANS_SESSION_SERVER_NOINIT; + } + + if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) { + TRANS_LOGE(TRANS_MSG, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + + ClientSessionServer *serverNode = NULL; + SessionInfo *sessionNode = NULL; + if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) { + (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); + TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", sessionId); + return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND; + } + *sessionState = sessionNode->sessionState; + if (sessionName != NULL && + strcpy_s(sessionName, SESSION_NAME_SIZE_MAX, serverNode->sessionName) != EOK) { + (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); + return SOFTBUS_STRCPY_ERR; + } + (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); + return SOFTBUS_OK; +} + +int32_t SetSessionStateBySessionId(int32_t sessionId, SessionState sessionState) +{ + if (sessionId <= 0) { + TRANS_LOGE(TRANS_SDK, "invalid session id =%{public}d", sessionId); + return SOFTBUS_TRANS_INVALID_SESSION_ID; + } + + if (g_clientSessionServerList == NULL) { + TRANS_LOGE(TRANS_INIT, "entry list not init"); + return SOFTBUS_TRANS_SESSION_SERVER_NOINIT; + } + + if (SoftBusMutexLock(&(g_clientSessionServerList->lock)) != 0) { + TRANS_LOGE(TRANS_MSG, "lock failed"); + return SOFTBUS_LOCK_ERR; + } + + ClientSessionServer *serverNode = NULL; + SessionInfo *sessionNode = NULL; + if (GetSessionById(sessionId, &serverNode, &sessionNode) != SOFTBUS_OK) { + (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); + TRANS_LOGE(TRANS_SDK, "socket not found. socketFd=%{public}d", sessionId); + return SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND; + } + + sessionNode->sessionState = sessionState; + (void)SoftBusMutexUnlock(&(g_clientSessionServerList->lock)); + return SOFTBUS_OK; } \ No newline at end of file diff --git a/sdk/transmission/session/src/client_trans_session_service.c b/sdk/transmission/session/src/client_trans_session_service.c index 6d8563aab8..962291463f 100644 --- a/sdk/transmission/session/src/client_trans_session_service.c +++ b/sdk/transmission/session/src/client_trans_session_service.c @@ -466,8 +466,18 @@ static int32_t CheckSessionIsOpened(int32_t sessionId) #define SESSION_CHECK_PERIOD 200000 int32_t i = 0; bool isEnable = false; - + SessionState sessionState = SESSION_STATE_INIT; + int32_t ret = SOFTBUS_OK; while (i < SESSION_STATUS_CHECK_MAX_NUM) { + ret = GetSessionStateAndSessionNameBySessionId(sessionId, NULL, &sessionState); + if (ret != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SDK, "Get socket state failed, ret=%{public}d", ret); + return ret; + } + if (sessionState == SESSION_STATE_CANCELLING) { + TRANS_LOGI(TRANS_SDK, "session is cancelling"); + return SOFTBUS_TRANS_STOP_BIND_BY_CANCEL; + } if (ClientGetChannelBySessionId(sessionId, NULL, NULL, &isEnable) != SOFTBUS_OK) { return SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED; } @@ -1067,7 +1077,9 @@ int32_t ClientBind(int32_t socket, const QosTV qos[], uint32_t qosCount, const I TRANS_LOGE(TRANS_SDK, "get maximum idle time failed, ret=%{public}d", ret); return ret; } - (void)SetSessionIsAsyncById(socket, isAsync); + ret = SetSessionIsAsyncById(socket, isAsync); + TRANS_CHECK_AND_RETURN_RET_LOGE( + ret == SOFTBUS_OK, ret, TRANS_SDK, "set session is async failed, ret=%{public}d", ret); TransInfo transInfo; ret = ClientIpcOpenSession(socket, qos, qosCount, &transInfo, isAsync); if (ret != SOFTBUS_OK) { @@ -1080,10 +1092,11 @@ int32_t ClientBind(int32_t socket, const QosTV qos[], uint32_t qosCount, const I TRANS_LOGE(TRANS_SDK, "set channel by socket=%{public}d failed, ret=%{public}d", socket, ret); return SOFTBUS_TRANS_SESSION_SET_CHANNEL_FAILED; } - + SetSessionStateBySessionId(socket, SESSION_STATE_OPENED); ret = CheckSessionIsOpened(socket); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SDK, "CheckSessionIsOpened err, ret=%{public}d", ret); + (void)ClientDeleteSession(socket); return SOFTBUS_TRANS_SESSION_NO_ENABLE; } } @@ -1138,20 +1151,42 @@ void ClientShutdown(int32_t socket) return; } - int32_t channelId = INVALID_CHANNEL_ID; - int32_t type = CHANNEL_TYPE_BUTT; - int32_t ret = ClientGetChannelBySessionId(socket, &channelId, &type, NULL); + SessionState sessionState = SESSION_STATE_BUTT; + char sessioName[SESSION_NAME_SIZE_MAX] = { 0 }; + int32_t ret = GetSessionStateAndSessionNameBySessionId(socket, sessioName, &sessionState); if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SDK, "get channel by socket=%{public}d failed, ret=%{public}d", socket, ret); + TRANS_LOGE(TRANS_SDK, "get socket state failed, socket=%{public}d failed, ret=%{public}d", socket, ret); return; } - - ret = ClientTransCloseChannel(channelId, type); - if (ret != SOFTBUS_OK) { - TRANS_LOGE(TRANS_SDK, "close channel err: ret=%{public}d, channelId=%{public}d, channeType=%{public}d", ret, - channelId, type); + if (sessionState == SESSION_STATE_CANCELLING) { + TRANS_LOGW(TRANS_SDK, "This socket already in cancelling state. socket=%{public}d", socket); + return; } + SetSessionStateBySessionId(socket, SESSION_STATE_CANCELLING); + if (sessionState == SESSION_STATE_INIT) { + TRANS_LOGI(TRANS_SDK, "This socket state is init, socket=%{public}d", socket); + } else if (sessionState == SESSION_STATE_OPENING) { + TRANS_LOGI(TRANS_SDK, "This socket state is opening, socket=%{public}d", socket); + int32_t ret = ServerIpcCloseChannel(sessioName, socket, CHANNEL_TYPE_UNDEFINED); + if (ret != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SDK, "Call sa delete socket failed: ret=%{public}d", ret); + } + } else if (sessionState == SESSION_STATE_OPENED || sessionState == SESSION_STATE_CALLBACK_FINISHED) { + TRANS_LOGI(TRANS_SDK, "This socket state is opened, socket=%{public}d", socket); + int32_t channelId = INVALID_CHANNEL_ID; + int32_t type = CHANNEL_TYPE_BUTT; + ret = ClientGetChannelBySessionId(socket, &channelId, &type, NULL); + if (ret != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SDK, "get channel by socket=%{public}d failed, ret=%{public}d", socket, ret); + return; + } + ret = ClientTransCloseChannel(channelId, type); + if (ret != SOFTBUS_OK) { + TRANS_LOGE(TRANS_SDK, "close channel err: ret=%{public}d, channelId=%{public}d, channeType=%{public}d", ret, + channelId, type); + } + } ret = ClientDeleteSocketSession(socket); if (ret != SOFTBUS_OK) { TRANS_LOGE(TRANS_SDK, "ClientShutdown delete socket session server: ret=%{public}d", ret); diff --git a/sdk/transmission/trans_channel/auth/src/client_trans_auth_manager.c b/sdk/transmission/trans_channel/auth/src/client_trans_auth_manager.c index 6b606bedff..20eacc42b8 100644 --- a/sdk/transmission/trans_channel/auth/src/client_trans_auth_manager.c +++ b/sdk/transmission/trans_channel/auth/src/client_trans_auth_manager.c @@ -88,7 +88,7 @@ int32_t ClientTransAuthOnDataReceived(int32_t channelId, void ClientTransAuthCloseChannel(int32_t channelId, ShutdownReason reason) { TRANS_LOGI(TRANS_SDK, "TransCloseAuthChannel, channelId=%{public}d", channelId); - if (ServerIpcCloseChannel(channelId, CHANNEL_TYPE_AUTH) != SOFTBUS_OK) { + if (ServerIpcCloseChannel(NULL, channelId, CHANNEL_TYPE_AUTH) != SOFTBUS_OK) { TRANS_LOGE(TRANS_SDK, "server ipc close err. channelId=%{public}d", channelId); } if (ClientTransAuthOnChannelClosed(channelId, reason) != SOFTBUS_OK) { diff --git a/sdk/transmission/trans_channel/proxy/src/client_trans_proxy_manager.c b/sdk/transmission/trans_channel/proxy/src/client_trans_proxy_manager.c index fb64596e4b..d76b9695c2 100644 --- a/sdk/transmission/trans_channel/proxy/src/client_trans_proxy_manager.c +++ b/sdk/transmission/trans_channel/proxy/src/client_trans_proxy_manager.c @@ -823,7 +823,7 @@ void ClientTransProxyCloseChannel(int32_t channelId) (void)ClientTransProxyDelChannelInfo(channelId); (void)TransProxyDelSliceProcessorByChannelId(channelId); TRANS_LOGI(TRANS_SDK, "TransCloseProxyChannel, channelId=%{public}d", channelId); - if (ServerIpcCloseChannel(channelId, CHANNEL_TYPE_PROXY) != SOFTBUS_OK) { + if (ServerIpcCloseChannel(NULL, channelId, CHANNEL_TYPE_PROXY) != SOFTBUS_OK) { TRANS_LOGE(TRANS_SDK, "server close err. channelId=%{public}d", channelId); } } diff --git a/sdk/transmission/trans_channel/tcp_direct/src/client_trans_tcp_direct_manager.c b/sdk/transmission/trans_channel/tcp_direct/src/client_trans_tcp_direct_manager.c index 7683a101a0..c7750f5553 100644 --- a/sdk/transmission/trans_channel/tcp_direct/src/client_trans_tcp_direct_manager.c +++ b/sdk/transmission/trans_channel/tcp_direct/src/client_trans_tcp_direct_manager.c @@ -107,7 +107,7 @@ TcpDirectChannelInfo *TransTdcGetInfoByFd(int32_t fd, TcpDirectChannelInfo *info void TransTdcCloseChannel(int32_t channelId) { TRANS_LOGI(TRANS_SDK, "Close tdc Channel, channelId=%{public}d.", channelId); - if (ServerIpcCloseChannel(channelId, CHANNEL_TYPE_TCP_DIRECT) != SOFTBUS_OK) { + if (ServerIpcCloseChannel(NULL, channelId, CHANNEL_TYPE_TCP_DIRECT) != SOFTBUS_OK) { TRANS_LOGE(TRANS_SDK, "close server tdc channelId=%{public}d err.", channelId); } diff --git a/sdk/transmission/trans_channel/udp/common/src/client_trans_udp_manager.c b/sdk/transmission/trans_channel/udp/common/src/client_trans_udp_manager.c index cb70b1f595..8dececc5ec 100644 --- a/sdk/transmission/trans_channel/udp/common/src/client_trans_udp_manager.c +++ b/sdk/transmission/trans_channel/udp/common/src/client_trans_udp_manager.c @@ -319,7 +319,7 @@ int32_t TransOnUdpChannelOpenFailed(int32_t channelId, int32_t errCode) static int32_t ClosePeerUdpChannel(int32_t channelId) { - return ServerIpcCloseChannel(channelId, CHANNEL_TYPE_UDP); + return ServerIpcCloseChannel(NULL, channelId, CHANNEL_TYPE_UDP); } static int32_t RleaseUdpResources(int32_t channelId) diff --git a/tests/core/transmission/trans_channel/common/trans_lane_test.cpp b/tests/core/transmission/trans_channel/common/trans_lane_test.cpp index 3e80f457e6..d2f058d264 100644 --- a/tests/core/transmission/trans_channel/common/trans_lane_test.cpp +++ b/tests/core/transmission/trans_channel/common/trans_lane_test.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022 Huawei Device Co., Ltd. + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -187,7 +187,7 @@ HWTEST_F(TransLaneTest, TransLaneTest003, TestSize.Level1) EXPECT_EQ(SOFTBUS_OK, ret); ret = TransGetLaneReqItemByLaneHandle(laneHandle, &bSucc, NULL, &errCode); - EXPECT_EQ(SOFTBUS_ERR, ret); + EXPECT_EQ(SOFTBUS_MEM_ERR, ret); ret = TransDelLaneReqFromPendingList(laneHandle, false); EXPECT_EQ(SOFTBUS_OK, ret); diff --git a/tests/core/transmission/trans_channel/manager/trans_channel_manager_test/trans_channel_manager_test.cpp b/tests/core/transmission/trans_channel/manager/trans_channel_manager_test/trans_channel_manager_test.cpp index c6a832b40f..faba4f1d8f 100644 --- a/tests/core/transmission/trans_channel/manager/trans_channel_manager_test/trans_channel_manager_test.cpp +++ b/tests/core/transmission/trans_channel/manager/trans_channel_manager_test/trans_channel_manager_test.cpp @@ -140,7 +140,8 @@ HWTEST_F(TransChannelManagerTest, GetAppInfo001, TestSize.Level1) SessionParam *param = (SessionParam *)SoftBusMalloc(sizeof(SessionParam)); ASSERT_TRUE(param != nullptr); (void)memset_s(param, sizeof(SessionParam), 0, sizeof(SessionParam)); - + param->sessionName = TEST_SESSION_NAME; + param->sessionId = 1; int tmp = 0; param->attr = &g_sessionAttr[tmp]; @@ -151,7 +152,7 @@ HWTEST_F(TransChannelManagerTest, GetAppInfo001, TestSize.Level1) AppInfo *appInfo = (AppInfo *)SoftBusMalloc(sizeof(AppInfo)); ASSERT_TRUE(appInfo != nullptr); (void)memset_s(appInfo, sizeof(AppInfo), 0, sizeof(AppInfo)); - + TransSocketLaneMgrInit(); int ret = TransOpenChannel(param, transInfo); EXPECT_EQ(INVALID_CHANNEL_ID, ret); @@ -173,6 +174,7 @@ HWTEST_F(TransChannelManagerTest, GetAppInfo001, TestSize.Level1) SoftBusFree(param); SoftBusFree(transInfo); SoftBusFree(appInfo); + TransSocketLaneMgrDeinit(); } /** @@ -450,7 +452,7 @@ HWTEST_F(TransChannelManagerTest, TransRequestQos001, TestSize.Level1) int32_t quality = 444; int32_t ret = TransRequestQos(channelId, channelType, appType, quality); - EXPECT_EQ(SOFTBUS_ERR, ret); + EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret); } /** @@ -465,22 +467,22 @@ HWTEST_F(TransChannelManagerTest, TransCloseChannel001, TestSize.Level1) int32_t channelType = 222; channelId++; - int32_t ret = TransCloseChannel(channelId, channelType); + int32_t ret = TransCloseChannel(NULL, channelId, channelType); EXPECT_EQ(SOFTBUS_ERR, ret); channelId++; channelType = CHANNEL_TYPE_UDP; - ret = TransCloseChannel(channelId, channelType); + ret = TransCloseChannel(NULL, channelId, channelType); EXPECT_EQ(SOFTBUS_ERR, ret); channelId++; channelType = CHANNEL_TYPE_AUTH; - ret = TransCloseChannel(channelId, channelType); + ret = TransCloseChannel(NULL, channelId, channelType); EXPECT_EQ(SOFTBUS_LOCK_ERR, ret); channelId++; channelType = CHANNEL_TYPE_TCP_DIRECT; - ret = TransCloseChannel(channelId, channelType); + ret = TransCloseChannel(NULL, channelId, channelType); EXPECT_EQ(SOFTBUS_OK, ret); } diff --git a/tests/core/transmission/trans_channel/manager/trans_lane_manager_test/trans_lane_manager_test.cpp b/tests/core/transmission/trans_channel/manager/trans_lane_manager_test/trans_lane_manager_test.cpp index d8780b3794..e25ca843bf 100644 --- a/tests/core/transmission/trans_channel/manager/trans_lane_manager_test/trans_lane_manager_test.cpp +++ b/tests/core/transmission/trans_channel/manager/trans_lane_manager_test/trans_lane_manager_test.cpp @@ -266,4 +266,57 @@ HWTEST_F(TransLaneManagerTest, TransGetChannelInfoByLaneReqId001, TestSize.Level ret = TransGetChannelInfoByLaneHandle(laneHandle, &channelId, &channelType); EXPECT_EQ(SOFTBUS_ERR, ret); } + +/** + * @tc.name: TransSocketChannelInfoTest001 + * @tc.desc: TransSocketChannelInfoTest001. + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(TransLaneManagerTest, TransSocketChannelInfoTest001, TestSize.Level1) +{ + int32_t ret = TransSocketLaneMgrInit(); + EXPECT_EQ(SOFTBUS_OK, ret); + char sessionName[SESSION_NAME_SIZE_MAX] = "testSessionName"; + int32_t sessionId = 1; + ret = TransAddSocketChannelInfo( + sessionName, sessionId, INVALID_CHANNEL_ID, CHANNEL_TYPE_BUTT, CORE_SESSION_STATE_INIT); + EXPECT_EQ(SOFTBUS_OK, ret); + CoreSessionState state; + ret = TransGetSocketChannelStateBySession(sessionName, sessionId, &state); + EXPECT_EQ(SOFTBUS_OK, ret); + EXPECT_EQ(state, CORE_SESSION_STATE_INIT); + int32_t channelId = 1; + int32_t channelType = CHANNEL_TYPE_TCP_DIRECT; + ret = TransUpdateSocketChannelInfoBySession(sessionName, sessionId, channelId, channelType); + EXPECT_EQ(SOFTBUS_OK, ret); + uint32_t lanHandele = 1; + ret = TransUpdateSocketChannelLaneInfoBySession(sessionName, sessionId, lanHandele, false, true); + EXPECT_EQ(SOFTBUS_OK, ret); + lanHandele = INVALID_CHANNEL_ID; + ret = TransGetSocketChannelLaneInfoBySession(sessionName, sessionId, &lanHandele, NULL, NULL); + EXPECT_EQ(SOFTBUS_OK, ret); + EXPECT_EQ(lanHandele, 1); + ret = TransGetSocketChannelStateByChannel(channelId, channelType, &state); + EXPECT_EQ(SOFTBUS_OK, ret); + EXPECT_EQ(state, CORE_SESSION_STATE_INIT); + ret = TransSetSocketChannelStateByChannel(channelId, channelType, CORE_SESSION_STATE_CHANNEL_OPENED); + EXPECT_EQ(SOFTBUS_OK, ret); + ret = TransGetSocketChannelStateBySession(sessionName, sessionId, &state); + EXPECT_EQ(SOFTBUS_OK, ret); + EXPECT_EQ(state, CORE_SESSION_STATE_CHANNEL_OPENED); + ret = TransSetSocketChannelStateBySession(sessionName, sessionId, CORE_SESSION_STATE_CANCELLING); + EXPECT_EQ(SOFTBUS_OK, ret); + ret = TransGetSocketChannelStateByChannel(channelId, channelType, &state); + EXPECT_EQ(SOFTBUS_OK, ret); + EXPECT_EQ(state, CORE_SESSION_STATE_CANCELLING); + ret = TransDeleteSocketChannelInfoByChannel(channelId, channelType); + EXPECT_EQ(SOFTBUS_OK, ret); + ret = TransDeleteSocketChannelInfoBySession(sessionName, sessionId); + EXPECT_EQ(SOFTBUS_NOT_FIND, ret); + TransSocketLaneMgrDeinit(); + ret = TransAddSocketChannelInfo( + sessionName, sessionId, INVALID_CHANNEL_ID, CHANNEL_TYPE_BUTT, CORE_SESSION_STATE_INIT); + EXPECT_EQ(SOFTBUS_NO_INIT, ret); +} } // OHOS diff --git a/tests/sdk/transmission/fuzztest/transserverproxyextern_fuzzer/transserverproxyextern_fuzzer.cpp b/tests/sdk/transmission/fuzztest/transserverproxyextern_fuzzer/transserverproxyextern_fuzzer.cpp index ec026d867d..69fafaf8d1 100644 --- a/tests/sdk/transmission/fuzztest/transserverproxyextern_fuzzer/transserverproxyextern_fuzzer.cpp +++ b/tests/sdk/transmission/fuzztest/transserverproxyextern_fuzzer/transserverproxyextern_fuzzer.cpp @@ -68,7 +68,7 @@ namespace OHOS { int32_t channelId = *(reinterpret_cast(data)); int32_t channelType = *(reinterpret_cast(data)); - ServerIpcCloseChannel(channelId, channelType); + ServerIpcCloseChannel(NULL, channelId, channelType); } void ServerIpcSendMessageTest(const uint8_t* data, size_t size) diff --git a/tests/sdk/transmission/ipc/trans_ipc_test.cpp b/tests/sdk/transmission/ipc/trans_ipc_test.cpp index d5cb69f149..6adc6093e5 100644 --- a/tests/sdk/transmission/ipc/trans_ipc_test.cpp +++ b/tests/sdk/transmission/ipc/trans_ipc_test.cpp @@ -300,7 +300,7 @@ HWTEST_F(TransIpcStandardTest, CloseChannelTest001, TestSize.Level0) TransServerProxy transServerProxy(nullptr); int32_t channelId = -1; int32_t channelType = CHANNEL_TYPE_AUTH; - int32_t ret = transServerProxy.CloseChannel(channelId, channelType); + int32_t ret = transServerProxy.CloseChannel(nullptr, channelId, channelType); EXPECT_TRUE(ret == SOFTBUS_ERR); } @@ -615,16 +615,16 @@ HWTEST_F(TransIpcStandardTest, ServerIpcCloseChannelTest001, TestSize.Level0) { int32_t channelId = 0; int32_t chanType = CHANNEL_TYPE_AUTH; - int32_t ret = ServerIpcCloseChannel(channelId, chanType); + int32_t ret = ServerIpcCloseChannel(nullptr, channelId, chanType); EXPECT_TRUE(ret == SOFTBUS_ERR); ret = TransServerProxyInit(); ASSERT_EQ(ret, SOFTBUS_OK); - ret = ServerIpcCloseChannel(-1, chanType); + ret = ServerIpcCloseChannel(nullptr, -1, chanType); EXPECT_TRUE(ret == SOFTBUS_ERR); - ret = ServerIpcCloseChannel(channelId, chanType); + ret = ServerIpcCloseChannel(nullptr, channelId, chanType); EXPECT_TRUE(ret != SOFTBUS_OK); TransClientDeinit(); diff --git a/tests/sdk/transmission/session/client_trans_session_manager_test.cpp b/tests/sdk/transmission/session/client_trans_session_manager_test.cpp index d6bf76a3a4..c12d60d993 100644 --- a/tests/sdk/transmission/session/client_trans_session_manager_test.cpp +++ b/tests/sdk/transmission/session/client_trans_session_manager_test.cpp @@ -817,7 +817,7 @@ HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSiz ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_PID, NULL); EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM); ret = ClientRemovePermission(NULL); - EXPECT_EQ(ret, SOFTBUS_ERR); + EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM); } /** @@ -1050,6 +1050,16 @@ HWTEST_F(TransClientSessionManagerTest, ClientTransSetChannelInfoTest01, TestSiz ClientGetChannelBySessionId(1, &channelId, &ChannelType, NULL); ASSERT_EQ(channelId, 11); ASSERT_EQ(ChannelType, CHANNEL_TYPE_TCP_DIRECT); + char sessionName[SESSION_NAME_SIZE_MAX]; + SessionState state; + ret = GetSessionStateAndSessionNameBySessionId(1, sessionName, &state); + ASSERT_EQ(ret, SOFTBUS_OK); + ASSERT_EQ(state, SESSION_STATE_OPENED); + ret = SetSessionStateBySessionId(1, SESSION_STATE_CANCELLING); + ASSERT_EQ(ret, SOFTBUS_OK); + ret = GetSessionStateAndSessionNameBySessionId(1, sessionName, &state); + ASSERT_EQ(ret, SOFTBUS_OK); + ASSERT_EQ(state, SESSION_STATE_CANCELLING); ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName); EXPECT_EQ(ret, SOFTBUS_OK); SoftBusFree(sessionParam); diff --git a/tests/sdk/transmission/session/client_trans_session_test.cpp b/tests/sdk/transmission/session/client_trans_session_test.cpp index c26b24eeaa..474b2f09cf 100644 --- a/tests/sdk/transmission/session/client_trans_session_test.cpp +++ b/tests/sdk/transmission/session/client_trans_session_test.cpp @@ -217,7 +217,7 @@ static SessionInfo *TestGenerateSession(const SessionParam *param) session->algorithm = TRANS_TEST_ALGORITHM; session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT; session->crc = TRANS_TEST_CRC; - + session->sessionState = SESSION_STATE_INIT; return session; } @@ -379,7 +379,7 @@ HWTEST_F(TransClientSessionTest, TransClientSessionTest05, TestSize.Level1) int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener); ASSERT_EQ(ret, SOFTBUS_OK); ret = OpenSession(g_sessionName, g_sessionName, g_networkId, g_groupId, &g_sessionAttr); - EXPECT_EQ(ret, SOFTBUS_ERR); + EXPECT_EQ(ret, -1); SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam)); ASSERT_TRUE(sessionParam != NULL); memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam)); @@ -557,7 +557,7 @@ HWTEST_F(TransClientSessionTest, TransClientSessionTest10, TestSize.Level1) ASSERT_TRUE(session != NULL); session->isEnable = true; ret = CheckSessionIsOpened(TRANS_TEST_CHANNEL_ID); - EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED); + EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND); ret = ClientAddNewSession(g_sessionName, session); ASSERT_EQ(ret, SOFTBUS_OK); ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId); -- Gitee