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 "softbus_access_token_adapter.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_def.h"
25 #include "softbus_error_code.h"
26 #include "softbus_permission.h"
27 #include "softbus_qos.h"
28 #include "softbus_scenario_manager.h"
29 #include "softbus_utils.h"
30 #include "trans_channel_manager.h"
31 #include "trans_client_proxy.h"
32 #include "trans_event.h"
33 #include "trans_log.h"
34 #include "trans_session_ipc_adapter.h"
35 #include "trans_session_manager.h"
36
37 static _Atomic bool g_transSessionInitFlag = false;
38
TransServerInit(void)39 int32_t TransServerInit(void)
40 {
41 if (atomic_load_explicit(&g_transSessionInitFlag, memory_order_acquire)) {
42 return SOFTBUS_OK;
43 }
44 int32_t ret = TransPermissionInit();
45 if (ret != SOFTBUS_OK) {
46 TRANS_LOGE(TRANS_INIT, "Init trans permission failed");
47 return ret;
48 }
49 ret = TransSessionMgrInit();
50 if (ret != SOFTBUS_OK) {
51 TRANS_LOGE(TRANS_INIT, "TransSessionMgrInit failed");
52 return ret;
53 }
54 ret = TransChannelInit();
55 if (ret != SOFTBUS_OK) {
56 TRANS_LOGE(TRANS_INIT, "TransChannelInit failed");
57 return ret;
58 }
59 ret = InitQos();
60 if (ret != SOFTBUS_OK) {
61 TRANS_LOGE(TRANS_INIT, "QosInit Failed");
62 return ret;
63 }
64 ret = ScenarioManagerGetInstance();
65 if (ret != SOFTBUS_OK) {
66 TRANS_LOGE(TRANS_INIT, "ScenarioManager init Failed");
67 return ret;
68 }
69 RegisterPermissionChangeCallback();
70 atomic_store_explicit(&g_transSessionInitFlag, true, memory_order_release);
71 TRANS_LOGI(TRANS_INIT, "trans session server list init succ");
72 return SOFTBUS_OK;
73 }
74
TransServerDeinit(void)75 void TransServerDeinit(void)
76 {
77 if (!atomic_load_explicit(&g_transSessionInitFlag, memory_order_acquire)) {
78 return;
79 }
80
81 TransSessionMgrDeinit();
82 TransChannelDeinit();
83 TransPermissionDeinit();
84 ScenarioManagerdestroyInstance();
85 atomic_store_explicit(&g_transSessionInitFlag, false, memory_order_release);
86 }
87
TransServerDeathCallback(const char * pkgName,int32_t pid)88 void TransServerDeathCallback(const char *pkgName, int32_t pid)
89 {
90 TransChannelDeathCallback(pkgName, pid);
91 TransDelItemByPackageName(pkgName, pid);
92 }
93
PrintSessionInfo(const char * pkgName,const char * sessionName,int32_t uid,int32_t pid)94 static void PrintSessionInfo(const char *pkgName, const char *sessionName, int32_t uid, int32_t pid)
95 {
96 char *tmpName = NULL;
97 Anonymize(sessionName, &tmpName);
98 TRANS_LOGI(TRANS_CTRL, "pkgName=%{public}s, sessionName=%{public}s, uid=%{public}d, pid=%{public}d",
99 pkgName, AnonymizeWrapper(tmpName), uid, pid);
100 AnonymizeFree(tmpName);
101 }
102
TransCreateSessionServer(const char * pkgName,const char * sessionName,int32_t uid,int32_t pid)103 int32_t TransCreateSessionServer(const char *pkgName, const char *sessionName, int32_t uid, int32_t pid)
104 {
105 if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) || !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
106 return SOFTBUS_INVALID_PARAM;
107 }
108 PrintSessionInfo(pkgName, sessionName, uid, pid);
109 SessionServer *newNode = (SessionServer *)SoftBusCalloc(sizeof(SessionServer));
110 TRANS_CHECK_AND_RETURN_RET_LOGE(newNode != NULL, SOFTBUS_MALLOC_ERR, TRANS_CTRL, "malloc failed");
111 if (strcpy_s(newNode->pkgName, sizeof(newNode->pkgName), pkgName) != EOK) {
112 SoftBusFree(newNode);
113 return SOFTBUS_STRCPY_ERR;
114 }
115 if (strcpy_s(newNode->sessionName, sizeof(newNode->sessionName), sessionName) != EOK) {
116 SoftBusFree(newNode);
117 return SOFTBUS_STRCPY_ERR;
118 }
119 newNode->type = SEC_TYPE_CIPHERTEXT;
120 newNode->uid = uid;
121 newNode->pid = pid;
122
123 int32_t ret = TransGetCallingFullTokenId(&newNode->tokenId);
124 if (ret != SOFTBUS_OK) {
125 TRANS_LOGE(TRANS_CTRL, "get callingTokenId failed, ret=%{public}d", ret);
126 SoftBusFree(newNode);
127 return ret;
128 }
129 int32_t tokenType = SoftBusGetAccessTokenType(newNode->tokenId);
130 newNode->callerType = (SoftBusAccessTokenType)tokenType == ACCESS_TOKEN_TYPE_HAP ?
131 CALLER_TYPE_FEATURE_ABILITY : CALLER_TYPE_SERVICE_ABILITY;
132 ret = TransSessionServerAddItem(newNode);
133 TransEventExtra extra = {
134 .socketName = sessionName,
135 .callerPkg = pkgName,
136 .errcode = ret,
137 .result = ret == SOFTBUS_OK ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED
138 };
139 if (ret != SOFTBUS_OK) {
140 SoftBusFree(newNode);
141 if (ret == SOFTBUS_SERVER_NAME_REPEATED) {
142 TRANS_LOGD(TRANS_CTRL, "session server is already created");
143 }
144 TRANS_EVENT(EVENT_SCENE_TRANS_CREATE_SESS_SERVER, EVENT_STAGE_TRANS_COMMON_ONE, extra);
145 return ret;
146 }
147 TRANS_EVENT(EVENT_SCENE_TRANS_CREATE_SESS_SERVER, EVENT_STAGE_TRANS_COMMON_ONE, extra);
148 TRANS_LOGD(TRANS_CTRL, "ok");
149 return SOFTBUS_OK;
150 }
151
TransRemoveSessionServer(const char * pkgName,const char * sessionName)152 int32_t TransRemoveSessionServer(const char *pkgName, const char *sessionName)
153 {
154 if (!IsValidString(pkgName, PKG_NAME_SIZE_MAX - 1) ||
155 !IsValidString(sessionName, SESSION_NAME_SIZE_MAX - 1)) {
156 return SOFTBUS_INVALID_PARAM;
157 }
158 int32_t ret = TransSessionServerDelItem(sessionName);
159 TransEventExtra extra = {
160 .socketName = sessionName,
161 .callerPkg = pkgName,
162 .errcode = ret,
163 .result = ret == SOFTBUS_OK ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED
164 };
165 TRANS_EVENT(EVENT_SCENE_TRANS_REMOVE_SESS_SERVER, EVENT_STAGE_TRANS_COMMON_ONE, extra);
166 return ret;
167 }
168
TransOpenSession(const SessionParam * param,TransInfo * info)169 int32_t TransOpenSession(const SessionParam *param, TransInfo *info)
170 {
171 if (!IsValidString(param->sessionName, SESSION_NAME_SIZE_MAX) ||
172 !IsValidString(param->peerSessionName, SESSION_NAME_SIZE_MAX) ||
173 !IsValidString(param->peerDeviceId, DEVICE_ID_SIZE_MAX) ||
174 (param->isQosLane && param->qosCount > QOS_TYPE_BUTT)) {
175 TRANS_LOGE(TRANS_CTRL, "SessionParam check failed");
176 return SOFTBUS_INVALID_PARAM;
177 }
178 if (param->groupId == NULL || strlen(param->groupId) >= GROUP_ID_SIZE_MAX) {
179 TRANS_LOGE(TRANS_CTRL, "invalid groupId");
180 return SOFTBUS_TRANS_SESSION_GROUP_INVALID;
181 }
182
183 if (!TransSessionServerIsExist(param->sessionName)) {
184 TRANS_LOGE(TRANS_CTRL, "session server invalid");
185 return SOFTBUS_TRANS_SESSION_NAME_NO_EXIST;
186 }
187
188 return TransOpenChannel(param, info);
189 }
190