WebSVN – Kolibri OS – Blame – /kernel/trunk/network/IPv4.inc

Rev	Author	Line No.	Line
3545	hidnplayr	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		2	;; ;;
		3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
		4	;; Distributed under terms of the GNU General Public License ;;
		5	;; ;;
		6	;; IPv4.INC ;;
		7	;; ;;
		8	;; Part of the TCP/IP network stack for KolibriOS ;;
		9	;; ;;
		10	;; Based on the work of [Johnny_B] and [smb] ;;
		11	;; ;;
		12	;; Written by hidnplayr@kolibrios.org ;;
		13	;; ;;
		14	;; GNU GENERAL PUBLIC LICENSE ;;
		15	;; Version 2, June 1991 ;;
		16	;; ;;
		17	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
		18
		19	$Revision: 3515 $
		20
		21	MAX_FRAGMENTS = 64
		22
		23	struct IPv4_header
		24
		25	VersionAndIHL db ? ; Version[0-3 bits] and IHL(header length)[4-7 bits]
		26	TypeOfService db ? ; precedence [7-5] minimize delay [4], maximize throughput [3], maximize riliability [2] minimize momentary cost [1] and zero [0]
		27	TotalLength dw ?
		28	Identification dw ?
		29	FlagsAndFragmentOffset dw ? ; Flags[0-2] and FragmentOffset[3-15]
		30	TimeToLive db ? ;
		31	Protocol db ?
		32	HeaderChecksum dw ?
		33	SourceAddress dd ?
		34	DestinationAddress dd ?
		35
		36	ends
		37
		38	struct FRAGMENT_slot
		39
		40	ttl dw ? ; Time to live for this entry, 0 for empty slot's
		41	id dw ? ; Identification field from IP header
		42	SrcIP dd ? ; .. from IP header
		43	DstIP dd ? ; .. from IP header
		44	ptr dd ? ; Pointer to first packet
		45
		46	ends
		47
		48	struct FRAGMENT_entry ; This structure will replace the ethernet header in fragmented ip packets
		49
		50	PrevPtr dd ? ; Pointer to previous fragment entry (-1 for first packet)
		51	NextPtr dd ? ; Pointer to next fragment entry (-1 for last packet)
		52	Owner dd ? ; Pointer to structure of driver
		53	rb 2 ; to match ethernet header size ;;; FIXME
		54	; Ip header begins here (we will need the IP header to re-construct the complete packet)
		55	ends
		56
		57
		58	align 4
		59	uglobal
		60
3600	hidnplayr	61	IP_LIST rd NET_DEVICES_MAX
		62	SUBNET_LIST rd NET_DEVICES_MAX
		63	DNS_LIST rd NET_DEVICES_MAX
		64	GATEWAY_LIST rd NET_DEVICES_MAX
		65	BROADCAST_LIST rd NET_DEVICES_MAX
3545	hidnplayr	66
3600	hidnplayr	67	IP_packets_tx rd NET_DEVICES_MAX
		68	IP_packets_rx rd NET_DEVICES_MAX
		69	IP_packets_dumped rd NET_DEVICES_MAX
3545	hidnplayr	70
3600	hidnplayr	71	FRAGMENT_LIST rb MAX_FRAGMENTS * sizeof.FRAGMENT_slot
3545	hidnplayr	72	endg
		73
		74
		75	;-----------------------------------------------------------------
		76	;
		77	; IPv4_init
		78	;
		79	; This function resets all IP variables
		80	;
		81	;-----------------------------------------------------------------
		82	macro IPv4_init {
		83
		84	xor eax, eax
		85	mov edi, IP_LIST
3600	hidnplayr	86	mov ecx, 7NET_DEVICES_MAX + (sizeof.FRAGMENT_slotMAX_FRAGMENTS)/4
3545	hidnplayr	87	rep stosd
		88
		89	}
		90
		91
		92	;-----------------------------------------------------------------
		93	;
		94	; Decrease TimeToLive of all fragment slots
		95	;
		96	;-----------------------------------------------------------------
		97	macro IPv4_decrease_fragment_ttls {
		98
		99	local .loop, .next
		100
		101	mov esi, FRAGMENT_LIST
		102	mov ecx, MAX_FRAGMENTS
		103	.loop:
		104	cmp [esi + FRAGMENT_slot.ttl], 0
		105	je .next
		106	dec [esi + FRAGMENT_slot.ttl]
		107	jz .died
		108	.next:
		109	add esi, sizeof.FRAGMENT_slot
		110	dec ecx
		111	jnz .loop
		112	jmp .done
		113
		114	.died:
3556	hidnplayr	115	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4 Fragment slot timed-out!\n"
3545	hidnplayr	116	;;; TODO: clear all entry's of timed-out slot
		117	jmp .next
		118
		119	.done:
		120	}
		121
		122
		123
		124	macro IPv4_checksum ptr {
		125
		126	; This is the fast procedure to create or check an IP header without options
		127	; To create a new checksum, the checksum field must be set to 0 before computation
		128	; To check an existing checksum, leave the checksum as is, and it will be 0 after this procedure, if it was correct
		129
		130	push ebx
		131	xor ebx, ebx
		132	add bl, [ptr+1]
		133	adc bh, [ptr+0]
		134
		135	adc bl, [ptr+3]
		136	adc bh, [ptr+2]
		137
		138	adc bl, [ptr+5]
		139	adc bh, [ptr+4]
		140
		141	adc bl, [ptr+7]
		142	adc bh, [ptr+6]
		143
		144	adc bl, [ptr+9]
		145	adc bh, [ptr+8]
		146
		147	; we skip 11th and 12th byte, they are the checksum bytes and should be 0 for re-calculation
		148
		149	adc bl, [ptr+13]
		150	adc bh, [ptr+12]
		151
		152	adc bl, [ptr+15]
		153	adc bh, [ptr+14]
		154
		155	adc bl, [ptr+17]
		156	adc bh, [ptr+16]
		157
		158	adc bl, [ptr+19]
		159	adc bh, [ptr+18]
		160
		161	adc ebx, 0
		162
		163	push ecx
		164	mov ecx, ebx
		165	shr ecx, 16
		166	and ebx, 0xffff
		167	add ebx, ecx
		168
		169	mov ecx, ebx
		170	shr ecx, 16
		171	add ebx, ecx
		172
		173	not bx
		174	jnz .not_zero
		175	dec bx
		176	.not_zero:
		177	xchg bl, bh
		178	pop ecx
		179
		180	neg word [ptr+10] ; zero will stay zero so we just get the checksum
		181	add word [ptr+10], bx ; , else we will get (new checksum - old checksum) in the end, wich should be 0 :)
		182	pop ebx
		183
		184	}
		185
		186
		187
		188	;-----------------------------------------------------------------
		189	;
		190	; IPv4_input:
		191	;
		192	; Will check if IPv4 Packet isnt damaged
		193	; and call appropriate handler. (TCP/UDP/ICMP/..)
		194	;
		195	; It will also re-construct fragmented packets
		196	;
		197	; IN: Pointer to buffer in [esp]
		198	; size of buffer in [esp+4]
		199	; pointer to device struct in ebx
		200	; pointer to IPv4 header in edx
		201	; size of IPv4 packet in ecx
		202	; OUT: /
		203	;
		204	;-----------------------------------------------------------------
		205	align 4
		206	IPv4_input: ; TODO: add IPv4 raw sockets support
		207
3556	hidnplayr	208	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input, packet from: %u.%u.%u.%u ",\
3545	hidnplayr	209	[edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\
		210	[edx + IPv4_header.SourceAddress + 2]:1,[edx + IPv4_header.SourceAddress + 3]:1
3556	hidnplayr	211	DEBUGF DEBUG_NETWORK_VERBOSE, "to: %u.%u.%u.%u\n",\
3545	hidnplayr	212	[edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\
		213	[edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1
		214
		215	;-------------------------------
		216	; re-calculate the checksum
		217
		218	IPv4_checksum edx
		219	jnz .dump ; if checksum isn't valid then dump packet
		220
3556	hidnplayr	221	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n"
3545	hidnplayr	222
		223	;-----------------------------------
		224	; Check if destination IP is correct
		225
		226	call NET_ptr_to_num
		227	shl edi, 2
		228
		229	; check if it matches local ip (Using RFC1122 strong end system model)
		230
		231	mov eax, [edx + IPv4_header.DestinationAddress]
		232	cmp eax, [IP_LIST + edi]
		233	je .ip_ok
		234
		235	; check for broadcast (IP or (not SUBNET))
		236
		237	cmp eax, [BROADCAST_LIST + edi]
		238	je .ip_ok
		239
		240	; or a special broadcast (255.255.255.255)
		241
		242	cmp eax, 0xffffffff
		243	je .ip_ok
		244
		245	; maybe it's a multicast (224.0.0.0/4)
		246
		247	and eax, 0x0fffffff
		248	cmp eax, 224
		249	je .ip_ok
		250
		251	; or a loopback address (127.0.0.0/8)
		252
		253	and eax, 0x00ffffff
		254	cmp eax, 127
		255	je .ip_ok
		256
		257	; or it's just not meant for us.. :(
		258
3556	hidnplayr	259	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Destination address does not match!\n"
3545	hidnplayr	260	jmp .dump
		261
		262	;------------------------
		263	; Now we can update stats
		264
		265	.ip_ok:
		266	inc [IP_packets_rx + edi]
		267
		268	;----------------------------------
		269	; Check if the packet is fragmented
		270
		271	test [edx + IPv4_header.FlagsAndFragmentOffset], 1 shl 5 ; Is 'more fragments' flag set ?
		272	jnz .has_fragments ; If so, we definately have a fragmented packet
		273
		274	test [edx + IPv4_header.FlagsAndFragmentOffset], 0xff1f ; If flag is not set, but there is a fragment offset, the packet is last in series of fragmented packets
		275	jnz .is_last_fragment
		276
		277	;-------------------------------------------------------------------
		278	; No, it's just a regular IP packet, pass it to the higher protocols
		279
		280	.handle_it: ; We reach here if packet hasnt been fragmented, or when it already has been re-constructed
		281
		282	movzx esi, [edx + IPv4_header.VersionAndIHL] ; Calculate Header length by using IHL field
		283	and esi, 0x0000000f ;
		284	shl esi, 2 ;
		285
		286	movzx ecx, [edx + IPv4_header.TotalLength] ; Calculate length of encapsulated Packet
		287	xchg cl, ch ;
		288	sub ecx, esi ;
		289
		290	lea edi, [edx + IPv4_header.SourceAddress] ; make edi ptr to source and dest IPv4 address
		291	mov al, [edx + IPv4_header.Protocol]
		292	add esi, edx ; make esi ptr to data
		293
		294	cmp al, IP_PROTO_TCP
		295	je TCP_input
		296
		297	cmp al, IP_PROTO_UDP
		298	je UDP_input
		299
		300	cmp al, IP_PROTO_ICMP
		301	je ICMP_input
		302
3556	hidnplayr	303	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: unknown protocol %u\n", al
3545	hidnplayr	304
		305	.dump:
3556	hidnplayr	306	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n"
3545	hidnplayr	307	inc [IP_packets_dumped] ; FIXME: use correct interface
		308	call kernel_free
		309	add esp, 4 ; pop (balance stack)
		310	ret
		311
		312
		313	;---------------------------
		314	; Fragmented packet handler
		315
		316
		317	.has_fragments:
		318	movzx eax, [edx + IPv4_header.FlagsAndFragmentOffset]
		319	xchg al, ah
		320	shl ax, 3
		321
3556	hidnplayr	322	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: fragmented packet offset=%u id=%x\n", ax, [edx + IPv4_header.Identification]:4
3545	hidnplayr	323
		324	test ax, ax ; Is this the first packet of the fragment?
		325	jz .is_first_fragment
		326
		327
		328	;-------------------------------------------------------
		329	; We have a fragmented IP packet, but it's not the first
		330
3556	hidnplayr	331	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n"
3545	hidnplayr	332
		333	call IPv4_find_fragment_slot
		334	cmp esi, -1
		335	je .dump
		336
		337	mov [esi + FRAGMENT_slot.ttl], 15 ; Reset the ttl
		338	mov esi, [esi + FRAGMENT_slot.ptr]
		339	or edi, -1
		340	.find_last_entry: ; The following routine will try to find the last entry
		341	cmp edi, [esi + FRAGMENT_entry.PrevPtr]
		342	jne .destroy_slot ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
		343	mov edi, esi
		344	mov esi, [esi + FRAGMENT_entry.NextPtr]
		345	cmp esi, -1
		346	jne .find_last_entry
		347	; We found the last entry (pointer is now in edi)
		348	; We are going to overwrite the ethernet header in received packet with a FRAGMENT_entry structure
		349
		350	pop eax ; pointer to packet
		351	mov [edi + FRAGMENT_entry.NextPtr], eax ; update pointer of previous entry to the new entry
		352	mov [eax + FRAGMENT_entry.NextPtr], -1
		353	mov [eax + FRAGMENT_entry.PrevPtr], edi
		354	mov [eax + FRAGMENT_entry.Owner], ebx
		355
		356	add esp, 4
		357	ret
		358
		359
		360	;------------------------------------
		361	; We have received the first fragment
		362
		363	.is_first_fragment:
3556	hidnplayr	364	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: First fragment packet received!\n"
3545	hidnplayr	365	; try to locate a free slot..
		366	mov ecx, MAX_FRAGMENTS
		367	mov esi, FRAGMENT_LIST
		368	.find_free_slot:
		369	cmp word [esi + FRAGMENT_slot.ttl], 0
		370	je .found_free_slot
		371	add esi, sizeof.FRAGMENT_slot
		372	loop .find_free_slot
		373	jmp .dump ; If no free slot was found, dump the packet
		374
		375	.found_free_slot: ; We found a free slot, let's fill in the FRAGMENT_slot structure
		376	mov [esi + FRAGMENT_slot.ttl], 15 ; RFC recommends 15 secs as ttl
		377	mov ax, [edx + IPv4_header.Identification]
		378	mov [esi + FRAGMENT_slot.id], ax
		379	mov eax, [edx + IPv4_header.SourceAddress]
		380	mov [esi + FRAGMENT_slot.SrcIP], eax
		381	mov eax, [edx + IPv4_header.DestinationAddress]
		382	mov [esi + FRAGMENT_slot.DstIP], eax
		383	pop eax
		384	mov [esi + FRAGMENT_slot.ptr], eax
		385	; Now, replace ethernet header in original buffer with a FRAGMENT_entry structure
		386	mov [eax + FRAGMENT_entry.NextPtr], -1
		387	mov [eax + FRAGMENT_entry.PrevPtr], -1
		388	mov [eax + FRAGMENT_entry.Owner], ebx
		389
		390	add esp, 4 ; balance stack and exit
		391	ret
		392
		393
		394	;-----------------------------------
		395	; We have received the last fragment
		396
		397	.is_last_fragment:
3556	hidnplayr	398	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n"
3545	hidnplayr	399
		400	call IPv4_find_fragment_slot
		401	cmp esi, -1
		402	je .dump
		403
		404	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
		405	push esi
		406	xor eax, eax
		407	or edi, -1
		408
		409	.count_bytes:
		410	cmp [esi + FRAGMENT_entry.PrevPtr], edi
		411	jne .destroy_slot_pop ; Damn, something screwed up, remove the whole slot (and free buffers too if possible!)
		412	mov cx, [esi + sizeof.FRAGMENT_entry + IPv4_header.TotalLength] ; Add total length
		413	xchg cl, ch
3556	hidnplayr	414	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
3545	hidnplayr	415	add ax, cx
		416	movzx cx, [esi + sizeof.FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Sub Header length
		417	and cx, 0x000F
		418	shl cx, 2
3556	hidnplayr	419	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Header size=%u\n", cx
3545	hidnplayr	420	sub ax, cx
		421	mov edi, esi
		422	mov esi, [esi + FRAGMENT_entry.NextPtr]
		423	cmp esi, -1
		424	jne .count_bytes
		425
		426	mov esi, [esp+4]
		427	mov [edi + FRAGMENT_entry.NextPtr], esi ; Add this packet to the chain, this simplifies the following code
		428	mov [esi + FRAGMENT_entry.NextPtr], -1
		429	mov [esi + FRAGMENT_entry.PrevPtr], edi
		430	mov [esi + FRAGMENT_entry.Owner], ebx
		431
		432	mov cx, [edx + IPv4_header.TotalLength] ; Note: This time we dont substract Header length
		433	xchg cl, ch
3556	hidnplayr	434	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Packet size=%u\n", cx
3545	hidnplayr	435	add ax, cx
3556	hidnplayr	436	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Received data size=%u\n", eax
3545	hidnplayr	437
		438	push eax
		439	mov ax, [edx + IPv4_header.FlagsAndFragmentOffset]
		440	xchg al, ah
		441	shl ax, 3
		442	add cx, ax
		443	pop eax
3556	hidnplayr	444	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Total Fragment size=%u\n", ecx
3545	hidnplayr	445
		446	cmp ax, cx
		447	jne .destroy_slot_pop
		448
		449	push eax
		450	push eax
		451	call kernel_alloc
		452	test eax, eax
		453	je .destroy_slot_pop ; If we dont have enough space to allocate the buffer, discard all packets in slot
		454	mov edx, [esp+4] ; Get pointer to first fragment entry back in edx
		455
		456	.rebuild_packet_loop:
		457	movzx ecx, [edx + sizeof.FRAGMENT_entry + IPv4_header.FlagsAndFragmentOffset] ; Calculate the fragment offset
		458	xchg cl, ch ; intel byte order
		459	shl cx, 3 ; multiply by 8 and clear first 3 bits
3556	hidnplayr	460	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Fragment offset=%u\n", cx
3545	hidnplayr	461
		462	lea edi, [eax + ecx] ; Notice that edi will be equal to eax for first fragment
		463	movzx ebx, [edx + sizeof.FRAGMENT_entry + IPv4_header.VersionAndIHL] ; Find header size (in ebx) of fragment
		464	and bx, 0x000F ;
		465	shl bx, 2 ;
		466
		467	lea esi, [edx + sizeof.FRAGMENT_entry] ; Set esi to the correct begin of fragment
		468	movzx ecx, [edx + sizeof.FRAGMENT_entry + IPv4_header.TotalLength] ; Calculate total length of fragment
		469	xchg cl, ch ; intel byte order
		470
		471	cmp edi, eax ; Is this packet the first fragment ?
		472	je .first_fragment
		473	sub cx, bx ; If not, dont copy the header
		474	add esi, ebx ;
		475	.first_fragment:
		476
		477	push cx ; First copy dword-wise, then byte-wise
		478	shr cx, 2 ;
		479	rep movsd ;
		480	pop cx ;
		481	and cx, 3 ;
		482	rep movsb ;
		483
		484	push eax
		485	push edx ; Push pointer to fragment onto stack
		486	mov ebx, [edx + FRAGMENT_entry.Owner] ; we need to remeber the owner, in case this is the last packet
		487	mov edx, [edx + FRAGMENT_entry.NextPtr] ; Set edx to the next pointer
		488	call kernel_free ; free the previous fragment buffer (this uses the value from stack)
		489	pop eax
		490	cmp edx, -1 ; Check if it is last fragment in chain
		491	jne .rebuild_packet_loop
		492
		493	pop ecx
		494	xchg cl, ch
		495	mov edx, eax
		496	mov [edx + IPv4_header.TotalLength], cx
		497	add esp, 8
		498	xchg cl, ch
		499	push ecx
		500
		501	push eax
		502	jmp .handle_it ; edx = buf ptr, ecx = size, [esp] buf ptr, [esp+4], total size, ebx=device ptr
		503
		504	.destroy_slot_pop:
		505	add esp, 4
		506	.destroy_slot:
3556	hidnplayr	507	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Destroy fragment slot!\n"
3545	hidnplayr	508	; TODO!
		509	jmp .dump
		510
		511
		512
		513
		514
		515	;-----------------------------------------------------------------
		516	;
		517	; find fragment slot
		518	;
		519	; IN: pointer to fragmented packet in edx
		520	; OUT: pointer to slot in esi, -1 on error
		521	;
		522	;-----------------------------------------------------------------
		523	align 4
		524	IPv4_find_fragment_slot:
		525
		526	;;; TODO: the RFC says we should check protocol number too
		527
		528	push eax ebx ecx edx
		529	mov ax, [edx + IPv4_header.Identification]
		530	mov ecx, MAX_FRAGMENTS
		531	mov esi, FRAGMENT_LIST
		532	mov ebx, [edx + IPv4_header.SourceAddress]
		533	mov edx, [edx + IPv4_header.DestinationAddress]
		534	.find_slot:
		535	cmp [esi + FRAGMENT_slot.id], ax
		536	jne .try_next
		537	cmp [esi + FRAGMENT_slot.SrcIP], ebx
		538	jne .try_next
		539	cmp [esi + FRAGMENT_slot.DstIP], edx
		540	je .found_slot
		541	.try_next:
		542	add esi, sizeof.FRAGMENT_slot
		543	loop .find_slot
		544
		545	or esi, -1
		546	.found_slot:
		547	pop edx ecx ebx eax
		548	ret
		549
		550
		551	;------------------------------------------------------------------
		552	;
		553	; IPv4_output
		554	;
		555	; IN: eax = dest ip
		556	; ebx = output device ptr/0 for automatic choice
		557	; ecx = data length
		558	; edx = source ip
		559	; di = TTL shl 8 + protocol
		560	;
		561	; OUT: eax = pointer to buffer start
		562	; ebx = pointer to device struct (needed for sending procedure)
		563	; ecx = unchanged (packet size of embedded data)
		564	; edx = size of complete buffer
		565	; edi = pointer to start of data (0 on error)
		566	;
		567	;------------------------------------------------------------------
		568	align 4
		569	IPv4_output:
		570
3601	hidnplayr	571	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: size=%u ip=0x%x\n", ecx, eax
3545	hidnplayr	572
		573	cmp ecx, 65500 ; Max IPv4 packet size
		574	ja .too_large
		575
		576	push ecx eax edx di
		577
		578	cmp eax, 1 shl 24 + 127
		579	je .loopback
		580
		581	call IPv4_route ; outputs device number in edi, dest ip in eax
		582	call ARP_IP_to_MAC
		583	test eax, 0xffff0000 ; error bits
		584	jnz .arp_error
		585	push ebx ; push the mac onto the stack
		586	push ax
		587
3601	hidnplayr	588	inc [IP_packets_tx + 4*edi] ; update stats
3545	hidnplayr	589
3601	hidnplayr	590	mov ebx, [NET_DRV_LIST + 4*edi]
3545	hidnplayr	591	lea eax, [ebx + ETH_DEVICE.mac]
		592	mov edx, esp
		593	mov ecx, [esp + 10 + 6]
		594	add ecx, sizeof.IPv4_header
3600	hidnplayr	595	mov di, ETHER_PROTO_IPv4
3545	hidnplayr	596	call ETH_output
		597	jz .eth_error
		598	add esp, 6 ; pop the mac out of the stack
		599
		600	.continue:
		601	xchg cl, ch ; internet byte order
		602	mov [edi + IPv4_header.VersionAndIHL], 0x45 ; IPv4, normal length (no Optional header)
		603	mov [edi + IPv4_header.TypeOfService], 0 ; nothing special, just plain ip packet
		604	mov [edi + IPv4_header.TotalLength], cx
		605	mov [edi + IPv4_header.Identification], 0 ; fragment id: FIXME
		606	mov [edi + IPv4_header.FlagsAndFragmentOffset], 0
		607	pop word [edi + IPv4_header.TimeToLive] ; ttl shl 8 + protocol
		608	; [edi + IPv4_header.Protocol]
		609	mov [edi + IPv4_header.HeaderChecksum], 0
		610	popd [edi + IPv4_header.SourceAddress]
		611	popd [edi + IPv4_header.DestinationAddress]
		612
		613	pop ecx
		614
		615	IPv4_checksum edi
		616	add edi, sizeof.IPv4_header
3556	hidnplayr	617	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: success!\n"
3545	hidnplayr	618	ret
		619
		620	.eth_error:
3556	hidnplayr	621	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: ethernet error\n"
3545	hidnplayr	622	add esp, 3*4+2+6
		623	xor edi, edi
		624	ret
		625
		626	.arp_error:
3556	hidnplayr	627	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: ARP error=%x\n", eax
3545	hidnplayr	628	add esp, 3*4+2
		629	xor edi, edi
		630	ret
		631
		632	.too_large:
3556	hidnplayr	633	DEBUGF DEBUG_NETWORK_ERROR, "IPv4_output: Packet too large!\n"
3545	hidnplayr	634	xor edi, edi
		635	ret
		636
		637	.loopback:
		638	mov dword [esp + 2], eax
		639	add ecx, sizeof.IPv4_header
3600	hidnplayr	640	mov edi, AF_INET4
3545	hidnplayr	641	call LOOP_output
		642	jmp .continue
		643
		644
		645
		646
		647	;------------------------------------------------------------------
		648	;
		649	; IPv4_output_raw
		650	;
		651	; IN: eax = socket ptr
		652	; ecx = data length
		653	; esi = data ptr
		654	;
		655	; OUT: /
		656	;
		657	;------------------------------------------------------------------
		658	align 4
		659	IPv4_output_raw:
		660
		661	DEBUGF 1,"IPv4_output_raw: size=%u ptr=%x socket=%x\n", ecx, esi, eax
		662
		663	cmp ecx, 1480 ;;;;; FIXME
		664	ja .too_large
		665
		666	sub esp, 8
		667	push esi eax
		668
		669	call IPv4_route
		670	call ARP_IP_to_MAC
		671
		672	test eax, 0xffff0000 ; error bits
		673	jnz .arp_error
		674
		675	push ebx ; push the mac
		676	push ax
		677
3601	hidnplayr	678	inc [IP_packets_tx + 4*edi]
		679	mov ebx, [NET_DRV_LIST + 4*edi]
3545	hidnplayr	680	lea eax, [ebx + ETH_DEVICE.mac]
		681	mov edx, esp
		682	mov ecx, [esp + 6 + 4]
		683	add ecx, sizeof.IPv4_header
3600	hidnplayr	684	mov di, ETHER_PROTO_IPv4
3545	hidnplayr	685	call ETH_output
		686	jz .error
		687
		688	add esp, 6 ; pop the mac
		689
		690	mov dword[esp+4+4], edx
		691	mov dword[esp+4+4+4], eax
		692
		693	pop eax esi
		694	;; todo: check socket options if we should add header, or just compute checksum
		695
		696	push edi ecx
		697	rep movsb
		698	pop ecx edi
		699
		700	; [edi + IPv4_header.VersionAndIHL] ; IPv4, normal length (no Optional header)
		701	; [edi + IPv4_header.TypeOfService] ; nothing special, just plain ip packet
		702	; [edi + IPv4_header.TotalLength]
		703	; [edi + IPv4_header.TotalLength] ; internet byte order
		704	; [edi + IPv4_header.FlagsAndFragmentOffset]
		705
		706	mov [edi + IPv4_header.HeaderChecksum], 0
		707
		708	; [edi + IPv4_header.TimeToLive] ; ttl shl 8 + protocol
		709	; [edi + IPv4_header.Protocol]
		710	; [edi + IPv4_header.Identification] ; fragment id
		711	; [edi + IPv4_header.SourceAddress]
		712	; [edi + IPv4_header.DestinationAddress]
		713
		714	IPv4_checksum edi ;;;; todo: checksum for IP packet with options!
		715	add edi, sizeof.IPv4_header
3556	hidnplayr	716	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output_raw: device=%x\n", ebx
3545	hidnplayr	717	call [ebx + NET_DEVICE.transmit]
		718	ret
		719
		720	.error:
		721	add esp, 6
		722	.arp_error:
		723	add esp, 8+4+4
		724	.too_large:
3556	hidnplayr	725	DEBUGF DEBUG_NETWORK_ERROR, "IPv4_output_raw: Failed\n"
3545	hidnplayr	726	sub edi, edi
		727	ret
		728
		729
		730	;--------------------------------------------------------
		731	;
		732	;
		733	; IN: dword [esp] = pointer to buffer containing ipv4 packet to be fragmented
		734	; dword [esp+4] = buffer size
		735	; esi = pointer to ip header in that buffer
		736	; ecx = max size of fragments
		737	;
		738	; OUT: /
		739	;
		740	;--------------------------------------------------------
		741
		742	align 4
		743	IPv4_fragment:
		744
3556	hidnplayr	745	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_fragment\n"
3545	hidnplayr	746
		747	and ecx, not 111b ; align 4
		748
		749	cmp ecx, sizeof.IPv4_header + 8 ; must be able to put at least 8 bytes
		750	jb .err2
		751
		752	push esi ecx
		753	mov eax, [esi + IPv4_header.DestinationAddress]
		754	call ARP_IP_to_MAC
		755	pop ecx esi
		756	cmp eax, -1
		757	jz .err2
		758
		759	push ebx
		760	push ax
		761
		762	mov ebx, [NET_DRV_LIST]
		763	lea eax, [ebx + ETH_DEVICE.mac]
		764	push eax
		765
		766
		767	push esi ; ptr to ip header
		768	sub ecx, sizeof.IPv4_header ; substract header size
		769	push ecx ; max data size
		770	push dword 0 ; offset
		771
		772	.new_fragment:
3556	hidnplayr	773	DEBUGF DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: new fragment"
3545	hidnplayr	774
		775
		776	mov eax, [esp + 3*4]
		777	lea ebx, [esp + 4*4]
3600	hidnplayr	778	mov di , ETHER_PROTO_IPv4
3545	hidnplayr	779	call ETH_output
		780
		781	cmp edi, -1
		782	jz .err
		783
		784	; copy header
		785	mov esi, [esp + 2*4]
		786	mov ecx, 5 ; 5 dwords: TODO: use IHL field of the header!
		787	rep movsd
		788
		789	; copy data
		790	mov esi, [esp + 2*4]
		791	add esi, sizeof.IPv4_header
		792	add esi, [esp] ; offset
		793
		794	mov ecx, [esp + 1*4]
3556	hidnplayr	795	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_fragment: copying %u bytes\n", ecx
3545	hidnplayr	796	rep movsb
		797
		798	; now, correct header
		799	mov ecx, [esp + 1*4]
		800	add ecx, sizeof.IPv4_header
		801	xchg cl, ch
		802	mov [edi + IPv4_header.TotalLength], cx
		803
		804	mov ecx, [esp] ; offset
		805	xchg cl, ch
		806
		807	; cmp dword[esp + 4*4], 0 ; last fragment?;<<<<<<
		808	; je .last_fragment
		809	or cx, 1 shl 2 ; more fragments
		810	; .last_fragment:
		811	mov [edi + IPv4_header.FlagsAndFragmentOffset], cx
		812
		813	mov [edi + IPv4_header.HeaderChecksum], 0
		814
		815	;<<<<<<<<<<<<<<<<<<<<<<<<<<<<< send the packet
		816	mov ecx, [esp + 1*4]
		817
		818	push edx eax
		819	IPv4_checksum edi
		820
		821	call [ebx + NET_DEVICE.transmit]
		822	;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
		823
		824	mov ecx, [esp+4]
		825	add [esp], ecx
		826
		827	mov ecx, [esp+3*4+6+4] ; ptr to begin of buff
		828	add ecx, [esp+3*4+6+4+4] ; buff size
		829	sub ecx, [esp+2*4] ; ptr to ip header
		830	add ecx, [esp] ; offset
		831
3556	hidnplayr	832	DEBUGF DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: %u bytes remaining\n", ecx
3545	hidnplayr	833
		834	cmp ecx, [esp+1*4]
		835	jae .new_fragment
		836
		837	mov [esp+4], ecx ; set fragment size to remaining packet size
		838	jmp .new_fragment
		839
		840	.err:
3556	hidnplayr	841	DEBUGF DEBUG_NETWORK_ERROR, "Ipv4_fragment: failed\n"
3545	hidnplayr	842	.done:
		843	add esp, 12 + 4 + 6
		844	.err2:
3556	hidnplayr	845	DEBUGF DEBUG_NETWORK_VERBOSE, "Ipv4_fragment: dumping\n"
3545	hidnplayr	846	call kernel_free
		847	add esp, 4
		848
		849	ret
		850
		851
		852
		853	;---------------------------------------------------------------------------
		854	;
		855	; IPv4_route
		856	;
		857	; IN: eax = Destination IP
3601	hidnplayr	858	; OUT: edi = device number
3545	hidnplayr	859	; eax = ip of gateway if nescessary, unchanged otherwise
		860	;
		861	;---------------------------------------------------------------------------
		862	align 4
		863	IPv4_route:
		864
		865	cmp eax, 0xffffffff
		866	je .broadcast
		867
		868	xor edi, edi
3600	hidnplayr	869	mov ecx, NET_DEVICES_MAX
3545	hidnplayr	870	.loop:
		871	mov ebx, [IP_LIST+edi]
		872	and ebx, [SUBNET_LIST+edi]
		873	jz .next
		874	mov edx, eax
		875	and edx, [SUBNET_LIST+edi]
		876
		877	cmp ebx, edx
		878	je .found_it
		879	.next:
		880	add edi, 4
		881	dec ecx
		882	jnz .loop
		883
		884	.invalid:
3601	hidnplayr	885	xor edi, edi ; if none found, use device 1 as default ;;; FIXME
		886	inc di
		887	mov eax, [GATEWAY_LIST+4]
3545	hidnplayr	888
		889	.found_it:
3556	hidnplayr	890	DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_route: %u\n", edi
3545	hidnplayr	891	ret
		892
		893	.broadcast:
3601	hidnplayr	894	xor edi, edi ;;;; FIXME
		895	inc di
3545	hidnplayr	896	ret
		897
		898
		899
		900	;---------------------------------------------------------------------------
		901	;
		902	; IPv4_get_frgmnt_num
		903	;
		904	; IN: /
		905	; OUT: fragment number in ax
		906	;
		907	;---------------------------------------------------------------------------
		908	align 4
		909	IPv4_get_frgmnt_num:
		910	xor ax, ax ;;; TODO: replace this with real code
		911
		912	ret
		913
		914
		915	;---------------------------------------------------------------------------
		916	;
		917	; IPv4_API
		918	;
		919	; This function is called by system function 75
		920	;
		921	; IN: subfunction number in bl
		922	; device number in bh
		923	; ecx, edx, .. depends on subfunction
		924	;
		925	; OUT:
		926	;
		927	;---------------------------------------------------------------------------
		928	align 4
		929	IPv4_api:
		930
		931	movzx eax, bh
		932	shl eax, 2
		933
		934	and ebx, 0x000000ff
		935	cmp ebx, .number
		936	ja .error
		937	jmp dword [.table + 4*ebx]
		938
		939	.table:
		940	dd .packets_tx ; 0
		941	dd .packets_rx ; 1
		942	dd .read_ip ; 2
		943	dd .write_ip ; 3
		944	dd .read_dns ; 4
		945	dd .write_dns ; 5
		946	dd .read_subnet ; 6
		947	dd .write_subnet ; 7
		948	dd .read_gateway ; 8
		949	dd .write_gateway ; 9
		950	.number = ($ - .table) / 4 - 1
		951
		952	.error:
		953	mov eax, -1
		954	ret
		955
		956	.packets_tx:
		957	mov eax, [IP_packets_tx + eax]
		958	ret
		959
		960	.packets_rx:
		961	mov eax, [IP_packets_rx + eax]
		962	ret
		963
		964	.read_ip:
		965	mov eax, [IP_LIST + eax]
		966	ret
		967
		968	.write_ip:
		969	mov [IP_LIST + eax], ecx
		970	mov edi, eax ; device number, we'll need it for ARP
		971
		972	; pre-calculate the local broadcast address
		973	mov ebx, [SUBNET_LIST + eax]
		974	not ebx
		975	or ebx, ecx
		976	mov [BROADCAST_LIST + eax], ebx
		977
3601	hidnplayr	978	mov ebx, [NET_DRV_LIST + eax]
		979	mov eax, [IP_LIST + eax]
3545	hidnplayr	980	call ARP_output_request ; now send a gratuitous ARP
		981
		982	call NET_send_event
		983	xor eax, eax
		984	ret
		985
		986	.read_dns:
		987	mov eax, [DNS_LIST + eax]
		988	ret
		989
		990	.write_dns:
		991	mov [DNS_LIST + eax], ecx
		992	call NET_send_event
		993	xor eax, eax
		994	ret
		995
		996	.read_subnet:
		997	mov eax, [SUBNET_LIST + eax]
		998	ret
		999
		1000	.write_subnet:
		1001	mov [SUBNET_LIST + eax], ecx
		1002
		1003	; pre-calculate the local broadcast address
		1004	mov ebx, [IP_LIST + eax]
		1005	not ecx
		1006	or ecx, ebx
		1007	mov [BROADCAST_LIST + eax], ecx
		1008
		1009	call NET_send_event
		1010	xor eax, eax
		1011	ret
		1012
		1013	.read_gateway:
		1014	mov eax, [GATEWAY_LIST + eax]
		1015	ret
		1016
		1017	.write_gateway:
		1018	mov [GATEWAY_LIST + eax], ecx
		1019
		1020	call NET_send_event
		1021	xor eax, eax
		1022	ret

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/IPv4.inc @ 6907 – Rev 3601