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


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/stack.inc – Rev 379 → 412