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