![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tcp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net|
Return to tcp.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / net |
1.1 ! root 1: #include <string.h> ! 2: #include <stdlib.h> ! 3: #include <stdio.h> ! 4: #include <assert.h> ! 5: #include <errno.h> ! 6: #include <byteswap.h> ! 7: #include <ipxe/timer.h> ! 8: #include <ipxe/iobuf.h> ! 9: #include <ipxe/malloc.h> ! 10: #include <ipxe/retry.h> ! 11: #include <ipxe/refcnt.h> ! 12: #include <ipxe/xfer.h> ! 13: #include <ipxe/open.h> ! 14: #include <ipxe/uri.h> ! 15: #include <ipxe/netdevice.h> ! 16: #include <ipxe/tcpip.h> ! 17: #include <ipxe/tcp.h> ! 18: ! 19: /** @file ! 20: * ! 21: * TCP protocol ! 22: * ! 23: */ ! 24: ! 25: FILE_LICENCE ( GPL2_OR_LATER ); ! 26: ! 27: /** A TCP connection */ ! 28: struct tcp_connection { ! 29: /** Reference counter */ ! 30: struct refcnt refcnt; ! 31: /** List of TCP connections */ ! 32: struct list_head list; ! 33: ! 34: /** Flags */ ! 35: unsigned int flags; ! 36: ! 37: /** Data transfer interface */ ! 38: struct interface xfer; ! 39: ! 40: /** Remote socket address */ ! 41: struct sockaddr_tcpip peer; ! 42: /** Local port */ ! 43: unsigned int local_port; ! 44: ! 45: /** Current TCP state */ ! 46: unsigned int tcp_state; ! 47: /** Previous TCP state ! 48: * ! 49: * Maintained only for debug messages ! 50: */ ! 51: unsigned int prev_tcp_state; ! 52: /** Current sequence number ! 53: * ! 54: * Equivalent to SND.UNA in RFC 793 terminology. ! 55: */ ! 56: uint32_t snd_seq; ! 57: /** Unacknowledged sequence count ! 58: * ! 59: * Equivalent to (SND.NXT-SND.UNA) in RFC 793 terminology. ! 60: */ ! 61: uint32_t snd_sent; ! 62: /** Send window ! 63: * ! 64: * Equivalent to SND.WND in RFC 793 terminology ! 65: */ ! 66: uint32_t snd_win; ! 67: /** Current acknowledgement number ! 68: * ! 69: * Equivalent to RCV.NXT in RFC 793 terminology. ! 70: */ ! 71: uint32_t rcv_ack; ! 72: /** Receive window ! 73: * ! 74: * Equivalent to RCV.WND in RFC 793 terminology. ! 75: */ ! 76: uint32_t rcv_win; ! 77: /** Received timestamp value ! 78: * ! 79: * Updated when a packet is received; copied to ts_recent when ! 80: * the window is advanced. ! 81: */ ! 82: uint32_t ts_val; ! 83: /** Most recent received timestamp that advanced the window ! 84: * ! 85: * Equivalent to TS.Recent in RFC 1323 terminology. ! 86: */ ! 87: uint32_t ts_recent; ! 88: ! 89: /** Transmit queue */ ! 90: struct list_head tx_queue; ! 91: /** Receive queue */ ! 92: struct list_head rx_queue; ! 93: /** Retransmission timer */ ! 94: struct retry_timer timer; ! 95: /** Shutdown (TIME_WAIT) timer */ ! 96: struct retry_timer wait; ! 97: }; ! 98: ! 99: /** TCP flags */ ! 100: enum tcp_flags { ! 101: /** TCP data transfer interface has been closed */ ! 102: TCP_XFER_CLOSED = 0x0001, ! 103: /** TCP timestamps are enabled */ ! 104: TCP_TS_ENABLED = 0x0002, ! 105: /** TCP acknowledgement is pending */ ! 106: TCP_ACK_PENDING = 0x0004, ! 107: }; ! 108: ! 109: /** TCP internal header ! 110: * ! 111: * This is the header that replaces the TCP header for packets ! 112: * enqueued on the receive queue. ! 113: */ ! 114: struct tcp_rx_queued_header { ! 115: /** SEQ value, in host-endian order ! 116: * ! 117: * This represents the SEQ value at the time the packet is ! 118: * enqueued, and so excludes the SYN, if present. ! 119: */ ! 120: uint32_t seq; ! 121: /** Flags ! 122: * ! 123: * Only FIN is valid within this flags byte; all other flags ! 124: * have already been processed by the time the packet is ! 125: * enqueued. ! 126: */ ! 127: uint8_t flags; ! 128: /** Reserved */ ! 129: uint8_t reserved[3]; ! 130: }; ! 131: ! 132: /** ! 133: * List of registered TCP connections ! 134: */ ! 135: static LIST_HEAD ( tcp_conns ); ! 136: ! 137: /* Forward declarations */ ! 138: static struct interface_descriptor tcp_xfer_desc; ! 139: static void tcp_expired ( struct retry_timer *timer, int over ); ! 140: static void tcp_wait_expired ( struct retry_timer *timer, int over ); ! 141: static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack, ! 142: uint32_t win ); ! 143: ! 144: /** ! 145: * Name TCP state ! 146: * ! 147: * @v state TCP state ! 148: * @ret name Name of TCP state ! 149: */ ! 150: static inline __attribute__ (( always_inline )) const char * ! 151: tcp_state ( int state ) { ! 152: switch ( state ) { ! 153: case TCP_CLOSED: return "CLOSED"; ! 154: case TCP_LISTEN: return "LISTEN"; ! 155: case TCP_SYN_SENT: return "SYN_SENT"; ! 156: case TCP_SYN_RCVD: return "SYN_RCVD"; ! 157: case TCP_ESTABLISHED: return "ESTABLISHED"; ! 158: case TCP_FIN_WAIT_1: return "FIN_WAIT_1"; ! 159: case TCP_FIN_WAIT_2: return "FIN_WAIT_2"; ! 160: case TCP_CLOSING_OR_LAST_ACK: return "CLOSING/LAST_ACK"; ! 161: case TCP_TIME_WAIT: return "TIME_WAIT"; ! 162: case TCP_CLOSE_WAIT: return "CLOSE_WAIT"; ! 163: default: return "INVALID"; ! 164: } ! 165: } ! 166: ! 167: /** ! 168: * Dump TCP state transition ! 169: * ! 170: * @v tcp TCP connection ! 171: */ ! 172: static inline __attribute__ (( always_inline )) void ! 173: tcp_dump_state ( struct tcp_connection *tcp ) { ! 174: ! 175: if ( tcp->tcp_state != tcp->prev_tcp_state ) { ! 176: DBGC ( tcp, "TCP %p transitioned from %s to %s\n", tcp, ! 177: tcp_state ( tcp->prev_tcp_state ), ! 178: tcp_state ( tcp->tcp_state ) ); ! 179: } ! 180: tcp->prev_tcp_state = tcp->tcp_state; ! 181: } ! 182: ! 183: /** ! 184: * Dump TCP flags ! 185: * ! 186: * @v flags TCP flags ! 187: */ ! 188: static inline __attribute__ (( always_inline )) void ! 189: tcp_dump_flags ( struct tcp_connection *tcp, unsigned int flags ) { ! 190: if ( flags & TCP_RST ) ! 191: DBGC2 ( tcp, " RST" ); ! 192: if ( flags & TCP_SYN ) ! 193: DBGC2 ( tcp, " SYN" ); ! 194: if ( flags & TCP_PSH ) ! 195: DBGC2 ( tcp, " PSH" ); ! 196: if ( flags & TCP_FIN ) ! 197: DBGC2 ( tcp, " FIN" ); ! 198: if ( flags & TCP_ACK ) ! 199: DBGC2 ( tcp, " ACK" ); ! 200: } ! 201: ! 202: /*************************************************************************** ! 203: * ! 204: * Open and close ! 205: * ! 206: *************************************************************************** ! 207: */ ! 208: ! 209: /** ! 210: * Bind TCP connection to local port ! 211: * ! 212: * @v tcp TCP connection ! 213: * @v port Local port number ! 214: * @ret rc Return status code ! 215: * ! 216: * If the port is 0, the connection is assigned an available port ! 217: * between 1024 and 65535. ! 218: */ ! 219: static int tcp_bind ( struct tcp_connection *tcp, unsigned int port ) { ! 220: struct tcp_connection *existing; ! 221: uint16_t try_port; ! 222: unsigned int i; ! 223: ! 224: /* If no port is specified, find an available port */ ! 225: if ( ! port ) { ! 226: try_port = random(); ! 227: for ( i = 0 ; i < 65536 ; i++ ) { ! 228: try_port++; ! 229: if ( try_port < 1024 ) ! 230: continue; ! 231: if ( tcp_bind ( tcp, try_port ) == 0 ) ! 232: return 0; ! 233: } ! 234: DBGC ( tcp, "TCP %p could not bind: no free ports\n", tcp ); ! 235: return -EADDRINUSE; ! 236: } ! 237: ! 238: /* Attempt bind to local port */ ! 239: list_for_each_entry ( existing, &tcp_conns, list ) { ! 240: if ( existing->local_port == port ) { ! 241: DBGC ( tcp, "TCP %p could not bind: port %d in use\n", ! 242: tcp, port ); ! 243: return -EADDRINUSE; ! 244: } ! 245: } ! 246: tcp->local_port = port; ! 247: ! 248: DBGC ( tcp, "TCP %p bound to port %d\n", tcp, port ); ! 249: return 0; ! 250: } ! 251: ! 252: /** ! 253: * Open a TCP connection ! 254: * ! 255: * @v xfer Data transfer interface ! 256: * @v peer Peer socket address ! 257: * @v local Local socket address, or NULL ! 258: * @ret rc Return status code ! 259: */ ! 260: static int tcp_open ( struct interface *xfer, struct sockaddr *peer, ! 261: struct sockaddr *local ) { ! 262: struct sockaddr_tcpip *st_peer = ( struct sockaddr_tcpip * ) peer; ! 263: struct sockaddr_tcpip *st_local = ( struct sockaddr_tcpip * ) local; ! 264: struct tcp_connection *tcp; ! 265: unsigned int bind_port; ! 266: int rc; ! 267: ! 268: /* Allocate and initialise structure */ ! 269: tcp = zalloc ( sizeof ( *tcp ) ); ! 270: if ( ! tcp ) ! 271: return -ENOMEM; ! 272: DBGC ( tcp, "TCP %p allocated\n", tcp ); ! 273: ref_init ( &tcp->refcnt, NULL ); ! 274: intf_init ( &tcp->xfer, &tcp_xfer_desc, &tcp->refcnt ); ! 275: timer_init ( &tcp->timer, tcp_expired, &tcp->refcnt ); ! 276: timer_init ( &tcp->wait, tcp_wait_expired, &tcp->refcnt ); ! 277: tcp->prev_tcp_state = TCP_CLOSED; ! 278: tcp->tcp_state = TCP_STATE_SENT ( TCP_SYN ); ! 279: tcp_dump_state ( tcp ); ! 280: tcp->snd_seq = random(); ! 281: INIT_LIST_HEAD ( &tcp->tx_queue ); ! 282: INIT_LIST_HEAD ( &tcp->rx_queue ); ! 283: memcpy ( &tcp->peer, st_peer, sizeof ( tcp->peer ) ); ! 284: ! 285: /* Bind to local port */ ! 286: bind_port = ( st_local ? ntohs ( st_local->st_port ) : 0 ); ! 287: if ( ( rc = tcp_bind ( tcp, bind_port ) ) != 0 ) ! 288: goto err; ! 289: ! 290: /* Start timer to initiate SYN */ ! 291: start_timer_nodelay ( &tcp->timer ); ! 292: ! 293: /* Attach parent interface, transfer reference to connection ! 294: * list and return ! 295: */ ! 296: intf_plug_plug ( &tcp->xfer, xfer ); ! 297: list_add ( &tcp->list, &tcp_conns ); ! 298: return 0; ! 299: ! 300: err: ! 301: ref_put ( &tcp->refcnt ); ! 302: return rc; ! 303: } ! 304: ! 305: /** ! 306: * Close TCP connection ! 307: * ! 308: * @v tcp TCP connection ! 309: * @v rc Reason for close ! 310: * ! 311: * Closes the data transfer interface. If the TCP state machine is in ! 312: * a suitable state, the connection will be deleted. ! 313: */ ! 314: static void tcp_close ( struct tcp_connection *tcp, int rc ) { ! 315: struct io_buffer *iobuf; ! 316: struct io_buffer *tmp; ! 317: ! 318: /* Close data transfer interface */ ! 319: intf_shutdown ( &tcp->xfer, rc ); ! 320: tcp->flags |= TCP_XFER_CLOSED; ! 321: ! 322: /* If we are in CLOSED, or have otherwise not yet received a ! 323: * SYN (i.e. we are in LISTEN or SYN_SENT), just delete the ! 324: * connection. ! 325: */ ! 326: if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) { ! 327: ! 328: /* Transition to CLOSED for the sake of debugging messages */ ! 329: tcp->tcp_state = TCP_CLOSED; ! 330: tcp_dump_state ( tcp ); ! 331: ! 332: /* Free any unprocessed I/O buffers */ ! 333: list_for_each_entry_safe ( iobuf, tmp, &tcp->rx_queue, list ) { ! 334: list_del ( &iobuf->list ); ! 335: free_iob ( iobuf ); ! 336: } ! 337: ! 338: /* Free any unsent I/O buffers */ ! 339: list_for_each_entry_safe ( iobuf, tmp, &tcp->tx_queue, list ) { ! 340: list_del ( &iobuf->list ); ! 341: free_iob ( iobuf ); ! 342: } ! 343: ! 344: /* Remove from list and drop reference */ ! 345: stop_timer ( &tcp->timer ); ! 346: list_del ( &tcp->list ); ! 347: ref_put ( &tcp->refcnt ); ! 348: DBGC ( tcp, "TCP %p connection deleted\n", tcp ); ! 349: return; ! 350: } ! 351: ! 352: /* If we have not had our SYN acknowledged (i.e. we are in ! 353: * SYN_RCVD), pretend that it has been acknowledged so that we ! 354: * can send a FIN without breaking things. ! 355: */ ! 356: if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) ) ! 357: tcp_rx_ack ( tcp, ( tcp->snd_seq + 1 ), 0 ); ! 358: ! 359: /* If we have no data remaining to send, start sending FIN */ ! 360: if ( list_empty ( &tcp->tx_queue ) ) { ! 361: tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN ); ! 362: tcp_dump_state ( tcp ); ! 363: } ! 364: } ! 365: ! 366: /*************************************************************************** ! 367: * ! 368: * Transmit data path ! 369: * ! 370: *************************************************************************** ! 371: */ ! 372: ! 373: /** ! 374: * Calculate transmission window ! 375: * ! 376: * @v tcp TCP connection ! 377: * @ret len Maximum length that can be sent in a single packet ! 378: */ ! 379: static size_t tcp_xmit_win ( struct tcp_connection *tcp ) { ! 380: size_t len; ! 381: ! 382: /* Not ready if we're not in a suitable connection state */ ! 383: if ( ! TCP_CAN_SEND_DATA ( tcp->tcp_state ) ) ! 384: return 0; ! 385: ! 386: /* Length is the minimum of the receiver's window and the path MTU */ ! 387: len = tcp->snd_win; ! 388: if ( len > TCP_PATH_MTU ) ! 389: len = TCP_PATH_MTU; ! 390: ! 391: return len; ! 392: } ! 393: ! 394: /** ! 395: * Process TCP transmit queue ! 396: * ! 397: * @v tcp TCP connection ! 398: * @v max_len Maximum length to process ! 399: * @v dest I/O buffer to fill with data, or NULL ! 400: * @v remove Remove data from queue ! 401: * @ret len Length of data processed ! 402: * ! 403: * This processes at most @c max_len bytes from the TCP connection's ! 404: * transmit queue. Data will be copied into the @c dest I/O buffer ! 405: * (if provided) and, if @c remove is true, removed from the transmit ! 406: * queue. ! 407: */ ! 408: static size_t tcp_process_tx_queue ( struct tcp_connection *tcp, size_t max_len, ! 409: struct io_buffer *dest, int remove ) { ! 410: struct io_buffer *iobuf; ! 411: struct io_buffer *tmp; ! 412: size_t frag_len; ! 413: size_t len = 0; ! 414: ! 415: list_for_each_entry_safe ( iobuf, tmp, &tcp->tx_queue, list ) { ! 416: frag_len = iob_len ( iobuf ); ! 417: if ( frag_len > max_len ) ! 418: frag_len = max_len; ! 419: if ( dest ) { ! 420: memcpy ( iob_put ( dest, frag_len ), iobuf->data, ! 421: frag_len ); ! 422: } ! 423: if ( remove ) { ! 424: iob_pull ( iobuf, frag_len ); ! 425: if ( ! iob_len ( iobuf ) ) { ! 426: list_del ( &iobuf->list ); ! 427: free_iob ( iobuf ); ! 428: } ! 429: } ! 430: len += frag_len; ! 431: max_len -= frag_len; ! 432: } ! 433: return len; ! 434: } ! 435: ! 436: /** ! 437: * Transmit any outstanding data ! 438: * ! 439: * @v tcp TCP connection ! 440: * ! 441: * Transmits any outstanding data on the connection. ! 442: * ! 443: * Note that even if an error is returned, the retransmission timer ! 444: * will have been started if necessary, and so the stack will ! 445: * eventually attempt to retransmit the failed packet. ! 446: */ ! 447: static int tcp_xmit ( struct tcp_connection *tcp ) { ! 448: struct io_buffer *iobuf; ! 449: struct tcp_header *tcphdr; ! 450: struct tcp_mss_option *mssopt; ! 451: struct tcp_timestamp_padded_option *tsopt; ! 452: void *payload; ! 453: unsigned int flags; ! 454: size_t len = 0; ! 455: uint32_t seq_len; ! 456: uint32_t app_win; ! 457: uint32_t max_rcv_win; ! 458: int rc; ! 459: ! 460: /* If retransmission timer is already running, do nothing */ ! 461: if ( timer_running ( &tcp->timer ) ) ! 462: return 0; ! 463: ! 464: /* Calculate both the actual (payload) and sequence space ! 465: * lengths that we wish to transmit. ! 466: */ ! 467: if ( TCP_CAN_SEND_DATA ( tcp->tcp_state ) ) { ! 468: len = tcp_process_tx_queue ( tcp, tcp_xmit_win ( tcp ), ! 469: NULL, 0 ); ! 470: } ! 471: seq_len = len; ! 472: flags = TCP_FLAGS_SENDING ( tcp->tcp_state ); ! 473: if ( flags & ( TCP_SYN | TCP_FIN ) ) { ! 474: /* SYN or FIN consume one byte, and we can never send both */ ! 475: assert ( ! ( ( flags & TCP_SYN ) && ( flags & TCP_FIN ) ) ); ! 476: seq_len++; ! 477: } ! 478: tcp->snd_sent = seq_len; ! 479: ! 480: /* If we have nothing to transmit, stop now */ ! 481: if ( ( seq_len == 0 ) && ! ( tcp->flags & TCP_ACK_PENDING ) ) ! 482: return 0; ! 483: ! 484: /* If we are transmitting anything that requires ! 485: * acknowledgement (i.e. consumes sequence space), start the ! 486: * retransmission timer. Do this before attempting to ! 487: * allocate the I/O buffer, in case allocation itself fails. ! 488: */ ! 489: if ( seq_len ) ! 490: start_timer ( &tcp->timer ); ! 491: ! 492: /* Allocate I/O buffer */ ! 493: iobuf = alloc_iob ( len + MAX_LL_NET_HEADER_LEN ); ! 494: if ( ! iobuf ) { ! 495: DBGC ( tcp, "TCP %p could not allocate iobuf for %08x..%08x " ! 496: "%08x\n", tcp, tcp->snd_seq, ( tcp->snd_seq + seq_len ), ! 497: tcp->rcv_ack ); ! 498: return -ENOMEM; ! 499: } ! 500: iob_reserve ( iobuf, MAX_LL_NET_HEADER_LEN ); ! 501: ! 502: /* Fill data payload from transmit queue */ ! 503: tcp_process_tx_queue ( tcp, len, iobuf, 0 ); ! 504: ! 505: /* Expand receive window if possible */ ! 506: max_rcv_win = ( ( freemem * 3 ) / 4 ); ! 507: if ( max_rcv_win > TCP_MAX_WINDOW_SIZE ) ! 508: max_rcv_win = TCP_MAX_WINDOW_SIZE; ! 509: app_win = xfer_window ( &tcp->xfer ); ! 510: if ( max_rcv_win > app_win ) ! 511: max_rcv_win = app_win; ! 512: max_rcv_win &= ~0x03; /* Keep everything dword-aligned */ ! 513: if ( tcp->rcv_win < max_rcv_win ) ! 514: tcp->rcv_win = max_rcv_win; ! 515: ! 516: /* Fill up the TCP header */ ! 517: payload = iobuf->data; ! 518: if ( flags & TCP_SYN ) { ! 519: mssopt = iob_push ( iobuf, sizeof ( *mssopt ) ); ! 520: mssopt->kind = TCP_OPTION_MSS; ! 521: mssopt->length = sizeof ( *mssopt ); ! 522: mssopt->mss = htons ( TCP_MSS ); ! 523: } ! 524: if ( ( flags & TCP_SYN ) || ( tcp->flags & TCP_TS_ENABLED ) ) { ! 525: tsopt = iob_push ( iobuf, sizeof ( *tsopt ) ); ! 526: memset ( tsopt->nop, TCP_OPTION_NOP, sizeof ( tsopt->nop ) ); ! 527: tsopt->tsopt.kind = TCP_OPTION_TS; ! 528: tsopt->tsopt.length = sizeof ( tsopt->tsopt ); ! 529: tsopt->tsopt.tsval = htonl ( currticks() ); ! 530: tsopt->tsopt.tsecr = htonl ( tcp->ts_recent ); ! 531: } ! 532: if ( len != 0 ) ! 533: flags |= TCP_PSH; ! 534: tcphdr = iob_push ( iobuf, sizeof ( *tcphdr ) ); ! 535: memset ( tcphdr, 0, sizeof ( *tcphdr ) ); ! 536: tcphdr->src = htons ( tcp->local_port ); ! 537: tcphdr->dest = tcp->peer.st_port; ! 538: tcphdr->seq = htonl ( tcp->snd_seq ); ! 539: tcphdr->ack = htonl ( tcp->rcv_ack ); ! 540: tcphdr->hlen = ( ( payload - iobuf->data ) << 2 ); ! 541: tcphdr->flags = flags; ! 542: tcphdr->win = htons ( tcp->rcv_win ); ! 543: tcphdr->csum = tcpip_chksum ( iobuf->data, iob_len ( iobuf ) ); ! 544: ! 545: /* Dump header */ ! 546: DBGC2 ( tcp, "TCP %p TX %d->%d %08x..%08x %08x %4zd", ! 547: tcp, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ), ! 548: ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) + seq_len ), ! 549: ntohl ( tcphdr->ack ), len ); ! 550: tcp_dump_flags ( tcp, tcphdr->flags ); ! 551: DBGC2 ( tcp, "\n" ); ! 552: ! 553: /* Transmit packet */ ! 554: if ( ( rc = tcpip_tx ( iobuf, &tcp_protocol, NULL, &tcp->peer, NULL, ! 555: &tcphdr->csum ) ) != 0 ) { ! 556: DBGC ( tcp, "TCP %p could not transmit %08x..%08x %08x: %s\n", ! 557: tcp, tcp->snd_seq, ( tcp->snd_seq + tcp->snd_sent ), ! 558: tcp->rcv_ack, strerror ( rc ) ); ! 559: return rc; ! 560: } ! 561: ! 562: /* Clear ACK-pending flag */ ! 563: tcp->flags &= ~TCP_ACK_PENDING; ! 564: ! 565: return 0; ! 566: } ! 567: ! 568: /** ! 569: * Retransmission timer expired ! 570: * ! 571: * @v timer Retransmission timer ! 572: * @v over Failure indicator ! 573: */ ! 574: static void tcp_expired ( struct retry_timer *timer, int over ) { ! 575: struct tcp_connection *tcp = ! 576: container_of ( timer, struct tcp_connection, timer ); ! 577: ! 578: DBGC ( tcp, "TCP %p timer %s in %s for %08x..%08x %08x\n", tcp, ! 579: ( over ? "expired" : "fired" ), tcp_state ( tcp->tcp_state ), ! 580: tcp->snd_seq, ( tcp->snd_seq + tcp->snd_sent ), tcp->rcv_ack ); ! 581: ! 582: assert ( ( tcp->tcp_state == TCP_SYN_SENT ) || ! 583: ( tcp->tcp_state == TCP_SYN_RCVD ) || ! 584: ( tcp->tcp_state == TCP_ESTABLISHED ) || ! 585: ( tcp->tcp_state == TCP_FIN_WAIT_1 ) || ! 586: ( tcp->tcp_state == TCP_CLOSE_WAIT ) || ! 587: ( tcp->tcp_state == TCP_CLOSING_OR_LAST_ACK ) ); ! 588: ! 589: if ( over ) { ! 590: /* If we have finally timed out and given up, ! 591: * terminate the connection ! 592: */ ! 593: tcp->tcp_state = TCP_CLOSED; ! 594: tcp_dump_state ( tcp ); ! 595: tcp_close ( tcp, -ETIMEDOUT ); ! 596: } else { ! 597: /* Otherwise, retransmit the packet */ ! 598: tcp_xmit ( tcp ); ! 599: } ! 600: } ! 601: ! 602: /** ! 603: * Shutdown timer expired ! 604: * ! 605: * @v timer Shutdown timer ! 606: * @v over Failure indicator ! 607: */ ! 608: static void tcp_wait_expired ( struct retry_timer *timer, int over __unused ) { ! 609: struct tcp_connection *tcp = ! 610: container_of ( timer, struct tcp_connection, wait ); ! 611: ! 612: assert ( tcp->tcp_state == TCP_TIME_WAIT ); ! 613: ! 614: DBGC ( tcp, "TCP %p wait complete in %s for %08x..%08x %08x\n", tcp, ! 615: tcp_state ( tcp->tcp_state ), tcp->snd_seq, ! 616: ( tcp->snd_seq + tcp->snd_sent ), tcp->rcv_ack ); ! 617: ! 618: tcp->tcp_state = TCP_CLOSED; ! 619: tcp_dump_state ( tcp ); ! 620: tcp_close ( tcp, 0 ); ! 621: } ! 622: ! 623: /** ! 624: * Send RST response to incoming packet ! 625: * ! 626: * @v in_tcphdr TCP header of incoming packet ! 627: * @ret rc Return status code ! 628: */ ! 629: static int tcp_xmit_reset ( struct tcp_connection *tcp, ! 630: struct sockaddr_tcpip *st_dest, ! 631: struct tcp_header *in_tcphdr ) { ! 632: struct io_buffer *iobuf; ! 633: struct tcp_header *tcphdr; ! 634: int rc; ! 635: ! 636: /* Allocate space for dataless TX buffer */ ! 637: iobuf = alloc_iob ( MAX_LL_NET_HEADER_LEN ); ! 638: if ( ! iobuf ) { ! 639: DBGC ( tcp, "TCP %p could not allocate iobuf for RST " ! 640: "%08x..%08x %08x\n", tcp, ntohl ( in_tcphdr->ack ), ! 641: ntohl ( in_tcphdr->ack ), ntohl ( in_tcphdr->seq ) ); ! 642: return -ENOMEM; ! 643: } ! 644: iob_reserve ( iobuf, MAX_LL_NET_HEADER_LEN ); ! 645: ! 646: /* Construct RST response */ ! 647: tcphdr = iob_push ( iobuf, sizeof ( *tcphdr ) ); ! 648: memset ( tcphdr, 0, sizeof ( *tcphdr ) ); ! 649: tcphdr->src = in_tcphdr->dest; ! 650: tcphdr->dest = in_tcphdr->src; ! 651: tcphdr->seq = in_tcphdr->ack; ! 652: tcphdr->ack = in_tcphdr->seq; ! 653: tcphdr->hlen = ( ( sizeof ( *tcphdr ) / 4 ) << 4 ); ! 654: tcphdr->flags = ( TCP_RST | TCP_ACK ); ! 655: tcphdr->win = htons ( TCP_MAX_WINDOW_SIZE ); ! 656: tcphdr->csum = tcpip_chksum ( iobuf->data, iob_len ( iobuf ) ); ! 657: ! 658: /* Dump header */ ! 659: DBGC2 ( tcp, "TCP %p TX %d->%d %08x..%08x %08x %4d", ! 660: tcp, ntohs ( tcphdr->src ), ntohs ( tcphdr->dest ), ! 661: ntohl ( tcphdr->seq ), ( ntohl ( tcphdr->seq ) ), ! 662: ntohl ( tcphdr->ack ), 0 ); ! 663: tcp_dump_flags ( tcp, tcphdr->flags ); ! 664: DBGC2 ( tcp, "\n" ); ! 665: ! 666: /* Transmit packet */ ! 667: if ( ( rc = tcpip_tx ( iobuf, &tcp_protocol, NULL, st_dest, ! 668: NULL, &tcphdr->csum ) ) != 0 ) { ! 669: DBGC ( tcp, "TCP %p could not transmit RST %08x..%08x %08x: " ! 670: "%s\n", tcp, ntohl ( in_tcphdr->ack ), ! 671: ntohl ( in_tcphdr->ack ), ntohl ( in_tcphdr->seq ), ! 672: strerror ( rc ) ); ! 673: return rc; ! 674: } ! 675: ! 676: return 0; ! 677: } ! 678: ! 679: /*************************************************************************** ! 680: * ! 681: * Receive data path ! 682: * ! 683: *************************************************************************** ! 684: */ ! 685: ! 686: /** ! 687: * Identify TCP connection by local port number ! 688: * ! 689: * @v local_port Local port ! 690: * @ret tcp TCP connection, or NULL ! 691: */ ! 692: static struct tcp_connection * tcp_demux ( unsigned int local_port ) { ! 693: struct tcp_connection *tcp; ! 694: ! 695: list_for_each_entry ( tcp, &tcp_conns, list ) { ! 696: if ( tcp->local_port == local_port ) ! 697: return tcp; ! 698: } ! 699: return NULL; ! 700: } ! 701: ! 702: /** ! 703: * Parse TCP received options ! 704: * ! 705: * @v tcp TCP connection ! 706: * @v data Raw options data ! 707: * @v len Raw options length ! 708: * @v options Options structure to fill in ! 709: */ ! 710: static void tcp_rx_opts ( struct tcp_connection *tcp, const void *data, ! 711: size_t len, struct tcp_options *options ) { ! 712: const void *end = ( data + len ); ! 713: const struct tcp_option *option; ! 714: unsigned int kind; ! 715: ! 716: memset ( options, 0, sizeof ( *options ) ); ! 717: while ( data < end ) { ! 718: option = data; ! 719: kind = option->kind; ! 720: if ( kind == TCP_OPTION_END ) ! 721: return; ! 722: if ( kind == TCP_OPTION_NOP ) { ! 723: data++; ! 724: continue; ! 725: } ! 726: switch ( kind ) { ! 727: case TCP_OPTION_MSS: ! 728: options->mssopt = data; ! 729: break; ! 730: case TCP_OPTION_TS: ! 731: options->tsopt = data; ! 732: break; ! 733: default: ! 734: DBGC ( tcp, "TCP %p received unknown option %d\n", ! 735: tcp, kind ); ! 736: break; ! 737: } ! 738: data += option->length; ! 739: } ! 740: } ! 741: ! 742: /** ! 743: * Consume received sequence space ! 744: * ! 745: * @v tcp TCP connection ! 746: * @v seq_len Sequence space length to consume ! 747: */ ! 748: static void tcp_rx_seq ( struct tcp_connection *tcp, uint32_t seq_len ) { ! 749: ! 750: /* Sanity check */ ! 751: assert ( seq_len > 0 ); ! 752: ! 753: /* Update acknowledgement number */ ! 754: tcp->rcv_ack += seq_len; ! 755: ! 756: /* Update window */ ! 757: if ( tcp->rcv_win > seq_len ) { ! 758: tcp->rcv_win -= seq_len; ! 759: } else { ! 760: tcp->rcv_win = 0; ! 761: } ! 762: ! 763: /* Update timestamp */ ! 764: tcp->ts_recent = tcp->ts_val; ! 765: ! 766: /* Mark ACK as pending */ ! 767: tcp->flags |= TCP_ACK_PENDING; ! 768: } ! 769: ! 770: /** ! 771: * Handle TCP received SYN ! 772: * ! 773: * @v tcp TCP connection ! 774: * @v seq SEQ value (in host-endian order) ! 775: * @v options TCP options ! 776: * @ret rc Return status code ! 777: */ ! 778: static int tcp_rx_syn ( struct tcp_connection *tcp, uint32_t seq, ! 779: struct tcp_options *options ) { ! 780: ! 781: /* Synchronise sequence numbers on first SYN */ ! 782: if ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) { ! 783: tcp->rcv_ack = seq; ! 784: if ( options->tsopt ) ! 785: tcp->flags |= TCP_TS_ENABLED; ! 786: } ! 787: ! 788: /* Ignore duplicate SYN */ ! 789: if ( seq != tcp->rcv_ack ) ! 790: return 0; ! 791: ! 792: /* Acknowledge SYN */ ! 793: tcp_rx_seq ( tcp, 1 ); ! 794: ! 795: /* Mark SYN as received and start sending ACKs with each packet */ ! 796: tcp->tcp_state |= ( TCP_STATE_SENT ( TCP_ACK ) | ! 797: TCP_STATE_RCVD ( TCP_SYN ) ); ! 798: ! 799: return 0; ! 800: } ! 801: ! 802: /** ! 803: * Handle TCP received ACK ! 804: * ! 805: * @v tcp TCP connection ! 806: * @v ack ACK value (in host-endian order) ! 807: * @v win WIN value (in host-endian order) ! 808: * @ret rc Return status code ! 809: */ ! 810: static int tcp_rx_ack ( struct tcp_connection *tcp, uint32_t ack, ! 811: uint32_t win ) { ! 812: uint32_t ack_len = ( ack - tcp->snd_seq ); ! 813: size_t len; ! 814: unsigned int acked_flags; ! 815: ! 816: /* Check for out-of-range or old duplicate ACKs */ ! 817: if ( ack_len > tcp->snd_sent ) { ! 818: DBGC ( tcp, "TCP %p received ACK for %08x..%08x, " ! 819: "sent only %08x..%08x\n", tcp, tcp->snd_seq, ! 820: ( tcp->snd_seq + ack_len ), tcp->snd_seq, ! 821: ( tcp->snd_seq + tcp->snd_sent ) ); ! 822: ! 823: if ( TCP_HAS_BEEN_ESTABLISHED ( tcp->tcp_state ) ) { ! 824: /* Just ignore what might be old duplicate ACKs */ ! 825: return 0; ! 826: } else { ! 827: /* Send RST if an out-of-range ACK is received ! 828: * on a not-yet-established connection, as per ! 829: * RFC 793. ! 830: */ ! 831: return -EINVAL; ! 832: } ! 833: } ! 834: ! 835: /* Ignore ACKs that don't actually acknowledge any new data. ! 836: * (In particular, do not stop the retransmission timer; this ! 837: * avoids creating a sorceror's apprentice syndrome when a ! 838: * duplicate ACK is received and we still have data in our ! 839: * transmit queue.) ! 840: */ ! 841: if ( ack_len == 0 ) ! 842: return 0; ! 843: ! 844: /* Stop the retransmission timer */ ! 845: stop_timer ( &tcp->timer ); ! 846: ! 847: /* Determine acknowledged flags and data length */ ! 848: len = ack_len; ! 849: acked_flags = ( TCP_FLAGS_SENDING ( tcp->tcp_state ) & ! 850: ( TCP_SYN | TCP_FIN ) ); ! 851: if ( acked_flags ) ! 852: len--; ! 853: ! 854: /* Update SEQ and sent counters, and window size */ ! 855: tcp->snd_seq = ack; ! 856: tcp->snd_sent = 0; ! 857: tcp->snd_win = win; ! 858: ! 859: /* Remove any acknowledged data from transmit queue */ ! 860: tcp_process_tx_queue ( tcp, len, NULL, 1 ); ! 861: ! 862: /* Mark SYN/FIN as acknowledged if applicable. */ ! 863: if ( acked_flags ) ! 864: tcp->tcp_state |= TCP_STATE_ACKED ( acked_flags ); ! 865: ! 866: /* Start sending FIN if we've had all possible data ACKed */ ! 867: if ( list_empty ( &tcp->tx_queue ) && ( tcp->flags & TCP_XFER_CLOSED ) ) ! 868: tcp->tcp_state |= TCP_STATE_SENT ( TCP_FIN ); ! 869: ! 870: return 0; ! 871: } ! 872: ! 873: /** ! 874: * Handle TCP received data ! 875: * ! 876: * @v tcp TCP connection ! 877: * @v seq SEQ value (in host-endian order) ! 878: * @v iobuf I/O buffer ! 879: * @ret rc Return status code ! 880: * ! 881: * This function takes ownership of the I/O buffer. ! 882: */ ! 883: static int tcp_rx_data ( struct tcp_connection *tcp, uint32_t seq, ! 884: struct io_buffer *iobuf ) { ! 885: uint32_t already_rcvd; ! 886: uint32_t len; ! 887: int rc; ! 888: ! 889: /* Ignore duplicate or out-of-order data */ ! 890: already_rcvd = ( tcp->rcv_ack - seq ); ! 891: len = iob_len ( iobuf ); ! 892: if ( already_rcvd >= len ) { ! 893: free_iob ( iobuf ); ! 894: return 0; ! 895: } ! 896: iob_pull ( iobuf, already_rcvd ); ! 897: len -= already_rcvd; ! 898: ! 899: /* Acknowledge new data */ ! 900: tcp_rx_seq ( tcp, len ); ! 901: ! 902: /* Deliver data to application */ ! 903: if ( ( rc = xfer_deliver_iob ( &tcp->xfer, iobuf ) ) != 0 ) { ! 904: DBGC ( tcp, "TCP %p could not deliver %08x..%08x: %s\n", ! 905: tcp, seq, ( seq + len ), strerror ( rc ) ); ! 906: return rc; ! 907: } ! 908: ! 909: return 0; ! 910: } ! 911: ! 912: /** ! 913: * Handle TCP received FIN ! 914: * ! 915: * @v tcp TCP connection ! 916: * @v seq SEQ value (in host-endian order) ! 917: * @ret rc Return status code ! 918: */ ! 919: static int tcp_rx_fin ( struct tcp_connection *tcp, uint32_t seq ) { ! 920: ! 921: /* Ignore duplicate or out-of-order FIN */ ! 922: if ( seq != tcp->rcv_ack ) ! 923: return 0; ! 924: ! 925: /* Acknowledge FIN */ ! 926: tcp_rx_seq ( tcp, 1 ); ! 927: ! 928: /* Mark FIN as received */ ! 929: tcp->tcp_state |= TCP_STATE_RCVD ( TCP_FIN ); ! 930: ! 931: /* Close connection */ ! 932: tcp_close ( tcp, 0 ); ! 933: ! 934: return 0; ! 935: } ! 936: ! 937: /** ! 938: * Handle TCP received RST ! 939: * ! 940: * @v tcp TCP connection ! 941: * @v seq SEQ value (in host-endian order) ! 942: * @ret rc Return status code ! 943: */ ! 944: static int tcp_rx_rst ( struct tcp_connection *tcp, uint32_t seq ) { ! 945: ! 946: /* Accept RST only if it falls within the window. If we have ! 947: * not yet received a SYN, then we have no window to test ! 948: * against, so fall back to checking that our SYN has been ! 949: * ACKed. ! 950: */ ! 951: if ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) { ! 952: if ( ! tcp_in_window ( seq, tcp->rcv_ack, tcp->rcv_win ) ) ! 953: return 0; ! 954: } else { ! 955: if ( ! ( tcp->tcp_state & TCP_STATE_ACKED ( TCP_SYN ) ) ) ! 956: return 0; ! 957: } ! 958: ! 959: /* Abort connection */ ! 960: tcp->tcp_state = TCP_CLOSED; ! 961: tcp_dump_state ( tcp ); ! 962: tcp_close ( tcp, -ECONNRESET ); ! 963: ! 964: DBGC ( tcp, "TCP %p connection reset by peer\n", tcp ); ! 965: return -ECONNRESET; ! 966: } ! 967: ! 968: /** ! 969: * Enqueue received TCP packet ! 970: * ! 971: * @v tcp TCP connection ! 972: * @v seq SEQ value (in host-endian order) ! 973: * @v flags TCP flags ! 974: * @v iobuf I/O buffer ! 975: */ ! 976: static void tcp_rx_enqueue ( struct tcp_connection *tcp, uint32_t seq, ! 977: uint8_t flags, struct io_buffer *iobuf ) { ! 978: struct tcp_rx_queued_header *tcpqhdr; ! 979: struct io_buffer *queued; ! 980: size_t len; ! 981: uint32_t seq_len; ! 982: ! 983: /* Calculate remaining flags and sequence length. Note that ! 984: * SYN, if present, has already been processed by this point. ! 985: */ ! 986: flags &= TCP_FIN; ! 987: len = iob_len ( iobuf ); ! 988: seq_len = ( len + ( flags ? 1 : 0 ) ); ! 989: ! 990: /* Discard immediately (to save memory) if: ! 991: * ! 992: * a) we have not yet received a SYN (and so have no defined ! 993: * receive window), or ! 994: * b) the packet lies entirely outside the receive window, or ! 995: * c) there is no further content to process. ! 996: */ ! 997: if ( ( ! ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) ) || ! 998: ( tcp_cmp ( seq, tcp->rcv_ack + tcp->rcv_win ) >= 0 ) || ! 999: ( tcp_cmp ( seq + seq_len, tcp->rcv_ack ) < 0 ) || ! 1000: ( seq_len == 0 ) ) { ! 1001: free_iob ( iobuf ); ! 1002: return; ! 1003: } ! 1004: ! 1005: /* Add internal header */ ! 1006: tcpqhdr = iob_push ( iobuf, sizeof ( *tcpqhdr ) ); ! 1007: tcpqhdr->seq = seq; ! 1008: tcpqhdr->flags = flags; ! 1009: ! 1010: /* Add to RX queue */ ! 1011: list_for_each_entry ( queued, &tcp->rx_queue, list ) { ! 1012: tcpqhdr = queued->data; ! 1013: if ( tcp_cmp ( seq, tcpqhdr->seq ) < 0 ) ! 1014: break; ! 1015: } ! 1016: list_add_tail ( &iobuf->list, &queued->list ); ! 1017: } ! 1018: ! 1019: /** ! 1020: * Process receive queue ! 1021: * ! 1022: * @v tcp TCP connection ! 1023: */ ! 1024: static void tcp_process_rx_queue ( struct tcp_connection *tcp ) { ! 1025: struct io_buffer *iobuf; ! 1026: struct tcp_rx_queued_header *tcpqhdr; ! 1027: uint32_t seq; ! 1028: unsigned int flags; ! 1029: size_t len; ! 1030: ! 1031: /* Process all applicable received buffers. Note that we ! 1032: * cannot use list_for_each_entry() to iterate over the RX ! 1033: * queue, since tcp_discard() may remove packets from the RX ! 1034: * queue while we are processing. ! 1035: */ ! 1036: while ( ( iobuf = list_first_entry ( &tcp->rx_queue, struct io_buffer, ! 1037: list ) ) ) { ! 1038: ! 1039: /* Stop processing when we hit the first gap */ ! 1040: tcpqhdr = iobuf->data; ! 1041: if ( tcp_cmp ( tcpqhdr->seq, tcp->rcv_ack ) > 0 ) ! 1042: break; ! 1043: ! 1044: /* Strip internal header and remove from RX queue */ ! 1045: list_del ( &iobuf->list ); ! 1046: seq = tcpqhdr->seq; ! 1047: flags = tcpqhdr->flags; ! 1048: iob_pull ( iobuf, sizeof ( *tcpqhdr ) ); ! 1049: len = iob_len ( iobuf ); ! 1050: ! 1051: /* Handle new data, if any */ ! 1052: tcp_rx_data ( tcp, seq, iob_disown ( iobuf ) ); ! 1053: seq += len; ! 1054: ! 1055: /* Handle FIN, if present */ ! 1056: if ( flags & TCP_FIN ) { ! 1057: tcp_rx_fin ( tcp, seq ); ! 1058: seq++; ! 1059: } ! 1060: } ! 1061: } ! 1062: ! 1063: /** ! 1064: * Process received packet ! 1065: * ! 1066: * @v iobuf I/O buffer ! 1067: * @v st_src Partially-filled source address ! 1068: * @v st_dest Partially-filled destination address ! 1069: * @v pshdr_csum Pseudo-header checksum ! 1070: * @ret rc Return status code ! 1071: */ ! 1072: static int tcp_rx ( struct io_buffer *iobuf, ! 1073: struct sockaddr_tcpip *st_src, ! 1074: struct sockaddr_tcpip *st_dest __unused, ! 1075: uint16_t pshdr_csum ) { ! 1076: struct tcp_header *tcphdr = iobuf->data; ! 1077: struct tcp_connection *tcp; ! 1078: struct tcp_options options; ! 1079: size_t hlen; ! 1080: uint16_t csum; ! 1081: uint32_t seq; ! 1082: uint32_t ack; ! 1083: uint32_t win; ! 1084: unsigned int flags; ! 1085: size_t len; ! 1086: uint32_t seq_len; ! 1087: int rc; ! 1088: ! 1089: /* Sanity check packet */ ! 1090: if ( iob_len ( iobuf ) < sizeof ( *tcphdr ) ) { ! 1091: DBG ( "TCP packet too short at %zd bytes (min %zd bytes)\n", ! 1092: iob_len ( iobuf ), sizeof ( *tcphdr ) ); ! 1093: rc = -EINVAL; ! 1094: goto discard; ! 1095: } ! 1096: hlen = ( ( tcphdr->hlen & TCP_MASK_HLEN ) / 16 ) * 4; ! 1097: if ( hlen < sizeof ( *tcphdr ) ) { ! 1098: DBG ( "TCP header too short at %zd bytes (min %zd bytes)\n", ! 1099: hlen, sizeof ( *tcphdr ) ); ! 1100: rc = -EINVAL; ! 1101: goto discard; ! 1102: } ! 1103: if ( hlen > iob_len ( iobuf ) ) { ! 1104: DBG ( "TCP header too long at %zd bytes (max %zd bytes)\n", ! 1105: hlen, iob_len ( iobuf ) ); ! 1106: rc = -EINVAL; ! 1107: goto discard; ! 1108: } ! 1109: csum = tcpip_continue_chksum ( pshdr_csum, iobuf->data, ! 1110: iob_len ( iobuf ) ); ! 1111: if ( csum != 0 ) { ! 1112: DBG ( "TCP checksum incorrect (is %04x including checksum " ! 1113: "field, should be 0000)\n", csum ); ! 1114: rc = -EINVAL; ! 1115: goto discard; ! 1116: } ! 1117: ! 1118: /* Parse parameters from header and strip header */ ! 1119: tcp = tcp_demux ( ntohs ( tcphdr->dest ) ); ! 1120: seq = ntohl ( tcphdr->seq ); ! 1121: ack = ntohl ( tcphdr->ack ); ! 1122: win = ntohs ( tcphdr->win ); ! 1123: flags = tcphdr->flags; ! 1124: tcp_rx_opts ( tcp, ( ( ( void * ) tcphdr ) + sizeof ( *tcphdr ) ), ! 1125: ( hlen - sizeof ( *tcphdr ) ), &options ); ! 1126: if ( options.tsopt ) ! 1127: tcp->ts_val = ntohl ( options.tsopt->tsval ); ! 1128: iob_pull ( iobuf, hlen ); ! 1129: len = iob_len ( iobuf ); ! 1130: seq_len = ( len + ( ( flags & TCP_SYN ) ? 1 : 0 ) + ! 1131: ( ( flags & TCP_FIN ) ? 1 : 0 ) ); ! 1132: ! 1133: /* Dump header */ ! 1134: DBGC2 ( tcp, "TCP %p RX %d<-%d %08x %08x..%08x %4zd", ! 1135: tcp, ntohs ( tcphdr->dest ), ntohs ( tcphdr->src ), ! 1136: ntohl ( tcphdr->ack ), ntohl ( tcphdr->seq ), ! 1137: ( ntohl ( tcphdr->seq ) + seq_len ), len ); ! 1138: tcp_dump_flags ( tcp, tcphdr->flags ); ! 1139: DBGC2 ( tcp, "\n" ); ! 1140: ! 1141: /* If no connection was found, send RST */ ! 1142: if ( ! tcp ) { ! 1143: tcp_xmit_reset ( tcp, st_src, tcphdr ); ! 1144: rc = -ENOTCONN; ! 1145: goto discard; ! 1146: } ! 1147: ! 1148: /* Handle ACK, if present */ ! 1149: if ( flags & TCP_ACK ) { ! 1150: if ( ( rc = tcp_rx_ack ( tcp, ack, win ) ) != 0 ) { ! 1151: tcp_xmit_reset ( tcp, st_src, tcphdr ); ! 1152: goto discard; ! 1153: } ! 1154: } ! 1155: ! 1156: /* Force an ACK if this packet is out of order */ ! 1157: if ( ( tcp->tcp_state & TCP_STATE_RCVD ( TCP_SYN ) ) && ! 1158: ( seq != tcp->rcv_ack ) ) { ! 1159: tcp->flags |= TCP_ACK_PENDING; ! 1160: } ! 1161: ! 1162: /* Handle SYN, if present */ ! 1163: if ( flags & TCP_SYN ) { ! 1164: tcp_rx_syn ( tcp, seq, &options ); ! 1165: seq++; ! 1166: } ! 1167: ! 1168: /* Handle RST, if present */ ! 1169: if ( flags & TCP_RST ) { ! 1170: if ( ( rc = tcp_rx_rst ( tcp, seq ) ) != 0 ) ! 1171: goto discard; ! 1172: } ! 1173: ! 1174: /* Enqueue received data */ ! 1175: tcp_rx_enqueue ( tcp, seq, flags, iob_disown ( iobuf ) ); ! 1176: ! 1177: /* Process receive queue */ ! 1178: tcp_process_rx_queue ( tcp ); ! 1179: ! 1180: /* Dump out any state change as a result of the received packet */ ! 1181: tcp_dump_state ( tcp ); ! 1182: ! 1183: /* Send out any pending data */ ! 1184: tcp_xmit ( tcp ); ! 1185: ! 1186: /* If this packet was the last we expect to receive, set up ! 1187: * timer to expire and cause the connection to be freed. ! 1188: */ ! 1189: if ( TCP_CLOSED_GRACEFULLY ( tcp->tcp_state ) ) { ! 1190: stop_timer ( &tcp->wait ); ! 1191: start_timer_fixed ( &tcp->wait, ( 2 * TCP_MSL ) ); ! 1192: } ! 1193: ! 1194: return 0; ! 1195: ! 1196: discard: ! 1197: /* Free received packet */ ! 1198: free_iob ( iobuf ); ! 1199: return rc; ! 1200: } ! 1201: ! 1202: /** TCP protocol */ ! 1203: struct tcpip_protocol tcp_protocol __tcpip_protocol = { ! 1204: .name = "TCP", ! 1205: .rx = tcp_rx, ! 1206: .tcpip_proto = IP_TCP, ! 1207: }; ! 1208: ! 1209: /** ! 1210: * Discard some cached TCP data ! 1211: * ! 1212: * @ret discarded Number of cached items discarded ! 1213: */ ! 1214: static unsigned int tcp_discard ( void ) { ! 1215: struct tcp_connection *tcp; ! 1216: struct io_buffer *iobuf; ! 1217: unsigned int discarded = 0; ! 1218: ! 1219: /* Try to drop one queued RX packet from each connection */ ! 1220: list_for_each_entry ( tcp, &tcp_conns, list ) { ! 1221: list_for_each_entry_reverse ( iobuf, &tcp->rx_queue, list ) { ! 1222: list_del ( &iobuf->list ); ! 1223: free_iob ( iobuf ); ! 1224: discarded++; ! 1225: break; ! 1226: } ! 1227: } ! 1228: ! 1229: return discarded; ! 1230: } ! 1231: ! 1232: /** TCP cache discarder */ ! 1233: struct cache_discarder tcp_cache_discarder __cache_discarder = { ! 1234: .discard = tcp_discard, ! 1235: }; ! 1236: ! 1237: /*************************************************************************** ! 1238: * ! 1239: * Data transfer interface ! 1240: * ! 1241: *************************************************************************** ! 1242: */ ! 1243: ! 1244: /** ! 1245: * Close interface ! 1246: * ! 1247: * @v tcp TCP connection ! 1248: * @v rc Reason for close ! 1249: */ ! 1250: static void tcp_xfer_close ( struct tcp_connection *tcp, int rc ) { ! 1251: ! 1252: /* Close data transfer interface */ ! 1253: tcp_close ( tcp, rc ); ! 1254: ! 1255: /* Transmit FIN, if possible */ ! 1256: tcp_xmit ( tcp ); ! 1257: } ! 1258: ! 1259: /** ! 1260: * Check flow control window ! 1261: * ! 1262: * @v tcp TCP connection ! 1263: * @ret len Length of window ! 1264: */ ! 1265: static size_t tcp_xfer_window ( struct tcp_connection *tcp ) { ! 1266: ! 1267: /* Not ready if data queue is non-empty. This imposes a limit ! 1268: * of only one unACKed packet in the TX queue at any time; we ! 1269: * do this to conserve memory usage. ! 1270: */ ! 1271: if ( ! list_empty ( &tcp->tx_queue ) ) ! 1272: return 0; ! 1273: ! 1274: /* Return TCP window length */ ! 1275: return tcp_xmit_win ( tcp ); ! 1276: } ! 1277: ! 1278: /** ! 1279: * Deliver datagram as I/O buffer ! 1280: * ! 1281: * @v tcp TCP connection ! 1282: * @v iobuf Datagram I/O buffer ! 1283: * @v meta Data transfer metadata ! 1284: * @ret rc Return status code ! 1285: */ ! 1286: static int tcp_xfer_deliver ( struct tcp_connection *tcp, ! 1287: struct io_buffer *iobuf, ! 1288: struct xfer_metadata *meta __unused ) { ! 1289: ! 1290: /* Enqueue packet */ ! 1291: list_add_tail ( &iobuf->list, &tcp->tx_queue ); ! 1292: ! 1293: /* Transmit data, if possible */ ! 1294: tcp_xmit ( tcp ); ! 1295: ! 1296: return 0; ! 1297: } ! 1298: ! 1299: /** TCP data transfer interface operations */ ! 1300: static struct interface_operation tcp_xfer_operations[] = { ! 1301: INTF_OP ( xfer_deliver, struct tcp_connection *, tcp_xfer_deliver ), ! 1302: INTF_OP ( xfer_window, struct tcp_connection *, tcp_xfer_window ), ! 1303: INTF_OP ( intf_close, struct tcp_connection *, tcp_xfer_close ), ! 1304: }; ! 1305: ! 1306: /** TCP data transfer interface descriptor */ ! 1307: static struct interface_descriptor tcp_xfer_desc = ! 1308: INTF_DESC ( struct tcp_connection, xfer, tcp_xfer_operations ); ! 1309: ! 1310: /*************************************************************************** ! 1311: * ! 1312: * Openers ! 1313: * ! 1314: *************************************************************************** ! 1315: */ ! 1316: ! 1317: /** TCP socket opener */ ! 1318: struct socket_opener tcp_socket_opener __socket_opener = { ! 1319: .semantics = TCP_SOCK_STREAM, ! 1320: .family = AF_INET, ! 1321: .open = tcp_open, ! 1322: }; ! 1323: ! 1324: /** Linkage hack */ ! 1325: int tcp_sock_stream = TCP_SOCK_STREAM; ! 1326: ! 1327: /** ! 1328: * Open TCP URI ! 1329: * ! 1330: * @v xfer Data transfer interface ! 1331: * @v uri URI ! 1332: * @ret rc Return status code ! 1333: */ ! 1334: static int tcp_open_uri ( struct interface *xfer, struct uri *uri ) { ! 1335: struct sockaddr_tcpip peer; ! 1336: ! 1337: /* Sanity check */ ! 1338: if ( ! uri->host ) ! 1339: return -EINVAL; ! 1340: ! 1341: memset ( &peer, 0, sizeof ( peer ) ); ! 1342: peer.st_port = htons ( uri_port ( uri, 0 ) ); ! 1343: return xfer_open_named_socket ( xfer, SOCK_STREAM, ! 1344: ( struct sockaddr * ) &peer, ! 1345: uri->host, NULL ); ! 1346: } ! 1347: ! 1348: /** TCP URI opener */ ! 1349: struct uri_opener tcp_uri_opener __uri_opener = { ! 1350: .scheme = "tcp", ! 1351: .open = tcp_open_uri, ! 1352: }; ! 1353:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.