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 #ifndef BUILD_FOR_WINDOWS
17 #include <netinet/tcp.h>
18 #endif
19
20 #include "nstackx_dfile_config.h"
21 #include "nstackx_dfile_session.h"
22 #include "nstackx_dfile_log.h"
23 #include "nstackx_error.h"
24 #include "nstackx_dfile.h"
25 #include "nstackx_socket.h"
26 #include "nstackx_util.h"
27 #include "nstackx_dev.h"
28
29 #define TAG "nStackXDFile"
30
31 /* thread pos io_0, io_1, io_2, send_0, send_1, send_2, recv, mainloop */
32 BindInfo g_sender8CoreList[DFILE_BIND_TYPE_INDEX_MAX][GSO_TYPE_INDEX_MAX][DFILE_MAX_THREAD_NUM] = {
33 {{{0, 0x10}, {0, 0x08}, {0, 0x04}, {0, 0x20}, {0, 0x40}, {0, 0x80}, {0, 0x02}, {0, 0x40}}, /* nogso highspeed */
34 {{0, 0x20}, {0, 0x10}, {0, 0x08}, {0, 0x80}, {0, 0xF0}, {0, 0x00}, {0, 0x02}, {0, 0x40}}}, /* gso highspeed */
35 {{{0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x20}, {0, 0x40}, {0, 0x80}, {0, 0x00}, {0, 0x00}}, /* nogso lowspeed */
36 {{0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x80}, {0, 0xF0}, {0, 0x00}, {0, 0x00}, {0, 0x00}}}, /* gso lowspeed */
37 };
38
39 BindInfo g_recver8CoreList[DFILE_BIND_TYPE_INDEX_MAX][DFILE_MAX_THREAD_NUM] = {
40 {{0, 0x40}, {0, 0x80}, {0, 0xF0}, {0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x20}, {0, 0x10}}, /* highspeed */
41 {{0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x00}, {0, 0x20}, {0, 0x00}}, /* lowspeed */
42 };
43
44 enum {
45 NO_CHECK = 0,
46 CHECKED_NOT_SUPPORT,
47 CHECKED_SUPPORT
48 };
49
50 static uint8_t g_aesInChecked = NO_CHECK;
51
SetTidToBindInfo(const DFileSession * session,uint32_t pos)52 void SetTidToBindInfo(const DFileSession *session, uint32_t pos)
53 {
54 pid_t tid = gettid();
55 int32_t isSupport = (CapsGSO(session) || CapsTcp(session)) ? 1 : 0;
56 int i;
57 for (i = 0; i < DFILE_BIND_TYPE_INDEX_MAX; i++) {
58 if (session->sessionType == DFILE_SESSION_TYPE_CLIENT) {
59 g_sender8CoreList[i][isSupport][pos].tid = tid;
60 } else {
61 g_recver8CoreList[i][pos].tid = tid;
62 }
63 }
64 }
65
GetFileConfigP2p(DFileConfig * dFileConfig,uint16_t mtu)66 static void GetFileConfigP2p(DFileConfig *dFileConfig, uint16_t mtu)
67 {
68 dFileConfig->dataFrameSize = NSTACKX_P2P_FRAME_SIZE_TIMES * mtu;
69 if (dFileConfig->dataFrameSize == 0 || dFileConfig->dataFrameSize <
70 NSTACKX_P2P_SEND_RATE * DATA_FRAME_SEND_INTERVAL_MS / MSEC_TICKS_PER_SEC /
71 (UINT16_MAX - NSTACKX_P2P_COMPENSATION_RATE)) {
72 return;
73 }
74 dFileConfig->sendRate =
75 (uint16_t)(NSTACKX_P2P_SEND_RATE / MSEC_TICKS_PER_SEC * DATA_FRAME_SEND_INTERVAL_MS /
76 dFileConfig->dataFrameSize + NSTACKX_P2P_COMPENSATION_RATE);
77 }
78
GetFileConfigWlan(DFileConfig * dFileConfig,uint16_t mtu)79 static void GetFileConfigWlan(DFileConfig *dFileConfig, uint16_t mtu)
80 {
81 dFileConfig->dataFrameSize = NSTACKX_WLAN_FRAME_SIZE_TIMES * mtu;
82 if (dFileConfig->dataFrameSize == 0 || dFileConfig->dataFrameSize <
83 NSTACKX_WLAN_SEND_RATE * DATA_FRAME_SEND_INTERVAL_MS / MSEC_TICKS_PER_SEC /
84 (UINT16_MAX - NSTACKX_WLAN_COMPENSATION_RATE)) {
85 return;
86 }
87 dFileConfig->sendRate =
88 (uint16_t)(NSTACKX_WLAN_SEND_RATE / MSEC_TICKS_PER_SEC * DATA_FRAME_SEND_INTERVAL_MS / dFileConfig->dataFrameSize +
89 NSTACKX_WLAN_COMPENSATION_RATE);
90 }
91
CheckConnType(uint16_t connType)92 static int32_t CheckConnType(uint16_t connType)
93 {
94 if ((connType != CONNECT_TYPE_P2P) && (connType != CONNECT_TYPE_WLAN)) {
95 return NSTACKX_EINVAL;
96 }
97 return NSTACKX_EOK;
98 }
99
GetDFileConfig(DFileConfig * dFileConfig,uint16_t mtu,uint16_t connType)100 int32_t GetDFileConfig(DFileConfig *dFileConfig, uint16_t mtu, uint16_t connType)
101 {
102 if ((dFileConfig == NULL) || CheckConnType(connType) != NSTACKX_EOK || (mtu == 0)) {
103 return NSTACKX_EINVAL;
104 }
105 if (connType == CONNECT_TYPE_P2P) {
106 GetFileConfigP2p(dFileConfig, mtu);
107 } else {
108 GetFileConfigWlan(dFileConfig, mtu);
109 }
110 return NSTACKX_EOK;
111 }
112
ConfigDFileTransP2p(DFileTransConfig * transConfig)113 static void ConfigDFileTransP2p(DFileTransConfig *transConfig)
114 {
115 transConfig->maxRtt = NSTACKX_P2P_UDP_RTT;
116 transConfig->maxAckCnt = NSTACKX_MAX_ACK_COUNT;
117 transConfig->maxCtrlFrameRetryCnt = NSTACKX_P2P_MAX_CONTROL_FRAME_RETRY_COUNT;
118 transConfig->maxCtrlFrameTimeout = NSTACKX_P2P_MAX_CONTROL_FRAME_TIMEOUT;
119 transConfig->maxFileHeaderConfirmFrameTimeout = NSTACKX_P2P_MAX_FILE_HEADER_CONFIRM_FRAME_TIMEOUT;
120 transConfig->maxFileWriteTimeout = NSTACKX_P2P_WRITE_ALL_FILE_DATA_TIMEOUT;
121 transConfig->initialRecvIdleTimeout = NSTACKX_P2P_RECEIVER_IDLE_INIT_TIMEOUT;
122 transConfig->maxRecvIdleCnt = NSTACKX_P2P_RECEIVER_IDLE_MAX_COUNT;
123 transConfig->initialAckInterval = NSTACKX_ACK_INTERVAL;
124 transConfig->recvLimitAckInterval = NSTACKX_P2P_RECEIVED_LIMIT_ACK_INTERVAL;
125 transConfig->lastFrameAckInterval = NSTACKX_P2P_RECEIVED_LAST_FRAME_ACK_INTERVAL;
126 transConfig->maxRetryPageCnt = NSTACKX_P2P_MAX_RETRY_PAGE_COUNT;
127 transConfig->maxRetryListNodeCnt = NSTACKX_P2P_MAX_RETRY_LIST_NODE_NUM;
128 }
129
ConfigDFileTransWlan(DFileTransConfig * transConfig)130 static void ConfigDFileTransWlan(DFileTransConfig *transConfig)
131 {
132 transConfig->maxRtt = NSTACKX_WLAN_UDP_RTT;
133 transConfig->maxAckCnt = NSTACKX_MAX_ACK_COUNT;
134 transConfig->maxCtrlFrameRetryCnt = NSTACKX_WLAN_MAX_CONTROL_FRAME_RETRY_COUNT;
135 transConfig->maxCtrlFrameTimeout = NSTACKX_WLAN_MAX_CONTROL_FRAME_TIMEOUT;
136 transConfig->maxFileHeaderConfirmFrameTimeout = NSTACKX_WLAN_MAX_FILE_HEADER_CONFIRM_FRAME_TIMEOUT;
137 transConfig->maxFileWriteTimeout = NSTACKX_WLAN_WRITE_ALL_FILE_DATA_TIMEOUT;
138 transConfig->initialRecvIdleTimeout = NSTACKX_WLAN_RECEIVER_IDLE_INIT_TIMEOUT;
139 transConfig->maxRecvIdleCnt = NSTACKX_WLAN_RECEIVER_IDLE_MAX_COUNT;
140 transConfig->initialAckInterval = NSTACKX_ACK_INTERVAL;
141 transConfig->recvLimitAckInterval = NSTACKX_WLAN_RECEIVED_LIMIT_ACK_INTERVAL;
142 transConfig->lastFrameAckInterval = NSTACKX_WLAN_RECEIVED_LAST_FRAME_ACK_INTERVAL;
143 transConfig->maxRetryPageCnt = NSTACKX_WLAN_MAX_RETRY_PAGE_COUNT;
144 transConfig->maxRetryListNodeCnt = NSTACKX_WLAN_MAX_RETRY_LIST_NODE_NUM;
145 }
146
ConfigDFileTrans(uint16_t connType,DFileTransConfig * transConfig)147 int32_t ConfigDFileTrans(uint16_t connType, DFileTransConfig *transConfig)
148 {
149 if (transConfig == NULL) {
150 DFILE_LOGE(TAG, "Invalid parameter");
151 return NSTACKX_EINVAL;
152 }
153
154 if (CheckConnType(connType) != NSTACKX_EOK) {
155 DFILE_LOGE(TAG, "Invalid connection type %u", connType);
156 return NSTACKX_EINVAL;
157 }
158
159 if (connType == CONNECT_TYPE_P2P) {
160 ConfigDFileTransP2p(transConfig);
161 } else {
162 ConfigDFileTransWlan(transConfig);
163 }
164
165 return NSTACKX_EOK;
166 }
167
SetTcpKeepAlive(SocketDesc fd)168 void SetTcpKeepAlive(SocketDesc fd)
169 {
170 #ifndef BUILD_FOR_WINDOWS
171 int32_t optval;
172
173 optval = 1;
174 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)(&optval), sizeof(optval)) != 0) {
175 DFILE_LOGI(TAG, "set KEEPALIVE failed");
176 } else {
177 DFILE_LOGI(TAG, "set KEEPALIVE = %d success", optval);
178 }
179
180 optval = KEEP_ALIVE_IDLE;
181 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, (void *)(&optval), sizeof(optval)) != 0) {
182 DFILE_LOGI(TAG, "set TCP_KEEPIDLE failed");
183 } else {
184 DFILE_LOGI(TAG, "set TCP_KEEPIDLE = %d success", optval);
185 }
186
187 optval = KEEP_ALIVE_CNT;
188 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, (void *)(&optval), sizeof(optval)) != 0) {
189 DFILE_LOGI(TAG, "set TCP_KEEPCNT failed");
190 } else {
191 DFILE_LOGI(TAG, "set TCP_KEEPCNT = %d success", optval);
192 }
193
194 optval = KEEP_ALIVE_INTERVAL;
195 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, (void *)(&optval), sizeof(optval)) != 0) {
196 DFILE_LOGI(TAG, "set TCP_KEEPINTVL failed");
197 } else {
198 DFILE_LOGI(TAG, "set TCP_KEEPINTVL = %d success", optval);
199 }
200
201 optval = TCP_USER_TIMEOUT_VALUE;
202 if (setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, (void *)(&optval), sizeof(optval)) != 0) {
203 DFILE_LOGI(TAG, "set TCP_USER_TIMEOUT option error");
204 } else {
205 DFILE_LOGI(TAG, "set TCP_USER_TIMEOUT option success time:%d", optval);
206 }
207 #endif
208 }
209
CheckIsSupportHardwareAesNi(void)210 static bool CheckIsSupportHardwareAesNi(void)
211 {
212 if (g_aesInChecked == NO_CHECK) {
213 g_aesInChecked = IsSupportHardwareAesNi() ? CHECKED_SUPPORT : CHECKED_NOT_SUPPORT;
214 DFILE_LOGI(TAG, "g_aesInChecked is set as %hhu", g_aesInChecked);
215 }
216 return g_aesInChecked == CHECKED_SUPPORT;
217 }
218
DFileGetCipherCaps(DFileSession * session,SettingFrame * settingFramePara)219 void DFileGetCipherCaps(DFileSession *session, SettingFrame *settingFramePara)
220 {
221 if (CapsChaCha(session) && QueryCipherSupportByName(CHACHA20_POLY1305_NAME)) {
222 session->cipherCapability |= NSTACKX_CIPHER_CHACHA;
223 DFILE_LOGI(TAG, "local cipher support %s.", CHACHA20_POLY1305_NAME);
224 } else {
225 session->cipherCapability &= ~NSTACKX_CIPHER_CHACHA;
226 DFILE_LOGI(TAG, "local cipher no support %s, CapsChaCha is %hhu.", CHACHA20_POLY1305_NAME, CapsChaCha(session));
227 }
228
229 bool ret = CheckIsSupportHardwareAesNi();
230 if (ret) {
231 session->cipherCapability |= NSTACKX_CIPHER_AES_NI;
232 }
233 settingFramePara->cipherCapability = session->cipherCapability;
234 DFILE_LOGI(TAG, "local cipher AES_NI state is %s", ret ? "true" : "false");
235 }
236
DFileChooseCipherType(SettingFrame * hostSettingFrame,DFileSession * session)237 void DFileChooseCipherType(SettingFrame *hostSettingFrame, DFileSession *session)
238 {
239 if (session->fileManager->keyLen != CHACHA20_KEY_LENGTH) {
240 session->cipherCapability &= ~NSTACKX_CIPHER_CHACHA;
241 DFILE_LOGI(TAG, "opposite replies no use chacha cipher");
242 return;
243 }
244
245 uint8_t isRemoteSupportChacha = ((hostSettingFrame->cipherCapability & NSTACKX_CIPHER_CHACHA) != 0);
246 uint8_t isRemoteSupportAesNi = ((hostSettingFrame->cipherCapability & NSTACKX_CIPHER_AES_NI) != 0);
247 uint8_t isUseMtp = NSTACKX_FALSE;
248 #ifdef DFILE_ADAPT_MTP
249 isUseMtp = session->useMtpFlag;
250 #endif
251 uint8_t isLocalUseChacha = QueryCipherSupportByName(CHACHA20_POLY1305_NAME) && !isUseMtp;
252 bool isLocalSupportAesNi = CheckIsSupportHardwareAesNi();
253 if (isRemoteSupportChacha && isLocalUseChacha && !(isRemoteSupportAesNi && isLocalSupportAesNi)) {
254 session->cipherCapability |= NSTACKX_CIPHER_CHACHA;
255 } else {
256 session->cipherCapability &= ~NSTACKX_CIPHER_CHACHA;
257 }
258
259 DFILE_LOGI(TAG, "opposite replies %s use chacha cipher", CapsChaCha(session) ? "" : "no");
260 }