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 
CheckSendLen(int32_t channelId, int32_t channelType, unsigned int len, int32_t businessType)33 int CheckSendLen(int32_t channelId, int32_t channelType, unsigned int len, int32_t businessType)
34 {
35     uint32_t dataConfig = INVALID_DATA_CONFIG;
36     if (ClientGetDataConfigByChannelId(channelId, channelType, &dataConfig) != SOFTBUS_OK) {
37         TRANS_LOGE(TRANS_SDK, "get config failed.");
38         return SOFTBUS_GET_CONFIG_VAL_ERR;
39     }
40     if (dataConfig == 0) {
41         ConfigType configType = (ConfigType)GetDefaultConfigType(channelType, businessType);
42         if (configType == SOFTBUS_CONFIG_TYPE_MAX) {
43             TRANS_LOGE(TRANS_SDK, "Invalid channelType=%{public}d, businessType=%{public}d",
44                 channelType, businessType);
45             return SOFTBUS_INVALID_PARAM;
46         }
47         if (SoftbusGetConfig(configType, (unsigned char *)&dataConfig, sizeof(dataConfig)) != SOFTBUS_OK) {
48             TRANS_LOGE(TRANS_SDK, "get config failed, configType=%{public}d.", configType);
49             return SOFTBUS_GET_CONFIG_VAL_ERR;
50         }
51     }
52     TRANS_LOGI(TRANS_SDK, "channelId=%{public}d, sendDataLen=%{public}u, maxDataLen=%{public}u",
53         channelId, len, dataConfig);
54     if (len > dataConfig) {
55         TRANS_LOGE(TRANS_SDK, "send data over limit.len=%{public}u", len);
56         return SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT;
57     }
58 
59     return SOFTBUS_OK;
60 }
61 
SendBytes(int sessionId, const void *data, unsigned int len)62 int SendBytes(int sessionId, const void *data, unsigned int len)
63 {
64     if (data == NULL || len == 0) {
65         TRANS_LOGW(TRANS_BYTES, "Invalid param");
66         return SOFTBUS_INVALID_PARAM;
67     }
68 
69     int ret = CheckPermissionState(sessionId);
70     if (ret != SOFTBUS_OK) {
71         TRANS_LOGE(TRANS_BYTES,
72             "SendBytes no permission, sessionId=%{public}d, len=%{public}u, ret=%{public}d", sessionId, len, ret);
73         return ret;
74     }
75 
76     int32_t channelId = INVALID_CHANNEL_ID;
77     int32_t channelType = CHANNEL_TYPE_BUTT;
78     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
79     ret = ClientGetChannelBySessionId(sessionId, &channelId, &channelType, &enableStatus);
80     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
81         TRANS_BYTES, "ClientGetChannelBySessionId fail, sessionId=%{public}d", sessionId);
82 
83     int32_t businessType = BUSINESS_TYPE_BUTT;
84     int32_t osType = OH_OS_TYPE;
85     ret = ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType);
86     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
87         TRANS_BYTES, "ClientGetChannelBusinessTypeBySessionId fail, sessionId=%{public}d", sessionId);
88     ret = ClientGetChannelOsTypeBySessionId(sessionId, &osType);
89     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
90         TRANS_BYTES, "ClientGetChannelOsTypeBySessionId fail, sessionId=%{public}d", sessionId);
91 
92     if ((osType == OH_OS_TYPE) && (businessType != BUSINESS_TYPE_BYTE) && (businessType != BUSINESS_TYPE_NOT_CARE) &&
93         (channelType != CHANNEL_TYPE_AUTH)) {
94         TRANS_LOGE(TRANS_BYTES,
95             "BusinessType no match, businessType=%{public}d,  sessionId=%{public}d", businessType, sessionId);
96         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
97     }
98 
99     int checkRet = CheckSendLen(channelId, channelType, len, BUSINESS_TYPE_BYTE);
100     TRANS_CHECK_AND_RETURN_RET_LOGE(checkRet == SOFTBUS_OK, checkRet,
101         TRANS_BYTES, "CheckSendLen fail, len=%{public}u,  sessionId=%{public}d", len, sessionId);
102 
103     if (enableStatus != ENABLE_STATUS_SUCCESS) {
104         TRANS_LOGE(TRANS_BYTES,
105             "Enable status fail, len=%{public}u,  sessionId=%{public}d", len, sessionId);
106         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
107     }
108     (void)ClientResetIdleTimeoutById(sessionId);
109     UpdateChannelStatistics(sessionId, len);
110     return ClientTransChannelSendBytes(channelId, channelType, data, len);
111 }
112 
SendMessage(int sessionId, const void *data, unsigned int len)113 int SendMessage(int sessionId, const void *data, unsigned int len)
114 {
115     TRANS_LOGI(TRANS_MSG, "sessionId=%{public}d, len=%{public}d", sessionId, len);
116     if (data == NULL || len == 0) {
117         TRANS_LOGW(TRANS_MSG, "Invalid param");
118         return SOFTBUS_INVALID_PARAM;
119     }
120     int ret = CheckPermissionState(sessionId);
121     if (ret != SOFTBUS_OK) {
122         TRANS_LOGE(TRANS_MSG, "SendMessage no permission, ret=%{public}d", ret);
123         return ret;
124     }
125 
126     int32_t channelId = INVALID_CHANNEL_ID;
127     int32_t channelType = CHANNEL_TYPE_BUTT;
128     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
129     if (ClientGetChannelBySessionId(sessionId, &channelId, &channelType, &enableStatus) != SOFTBUS_OK) {
130         return SOFTBUS_TRANS_INVALID_SESSION_ID;
131     }
132 
133     int32_t businessType = BUSINESS_TYPE_BUTT;
134     if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
135         return SOFTBUS_TRANS_INVALID_SESSION_ID;
136     }
137     if ((businessType != BUSINESS_TYPE_MESSAGE) && (businessType != BUSINESS_TYPE_NOT_CARE) &&
138         (channelType != CHANNEL_TYPE_AUTH)) {
139         TRANS_LOGE(TRANS_MSG, "BusinessType no match, businessType=%{public}d", businessType);
140         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
141     }
142 
143     int checkRet = CheckSendLen(channelId, channelType, len, BUSINESS_TYPE_MESSAGE);
144     if (checkRet != SOFTBUS_OK) {
145         return checkRet;
146     }
147 
148     if (enableStatus != ENABLE_STATUS_SUCCESS) {
149         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
150     }
151     (void)ClientResetIdleTimeoutById(sessionId);
152     UpdateChannelStatistics(sessionId, len);
153     return ClientTransChannelSendMessage(channelId, channelType, data, len);
154 }
155 
SendStream(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)156 int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
157 {
158     if ((data == NULL) || (ext == NULL) || (param == NULL)) {
159         TRANS_LOGW(TRANS_STREAM, "Invalid param");
160         return SOFTBUS_INVALID_PARAM;
161     }
162     int ret = CheckPermissionState(sessionId);
163     if (ret != SOFTBUS_OK) {
164         TRANS_LOGE(TRANS_STREAM, "SendStream no permission, ret=%{public}d", ret);
165         return ret;
166     }
167 
168     int32_t channelId = INVALID_CHANNEL_ID;
169     int32_t type = CHANNEL_TYPE_BUTT;
170     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
171     if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &enableStatus) != SOFTBUS_OK) {
172         return SOFTBUS_TRANS_INVALID_SESSION_ID;
173     }
174     if (type != CHANNEL_TYPE_UDP) {
175         return SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL;
176     }
177 
178     int32_t businessType = BUSINESS_TYPE_BUTT;
179     if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
180         return SOFTBUS_TRANS_INVALID_SESSION_ID;
181     }
182     if ((businessType != BUSINESS_TYPE_STREAM) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
183         TRANS_LOGE(TRANS_STREAM, "BusinessType no match, businessType=%{public}d", businessType);
184         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
185     }
186 
187     if (enableStatus != ENABLE_STATUS_SUCCESS) {
188         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
189     }
190     (void)ClientResetIdleTimeoutById(sessionId);
191     UpdateChannelStatistics(sessionId, data->bufLen);
192     return ClientTransChannelSendStream(channelId, type, data, ext, param);
193 }
194 
SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt)195 int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt)
196 {
197     if ((sFileList == NULL) || (fileCnt == 0)) {
198         TRANS_LOGW(TRANS_FILE, "Invalid param");
199         return SOFTBUS_INVALID_PARAM;
200     }
201     int ret = CheckPermissionState(sessionId);
202     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
203         TRANS_FILE,  "SendFile no permission, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
204 
205     FileSchemaListener *fileSchemaListener = (FileSchemaListener*)SoftBusCalloc(sizeof(FileSchemaListener));
206     if (fileSchemaListener == NULL) {
207         return SOFTBUS_MALLOC_ERR;
208     }
209     if (CheckFileSchema(sessionId, fileSchemaListener) == SOFTBUS_OK) {
210         ret = SetSchemaCallback(fileSchemaListener->schema, sFileList, fileCnt);
211         if (ret != SOFTBUS_OK) {
212             TRANS_LOGE(TRANS_FILE, "set schema callback failed, sessionId=%{public}d, ret=%{public}d", sessionId, ret);
213             SoftBusFree(fileSchemaListener);
214             return ret;
215         }
216     }
217 
218     int32_t channelId = INVALID_CHANNEL_ID;
219     int32_t type = CHANNEL_TYPE_BUTT;
220     SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
221     if (ClientGetChannelBySessionId(sessionId, &channelId, &type, &enableStatus) != SOFTBUS_OK) {
222         TRANS_LOGE(TRANS_FILE, "ClientGetChannelBySessionId failed, sessionId=%{public}d", sessionId);
223         SoftBusFree(fileSchemaListener);
224         return SOFTBUS_TRANS_INVALID_SESSION_ID;
225     }
226 
227     int32_t businessType = BUSINESS_TYPE_BUTT;
228     if (ClientGetChannelBusinessTypeBySessionId(sessionId, &businessType) != SOFTBUS_OK) {
229         TRANS_LOGE(TRANS_FILE, "ClientGetChannelBusinessTypeBySessionId failed, sessionId=%{public}d", sessionId);
230         SoftBusFree(fileSchemaListener);
231         return SOFTBUS_TRANS_INVALID_SESSION_ID;
232     }
233     if ((businessType != BUSINESS_TYPE_FILE) && (businessType != BUSINESS_TYPE_NOT_CARE)) {
234         TRANS_LOGE(TRANS_FILE,
235             "BusinessType no match, sessionId=%{public}d, businessType=%{public}d", sessionId, businessType);
236         SoftBusFree(fileSchemaListener);
237         return SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH;
238     }
239 
240     if (enableStatus !=  ENABLE_STATUS_SUCCESS) {
241         TRANS_LOGE(TRANS_FILE, "Enable status failed, sessionId=%{public}d", sessionId);
242         SoftBusFree(fileSchemaListener);
243         return SOFTBUS_TRANS_SESSION_NO_ENABLE;
244     }
245     SoftBusFree(fileSchemaListener);
246     (void)ClientResetIdleTimeoutById(sessionId);
247     return ClientTransChannelSendFile(channelId, type, sFileList, dFileList, fileCnt);
248 }
249