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
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233 #include <cfg/os.h>
00234 #include <cfg/tcp.h>
00235
00236 #include <sys/thread.h>
00237 #include <sys/heap.h>
00238 #include <sys/event.h>
00239 #include <sys/timer.h>
00240
00241 #include <net/errno.h>
00242 #include <netinet/in.h>
00243 #include <netinet/ip.h>
00244 #include <net/route.h>
00245 #include <sys/socket.h>
00246 #include <netinet/tcputil.h>
00247 #include <netinet/tcp.h>
00248
00249 #ifdef NUTDEBUG
00250 #include <net/netdebug.h>
00251 #endif
00252
00253 #ifndef NUT_THREAD_TCPSMSTACK
00254 #if defined(__AVR__)
00255
00256 #define NUT_THREAD_TCPSMSTACK 256
00257 #else
00258
00259 #define NUT_THREAD_TCPSMSTACK 384
00260 #endif
00261 #endif
00262
00263 #ifndef TCP_RETRIES_MAX
00264 #define TCP_RETRIES_MAX 7
00265 #endif
00266
00267 extern TCPSOCKET *tcpSocketList;
00268
00273
00274 HANDLE tcp_in_rdy;
00275 NETBUF *volatile tcp_in_nbq;
00276 static uint16_t tcp_in_cnt;
00277 static HANDLE tcpThread = 0;
00278
00279
00280
00281
00282
00283
00292 static void NutTcpInputOptions(TCPSOCKET * sock, NETBUF * nb)
00293 {
00294 uint8_t *cp;
00295 uint16_t s;
00296
00297
00298 if (nb->nb_tp.sz <= sizeof (TCPHDR))
00299 return;
00300
00301
00302 for (cp = ((uint8_t*) nb->nb_tp.vp) + sizeof(TCPHDR); (*cp != TCPOPT_EOL)
00303 && (cp - (uint8_t *)nb->nb_tp.vp < (int)nb->nb_tp.sz); )
00304 {
00305 switch (*cp)
00306 {
00307
00308 case TCPOPT_NOP:
00309 cp++;
00310 continue;
00311
00312
00313 case TCPOPT_MAXSEG:
00314 s = ntohs(((uint16_t)cp[2] << 8) | cp[3]);
00315 if (s < sock->so_mss)
00316 sock->so_mss = s;
00317 cp += TCPOLEN_MAXSEG;
00318 break;
00319
00320 default:
00321 cp += *(uint8_t*) (cp + 1);
00322 break;
00323 }
00324 }
00325 }
00326
00335 static void NutTcpProcessAppData(TCPSOCKET * sock, NETBUF * nb)
00336 {
00337
00338
00339
00340 if (sock->so_rx_buf) {
00341 NETBUF *nbp = sock->so_rx_buf;
00342
00343 while (nbp->nb_next)
00344 nbp = nbp->nb_next;
00345 nbp->nb_next = nb;
00346 } else
00347 sock->so_rx_buf = nb;
00348
00349
00350
00351
00352
00353 sock->so_rx_cnt += nb->nb_ap.sz;
00354 sock->so_rx_nxt += nb->nb_ap.sz;
00355
00356
00357
00358
00359 if (nb->nb_ap.sz >= sock->so_rx_win)
00360 sock->so_rx_win = 0;
00361 else
00362 sock->so_rx_win -= nb->nb_ap.sz;
00363
00364
00365
00366
00367
00368
00369 sock->so_tx_flags |= SO_ACK;
00370 if (nb->nb_next)
00371 nb->nb_next = 0;
00372 else
00373 sock->so_tx_flags |= SO_FORCE;
00374
00375 NutTcpOutput(sock, 0, 0);
00376 }
00377
00378
00379
00380
00381 static void NutTcpProcessSyn(TCPSOCKET * sock, IPHDR * ih, TCPHDR * th)
00382 {
00383 uint16_t mss;
00384 NUTDEVICE *dev;
00385 IFNET *nif;
00386
00387 sock->so_local_addr = ih->ip_dst;
00388 sock->so_remote_port = th->th_sport;
00389 sock->so_remote_addr = ih->ip_src;
00390
00391 sock->so_rx_nxt = sock->so_tx_wl1 = sock->so_rx_isn = ntohl(th->th_seq);
00392 sock->so_rx_nxt++;
00393 sock->so_tx_win = ntohs(th->th_win);
00394
00395
00396
00397
00398
00399
00400 if ((dev = NutIpRouteQuery(ih->ip_src, 0)) != 0) {
00401 nif = dev->dev_icb;
00402 mss = nif->if_mtu - sizeof(IPHDR) - sizeof(TCPHDR);
00403 if (sock->so_mss == 0 || sock->so_mss > mss)
00404 sock->so_mss = mss;
00405
00406
00407 if (sock->so_devobsz > sock->so_mss)
00408 sock->so_devobsz = sock->so_mss;
00409 }
00410 }
00411
00419 static int NutTcpProcessAck(TCPSOCKET * sock, TCPHDR * th, uint16_t length)
00420 {
00421 NETBUF *nb;
00422 uint32_t h_seq;
00423 uint32_t h_ack;
00424
00425
00426
00427
00428 h_ack = ntohl(th->th_ack);
00429 if (h_ack > sock->so_tx_nxt) {
00430 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00431 return 0;
00432 }
00433
00434
00435
00436
00437
00438
00439 if (h_ack == sock->so_tx_una) {
00440 h_seq = ntohl(th->th_seq);
00441 if (h_seq > sock->so_tx_wl1 || (h_seq == sock->so_tx_wl1 && h_ack >= sock->so_tx_wl2)) {
00442 sock->so_tx_win = ntohs(th->th_win);
00443 sock->so_tx_wl1 = h_seq;
00444 sock->so_tx_wl2 = h_ack;
00445 }
00446 }
00447
00448
00449
00450
00451
00452 if (h_ack < sock->so_tx_una) {
00453 return 0;
00454 }
00455
00456
00457
00458
00459 if (h_ack == sock->so_tx_una) {
00460
00461
00462
00463
00464 if (sock->so_tx_nbq && length == 0 && (th->th_flags & (TH_SYN | TH_FIN)) == 0) {
00465
00466
00467
00468
00469 if (++sock->so_tx_dup >= 3) {
00470 sock->so_tx_dup = 0;
00471 #ifdef NUTDEBUG
00472 if (__tcp_trf)
00473 NutDumpTcpHeader(__tcp_trs, "RET", sock, sock->so_tx_nbq);
00474 #endif
00475
00476
00477
00478
00479 if (NutTcpStateRetranTimeout(sock))
00480 return -1;
00481 }
00482 }
00483 return 0;
00484 }
00485
00486
00487
00488
00489 sock->so_tx_dup = 0;
00490 sock->so_tx_una = h_ack;
00491
00492
00493
00494
00495
00496
00497 sock->so_tx_win = ntohs(th->th_win);
00498
00499
00500
00501
00502 if (sock->so_rtt_seq && sock->so_rtt_seq < h_ack)
00503 NutTcpCalcRtt (sock);
00504 sock->so_rtt_seq = 0;
00505
00506
00507
00508 while ((nb = sock->so_tx_nbq) != 0) {
00509
00510 h_seq = ntohl(((TCPHDR *) (nb->nb_tp.vp))->th_seq) + nb->nb_ap.sz;
00511 if (((TCPHDR *) (nb->nb_tp.vp))->th_flags & (TH_SYN | TH_FIN)) {
00512 h_seq++;
00513 }
00514
00515 if (h_seq > h_ack) {
00516 break;
00517 }
00518 sock->so_tx_nbq = nb->nb_next;
00519 NutNetBufFree(nb);
00520 }
00521
00522
00523
00524
00525 if (sock->so_tx_nbq) {
00526 sock->so_retran_time = (uint16_t) NutGetMillis() | 1;
00527 } else {
00528 sock->so_retran_time = 0;
00529 }
00530 sock->so_retransmits = 0;
00531
00532 return 0;
00533 }
00534
00535
00536
00537
00538
00539
00540
00549 static int NutTcpStateChange(TCPSOCKET * sock, uint8_t state)
00550 {
00551 int rc = 0;
00552 ureg_t txf = 0;
00553
00554 switch (sock->so_state) {
00555
00556 case TCPS_ESTABLISHED:
00557 switch (state) {
00558 case TCPS_FIN_WAIT_1:
00559
00560
00561
00562 sock->so_tx_flags |= SO_FIN | SO_ACK;
00563 txf = 1;
00564
00565 #ifdef RTLCONNECTHACK
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575 NutDelay(5);
00576 #endif
00577 break;
00578 case TCPS_CLOSE_WAIT:
00579
00580
00581
00582 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00583 txf = 1;
00584 break;
00585 default:
00586 rc = -1;
00587 break;
00588 }
00589 break;
00590
00591 case TCPS_LISTEN:
00592
00593
00594
00595 if (state == TCPS_SYN_RECEIVED) {
00596 sock->so_tx_flags |= SO_SYN | SO_ACK;
00597 txf = 1;
00598 #ifdef RTLCONNECTHACK
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608 NutDelay(5);
00609 #endif
00610 } else
00611 rc = -1;
00612 break;
00613
00614 case TCPS_SYN_SENT:
00615 switch (state) {
00616 case TCPS_LISTEN:
00617
00618
00619
00620 break;
00621 case TCPS_SYN_RECEIVED:
00622
00623
00624
00625 sock->so_tx_flags |= SO_SYN | SO_ACK;
00626 txf = 1;
00627 break;
00628 case TCPS_ESTABLISHED:
00629
00630
00631
00632 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00633 txf = 1;
00634 break;
00635 default:
00636 rc = -1;
00637 break;
00638 }
00639 break;
00640
00641 case TCPS_SYN_RECEIVED:
00642 switch (state) {
00643 case TCPS_LISTEN:
00644
00645
00646
00647 break;
00648 case TCPS_ESTABLISHED:
00649
00650
00651
00652 break;
00653 case TCPS_FIN_WAIT_1:
00654
00655
00656
00657 sock->so_tx_flags |= SO_FIN;
00658 txf = 1;
00659 break;
00660 case TCPS_CLOSE_WAIT:
00661
00662
00663
00664 sock->so_tx_flags |= SO_FIN | SO_ACK;
00665 txf = 1;
00666 break;
00667 default:
00668 rc = -1;
00669 break;
00670 }
00671 break;
00672
00673 case TCPS_FIN_WAIT_1:
00674 switch (state) {
00675 case TCPS_FIN_WAIT_1:
00676 case TCPS_FIN_WAIT_2:
00677
00678
00679
00680 break;
00681 case TCPS_CLOSING:
00682
00683
00684
00685 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00686 txf = 1;
00687 break;
00688 case TCPS_TIME_WAIT:
00689
00690
00691
00692 break;
00693 default:
00694 rc = -1;
00695 break;
00696 }
00697 break;
00698
00699 case TCPS_FIN_WAIT_2:
00700
00701
00702
00703 if (state != TCPS_TIME_WAIT)
00704 rc = -1;
00705 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00706 txf = 1;
00707 break;
00708
00709 case TCPS_CLOSE_WAIT:
00710
00711
00712
00713 if (state == TCPS_LAST_ACK) {
00714 sock->so_tx_flags |= SO_FIN | SO_ACK;
00715 txf = 1;
00716 } else
00717 rc = -1;
00718 break;
00719
00720 case TCPS_CLOSING:
00721
00722
00723
00724 if (state != TCPS_TIME_WAIT)
00725 rc = -1;
00726 break;
00727
00728 case TCPS_LAST_ACK:
00729 rc = -1;
00730 break;
00731
00732 case TCPS_TIME_WAIT:
00733 rc = -1;
00734 break;
00735
00736 case TCPS_CLOSED:
00737 switch (state) {
00738 case TCPS_LISTEN:
00739
00740
00741
00742 break;
00743 case TCPS_SYN_SENT:
00744
00745
00746
00747 sock->so_tx_flags |= SO_SYN;
00748 txf = 1;
00749 break;
00750 default:
00751 rc = -1;
00752 break;
00753 }
00754 break;
00755 }
00756 #ifdef NUTDEBUG
00757 if (__tcp_trf) {
00758 fprintf(__tcp_trs, " %04x-", (unsigned int) sock);
00759 if (rc)
00760 NutDumpSockState(__tcp_trs, sock->so_state, "**ERR ", "**>");
00761 NutDumpSockState(__tcp_trs, state, "[>", "]");
00762 }
00763 #endif
00764
00765 if (rc == 0) {
00766 sock->so_state = state;
00767 if (txf && NutTcpOutput(sock, 0, 0)) {
00768 if (state == TCPS_SYN_SENT) {
00769 rc = -1;
00770 sock->so_last_error = EHOSTDOWN;
00771 NutEventPostAsync(&sock->so_ac_tq);
00772 }
00773 }
00774 if (state == TCPS_CLOSE_WAIT) {
00775
00776
00777
00778 NutEventBroadcast(&sock->so_rx_tq);
00779 NutEventBroadcast(&sock->so_pc_tq);
00780 NutEventBroadcast(&sock->so_ac_tq);
00781 }
00782 }
00783 return rc;
00784 }
00785
00786
00787
00788
00789
00798 int NutTcpStatePassiveOpenEvent(TCPSOCKET * sock)
00799 {
00800 if (sock->so_state != TCPS_CLOSED)
00801 return (sock->so_last_error = EISCONN);
00802
00803 NutTcpStateChange(sock, TCPS_LISTEN);
00804
00805
00806
00807
00808 NutEventWait(&sock->so_pc_tq, 0);
00809
00810 return 0;
00811 }
00812
00823 int NutTcpStateActiveOpenEvent(TCPSOCKET * sock)
00824 {
00825
00826
00827
00828
00829 NutTcpStateChange(sock, TCPS_SYN_SENT);
00830
00831
00832
00833
00834 if(sock->so_state == TCPS_SYN_SENT)
00835 NutEventWait(&sock->so_ac_tq, 0);
00836
00837 if (sock->so_state != TCPS_ESTABLISHED)
00838 return -1;
00839
00840 return 0;
00841 }
00842
00855 int NutTcpStateCloseEvent(TCPSOCKET * sock)
00856 {
00857 if (sock == 0)
00858 return -1;
00859
00860 NutThreadYield();
00861
00862 switch (sock->so_state) {
00863 case TCPS_LISTEN:
00864 case TCPS_SYN_SENT:
00865 case TCPS_CLOSED:
00866
00867
00868
00869 NutTcpDestroySocket(sock);
00870 break;
00871
00872 case TCPS_SYN_RECEIVED:
00873 case TCPS_ESTABLISHED:
00874
00875
00876
00877
00878 NutTcpStateChange(sock, TCPS_FIN_WAIT_1);
00879 break;
00880
00881 case TCPS_CLOSE_WAIT:
00882
00883
00884
00885
00886 NutTcpStateChange(sock, TCPS_LAST_ACK);
00887 break;
00888
00889 case TCPS_FIN_WAIT_1:
00890 case TCPS_FIN_WAIT_2:
00891 case TCPS_CLOSING:
00892 case TCPS_LAST_ACK:
00893 case TCPS_TIME_WAIT:
00894 sock->so_last_error = EALREADY;
00895 return -1;
00896
00897 default:
00898 sock->so_last_error = ENOTCONN;
00899 return -1;
00900 }
00901 return 0;
00902 }
00903
00910 int NutTcpStateWindowEvent(TCPSOCKET * sock)
00911 {
00912 if (sock == 0)
00913 return -1;
00914 sock->so_tx_flags |= SO_ACK | SO_FORCE;
00915 NutTcpOutput(sock, 0, 0);
00916
00917 return 0;
00918 }
00919
00920
00921
00922
00923
00935 int NutTcpStateRetranTimeout(TCPSOCKET * sock)
00936 {
00937 NETBUF *so_tx_next;
00938 if (sock->so_retransmits++ > TCP_RETRIES_MAX)
00939 {
00940
00941 NutTcpAbortSocket(sock, ETIMEDOUT);
00942 return -1;
00943 } else {
00944 #ifdef NUTDEBUG
00945 if (__tcp_trf)
00946 NutDumpTcpHeader(__tcp_trs, "RET", sock, sock->so_tx_nbq);
00947 #endif
00948
00949
00950
00951
00952 so_tx_next = sock->so_tx_nbq->nb_next;
00953 if (NutIpOutput(IPPROTO_TCP, sock->so_remote_addr, sock->so_tx_nbq)) {
00954
00955 sock->so_tx_nbq = so_tx_next;
00956
00957 NutTcpAbortSocket(sock, ENETDOWN);
00958 return -1;
00959 } else {
00960
00961 sock->so_retran_time = (uint16_t) NutGetMillis() | 1;
00962 return 0;
00963 }
00964 }
00965 }
00966
00967
00968
00969
00970
00971
00981 static void NutTcpStateListen(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
00982 {
00983
00984
00985
00986
00987 if ((flags & (TH_SYN | TH_ACK | TH_RST)) == TH_SYN) {
00988 NutTcpProcessSyn(sock, nb->nb_nw.vp, th);
00989 NutTcpStateChange(sock, TCPS_SYN_RECEIVED);
00990 NutNetBufFree(nb);
00991 } else
00992 NutTcpReject(nb);
00993 }
00994
00995
01004 static void NutTcpStateSynSent(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01005 {
01006
01007
01008
01009 if (flags & TH_ACK) {
01010 if (!IsInLimits(ntohl(th->th_ack), sock->so_tx_isn + 1, sock->so_tx_nxt)) {
01011 NutTcpReject(nb);
01012 return;
01013 }
01014 }
01015
01016
01017
01018
01019
01020
01021 if (flags & TH_RST) {
01022 if (flags & TH_ACK) {
01023
01024
01025
01026 NutTcpAbortSocket(sock, ECONNREFUSED);
01027 }
01028 NutNetBufFree(nb);
01029 return;
01030 }
01031
01032
01033
01034
01035
01036
01037 if (flags & TH_SYN) {
01038 NutTcpProcessSyn(sock, nb->nb_nw.vp, th);
01039 if (flags & TH_ACK) {
01040 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01041 NutTcpStateChange(sock, TCPS_ESTABLISHED);
01042
01043 NutEventPost(&sock->so_ac_tq);
01044 } else {
01045 NutTcpStateChange(sock, TCPS_SYN_RECEIVED);
01046 }
01047 }
01048 NutNetBufFree(nb);
01049 }
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062 static void NutTcpStateSynReceived(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01063 {
01064
01065
01066
01067
01068 if (flags & TH_RST) {
01069 if (sock->so_pc_tq)
01070 NutTcpStateChange(sock, TCPS_LISTEN);
01071 else
01072 NutTcpAbortSocket(sock, ECONNREFUSED);
01073 NutNetBufFree(nb);
01074 sock->so_retran_time = 0;
01075 NutTcpDiscardBuffers(sock);
01076 return;
01077 }
01078
01079
01080
01081
01082 if (flags & TH_SYN) {
01083 NutTcpReject(nb);
01084 return;
01085 }
01086
01087
01088
01089
01090 if ((flags & TH_ACK) == 0) {
01091 NutNetBufFree(nb);
01092 return;
01093 }
01094
01095
01096
01097
01098 if (!IsInLimits(ntohl(th->th_ack), sock->so_tx_una + 1, sock->so_tx_nxt)) {
01099 NutTcpReject(nb);
01100 return;
01101 }
01102
01103
01104 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01105
01106
01107
01108
01109
01110
01111
01112 if (nb->nb_ap.sz)
01113 NutTcpProcessAppData(sock, nb);
01114 else
01115 NutNetBufFree(nb);
01116
01117
01118
01119
01120 if (flags & TH_FIN) {
01121 sock->so_rx_nxt++;
01122 NutTcpStateChange(sock, TCPS_CLOSE_WAIT);
01123 } else {
01124 NutTcpStateChange(sock, TCPS_ESTABLISHED);
01125 NutEventPost(&sock->so_pc_tq);
01126 NutEventPost(&sock->so_ac_tq);
01127 }
01128 }
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144 static void NutTcpStateEstablished(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01145 {
01146 if (flags & TH_RST) {
01147 NutNetBufFree(nb);
01148 NutTcpAbortSocket(sock, ECONNRESET);
01149 return;
01150 }
01151
01152
01153
01154
01155
01156 if (flags & TH_SYN) {
01157 if (htonl(th->th_seq) != sock->so_rx_isn)
01158 NutTcpReject(nb);
01159 else
01160 NutNetBufFree(nb);
01161 return;
01162 }
01163
01164
01165
01166
01167 if ((flags & TH_ACK) == 0) {
01168 NutNetBufFree(nb);
01169 return;
01170 }
01171
01172 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01173
01174
01175
01176
01177
01178
01179
01180 if (htonl(th->th_seq) > sock->so_rx_nxt) {
01181 NETBUF *nbq;
01182 NETBUF **nbqp;
01183 TCPHDR *thq;
01184 uint32_t th_seq;
01185 uint32_t thq_seq;
01186
01187 if (nb->nb_ap.sz) {
01188 nbq = sock->so_rx_nbq;
01189 nbqp = &sock->so_rx_nbq;
01190 while (nbq) {
01191 thq = (TCPHDR *) (nbq->nb_tp.vp);
01192 th_seq = htonl(th->th_seq);
01193 thq_seq = htonl(thq->th_seq);
01194 if (th_seq < thq_seq) {
01195 *nbqp = nb;
01196 nb->nb_next = nbq;
01197 break;
01198 }
01199 if (th_seq == thq_seq) {
01200 NutNetBufFree(nb);
01201 sock->so_tx_flags |= SO_ACK | SO_FORCE;
01202 NutTcpOutput(sock, 0, 0);
01203 return;
01204 }
01205 nbqp = &nbq->nb_next;
01206 nbq = nbq->nb_next;
01207 }
01208 if (nbq == 0) {
01209 *nbqp = nb;
01210 nb->nb_next = 0;
01211 }
01212 } else
01213 NutNetBufFree(nb);
01214
01215 sock->so_tx_flags |= SO_ACK | SO_FORCE;
01216 NutTcpOutput(sock, 0, 0);
01217 return;
01218 }
01219
01220
01221
01222
01223
01224
01225
01226
01227 if (htonl(th->th_seq) != sock->so_rx_nxt) {
01228 sock->so_tx_flags |= SO_ACK | SO_FORCE;
01229
01230 sock->so_oos_drop++;
01231 NutNetBufFree(nb);
01232 NutTcpOutput(sock, 0, 0);
01233 }
01234
01235
01236
01237
01238 else if (nb->nb_ap.sz) {
01239 NutTcpProcessAppData(sock, nb);
01240
01241
01242
01243 while ((nb = sock->so_rx_nbq) != 0) {
01244 th = (TCPHDR *) (nb->nb_tp.vp);
01245 if (htonl(th->th_seq) > sock->so_rx_nxt)
01246 break;
01247 sock->so_rx_nbq = nb->nb_next;
01248 if (htonl(th->th_seq) == sock->so_rx_nxt) {
01249 NutTcpProcessAppData(sock, nb);
01250 flags |= th->th_flags;
01251 } else
01252 NutNetBufFree(nb);
01253 }
01254
01255 NutEventPost(&sock->so_rx_tq);
01256 } else {
01257 NutNetBufFree(nb);
01258
01259
01260 }
01261 if (flags & TH_FIN) {
01262
01263 sock->so_rx_nxt++;
01264 NutTcpStateChange(sock, TCPS_CLOSE_WAIT);
01265 }
01266 }
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283 static void NutTcpStateFinWait1(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01284 {
01285
01286 if (flags & TH_RST) {
01287 NutNetBufFree(nb);
01288 NutTcpDestroySocket(sock);
01289 return;
01290 }
01291
01292
01293
01294
01295 if (flags & TH_SYN) {
01296 NutTcpReject(nb);
01297 return;
01298 }
01299
01300
01301
01302
01303 if ((flags & TH_ACK) == 0) {
01304 NutNetBufFree(nb);
01305 return;
01306 }
01307
01308
01309
01310
01311
01312 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01313
01314
01315
01316
01317
01318 if (sock->so_tx_nxt == sock->so_tx_una) {
01319
01320 NutTcpStateChange(sock, TCPS_FIN_WAIT_2);
01321 }
01322
01323
01324
01325
01326
01327 if (nb->nb_ap.sz) {
01328 NutTcpProcessAppData(sock, nb);
01329
01330 NutEventPost(&sock->so_rx_tq);
01331 }
01332 else
01333 NutNetBufFree(nb);
01334
01335 if (flags & TH_FIN) {
01336 sock->so_rx_nxt++;
01337
01338
01339
01340 sock->so_time_wait = 0;
01341
01342 if (sock->so_state == TCPS_FIN_WAIT_2)
01343 NutTcpStateChange(sock, TCPS_TIME_WAIT);
01344 else
01345 NutTcpStateChange(sock, TCPS_CLOSING);
01346 }
01347 }
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362 static void NutTcpStateFinWait2(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01363 {
01364
01365 if (flags & TH_RST) {
01366 NutNetBufFree(nb);
01367 NutTcpDestroySocket(sock);
01368 return;
01369 }
01370
01371
01372
01373
01374 if (flags & TH_SYN) {
01375 NutTcpReject(nb);
01376 return;
01377 }
01378
01379
01380
01381
01382 if ((flags & TH_ACK) == 0) {
01383 NutNetBufFree(nb);
01384 return;
01385 }
01386
01387
01388
01389
01390
01391
01392 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01393
01394
01395
01396 if (nb->nb_ap.sz) {
01397 NutTcpProcessAppData(sock, nb);
01398
01399 NutEventPost(&sock->so_rx_tq);
01400 }
01401 else
01402 NutNetBufFree(nb);
01403
01404 if (flags & TH_FIN) {
01405 sock->so_rx_nxt++;
01406 sock->so_time_wait = 0;
01407
01408 NutTcpStateChange(sock, TCPS_TIME_WAIT);
01409 }
01410 }
01411
01412
01413
01414
01415
01416
01417
01418
01419
01420
01421
01422 static void NutTcpStateCloseWait(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01423 {
01424
01425 if (flags & TH_RST) {
01426 NutNetBufFree(nb);
01427 NutTcpAbortSocket(sock, ECONNRESET);
01428 return;
01429 }
01430
01431
01432
01433
01434 if (flags & TH_SYN) {
01435 NutTcpReject(nb);
01436 return;
01437 }
01438
01439
01440
01441
01442 if ((flags & TH_ACK) == 0) {
01443 NutNetBufFree(nb);
01444 return;
01445 }
01446
01447 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01448
01449 NutNetBufFree(nb);
01450 }
01451
01452
01453
01454
01455
01456
01457
01458
01459
01460
01461
01462
01463
01464 static void NutTcpStateClosing(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01465 {
01466
01467 if (flags & TH_RST) {
01468 NutNetBufFree(nb);
01469 NutTcpDestroySocket(sock);
01470 return;
01471 }
01472
01473
01474
01475
01476 if (flags & TH_SYN) {
01477 NutTcpReject(nb);
01478 return;
01479 }
01480
01481
01482
01483
01484 if ((flags & TH_ACK) == 0) {
01485 NutNetBufFree(nb);
01486 return;
01487 }
01488
01489 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01490
01491
01492
01493
01494 if (sock->so_tx_nxt == sock->so_tx_una) {
01495 sock->so_time_wait = 0;
01496 NutTcpStateChange(sock, TCPS_TIME_WAIT);
01497
01498 }
01499
01500
01501 NutNetBufFree(nb);
01502 }
01503
01518 static void NutTcpStateLastAck(TCPSOCKET * sock, uint8_t flags, TCPHDR * th, NETBUF * nb)
01519 {
01520
01521 if (flags & TH_RST) {
01522 NutNetBufFree(nb);
01523 NutTcpDestroySocket(sock);
01524 return;
01525 }
01526
01527
01528
01529
01530 if (flags & TH_SYN) {
01531 NutTcpReject(nb);
01532 return;
01533 }
01534
01535
01536
01537
01538 if ((flags & TH_ACK) == 0) {
01539 NutNetBufFree(nb);
01540 return;
01541 }
01542
01543 NutTcpProcessAck(sock, th, nb->nb_ap.sz);
01544 NutNetBufFree(nb);
01545
01546 if (sock->so_tx_nxt == sock->so_tx_una)
01547 NutTcpDestroySocket(sock);
01548
01549 }
01550
01561 static void NutTcpStateProcess(TCPSOCKET * sock, NETBUF * nb)
01562 {
01563 uint32_t tx_win;
01564 uint32_t tx_una;
01565 TCPHDR *th = (TCPHDR *) nb->nb_tp.vp;
01566 uint8_t flags = th->th_flags;
01567
01568 #ifdef NUTDEBUG
01569 if (__tcp_trf) {
01570 fprintf(__tcp_trs, " %04x-", (unsigned int) sock);
01571 NutDumpSockState(__tcp_trs, sock->so_state, "[", ">]");
01572 }
01573 #endif
01574 switch (sock->so_state) {
01575
01576 case TCPS_ESTABLISHED:
01577 tx_win = sock->so_tx_win;
01578 tx_una = sock->so_tx_una;
01579 NutTcpStateEstablished(sock, flags, th, nb);
01580
01581 if(sock->so_state != TCPS_ESTABLISHED ||
01582 sock->so_tx_win > tx_win ||
01583 sock->so_tx_una > tx_una) {
01584 NutEventBroadcast(&sock->so_tx_tq);
01585 }
01586 break;
01587 case TCPS_LISTEN:
01588 NutTcpStateListen(sock, flags, th, nb);
01589 break;
01590 case TCPS_SYN_SENT:
01591 NutTcpStateSynSent(sock, flags, th, nb);
01592 break;
01593 case TCPS_SYN_RECEIVED:
01594 NutTcpStateSynReceived(sock, flags, th, nb);
01595 break;
01596 case TCPS_FIN_WAIT_1:
01597 NutTcpStateFinWait1(sock, flags, th, nb);
01598 break;
01599 case TCPS_FIN_WAIT_2:
01600 NutTcpStateFinWait2(sock, flags, th, nb);
01601 break;
01602 case TCPS_CLOSE_WAIT:
01603 NutTcpStateCloseWait(sock, flags, th, nb);
01604 break;
01605 case TCPS_CLOSING:
01606 NutTcpStateClosing(sock, flags, th, nb);
01607 break;
01608 case TCPS_LAST_ACK:
01609 NutTcpStateLastAck(sock, flags, th, nb);
01610 break;
01611 case TCPS_TIME_WAIT:
01612
01613
01614
01615 NutNetBufFree(nb);
01616 break;
01617 case TCPS_CLOSED:
01618
01619
01620
01621 NutTcpReject(nb);
01622 break;
01623 default:
01624 NutNetBufFree(nb);
01625 break;
01626 }
01627 }
01628
01635 THREAD(NutTcpSm, arg)
01636 {
01637 NETBUF *nb;
01638 NETBUF *nbx;
01639 TCPHDR *th;
01640 IPHDR *ih;
01641 TCPSOCKET *sock;
01642 uint8_t tac = 0;
01643
01644
01645
01646
01647
01648 NutThreadSetPriority (32);
01649
01650 for (;;) {
01651 if (++tac > 3 || NutEventWait(&tcp_in_rdy, 200)) {
01652 tac = 0;
01653 for (sock = tcpSocketList; sock; sock = sock->so_next) {
01654
01655
01656
01657
01658 if (sock->so_tx_flags & SO_ACK) {
01659 sock->so_tx_flags |= SO_FORCE;
01660 NutTcpOutput(sock, 0, 0);
01661 }
01662
01663
01664
01665
01666 if (sock->so_tx_nbq && sock->so_retran_time) {
01667 if ((uint16_t)((uint16_t)NutGetMillis() - sock->so_retran_time) > sock->so_rtto) {
01668 NutTcpStateRetranTimeout(sock);
01669 }
01670 }
01671
01672
01673
01674
01675 if (sock->so_state == TCPS_TIME_WAIT || sock->so_state == TCPS_FIN_WAIT_2) {
01676 if (sock->so_time_wait++ >= 9) {
01677 NutTcpDestroySocket(sock);
01678 break;
01679 }
01680 }
01681
01682
01683
01684
01685 else if (sock->so_state == TCPS_SYN_RECEIVED) {
01686 if (sock->so_time_wait++ >= 45) {
01687 sock->so_state = TCPS_LISTEN;
01688 sock->so_time_wait = 0;
01689 }
01690 }
01691 }
01692 } else {
01693 nb = tcp_in_nbq;
01694 tcp_in_nbq = 0;
01695 tcp_in_cnt = 0;
01696 while (nb) {
01697 ih = (IPHDR *) nb->nb_nw.vp;
01698 th = (TCPHDR *) nb->nb_tp.vp;
01699 sock = NutTcpFindSocket(th->th_dport, th->th_sport, ih->ip_src);
01700 #ifdef NUTDEBUG
01701 if (__tcp_trf)
01702 NutDumpTcpHeader(__tcp_trs, " IN", sock, nb);
01703 #endif
01704 nbx = nb->nb_next;
01705 if (sock) {
01706 NutTcpInputOptions(sock, nb);
01707 NutTcpStateProcess(sock, nb);
01708 }
01709
01710
01711
01712
01713 else
01714 NutTcpReject(nb);
01715 nb = nbx;
01716 }
01717 }
01718 }
01719 }
01720
01732 void NutTcpStateMachine(NETBUF * nb)
01733 {
01734 NETBUF *nbp;
01735 uint16_t size;
01736
01737 nb->nb_next = 0;
01738
01739
01740
01741
01742
01743
01744
01745 if (tcpThread == 0) {
01746 NutTcpReject(nb);
01747 return;
01748 }
01749
01750 if ((nbp = tcp_in_nbq) == 0) {
01751 tcp_in_nbq = nb;
01752 NutEventPost(&tcp_in_rdy);
01753 } else {
01754 size = nb->nb_nw.sz + nb->nb_tp.sz + nb->nb_ap.sz;
01755 if (tcp_in_cnt + size + 2048 < NutHeapAvailable()) {
01756 tcp_in_cnt += size;
01757 while (nbp->nb_next)
01758 nbp = nbp->nb_next;
01759 nbp->nb_next = nb;
01760 NutEventPost(&tcp_in_rdy);
01761 } else
01762 NutNetBufFree(nb);
01763 }
01764 }
01765
01774 int NutTcpInitStateMachine(void)
01775 {
01776 if (tcpThread == 0 && (tcpThread = NutThreadCreate("tcpsm", NutTcpSm, NULL,
01777 (NUT_THREAD_TCPSMSTACK * NUT_THREAD_STACK_MULT) + NUT_THREAD_STACK_ADD)) == 0)
01778 return -1;
01779 return 0;
01780 }
01781
01795 int NutTcpAbortSocket(TCPSOCKET * sock, uint16_t last_error)
01796 {
01797 sock->so_last_error = last_error;
01798 sock->so_retran_time = 0;
01799 sock->so_time_wait = 0;
01800
01801
01802
01803
01804
01805 if (sock->so_state >= TCPS_FIN_WAIT_1)
01806 sock->so_state = TCPS_TIME_WAIT;
01807 else
01808 sock->so_state = TCPS_CLOSED;
01809 NutTcpDiscardBuffers(sock);
01810 NutEventBroadcast(&sock->so_rx_tq);
01811 NutEventBroadcast(&sock->so_tx_tq);
01812 NutEventBroadcast(&sock->so_pc_tq);
01813 NutEventBroadcast(&sock->so_ac_tq);
01814 return 0;
01815 }
01816