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_errcode.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 
SendBytes(int sessionId,const void * data,unsigned int len)77 int SendBytes(int sessionId, const void *data, unsigned int len)
78 {
79     if (data == NULL || len == 0) {
80         TRANS_LOGW(TRANS_BYTES, "Invalid param");
81         return SOFTBUS_INVALID_PARAM;
82     }
83 
84     int ret = CheckPermissionState(sessionId);
85     if (ret != SOFTBUS_OK) {
86         TRANS_LOGE(TRANS_BYTES,
87             "SendBytes no permission, sessionId=%{public}d, len=%{public}u, ret=%{public}d", sessionId, len, ret);
88         return ret;
89     }
90 
91     int32_t channelId = INVALID_CHANNEL_ID;
92     int32_t channelType = CHANNEL_TYPE_BUTT;
93     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
94     ret = ClientGetChannelBySessionId(sessionId, &channelId, &channelType, &enableStatus);
95     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
96         TRANS_BYTES, "ClientGetChannelBySessionId fail, sessionId=%{public}d", sessionId);
97 
98     int32_t businessType = BUSINESS_TYPE_BUTT;
99     int32_t osType = OH_OS_TYPE;
100     ret = ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType);
101     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
102         TRANS_BYTES, "ClientGetChannelBusinessTypeBySessionId fail, sessionId=%{public}d", sessionId);
103     ret = ClientGetChannelOsTypeBySessionId(sessionId, &osType);
104     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
105         TRANS_BYTES, "ClientGetChannelOsTypeBySessionId fail, sessionId=%{public}d", sessionId);
106 
107     if ((osType == OH_OS_TYPE) && (businessType != BUSINESS_TYPE_BYTE) && (businessType != BUSINESS_TYPE_NOT_CARE) &&
108         (channelType != CHANNEL_TYPE_AUTH)) {
109         TRANS_LOGE(TRANS_BYTES,
110             "BusinessType no match, businessType=%{public}d, sessionId=%{public}d", businessType, sessionId);
111         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
112     }
113 
114     if (osType != OH_OS_TYPE && businessType == BUSINESS_TYPE_MESSAGE) {
115         ret = CheckSendLenForBooster(len);
116         TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
117             TRANS_BYTES, "CheckSendLenForBooster fail, len=%{public}u, sessionId=%{public}d", len, sessionId);
118     } else {
119         ret = CheckSendLen(channelId, channelType, len, BUSINESS_TYPE_BYTE);
120         TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
121             TRANS_BYTES, "CheckSendLen fail, len=%{public}u, sessionId=%{public}d", len, sessionId);
122     }
123     if (enableStatus != ENABLE_STATUS_SUCCESS) {
124         TRANS_LOGE(TRANS_BYTES,
125             "Enable status fail, len=%{public}u, sessionId=%{public}d", len, sessionId);
126         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
127     }
128     (void)ClientResetIdleTimeoutById(sessionId);
129     UpdateChannelStatistics(sessionId, len);
130     return ClientTransChannelSendBytes(channelId, channelType, data, len);
131 }
132 
SendMessage(int sessionId,const void * data,unsigned int len)133 int SendMessage(int sessionId, const void *data, unsigned int len)
134 {
135     TRANS_LOGI(TRANS_MSG, "sessionId=%{public}d, len=%{public}d", sessionId, len);
136     if (data == NULL || len == 0) {
137         TRANS_LOGW(TRANS_MSG, "Invalid param");
138         return SOFTBUS_INVALID_PARAM;
139     }
140     int ret = CheckPermissionState(sessionId);
141     if (ret != SOFTBUS_OK) {
142         TRANS_LOGE(TRANS_MSG, "SendMessage no permission, ret=%{public}d", ret);
143         return ret;
144     }
145 
146     int32_t channelId = INVALID_CHANNEL_ID;
147     int32_t channelType = CHANNEL_TYPE_BUTT;
148     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
149     if (ClientGetChannelBySessionId(sessionId, &channelId, &channelType, &enableStatus) != SOFTBUS_OK) {
150         return SOFTBUS_TRANS_INVALID_SESSION_ID;
151     }
152 
153     int32_t businessType = BUSINESS_TYPE_BUTT;
154     if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
155         return SOFTBUS_TRANS_INVALID_SESSION_ID;
156     }
157     if ((businessType != BUSINESS_TYPE_MESSAGE) && (businessType != BUSINESS_TYPE_NOT_CARE) &&
158         (channelType != CHANNEL_TYPE_AUTH)) {
159         TRANS_LOGE(TRANS_MSG, "BusinessType no match, businessType=%{public}d", businessType);
160         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
161     }
162 
163     int checkRet = CheckSendLen(channelId, channelType, len, BUSINESS_TYPE_MESSAGE);
164     if (checkRet != SOFTBUS_OK) {
165         return checkRet;
166     }
167 
168     if (enableStatus != ENABLE_STATUS_SUCCESS) {
169         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
170     }
171     (void)ClientResetIdleTimeoutById(sessionId);
172     UpdateChannelStatistics(sessionId, len);
173     return ClientTransChannelSendMessage(channelId, channelType, data, len);
174 }
175 
SendStream(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)176 int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
177 {
178     if ((data == NULL) || (ext == NULL) || (param == NULL)) {
179         TRANS_LOGW(TRANS_STREAM, "Invalid param");
180         return SOFTBUS_INVALID_PARAM;
181     }
182     int ret = CheckPermissionState(sessionId);
183     if (ret != SOFTBUS_OK) {
184         TRANS_LOGE(TRANS_STREAM, "SendStream no permission, ret=%{public}d", ret);
185         return ret;
186     }
187 
188     int32_t channelId = INVALID_CHANNEL_ID;
189     int32_t type = CHANNEL_TYPE_BUTT;
190     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
191     if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &enableStatus) != SOFTBUS_OK) {
192         return SOFTBUS_TRANS_INVALID_SESSION_ID;
193     }
194     if (type != CHANNEL_TYPE_UDP) {
195         return SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL;
196     }
197 
198     int32_t businessType = BUSINESS_TYPE_BUTT;
199     if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
200         return SOFTBUS_TRANS_INVALID_SESSION_ID;
201     }
202     if ((businessType != BUSINESS_TYPE_STREAM) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
203         TRANS_LOGE(TRANS_STREAM, "BusinessType no match, businessType=%{public}d", businessType);
204         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
205     }
206 
207     if (enableStatus != ENABLE_STATUS_SUCCESS) {
208         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
209     }
210     (void)ClientResetIdleTimeoutById(sessionId);
211     UpdateChannelStatistics(sessionId, data->bufLen);
212     return ClientTransChannelSendStream(channelId, type, data, ext, param);
213 }
214 
SendFile(int sessionId,const char * sFileList[],const char * dFileList[],uint32_t fileCnt)215 int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt)
216 {
217     if ((sFileList == NULL) || (fileCnt == 0)) {
218         TRANS_LOGW(TRANS_FILE, "Invalid param");
219         return SOFTBUS_INVALID_PARAM;
220     }
221     int ret = CheckPermissionState(sessionId);
222     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
223         TRANS_FILE,  "SendFile no permission, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
224 
225     FileSchemaListener *fileSchemaListener = (FileSchemaListener*)SoftBusCalloc(sizeof(FileSchemaListener));
226     if (fileSchemaListener == NULL) {
227         return SOFTBUS_MALLOC_ERR;
228     }
229     if (CheckFileSchema(sessionId, fileSchemaListener) == SOFTBUS_OK) {
230         ret = SetSchemaCallback(fileSchemaListener->schema, sFileList, fileCnt);
231         if (ret != SOFTBUS_OK) {
232             TRANS_LOGE(TRANS_FILE, "set schema callback failed, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
233             SoftBusFree(fileSchemaListener);
234             return ret;
235         }
236     }
237 
238     int32_t channelId = INVALID_CHANNEL_ID;
239     int32_t type = CHANNEL_TYPE_BUTT;
240     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
241     if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &enableStatus) != SOFTBUS_OK) {
242         TRANS_LOGE(TRANS_FILE, "ClientGetChannelBySessionId failed, sessionId=%{public}d", sessionId);
243         SoftBusFree(fileSchemaListener);
244         return SOFTBUS_TRANS_INVALID_SESSION_ID;
245     }
246 
247     int32_t businessType = BUSINESS_TYPE_BUTT;
248     if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
249         TRANS_LOGE(TRANS_FILE, "ClientGetChannelBusinessTypeBySessionId failed, sessionId=%{public}d", sessionId);
250         SoftBusFree(fileSchemaListener);
251         return SOFTBUS_TRANS_INVALID_SESSION_ID;
252     }
253     if ((businessType != BUSINESS_TYPE_FILE) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
254         TRANS_LOGE(TRANS_FILE,
255             "BusinessType no match, sessionId=%{public}d, businessType=%{public}d", sessionId, businessType);
256         SoftBusFree(fileSchemaListener);
257         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
258     }
259 
260     if (enableStatus !=  ENABLE_STATUS_SUCCESS) {
261         TRANS_LOGE(TRANS_FILE, "Enable status failed, sessionId=%{public}d", sessionId);
262         SoftBusFree(fileSchemaListener);
263         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
264     }
265     SoftBusFree(fileSchemaListener);
266     (void)ClientResetIdleTimeoutById(sessionId);
267     return ClientTransChannelSendFile(channelId, type, sFileList, dFileList, fileCnt);
268 }
269