1 /*
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "trans_session_service.h"
17
18 #include "securec.h"
19 #include <stdatomic.h>
20
21 #include "anonymizer.h"
22 #include "lnn_ohos_account_adapter.h"
23 #include "g_enhance_trans_func.h"
24 #include "g_enhance_trans_func_pack.h"
25 #include "softbus_access_token_adapter.h"
26 #include "softbus_adapter_mem.h"
27 #include "softbus_def.h"
28 #include "softbus_error_code.h"
29 #include "softbus_permission.h"
30 #include "softbus_scenario_manager.h"
31 #include "softbus_utils.h"
32 #include "softbus_init_common.h"
33 #include "trans_channel_manager.h"
34 #include "trans_client_proxy.h"
35 #include "trans_event.h"
36 #include "trans_inner.h"
37 #include "trans_log.h"
38 #include "trans_session_account_adapter.h"
39 #include "trans_session_ipc_adapter.h"
40 #include "trans_session_manager.h"
41
42 static _Atomic bool g_transSessionInitFlag = false;
43
TransServerInit(void)44 int32_t TransServerInit(void)
45 {
46 if (atomic_load_explicit(&g_transSessionInitFlag, memory_order_acquire)) {
47 return SOFTBUS_OK;
48 }
49 int32_t ret = TransPermissionInit();
50 if (ret != SOFTBUS_OK) {
51 TRANS_LOGE(TRANS_INIT, "Init trans permission failed");
52 return ret;
53 }
54 ret = TransSessionMgrInit();
55 if (ret != SOFTBUS_OK) {
56 TRANS_LOGE(TRANS_INIT, "TransSessionMgrInit failed");
57 return ret;
58 }
59 ret = TransChannelInit();
60 if (ret != SOFTBUS_OK) {
61 TRANS_LOGE(TRANS_INIT, "TransChannelInit failed");
62 return ret;
63 }
64 ret = InitQosPacked();
65 if (ret != SOFTBUS_OK) {
66 TRANS_LOGE(TRANS_INIT, "QosInit Failed");
67 return ret;
68 }
69 ret = InnerListInit();
70 if (ret != SOFTBUS_OK) {
71 TRANS_LOGE(TRANS_INIT, "InnerListInit Failed");
72 return ret;
73 }
74 if (ScenarioManagerGetInstance() == NULL) {
75 TRANS_LOGE(TRANS_INIT, "ScenarioManager init Failed");
76 return SOFTBUS_NO_INIT;
77 }
78 if (InitSoftbusPagingResPullPacked() != SOFTBUS_OK) {
79 TRANS_LOGE(TRANS_INIT, "InitSoftbusPagingResPullPacked Failed");
80 }
81 if (InitSoftbusPagingPacked() != SOFTBUS_OK) {
82 TRANS_LOGE(TRANS_INIT, "InitSoftbusPagingPacked Failed");
83 }
84 RegisterPermissionChangeCallback();
85 atomic_store_explicit(&g_transSessionInitFlag, true, memory_order_release);
86 TRANS_LOGI(TRANS_INIT, "trans session server list init succ");
87 return SOFTBUS_OK;
88 }
89
TransServerDeinit(void)90 void TransServerDeinit(void)
91 {
92 if (!atomic_load_explicit(&g_transSessionInitFlag, memory_order_acquire)) {
93 return;
94 }
95
96 TransSessionMgrDeinit();
97 TransChannelDeinit();
98 InnerListDeinit();
99 TransPermissionDeinit();
100 ScenarioManagerdestroyInstance();
101 DeInitSoftbusPagingResPullPacked();
102 DeInitSoftbusPagingPacked();
103 atomic_store_explicit(&g_transSessionInitFlag, false, memory_order_release);
104 }
105
TransServerDeathCallback(const char * pkgName,int32_t pid)106 void TransServerDeathCallback(const char *pkgName, int32_t pid)
107 {
108 TransChannelDeathCallback(pkgName, pid);
109 TransDelItemByPackageName(pkgName, pid);
110 TransPagingDeathCallbackPacked(pkgName, pid);
111 TransProcessGroupTalkieInfoPacked(pkgName);
112 }
113
TransSetUserId(CallerType callerType,SessionServer * newNode)114 static void TransSetUserId(CallerType callerType, SessionServer *newNode)
115 {
116 if (callerType == CALLER_TYPE_FEATURE_ABILITY) {
117 newNode->accessInfo.userId = TransGetUserIdFromUid(newNode->uid);
118 if (newNode->accessInfo.userId == INVALID_USER_ID) {
119 TRANS_LOGE(TRANS_CTRL, "TransGetUserIdFromUid failed");
120 return;
121 }
122 } else {
123 newNode->accessInfo.userId = INVALID_USER_ID;
124 }
125 }
126
PrintSessionInfo(const char * pkgName,const char * sessionName,int32_t uid,int32_t pid)127 static void PrintSessionInfo(const char *pkgName, const char *sessionName, int32_t uid, int32_t pid)
128 {
129 char *tmpName = NULL;
130 Anonymize(sessionName, &tmpName);
131 TRANS_LOGI(TRANS_CTRL, "pkgName=%{public}s, sessionName=%{public}s, uid=%{public}d, pid=%{public}d",
132 pkgName, AnonymizeWrapper(tmpName), uid, pid);
133 AnonymizeFree(tmpName);
134 }
135
TransCreateSessionServer(const char * pkgName,const char * sessionName,int32_t uid,int32_t pid)136 int32_t TransCreateSessionServer(const char *pkgName, const char *sessionName, int32_t uid, int32_t pid)
137 {
138 if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
139 return SOFTBUS_INVALID_PARAM;
140 }
141 PrintSessionInfo(pkgName, sessionName, uid, pid);
142 SessionServer *newNode = (SessionServer *)SoftBusCalloc(sizeof(SessionServer));
143 TRANS_CHECK_AND_RETURN_RET_LOGE(newNode != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "malloc failed");
144 if (strcpy_s(newNode->pkgName, sizeof(newNode->pkgName), pkgName) != EOK) {
145 SoftBusFree(newNode);
146 return SOFTBUS_STRCPY_ERR;
147 }
148 if (strcpy_s(newNode->sessionName, sizeof(newNode->sessionName), sessionName) != EOK) {
149 SoftBusFree(newNode);
150 return SOFTBUS_STRCPY_ERR;
151 }
152 newNode->type = SEC_TYPE_CIPHERTEXT;
153 newNode->uid = uid;
154 newNode->pid = pid;
155
156 int32_t ret = TransGetCallingFullTokenId(&newNode->tokenId);
157 if (ret != SOFTBUS_OK) {
158 TRANS_LOGE(TRANS_CTRL, "get callingTokenId failed, ret=%{public}d", ret);
159 SoftBusFree(newNode);
160 return ret;
161 }
162 newNode->accessInfo.localTokenId = newNode->tokenId;
163 int32_t tokenType = SoftBusGetAccessTokenType(newNode->tokenId);
164 newNode->callerType = (SoftBusAccessTokenType)tokenType == ACCESS_TOKEN_TYPE_HAP ?
165 CALLER_TYPE_FEATURE_ABILITY : CALLER_TYPE_SERVICE_ABILITY;
166 newNode->tokenType = tokenType;
167 TransSetUserId(newNode->callerType, newNode);
168 ret = TransSessionServerAddItem(newNode);
169 TransEventExtra extra = {
170 .socketName = sessionName,
171 .callerPkg = pkgName,
172 .errcode = ret,
173 .result = ret == SOFTBUS_OK ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED
174 };
175 if (ret != SOFTBUS_OK) {
176 SoftBusFree(newNode);
177 if (ret == SOFTBUS_SERVER_NAME_REPEATED) {
178 TRANS_LOGD(TRANS_CTRL, "session server is already created");
179 }
180 TRANS_EVENT(EVENT_SCENE_TRANS_CREATE_SESS_SERVER, EVENT_STAGE_TRANS_COMMON_ONE, extra);
181 return ret;
182 }
183 TRANS_EVENT(EVENT_SCENE_TRANS_CREATE_SESS_SERVER, EVENT_STAGE_TRANS_COMMON_ONE, extra);
184 TRANS_LOGD(TRANS_CTRL, "ok");
185 return SOFTBUS_OK;
186 }
187
TransRemoveSessionServer(const char * pkgName,const char * sessionName)188 int32_t TransRemoveSessionServer(const char *pkgName, const char *sessionName)
189 {
190 if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) ||
191 !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
192 return SOFTBUS_INVALID_PARAM;
193 }
194 int32_t ret = TransSessionServerDelItem(sessionName);
195 TransEventExtra extra = {
196 .socketName = sessionName,
197 .callerPkg = pkgName,
198 .errcode = ret,
199 .result = ret == SOFTBUS_OK ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED
200 };
201 TRANS_EVENT(EVENT_SCENE_TRANS_REMOVE_SESS_SERVER, EVENT_STAGE_TRANS_COMMON_ONE, extra);
202 return ret;
203 }
204
TransOpenSession(const SessionParam * param,TransInfo * info)205 int32_t TransOpenSession(const SessionParam *param, TransInfo *info)
206 {
207 if (!param ||!IsValidString(param->sessionName, SESSION_NAME_SIZE_MAX) ||
208 !IsValidString(param->peerSessionName, SESSION_NAME_SIZE_MAX) ||
209 !IsValidString(param->peerDeviceId, DEVICE_ID_SIZE_MAX) ||
210 (param->isQosLane && param->qosCount > QOS_TYPE_BUTT)) {
211 TRANS_LOGE(TRANS_CTRL, "SessionParam check failed");
212 return SOFTBUS_INVALID_PARAM;
213 }
214 if (param->groupId == NULL || strlen(param->groupId) >= GROUP_ID_SIZE_MAX) {
215 TRANS_LOGE(TRANS_CTRL, "invalid groupId");
216 return SOFTBUS_TRANS_SESSION_GROUP_INVALID;
217 }
218
219 if (!TransSessionServerIsExist(param->sessionName)) {
220 TRANS_LOGE(TRANS_CTRL, "session server invalid");
221 return SOFTBUS_TRANS_SESSION_NAME_NO_EXIST;
222 }
223
224 return TransOpenChannel(param, info);
225 }
226