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
		61	IP_LIST rd MAX_NET_DEVICES
		62	SUBNET_LIST rd MAX_NET_DEVICES
		63	DNS_LIST rd MAX_NET_DEVICES
		64	GATEWAY_LIST rd MAX_NET_DEVICES
		65	BROADCAST_LIST rd MAX_NET_DEVICES
		66
		67	IP_packets_tx rd MAX_NET_DEVICES
		68	IP_packets_rx rd MAX_NET_DEVICES
		69	IP_packets_dumped rd MAX_NET_DEVICES
		70
		71	FRAGMENT_LIST rb MAX_FRAGMENTS * sizeof.FRAGMENT_slot
		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
		86	mov ecx, 7MAX_NET_DEVICES + (sizeof.FRAGMENT_slotMAX_FRAGMENTS)/4
		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:
		115	DEBUGF 2,"IPv4 Fragment slot timed-out!\n"
		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
		208	DEBUGF 2,"IPv4_input, packet from: %u.%u.%u.%u ",\
		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
		211	DEBUGF 2,"to: %u.%u.%u.%u\n",\
		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
		221	DEBUGF 1,"IPv4_input: Checksum ok\n"
		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
		259	DEBUGF 2,"IPv4_input: Destination address does not match!\n"
		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
		303	DEBUGF 2,"IPv4_input: unknown protocol %u\n", al
		304
		305	.dump:
		306	DEBUGF 1,"IPv4_input: dumping\n"
		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
		322	DEBUGF 1,"IPv4_input: fragmented packet offset=%u id=%x\n", ax, [edx + IPv4_header.Identification]:4
		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
		331	DEBUGF 1,"IPv4_input: Middle fragment packet received!\n"
		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:
		364	DEBUGF 1,"IPv4_input: First fragment packet received!\n"
		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:
		398	DEBUGF 1,"IPv4_input: Last fragment packet received!\n"
		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
		414	DEBUGF 1,"IPv4_input: Packet size=%u\n", cx
		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
		419	DEBUGF 1,"IPv4_input: Header size=%u\n", cx
		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
		434	DEBUGF 1,"IPv4_input: Packet size=%u\n", cx
		435	add ax, cx
		436	DEBUGF 1,"IPv4_input: Total Received data size=%u\n", eax
		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
		444	DEBUGF 1,"IPv4_input: Total Fragment size=%u\n", ecx
		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
		460	DEBUGF 1,"IPv4_input: Fragment offset=%u\n", cx
		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:
		507	DEBUGF 1,"IPv4_input: Destroy fragment slot!\n"
		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
		571	DEBUGF 1,"IPv4_output: size=%u\n", ecx
		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
		588	inc [IP_packets_tx + edi] ; update stats
		589
		590	mov ebx, [NET_DRV_LIST + edi]
		591	lea eax, [ebx + ETH_DEVICE.mac]
		592	mov edx, esp
		593	mov ecx, [esp + 10 + 6]
		594	add ecx, sizeof.IPv4_header
		595	mov di, ETHER_IPv4
		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
		617	DEBUGF 2,"IPv4_output: success!\n"
		618	ret
		619
		620	.eth_error:
		621	DEBUGF 2,"IPv4_output: ethernet error\n"
		622	add esp, 3*4+2+6
		623	xor edi, edi
		624	ret
		625
		626	.arp_error:
		627	DEBUGF 2,"IPv4_output: ARP error=%x\n", eax
		628	add esp, 3*4+2
		629	xor edi, edi
		630	ret
		631
		632	.too_large:
		633	DEBUGF 2,"IPv4_output: Packet too large!\n"
		634	xor edi, edi
		635	ret
		636
		637	.loopback:
		638	mov dword [esp + 2], eax
		639	add ecx, sizeof.IPv4_header
		640	mov di, ETHER_IPv4
		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
		678	inc [IP_packets_tx + edi]
		679	mov ebx, [NET_DRV_LIST + edi]
		680	lea eax, [ebx + ETH_DEVICE.mac]
		681	mov edx, esp
		682	mov ecx, [esp + 6 + 4]
		683	add ecx, sizeof.IPv4_header
		684	mov di, ETHER_IPv4
		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
		716	DEBUGF 2,"IPv4_output_raw: device=%x\n", ebx
		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:
		725	DEBUGF 2,"IPv4_output_raw: Failed\n"
		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
		745	DEBUGF 1,"IPv4_fragment\n"
		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:
		773	DEBUGF 1,"Ipv4_fragment: new fragment"
		774
		775
		776	mov eax, [esp + 3*4]
		777	lea ebx, [esp + 4*4]
		778	mov di , ETHER_IPv4
		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]
		795	DEBUGF 1,"IPv4_fragment: copying %u bytes\n", ecx
		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
		832	DEBUGF 1,"Ipv4_fragment: %u bytes remaining\n", ecx
		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:
		841	DEBUGF 1,"Ipv4_fragment: failed\n"
		842	.done:
		843	add esp, 12 + 4 + 6
		844	.err2:
		845	DEBUGF 1,"Ipv4_fragment: dumping\n"
		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
		858	; OUT: edi = device id * 4
		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
		869	mov ecx, MAX_NET_DEVICES
		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:
		885	xor edi, edi ; if none found, use device 0 as default
		886	mov eax, [GATEWAY_LIST]
		887
		888	.found_it:
		889	DEBUGF 1,"IPv4_dest_to_dev: %u\n", edi
		890	ret
		891
		892	.broadcast:
		893	xor edi, edi
		894	ret
		895
		896
		897
		898	;---------------------------------------------------------------------------
		899	;
		900	; IPv4_get_frgmnt_num
		901	;
		902	; IN: /
		903	; OUT: fragment number in ax
		904	;
		905	;---------------------------------------------------------------------------
		906	align 4
		907	IPv4_get_frgmnt_num:
		908	xor ax, ax ;;; TODO: replace this with real code
		909
		910	ret
		911
		912
		913	;---------------------------------------------------------------------------
		914	;
		915	; IPv4_API
		916	;
		917	; This function is called by system function 75
		918	;
		919	; IN: subfunction number in bl
		920	; device number in bh
		921	; ecx, edx, .. depends on subfunction
		922	;
		923	; OUT:
		924	;
		925	;---------------------------------------------------------------------------
		926	align 4
		927	IPv4_api:
		928
		929	movzx eax, bh
		930	shl eax, 2
		931
		932	and ebx, 0x000000ff
		933	cmp ebx, .number
		934	ja .error
		935	jmp dword [.table + 4*ebx]
		936
		937	.table:
		938	dd .packets_tx ; 0
		939	dd .packets_rx ; 1
		940	dd .read_ip ; 2
		941	dd .write_ip ; 3
		942	dd .read_dns ; 4
		943	dd .write_dns ; 5
		944	dd .read_subnet ; 6
		945	dd .write_subnet ; 7
		946	dd .read_gateway ; 8
		947	dd .write_gateway ; 9
		948	.number = ($ - .table) / 4 - 1
		949
		950	.error:
		951	mov eax, -1
		952	ret
		953
		954	.packets_tx:
		955	mov eax, [IP_packets_tx + eax]
		956	ret
		957
		958	.packets_rx:
		959	mov eax, [IP_packets_rx + eax]
		960	ret
		961
		962	.read_ip:
		963	mov eax, [IP_LIST + eax]
		964	ret
		965
		966	.write_ip:
		967	mov [IP_LIST + eax], ecx
		968	mov edi, eax ; device number, we'll need it for ARP
		969
		970	; pre-calculate the local broadcast address
		971	mov ebx, [SUBNET_LIST + eax]
		972	not ebx
		973	or ebx, ecx
		974	mov [BROADCAST_LIST + eax], ebx
		975
		976	mov eax, ecx
		977	call ARP_output_request ; now send a gratuitous ARP
		978
		979	call NET_send_event
		980	xor eax, eax
		981	ret
		982
		983	.read_dns:
		984	mov eax, [DNS_LIST + eax]
		985	ret
		986
		987	.write_dns:
		988	mov [DNS_LIST + eax], ecx
		989	call NET_send_event
		990	xor eax, eax
		991	ret
		992
		993	.read_subnet:
		994	mov eax, [SUBNET_LIST + eax]
		995	ret
		996
		997	.write_subnet:
		998	mov [SUBNET_LIST + eax], ecx
		999
		1000	; pre-calculate the local broadcast address
		1001	mov ebx, [IP_LIST + eax]
		1002	not ecx
		1003	or ecx, ebx
		1004	mov [BROADCAST_LIST + eax], ecx
		1005
		1006	call NET_send_event
		1007	xor eax, eax
		1008	ret
		1009
		1010	.read_gateway:
		1011	mov eax, [GATEWAY_LIST + eax]
		1012	ret
		1013
		1014	.write_gateway:
		1015	mov [GATEWAY_LIST + eax], ecx
		1016
		1017	call NET_send_event
		1018	xor eax, eax
		1019	ret

Subversion Repositories Kolibri OS

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