WebSVN – Kolibri OS – Diff – /kernel/trunk/network/socket.inc

 ;;   22.09.2003 - [Mike Hibbett] : mikeh@oceanfree.net          ;;
 ;;   11.11.2006 - [Johnny_B] and [smb]                          ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 738 $
+$Revision: 907 $
 ;   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 ; 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
-; so, define struct
+struc SOCKET
 struc SOCKET
-{  .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)
    .RCV_NXT		    dd	 ?  ;+56 - Next receive sequence number to use
    .RCV_WND		    dd	 ?  ;+60 - Receive window
    .SEG_LEN		    dd	 ?  ;+64 - Segment length
    .SEG_WND		    dd	 ?  ;+68 - Segment window
    .wndsizeTimer	    dd	 ?  ;+72 - Retransmit queue # NOW WINDOW SIZE TIMER
+   .PrevPtr		    dd	 ?
+   .NextPtr		    dd	 ?
    .rxData		    dd	 ?  ;+76 - receive data buffer here
+}
 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
-; TCP opening modes
+SOCKET_ACTIVE	   equ	   1
-SOCKET_PASSIVE	   equ	   0
-SOCKET_ACTIVE	   equ	   1
+proc net_socket_alloc stdcall uses ebx ecx edx edi
+	stdcall kernel_alloc, SOCKETBUFFSIZE
-;***************************************************************************
-;   Function
-;      is_localport_unused
-;
+	DEBUGF	1, "K : net_socket_alloc (0x%x)\n", eax
-;   Description
+	or	eax, eax
-;         scans through all the active sockets , looking to see if the
+	jz	.exit
-;      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
+	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
-is_localport_unused:
+	pop	ebx
+	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     al, bh
+	mov	[eax + SOCKET.PID], ebx
+  .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
-    mov     ah, bl
+	or	ebx, ebx
-    mov     bx, ax
+	jz	@f
-    mov     edx, SOCKETBUFFSIZE * NUM_SOCKETS
+	mov	[ebx + SOCKET.PrevPtr], eax
+    @@: stdcall kernel_free, [sock]
+	ret
+  .error:
+	DEBUGF	1, "K :   failed\n"
+	ret
-    mov     ecx, NUM_SOCKETS
+endp
+proc net_socket_num_to_addr stdcall uses ebx ecx, x:DWORD
+; FIXME: do real transform
+	mov	eax, [x]
+	mov	ebx, net_sockets
-    mov     eax, 0		      ; Assume the return value is 'in use'
+	mov	ecx, [TASK_BASE]
+	mov	ecx, [ecx + TASKDATA.pid]
+  .next_socket:
+	mov	ebx, [ebx + SOCKET.NextPtr]
+	or	ebx, ebx
-ilu1:
+	jz	.error
+	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
-    sub     edx, SOCKETBUFFSIZE
+	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
+	ret
+  .error:
+	xor	eax, eax
+	ret
-    inc     eax 			; return port not in use
+endp
-ilu_exit:
-    ret
+;***************************************************************************
-;***************************************************************************
-;   Function
-;      get_free_socket
-;
-;   Description
+;   Function
-;
-;***************************************************************************
+;      is_localport_unused
+;
+;   Description
+;         scans through all the active sockets , looking to see if the
+;      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
+;
+;***************************************************************************
+proc is_localport_unused stdcall
+	xchg	bl, bh
-get_free_socket:
-    push    ecx
+	xor	eax, eax			; Assume the return value is 'free'
+	inc	al
-    mov     eax, SOCKETBUFFSIZE * NUM_SOCKETS
+	mov	edx, net_sockets
     mov     ecx, NUM_SOCKETS
   .next_socket:
 ;       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
+	xchg	bh, bl
-    mov     [eax + SOCKET.LocalPort], bx
-    xchg    ch, cl
+	mov	[eax + SOCKET.LocalPort], bx
-    mov     [eax + SOCKET.RemotePort], cx
+	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.PID], ebx	    ; save the process ID
+	mov	[eax + SOCKET.RemoteIP], edx
+	;pop     eax      ; Get the socket number back, so we can return it
+	stdcall net_socket_addr_to_num
+	ret
-    pop     eax      ; Get the socket number back, so we can return it
+  .error:
 	DEBUGF	1, "K : socket_open (fail)\n"
-so_exit:
+	or	eax, -1
 ;       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
+	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
-    je	    sot_done
+	call	dequeue
+	cmp	ax, NO_BUFFER
-    push    eax
+	je	.exit
-    mov     bl, 0x02	    ; SYN
-    mov     ecx, 0
+	push	eax
-    call    buildTCPPacket
+	mov	bl, TH_SYN
 	xor	ecx, ecx
-    mov     eax, NET1OUT_QUEUE
+	stdcall build_tcp_packet, [sockAddr]
-    mov     edx, [stack_ip]
+	mov	eax, NET1OUT_QUEUE
-    mov     ecx, [sktAddr ]
+	mov	edx, [stack_ip]
-    mov     ecx, [ecx + 16]
+	mov	ecx, [sockAddr]
-    cmp     edx, ecx
+	cmp	edx, [ecx + SOCKET.RemoteIP]
+	jne	.not_local
+	mov	eax, IPIN_QUEUE
-    jne     sot_notlocal
-    mov     eax, IPIN_QUEUE
+  .not_local:
-sot_notlocal:
+	; Send it.
+	pop	ebx
+	call	queue
+	mov	esi, [sockAddr]
-       ; Send it.
+	; increment SND.NXT in socket
-    pop     ebx
+	add	esi, SOCKET.SND_NXT
-    call    queue
+	call	inc_inet_esi
 ;   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
+	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
+	; first, remove any resend entries
-    pusha
+	pusha
-    mov     esi, resendQ
+	mov	esi, resendQ
-    mov     ecx, 0
+	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
+	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
+	; Now construct the response, and queue for sending by IP
-    mov     eax, EMPTY_QUEUE
+	mov	eax, EMPTY_QUEUE
-    call    dequeue
+	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
-    call    buildTCPPacket
+	mov	bl, TH_FIN					;xxx
 	xor	ecx, ecx
-    mov     ebx, [sktAddr]
+	xor	esi, esi
+	stdcall build_tcp_packet, [sockAddr]
-    ; increament SND.NXT in socket
-    mov     esi, 48
+	mov	 ebx, [sockAddr]
-    add     esi, ebx
+	; increament SND.NXT in socket
-    call    inc_inet_esi
+	lea	esi, [ebx + SOCKET.SND_NXT]
 	call	inc_inet_esi
-    ; Get the socket state
+	; Get the socket state
-    mov     eax, [ebx + SOCKET.TCBState]
+	mov	eax, [ebx + SOCKET.TCBState]
-    cmp     eax, TCB_LISTEN
+;xxx    cmp     eax, TCB_LISTEN
-    je	    destroyTCB
+;xxx    je      .destroy_tcb
-    cmp     eax, TCB_SYN_SENT
-    je	    destroyTCB
+;xxx    cmp     eax, TCB_SYN_SENT
-    cmp     eax, TCB_SYN_RECEIVED
+;xxx    je      .destroy_tcb
-    je	    sct_finwait1
+	cmp	eax, TCB_SYN_RECEIVED
-    cmp     eax, TCB_ESTABLISHED
-    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
-    xor     eax, eax
+	; assume CLOSE WAIT
-    jmp     sct_send
+	; Send a fin, then enter last-ack state
-sct_finwait1:
+	; TODO: check if it's really a TCB_CLOSE_WAIT
-    ; Send a fin, then enter finwait2 state
+	mov	[ebx + SOCKET.TCBState], TCB_LAST_ACK
-    mov     eax, TCB_FIN_WAIT_1
+	jmp	.send
     mov     [ebx + SOCKET.TCBState], eax
-    xor     eax, eax
+  .fin_wait_1:
 	; Send a fin, then enter finwait2 state
-sct_send:
+	mov	[ebx + SOCKET.TCBState], TCB_FIN_WAIT_1
-    mov     eax, NET1OUT_QUEUE
+  .send:
-    mov     edx, [stack_ip]
-    mov     ecx, [sktAddr ]
-    mov     ecx, [ecx + 16]
-    cmp     edx, ecx
-    jne     sct_notlocal
-    mov     eax, IPIN_QUEUE
+	mov	eax, NET1OUT_QUEUE
+	mov	edx, [stack_ip]
+	mov	ecx, [sockAddr]
+	cmp	edx, [ecx + SOCKET.RemoteIP]
+	jne	.not_local
+	mov	eax, IPIN_QUEUE
 sct_notlocal:
+  .not_local:
+	; Send it.
+	pop	ebx
+	call	queue
+	jmp	.exit
        ; Send it.
-    pop     ebx
+  .destroy_tcb:
-    call    queue
+;xxx    pop     eax
 ;   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	eax, [ebx + SOCKET.rxDataCount] 	; get count of bytes
-    mov     ecx, 1
-    test    eax, eax
+	test	eax, eax
-    jz	    sr2
+	jz	.error
-    dec     eax
+	dec	eax
-    mov     esi, ebx		; esi is address of socket
+	mov	esi, ebx	    ; esi is address of socket
-    mov     [ebx + SOCKET.rxDataCount], eax	    ; store new count
+	mov	[ebx + SOCKET.rxDataCount], eax 	; store new count
-    add     esi, SOCKETHEADERSIZE
+	add	esi, SOCKETHEADERSIZE
-    mov     edi, esi
+	mov	edi, esi
-    inc     esi
+	inc	esi
+	mov	ecx, (SOCKETBUFFSIZE - SOCKETHEADERSIZE) / 4
+	lea	edi, [ebx + SOCKETHEADERSIZE]
-    mov     ecx, (SOCKETBUFFSIZE - SOCKETHEADERSIZE) / 4
+	lea	esi, [edi + 1]
-    cld
+	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
+	mov	eax, [ebx + SOCKET.rxDataCount] 	   ; get count of bytes
-    test    eax, eax					   ; if count of bytes is zero..
+	test	eax, eax				   ; if count of bytes is zero..
-    jz	    .exit					   ; exit function (eax will be zero)
+	jz	.exit					   ; exit function (eax will be zero)
-    test    edx, edx					   ; if buffer size is zero, copy all data
+	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
+	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)
+	sub	eax, edx				   ; store new count (data bytes in buffer - bytes we're about to copy)
-    mov     [ebx + SOCKET.rxDataCount], eax		   ;
+	mov	[ebx + SOCKET.rxDataCount], eax 	   ;
-    push    eax
+	push	eax
-    mov     eax, edx					   ; number of bytes we want to copy must be in 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
+	mov	esi, ebx				   ; now we're going to copy the remaining bytes to the beginning
-    rep     movsd					   ; copy all full dwords
+	rep	movsd					   ; copy all full dwords
-    pop     ecx
+	pop	ecx
-    and     ecx, 3
+	and	ecx, 3
-    rep     movsb					   ; copy remaining bytes
+	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
+	add	esi, SOCKETHEADERSIZE			   ; we dont need to copy the header
-    mov     ecx, eax					   ; eax is count of bytes
+	mov	ecx, eax				   ; eax is count of bytes
-    push    ecx
+	push	ecx
-    shr     ecx, 2					   ; divide eax by 4
+	shr	ecx, 2					   ; divide eax by 4
-    cld 						   ; copy all full dwords
+	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
+	mov	eax, EMPTY_QUEUE
-    call    dequeue
+	call	dequeue
-    cmp     ax, NO_BUFFER
+	cmp	ax, NO_BUFFER
-    je	    sw_exit
+	je	.error
-    mov     edx, eax
+	mov	edx, eax
-    ; So, ebx holds the socket ptr, edx holds the IPbuffer ptr
+	; 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
+	pop	eax
-    push    eax
+	push	eax
-    rep     movsb		; copy the data across
+	rep	movsb		    ; copy the data across
-    ; we have edx as IPbuffer ptr.
+	; we have edx as IPbuffer ptr.
-    ; Fill in the UDP checksum
+	; Fill in the UDP checksum
-    ; First, fill in pseudoheader
+	; First, fill in pseudoheader
-    mov     eax, [edx + 12]
+	mov	eax, [edx + IP_PACKET.SourceAddress]
-    mov     [pseudoHeader], eax
+	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
+	add	ebx, 8
-    mov     eax, ebx
+	mov	eax, ebx
-    mov     [pseudoHeader+10], ah
+	xchg	al, ah
-    mov     [pseudoHeader+11], al
+	mov	[pseudoHeader + 10], ax
-    mov     eax, pseudoHeader
+	mov	eax, pseudoHeader
-    mov     [checkAdd1], eax
+	mov	[checkAdd1], eax
-    ; store it in the UDP checksum ( in the correct order! )
+	; store it in the UDP checksum ( in the correct order! )
-    mov     ax, [checkResult]
+	mov	ax, [checkResult]
-    ; If the UDP checksum computes to 0, we must make it 0xffff
+	; If the UDP checksum computes to 0, we must make it 0xffff
-    ; (0 is reserved for 'not used')
+	; (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.
+	; Check destination IP address.
-    ; If it is the local host IP, route it back to IP_RX
+	; If it is the local host IP, route it back to IP_RX
-    pop     ebx
+	pop	ebx
     mov     eax, NET1OUT_QUEUE
+	mov	eax, NET1OUT_QUEUE
-    mov     ecx, [ edx + 16]
+	mov	ecx, [edx + SOCKET.RemoteIP]
-    mov     edx, [stack_ip]
+	mov	edx, [stack_ip]
-    cmp     edx, ecx
+	cmp	edx, ecx
-    jne     sw_notlocal
-    mov     eax, IPIN_QUEUE
 	jne	.not_local
+	mov	eax, IPIN_QUEUE
+  .not_local:
+	; Send it.
-sw_notlocal:
+	call	queue
     ; Send it.
-    call    queue
+	xor	eax, eax
 ;       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
+	; 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
+	; If the sockets window timer is nonzero, do not queue packet
-    ; TODO - done
+	; TODO - done
-    cmp     [ebx + SOCKET.wndsizeTimer], dword 0
+	cmp	[ebx + SOCKET.wndsizeTimer], 0
-    jne     swt_exit
+	jne	.error
-    mov     eax, EMPTY_QUEUE
+	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
+	; Get the address of the callers data
-    mov     edi, [TASK_BASE]
+	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
+	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
-    mov     eax, NET1OUT_QUEUE
+	pop	ebx
 	push	ecx
-    mov     edx, [stack_ip]
-    mov     ecx, [sktAddr ]
+	mov	eax, NET1OUT_QUEUE
-    mov     ecx, [ecx + 16]
+	mov	edx, [stack_ip]
-    cmp     edx, ecx
+	mov	ecx, [sockAddr]
-    jne     swt_notlocal
+	cmp	edx, [ecx + SOCKET.RemoteIP]
-    mov     eax, IPIN_QUEUE
+	jne	.not_local
 	mov	eax, IPIN_QUEUE
 swt_notlocal:
-    pop     ecx
+  .not_local:
 	pop	ecx
-    push    ebx 		; save ipbuffer number
+	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, SOCKET.SND_NXT
-    add     esi, 48
-    call    add_inet_esi
+	call	add_inet_esi
-    pop     ebx
+	pop	ebx
-    ; Copy the IP buffer to a resend queue
+	; Copy the IP buffer to a resend queue
-    ; If there isn't one, dont worry about it for now
+	; If there isn't one, dont worry about it for now
-    mov     esi, resendQ
+	mov	esi, resendQ
-    mov     ecx, 0
+	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.
-    ;  Populate it
+	; resend entry # in ecx
-    ; do copy
+	; do copy
-    mov     ecx, IPBUFFSIZE
+	mov	ecx, IPBUFFSIZE
-    cld
+	cld
-    rep     movsb
+	rep	movsb
-swt001:
+  .exit:
-    xor     eax, eax
-swt_exit:
+	xor	eax, eax
+	ret
+  .error:
+	or	eax, -1

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/socket.inc – Rev 738 → 907