Rev 3556 | Go to most recent revision | Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
3545 | hidnplayr | 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 | ; |
||
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 |