Subversion Repositories Kolibri OS

Rev

Rev 3556 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                                 ;;
  3. ;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
  4. ;; Distributed under terms of the GNU General Public License       ;;
  5. ;;                                                                 ;;
  6. ;;  Part of the TCP/IP network stack for KolibriOS                 ;;
  7. ;;                                                                 ;;
  8. ;;   Written by hidnplayr@kolibrios.org                            ;;
  9. ;;                                                                 ;;
  10. ;;    Based on the code of 4.4BSD                                  ;;
  11. ;;                                                                 ;;
  12. ;;          GNU GENERAL PUBLIC LICENSE                             ;;
  13. ;;             Version 2, June 1991                                ;;
  14. ;;                                                                 ;;
  15. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  16.  
  17. $Revision: 3289 $
  18.  
  19. ;-----------------------------------------------------------------
  20. ;
  21. ; TCP_output
  22. ;
  23. ; IN:  eax = socket pointer
  24. ;
  25. ; OUT: /
  26. ;
  27. ;-----------------------------------------------------------------
  28. align 4
  29. TCP_output:
  30.  
  31.         DEBUGF  1,"TCP_output: socket=%x\n", eax
  32.  
  33.         push    eax
  34.         lea     ecx, [eax + SOCKET.mutex]
  35.         call    mutex_lock
  36.         pop     eax
  37.  
  38. ; We'll detect the length of the data to be transmitted, and flags to be used
  39. ; If there is some data, or any critical controls to send (SYN / RST), then transmit
  40. ; Otherwise, investigate further
  41.  
  42.         mov     ebx, [eax + TCP_SOCKET.SND_MAX]
  43.         cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
  44.         jbe     .not_idle
  45.  
  46.         mov     ebx, [eax + TCP_SOCKET.t_idle]
  47.         cmp     ebx, [eax + TCP_SOCKET.t_rxtcur]
  48.         jbe     .not_idle
  49.  
  50. ; We have been idle for a while and no ACKS are expected to clock out any data we send..
  51. ; Slow start to get ack "clock" running again.
  52.  
  53.         mov     ebx, [eax + TCP_SOCKET.t_maxseg]
  54.         mov     [eax + TCP_SOCKET.SND_CWND], ebx
  55.  
  56.   .not_idle:
  57.   .again:
  58.         mov     [eax + TCP_SOCKET.temp_bits], 0
  59.  
  60.         mov     ebx, [eax + TCP_SOCKET.SND_NXT]         ; calculate offset (71)
  61.         sub     ebx, [eax + TCP_SOCKET.SND_UNA]         ;
  62.  
  63.         mov     ecx, [eax + TCP_SOCKET.SND_WND]         ; determine window
  64.         cmp     ecx, [eax + TCP_SOCKET.SND_CWND]        ;
  65.         jb      @f                                      ;
  66.         mov     ecx, [eax + TCP_SOCKET.SND_CWND]        ;
  67.        @@:                                              ;
  68.  
  69.         call    TCP_outflags                            ; flags in dl
  70.  
  71. ;------------------------
  72. ; data being forced out ?
  73.  
  74. ; If in persist timeout with window of 0, send 1 byte.
  75. ; Otherwise, if window is small but nonzero, and timer expired,
  76. ; we will send what we can and go to transmit state
  77.  
  78.         cmp     [eax + TCP_SOCKET.t_force], 0
  79.         je      .no_force
  80.  
  81.         DEBUGF 1,"TCP_output: forcing data out\n"
  82.  
  83.         test    ecx, ecx
  84.         jnz     .no_zero_window
  85.  
  86.         cmp     ebx, [eax + STREAM_SOCKET.snd.size]
  87.         jae     @f
  88.  
  89.         and     dl, not (TH_FIN)
  90.  
  91.        @@:
  92.         inc     ecx
  93.         jmp     .no_force
  94.  
  95.   .no_zero_window:
  96.         mov     [eax + TCP_SOCKET.timer_persist], 0
  97.         mov     [eax + TCP_SOCKET.t_rxtshift], 0
  98.  
  99.   .no_force:
  100.  
  101. ;--------------------------------
  102. ; Calculate how much data to send (106)
  103.  
  104.         mov     esi, [eax + STREAM_SOCKET.snd.size]
  105.         cmp     esi, ecx
  106.         jb      @f
  107.         mov     esi, ecx
  108.        @@:
  109.         sub     esi, ebx
  110.  
  111.  
  112. ;------------------------
  113. ; check for window shrink (107)
  114.  
  115. ; If FIN has been set, but not ACKed, but we havent been called to retransmit, esi will be -1
  116. ; Otherwise, window shrank after we sent into it.
  117.  
  118.         jae     .not_persist
  119.  
  120. ; enter persist state
  121.         xor     esi, esi
  122.  
  123. ; If window shrank to 0
  124.         test    ecx, ecx
  125.         jnz     @f
  126.  
  127. ; cancel pending retransmit
  128.         mov     [eax + TCP_SOCKET.timer_retransmission], 0
  129.  
  130. ; pull SND_NXT back to (closed) window, We will enter persist state below.
  131.         push    [eax + TCP_SOCKET.SND_UNA]
  132.         pop     [eax + TCP_SOCKET.SND_NXT]
  133.        @@:
  134.  
  135. ; If window didn't close completely, just wait for an ACK
  136.  
  137.   .not_persist:
  138.  
  139. ;---------------------------
  140. ; Send one segment at a time (124)
  141.  
  142.         cmp     esi, [eax + TCP_SOCKET.t_maxseg]
  143.         jbe     @f
  144.  
  145.         mov     esi, [eax + TCP_SOCKET.t_maxseg]
  146.         or      [eax + TCP_SOCKET.temp_bits], TCP_BIT_SENDALOT
  147.        @@:
  148.  
  149. ;--------------------------------------------
  150. ; Turn of FIN flag if send buffer not emptied (128)
  151.  
  152.         mov     edi, [eax + TCP_SOCKET.SND_NXT]
  153.         add     edi, esi
  154.         sub     edi, [eax + TCP_SOCKET.SND_UNA]
  155.         cmp     edi, [eax + STREAM_SOCKET.snd.size]
  156.         jae     @f
  157.         and     dl, not (TH_FIN)
  158.  
  159.        @@:
  160.  
  161. ;-------------------------------
  162. ; calculate window advertisement (130)
  163.  
  164.         mov     ecx, SOCKET_MAXDATA
  165.         sub     ecx, [eax + STREAM_SOCKET.rcv.size]
  166.  
  167. ;------------------------------
  168. ; Sender silly window avoidance (131)
  169.  
  170.         test    esi, esi
  171.         jz      .len_zero
  172.  
  173.         cmp     esi, [eax + TCP_SOCKET.t_maxseg]
  174.         je      TCP_send
  175.  
  176.         add     ebx, esi                                ; offset + length
  177.         cmp     ebx, [eax + STREAM_SOCKET.snd.size]
  178.         jb      @f
  179.  
  180.         test    [eax + TCP_SOCKET.t_flags], TF_NODELAY
  181.         jnz     TCP_send
  182.  
  183.         mov     ebx, [eax + TCP_SOCKET.SND_MAX]
  184.         cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
  185.         je      TCP_send
  186.        @@:
  187.  
  188.         test    [eax + TCP_SOCKET.t_force], -1  ;;;
  189.         jnz     TCP_send
  190.  
  191.         mov     ebx, [eax + TCP_SOCKET.max_sndwnd]
  192.         shr     ebx, 1
  193.         cmp     esi, ebx
  194.         jae     TCP_send
  195.  
  196.         mov     ebx, [eax + TCP_SOCKET.SND_NXT]
  197.         cmp     ebx, [eax + TCP_SOCKET.SND_MAX]
  198.         jb      TCP_send
  199.  
  200.   .len_zero:
  201.  
  202. ;----------------------------------------
  203. ; Check if a window update should be sent (154)
  204.  
  205.         DEBUGF  1,"TCP_output: window=%d\n", ecx
  206.  
  207. ; Compare available window to amount of window known to peer (as advertised window less next expected input)
  208. ; If the difference is at least two max size segments, or at least 50% of the maximum possible window,
  209. ; Then we want to send a window update to the peer.
  210.  
  211.         test    ecx, ecx
  212.         jz      .no_window
  213.  
  214.         push    ecx
  215.         mov     cl, [eax + TCP_SOCKET.RCV_SCALE]
  216.         mov     ebx, TCP_max_win
  217.         shl     ebx, cl
  218.         pop     ecx
  219.         cmp     ebx, ecx
  220.         jb      @f
  221.         mov     ebx, ecx
  222.        @@:
  223.         sub     ebx, [eax + TCP_SOCKET.RCV_ADV]
  224.         add     ebx, [eax + TCP_SOCKET.RCV_NXT]
  225.  
  226.         mov     edi, [eax + TCP_SOCKET.t_maxseg]
  227.         shl     edi, 1
  228.  
  229. ;        cmp     ebx, edi
  230. ;        jae     TCP_send
  231.  
  232. ;        cmp     ebx, [eax + TCP_SOCKET.]    ;;; TODO: check with receive buffer high water mark
  233. ;        jae     TCP_send
  234.  
  235.   .no_window:
  236.  
  237. ;--------------------------
  238. ; Should a segment be sent? (174)
  239.  
  240.         DEBUGF  1,"TCP_output: 174\n"
  241.  
  242.         test    [eax + TCP_SOCKET.t_flags], TF_ACKNOW   ; we need to ACK
  243.         jnz     TCP_send
  244.  
  245.         test    dl, TH_SYN + TH_RST                     ; we need to send a SYN or RST
  246.         jnz     TCP_send
  247.  
  248.         mov     ebx, [eax + TCP_SOCKET.SND_UP]          ; when urgent pointer is beyond start of send bufer
  249.         cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
  250.         ja      TCP_send
  251.  
  252.         test    dl, TH_FIN
  253.         jz      .enter_persist  ; no reason to send, enter persist state
  254.  
  255. ; FIN was set, only send if not already sent, or on retransmit
  256.  
  257.         test    [eax + TCP_SOCKET.t_flags], TF_SENTFIN
  258.         jz      TCP_send
  259.  
  260.         mov     ebx, [eax + TCP_SOCKET.SND_NXT]
  261.         cmp     ebx, [eax + TCP_SOCKET.SND_UNA]
  262.         je      TCP_send
  263.  
  264. ;--------------------
  265. ; Enter persist state (191)
  266.  
  267.   .enter_persist:
  268.  
  269.         cmp     [eax + STREAM_SOCKET.snd.size], 0       ; Data ready to send?
  270.         jne     @f
  271.         cmp     [eax + TCP_SOCKET.timer_retransmission], 0
  272.         jne     @f
  273.         cmp     [eax + TCP_SOCKET.timer_persist], 0     ; Persist timer already expired?
  274.         jne     @f
  275.  
  276.         DEBUGF  1,"TCP_output: Entering persist state\n"
  277.  
  278.         mov     [eax + TCP_SOCKET.t_rxtshift], 0
  279.         call    TCP_set_persist
  280.        @@:
  281.  
  282. ;----------------------------
  283. ; No reason to send a segment (219)
  284.  
  285.         DEBUGF  1,"TCP_output: No reason to send a segment\n"
  286.  
  287.         pusha
  288.         lea     ecx, [eax + SOCKET.mutex]
  289.         call    mutex_unlock
  290.         popa
  291.  
  292. ; Fixme: returnvalue?
  293.  
  294.         ret
  295.  
  296.  
  297.  
  298.  
  299.  
  300.  
  301.  
  302.  
  303.  
  304. ;-----------------------------------------------
  305. ;
  306. ; Send a segment (222)
  307. ;
  308. ; eax = socket pointer
  309. ; esi = data len
  310. ;  dl = flags
  311. ;
  312. ;-----------------------------------------------
  313. align 4
  314. TCP_send:
  315.  
  316.         DEBUGF  1,"TCP_send: socket=%x length=%u flags=%x\n", eax, esi, dl
  317.  
  318.         push    eax                     ; save socket ptr
  319.         push    esi                     ; and data length too
  320.         mov     edi, sizeof.TCP_header  ; edi will contain headersize
  321.  
  322. ;------------------------------------
  323. ; Send options with first SYN segment
  324.  
  325.         test    dl, TH_SYN
  326.         jz      .options_done
  327.  
  328.         push    [eax + TCP_SOCKET.ISS]
  329.         pop     [eax + TCP_SOCKET.SND_NXT]
  330.  
  331.         test    [eax + TCP_SOCKET.t_flags], TF_NOOPT
  332.         jnz     .options_done
  333.  
  334.         mov     ecx, 1460                              ;;;; FIXME: use routing blablabla to determine MSS
  335.         or      ecx, TCP_OPT_MAXSEG shl 24 + 4 shl 16
  336.         bswap   ecx
  337.         push    ecx
  338.         add     di, 4
  339.  
  340.         DEBUGF  1,"TCP_send: added maxseg option\n"
  341.  
  342.         test    [eax + TCP_SOCKET.t_flags], TF_REQ_SCALE
  343.         jz      .no_scale
  344.  
  345.         test    dl, TH_ACK
  346.         jz      .scale_opt
  347.  
  348.         test    [eax + TCP_SOCKET.t_flags], TF_RCVD_SCALE
  349.         jz      .no_scale
  350.  
  351.   .scale_opt:
  352.         mov     cl, [eax + TCP_SOCKET.request_r_scale]
  353.         mov     ch, TCP_OPT_NOP
  354.         pushw   cx
  355.         pushw   TCP_OPT_WINDOW + 3 shl 8
  356.         add     di, 4
  357.  
  358.         DEBUGF  1,"TCP_send: added scale option\n"
  359.  
  360.   .no_scale:
  361.   .no_syn:
  362.  
  363. ;------------------------------------
  364. ; Make the timestamp option if needed
  365.  
  366.         test    [eax + TCP_SOCKET.t_flags], TF_REQ_TSTMP
  367.         jz      .no_timestamp
  368.  
  369.         test    dl, TH_RST
  370.         jnz     .no_timestamp
  371.  
  372.         test    dl, TH_ACK
  373.         jz      .timestamp
  374.  
  375.         test    [eax + TCP_SOCKET.t_flags], TF_RCVD_TSTMP
  376.         jz      .no_timestamp
  377.  
  378.   .timestamp:
  379.         pushd   0
  380.         pushd   [timer_ticks]
  381.         pushd   TCP_OPT_NOP + TCP_OPT_NOP shl 8 + TCP_OPT_TIMESTAMP shl 16 + 10 shl 24
  382.         add     di, 12
  383.  
  384.         DEBUGF  1,"TCP_send: added timestamp\n"
  385.  
  386.   .no_timestamp:
  387.  
  388.         ; <Add additional options here>
  389.  
  390.   .options_done:
  391.  
  392. ; eax = socket ptr
  393. ; edx = flags
  394. ; edi = header size
  395. ; esi = data len
  396.  
  397. ;---------------------------------------------
  398. ; check if we dont exceed the max segment size (270)
  399.  
  400.         add     esi, edi                        ; total TCP segment size
  401.         cmp     esi, [eax + TCP_SOCKET.t_maxseg]
  402.         jbe     .no_overflow
  403.  
  404.         mov     esi, [eax + TCP_SOCKET.t_maxseg]
  405.         or      [eax + TCP_SOCKET.temp_bits], TCP_BIT_SENDALOT
  406.   .no_overflow:
  407.  
  408. ;-----------------------------------------------------------------
  409. ; Start by pushing all TCP header values in reverse order on stack
  410. ; (essentially, creating the tcp header on the stack!)
  411.  
  412.         pushw   0       ;        .UrgentPointer          dw ?
  413.         pushw   0       ;        .Checksum               dw ?
  414.         pushw   0x00a0  ;        .Window                 dw ?    ;;;;;;; FIXME (370)
  415.         shl     edi, 2  ;        .DataOffset             db ?  only 4 left-most bits
  416.         shl     dx, 8
  417.         or      dx, di  ;        .Flags                  db ?
  418.         pushw   dx
  419.         shr     edi, 2  ;        .DataOffset             db ?
  420.  
  421.         push    [eax + TCP_SOCKET.RCV_NXT]      ;        .AckNumber              dd ?
  422.         ntohd   [esp]
  423.  
  424.         push    [eax + TCP_SOCKET.SND_NXT]      ;        .SequenceNumber         dd ?
  425.         ntohd   [esp]
  426.  
  427.         push    [eax + TCP_SOCKET.RemotePort]   ;        .DestinationPort        dw ?
  428.         push    [eax + TCP_SOCKET.LocalPort]    ;        .SourcePort             dw ?
  429.  
  430.         push    edi                     ; header size
  431.  
  432. ;---------------------
  433. ; Create the IP packet
  434.  
  435.         mov     ecx, esi
  436.  
  437.         mov     ebx, [eax + SOCKET.device]
  438.         mov     edx, [eax + IP_SOCKET.LocalIP]  ; source ip
  439.         mov     eax, [eax + IP_SOCKET.RemoteIP] ; dest ip
  440.         mov     di, IP_PROTO_TCP shl 8 + 128
  441.         call    IPv4_output
  442.         jz      .ip_error
  443.  
  444. ;-----------------------------------------
  445. ; Move TCP header from stack to TCP packet
  446.  
  447.         push    ecx
  448.         mov     ecx, [esp + 4]
  449.         lea     esi, [esp + 8]
  450.         shr     ecx, 2                  ; count is in bytes, we will work with dwords
  451.         rep     movsd
  452.         pop     ecx                     ; full TCP packet size
  453.  
  454.         pop     esi                     ; headersize
  455.         add     esp, esi                ; remove it from stack
  456.  
  457.         push    edx                     ; packet size for send proc
  458.         push    eax                     ; packet ptr for send proc
  459.  
  460.         mov     edx, edi                ; begin of data
  461.         sub     edx, esi                ; begin of packet (edi = begin of data)
  462.         push    ecx
  463.         sub     ecx, esi                ; data size
  464.  
  465. ;--------------
  466. ; Copy the data
  467.  
  468. ; eax = ptr to ring struct
  469. ; ecx = buffer size
  470. ; edi = ptr to buffer
  471.  
  472.         mov     eax, [esp + 16]                 ; get socket ptr
  473.  
  474.         push    edx
  475.         push    [eax + TCP_SOCKET.SND_NXT]      ; we'll need this for timing the transmission
  476.         test    ecx, ecx
  477.         jz      .nodata
  478.         mov     edx, [eax + TCP_SOCKET.SND_NXT]
  479.         add     [eax + TCP_SOCKET.SND_NXT], ecx ; update sequence number <<< CHECKME
  480.         sub     edx, [eax + TCP_SOCKET.SND_UNA] ; offset
  481.         add     eax, STREAM_SOCKET.snd
  482.         call    SOCKET_ring_read
  483.   .nodata:
  484.         pop     edi
  485.         pop     esi                             ; begin of data
  486.         pop     ecx                             ; full packet size
  487.         mov     eax, [esp + 12]                 ; socket ptr
  488.  
  489. ;----------------------------------
  490. ; initialize retransmit timer (400)
  491.  
  492. ;TODO: check t_force and persist
  493.  
  494.         test    [esi + TCP_header.Flags], TH_SYN + TH_FIN       ; syn and fin take a sequence number
  495.         jz      @f
  496.         inc     [eax + TCP_SOCKET.SND_NXT]
  497.         test    [esi + TCP_header.Flags], TH_FIN
  498.         jz      @f
  499.         or      [eax + TCP_SOCKET.t_flags], TF_SENTFIN          ; if we sent a fin, set the sentfin flag
  500.        @@:
  501.  
  502.         mov     edx, [eax + TCP_SOCKET.SND_NXT]
  503.         cmp     edx, [eax + TCP_SOCKET.SND_MAX]                 ; is this a retransmission?
  504.         jbe     @f
  505.         mov     [eax + TCP_SOCKET.SND_MAX], edx                 ; [eax + TCP_SOCKET.SND_NXT] from before we updated it
  506.  
  507.         cmp     [eax + TCP_SOCKET.t_rtt], 0                     ; are we currently timing anything?
  508.         je      @f
  509.         mov     [eax + TCP_SOCKET.t_rtt], 1                     ; nope, start transmission timer
  510.         mov     [eax + TCP_SOCKET.t_rtseq], edi
  511. ;TODO: update stats
  512.        @@:
  513.  
  514. ; set retransmission timer if not already set, and not doing an ACK or keepalive probe
  515.  
  516.         cmp     [eax + TCP_SOCKET.timer_retransmission], 0 ;;;; FIXME
  517.         ja      .retransmit_set
  518.  
  519.         cmp     edx, [eax + TCP_SOCKET.SND_UNA]                 ; edx is still [eax + TCP_SOCKET.SND_NXT]
  520.         je      .retransmit_set
  521.  
  522.         mov     edx, [eax + TCP_SOCKET.t_rxtcur]
  523.         mov     [eax + TCP_SOCKET.timer_retransmission], edx
  524.  
  525.         cmp     [eax + TCP_SOCKET.timer_persist], 0
  526.         jne     .retransmit_set
  527.         mov     [eax + TCP_SOCKET.timer_persist], 0
  528.         mov     [eax + TCP_SOCKET.t_rxtshift], 0
  529.  
  530.   .retransmit_set:
  531.  
  532. ;--------------------
  533. ; Create the checksum
  534.  
  535.         TCP_checksum (eax + IP_SOCKET.LocalIP), (eax + IP_SOCKET.RemoteIP)
  536.         mov     [esi + TCP_header.Checksum], dx
  537.  
  538. ;----------------
  539. ; Send the packet
  540.  
  541.         DEBUGF  1,"TCP_send: Sending with device %x\n", ebx
  542.         call    [ebx + NET_DEVICE.transmit]
  543.         jnz     .send_error
  544.  
  545. ;---------------
  546. ; Ok, data sent!
  547.  
  548.         pop     ecx
  549.         pop     eax
  550.  
  551.         inc     [TCP_segments_tx]       ; FIXME: correct interface?
  552.  
  553. ; update advertised receive window
  554.         test    ecx, ecx
  555.         jz      @f
  556.         add     ecx, [eax + TCP_SOCKET.RCV_NXT]
  557.         cmp     ecx, [eax + TCP_SOCKET.RCV_ADV]
  558.         jbe     @f
  559.         mov     [eax + TCP_SOCKET.RCV_ADV], ecx
  560.        @@:
  561.  
  562. ; update last ack sent
  563.         push    [eax + TCP_SOCKET.RCV_NXT]
  564.         pop     [eax + TCP_SOCKET.last_ack_sent]
  565.  
  566. ; and flags
  567.         and     [eax + TCP_SOCKET.t_flags], not (TF_ACKNOW + TF_DELACK)
  568.  
  569. ;--------------
  570. ; unlock socket
  571.  
  572.         push    eax
  573.         lea     ecx, [eax + SOCKET.mutex]
  574.         call    mutex_unlock
  575.         pop     eax
  576.  
  577. ;-----------------------------
  578. ; Check if we need more output
  579.  
  580.         test    [eax + TCP_SOCKET.temp_bits], TCP_BIT_SENDALOT
  581.         jnz     TCP_output.again
  582.  
  583.         DEBUGF 1,"TCP_send: success!\n"
  584.  
  585.         xor     eax, eax
  586.         ret
  587.  
  588.  
  589.   .ip_error:
  590.         pop     ecx
  591.         add     esp, ecx
  592.         add     esp, 4
  593.         pop     eax
  594.  
  595.         mov     [eax + TCP_SOCKET.timer_retransmission], TCP_time_re_min
  596.  
  597.         lea     ecx, [eax + SOCKET.mutex]
  598.         call    mutex_unlock
  599.  
  600.         DEBUGF 1,"TCP_send: IP error\n"
  601.  
  602.         or      eax, -1
  603.         ret
  604.  
  605.  
  606.   .send_error:
  607.         add     esp, 8
  608.  
  609.         lea     ecx, [eax + SOCKET.mutex]
  610.         call    mutex_unlock
  611.  
  612.         DEBUGF 1,"TCP_send: sending failed\n"
  613.  
  614.         or      eax, -2
  615.         ret
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.