Subversion Repositories Kolibri OS

Rev

Rev 3555 | Rev 3626 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3555 Serge 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
 
3589 Serge 31
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: socket=%x\n", eax
3555 Serge 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
 
3589 Serge 81
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: forcing data out\n"
3555 Serge 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
 
3589 Serge 205
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: window=%d\n", ecx
3555 Serge 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
 
3589 Serge 240
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: 174\n"
3555 Serge 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
 
3589 Serge 276
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: Entering persist state\n"
3555 Serge 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
 
3589 Serge 285
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_output: No reason to send a segment\n"
3555 Serge 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
 
3589 Serge 316
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: socket=%x length=%u flags=%x\n", eax, esi, dl
3555 Serge 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
 
3589 Serge 340
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: added maxseg option\n"
3555 Serge 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
 
3589 Serge 358
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: added scale option\n"
3555 Serge 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
 
3589 Serge 384
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: added timestamp\n"
3555 Serge 385
 
386
  .no_timestamp:
387
 
388
        ; 
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
 
3589 Serge 541
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: Sending with device %x\n", ebx
3555 Serge 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
 
3589 Serge 583
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: success!\n"
3555 Serge 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
 
3589 Serge 600
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: IP error\n"
3555 Serge 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
 
3589 Serge 612
        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_send: sending failed\n"
3555 Serge 613
 
614
        or      eax, -2
615
        ret
616