kolibrios/kernel/branches/Kolibri-acpi/network/stack.inc

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  STACK.INC                                                   ;;
;;                                                              ;;
;;  TCP/IP stack for Menuet OS                                  ;;
;;                                                              ;;
;;  Copyright 2002 Mike Hibbett, mikeh@oceanfree.net            ;;
;;                                                              ;;
;;  See file COPYING for details                                ;;
;;                                                              ;;
;; Version 0.7                                                  ;;
;;      Added a timer per socket to allow delays when rx window ;;
;;      gets below 1KB                                          ;;
;;                                                              ;;
;;10.01.2007 Bugfix for checksum function from Paolo Franchetti ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision$


;*******************************************************************
;   Interface
;      The interfaces defined in ETHERNET.INC plus:
;      stack_init
;      stack_handler
;      app_stack_handler
;      app_socket_handler
;      checksum
;
;*******************************************************************

uglobal
StackCounters:
  dumped_rx_count     dd  0
  arp_tx_count:       dd  0
  arp_rx_count:       dd  0
  ip_rx_count:        dd  0
  ip_tx_count:        dd  0
endg

; socket buffers
SOCKETBUFFSIZE     equ        4096  ; state + config + buffer.
SOCKETHEADERSIZE   equ        SOCKET.rxData ; thus 4096 - SOCKETHEADERSIZE bytes data

;NUM_SOCKETS        equ        16    ; Number of open sockets supported. Was 20

; IPBUFF status values
BUFF_EMPTY         equ     0
BUFF_RX_FULL       equ     1
BUFF_ALLOCATED     equ     2
BUFF_TX_FULL       equ     3

NUM_IPBUFFERS      equ     20    ; buffers allocated for TX/RX

NUMQUEUES          equ        4

EMPTY_QUEUE        equ        0
IPIN_QUEUE         equ        1
IPOUT_QUEUE        equ        2
NET1OUT_QUEUE      equ        3

NO_BUFFER          equ        0xFFFF
IPBUFFSIZE         equ        1500                ; MTU of an ethernet packet
NUMQUEUEENTRIES    equ        NUM_IPBUFFERS
NUMRESENDENTRIES    equ         18              ; Buffers for TCP resend packets

; These are the 0x40 function codes for application access to the stack
STACK_DRIVER_STATUS  equ   52
SOCKET_INTERFACE     equ   53


; 128KB allocated for the stack and network driver buffers and other
; data requirements
;stack_data_start     equ   0x700000
;eth_data_start       equ   0x700000
;stack_data           equ   0x704000
;stack_data_end       equ   0x71ffff

; 32 bit word
stack_config         equ   stack_data

; 32 bit word - IP Address in network format
stack_ip             equ   stack_data + 4

; 1 byte. 0 == inactive, 1 = active
ethernet_active      equ   stack_data + 9


; TODO :: empty memory area

; Address of selected socket
;sktAddr              equ   stack_data + 32
; Parameter to checksum routine - data ptr
checkAdd1            equ   stack_data + 36
; Parameter to checksum routine - 2nd data ptr
checkAdd2            equ   stack_data + 40
; Parameter to checksum routine - data size
checkSize1           equ   stack_data + 44
; Parameter to checksum routine - 2nd data size
checkSize2           equ   stack_data + 46
; result of checksum routine
checkResult          equ   stack_data + 48

; holds the TCP/UDP pseudo header. SA|DA|0|prot|UDP len|
pseudoHeader         equ   stack_data + 50

; receive and transmit IP buffer allocation
;sockets              equ   stack_data + 62
Next_free2 equ stack_data + 62;Next_free2           equ   sockets + (SOCKETBUFFSIZE * NUM_SOCKETS)
; 1560 byte buffer for rx / tx ethernet packets
Ether_buffer         equ   Next_free2
Next_free3           equ   Ether_buffer + 1518
last_1sTick          equ   Next_free3
IPbuffs              equ   Next_free3 + 1
queues               equ   IPbuffs + ( NUM_IPBUFFERS * IPBUFFSIZE )
queueList            equ   queues + (2 * NUMQUEUES)
last_1hsTick         equ   queueList + ( 2 * NUMQUEUEENTRIES )

;resendQ              equ   queueList + ( 2 * NUMQUEUEENTRIES )
;resendBuffer         equ    resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP
;                    equ    resendBuffer + ( IPBUFFSIZE * NUMRESENDENTRIES )



;resendQ             equ     0x770000
;resendBuffer        equ     resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP        ; XTODO: validate size
resendBuffer        equ     resendQ + ( 8 * NUMRESENDENTRIES ) ; for TCP


uglobal
net_sockets rd 2
endg

; simple macro for memory set operation
macro _memset_dw adr,value,amount
{
        mov     edi, adr
        mov     ecx, amount
        if value = 0
                xor     eax, eax
        else
                mov     eax, value
        end if
        cld
        rep     stosd
}


; Below, the main network layer source code is included
;
include "queue.inc"
include "eth_drv/ethernet.inc"
include "ip.inc"
include "socket.inc"

;***************************************************************************
;   Function
;      stack_init
;
;   Description
;      Clear all allocated memory to zero. This ensures that
;       on startup, the stack is inactive, and consumes no resources
;       This is a kernel function, called prior to the OS main loop
;       in set_variables
;
;***************************************************************************

stack_init:
        ; Init two address spaces with default values
        _memset_dw      stack_data_start, 0, 0x20000/4
        _memset_dw      resendQ, 0, NUMRESENDENTRIES * 2

        mov     [net_sockets], 0
        mov     [net_sockets + 4], 0

        ; Queries initialization
        call    queueInit

        ; The following block sets up the 1s timer
        mov     al, 0x0
        out     0x70, al
        in      al, 0x71
        mov     [last_1sTick], al
ret



;***************************************************************************
;   Function
;      stack_handler
;
;   Description
;       The kernel loop routine for the stack
;       This is a kernel function, called in the main loop
;
;***************************************************************************
align 4
stack_handler:

    call    ethernet_driver
    call    ip_rx


    ; Test for 10ms tick, call tcp timer
    mov     eax, [timer_ticks] ;[0xfdf0]
    cmp     eax, [last_1hsTick]
    je      sh_001

    mov     [last_1hsTick], eax
    call    tcp_tx_handler

sh_001:

    ; Test for 1 second event, call 1s timer functions
    mov     al, 0x0   ;second
    out     0x70, al
    in      al, 0x71
    cmp     al, [last_1sTick]
    je      sh_exit

    mov     [last_1sTick], al

    stdcall arp_table_manager, ARP_TABLE_TIMER, 0, 0
    call    tcp_tcb_handler

sh_exit:
    ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Checksum [by Johnny_B]
;;  IN:
;;    buf_ptr=POINTER to buffer
;;    buf_size=SIZE of buffer
;;  OUT:
;;    AX=16-bit checksum
;;              Saves all used registers
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
proc checksum_jb stdcall uses ebx esi ecx,\
     buf_ptr:DWORD, buf_size:DWORD

    xor     eax, eax
    xor     ebx, ebx  ;accumulator
    mov     esi, dword[buf_ptr]
    mov     ecx, dword[buf_size]
    shr     ecx, 1  ; ecx=ecx/2
    jnc     @f      ; if CF==0 then size is even number
    mov     bh, byte[esi + ecx*2]
  @@:
    cld

  .loop:
    lodsw   ;eax=word[esi],esi=esi+2
    xchg    ah,al    ;cause must be a net byte-order
    add     ebx, eax
    loop    .loop

    mov     eax, ebx
    shr     eax, 16
    add     ax, bx
    not     ax

    ret
endp

;***************************************************************************
;   Function
;      checksum
;
;   Description
;       checkAdd1,checkAdd2, checkSize1, checkSize2, checkResult
;       Dont break anything; Most registers are used by the caller
;       This code is derived from the 'C' source, cksum.c, in the book
;       Internetworking with TCP/IP Volume II by D.E. Comer
;
;***************************************************************************


checksum:
    pusha
    mov     eax, [checkAdd1]
    xor     edx, edx                  ; edx is the accumulative checksum
    xor     ebx, ebx
    mov     cx, [checkSize1]
    shr     cx, 1
    jz      cs1_1

cs1:
    mov     bh, [eax]
    mov     bl, [eax + 1]

    add     eax, 2
    add     edx, ebx

    loopw   cs1

cs1_1:
    and     word [checkSize1], 0x01
    jz      cs_test2

    mov     bh, [eax]
    xor     bl, bl

    add     edx, ebx

cs_test2:
    mov     cx, [checkSize2]
    cmp     cx, 0
    jz      cs_exit                     ; Finished if no 2nd buffer

    mov     eax, [checkAdd2]

    shr     cx, 1
    jz      cs2_1

cs2:
    mov     bh, [eax]
    mov     bl, [eax + 1]

    add     eax, 2
    add     edx, ebx

    loopw   cs2

cs2_1:
    and     word [checkSize2], 0x01
    jz      cs_exit

    mov     bh, [eax]
    xor     bl, bl

    add     edx, ebx

cs_exit:
    mov     ebx, edx

    shr     ebx, 16
    and     edx, 0xffff
    add     edx, ebx
    mov     eax, edx
    shr     eax, 16
    add     edx, eax
    not     dx

    mov     [checkResult], dx
    popa
    ret




;***************************************************************************
;   Function
;      app_stack_handler
;
;   Description
;       This is an application service, called by int 0x40, function 52
;       It provides application access to the network interface layer
;
;***************************************************************************
iglobal
align 4
f52call:
	dd	app_stack_handler.00
	dd	app_stack_handler.01
	dd	app_stack_handler.02
	dd	app_stack_handler.03
	dd	app_stack_handler.fail	;04
	dd	app_stack_handler.fail	;05
	dd	stack_insert_packet	;app_stack_handler.06
	dd	app_stack_handler.fail	;07
	dd	stack_get_packet	;app_stack_handler.08
	dd	app_stack_handler.09
	dd	app_stack_handler.10
	dd	app_stack_handler.11
	dd	app_stack_handler.12
	dd	app_stack_handler.13
	dd	app_stack_handler.14
	dd	app_stack_handler.15
endg
app_stack_handler:
;in ebx,ecx
;out eax
	cmp	ebx,15
	ja	.fail			;if more than 15 then exit

	jmp	dword [f52call+ebx*4]


.00:
; Read the configuration word
	mov	eax, [stack_config]
	ret

.01:
; read the IP address
	mov     eax, [stack_ip]
	ret

.02:
; write the configuration word
	mov     [stack_config], ecx

; <Slip shouldn't be active anyway - thats an operational issue.>
; If ethernet now enabled, probe for the card, reset it and empty
; the packet buffer
; If all successfull, enable the card.
; If ethernet now disabled, set it as disabled. Should really
; empty the tcpip data area too.

; ethernet interface is '3' in ls 7 bits
	and     cl, 0x7f
	cmp     cl, 3
	je      ash_eth_enable
; Ethernet isn't enabled, so make sure that the card is disabled
	mov     [ethernet_active], byte 0
	ret

.03:
; write the IP Address
	mov     [stack_ip], ecx
	ret
;old functions was deleted
;.06:
; Insert an IP packet into the stacks received packet queue
;	call    stack_insert_packet
;	ret

; Test for any packets queued for transmission over the network

;.08:
;	call    stack_get_packet
; Extract a packet queued for transmission by the network
;	ret

.09:
; read the gateway IP address
	mov     eax, [gateway_ip]
	ret

.10:
; read the subnet mask
	mov     eax, [subnet_mask]
	ret
.11:
; write the gateway IP Address
	mov     [gateway_ip], ecx
	ret

.12:
; write the subnet mask
	mov     [subnet_mask], ecx
	ret

.13:
; read the dns
	mov     eax, [dns_ip]
	ret

.14:
; write the dns IP Address
	mov     [dns_ip], ecx
	ret

.15:
;<added by Frank Sommer>
; in ecx we need 4 to read the last 2 bytes
; or we need 0 to read the first 4 bytes
	cmp     ecx,4
        ja	.param_error

; read MAC, returned (in mirrored byte order) in eax
        mov     eax, [node_addr + ecx]
        ret

.param_error:
        or     	eax, -1		; params not accepted
        ret

.16:
; 0 -> arp_probe
; 1 -> arp_announce
; 2 -> arp_responce (not supported yet)
        test    ecx,ecx
        je      a_probe

        dec     ebx
        jz      a_ann                   ; arp announce
.fail:
        or	eax, -1
        ret

;       cmp     ebx,2
;       jne     a_resp                  ; arp response

; arp probe, sender IP must be set to 0.0.0.0, target IP is set to address being probed
; ecx: pointer to target MAC, MAC should set to 0 by application
; edx: target IP
a_probe:
        push    dword [stack_ip]

        mov     edx, [stack_ip]
        and     [stack_ip], dword 0
        mov     esi, ecx                ; pointer to target MAC address
        call    arp_request

        pop     dword [stack_ip]
        ret

; arp announce, sender IP must be set to target IP
; ecx: pointer to target MAC
a_ann:
        mov     edx, [stack_ip]
        mov     esi, ecx                ; pointer to target MAC address
        call    arp_request
        ret

.17:
;</added by Frank Sommer>
; modified by [smb]

;<added by Johnny_B>
; ARPTable manager interface
    ;see "proc arp_table_manager" for more details
    stdcall arp_table_manager,ecx,edx,esi  ;Opcode,Index,Extra
    ret
;</added by Johnny_B>

;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ash_eth_enable:
; Probe for the card. This will reset it and enable the interface
; if found
	call	eth_probe
	test	eax,eax
	jz	ash_eth_done            ; Abort if no hardware found

	mov     [ethernet_active], byte 1
ash_eth_done:
	ret
;***************************************************************************
;   Function
;      app_socket_handler
;
;   Description
;       This is an application service, called by int 0x40, function 53
;       It provides application access to stack socket services
;       such as opening sockets
;
;***************************************************************************
iglobal
align 4
f53call:
	dd	socket_open			;00
	dd	socket_close			;01
	dd	socket_poll			;02
	dd	socket_read			;03
	dd	socket_write			;04
	dd	socket_open_tcp			;05
	dd	socket_status			;06
	dd	socket_write_tcp		;07
	dd	socket_close_tcp		;08
	dd	is_localport_unused		;09
	dd	app_socket_handler.10
	dd	socket_read_packet		;11
endg

app_socket_handler:
;in ebx,ecx,edx,wsi
;out eax
	cmp	eax,255
	je	stack_internal_status

	cmp	eax,11
	ja	.fail			;if more than 15 then exit

	jmp	dword [f53call+eax*4]

.10:
	mov     eax,dword[drvr_cable]
	test    eax,eax
	jnz     @f                	; if function is not implented, return -1
	or      al,-1
	ret
@@:
	jmp    dword[drvr_cable]

.fail:
	or	eax,-1
	ret
uglobal
  ARPTmp:
  times 14 db 0
endg

;***************************************************************************
;   Function
;      stack_internal_status
;
;   Description
;       Returns information about the internal status of the stack
;       This is only useful for debugging
;       It works with the ethernet driver
;       sub function in ebx
;       return requested data in eax
;
;***************************************************************************
; This sub function allows access to debugging information on the stack
; ecx holds the request:
; 100 : return length of empty queue
; 101 : return length of IPOUT QUEUE
; 102 : return length of IPIN QUEUE
; 103 : return length of NET1OUT QUEUE
; 200 : return # of ARP entries
; 201 : return size of ARP table ( max # entries )
; 202 : select ARP table entry #
; 203 : return IP of selected table entry
; 204 : return High 4 bytes of MAC address of selected table entry
; 205 : return low  2 bytes of MAC address of selected table entry
; 206 : return status word of selected table entry
; 207 : return Time to live of selected table entry


;  2 : return number of IP packets received
;  3 : return number of packets transmitted
;  4 : return number of received packets dumped
;  5 : return number of arp packets received
;  6 : return status of packet driver
;  ( 0 == not active, FFFFFFFF = successful )


stack_internal_status:
    cmp     ebx, 100
    jnz     notsis100

    ;  100 : return length of EMPTY QUEUE
    mov     ebx, EMPTY_QUEUE
    call    queueSize
    ret

notsis100:
    cmp     ebx, 101
    jnz     notsis101

    ;  101 : return length of IPOUT QUEUE
    mov     ebx, IPOUT_QUEUE
    call    queueSize                       
    ret

notsis101:
    cmp     ebx, 102
    jnz     notsis102

    ;  102 : return length of IPIN QUEUE
    mov     ebx, IPIN_QUEUE
    call    queueSize
    ret

notsis102:
    cmp     ebx, 103
    jnz     notsis103

    ;  103 : return length of NET1OUT QUEUE
    mov     ebx, NET1OUT_QUEUE
    call    queueSize
    ret

notsis103:
    cmp     ebx, 200
    jnz     notsis200

    ; 200 : return num entries in arp table
    movzx   eax, byte [NumARP]
    ret

notsis200:
    cmp     ebx, 201
    jnz     notsis201

    ; 201 : return arp table size
    mov     eax, 20 ; ARP_TABLE_SIZE
    ret

notsis201:
    cmp     ebx, 202
    jnz     notsis202

    ; 202 - read the requested table entry
    ; into a temporary buffer
    ; ecx holds the entry number

    mov     eax, ecx
    mov     ecx, 14 ; ARP_ENTRY_SIZE
    mul     ecx

    mov     ecx, [eax + ARPTable]
    mov     [ARPTmp], ecx
    mov     ecx, [eax + ARPTable+4]
    mov     [ARPTmp+4], ecx
    mov     ecx, [eax + ARPTable+8]
    mov     [ARPTmp+8], ecx
    mov     cx, [eax + ARPTable+12]
    mov     [ARPTmp+12], cx
    ret

notsis202:
    cmp     ebx, 203
    jnz     notsis203

    ; 203 - return IP address
    mov     eax, [ARPTmp]
    ret

notsis203:
    cmp     ebx, 204
    jnz     notsis204

    ; 204 - return MAC high dword
    mov     eax, [ARPTmp+4]
    ret

notsis204:
    cmp     ebx, 205
    jnz     notsis205

    ; 205 - return MAC ls word
    movzx   eax, word [ARPTmp+8]
    ret

notsis205:
    cmp     ebx, 206
    jnz     notsis206

    ; 206 - return status word
    movzx   eax, word [ARPTmp+10]
    ret

notsis206:
    cmp     ebx, 207
    jnz     notsis207

    ; 207 - return ttl word
    movzx   eax, word [ARPTmp+12]
    ret

notsis207:
    cmp     ebx, 2
    jnz     notsis2

    ;  2 : return number of IP packets received
    mov     eax, [ip_rx_count]
    ret

notsis2:
    cmp     ebx, 3
    jnz     notsis3

    ;  3 : return number of packets transmitted
    mov     eax, [ip_tx_count]
    ret

notsis3:
    cmp     ebx, 4
    jnz     notsis4

    ;  4 : return number of received packets dumped
    mov     eax, [dumped_rx_count]
    ret

notsis4:
    cmp     ebx, 5
    jnz     notsis5

    ;  5 : return number of arp packets received
    mov     eax, [arp_rx_count]
    ret

notsis5:
    cmp     ebx, 6
    jnz     notsis6

    ;  6 : return status of packet driver
    ;  ( 0 == not active, FFFFFFFF = successful )
    mov     eax, [eth_status]
    ret

notsis6:
    xor     eax, eax
    ret



;***************************************************************************
;   Function
;      stack_get_packet
;
;   Description
;       extracts an IP packet from the NET1 output queue
;       and sends the data to the calling process
;       pointer to data in edx
;       returns number of bytes read in eax
;
;***************************************************************************
stack_get_packet:
    ; Look for a buffer to tx
    mov     eax, NET1OUT_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      sgp_non_exit            ; Exit if no buffer available

    push    eax                     ; Save buffer number for freeing at end

    push    edx
    ; convert buffer pointer eax to the absolute address
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs
    pop     edx

    push    eax                     ; save address of IP data
    ; Get the address of the callers data
    mov     edi,[TASK_BASE]
    add     edi,TASKDATA.mem_start
    add     edx,[edi]
    mov     edi, edx
    pop     eax

    mov     ecx, 1500           ; should get the actual number of bytes to write
    mov     esi, eax
    cld
    rep     movsb               ; copy the data across

    ; And finally, return the buffer to the free queue
    pop     eax
    call    freeBuff

    mov     eax, 1500
    ret

sgp_non_exit:
    xor     eax, eax
    ret



;***************************************************************************
;   Function
;      stack_insert_packet
;
;   Description
;       writes an IP packet into the stacks receive queue
;       # of bytes to write in ecx
;       pointer to data in edx
;       returns 0 in eax ok, -1 == failed
;
;***************************************************************************
stack_insert_packet:

    mov     eax, EMPTY_QUEUE
    call    dequeue
    cmp     ax, NO_BUFFER
    je      sip_err_exit

    push    eax

    ; save the pointers to the data buffer & size
    push    edx
    push    ecx

    ; convert buffer pointer eax to the absolute address
    mov     ecx, IPBUFFSIZE
    mul     ecx
    add     eax, IPbuffs

    mov     edx, eax

    ; So, edx holds the IPbuffer ptr

    pop     ecx                     ; count of bytes to send
    mov     ebx, ecx                ; need the length later
    pop     eax                     ; get callers ptr to data to send

    ; Get the address of the callers data
    mov     edi,[TASK_BASE]
    add     edi,TASKDATA.mem_start
    add     eax,[edi]
    mov     esi, eax

    mov     edi, edx
    cld
    rep     movsb               ; copy the data across

    pop     ebx

    mov     eax, IPIN_QUEUE
    call    queue

    inc     dword [ip_rx_count]

    mov     eax, 0
    ret

sip_err_exit:
    mov     eax, 0xFFFFFFFF
    ret