WebSVN – Kolibri OS – Diff – /kernel/branches/net/network/IPv4.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2010. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  IPv4.INC                                                       ;;
;;                                                                 ;;
;;  Part of the tcp/ip network stack for KolibriOS                 ;;
;;                                                                 ;;
;;  Based on the work of [Johnny_B] and [smb]                      ;;
;;                                                                 ;;
;;    Written by hidnplayr@kolibrios.org                           ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 1541 $
 
MAX_FRAGMENTS	equ 64
MAX_IP		equ MAX_NET_DEVICES
IP_MAX_INTERFACES   equ MAX_IP
 
struct	IPv4_Packet
	.VersionAndIHL		db  ?  ; Version[0-3 bits] and IHL(header length)[4-7 bits]
	.TypeOfService		db  ?  ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]
	.TotalLength		dw  ?
	.Identification 	dw  ?
	.FlagsAndFragmentOffset dw  ?  ; Flags[0-2] and FragmentOffset[3-15]
	.TimeToLive		db  ?  ;
	.Protocol		db  ?
	.HeaderChecksum 	dw  ?
	.SourceAddress		dd  ?
	.DestinationAddress	dd  ?
	.DataOrOptional:
ends
 
struct	FRAGMENT_slot
	.ttl			dw  ?  ; Time to live for this entry, 0 for empty slot's
	.id			dw  ?  ; Identification field from IP header
	.SrcIP			dd  ?  ; .. from IP header
	.DstIP			dd  ?  ; .. from IP header
	.ptr			dd  ?  ; Pointer to first packet
	.size:
ends
 
struct	FRAGMENT_entry		       ; This structure will replace the ethernet header in fragmented ip packets
	.PrevPtr		dd  ?  ; Pointer to previous fragment entry  (-1 for first packet)
	.NextPtr		dd  ?  ; Pointer to next fragment entry (-1 for last packet)
	.Owner			dd  ?  ; Pointer to structure of driver
				rb  2  ; to match ethernet header size          ; TODO: fix this hack
	.Data:			       ; Ip header begins here (we will need the IP header to re-construct the complete packet)
ends
 
 
align 4
uglobal
 
	IP_LIST 	rd  MAX_IP
	SUBNET_LIST	rd  MAX_IP
	DNS_LIST	rd  MAX_IP
	GATEWAY_LIST	rd  MAX_IP
 
	IP_PACKETS_TX	rd  MAX_IP
	IP_PACKETS_RX	rd  MAX_IP
 
	FRAGMENT_LIST	rb  MAX_FRAGMENTS*FRAGMENT_slot.size
endg
 
 
;-----------------------------------------------------------------
;
; IPv4_init
;
;  This function resets all IP variables
;
;-----------------------------------------------------------------
macro	IPv4_init {
 
	xor	eax, eax
	mov	edi, IP_LIST
	mov	ecx, 4*MAX_IP
	rep	stosd
 
	mov	edi, FRAGMENT_LIST
	mov	ecx, FRAGMENT_slot.size*MAX_FRAGMENTS/4 + 2*MAX_IP
	rep	stosd
 
}
 
 
;-----------------------------------------------------------------
;
; Decrease TimeToLive of all fragment slots
;
;-----------------------------------------------------------------
macro IPv4_decrease_fragment_ttls {
 
local	.loop
 
	mov	esi, FRAGMENT_LIST
	mov	ecx, MAX_FRAGMENTS
  .loop:
	cmp	[esi + FRAGMENT_slot.ttl], 0
	je	.try_next
	dec	[esi + FRAGMENT_slot.ttl]
	jnz	.try_next
	DEBUGF 1,"Fragment slot timed-out!\n"
;;; TODO: clear all entry's of timed-out slot
  .try_next:
	add	esi, 4
	loop	.loop
}
 
 
 
macro IPv4_checksum ptr {
 
; This is the fast procedure to create or check a IP header without options
; To create a new checksum, the checksum field must be set to 0 before computation
; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct
 
	push	ebx
	xor	ebx, ebx
	add	bl, [ptr+1]
	adc	bh, [ptr+0]
 
	adc	bl, [ptr+3]
	adc	bh, [ptr+2]
 
	adc	bl, [ptr+5]
	adc	bh, [ptr+4]
 
	adc	bl, [ptr+7]
	adc	bh, [ptr+6]
 
	adc	bl, [ptr+9]
	adc	bh, [ptr+8]
 
; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation
 
	adc	bl, [ptr+13]
	adc	bh, [ptr+12]
 
	adc	bl, [ptr+15]
	adc	bh, [ptr+14]
 
	adc	bl, [ptr+17]
	adc	bh, [ptr+16]
 
	adc	bl, [ptr+19]
	adc	bh, [ptr+18]
 
	adc	ebx, 0
 
	push	ecx
	mov	ecx, ebx
	shr	ecx, 16
	and	ebx, 0xffff
	add	ebx, ecx
 
	mov	ecx, ebx
	shr	ecx, 16
	add	ebx, ecx
 
	not	bx
	jnz	.not_zero
	dec	bx
  .not_zero:
	xchg	bl, bh
	pop	ecx
 
	neg	word [ptr+10]		; zero will stay zero so we just get the checksum
	add	word [ptr+10], bx	;  , else we will get (new checksum - old checksum) in the end, wich should be 0 :)
	pop	ebx
 
}
 
 
 
;-----------------------------------------------------------------
;
; IPv4_input:
;
;  Will check if IP Packet isnt damaged
;  and call appropriate handler. (TCP/UDP/ICMP/..)
;
;  It will also re-construct fragmented packets
;
;  IN:  Pointer to buffer in [esp]
;       size of buffer in [esp+4]
;       pointer to device struct in ebx
;       pointer to IP Packet data in edx
;  OUT: /
;
;-----------------------------------------------------------------
align 4
IPv4_input:	 ; TODO: implement handler for IP options
		 ; TODO2: add code for raw sockets
 
	DEBUGF	1,"IPv4_Handler, packet from: %u.%u.%u.%u ",\
	[edx + IPv4_Packet.SourceAddress]:1,[edx + IPv4_Packet.SourceAddress + 1]:1,[edx + IPv4_Packet.SourceAddress + 2]:1,[edx + IPv4_Packet.SourceAddress + 3]:1
	DEBUGF	1,"to: %u.%u.%u.%u\n",\
	[edx + IPv4_Packet.DestinationAddress]:1,[edx + IPv4_Packet.DestinationAddress + 1]:1,[edx + IPv4_Packet.DestinationAddress + 2]:1,[edx + IPv4_Packet.DestinationAddress + 3]:1
 
;-------------------------------------------
; Check if the packet still has time to live
 
	cmp	byte [edx + IPv4_Packet.TimeToLive], 0
	je	.dump
 
;--------------------------------------
; First, check if IP packet has options
 
	movzx	eax, [edx + IPv4_Packet.VersionAndIHL]
	and	al , 0x0f					; get IHL(header length)
	cmp	al , 0x05					; IHL!= 5*4(20 bytes)
	jnz	.has_options
 
;-------------------------------
; Now, re-calculate the checksum
 
	IPv4_checksum edx
	jnz	.dump						; if checksum isn't valid then dump packet
 
	DEBUGF	1,"IPv4 Checksum is correct\n"
 
;-----------------------------------
; Check if destination IP is correct
 
	call	NET_ptr_to_num
	shl	edi, 2
 
	; check if it matches local ip
 
	mov	eax, dword[IP_LIST+edi]
	cmp	[edx + IPv4_Packet.DestinationAddress], eax
	je	.ip_ok
 
	; check for broadcast
 
	mov	eax, dword[SUBNET_LIST+edi]
	not	eax
	or	eax, dword[IP_LIST+edi]
	cmp	[edx + IPv4_Packet.DestinationAddress], eax
	je	.ip_ok
 
	; or a special broadcast
 
	cmp	[edx + IPv4_Packet.DestinationAddress], -1
	je	.ip_ok
 
	; maybe it's a multicast then
 
	mov	eax, [edx + IPv4_Packet.DestinationAddress]
	and	eax, 0xff000000
;        cmp     eax, 224 shl 24
;        je      .ip_ok
 
	; or a loopback address
 
	cmp	eax, 127 shl 24
	je	.ip_ok
 
	; or it's not meant for us..
 
	DEBUGF	2,"Destination address does not match!\n"
	jmp	.dump
 
;------------------------
; Now we can update stats
 
  .ip_ok:
	inc	[IP_PACKETS_RX+edi]
 
;----------------------------------
; Check if the packet is fragmented
 
	test	[edx + IPv4_Packet.FlagsAndFragmentOffset], 1 shl 5	; Is 'more fragments' flag set ?
	jnz	.has_fragments						; If so, we definately have a fragmented packet
 
	test	[edx + IPv4_Packet.FlagsAndFragmentOffset], 0xff1f	; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets
	jnz	.is_last_fragment
 
;-------------------------------------------------------------------
; No, it's just a regular IP packet, pass it to the higher protocols
 
  .handle_it:							; We reach here if packet hasnt been fragmented, or when it already has been re-constructed
	movzx	eax, byte [edx + IPv4_Packet.VersionAndIHL]	; Calculate Header length by using IHL field
	and	eax, 0x0000000f 				;
	shl	eax, 2						;
	movzx	ecx, word [edx + IPv4_Packet.TotalLength]	; Calculate length of encapsulated Packet
	xchg	cl , ch 					;
	sub	ecx, eax					;
 
	add	eax, edx
	push	eax
 
	mov	esi, [edx + IPv4_Packet.SourceAddress]		; These values might be of interest to the higher protocols
	mov	edi, [edx + IPv4_Packet.DestinationAddress]	;
	mov	al , [edx + IPv4_Packet.Protocol]
	pop	edx						; Offset to data (tcp/udp/icmp/.. Packet)
 
	cmp	al , IP_PROTO_TCP
	je	TCP_input
 
	cmp	al , IP_PROTO_UDP
	je	UDP_input
 
	cmp	al , IP_PROTO_ICMP
	je	ICMP_input
 
	DEBUGF	2,"unknown Internet protocol: %u\n", al
 
  .dump:
	DEBUGF	2,"IP_Handler - dumping\n"
;        inc     [dumped_rx_count]
	call	kernel_free
	add	esp, 4						; pop (balance stack)
	ret
 
 
;---------------------------
; Fragmented packet handler
 
 
  .has_fragments:
	movzx	eax, [edx + IPv4_Packet.FlagsAndFragmentOffset]
	xchg	al , ah
	shl	ax , 3
 
	DEBUGF	1,"Fragmented packet, offset:%u, id:%x\n", ax, [edx + IPv4_Packet.Identification]:4
 
	test	ax , ax 					; Is this the first packet of the fragment?
	jz	.is_first_fragment
 
 
;-------------------------------------------------------
; We have a fragmented IP packet, but it's not the first
 
	DEBUGF	1,"Middle fragmented packet received!\n"
 
	call	IPv4_find_fragment_slot
	cmp	esi, -1
	je	.dump
 
	mov	word [esi + FRAGMENT_slot.ttl], 15		; Reset the ttl
	mov	esi, [esi + FRAGMENT_slot.ptr]
	or	edi, -1
  .find_last_entry:						; The following routine will try to find the last entry
	cmp	edi, [esi + FRAGMENT_entry.PrevPtr]
	jne	.destroy_slot					; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
	mov	edi, esi
	mov	esi, [esi + FRAGMENT_entry.NextPtr]
	cmp	esi, -1
	jne	.find_last_entry
								; We found the last entry (pointer is now in edi)
								; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
 
	pop	eax						; pointer to packet
	mov	[edi + FRAGMENT_entry.NextPtr], eax		; update pointer of previous entry to the new entry
	mov	[eax + FRAGMENT_entry.NextPtr], -1
	mov	[eax + FRAGMENT_entry.PrevPtr], edi
	mov	[eax + FRAGMENT_entry.Owner], ebx
 
	add	esp, 4
	ret
 
 
;------------------------------------
; We have received the first fragment
 
  .is_first_fragment:
	DEBUGF	1,"First fragmented packet received!\n"
								; try to locate a free slot..
	mov	ecx, MAX_FRAGMENTS
	mov	esi, FRAGMENT_LIST
  .find_free_slot:
	cmp	word [esi + FRAGMENT_slot.ttl], 0
	je	.found_free_slot
	add	esi, FRAGMENT_slot.size
	loop	.find_free_slot
	jmp	.dump						; If no free slot was found, dump the packet
 
  .found_free_slot:						; We found a free slot, let's fill in the FRAGMENT_slot structure
	mov	word [esi + FRAGMENT_slot.ttl], 15		; RFC recommends 15 secs as ttl
	mov	ax , word [edx + IPv4_Packet.Identification]
	mov	word [esi + FRAGMENT_slot.id], ax
	mov	eax, dword [edx + IPv4_Packet.SourceAddress]
	mov	dword [esi + FRAGMENT_slot.SrcIP], eax
	mov	eax, dword [edx + IPv4_Packet.DestinationAddress]
	mov	dword [esi + FRAGMENT_slot.DstIP], eax
	pop	eax
	mov	dword [esi + FRAGMENT_slot.ptr], eax
								; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
	mov	[eax + FRAGMENT_entry.NextPtr], -1
	mov	[eax + FRAGMENT_entry.PrevPtr], -1
	mov	[eax + FRAGMENT_entry.Owner], ebx
 
	add	esp, 4						; balance stack and exit
	ret
 
 
;-----------------------------------
; We have received the last fragment
 
  .is_last_fragment:
	DEBUGF	1,"Last fragmented packet received!\n"
 
	call	IPv4_find_fragment_slot
	cmp	esi, -1
	je	.dump
 
	mov	esi, [esi + FRAGMENT_slot.ptr]			; We found the first entry, let's calculate total size of the packet in eax, so we can allocate a buffer
	push	esi
	xor	eax, eax
	or	edi, -1
 
  .count_bytes:
	cmp	[esi + FRAGMENT_entry.PrevPtr], edi
	jne	.destroy_slot_pop						  ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
	mov	cx, word [esi + FRAGMENT_entry.Data + IPv4_Packet.TotalLength]	  ; Add total length
	xchg	cl, ch
	DEBUGF	1,"Packet size: %u\n", cx
	add	ax, cx
	movzx	cx, byte [esi + FRAGMENT_entry.Data + IPv4_Packet.VersionAndIHL]  ; Sub Header length
	and	cx, 0x000F
	shl	cx, 2
	DEBUGF	1,"Header size: %u\n", cx
	sub	ax, cx
	mov	edi, esi
	mov	esi, [esi + FRAGMENT_entry.NextPtr]
	cmp	esi, -1
	jne	.count_bytes
 
	mov	esi, [esp+4]
	mov	[edi + FRAGMENT_entry.NextPtr], esi			       ; Add this packet to the chain, this simplifies the following code
	mov	[esi + FRAGMENT_entry.NextPtr], -1
	mov	[esi + FRAGMENT_entry.PrevPtr], edi
	mov	[esi + FRAGMENT_entry.Owner], ebx
 
	mov	cx, [edx + IPv4_Packet.TotalLength]			       ; Note: This time we dont substract Header length
	xchg	cl , ch
	DEBUGF	1,"Packet size: %u\n", cx
	add	ax , cx
	DEBUGF	1,"Total Received data size: %u\n", eax
 
	push	eax
	mov	ax , [edx + IPv4_Packet.FlagsAndFragmentOffset]
	xchg	al , ah
	shl	ax , 3
	add	cx , ax
	pop	eax
	DEBUGF	1,"Total Fragment size: %u\n", ecx
 
	cmp	ax, cx
	jne	.destroy_slot_pop
 
	push	eax
	push	eax
	call	kernel_alloc
	test	eax, eax
	je	.destroy_slot_pop							; If we dont have enough space to allocate the buffer, discard all packets in slot
	mov	edx, [esp+4]								; Get pointer to first fragment entry back in edx
 
  .rebuild_packet_loop:
	movzx	ecx, word [edx + FRAGMENT_entry.Data + IPv4_Packet.FlagsAndFragmentOffset]	; Calculate the fragment offset
	xchg	cl , ch 									;  intel byte order
	shl	cx , 3										;   multiply by 8 and clear first 3 bits
	DEBUGF	1,"Fragment offset: %u\n", cx
 
	lea	edi, [eax + ecx]								; Notice that edi will be equal to eax for first fragment
	movzx	ebx, byte [edx + FRAGMENT_entry.Data + IPv4_Packet.VersionAndIHL]		; Find header size (in ebx) of fragment
	and	bx , 0x000F									;
	shl	bx , 2										;
 
	lea	esi, [edx + FRAGMENT_entry.Data]						; Set esi to the correct begin of fragment
	movzx	ecx, word [edx + FRAGMENT_entry.Data + IPv4_Packet.TotalLength] 		; Calculate total length of fragment
	xchg	cl, ch										;  intel byte order
 
	cmp	edi, eax									; Is this packet the first fragment ?
	je	.first_fragment
	sub	cx, bx										; If not, dont copy the header
	add	esi, ebx									;
  .first_fragment:
 
	push	cx										; First copy dword-wise, then byte-wise
	shr	cx, 2										;
	rep	movsd										;
	pop	cx										;
	and	cx, 3										;
	rep	movsb										;
 
	push	eax
	push	edx										; Push pointer to fragment onto stack
	mov	ebx, [edx + FRAGMENT_entry.Owner]						; we need to remeber the owner, in case this is the last packet
	mov	edx, [edx + FRAGMENT_entry.NextPtr]						; Set edx to the next pointer
	call	kernel_free									; free the previous fragment buffer (this uses the value from stack)
	pop	eax
	cmp	edx, -1 									; Check if it is last fragment in chain
	jne	.rebuild_packet_loop
 
	pop	ecx										;
	xchg	cl, ch
	mov	edx, eax
	mov	word [edx + IPv4_Packet.TotalLength], cx
	add	esp, 8
 
	xchg	cl, ch		    ;
 
	push	ecx		   ;;;;
	push	eax		   ;;;;
 
;        mov     esi, edx           ;  This prints the IP packet to the debug board (usefull when using serial output debug..)
;                                   ;
;        packet_to_debug
 
	jmp	.handle_it	    ; edx = buf ptr, ecx = size, [esp] buf ptr, [esp+4], total size, ebx=device ptr
 
  .destroy_slot_pop:
	add	esp, 4
  .destroy_slot:
	DEBUGF	1,"Destroy fragment slot!\n"
	; TODO!
	jmp	.dump
 
 
 
 
;-----------------------------------
; The IP packet has some options
 
  .has_options:
	jmp	.dump
 
 
 
;-----------------------------------------------------------------
;
; find fragment slot
;
; IN: pointer to fragmented packet in edx
; OUT: pointer to slot in edi, -1 on error
;
;-----------------------------------------------------------------
align 4
IPv4_find_fragment_slot:
 
;;; TODO: the RFC says we should check protocol number too
 
	push	eax ebx ecx edx
	mov	ax , word [edx + IPv4_Packet.Identification]
	mov	ecx, MAX_FRAGMENTS
	mov	esi, FRAGMENT_LIST
	mov	ebx, dword [edx + IPv4_Packet.SourceAddress]
	mov	edx, dword [edx + IPv4_Packet.DestinationAddress]
  .find_slot:
	cmp	word [esi + FRAGMENT_slot.id], ax
	jne	.try_next
	cmp	dword [esi + FRAGMENT_slot.SrcIP], ebx
	jne	.try_next
	cmp	dword [esi + FRAGMENT_slot.DstIP], edx
	je	.found_slot
  .try_next:
	add	esi, FRAGMENT_slot.size
	loop	.find_slot
;        pop     edx ebx
	or	esi, -1
;        ret
 
  .found_slot:
	pop	edx ecx ebx eax
	ret
 
 
;------------------------------------------------------------------
;
; IPv4_output
;
; IN: eax = dest ip
;     ebx = source ip
;     ecx = data length
;     dx  = fragment id
;     di  = TTL shl 8 + protocol
;
; OUT: eax = pointer to buffer start
;      ebx = pointer to device struct (needed for sending procedure)
;      ecx = unchanged (packet size of embedded data)
;      edx = size of complete buffer
;      edi = pointer to start of data (0 on error)
;
;------------------------------------------------------------------
align 4
IPv4_output:
 
	DEBUGF 1,"IPv4_create_packet: size=%u\n", ecx
 
	cmp	ecx, 65500		; Max IPv4 packet size
	jg	.too_large
 
	push	ecx eax ebx dx di
 
	call	ARP_IP_to_MAC
 
	test	eax, 0xffff0000 	; error bits
	jnz	.arp_error
 
  .continue:
 
	push	ebx	; push the mac
	push	ax
 
	call	IPv4_dest_to_dev
	inc	[IP_PACKETS_TX+edi]
	mov	ebx, [NET_DRV_LIST+edi]
	lea	eax, [ebx + ETH_DEVICE.mac]
	mov	edx, esp
	mov	ecx, [esp + 18]
	add	ecx, IPv4_Packet.DataOrOptional
	mov	di , ETHER_IPv4
	call	ETH_output
	jz	.error
 
	add	esp, 6	; pop the mac
 
	mov	[edi + IPv4_Packet.VersionAndIHL], 0x45 ; IPv4, normal length (no Optional header)
	mov	[edi + IPv4_Packet.TypeOfService], 0	; nothing special, just plain ip packet
	mov	[edi + IPv4_Packet.TotalLength], cx
	rol	[edi + IPv4_Packet.TotalLength], 8	; internet byte order
	mov	[edi + IPv4_Packet.FlagsAndFragmentOffset], 0x0000
	mov	[edi + IPv4_Packet.HeaderChecksum], 0
	popw	word [edi + IPv4_Packet.TimeToLive]	; ttl shl 8 + protocol
;               [edi + IPv4_Packet.Protocol]
	popw	[edi + IPv4_Packet.Identification]	; fragment id
	popd	[edi + IPv4_Packet.SourceAddress]
	popd	[edi + IPv4_Packet.DestinationAddress]
 
	pop	ecx
 
	IPv4_checksum edi
	add	edi, IPv4_Packet.DataOrOptional
	DEBUGF	1,"IPv4 Packet for device %x created successfully\n", ebx
	ret
 
  .error:
	add	esp, 6
  .arp_error:
	add	esp, 4+4+4+2+2
  .too_large:
	DEBUGF	1,"IPv4_create_packet: Failed\n"
	sub	edi, edi
	ret
 
 
 
 
 
;------------------------------------------------------------------
;
; IPv4_output_raw
;
; IN: eax = socket ptr
;     ecx = data length
;     esi = data ptr
;
; OUT: /
;
;------------------------------------------------------------------
align 4
IPv4_output_raw:
 
	DEBUGF 1,"IPv4_output_raw: size=%u ptr=%x socket=%x\n", ecx, esi, eax
 
	cmp	ecx, 1480		;;;;;
	jg	.too_large
 
	sub	esp, 8
	push	esi eax
 
	call	ARP_IP_to_MAC
 
	test	eax, 0xffff0000 	; error bits
	jnz	.arp_error
 
  .continue:
 
	push	ebx	; push the mac
	push	ax
 
	call	IPv4_dest_to_dev
	inc	[IP_PACKETS_TX+edi]
	mov	ebx, [NET_DRV_LIST+edi]
	lea	eax, [ebx + ETH_DEVICE.mac]
	mov	edx, esp
	mov	ecx, [esp + 6+4]
	add	ecx, IPv4_Packet.DataOrOptional
	mov	di, ETHER_IPv4
	call	ETH_output
	jz	.error
 
	add	esp, 6	; pop the mac
 
	mov	dword[esp+4+4], edx
	mov	dword[esp+4+4+4], eax
 
	pop	eax esi
;; todo: check socket options if we should add header, or just compute checksum
 
	push	edi ecx
	rep	movsb
	pop	ecx edi
 
;        [edi + IPv4_Packet.VersionAndIHL]              ; IPv4, normal length (no Optional header)
;        [edi + IPv4_Packet.TypeOfService]              ; nothing special, just plain ip packet
;        [edi + IPv4_Packet.TotalLength]
;        [edi + IPv4_Packet.TotalLength]                ; internet byte order
;        [edi + IPv4_Packet.FlagsAndFragmentOffset]
 
	mov	[edi + IPv4_Packet.HeaderChecksum], 0
 
;        [edi + IPv4_Packet.TimeToLive]                 ; ttl shl 8 + protocol
;        [edi + IPv4_Packet.Protocol]
;        [edi + IPv4_Packet.Identification]             ; fragment id
;        [edi + IPv4_Packet.SourceAddress]
;        [edi + IPv4_Packet.DestinationAddress]
 
	IPv4_checksum edi			;;;; todo: checksum for IP packet with options!
	add	edi, IPv4_Packet.DataOrOptional
	DEBUGF	1,"IPv4 Packet for device %x created successfully\n", ebx
	call	[ebx + NET_DEVICE.transmit]
	ret
 
  .error:
	add	esp, 6
  .arp_error:
	add	esp, 8+4+4
  .too_large:
	DEBUGF	1,"IPv4_output_raw: Failed\n"
	sub	edi, edi
	ret
 
 
;--------------------------------------------------------
;
;
; IN: dword [esp] = pointer to buffer containing ipv4 packet to be fragmented
;     dword [esp+4] = buffer size
;     esi = pointer to ip header in that buffer
;     ecx = max size of fragments
;
; OUT: /
;
;--------------------------------------------------------
 
align 4
IPv4_fragment:
 
	DEBUGF 1,"IPv4_fragment\n"
 
	and	ecx, not 111b	; align 4
 
	cmp	ecx, IPv4_Packet.DataOrOptional + 8	; must be able to put at least 8 bytes
	jl	.err2
 
	push	esi ecx
	mov	eax, [esi + IPv4_Packet.DestinationAddress]
	call	ARP_IP_to_MAC
	pop	ecx esi
	cmp	eax, -1
	jz	.err2
 
	push	ebx
	push	ax
 
	mov	ebx, [NET_DRV_LIST]
	lea	eax, [ebx + ETH_DEVICE.mac]
	push	eax
 
 
	push	esi		; ptr to ip header
	sub	ecx, 20 	; substract header size
	push	ecx		; max data size
	push	dword 0 	; offset
 
  .new_fragment:
	DEBUGF 1,"Ipv4_fragment - new_fragmentn"
 
 
	mov	eax, [esp + 3*4]
	lea	ebx, [esp + 4*4]
	mov	di , ETHER_IPv4
	call	ETH_output
 
	cmp	edi, -1
	jz	.err
 
; copy header
	mov	esi, [esp + 2*4]
	mov	ecx, 5	; 5 dwords: TODO: use IHL field of the header!
	rep	movsd
 
; copy data
	mov	esi, [esp + 2*4]
	add	esi, 20
	add	esi, [esp]	; offset
 
	mov	ecx, [esp + 1*4]
	DEBUGF 1,"IPv4_fragment - copying data (%u bytes)\n", ecx
	rep	movsb
 
; now, correct header
	mov	ecx, [esp + 1*4]
	add	ecx, 20
	xchg	cl, ch
	mov	[edi + IPv4_Packet.TotalLength], cx
 
	mov	ecx, [esp]		; offset
	xchg	cl, ch
 
;        cmp     dword[esp + 4*4], 0     ; last fragment?;<<<<<<
;        je      .last_fragment
	or	cx, 1 shl 2		; more fragments
;  .last_fragment:
	mov	[edi + IPv4_Packet.FlagsAndFragmentOffset], cx
 
	mov	[edi + IPv4_Packet.HeaderChecksum], 0
 
	;<<<<<<<<<<<<<<<<<<<<<<<<<<<<< send the packet
	mov	ecx, [esp + 1*4]
 
	push	edx eax
	IPv4_checksum edi
 
	call	[ebx + NET_DEVICE.transmit]
	;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
 
	mov	ecx,  [esp+4]
	add	[esp], ecx
 
	mov	ecx, [esp+3*4+6+4]	; ptr to begin of buff
	add	ecx, [esp+3*4+6+4+4]	; buff size
	sub	ecx, [esp+2*4]		; ptr to ip header
	add	ecx, [esp]		; offset
 
	DEBUGF 1,"Ipv4_fragment - bytes remaining: %u\n", ecx
 
	cmp	ecx, [esp+1*4]
	jge	.new_fragment
 
	mov	[esp+4], ecx		; set fragment size to remaining packet size
	jmp	.new_fragment
 
      .err:
	DEBUGF 1,"Ipv4_fragment - failed\n"
      .done:
	add	esp, 12 + 4 + 6
      .err2:
	DEBUGF 1,"Ipv4_fragment - dumping\n"
	call	kernel_free
	add	esp, 4
 
	ret
 
 
 
;---------------------------------------------------------------------------
;
; IPv4_dest_to_dev
;
; IN:  eax = Destination IP
; OUT: edi = device id * 4
;
;---------------------------------------------------------------------------
align 4
IPv4_dest_to_dev:
 
	cmp	eax, 0xffffffff
	je	.invalid
 
	xor	edi, edi
	mov	ecx, MAX_IP
 
  .loop:
	mov	ebx, [IP_LIST+edi]
	and	ebx, [SUBNET_LIST+edi]
	jz	.next
 
	mov	edx, eax
	and	edx, [SUBNET_LIST+edi]
 
	cmp	ebx, edx
	je	.found_it
  .next:
	add	edi, 4
	loop	.loop
 
  .invalid:
	xor	edi, edi			; if none found, use device 0 as default device
 
  .found_it:
	DEBUGF	1,"IPv4_dest_to_dev: %u\n", edi
 
	ret
 
 
 
;---------------------------------------------------------------------------
;
; IPv4_get_frgmnt_num
;
; IN: /
; OUT: fragment number in ax
;
;---------------------------------------------------------------------------
align 4
IPv4_get_frgmnt_num:
	xor	ax, ax	;;; TODO: replace this with real code
 
	ret
 
 
;---------------------------------------------------------------------------
;
; IPv4_API
;
; This function is called by system function 75
;
; IN:  subfunction number in bl
;      device number in bh
;      ecx, edx, .. depends on subfunction
;
; OUT:
;
;---------------------------------------------------------------------------
align 4
IPv4_API:
 
	movzx	eax, bh
	shl	eax, 2
 
	test	bl, bl
	jz	.packets_tx	; 0
	dec	bl
	jz	.packets_rx	; 1
	dec	bl
	jz	.read_ip	; 2
	dec	bl
	jz	.write_ip	; 3
	dec	bl
	jz	.read_dns	; 4
	dec	bl
	jz	.write_dns	; 5
	dec	bl
	jz	.read_subnet	; 6
	dec	bl
	jz	.write_subnet	; 7
	dec	bl
	jz	.read_gateway	; 8
	dec	bl
	jz	.write_gateway	; 9
 
  .error:
	mov	eax, -1
	ret
 
  .packets_tx:
	add	eax, IP_PACKETS_TX
	mov	eax, [eax]
	ret
 
  .packets_rx:
	add	eax, IP_PACKETS_RX
	mov	eax, [eax]
	ret
 
  .read_ip:
	add	eax, IP_LIST
	mov	eax, [eax]
	ret
 
  .write_ip:
	add	eax, IP_LIST
	mov	[eax], ecx
	xor	eax, eax
	ret
 
  .read_dns:
	add	eax, DNS_LIST
	mov	eax, [eax]
	ret
 
  .write_dns:
	add	eax, DNS_LIST
	mov	[eax], ecx
	xor	eax, eax
	ret
 
  .read_subnet:
	add	eax, SUBNET_LIST
	mov	eax, [eax]
	ret
 
  .write_subnet:
	add	eax, SUBNET_LIST
	mov	[eax], ecx
	xor	eax, eax
	ret
 
  .read_gateway:
	add	eax, GATEWAY_LIST
	mov	eax, [eax]
	ret
 
  .write_gateway:
	add	eax, GATEWAY_LIST
	mov	[eax], ecx
	xor	eax, eax
	ret
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
 
>
;>
;>
;>
;>
;>
;>

Rev 1530	Rev 1541
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2010. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2010. 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	;; IPv4.INC ;;	6	;; IPv4.INC ;;
7	;; ;;	7	;; ;;
8	;; Part of the tcp/ip network stack for KolibriOS ;;	8	;; Part of the tcp/ip network stack for KolibriOS ;;
9	;; ;;	9	;; ;;
10	;; Based on the work of [Johnny_B] and [smb] ;;	10	;; Based on the work of [Johnny_B] and [smb] ;;
11	;; ;;	11	;; ;;
12	;; Written by hidnplayr@kolibrios.org ;;	12	;; Written by hidnplayr@kolibrios.org ;;
13	;; ;;	13	;; ;;
14	;; GNU GENERAL PUBLIC LICENSE ;;	14	;; GNU GENERAL PUBLIC LICENSE ;;
15	;; Version 2, June 1991 ;;	15	;; Version 2, June 1991 ;;
16	;; ;;	16	;; ;;
17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18		18
19	$Revision: 1530 $	19	$Revision: 1541 $
20		20
21	MAX_FRAGMENTS equ 64	21	MAX_FRAGMENTS equ 64
22	MAX_IP equ MAX_NET_DEVICES	22	MAX_IP equ MAX_NET_DEVICES
23	IP_MAX_INTERFACES equ MAX_IP	23	IP_MAX_INTERFACES equ MAX_IP
24		24
25	struct IPv4_Packet	25	struct IPv4_Packet
26	.VersionAndIHL db ? ; Version[0-3 bits] and IHL(header length)[4-7 bits]	26	.VersionAndIHL db ? ; Version[0-3 bits] and IHL(header length)[4-7 bits]
27	.TypeOfService db ? ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]	27	.TypeOfService db ? ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]
28	.TotalLength dw ?	28	.TotalLength dw ?
29	.Identification dw ?	29	.Identification dw ?
30	.FlagsAndFragmentOffset dw ? ; Flags[0-2] and FragmentOffset[3-15]	30	.FlagsAndFragmentOffset dw ? ; Flags[0-2] and FragmentOffset[3-15]
31	.TimeToLive db ? ;	31	.TimeToLive db ? ;
32	.Protocol db ?	32	.Protocol db ?
33	.HeaderChecksum dw ?	33	.HeaderChecksum dw ?
34	.SourceAddress dd ?	34	.SourceAddress dd ?
35	.DestinationAddress dd ?	35	.DestinationAddress dd ?
36	.DataOrOptional:	36	.DataOrOptional:
37	ends	37	ends
38		38
39	struct FRAGMENT_slot	39	struct FRAGMENT_slot
40	.ttl dw ? ; Time to live for this entry, 0 for empty slot's	40	.ttl dw ? ; Time to live for this entry, 0 for empty slot's
41	.id dw ? ; Identification field from IP header	41	.id dw ? ; Identification field from IP header
42	.SrcIP dd ? ; .. from IP header	42	.SrcIP dd ? ; .. from IP header
43	.DstIP dd ? ; .. from IP header	43	.DstIP dd ? ; .. from IP header
44	.ptr dd ? ; Pointer to first packet	44	.ptr dd ? ; Pointer to first packet
45	.size:	45	.size:
46	ends	46	ends
47		47
48	struct FRAGMENT_entry ; This structure will replace the ethernet header in fragmented ip packets	48	struct FRAGMENT_entry ; This structure will replace the ethernet header in fragmented ip packets
49	.PrevPtr dd ? ; Pointer to previous fragment entry (-1 for first packet)	49	.PrevPtr dd ? ; Pointer to previous fragment entry (-1 for first packet)
50	.NextPtr dd ? ; Pointer to next fragment entry (-1 for last packet)	50	.NextPtr dd ? ; Pointer to next fragment entry (-1 for last packet)
51	.Owner dd ? ; Pointer to structure of driver	51	.Owner dd ? ; Pointer to structure of driver
52	rb 2 ; to match ethernet header size ; TODO: fix this hack	52	rb 2 ; to match ethernet header size ; TODO: fix this hack
53	.Data: ; Ip header begins here (we will need the IP header to re-construct the complete packet)	53	.Data: ; Ip header begins here (we will need the IP header to re-construct the complete packet)
54	ends	54	ends
55		55
56		56
57	align 4	57	align 4
58	uglobal	58	uglobal
59		59
60	IP_LIST rd MAX_IP	60	IP_LIST rd MAX_IP
61	SUBNET_LIST rd MAX_IP	61	SUBNET_LIST rd MAX_IP
62	DNS_LIST rd MAX_IP	62	DNS_LIST rd MAX_IP
63	GATEWAY_LIST rd MAX_IP	63	GATEWAY_LIST rd MAX_IP
64		64
65	IP_PACKETS_TX rd MAX_IP	65	IP_PACKETS_TX rd MAX_IP
66	IP_PACKETS_RX rd MAX_IP	66	IP_PACKETS_RX rd MAX_IP
67		67
68	FRAGMENT_LIST rb MAX_FRAGMENTS*FRAGMENT_slot.size	68	FRAGMENT_LIST rb MAX_FRAGMENTS*FRAGMENT_slot.size
69	endg	69	endg
70		70
71		71
72	;-----------------------------------------------------------------	72	;-----------------------------------------------------------------
73	;	73	;
74	; IPv4_init	74	; IPv4_init
75	;	75	;
76	; This function resets all IP variables	76	; This function resets all IP variables
77	;	77	;
78	;-----------------------------------------------------------------	78	;-----------------------------------------------------------------
79	macro IPv4_init {	79	macro IPv4_init {
80		80
81	xor eax, eax	81	xor eax, eax
82	mov edi, IP_LIST	82	mov edi, IP_LIST
83	mov ecx, 4*MAX_IP	83	mov ecx, 4*MAX_IP
84	rep stosd	84	rep stosd
85		85
86	mov edi, FRAGMENT_LIST	86	mov edi, FRAGMENT_LIST
87	mov ecx, FRAGMENT_slot.sizeMAX_FRAGMENTS/4 + 2MAX_IP	87	mov ecx, FRAGMENT_slot.sizeMAX_FRAGMENTS/4 + 2MAX_IP
88	rep stosd	88	rep stosd
89		89
90	}	90	}
91		91
92		92
93	;-----------------------------------------------------------------	93	;-----------------------------------------------------------------
94	;	94	;
95	; Decrease TimeToLive of all fragment slots	95	; Decrease TimeToLive of all fragment slots
96	;	96	;
97	;-----------------------------------------------------------------	97	;-----------------------------------------------------------------
98	macro IPv4_decrease_fragment_ttls {	98	macro IPv4_decrease_fragment_ttls {
99		99
100	local .loop	100	local .loop
101		101
102	mov esi, FRAGMENT_LIST	102	mov esi, FRAGMENT_LIST
103	mov ecx, MAX_FRAGMENTS	103	mov ecx, MAX_FRAGMENTS
104	.loop:	104	.loop:
105	cmp [esi + FRAGMENT_slot.ttl], 0	105	cmp [esi + FRAGMENT_slot.ttl], 0
106	je .try_next	106	je .try_next
107	dec [esi + FRAGMENT_slot.ttl]	107	dec [esi + FRAGMENT_slot.ttl]
108	jnz .try_next	108	jnz .try_next
109	DEBUGF 1,"Fragment slot timed-out!\n"	109	DEBUGF 1,"Fragment slot timed-out!\n"
110	;;; TODO: clear all entry's of timed-out slot	110	;;; TODO: clear all entry's of timed-out slot
111	.try_next:	111	.try_next:
112	add esi, 4	112	add esi, 4
113	loop .loop	113	loop .loop
114	}	114	}
115		115
116		116
117		117
118	macro IPv4_checksum ptr {	118	macro IPv4_checksum ptr {
119		119
120	; This is the fast procedure to create or check a IP header without options	120	; This is the fast procedure to create or check a IP header without options
121	; To create a new checksum, the checksum field must be set to 0 before computation	121	; To create a new checksum, the checksum field must be set to 0 before computation
122	; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct	122	; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct
123		123
124	push ebx	124	push ebx
125	xor ebx, ebx	125	xor ebx, ebx
126	add bl, [ptr+1]	126	add bl, [ptr+1]
127	adc bh, [ptr+0]	127	adc bh, [ptr+0]
128		128
129	adc bl, [ptr+3]	129	adc bl, [ptr+3]
130	adc bh, [ptr+2]	130	adc bh, [ptr+2]
131		131
132	adc bl, [ptr+5]	132	adc bl, [ptr+5]
133	adc bh, [ptr+4]	133	adc bh, [ptr+4]
134		134
135	adc bl, [ptr+7]	135	adc bl, [ptr+7]
136	adc bh, [ptr+6]	136	adc bh, [ptr+6]
137		137
138	adc bl, [ptr+9]	138	adc bl, [ptr+9]
139	adc bh, [ptr+8]	139	adc bh, [ptr+8]
140		140
141	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation	141	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation
142		142
143	adc bl, [ptr+13]	143	adc bl, [ptr+13]
144	adc bh, [ptr+12]	144	adc bh, [ptr+12]
145		145
146	adc bl, [ptr+15]	146	adc bl, [ptr+15]
147	adc bh, [ptr+14]	147	adc bh, [ptr+14]
148		148
149	adc bl, [ptr+17]	149	adc bl, [ptr+17]
150	adc bh, [ptr+16]	150	adc bh, [ptr+16]
151		151
152	adc bl, [ptr+19]	152	adc bl, [ptr+19]
153	adc bh, [ptr+18]	153	adc bh, [ptr+18]
154		154
155	adc ebx, 0	155	adc ebx, 0
156		156
157	push ecx	157	push ecx
158	mov ecx, ebx	158	mov ecx, ebx
159	shr ecx, 16	159	shr ecx, 16
160	and ebx, 0xffff	160	and ebx, 0xffff
161	add ebx, ecx	161	add ebx, ecx
162		162
163	mov ecx, ebx	163	mov ecx, ebx
164	shr ecx, 16	164	shr ecx, 16
165	add ebx, ecx	165	add ebx, ecx
166		166
167	not bx	167	not bx
168	jnz .not_zero	168	jnz .not_zero
169	dec bx	169	dec bx
170	.not_zero:	170	.not_zero:
171	xchg bl, bh	171	xchg bl, bh
172	pop ecx	172	pop ecx
173		173
174	neg word [ptr+10] ; zero will stay zero so we just get the checksum	174	neg word [ptr+10] ; zero will stay zero so we just get the checksum
175	add word [ptr+10], bx ; , else we will get (new checksum - old checksum) in the end, wich should be 0 :)	175	add word [ptr+10], bx ; , else we will get (new checksum - old checksum) in the end, wich should be 0 :)
176	pop ebx	176	pop ebx
177		177
178	}	178	}
179		179
180		180
181		181
182	;-----------------------------------------------------------------	182	;-----------------------------------------------------------------
183	;	183	;
184	; IPv4_input:	184	; IPv4_input:
185	;	185	;
186	; Will check if IP Packet isnt damaged	186	; Will check if IP Packet isnt damaged
187	; and call appropriate handler. (TCP/UDP/ICMP/..)	187	; and call appropriate handler. (TCP/UDP/ICMP/..)
188	;	188	;
189	; It will also re-construct fragmented packets	189	; It will also re-construct fragmented packets
190	;	190	;
191	; IN: Pointer to buffer in [esp]	191	; IN: Pointer to buffer in [esp]
192	; size of buffer in [esp+4]	192	; size of buffer in [esp+4]
193	; pointer to device struct in ebx	193	; pointer to device struct in ebx
194	; pointer to IP Packet data in edx	194	; pointer to IP Packet data in edx
195	; OUT: /	195	; OUT: /
196	;	196	;
197	;-----------------------------------------------------------------	197	;-----------------------------------------------------------------
198	align 4	198	align 4
199	IPv4_input: ; TODO: implement handler for IP options	199	IPv4_input: ; TODO: implement handler for IP options
200	; TODO2: add code for raw sockets	200	; TODO2: add code for raw sockets
201		201
202	DEBUGF 1,"IPv4_Handler, packet from: %u.%u.%u.%u ",\	202	DEBUGF 1,"IPv4_Handler, packet from: %u.%u.%u.%u ",\
203	[edx + IPv4_Packet.SourceAddress]:1,[edx + IPv4_Packet.SourceAddress + 1]:1,[edx + IPv4_Packet.SourceAddress + 2]:1,[edx + IPv4_Packet.SourceAddress + 3]:1	203	[edx + IPv4_Packet.SourceAddress]:1,[edx + IPv4_Packet.SourceAddress + 1]:1,[edx + IPv4_Packet.SourceAddress + 2]:1,[edx + IPv4_Packet.SourceAddress + 3]:1
204	DEBUGF 1,"to: %u.%u.%u.%u\n",\	204	DEBUGF 1,"to: %u.%u.%u.%u\n",\
205	[edx + IPv4_Packet.DestinationAddress]:1,[edx + IPv4_Packet.DestinationAddress + 1]:1,[edx + IPv4_Packet.DestinationAddress + 2]:1,[edx + IPv4_Packet.DestinationAddress + 3]:1	205	[edx + IPv4_Packet.DestinationAddress]:1,[edx + IPv4_Packet.DestinationAddress + 1]:1,[edx + IPv4_Packet.DestinationAddress + 2]:1,[edx + IPv4_Packet.DestinationAddress + 3]:1
206		206
207	;-------------------------------------------	207	;-------------------------------------------
208	; Check if the packet still has time to live	208	; Check if the packet still has time to live
209		209
210	cmp byte [edx + IPv4_Packet.TimeToLive], 0	210	cmp byte [edx + IPv4_Packet.TimeToLive], 0
211	je .dump	211	je .dump
212		212
213	;--------------------------------------	213	;--------------------------------------
214	; First, check if IP packet has options	214	; First, check if IP packet has options
215		215
216	movzx eax, [edx + IPv4_Packet.VersionAndIHL]	216	movzx eax, [edx + IPv4_Packet.VersionAndIHL]
217	and al , 0x0f ; get IHL(header length)	217	and al , 0x0f ; get IHL(header length)
218	cmp al , 0x05 ; IHL!= 5*4(20 bytes)	218	cmp al , 0x05 ; IHL!= 5*4(20 bytes)
219	jnz .has_options	219	jnz .has_options
220		220
221	;-------------------------------	221	;-------------------------------
222	; Now, re-calculate the checksum	222	; Now, re-calculate the checksum
223		223
224	IPv4_checksum edx	224	IPv4_checksum edx
225	jnz .dump ; if checksum isn't valid then dump packet	225	jnz .dump ; if checksum isn't valid then dump packet
226		226
227	DEBUGF 1,"IPv4 Checksum is correct\n"	227	DEBUGF 1,"IPv4 Checksum is correct\n"
228		228
229	;-----------------------------------	229	;-----------------------------------
230	; Check if destination IP is correct	230	; Check if destination IP is correct
231		231
232	call NET_ptr_to_num	232	call NET_ptr_to_num
233	shl edi, 2	233	shl edi, 2
234		234
235	; check if it matches local ip	235	; check if it matches local ip
236		236
237	mov eax, dword[IP_LIST+edi]	237	mov eax, dword[IP_LIST+edi]
238	cmp [edx + IPv4_Packet.DestinationAddress], eax	238	cmp [edx + IPv4_Packet.DestinationAddress], eax
239	je .ip_ok	239	je .ip_ok
240		240
241	; check for broadcast	241	; check for broadcast
242		242
243	mov eax, dword[SUBNET_LIST+edi]	243	mov eax, dword[SUBNET_LIST+edi]
244	not eax	244	not eax
245	or eax, dword[IP_LIST+edi]	245	or eax, dword[IP_LIST+edi]
246	cmp [edx + IPv4_Packet.DestinationAddress], eax	246	cmp [edx + IPv4_Packet.DestinationAddress], eax
247	je .ip_ok	247	je .ip_ok
248		248
249	; or a special broadcast	249	; or a special broadcast
250		250
251	cmp [edx + IPv4_Packet.DestinationAddress], -1	251	cmp [edx + IPv4_Packet.DestinationAddress], -1
252	je .ip_ok	252	je .ip_ok
253		253
254	; maybe it's a multicast then	254	; maybe it's a multicast then
255		255
256	mov eax, [edx + IPv4_Packet.DestinationAddress]	256	mov eax, [edx + IPv4_Packet.DestinationAddress]
257	and eax, 0xff000000	257	and eax, 0xff000000
258	; cmp eax, 224 shl 24	258	; cmp eax, 224 shl 24
259	; je .ip_ok	259	; je .ip_ok
260		260
261	; or a loopback address	261	; or a loopback address
262		262
263	cmp eax, 127 shl 24	263	cmp eax, 127 shl 24
264	je .ip_ok	264	je .ip_ok
265		265
266	; or it's not meant for us..	266	; or it's not meant for us..
267		267
268	DEBUGF 2,"Destination address does not match!\n"	268	DEBUGF 2,"Destination address does not match!\n"
269	jmp .dump	269	jmp .dump
270		270
271	;------------------------	271	;------------------------
272	; Now we can update stats	272	; Now we can update stats
273		273
274	.ip_ok:	274	.ip_ok:
275	inc [IP_PACKETS_RX+edi]	275	inc [IP_PACKETS_RX+edi]
276		276
277	;----------------------------------	277	;----------------------------------
278	; Check if the packet is fragmented	278	; Check if the packet is fragmented
279		279
280	test [edx + IPv4_Packet.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?	280	test [edx + IPv4_Packet.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?
281	jnz .has_fragments ; If so, we definately have a fragmented packet	281	jnz .has_fragments ; If so, we definately have a fragmented packet
282		282
283	test [edx + IPv4_Packet.FlagsAndFragmentOffset], 0xff1f ; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets	283	test [edx + IPv4_Packet.FlagsAndFragmentOffset], 0xff1f ; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets
284	jnz .is_last_fragment	284	jnz .is_last_fragment
285		285
286	;-------------------------------------------------------------------	286	;-------------------------------------------------------------------
287	; No, it's just a regular IP packet, pass it to the higher protocols	287	; No, it's just a regular IP packet, pass it to the higher protocols
288		288
289	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed	289	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed
290	movzx eax, byte [edx + IPv4_Packet.VersionAndIHL] ; Calculate Header length by using IHL field	290	movzx eax, byte [edx + IPv4_Packet.VersionAndIHL] ; Calculate Header length by using IHL field
291	and eax, 0x0000000f ;	291	and eax, 0x0000000f ;
292	shl eax, 2 ;	292	shl eax, 2 ;
293	movzx ecx, word [edx + IPv4_Packet.TotalLength] ; Calculate length of encapsulated Packet	293	movzx ecx, word [edx + IPv4_Packet.TotalLength] ; Calculate length of encapsulated Packet
294	xchg cl , ch ;	294	xchg cl , ch ;
295	sub ecx, eax ;	295	sub ecx, eax ;
296		296
297	add eax, edx	297	add eax, edx
298	push eax	298	push eax
299		299
300	mov esi, [edx + IPv4_Packet.SourceAddress] ; These values might be of interest to the higher protocols	300	mov esi, [edx + IPv4_Packet.SourceAddress] ; These values might be of interest to the higher protocols
301	mov edi, [edx + IPv4_Packet.DestinationAddress] ;	301	mov edi, [edx + IPv4_Packet.DestinationAddress] ;
302	mov al , [edx + IPv4_Packet.Protocol]	302	mov al , [edx + IPv4_Packet.Protocol]
303	pop edx ; Offset to data (tcp/udp/icmp/.. Packet)	303	pop edx ; Offset to data (tcp/udp/icmp/.. Packet)
304		304
305	cmp al , IP_PROTO_TCP	305	cmp al , IP_PROTO_TCP
306	je TCP_input	306	je TCP_input
307		307
308	cmp al , IP_PROTO_UDP	308	cmp al , IP_PROTO_UDP
309	je UDP_input	309	je UDP_input
310		310
311	cmp al , IP_PROTO_ICMP	311	cmp al , IP_PROTO_ICMP
312	je ICMP_input	312	je ICMP_input
313		313
314	DEBUGF 2,"unknown Internet protocol: %u\n", al	314	DEBUGF 2,"unknown Internet protocol: %u\n", al
315		315
316	.dump:	316	.dump:
317	DEBUGF 2,"IP_Handler - dumping\n"	317	DEBUGF 2,"IP_Handler - dumping\n"
318	; inc [dumped_rx_count]	318	; inc [dumped_rx_count]
319	call kernel_free	319	call kernel_free
320	add esp, 4 ; pop (balance stack)	320	add esp, 4 ; pop (balance stack)
321	ret	321	ret
322		322
323		323
324	;---------------------------	324	;---------------------------
325	; Fragmented packet handler	325	; Fragmented packet handler
326		326
327		327
328	.has_fragments:	328	.has_fragments:
329	movzx eax, [edx + IPv4_Packet.FlagsAndFragmentOffset]	329	movzx eax, [edx + IPv4_Packet.FlagsAndFragmentOffset]
330	xchg al , ah	330	xchg al , ah
331	shl ax , 3	331	shl ax , 3
332		332
333	DEBUGF 1,"Fragmented packet, offset:%u, id:%x\n", ax, [edx + IPv4_Packet.Identification]:4	333	DEBUGF 1,"Fragmented packet, offset:%u, id:%x\n", ax, [edx + IPv4_Packet.Identification]:4
334		334
335	test ax , ax ; Is this the first packet of the fragment?	335	test ax , ax ; Is this the first packet of the fragment?
336	jz .is_first_fragment	336	jz .is_first_fragment
337		337
338		338
339	;-------------------------------------------------------	339	;-------------------------------------------------------
340	; We have a fragmented IP packet, but it's not the first	340	; We have a fragmented IP packet, but it's not the first
341		341
342	DEBUGF 1,"Middle fragmented packet received!\n"	342	DEBUGF 1,"Middle fragmented packet received!\n"
343		343
344	call IPv4_find_fragment_slot	344	call IPv4_find_fragment_slot
345	cmp esi, -1	345	cmp esi, -1
346	je .dump	346	je .dump
347		347
348	mov word [esi + FRAGMENT_slot.ttl], 15 ; Reset the ttl	348	mov word [esi + FRAGMENT_slot.ttl], 15 ; Reset the ttl
349	mov esi, [esi + FRAGMENT_slot.ptr]	349	mov esi, [esi + FRAGMENT_slot.ptr]
350	or edi, -1	350	or edi, -1
351	.find_last_entry: ; The following routine will try to find the last entry	351	.find_last_entry: ; The following routine will try to find the last entry
352	cmp edi, [esi + FRAGMENT_entry.PrevPtr]	352	cmp edi, [esi + FRAGMENT_entry.PrevPtr]
353	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	353	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
354	mov edi, esi	354	mov edi, esi
355	mov esi, [esi + FRAGMENT_entry.NextPtr]	355	mov esi, [esi + FRAGMENT_entry.NextPtr]
356	cmp esi, -1	356	cmp esi, -1
357	jne .find_last_entry	357	jne .find_last_entry
358	; We found the last entry (pointer is now in edi)	358	; We found the last entry (pointer is now in edi)
359	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure	359	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
360		360
361	pop eax ; pointer to packet	361	pop eax ; pointer to packet
362	mov [edi + FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry	362	mov [edi + FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry
363	mov [eax + FRAGMENT_entry.NextPtr], -1	363	mov [eax + FRAGMENT_entry.NextPtr], -1
364	mov [eax + FRAGMENT_entry.PrevPtr], edi	364	mov [eax + FRAGMENT_entry.PrevPtr], edi
365	mov [eax + FRAGMENT_entry.Owner], ebx	365	mov [eax + FRAGMENT_entry.Owner], ebx
366		366
367	add esp, 4	367	add esp, 4
368	ret	368	ret
369		369
370		370
371	;------------------------------------	371	;------------------------------------
372	; We have received the first fragment	372	; We have received the first fragment
373		373
374	.is_first_fragment:	374	.is_first_fragment:
375	DEBUGF 1,"First fragmented packet received!\n"	375	DEBUGF 1,"First fragmented packet received!\n"
376	; try to locate a free slot..	376	; try to locate a free slot..
377	mov ecx, MAX_FRAGMENTS	377	mov ecx, MAX_FRAGMENTS
378	mov esi, FRAGMENT_LIST	378	mov esi, FRAGMENT_LIST
379	.find_free_slot:	379	.find_free_slot:
380	cmp word [esi + FRAGMENT_slot.ttl], 0	380	cmp word [esi + FRAGMENT_slot.ttl], 0
381	je .found_free_slot	381	je .found_free_slot
382	add esi, FRAGMENT_slot.size	382	add esi, FRAGMENT_slot.size
383	loop .find_free_slot	383	loop .find_free_slot
384	jmp .dump ; If no free slot was found, dump the packet	384	jmp .dump ; If no free slot was found, dump the packet
385		385
386	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure	386	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure
387	mov word [esi + FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl	387	mov word [esi + FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl
388	mov ax , word [edx + IPv4_Packet.Identification]	388	mov ax , word [edx + IPv4_Packet.Identification]
389	mov word [esi + FRAGMENT_slot.id], ax	389	mov word [esi + FRAGMENT_slot.id], ax
390	mov eax, dword [edx + IPv4_Packet.SourceAddress]	390	mov eax, dword [edx + IPv4_Packet.SourceAddress]
391	mov dword [esi + FRAGMENT_slot.SrcIP], eax	391	mov dword [esi + FRAGMENT_slot.SrcIP], eax
392	mov eax, dword [edx + IPv4_Packet.DestinationAddress]	392	mov eax, dword [edx + IPv4_Packet.DestinationAddress]
393	mov dword [esi + FRAGMENT_slot.DstIP], eax	393	mov dword [esi + FRAGMENT_slot.DstIP], eax
394	pop eax	394	pop eax
395	mov dword [esi + FRAGMENT_slot.ptr], eax	395	mov dword [esi + FRAGMENT_slot.ptr], eax
396	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure	396	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
397	mov [eax + FRAGMENT_entry.NextPtr], -1	397	mov [eax + FRAGMENT_entry.NextPtr], -1
398	mov [eax + FRAGMENT_entry.PrevPtr], -1	398	mov [eax + FRAGMENT_entry.PrevPtr], -1
399	mov [eax + FRAGMENT_entry.Owner], ebx	399	mov [eax + FRAGMENT_entry.Owner], ebx
400		400
401	add esp, 4 ; balance stack and exit	401	add esp, 4 ; balance stack and exit
402	ret	402	ret
403		403
404		404
405	;-----------------------------------	405	;-----------------------------------
406	; We have received the last fragment	406	; We have received the last fragment
407		407
408	.is_last_fragment:	408	.is_last_fragment:
409	DEBUGF 1,"Last fragmented packet received!\n"	409	DEBUGF 1,"Last fragmented packet received!\n"
410		410
411	call IPv4_find_fragment_slot	411	call IPv4_find_fragment_slot
412	cmp esi, -1	412	cmp esi, -1
413	je .dump	413	je .dump
414		414
415	mov esi, [esi + FRAGMENT_slot.ptr] ; We found the first entry, let's calculate total size of the packet in eax, so we can allocate a buffer	415	mov esi, [esi + FRAGMENT_slot.ptr] ; We found the first entry, let's calculate total size of the packet in eax, so we can allocate a buffer
416	push esi	416	push esi
417	xor eax, eax	417	xor eax, eax
418	or edi, -1	418	or edi, -1
419		419
420	.count_bytes:	420	.count_bytes:
421	cmp [esi + FRAGMENT_entry.PrevPtr], edi	421	cmp [esi + FRAGMENT_entry.PrevPtr], edi
422	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)	422	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
423	mov cx, word [esi + FRAGMENT_entry.Data + IPv4_Packet.TotalLength] ; Add total length	423	mov cx, word [esi + FRAGMENT_entry.Data + IPv4_Packet.TotalLength] ; Add total length
424	xchg cl, ch	424	xchg cl, ch
425	DEBUGF 1,"Packet size: %u\n", cx	425	DEBUGF 1,"Packet size: %u\n", cx
426	add ax, cx	426	add ax, cx
427	movzx cx, byte [esi + FRAGMENT_entry.Data + IPv4_Packet.VersionAndIHL] ; Sub Header length	427	movzx cx, byte [esi + FRAGMENT_entry.Data + IPv4_Packet.VersionAndIHL] ; Sub Header length
428	and cx, 0x000F	428	and cx, 0x000F
429	shl cx, 2	429	shl cx, 2
430	DEBUGF 1,"Header size: %u\n", cx	430	DEBUGF 1,"Header size: %u\n", cx
431	sub ax, cx	431	sub ax, cx
432	mov edi, esi	432	mov edi, esi
433	mov esi, [esi + FRAGMENT_entry.NextPtr]	433	mov esi, [esi + FRAGMENT_entry.NextPtr]
434	cmp esi, -1	434	cmp esi, -1
435	jne .count_bytes	435	jne .count_bytes
436		436
437	mov esi, [esp+4]	437	mov esi, [esp+4]
438	mov [edi + FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code	438	mov [edi + FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code
439	mov [esi + FRAGMENT_entry.NextPtr], -1	439	mov [esi + FRAGMENT_entry.NextPtr], -1
440	mov [esi + FRAGMENT_entry.PrevPtr], edi	440	mov [esi + FRAGMENT_entry.PrevPtr], edi
441	mov [esi + FRAGMENT_entry.Owner], ebx	441	mov [esi + FRAGMENT_entry.Owner], ebx
442		442
443	mov cx, [edx + IPv4_Packet.TotalLength] ; Note: This time we dont substract Header length	443	mov cx, [edx + IPv4_Packet.TotalLength] ; Note: This time we dont substract Header length
444	xchg cl , ch	444	xchg cl , ch
445	DEBUGF 1,"Packet size: %u\n", cx	445	DEBUGF 1,"Packet size: %u\n", cx
446	add ax , cx	446	add ax , cx
447	DEBUGF 1,"Total Received data size: %u\n", eax	447	DEBUGF 1,"Total Received data size: %u\n", eax
448		448
449	push eax	449	push eax
450	mov ax , [edx + IPv4_Packet.FlagsAndFragmentOffset]	450	mov ax , [edx + IPv4_Packet.FlagsAndFragmentOffset]
451	xchg al , ah	451	xchg al , ah
452	shl ax , 3	452	shl ax , 3
453	add cx , ax	453	add cx , ax
454	pop eax	454	pop eax
455	DEBUGF 1,"Total Fragment size: %u\n", ecx	455	DEBUGF 1,"Total Fragment size: %u\n", ecx
456		456
457	cmp ax, cx	457	cmp ax, cx
458	jne .destroy_slot_pop	458	jne .destroy_slot_pop
459		459
460	push eax	460	push eax
461	push eax	461	push eax
462	call kernel_alloc	462	call kernel_alloc
463	test eax, eax	463	test eax, eax
464	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot	464	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot
465	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx	465	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx
466		466
467	.rebuild_packet_loop:	467	.rebuild_packet_loop:
468	movzx ecx, word [edx + FRAGMENT_entry.Data + IPv4_Packet.FlagsAndFragmentOffset] ; Calculate the fragment offset	468	movzx ecx, word [edx + FRAGMENT_entry.Data + IPv4_Packet.FlagsAndFragmentOffset] ; Calculate the fragment offset
469	xchg cl , ch ; intel byte order	469	xchg cl , ch ; intel byte order
470	shl cx , 3 ; multiply by 8 and clear first 3 bits	470	shl cx , 3 ; multiply by 8 and clear first 3 bits
471	DEBUGF 1,"Fragment offset: %u\n", cx	471	DEBUGF 1,"Fragment offset: %u\n", cx
472		472
473	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment	473	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment
474	movzx ebx, byte [edx + FRAGMENT_entry.Data + IPv4_Packet.VersionAndIHL] ; Find header size (in ebx) of fragment	474	movzx ebx, byte [edx + FRAGMENT_entry.Data + IPv4_Packet.VersionAndIHL] ; Find header size (in ebx) of fragment
475	and bx , 0x000F ;	475	and bx , 0x000F ;
476	shl bx , 2 ;	476	shl bx , 2 ;
477		477
478	lea esi, [edx + FRAGMENT_entry.Data] ; Set esi to the correct begin of fragment	478	lea esi, [edx + FRAGMENT_entry.Data] ; Set esi to the correct begin of fragment
479	movzx ecx, word [edx + FRAGMENT_entry.Data + IPv4_Packet.TotalLength] ; Calculate total length of fragment	479	movzx ecx, word [edx + FRAGMENT_entry.Data + IPv4_Packet.TotalLength] ; Calculate total length of fragment
480	xchg cl, ch ; intel byte order	480	xchg cl, ch ; intel byte order
481		481
482	cmp edi, eax ; Is this packet the first fragment ?	482	cmp edi, eax ; Is this packet the first fragment ?
483	je .first_fragment	483	je .first_fragment
484	sub cx, bx ; If not, dont copy the header	484	sub cx, bx ; If not, dont copy the header
485	add esi, ebx ;	485	add esi, ebx ;
486	.first_fragment:	486	.first_fragment:
487		487
488	push cx ; First copy dword-wise, then byte-wise	488	push cx ; First copy dword-wise, then byte-wise
489	shr cx, 2 ;	489	shr cx, 2 ;
490	rep movsd ;	490	rep movsd ;
491	pop cx ;	491	pop cx ;
492	and cx, 3 ;	492	and cx, 3 ;
493	rep movsb ;	493	rep movsb ;
494		494
495	push eax	495	push eax
496	push edx ; Push pointer to fragment onto stack	496	push edx ; Push pointer to fragment onto stack
497	mov ebx, [edx + FRAGMENT_entry.Owner] ; we need to remeber the owner, in case this is the last packet	497	mov ebx, [edx + FRAGMENT_entry.Owner] ; we need to remeber the owner, in case this is the last packet
498	mov edx, [edx + FRAGMENT_entry.NextPtr] ; Set edx to the next pointer	498	mov edx, [edx + FRAGMENT_entry.NextPtr] ; Set edx to the next pointer
499	call kernel_free ; free the previous fragment buffer (this uses the value from stack)	499	call kernel_free ; free the previous fragment buffer (this uses the value from stack)
500	pop eax	500	pop eax

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/IPv4.inc – Rev 1530 → 1541