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
SetTidToBindInfo(const DFileSession * session,uint32_t pos)44 void SetTidToBindInfo(const DFileSession *session, uint32_t pos)
45 {
46 pid_t tid = gettid();
47 int32_t isSupport = (CapsGSO(session) || CapsTcp(session)) ? 1 : 0;
48 int i;
49 for (i = 0; i < DFILE_BIND_TYPE_INDEX_MAX; i++) {
50 if (session->sessionType == DFILE_SESSION_TYPE_CLIENT) {
51 g_sender8CoreList[i][isSupport][pos].tid = tid;
52 } else {
53 g_recver8CoreList[i][pos].tid = tid;
54 }
55 }
56 }
57
GetFileConfigP2p(DFileConfig * dFileConfig,uint16_t mtu)58 static void GetFileConfigP2p(DFileConfig *dFileConfig, uint16_t mtu)
59 {
60 dFileConfig->dataFrameSize = NSTACKX_P2P_FRAME_SIZE_TIMES * mtu;
61 if (dFileConfig->dataFrameSize == 0 || dFileConfig->dataFrameSize <
62 NSTACKX_P2P_SEND_RATE * DATA_FRAME_SEND_INTERVAL_MS / MSEC_TICKS_PER_SEC /
63 (UINT16_MAX - NSTACKX_P2P_COMPENSATION_RATE)) {
64 return;
65 }
66 dFileConfig->sendRate =
67 (uint16_t)(NSTACKX_P2P_SEND_RATE / MSEC_TICKS_PER_SEC * DATA_FRAME_SEND_INTERVAL_MS /
68 dFileConfig->dataFrameSize + NSTACKX_P2P_COMPENSATION_RATE);
69 }
70
GetFileConfigWlan(DFileConfig * dFileConfig,uint16_t mtu)71 static void GetFileConfigWlan(DFileConfig *dFileConfig, uint16_t mtu)
72 {
73 dFileConfig->dataFrameSize = NSTACKX_WLAN_FRAME_SIZE_TIMES * mtu;
74 if (dFileConfig->dataFrameSize == 0 || dFileConfig->dataFrameSize <
75 NSTACKX_WLAN_SEND_RATE * DATA_FRAME_SEND_INTERVAL_MS / MSEC_TICKS_PER_SEC /
76 (UINT16_MAX - NSTACKX_WLAN_COMPENSATION_RATE)) {
77 return;
78 }
79 dFileConfig->sendRate =
80 (uint16_t)(NSTACKX_WLAN_SEND_RATE / MSEC_TICKS_PER_SEC * DATA_FRAME_SEND_INTERVAL_MS / dFileConfig->dataFrameSize +
81 NSTACKX_WLAN_COMPENSATION_RATE);
82 }
83
CheckConnType(uint16_t connType)84 static int32_t CheckConnType(uint16_t connType)
85 {
86 if ((connType != CONNECT_TYPE_P2P) && (connType != CONNECT_TYPE_WLAN)) {
87 return NSTACKX_EINVAL;
88 }
89 return NSTACKX_EOK;
90 }
91
GetDFileConfig(DFileConfig * dFileConfig,uint16_t mtu,uint16_t connType)92 int32_t GetDFileConfig(DFileConfig *dFileConfig, uint16_t mtu, uint16_t connType)
93 {
94 if ((dFileConfig == NULL) || CheckConnType(connType) != NSTACKX_EOK || (mtu == 0)) {
95 return NSTACKX_EINVAL;
96 }
97 if (connType == CONNECT_TYPE_P2P) {
98 GetFileConfigP2p(dFileConfig, mtu);
99 } else {
100 GetFileConfigWlan(dFileConfig, mtu);
101 }
102 return NSTACKX_EOK;
103 }
104
ConfigDFileTransP2p(DFileTransConfig * transConfig)105 static void ConfigDFileTransP2p(DFileTransConfig *transConfig)
106 {
107 transConfig->maxRtt = NSTACKX_P2P_UDP_RTT;
108 transConfig->maxAckCnt = NSTACKX_MAX_ACK_COUNT;
109 transConfig->maxCtrlFrameRetryCnt = NSTACKX_P2P_MAX_CONTROL_FRAME_RETRY_COUNT;
110 transConfig->maxCtrlFrameTimeout = NSTACKX_P2P_MAX_CONTROL_FRAME_TIMEOUT;
111 transConfig->maxFileHeaderConfirmFrameTimeout = NSTACKX_P2P_MAX_FILE_HEADER_CONFIRM_FRAME_TIMEOUT;
112 transConfig->maxFileWriteTimeout = NSTACKX_P2P_WRITE_ALL_FILE_DATA_TIMEOUT;
113 transConfig->initialRecvIdleTimeout = NSTACKX_P2P_RECEIVER_IDLE_INIT_TIMEOUT;
114 transConfig->maxRecvIdleCnt = NSTACKX_P2P_RECEIVER_IDLE_MAX_COUNT;
115 transConfig->initialAckInterval = NSTACKX_ACK_INTERVAL;
116 transConfig->recvLimitAckInterval = NSTACKX_P2P_RECEIVED_LIMIT_ACK_INTERVAL;
117 transConfig->lastFrameAckInterval = NSTACKX_P2P_RECEIVED_LAST_FRAME_ACK_INTERVAL;
118 transConfig->maxRetryPageCnt = NSTACKX_P2P_MAX_RETRY_PAGE_COUNT;
119 transConfig->maxRetryListNodeCnt = NSTACKX_P2P_MAX_RETRY_LIST_NODE_NUM;
120 }
121
ConfigDFileTransWlan(DFileTransConfig * transConfig)122 static void ConfigDFileTransWlan(DFileTransConfig *transConfig)
123 {
124 transConfig->maxRtt = NSTACKX_WLAN_UDP_RTT;
125 transConfig->maxAckCnt = NSTACKX_MAX_ACK_COUNT;
126 transConfig->maxCtrlFrameRetryCnt = NSTACKX_WLAN_MAX_CONTROL_FRAME_RETRY_COUNT;
127 transConfig->maxCtrlFrameTimeout = NSTACKX_WLAN_MAX_CONTROL_FRAME_TIMEOUT;
128 transConfig->maxFileHeaderConfirmFrameTimeout = NSTACKX_WLAN_MAX_FILE_HEADER_CONFIRM_FRAME_TIMEOUT;
129 transConfig->maxFileWriteTimeout = NSTACKX_WLAN_WRITE_ALL_FILE_DATA_TIMEOUT;
130 transConfig->initialRecvIdleTimeout = NSTACKX_WLAN_RECEIVER_IDLE_INIT_TIMEOUT;
131 transConfig->maxRecvIdleCnt = NSTACKX_WLAN_RECEIVER_IDLE_MAX_COUNT;
132 transConfig->initialAckInterval = NSTACKX_ACK_INTERVAL;
133 transConfig->recvLimitAckInterval = NSTACKX_WLAN_RECEIVED_LIMIT_ACK_INTERVAL;
134 transConfig->lastFrameAckInterval = NSTACKX_WLAN_RECEIVED_LAST_FRAME_ACK_INTERVAL;
135 transConfig->maxRetryPageCnt = NSTACKX_WLAN_MAX_RETRY_PAGE_COUNT;
136 transConfig->maxRetryListNodeCnt = NSTACKX_WLAN_MAX_RETRY_LIST_NODE_NUM;
137 }
138
ConfigDFileTrans(uint16_t connType,DFileTransConfig * transConfig)139 int32_t ConfigDFileTrans(uint16_t connType, DFileTransConfig *transConfig)
140 {
141 if (transConfig == NULL) {
142 DFILE_LOGE(TAG, "Invalid parameter");
143 return NSTACKX_EINVAL;
144 }
145
146 if (CheckConnType(connType) != NSTACKX_EOK) {
147 DFILE_LOGE(TAG, "Invalid connection type %u", connType);
148 return NSTACKX_EINVAL;
149 }
150
151 if (connType == CONNECT_TYPE_P2P) {
152 ConfigDFileTransP2p(transConfig);
153 } else {
154 ConfigDFileTransWlan(transConfig);
155 }
156
157 return NSTACKX_EOK;
158 }
159
SetTcpKeepAlive(SocketDesc fd)160 void SetTcpKeepAlive(SocketDesc fd)
161 {
162 #ifndef BUILD_FOR_WINDOWS
163 int32_t optval;
164
165 optval = 1;
166 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)(&optval), sizeof(optval)) != 0) {
167 DFILE_LOGI(TAG, "set KEEPALIVE failed");
168 } else {
169 DFILE_LOGI(TAG, "set KEEPALIVE = %d success", optval);
170 }
171
172 optval = KEEP_ALIVE_IDLE;
173 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, (void *)(&optval), sizeof(optval)) != 0) {
174 DFILE_LOGI(TAG, "set TCP_KEEPIDLE failed");
175 } else {
176 DFILE_LOGI(TAG, "set TCP_KEEPIDLE = %d success", optval);
177 }
178
179 optval = KEEP_ALIVE_CNT;
180 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, (void *)(&optval), sizeof(optval)) != 0) {
181 DFILE_LOGI(TAG, "set TCP_KEEPCNT failed");
182 } else {
183 DFILE_LOGI(TAG, "set TCP_KEEPCNT = %d success", optval);
184 }
185
186 optval = KEEP_ALIVE_INTERVAL;
187 if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, (void *)(&optval), sizeof(optval)) != 0) {
188 DFILE_LOGI(TAG, "set TCP_KEEPINTVL failed");
189 } else {
190 DFILE_LOGI(TAG, "set TCP_KEEPINTVL = %d success", optval);
191 }
192
193 optval = TCP_USER_TIMEOUT_VALUE;
194 if (setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, (void *)(&optval), sizeof(optval)) != 0) {
195 DFILE_LOGI(TAG, "set TCP_USER_TIMEOUT option error");
196 } else {
197 DFILE_LOGI(TAG, "set TCP_USER_TIMEOUT option success time:%d", optval);
198 }
199 #endif
200 }
201
DFileGetCipherCaps(DFileSession * session,SettingFrame * settingFramePara)202 void DFileGetCipherCaps(DFileSession *session, SettingFrame *settingFramePara)
203 {
204 if (CapsChaCha(session) && DFileGetDeviceBits() == DEVICE_32_BITS &&
205 QueryCipherSupportByName(CHACHA20_POLY1305_NAME)) {
206 settingFramePara->cipherCapability |= NSTACKX_CIPHER_CHACHA;
207 } else {
208 session->capability &= ~NSTACKX_CAPS_CHACHA;
209 DFILE_LOGI(TAG, "local cipher no support %s.", CHACHA20_POLY1305_NAME);
210 }
211 }
212
DFileChooseCipherType(SettingFrame * hostSettingFrame,DFileSession * session)213 void DFileChooseCipherType(SettingFrame *hostSettingFrame, DFileSession *session)
214 {
215 if ((hostSettingFrame->cipherCapability & NSTACKX_CIPHER_CHACHA) && (DFileGetDeviceBits() == DEVICE_32_BITS) &&
216 (session->fileManager->keyLen == CHACHA20_KEY_LENGTH)) {
217 session->capability |= NSTACKX_CAPS_CHACHA;
218 } else {
219 session->capability &= ~NSTACKX_CAPS_CHACHA;
220 }
221 DFILE_LOGI(TAG, "opposite replies %s use chacha cipher", CapsChaCha(session) ? "" : "no");
222 }