1 /*
2 * Copyright (C) 2022 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 "fillp_common.h"
17 #include "fillp_mgt_msg_log.h"
18 #include "fillp_dfx.h"
19
20 #ifdef __cplusplus
21 extern "C" {
22 #endif
23
24 struct FillpFinFlags {
25 FILLP_BOOL wrSet;
26 FILLP_BOOL rdSet;
27 FILLP_BOOL ackSet;
28 FILLP_BOOL verSet;
29 };
30
31 static FILLP_UCHAR g_rawMsg[FILLP_FRAME_MTU] = {0};
32
FillpConnReqInputTrace(FILLP_CONST struct FillpPcb * pcb,FILLP_CONST struct FtSocket * sock,struct FillpPktConnReq * req,FILLP_UINT16 flag)33 static void FillpConnReqInputTrace(FILLP_CONST struct FillpPcb *pcb, FILLP_CONST struct FtSocket *sock,
34 struct FillpPktConnReq *req, FILLP_UINT16 flag)
35 {
36 FillpTraceDescriptSt fillpTrcDesc;
37
38 if (sock->traceFlag >= FILLP_TRACE_DIRECT_NETWORK) {
39 struct FillpPktConnReq tmpConnReq;
40 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
41 (void)memset_s(&tmpConnReq, sizeof(struct FillpPktConnReq),
42 0, sizeof(struct FillpPktConnReq));
43
44 pktHdr = (struct FillpPktHead *)(void *)req->head;
45 struct FillpPktHead *tmpHead1 = (struct FillpPktHead *)(void *)tmpConnReq.head;
46 /* Recovert the header to NETWORK byte order to provide indication */
47 tmpHead1->flag = FILLP_HTONS(flag);
48 tmpHead1->dataLen = FILLP_HTONS(pktHdr->dataLen);
49 tmpHead1->pktNum = FILLP_HTONL(pktHdr->pktNum);
50 tmpHead1->seqNum = FILLP_HTONL(pktHdr->seqNum);
51
52 /* Below field is already in NETWORK byte order */
53 tmpConnReq.cookiePreserveTime = req->cookiePreserveTime;
54 tmpConnReq.sendCache = req->sendCache;
55 tmpConnReq.recvCache = req->recvCache;
56
57 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
58 sizeof(struct FillpPktConnReq), FILLP_GET_SOCKET(pcb)->index, fillpTrcDesc,
59 (FILLP_CHAR *)(&tmpConnReq));
60 }
61 }
62
FillpConnReqStateCheck(struct FillpPcb * pcb,FILLP_CONST struct FtSocket * sock)63 static FILLP_INT FillpConnReqStateCheck(struct FillpPcb *pcb, FILLP_CONST struct FtSocket *sock)
64 {
65 FILLP_UINT8 connState = FILLP_GET_CONN_STATE(pcb);
66 if (connState == CONN_STATE_CONNECTED) {
67 if ((pcb->recv.seqNum == pcb->recv.seqStartNum) && (pcb->send.maxAckNumFromReceiver ==
68 pcb->send.seqStartNum)) { /* Only if no data received or no data acked */
69 FILLP_LOGINF("fillp_sock_id:%d Conn req in open state"
70 "as data not received, so sending conn resp,state = %u",
71 sock->index, connState);
72
73 FillpSendConnConfirmAck(pcb);
74 } else {
75 FILLP_LOGINF("fillp_sock_id:%d Conn req in open state"
76 "so dropping the message, state = %u",
77 sock->index, connState);
78 }
79
80 return ERR_FAILURE;
81 }
82
83 if (connState != CONN_STATE_LISTENING) {
84 FILLP_LOGINF("fillp_sock_id:%d Connection state in not correct, state = %u", sock->index, connState);
85 return ERR_CONNREFUSED;
86 }
87
88 return ERR_OK;
89 }
90
FillpConnReqInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)91 void FillpConnReqInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
92 {
93 struct FillpPktConnReq *req = FILLP_NULL_PTR;
94 FillpCookieContent stateCookie;
95 FILLP_UINT16 flag;
96 struct FillpPktHead *tmpHead = FILLP_NULL_PTR;
97 struct FtSocket *sock = FILLP_GET_SOCKET(pcb);
98 if (sock == FILLP_NULL_PTR) {
99 FILLP_LOGERR("sock is NULL");
100 return;
101 }
102
103 /* We should check for minimum length because of optional parameter total length may be more, which can be added in
104 future version of stack, current version just ignore optlen as none is defined */
105 if (p->len < (FILLP_INT)(sizeof(struct FillpPktConnReq) - FILLP_HLEN)) {
106 FILLP_LOGWAR("fillp_sock_id:%d, Invalid connection request, len = %d", FILLP_GET_SOCKET(pcb)->index, p->len);
107 return;
108 }
109
110 FILLP_LOGINF("Get conn request, fillp_sock_id:%d, source port:%u, remote port:%u", sock->index,
111 UTILS_GET_ADDRPORT(&((struct SpungePcb*)(pcb->spcb))->localAddr), UTILS_GET_ADDRPORT(&p->addr));
112
113 req = (struct FillpPktConnReq *)(void *)p->p;
114 tmpHead = (struct FillpPktHead *)(void *)req->head;
115 flag = tmpHead->flag;
116
117 FillpConnReqInputTrace(pcb, sock, req, flag);
118 FILLP_CONN_REQ_LOG(sock->index, req, FILLP_DIRECTION_RX);
119 if (FillpConnReqStateCheck(pcb, sock) != ERR_OK) {
120 return;
121 }
122
123 req->cookiePreserveTime = FILLP_NTOHL(req->cookiePreserveTime);
124 req->sendCache = FILLP_NTOHL(req->sendCache);
125 req->recvCache = FILLP_NTOHL(req->recvCache);
126 req->timestamp = FILLP_NTOHLL(req->timestamp);
127
128 if ((req->recvCache == 0) || (req->sendCache == 0) || (req->timestamp == 0)) {
129 FILLP_LOGINF("fillp_sock_id:%d recv cache or sendCache size or timestamp is not correct"
130 "recvCache=%u, sendCache=%u, timestamp=%llu",
131 sock->index, req->recvCache, req->sendCache, req->timestamp);
132 return;
133 }
134
135 (void)memset_s(&stateCookie, sizeof(FillpCookieContent), 0, sizeof(FillpCookieContent));
136 FillpGenerateCookie(pcb, req, &p->addr, ((struct sockaddr_in *)(&FILLP_GET_CONN(pcb)->pcb->localAddr))->sin_port,
137 &stateCookie);
138
139 FillpSendConnReqAck(pcb, &stateCookie, req->timestamp);
140 }
141
142 /* On success return number of bytes used to encode and on failure -ve values */
FillpEncodeExtPara(FILLP_UCHAR * buf,FILLP_INT32 bufLen,FILLP_UCHAR paraType,FILLP_UCHAR paraLen,FILLP_UCHAR * paraValue)143 static FILLP_INT32 FillpEncodeExtPara(FILLP_UCHAR *buf, FILLP_INT32 bufLen, FILLP_UCHAR paraType, FILLP_UCHAR paraLen,
144 FILLP_UCHAR *paraValue)
145 {
146 FILLP_INT32 len;
147 /* If paraLen is more than 1 then encode as name-length-value,
148 If paraLen is 1 or 0 then encode as name-value.
149 If MSB bit is set to 1 then it is encoded as name length value, otherwise it is encoded as
150 name value */
151 len = (paraLen <= 1) ? FILLP_ONE_EXT_PARA_LENGTH : (paraLen + FILLP_ONE_EXT_PARA_LENGTH);
152 if (bufLen < len) {
153 return ERR_FAILURE;
154 }
155
156 *buf = paraType;
157
158 if (paraLen > 1) {
159 *buf |= (FILLP_UCHAR)0x80;
160 } else {
161 buf++;
162 *buf = *paraValue;
163 return len;
164 }
165
166 buf++;
167 *buf = paraLen;
168 buf++;
169
170 FillpErrorType err = memcpy_s(buf, (FILLP_UINT32)bufLen - FILLP_ONE_EXT_PARA_LENGTH, paraValue, paraLen);
171 if (err != EOK) {
172 FILLP_LOGERR("fillp_encode_ext_para memcpy_s failed:%d", err);
173 return ERR_FAILURE;
174 }
175 return len;
176 }
177
178
179 /* On success returns buffer consumed, otherwise -ve value */
FillpDecodeExtParaNameLen(FILLP_CONST FILLP_UCHAR * buf,FILLP_INT bufLen,FILLP_UCHAR * paraType,FILLP_UCHAR * paraLen)180 static FILLP_INT32 FillpDecodeExtParaNameLen(FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen, FILLP_UCHAR *paraType,
181 FILLP_UCHAR *paraLen)
182 {
183 FILLP_INT len;
184 /* If paraLen is more then 1 then encode as name length value,
185 If paraLen is 1 or 0 then encode as name value.
186 If MSB bit is set to 1 then it is encoded as name length value, otherwise it is encoded as
187 name value */
188 if (bufLen < FILLP_ONE_EXT_PARA_LENGTH) {
189 return ERR_FAILURE;
190 }
191
192 *paraType = *buf;
193
194 if (*paraType & 0x80) {
195 *paraLen = *(buf + 1);
196 *paraType = (FILLP_UCHAR)((*paraType) & (FILLP_UCHAR)~(0x80));
197 len = FILLP_ONE_EXT_PARA_LENGTH;
198 } else {
199 *paraLen = 1;
200 len = 1;
201 }
202
203 if ((*paraLen == 0) || ((FILLP_INT)(len + (FILLP_INT)(*paraLen)) > bufLen)) {
204 return ERR_FAILURE;
205 }
206
207 return len;
208 }
209
FillpDecodeRtt(struct FtNetconn * conn,FILLP_CONST FILLP_UCHAR * buf,FILLP_INT bufLen)210 static void FillpDecodeRtt(struct FtNetconn *conn, FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen)
211 {
212 FILLP_ULLONG rtt;
213 if (bufLen != (FILLP_INT)sizeof(rtt)) {
214 return;
215 }
216
217 FILLP_INT err = memcpy_s(&rtt, sizeof(rtt), buf, (FILLP_UINT32)bufLen);
218 if (err != EOK) {
219 FILLP_LOGERR("memcpy_s failed: %d", err);
220 return;
221 }
222
223 conn->calcRttDuringConnect = FILLP_NTOHLL(rtt);
224 #ifdef FILLP_MGT_MSG_LOG
225 conn->extParameterExisted[FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_RTT] = FILLP_TRUE;
226 #endif
227 }
228
FillpDecodePktSize(struct FtNetconn * conn,FILLP_CONST FILLP_UCHAR * buf,FILLP_INT bufLen)229 static void FillpDecodePktSize(struct FtNetconn *conn, FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen)
230 {
231 FILLP_UINT32 pktSize;
232 if (bufLen != (FILLP_INT)sizeof(pktSize)) {
233 return;
234 }
235
236 FILLP_INT err = memcpy_s(&pktSize, sizeof(pktSize), buf, (FILLP_UINT32)bufLen);
237 if (err != EOK) {
238 FILLP_LOGERR("memcpy_s failed: %d", err);
239 return;
240 }
241
242 conn->peerPktSize = FILLP_NTOHL(pktSize);
243 #ifdef FILLP_MGT_MSG_LOG
244 conn->extParameterExisted[FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE] = FILLP_TRUE;
245 #endif
246 }
247
FillpDecodeCharacters(struct FtNetconn * conn,FILLP_CONST FILLP_UCHAR * buf,FILLP_INT bufLen)248 static void FillpDecodeCharacters(struct FtNetconn *conn, FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen)
249 {
250 FILLP_UINT32 characters;
251 if (bufLen != (FILLP_INT)sizeof(characters)) {
252 return;
253 }
254
255 FILLP_INT err = memcpy_s(&characters, sizeof(characters), buf, (FILLP_UINT32)bufLen);
256 if (err != EOK) {
257 FILLP_LOGERR("memcpy_s failed: %d", err);
258 return;
259 }
260
261 conn->peerCharacters = FILLP_NTOHL(characters);
262 #ifdef FILLP_MGT_MSG_LOG
263 conn->extParameterExisted[FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER] = FILLP_TRUE;
264 #endif
265 }
266
FillpDecodeFcAlg(struct FtNetconn * conn,FILLP_CONST FILLP_UCHAR * buf,FILLP_INT bufLen)267 static void FillpDecodeFcAlg(struct FtNetconn *conn, FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen)
268 {
269 if (bufLen != (FILLP_INT)sizeof(conn->peerFcAlgs)) {
270 return;
271 }
272
273 conn->peerFcAlgs = *(FILLP_UINT8 *)buf;
274 #ifdef FILLP_MGT_MSG_LOG
275 conn->extParameterExisted[FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG] = FILLP_TRUE;
276 #endif
277 }
278
279 typedef void (*FIllpExtParaDecoder)(struct FtNetconn *conn, FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen);
280 static FIllpExtParaDecoder g_extParaDecoder[FILLP_PKT_EXT_BUTT] = {
281 FILLP_NULL_PTR, /* FILLP_PKT_EXT_START */
282 FillpDecodeRtt, /* FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_RTT */
283 FillpDecodePktSize, /* FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE */
284 FillpDecodeCharacters, /* FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER */
285 FillpDecodeFcAlg, /* FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG */
286 };
287
FillpDecodeExtPara(FILLP_CONST FILLP_UCHAR * buf,FILLP_INT bufLen,struct FtNetconn * conn)288 FILLP_INT32 FillpDecodeExtPara(FILLP_CONST FILLP_UCHAR *buf, FILLP_INT bufLen, struct FtNetconn *conn)
289 {
290 FILLP_INT len = 0;
291 FILLP_UCHAR paraType = 0;
292 FILLP_UCHAR paraLen = 0;
293 FILLP_INT ret;
294
295 while (len < bufLen) {
296 ret = FillpDecodeExtParaNameLen(buf + len, bufLen - len, ¶Type, ¶Len);
297 if (ret <= ERR_OK) {
298 /* This can fail because of insufficient space so return */
299 return ret;
300 }
301
302 len += ret;
303
304 FILLP_LOGERR("paraType:%u ", paraType);
305
306 if (bufLen - len >= paraLen &&
307 paraType > FILLP_PKT_EXT_START && paraType < FILLP_PKT_EXT_BUTT &&
308 g_extParaDecoder[paraType] != FILLP_NULL_PTR) {
309 g_extParaDecoder[paraType](conn, buf + len, paraLen);
310 }
311
312 len += paraLen;
313 }
314
315 return ERR_OK;
316 }
317
FillpConnReqAckClientBuild(FILLP_CHAR * buf,FILLP_INT32 * len,FILLP_CONST struct NetBuf * p,struct FillpConnReqAckClient * reqAck)318 static FILLP_INT32 FillpConnReqAckClientBuild(FILLP_CHAR *buf, FILLP_INT32 *len, FILLP_CONST struct NetBuf *p,
319 struct FillpConnReqAckClient *reqAck)
320 {
321 reqAck->tagCookie = *((FILLP_UINT16 *)buf);
322 buf = buf + sizeof(FILLP_UINT16);
323 *len += sizeof(FILLP_UINT16);
324 reqAck->tagCookie = FILLP_NTOHS(reqAck->tagCookie);
325 reqAck->cookieLength = *((FILLP_UINT16 *)buf);
326 buf = buf + sizeof(FILLP_UINT16);
327 *len += sizeof(FILLP_UINT16);
328 reqAck->cookieLength = FILLP_NTOHS(reqAck->cookieLength);
329
330 if ((p->len < (FILLP_INT)(reqAck->cookieLength + *len)) || (reqAck->cookieLength == 0)) {
331 return FILLP_FAILURE;
332 }
333
334 reqAck->cookieContent = buf;
335
336 buf = buf + reqAck->cookieLength;
337 *len += reqAck->cookieLength;
338
339 if (p->len < (*len + (FILLP_INT)sizeof(FILLP_ULLONG))) {
340 return FILLP_FAILURE;
341 }
342
343 reqAck->timestamp = *((FILLP_ULLONG *)buf);
344 reqAck->timestamp = FILLP_NTOHLL(reqAck->timestamp);
345
346 buf = buf + sizeof(FILLP_ULLONG);
347 *len += sizeof(FILLP_ULLONG);
348 return FILLP_OK;
349 }
350
FillpConsultFcAlg(FILLP_UINT8 presetFcAlg,FILLP_UINT8 peerFcAlgs)351 static FILLP_UINT8 FillpConsultFcAlg(FILLP_UINT8 presetFcAlg, FILLP_UINT8 peerFcAlgs)
352 {
353 FILLP_UINT8 resultFcAlg;
354 FILLP_UINT8 range = peerFcAlgs & (FILLP_UINT8)FILLP_SUPPORT_ALGS;
355 if (presetFcAlg == FILLP_SUPPORT_ALG_BASE && g_resource.flowControl.fcAlg != FILLP_ALG_BASE) {
356 presetFcAlg = (FILLP_UINT8)FILLP_SUPPORT_ALG_N(g_resource.flowControl.fcAlg);
357 }
358 if ((range & presetFcAlg) != 0) {
359 range &= presetFcAlg;
360 }
361 resultFcAlg = FILLP_SUPPORT_ALG_HIGHEST;
362 while (resultFcAlg > FILLP_SUPPORT_ALG_BASE) {
363 if ((resultFcAlg & range) != 0) {
364 break;
365 }
366 resultFcAlg >>= 1;
367 }
368 return resultFcAlg;
369 }
370
FillpDecodeConnReqAckClientPara(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,struct FillpConnReqAckClient * reqAck)371 static FILLP_INT32 FillpDecodeConnReqAckClientPara(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p,
372 struct FillpConnReqAckClient *reqAck)
373 {
374 FILLP_INT32 len = 0;
375 FILLP_CHAR *buf = p->p + FILLP_HLEN;
376 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
377
378 if (p->len < (FILLP_INT)(sizeof(FILLP_UINT16) * 2)) {
379 return FILLP_FAILURE;
380 }
381
382 if (FillpConnReqAckClientBuild(buf, &len, p, reqAck) != FILLP_OK) {
383 return FILLP_FAILURE;
384 }
385 buf += len;
386
387 conn->peerFcAlgs = 0;
388 conn->peerCharacters = 0;
389 if (FillpDecodeExtPara((FILLP_UCHAR *)buf, p->len - len, conn) != ERR_OK) {
390 FILLP_LOGERR("FillpDecodeExtPara failed");
391 return FILLP_FAILURE;
392 }
393
394 FILLP_CONN_REQ_ACK_RX_LOG(FILLP_GET_SOCKET(pcb)->index, (struct FillpPktHead *)p->p, reqAck,
395 (FILLP_UCHAR *)buf, p->len - len);
396
397 pcb->characters = conn->peerCharacters & (FILLP_UINT32)FILLP_DEFAULT_SUPPORT_CHARACTERS;
398 pcb->fcAlg = FillpConsultFcAlg(pcb->fcAlg, conn->peerFcAlgs);
399
400 return FILLP_SUCCESS;
401 }
402
FillpConnReqAckTrace(struct FtSocket * sock,struct FillpPktHead * pktHdr)403 static void FillpConnReqAckTrace(struct FtSocket *sock, struct FillpPktHead *pktHdr)
404 {
405 FillpTraceDescriptSt fillpTrcDesc;
406 if (sock->traceFlag < FILLP_TRACE_DIRECT_NETWORK) {
407 return;
408 }
409 struct FillpPktConnReqAck tmpConnReqAck;
410 struct FillpPktHead *tmpHead = (struct FillpPktHead *)(void *)tmpConnReqAck.head;
411
412 (void)memset_s(&tmpConnReqAck, sizeof(struct FillpPktConnReqAck), 0,
413 sizeof(struct FillpPktConnReqAck));
414
415 /* Recovert the header to NETWORK byte order to provide indication */
416 tmpHead->flag = FILLP_HTONS(pktHdr->flag);
417 tmpHead->dataLen = FILLP_HTONS(pktHdr->dataLen);
418 tmpHead->pktNum = FILLP_HTONL(pktHdr->pktNum);
419 tmpHead->seqNum = FILLP_HTONL(pktHdr->seqNum);
420
421 /* cookieContent information , including tag or length should not be given to
422 user in indication. */
423 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
424 sizeof(struct FillpPktConnReqAck), sock->index, fillpTrcDesc, (FILLP_CHAR *)(&tmpConnReqAck));
425 }
426
FillpConnReqAckInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)427 void FillpConnReqAckInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
428 {
429 struct FillpConnReqAckClient reqAck = {0};
430 struct FtSocket *sock = FILLP_GET_SOCKET(pcb);
431
432 if (sock == FILLP_NULL_PTR) {
433 FILLP_LOGERR("sock is null");
434 return;
435 }
436
437 FILLP_LOGINF("req ack input, fillp_sock_id:%d, pcb, source port:%u, destport:%u", sock->index,
438 UTILS_GET_ADDRPORT(&(FILLP_GET_CONN(pcb))->pcb->localAddr), UTILS_GET_ADDRPORT(&p->addr));
439
440
441 if (FillpDecodeConnReqAckClientPara(pcb, p, &reqAck) != FILLP_SUCCESS) {
442 FILLP_LOGINF("fillp_sock_id:%d Invalid connection request, len = %d", sock->index, p->len);
443 return;
444 }
445
446 struct FillpPktHead *pktHdr = (struct FillpPktHead *)(void *)p->p;
447 FillpConnReqAckTrace(sock, pktHdr);
448
449 FILLP_UINT8 connState = FILLP_GET_CONN_STATE(pcb);
450 if (connState != CONN_STATE_CONNECTING) {
451 FILLP_LOGINF("fillp_sock_id=%d Connection state in not correct,state=%u", sock->index, connState);
452 return;
453 }
454
455 pcb->peerUniqueId = pktHdr->seqNum;
456 FILLP_LLONG curTime = SYS_ARCH_GET_CUR_TIME_LONGLONG();
457 FILLP_LLONG rttTime = curTime - (FILLP_LLONG)reqAck.timestamp;
458 if (rttTime <= 0) {
459 FILLP_LOGWAR("System Time has changed;curTime:%lld,reqTime:%llu", curTime, reqAck.timestamp);
460 return;
461 }
462
463 pcb->rtt = (FILLP_ULLONG)rttTime;
464
465
466 if (FILLP_GET_CONN(pcb)->calcRttDuringConnect == 0) {
467 FILLP_GET_CONN(pcb)->calcRttDuringConnect = pcb->rtt;
468 }
469
470 FILLP_GET_CONN(pcb)->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_REQACK_RCVED;
471
472 {
473 struct SpungePcb *spcb = (struct SpungePcb*)pcb->spcb;
474 struct sockaddr *addr = (struct sockaddr *)(void *)&p->addr;
475
476
477 if (addr->sa_family == AF_INET) {
478 spcb->addrType = AF_INET;
479 *((struct sockaddr_in *)&spcb->remoteAddr) = *(struct sockaddr_in *)addr;
480 spcb->addrLen = sizeof(struct sockaddr);
481 } else {
482 spcb->addrType = AF_INET6;
483 spcb->remoteAddr = p->addr;
484 spcb->addrLen = sizeof(struct sockaddr_in6);
485 }
486 }
487
488 FillpSendConnConfirm(pcb, &reqAck);
489 }
490
FillpInitNewPcbByNewConn(struct FtNetconn * newConn,FILLP_SIZE_T maxSendCache,FILLP_SIZE_T maxRecvCache)491 static FILLP_INT FillpInitNewPcbByNewConn(struct FtNetconn *newConn, FILLP_SIZE_T maxSendCache,
492 FILLP_SIZE_T maxRecvCache)
493 {
494 struct FtSocket *sock = (struct FtSocket *)newConn->sock;
495 newConn->pcb->fpcb.pktSize = UTILS_MIN(sock->resConf.flowControl.pktSize, newConn->peerPktSize);
496 if ((newConn->pcb->fpcb.pktSize > (FILLP_MAX_PKT_SIZE - FILLP_HLEN)) || (newConn->pcb->fpcb.pktSize == 0)) {
497 newConn->pcb->fpcb.pktSize = (FILLP_MAX_PKT_SIZE - FILLP_HLEN);
498 }
499
500 newConn->pcb->fpcb.recv.pktRecvCache = (FILLP_UINT32)maxRecvCache * (FILLP_UINT32)newConn->pcb->fpcb.pktSize;
501 newConn->pcb->fpcb.send.pktSendCache = (FILLP_UINT32)maxSendCache * (FILLP_UINT32)newConn->pcb->fpcb.pktSize;
502
503 if (((newConn->pcb->fpcb.recv.pktRecvCache / newConn->pcb->fpcb.pktSize) != maxRecvCache) ||
504 ((newConn->pcb->fpcb.send.pktSendCache / newConn->pcb->fpcb.pktSize) != maxSendCache)) {
505 FILLP_LOGERR("fillp_sock_id:%d Invalid pkt cache size", sock->index);
506 return -1;
507 }
508
509 if (newConn->calcRttDuringConnect) {
510 struct FillpPcb *fpcb = &(newConn->pcb->fpcb);
511 fpcb->rtt = newConn->calcRttDuringConnect;
512 }
513
514 newConn->pcb->fpcb.characters = newConn->peerCharacters & (FILLP_UINT32)FILLP_DEFAULT_SUPPORT_CHARACTERS;
515 newConn->pcb->fpcb.fcAlg = newConn->peerFcAlgs & (FILLP_UINT8)FILLP_SUPPORT_ALGS;
516
517 if (FillpInitPcb(&newConn->pcb->fpcb, (FILLP_INT)maxSendCache, (FILLP_INT)maxRecvCache) != ERR_OK) {
518 FILLP_LOGERR("fillp_sock_id:%d Failed to init fillp pcb", sock->index);
519 return -1;
520 }
521 return 0;
522 }
523
FillpInitNewPcbByConfirm(struct FtNetconn * newConn,FILLP_CONST struct FillpPktConnConfirm * confirm)524 static void FillpInitNewPcbByConfirm(struct FtNetconn *newConn, FILLP_CONST struct FillpPktConnConfirm *confirm)
525 {
526 newConn->pcb->fpcb.send.pktNum = confirm->cookieContent.localPacketSeqNumber;
527 newConn->pcb->fpcb.send.seqNum = confirm->cookieContent.localMessageSeqNumber;
528 newConn->pcb->fpcb.recv.lastPackPktNum = confirm->cookieContent.remotePacketSeqNumber;
529 newConn->pcb->fpcb.recv.lastPackSeqNum = confirm->cookieContent.remoteMessageSeqNumber;
530 newConn->pcb->fpcb.send.pktStartNum = confirm->cookieContent.localPacketSeqNumber;
531 newConn->pcb->fpcb.send.seqStartNum = confirm->cookieContent.localMessageSeqNumber;
532 newConn->pcb->fpcb.send.ackSeqNum = confirm->cookieContent.localMessageSeqNumber;
533 newConn->pcb->fpcb.send.maxAckNumFromReceiver = confirm->cookieContent.localMessageSeqNumber;
534
535 newConn->pcb->fpcb.recv.prePackPktNum = confirm->cookieContent.remotePacketSeqNumber;
536 newConn->pcb->fpcb.recv.pktNum = confirm->cookieContent.remotePacketSeqNumber;
537 newConn->pcb->fpcb.recv.seqNum = confirm->cookieContent.remoteMessageSeqNumber;
538 newConn->pcb->fpcb.recv.pktStartNum = confirm->cookieContent.remotePacketSeqNumber;
539 newConn->pcb->fpcb.recv.seqStartNum = confirm->cookieContent.remoteMessageSeqNumber;
540 newConn->pcb->fpcb.recv.endSeqNum = confirm->cookieContent.remoteMessageSeqNumber;
541 newConn->pcb->fpcb.statistics.pack.packPktNum = confirm->cookieContent.remotePacketSeqNumber;
542 newConn->pcb->fpcb.statistics.appFcStastics.pktNum = confirm->cookieContent.remotePacketSeqNumber;
543
544 newConn->pcb->fpcb.localUniqueId = confirm->cookieContent.localMessageSeqNumber;
545 newConn->pcb->fpcb.peerUniqueId = confirm->cookieContent.remoteMessageSeqNumber;
546 }
547
FillpInitNewconnBySock(struct FtNetconn * conn,FILLP_CONST struct FtSocket * sock)548 void FillpInitNewconnBySock(struct FtNetconn *conn, FILLP_CONST struct FtSocket *sock)
549 {
550 NetconnSetAddrType(conn, sock->sockAddrType);
551 NetconnSetPktSize(conn, sock->resConf.flowControl.pktSize);
552 NetconnSetOpersiteRate(conn, sock->resConf.flowControl.oppositeSetRate);
553 NetconnSetSlowStart(conn, sock->resConf.flowControl.slowStart);
554 NetconnSetPackInterval(conn, sock->resConf.flowControl.packInterval);
555 FILLP_LOGDBG("Set pack interval:%u", sock->resConf.flowControl.packInterval);
556 NetconnSetDirectlySend(conn, sock->directlySend);
557 }
558
FillpInitNewConnByConfirm(struct FillpPcb * pcb,struct FtNetconn * newConn,FILLP_CONST struct FillpPktConnConfirm * confirm,FILLP_CONST struct FtNetconn * conn,FILLP_CONST struct NetBuf * p)559 static FILLP_INT FillpInitNewConnByConfirm(struct FillpPcb *pcb, struct FtNetconn *newConn,
560 FILLP_CONST struct FillpPktConnConfirm *confirm, FILLP_CONST struct FtNetconn *conn, FILLP_CONST struct NetBuf *p)
561 {
562 FILLP_SIZE_T maxSendCache;
563 FILLP_SIZE_T maxRecvCache;
564 struct sockaddr *addr = FILLP_NULL_PTR;
565 FILLP_UINT16 addrLen = 0;
566 struct SpungePcb *spcb = (struct SpungePcb*)pcb->spcb;
567 struct sockaddr *localAddr = (struct sockaddr *)(void *)(&spcb->localAddr);
568 struct FtSocket *sock = (struct FtSocket *)conn->sock;
569
570 maxSendCache = sock->resConf.common.maxServerAllowSendCache;
571 maxRecvCache = sock->resConf.common.maxServerAllowRecvCache;
572
573 maxSendCache = UTILS_MIN(maxSendCache, confirm->cookieContent.remoteRecvCache);
574 maxRecvCache = UTILS_MIN(maxRecvCache, confirm->cookieContent.remoteSendCache);
575
576 NetconnSetRecvCacheSize(newConn, (FILLP_UINT32)maxRecvCache);
577 NetconnSetSendCacheSize(newConn, (FILLP_UINT32)maxSendCache);
578 FillpInitNewconnBySock(newConn, sock);
579 NetconnSetLocalPort(newConn, conn->pcb->localPort); // The same with the server listen port
580
581 /* Scenario: FtAccept() is not done. So NetconnSetSock() is not yet set in
582 SpungeHandleMsgConnAccepted(), hence the variable ftSock is NULL
583 and dumping in FillpDoInput.
584
585 Temporarily the accepted->netconn sock reference is LISTEN socket. It will reference
586 to actual accepted sock in SpungeHandleMsgConnAccepted() when APP
587 calls the FtAccept(). So if the keep alive timer expires before APP calls the FtAccept()
588 then fc_cyle() will run and coredump can happen as the netconn->sock will be NULL
589
590 */
591 newConn->sock = sock; // It is very important to set this , because it is necessary to make netconn has a socket
592 if (FillpInitNewPcbByNewConn(newConn, maxSendCache, maxRecvCache) != 0) {
593 return -1;
594 }
595
596 FillpInitNewPcbByConfirm(newConn, confirm);
597 FillpErrorType err = memcpy_s(&newConn->pcb->localAddr, sizeof(newConn->pcb->localAddr), localAddr,
598 sizeof(spcb->localAddr));
599 if (err != EOK) {
600 FILLP_LOGERR("fillp_init_newConn_by_confirm memcpy_s local ip failed: %d", err);
601 return err;
602 }
603
604 addr = (struct sockaddr *)(void *)&p->addr;
605 NetconnSetAddrType(newConn, addr->sa_family);
606 if (addr->sa_family == AF_INET) {
607 addrLen = sizeof(struct sockaddr_in);
608 } else {
609 addrLen = sizeof(struct sockaddr_in6);
610 }
611
612 err = memcpy_s(&newConn->pcb->remoteAddr, sizeof(newConn->pcb->remoteAddr), addr, addrLen);
613 if (err != EOK) {
614 FILLP_LOGERR("fillp_init_newConn_by_confirm memcpy_s remote ip failed: %d", err);
615 return err;
616 }
617 newConn->pcb->addrLen = addrLen;
618
619 FillpNetconnSetState(newConn, CONN_STATE_CONNECTING);
620
621 return ERR_OK;
622 }
623
FillpInitPeerOfNewconn(struct FtNetconn * newConn,FILLP_UINT32 peerPktSize)624 static inline void FillpInitPeerOfNewconn(struct FtNetconn *newConn, FILLP_UINT32 peerPktSize)
625 {
626 newConn->peerPktSize = peerPktSize;
627 newConn->peerFcAlgs = 0;
628 newConn->peerCharacters = 0;
629 }
630
FillpProcessConnConfirm(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,FILLP_CONST struct FillpPktConnConfirm * confirm,FILLP_CONST struct FtNetconn * conn,struct SpungeInstance * inst)631 static void FillpProcessConnConfirm(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p,
632 FILLP_CONST struct FillpPktConnConfirm *confirm, FILLP_CONST struct FtNetconn *conn,
633 struct SpungeInstance *inst)
634 {
635 struct sockaddr *addr = (struct sockaddr *)(void *)&p->addr;
636 struct FtSocket *sock = (struct FtSocket *)conn->sock;
637
638 if (sock == FILLP_NULL_PTR) {
639 FILLP_LOGERR("sock is null");
640 return;
641 }
642
643 struct FtNetconn *newConn = FillpNetconnAlloc(addr->sa_family, inst);
644 if (newConn == FILLP_NULL_PTR) {
645 FILLP_LOGERR("fillp_sock_id:%d Failed in allocate new netconn connection", sock->index);
646 return;
647 }
648
649 /* If client is old version then it will not have FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE
650 parameter, so used current node pkt size */
651 FillpInitPeerOfNewconn(newConn, sock->resConf.flowControl.pktSize);
652
653 /* Decode connection confirm extension parameters */
654 (void)FillpDecodeExtPara((FILLP_UCHAR *)(p->p) + sizeof(struct FillpPktConnConfirm),
655 (FILLP_INT)(p->len - ((FILLP_INT)sizeof(struct FillpPktConnConfirm) - FILLP_HLEN)), newConn);
656
657 if (FillpInitNewConnByConfirm(pcb, newConn, confirm, conn, p) != ERR_OK) {
658 FillpNetconnDestroy(newConn);
659 return;
660 }
661
662 struct SockOsSocket *osSock = NETCONN_GET_OSSOCK(conn, SPUNGE_GET_CUR_INSTANCE()->instIndex);
663 if (!OS_SOCK_OPS_FUNC_VALID(osSock, handlePacket)) {
664 FILLP_LOGERR("os sock ops handlePacket is null");
665 FillpNetconnDestroy(newConn);
666 return;
667 }
668 FillpErrorType err = osSock->ioSock->ops->handlePacket(FILLP_PKT_TYPE_CONN_CONFIRM, (void *)osSock->ioSock,
669 (void *)newConn->pcb, (void *)p);
670
671 /* Here we need to set newConn->osSock, or it will be null pointer, and when do accept, it will be rewrite */
672 newConn->osSocket[SPUNGE_GET_CUR_INSTANCE()->instIndex] = osSock;
673 osSock->reference++;
674 if (err != ERR_OK) {
675 FILLP_LOGERR("sysio connect fail");
676 FillpNetconnDestroy(newConn);
677 return;
678 }
679
680 if (FillpQueuePush(sock->acceptBox, (void *)&newConn, FILLP_TRUE, 1) != ERR_OK) {
681 FILLP_LOGERR("push to accept box fail");
682 FillpNetconnDestroy(newConn);
683 return;
684 }
685
686 if (!(SOCK_IS_NONBLOCKING(sock))) {
687 (void)SYS_ARCH_SEM_POST(&sock->acceptSem);
688 }
689
690 sock->listenBacklog--;
691
692 FILLP_LOGINF("Push conn to accept box fillp_sock_id:%d,sock->listenBacklog:%d", sock->index, sock->listenBacklog);
693
694 SpungeEpollEventCallback(sock, SPUNGE_EPOLLIN, 1);
695 }
696
FillpConnConfirmTrace(struct FtSocket * sock,struct FillpPktConnConfirm * confirm)697 static void FillpConnConfirmTrace(struct FtSocket *sock, struct FillpPktConnConfirm *confirm)
698 {
699 FillpTraceDescriptSt fillpTrcDesc;
700 if (sock->traceFlag < FILLP_TRACE_DIRECT_NETWORK) {
701 return;
702 }
703 struct FillpPktConnConfirm tmpConnConfirm;
704 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
705 struct FillpPktHead *tempHdr = FILLP_NULL_PTR;
706
707 (void)memset_s(&tmpConnConfirm, sizeof(struct FillpPktConnConfirm), 0,
708 sizeof(struct FillpPktConnConfirm));
709
710 pktHdr = (struct FillpPktHead *)confirm->head;
711 tempHdr = (struct FillpPktHead *)tmpConnConfirm.head;
712 /* Recovert the header to NETWORK byte order to provide indication */
713 tempHdr->flag = FILLP_HTONS(pktHdr->flag);
714 tempHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
715 tempHdr->pktNum = FILLP_HTONL(pktHdr->pktNum);
716 tempHdr->seqNum = FILLP_HTONL(pktHdr->seqNum);
717
718 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
719 sizeof(struct FillpPktConnConfirm), sock->index, fillpTrcDesc, (FILLP_CHAR *)(&tmpConnConfirm));
720 }
721
FillpConfirmCheckState(FILLP_UINT8 connState,struct FtSocket * sock,struct FillpPcb * pcb)722 static FILLP_BOOL FillpConfirmCheckState(FILLP_UINT8 connState, struct FtSocket *sock, struct FillpPcb *pcb)
723 {
724 if (connState == CONN_STATE_CONNECTED) {
725 if ((pcb->recv.seqNum == pcb->recv.seqStartNum) && (pcb->send.maxAckNumFromReceiver ==
726 pcb->send.seqStartNum)) { /* Only if no data recved or no data acked */
727 FILLP_LOGDBG("fillp_sock_id:%d Conn confirm in open state "
728 "as data not received, so sending conn confirm ack, state = %u",
729 sock->index, connState);
730
731 FillpSendConnConfirmAck(pcb);
732 } else {
733 FILLP_LOGINF("fillp_sock_id:%d Conn confirm in open state "
734 "so dropping the message,state=%u",
735 sock->index, connState);
736 }
737
738 return FILLP_FALSE;
739 }
740
741 if (connState != CONN_STATE_LISTENING) {
742 FILLP_LOGINF("fillp_sock_id:%d Connection state in not correct, state = %u", sock->index, connState);
743 return FILLP_FALSE;
744 }
745 return FILLP_TRUE;
746 }
747
FillpConnConfirmInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,struct SpungeInstance * inst)748 void FillpConnConfirmInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p, struct SpungeInstance *inst)
749 {
750 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
751 struct FtSocket *sock = (struct FtSocket *)conn->sock;
752 if (sock == FILLP_NULL_PTR) {
753 FILLP_LOGERR("sock is null");
754 return;
755 }
756
757 FILLP_LOGINF("conn confirm input, fillp_sock_id:%d, source port:%u, remote port:%u", sock->index,
758 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&p->addr));
759
760 if (p->len < (FILLP_INT)(sizeof(struct FillpPktConnConfirm) - FILLP_HLEN)) {
761 FILLP_LOGINF("fillp_sock_id:%d Invalid connection confirm,len=%d", sock->index, p->len);
762 return;
763 }
764
765 struct FillpPktConnConfirm *confirm = (struct FillpPktConnConfirm *)(void *)p->p;
766 FillpConnConfirmTrace(sock, confirm);
767 FILLP_CONN_CONFIRM_RX_LOG(sock->index, confirm, (FILLP_UCHAR *)p->p + sizeof(struct FillpPktConnConfirm),
768 (FILLP_INT)(p->len - ((FILLP_INT)sizeof(struct FillpPktConnConfirm) - FILLP_HLEN)));
769
770 FILLP_UINT8 connState = NETCONN_GET_STATE(conn);
771 if (FillpConfirmCheckState(connState, sock, pcb) == FILLP_FALSE) {
772 return;
773 }
774
775 /* Below two parameters are not used at the server side */
776 confirm->cookieLength = FILLP_NTOHS(confirm->cookieLength);
777 confirm->tagCookie = FILLP_NTOHS(confirm->tagCookie);
778
779 if ((confirm->tagCookie != FILLP_COOKIE_TAG) || (confirm->cookieLength != sizeof(FillpCookieContent))) {
780 FILLP_LOGINF("fillp_sock_id:%d, received cookie length = %u,"
781 "actual cookie size = %zu, discarding the packet",
782 sock->index, confirm->cookieLength, sizeof(FillpCookieContent));
783 return;
784 }
785
786 FILLP_INT ret = FillpValidateCookie(pcb, ((struct sockaddr_in *)(&conn->pcb->localAddr))->sin_port, &p->addr,
787 &confirm->cookieContent);
788 if (ret != FILLP_SUCCESS) {
789 FILLP_LOGINF("fillp_sock_id:%d cookieContent validation fails"
790 "state = %u, discarding the packet",
791 sock->index, connState);
792 return;
793 }
794
795 if (sock->listenBacklog <= 0) {
796 FILLP_UINT32 localUniqueIdBk = pcb->localUniqueId;
797 FILLP_LOGINF("fillp_sock_id:%d listen backLog is not available, backLog = %d",
798 sock->index, sock->listenBacklog);
799 /*
800 We are not using 3rd parmeter , so removed to fix leval 4
801 warning(warning:formal parameter not used)
802 */
803 pcb->localUniqueId = confirm->cookieContent.localMessageSeqNumber;
804 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
805 pcb->localUniqueId = localUniqueIdBk;
806 return;
807 }
808 FillpProcessConnConfirm(pcb, p, confirm, conn, inst);
809 }
810
FillpHandleConnConfirmAckInput(struct FtSocket * sock,struct FtNetconn * conn,struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)811 void FillpHandleConnConfirmAckInput(struct FtSocket *sock, struct FtNetconn *conn, struct FillpPcb *pcb,
812 FILLP_CONST struct NetBuf *p)
813 {
814 /* Check the connection max rate, it should not be configured to more
815 than the core max rate */
816 if (sock->resConf.flowControl.maxRate > g_resource.flowControl.maxRate) {
817 sock->resConf.flowControl.maxRate = g_resource.flowControl.maxRate;
818 }
819
820 if (sock->resConf.flowControl.maxRecvRate > g_resource.flowControl.maxRecvRate) {
821 sock->resConf.flowControl.maxRecvRate = g_resource.flowControl.maxRecvRate;
822 }
823
824 FILLP_LOGINF("FillpConnConfirmAckInput: fillp_sock_id:%d client connection "
825 "established, time = %lld, local seq num = %u, local pkt num = %u, peer seq num = %u, "
826 "peer pkt num = %u, maxRate:%u, maxRecvRate:%u",
827 sock->index, SYS_ARCH_GET_CUR_TIME_LONGLONG(), pcb->send.seqNum, pcb->send.pktNum, pcb->recv.seqNum,
828 pcb->recv.pktNum, sock->resConf.flowControl.maxRate, sock->resConf.flowControl.maxRecvRate);
829
830 FillpNetconnSetState(conn, CONN_STATE_CONNECTED);
831 FILLP_SOCK_SET_ERR(sock, ERR_OK);
832 FillpNetconnSetSafeErr(sock->netconn, ERR_OK);
833 SpungeConnConnectSuccess(conn->sock);
834 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_OK;
835
836 FILLP_UNUSED_PARA(p);
837
838 pcb->connTimestamp = SYS_ARCH_GET_CUR_TIME_LONGLONG();
839 }
840
FillpCheckConfirmAckInfoIsValid(struct FillpPcb * pcb,struct FtSocket * sock,struct FillpPktConnConfirmAck * confirmAck)841 static FILLP_BOOL FillpCheckConfirmAckInfoIsValid(struct FillpPcb *pcb, struct FtSocket *sock,
842 struct FillpPktConnConfirmAck *confirmAck)
843 {
844 FILLP_UINT32 serverSendCache;
845 FILLP_UINT32 serverRecvCache;
846
847 if ((confirmAck->pktSize == 0) || (confirmAck->pktSize > (FILLP_MAX_PKT_SIZE - FILLP_HLEN))) {
848 FILLP_LOGINF("fillp_sock_id:%d pktSize value is not correct, pktSize = %u "
849 "conn->pcb->sock->g_resource.flowControl.pktSize = %u",
850 sock->index, confirmAck->pktSize, sock->resConf.flowControl.pktSize);
851 return FILLP_FALSE;
852 }
853
854 if (confirmAck->sendCache == 0) {
855 FILLP_LOGINF("fillp_sock_id:%d sendCache value is not correct, sendCache = %u",
856 sock->index, confirmAck->sendCache);
857 return FILLP_FALSE;
858 }
859
860 if (confirmAck->recvCache == 0) {
861 FILLP_LOGINF("fillp_sock_id:%d recvCache value is not correct, recvCache = %u",
862 sock->index, confirmAck->recvCache);
863 return FILLP_FALSE;
864 }
865
866 serverSendCache = confirmAck->sendCache;
867 serverRecvCache = confirmAck->recvCache;
868
869 if ((serverSendCache > pcb->mpRecvSize) || (serverRecvCache > pcb->mpSendSize)) {
870 FILLP_LOGINF("FillpConnConfirmAckInput: fillp_sock_id:%d Connection response send cache or receive "
871 "cache is more than what client requested sendCache : %u receive_cache:%u \r\n",
872 sock->index, serverSendCache, serverRecvCache);
873 return FILLP_FALSE;
874 }
875
876 /* FILLP_SIZE_T is added to remove the linux compile warning */
877 pcb->pktSize = (FILLP_SIZE_T)confirmAck->pktSize;
878
879 pcb->recv.pktRecvCache = (FILLP_UINT32)(serverSendCache * pcb->pktSize);
880 pcb->send.pktSendCache = (FILLP_UINT32)(serverRecvCache * pcb->pktSize);
881
882 if (((pcb->recv.pktRecvCache / pcb->pktSize) != serverSendCache) ||
883 ((pcb->send.pktSendCache / pcb->pktSize) != serverRecvCache)) {
884 FILLP_LOGINF("send/recvCache out of range pcb->send.pktSendCache:%u,recvCache:%u", pcb->send.pktSendCache,
885 pcb->recv.pktRecvCache);
886 return FILLP_FALSE;
887 }
888 return FILLP_TRUE;
889 }
890
FillpConnConnectionEstFailure(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)891 void FillpConnConnectionEstFailure(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
892 {
893 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
894 struct FtSocket *sock = FILLP_NULL_PTR;
895 if (conn == FILLP_NULL_PTR) {
896 FILLP_LOGERR("conn is NULL");
897 return;
898 }
899
900 sock = (struct FtSocket *)conn->sock;
901 if (sock == FILLP_NULL_PTR) {
902 FILLP_LOGERR("sock is null");
903 return;
904 }
905
906 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
907
908 FillpNetconnSetState(conn, CONN_STATE_IDLE);
909 SET_ERRNO(FILLP_ENOMEM);
910 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_SYSTEM_MEMORY_FAILURE;
911 if (SOCK_IS_NONBLOCKING(sock)) {
912 FILLP_SOCK_SET_ERR(sock, FILLP_ENOMEM);
913 FillpNetconnSetSafeErr(conn, ERR_NORES);
914 } else {
915 FillpNetconnSetSafeErr(conn, ERR_NORES);
916 }
917
918 SpungeConnConnectFail(conn->sock);
919 }
920
FillpCheckandcopyConfirmAckAddr(struct FillpPcb * fpcb,FILLP_CONST struct FillpPktConnConfirmAck * confirmAck)921 static void FillpCheckandcopyConfirmAckAddr(struct FillpPcb *fpcb,
922 FILLP_CONST struct FillpPktConnConfirmAck *confirmAck)
923 {
924 struct SpungePcb *spcb = (struct SpungePcb*)fpcb->spcb;
925 struct FtSocket *sock = FILLP_GET_SOCKET(fpcb);
926 struct sockaddr_in6 matchAddr;
927 FILLP_BOOL match;
928
929 (void)memset_s(&matchAddr, sizeof(matchAddr), 0, sizeof(matchAddr));
930 matchAddr.sin6_family = sock->sockAddrType;
931 /* check whether confirmAck->remoteAddr is 0 or not */
932 match = UtilsAddrMatch((FILLP_CONST struct sockaddr_in *)&matchAddr,
933 (FILLP_CONST struct sockaddr_in *)&confirmAck->remoteAddr);
934 if (match == FILLP_TRUE) {
935 FILLP_LOGERR("fillp_sock_id:%d invalidity remoteAddr 0", sock->index);
936 return;
937 }
938
939 if (sock->sockAddrType == AF_INET) {
940 FILLP_CONST struct sockaddr_in *ipv4Addr = (FILLP_CONST struct sockaddr_in *)&confirmAck->remoteAddr;
941 FILLP_CONST struct sockaddr_in *bind4Addr = (FILLP_CONST struct sockaddr_in *)&spcb->localAddr;
942
943 /* socket bound, but remoteAddr is not equal to the bind addr */
944 if ((sock->isSockBind == FILLP_TRUE) &&
945 ((bind4Addr->sin_addr.s_addr != ipv4Addr->sin_addr.s_addr) || ((bind4Addr->sin_port != 0) &&
946 (bind4Addr->sin_port != ipv4Addr->sin_port)))) { /* when call bind, sin_port can be set to 0 */
947 FILLP_LOGERR("fillp_sock_id:%d invalidity remoteAddr != bind addr", sock->index);
948 return;
949 }
950 } else if (sock->sockAddrType == AF_INET6) {
951 FILLP_CONST struct sockaddr_in6 *ipv6Addr = (FILLP_CONST struct sockaddr_in6 *)&confirmAck->remoteAddr;
952 FILLP_CONST struct sockaddr_in6 *bind6Addr = (FILLP_CONST struct sockaddr_in6 *)&spcb->localAddr;
953
954 /* socket bound, but remoteAddr is not equal to the bind addr */
955 if ((sock->isSockBind == FILLP_TRUE) &&
956 (((FILLP_BOOL)UtilsIpv6AddrMatch(ipv6Addr, bind6Addr)) == FILLP_FALSE || ((bind6Addr->sin6_port != 0) &&
957 (bind6Addr->sin6_port != ipv6Addr->sin6_port)))) { /* when call bind, sin6_port can be set to 0 */
958 FILLP_LOGERR("fillp_sock_id:%d invalidity remoteAddr != bind addr", sock->index);
959 return;
960 }
961 } else {
962 FILLP_LOGERR("fillp_sock_id:%d invalidity sa_family", sock->index);
963 return;
964 }
965
966 (void)memcpy_s(&spcb->localAddr, sizeof(struct sockaddr_in6), &confirmAck->remoteAddr,
967 sizeof(struct sockaddr_in6));
968 }
969
FillpCheckConfirmAckPar(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)970 static FILLP_BOOL FillpCheckConfirmAckPar(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
971 {
972 if (pcb == FILLP_NULL_PTR) {
973 FILLP_LOGWAR("fillp pcb pointer is NULL \r\n");
974 return FILLP_FALSE;
975 }
976 if (p == FILLP_NULL_PTR) {
977 FILLP_LOGWAR("net buf pointer is NULL \r\n");
978 return FILLP_FALSE;
979 }
980 if (p->len < (FILLP_INT)(sizeof(struct FillpPktConnConfirmAck) - FILLP_HLEN)) {
981 FILLP_LOGINF("Invalid confirm ack, len = %d", p->len);
982 return FILLP_FALSE;
983 }
984 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
985 if (conn == FILLP_NULL_PTR) {
986 FILLP_LOGERR("conn is NULL");
987 return FILLP_FALSE;
988 }
989 struct FtSocket *sock = (struct FtSocket *)conn->sock;
990 if (sock == FILLP_NULL_PTR) {
991 FILLP_LOGERR("sock is null");
992 return FILLP_FALSE;
993 }
994 FILLP_LOGINF("confirm ack input fillp_sock_id:%d, source port:%u, remote port:%u", sock->index,
995 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&p->addr));
996 return FILLP_TRUE;
997 }
998
FillpConnConfirmAckTrace(struct FtSocket * sock,struct FillpPktConnConfirmAck * confirmAck)999 static void FillpConnConfirmAckTrace(struct FtSocket *sock, struct FillpPktConnConfirmAck *confirmAck)
1000 {
1001 FillpTraceDescriptSt fillpTrcDesc;
1002 if (sock->traceFlag < FILLP_TRACE_DIRECT_NETWORK) {
1003 return;
1004 }
1005 struct FillpPktConnConfirmAck tmpConnConfirmAck;
1006 (void)memset_s(&tmpConnConfirmAck, sizeof(struct FillpPktConnConfirmAck), 0,
1007 sizeof(struct FillpPktConnConfirmAck));
1008
1009 struct FillpPktHead *pktHdr = (struct FillpPktHead *)confirmAck->head;
1010 struct FillpPktHead *tmpHeader = (struct FillpPktHead *)(void *)tmpConnConfirmAck.head;
1011
1012 /* Recovert the header to NETWORK byte order to provide indication */
1013 tmpHeader->flag = FILLP_HTONS(pktHdr->flag);
1014 tmpHeader->dataLen = FILLP_HTONS(pktHdr->dataLen);
1015 tmpHeader->pktNum = FILLP_HTONL(pktHdr->pktNum);
1016 tmpHeader->seqNum = FILLP_HTONL(pktHdr->seqNum);
1017
1018 /* Below field is already in NETWORK byte order */
1019 tmpConnConfirmAck.sendCache = confirmAck->sendCache;
1020 tmpConnConfirmAck.recvCache = confirmAck->recvCache;
1021 tmpConnConfirmAck.pktSize = confirmAck->pktSize;
1022
1023 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1024 sizeof(struct FillpPktConnConfirmAck), sock->index, fillpTrcDesc,
1025 (FILLP_CHAR *)(&tmpConnConfirmAck));
1026 }
1027
FillpSaveConfirmActToPcb(struct FillpPktConnConfirmAck * confirmAck,struct FillpPcb * pcb)1028 static void FillpSaveConfirmActToPcb(struct FillpPktConnConfirmAck *confirmAck, struct FillpPcb *pcb)
1029 {
1030 struct FillpPktHead *tmpHeader = (struct FillpPktHead *)(void *)confirmAck->head;
1031 pcb->peerUniqueId = tmpHeader->seqNum;
1032 pcb->recv.prePackPktNum = tmpHeader->pktNum;
1033 pcb->recv.pktNum = tmpHeader->pktNum;
1034 pcb->recv.seqNum = tmpHeader->seqNum;
1035 pcb->recv.pktStartNum = tmpHeader->pktNum;
1036 pcb->recv.seqStartNum = tmpHeader->seqNum;
1037 pcb->recv.endSeqNum = pcb->recv.seqStartNum;
1038 pcb->statistics.pack.packPktNum = pcb->recv.pktNum;
1039 pcb->statistics.appFcStastics.pktNum = pcb->recv.pktNum;
1040 }
1041
FillpConnConfirmAckInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)1042 void FillpConnConfirmAckInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
1043 {
1044 if (FillpCheckConfirmAckPar(pcb, p) == FILLP_FALSE) {
1045 return;
1046 }
1047 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1048 struct FillpPktConnConfirmAck *confirmAck = (struct FillpPktConnConfirmAck *)(void *)p->p;
1049 struct FtSocket *sock = (struct FtSocket *)conn->sock;
1050 FillpConnConfirmAckTrace(sock, confirmAck);
1051 FILLP_CONN_CONFIRM_ACK_LOG(sock->index, confirmAck, FILLP_DIRECTION_RX);
1052 FILLP_UINT8 connState = FILLP_GET_CONN_STATE(pcb);
1053 if (connState != CONN_STATE_CONNECTING) {
1054 FILLP_LOGINF("fillp_sock_id:%d Connection state response is not correct, state = %u", sock->index, connState);
1055 return;
1056 }
1057 confirmAck->sendCache = FILLP_NTOHL(confirmAck->sendCache);
1058 confirmAck->recvCache = FILLP_NTOHL(confirmAck->recvCache);
1059 confirmAck->pktSize = FILLP_NTOHL(confirmAck->pktSize);
1060
1061 if (FillpCheckConfirmAckInfoIsValid(pcb, sock, confirmAck) == FILLP_FALSE) {
1062 return;
1063 }
1064 sock->resConf.flowControl.pktSize = (FILLP_UINT16)confirmAck->pktSize;
1065 FillpCheckandcopyConfirmAckAddr(pcb, confirmAck);
1066 if (FillpInitPcb(pcb, (FILLP_INT)(confirmAck->recvCache), (FILLP_INT)(confirmAck->sendCache)) != ERR_OK) {
1067 FILLP_LOGERR("fillp_sock_id:%d Failed to init the fillp PCB, releasing the connection", sock->index);
1068 FillpDisableConnRetryCheckTimer(&conn->pcb->fpcb);
1069 FillpConnConnectionEstFailure(pcb, p);
1070 return;
1071 }
1072 (void)SYS_ARCH_ATOMIC_SET(&sock->sendEventCount, (FILLP_INT)pcb->send.curItemCount);
1073 FillpDisableConnRetryCheckTimer(&conn->pcb->fpcb);
1074 FillpSaveConfirmActToPcb(confirmAck, pcb);
1075 struct SockOsSocket *osSock = NETCONN_GET_OSSOCK(sock->netconn, sock->inst->instIndex);
1076 if (!OS_SOCK_OPS_FUNC_VALID(osSock, connected)) {
1077 FILLP_LOGERR("osSock is null");
1078 FillpConnConnectionEstFailure(pcb, p);
1079 return;
1080 }
1081 osSock->ioSock->ops->connected(sock, osSock->ioSock);
1082 FillpHandleConnConfirmAckInput(sock, conn, pcb, p);
1083 conn->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRMACK_RCVED;
1084 FILLP_LOGDBG("FillpConnConfirmAckInput: fillp_sock_id:%d, initial_send_rate = %u", FILLP_GET_SOCKET(pcb)->index,
1085 pcb->send.flowControl.sendRate);
1086 }
1087
ConnectingHandleFinInput(struct FillpPcb * pcb,struct FtSocket * sock,struct FtNetconn * conn,FILLP_CONST struct NetBuf * p,FILLP_CONST struct FillpFinFlags * flags)1088 static void ConnectingHandleFinInput(struct FillpPcb *pcb, struct FtSocket *sock,
1089 struct FtNetconn *conn, FILLP_CONST struct NetBuf *p, FILLP_CONST struct FillpFinFlags *flags)
1090 {
1091 /* If this socket is not accepted then no event need to given to application as listen socket
1092 IN event is already gives and current socket is accepted by application. No need to change state also.
1093 This socket will be released after keep alive timeout after accept.
1094 We just drop FIN message wait for retranmission in connected state and then handle */
1095 if (sock->isListenSock) {
1096 return;
1097 }
1098
1099 if (!flags->ackSet) { // Only non-ack needs to reply, or it may cause flooding
1100 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
1101 }
1102
1103 FillpDisableConnRetryCheckTimer(&conn->pcb->fpcb);
1104
1105 if (flags->verSet) {
1106 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_REMOTE_REJECT_VERSION;
1107 } else {
1108 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_REMOTE_REJECT_OR_CLOSE;
1109 }
1110
1111 FillpNetconnSetState(conn, CONN_STATE_IDLE);
1112 SpungeConnConnectFail(conn->sock);
1113 }
1114
FillpStateClosingHandleFinInput(struct FillpPcb * pcb,struct FtNetconn * conn,FILLP_BOOL isAck,FILLP_BOOL isWr,FILLP_BOOL * pcbFreed)1115 static void FillpStateClosingHandleFinInput(struct FillpPcb *pcb, struct FtNetconn *conn,
1116 FILLP_BOOL isAck, FILLP_BOOL isWr, FILLP_BOOL *pcbFreed)
1117 {
1118 if (isAck) {
1119 pcb->isFinAckReceived = FILLP_TRUE;
1120 }
1121
1122 if (isWr || conn->peerWrSet || (isAck && conn->shutdownRdSet && conn->shutdownWrSet)) {
1123 // If not recved fin before, then there should be one IN event
1124 struct FtSocket *sock = (struct FtSocket *)conn->sock;
1125 FILLP_INT epEvt = (conn->peerWrSet ? 0 : (SPUNGE_EPOLLIN | SPUNGE_EPOLLRDHUP));
1126 conn->peerWrSet = FILLP_TRUE;
1127 SpungeShutdownSock(conn->sock, SPUNGE_SHUT_RDWR);
1128
1129 epEvt = (FILLP_INT)((FILLP_UINT32)epEvt | (SPUNGE_EPOLLHUP | SPUNGE_EPOLLOUT));
1130 sock->errEvent |= SPUNGE_EPOLLHUP;
1131 SpungeEpollEventCallback(sock, epEvt, 1);
1132
1133 *pcbFreed = FILLP_TRUE;
1134 SpungeConnClosed(conn);
1135 }
1136 }
1137
ConnectedHandleFinInput(struct FtSocket * sock,struct FtNetconn * conn,FILLP_BOOL isWr)1138 static void ConnectedHandleFinInput(struct FtSocket *sock, struct FtNetconn *conn, FILLP_BOOL isWr)
1139 {
1140 if (isWr && !conn->peerWrSet) {
1141 conn->peerWrSet = FILLP_TRUE;
1142 SpungeShutdownSock(sock, SPUNGE_SHUT_RD);
1143 sock->errEvent |= SPUNGE_EPOLLRDHUP;
1144 SpungeEpollEventCallback(sock, ((FILLP_INT)SPUNGE_EPOLLIN | (FILLP_INT)SPUNGE_EPOLLRDHUP), 1);
1145 }
1146 }
1147
FillpFinInputTrace(FILLP_CONST struct FtSocket * sock,FILLP_CONST struct NetBuf * p)1148 static void FillpFinInputTrace(FILLP_CONST struct FtSocket *sock, FILLP_CONST struct NetBuf *p)
1149 {
1150 struct FillpPktFin *req = FILLP_NULL_PTR;
1151 struct FillpPktFin tmpFinPkt;
1152 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1153 struct FillpPktHead *tmpHead = FILLP_NULL_PTR;
1154 FILLP_UINT16 flag;
1155 FillpTraceDescriptSt fillpTrcDesc;
1156
1157 (void)memset_s(&tmpFinPkt, sizeof(struct FillpPktFin), 0, sizeof(struct FillpPktFin));
1158 if (sock->traceFlag >= FILLP_TRACE_DIRECT_NETWORK) {
1159 req = (struct FillpPktFin *)(void *)p->p;
1160 pktHdr = (struct FillpPktHead *)(void *)req->head;
1161 tmpHead = (struct FillpPktHead *)(void *)tmpFinPkt.head;
1162 flag = tmpHead->flag;
1163 /* Recovert the header to NETWORK byte order to provide indication */
1164 tmpHead->flag = FILLP_HTONS(flag);
1165 tmpHead->dataLen = FILLP_HTONS(pktHdr->dataLen);
1166 tmpHead->pktNum = FILLP_HTONL(pktHdr->pktNum);
1167 tmpHead->seqNum = FILLP_HTONL(pktHdr->seqNum);
1168
1169 /* Below field is already in NETWORK byte order */
1170 tmpFinPkt.flag = req->flag;
1171
1172 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1173 sizeof(struct FillpPktFin), sock->index, fillpTrcDesc, (FILLP_CHAR *)(&tmpFinPkt));
1174 }
1175 }
1176
FillpHandleFinFlagGet(FILLP_CONST struct NetBuf * p,struct FillpFinFlags * flags)1177 static FILLP_INT FillpHandleFinFlagGet(FILLP_CONST struct NetBuf *p, struct FillpFinFlags *flags)
1178 {
1179 struct FillpPktFin *fin = (struct FillpPktFin *)(void *)p->p;
1180 fin->flag = FILLP_HTONS(fin->flag);
1181
1182 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_ACK(fin->flag)) {
1183 flags->ackSet = FILLP_TRUE;
1184 }
1185
1186 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_RD(fin->flag)) {
1187 flags->rdSet = FILLP_TRUE;
1188 }
1189
1190 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_WR(fin->flag)) {
1191 flags->wrSet = FILLP_TRUE;
1192 }
1193
1194 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_VER(fin->flag)) {
1195 flags->verSet = FILLP_TRUE;
1196 }
1197
1198 if (!flags->wrSet && !flags->ackSet) {
1199 FILLP_LOGWAR("Invalid fin flag!!!fin ack:%u,peer_rd:%u,peer_wr:%u,ver:%u",
1200 flags->ackSet, flags->rdSet, flags->wrSet, flags->verSet);
1201 return ERR_FAILURE;
1202 }
1203
1204 FILLP_LOGINF("fin ack:%u,peer_rd:%u,peer_wr:%u,ver:%u", flags->ackSet, flags->rdSet, flags->wrSet, flags->verSet);
1205 return ERR_OK;
1206 }
1207
FillpHandleFinRst(struct FtNetconn * conn,struct FtSocket * sock)1208 static void FillpHandleFinRst(struct FtNetconn *conn, struct FtSocket *sock)
1209 {
1210 // If not recved fin before, then there should be one IN event
1211 FILLP_INT epEvt = conn->peerWrSet ? 0 : (SPUNGE_EPOLLIN | SPUNGE_EPOLLRDHUP);
1212 conn->peerRdSet = conn->peerWrSet = FILLP_TRUE;
1213 SpungeShutdownSock(conn->sock, SPUNGE_SHUT_RDWR);
1214
1215 epEvt = (FILLP_INT)((FILLP_UINT32)epEvt | (SPUNGE_EPOLLHUP | SPUNGE_EPOLLOUT));
1216 sock->errEvent |= (FILLP_UINT32)SPUNGE_EPOLLHUP;
1217 SpungeEpollEventCallback(sock, epEvt, 1);
1218
1219 SpungeConnClosed(conn);
1220 }
1221
FillpHandleFin(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,FILLP_BOOL * pcbFreed)1222 static void FillpHandleFin(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p, FILLP_BOOL *pcbFreed)
1223 {
1224 struct FtNetconn *conn = FILLP_NULL_PTR;
1225 struct FtSocket *sock = FILLP_NULL_PTR;
1226 struct FillpFinFlags flags = {0};
1227 int netconnState = 0;
1228
1229 conn = FILLP_GET_CONN(pcb);
1230 netconnState = NETCONN_GET_STATE(conn);
1231 sock = (struct FtSocket *)conn->sock;
1232
1233
1234 if (FillpHandleFinFlagGet(p, &flags) != ERR_OK) {
1235 return;
1236 }
1237
1238 /* Now we received disconn message
1239 1) if we has send disconn message before, this one may be the ack, then we need to cancel timer
1240 2) if wr set, means peer won't send data anymore
1241 then we need to set the read shutdown, when the application read all the data of stack, we will rise HUP event
1242 and recv() returns 0
1243 3) if rdwr set, means it is reset message, then need to set rdwr shutdown, application will get HUP event, and
1244 send() return 0 and netconn state goto CLOSED
1245 */
1246 switch (netconnState) {
1247 /* If state is not connected or closing, it handle depends on different state */
1248 case CONN_STATE_LISTENING:
1249 if (!flags.ackSet) { // Only non-ack needs to reply, or it may cause flooding
1250 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
1251 }
1252 return;
1253
1254 case CONN_STATE_CONNECTING:
1255 ConnectingHandleFinInput(pcb, sock, conn, p, &flags);
1256 return;
1257
1258 case CONN_STATE_CLOSED:
1259 /* If this is ack, means no need to response anymore, because that means peer already
1260 know you are shutdown */
1261 if (!flags.ackSet) {
1262 FillpSendFinAck(pcb, (struct sockaddr *)&p->addr);
1263 }
1264 break;
1265
1266 case CONN_STATE_CLOSING:
1267 case CONN_STATE_CONNECTED:
1268 /* If this is ack, means no need to response anymore, because that means peer already
1269 know you are shutdown */
1270 if (!flags.ackSet) {
1271 FillpSendFinAck(pcb, (struct sockaddr *)&p->addr);
1272 }
1273
1274 if (flags.rdSet) {
1275 conn->peerRdSet = FILLP_TRUE;
1276 }
1277
1278 /* RST case */
1279 FillpDfxSockLinkAndQosNotify(sock, FILLP_DFX_LINK_FIN_INPUT);
1280 if (flags.wrSet && flags.rdSet) {
1281 FillpHandleFinRst(conn, sock);
1282 return;
1283 }
1284
1285 if (netconnState == CONN_STATE_CLOSING) {
1286 FillpStateClosingHandleFinInput(pcb, conn, flags.ackSet, flags.wrSet, pcbFreed);
1287 } else if (netconnState == CONN_STATE_CONNECTED) {
1288 ConnectedHandleFinInput(sock, conn, flags.wrSet);
1289 }
1290
1291 break;
1292
1293 default:
1294 FILLP_LOGINF("State err, fillp_sock_id:%d, state:%d", sock->index, netconnState);
1295 break;
1296 }
1297 }
1298
FillpFinInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,FILLP_BOOL * pcbFreed)1299 void FillpFinInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p, FILLP_BOOL *pcbFreed)
1300 {
1301 struct FillpPktHead *fillpHead = FILLP_NULL_PTR;
1302 struct FillpPktFin *fin = FILLP_NULL_PTR;
1303 struct FtNetconn *conn = FILLP_NULL_PTR;
1304 struct FtSocket *sock = FILLP_NULL_PTR;
1305
1306 conn = FILLP_GET_CONN(pcb);
1307 sock = (struct FtSocket *)conn->sock;
1308
1309 if (p->len < (FILLP_INT)(sizeof(struct FillpPktFin) - FILLP_HLEN)) {
1310 FILLP_LOGINF("Fin packet size invalid fillp_sock_id:%d,pkt_len:%d,expected length:%zu", sock->index, p->len,
1311 (sizeof(struct FillpPktFin) - FILLP_HLEN));
1312 return;
1313 }
1314
1315 FILLP_CONN_FIN_LOG(sock->index, (struct FillpPktFin *)(void *)p->p, FILLP_DIRECTION_RX);
1316
1317 if (sock->isListenSock) {
1318 return;
1319 }
1320
1321 FillpFinInputTrace(sock, p);
1322
1323 /* Header fields are already converted in FillpDoInput, and hence here
1324 should not be converted again
1325 */
1326 fin = (struct FillpPktFin *)(void *)p->p;
1327 fillpHead = (struct FillpPktHead *)fin->head;
1328
1329 if (fillpHead->seqNum != pcb->peerUniqueId) {
1330 FILLP_LOGWAR("FillpFinInput: fillp_sock_id:%d Stale fin received peerUniqueId = %u,"
1331 "fin->head.seqNum %u\r\n", sock->index, pcb->peerUniqueId, fillpHead->seqNum);
1332 return;
1333 }
1334
1335 FillpHandleFin(pcb, p, pcbFreed);
1336 }
1337
FillpSendConnReqBuild(struct FillpPcb * pcb,struct FillpPktConnReq * req,FILLP_LLONG curTime)1338 static void FillpSendConnReqBuild(struct FillpPcb *pcb, struct FillpPktConnReq *req, FILLP_LLONG curTime)
1339 {
1340 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1341
1342 req->sendCache = FILLP_HTONL(pcb->mpSendSize);
1343 req->recvCache = FILLP_HTONL(pcb->mpRecvSize);
1344
1345 req->cookiePreserveTime = FILLP_HTONL(pcb->clientCookiePreserveTime);
1346 req->timestamp = FILLP_HTONLL((FILLP_ULLONG)curTime);
1347
1348 pktHdr = (struct FillpPktHead *)req->head;
1349
1350 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1351 pcb->send.pktNum = pcb->send.pktStartNum;
1352 pcb->send.ackSeqNum = pcb->send.seqStartNum;
1353 pcb->send.maxAckNumFromReceiver = pcb->send.ackSeqNum;
1354 pcb->send.seqNum = pcb->send.seqStartNum;
1355
1356 pcb->localUniqueId = pcb->send.seqStartNum;
1357
1358 pktHdr->pktNum = pcb->send.pktStartNum;
1359 pktHdr->seqNum = pcb->send.seqStartNum;
1360
1361 pktHdr->flag = FILLP_NULL_NUM;
1362 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_REQ);
1363 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, FILLP_PROTOCOL_VERSION_NUMBER);
1364 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1365
1366 pktHdr->dataLen = (sizeof(struct FillpPktConnReq) - FILLP_HLEN);
1367 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1368
1369 pktHdr->pktNum = FILLP_HTONL(pktHdr->pktNum);
1370 pktHdr->seqNum = FILLP_HTONL(pktHdr->seqNum);
1371
1372 FILLP_CONN_REQ_LOG(FILLP_GET_SOCKET(pcb)->index, req, FILLP_DIRECTION_RX);
1373 }
1374
FillpSendConnReq(struct FillpPcb * pcb)1375 FILLP_INT FillpSendConnReq(struct FillpPcb *pcb)
1376 {
1377 struct FillpPktConnReq req;
1378 FILLP_LLONG curTime;
1379 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1380 struct FtSocket *sock = (struct FtSocket *)conn->sock;
1381 FillpTraceDescriptSt fillpTrcDesc;
1382 FILLP_INT ret;
1383 FILLP_INT osErrno;
1384
1385 if (sock == FILLP_NULL_PTR) {
1386 FILLP_LOGERR("sock is NULL");
1387 return -1;
1388 }
1389
1390 /* If already received the confirmAck then no need to send the conn_req again after timeout */
1391 if (conn->clientFourHandshakeState == FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRMACK_RCVED) {
1392 FILLP_LOGINF("already received confirmAck");
1393 return ERR_NON_FATAL;
1394 }
1395
1396 curTime = SYS_ARCH_GET_CUR_TIME_LONGLONG();
1397 FillpSendConnReqBuild(pcb, &req, curTime);
1398 FILLP_LOGINF("fillp_sock_id:%d,send req, "
1399 "sendCache:%u,recvCache:%u,timestamp:%lld,startSeqNum:%u,startPktNum:%u,source port:%u,dest port:%u",
1400 sock->index, pcb->mpSendSize, pcb->mpRecvSize, curTime, pcb->send.seqStartNum,
1401 pcb->send.pktStartNum, UTILS_GET_ADDRPORT(&conn->pcb->localAddr),
1402 UTILS_GET_ADDRPORT(&conn->pcb->remoteAddr));
1403 ret = pcb->sendFunc(conn, (char *)&req, sizeof(struct FillpPktConnReq), conn->pcb);
1404 if (ret <= 0) {
1405 osErrno = FT_OS_GET_ERRNO;
1406 pcb->statistics.debugPcb.connReqFailed++;
1407
1408 if ((osErrno == FILLP_EWOULDBLOCK) || (osErrno == FILLP_EINPROGRESS)) {
1409 return ERR_NON_FATAL;
1410 }
1411 FILLP_LOGINF("send connreq fail");
1412 return ret;
1413 } else {
1414 fillpTrcDesc.traceDirection = FILLP_TRACE_DIRECT_SEND;
1415
1416 FILLP_LM_FILLPMSGTRACE_OUTPUT(sock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1417 sizeof(struct FillpPktConnReq), sock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1418 (FILLP_CHAR *)(&req));
1419
1420 if ((conn->clientFourHandshakeState != FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRMACK_RCVED) &&
1421 (conn->clientFourHandshakeState != FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRM_SENT)) {
1422 conn->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_REQSENT;
1423 }
1424
1425 pcb->statistics.debugPcb.connReqSend++;
1426 }
1427
1428 return ret;
1429 }
1430
FillpSendConnReqAckBuild(FILLP_CONST struct FillpPcb * pcb,FILLP_CONST FillpCookieContent * stateCookie,FILLP_ULLONG timestamp)1431 static FILLP_UINT16 FillpSendConnReqAckBuild(FILLP_CONST struct FillpPcb *pcb,
1432 FILLP_CONST FillpCookieContent *stateCookie, FILLP_ULLONG timestamp)
1433 {
1434 FILLP_INT ret;
1435 FILLP_UINT32 localCharacters = (FILLP_UINT32)FILLP_DEFAULT_SUPPORT_CHARACTERS;
1436 FILLP_UINT8 localAlg = (FILLP_UINT8)FILLP_SUPPORT_ALGS;
1437 FILLP_UINT16 dataLen = 0;
1438 struct FillpPktConnReqAck *reqAck = FILLP_NULL_PTR;
1439 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1440 reqAck = (struct FillpPktConnReqAck *)g_rawMsg;
1441 pktHdr = (struct FillpPktHead *)reqAck->head;
1442
1443 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1444 pktHdr->pktNum = 0;
1445 pktHdr->seqNum = FILLP_HTONL(stateCookie->localMessageSeqNumber);
1446
1447 pktHdr->flag = FILLP_NULL_NUM;
1448 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_REQ_ACK);
1449 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, FILLP_PROTOCOL_VERSION_NUMBER);
1450
1451 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1452 reqAck->timestamp = FILLP_HTONLL(timestamp);
1453 reqAck->tagCookie = FILLP_COOKIE_TAG;
1454 reqAck->tagCookie = FILLP_HTONS(reqAck->tagCookie);
1455 reqAck->cookieLength = sizeof(FillpCookieContent);
1456
1457 ret = memcpy_s(&reqAck->cookieContent, sizeof(FillpCookieContent), stateCookie, reqAck->cookieLength);
1458 if (ret != EOK) {
1459 FILLP_LOGERR("fillp_send_conn_reqAck memcpy_s cookieContent failed: %d", ret);
1460 return 0;
1461 }
1462
1463 reqAck->cookieLength = FILLP_HTONS(reqAck->cookieLength);
1464 dataLen = sizeof(struct FillpPktConnReqAck);
1465 ret = FillpEncodeExtPara(g_rawMsg + dataLen, (FILLP_INT32)(FILLP_FRAME_MTU - dataLen),
1466 FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG, (FILLP_UCHAR)(sizeof(FILLP_UINT8)), (FILLP_UCHAR *)&localAlg);
1467 if (ret <= 0) {
1468 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1469 * functionality */
1470 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG failed");
1471 } else {
1472 dataLen += (FILLP_UINT16)ret;
1473 }
1474
1475 localCharacters = FILLP_HTONL(localCharacters);
1476 ret = FillpEncodeExtPara(g_rawMsg + dataLen, (FILLP_INT32)(FILLP_FRAME_MTU - dataLen),
1477 FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER, (FILLP_UCHAR)(sizeof(FILLP_UINT32)), (FILLP_UCHAR *)&localCharacters);
1478 if (ret <= 0) {
1479 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1480 * functionality */
1481 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER failed");
1482 } else {
1483 dataLen += (FILLP_UINT16)ret;
1484 }
1485
1486 pktHdr->dataLen = FILLP_HTONS(dataLen - (FILLP_UINT16)FILLP_HLEN);
1487
1488 FILLP_CONN_REQ_ACK_TX_LOG(FILLP_GET_SOCKET(pcb)->index, reqAck, g_rawMsg + sizeof(struct FillpPktConnReqAck),
1489 dataLen - sizeof(struct FillpPktConnReqAck));
1490 return dataLen;
1491 }
1492
FillpSendConnReqAck(struct FillpPcb * pcb,FILLP_CONST FillpCookieContent * stateCookie,FILLP_ULLONG timestamp)1493 void FillpSendConnReqAck(struct FillpPcb *pcb, FILLP_CONST FillpCookieContent *stateCookie,
1494 FILLP_ULLONG timestamp)
1495 {
1496 struct FillpPktConnReqAck *reqAck = (struct FillpPktConnReqAck *)g_rawMsg;
1497 struct FtNetconn *conn = FILLP_NULL_PTR;
1498 struct FtSocket *sock = FILLP_NULL_PTR;
1499 FILLP_INT ret;
1500 FILLP_UINT16 dataLen;
1501 struct SpungePcb *tempPcb = FILLP_NULL_PTR;
1502
1503 if (pcb == FILLP_NULL_PTR) {
1504 FILLP_LOGERR("FillpSendConnReq: PCB pointer is NULL");
1505 return;
1506 }
1507
1508 tempPcb = &SPUNGE_GET_CUR_INSTANCE()->tempSpcb;
1509 (void)memset_s(tempPcb, sizeof(struct SpungePcb), 0, sizeof(struct SpungePcb));
1510
1511 conn = FILLP_GET_CONN(pcb);
1512 sock = (struct FtSocket *)conn->sock;
1513
1514 dataLen = FillpSendConnReqAckBuild(pcb, stateCookie, timestamp);
1515 if (dataLen == 0) {
1516 return;
1517 }
1518
1519 if (AF_INET == stateCookie->addressType) {
1520 *((struct sockaddr_in *)&tempPcb->remoteAddr) = *((struct sockaddr_in *)&stateCookie->remoteSockIpv6Addr);
1521 tempPcb->addrType = AF_INET;
1522 tempPcb->addrLen = sizeof(struct sockaddr_in);
1523 } else {
1524 tempPcb->remoteAddr = *(struct sockaddr_in6 *)&stateCookie->remoteSockIpv6Addr;
1525 tempPcb->addrType = AF_INET6;
1526 tempPcb->addrLen = sizeof(struct sockaddr_in6);
1527 }
1528
1529 ret = pcb->sendFunc(conn, (char *)g_rawMsg, (FILLP_INT)dataLen, tempPcb);
1530 if (ret <= 0) {
1531 pcb->statistics.debugPcb.connReqAckFailed++;
1532 FILLP_LOGINF("Send fail");
1533 } else {
1534 FillpTraceDescriptSt fillpTrcDesc = FILLP_TRACE_DESC_INIT(FILLP_TRACE_DIRECT_SEND);
1535
1536 FILLP_LM_FILLPMSGTRACE_OUTPUT(sock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1537 sizeof(struct FillpPktConnReqAck), sock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1538 (FILLP_CHAR *)reqAck);
1539
1540 pcb->statistics.debugPcb.connReqAckSend++;
1541 }
1542
1543 FILLP_LOGINF("send conn_reqAck fillp_sock_id:%d,destport:%u", sock->index,
1544 UTILS_GET_ADDRPORT(&tempPcb->remoteAddr));
1545 }
1546
ConnConfirmBuild(struct FillpPcb * pcb,FILLP_CONST struct FillpConnReqAckClient * reqAck,struct FillpPktHead * pktHdr)1547 static FILLP_INT32 ConnConfirmBuild(struct FillpPcb *pcb, FILLP_CONST struct FillpConnReqAckClient *reqAck,
1548 struct FillpPktHead *pktHdr)
1549 {
1550 FILLP_INT32 encMsgLen = 0;
1551 FILLP_INT ret;
1552 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1553 pktHdr->pktNum = 0;
1554 pktHdr->seqNum = 0;
1555 pktHdr->flag = 0;
1556 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_CONFIRM);
1557 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, (FILLP_UINT16)FILLP_PROTOCOL_VERSION_NUMBER);
1558 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1559
1560 encMsgLen = FILLP_HLEN;
1561 *((FILLP_UINT16 *)(g_rawMsg + encMsgLen)) = FILLP_HTONS(reqAck->tagCookie);
1562 encMsgLen += sizeof(FILLP_UINT16);
1563 *((FILLP_UINT16 *)(g_rawMsg + encMsgLen)) = FILLP_HTONS(reqAck->cookieLength);
1564 encMsgLen += sizeof(FILLP_UINT16);
1565 if (reqAck->cookieLength != sizeof(FillpCookieContent) || reqAck->cookieContent == FILLP_NULL_PTR) {
1566 FILLP_LOGERR("fillp_send_conn_confirm reqAck->cookieLength is wrong:%u, expect : %zu",
1567 reqAck->cookieLength, sizeof(FillpCookieContent));
1568 return 0;
1569 }
1570 ret = memcpy_s(g_rawMsg + encMsgLen, (FILLP_UINT32)(FILLP_FRAME_MTU - encMsgLen),
1571 reqAck->cookieContent, reqAck->cookieLength);
1572 if (ret != EOK) {
1573 FILLP_LOGERR("fillp_send_conn_confirm memcpy_s cookieContent failed:%d", ret);
1574 return 0;
1575 }
1576 encMsgLen += reqAck->cookieLength;
1577
1578 /* NOTE: This parameter needs to be encoded as old server will use struct FillpPktConnConfirm-> remoteAddr
1579 address. */
1580 {
1581 struct SpungePcb*spcb = (struct SpungePcb*)pcb->spcb;
1582 ret = memcpy_s(g_rawMsg + encMsgLen, (FILLP_UINT32)((FILLP_INT)sizeof(g_rawMsg) - encMsgLen),
1583 &spcb->remoteAddr, sizeof(spcb->remoteAddr));
1584 if (ret != EOK) {
1585 FILLP_LOGERR("fillp_send_conn_confirm memcpy_s remoteAddr failed:%d", ret);
1586 return 0;
1587 }
1588 encMsgLen += sizeof(spcb->remoteAddr);
1589 }
1590 return encMsgLen;
1591 }
1592
ConnConfirmEncodeExtPara(const struct FillpPcb * pcb,FILLP_INT32 encMsgLen)1593 static FILLP_INT32 ConnConfirmEncodeExtPara(const struct FillpPcb *pcb, FILLP_INT32 encMsgLen)
1594 {
1595 FILLP_INT ret;
1596 FILLP_ULLONG tempRtt;
1597 FILLP_UINT32 tempValue32;
1598
1599 tempRtt = FILLP_HTONLL(pcb->rtt);
1600 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1601 FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_RTT, (FILLP_UCHAR)(sizeof(FILLP_ULLONG)), (FILLP_UCHAR *)&tempRtt);
1602 if (ret <= 0) {
1603 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1604 * functionality */
1605 FILLP_LOGWAR("encode extension parameter failed");
1606 } else {
1607 encMsgLen += ret;
1608 }
1609
1610 tempValue32 = (FILLP_UINT32)pcb->pktSize;
1611 tempValue32 = FILLP_HTONL(tempValue32);
1612 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1613 FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE, (FILLP_UCHAR)(sizeof(FILLP_UINT32)),
1614 (FILLP_UCHAR *)&(tempValue32));
1615 if (ret <= 0) {
1616 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1617 * functionality */
1618 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE failed");
1619 } else {
1620 encMsgLen += ret;
1621 }
1622
1623 FILLP_LOGERR("fcAlg %u", pcb->fcAlg);
1624 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1625 FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG, (FILLP_UCHAR)(sizeof(FILLP_UINT8)), (FILLP_UCHAR *)&(pcb->fcAlg));
1626 if (ret <= 0) {
1627 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1628 * functionality */
1629 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG failed");
1630 } else {
1631 encMsgLen += ret;
1632 }
1633
1634 tempValue32 = FILLP_HTONL(pcb->characters);
1635 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1636 FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER, (FILLP_UCHAR)(sizeof(FILLP_UINT32)), (FILLP_UCHAR *)&tempValue32);
1637 if (ret <= 0) {
1638 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1639 * functionality */
1640 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER failed");
1641 } else {
1642 encMsgLen += ret;
1643 }
1644 return encMsgLen;
1645 }
1646
FillpSendConnConfirm(struct FillpPcb * pcb,FILLP_CONST struct FillpConnReqAckClient * reqAck)1647 void FillpSendConnConfirm(struct FillpPcb *pcb, FILLP_CONST struct FillpConnReqAckClient *reqAck)
1648 {
1649 FILLP_INT32 encMsgLen = 0;
1650 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1651 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1652 FILLP_INT ret;
1653 struct FtSocket *ftSock = (struct FtSocket *)conn->sock;
1654 FillpTraceDescriptSt fillpTrcDesc = FILLP_TRACE_DESC_INIT(FILLP_TRACE_DIRECT_SEND);
1655
1656 if (ftSock == FILLP_NULL_PTR) {
1657 return;
1658 }
1659
1660 (void)memset_s(g_rawMsg, FILLP_FRAME_MTU, 0, FILLP_FRAME_MTU);
1661 pktHdr = (struct FillpPktHead *)(void *)g_rawMsg;
1662 encMsgLen = ConnConfirmBuild(pcb, reqAck, pktHdr);
1663 if (encMsgLen == 0) {
1664 return;
1665 }
1666
1667 FILLP_INT extParaOffset = encMsgLen;
1668 encMsgLen = ConnConfirmEncodeExtPara(pcb, encMsgLen);
1669 /* To send the FILLP_CONNECT_CONFIRM_CARRY_RTT */
1670 pktHdr->dataLen = (FILLP_UINT16)(encMsgLen - FILLP_HLEN);
1671 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1672
1673 FILLP_CONN_CONFIRM_TX_LOG(ftSock->index, g_rawMsg, encMsgLen, extParaOffset);
1674
1675 ret = pcb->sendFunc(conn, (FILLP_CHAR *)g_rawMsg, encMsgLen, conn->pcb);
1676 if (ret <= 0) {
1677 pcb->statistics.debugPcb.connConfirmFailed++;
1678 FILLP_LOGINF("send fail fillp_sock_id:%d", ftSock->index);
1679 } else {
1680 FILLP_LM_FILLPMSGTRACE_OUTPUT(ftSock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, ftSock->traceHandle,
1681 (FILLP_UINT32)encMsgLen, ftSock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1682 (FILLP_CHAR *)g_rawMsg);
1683
1684 pcb->statistics.debugPcb.connConfirmSend++;
1685
1686 conn->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRM_SENT;
1687 }
1688
1689 FILLP_LOGINF("Send conn confirm fillp_sock_id:%d, source port:%u, dest port:%u", ftSock->index,
1690 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&conn->pcb->remoteAddr));
1691 }
1692
1693
FillpSendConnConfirmAck(struct FillpPcb * pcb)1694 void FillpSendConnConfirmAck(struct FillpPcb *pcb)
1695 {
1696 struct FillpPktConnConfirmAck confirmAck;
1697 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1698 FILLP_INT ret;
1699 FillpTraceDescriptSt fillpTrcDesc;
1700
1701 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1702 struct FtSocket *ftSock = (struct FtSocket *)conn->sock;
1703
1704 if (ftSock == FILLP_NULL_PTR) {
1705 FILLP_LOGERR("ftSock is NULL");
1706 return;
1707 }
1708
1709 FILLP_LOGINF("Send conn confirm ack fillp_sock_id:%d, source port:%u, remote port:%u", ftSock->index,
1710 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&conn->pcb->remoteAddr));
1711
1712 confirmAck.sendCache = FILLP_HTONL(pcb->mpSendSize);
1713 confirmAck.recvCache = FILLP_HTONL(pcb->mpRecvSize);
1714
1715 confirmAck.pktSize = FILLP_HTONL((FILLP_UINT32)pcb->pktSize);
1716
1717 pktHdr = (struct FillpPktHead *)confirmAck.head;
1718
1719 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1720 pktHdr->pktNum = FILLP_HTONL(pcb->send.pktStartNum);
1721 pktHdr->seqNum = FILLP_HTONL(pcb->send.seqStartNum);
1722
1723 pktHdr->flag = 0;
1724 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_CONFIRM_ACK);
1725 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, (FILLP_UINT16)FILLP_PROTOCOL_VERSION_NUMBER);
1726 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1727
1728 pktHdr->dataLen = (sizeof(struct FillpPktConnConfirmAck) - FILLP_HLEN);
1729 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1730 (void)memcpy_s(&confirmAck.remoteAddr, sizeof(confirmAck.remoteAddr), &conn->pcb->remoteAddr,
1731 sizeof(conn->pcb->remoteAddr));
1732
1733 FILLP_CONN_CONFIRM_ACK_LOG(ftSock->index, &confirmAck, FILLP_DIRECTION_TX);
1734
1735 ret = pcb->sendFunc(FILLP_GET_CONN(pcb), (char *)&confirmAck, sizeof(struct FillpPktConnConfirmAck), conn->pcb);
1736 if (ret <= 0) {
1737 pcb->statistics.debugPcb.connConfirmAckFailed++;
1738 FILLP_LOGINF("send fail fillp_sock_id:%d", ftSock->index);
1739 } else {
1740 fillpTrcDesc.traceDirection = FILLP_TRACE_DIRECT_SEND;
1741
1742 FILLP_LM_FILLPMSGTRACE_OUTPUT(ftSock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, ftSock->traceHandle,
1743 sizeof(struct FillpPktConnConfirmAck), ftSock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1744 (FILLP_CHAR *)(&confirmAck));
1745
1746 pcb->statistics.debugPcb.connConfirmAckSend++;
1747 pcb->connTimestamp = SYS_ARCH_GET_CUR_TIME_LONGLONG();
1748 }
1749 }
1750
FillpSendFinBuild(FILLP_CONST struct FillpPcb * pcb,struct FillpPktFin * req,FILLP_CONST struct FillpFinFlags * flags)1751 static void FillpSendFinBuild(FILLP_CONST struct FillpPcb *pcb, struct FillpPktFin *req,
1752 FILLP_CONST struct FillpFinFlags *flags)
1753 {
1754 struct FillpPktHead *pktHdr = (struct FillpPktHead *)req->head;
1755
1756 pktHdr->seqNum = FILLP_HTONL(pcb->localUniqueId);
1757 pktHdr->pktNum = FILLP_HTONL(pcb->send.pktNum);
1758
1759 pktHdr->flag = FILLP_NULL_NUM;
1760 req->flag = FILLP_NULL_NUM;
1761 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_FIN);
1762 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, FILLP_PROTOCOL_VERSION_NUMBER);
1763 if (flags->wrSet) {
1764 FILLP_PKT_DISCONN_MSG_FLAG_SET_WR(req->flag);
1765 }
1766 if (flags->rdSet) {
1767 FILLP_PKT_DISCONN_MSG_FLAG_SET_RD(req->flag);
1768 }
1769 if (flags->ackSet) {
1770 FILLP_PKT_DISCONN_MSG_FLAG_SET_ACK(req->flag);
1771 }
1772 if (flags->verSet) {
1773 FILLP_PKT_DISCONN_MSG_FLAG_SET_VER(req->flag);
1774 }
1775
1776 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1777 req->flag = FILLP_HTONS(req->flag);
1778
1779 pktHdr->dataLen = (sizeof(struct FillpPktFin) - FILLP_HLEN);
1780 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1781 }
1782
FillpSendFinInnerImpl(struct FillpPcb * pcb,FILLP_CONST struct FillpFinFlags * flags,struct sockaddr * remoteAddr)1783 static void FillpSendFinInnerImpl(struct FillpPcb *pcb, FILLP_CONST struct FillpFinFlags *flags,
1784 struct sockaddr *remoteAddr)
1785 {
1786 struct FillpPktFin req;
1787 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1788 struct SpungePcb *remotePcb = FILLP_NULL_PTR;
1789 FILLP_INT ret;
1790 FillpTraceDescriptSt fillpTrcDesc;
1791
1792 FILLP_LOGINF("wrSet:%u,rdSet:%u,ackSet:%u,verSet:%u", flags->wrSet, flags->rdSet, flags->ackSet, flags->verSet);
1793
1794 if (conn == FILLP_NULL_PTR) {
1795 FILLP_LOGERR("conn is NULL");
1796 return;
1797 }
1798
1799 FillpSendFinBuild(pcb, &req, flags);
1800 remotePcb = &SPUNGE_GET_CUR_INSTANCE()->tempSpcb;
1801 UtilsAddrCopy((struct sockaddr *)&remotePcb->remoteAddr, (struct sockaddr *)remoteAddr);
1802
1803 if (((struct SpungePcb *)(pcb->spcb))->addrLen) {
1804 remotePcb->addrLen = ((struct SpungePcb *)(pcb->spcb))->addrLen;
1805 remotePcb->addrType = ((struct SpungePcb *)(pcb->spcb))->addrType;
1806 } else {
1807 if (remoteAddr->sa_family == AF_INET) {
1808 remotePcb->addrLen = sizeof(struct sockaddr_in);
1809 remotePcb->addrType = AF_INET;
1810 } else {
1811 remotePcb->addrLen = sizeof(struct sockaddr_in6);
1812 remotePcb->addrType = AF_INET6;
1813 }
1814 }
1815
1816 FILLP_CONN_FIN_LOG(FILLP_GET_SOCKET(pcb)->index, &req, FILLP_DIRECTION_TX);
1817
1818 ret = pcb->sendFunc(conn, (char *)&req, sizeof(struct FillpPktFin), remotePcb);
1819 if (ret <= 0) {
1820 pcb->statistics.debugPcb.disconnReqFailed++;
1821 } else {
1822 struct FtSocket *ftSock;
1823
1824 ftSock = (struct FtSocket *)conn->sock;
1825 fillpTrcDesc.traceDirection = FILLP_TRACE_DIRECT_SEND;
1826
1827 if (ftSock != FILLP_NULL_PTR) {
1828 FILLP_LM_FILLPMSGTRACE_OUTPUT(ftSock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, ftSock->traceHandle,
1829 sizeof(struct FillpPktFin), ftSock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc, (FILLP_CHAR *)(&req));
1830 }
1831
1832 pcb->statistics.debugPcb.disconnReqSend++;
1833 }
1834 }
1835
FillpSendFinInner(struct FillpPcb * pcb,FILLP_BOOL wrSet,FILLP_BOOL rdSet,FILLP_BOOL ackSet,struct sockaddr * remoteAddr)1836 static void FillpSendFinInner(struct FillpPcb *pcb, FILLP_BOOL wrSet, FILLP_BOOL rdSet, FILLP_BOOL ackSet,
1837 struct sockaddr *remoteAddr)
1838 {
1839 struct FillpFinFlags flags = {0};
1840 flags.wrSet = wrSet;
1841 flags.rdSet = rdSet;
1842 flags.ackSet = ackSet;
1843 flags.verSet = FILLP_FALSE;
1844
1845 FillpSendFinInnerImpl(pcb, &flags, remoteAddr);
1846 }
1847
FillpSendRstWithVersionImcompatible(struct FillpPcb * pcb,struct sockaddr * remoteAddr)1848 void FillpSendRstWithVersionImcompatible(struct FillpPcb *pcb, struct sockaddr *remoteAddr)
1849 {
1850 struct FillpFinFlags flags = {0};
1851 flags.wrSet = FILLP_TRUE;
1852 flags.rdSet = FILLP_TRUE;
1853 flags.ackSet = FILLP_TRUE;
1854 flags.verSet = FILLP_TRUE;
1855
1856 FillpSendFinInnerImpl(pcb, &flags, remoteAddr);
1857 }
1858
FillpSendFin(struct FillpPcb * pcb)1859 void FillpSendFin(struct FillpPcb *pcb)
1860 {
1861 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1862 FILLP_BOOL wrSet = FILLP_FALSE;
1863 FILLP_BOOL rdSet = FILLP_FALSE;
1864 FILLP_BOOL ackSet = FILLP_FALSE;
1865
1866 if (conn->shutdownWrSet && conn->sendBufRunOut) {
1867 wrSet = FILLP_TRUE;
1868 }
1869 if (conn->shutdownRdSet) {
1870 rdSet = FILLP_TRUE;
1871 }
1872
1873 FillpSendFinInner(pcb, wrSet, rdSet, ackSet,
1874 (struct sockaddr *)(&((struct SpungePcb*)(pcb->spcb))->remoteAddr));
1875 }
1876
FillpSendFinAck(struct FillpPcb * pcb,struct sockaddr * remoteAddr)1877 void FillpSendFinAck(struct FillpPcb *pcb, struct sockaddr *remoteAddr)
1878 {
1879 FillpSendFinInner(pcb, FILLP_FALSE, FILLP_FALSE, FILLP_TRUE, remoteAddr);
1880 }
1881
FillpSendRst(struct FillpPcb * pcb,struct sockaddr * remoteAddr)1882 void FillpSendRst(struct FillpPcb *pcb, struct sockaddr *remoteAddr)
1883 {
1884 FillpSendFinInner(pcb, FILLP_TRUE, FILLP_TRUE, FILLP_TRUE, remoteAddr);
1885 }
1886
1887
1888 /* This function Generates the cookieContent for fillp on receiving Connection request from peer. */
FillpGenerateCookie(IN FILLP_CONST struct FillpPcb * pcb,IN struct FillpPktConnReq * req,IN FILLP_CONST struct sockaddr_in6 * remoteAddr,IN FILLP_UINT16 serverPort,OUT FillpCookieContent * stateCookie)1889 void FillpGenerateCookie(IN FILLP_CONST struct FillpPcb *pcb, IN struct FillpPktConnReq *req,
1890 IN FILLP_CONST struct sockaddr_in6 *remoteAddr, IN FILLP_UINT16 serverPort, OUT FillpCookieContent *stateCookie)
1891 {
1892 struct FillpPktHead *pktHdr = (struct FillpPktHead *)req->head;
1893 struct SpungePcb*spcb = (struct SpungePcb*)pcb->spcb;
1894 struct sockaddr *localAddr = (struct sockaddr *)(void *)(&spcb->localAddr);
1895 FillpHmacSha256 ctx;
1896 FillpCookieContentCalculate cookieCal;
1897 void *cookieDataPtr = FILLP_NULL_PTR;
1898
1899 (void)memset_s(&cookieCal, sizeof(cookieCal), 0, sizeof(cookieCal));
1900 (void)memcpy_s(stateCookie->digest, FILLP_KEYSIZE, pcb->pcbInst->macInfo.currentMacKey, FILLP_KEYSIZE);
1901 FILLP_CONST struct sockaddr *addr = (struct sockaddr *)(void *)remoteAddr;
1902 FillpErrorType err = memcpy_s(&stateCookie->remoteSockIpv6Addr, sizeof(stateCookie->remoteSockIpv6Addr), remoteAddr,
1903 ((addr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)));
1904 if (err != EOK) {
1905 FILLP_LOGERR("fillp_generate_cookie memcpy_s remote %u failed:%d", addr->sa_family, err);
1906 return;
1907 }
1908 stateCookie->remoteRecvCache = req->recvCache;
1909 stateCookie->remoteSendCache = req->sendCache;
1910 FILLP_LLONG *cookieTime = (FILLP_LLONG *)(void *)(stateCookie->arr);
1911 *cookieTime = (FILLP_LLONG)SYS_ARCH_GET_CUR_TIME_LONGLONG();
1912 stateCookie->localMessageSeqNumber = FILLP_CRYPTO_RAND();
1913 stateCookie->localPacketSeqNumber = FILLP_CRYPTO_RAND();
1914 stateCookie->remoteMessageSeqNumber = pktHdr->seqNum;
1915 stateCookie->remotePacketSeqNumber = pktHdr->pktNum;
1916 stateCookie->addressType = addr->sa_family;
1917 stateCookie->srcPort = serverPort;
1918 if (req->cookiePreserveTime <= FILLP_MAX_COOKIE_LIFETIME) {
1919 stateCookie->lifeTime = FILLP_INITIAL_COOKIE_LIFETIME + req->cookiePreserveTime;
1920 } else {
1921 stateCookie->lifeTime = FILLP_INITIAL_COOKIE_LIFETIME;
1922 }
1923 if (memcpy_s(&cookieCal, sizeof(cookieCal), stateCookie, sizeof(FillpCookieContent)) != EOK) {
1924 return;
1925 }
1926 err = memcpy_s(&cookieCal.localSockIpv6Addr, sizeof(cookieCal.localSockIpv6Addr),
1927 &((struct SpungePcb*)(pcb->spcb))->localAddr,
1928 ((localAddr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)));
1929 if (err != EOK) {
1930 FILLP_LOGERR("fillp_generate_cookie memcpy_s local %u failed:%d", localAddr->sa_family, err);
1931 return;
1932 }
1933 FillpHmacSha256Init(&ctx, pcb->pcbInst->macInfo.currentMacKey, FILLP_KEYSIZE, pcb->pcbInst);
1934 cookieDataPtr = (void *)((uintptr_t)(&cookieCal) + FILLP_KEYSIZE);
1935 FillpHmacSha256Update(&ctx, cookieDataPtr, (sizeof(FillpCookieContentCalculate) - FILLP_KEYSIZE));
1936 FillpHmacSha256Final(&ctx, stateCookie->digest, FILLP_KEYSIZE);
1937 }
1938
FillpValidateCookieHmac(FILLP_CONST struct FillpPcb * pcb,FILLP_CONST FillpCookieContent * stateCookie)1939 static FILLP_INT FillpValidateCookieHmac(FILLP_CONST struct FillpPcb *pcb, FILLP_CONST FillpCookieContent *stateCookie)
1940 {
1941 FILLP_UINT32 count = 0;
1942 FILLP_UINT8 key[FILLP_KEYSIZE];
1943 FILLP_UINT8 outDigest[FILLP_KEYSIZE] = {0};
1944 FillpHmacSha256 ctx;
1945 FillpCookieContentCalculate cookieCal;
1946 struct SpungePcb *spcb = (struct SpungePcb*)pcb->spcb;
1947 struct sockaddr *localAddr = (struct sockaddr *)(void *)(&spcb->localAddr);
1948 void *cookieDataPtr = FILLP_NULL_PTR;
1949 FILLP_ULLONG *cookieTime = FILLP_NULL_PTR;
1950
1951 (void)memset_s(&cookieCal, sizeof(cookieCal), 0, sizeof(cookieCal));
1952 FillpErrorType err = memcpy_s(&cookieCal, sizeof(cookieCal), stateCookie, sizeof(FillpCookieContent));
1953 if (err != EOK) {
1954 FILLP_LOGERR("fillp_validate_cookie memcpy_s cookieCal failed : %d", err);
1955 return err;
1956 }
1957
1958 err = memcpy_s(&cookieCal.localSockIpv6Addr, sizeof(cookieCal.localSockIpv6Addr),
1959 &((struct SpungePcb*)(pcb->spcb))->localAddr,
1960 ((localAddr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)));
1961 if (err != EOK) {
1962 FILLP_LOGERR("fillp_validate_cookie memcpy_s %u failed : %d", localAddr->sa_family, err);
1963 return err;
1964 }
1965
1966 cookieTime = (FILLP_ULLONG *)(void *)stateCookie->arr;
1967 if (pcb->pcbInst->macInfo.switchOverTime < *cookieTime) {
1968 for (count = 0; count < FILLP_KEYSIZE; count++) {
1969 key[count] = pcb->pcbInst->macInfo.currentMacKey[count];
1970 }
1971 } else {
1972 for (count = 0; count < FILLP_KEYSIZE; count++) {
1973 key[count] = pcb->pcbInst->macInfo.oldMacKey[count];
1974 }
1975 }
1976
1977 FillpHmacSha256Init(&ctx, key, FILLP_KEYSIZE, pcb->pcbInst);
1978 cookieDataPtr = (void *)((uintptr_t)(&cookieCal) + FILLP_KEYSIZE);
1979 FillpHmacSha256Update(&ctx, cookieDataPtr,
1980 (sizeof(FillpCookieContentCalculate) - FILLP_KEYSIZE));
1981 FillpHmacSha256Final(&ctx, outDigest, FILLP_KEYSIZE);
1982
1983 for (count = 0; count < FILLP_KEYSIZE; count++) {
1984 if (stateCookie->digest[count] != outDigest[count]) {
1985 FILLP_LOGINF("fillp_sock_id:%d HMAC-SHA2 digest mismatched. SaveDigest:%d NewDigest:%d",
1986 FILLP_GET_SOCKET(pcb)->index, stateCookie->digest[count], outDigest[count]);
1987 return ERR_HMAC_SHA2_DIGEST_MISMATCH;
1988 }
1989 }
1990
1991 return ERR_OK;
1992 }
1993
1994 /* This function validates the cookieContent from peer. */
FillpValidateCookie(IN FILLP_CONST struct FillpPcb * pcb,IN FILLP_UINT16 serverPort,IN FILLP_CONST struct sockaddr_in6 * clientAddr,IN FILLP_CONST FillpCookieContent * stateCookie)1995 FILLP_INT FillpValidateCookie(IN FILLP_CONST struct FillpPcb *pcb, IN FILLP_UINT16 serverPort,
1996 IN FILLP_CONST struct sockaddr_in6 *clientAddr, IN FILLP_CONST FillpCookieContent *stateCookie)
1997 {
1998 FILLP_LLONG timeDiffVal;
1999 FILLP_LLONG curTime;
2000 FILLP_INT ret;
2001 FILLP_ULLONG *cookieTime = FILLP_NULL_PTR;
2002
2003 ret = FillpValidateCookieHmac(pcb, stateCookie);
2004 if (ret != ERR_OK) {
2005 return ret;
2006 }
2007
2008 if (stateCookie->srcPort != serverPort) {
2009 FILLP_LOGINF("fillp_sock_id:%d FillP cookieContent Server Port mismatch. "
2010 "cookieContent Generated server port:%u Msg Server Port:%u \r\n",
2011 FILLP_GET_SOCKET(pcb)->index, stateCookie->srcPort, serverPort);
2012 return ERR_COOKIE_PORT_MISMATCH;
2013 }
2014
2015 /* no need to explicitly validate the server IP again here, since it is already
2016 validated in hash when receive the UDP packet
2017 Validate the source port and IP of the client against the port and IP
2018 of the client stored in the cookie content, if mismatches, then discard the
2019 connection confirm message silently */
2020 if (UtilsAddrMatch((FILLP_CONST struct sockaddr_in *)&stateCookie->remoteSockIpv6Addr,
2021 (FILLP_CONST struct sockaddr_in *)clientAddr) == FILLP_FALSE) {
2022 FILLP_LOGINF("fillp_sock_id:%d Client address mismatch between cookie"
2023 " and message client",
2024 FILLP_GET_SOCKET(pcb)->index);
2025 return ERR_COOKIE_PORT_MISMATCH;
2026 }
2027
2028 curTime = (FILLP_LLONG)SYS_ARCH_GET_CUR_TIME_LONGLONG();
2029 cookieTime = (FILLP_ULLONG *)(void *)stateCookie->arr;
2030 timeDiffVal = (FILLP_LLONG)((FILLP_ULLONG)curTime - (*cookieTime));
2031
2032 if (timeDiffVal < 0) {
2033 FILLP_LOGERR("fillp_sock_id:%d FillP cookieContent is stale due to system time change."
2034 "CookieGenerated time:%llu Current time:%lld Life time of cookie:%u \r\n",
2035 FILLP_GET_SOCKET(pcb)->index, *cookieTime, curTime, stateCookie->lifeTime);
2036 return ERR_STALE_COOKIE_ERROR;
2037 }
2038
2039 if (timeDiffVal > stateCookie->lifeTime) {
2040 FILLP_LOGINF("fillp_sock_id:%d FillP cookieContent is stale. CookieGenerated time:%llu"
2041 "Current time:%lld Life time of cookie:%u \r\n",
2042 FILLP_GET_SOCKET(pcb)->index, *cookieTime, curTime, stateCookie->lifeTime);
2043 return ERR_STALE_COOKIE_ERROR;
2044 }
2045
2046 return FILLP_SUCCESS;
2047 }
2048
2049 #ifdef __cplusplus
2050 }
2051 #endif
2052