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_control.h"
17
18 #include <securec.h>
19 #include <string.h>
20
21 #include "auth_interface.h"
22 #include "cJSON.h"
23 #include "softbus_errcode.h"
24 #include "softbus_log.h"
25 #include "softbus_proxychannel_manager.h"
26 #include "softbus_proxychannel_message.h"
27 #include "softbus_proxychannel_transceiver.h"
28 #include "softbus_utils.h"
29
TransProxySendMessage(ProxyChannelInfo * info,const char * payLoad,uint32_t payLoadLen,int32_t priority)30 int32_t TransProxySendMessage(ProxyChannelInfo *info, const char *payLoad, uint32_t payLoadLen, int32_t priority)
31 {
32 if (info == NULL) {
33 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
34 return SOFTBUS_INVALID_PARAM;
35 }
36
37 ProxyDataInfo dataInfo = {0};
38 ProxyMessageHead msgHead = {0};
39 msgHead.type = (PROXYCHANNEL_MSG_TYPE_NORMAL & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
40 if (info->appInfo.appType != APP_TYPE_AUTH) {
41 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
42 }
43 msgHead.myId = info->myId;
44 msgHead.peerId = info->peerId;
45
46 dataInfo.inData = (uint8_t *)payLoad;
47 dataInfo.inLen = payLoadLen;
48 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
49 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack msg error");
50 return SOFTBUS_TRANS_PROXY_PACKMSG_ERR;
51 }
52 return TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
53 priority, info->appInfo.myData.pid);
54 }
55
SetCipherOfHandshakeMsg(uint32_t channelId,uint8_t * cipher)56 static int32_t SetCipherOfHandshakeMsg(uint32_t channelId, uint8_t *cipher)
57 {
58 int64_t authId = TransProxyGetAuthId(channelId);
59 if (authId == AUTH_INVALID_ID) {
60 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get authId fail");
61 return SOFTBUS_ERR;
62 }
63 AuthConnInfo connInfo;
64 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
65 if (AuthGetConnInfo(authId, &connInfo) != SOFTBUS_OK) {
66 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get auth connInfo fail");
67 return SOFTBUS_ERR;
68 }
69 bool isAuthServer = false;
70 if (AuthGetServerSide(authId, &isAuthServer) != SOFTBUS_OK) {
71 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get auth server side fail");
72 return SOFTBUS_ERR;
73 }
74
75 *cipher |= ENCRYPTED;
76 if (isAuthServer) {
77 *cipher |= AUTH_SERVER_SIDE;
78 }
79 if (connInfo.type == AUTH_LINK_TYPE_BLE) {
80 *cipher |= USE_BLE_CIPHER;
81 }
82 return SOFTBUS_OK;
83 }
84
TransProxyHandshake(ProxyChannelInfo * info)85 int32_t TransProxyHandshake(ProxyChannelInfo *info)
86 {
87 if (info == NULL) {
88 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
89 return SOFTBUS_INVALID_PARAM;
90 }
91 char *payLoad = NULL;
92 ProxyDataInfo dataInfo = {0};
93 ProxyMessageHead msgHead = {0};
94 msgHead.type = (PROXYCHANNEL_MSG_TYPE_HANDSHAKE & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
95 if (info->appInfo.appType != APP_TYPE_AUTH) {
96 if (SetCipherOfHandshakeMsg(info->channelId, &msgHead.cipher) != SOFTBUS_OK) {
97 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "set cipher fail");
98 return SOFTBUS_ERR;
99 }
100 }
101 msgHead.myId = info->myId;
102 msgHead.peerId = INVALID_CHANNEL_ID;
103 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
104 "handshake myId=%d cipher=0x%02x", msgHead.myId, msgHead.cipher);
105 payLoad = TransProxyPackHandshakeMsg(info);
106 if (payLoad == NULL) {
107 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake fail");
108 return SOFTBUS_ERR;
109 }
110 dataInfo.inData = (uint8_t *)payLoad;
111 dataInfo.inLen = strlen(payLoad) + 1;
112 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
113 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake head fail");
114 cJSON_free(payLoad);
115 return SOFTBUS_ERR;
116 }
117 cJSON_free(payLoad);
118 dataInfo.inData = NULL;
119
120 if (TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
121 CONN_HIGH, info->appInfo.myData.pid) != SOFTBUS_OK) {
122 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send handshake buf fail");
123 return SOFTBUS_ERR;
124 }
125 return SOFTBUS_OK;
126 }
127
TransProxyAckHandshake(uint32_t connId,ProxyChannelInfo * chan,int32_t retCode)128 int32_t TransProxyAckHandshake(uint32_t connId, ProxyChannelInfo *chan, int32_t retCode)
129 {
130 if (chan == NULL) {
131 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
132 return SOFTBUS_INVALID_PARAM;
133 }
134 char *payLoad = NULL;
135 ProxyDataInfo dataInfo = {0};
136 ProxyMessageHead msgHead = {0};
137 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send handshake ack msg myid %d peerid %d",
138 chan->myId, chan->peerId);
139 msgHead.type = (PROXYCHANNEL_MSG_TYPE_HANDSHAKE_ACK & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
140 if (chan->appInfo.appType != APP_TYPE_AUTH) {
141 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
142 }
143 msgHead.myId = chan->myId;
144 msgHead.peerId = chan->peerId;
145
146 if (retCode != SOFTBUS_OK) {
147 payLoad = TransProxyPackHandshakeErrMsg(retCode);
148 } else {
149 payLoad = TransProxyPackHandshakeAckMsg(chan);
150 }
151 if (payLoad == NULL) {
152 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake ack fail");
153 return SOFTBUS_ERR;
154 }
155 dataInfo.inData = (uint8_t *)payLoad;
156 dataInfo.inLen = strlen(payLoad) + 1;
157 if (TransProxyPackMessage(&msgHead, chan->authId, &dataInfo) != SOFTBUS_OK) {
158 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake ack head fail");
159 cJSON_free(payLoad);
160 return SOFTBUS_ERR;
161 }
162 cJSON_free(payLoad);
163 if (TransProxyTransSendMsg(connId, dataInfo.outData, dataInfo.outLen,
164 CONN_HIGH, chan->appInfo.myData.pid) != SOFTBUS_OK) {
165 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send handshakeack buf fail");
166 return SOFTBUS_ERR;
167 }
168 return SOFTBUS_OK;
169 }
170
TransProxyKeepalive(uint32_t connId,const ProxyChannelInfo * info)171 void TransProxyKeepalive(uint32_t connId, const ProxyChannelInfo *info)
172 {
173 if (info == NULL) {
174 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
175 return;
176 }
177
178 char *payLoad = NULL;
179 ProxyDataInfo dataInfo = {0};
180 ProxyMessageHead msgHead = {0};
181 msgHead.type = (PROXYCHANNEL_MSG_TYPE_KEEPALIVE & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
182 msgHead.myId = info->myId;
183 msgHead.peerId = info->peerId;
184 if (info->appInfo.appType != APP_TYPE_AUTH) {
185 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
186 }
187
188 payLoad = TransProxyPackIdentity(info->identity);
189 if (payLoad == NULL) {
190 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive fail");
191 return;
192 }
193 dataInfo.inData = (uint8_t *)payLoad;
194 dataInfo.inLen = strlen(payLoad) + 1;
195 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
196 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive head fail");
197 cJSON_free(payLoad);
198 return;
199 }
200 cJSON_free(payLoad);
201 if (TransProxyTransSendMsg(connId, dataInfo.outData, dataInfo.outLen,
202 CONN_HIGH, info->appInfo.myData.pid) != SOFTBUS_OK) {
203 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send keepalive buf fail");
204 return;
205 }
206 }
207
TransProxyAckKeepalive(ProxyChannelInfo * info)208 int32_t TransProxyAckKeepalive(ProxyChannelInfo *info)
209 {
210 if (info == NULL) {
211 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
212 return SOFTBUS_INVALID_PARAM;
213 }
214 char *payLoad = NULL;
215 ProxyDataInfo dataInfo = {0};
216 ProxyMessageHead msgHead = {0};
217 msgHead.type = (PROXYCHANNEL_MSG_TYPE_KEEPALIVE_ACK & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
218 msgHead.myId = info->myId;
219 msgHead.peerId = info->peerId;
220 if (info->appInfo.appType != APP_TYPE_AUTH) {
221 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
222 }
223
224 payLoad = TransProxyPackIdentity(info->identity);
225 if (payLoad == NULL) {
226 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive ack fail");
227 return SOFTBUS_ERR;
228 }
229 dataInfo.inData = (uint8_t *)payLoad;
230 dataInfo.inLen = strlen(payLoad) + 1;
231 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
232 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive ack head fail");
233 cJSON_free(payLoad);
234 return SOFTBUS_ERR;
235 }
236 cJSON_free(payLoad);
237 if (TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
238 CONN_HIGH, info->appInfo.myData.pid) != SOFTBUS_OK) {
239 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send keepalive ack buf fail");
240 return SOFTBUS_ERR;
241 }
242 return SOFTBUS_OK;
243 }
244
TransProxyResetPeer(ProxyChannelInfo * info)245 int32_t TransProxyResetPeer(ProxyChannelInfo *info)
246 {
247 if (info == NULL) {
248 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
249 return SOFTBUS_INVALID_PARAM;
250 }
251
252 char *payLoad = NULL;
253 ProxyDataInfo dataInfo = {0};
254 ProxyMessageHead msgHead = {0};
255 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send reset msg myId %d peerid %d", info->myId, info->peerId);
256 msgHead.type = (PROXYCHANNEL_MSG_TYPE_RESET & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
257 msgHead.myId = info->myId;
258 msgHead.peerId = info->peerId;
259 if (info->appInfo.appType != APP_TYPE_AUTH) {
260 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
261 }
262
263 payLoad = TransProxyPackIdentity(info->identity);
264 if (payLoad == NULL) {
265 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack reset fail");
266 return SOFTBUS_ERR;
267 }
268 dataInfo.inData = (uint8_t *)payLoad;
269 dataInfo.inLen = strlen(payLoad) + 1;
270 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
271 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack reset head fail");
272 cJSON_free(payLoad);
273 return SOFTBUS_ERR;
274 }
275 cJSON_free(payLoad);
276 if (TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
277 CONN_LOW, info->appInfo.myData.pid) != SOFTBUS_OK) {
278 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send reset buf fail");
279 return SOFTBUS_ERR;
280 }
281 return SOFTBUS_OK;
282 }
283