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 "softbus_proxychannel_session.h"
17
18 #include <securec.h>
19
20 #include "softbus_adapter_crypto.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_adapter_socket.h"
23 #include "softbus_adapter_thread.h"
24 #include "softbus_conn_interface.h"
25 #include "softbus_def.h"
26 #include "softbus_errcode.h"
27 #include "softbus_log.h"
28 #include "softbus_property.h"
29 #include "softbus_proxychannel_callback.h"
30 #include "softbus_proxychannel_manager.h"
31 #include "softbus_proxychannel_message.h"
32 #include "softbus_proxychannel_transceiver.h"
33 #include "softbus_socket.h"
34 #include "softbus_transmission_interface.h"
35 #include "softbus_utils.h"
36 #include "trans_pending_pkt.h"
37 #include "softbus_datahead_transform.h"
38
39 #define TIME_OUT 10
40 #define USECTONSEC 1000
41 #define MSG_HEAD_LENGTH (28 + 16 + 16)
42
43 int32_t TransProxyTransDataSendMsg(ProxyChannelInfo *chanInfo, const unsigned char *payLoad,
44 int payLoadLen, ProxyPacketType flag);
45
46
NotifyClientMsgReceived(const char * pkgName,int32_t pid,int32_t channelId,TransReceiveData * receiveData)47 NO_SANITIZE("cfi") int32_t NotifyClientMsgReceived(const char *pkgName, int32_t pid, int32_t channelId,
48 TransReceiveData *receiveData)
49 {
50 int32_t ret = TransProxyOnMsgReceived(pkgName, pid, channelId, receiveData);
51 if (ret != SOFTBUS_OK) {
52 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "notify err[%d]", ret);
53 }
54 return ret;
55 }
56
SessionTypeToPacketType(SessionPktType sessionType)57 NO_SANITIZE("cfi") ProxyPacketType SessionTypeToPacketType(SessionPktType sessionType)
58 {
59 switch (sessionType) {
60 case TRANS_SESSION_BYTES:
61 return PROXY_FLAG_BYTES;
62 case TRANS_SESSION_MESSAGE:
63 return PROXY_FLAG_MESSAGE;
64 case TRANS_SESSION_FILE_FIRST_FRAME:
65 return PROXY_FILE_FIRST_FRAME;
66 case TRANS_SESSION_FILE_ONGOINE_FRAME:
67 return PROXY_FILE_ONGOINE_FRAME;
68 case TRANS_SESSION_FILE_LAST_FRAME:
69 return PROXY_FILE_LAST_FRAME;
70 case TRANS_SESSION_FILE_ONLYONE_FRAME:
71 return PROXY_FILE_ONLYONE_FRAME;
72 case TRANS_SESSION_FILE_ALLFILE_SENT:
73 return PROXY_FILE_ALLFILE_SENT;
74 case TRANS_SESSION_FILE_CRC_CHECK_FRAME:
75 return PROXY_FILE_CRC_CHECK_FRAME;
76 case TRANS_SESSION_FILE_RESULT_FRAME:
77 return PROXY_FILE_RESULT_FRAME;
78 case TRANS_SESSION_FILE_ACK_REQUEST_SENT:
79 return PROXY_FILE_ACK_REQUEST_SENT;
80 case TRANS_SESSION_FILE_ACK_RESPONSE_SENT:
81 return PROXY_FILE_ACK_RESPONSE_SENT;
82 default:
83 return PROXY_FLAG_BYTES;
84 }
85 }
86
ProxyTypeToConnPri(ProxyPacketType proxyType)87 NO_SANITIZE("cfi") SendPriority ProxyTypeToConnPri(ProxyPacketType proxyType)
88 {
89 switch (proxyType) {
90 case PROXY_FLAG_BYTES:
91 return CONN_MIDDLE;
92 case PROXY_FLAG_MESSAGE:
93 case PROXY_FLAG_ASYNC_MESSAGE:
94 case PROXY_FLAG_ACK:
95 return CONN_HIGH;
96 default:
97 return CONN_DEFAULT;
98 }
99 }
100
TransProxyPostPacketData(int32_t channelId,const unsigned char * data,uint32_t len,ProxyPacketType flags)101 NO_SANITIZE("cfi") int32_t TransProxyPostPacketData(int32_t channelId, const unsigned char *data,
102 uint32_t len, ProxyPacketType flags)
103 {
104 int32_t seq = 0;
105 ConnectType type = 0;
106
107 if ((data == NULL) || (len == 0)) {
108 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "invalid para");
109 return SOFTBUS_INVALID_PARAM;
110 }
111 ProxyChannelInfo *chanInfo = (ProxyChannelInfo *)SoftBusCalloc(sizeof(ProxyChannelInfo));
112 if (chanInfo == NULL) {
113 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "malloc in TransProxyPostPacketData.id[%d]", channelId);
114 return SOFTBUS_MALLOC_ERR;
115 }
116 if (TransProxyGetSendMsgChanInfo(channelId, chanInfo) != SOFTBUS_OK) {
117 SoftBusFree(chanInfo);
118 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "can not find proxy channel channel id = %d", channelId);
119 return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND;
120 }
121 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "InLen[%d] seq[%d] flags[%d]", len, seq, flags);
122 int32_t ret = TransProxyTransDataSendMsg(chanInfo, data, len, flags);
123 if (ret != SOFTBUS_OK) {
124 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "TransProxyTransDataSendMsg fail ret = %d", ret);
125 }
126
127 if (ConnGetTypeByConnectionId(chanInfo->connId, &type) != SOFTBUS_OK) {
128 TLOGE("obtain link type failed!");
129 }
130
131 SoftBusFree(chanInfo);
132 return ret;
133 }
134
TransProxyPostSessionData(int32_t channelId,const unsigned char * data,uint32_t len,SessionPktType flags)135 NO_SANITIZE("cfi") int32_t TransProxyPostSessionData(int32_t channelId, const unsigned char *data, uint32_t len,
136 SessionPktType flags)
137 {
138 ProxyPacketType type = SessionTypeToPacketType(flags);
139 return TransProxyPostPacketData(channelId, data, len, type);
140 }
141
TransProxyPackAppNormalMsg(const ProxyMessageHead * msg,const char * payLoad,int32_t datalen,int32_t * outlen)142 static char *TransProxyPackAppNormalMsg(const ProxyMessageHead *msg, const char *payLoad,
143 int32_t datalen, int32_t *outlen)
144 {
145 char *buf = NULL;
146 uint32_t dstLen;
147 ProxyMessageHead proxyMessageHead;
148 uint32_t connHeadLen = ConnGetHeadSize();
149 uint32_t bufLen = PROXY_CHANNEL_HEAD_LEN + connHeadLen + (uint32_t)datalen;
150
151 buf = (char*)SoftBusCalloc(bufLen);
152 if (buf == NULL) {
153 return NULL;
154 }
155 if (memcpy_s(&proxyMessageHead, sizeof(ProxyMessageHead), msg, sizeof(ProxyMessageHead)) != EOK) {
156 SoftBusFree(buf);
157 return NULL;
158 }
159 PackProxyMessageHead(&proxyMessageHead);
160 if (memcpy_s(buf + connHeadLen, bufLen - connHeadLen, &proxyMessageHead, sizeof(ProxyMessageHead)) != EOK) {
161 SoftBusFree(buf);
162 return NULL;
163 }
164 dstLen = bufLen - connHeadLen - sizeof(ProxyMessageHead);
165 if (memcpy_s(buf + connHeadLen + sizeof(ProxyMessageHead), dstLen, payLoad, datalen) != EOK) {
166 SoftBusFree(buf);
167 return NULL;
168 }
169 *outlen = (int32_t)bufLen;
170
171 return buf;
172 }
173
TransProxyTransNormalMsg(const ProxyChannelInfo * info,const char * payLoad,int payLoadLen,ProxyPacketType flag)174 static int32_t TransProxyTransNormalMsg(const ProxyChannelInfo *info, const char *payLoad, int payLoadLen,
175 ProxyPacketType flag)
176 {
177 ProxyMessageHead msgHead = {0};
178 msgHead.type = (PROXYCHANNEL_MSG_TYPE_NORMAL & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
179 msgHead.myId = info->myId;
180 msgHead.peerId = info->peerId;
181 int bufLen = 0;
182 char *buf = TransProxyPackAppNormalMsg(&msgHead, payLoad, payLoadLen, &bufLen);
183 if (buf == NULL) {
184 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy pack msg error");
185 return SOFTBUS_TRANS_PROXY_PACKMSG_ERR;
186 }
187 int32_t ret = TransProxyTransSendMsg(info->connId, (uint8_t *)buf, (uint32_t)bufLen,
188 ProxyTypeToConnPri(flag), info->appInfo.myData.pid);
189 if (ret == SOFTBUS_CONNECTION_ERR_SENDQUEUE_FULL) {
190 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy send queue full!!");
191 return SOFTBUS_CONNECTION_ERR_SENDQUEUE_FULL;
192 }
193 if (ret != SOFTBUS_OK) {
194 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "proxy send msg error");
195 return SOFTBUS_TRANS_PROXY_SENDMSG_ERR;
196 }
197 return SOFTBUS_OK;
198 }
199
TransProxyTransDataSendMsg(ProxyChannelInfo * info,const unsigned char * payLoad,int payLoadLen,ProxyPacketType flag)200 NO_SANITIZE("cfi") int32_t TransProxyTransDataSendMsg(ProxyChannelInfo *info, const unsigned char *payLoad,
201 int payLoadLen, ProxyPacketType flag)
202 {
203 if ((info->status != PROXY_CHANNEL_STATUS_COMPLETED && info->status != PROXY_CHANNEL_STATUS_KEEPLIVEING)) {
204 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "status is err %d", info->status);
205 return SOFTBUS_TRANS_PROXY_CHANNLE_STATUS_INVALID;
206 }
207 if (info->appInfo.appType == APP_TYPE_INNER) {
208 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "err app type Inner");
209 return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
210 }
211
212 return TransProxyTransNormalMsg(info, (const char*)payLoad, payLoadLen, flag);
213 }
214
TransOnNormalMsgReceived(const char * pkgName,int32_t pid,int32_t channelId,const char * data,uint32_t len)215 NO_SANITIZE("cfi") int32_t TransOnNormalMsgReceived(const char *pkgName, int32_t pid, int32_t channelId,
216 const char *data, uint32_t len)
217 {
218 if (data == NULL) {
219 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "data null.");
220 return SOFTBUS_ERR;
221 }
222 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "AuthReceived inputLen[%d]", len);
223
224 TransReceiveData receiveData;
225 receiveData.data = (void*)data;
226 receiveData.dataLen = len;
227
228 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "notify receive msg received");
229 if (NotifyClientMsgReceived(pkgName, pid, channelId, &receiveData) != SOFTBUS_OK) {
230 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "notify receive msg received err");
231 return SOFTBUS_ERR;
232 }
233 return SOFTBUS_OK;
234 }
235