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
489 FillpSendConnConfirm(pcb, &reqAck);
490 return;
491 }
492
FillpInitNewPcbByNewConn(struct FtNetconn * newConn,FILLP_SIZE_T maxSendCache,FILLP_SIZE_T maxRecvCache)493 static FILLP_INT FillpInitNewPcbByNewConn(struct FtNetconn *newConn, FILLP_SIZE_T maxSendCache,
494 FILLP_SIZE_T maxRecvCache)
495 {
496 struct FtSocket *sock = (struct FtSocket *)newConn->sock;
497 newConn->pcb->fpcb.pktSize = UTILS_MIN(sock->resConf.flowControl.pktSize, newConn->peerPktSize);
498 if ((newConn->pcb->fpcb.pktSize > (FILLP_MAX_PKT_SIZE - FILLP_HLEN)) || (newConn->pcb->fpcb.pktSize == 0)) {
499 newConn->pcb->fpcb.pktSize = (FILLP_MAX_PKT_SIZE - FILLP_HLEN);
500 }
501
502 newConn->pcb->fpcb.recv.pktRecvCache = (FILLP_UINT32)maxRecvCache * (FILLP_UINT32)newConn->pcb->fpcb.pktSize;
503 newConn->pcb->fpcb.send.pktSendCache = (FILLP_UINT32)maxSendCache * (FILLP_UINT32)newConn->pcb->fpcb.pktSize;
504
505 if (((newConn->pcb->fpcb.recv.pktRecvCache / newConn->pcb->fpcb.pktSize) != maxRecvCache) ||
506 ((newConn->pcb->fpcb.send.pktSendCache / newConn->pcb->fpcb.pktSize) != maxSendCache)) {
507 FILLP_LOGERR("fillp_sock_id:%d Invalid pkt cache size", sock->index);
508 return -1;
509 }
510
511 if (newConn->calcRttDuringConnect) {
512 struct FillpPcb *fpcb = &(newConn->pcb->fpcb);
513 fpcb->rtt = newConn->calcRttDuringConnect;
514 }
515
516 newConn->pcb->fpcb.characters = newConn->peerCharacters & (FILLP_UINT32)FILLP_DEFAULT_SUPPORT_CHARACTERS;
517 newConn->pcb->fpcb.fcAlg = newConn->peerFcAlgs & (FILLP_UINT8)FILLP_SUPPORT_ALGS;
518
519 if (FillpInitPcb(&newConn->pcb->fpcb, (FILLP_INT)maxSendCache, (FILLP_INT)maxRecvCache) != ERR_OK) {
520 FILLP_LOGERR("fillp_sock_id:%d Failed to init fillp pcb", sock->index);
521 return -1;
522 }
523 return 0;
524 }
525
FillpInitNewPcbByConfirm(struct FtNetconn * newConn,FILLP_CONST struct FillpPktConnConfirm * confirm)526 static void FillpInitNewPcbByConfirm(struct FtNetconn *newConn, FILLP_CONST struct FillpPktConnConfirm *confirm)
527 {
528 newConn->pcb->fpcb.send.pktNum = confirm->cookieContent.localPacketSeqNumber;
529 newConn->pcb->fpcb.send.seqNum = confirm->cookieContent.localMessageSeqNumber;
530 newConn->pcb->fpcb.recv.lastPackPktNum = confirm->cookieContent.remotePacketSeqNumber;
531 newConn->pcb->fpcb.recv.lastPackSeqNum = confirm->cookieContent.remoteMessageSeqNumber;
532 newConn->pcb->fpcb.send.pktStartNum = confirm->cookieContent.localPacketSeqNumber;
533 newConn->pcb->fpcb.send.seqStartNum = confirm->cookieContent.localMessageSeqNumber;
534 newConn->pcb->fpcb.send.ackSeqNum = confirm->cookieContent.localMessageSeqNumber;
535 newConn->pcb->fpcb.send.maxAckNumFromReceiver = confirm->cookieContent.localMessageSeqNumber;
536
537 newConn->pcb->fpcb.recv.prePackPktNum = confirm->cookieContent.remotePacketSeqNumber;
538 newConn->pcb->fpcb.recv.pktNum = confirm->cookieContent.remotePacketSeqNumber;
539 newConn->pcb->fpcb.recv.seqNum = confirm->cookieContent.remoteMessageSeqNumber;
540 newConn->pcb->fpcb.recv.pktStartNum = confirm->cookieContent.remotePacketSeqNumber;
541 newConn->pcb->fpcb.recv.seqStartNum = confirm->cookieContent.remoteMessageSeqNumber;
542 newConn->pcb->fpcb.recv.endSeqNum = confirm->cookieContent.remoteMessageSeqNumber;
543 newConn->pcb->fpcb.statistics.pack.packPktNum = confirm->cookieContent.remotePacketSeqNumber;
544 newConn->pcb->fpcb.statistics.appFcStastics.pktNum = confirm->cookieContent.remotePacketSeqNumber;
545
546 newConn->pcb->fpcb.localUniqueId = confirm->cookieContent.localMessageSeqNumber;
547 newConn->pcb->fpcb.peerUniqueId = confirm->cookieContent.remoteMessageSeqNumber;
548 }
549
FillpInitNewconnBySock(struct FtNetconn * conn,FILLP_CONST struct FtSocket * sock)550 void FillpInitNewconnBySock(struct FtNetconn *conn, FILLP_CONST struct FtSocket *sock)
551 {
552 NetconnSetAddrType(conn, sock->sockAddrType);
553 NetconnSetPktSize(conn, sock->resConf.flowControl.pktSize);
554 NetconnSetOpersiteRate(conn, sock->resConf.flowControl.oppositeSetRate);
555 NetconnSetSlowStart(conn, sock->resConf.flowControl.slowStart);
556 NetconnSetPackInterval(conn, sock->resConf.flowControl.packInterval);
557 FILLP_LOGDBG("Set pack interval:%u", sock->resConf.flowControl.packInterval);
558 NetconnSetDirectlySend(conn, sock->directlySend);
559 }
560
FillpInitNewConnByConfirm(struct FillpPcb * pcb,struct FtNetconn * newConn,FILLP_CONST struct FillpPktConnConfirm * confirm,FILLP_CONST struct FtNetconn * conn,FILLP_CONST struct NetBuf * p)561 static FILLP_INT FillpInitNewConnByConfirm(struct FillpPcb *pcb, struct FtNetconn *newConn,
562 FILLP_CONST struct FillpPktConnConfirm *confirm, FILLP_CONST struct FtNetconn *conn, FILLP_CONST struct NetBuf *p)
563 {
564 FILLP_SIZE_T maxSendCache;
565 FILLP_SIZE_T maxRecvCache;
566 struct sockaddr *addr = FILLP_NULL_PTR;
567 FILLP_UINT16 addrLen = 0;
568 struct SpungePcb *spcb = (struct SpungePcb*)pcb->spcb;
569 struct sockaddr *localAddr = (struct sockaddr *)(void *)(&spcb->localAddr);
570 struct FtSocket *sock = (struct FtSocket *)conn->sock;
571
572 maxSendCache = sock->resConf.common.maxServerAllowSendCache;
573 maxRecvCache = sock->resConf.common.maxServerAllowRecvCache;
574
575 maxSendCache = UTILS_MIN(maxSendCache, confirm->cookieContent.remoteRecvCache);
576 maxRecvCache = UTILS_MIN(maxRecvCache, confirm->cookieContent.remoteSendCache);
577
578 NetconnSetRecvCacheSize(newConn, (FILLP_UINT32)maxRecvCache);
579 NetconnSetSendCacheSize(newConn, (FILLP_UINT32)maxSendCache);
580 FillpInitNewconnBySock(newConn, sock);
581 NetconnSetLocalPort(newConn, conn->pcb->localPort); // The same with the server listen port
582
583 /* Scenario: FtAccept() is not done. So NetconnSetSock() is not yet set in
584 SpungeHandleMsgConnAccepted(), hence the variable ftSock is NULL
585 and dumping in FillpDoInput.
586
587 Temporarily the accepted->netconn sock reference is LISTEN socket. It will reference
588 to actual accepted sock in SpungeHandleMsgConnAccepted() when APP
589 calls the FtAccept(). So if the keep alive timer expires before APP calls the FtAccept()
590 then fc_cyle() will run and coredump can happen as the netconn->sock will be NULL
591
592 */
593 newConn->sock = sock; // It is very important to set this , because it is necessary to make netconn has a socket
594 if (FillpInitNewPcbByNewConn(newConn, maxSendCache, maxRecvCache) != 0) {
595 return -1;
596 }
597
598 FillpInitNewPcbByConfirm(newConn, confirm);
599 FillpErrorType err = memcpy_s(&newConn->pcb->localAddr, sizeof(newConn->pcb->localAddr), localAddr,
600 sizeof(spcb->localAddr));
601 if (err != EOK) {
602 FILLP_LOGERR("fillp_init_newConn_by_confirm memcpy_s local ip failed: %d", err);
603 return err;
604 }
605
606 addr = (struct sockaddr *)(void *)&p->addr;
607 NetconnSetAddrType(newConn, addr->sa_family);
608 if (addr->sa_family == AF_INET) {
609 addrLen = sizeof(struct sockaddr_in);
610 } else {
611 addrLen = sizeof(struct sockaddr_in6);
612 }
613
614 err = memcpy_s(&newConn->pcb->remoteAddr, sizeof(newConn->pcb->remoteAddr), addr, addrLen);
615 if (err != EOK) {
616 FILLP_LOGERR("fillp_init_newConn_by_confirm memcpy_s remote ip failed: %d", err);
617 return err;
618 }
619 newConn->pcb->addrLen = addrLen;
620
621 FillpNetconnSetState(newConn, CONN_STATE_CONNECTING);
622
623 return ERR_OK;
624 }
625
FillpInitPeerOfNewconn(struct FtNetconn * newConn,FILLP_UINT32 peerPktSize)626 static inline void FillpInitPeerOfNewconn(struct FtNetconn *newConn, FILLP_UINT32 peerPktSize)
627 {
628 newConn->peerPktSize = peerPktSize;
629 newConn->peerFcAlgs = 0;
630 newConn->peerCharacters = 0;
631 }
632
FillpProcessConnConfirm(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,FILLP_CONST struct FillpPktConnConfirm * confirm,FILLP_CONST struct FtNetconn * conn,struct SpungeInstance * inst)633 static void FillpProcessConnConfirm(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p,
634 FILLP_CONST struct FillpPktConnConfirm *confirm, FILLP_CONST struct FtNetconn *conn,
635 struct SpungeInstance *inst)
636 {
637 struct sockaddr *addr = (struct sockaddr *)(void *)&p->addr;
638 struct FtSocket *sock = (struct FtSocket *)conn->sock;
639
640 if (sock == FILLP_NULL_PTR) {
641 FILLP_LOGERR("sock is null");
642 return;
643 }
644
645 struct FtNetconn *newConn = FillpNetconnAlloc(addr->sa_family, inst);
646 if (newConn == FILLP_NULL_PTR) {
647 FILLP_LOGERR("fillp_sock_id:%d Failed in allocate new netconn connection", sock->index);
648
649 return;
650 }
651
652 /* If client is old version then it will not have FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE
653 parameter, so used current node pkt size */
654 FillpInitPeerOfNewconn(newConn, sock->resConf.flowControl.pktSize);
655
656 /* Decode connection confirm extension parameters */
657 (void)FillpDecodeExtPara((FILLP_UCHAR *)(p->p) + sizeof(struct FillpPktConnConfirm),
658 (FILLP_INT)(p->len - ((FILLP_INT)sizeof(struct FillpPktConnConfirm) - FILLP_HLEN)), newConn);
659
660 if (FillpInitNewConnByConfirm(pcb, newConn, confirm, conn, p) != ERR_OK) {
661 FillpNetconnDestroy(newConn);
662 return;
663 }
664
665 struct SockOsSocket *osSock = NETCONN_GET_OSSOCK(conn, SPUNGE_GET_CUR_INSTANCE()->instIndex);
666 if (!OS_SOCK_OPS_FUNC_VALID(osSock, handlePacket)) {
667 FILLP_LOGERR("os sock ops handlePacket is null");
668 FillpNetconnDestroy(newConn);
669 return;
670 }
671 FillpErrorType err = osSock->ioSock->ops->handlePacket(FILLP_PKT_TYPE_CONN_CONFIRM, (void *)osSock->ioSock,
672 (void *)newConn->pcb, (void *)p);
673
674 /* Here we need to set newConn->osSock, or it will be null pointer, and when do accept, it will be rewrite */
675 newConn->osSocket[SPUNGE_GET_CUR_INSTANCE()->instIndex] = osSock;
676 osSock->reference++;
677 if (err != ERR_OK) {
678 FILLP_LOGERR("sysio connect fail");
679 FillpNetconnDestroy(newConn);
680 return;
681 }
682
683 if (FillpQueuePush(sock->acceptBox, (void *)&newConn, FILLP_TRUE, 1) != ERR_OK) {
684 FILLP_LOGERR("push to accept box fail");
685 FillpNetconnDestroy(newConn);
686 return;
687 }
688
689 if (!(SOCK_IS_NONBLOCKING(sock))) {
690 (void)SYS_ARCH_SEM_POST(&sock->acceptSem);
691 }
692
693 sock->listenBacklog--;
694
695 FILLP_LOGINF("Push conn to accept box fillp_sock_id:%d,sock->listenBacklog:%d", sock->index, sock->listenBacklog);
696
697 SpungeEpollEventCallback(sock, SPUNGE_EPOLLIN, 1);
698 }
699
FillpConnConfirmTrace(struct FtSocket * sock,struct FillpPktConnConfirm * confirm)700 static void FillpConnConfirmTrace(struct FtSocket *sock, struct FillpPktConnConfirm *confirm)
701 {
702 FillpTraceDescriptSt fillpTrcDesc;
703 if (sock->traceFlag < FILLP_TRACE_DIRECT_NETWORK) {
704 return;
705 }
706 struct FillpPktConnConfirm tmpConnConfirm;
707 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
708 struct FillpPktHead *tempHdr = FILLP_NULL_PTR;
709
710 (void)memset_s(&tmpConnConfirm, sizeof(struct FillpPktConnConfirm), 0,
711 sizeof(struct FillpPktConnConfirm));
712
713 pktHdr = (struct FillpPktHead *)confirm->head;
714 tempHdr = (struct FillpPktHead *)tmpConnConfirm.head;
715 /* Recovert the header to NETWORK byte order to provide indication */
716 tempHdr->flag = FILLP_HTONS(pktHdr->flag);
717 tempHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
718 tempHdr->pktNum = FILLP_HTONL(pktHdr->pktNum);
719 tempHdr->seqNum = FILLP_HTONL(pktHdr->seqNum);
720
721 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
722 sizeof(struct FillpPktConnConfirm), sock->index, fillpTrcDesc, (FILLP_CHAR *)(&tmpConnConfirm));
723 }
724
FillpConfirmCheckState(FILLP_UINT8 connState,struct FtSocket * sock,struct FillpPcb * pcb)725 static FILLP_BOOL FillpConfirmCheckState(FILLP_UINT8 connState, struct FtSocket *sock, struct FillpPcb *pcb)
726 {
727 if (connState == CONN_STATE_CONNECTED) {
728 if ((pcb->recv.seqNum == pcb->recv.seqStartNum) && (pcb->send.maxAckNumFromReceiver ==
729 pcb->send.seqStartNum)) { /* Only if no data recved or no data acked */
730 FILLP_LOGDBG("fillp_sock_id:%d Conn confirm in open state "
731 "as data not received, so sending conn confirm ack, state = %u",
732 sock->index, connState);
733
734 FillpSendConnConfirmAck(pcb);
735 } else {
736 FILLP_LOGINF("fillp_sock_id:%d Conn confirm in open state "
737 "so dropping the message,state=%u",
738 sock->index, connState);
739 }
740
741 return FILLP_FALSE;
742 }
743
744 if (connState != CONN_STATE_LISTENING) {
745 FILLP_LOGINF("fillp_sock_id:%d Connection state in not correct, state = %u", sock->index, connState);
746 return FILLP_FALSE;
747 }
748 return FILLP_TRUE;
749 }
750
FillpConnConfirmInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,struct SpungeInstance * inst)751 void FillpConnConfirmInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p, struct SpungeInstance *inst)
752 {
753 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
754 struct FtSocket *sock = (struct FtSocket *)conn->sock;
755 if (sock == FILLP_NULL_PTR) {
756 FILLP_LOGERR("sock is null");
757 return;
758 }
759
760 FILLP_LOGINF("conn confirm input, fillp_sock_id:%d, source port:%u, remote port:%u", sock->index,
761 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&p->addr));
762
763 if (p->len < (FILLP_INT)(sizeof(struct FillpPktConnConfirm) - FILLP_HLEN)) {
764 FILLP_LOGINF("fillp_sock_id:%d Invalid connection confirm,len=%d", sock->index, p->len);
765 return;
766 }
767
768 struct FillpPktConnConfirm *confirm = (struct FillpPktConnConfirm *)(void *)p->p;
769 FillpConnConfirmTrace(sock, confirm);
770 FILLP_CONN_CONFIRM_RX_LOG(sock->index, confirm, (FILLP_UCHAR *)p->p + sizeof(struct FillpPktConnConfirm),
771 (FILLP_INT)(p->len - ((FILLP_INT)sizeof(struct FillpPktConnConfirm) - FILLP_HLEN)));
772
773 FILLP_UINT8 connState = NETCONN_GET_STATE(conn);
774 if (FillpConfirmCheckState(connState, sock, pcb) == FILLP_FALSE) {
775 return;
776 }
777
778 /* Below two parameters are not used at the server side */
779 confirm->cookieLength = FILLP_NTOHS(confirm->cookieLength);
780 confirm->tagCookie = FILLP_NTOHS(confirm->tagCookie);
781
782 if ((confirm->tagCookie != FILLP_COOKIE_TAG) || (confirm->cookieLength != sizeof(FillpCookieContent))) {
783 FILLP_LOGINF("fillp_sock_id:%d, received cookie length = %u,"
784 "actual cookie size = %zu, discarding the packet",
785 sock->index, confirm->cookieLength, sizeof(FillpCookieContent));
786 return;
787 }
788
789 FILLP_INT ret = FillpValidateCookie(pcb, ((struct sockaddr_in *)(&conn->pcb->localAddr))->sin_port, &p->addr,
790 &confirm->cookieContent);
791 if (ret != FILLP_SUCCESS) {
792 FILLP_LOGINF("fillp_sock_id:%d cookieContent validation fails"
793 "state = %u, discarding the packet",
794 sock->index, connState);
795 return;
796 }
797
798 if (sock->listenBacklog <= 0) {
799 FILLP_UINT32 localUniqueIdBk = pcb->localUniqueId;
800 FILLP_LOGINF("fillp_sock_id:%d listen backLog is not available, backLog = %d",
801 sock->index, sock->listenBacklog);
802 /*
803 We are not using 3rd parmeter , so removed to fix leval 4
804 warning(warning:formal parameter not used)
805 */
806 pcb->localUniqueId = confirm->cookieContent.localMessageSeqNumber;
807 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
808 pcb->localUniqueId = localUniqueIdBk;
809 return;
810 }
811 FillpProcessConnConfirm(pcb, p, confirm, conn, inst);
812 return;
813 }
814
FillpHandleConnConfirmAckInput(struct FtSocket * sock,struct FtNetconn * conn,struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)815 void FillpHandleConnConfirmAckInput(struct FtSocket *sock, struct FtNetconn *conn, struct FillpPcb *pcb,
816 FILLP_CONST struct NetBuf *p)
817 {
818 /* Check the connection max rate, it should not be configured to more
819 than the core max rate */
820 if (sock->resConf.flowControl.maxRate > g_resource.flowControl.maxRate) {
821 sock->resConf.flowControl.maxRate = g_resource.flowControl.maxRate;
822 }
823
824 if (sock->resConf.flowControl.maxRecvRate > g_resource.flowControl.maxRecvRate) {
825 sock->resConf.flowControl.maxRecvRate = g_resource.flowControl.maxRecvRate;
826 }
827
828 FILLP_LOGINF("FillpConnConfirmAckInput: fillp_sock_id:%d client connection "
829 "established, time = %lld, local seq num = %u, local pkt num = %u, peer seq num = %u, "
830 "peer pkt num = %u, maxRate:%u, maxRecvRate:%u",
831 sock->index, SYS_ARCH_GET_CUR_TIME_LONGLONG(), pcb->send.seqNum, pcb->send.pktNum, pcb->recv.seqNum,
832 pcb->recv.pktNum, sock->resConf.flowControl.maxRate, sock->resConf.flowControl.maxRecvRate);
833
834 FillpNetconnSetState(conn, CONN_STATE_CONNECTED);
835 FILLP_SOCK_SET_ERR(sock, ERR_OK);
836 FillpNetconnSetSafeErr(sock->netconn, ERR_OK);
837 SpungeConnConnectSuccess(conn->sock);
838 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_OK;
839
840 FILLP_UNUSED_PARA(p);
841
842 pcb->connTimestamp = SYS_ARCH_GET_CUR_TIME_LONGLONG();
843 }
844
FillpCheckConfirmAckInfoIsValid(struct FillpPcb * pcb,struct FtSocket * sock,struct FillpPktConnConfirmAck * confirmAck)845 static FILLP_BOOL FillpCheckConfirmAckInfoIsValid(struct FillpPcb *pcb, struct FtSocket *sock,
846 struct FillpPktConnConfirmAck *confirmAck)
847 {
848 FILLP_UINT32 serverSendCache;
849 FILLP_UINT32 serverRecvCache;
850
851 if ((confirmAck->pktSize == 0) || (confirmAck->pktSize > (FILLP_MAX_PKT_SIZE - FILLP_HLEN))) {
852 FILLP_LOGINF("fillp_sock_id:%d pktSize value is not correct, pktSize = %u "
853 "conn->pcb->sock->g_resource.flowControl.pktSize = %u",
854 sock->index, confirmAck->pktSize, sock->resConf.flowControl.pktSize);
855 return FILLP_FALSE;
856 }
857
858 if (confirmAck->sendCache == 0) {
859 FILLP_LOGINF("fillp_sock_id:%d sendCache value is not correct, sendCache = %u",
860 sock->index, confirmAck->sendCache);
861 return FILLP_FALSE;
862 }
863
864 if (confirmAck->recvCache == 0) {
865 FILLP_LOGINF("fillp_sock_id:%d recvCache value is not correct, recvCache = %u",
866 sock->index, confirmAck->recvCache);
867 return FILLP_FALSE;
868 }
869
870 serverSendCache = confirmAck->sendCache;
871 serverRecvCache = confirmAck->recvCache;
872
873 if ((serverSendCache > pcb->mpRecvSize) || (serverRecvCache > pcb->mpSendSize)) {
874 FILLP_LOGINF("FillpConnConfirmAckInput: fillp_sock_id:%d Connection response send cache or receive "
875 "cache is more than what client requested sendCache : %u receive_cache:%u \r\n",
876 sock->index, serverSendCache, serverRecvCache);
877 return FILLP_FALSE;
878 }
879
880 /* FILLP_SIZE_T is added to remove the linux compile warning */
881 pcb->pktSize = (FILLP_SIZE_T)confirmAck->pktSize;
882
883 pcb->recv.pktRecvCache = (FILLP_UINT32)(serverSendCache * pcb->pktSize);
884 pcb->send.pktSendCache = (FILLP_UINT32)(serverRecvCache * pcb->pktSize);
885
886 if (((pcb->recv.pktRecvCache / pcb->pktSize) != serverSendCache) ||
887 ((pcb->send.pktSendCache / pcb->pktSize) != serverRecvCache)) {
888 FILLP_LOGINF("send/recvCache out of range pcb->send.pktSendCache:%u,recvCache:%u", pcb->send.pktSendCache,
889 pcb->recv.pktRecvCache);
890 return FILLP_FALSE;
891 }
892 return FILLP_TRUE;
893 }
894
FillpConnConnectionEstFailure(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)895 void FillpConnConnectionEstFailure(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
896 {
897 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
898 struct FtSocket *sock = FILLP_NULL_PTR;
899 if (conn == FILLP_NULL_PTR) {
900 FILLP_LOGERR("conn is NULL");
901 return;
902 }
903
904 sock = (struct FtSocket *)conn->sock;
905 if (sock == FILLP_NULL_PTR) {
906 FILLP_LOGERR("sock is null");
907 return;
908 }
909
910 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
911
912 FillpNetconnSetState(conn, CONN_STATE_IDLE);
913 SET_ERRNO(FILLP_ENOMEM);
914 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_SYSTEM_MEMORY_FAILURE;
915 if (SOCK_IS_NONBLOCKING(sock)) {
916 FILLP_SOCK_SET_ERR(sock, FILLP_ENOMEM);
917 FillpNetconnSetSafeErr(conn, ERR_NORES);
918 } else {
919 FillpNetconnSetSafeErr(conn, ERR_NORES);
920 }
921
922 SpungeConnConnectFail(conn->sock);
923 }
924
FillpCheckandcopyConfirmAckAddr(struct FillpPcb * fpcb,FILLP_CONST struct FillpPktConnConfirmAck * confirmAck)925 static void FillpCheckandcopyConfirmAckAddr(struct FillpPcb *fpcb,
926 FILLP_CONST struct FillpPktConnConfirmAck *confirmAck)
927 {
928 struct SpungePcb *spcb = (struct SpungePcb*)fpcb->spcb;
929 struct FtSocket *sock = FILLP_GET_SOCKET(fpcb);
930 struct sockaddr_in6 matchAddr;
931 FILLP_BOOL match;
932
933 (void)memset_s(&matchAddr, sizeof(matchAddr), 0, sizeof(matchAddr));
934 matchAddr.sin6_family = sock->sockAddrType;
935 /* check whether confirmAck->remoteAddr is 0 or not */
936 match = UtilsAddrMatch((FILLP_CONST struct sockaddr_in *)&matchAddr,
937 (FILLP_CONST struct sockaddr_in *)&confirmAck->remoteAddr);
938 if (match == FILLP_TRUE) {
939 FILLP_LOGERR("fillp_sock_id:%d invalidity remoteAddr 0", sock->index);
940 return;
941 }
942
943 if (sock->sockAddrType == AF_INET) {
944 FILLP_CONST struct sockaddr_in *ipv4Addr = (FILLP_CONST struct sockaddr_in *)&confirmAck->remoteAddr;
945 FILLP_CONST struct sockaddr_in *bind4Addr = (FILLP_CONST struct sockaddr_in *)&spcb->localAddr;
946
947 /* socket bound, but remoteAddr is not equal to the bind addr */
948 if ((sock->isSockBind == FILLP_TRUE) &&
949 ((bind4Addr->sin_addr.s_addr != ipv4Addr->sin_addr.s_addr) || ((bind4Addr->sin_port != 0) &&
950 (bind4Addr->sin_port != ipv4Addr->sin_port)))) { /* when call bind, sin_port can be set to 0 */
951 FILLP_LOGERR("fillp_sock_id:%d invalidity remoteAddr != bind addr", sock->index);
952 return;
953 }
954 } else if (sock->sockAddrType == AF_INET6) {
955 FILLP_CONST struct sockaddr_in6 *ipv6Addr = (FILLP_CONST struct sockaddr_in6 *)&confirmAck->remoteAddr;
956 FILLP_CONST struct sockaddr_in6 *bind6Addr = (FILLP_CONST struct sockaddr_in6 *)&spcb->localAddr;
957
958 /* socket bound, but remoteAddr is not equal to the bind addr */
959 if ((sock->isSockBind == FILLP_TRUE) &&
960 (((FILLP_BOOL)UtilsIpv6AddrMatch(ipv6Addr, bind6Addr)) == FILLP_FALSE || ((bind6Addr->sin6_port != 0) &&
961 (bind6Addr->sin6_port != ipv6Addr->sin6_port)))) { /* when call bind, sin6_port can be set to 0 */
962 FILLP_LOGERR("fillp_sock_id:%d invalidity remoteAddr != bind addr", sock->index);
963 return;
964 }
965 } else {
966 FILLP_LOGERR("fillp_sock_id:%d invalidity sa_family", sock->index);
967 return;
968 }
969
970 (void)memcpy_s(&spcb->localAddr, sizeof(struct sockaddr_in6), &confirmAck->remoteAddr,
971 sizeof(struct sockaddr_in6));
972
973 return;
974 }
975
FillpCheckConfirmAckPar(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)976 static FILLP_BOOL FillpCheckConfirmAckPar(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
977 {
978 if (pcb == FILLP_NULL_PTR) {
979 FILLP_LOGWAR("fillp pcb pointer is NULL \r\n");
980 return FILLP_FALSE;
981 }
982 if (p == FILLP_NULL_PTR) {
983 FILLP_LOGWAR("net buf pointer is NULL \r\n");
984 return FILLP_FALSE;
985 }
986 if (p->len < (FILLP_INT)(sizeof(struct FillpPktConnConfirmAck) - FILLP_HLEN)) {
987 FILLP_LOGINF("Invalid confirm ack, len = %d", p->len);
988 return FILLP_FALSE;
989 }
990 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
991 if (conn == FILLP_NULL_PTR) {
992 FILLP_LOGERR("conn is NULL");
993 return FILLP_FALSE;
994 }
995 struct FtSocket *sock = (struct FtSocket *)conn->sock;
996 if (sock == FILLP_NULL_PTR) {
997 FILLP_LOGERR("sock is null");
998 return FILLP_FALSE;
999 }
1000 FILLP_LOGINF("confirm ack input fillp_sock_id:%d, source port:%u, remote port:%u", sock->index,
1001 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&p->addr));
1002 return FILLP_TRUE;
1003 }
1004
FillpConnConfirmAckTrace(struct FtSocket * sock,struct FillpPktConnConfirmAck * confirmAck)1005 static void FillpConnConfirmAckTrace(struct FtSocket *sock, struct FillpPktConnConfirmAck *confirmAck)
1006 {
1007 FillpTraceDescriptSt fillpTrcDesc;
1008 if (sock->traceFlag < FILLP_TRACE_DIRECT_NETWORK) {
1009 return;
1010 }
1011 struct FillpPktConnConfirmAck tmpConnConfirmAck;
1012 (void)memset_s(&tmpConnConfirmAck, sizeof(struct FillpPktConnConfirmAck), 0,
1013 sizeof(struct FillpPktConnConfirmAck));
1014
1015 struct FillpPktHead *pktHdr = (struct FillpPktHead *)confirmAck->head;
1016 struct FillpPktHead *tmpHeader = (struct FillpPktHead *)(void *)tmpConnConfirmAck.head;
1017
1018 /* Recovert the header to NETWORK byte order to provide indication */
1019 tmpHeader->flag = FILLP_HTONS(pktHdr->flag);
1020 tmpHeader->dataLen = FILLP_HTONS(pktHdr->dataLen);
1021 tmpHeader->pktNum = FILLP_HTONL(pktHdr->pktNum);
1022 tmpHeader->seqNum = FILLP_HTONL(pktHdr->seqNum);
1023
1024 /* Below field is already in NETWORK byte order */
1025 tmpConnConfirmAck.sendCache = confirmAck->sendCache;
1026 tmpConnConfirmAck.recvCache = confirmAck->recvCache;
1027 tmpConnConfirmAck.pktSize = confirmAck->pktSize;
1028
1029 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1030 sizeof(struct FillpPktConnConfirmAck), sock->index, fillpTrcDesc,
1031 (FILLP_CHAR *)(&tmpConnConfirmAck));
1032 }
1033
FillpSaveConfirmActToPcb(struct FillpPktConnConfirmAck * confirmAck,struct FillpPcb * pcb)1034 static void FillpSaveConfirmActToPcb(struct FillpPktConnConfirmAck *confirmAck, struct FillpPcb *pcb)
1035 {
1036 struct FillpPktHead *tmpHeader = (struct FillpPktHead *)(void *)confirmAck->head;
1037 pcb->peerUniqueId = tmpHeader->seqNum;
1038 pcb->recv.prePackPktNum = tmpHeader->pktNum;
1039 pcb->recv.pktNum = tmpHeader->pktNum;
1040 pcb->recv.seqNum = tmpHeader->seqNum;
1041 pcb->recv.pktStartNum = tmpHeader->pktNum;
1042 pcb->recv.seqStartNum = tmpHeader->seqNum;
1043 pcb->recv.endSeqNum = pcb->recv.seqStartNum;
1044 pcb->statistics.pack.packPktNum = pcb->recv.pktNum;
1045 pcb->statistics.appFcStastics.pktNum = pcb->recv.pktNum;
1046 }
1047
FillpConnConfirmAckInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p)1048 void FillpConnConfirmAckInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p)
1049 {
1050 if (FillpCheckConfirmAckPar(pcb, p) == FILLP_FALSE) {
1051 return;
1052 }
1053 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1054 struct FillpPktConnConfirmAck *confirmAck = (struct FillpPktConnConfirmAck *)(void *)p->p;
1055 struct FtSocket *sock = (struct FtSocket *)conn->sock;
1056 FillpConnConfirmAckTrace(sock, confirmAck);
1057 FILLP_CONN_CONFIRM_ACK_LOG(sock->index, confirmAck, FILLP_DIRECTION_RX);
1058 FILLP_UINT8 connState = FILLP_GET_CONN_STATE(pcb);
1059 if (connState != CONN_STATE_CONNECTING) {
1060 FILLP_LOGINF("fillp_sock_id:%d Connection state response is not correct, state = %u", sock->index, connState);
1061 return;
1062 }
1063 confirmAck->sendCache = FILLP_NTOHL(confirmAck->sendCache);
1064 confirmAck->recvCache = FILLP_NTOHL(confirmAck->recvCache);
1065 confirmAck->pktSize = FILLP_NTOHL(confirmAck->pktSize);
1066
1067 if (FillpCheckConfirmAckInfoIsValid(pcb, sock, confirmAck) == FILLP_FALSE) {
1068 return;
1069 }
1070 sock->resConf.flowControl.pktSize = (FILLP_UINT16)confirmAck->pktSize;
1071 FillpCheckandcopyConfirmAckAddr(pcb, confirmAck);
1072 if (FillpInitPcb(pcb, (FILLP_INT)(confirmAck->recvCache), (FILLP_INT)(confirmAck->sendCache)) != ERR_OK) {
1073 FILLP_LOGERR("fillp_sock_id:%d Failed to init the fillp PCB, releasing the connection", sock->index);
1074 FillpDisableConnRetryCheckTimer(&conn->pcb->fpcb);
1075 FillpConnConnectionEstFailure(pcb, p);
1076 return;
1077 }
1078 (void)SYS_ARCH_ATOMIC_SET(&sock->sendEventCount, (FILLP_INT)pcb->send.curItemCount);
1079 FillpDisableConnRetryCheckTimer(&conn->pcb->fpcb);
1080 FillpSaveConfirmActToPcb(confirmAck, pcb);
1081 struct SockOsSocket *osSock = NETCONN_GET_OSSOCK(sock->netconn, sock->inst->instIndex);
1082 if (!OS_SOCK_OPS_FUNC_VALID(osSock, connected)) {
1083 FILLP_LOGERR("osSock is null");
1084 FillpConnConnectionEstFailure(pcb, p);
1085 return;
1086 }
1087 osSock->ioSock->ops->connected(sock, osSock->ioSock);
1088 FillpHandleConnConfirmAckInput(sock, conn, pcb, p);
1089 conn->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRMACK_RCVED;
1090 FILLP_LOGDBG("FillpConnConfirmAckInput: fillp_sock_id:%d, initial_send_rate = %u", FILLP_GET_SOCKET(pcb)->index,
1091 pcb->send.flowControl.sendRate);
1092 return;
1093 }
1094
ConnectingHandleFinInput(struct FillpPcb * pcb,struct FtSocket * sock,struct FtNetconn * conn,FILLP_CONST struct NetBuf * p,FILLP_CONST struct FillpFinFlags * flags)1095 static void ConnectingHandleFinInput(struct FillpPcb *pcb, struct FtSocket *sock,
1096 struct FtNetconn *conn, FILLP_CONST struct NetBuf *p, FILLP_CONST struct FillpFinFlags *flags)
1097 {
1098 /* If this socket is not accepted then no event need to given to application as listen socket
1099 IN event is already gives and current socket is accepted by application. No need to change state also.
1100 This socket will be released after keep alive timeout after accept.
1101 We just drop FIN message wait for retranmission in connected state and then handle */
1102 if (sock->isListenSock) {
1103 return;
1104 }
1105
1106 if (!flags->ackSet) { // Only non-ack needs to reply, or it may cause flooding
1107 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
1108 }
1109
1110 FillpDisableConnRetryCheckTimer(&conn->pcb->fpcb);
1111
1112 if (flags->verSet) {
1113 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_REMOTE_REJECT_VERSION;
1114 } else {
1115 sock->coreErrType[MSG_TYPE_DO_CONNECT] = ERR_REMOTE_REJECT_OR_CLOSE;
1116 }
1117
1118 FillpNetconnSetState(conn, CONN_STATE_IDLE);
1119 SpungeConnConnectFail(conn->sock);
1120 }
1121
FillpStateClosingHandleFinInput(struct FillpPcb * pcb,struct FtNetconn * conn,FILLP_BOOL isAck,FILLP_BOOL isWr,FILLP_BOOL * pcbFreed)1122 static void FillpStateClosingHandleFinInput(struct FillpPcb *pcb, struct FtNetconn *conn,
1123 FILLP_BOOL isAck, FILLP_BOOL isWr, FILLP_BOOL *pcbFreed)
1124 {
1125 if (isAck) {
1126 pcb->isFinAckReceived = FILLP_TRUE;
1127 }
1128
1129 if (isWr || conn->peerWrSet || (isAck && conn->shutdownRdSet && conn->shutdownWrSet)) {
1130 // If not recved fin before, then there should be one IN event
1131 struct FtSocket *sock = (struct FtSocket *)conn->sock;
1132 FILLP_INT epEvt = (conn->peerWrSet ? 0 : (SPUNGE_EPOLLIN | SPUNGE_EPOLLRDHUP));
1133 conn->peerWrSet = FILLP_TRUE;
1134 SpungeShutdownSock(conn->sock, SPUNGE_SHUT_RDWR);
1135
1136 epEvt = (FILLP_INT)((FILLP_UINT32)epEvt | (SPUNGE_EPOLLHUP | SPUNGE_EPOLLOUT));
1137 sock->errEvent |= SPUNGE_EPOLLHUP;
1138 SpungeEpollEventCallback(sock, epEvt, 1);
1139
1140 *pcbFreed = FILLP_TRUE;
1141 SpungeConnClosed(conn);
1142 return;
1143 }
1144 }
1145
ConnectedHandleFinInput(struct FtSocket * sock,struct FtNetconn * conn,FILLP_BOOL isWr)1146 static void ConnectedHandleFinInput(struct FtSocket *sock, struct FtNetconn *conn, FILLP_BOOL isWr)
1147 {
1148 if (isWr && !conn->peerWrSet) {
1149 conn->peerWrSet = FILLP_TRUE;
1150 SpungeShutdownSock(sock, SPUNGE_SHUT_RD);
1151 sock->errEvent |= SPUNGE_EPOLLRDHUP;
1152 SpungeEpollEventCallback(sock, ((FILLP_INT)SPUNGE_EPOLLIN | (FILLP_INT)SPUNGE_EPOLLRDHUP), 1);
1153 }
1154 }
1155
FillpFinInputTrace(FILLP_CONST struct FtSocket * sock,FILLP_CONST struct NetBuf * p)1156 static void FillpFinInputTrace(FILLP_CONST struct FtSocket *sock, FILLP_CONST struct NetBuf *p)
1157 {
1158 struct FillpPktFin *req = FILLP_NULL_PTR;
1159 struct FillpPktFin tmpFinPkt;
1160 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1161 struct FillpPktHead *tmpHead = FILLP_NULL_PTR;
1162 FILLP_UINT16 flag;
1163 FillpTraceDescriptSt fillpTrcDesc;
1164
1165 (void)memset_s(&tmpFinPkt, sizeof(struct FillpPktFin), 0, sizeof(struct FillpPktFin));
1166 if (sock->traceFlag >= FILLP_TRACE_DIRECT_NETWORK) {
1167 req = (struct FillpPktFin *)(void *)p->p;
1168 pktHdr = (struct FillpPktHead *)(void *)req->head;
1169 tmpHead = (struct FillpPktHead *)(void *)tmpFinPkt.head;
1170 flag = tmpHead->flag;
1171 /* Recovert the header to NETWORK byte order to provide indication */
1172 tmpHead->flag = FILLP_HTONS(flag);
1173 tmpHead->dataLen = FILLP_HTONS(pktHdr->dataLen);
1174 tmpHead->pktNum = FILLP_HTONL(pktHdr->pktNum);
1175 tmpHead->seqNum = FILLP_HTONL(pktHdr->seqNum);
1176
1177 /* Below field is already in NETWORK byte order */
1178 tmpFinPkt.flag = req->flag;
1179
1180 FILLP_LM_FILLPMSGTRACE_OUTPUT_WITHOUT_FT_TRACE_ENABLE_FLAG(FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1181 sizeof(struct FillpPktFin), sock->index, fillpTrcDesc, (FILLP_CHAR *)(&tmpFinPkt));
1182 }
1183 return;
1184 }
1185
FillpHandleFinFlagGet(FILLP_CONST struct NetBuf * p,struct FillpFinFlags * flags)1186 static FILLP_INT FillpHandleFinFlagGet(FILLP_CONST struct NetBuf *p, struct FillpFinFlags *flags)
1187 {
1188 struct FillpPktFin *fin = (struct FillpPktFin *)(void *)p->p;
1189 fin->flag = FILLP_HTONS(fin->flag);
1190
1191 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_ACK(fin->flag)) {
1192 flags->ackSet = FILLP_TRUE;
1193 }
1194
1195 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_RD(fin->flag)) {
1196 flags->rdSet = FILLP_TRUE;
1197 }
1198
1199 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_WR(fin->flag)) {
1200 flags->wrSet = FILLP_TRUE;
1201 }
1202
1203 if (FILLP_PKT_DISCONN_MSG_FLAG_IS_VER(fin->flag)) {
1204 flags->verSet = FILLP_TRUE;
1205 }
1206
1207 if (!flags->wrSet && !flags->ackSet) {
1208 FILLP_LOGWAR("Invalid fin flag!!!fin ack:%u,peer_rd:%u,peer_wr:%u,ver:%u",
1209 flags->ackSet, flags->rdSet, flags->wrSet, flags->verSet);
1210 return ERR_FAILURE;
1211 }
1212
1213 FILLP_LOGINF("fin ack:%u,peer_rd:%u,peer_wr:%u,ver:%u", flags->ackSet, flags->rdSet, flags->wrSet, flags->verSet);
1214 return ERR_OK;
1215 }
1216
FillpHandleFinRst(struct FtNetconn * conn,struct FtSocket * sock)1217 static void FillpHandleFinRst(struct FtNetconn *conn, struct FtSocket *sock)
1218 {
1219 // If not recved fin before, then there should be one IN event
1220 FILLP_INT epEvt = conn->peerWrSet ? 0 : (SPUNGE_EPOLLIN | SPUNGE_EPOLLRDHUP);
1221 conn->peerRdSet = conn->peerWrSet = FILLP_TRUE;
1222 SpungeShutdownSock(conn->sock, SPUNGE_SHUT_RDWR);
1223
1224 epEvt = (FILLP_INT)((FILLP_UINT32)epEvt | (SPUNGE_EPOLLHUP | SPUNGE_EPOLLOUT));
1225 sock->errEvent |= (FILLP_UINT32)SPUNGE_EPOLLHUP;
1226 SpungeEpollEventCallback(sock, epEvt, 1);
1227
1228 SpungeConnClosed(conn);
1229 }
1230
FillpHandleFin(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,FILLP_BOOL * pcbFreed)1231 static void FillpHandleFin(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p, FILLP_BOOL *pcbFreed)
1232 {
1233 struct FtNetconn *conn = FILLP_NULL_PTR;
1234 struct FtSocket *sock = FILLP_NULL_PTR;
1235 struct FillpFinFlags flags = {0};
1236 int netconnState = 0;
1237
1238 conn = FILLP_GET_CONN(pcb);
1239 netconnState = NETCONN_GET_STATE(conn);
1240 sock = (struct FtSocket *)conn->sock;
1241
1242
1243 if (FillpHandleFinFlagGet(p, &flags) != ERR_OK) {
1244 return;
1245 }
1246
1247 /* Now we received disconn message
1248 1) if we has send disconn message before, this one may be the ack, then we need to cancel timer
1249 2) if wr set, means peer won't send data anymore
1250 then we need to set the read shutdown, when the application read all the data of stack, we will rise HUP event
1251 and recv() returns 0
1252 3) if rdwr set, means it is reset message, then need to set rdwr shutdown, application will get HUP event, and
1253 send() return 0 and netconn state goto CLOSED
1254 */
1255 switch (netconnState) {
1256 /* If state is not connected or closing, it handle depends on different state */
1257 case CONN_STATE_LISTENING:
1258 if (!flags.ackSet) { // Only non-ack needs to reply, or it may cause flooding
1259 FillpSendRst(pcb, (struct sockaddr *)&p->addr);
1260 }
1261 return;
1262
1263 case CONN_STATE_CONNECTING:
1264 ConnectingHandleFinInput(pcb, sock, conn, p, &flags);
1265 return;
1266
1267 case CONN_STATE_CLOSED:
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 break;
1274
1275 case CONN_STATE_CLOSING:
1276 case CONN_STATE_CONNECTED:
1277 /* If this is ack, means no need to response anymore, because that means peer already
1278 know you are shutdown */
1279 if (!flags.ackSet) {
1280 FillpSendFinAck(pcb, (struct sockaddr *)&p->addr);
1281 }
1282
1283 if (flags.rdSet) {
1284 conn->peerRdSet = FILLP_TRUE;
1285 }
1286
1287 /* RST case */
1288 FillpDfxSockLinkAndQosNotify(sock, FILLP_DFX_LINK_FIN_INPUT);
1289 if (flags.wrSet && flags.rdSet) {
1290 FillpHandleFinRst(conn, sock);
1291 return;
1292 }
1293
1294 if (netconnState == CONN_STATE_CLOSING) {
1295 FillpStateClosingHandleFinInput(pcb, conn, flags.ackSet, flags.wrSet, pcbFreed);
1296 } else if (netconnState == CONN_STATE_CONNECTED) {
1297 ConnectedHandleFinInput(sock, conn, flags.wrSet);
1298 }
1299
1300 break;
1301
1302 default:
1303 FILLP_LOGINF("State err, fillp_sock_id:%d, state:%d", sock->index, netconnState);
1304 break;
1305 }
1306 }
1307
FillpFinInput(struct FillpPcb * pcb,FILLP_CONST struct NetBuf * p,FILLP_BOOL * pcbFreed)1308 void FillpFinInput(struct FillpPcb *pcb, FILLP_CONST struct NetBuf *p, FILLP_BOOL *pcbFreed)
1309 {
1310 struct FillpPktHead *fillpHead = FILLP_NULL_PTR;
1311 struct FillpPktFin *fin = FILLP_NULL_PTR;
1312 struct FtNetconn *conn = FILLP_NULL_PTR;
1313 struct FtSocket *sock = FILLP_NULL_PTR;
1314
1315 conn = FILLP_GET_CONN(pcb);
1316 sock = (struct FtSocket *)conn->sock;
1317
1318 if (p->len < (FILLP_INT)(sizeof(struct FillpPktFin) - FILLP_HLEN)) {
1319 FILLP_LOGINF("Fin packet size invalid fillp_sock_id:%d,pkt_len:%d,expected length:%zu", sock->index, p->len,
1320 (sizeof(struct FillpPktFin) - FILLP_HLEN));
1321 return;
1322 }
1323
1324 FILLP_CONN_FIN_LOG(sock->index, (struct FillpPktFin *)(void *)p->p, FILLP_DIRECTION_RX);
1325
1326 if (sock->isListenSock) {
1327 return;
1328 }
1329
1330 FillpFinInputTrace(sock, p);
1331
1332 /* Header fields are already converted in FillpDoInput, and hence here
1333 should not be converted again
1334 */
1335 fin = (struct FillpPktFin *)(void *)p->p;
1336 fillpHead = (struct FillpPktHead *)fin->head;
1337
1338 if (fillpHead->seqNum != pcb->peerUniqueId) {
1339 FILLP_LOGWAR("FillpFinInput: fillp_sock_id:%d Stale fin received peerUniqueId = %u,"
1340 "fin->head.seqNum %u\r\n", sock->index, pcb->peerUniqueId, fillpHead->seqNum);
1341 return;
1342 }
1343
1344 FillpHandleFin(pcb, p, pcbFreed);
1345 return;
1346 }
1347
FillpSendConnReqBuild(struct FillpPcb * pcb,struct FillpPktConnReq * req,FILLP_LLONG curTime)1348 static void FillpSendConnReqBuild(struct FillpPcb *pcb, struct FillpPktConnReq *req, FILLP_LLONG curTime)
1349 {
1350 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1351
1352 req->sendCache = FILLP_HTONL(pcb->mpSendSize);
1353 req->recvCache = FILLP_HTONL(pcb->mpRecvSize);
1354
1355 req->cookiePreserveTime = FILLP_HTONL(pcb->clientCookiePreserveTime);
1356 req->timestamp = FILLP_HTONLL((FILLP_ULLONG)curTime);
1357
1358 pktHdr = (struct FillpPktHead *)req->head;
1359
1360 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1361 pcb->send.pktNum = pcb->send.pktStartNum;
1362 pcb->send.ackSeqNum = pcb->send.seqStartNum;
1363 pcb->send.maxAckNumFromReceiver = pcb->send.ackSeqNum;
1364 pcb->send.seqNum = pcb->send.seqStartNum;
1365
1366 pcb->localUniqueId = pcb->send.seqStartNum;
1367
1368 pktHdr->pktNum = pcb->send.pktStartNum;
1369 pktHdr->seqNum = pcb->send.seqStartNum;
1370
1371 pktHdr->flag = FILLP_NULL_NUM;
1372 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_REQ);
1373 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, FILLP_PROTOCOL_VERSION_NUMBER);
1374 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1375
1376 pktHdr->dataLen = (sizeof(struct FillpPktConnReq) - FILLP_HLEN);
1377 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1378
1379 pktHdr->pktNum = FILLP_HTONL(pktHdr->pktNum);
1380 pktHdr->seqNum = FILLP_HTONL(pktHdr->seqNum);
1381
1382 FILLP_CONN_REQ_LOG(FILLP_GET_SOCKET(pcb)->index, req, FILLP_DIRECTION_RX);
1383 }
1384
FillpSendConnReq(struct FillpPcb * pcb)1385 FILLP_INT FillpSendConnReq(struct FillpPcb *pcb)
1386 {
1387 struct FillpPktConnReq req;
1388 FILLP_LLONG curTime;
1389 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1390 struct FtSocket *sock = (struct FtSocket *)conn->sock;
1391 FillpTraceDescriptSt fillpTrcDesc;
1392 FILLP_INT ret;
1393 FILLP_INT osErrno;
1394
1395 if (sock == FILLP_NULL_PTR) {
1396 FILLP_LOGERR("sock is NULL");
1397 return -1;
1398 }
1399
1400 /* If already received the confirmAck then no need to send the conn_req again after timeout */
1401 if (conn->clientFourHandshakeState == FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRMACK_RCVED) {
1402 FILLP_LOGINF("already received confirmAck");
1403 return ERR_NON_FATAL;
1404 }
1405
1406 curTime = SYS_ARCH_GET_CUR_TIME_LONGLONG();
1407 FillpSendConnReqBuild(pcb, &req, curTime);
1408 FILLP_LOGINF("fillp_sock_id:%d,send req, "
1409 "sendCache:%u,recvCache:%u,timestamp:%lld,startSeqNum:%u,startPktNum:%u,source port:%u,dest port:%u",
1410 sock->index, pcb->mpSendSize, pcb->mpRecvSize, curTime, pcb->send.seqStartNum,
1411 pcb->send.pktStartNum, UTILS_GET_ADDRPORT(&conn->pcb->localAddr),
1412 UTILS_GET_ADDRPORT(&conn->pcb->remoteAddr));
1413 ret = pcb->sendFunc(conn, (char *)&req, sizeof(struct FillpPktConnReq), conn->pcb);
1414 if (ret <= 0) {
1415 osErrno = FT_OS_GET_ERRNO;
1416 pcb->statistics.debugPcb.connReqFailed++;
1417
1418 if ((osErrno == FILLP_EWOULDBLOCK) || (osErrno == FILLP_EINPROGRESS)) {
1419 return ERR_NON_FATAL;
1420 }
1421 FILLP_LOGINF("send connreq fail");
1422 return ret;
1423 } else {
1424 fillpTrcDesc.traceDirection = FILLP_TRACE_DIRECT_SEND;
1425
1426 FILLP_LM_FILLPMSGTRACE_OUTPUT(sock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1427 sizeof(struct FillpPktConnReq), sock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1428 (FILLP_CHAR *)(&req));
1429
1430 if ((conn->clientFourHandshakeState != FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRMACK_RCVED) &&
1431 (conn->clientFourHandshakeState != FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRM_SENT)) {
1432 conn->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_REQSENT;
1433 }
1434
1435 pcb->statistics.debugPcb.connReqSend++;
1436 }
1437
1438 return ret;
1439 }
1440
FillpSendConnReqAckBuild(FILLP_CONST struct FillpPcb * pcb,FILLP_CONST FillpCookieContent * stateCookie,FILLP_ULLONG timestamp)1441 static FILLP_UINT16 FillpSendConnReqAckBuild(FILLP_CONST struct FillpPcb *pcb,
1442 FILLP_CONST FillpCookieContent *stateCookie, FILLP_ULLONG timestamp)
1443 {
1444 FILLP_INT ret;
1445 FILLP_UINT32 localCharacters = (FILLP_UINT32)FILLP_DEFAULT_SUPPORT_CHARACTERS;
1446 FILLP_UINT8 localAlg = (FILLP_UINT8)FILLP_SUPPORT_ALGS;
1447 FILLP_UINT16 dataLen = 0;
1448 struct FillpPktConnReqAck *reqAck = FILLP_NULL_PTR;
1449 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1450 reqAck = (struct FillpPktConnReqAck *)g_rawMsg;
1451 pktHdr = (struct FillpPktHead *)reqAck->head;
1452
1453 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1454 pktHdr->pktNum = 0;
1455 pktHdr->seqNum = FILLP_HTONL(stateCookie->localMessageSeqNumber);
1456
1457 pktHdr->flag = FILLP_NULL_NUM;
1458 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_REQ_ACK);
1459 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, FILLP_PROTOCOL_VERSION_NUMBER);
1460
1461 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1462 reqAck->timestamp = FILLP_HTONLL(timestamp);
1463 reqAck->tagCookie = FILLP_COOKIE_TAG;
1464 reqAck->tagCookie = FILLP_HTONS(reqAck->tagCookie);
1465 reqAck->cookieLength = sizeof(FillpCookieContent);
1466
1467 ret = memcpy_s(&reqAck->cookieContent, sizeof(FillpCookieContent), stateCookie, reqAck->cookieLength);
1468 if (ret != EOK) {
1469 FILLP_LOGERR("fillp_send_conn_reqAck memcpy_s cookieContent failed: %d", ret);
1470 return 0;
1471 }
1472
1473 reqAck->cookieLength = FILLP_HTONS(reqAck->cookieLength);
1474 dataLen = sizeof(struct FillpPktConnReqAck);
1475 ret = FillpEncodeExtPara(g_rawMsg + dataLen, (FILLP_INT32)(FILLP_FRAME_MTU - dataLen),
1476 FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG, (FILLP_UCHAR)(sizeof(FILLP_UINT8)), (FILLP_UCHAR *)&localAlg);
1477 if (ret <= 0) {
1478 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1479 * functionality */
1480 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG failed");
1481 } else {
1482 dataLen += (FILLP_UINT16)ret;
1483 }
1484
1485 localCharacters = FILLP_HTONL(localCharacters);
1486 ret = FillpEncodeExtPara(g_rawMsg + dataLen, (FILLP_INT32)(FILLP_FRAME_MTU - dataLen),
1487 FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER, (FILLP_UCHAR)(sizeof(FILLP_UINT32)), (FILLP_UCHAR *)&localCharacters);
1488 if (ret <= 0) {
1489 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1490 * functionality */
1491 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER failed");
1492 } else {
1493 dataLen += (FILLP_UINT16)ret;
1494 }
1495
1496 pktHdr->dataLen = FILLP_HTONS(dataLen - (FILLP_UINT16)FILLP_HLEN);
1497
1498 FILLP_CONN_REQ_ACK_TX_LOG(FILLP_GET_SOCKET(pcb)->index, reqAck, g_rawMsg + sizeof(struct FillpPktConnReqAck),
1499 dataLen - sizeof(struct FillpPktConnReqAck));
1500 return dataLen;
1501 }
1502
FillpSendConnReqAck(struct FillpPcb * pcb,FILLP_CONST FillpCookieContent * stateCookie,FILLP_ULLONG timestamp)1503 void FillpSendConnReqAck(struct FillpPcb *pcb, FILLP_CONST FillpCookieContent *stateCookie,
1504 FILLP_ULLONG timestamp)
1505 {
1506 struct FillpPktConnReqAck *reqAck = (struct FillpPktConnReqAck *)g_rawMsg;
1507 struct FtNetconn *conn = FILLP_NULL_PTR;
1508 struct FtSocket *sock = FILLP_NULL_PTR;
1509 FILLP_INT ret;
1510 FILLP_UINT16 dataLen;
1511 struct SpungePcb *tempPcb = FILLP_NULL_PTR;
1512
1513 if (pcb == FILLP_NULL_PTR) {
1514 FILLP_LOGERR("FillpSendConnReq: PCB pointer is NULL");
1515 return;
1516 }
1517
1518 tempPcb = &SPUNGE_GET_CUR_INSTANCE()->tempSpcb;
1519 (void)memset_s(tempPcb, sizeof(struct SpungePcb), 0, sizeof(struct SpungePcb));
1520
1521 conn = FILLP_GET_CONN(pcb);
1522 sock = (struct FtSocket *)conn->sock;
1523
1524 dataLen = FillpSendConnReqAckBuild(pcb, stateCookie, timestamp);
1525 if (dataLen == 0) {
1526 return;
1527 }
1528
1529 if (AF_INET == stateCookie->addressType) {
1530 *((struct sockaddr_in *)&tempPcb->remoteAddr) = *((struct sockaddr_in *)&stateCookie->remoteSockIpv6Addr);
1531 tempPcb->addrType = AF_INET;
1532 tempPcb->addrLen = sizeof(struct sockaddr_in);
1533 } else {
1534 tempPcb->remoteAddr = *(struct sockaddr_in6 *)&stateCookie->remoteSockIpv6Addr;
1535 tempPcb->addrType = AF_INET6;
1536 tempPcb->addrLen = sizeof(struct sockaddr_in6);
1537 }
1538
1539 ret = pcb->sendFunc(conn, (char *)g_rawMsg, (FILLP_INT)dataLen, tempPcb);
1540 if (ret <= 0) {
1541 pcb->statistics.debugPcb.connReqAckFailed++;
1542 FILLP_LOGINF("Send fail");
1543 } else {
1544 FillpTraceDescriptSt fillpTrcDesc = FILLP_TRACE_DESC_INIT(FILLP_TRACE_DIRECT_SEND);
1545
1546 FILLP_LM_FILLPMSGTRACE_OUTPUT(sock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, sock->traceHandle,
1547 sizeof(struct FillpPktConnReqAck), sock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1548 (FILLP_CHAR *)reqAck);
1549
1550 pcb->statistics.debugPcb.connReqAckSend++;
1551 }
1552
1553 FILLP_LOGINF("send conn_reqAck fillp_sock_id:%d,destport:%u", sock->index,
1554 UTILS_GET_ADDRPORT(&tempPcb->remoteAddr));
1555 }
1556
ConnConfirmBuild(struct FillpPcb * pcb,FILLP_CONST struct FillpConnReqAckClient * reqAck,struct FillpPktHead * pktHdr)1557 static FILLP_INT32 ConnConfirmBuild(struct FillpPcb *pcb, FILLP_CONST struct FillpConnReqAckClient *reqAck,
1558 struct FillpPktHead *pktHdr)
1559 {
1560 FILLP_INT32 encMsgLen = 0;
1561 FILLP_INT ret;
1562 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1563 pktHdr->pktNum = 0;
1564 pktHdr->seqNum = 0;
1565 pktHdr->flag = 0;
1566 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_CONFIRM);
1567 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, (FILLP_UINT16)FILLP_PROTOCOL_VERSION_NUMBER);
1568 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1569
1570 encMsgLen = FILLP_HLEN;
1571 *((FILLP_UINT16 *)(g_rawMsg + encMsgLen)) = FILLP_HTONS(reqAck->tagCookie);
1572 encMsgLen += sizeof(FILLP_UINT16);
1573 *((FILLP_UINT16 *)(g_rawMsg + encMsgLen)) = FILLP_HTONS(reqAck->cookieLength);
1574 encMsgLen += sizeof(FILLP_UINT16);
1575 if (reqAck->cookieLength != sizeof(FillpCookieContent) || reqAck->cookieContent == FILLP_NULL_PTR) {
1576 FILLP_LOGERR("fillp_send_conn_confirm reqAck->cookieLength is wrong:%u, expect : %zu",
1577 reqAck->cookieLength, sizeof(FillpCookieContent));
1578 return 0;
1579 }
1580 ret = memcpy_s(g_rawMsg + encMsgLen, (FILLP_UINT32)(FILLP_FRAME_MTU - encMsgLen),
1581 reqAck->cookieContent, reqAck->cookieLength);
1582 if (ret != EOK) {
1583 FILLP_LOGERR("fillp_send_conn_confirm memcpy_s cookieContent failed:%d", ret);
1584 return 0;
1585 }
1586 encMsgLen += reqAck->cookieLength;
1587
1588 /* NOTE: This parameter needs to be encoded as old server will use struct FillpPktConnConfirm-> remoteAddr
1589 address. */
1590 {
1591 struct SpungePcb*spcb = (struct SpungePcb*)pcb->spcb;
1592 ret = memcpy_s(g_rawMsg + encMsgLen, (FILLP_UINT32)((FILLP_INT)sizeof(g_rawMsg) - encMsgLen),
1593 &spcb->remoteAddr, sizeof(spcb->remoteAddr));
1594 if (ret != EOK) {
1595 FILLP_LOGERR("fillp_send_conn_confirm memcpy_s remoteAddr failed:%d", ret);
1596 return 0;
1597 }
1598 encMsgLen += sizeof(spcb->remoteAddr);
1599 }
1600 return encMsgLen;
1601 }
1602
ConnConfirmEncodeExtPara(const struct FillpPcb * pcb,FILLP_INT32 encMsgLen)1603 static FILLP_INT32 ConnConfirmEncodeExtPara(const struct FillpPcb *pcb, FILLP_INT32 encMsgLen)
1604 {
1605 FILLP_INT ret;
1606 FILLP_ULLONG tempRtt;
1607 FILLP_UINT32 tempValue32;
1608
1609 tempRtt = FILLP_HTONLL(pcb->rtt);
1610 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1611 FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_RTT, (FILLP_UCHAR)(sizeof(FILLP_ULLONG)), (FILLP_UCHAR *)&tempRtt);
1612 if (ret <= 0) {
1613 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1614 * functionality */
1615 FILLP_LOGWAR("encode extension parameter failed");
1616 } else {
1617 encMsgLen += ret;
1618 }
1619
1620 tempValue32 = (FILLP_UINT32)pcb->pktSize;
1621 tempValue32 = FILLP_HTONL(tempValue32);
1622 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1623 FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE, (FILLP_UCHAR)(sizeof(FILLP_UINT32)),
1624 (FILLP_UCHAR *)&(tempValue32));
1625 if (ret <= 0) {
1626 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1627 * functionality */
1628 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CONFIRM_CARRY_PKT_SIZE failed");
1629 } else {
1630 encMsgLen += ret;
1631 }
1632
1633 FILLP_LOGERR("fcAlg %u", pcb->fcAlg);
1634 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1635 FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG, (FILLP_UCHAR)(sizeof(FILLP_UINT8)), (FILLP_UCHAR *)&(pcb->fcAlg));
1636 if (ret <= 0) {
1637 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1638 * functionality */
1639 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_FC_ALG failed");
1640 } else {
1641 encMsgLen += ret;
1642 }
1643
1644 tempValue32 = FILLP_HTONL(pcb->characters);
1645 ret = FillpEncodeExtPara(g_rawMsg + encMsgLen, (FILLP_INT32)(FILLP_FRAME_MTU - encMsgLen),
1646 FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER, (FILLP_UCHAR)(sizeof(FILLP_UINT32)), (FILLP_UCHAR *)&tempValue32);
1647 if (ret <= 0) {
1648 /* As encode of extension parameter has failed, still we can continue to send request, it does not impact base
1649 * functionality */
1650 FILLP_LOGWAR("encode extension parameter FILLP_PKT_EXT_CONNECT_CARRY_CHARACTER failed");
1651 } else {
1652 encMsgLen += ret;
1653 }
1654 return encMsgLen;
1655 }
1656
FillpSendConnConfirm(struct FillpPcb * pcb,FILLP_CONST struct FillpConnReqAckClient * reqAck)1657 void FillpSendConnConfirm(struct FillpPcb *pcb, FILLP_CONST struct FillpConnReqAckClient *reqAck)
1658 {
1659 FILLP_INT32 encMsgLen = 0;
1660 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1661 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1662 FILLP_INT ret;
1663 struct FtSocket *ftSock = (struct FtSocket *)conn->sock;
1664 FillpTraceDescriptSt fillpTrcDesc = FILLP_TRACE_DESC_INIT(FILLP_TRACE_DIRECT_SEND);
1665
1666 if (ftSock == FILLP_NULL_PTR) {
1667 return;
1668 }
1669
1670 (void)memset_s(g_rawMsg, FILLP_FRAME_MTU, 0, FILLP_FRAME_MTU);
1671 pktHdr = (struct FillpPktHead *)(void *)g_rawMsg;
1672 encMsgLen = ConnConfirmBuild(pcb, reqAck, pktHdr);
1673 if (encMsgLen == 0) {
1674 return;
1675 }
1676
1677 FILLP_INT extParaOffset = encMsgLen;
1678 encMsgLen = ConnConfirmEncodeExtPara(pcb, encMsgLen);
1679 /* To send the FILLP_CONNECT_CONFIRM_CARRY_RTT */
1680 pktHdr->dataLen = (FILLP_UINT16)(encMsgLen - FILLP_HLEN);
1681 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1682
1683 FILLP_CONN_CONFIRM_TX_LOG(ftSock->index, g_rawMsg, encMsgLen, extParaOffset);
1684
1685 ret = pcb->sendFunc(conn, (FILLP_CHAR *)g_rawMsg, encMsgLen, conn->pcb);
1686 if (ret <= 0) {
1687 pcb->statistics.debugPcb.connConfirmFailed++;
1688 FILLP_LOGINF("send fail fillp_sock_id:%d", ftSock->index);
1689 } else {
1690 FILLP_LM_FILLPMSGTRACE_OUTPUT(ftSock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, ftSock->traceHandle,
1691 (FILLP_UINT32)encMsgLen, ftSock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1692 (FILLP_CHAR *)g_rawMsg);
1693
1694 pcb->statistics.debugPcb.connConfirmSend++;
1695
1696 conn->clientFourHandshakeState = FILLP_CLIENT_FOUR_HANDSHAKE_STATE_CONFIRM_SENT;
1697 }
1698
1699 FILLP_LOGINF("Send conn confirm fillp_sock_id:%d, source port:%u, dest port:%u", ftSock->index,
1700 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&conn->pcb->remoteAddr));
1701 }
1702
1703
FillpSendConnConfirmAck(struct FillpPcb * pcb)1704 void FillpSendConnConfirmAck(struct FillpPcb *pcb)
1705 {
1706 struct FillpPktConnConfirmAck confirmAck;
1707 struct FillpPktHead *pktHdr = FILLP_NULL_PTR;
1708 FILLP_INT ret;
1709 FillpTraceDescriptSt fillpTrcDesc;
1710
1711 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1712 struct FtSocket *ftSock = (struct FtSocket *)conn->sock;
1713
1714 if (ftSock == FILLP_NULL_PTR) {
1715 FILLP_LOGERR("ftSock is NULL");
1716 return;
1717 }
1718
1719 FILLP_LOGINF("Send conn confirm ack fillp_sock_id:%d, source port:%u, remote port:%u", ftSock->index,
1720 UTILS_GET_ADDRPORT(&conn->pcb->localAddr), UTILS_GET_ADDRPORT(&conn->pcb->remoteAddr));
1721
1722 confirmAck.sendCache = FILLP_HTONL(pcb->mpSendSize);
1723 confirmAck.recvCache = FILLP_HTONL(pcb->mpRecvSize);
1724
1725 confirmAck.pktSize = FILLP_HTONL((FILLP_UINT32)pcb->pktSize);
1726
1727 pktHdr = (struct FillpPktHead *)confirmAck.head;
1728
1729 /* 0 converted to network order is also 0, hence explicit conversion not applied */
1730 pktHdr->pktNum = FILLP_HTONL(pcb->send.pktStartNum);
1731 pktHdr->seqNum = FILLP_HTONL(pcb->send.seqStartNum);
1732
1733 pktHdr->flag = 0;
1734 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_CONN_CONFIRM_ACK);
1735 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, (FILLP_UINT16)FILLP_PROTOCOL_VERSION_NUMBER);
1736 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1737
1738 pktHdr->dataLen = (sizeof(struct FillpPktConnConfirmAck) - FILLP_HLEN);
1739 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1740 (void)memcpy_s(&confirmAck.remoteAddr, sizeof(confirmAck.remoteAddr), &conn->pcb->remoteAddr,
1741 sizeof(conn->pcb->remoteAddr));
1742
1743 FILLP_CONN_CONFIRM_ACK_LOG(ftSock->index, &confirmAck, FILLP_DIRECTION_TX);
1744
1745 ret = pcb->sendFunc(FILLP_GET_CONN(pcb), (char *)&confirmAck, sizeof(struct FillpPktConnConfirmAck), conn->pcb);
1746 if (ret <= 0) {
1747 pcb->statistics.debugPcb.connConfirmAckFailed++;
1748 FILLP_LOGINF("send fail fillp_sock_id:%d", ftSock->index);
1749 } else {
1750 fillpTrcDesc.traceDirection = FILLP_TRACE_DIRECT_SEND;
1751
1752 FILLP_LM_FILLPMSGTRACE_OUTPUT(ftSock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, ftSock->traceHandle,
1753 sizeof(struct FillpPktConnConfirmAck), ftSock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc,
1754 (FILLP_CHAR *)(&confirmAck));
1755
1756 pcb->statistics.debugPcb.connConfirmAckSend++;
1757 pcb->connTimestamp = SYS_ARCH_GET_CUR_TIME_LONGLONG();
1758 }
1759
1760 return;
1761 }
1762
FillpSendFinBuild(FILLP_CONST struct FillpPcb * pcb,struct FillpPktFin * req,FILLP_CONST struct FillpFinFlags * flags)1763 static void FillpSendFinBuild(FILLP_CONST struct FillpPcb *pcb, struct FillpPktFin *req,
1764 FILLP_CONST struct FillpFinFlags *flags)
1765 {
1766 struct FillpPktHead *pktHdr = (struct FillpPktHead *)req->head;
1767
1768 pktHdr->seqNum = FILLP_HTONL(pcb->localUniqueId);
1769 pktHdr->pktNum = FILLP_HTONL(pcb->send.pktNum);
1770
1771 pktHdr->flag = FILLP_NULL_NUM;
1772 req->flag = FILLP_NULL_NUM;
1773 FILLP_HEADER_SET_PKT_TYPE(pktHdr->flag, FILLP_PKT_TYPE_FIN);
1774 FILLP_HEADER_SET_PROTOCOL_VERSION(pktHdr->flag, FILLP_PROTOCOL_VERSION_NUMBER);
1775 if (flags->wrSet) {
1776 FILLP_PKT_DISCONN_MSG_FLAG_SET_WR(req->flag);
1777 }
1778 if (flags->rdSet) {
1779 FILLP_PKT_DISCONN_MSG_FLAG_SET_RD(req->flag);
1780 }
1781 if (flags->ackSet) {
1782 FILLP_PKT_DISCONN_MSG_FLAG_SET_ACK(req->flag);
1783 }
1784 if (flags->verSet) {
1785 FILLP_PKT_DISCONN_MSG_FLAG_SET_VER(req->flag);
1786 }
1787
1788 pktHdr->flag = FILLP_HTONS(pktHdr->flag);
1789 req->flag = FILLP_HTONS(req->flag);
1790
1791 pktHdr->dataLen = (sizeof(struct FillpPktFin) - FILLP_HLEN);
1792 pktHdr->dataLen = FILLP_HTONS(pktHdr->dataLen);
1793 }
1794
FillpSendFinInnerImpl(struct FillpPcb * pcb,FILLP_CONST struct FillpFinFlags * flags,struct sockaddr * remoteAddr)1795 static void FillpSendFinInnerImpl(struct FillpPcb *pcb, FILLP_CONST struct FillpFinFlags *flags,
1796 struct sockaddr *remoteAddr)
1797 {
1798 struct FillpPktFin req;
1799 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1800 struct SpungePcb *remotePcb = FILLP_NULL_PTR;
1801 FILLP_INT ret;
1802 FillpTraceDescriptSt fillpTrcDesc;
1803
1804 FILLP_LOGINF("wrSet:%u,rdSet:%u,ackSet:%u,verSet:%u", flags->wrSet, flags->rdSet, flags->ackSet, flags->verSet);
1805
1806 if (conn == FILLP_NULL_PTR) {
1807 FILLP_LOGERR("conn is NULL");
1808 return;
1809 }
1810
1811 FillpSendFinBuild(pcb, &req, flags);
1812 remotePcb = &SPUNGE_GET_CUR_INSTANCE()->tempSpcb;
1813 UtilsAddrCopy((struct sockaddr *)&remotePcb->remoteAddr, (struct sockaddr *)remoteAddr);
1814
1815 if (((struct SpungePcb *)(pcb->spcb))->addrLen) {
1816 remotePcb->addrLen = ((struct SpungePcb *)(pcb->spcb))->addrLen;
1817 remotePcb->addrType = ((struct SpungePcb *)(pcb->spcb))->addrType;
1818 } else {
1819 if (remoteAddr->sa_family == AF_INET) {
1820 remotePcb->addrLen = sizeof(struct sockaddr_in);
1821 remotePcb->addrType = AF_INET;
1822 } else {
1823 remotePcb->addrLen = sizeof(struct sockaddr_in6);
1824 remotePcb->addrType = AF_INET6;
1825 }
1826 }
1827
1828 FILLP_CONN_FIN_LOG(FILLP_GET_SOCKET(pcb)->index, &req, FILLP_DIRECTION_TX);
1829
1830 ret = pcb->sendFunc(conn, (char *)&req, sizeof(struct FillpPktFin), remotePcb);
1831 if (ret <= 0) {
1832 pcb->statistics.debugPcb.disconnReqFailed++;
1833 } else {
1834 struct FtSocket *ftSock;
1835
1836 ftSock = (struct FtSocket *)conn->sock;
1837 fillpTrcDesc.traceDirection = FILLP_TRACE_DIRECT_SEND;
1838
1839 if (ftSock != FILLP_NULL_PTR) {
1840 FILLP_LM_FILLPMSGTRACE_OUTPUT(ftSock->traceFlag, FILLP_TRACE_DIRECT_NETWORK, ftSock->traceHandle,
1841 sizeof(struct FillpPktFin), ftSock->index, (FILLP_UINT8 *)(void *)&fillpTrcDesc, (FILLP_CHAR *)(&req));
1842 }
1843
1844 pcb->statistics.debugPcb.disconnReqSend++;
1845 }
1846 }
1847
FillpSendFinInner(struct FillpPcb * pcb,FILLP_BOOL wrSet,FILLP_BOOL rdSet,FILLP_BOOL ackSet,struct sockaddr * remoteAddr)1848 static void FillpSendFinInner(struct FillpPcb *pcb, FILLP_BOOL wrSet, FILLP_BOOL rdSet, FILLP_BOOL ackSet,
1849 struct sockaddr *remoteAddr)
1850 {
1851 struct FillpFinFlags flags = {0};
1852 flags.wrSet = wrSet;
1853 flags.rdSet = rdSet;
1854 flags.ackSet = ackSet;
1855 flags.verSet = FILLP_FALSE;
1856
1857 FillpSendFinInnerImpl(pcb, &flags, remoteAddr);
1858 }
1859
FillpSendRstWithVersionImcompatible(struct FillpPcb * pcb,struct sockaddr * remoteAddr)1860 void FillpSendRstWithVersionImcompatible(struct FillpPcb *pcb, struct sockaddr *remoteAddr)
1861 {
1862 struct FillpFinFlags flags = {0};
1863 flags.wrSet = FILLP_TRUE;
1864 flags.rdSet = FILLP_TRUE;
1865 flags.ackSet = FILLP_TRUE;
1866 flags.verSet = FILLP_TRUE;
1867
1868 FillpSendFinInnerImpl(pcb, &flags, remoteAddr);
1869 }
1870
FillpSendFin(struct FillpPcb * pcb)1871 void FillpSendFin(struct FillpPcb *pcb)
1872 {
1873 struct FtNetconn *conn = FILLP_GET_CONN(pcb);
1874 FILLP_BOOL wrSet = FILLP_FALSE;
1875 FILLP_BOOL rdSet = FILLP_FALSE;
1876 FILLP_BOOL ackSet = FILLP_FALSE;
1877
1878 if (conn->shutdownWrSet && conn->sendBufRunOut) {
1879 wrSet = FILLP_TRUE;
1880 }
1881 if (conn->shutdownRdSet) {
1882 rdSet = FILLP_TRUE;
1883 }
1884
1885 FillpSendFinInner(pcb, wrSet, rdSet, ackSet,
1886 (struct sockaddr *)(&((struct SpungePcb*)(pcb->spcb))->remoteAddr));
1887 }
1888
FillpSendFinAck(struct FillpPcb * pcb,struct sockaddr * remoteAddr)1889 void FillpSendFinAck(struct FillpPcb *pcb, struct sockaddr *remoteAddr)
1890 {
1891 FillpSendFinInner(pcb, FILLP_FALSE, FILLP_FALSE, FILLP_TRUE, remoteAddr);
1892 }
1893
FillpSendRst(struct FillpPcb * pcb,struct sockaddr * remoteAddr)1894 void FillpSendRst(struct FillpPcb *pcb, struct sockaddr *remoteAddr)
1895 {
1896 FillpSendFinInner(pcb, FILLP_TRUE, FILLP_TRUE, FILLP_TRUE, remoteAddr);
1897 }
1898
1899
1900 /* *****************************************************************************
1901 Function : FillpGenerateCookie
1902
1903 Description : This function Generates the cookieContent for fillp on receiving
1904 Connection request from peer.
1905
1906 Input :
1907 Output : NONE
1908
1909
1910 Return : FILLP_SUCCESS/FILLP_FAILURE
1911 ***************************************************************************** */
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)1912 void FillpGenerateCookie(IN FILLP_CONST struct FillpPcb *pcb, IN struct FillpPktConnReq *req,
1913 IN FILLP_CONST struct sockaddr_in6 *remoteAddr, IN FILLP_UINT16 serverPort, OUT FillpCookieContent *stateCookie)
1914 {
1915 struct FillpPktHead *pktHdr = (struct FillpPktHead *)req->head;
1916 struct SpungePcb*spcb = (struct SpungePcb*)pcb->spcb;
1917 struct sockaddr *localAddr = (struct sockaddr *)(void *)(&spcb->localAddr);
1918 FillpHmacSha256 ctx;
1919 FillpCookieContentCalculate cookieCal;
1920 void *cookieDataPtr = FILLP_NULL_PTR;
1921
1922 (void)memset_s(&cookieCal, sizeof(cookieCal), 0, sizeof(cookieCal));
1923 (void)memcpy_s(stateCookie->digest, FILLP_KEYSIZE, pcb->pcbInst->macInfo.currentMacKey, FILLP_KEYSIZE);
1924 FILLP_CONST struct sockaddr *addr = (struct sockaddr *)(void *)remoteAddr;
1925 FillpErrorType err = memcpy_s(&stateCookie->remoteSockIpv6Addr, sizeof(stateCookie->remoteSockIpv6Addr), remoteAddr,
1926 ((addr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)));
1927 if (err != EOK) {
1928 FILLP_LOGERR("fillp_generate_cookie memcpy_s remote %u failed:%d", addr->sa_family, err);
1929 return;
1930 }
1931 stateCookie->remoteRecvCache = req->recvCache;
1932 stateCookie->remoteSendCache = req->sendCache;
1933 FILLP_LLONG *cookieTime = (FILLP_LLONG *)(void *)(stateCookie->arr);
1934 *cookieTime = (FILLP_LLONG)SYS_ARCH_GET_CUR_TIME_LONGLONG();
1935 stateCookie->localMessageSeqNumber = FILLP_CRYPTO_RAND();
1936 stateCookie->localPacketSeqNumber = FILLP_CRYPTO_RAND();
1937 stateCookie->remoteMessageSeqNumber = pktHdr->seqNum;
1938 stateCookie->remotePacketSeqNumber = pktHdr->pktNum;
1939 stateCookie->addressType = addr->sa_family;
1940 stateCookie->srcPort = serverPort;
1941 if (req->cookiePreserveTime <= FILLP_MAX_COOKIE_LIFETIME) {
1942 stateCookie->lifeTime = FILLP_INITIAL_COOKIE_LIFETIME + req->cookiePreserveTime;
1943 } else {
1944 stateCookie->lifeTime = FILLP_INITIAL_COOKIE_LIFETIME;
1945 }
1946 if (memcpy_s(&cookieCal, sizeof(cookieCal), stateCookie, sizeof(FillpCookieContent)) != EOK) {
1947 return;
1948 }
1949 err = memcpy_s(&cookieCal.localSockIpv6Addr, sizeof(cookieCal.localSockIpv6Addr),
1950 &((struct SpungePcb*)(pcb->spcb))->localAddr,
1951 ((localAddr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)));
1952 if (err != EOK) {
1953 FILLP_LOGERR("fillp_generate_cookie memcpy_s local %u failed:%d", localAddr->sa_family, err);
1954 return;
1955 }
1956 FillpHmacSha256Init(&ctx, pcb->pcbInst->macInfo.currentMacKey, FILLP_KEYSIZE, pcb->pcbInst);
1957 cookieDataPtr = (void *)((uintptr_t)(&cookieCal) + FILLP_KEYSIZE);
1958 FillpHmacSha256Update(&ctx, cookieDataPtr, (sizeof(FillpCookieContentCalculate) - FILLP_KEYSIZE));
1959 FillpHmacSha256Final(&ctx, stateCookie->digest, FILLP_KEYSIZE);
1960 }
1961
FillpValidateCookieHmac(FILLP_CONST struct FillpPcb * pcb,FILLP_CONST FillpCookieContent * stateCookie)1962 static FILLP_INT FillpValidateCookieHmac(FILLP_CONST struct FillpPcb *pcb, FILLP_CONST FillpCookieContent *stateCookie)
1963 {
1964 FILLP_UINT32 count = 0;
1965 FILLP_UINT8 key[FILLP_KEYSIZE];
1966 FILLP_UINT8 outDigest[FILLP_KEYSIZE] = {0};
1967 FillpHmacSha256 ctx;
1968 FillpCookieContentCalculate cookieCal;
1969 struct SpungePcb *spcb = (struct SpungePcb*)pcb->spcb;
1970 struct sockaddr *localAddr = (struct sockaddr *)(void *)(&spcb->localAddr);
1971 void *cookieDataPtr = FILLP_NULL_PTR;
1972 FILLP_ULLONG *cookieTime = FILLP_NULL_PTR;
1973
1974 (void)memset_s(&cookieCal, sizeof(cookieCal), 0, sizeof(cookieCal));
1975 FillpErrorType err = memcpy_s(&cookieCal, sizeof(cookieCal), stateCookie, sizeof(FillpCookieContent));
1976 if (err != EOK) {
1977 FILLP_LOGERR("fillp_validate_cookie memcpy_s cookieCal failed : %d", err);
1978 return err;
1979 }
1980
1981 err = memcpy_s(&cookieCal.localSockIpv6Addr, sizeof(cookieCal.localSockIpv6Addr),
1982 &((struct SpungePcb*)(pcb->spcb))->localAddr,
1983 ((localAddr->sa_family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6)));
1984 if (err != EOK) {
1985 FILLP_LOGERR("fillp_validate_cookie memcpy_s %u failed : %d", localAddr->sa_family, err);
1986 return err;
1987 }
1988
1989 cookieTime = (FILLP_ULLONG *)(void *)stateCookie->arr;
1990 if (pcb->pcbInst->macInfo.switchOverTime < *cookieTime) {
1991 for (count = 0; count < FILLP_KEYSIZE; count++) {
1992 key[count] = pcb->pcbInst->macInfo.currentMacKey[count];
1993 }
1994 } else {
1995 for (count = 0; count < FILLP_KEYSIZE; count++) {
1996 key[count] = pcb->pcbInst->macInfo.oldMacKey[count];
1997 }
1998 }
1999
2000 FillpHmacSha256Init(&ctx, key, FILLP_KEYSIZE, pcb->pcbInst);
2001 cookieDataPtr = (void *)((uintptr_t)(&cookieCal) + FILLP_KEYSIZE);
2002 FillpHmacSha256Update(&ctx, cookieDataPtr,
2003 (sizeof(FillpCookieContentCalculate) - FILLP_KEYSIZE));
2004 FillpHmacSha256Final(&ctx, outDigest, FILLP_KEYSIZE);
2005
2006 for (count = 0; count < FILLP_KEYSIZE; count++) {
2007 if (stateCookie->digest[count] != outDigest[count]) {
2008 FILLP_LOGINF("fillp_sock_id:%d HMAC-SHA2 digest mismatched. SaveDigest:%d NewDigest:%d",
2009 FILLP_GET_SOCKET(pcb)->index, stateCookie->digest[count], outDigest[count]);
2010 return ERR_HMAC_SHA2_DIGEST_MISMATCH;
2011 }
2012 }
2013
2014 return ERR_OK;
2015 }
2016
2017 /* *****************************************************************************
2018 Function : FillpValidateCookie
2019
2020 Description : This function validates the cookieContent from peer.
2021
2022 Input :
2023 Output : NONE
2024
2025
2026 Return : FILLP_SUCCESS/FILLP_FAILURE
2027 Modify : Change prototype to include usClientPort
2028
2029 ***************************************************************************** */
FillpValidateCookie(IN FILLP_CONST struct FillpPcb * pcb,IN FILLP_UINT16 serverPort,IN FILLP_CONST struct sockaddr_in6 * clientAddr,IN FILLP_CONST FillpCookieContent * stateCookie)2030 FILLP_INT FillpValidateCookie(IN FILLP_CONST struct FillpPcb *pcb, IN FILLP_UINT16 serverPort,
2031 IN FILLP_CONST struct sockaddr_in6 *clientAddr, IN FILLP_CONST FillpCookieContent *stateCookie)
2032 {
2033 FILLP_LLONG timeDiffVal;
2034 FILLP_LLONG curTime;
2035 FILLP_INT ret;
2036 FILLP_ULLONG *cookieTime = FILLP_NULL_PTR;
2037
2038 ret = FillpValidateCookieHmac(pcb, stateCookie);
2039 if (ret != ERR_OK) {
2040 return ret;
2041 }
2042
2043 if (stateCookie->srcPort != serverPort) {
2044 FILLP_LOGINF("fillp_sock_id:%d FillP cookieContent Server Port mismatch. "
2045 "cookieContent Generated server port:%u Msg Server Port:%u \r\n",
2046 FILLP_GET_SOCKET(pcb)->index, stateCookie->srcPort, serverPort);
2047 return ERR_COOKIE_PORT_MISMATCH;
2048 }
2049
2050 /* no need to explicitly validate the server IP again here, since it is already
2051 validated in hash when receive the UDP packet
2052 Validate the source port and IP of the client against the port and IP
2053 of the client stored in the cookie content, if mismatches, then discard the
2054 connection confirm message silently */
2055 if (UtilsAddrMatch((FILLP_CONST struct sockaddr_in *)&stateCookie->remoteSockIpv6Addr,
2056 (FILLP_CONST struct sockaddr_in *)clientAddr) == FILLP_FALSE) {
2057 FILLP_LOGINF("fillp_sock_id:%d Client address mismatch between cookie"
2058 " and message client",
2059 FILLP_GET_SOCKET(pcb)->index);
2060 return ERR_COOKIE_PORT_MISMATCH;
2061 }
2062
2063 curTime = (FILLP_LLONG)SYS_ARCH_GET_CUR_TIME_LONGLONG();
2064 cookieTime = (FILLP_ULLONG *)(void *)stateCookie->arr;
2065 timeDiffVal = (FILLP_LLONG)((FILLP_ULLONG)curTime - (*cookieTime));
2066
2067 if (timeDiffVal < 0) {
2068 FILLP_LOGERR("fillp_sock_id:%d FillP cookieContent is stale due to system time change."
2069 "CookieGenerated time:%llu Current time:%lld Life time of cookie:%u \r\n",
2070 FILLP_GET_SOCKET(pcb)->index, *cookieTime, curTime, stateCookie->lifeTime);
2071 return ERR_STALE_COOKIE_ERROR;
2072 }
2073
2074 if (timeDiffVal > stateCookie->lifeTime) {
2075 FILLP_LOGINF("fillp_sock_id:%d FillP cookieContent is stale. CookieGenerated time:%llu"
2076 "Current time:%lld Life time of cookie:%u \r\n",
2077 FILLP_GET_SOCKET(pcb)->index, *cookieTime, curTime, stateCookie->lifeTime);
2078 return ERR_STALE_COOKIE_ERROR;
2079 }
2080
2081 return FILLP_SUCCESS;
2082 }
2083
2084 #ifdef __cplusplus
2085 }
2086 #endif
2087