00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223 #include <cfg/os.h>
00224 #include <cfg/tcp.h>
00225
00226 #include <sys/thread.h>
00227 #include <sys/heap.h>
00228 #include <sys/event.h>
00229 #include <sys/timer.h>
00230
00231 #include <net/errno.h>
00232 #include <netinet/in.h>
00233 #include <netinet/ip.h>
00234 #include <net/route.h>
00235 #include <sys/socket.h>
00236 #include <netinet/tcputil.h>
00237 #include <netinet/tcp.h>
00238
00239 #ifdef NUTDEBUG
00240 #include <net/netdebug.h>
00241 #endif
00242
00243 #ifndef NUT_THREAD_TCPSMSTACK
00244 #define NUT_THREAD_TCPSMSTACK 512
00245 #endif
00246
00247 #ifndef TCP_RETRIES_MAX
00248 #define TCP_RETRIES_MAX 7
00249 #endif
00250
00251 extern TCPSOCKET *tcpSocketList;
00252
00257
00258 HANDLE tcp_in_rdy;
00259 NETBUF *volatile tcp_in_nbq;
00260 static u_short tcp_in_cnt;
00261 static HANDLE tcpThread = 0;
00262
00263
00264
00265
00266
00267
00276 static void NutTcpInputOptions(TCPSOCKET * sock, NETBUF * nb)
00277 {
00278 u_char *cp;
00279 u_short s;
00280
00281
00282 if (nb->nb_tp.sz <= sizeof (TCPHDR))
00283 return;
00284
00285
00286 for (cp = ((u_char*) nb->nb_tp.vp) + sizeof(TCPHDR); (*cp != TCPOPT_EOL)
00287 && (cp - (u_char *)nb->nb_tp.vp < (int)nb->nb_tp.sz); )
00288 {
00289 switch (*cp)
00290 {
00291
00292 case TCPOPT_NOP:
00293 cp++;
00294 continue;
00295
00296
00297 case TCPOPT_MAXSEG:
00298 s = ntohs(((u_short)cp[2] << 8) | cp[3]);
00299 if (s < sock->so_mss)
00300 sock->so_mss = s;
00301 cp += TCPOLEN_MAXSEG;
00302 break;
00303
00304 default:
00305 cp += *(u_char*) (cp + 1);
00306 break;
00307 }
00308 }
00309 }
00310
00319 static void NutTcpProcessAppData(TCPSOCKET * sock, NETBUF * nb)
00320 {
00321
00322
00323
00324 if (sock->so_rx_buf) {
00325 NETBUF *nbp = sock->so_rx_buf;
00326
00327 while (nbp->nb_next)
00328 nbp = nbp->nb_next;
00329 nbp->nb_next = nb;
00330 } else
00331 sock->so_rx_buf = nb;
00332
00333
00334
00335
00336
00337 sock->so_rx_cnt += nb->nb_ap.sz;
00338 sock->so_rx_nxt += nb->nb_ap.sz;
00339
00340
00341
00342
00343 if (nb->nb_ap.sz >= sock->so_rx_win)
00344 sock->so_rx_win = 0;
00345 else
00346 sock->so_rx_win -= nb->nb_ap.sz;
00347
00348
00349
00350
00351
00352
00353 sock->so_tx_flags |= SO_ACK;
00354 if (nb->nb_next)
00355 nb->nb_next = 0;
00356 else
00357 sock->so_tx_flags |= SO_FORCE;
00358
00359 NutTcpOutput(sock, 0, 0);
00360 }
00361
00362
00363
00364
00365 static void NutTcpProcessSyn(TCPSOCKET * sock, IPHDR * ih, TCPHDR * th)
00366 {
00367 u_short mss;
00368 NUTDEVICE *dev;
00369 IFNET *nif;
00370
00371 sock->so_local_addr = ih->ip_dst;
00372 sock->so_remote_port = th->th_sport;
00373 sock->so_remote_addr = ih->ip_src;
00374
00375 sock->so_rx_nxt = sock->so_tx_wl1 = sock->so_rx_isn = ntohl(th->th_seq);
00376 sock->so_rx_nxt++;
00377 sock->so_tx_win = ntohs(th->th_win);
00378
00379
00380
00381
00382
00383
00384 if ((dev = NutIpRouteQuery(ih->ip_src, 0)) != 0) {
00385 nif = dev->dev_icb;
00386 mss = nif->if_mtu - sizeof(IPHDR) - sizeof(TCPHDR);
00387 if (sock->so_mss == 0 || sock->so_mss > mss)
00388 sock->so_mss = mss;
00389
00390
00391 if (sock->so_devobsz > sock->so_mss)
00392 sock->so_devobsz = sock->so_mss;
00393 }
00394 }
00395
00403 static int NutTcpProcessAck(TCPSOCKET * sock, TCPHDR * th, u_short length)
00404 {
00405 NETBUF *nb;
00406 u_long h_seq;
00407 u_long h_ack;
00408
00409
00410
00411
00412 h_ack = ntohl(th->th_ack);
00413 if (h_ack > sock->so_tx_nxt) {
00414 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00415 return 0;
00416 }
00417
00418
00419
00420
00421
00422
00423 if (h_ack == sock->so_tx_una) {
00424 h_seq = ntohl(th->th_seq);
00425 if (h_seq > sock->so_tx_wl1 || (h_seq == sock->so_tx_wl1 && h_ack >= sock->so_tx_wl2)) {
00426 sock->so_tx_win = ntohs(th->th_win);
00427 sock->so_tx_wl1 = h_seq;
00428 sock->so_tx_wl2 = h_ack;
00429 }
00430 }
00431
00432
00433
00434
00435
00436 if (h_ack < sock->so_tx_una) {
00437 return 0;
00438 }
00439
00440
00441
00442
00443 if (h_ack == sock->so_tx_una) {
00444
00445
00446
00447
00448 if (sock->so_tx_nbq && length == 0 && (th->th_flags & (TH_SYN | TH_FIN)) == 0) {
00449
00450
00451
00452
00453 if (++sock->so_tx_dup >= 3) {
00454 sock->so_tx_dup = 0;
00455 #ifdef NUTDEBUG
00456 if (__tcp_trf)
00457 NutDumpTcpHeader(__tcp_trs, "RET", sock, sock->so_tx_nbq);
00458 #endif
00459
00460
00461
00462
00463 if (NutTcpStateRetranTimeout(sock))
00464 return -1;
00465 }
00466 }
00467 return 0;
00468 }
00469
00470
00471
00472
00473 sock->so_tx_dup = 0;
00474 sock->so_tx_una = h_ack;
00475
00476
00477
00478
00479
00480
00481 sock->so_tx_win = ntohs(th->th_win);
00482
00483
00484
00485
00486 if (sock->so_rtt_seq && sock->so_rtt_seq < h_ack)
00487 NutTcpCalcRtt (sock);
00488 sock->so_rtt_seq = 0;
00489
00490
00491
00492 while ((nb = sock->so_tx_nbq) != 0) {
00493
00494 h_seq = ntohl(((TCPHDR *) (nb->nb_tp.vp))->th_seq) + nb->nb_ap.sz;
00495 if (((TCPHDR *) (nb->nb_tp.vp))->th_flags & (TH_SYN | TH_FIN)) {
00496 h_seq++;
00497 }
00498
00499 if (h_seq > h_ack) {
00500 break;
00501 }
00502 sock->so_tx_nbq = nb->nb_next;
00503 NutNetBufFree(nb);
00504 }
00505
00506
00507
00508
00509 if (sock->so_tx_nbq) {
00510 sock->so_retran_time = (u_short) NutGetMillis() | 1;
00511 } else {
00512 sock->so_retran_time = 0;
00513 }
00514 sock->so_retransmits = 0;
00515
00516 return 0;
00517 }
00518
00519
00520
00521
00522
00523
00524
00533 static int NutTcpStateChange(TCPSOCKET * sock, u_char state)
00534 {
00535 int rc = 0;
00536 ureg_t txf = 0;
00537
00538 switch (sock->so_state) {
00539
00540 case TCPS_ESTABLISHED:
00541 switch (state) {
00542 case TCPS_FIN_WAIT_1:
00543
00544
00545
00546 sock->so_tx_flags |= SO_FIN | SO_ACK;
00547 txf = 1;
00548
00549 #ifdef RTLCONNECTHACK
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559 NutDelay(5);
00560 #endif
00561 break;
00562 case TCPS_CLOSE_WAIT:
00563
00564
00565
00566 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00567 txf = 1;
00568 break;
00569 default:
00570 rc = -1;
00571 break;
00572 }
00573 break;
00574
00575 case TCPS_LISTEN:
00576
00577
00578
00579 if (state == TCPS_SYN_RECEIVED) {
00580 sock->so_tx_flags |= SO_SYN | SO_ACK;
00581 txf = 1;
00582 #ifdef RTLCONNECTHACK
00583
00584
00585
00586
00587
00588
00589
00590
00591
00592 NutDelay(5);
00593 #endif
00594 } else
00595 rc = -1;
00596 break;
00597
00598 case TCPS_SYN_SENT:
00599 switch (state) {
00600 case TCPS_LISTEN:
00601
00602
00603
00604 break;
00605 case TCPS_SYN_RECEIVED:
00606
00607
00608
00609 sock->so_tx_flags |= SO_SYN | SO_ACK;
00610 txf = 1;
00611 break;
00612 case TCPS_ESTABLISHED:
00613
00614
00615
00616 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00617 txf = 1;
00618 break;
00619 default:
00620 rc = -1;
00621 break;
00622 }
00623 break;
00624
00625 case TCPS_SYN_RECEIVED:
00626 switch (state) {
00627 case TCPS_LISTEN:
00628
00629
00630
00631 break;
00632 case TCPS_ESTABLISHED:
00633
00634
00635
00636 break;
00637 case TCPS_FIN_WAIT_1:
00638
00639
00640
00641 sock->so_tx_flags |= SO_FIN;
00642 txf = 1;
00643 break;
00644 case TCPS_CLOSE_WAIT:
00645
00646
00647
00648 sock->so_tx_flags |= SO_FIN | SO_ACK;
00649 txf = 1;
00650 break;
00651 default:
00652 rc = -1;
00653 break;
00654 }
00655 break;
00656
00657 case TCPS_FIN_WAIT_1:
00658 switch (state) {
00659 case TCPS_FIN_WAIT_1:
00660 case TCPS_FIN_WAIT_2:
00661
00662
00663
00664 break;
00665 case TCPS_CLOSING:
00666
00667
00668
00669 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00670 txf = 1;
00671 break;
00672 case TCPS_TIME_WAIT:
00673
00674
00675
00676 break;
00677 default:
00678 rc = -1;
00679 break;
00680 }
00681 break;
00682
00683 case TCPS_FIN_WAIT_2:
00684
00685
00686
00687 if (state != TCPS_TIME_WAIT)
00688 rc = -1;
00689 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00690 txf = 1;
00691 break;
00692
00693 case TCPS_CLOSE_WAIT:
00694
00695
00696
00697 if (state == TCPS_LAST_ACK) {
00698 sock->so_tx_flags |= SO_FIN | SO_ACK;
00699 txf = 1;
00700 } else
00701 rc = -1;
00702 break;
00703
00704 case TCPS_CLOSING:
00705
00706
00707
00708 if (state != TCPS_TIME_WAIT)
00709 rc = -1;
00710 break;
00711
00712 case TCPS_LAST_ACK:
00713 rc = -1;
00714 break;
00715
00716 case TCPS_TIME_WAIT:
00717 rc = -1;
00718 break;
00719
00720 case TCPS_CLOSED:
00721 switch (state) {
00722 case TCPS_LISTEN:
00723
00724
00725
00726 break;
00727 case TCPS_SYN_SENT:
00728
00729
00730
00731 sock->so_tx_flags |= SO_SYN;
00732 txf = 1;
00733 break;
00734 default:
00735 rc = -1;
00736 break;
00737 }
00738 break;
00739 }
00740 #ifdef NUTDEBUG
00741 if (__tcp_trf) {
00742 fprintf(__tcp_trs, " %04x-", (u_int) sock);
00743 if (rc)
00744 NutDumpSockState(__tcp_trs, sock->so_state, "**ERR ", "**>");
00745 NutDumpSockState(__tcp_trs, state, "[>", "]");
00746 }
00747 #endif
00748
00749 if (rc == 0) {
00750 sock->so_state = state;
00751 if (txf && NutTcpOutput(sock, 0, 0)) {
00752 if (state == TCPS_SYN_SENT) {
00753 rc = -1;
00754 sock->so_last_error = EHOSTDOWN;
00755 NutEventPostAsync(&sock->so_ac_tq);
00756 }
00757 }
00758 if (state == TCPS_CLOSE_WAIT) {
00759
00760
00761
00762 NutEventBroadcast(&sock->so_rx_tq);
00763 NutEventBroadcast(&sock->so_pc_tq);
00764 NutEventBroadcast(&sock->so_ac_tq);
00765 }
00766 }
00767 return rc;
00768 }
00769
00770
00771
00772
00773
00782 int NutTcpStatePassiveOpenEvent(TCPSOCKET * sock)
00783 {
00784 if (sock->so_state != TCPS_CLOSED)
00785 return (sock->so_last_error = EISCONN);
00786
00787 NutTcpStateChange(sock, TCPS_LISTEN);
00788
00789
00790
00791
00792 NutEventWait(&sock->so_pc_tq, 0);
00793
00794 return 0;
00795 }
00796
00807 int NutTcpStateActiveOpenEvent(TCPSOCKET * sock)
00808 {
00809
00810
00811
00812
00813 NutTcpStateChange(sock, TCPS_SYN_SENT);
00814
00815
00816
00817
00818 if(sock->so_state == TCPS_SYN_SENT)
00819 NutEventWait(&sock->so_ac_tq, 0);
00820
00821 if (sock->so_state != TCPS_ESTABLISHED)
00822 return -1;
00823
00824 return 0;
00825 }
00826
00839 int NutTcpStateCloseEvent(TCPSOCKET * sock)
00840 {
00841 if (sock == 0)
00842 return -1;
00843
00844 NutThreadYield();
00845
00846 switch (sock->so_state) {
00847 case TCPS_LISTEN:
00848 case TCPS_SYN_SENT:
00849 case TCPS_CLOSED:
00850
00851
00852
00853 NutTcpDestroySocket(sock);
00854 break;
00855
00856 case TCPS_SYN_RECEIVED:
00857 case TCPS_ESTABLISHED:
00858
00859
00860
00861
00862 NutTcpStateChange(sock, TCPS_FIN_WAIT_1);
00863 break;
00864
00865 case TCPS_CLOSE_WAIT:
00866
00867
00868
00869
00870 NutTcpStateChange(sock, TCPS_LAST_ACK);
00871 break;
00872
00873 case TCPS_FIN_WAIT_1:
00874 case TCPS_FIN_WAIT_2:
00875 case TCPS_CLOSING:
00876 case TCPS_LAST_ACK:
00877 case TCPS_TIME_WAIT:
00878 sock->so_last_error = EALREADY;
00879 return -1;
00880
00881 default:
00882 sock->so_last_error = ENOTCONN;
00883 return -1;
00884 }
00885 return 0;
00886 }
00887
00894 int NutTcpStateWindowEvent(TCPSOCKET * sock)
00895 {
00896 if (sock == 0)
00897 return -1;
00898 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00899 NutTcpOutput(sock, 0, 0);
00900
00901 return 0;
00902 }
00903
00904
00905
00906
00907
00919 int NutTcpStateRetranTimeout(TCPSOCKET * sock)
00920 {
00921 NETBUF *so_tx_next;
00922 if (sock->so_retransmits++ > TCP_RETRIES_MAX)
00923 {
00924
00925 NutTcpAbortSocket(sock, ETIMEDOUT);
00926 return -1;
00927 } else {
00928 #ifdef NUTDEBUG
00929 if (__tcp_trf)
00930 NutDumpTcpHeader(__tcp_trs, "RET", sock, sock->so_tx_nbq);
00931 #endif
00932
00933
00934
00935
00936 so_tx_next = sock->so_tx_nbq->nb_next;
00937 if (NutIpOutput(IPPROTO_TCP, sock->so_remote_addr, sock->so_tx_nbq)) {
00938
00939 sock->so_tx_nbq = so_tx_next;
00940
00941 NutTcpAbortSocket(sock, ENETDOWN);
00942 return -1;
00943 } else {
00944
00945 sock->so_retran_time = (u_short) NutGetMillis() | 1;
00946 return 0;
00947 }
00948 }
00949 }
00950
00951
00952
00953
00954
00955
00965 static void NutTcpStateListen(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
00966 {
00967
00968
00969
00970
00971 if ((flags & (TH_SYN | TH_ACK | TH_RST)) == TH_SYN) {
00972 NutTcpProcessSyn(sock, nb->nb_nw.vp, th);
00973 NutTcpStateChange(sock, TCPS_SYN_RECEIVED);
00974 NutNetBufFree(nb);
00975 } else
00976 NutTcpReject(nb);
00977 }
00978
00979
00988 static void NutTcpStateSynSent(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
00989 {
00990
00991
00992
00993 if (flags & TH_ACK) {
00994 if (!IsInLimits(ntohl(th->th_ack), sock->so_tx_isn + 1, sock->so_tx_nxt)) {
00995 NutTcpReject(nb);
00996 return;
00997 }
00998 }
00999
01000
01001
01002
01003
01004
01005 if (flags & TH_RST) {
01006 if (flags & TH_ACK) {
01007
01008
01009
01010 NutTcpAbortSocket(sock, ECONNREFUSED);
01011 }
01012 NutNetBufFree(nb);
01013 return;
01014 }
01015
01016
01017
01018
01019
01020
01021 if (flags & TH_SYN) {
01022 NutTcpProcessSyn(sock, nb->nb_nw.vp, th);
01023 if (flags & TH_ACK) {
01024 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01025 NutTcpStateChange(sock, TCPS_ESTABLISHED);
01026
01027 NutEventPost(&sock->so_ac_tq);
01028 } else {
01029 NutTcpStateChange(sock, TCPS_SYN_RECEIVED);
01030 }
01031 }
01032 NutNetBufFree(nb);
01033 }
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046 static void NutTcpStateSynReceived(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01047 {
01048
01049
01050
01051
01052 if (flags & TH_RST) {
01053 if (sock->so_pc_tq)
01054 NutTcpStateChange(sock, TCPS_LISTEN);
01055 else
01056 NutTcpAbortSocket(sock, ECONNREFUSED);
01057 NutNetBufFree(nb);
01058 sock->so_retran_time = 0;
01059 NutTcpDiscardBuffers(sock);
01060 return;
01061 }
01062
01063
01064
01065
01066 if (flags & TH_SYN) {
01067 NutTcpReject(nb);
01068 return;
01069 }
01070
01071
01072
01073
01074 if ((flags & TH_ACK) == 0) {
01075 NutNetBufFree(nb);
01076 return;
01077 }
01078
01079
01080
01081
01082 if (!IsInLimits(ntohl(th->th_ack), sock->so_tx_una + 1, sock->so_tx_nxt)) {
01083 NutTcpReject(nb);
01084 return;
01085 }
01086
01087
01088 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01089
01090
01091
01092
01093
01094
01095
01096 if (nb->nb_ap.sz)
01097 NutTcpProcessAppData(sock, nb);
01098 else
01099 NutNetBufFree(nb);
01100
01101
01102
01103
01104 if (flags & TH_FIN) {
01105 sock->so_rx_nxt++;
01106 NutTcpStateChange(sock, TCPS_CLOSE_WAIT);
01107 } else {
01108 NutTcpStateChange(sock, TCPS_ESTABLISHED);
01109 NutEventPost(&sock->so_pc_tq);
01110 NutEventPost(&sock->so_ac_tq);
01111 }
01112 }
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128 static void NutTcpStateEstablished(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01129 {
01130 if (flags & TH_RST) {
01131 NutNetBufFree(nb);
01132 NutTcpAbortSocket(sock, ECONNRESET);
01133 return;
01134 }
01135
01136
01137
01138
01139
01140 if (flags & TH_SYN) {
01141 if (htonl(th->th_seq) != sock->so_rx_isn)
01142 NutTcpReject(nb);
01143 else
01144 NutNetBufFree(nb);
01145 return;
01146 }
01147
01148
01149
01150
01151 if ((flags & TH_ACK) == 0) {
01152 NutNetBufFree(nb);
01153 return;
01154 }
01155
01156 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01157
01158
01159
01160
01161
01162
01163
01164 if (htonl(th->th_seq) > sock->so_rx_nxt) {
01165 NETBUF *nbq;
01166 NETBUF **nbqp;
01167 TCPHDR *thq;
01168 u_long th_seq;
01169 u_long thq_seq;
01170
01171 if (nb->nb_ap.sz) {
01172 nbq = sock->so_rx_nbq;
01173 nbqp = &sock->so_rx_nbq;
01174 while (nbq) {
01175 thq = (TCPHDR *) (nbq->nb_tp.vp);
01176 th_seq = htonl(th->th_seq);
01177 thq_seq = htonl(thq->th_seq);
01178 if (th_seq < thq_seq) {
01179 *nbqp = nb;
01180 nb->nb_next = nbq;
01181 break;
01182 }
01183 if (th_seq == thq_seq) {
01184 NutNetBufFree(nb);
01185 sock->so_tx_flags |= SO_ACK | SO_FORCE;
01186 NutTcpOutput(sock, 0, 0);
01187 return;
01188 }
01189 nbqp = &nbq->nb_next;
01190 nbq = nbq->nb_next;
01191 }
01192 if (nbq == 0) {
01193 *nbqp = nb;
01194 nb->nb_next = 0;
01195 }
01196 } else
01197 NutNetBufFree(nb);
01198
01199 sock->so_tx_flags |= SO_ACK | SO_FORCE;
01200 NutTcpOutput(sock, 0, 0);
01201 return;
01202 }
01203
01204
01205
01206
01207
01208
01209
01210
01211 if (htonl(th->th_seq) != sock->so_rx_nxt) {
01212 sock->so_tx_flags |= SO_ACK | SO_FORCE;
01213
01214 sock->so_oos_drop++;
01215 NutNetBufFree(nb);
01216 NutTcpOutput(sock, 0, 0);
01217 }
01218
01219
01220
01221
01222 else if (nb->nb_ap.sz) {
01223 NutTcpProcessAppData(sock, nb);
01224
01225
01226
01227 while ((nb = sock->so_rx_nbq) != 0) {
01228 th = (TCPHDR *) (nb->nb_tp.vp);
01229 if (htonl(th->th_seq) > sock->so_rx_nxt)
01230 break;
01231 sock->so_rx_nbq = nb->nb_next;
01232 if (htonl(th->th_seq) == sock->so_rx_nxt) {
01233 NutTcpProcessAppData(sock, nb);
01234 flags |= th->th_flags;
01235 } else
01236 NutNetBufFree(nb);
01237 }
01238
01239 NutEventPost(&sock->so_rx_tq);
01240 } else {
01241 NutNetBufFree(nb);
01242
01243
01244 }
01245 if (flags & TH_FIN) {
01246
01247 sock->so_rx_nxt++;
01248 NutTcpStateChange(sock, TCPS_CLOSE_WAIT);
01249 }
01250 }
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263
01264
01265
01266
01267 static void NutTcpStateFinWait1(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01268 {
01269
01270 if (flags & TH_RST) {
01271 NutNetBufFree(nb);
01272 NutTcpDestroySocket(sock);
01273 return;
01274 }
01275
01276
01277
01278
01279 if (flags & TH_SYN) {
01280 NutTcpReject(nb);
01281 return;
01282 }
01283
01284
01285
01286
01287 if ((flags & TH_ACK) == 0) {
01288 NutNetBufFree(nb);
01289 return;
01290 }
01291
01292
01293
01294
01295
01296 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01297
01298
01299
01300
01301
01302 if (sock->so_tx_nxt == sock->so_tx_una) {
01303
01304 NutTcpStateChange(sock, TCPS_FIN_WAIT_2);
01305 }
01306
01307
01308
01309
01310
01311 if (nb->nb_ap.sz) {
01312 NutTcpProcessAppData(sock, nb);
01313
01314 NutEventPost(&sock->so_rx_tq);
01315 }
01316 else
01317 NutNetBufFree(nb);
01318
01319 if (flags & TH_FIN) {
01320 sock->so_rx_nxt++;
01321
01322
01323
01324 sock->so_time_wait = 0;
01325
01326 if (sock->so_state == TCPS_FIN_WAIT_2)
01327 NutTcpStateChange(sock, TCPS_TIME_WAIT);
01328 else
01329 NutTcpStateChange(sock, TCPS_CLOSING);
01330 }
01331 }
01332
01333
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346 static void NutTcpStateFinWait2(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01347 {
01348
01349 if (flags & TH_RST) {
01350 NutNetBufFree(nb);
01351 NutTcpDestroySocket(sock);
01352 return;
01353 }
01354
01355
01356
01357
01358 if (flags & TH_SYN) {
01359 NutTcpReject(nb);
01360 return;
01361 }
01362
01363
01364
01365
01366 if ((flags & TH_ACK) == 0) {
01367 NutNetBufFree(nb);
01368 return;
01369 }
01370
01371
01372
01373
01374
01375
01376 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01377
01378
01379
01380 if (nb->nb_ap.sz) {
01381 NutTcpProcessAppData(sock, nb);
01382
01383 NutEventPost(&sock->so_rx_tq);
01384 }
01385 else
01386 NutNetBufFree(nb);
01387
01388 if (flags & TH_FIN) {
01389 sock->so_rx_nxt++;
01390 sock->so_time_wait = 0;
01391
01392 NutTcpStateChange(sock, TCPS_TIME_WAIT);
01393 }
01394 }
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406 static void NutTcpStateCloseWait(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01407 {
01408
01409 if (flags & TH_RST) {
01410 NutNetBufFree(nb);
01411 NutTcpAbortSocket(sock, ECONNRESET);
01412 return;
01413 }
01414
01415
01416
01417
01418 if (flags & TH_SYN) {
01419 NutTcpReject(nb);
01420 return;
01421 }
01422
01423
01424
01425
01426 if ((flags & TH_ACK) == 0) {
01427 NutNetBufFree(nb);
01428 return;
01429 }
01430
01431 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01432
01433 NutNetBufFree(nb);
01434 }
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444
01445
01446
01447
01448 static void NutTcpStateClosing(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01449 {
01450
01451 if (flags & TH_RST) {
01452 NutNetBufFree(nb);
01453 NutTcpDestroySocket(sock);
01454 return;
01455 }
01456
01457
01458
01459
01460 if (flags & TH_SYN) {
01461 NutTcpReject(nb);
01462 return;
01463 }
01464
01465
01466
01467
01468 if ((flags & TH_ACK) == 0) {
01469 NutNetBufFree(nb);
01470 return;
01471 }
01472
01473 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01474
01475
01476
01477
01478 if (sock->so_tx_nxt == sock->so_tx_una) {
01479 sock->so_time_wait = 0;
01480 NutTcpStateChange(sock, TCPS_TIME_WAIT);
01481
01482 }
01483
01484
01485 NutNetBufFree(nb);
01486 }
01487
01502 static void NutTcpStateLastAck(TCPSOCKET * sock, u_char flags, TCPHDR * th, NETBUF * nb)
01503 {
01504
01505 if (flags & TH_RST) {
01506 NutNetBufFree(nb);
01507 NutTcpDestroySocket(sock);
01508 return;
01509 }
01510
01511
01512
01513
01514 if (flags & TH_SYN) {
01515 NutTcpReject(nb);
01516 return;
01517 }
01518
01519
01520
01521
01522 if ((flags & TH_ACK) == 0) {
01523 NutNetBufFree(nb);
01524 return;
01525 }
01526
01527 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01528 NutNetBufFree(nb);
01529
01530 if (sock->so_tx_nxt == sock->so_tx_una)
01531 NutTcpDestroySocket(sock);
01532
01533 }
01534
01545 static void NutTcpStateProcess(TCPSOCKET * sock, NETBUF * nb)
01546 {
01547 u_long tx_win;
01548 u_long tx_una;
01549 TCPHDR *th = (TCPHDR *) nb->nb_tp.vp;
01550 u_char flags = th->th_flags;
01551
01552 #ifdef NUTDEBUG
01553 if (__tcp_trf) {
01554 fprintf(__tcp_trs, " %04x-", (u_int) sock);
01555 NutDumpSockState(__tcp_trs, sock->so_state, "[", ">]");
01556 }
01557 #endif
01558 switch (sock->so_state) {
01559
01560 case TCPS_ESTABLISHED:
01561 tx_win = sock->so_tx_win;
01562 tx_una = sock->so_tx_una;
01563 NutTcpStateEstablished(sock, flags, th, nb);
01564
01565 if(sock->so_state != TCPS_ESTABLISHED ||
01566 sock->so_tx_win > tx_win ||
01567 sock->so_tx_una > tx_una) {
01568 NutEventBroadcast(&sock->so_tx_tq);
01569 }
01570 break;
01571 case TCPS_LISTEN:
01572 NutTcpStateListen(sock, flags, th, nb);
01573 break;
01574 case TCPS_SYN_SENT:
01575 NutTcpStateSynSent(sock, flags, th, nb);
01576 break;
01577 case TCPS_SYN_RECEIVED:
01578 NutTcpStateSynReceived(sock, flags, th, nb);
01579 break;
01580 case TCPS_FIN_WAIT_1:
01581 NutTcpStateFinWait1(sock, flags, th, nb);
01582 break;
01583 case TCPS_FIN_WAIT_2:
01584 NutTcpStateFinWait2(sock, flags, th, nb);
01585 break;
01586 case TCPS_CLOSE_WAIT:
01587 NutTcpStateCloseWait(sock, flags, th, nb);
01588 break;
01589 case TCPS_CLOSING:
01590 NutTcpStateClosing(sock, flags, th, nb);
01591 break;
01592 case TCPS_LAST_ACK:
01593 NutTcpStateLastAck(sock, flags, th, nb);
01594 break;
01595 case TCPS_TIME_WAIT:
01596
01597
01598
01599 NutNetBufFree(nb);
01600 break;
01601 case TCPS_CLOSED:
01602
01603
01604
01605 NutTcpReject(nb);
01606 break;
01607 default:
01608 NutNetBufFree(nb);
01609 break;
01610 }
01611 }
01612
01619 THREAD(NutTcpSm, arg)
01620 {
01621 NETBUF *nb;
01622 NETBUF *nbx;
01623 TCPHDR *th;
01624 IPHDR *ih;
01625 TCPSOCKET *sock;
01626 u_char tac = 0;
01627
01628
01629
01630
01631
01632 NutThreadSetPriority (32);
01633
01634 for (;;) {
01635 if (++tac > 3 || NutEventWait(&tcp_in_rdy, 200)) {
01636 tac = 0;
01637 for (sock = tcpSocketList; sock; sock = sock->so_next) {
01638
01639
01640
01641
01642 if (sock->so_tx_flags & SO_ACK) {
01643 sock->so_tx_flags |= SO_FORCE;
01644 NutTcpOutput(sock, 0, 0);
01645 }
01646
01647
01648
01649
01650 if (sock->so_tx_nbq && sock->so_retran_time) {
01651 if ((u_short)((u_short)NutGetMillis() - sock->so_retran_time) > sock->so_rtto) {
01652 NutTcpStateRetranTimeout(sock);
01653 }
01654 }
01655
01656
01657
01658
01659 if (sock->so_state == TCPS_TIME_WAIT || sock->so_state == TCPS_FIN_WAIT_2) {
01660 if (sock->so_time_wait++ >= 9) {
01661 NutTcpDestroySocket(sock);
01662 break;
01663 }
01664 }
01665
01666
01667
01668
01669 else if (sock->so_state == TCPS_SYN_RECEIVED) {
01670 if (sock->so_time_wait++ >= 45) {
01671 sock->so_state = TCPS_LISTEN;
01672 sock->so_time_wait = 0;
01673 }
01674 }
01675 }
01676 } else {
01677 nb = tcp_in_nbq;
01678 tcp_in_nbq = 0;
01679 tcp_in_cnt = 0;
01680 while (nb) {
01681 ih = (IPHDR *) nb->nb_nw.vp;
01682 th = (TCPHDR *) nb->nb_tp.vp;
01683 sock = NutTcpFindSocket(th->th_dport, th->th_sport, ih->ip_src);
01684 #ifdef NUTDEBUG
01685 if (__tcp_trf)
01686 NutDumpTcpHeader(__tcp_trs, " IN", sock, nb);
01687 #endif
01688 nbx = nb->nb_next;
01689 if (sock) {
01690 NutTcpInputOptions(sock, nb);
01691 NutTcpStateProcess(sock, nb);
01692 }
01693
01694
01695
01696
01697 else
01698 NutTcpReject(nb);
01699 nb = nbx;
01700 }
01701 }
01702 }
01703 }
01704
01716 void NutTcpStateMachine(NETBUF * nb)
01717 {
01718 NETBUF *nbp;
01719 u_short size;
01720
01721 nb->nb_next = 0;
01722
01723
01724
01725
01726
01727
01728
01729 if (tcpThread == 0) {
01730 NutTcpReject(nb);
01731 return;
01732 }
01733
01734 if ((nbp = tcp_in_nbq) == 0) {
01735 tcp_in_nbq = nb;
01736 NutEventPost(&tcp_in_rdy);
01737 } else {
01738 size = nb->nb_nw.sz + nb->nb_tp.sz + nb->nb_ap.sz;
01739 if (tcp_in_cnt + size + 2048 < NutHeapAvailable()) {
01740 tcp_in_cnt += size;
01741 while (nbp->nb_next)
01742 nbp = nbp->nb_next;
01743 nbp->nb_next = nb;
01744 NutEventPost(&tcp_in_rdy);
01745 } else
01746 NutNetBufFree(nb);
01747 }
01748 }
01749
01758 int NutTcpInitStateMachine(void)
01759 {
01760 if (tcpThread == 0 && (tcpThread = NutThreadCreate("tcpsm", NutTcpSm, NULL, NUT_THREAD_TCPSMSTACK)) == 0)
01761 return -1;
01762 return 0;
01763 }
01764
01778 int NutTcpAbortSocket(TCPSOCKET * sock, u_short last_error)
01779 {
01780 sock->so_last_error = last_error;
01781 sock->so_retran_time = 0;
01782 sock->so_time_wait = 0;
01783
01784
01785
01786
01787
01788 if (sock->so_state >= TCPS_FIN_WAIT_1)
01789 sock->so_state = TCPS_TIME_WAIT;
01790 else
01791 sock->so_state = TCPS_CLOSED;
01792 NutTcpDiscardBuffers(sock);
01793 NutEventBroadcast(&sock->so_rx_tq);
01794 NutEventBroadcast(&sock->so_tx_tq);
01795 NutEventBroadcast(&sock->so_pc_tq);
01796 NutEventBroadcast(&sock->so_ac_tq);
01797 return 0;
01798 }
01799