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


$Revision: 431 $
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;  STACK.INC                                                   ;;
;;                                                              ;;
;;  TCP/IP stack for Menuet OS                                  ;;
;;                                                              ;;
;;  Version 0.7  4th July 2004                                  ;;
;;                                                              ;;
;;  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 ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
;*******************************************************************
;   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	      76    ; 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   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
 
 
; 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 "icmp.inc"
include "tcp.inc"
include "udp.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, 0xFFFFFFFF, NUMRESENDENTRIES
 
	; 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
;
;***************************************************************************
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
;
;***************************************************************************
app_stack_handler:
    cmp     eax, 0
    jnz     not0
    ; Read the configuration word
    mov     eax, [stack_config]
    ret
 
not0:
    cmp     eax, 1
    jnz     not1
    ; read the IP address
 
    mov     eax, [stack_ip]
    ret
 
not1:
    cmp     eax, 2
    jnz     not2
 
    ; write the configuration word
    mov     [stack_config], ebx
 
    ; 
    ; 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     bl, 0x7f
    cmp     bl, 3
 
    je	     ash_eth_enable
    ; Ethernet isn't enabled, so make sure that the card is disabled
    mov     [ethernet_active], byte 0
 
    ret
 
ash_eth_enable:
    ; Probe for the card. This will reset it and enable the interface
    ; if found
    call    eth_probe
    cmp     eax, 0
    je	    ash_eth_done	    ; Abort if no hardware found
 
    mov     [ethernet_active], byte 1
 
ash_eth_done:
    ret
 
not2:
    cmp     eax, 3
    jnz     not3
    ; write the IP Address
    mov     [stack_ip], ebx
    ret
 
;old functions was deleted
 
not3:
    cmp     eax, 6
    jnz     not6
 
    ; Insert an IP packet into the stacks received packet queue
    call    stack_insert_packet
    ret
 
not6:
    cmp     eax, 7
    jnz     not7
 
    ; Test for any packets queued for transmission over the network
 
not7:
    cmp     eax, 8
    jnz     not8
 
    call    stack_get_packet
    ; Extract a packet queued for transmission by the network
    ret
 
not8:
    cmp     eax, 9
    jnz     not9
 
    ; read the gateway IP address
 
    mov     eax, [gateway_ip]
    ret
 
not9:
    cmp     eax, 10
    jnz     not10
 
    ; read the subnet mask
 
    mov     eax, [subnet_mask]
    ret
 
not10:
    cmp     eax, 11
    jnz     not11
 
    ; write the gateway IP Address
    mov     [gateway_ip], ebx
 
    ret
 
not11:
    cmp     eax, 12
    jnz     not12
 
    ; write the subnet mask
    mov     [subnet_mask], ebx
 
 
not12:
    cmp     eax, 13
    jnz     not13
 
    ; read the dns
 
    mov     eax, [dns_ip]
    ret
 
not13:
    cmp     eax, 14
    jnz     not14
 
    ; write the dns IP Address
    mov     [dns_ip], ebx
 
    ret
 
;
not14:
	cmp	eax, 15
	jnz	not15
 
    ; in ebx we need 4 to read the last 2 bytes
	cmp	ebx, dword 4
	je	read
 
    ; or we need 0 to read the first 4 bytes
	cmp	ebx, dword 0
	jnz	param_error
 
    ; read MAC, returned (in mirrored byte order) in eax
read:
	mov	eax, [node_addr + ebx]
	jmp	@f
 
param_error:
	mov	eax, -1     ; params not accepted
@@:
	ret
 
 
; 0 -> arp_probe
; 1 -> arp_announce
; 2 -> arp_responce (not supported yet)
 
not15:					; ARP stuff
	cmp	eax, 16
	jnz	not16
 
	cmp	ebx, 0
	je	a_probe
 
	cmp	ebx, 1
	je	a_ann			; arp announce
 
;       cmp     ebx,2
;       jne     a_resp                  ; arp response
 
	jmp	param15_error
 
 
; 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]
	mov	[stack_ip], dword 0
	mov	esi, ecx		; pointer to target MAC address
	call	arp_request
 
	pop	dword [stack_ip]
	jmp	@f
 
; 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
	jmp	@f
 
param15_error:
	mov	eax, -1
 
@@:
	ret
;
; modified by [smb]
 
;
; ARPTable manager interface
not16:
    cmp     eax, 17
    jnz     stack_driver_end
 
    ;see "proc arp_table_manager" for more details
    stdcall arp_table_manager,ebx,ecx,edx  ;Opcode,Index,Extra
 
    ret
;
 
stack_driver_end:
	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
;
;***************************************************************************
app_socket_handler:
    cmp     eax, 0
    jnz     nots0
 
    call    socket_open
    ret
 
nots0:
    cmp     eax, 1
    jnz     nots1
 
    call    socket_close
    ret
 
nots1:
    cmp     eax, 2
    jnz     nots2
 
    call    socket_poll
    ret
 
nots2:
    cmp     eax, 3
    jnz     nots3
 
    call    socket_read
    ret
 
nots3:
    cmp     eax, 4
    jnz     nots4
 
    call    socket_write
    ret
 
nots4:
    cmp     eax, 5
    jnz     nots5
 
    call    socket_open_tcp
    ret
 
nots5:
    cmp     eax, 6
    jnz     nots6
 
    call    socket_status
    ret
 
nots6:
    cmp     eax, 7
    jnz     nots7
 
    call    socket_write_tcp
    ret
 
nots7:
    cmp     eax, 8
    jnz     nots8
 
    call    socket_close_tcp
    ret
 
nots8:
    cmp     eax, 9
    jnz     nots9
 
    call    is_localport_unused
    ret
 
nots9:
    cmp     eax, 10
    jnz     nots10
 
    mov     eax,dword[drvr_cable]
    test    eax,eax
    jnz     @f		      ; if function is not implented, return -1
    mov     al,-1
    ret
 
   @@:
    call    dword[drvr_cable]
    ret
 
 
nots10:
    cmp     eax, 11
    jnz     nots11
 
    call    socket_read_packet
    ret
 
nots11:
    cmp     eax, 254
    jnz     notdump
 
    ret
 
notdump:
    cmp     eax, 255
    jnz     notsdebug
 
    ; This sub function allows access to debugging information on the stack
    ; ebx 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 )
 
    call    stack_internal_status
    ret
 
notsdebug:
    ; Invalid Option
    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
;
;***************************************************************************
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

Rev 425	Rev 431
1	$Revision: 425 $	1	$Revision: 431 $
2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	2	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		3	;; ;;
-		4	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
-		5	;; Distributed under terms of the GNU General Public License ;;
3	;; ;;	6	;; ;;
4	;; STACK.INC ;;	7	;; STACK.INC ;;
5	;; ;;	8	;; ;;
6	;; TCP/IP stack for Menuet OS ;;	9	;; TCP/IP stack for Menuet OS ;;
7	;; ;;	10	;; ;;
8	;; Version 0.7 4th July 2004 ;;	11	;; Version 0.7 4th July 2004 ;;
9	;; ;;	12	;; ;;
10	;; Copyright 2002 Mike Hibbett, mikeh@oceanfree.net ;;	13	;; Copyright 2002 Mike Hibbett, mikeh@oceanfree.net ;;
11	;; ;;	14	;; ;;
12	;; See file COPYING for details ;;	15	;; See file COPYING for details ;;
13	;; ;;	16	;; ;;
14	;; Version 0.7 ;;	17	;; Version 0.7 ;;
15	;; Added a timer per socket to allow delays when rx window ;;	18	;; Added a timer per socket to allow delays when rx window ;;
16	;; gets below 1KB ;;	19	;; gets below 1KB ;;
17	;; ;;	20	;; ;;
18	;; 10.01.2007 Bugfix for checksum function from Paolo Franchetti ;;	21	;;10.01.2007 Bugfix for checksum function from Paolo Franchetti ;;
19	;; ;;	22	;; ;;
20	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	23	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
21		24
22		25
23		26
24	;*******************************************************************	27	;*******************************************************************
25	; Interface	28	; Interface
26	; The interfaces defined in ETHERNET.INC plus:	29	; The interfaces defined in ETHERNET.INC plus:
27	; stack_init	30	; stack_init
28	; stack_handler	31	; stack_handler
29	; app_stack_handler	32	; app_stack_handler
30	; app_socket_handler	33	; app_socket_handler
31	; checksum	34	; checksum
32	;	35	;
33	;*******************************************************************	36	;*******************************************************************
34		37
35	uglobal	38	uglobal
36	StackCounters:	39	StackCounters:
37	dumped_rx_count: dd 0	40	dumped_rx_count: dd 0
38	arp_tx_count: dd 0	41	arp_tx_count: dd 0
39	arp_rx_count: dd 0	42	arp_rx_count: dd 0
40	ip_rx_count: dd 0	43	ip_rx_count: dd 0
41	ip_tx_count: dd 0	44	ip_tx_count: dd 0
42	endg	45	endg
43		46
44	; socket buffers	47	; socket buffers
45	SOCKETBUFFSIZE equ 4096 ; state + config + buffer.	48	SOCKETBUFFSIZE equ 4096 ; state + config + buffer.
46	SOCKETHEADERSIZE equ 76 ; thus 4096 - SOCKETHEADERSIZE bytes data	49	SOCKETHEADERSIZE equ 76 ; thus 4096 - SOCKETHEADERSIZE bytes data
47		50
48	NUM_SOCKETS equ 16 ; Number of open sockets supported. Was 20	51	NUM_SOCKETS equ 16 ; Number of open sockets supported. Was 20
49		52
50	; IPBUFF status values	53	; IPBUFF status values
51	BUFF_EMPTY equ 0	54	BUFF_EMPTY equ 0
52	BUFF_RX_FULL equ 1	55	BUFF_RX_FULL equ 1
53	BUFF_ALLOCATED equ 2	56	BUFF_ALLOCATED equ 2
54	BUFF_TX_FULL equ 3	57	BUFF_TX_FULL equ 3
55		58
56	NUM_IPBUFFERS equ 20 ; buffers allocated for TX/RX	59	NUM_IPBUFFERS equ 20 ; buffers allocated for TX/RX
57		60
58	NUMQUEUES equ 4	61	NUMQUEUES equ 4
59	EMPTY_QUEUE equ 0	62	EMPTY_QUEUE equ 0
60	IPIN_QUEUE equ 1	63	IPIN_QUEUE equ 1
61	IPOUT_QUEUE equ 2	64	IPOUT_QUEUE equ 2
62	NET1OUT_QUEUE equ 3	65	NET1OUT_QUEUE equ 3
63		66
64	NO_BUFFER equ 0xFFFF	67	NO_BUFFER equ 0xFFFF
65	IPBUFFSIZE equ 1500 ; MTU of an ethernet packet	68	IPBUFFSIZE equ 1500 ; MTU of an ethernet packet
66	NUMQUEUEENTRIES equ NUM_IPBUFFERS	69	NUMQUEUEENTRIES equ NUM_IPBUFFERS
67	NUMRESENDENTRIES equ 18 ; Buffers for TCP resend packets	70	NUMRESENDENTRIES equ 18 ; Buffers for TCP resend packets
68		71
69	; These are the 0x40 function codes for application access to the stack	72	; These are the 0x40 function codes for application access to the stack
70	STACK_DRIVER_STATUS equ 52	73	STACK_DRIVER_STATUS equ 52
71	SOCKET_INTERFACE equ 53	74	SOCKET_INTERFACE equ 53
72		75
73		76
74	; 128KB allocated for the stack and network driver buffers and other	77	; 128KB allocated for the stack and network driver buffers and other
75	; data requirements	78	; data requirements
76	;stack_data_start equ 0x700000	79	;stack_data_start equ 0x700000
77	;eth_data_start equ 0x700000	80	;eth_data_start equ 0x700000
78	;stack_data equ 0x704000	81	;stack_data equ 0x704000
79	;stack_data_end equ 0x71ffff	82	;stack_data_end equ 0x71ffff
80		83
81	; 32 bit word	84	; 32 bit word
82	stack_config equ stack_data	85	stack_config equ stack_data
83		86
84	; 32 bit word - IP Address in network format	87	; 32 bit word - IP Address in network format
85	stack_ip equ stack_data + 4	88	stack_ip equ stack_data + 4
86		89
87	; 1 byte. 0 == inactive, 1 = active	90	; 1 byte. 0 == inactive, 1 = active
88	ethernet_active equ stack_data + 9	91	ethernet_active equ stack_data + 9
89		92
90		93
91	; TODO :: empty memory area	94	; TODO :: empty memory area
92		95
93	; Address of selected socket	96	; Address of selected socket
94	sktAddr equ stack_data + 32	97	sktAddr equ stack_data + 32
95	; Parameter to checksum routine - data ptr	98	; Parameter to checksum routine - data ptr
96	checkAdd1 equ stack_data + 36	99	checkAdd1 equ stack_data + 36
97	; Parameter to checksum routine - 2nd data ptr	100	; Parameter to checksum routine - 2nd data ptr
98	checkAdd2 equ stack_data + 40	101	checkAdd2 equ stack_data + 40
99	; Parameter to checksum routine - data size	102	; Parameter to checksum routine - data size
100	checkSize1 equ stack_data + 44	103	checkSize1 equ stack_data + 44
101	; Parameter to checksum routine - 2nd data size	104	; Parameter to checksum routine - 2nd data size
102	checkSize2 equ stack_data + 46	105	checkSize2 equ stack_data + 46
103	; result of checksum routine	106	; result of checksum routine
104	checkResult equ stack_data + 48	107	checkResult equ stack_data + 48
105		108
106	; holds the TCP/UDP pseudo header. SA\|DA\|0\|prot\|UDP len\|	109	; holds the TCP/UDP pseudo header. SA\|DA\|0\|prot\|UDP len\|
107	pseudoHeader equ stack_data + 50	110	pseudoHeader equ stack_data + 50
108		111
109	; receive and transmit IP buffer allocation	112	; receive and transmit IP buffer allocation
110	sockets equ stack_data + 62	113	sockets equ stack_data + 62
111	Next_free2 equ sockets + (SOCKETBUFFSIZE * NUM_SOCKETS)	114	Next_free2 equ sockets + (SOCKETBUFFSIZE * NUM_SOCKETS)
112	; 1560 byte buffer for rx / tx ethernet packets	115	; 1560 byte buffer for rx / tx ethernet packets
113	Ether_buffer equ Next_free2	116	Ether_buffer equ Next_free2
114	Next_free3 equ Ether_buffer + 1518	117	Next_free3 equ Ether_buffer + 1518
115	last_1sTick equ Next_free3	118	last_1sTick equ Next_free3
116	IPbuffs equ Next_free3 + 1	119	IPbuffs equ Next_free3 + 1
117	queues equ IPbuffs + ( NUM_IPBUFFERS * IPBUFFSIZE )	120	queues equ IPbuffs + ( NUM_IPBUFFERS * IPBUFFSIZE )
118	queueList equ queues + (2 * NUMQUEUES)	121	queueList equ queues + (2 * NUMQUEUES)
119	last_1hsTick equ queueList + ( 2 * NUMQUEUEENTRIES )	122	last_1hsTick equ queueList + ( 2 * NUMQUEUEENTRIES )
120		123
121	;resendQ equ queueList + ( 2 * NUMQUEUEENTRIES )	124	;resendQ equ queueList + ( 2 * NUMQUEUEENTRIES )
122	;resendBuffer equ resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP	125	;resendBuffer equ resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP
123	; equ resendBuffer + ( IPBUFFSIZE * NUMRESENDENTRIES )	126	; equ resendBuffer + ( IPBUFFSIZE * NUMRESENDENTRIES )
124		127
125		128
126		129
127	;resendQ equ 0x770000	130	;resendQ equ 0x770000
128	resendBuffer equ resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP	131	resendBuffer equ resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP
129		132
130		133
131	; simple macro for memory set operation	134	; simple macro for memory set operation
132	macro _memset_dw adr,value,amount	135	macro _memset_dw adr,value,amount
133	{	136	{
134	mov edi, adr	137	mov edi, adr
135	mov ecx, amount	138	mov ecx, amount
136	if value = 0	139	if value = 0
137	xor eax, eax	140	xor eax, eax
138	else	141	else
139	mov eax, value	142	mov eax, value
140	end if	143	end if
141	cld	144	cld
142	rep stosd	145	rep stosd
143	}	146	}
144		147
145		148
146	; Below, the main network layer source code is included	149	; Below, the main network layer source code is included
147	;	150	;
148	include "queue.inc"	151	include "queue.inc"
149	include "eth_drv/ethernet.inc"	152	include "eth_drv/ethernet.inc"
150	include "ip.inc"	153	include "ip.inc"
151	include "icmp.inc"	154	include "icmp.inc"
152	include "tcp.inc"	155	include "tcp.inc"
153	include "udp.inc"	156	include "udp.inc"
154	include "socket.inc"	157	include "socket.inc"
155		158
156	;***************************************************************************	159	;***************************************************************************
157	; Function	160	; Function
158	; stack_init	161	; stack_init
159	;	162	;
160	; Description	163	; Description
161	; Clear all allocated memory to zero. This ensures that	164	; Clear all allocated memory to zero. This ensures that
162	; on startup, the stack is inactive, and consumes no resources	165	; on startup, the stack is inactive, and consumes no resources
163	; This is a kernel function, called prior to the OS main loop	166	; This is a kernel function, called prior to the OS main loop
164	; in set_variables	167	; in set_variables
165	;	168	;
166	;***************************************************************************	169	;***************************************************************************
167		170
168	stack_init:	171	stack_init:
169	; Init two address spaces with default values	172	; Init two address spaces with default values
170	_memset_dw stack_data_start, 0, 0x20000/4	173	_memset_dw stack_data_start, 0, 0x20000/4
171	_memset_dw resendQ, 0xFFFFFFFF, NUMRESENDENTRIES	174	_memset_dw resendQ, 0xFFFFFFFF, NUMRESENDENTRIES
172		175
173	; Queries initialization	176	; Queries initialization
174	call queueInit	177	call queueInit
175		178
176	; The following block sets up the 1s timer	179	; The following block sets up the 1s timer
177	mov al, 0x0	180	mov al, 0x0
178	out 0x70, al	181	out 0x70, al
179	in al, 0x71	182	in al, 0x71
180	mov [last_1sTick], al	183	mov [last_1sTick], al
181	ret	184	ret
182		185
183		186
184		187
185	;***************************************************************************	188	;***************************************************************************
186	; Function	189	; Function
187	; stack_handler	190	; stack_handler
188	;	191	;
189	; Description	192	; Description
190	; The kernel loop routine for the stack	193	; The kernel loop routine for the stack
191	; This is a kernel function, called in the main loop	194	; This is a kernel function, called in the main loop
192	;	195	;
193	;***************************************************************************	196	;***************************************************************************
194	stack_handler:	197	stack_handler:
195		198
196	call ethernet_driver	199	call ethernet_driver
197	call ip_rx	200	call ip_rx
198		201
199		202
200	; Test for 10ms tick, call tcp timer	203	; Test for 10ms tick, call tcp timer
201	mov eax, [timer_ticks] ;[0xfdf0]	204	mov eax, [timer_ticks] ;[0xfdf0]
202	cmp eax, [last_1hsTick]	205	cmp eax, [last_1hsTick]
203	je sh_001	206	je sh_001
204		207
205	mov [last_1hsTick], eax	208	mov [last_1hsTick], eax
206	call tcp_tx_handler	209	call tcp_tx_handler
207		210
208	sh_001:	211	sh_001:
209		212
210	; Test for 1 second event, call 1s timer functions	213	; Test for 1 second event, call 1s timer functions
211	mov al, 0x0 ;second	214	mov al, 0x0 ;second
212	out 0x70, al	215	out 0x70, al
213	in al, 0x71	216	in al, 0x71
214	cmp al, [last_1sTick]	217	cmp al, [last_1sTick]
215	je sh_exit	218	je sh_exit
216		219
217	mov [last_1sTick], al	220	mov [last_1sTick], al
218		221
219	stdcall arp_table_manager, ARP_TABLE_TIMER, 0, 0	222	stdcall arp_table_manager, ARP_TABLE_TIMER, 0, 0
220	call tcp_tcb_handler	223	call tcp_tcb_handler
221		224
222	sh_exit:	225	sh_exit:
223	ret	226	ret
224		227
225	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	228	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
226	;; Checksum [by Johnny_B]	229	;; Checksum [by Johnny_B]
227	;; IN:	230	;; IN:
228	;; buf_ptr=POINTER to buffer	231	;; buf_ptr=POINTER to buffer
229	;; buf_size=SIZE of buffer	232	;; buf_size=SIZE of buffer
230	;; OUT:	233	;; OUT:
231	;; AX=16-bit checksum	234	;; AX=16-bit checksum
232	;; Saves all used registers	235	;; Saves all used registers
233	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	236	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
234	proc checksum_jb stdcall uses ebx esi ecx,\	237	proc checksum_jb stdcall uses ebx esi ecx,\
235	buf_ptr:DWORD, buf_size:DWORD	238	buf_ptr:DWORD, buf_size:DWORD
236		239
237	xor eax, eax	240	xor eax, eax
238	xor ebx, ebx ;accumulator	241	xor ebx, ebx ;accumulator
239	mov esi, dword[buf_ptr]	242	mov esi, dword[buf_ptr]
240	mov ecx, dword[buf_size]	243	mov ecx, dword[buf_size]
241	shr ecx, 1 ; ecx=ecx/2	244	shr ecx, 1 ; ecx=ecx/2
242	jnc @f ; if CF==0 then size is even number	245	jnc @f ; if CF==0 then size is even number
243	mov bh, byte[esi + ecx*2]	246	mov bh, byte[esi + ecx*2]
244	@@:	247	@@:
245	cld	248	cld
246		249
247	.loop:	250	.loop:
248	lodsw ;eax=word[esi],esi=esi+2	251	lodsw ;eax=word[esi],esi=esi+2
249	xchg ah,al ;cause must be a net byte-order	252	xchg ah,al ;cause must be a net byte-order
250	add ebx, eax	253	add ebx, eax
251	loop .loop	254	loop .loop
252		255
253	mov eax, ebx	256	mov eax, ebx
254	shr eax, 16	257	shr eax, 16
255	add ax, bx	258	add ax, bx
256	not ax	259	not ax
257		260
258	ret	261	ret
259	endp	262	endp
260		263
261	;***************************************************************************	264	;***************************************************************************
262	; Function	265	; Function
263	; checksum	266	; checksum
264	;	267	;
265	; Description	268	; Description
266	; checkAdd1,checkAdd2, checkSize1, checkSize2, checkResult	269	; checkAdd1,checkAdd2, checkSize1, checkSize2, checkResult
267	; Dont break anything; Most registers are used by the caller	270	; Dont break anything; Most registers are used by the caller
268	; This code is derived from the 'C' source, cksum.c, in the book	271	; This code is derived from the 'C' source, cksum.c, in the book
269	; Internetworking with TCP/IP Volume II by D.E. Comer	272	; Internetworking with TCP/IP Volume II by D.E. Comer
270	;	273	;
271	;***************************************************************************	274	;***************************************************************************
272		275
273		276
274	checksum:	277	checksum:
275	pusha	278	pusha
276	mov eax, [checkAdd1]	279	mov eax, [checkAdd1]
277	xor edx, edx ; edx is the accumulative checksum	280	xor edx, edx ; edx is the accumulative checksum
278	xor ebx, ebx	281	xor ebx, ebx
279	mov cx, [checkSize1]	282	mov cx, [checkSize1]
280	shr cx, 1	283	shr cx, 1
281	jz cs1_1	284	jz cs1_1
282		285
283	cs1:	286	cs1:
284	mov bh, [eax]	287	mov bh, [eax]
285	mov bl, [eax + 1]	288	mov bl, [eax + 1]
286		289
287	add eax, 2	290	add eax, 2
288	add edx, ebx	291	add edx, ebx
289		292
290	loopw cs1	293	loopw cs1
291		294
292	cs1_1:	295	cs1_1:
293	and word [checkSize1], 0x01	296	and word [checkSize1], 0x01
294	jz cs_test2	297	jz cs_test2
295		298
296	mov bh, [eax]	299	mov bh, [eax]
297	xor bl, bl	300	xor bl, bl
298		301
299	add edx, ebx	302	add edx, ebx
300		303
301	cs_test2:	304	cs_test2:
302	mov cx, [checkSize2]	305	mov cx, [checkSize2]
303	cmp cx, 0	306	cmp cx, 0
304	jz cs_exit ; Finished if no 2nd buffer	307	jz cs_exit ; Finished if no 2nd buffer
305		308
306	mov eax, [checkAdd2]	309	mov eax, [checkAdd2]
307		310
308	shr cx, 1	311	shr cx, 1
309	jz cs2_1	312	jz cs2_1
310		313
311	cs2:	314	cs2:
312	mov bh, [eax]	315	mov bh, [eax]
313	mov bl, [eax + 1]	316	mov bl, [eax + 1]
314		317
315	add eax, 2	318	add eax, 2
316	add edx, ebx	319	add edx, ebx
317		320
318	loopw cs2	321	loopw cs2
319		322
320	cs2_1:	323	cs2_1:
321	and word [checkSize2], 0x01	324	and word [checkSize2], 0x01
322	jz cs_exit	325	jz cs_exit
323		326
324	mov bh, [eax]	327	mov bh, [eax]
325	xor bl, bl	328	xor bl, bl
326		329
327	add edx, ebx	330	add edx, ebx
328		331
329	cs_exit:	332	cs_exit:
330	mov ebx, edx	333	mov ebx, edx
331		334
332	shr ebx, 16	335	shr ebx, 16
333	and edx, 0xffff	336	and edx, 0xffff
334	add edx, ebx	337	add edx, ebx
335	mov eax, edx	338	mov eax, edx
336	shr eax, 16	339	shr eax, 16
337	add edx, eax	340	add edx, eax
338	not dx	341	not dx
339		342
340	mov [checkResult], dx	343	mov [checkResult], dx
341	popa	344	popa
342	ret	345	ret
343		346
344		347
345		348
346		349
347	;***************************************************************************	350	;***************************************************************************
348	; Function	351	; Function
349	; app_stack_handler	352	; app_stack_handler
350	;	353	;
351	; Description	354	; Description
352	; This is an application service, called by int 0x40, function 52	355	; This is an application service, called by int 0x40, function 52
353	; It provides application access to the network interface layer	356	; It provides application access to the network interface layer
354	;	357	;
355	;***************************************************************************	358	;***************************************************************************
356	app_stack_handler:	359	app_stack_handler:
357	cmp eax, 0	360	cmp eax, 0
358	jnz not0	361	jnz not0
359	; Read the configuration word	362	; Read the configuration word
360	mov eax, [stack_config]	363	mov eax, [stack_config]
361	ret	364	ret
362		365
363	not0:	366	not0:
364	cmp eax, 1	367	cmp eax, 1
365	jnz not1	368	jnz not1
366	; read the IP address	369	; read the IP address
367		370
368	mov eax, [stack_ip]	371	mov eax, [stack_ip]
369	ret	372	ret
370		373
371	not1:	374	not1:
372	cmp eax, 2	375	cmp eax, 2
373	jnz not2	376	jnz not2
374		377
375	; write the configuration word	378	; write the configuration word
376	mov [stack_config], ebx	379	mov [stack_config], ebx
377		380
378	;	381	;
379	; If ethernet now enabled, probe for the card, reset it and empty	382	; If ethernet now enabled, probe for the card, reset it and empty
380	; the packet buffer	383	; the packet buffer
381	; If all successfull, enable the card.	384	; If all successfull, enable the card.
382	; If ethernet now disabled, set it as disabled. Should really	385	; If ethernet now disabled, set it as disabled. Should really
383	; empty the tcpip data area too.	386	; empty the tcpip data area too.
384		387
385	; ethernet interface is '3' in ls 7 bits	388	; ethernet interface is '3' in ls 7 bits
386	and bl, 0x7f	389	and bl, 0x7f
387	cmp bl, 3	390	cmp bl, 3
388		391
389	je ash_eth_enable	392	je ash_eth_enable
390	; Ethernet isn't enabled, so make sure that the card is disabled	393	; Ethernet isn't enabled, so make sure that the card is disabled
391	mov [ethernet_active], byte 0	394	mov [ethernet_active], byte 0
392		395
393	ret	396	ret
394		397
395	ash_eth_enable:	398	ash_eth_enable:
396	; Probe for the card. This will reset it and enable the interface	399	; Probe for the card. This will reset it and enable the interface
397	; if found	400	; if found
398	call eth_probe	401	call eth_probe
399	cmp eax, 0	402	cmp eax, 0
400	je ash_eth_done ; Abort if no hardware found	403	je ash_eth_done ; Abort if no hardware found
401		404
402	mov [ethernet_active], byte 1	405	mov [ethernet_active], byte 1
403		406
404	ash_eth_done:	407	ash_eth_done:
405	ret	408	ret
406		409
407	not2:	410	not2:
408	cmp eax, 3	411	cmp eax, 3
409	jnz not3	412	jnz not3
410	; write the IP Address	413	; write the IP Address
411	mov [stack_ip], ebx	414	mov [stack_ip], ebx
412	ret	415	ret
413		416
414	;old functions was deleted	417	;old functions was deleted
415		418
416	not3:	419	not3:
417	cmp eax, 6	420	cmp eax, 6
418	jnz not6	421	jnz not6
419		422
420	; Insert an IP packet into the stacks received packet queue	423	; Insert an IP packet into the stacks received packet queue
421	call stack_insert_packet	424	call stack_insert_packet
422	ret	425	ret
423		426
424	not6:	427	not6:
425	cmp eax, 7	428	cmp eax, 7
426	jnz not7	429	jnz not7
427		430
428	; Test for any packets queued for transmission over the network	431	; Test for any packets queued for transmission over the network
429		432
430	not7:	433	not7:
431	cmp eax, 8	434	cmp eax, 8
432	jnz not8	435	jnz not8
433		436
434	call stack_get_packet	437	call stack_get_packet
435	; Extract a packet queued for transmission by the network	438	; Extract a packet queued for transmission by the network
436	ret	439	ret
437		440
438	not8:	441	not8:
439	cmp eax, 9	442	cmp eax, 9
440	jnz not9	443	jnz not9
441		444
442	; read the gateway IP address	445	; read the gateway IP address
443		446
444	mov eax, [gateway_ip]	447	mov eax, [gateway_ip]
445	ret	448	ret
446		449
447	not9:	450	not9:
448	cmp eax, 10	451	cmp eax, 10
449	jnz not10	452	jnz not10
450		453
451	; read the subnet mask	454	; read the subnet mask
452		455
453	mov eax, [subnet_mask]	456	mov eax, [subnet_mask]
454	ret	457	ret
455		458
456	not10:	459	not10:
457	cmp eax, 11	460	cmp eax, 11
458	jnz not11	461	jnz not11
459		462
460	; write the gateway IP Address	463	; write the gateway IP Address
461	mov [gateway_ip], ebx	464	mov [gateway_ip], ebx
462		465
463	ret	466	ret
464		467
465	not11:	468	not11:
466	cmp eax, 12	469	cmp eax, 12
467	jnz not12	470	jnz not12
468		471
469	; write the subnet mask	472	; write the subnet mask
470	mov [subnet_mask], ebx	473	mov [subnet_mask], ebx
471		474
472		475
473	not12:	476	not12:
474	cmp eax, 13	477	cmp eax, 13
475	jnz not13	478	jnz not13
476		479
477	; read the dns	480	; read the dns
478		481
479	mov eax, [dns_ip]	482	mov eax, [dns_ip]
480	ret	483	ret
481		484
482	not13:	485	not13:
483	cmp eax, 14	486	cmp eax, 14
484	jnz not14	487	jnz not14
485		488
486	; write the dns IP Address	489	; write the dns IP Address
487	mov [dns_ip], ebx	490	mov [dns_ip], ebx
488		491
489	ret	492	ret
490		493
491	;	494	;
492	not14:	495	not14:
493	cmp eax, 15	496	cmp eax, 15
494	jnz not15	497	jnz not15
495		498
496	; in ebx we need 4 to read the last 2 bytes	499	; in ebx we need 4 to read the last 2 bytes
497	cmp ebx, dword 4	500	cmp ebx, dword 4

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/stack.inc – Rev 425 → 431