WebSVN – Kolibri OS – Diff – /kernel/branches/kolibri_pe/network/socket.inc

 ;;   22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net          ;;
 ;;   11.11.2006 - [Johnny_B] and [smb]                          ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 738 $
+$Revision: 914 $
 ;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ; 68| SEG.WND  Segment window                           INTEL format|
 ;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ; 72| Retransmit queue # NOW WINDOW SIZE TIMER          INTEL format|
 ;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
-; 76|      RX offset from
-; 76|       RX Data                                                 |
+; 76|       RX Data Buffer                                          |
 ;   +-+-+-..........                                               -+
+; so, define struct
+struc SOCKET
+{
-; so, define struct
+   .PrevPtr		    dd	 ?
-struc SOCKET
+   .NextPtr		    dd	 ?
-{  .Status		    dd	 ?  ;+00 - Status ( of this buffer )
+   .Status		    dd	 ?  ;+00 - Status ( of this buffer )
    .PID 		    dd	 ?  ;+04 - Application Process ID
-   .LocalIP		    dd	 ?  ;+08 -  Local IP Address
-   .LocalPort		    dw	 ?  ;+12 - Local Port
+   .LocalIP		    dd	 ?  ;+08 -  Local IP Address
-   .UnusedL		    dw	 ?  ;+14 - may be removed in future
+   .LocalPort		    dw	 ?  ;+12 - Local Port
+   .RemoteIP		    dd	 ?  ;+16 - Remote IP Address
-   .RemoteIP		    dd	 ?  ;+16 - Remote IP Address
+   .RemotePort		    dw	 ?  ;+20 - Remote Port
-   .RemotePort		    dw	 ?  ;+20 - Remote Port
+   .OrigRemoteIP	    dd	 ?
-   .UnusedR		    dw	 ?  ;+22 - may be removed in future
+   .OrigRemotePort	    dw	 ?
    .rxDataCount 	    dd	 ?  ;+24 - Rx Data Count
    .TCBState		    dd	 ?  ;+28 - TCB STATE
    .TCBTimer		    dd	 ?  ;+32 - TCB Timer (seconds)
 virtual at 0
   SOCKET SOCKET
 end virtual
 ; simple macro calcing real memory address of SOCKET struct by socket's
-macro	Index2RealAddr reg
+;macro   Index2RealAddr reg
-{
+;{
-	shl	reg, 12
+;        shl     reg, 12
-    add     reg, sockets
+;    add     reg, sockets
 ;}
 ;Constants
 ; current socket statuses
-SOCK_EMPTY	   equ	   0	    ; socket not in use
+SOCK_EMPTY	   =	 0	  ; socket not in use
-SOCK_OPEN	   equ	   1	    ; open issued, but no data sent
+SOCK_OPEN	   =	 1	  ; open issued, but no data sent
 ; TCP opening modes
-SOCKET_PASSIVE	   equ	   0
-SOCKET_ACTIVE	   equ	   1
+SOCKET_PASSIVE	   equ	   0
-;***************************************************************************
+SOCKET_ACTIVE	   equ	   1
-;   Function
-;      is_localport_unused
-;
-;   Description
-;         scans through all the active sockets , looking to see if the
+proc net_socket_alloc stdcall uses ebx ecx edx edi
-;      port number specified in bx is in use as a localport number.
-;      This is useful when you want a to generate a unique local port
-;      number.
-;          On return, eax = 1 for free, 0 for in use
-;
+    mov ecx, SOCKETBUFFSIZE
-;***************************************************************************
+    mov edx, PG_SW
+    call @mem_alloc@8
+	DEBUGF	1, "K : net_socket_alloc (0x%x)\n", eax
-is_localport_unused:
+	or	eax, eax
+	jz	.exit
+	push	eax
+	mov	edi, eax
+	mov	ecx, SOCKETBUFFSIZE / 4
+	cld
+	xor	eax, eax
+	rep	stosd
+	pop	eax
+	mov	ebx, net_sockets
+	push	[ebx + SOCKET.NextPtr]
+	mov	[ebx + SOCKET.NextPtr], eax
+	mov	[eax + SOCKET.PrevPtr], ebx
+	pop	ebx
-    mov     al, bh
+	mov	[eax + SOCKET.NextPtr], ebx
+	or	ebx, ebx
+	jz	@f
+	mov	[ebx + SOCKET.PrevPtr], eax
+    @@: mov	ebx, [TASK_BASE]
+	mov	ebx, [ebx + TASKDATA.pid]
+	mov	[eax + SOCKET.PID], ebx
-    mov     ah, bl
+  .exit:
+	ret
+endp
+proc net_socket_free stdcall uses ebx ecx edx, sock:DWORD
+	mov	eax, [sock]
+	DEBUGF	1, "K : net_socket_free (0x%x)\n", eax
+	or	eax, eax
+	jz	.error
+	mov	ebx, net_sockets
+	mov	ecx, [TASK_BASE]
+	mov	ecx, [ecx + TASKDATA.pid]
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
+	jz	.error
+	cmp	ebx, eax
+	jne	.next_socket
+	;cmp     [ebx + SOCKET.PID], ecx
+	;jne     .next_socket
+	mov	ebx, [eax + SOCKET.NextPtr]
+	mov	eax, [eax + SOCKET.PrevPtr]
+	mov	[eax + SOCKET.NextPtr], ebx
+	or	ebx, ebx
+	jz	@f
+	mov	[ebx + SOCKET.PrevPtr], eax
-    mov     bx, ax
+@@:
-    mov     edx, SOCKETBUFFSIZE * NUM_SOCKETS
-    mov     ecx, NUM_SOCKETS
+    mov ecx, [sock]
+    call @mem_free@4
+	ret
+  .error:
+	DEBUGF	1, "K :   failed\n"
+	ret
+endp
-    mov     eax, 0		      ; Assume the return value is 'in use'
+proc net_socket_num_to_addr stdcall uses ebx ecx, x:DWORD
+; FIXME: do real transform
+	mov	eax, [x]
+	mov	ebx, net_sockets
+	mov	ecx, [TASK_BASE]
+	mov	ecx, [ecx + TASKDATA.pid]
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
-ilu1:
+	or	ebx, ebx
+	jz	.error
-    sub     edx, SOCKETBUFFSIZE
+	cmp	ebx, eax
+	jne	.next_socket
+	;cmp     [ebx + SOCKET.PID], ecx
+	;jne     .next_socket
+	ret
+  .error:
+	xor	eax, eax
+	ret
+endp
+proc net_socket_addr_to_num stdcall uses ebx ecx, x:DWORD
+; FIXME: do real transform
+	mov	eax, [x]
+	mov	ebx, net_sockets
+	mov	ecx, [TASK_BASE]
+	mov	ecx, [ecx + TASKDATA.pid]
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
+	jz	.error
-    cmp     [edx + sockets + SOCKET.LocalPort], bx
+	cmp	ebx, eax
-    loopnz  ilu1		  ; Return back if the socket is occupied
+	jne	.next_socket
+	;cmp     [ebx + SOCKET.PID], ecx
-    jz	    ilu_exit
+	;jne     .next_socket
-    inc     eax 			; return port not in use
+	ret
+  .error:
+	xor	eax, eax
+	ret
+endp
-ilu_exit:
+;***************************************************************************
-    ret
+;   Function
-;***************************************************************************
+;      is_localport_unused
+;
-;   Function
+;   Description
+;         scans through all the active sockets , looking to see if the
-;      get_free_socket
+;      port number specified in bx is in use as a localport number.
+;      This is useful when you want a to generate a unique local port
-;
+;      number.
-;   Description
+;          On return, eax = 1 for free, 0 for in use
 ;
 ;***************************************************************************
+proc is_localport_unused stdcall
+	xchg	bl, bh
-get_free_socket:
-    push    ecx
+	xor	eax, eax			; Assume the return value is 'free'
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
+	inc	al
+	mov	edx, net_sockets
     mov     ecx, NUM_SOCKETS
   .next_socket:
-gfs1:
+	mov	edx, [edx + SOCKET.NextPtr]
 ;       remote port in ecx
 ;       remote ip in edx
 ;       return socket # in eax, -1 if none available
+;
 ;***************************************************************************
-socket_open:
+proc socket_open stdcall
-    call    get_free_socket
+	call	net_socket_alloc
+	or	eax, eax
+	jz	.error
-    cmp     eax, 0xFFFFFFFF
-    jz	    so_exit
 	DEBUGF	1, "K : socket_open (0x%x)\n", eax
-    ; ax holds the socket number that is free. Get real address
-    push    eax
-    Index2RealAddr eax
     push    eax
     mov     [eax + SOCKET.Status], dword SOCK_OPEN
 	mov	[eax + SOCKET.Status], SOCK_OPEN
     xchg    bh, bl
     mov     [eax + SOCKET.LocalPort], bx
     xchg    ch, cl
     mov     [eax + SOCKET.RemotePort], cx
-    mov     ebx, [stack_ip]
-    mov     [eax + SOCKET.LocalIP], ebx
-    mov     [eax + SOCKET.RemoteIP], edx
-    mov     [eax + SOCKET.rxDataCount], dword 0      ; recieved data count
-    mov     esi, [TASK_BASE]
+    mov     ebx, [stack_ip]
-    mov     ebx, [esi+TASKDATA.pid]
+    mov     [eax + SOCKET.LocalIP], ebx
+    mov     [eax + SOCKET.RemoteIP], edx
+	;pop     eax      ; Get the socket number back, so we can return it
+	stdcall net_socket_addr_to_num
+	ret
     mov     [eax + SOCKET.PID], ebx	    ; save the process ID
-    pop     eax      ; Get the socket number back, so we can return it
+  .error:
 	DEBUGF	1, "K : socket_open (fail)\n"
 ;       remote ip in edx ( in Internet byte order )
 ;       Socket open mode in esi  ( SOCKET_PASSIVE or SOCKET_ACTIVE )
 ;       return socket # in eax, -1 if none available
+;
 ;***************************************************************************
-socket_open_tcp:
+proc socket_open_tcp stdcall
-    call    get_free_socket
+local sockAddr dd ?
-    cmp     eax, 0xFFFFFFFF
+	cmp	esi, SOCKET_PASSIVE
-    jz	    so_exit
+	jne	.skip_port_check
+	push	ebx
-    ; ax holds the socket number that is free. Get real address
+	mov	eax, ebx
-    push eax
+	xchg	al, ah
-    Index2RealAddr eax
+	mov	ebx, net_sockets
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
+	jz	.last_socket
+	cmp	[ebx + SOCKET.TCBState], TCB_LISTEN
+	jne	.next_socket
+	cmp	[ebx + SOCKET.LocalPort], ax
+	jne	.next_socket
+	xchg	al, ah
+	DEBUGF	1, "K : error: port %u is listened by 0x%x\n", ax, ebx
+	pop	ebx
+	jmp	.error
+  .last_socket:
+	pop	ebx
+  .skip_port_check:
+	call	net_socket_alloc
+	or	eax, eax
+	jz	.error
 	DEBUGF	1, "K : socket_open_tcp (0x%x)\n", eax
-    mov     [sktAddr], eax
+	mov	[sockAddr], eax
     mov     [eax], dword SOCK_OPEN
     ; TODO - check this works!
-    ; TODO - check this works!
-    mov     [eax + SOCKET.wndsizeTimer], dword 0     ; Reset the window timer.
-	xchg	bh, bl
+	;xxx: already 0 (intialized by net_socket_alloc)
-	mov	[eax + SOCKET.LocalPort], bx
+	;mov     [eax + SOCKET.wndsizeTimer], 0     ; Reset the window timer.
-;    mov     [eax + 12], byte bh      ; Local port ( LS 16 bits )
-;    mov     [eax + 13], byte bl      ; Local port ( LS 16 bits )
-	xchg	ch, cl
+	xchg	bh, bl
-	mov	[eax + SOCKET.RemotePort], cx
+	mov	[eax + SOCKET.LocalPort], bx
-;    mov     [eax + 20], ch         ; Remote Port ( LS 16 bits )
+	xchg	ch, cl
-;    mov     [eax + 21], cl         ; Remote Port ( LS 16 bits )
+	mov	[eax + SOCKET.RemotePort], cx
-    mov     ebx, [stack_ip]
+	mov	[eax + SOCKET.OrigRemotePort], cx
-    mov     [eax + SOCKET.LocalIP], ebx
+    mov     ebx, [stack_ip]
-    mov     [eax + SOCKET.RemoteIP], edx
+    mov     [eax + SOCKET.LocalIP], ebx
-    mov     [eax + SOCKET.rxDataCount], dword 0
+    mov     [eax + SOCKET.RemoteIP], edx
-    ; Now fill in TCB state
-    mov     ebx, TCB_LISTEN
+	mov	[eax + SOCKET.OrigRemoteIP], edx
-    cmp     esi, SOCKET_PASSIVE
-    jz	    sot_001
-    mov     ebx, TCB_SYN_SENT
 sot_001:
-    mov     [eax + SOCKET.TCBState], ebx	    ; Indicate the state of the TCB
+    mov     ebx, TCB_LISTEN
     cmp     esi, SOCKET_PASSIVE
-    mov     esi, [TASK_BASE]
+	je	@f
-    mov     ecx, [esi+TASKDATA.pid]
+    mov     ebx, TCB_SYN_SENT
-    mov     [eax + SOCKET.PID], ecx	    ; save the process ID
+    @@: mov	[eax + SOCKET.TCBState], ebx		; Indicate the state of the TCB
     cmp     ebx, TCB_LISTEN
-    je	    sot_done
+	je	.exit
-    ; Now, if we are in active mode, then we have to send a SYN to the specified remote port
-    mov     eax, EMPTY_QUEUE
+    ; Now, if we are in active mode, then we have to send a SYN to the specified remote port
-    call    dequeue
+    mov     eax, EMPTY_QUEUE
-    cmp     ax, NO_BUFFER
+    call    dequeue
-    je	    sot_done
+    cmp     ax, NO_BUFFER
+	je	.exit
-    push    eax
-    mov     bl, 0x02	    ; SYN
+    push    eax
-    mov     ecx, 0
 	mov	bl, TH_SYN
-    call    buildTCPPacket
+	xor	ecx, ecx
 	stdcall build_tcp_packet, [sockAddr]
-    mov     eax, NET1OUT_QUEUE
     mov     eax, NET1OUT_QUEUE
-    mov     edx, [stack_ip]
-    mov     ecx, [sktAddr ]
+    mov     edx, [stack_ip]
-    mov     ecx, [ecx + 16]
+	mov	ecx, [sockAddr]
+	cmp	edx, [ecx + SOCKET.RemoteIP]
+	jne	.not_local
-    cmp     edx, ecx
+    mov     eax, IPIN_QUEUE
-    jne     sot_notlocal
-    mov     eax, IPIN_QUEUE
   .not_local:
+       ; Send it.
+    pop     ebx
+    call    queue
+	mov	esi, [sockAddr]
 sot_notlocal:
-       ; Send it.
+    ; increment SND.NXT in socket
-    pop     ebx
+	add	esi, SOCKET.SND_NXT
 ;   Description
 ;       socket # in ebx
 ;       returns 0 for ok, -1 for socket not open (fail)
+;
 ;***************************************************************************
-socket_close:
+proc socket_close stdcall
-    mov     eax, 0xFFFFFFFF	    ; assume this operation will fail..
+	DEBUGF	1, "K : socket_close (0x%x)\n", ebx
-    cmp     ebx, NUM_SOCKETS
+	stdcall net_socket_num_to_addr, ebx
-    jae     sc_exit
+	or	eax, eax
-    Index2RealAddr ebx
+	jz	.error
-    cmp     [ebx + SOCKET.Status], dword SOCK_EMPTY
+	cmp	[eax + SOCKET.Status], dword SOCK_EMPTY
-    jz	    sc_exit
+	jz	.error
+    ; Clear the socket varaibles
-    ; Clear the socket varaibles
+	stdcall net_socket_free, eax
-    xor     eax, eax
+;        mov     edi, eax
-    mov     edi, ebx
+;        xor     eax, eax
-    mov     ecx, SOCKETHEADERSIZE
+;        mov     ecx, SOCKETHEADERSIZE
-    cld
+;        cld
-    rep     stosb
+;        rep     stosb
+    xor     eax, eax
+	ret
+  .error:
+	DEBUGF	1, "K : socket_close (fail)\n"
-sc_exit:
+	or	eax, -1
     ret
 endp
 ;   Description
 ;       socket # in ebx
 ;       returns 0 for ok, -1 for socket not open (fail)
+;
 ;***************************************************************************
-socket_close_tcp:
+proc socket_close_tcp stdcall
+local sockAddr dd ?
+	DEBUGF	1, "K : socket_close_tcp (0x%x)\n", ebx
     ; first, remove any resend entries
     pusha
     mov     esi, resendQ
     mov     ecx, 0
-sct001:
+  .next_resendq:
+    cmp     ecx, NUMRESENDENTRIES
-    cmp     ecx, NUMRESENDENTRIES
+	je	.last_resendq	    ; None left
-    je	    sct003		; None left
+	;cmp     [esi], bl                               ; XTODO: bl -> ebx
-    cmp     [esi], bl
+	cmp	[esi + 4], ebx
-    je	    sct002		; found one
+	je	@f		    ; found one
     inc     ecx
+	add	esi, 8
+	jmp	.next_resendq
-    add     esi, 4
-    jmp     sct001
+    ;@@: mov     byte[esi], 0xff                         ; XTODO: 0xff -> 0
-sct002:
+    @@: mov	dword[esi + 4], 0
+	inc	ecx
-    mov     [esi], byte 0xFF
+	add	esi, 8
-    jmp     sct001
+	jmp	.next_resendq
+  .last_resendq:
+	popa
+	stdcall net_socket_num_to_addr, ebx
+	or	eax, eax
+	jz	.error
-sct003:
+	mov	ebx, eax
+	mov	[sockAddr], eax
-    popa
+	cmp	[ebx + SOCKET.Status], SOCK_EMPTY
+	je	.error
     Index2RealAddr ebx
-    mov     [sktAddr], ebx
+	cmp	[ebx + SOCKET.TCBState], TCB_LISTEN		;xxx
-    mov     eax, 0xFFFFFFFF	    ; assume this operation will fail..
+	je	.destroy_tcb					;xxx
-    cmp     [ebx + SOCKET.Status], dword SOCK_EMPTY
+	cmp	[ebx + SOCKET.TCBState], TCB_SYN_SENT		;xxx
-    jz	    sct_exit
+	je	.destroy_tcb					;xxx
     ; Now construct the response, and queue for sending by IP
     mov     eax, EMPTY_QUEUE
     call    dequeue
-    cmp     ax, NO_BUFFER
-    je	    stl_exit
+    cmp     ax, NO_BUFFER
-    push    eax
+	je	.error
     push    eax
-    mov     bl, 0x11	    ; FIN + ACK
-    mov     ecx, 0
-    mov     esi, 0
+;xxx    mov     bl, TH_FIN + TH_ACK
 	mov	bl, TH_FIN					;xxx
-    call    buildTCPPacket
+	xor	ecx, ecx
+	xor	esi, esi
-    mov     ebx, [sktAddr]
+	stdcall build_tcp_packet, [sockAddr]
-    ; increament SND.NXT in socket
+	mov	 ebx, [sockAddr]
-    mov     esi, 48
+    ; increament SND.NXT in socket
-    add     esi, ebx
+	lea	esi, [ebx + SOCKET.SND_NXT]
     call    inc_inet_esi
     ; Get the socket state
     mov     eax, [ebx + SOCKET.TCBState]
-    cmp     eax, TCB_LISTEN
+;xxx    cmp     eax, TCB_LISTEN
-    je	    destroyTCB
-    cmp     eax, TCB_SYN_SENT
+;xxx    je      .destroy_tcb
-    je	    destroyTCB
+;xxx    cmp     eax, TCB_SYN_SENT
-    cmp     eax, TCB_SYN_RECEIVED
+;xxx    je      .destroy_tcb
-    je	    sct_finwait1
-    cmp     eax, TCB_ESTABLISHED
+    cmp     eax, TCB_SYN_RECEIVED
-    je	    sct_finwait1
+	je	.fin_wait_1
-    ; assume CLOSE WAIT
+    cmp     eax, TCB_ESTABLISHED
-    ; Send a fin, then enter last-ack state
+	je	.fin_wait_1
-    mov     eax, TCB_LAST_ACK
-    mov     [ebx + SOCKET.TCBState], eax
+    ; assume CLOSE WAIT
-    xor     eax, eax
-    jmp     sct_send
+    ; Send a fin, then enter last-ack state
 	; TODO: check if it's really a TCB_CLOSE_WAIT
-sct_finwait1:
+	mov	[ebx + SOCKET.TCBState], TCB_LAST_ACK
-    ; Send a fin, then enter finwait2 state
+	jmp	.send
     mov     eax, TCB_FIN_WAIT_1
-    mov     [ebx + SOCKET.TCBState], eax
+  .fin_wait_1:
-    xor     eax, eax
+    ; Send a fin, then enter finwait2 state
+	mov	[ebx + SOCKET.TCBState], TCB_FIN_WAIT_1
-sct_send:
-    mov     eax, NET1OUT_QUEUE
-    mov     edx, [stack_ip]
-    mov     ecx, [sktAddr ]
-    mov     ecx, [ecx + 16]
-    cmp     edx, ecx
+  .send:
+    mov     eax, NET1OUT_QUEUE
+    mov     edx, [stack_ip]
-    jne     sct_notlocal
+	mov	ecx, [sockAddr]
+	cmp	edx, [ecx + SOCKET.RemoteIP]
-    mov     eax, IPIN_QUEUE
+	jne	.not_local
+    mov     eax, IPIN_QUEUE
+  .not_local:
+       ; Send it.
+    pop     ebx
     call    queue
-sct_notlocal:
+	jmp	.exit
        ; Send it.
 ;   Description
 ;       socket # in ebx
 ;       returns count in eax.
+;
 ;***************************************************************************
-socket_poll:
+proc socket_poll stdcall
-    Index2RealAddr ebx
+;        DEBUGF  1, "socket_poll(0x%x)\n", ebx
-    mov     eax, [ebx + SOCKET.rxDataCount]
+	stdcall net_socket_num_to_addr, ebx
+	or	eax, eax
+	jz	.error
 	mov	eax, [eax + SOCKET.rxDataCount]
+    ret
+  .error:
+	;or      eax, -1
+	xor	eax, eax
-    ret
+	ret
 endp
 ;   Description
 ;       socket # in ebx
 ;       returns TCB state in eax.
+;
 ;***************************************************************************
-socket_status:
+proc socket_status stdcall
+;;       DEBUGF  1, "socket_status(0x%x)\n", ebx
-    Index2RealAddr ebx
+	stdcall net_socket_num_to_addr, ebx
+	or	eax, eax
+	jz	.error
-    mov     eax, [ebx + SOCKET.TCBState]
+	mov	eax, [eax + SOCKET.TCBState]
+	ret
+  .error:
+	;or      eax, -1
 	xor	eax, eax
+    ret
+endp
+;    Index2RealAddr ebx
+;    mov     eax, [ebx + SOCKET.TCBState]
     ret
 ;    ret
 ;   Description
 ;       socket # in ebx
 ;       returns # of bytes remaining in eax, data in bl
+;
 ;***************************************************************************
-socket_read:
+proc socket_read stdcall
+;        DEBUGF  1, "socket_read(0x%x)\n", ebx
-    Index2RealAddr ebx
+	stdcall net_socket_num_to_addr, ebx
+	or	eax, eax
+	jz	.error
+	mov	ebx, eax
     mov     eax, [ebx + SOCKET.rxDataCount]	    ; get count of bytes
-    mov     ecx, 1
     test    eax, eax
-    jz	    sr2
+	jz	.error
     dec     eax
     mov     esi, ebx		; esi is address of socket
     mov     [ebx + SOCKET.rxDataCount], eax	    ; store new count
     add     esi, SOCKETHEADERSIZE
     mov     edi, esi
     inc     esi
+    mov     ecx, (SOCKETBUFFSIZE - SOCKETHEADERSIZE) / 4
+	lea	edi, [ebx + SOCKETHEADERSIZE]
-    mov     ecx, (SOCKETBUFFSIZE - SOCKETHEADERSIZE) / 4
+	lea	esi, [edi + 1]
     cld
-    rep     movsd
-    xor     ecx, ecx
-sr1:
-    jmp     sor_exit
+    rep     movsd
+	ret
-sr2:
+  .error:
-    xor     bl, bl
+	;or      eax, -1
+	xor	eax, eax
 	xor	ebx, ebx
-sor_exit:
+    ret
-    ret
+endp
 ;       datapointer # in ecx
 ;       buffer size in edx
 ;       returns # of bytes copied in eax
+;
 ;***************************************************************************
-socket_read_packet:
+proc socket_read_packet stdcall
+;        DEBUGF  1, "socket_read_packet(0x%x)\n", ebx
-    Index2RealAddr ebx					   ; get real socket address
+	stdcall net_socket_num_to_addr, ebx		   ; get real socket address
+	or	eax, eax
+	jz	.error
+	mov	ebx, eax
     mov     eax, [ebx + SOCKET.rxDataCount]		   ; get count of bytes
     test    eax, eax					   ; if count of bytes is zero..
     jz	    .exit					   ; exit function (eax will be zero)
     test    edx, edx					   ; if buffer size is zero, copy all data
-    jz	    .copyallbytes
+	jz	.copy_all_bytes
     cmp     edx, eax					   ; if buffer size is larger then the bytes of data, copy all data
-    jge     .copyallbytes
+	jge	.copy_all_bytes
     sub     eax, edx					   ; store new count (data bytes in buffer - bytes we're about to copy)
     mov     [ebx + SOCKET.rxDataCount], eax		   ;
     push    eax
     mov     eax, edx					   ; number of bytes we want to copy must be in eax
-    call    .startcopy					   ; copy to the application
+	call	.start_copy				   ; copy to the application
     mov     esi, ebx					   ; now we're going to copy the remaining bytes to the beginning
     rep     movsd					   ; copy all full dwords
     pop     ecx
     and     ecx, 3
     rep     movsb					   ; copy remaining bytes
   .exit:
+    ret 						   ; at last, exit
+  .error:
+	;or      eax, -1
+	xor	eax, eax
-    ret 						   ; at last, exit
+	ret
-.copyallbytes:
+  .copy_all_bytes:
+    xor     esi, esi
+    mov     [ebx + SOCKET.rxDataCount], esi		   ; store new count (zero)
-    xor     esi, esi
+	call	.start_copy
-    mov     [ebx + SOCKET.rxDataCount], esi		   ; store new count (zero)
+	ret
-.startcopy:
-    mov     edi, ecx					   ;
- ;   add     edi, std_application_base_address              ; get data pointer to buffer in application
+  .start_copy:
 	mov	edi, ecx
-    mov     esi, ebx					   ;
+	mov	esi, ebx
     add     esi, SOCKETHEADERSIZE			   ; we dont need to copy the header
     mov     ecx, eax					   ; eax is count of bytes
     push    ecx
     shr     ecx, 2					   ; divide eax by 4
     cld 						   ; copy all full dwords
-    rep     movsd					   ;
+	rep	movsd
-    pop     ecx
-    and     ecx, 3
-    rep     movsb					   ; copy the rest bytes
+    pop     ecx
-.exit:
+    and     ecx, 3
-    ret 						   ; exit, or go back to shift remaining bytes if any
+    rep     movsb					   ; copy the rest bytes
 	retn						   ; exit, or go back to shift remaining bytes if any
 endp
 ;       pointer to data in edx
 ;       returns 0 in eax ok, -1 == failed ( invalid socket, or
 ;       could not queue IP packet )
+;
 ;***************************************************************************
-socket_write:
+proc socket_write stdcall
+;        DEBUGF  1, "socket_write(0x%x)\n", ebx
+	stdcall net_socket_num_to_addr, ebx		   ; get real socket address
-    Index2RealAddr ebx
+	or	eax, eax
+	jz	.error
-    mov     eax, 0xFFFFFFFF
-    ; If the socket is invalid, return with an error code
-    cmp     [ebx], dword SOCK_EMPTY
+	mov	ebx, eax
+    ; If the socket is invalid, return with an error code
-    je	    sw_exit
+	cmp	[ebx + SOCKET.Status], SOCK_EMPTY
 	je	.error
     mov     eax, EMPTY_QUEUE
     call    dequeue
     cmp     ax, NO_BUFFER
-    je	    sw_exit
+	je	.error
     mov     edx, eax
     ; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
-    ; Fill in the IP header ( some data is in the socket descriptor)
+	; Fill in the IP header (some data is in the socket descriptor)
-    mov     eax, [ebx + 8]
+	mov	eax, [ebx + SOCKET.LocalIP]
-    mov     [edx + 12], eax	 ; source IP
+	mov	[edx + IP_PACKET.SourceAddress], eax
-    mov     eax, [ebx + 16]
+	mov	eax, [ebx + SOCKET.RemoteIP]
-    mov     [edx + 16], eax	 ; Destination IP
+	mov	[edx + IP_PACKET.DestinationAddress], eax
-    mov     al, 0x45
-    mov     [edx], al	      ; Version, IHL
-    xor     al, al
+	mov	[edx + IP_PACKET.VersionAndIHL], 0x45
-    mov     [edx + 1], al     ; Type of service
+	mov	[edx + IP_PACKET.TypeOfService], 0
-    pop     eax 		  ; Get the UDP data length
-    push    eax
+    pop     eax 		  ; Get the UDP data length
-    add     eax, 20 + 8 	  ; add IP header and UDP header lengths
-    mov     [edx + 2], ah
+    push    eax
-    mov     [edx + 3], al
-    xor     al, al
-    mov     [edx + 4], al
-    mov     [edx + 5], al
+    add     eax, 20 + 8 	  ; add IP header and UDP header lengths
-    mov     al, 0x40
+	xchg	al, ah
-    mov     [edx + 6], al
+	mov	[edx + IP_PACKET.TotalLength], ax
-    xor     al, al
-    mov     [edx + 7], al
+	xor	eax, eax
-    mov     al, 0x20
+	mov	[edx + IP_PACKET.Identification], ax
-    mov     [edx + 8], al
-    mov     al, 17
+	mov	[edx + IP_PACKET.FlagsAndFragmentOffset], 0x0040
-    mov     [edx + 9], al
+	mov	[edx + IP_PACKET.TimeToLive], 0x20
+	mov	[edx + IP_PACKET.Protocol], PROTOCOL_UDP
-    ; Checksum left unfilled
-    xor     ax, ax
+    ; Checksum left unfilled
-    mov     [edx + 10], ax
+	mov	[edx + IP_PACKET.HeaderChecksum], ax
-    ; Fill in the UDP header ( some data is in the socket descriptor)
+	; Fill in the UDP header (some data is in the socket descriptor)
-    mov     ax, [ebx + 12]
+	mov	ax, [ebx + SOCKET.LocalPort]
-    mov     [edx + 20], ax
+	mov	[edx + 20 + UDP_PACKET.SourcePort], ax
-    mov     ax, [ebx + 20]
+	mov	ax, [ebx + SOCKET.RemotePort]
-    mov     [edx + 20 + 2], ax
+	mov	[edx + 20 + UDP_PACKET.DestinationPort], ax
     pop     eax
     push    eax
     rep     movsb		; copy the data across
     ; we have edx as IPbuffer ptr.
     ; Fill in the UDP checksum
     ; First, fill in pseudoheader
-    mov     eax, [edx + 12]
+	mov	eax, [edx + IP_PACKET.SourceAddress]
     mov     [pseudoHeader], eax
-    mov     eax, [edx + 16]
+	mov	eax, [edx + IP_PACKET.DestinationAddress]
-    mov     [pseudoHeader+4], eax
+	mov	[pseudoHeader + 4], eax
-    mov     ax, 0x1100		  ; 0 + protocol
-    mov     [pseudoHeader+8], ax
+	mov	word[pseudoHeader + 8], PROTOCOL_UDP shl 8 + 0	    ; 0 + protocol
     add     ebx, 8
     mov     eax, ebx
-    mov     [pseudoHeader+10], ah
+	xchg	al, ah
-    mov     [pseudoHeader+11], al
+	mov	[pseudoHeader + 10], ax
     mov     eax, pseudoHeader
     mov     [checkAdd1], eax
     ; store it in the UDP checksum ( in the correct order! )
     mov     ax, [checkResult]
     ; If the UDP checksum computes to 0, we must make it 0xffff
     ; (0 is reserved for 'not used')
-    cmp     ax, 0
+	test	ax, ax
-    jne     sw_001
+	jnz	@f
-    mov     ax, 0xffff
+    mov     ax, 0xffff
-sw_001:
-    mov     [edx + 20 + 6], ah
+    @@: xchg	al, ah
-    mov     [edx + 20 + 7], al
+	mov	[edx + 20 + UDP_PACKET.Checksum], ax
-    ; Fill in the IP header checksum
-    GET_IHL ecx,edx		 ; get IP-Header length
+    ; Fill in the IP header checksum
-    stdcall checksum_jb,edx,ecx  ; buf_ptr, buf_size
+    GET_IHL ecx,edx		 ; get IP-Header length
     stdcall checksum_jb,edx,ecx  ; buf_ptr, buf_size
-    mov     [edx + 10], ah
+	xchg	al, ah
-    mov     [edx + 11], al
+	mov	[edx + IP_PACKET.HeaderChecksum], ax
-    ; Check destination IP address.
-    ; If it is the local host IP, route it back to IP_RX
+    ; Check destination IP address.
     ; If it is the local host IP, route it back to IP_RX
     pop     ebx
-    mov     eax, NET1OUT_QUEUE
+    pop     ebx
     mov     eax, NET1OUT_QUEUE
-    mov     ecx, [ edx + 16]
+	mov	ecx, [edx + SOCKET.RemoteIP]
     mov     edx, [stack_ip]
     cmp     edx, ecx
-    jne     sw_notlocal
+	jne	.not_local
-    mov     eax, IPIN_QUEUE
-sw_notlocal:
+    mov     eax, IPIN_QUEUE
+  .not_local:
+    ; Send it.
+    call    queue
     ; Send it.
-    call    queue
+    xor     eax, eax
 	ret
 ;       pointer to data in edx
 ;       returns 0 in eax ok, -1 == failed ( invalid socket, or
 ;       could not queue IP packet )
+;
 ;***************************************************************************
-socket_write_tcp:
+proc socket_write_tcp stdcall
-	Index2RealAddr ebx
+local sockAddr dd ?
+;        DEBUGF  1, "socket_write_tcp(0x%x)\n", ebx
+	stdcall net_socket_num_to_addr, ebx
+	or	eax, eax
+	jz	.error
+	mov	ebx, eax
-    mov     [sktAddr], ebx
 	mov	[sockAddr], ebx
-    mov     eax, 0xFFFFFFFF
     ; If the socket is invalid, return with an error code
-    cmp     [ebx], dword SOCK_EMPTY
+	cmp	[ebx + SOCKET.Status], SOCK_EMPTY
-    je	    swt_exit
+	je	.error
     ; If the sockets window timer is nonzero, do not queue packet
     ; TODO - done
-    cmp     [ebx + SOCKET.wndsizeTimer], dword 0
+	cmp	[ebx + SOCKET.wndsizeTimer], 0
-    jne     swt_exit
+	jne	.error
     mov     eax, EMPTY_QUEUE
-    call    dequeue
-    cmp     ax, NO_BUFFER
-    je	    swt_exit
+    call    dequeue
     cmp     ax, NO_BUFFER
-    push    eax
+	je	.error
-    mov     bl, 0x10	    ; ACK
+    push    eax
     ; Get the address of the callers data
     mov     edi, [TASK_BASE]
+    add     edi, TASKDATA.mem_start
-    add     edi, TASKDATA.mem_start
+    add     edx, [edi]
-    add     edx, [edi]
+    mov     esi, edx
     mov     esi, edx
     pop     eax
-    pop     eax
+    push    eax
     push    eax
     push    ecx
-    push    ecx
+	mov	bl, TH_ACK
-    call    buildTCPPacket
+	stdcall build_tcp_packet, [sockAddr]
     pop     ecx
-    ; Check destination IP address.
-    ; If it is the local host IP, route it back to IP_RX
+    ; Check destination IP address.
+    ; If it is the local host IP, route it back to IP_RX
     pop     ebx
-    push    ecx
+    pop     ebx
-    mov     eax, NET1OUT_QUEUE
+    push    ecx
+    mov     eax, NET1OUT_QUEUE
     mov     edx, [stack_ip]
-    mov     ecx, [sktAddr ]
+    mov     edx, [stack_ip]
-    mov     ecx, [ecx + 16]
+	mov	ecx, [sockAddr]
-    cmp     edx, ecx
+	cmp	edx, [ecx + SOCKET.RemoteIP]
-    jne     swt_notlocal
+	jne	.not_local
     mov     eax, IPIN_QUEUE
-swt_notlocal:
+  .not_local:
     pop     ecx
     push    ebx 		; save ipbuffer number
+    call    queue
-    call    queue
+	mov	esi, [sockAddr]
     mov     esi, [sktAddr]
+    ; increament SND.NXT in socket
-    ; increament SND.NXT in socket
+    ; Amount to increment by is in ecx
-    ; Amount to increment by is in ecx
-    add     esi, 48
+	add	esi, SOCKET.SND_NXT
     call    add_inet_esi
     pop     ebx
     ; Copy the IP buffer to a resend queue
     ; If there isn't one, dont worry about it for now
     mov     esi, resendQ
     mov     ecx, 0
-swt003:
-    cmp     ecx, NUMRESENDENTRIES
+  .next_resendq:
-    je	    swt001		; None found
+    cmp     ecx, NUMRESENDENTRIES
-    cmp     [esi], byte 0xFF
+	je	.exit		   ; None found
-    je	    swt002		; found one
+	;cmp     byte[esi], 0xff                                 ; XTODO: 0xff -> 0
-    inc     ecx
+	cmp	dword[esi + 4], 0
-    add     esi, 4
+	je	@f		   ; found one
-    jmp     swt003
+    inc     ecx
+	add	esi, 8
-swt002:
+	jmp	.next_resendq
     push    ebx
     @@: push	ebx
     ; OK, we have a buffer descriptor ptr in esi.
-    ; resend entry # in ecx
+    ; OK, we have a buffer descriptor ptr in esi.
     ; do copy
     mov     ecx, IPBUFFSIZE
     cld
     rep     movsb
-swt001:
+  .exit:
-    xor     eax, eax
-swt_exit:
+    xor     eax, eax
+	ret
+  .error:
+	or	eax, -1

Subversion Repositories Kolibri OS

(root)/kernel/branches/kolibri_pe/network/socket.inc – Rev 837 → 914