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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/stack.inc – Rev 922 → 983