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 #include <cfg/os.h>
00187 #include <sys/types.h>
00188 #include <string.h>
00189
00190 #include <sys/atom.h>
00191 #include <sys/heap.h>
00192 #include <sys/thread.h>
00193 #include <sys/event.h>
00194 #include <sys/timer.h>
00195
00196 #include <net/errno.h>
00197 #include <net/route.h>
00198 #include <netinet/in.h>
00199 #include <netinet/ip.h>
00200 #include <netinet/icmp.h>
00201 #include <netinet/ip_icmp.h>
00202 #include <netinet/ipcsum.h>
00203 #include <sys/socket.h>
00204 #include <netinet/tcp.h>
00205 #include <stdio.h>
00206 #include <io.h>
00207
00208 #ifdef NUTDEBUG
00209 #include <net/netdebug.h>
00210 #endif
00211
00212 #define TICK_RATE 1
00213
00218
00219 TCPSOCKET *tcpSocketList = 0;
00221 static volatile u_short last_local_port = 4096;
00222
00223 static u_char tcpStateRunning = 0;
00224
00225 void NutTcpDiscardBuffers(TCPSOCKET * sock)
00226 {
00227 NETBUF *nb;
00228 while ((nb = sock->so_rx_buf) != 0) {
00229 sock->so_rx_buf = nb->nb_next;
00230 NutNetBufFree(nb);
00231 }
00232 while ((nb = sock->so_tx_nbq) != 0) {
00233 sock->so_tx_nbq = nb->nb_next;
00234 NutNetBufFree(nb);
00235 }
00236 while ((nb = sock->so_rx_nbq) != 0) {
00237 sock->so_rx_nbq = nb->nb_next;
00238 NutNetBufFree(nb);
00239 }
00240 }
00241
00242
00254 void NutTcpDestroySocket(TCPSOCKET * sock)
00255 {
00256 TCPSOCKET *sp;
00257 TCPSOCKET *volatile *spp;
00258
00259
00260
00261
00262
00263
00264 sp = tcpSocketList;
00265 spp = &tcpSocketList;
00266 while (sp) {
00267 if (sp == sock) {
00268 *spp = sp->so_next;
00269 break;
00270 }
00271 spp = &sp->so_next;
00272 sp = sp->so_next;
00273 }
00274
00275
00276
00277
00278 if (sp) {
00279 NutTcpDiscardBuffers(sock);
00280 if (sock->so_devocnt)
00281 {
00282 NutHeapFree(sock->so_devobuf);
00283 sock->so_devocnt = 0;
00284 }
00285 memset(sock, 0, sizeof(TCPSOCKET));
00286 NutHeapFree(sock);
00287 }
00288 }
00289
00304 TCPSOCKET *NutTcpFindSocket(u_short lport, u_short rport, u_long raddr)
00305 {
00306 TCPSOCKET *sp;
00307 TCPSOCKET *sock = 0;
00308
00309
00310
00311
00312
00313 for (sp = tcpSocketList; sp; sp = sp->so_next) {
00314 if (sp->so_local_port == lport) {
00315 if (sp->so_remote_addr == raddr && sp->so_remote_port == rport && sp->so_state != TCPS_CLOSED) {
00316 sock = sp;
00317 break;
00318 }
00319 }
00320 }
00321
00322
00323
00324
00325
00326
00327
00328
00329 if (sock == 0) {
00330 for (sp = tcpSocketList; sp; sp = sp->so_next) {
00331 if (sp->so_state == TCPS_LISTEN && sp->so_local_port == lport) {
00332 sock = sp;
00333 break;
00334 }
00335 }
00336 }
00337
00338 return sock;
00339 }
00340
00341
00356 TCPSOCKET *NutTcpCreateSocket(void)
00357 {
00358 TCPSOCKET *sock = 0;
00359
00360 if (tcpStateRunning || (tcpStateRunning = (NutTcpInitStateMachine() == 0))) {
00361
00362 if ((sock = NutHeapAllocClear(sizeof(TCPSOCKET))) != 0) {
00363 sock->so_state = TCPS_CLOSED;
00364
00365
00366
00367
00368 sock->so_devtype = IFTYP_TCPSOCK;
00369 sock->so_devread = NutTcpDeviceRead;
00370 sock->so_devwrite = NutTcpDeviceWrite;
00371 #ifdef __HARVARD_ARCH__
00372 sock->so_devwrite_P = NutTcpDeviceWrite_P;
00373 #endif
00374 sock->so_devioctl = NutTcpDeviceIOCtl;
00375
00376 sock->so_tx_isn = NutGetTickCount();
00377 sock->so_tx_una = sock->so_tx_isn;
00378 sock->so_tx_nxt = sock->so_tx_isn;
00379 sock->so_rx_bsz = sock->so_rx_win = TCP_WINSIZE;
00380
00381 sock->so_mss = TCP_MSS;
00382 sock->so_rtto = 1000;
00383
00384 sock->so_next = tcpSocketList;
00385
00386 sock->so_devobsz = TCP_MSS;
00387
00388 tcpSocketList = sock;
00389 }
00390 }
00391 return sock;
00392 }
00393
00413 int NutTcpSetSockOpt(TCPSOCKET * sock, int optname, CONST void *optval, int optlen)
00414 {
00415 int rc = -1;
00416
00417 if (sock == 0)
00418 return -1;
00419 switch (optname) {
00420
00421 case TCP_MAXSEG:
00422 if (optval == 0 || optlen != sizeof(u_short))
00423 sock->so_last_error = EINVAL;
00424 else if (sock->so_state != TCPS_CLOSED)
00425 sock->so_last_error = EISCONN;
00426 else {
00427 sock->so_mss = *((u_short *) optval);
00428 rc = 0;
00429 }
00430 break;
00431
00432 case SO_RCVBUF:
00433 if (optval == 0 || optlen != sizeof(u_short))
00434 sock->so_last_error = EINVAL;
00435 else {
00436 sock->so_rx_bsz = *((u_short *) optval);
00437 sock->so_rx_win = sock->so_rx_bsz;
00438 rc = 0;
00439 }
00440 break;
00441
00442 case SO_SNDTIMEO:
00443 if (optval == 0 || optlen != sizeof(u_long))
00444 sock->so_last_error = EINVAL;
00445 else {
00446 sock->so_write_to = *((u_long *) optval);
00447 rc = 0;
00448 }
00449 break;
00450
00451 case SO_RCVTIMEO:
00452 if (optval == 0 || optlen != sizeof(u_long))
00453 sock->so_last_error = EINVAL;
00454 else {
00455 sock->so_read_to = *((u_long *) optval);
00456 rc = 0;
00457 }
00458 break;
00459
00460 case SO_SNDBUF:
00461 if (optval == 0 || optlen != sizeof(u_short))
00462 sock->so_last_error = EINVAL;
00463 else {
00464 NutTcpDeviceWrite(sock, 0, 0);
00465 sock->so_devobsz = *((u_short *) optval);
00466 rc = 0;
00467 }
00468 break;
00469
00470 default:
00471 sock->so_last_error = ENOPROTOOPT;
00472 break;
00473 }
00474 return rc;
00475 }
00476
00496 int NutTcpGetSockOpt(TCPSOCKET * sock, int optname, void *optval, int optlen)
00497 {
00498 int rc = -1;
00499
00500 if (sock == 0)
00501 return -1;
00502 switch (optname) {
00503
00504 case TCP_MAXSEG:
00505 if (optval == 0 || optlen != sizeof(u_short))
00506 sock->so_last_error = EINVAL;
00507 else {
00508 *((u_short *) optval) = sock->so_mss;
00509 rc = 0;
00510 }
00511 break;
00512
00513 case SO_RCVBUF:
00514 if (optval == 0 || optlen != sizeof(u_short))
00515 sock->so_last_error = EINVAL;
00516 else {
00517 *((u_short *) optval) = sock->so_rx_bsz;
00518 rc = 0;
00519 }
00520 break;
00521
00522 case SO_SNDTIMEO:
00523 if (optval == 0 || optlen != sizeof(u_long))
00524 sock->so_last_error = EINVAL;
00525 else {
00526 *((u_long *) optval) = sock->so_write_to;
00527 rc = 0;
00528 }
00529 break;
00530
00531 case SO_RCVTIMEO:
00532 if (optval == 0 || optlen != sizeof(u_long))
00533 sock->so_last_error = EINVAL;
00534 else {
00535 *((u_long *) optval) = sock->so_read_to;
00536 rc = 0;
00537 }
00538 break;
00539
00540 case SO_SNDBUF:
00541 if (optval == 0 || optlen != sizeof(u_short))
00542 sock->so_last_error = EINVAL;
00543 else {
00544 *((u_short *) optval) = sock->so_devobsz;
00545 rc = 0;
00546 }
00547 break;
00548 default:
00549 sock->so_last_error = ENOPROTOOPT;
00550 break;
00551 }
00552 return rc;
00553 }
00554
00573 int NutTcpConnect(TCPSOCKET * sock, u_long addr, u_short port)
00574 {
00575 TCPSOCKET *sp;
00576 NUTDEVICE *dev;
00577
00578 if (sock == 0)
00579 return -1;
00580
00581
00582
00583
00584 if (sock->so_state == TCPS_LISTEN) {
00585 sock->so_last_error = EOPNOTSUPP;
00586 return -1;
00587 } else if (sock->so_state != TCPS_CLOSED) {
00588 sock->so_last_error = EISCONN;
00589 return -1;
00590 }
00591
00592
00593
00594
00595 do {
00596 if (++last_local_port == 0)
00597 last_local_port = 4096;
00598
00599 sp = tcpSocketList;
00600 while (sp) {
00601
00602 if (sp->so_local_port == htons(last_local_port))
00603 break;
00604 sp = sp->so_next;
00605 }
00606 } while (sp);
00607
00608
00609
00610
00611
00612 sock->so_local_port = htons(last_local_port);
00613 sock->so_remote_port = htons(port);
00614 sock->so_remote_addr = addr;
00615
00616
00617
00618
00619 if ((dev = NutIpRouteQuery(addr, 0)) != 0) {
00620 IFNET *nif = dev->dev_icb;
00621 sock->so_local_addr = nif->if_local_ip;
00622 } else {
00623 sock->so_last_error = EHOSTUNREACH;
00624 return -1;
00625 }
00626
00627
00628
00629
00630
00631 return NutTcpStateActiveOpenEvent(sock);
00632 }
00633
00649 int NutTcpAccept(TCPSOCKET * sock, u_short port)
00650 {
00651 sock->so_local_port = htons(port);
00652
00653 return NutTcpStatePassiveOpenEvent(sock);
00654 }
00655
00672 int NutTcpSend(TCPSOCKET * sock, CONST void *data, int len)
00673 {
00674 u_short unacked;
00675
00676
00677
00678
00679 NutThreadYield();
00680
00681 if (sock == 0)
00682 return -1;
00683 if (data == 0 || len == 0)
00684 return 0;
00685
00686
00687
00688
00689 if (len > sock->so_mss)
00690 len = sock->so_mss;
00691
00692 for (;;) {
00693
00694
00695
00696 if (sock->so_state != TCPS_ESTABLISHED) {
00697 sock->so_last_error = ENOTCONN;
00698 return -1;
00699 }
00700
00701
00702
00703
00704
00705
00706 unacked = sock->so_tx_nxt - sock->so_tx_una;
00707 if ((unacked >> 2) < sock->so_mss && len <= sock->so_tx_win - unacked) {
00708 break;
00709 }
00710 if (NutEventWait(&sock->so_tx_tq, sock->so_write_to)) {
00711 return 0;
00712 }
00713 }
00714
00715
00716
00717
00718
00719 sock->so_tx_flags |= SO_ACK;
00720 if (NutTcpOutput(sock, data, len))
00721 return -1;
00722 return len;
00723 }
00724
00742 int NutTcpReceive(TCPSOCKET * sock, void *data, int size)
00743 {
00744 int i;
00745
00746 NutThreadYield();
00747
00748
00749
00750 if (sock == 0)
00751 return -1;
00752 if (sock->so_state != TCPS_ESTABLISHED && sock->so_state != TCPS_CLOSE_WAIT) {
00753 sock->so_last_error = ENOTCONN;
00754 return -1;
00755 }
00756 if (data == 0 || size == 0)
00757 return 0;
00758
00759
00760
00761
00762
00763 while (sock->so_rx_cnt - sock->so_rd_cnt == 0) {
00764 if (sock->so_state != TCPS_ESTABLISHED) {
00765 sock->so_last_error = ENOTCONN;
00766 return -1;
00767 }
00768 if (NutEventWait(&sock->so_rx_tq, sock->so_read_to))
00769 return 0;
00770 }
00771
00772 if (size > sock->so_rx_cnt - sock->so_rd_cnt)
00773 size = sock->so_rx_cnt - sock->so_rd_cnt;
00774 if (size) {
00775 NETBUF *nb;
00776 u_short rd_cnt;
00777 u_short nb_cnt;
00778 u_short ab_cnt;
00779 u_short mv_cnt;
00780
00781 rd_cnt = sock->so_rd_cnt;
00782
00783 ab_cnt = 0;
00784 while (ab_cnt < size) {
00785 nb = sock->so_rx_buf;
00786 nb_cnt = nb->nb_ap.sz - rd_cnt;
00787 mv_cnt = size - ab_cnt;
00788 if (mv_cnt > nb_cnt)
00789 mv_cnt = nb_cnt;
00790 memcpy((char *) data + ab_cnt, (char *) (nb->nb_ap.vp) + rd_cnt, mv_cnt);
00791 ab_cnt += mv_cnt;
00792 rd_cnt += mv_cnt;
00793 if (mv_cnt >= nb_cnt) {
00794 sock->so_rx_buf = nb->nb_next;
00795 sock->so_rx_cnt -= rd_cnt;
00796 NutNetBufFree(nb);
00797 nb = sock->so_rx_buf;
00798 rd_cnt = 0;
00799 }
00800 }
00801 sock->so_rd_cnt = rd_cnt;
00802
00803
00804
00805
00806 if (sock->so_state == TCPS_ESTABLISHED) {
00807 i = sock->so_rx_win;
00808 if ((i += size) > sock->so_rx_bsz)
00809 i = sock->so_rx_bsz;
00810
00811 if (sock->so_rx_win <= sock->so_mss && i > sock->so_mss) {
00812 sock->so_rx_win = i;
00813 NutTcpStateWindowEvent(sock);
00814 } else {
00815 sock->so_rx_win = i;
00816 }
00817 }
00818 }
00819 return size;
00820 }
00821
00834 int NutTcpCloseSocket(TCPSOCKET * sock)
00835 {
00836
00837
00838 NutTcpDeviceWrite(sock, 0, 0);
00839 return NutTcpStateCloseEvent(sock);
00840 }
00841
00890 int NutTcpError(TCPSOCKET * sock)
00891 {
00892 if (sock == 0)
00893 return ENOTSOCK;
00894 return sock->so_last_error;
00895 }
00896
00916 int NutTcpDeviceRead(TCPSOCKET * sock, void *buffer, int size)
00917 {
00918 return NutTcpReceive(sock, buffer, size);
00919 }
00920
00921 static int SendBuffer(TCPSOCKET * sock, CONST void *buffer, int size)
00922 {
00923 int rc;
00924 int bite;
00925
00926 for (rc = 0; rc < size; rc += bite) {
00927 if ((bite = NutTcpSend(sock, (u_char *) buffer + rc, size - rc)) <= 0) {
00928 return -1;
00929 }
00930 }
00931 return rc;
00932 }
00933
00956 int NutTcpDeviceWrite(TCPSOCKET * sock, CONST void *buf, int size)
00957 {
00958 int rc;
00959 u_short sz;
00960
00961 u_char *buffer = (u_char*) buf;
00962
00963
00964
00965
00966 if (sock == 0)
00967 return -1;
00968 if (sock->so_state != TCPS_ESTABLISHED) {
00969 sock->so_last_error = ENOTCONN;
00970 return -1;
00971 }
00972
00973
00974 if (size == 0) {
00975 if (sock->so_devocnt) {
00976 if (SendBuffer(sock, sock->so_devobuf, sock->so_devocnt) < 0) {
00977 NutHeapFree(sock->so_devobuf);
00978 sock->so_devocnt = 0;
00979 return -1;
00980 }
00981 NutHeapFree(sock->so_devobuf);
00982 sock->so_devocnt = 0;
00983 }
00984 return 0;
00985 }
00986
00987
00988 if (sock->so_devocnt == 0) {
00989
00990
00991
00992
00993 if ((u_short) size >= sock->so_devobsz) {
00994 rc = size % sock->so_devobsz;
00995 if (SendBuffer(sock, buffer, size - rc) < 0)
00996 return -1;
00997 buffer += size - rc;
00998 } else
00999 rc = size;
01000
01001
01002
01003
01004 if (rc) {
01005 if (!(sock->so_devobuf = NutHeapAlloc(sock->so_devobsz)))
01006 return -1;
01007 memcpy(sock->so_devobuf, buffer, rc);
01008 sock->so_devocnt = rc;
01009 }
01010 return size;
01011 }
01012
01013
01014 if (sock->so_devocnt + size < sock->so_devobsz) {
01015 memcpy(sock->so_devobuf + sock->so_devocnt, buffer, size);
01016 sock->so_devocnt += size;
01017 return size;
01018 }
01019
01020
01021
01022
01023 sz = sock->so_devobsz - sock->so_devocnt;
01024 memcpy(sock->so_devobuf + sock->so_devocnt, buffer, sz);
01025 buffer += sz;
01026 if (SendBuffer(sock, sock->so_devobuf, sock->so_devobsz) < 0) {
01027 NutHeapFree(sock->so_devobuf);
01028 sock->so_devocnt = 0;
01029 return -1;
01030 }
01031
01032
01033
01034
01035
01036 sz = size - sz;
01037 if (sz >= sock->so_devobsz) {
01038 rc = size % sock->so_devobsz;
01039 if (SendBuffer(sock, buffer, sz - rc) < 0) {
01040 NutHeapFree(sock->so_devobuf);
01041 sock->so_devocnt = 0;
01042 return -1;
01043 }
01044 buffer += sz - rc;
01045 } else
01046 rc = sz;
01047
01048
01049
01050 if (rc)
01051 memcpy(sock->so_devobuf, buffer, rc);
01052 else
01053 NutHeapFree(sock->so_devobuf);
01054 sock->so_devocnt = rc;
01055
01056 return size;
01057 }
01058
01083 #ifdef __HARVARD_ARCH__
01084 int NutTcpDeviceWrite_P(TCPSOCKET * sock, PGM_P buffer, int size)
01085 {
01086 int rc;
01087 char *rp = 0;
01088
01089
01090
01091
01092
01093 if (size && (rp = NutHeapAlloc(size)) != 0)
01094 memcpy_P(rp, buffer, size);
01095 rc = NutTcpDeviceWrite(sock, rp, size);
01096 if (rp)
01097 NutHeapFree(rp);
01098
01099 return rc;
01100 }
01101 #endif
01102
01122 int NutTcpDeviceIOCtl(TCPSOCKET * sock, int cmd, void *param)
01123 {
01124 u_long *lvp = (u_long *) param;
01125 int rc = 0;
01126
01127 switch (cmd) {
01128 case IOCTL_GETFILESIZE:
01129 case IOCTL_GETINBUFCOUNT:
01130 *lvp = (sock->so_rx_cnt - sock->so_rd_cnt);
01131 break;
01132 case IOCTL_GETOUTBUFCOUNT:
01133 *lvp = (sock->so_devocnt);
01134 break;
01135 default:
01136 rc = -1;
01137 }
01138
01139 return rc;
01140 }
01141