Subversion Repositories Kolibri OS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; 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: 1369 $

;*******************************************************************

;   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

; 

; 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:

;

; 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:

;

; modified by [smb]

;

; ARPTable manager interface

    ;see "proc arp_table_manager" for more details

    stdcall arp_table_manager,ecx,edx,esi  ;Opcode,Index,Extra

    ret

;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;

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