1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "client_trans_message_service.h"
17
18 #include "client_trans_channel_manager.h"
19 #include "client_trans_file.h"
20 #include "client_trans_file_listener.h"
21 #include "client_trans_session_manager.h"
22 #include "client_trans_session_service.h"
23 #include "client_trans_socket_manager.h"
24 #include "client_trans_statistics.h"
25 #include "softbus_def.h"
26 #include "softbus_error_code.h"
27 #include "softbus_feature_config.h"
28 #include "softbus_adapter_mem.h"
29 #include "trans_log.h"
30
31 #define OH_OS_TYPE 10
32
CheckSendLenForBooster(unsigned int len)33 int32_t CheckSendLenForBooster(unsigned int len)
34 {
35 uint32_t dataConfig = INVALID_DATA_CONFIG;
36 int32_t ret = SoftbusGetConfig(SOFTBUS_INT_MAX_BYTES_LENGTH, (unsigned char *)&dataConfig, sizeof(dataConfig));
37 if (ret != SOFTBUS_OK) {
38 TRANS_LOGE(TRANS_SDK, "get config failed");
39 return SOFTBUS_GET_CONFIG_VAL_ERR;
40 }
41 if (len > dataConfig) {
42 TRANS_LOGE(TRANS_SDK, "send data over limit.len=%{public}u", len);
43 return SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT;
44 }
45 return SOFTBUS_OK;
46 }
47
CheckSendLen(int32_t channelId,int32_t channelType,unsigned int len,int32_t businessType)48 int CheckSendLen(int32_t channelId, int32_t channelType, unsigned int len, int32_t businessType)
49 {
50 uint32_t dataConfig = INVALID_DATA_CONFIG;
51 if (ClientGetDataConfigByChannelId(channelId, channelType, &dataConfig) != SOFTBUS_OK) {
52 TRANS_LOGE(TRANS_SDK, "get config failed.");
53 return SOFTBUS_GET_CONFIG_VAL_ERR;
54 }
55 if (dataConfig == 0) {
56 ConfigType configType = (ConfigType)GetDefaultConfigType(channelType, businessType);
57 if (configType == SOFTBUS_CONFIG_TYPE_MAX) {
58 TRANS_LOGE(TRANS_SDK, "Invalid channelType=%{public}d, businessType=%{public}d",
59 channelType, businessType);
60 return SOFTBUS_INVALID_PARAM;
61 }
62 if (SoftbusGetConfig(configType, (unsigned char *)&dataConfig, sizeof(dataConfig)) != SOFTBUS_OK) {
63 TRANS_LOGE(TRANS_SDK, "get config failed, configType=%{public}d.", configType);
64 return SOFTBUS_GET_CONFIG_VAL_ERR;
65 }
66 }
67 TRANS_LOGI(TRANS_SDK, "channelId=%{public}d, sendDataLen=%{public}u, maxDataLen=%{public}u",
68 channelId, len, dataConfig);
69 if (len > dataConfig) {
70 TRANS_LOGE(TRANS_SDK, "send data over limit.len=%{public}u", len);
71 return SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT;
72 }
73
74 return SOFTBUS_OK;
75 }
76
CheckBusinessTypeAndOsTypeBySessionId(int32_t sessionId,int32_t channelId,int32_t channelType,uint32_t len)77 static int32_t CheckBusinessTypeAndOsTypeBySessionId(int32_t sessionId, int32_t channelId, int32_t channelType,
78 uint32_t len)
79 {
80 int32_t businessType = BUSINESS_TYPE_BUTT;
81 int32_t osType = OH_OS_TYPE;
82 int32_t ret = ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType);
83 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
84 TRANS_BYTES, "ClientGetChannelBusinessTypeBySessionId fail, sessionId=%{public}d", sessionId);
85 ret = ClientGetChannelOsTypeBySessionId(sessionId, &osType);
86 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
87 TRANS_BYTES, "ClientGetChannelOsTypeBySessionId fail, sessionId=%{public}d", sessionId);
88
89 if ((osType == OH_OS_TYPE) && (businessType != BUSINESS_TYPE_BYTE) && (businessType != BUSINESS_TYPE_NOT_CARE) &&
90 (channelType != CHANNEL_TYPE_AUTH)) {
91 TRANS_LOGE(TRANS_BYTES,
92 "BusinessType no match, businessType=%{public}d, sessionId=%{public}d", businessType, sessionId);
93 return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
94 }
95 if (osType != OH_OS_TYPE && businessType == BUSINESS_TYPE_MESSAGE) {
96 ret = CheckSendLenForBooster(len);
97 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
98 TRANS_BYTES, "CheckSendLenForBooster fail, len=%{public}u, sessionId=%{public}d", len, sessionId);
99 } else {
100 ret = CheckSendLen(channelId, channelType, len, BUSINESS_TYPE_BYTE);
101 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
102 TRANS_BYTES, "CheckSendLen fail, len=%{public}u, sessionId=%{public}d", len, sessionId);
103 }
104 return SOFTBUS_OK;
105 }
106
SendBytes(int sessionId,const void * data,unsigned int len)107 int SendBytes(int sessionId, const void *data, unsigned int len)
108 {
109 if (data == NULL || len == 0) {
110 TRANS_LOGW(TRANS_BYTES, "Invalid param");
111 return SOFTBUS_INVALID_PARAM;
112 }
113
114 int ret = CheckPermissionState(sessionId);
115 if (ret != SOFTBUS_OK) {
116 TRANS_LOGE(TRANS_BYTES,
117 "SendBytes no permission, sessionId=%{public}d, len=%{public}u, ret=%{public}d", sessionId, len, ret);
118 return ret;
119 }
120
121 int32_t channelId = INVALID_CHANNEL_ID;
122 int32_t channelType = CHANNEL_TYPE_BUTT;
123 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
124 ret = ClientGetChannelBySessionId(sessionId, &channelId, &channelType, &enableStatus);
125 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
126 TRANS_BYTES, "ClientGetChannelBySessionId fail, sessionId=%{public}d", sessionId);
127
128 ret = CheckBusinessTypeAndOsTypeBySessionId(sessionId, channelId, channelType, len);
129 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
130 TRANS_BYTES, "CheckBusinessTypeAndOsTypeBySessionId fail, sessionId=%{public}d", sessionId);
131 if (enableStatus != ENABLE_STATUS_SUCCESS) {
132 TRANS_LOGE(TRANS_BYTES,
133 "Enable status fail, len=%{public}u, sessionId=%{public}d", len, sessionId);
134 return SOFTBUS_TRANS_SESSION_NO_ENABLE;
135 }
136 (void)ClientResetIdleTimeoutById(sessionId);
137 UpdateChannelStatistics(sessionId, len);
138 return ClientTransChannelSendBytes(channelId, channelType, data, len);
139 }
140
CheckAsyncSendBytesFunc(int32_t channelId,int32_t channelType)141 static int32_t CheckAsyncSendBytesFunc(int32_t channelId, int32_t channelType)
142 {
143 bool supportTlv = false;
144 bool needAck = false;
145 int32_t ret = GetSupportTlvAndNeedAckById(channelId, channelType, &supportTlv, &needAck);
146 if (ret != SOFTBUS_OK) {
147 TRANS_LOGE(TRANS_BYTES, "GetSupportTlvAndNeedAckById fail, channelId=%{public}d", channelId);
148 return ret;
149 }
150 if (!supportTlv || !needAck) {
151 TRANS_LOGE(TRANS_BYTES, "supportTlv or needAck is false, not support async sendbytes, channelId=%{public}d",
152 channelId);
153 return SOFTBUS_TRANS_NOT_SUPPORT_ASYNC_SEND_BYTES;
154 }
155 return SOFTBUS_OK;
156 }
157
SendBytesAsync(int32_t socket,uint32_t dataSeq,const void * data,uint32_t len)158 int32_t SendBytesAsync(int32_t socket, uint32_t dataSeq, const void *data, uint32_t len)
159 {
160 if (data == NULL || dataSeq <= 0 || len == 0) {
161 TRANS_LOGE(TRANS_BYTES, "Invalid param");
162 return SOFTBUS_INVALID_PARAM;
163 }
164 int ret = CheckPermissionState(socket);
165 if (ret != SOFTBUS_OK) {
166 TRANS_LOGE(TRANS_BYTES,
167 "no permission, socket=%{public}d, len=%{public}u, ret=%{public}d", socket, len, ret);
168 return ret;
169 }
170
171 int32_t channelId = INVALID_CHANNEL_ID;
172 int32_t channelType = CHANNEL_TYPE_BUTT;
173 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
174 ret = ClientGetChannelBySessionId(socket, &channelId, &channelType, &enableStatus);
175 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
176 TRANS_BYTES, "ClientGetChannelBySessionId fail, socket=%{public}d", socket);
177 ret = CheckAsyncSendBytesFunc(channelId, channelType);
178 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
179 TRANS_BYTES, "checkAsyncSendByts fail, socket=%{public}d", socket);
180 ret = CheckBusinessTypeAndOsTypeBySessionId(socket, channelId, channelType, len);
181 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
182 TRANS_BYTES, "CheckBusinessTypeAndOsTypeBySessionId fail, socket=%{public}d", socket);
183 if (enableStatus != ENABLE_STATUS_SUCCESS) {
184 TRANS_LOGE(TRANS_BYTES,
185 "session is not enable, len=%{public}u, socket=%{public}d", len, socket);
186 return SOFTBUS_TRANS_SESSION_NO_ENABLE;
187 }
188 (void)ClientResetIdleTimeoutById(socket);
189 UpdateChannelStatistics(socket, len);
190 return ClientTransChannelAsyncSendBytes(channelId, channelType, data, len, dataSeq);
191 }
192
SendMessage(int sessionId,const void * data,unsigned int len)193 int SendMessage(int sessionId, const void *data, unsigned int len)
194 {
195 TRANS_LOGI(TRANS_MSG, "sessionId=%{public}d, len=%{public}d", sessionId, len);
196 if (data == NULL || len == 0) {
197 TRANS_LOGW(TRANS_MSG, "Invalid param");
198 return SOFTBUS_INVALID_PARAM;
199 }
200 int ret = CheckPermissionState(sessionId);
201 if (ret != SOFTBUS_OK) {
202 TRANS_LOGE(TRANS_MSG, "SendMessage no permission, ret=%{public}d", ret);
203 return ret;
204 }
205
206 int32_t channelId = INVALID_CHANNEL_ID;
207 int32_t channelType = CHANNEL_TYPE_BUTT;
208 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
209 if (ClientGetChannelBySessionId(sessionId, &channelId, &channelType, &enableStatus) != SOFTBUS_OK) {
210 return SOFTBUS_TRANS_INVALID_SESSION_ID;
211 }
212
213 int32_t businessType = BUSINESS_TYPE_BUTT;
214 if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
215 return SOFTBUS_TRANS_INVALID_SESSION_ID;
216 }
217 if ((businessType != BUSINESS_TYPE_MESSAGE) && (businessType != BUSINESS_TYPE_NOT_CARE) &&
218 (channelType != CHANNEL_TYPE_AUTH)) {
219 TRANS_LOGE(TRANS_MSG, "BusinessType no match, businessType=%{public}d", businessType);
220 return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
221 }
222
223 int checkRet = CheckSendLen(channelId, channelType, len, BUSINESS_TYPE_MESSAGE);
224 if (checkRet != SOFTBUS_OK) {
225 return checkRet;
226 }
227
228 if (enableStatus != ENABLE_STATUS_SUCCESS) {
229 return SOFTBUS_TRANS_SESSION_NO_ENABLE;
230 }
231 (void)ClientResetIdleTimeoutById(sessionId);
232 UpdateChannelStatistics(sessionId, len);
233 return ClientTransChannelSendMessage(channelId, channelType, data, len);
234 }
235
SendStream(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)236 int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
237 {
238 if ((data == NULL) || (ext == NULL) || (param == NULL)) {
239 TRANS_LOGW(TRANS_STREAM, "Invalid param");
240 return SOFTBUS_INVALID_PARAM;
241 }
242 int ret = CheckPermissionState(sessionId);
243 if (ret != SOFTBUS_OK) {
244 TRANS_LOGE(TRANS_STREAM, "SendStream no permission, ret=%{public}d", ret);
245 return ret;
246 }
247
248 int32_t channelId = INVALID_CHANNEL_ID;
249 int32_t type = CHANNEL_TYPE_BUTT;
250 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
251 if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &enableStatus) != SOFTBUS_OK) {
252 return SOFTBUS_TRANS_INVALID_SESSION_ID;
253 }
254 if (type != CHANNEL_TYPE_UDP) {
255 return SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL;
256 }
257
258 int32_t businessType = BUSINESS_TYPE_BUTT;
259 if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
260 return SOFTBUS_TRANS_INVALID_SESSION_ID;
261 }
262 if ((businessType != BUSINESS_TYPE_STREAM) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
263 TRANS_LOGE(TRANS_STREAM, "BusinessType no match, businessType=%{public}d", businessType);
264 return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
265 }
266
267 if (enableStatus != ENABLE_STATUS_SUCCESS) {
268 return SOFTBUS_TRANS_SESSION_NO_ENABLE;
269 }
270 (void)ClientResetIdleTimeoutById(sessionId);
271 UpdateChannelStatistics(sessionId, data->bufLen);
272 return ClientTransChannelSendStream(channelId, type, data, ext, param);
273 }
274
SendFile(int sessionId,const char * sFileList[],const char * dFileList[],uint32_t fileCnt)275 int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt)
276 {
277 if ((sFileList == NULL) || (fileCnt == 0)) {
278 TRANS_LOGW(TRANS_FILE, "Invalid param");
279 return SOFTBUS_INVALID_PARAM;
280 }
281 int ret = CheckPermissionState(sessionId);
282 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
283 TRANS_FILE, "SendFile no permission, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
284
285 FileSchemaListener *fileSchemaListener = (FileSchemaListener*)SoftBusCalloc(sizeof(FileSchemaListener));
286 if (fileSchemaListener == NULL) {
287 return SOFTBUS_MALLOC_ERR;
288 }
289 if (CheckFileSchema(sessionId, fileSchemaListener) == SOFTBUS_OK) {
290 ret = SetSchemaCallback(fileSchemaListener->schema, sFileList, fileCnt);
291 if (ret != SOFTBUS_OK) {
292 TRANS_LOGE(TRANS_FILE, "set schema callback failed, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
293 SoftBusFree(fileSchemaListener);
294 return ret;
295 }
296 }
297
298 int32_t channelId = INVALID_CHANNEL_ID;
299 int32_t type = CHANNEL_TYPE_BUTT;
300 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
301 if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &enableStatus) != SOFTBUS_OK) {
302 TRANS_LOGE(TRANS_FILE, "ClientGetChannelBySessionId failed, sessionId=%{public}d", sessionId);
303 SoftBusFree(fileSchemaListener);
304 return SOFTBUS_TRANS_INVALID_SESSION_ID;
305 }
306
307 int32_t businessType = BUSINESS_TYPE_BUTT;
308 if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
309 TRANS_LOGE(TRANS_FILE, "ClientGetChannelBusinessTypeBySessionId failed, sessionId=%{public}d", sessionId);
310 SoftBusFree(fileSchemaListener);
311 return SOFTBUS_TRANS_INVALID_SESSION_ID;
312 }
313 if ((businessType != BUSINESS_TYPE_FILE) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
314 TRANS_LOGE(TRANS_FILE,
315 "BusinessType no match, sessionId=%{public}d, businessType=%{public}d", sessionId, businessType);
316 SoftBusFree(fileSchemaListener);
317 return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
318 }
319
320 if (enableStatus != ENABLE_STATUS_SUCCESS) {
321 TRANS_LOGE(TRANS_FILE, "Enable status failed, sessionId=%{public}d", sessionId);
322 SoftBusFree(fileSchemaListener);
323 return SOFTBUS_TRANS_SESSION_NO_ENABLE;
324 }
325 SoftBusFree(fileSchemaListener);
326 (void)ClientResetIdleTimeoutById(sessionId);
327 return ClientTransChannelSendFile(channelId, type, sFileList, dFileList, fileCnt);
328 }
329