/kernel/branches/Kolibri-acpi/network/ARP.inc |
---|
70,14 → 70,12 |
;----------------------------------------------------------------- |
; |
; ARP_init |
; |
; This function resets all ARP variables |
; |
;----------------------------------------------------------------- |
macro ARP_init { |
;-----------------------------------------------------------------; |
; ; |
; arp_init: Resets all ARP variables. ; |
; ; |
;-----------------------------------------------------------------; |
macro arp_init { |
xor eax, eax |
mov edi, ARP_entries_num |
86,14 → 84,13 |
} |
;--------------------------------------------------------------------------- |
; |
; ARP_decrease_entry_ttls |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; arp_decrease_entry_ttls ; |
; ; |
;-----------------------------------------------------------------; |
macro arp_decrease_entry_ttls { |
macro ARP_decrease_entry_ttls { |
local .loop |
local .exit |
135,7 → 132,7 |
je .response_timeout |
push esi edi ecx |
call ARP_del_entry |
call arp_del_entry |
pop ecx edi esi |
jmp .next |
154,20 → 151,21 |
} |
;----------------------------------------------------------------- |
; |
; ARP_input |
; |
; IN: Pointer to buffer in [esp] |
; size of buffer in [esp+4] |
; packet size (without ethernet header) in ecx |
; packet ptr in edx |
; device ptr in ebx |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; arp_input ; |
; ; |
; IN: [esp] = Pointer to buffer ; |
; [esp+4] = size of buffer ; |
; ecx = packet size (without ethernet header) ; |
; edx = packet ptr ; |
; ebx = device ptr ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ARP_input: |
arp_input: |
;----------------------------------------- |
; Check validity and print some debug info |
175,7 → 173,7 |
cmp ecx, sizeof.ARP_header |
jb .exit |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
cmp edi, -1 |
jz .exit |
294,21 → 292,21 |
.exit: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_input: exiting\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
;--------------------------------------------------------------------------- |
; |
; ARP_output_request |
; |
; IN: ebx = device ptr |
; eax = IP |
; OUT: / |
; scratched: probably everything |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; arp_output_request ; |
; ; |
; IN: ebx = device ptr ; |
; eax = IP ; |
; ; |
; OUT: scratched: probably everything ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ARP_output_request: |
arp_output_request: |
push eax |
318,7 → 316,7 |
mov ax, ETHER_PROTO_ARP |
mov ecx, sizeof.ARP_header |
mov edx, ETH_BROADCAST ; broadcast mac |
call ETH_output |
call eth_output |
jz .exit |
mov [edi + ARP_header.HardwareType], 0x0100 ; Ethernet |
333,7 → 331,7 |
movsd ; |
push edi |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [ARP_PACKETS_TX + edi] ; assume we will succeed |
lea esi, [IP_LIST + edi] ; SenderIP |
pop edi |
354,19 → 352,23 |
ret |
;----------------------------------------------------------------- |
; |
; ARP_add_entry (or update) |
; |
; IN: esi = ptr to entry (can easily be made on the stack) |
; edi = device num*4 |
; OUT: eax = entry #, -1 on error |
; esi = ptr to newly created entry |
; |
;----------------------------------------------------------------- ; TODO: use a mutex |
;-----------------------------------------------------------------; |
; ; |
; arp_add_entry: Add or update an entry in the ARP table. ; |
; ; |
; IN: esi = ptr to entry (can easily be made on the stack) ; |
; edi = device num*4 ; |
; ; |
; OUT: eax = entry number on success ; |
; eax = -1 on error ; |
; esi = ptr to newly created entry ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ARP_add_entry: |
arp_add_entry: |
; TODO: use a mutex to lock ARP table |
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_add_entry: device=%u\n", edi |
mov ecx, [ARP_entries_num + edi] |
421,19 → 423,22 |
ret |
;----------------------------------------------------------------- |
; |
; ARP_del_entry |
; |
; IN: esi = ptr to arp entry |
; edi = device number |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; arp_del_entry: Remove an entry from the ARP table. ; |
; ; |
; IN: esi = ptr to arp entry ; |
; edi = device number ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ARP_del_entry: |
arp_del_entry: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=%x entrys=%u\n", esi, [ARP_entries_num + 4*edi] |
; TODO: use a mutex to lock ARP table |
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: entry=0x%x entrys=%u\n", esi, [ARP_entries_num + 4*edi] |
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_del_entry: IP=%u.%u.%u.%u\n", \ |
[esi + ARP_entry.IP]:1, [esi + ARP_entry.IP + 1]:1, [esi + ARP_entry.IP + 2]:1, [esi + ARP_entry.IP + 3]:1 |
463,22 → 468,22 |
;----------------------------------------------------------------- |
; |
; ARP_IP_to_MAC |
; |
; This function translates an IP address to a MAC address |
; |
; IN: eax = IPv4 address |
; edi = device number * 4 |
; OUT: eax = -1 on error, -2 means request send |
; else, ax = first two bytes of mac (high 16 bits of eax will be 0) |
; ebx = last four bytes of mac |
; edi = unchanged |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; arp_ip_to_mac: Translate an IP address to a MAC address. ; |
; ; |
; IN: eax = IPv4 address ; |
; edi = device number * 4 ; |
; ; |
; OUT: eax = -1 on error ; |
; eax = -2 when request send ; |
; eax = first two bytes of mac on success ; |
; ebx = last four bytes of mac on success ; |
; edi = unchanged ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ARP_IP_to_MAC: |
arp_ip_to_mac: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ARP_IP_to_MAC: %u.%u", al, ah |
rol eax, 16 |
513,11 → 518,11 |
pushw ARP_AWAITING_RESPONSE ; status |
pushd 0 ; mac |
pushw 0 |
pushd eax ; ip |
pushd eax ; IP |
mov esi, esp |
; Add it to the list |
call ARP_add_entry |
call arp_add_entry |
; Delete the temporary entry |
add esp, sizeof.ARP_entry ; clear the entry from stack |
534,7 → 539,7 |
push esi edi |
mov ebx, [NET_DRV_LIST + edi] |
call ARP_output_request |
call arp_output_request |
pop edi esi |
.found_it: |
cmp [esi + ARP_entry.Status], ARP_VALID_MAPPING ; Does it have a MAC assigned? |
576,21 → 581,19 |
ret |
;----------------------------------------------------------------- |
; |
; ARP_API |
; |
; This function is called by system function 76 |
; |
; IN: subfunction number in bl |
; device number in bh |
; ecx, edx, .. depends on subfunction |
; |
; OUT: ? |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; arp_api: Part of system function 76. ; |
; ; |
; IN: bl = subfunction number ; |
; bh = device number ; |
; ecx, edx, .. depends on subfunction ; |
; ; |
; OUT: depends on subfunction ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ARP_api: |
arp_api: |
movzx eax, bh |
shl eax, 2 |
650,7 → 653,7 |
.write: |
; esi = pointer to buffer |
mov edi, eax |
call ARP_add_entry ; out: eax = entry number, -1 on error |
call arp_add_entry ; out: eax = entry number, -1 on error |
ret |
.remove: |
661,12 → 664,12 |
lea esi, [ARP_table + ecx] |
mov edi, eax |
shr edi, 2 |
call ARP_del_entry |
call arp_del_entry |
ret |
.send_announce: |
mov ebx, [NET_DRV_LIST + eax] |
mov eax, [IP_LIST + eax] |
call ARP_output_request ; now send a gratuitous ARP |
call arp_output_request ; now send a gratuitous ARP |
ret |
/kernel/branches/Kolibri-acpi/network/IPv4.inc |
---|
16,7 → 16,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5842 $ |
$Revision: 6011 $ |
IPv4_MAX_FRAGMENTS = 64 |
IPv4_MAX_ROUTES = 64 |
92,14 → 92,12 |
endg |
;----------------------------------------------------------------- |
; |
; IPv4_init |
; |
; This function resets all IP variables |
; |
;----------------------------------------------------------------- |
macro IPv4_init { |
;-----------------------------------------------------------------; |
; ; |
; ipv4_init: Resets all IPv4 variables ; |
; ; |
;-----------------------------------------------------------------; |
macro ipv4_init { |
xor eax, eax |
mov edi, IP_LIST |
109,12 → 107,12 |
} |
;----------------------------------------------------------------- |
; |
; Decrease TimeToLive of all fragment slots |
; |
;----------------------------------------------------------------- |
macro IPv4_decrease_fragment_ttls { |
;-----------------------------------------------------------------; |
; ; |
; Decrease TimeToLive of all fragment slots ; |
; ; |
;-----------------------------------------------------------------; |
macro ipv4_decrease_fragment_ttls { |
local .loop, .next |
141,7 → 139,7 |
macro IPv4_checksum ptr { |
macro ipv4_checksum ptr { |
; This is the fast procedure to create or check an IP header without options |
; To create a new checksum, the checksum field must be set to 0 before computation |
205,24 → 203,22 |
;----------------------------------------------------------------- |
; |
; IPv4_input: |
; |
; Will check if IPv4 Packet isnt damaged |
; and call appropriate handler. (TCP/UDP/ICMP/..) |
; |
; It will also re-construct fragmented packets |
; |
; IN: Pointer to buffer in [esp] |
; pointer to device struct in ebx |
; pointer to IPv4 header in edx |
; size of IPv4 packet in ecx |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv4_input: Check if IPv4 Packet isnt damaged and call ; |
; appropriate handler. (TCP/UDP/ICMP/..) ; |
; We will also re-construct fragmented packets. ; |
; ; |
; IN: Pointer to buffer in [esp] ; |
; pointer to device struct in ebx ; |
; pointer to IPv4 header in edx ; |
; size of IPv4 packet in ecx ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv4_input: |
ipv4_input: |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: packet from %u.%u.%u.%u ",\ |
[edx + IPv4_header.SourceAddress + 0]:1,[edx + IPv4_header.SourceAddress + 1]:1,\ |
231,7 → 227,7 |
[edx + IPv4_header.DestinationAddress + 0]:1,[edx + IPv4_header.DestinationAddress + 1]:1,\ |
[edx + IPv4_header.DestinationAddress + 2]:1,[edx + IPv4_header.DestinationAddress + 3]:1 |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
cmp edi, -1 |
je .invalid_device |
238,7 → 234,7 |
;------------------------------- |
; re-calculate the checksum |
IPv4_checksum edx |
ipv4_checksum edx |
jnz .dump ; if checksum isn't valid then dump packet |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Checksum ok\n" |
304,13 → 300,13 |
add esi, edx ; make esi ptr to data |
cmp al, IP_PROTO_TCP |
je TCP_input |
je tcp_input |
cmp al, IP_PROTO_UDP |
je UDP_input |
je udp_input |
cmp al, IP_PROTO_ICMP |
je ICMP_input |
je icmp_input |
;------------------------------- |
; Look for a matching RAW socket |
347,7 → 343,7 |
call mutex_lock |
popa |
jmp SOCKET_input |
jmp socket_input |
.dump_unlock: |
361,12 → 357,12 |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: dumping\n" |
inc [IPv4_packets_dumped + edi] |
call NET_BUFF_free |
call net_buff_free |
ret |
.invalid_device: |
DEBUGF DEBUG_NETWORK_ERROR, "IPv4_input: packet originated from invalid device\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
390,7 → 386,7 |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Middle fragment packet received!\n" |
call IPv4_find_fragment_slot |
call ipv4_find_fragment_slot |
cmp esi, -1 |
je .dump |
455,7 → 451,7 |
.is_last_fragment: |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Last fragment packet received!\n" |
call IPv4_find_fragment_slot |
call ipv4_find_fragment_slot |
cmp esi, -1 |
je .dump |
546,7 → 542,7 |
push [edx + IPv4_FRAGMENT_entry.NextPtr] ; Set edx to the next pointer |
push edx ; Push pointer to fragment onto stack |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_input: Next Fragment: 0x%x\n", edx |
call NET_BUFF_free ; free the previous fragment buffer (this uses the value from stack) |
call net_buff_free ; free the previous fragment buffer (this uses the value from stack) |
pop edx ebx eax |
cmp edx, -1 ; Check if it is last fragment in chain |
jne .rebuild_packet_loop |
571,16 → 567,17 |
;----------------------------------------------------------------- |
; |
; find fragment slot |
; |
; IN: pointer to fragmented packet in edx |
; OUT: pointer to slot in esi, -1 on error |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv4_find_fragment_slot ; |
; ; |
; IN: pointer to fragmented packet in edx ; |
; ; |
; OUT: pointer to slot in esi, -1 on error ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv4_find_fragment_slot: |
ipv4_find_fragment_slot: |
;;; TODO: the RFC says we should check protocol number too |
607,26 → 604,27 |
ret |
;------------------------------------------------------------------ |
; |
; IPv4_output |
; |
; IN: al = protocol |
; ah = TTL |
; ebx = device ptr (or 0 to let IP layer decide) |
; ecx = data length |
; edx = Source IP |
; edi = Destination IP |
; |
; OUT: eax = pointer to buffer start / 0 on error |
; ebx = device ptr (send packet through this device) |
; ecx = data length |
; edx = size of complete frame |
; edi = start of IPv4 payload |
; |
;------------------------------------------------------------------ |
;------------------------------------------------------------------; |
; ; |
; ipv4_output ; |
; ; |
; IN: al = protocol ; |
; ah = TTL ; |
; ebx = device ptr (or 0 to let IP layer decide) ; |
; ecx = data length ; |
; edx = Source IP ; |
; edi = Destination IP ; |
; ; |
; OUT: eax = pointer to buffer start ; |
; eax = 0 on error ; |
; ebx = device ptr (send packet through this device) ; |
; ecx = data length ; |
; edx = size of complete frame ; |
; edi = start of IPv4 payload ; |
; ; |
;------------------------------------------------------------------; |
align 4 |
IPv4_output: |
ipv4_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: size=%u ip=0x%x\n", ecx, eax |
635,12 → 633,12 |
push ecx ax edi |
mov eax, edi |
call IPv4_route ; outputs device number in edi, dest ip in eax, source IP in edx |
call ipv4_route ; outputs device number in edi, dest ip in eax, source IP in edx |
push edx |
test edi, edi |
jz .loopback |
call ARP_IP_to_MAC |
call arp_ip_to_mac |
test eax, 0xffff0000 ; error bits |
jnz .arp_error |
push ebx ; push the mac onto the stack |
653,7 → 651,7 |
mov ecx, [esp + 6 + 8 + 2] |
add ecx, sizeof.IPv4_header |
mov edx, esp |
call ETH_output |
call eth_output |
jz .eth_error |
add esp, 6 ; pop the mac out of the stack |
674,7 → 672,7 |
pop ecx |
IPv4_checksum edi |
ipv4_checksum edi |
add edi, sizeof.IPv4_header |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output: success!\n" |
ret |
704,25 → 702,25 |
mov ecx, [esp + 10] |
add ecx, sizeof.IPv4_header |
mov edi, AF_INET4 |
call LOOP_output |
call loop_output |
jmp .continue |
;------------------------------------------------------------------ |
; |
; IPv4_output_raw |
; |
; IN: eax = socket ptr |
; ecx = data length |
; esi = data ptr |
; |
; OUT: eax = -1 on error |
; |
;------------------------------------------------------------------ |
;------------------------------------------------------------------; |
; ; |
; ipv4_output_raw ; |
; ; |
; IN: eax = socket ptr ; |
; ecx = data length ; |
; esi = data ptr ; |
; ; |
; OUT: eax = -1 on error ; |
; ; |
;------------------------------------------------------------------; |
align 4 |
IPv4_output_raw: |
ipv4_output_raw: |
DEBUGF 1,"IPv4_output_raw: size=%u ptr=%x socket=%x\n", ecx, esi, eax |
729,8 → 727,8 |
sub esp, 8 |
push esi eax |
call IPv4_route |
call ARP_IP_to_MAC |
call ipv4_route |
call arp_ip_to_mac |
test eax, 0xffff0000 ; error bits |
jnz .arp_error |
744,7 → 742,7 |
mov ecx, [esp + 6 + 4] |
add ecx, sizeof.IPv4_header |
mov edx, esp |
call ETH_output |
call eth_output |
jz .error |
add esp, 6 ; pop the mac |
772,7 → 770,7 |
; [edi + IPv4_header.SourceAddress] |
; [edi + IPv4_header.DestinationAddress] |
IPv4_checksum edi ;;;; todo: checksum for IP packet with options! |
ipv4_checksum edi ;;;; todo: checksum for IP packet with options! |
add edi, sizeof.IPv4_header |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv4_output_raw: device=%x\n", ebx |
call [ebx + NET_DEVICE.transmit] |
791,17 → 789,18 |
ret |
;-------------------------------------------------------- |
; |
; |
; IN: [esp] = pointer to buffer containing ipv4 packet to be fragmented |
; edi = pointer to ip header in that buffer |
; ebx = device ptr |
; |
; OUT: / |
; |
;-------------------------------------------------------- |
proc IPv4_fragment stdcall buffer |
;-----------------------------------------------------------------; |
; ; |
; ipv4_fragment ; |
; ; |
; IN: [esp] = ptr to packet buffer to fragment ; |
; edi = ptrr to ip header in that buffer ; |
; ebx = device ptr ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
proc ipv4_fragment stdcall buffer |
locals |
offset dd ? |
910,22 → 909,24 |
;--------------------------------------------------------------------------- |
; |
; IPv4_route |
; |
; IN: eax = Destination IP |
; ebx = outgoing device / 0 |
; edx = Source IP |
; OUT: eax = Destination IP (or gateway IP) |
; edx = Source IP |
; edi = device number*4 |
; DESTROYED: |
; ecx |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv4_route ; |
; ; |
; IN: eax = Destination IP ; |
; ebx = outgoing device / 0 ; |
; edx = Source IP ; |
; ; |
; OUT: eax = Destination IP (or gateway IP) ; |
; edx = Source IP ; |
; edi = device number*4 ; |
; ; |
; DESTROYED: ; |
; ecx ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv4_route: ; TODO: return error if no valid route found |
ipv4_route: ; TODO: return error if no valid route found |
test ebx, ebx |
jnz .got_device |
961,7 → 962,7 |
.got_device: |
; Validate device ptr and convert to device number |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
cmp edi, -1 |
je .fail |
982,32 → 983,35 |
;--------------------------------------------------------------------------- |
; |
; IPv4_get_frgmnt_num |
; |
; IN: / |
; OUT: fragment number in ax |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv4_get_frgmnt_num ; |
; ; |
; IN: / ; |
; ; |
; OUT: ax = fragment number ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv4_get_frgmnt_num: |
ipv4_get_frgmnt_num: |
xor ax, ax ;;; TODO: replace this with real code |
ret |
;----------------------------------------------------------------- |
; |
; IPv4_connect |
; |
; IN: eax = socket pointer |
; OUT: eax = 0 ok / -1 error |
; ebx = error code |
; |
;------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv4_connect ; |
; ; |
; IN: eax = socket pointer ; |
; ; |
; OUT: eax = 0 on success ; |
; eax = -1 on error ; |
; ebx = error code on error ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv4_connect: |
ipv4_connect: |
push eax edx |
lea ecx, [eax + SOCKET.mutex] |
1031,21 → 1035,19 |
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: |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv4_API: Part of system function 76. ; |
; ; |
; IN: bl = subfunction number ; |
; bh = device number ; |
; ecx, edx, .. depends on subfunction ; |
; ; |
; OUT: depends on subfunction ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv4_api: |
ipv4_api: |
movzx eax, bh |
shl eax, 2 |
1096,9 → 1098,9 |
mov ebx, [NET_DRV_LIST + eax] |
mov eax, [IP_LIST + eax] |
call ARP_output_request ; now send a gratuitous ARP |
call arp_output_request ; now send a gratuitous ARP |
call NET_send_event |
call net_send_event |
xor eax, eax |
ret |
1108,7 → 1110,7 |
.write_dns: |
mov [DNS_LIST + eax], ecx |
call NET_send_event |
call net_send_event |
xor eax, eax |
ret |
1125,7 → 1127,7 |
or ecx, ebx |
mov [BROADCAST_LIST + eax], ecx |
call NET_send_event |
call net_send_event |
xor eax, eax |
ret |
1136,6 → 1138,6 |
.write_gateway: |
mov [GATEWAY_LIST + eax], ecx |
call NET_send_event |
call net_send_event |
xor eax, eax |
ret |
/kernel/branches/Kolibri-acpi/network/IPv6.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5522 $ |
$Revision: 6011 $ |
struct IPv6_header |
45,14 → 45,12 |
endg |
;----------------------------------------------------------------- |
; |
; IPv6_init |
; |
; This function resets all IP variables |
; |
;----------------------------------------------------------------- |
macro IPv6_init { |
;-----------------------------------------------------------------; |
; ; |
; ipv6_init: Resets all IPv6 variables ; |
; ; |
;-----------------------------------------------------------------; |
macro ipv6_init { |
xor eax, eax |
mov edi, IPv6 |
63,25 → 61,23 |
;----------------------------------------------------------------- |
; |
; IPv6_input: |
; |
; Will check if IPv6 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 IPv6 header in edx |
; size of IPv6 packet in ecx |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv6_input: Check if IPv6 Packet isnt damaged and call ; |
; appropriate handler. (TCP/UDP/ICMP/..) ; |
; We will also re-construct fragmented packets ; |
; ; |
; IN: [esp] = ptr to buffer ; |
; [esp+4] = size of buffer ; |
; ebx = ptr to device struct ; |
; edx = ptr to IPv6 header ; |
; ecx = size of IPv6 packet ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv6_input: |
ipv6_input: |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv6_input from: %x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x\n",\ |
[edx + IPv6_header.SourceAddress + 0]:2,[edx + IPv6_header.SourceAddress + 1]:2,\ |
147,7 → 143,7 |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "IPv6_input - dumping\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
.dump_options: |
245,21 → 241,19 |
;--------------------------------------------------------------------------- |
; |
; IPv6_API |
; |
; This function is called by system function 75 |
; |
; IN: subfunction number in bl |
; device number in bh |
; ecx, edx, .. depends on subfunction |
; |
; OUT: |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ipv6_api: Part of system function 76 ; |
; ; |
; IN: bl = subfunction number ; |
; bh = device number ; |
; ecx, edx, .. depends on subfunction ; |
; ; |
; OUT: depends on subfunction ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
IPv6_api: |
ipv6_api: |
movzx eax, bh |
shl eax, 2 |
/kernel/branches/Kolibri-acpi/network/PPPoE.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5522 $ |
$Revision: 6011 $ |
struct PPPoE_frame |
33,37 → 33,33 |
endg |
;----------------------------------------------------------------- |
; |
; PPPoE_init |
; |
; This function resets all IP variables |
; |
;----------------------------------------------------------------- |
macro PPPoE_init { |
;-----------------------------------------------------------------; |
; ; |
; pppoe_init: Reset all pppoe variables ; |
; ; |
;-----------------------------------------------------------------; |
macro pppoe_init { |
call PPPoE_stop_connection |
call pppoe_stop_connection |
} |
;----------------------------------------------------------------- |
; |
; PPPoE discovery input |
; |
; Handler of received Ethernet packet with type = Discovery |
; |
; |
; IN: Pointer to buffer in [esp] |
; size of buffer in [esp+4] |
; pointer to device struct in ebx |
; pointer to PPP header in edx |
; size of PPP packet in ecx |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; pppoe_discovery_input ; |
; ; |
; IN: [esp] = ptr to buffer ; |
; [esp+4] = size of buffer ; |
; ebx = ptr to device struct ; |
; ecx = size of PPP packet ; |
; edx = ptr to PPP header ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
PPPoE_discovery_input: |
pppoe_discovery_input: |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_discovery_input\n" |
97,7 → 93,7 |
mov ecx, [esp + 4] |
mov esi, [esp] |
jmp SOCKET_input |
jmp socket_input |
.dump: |
pusha |
106,22 → 102,21 |
popa |
DEBUGF DEBUG_NETWORK_VERBOSE, 'PPPoE_discovery_input: dumping\n' |
call NET_BUFF_free |
call net_buff_free |
ret |
;-------------------------------------- |
; |
; Send discovery packet |
; |
; IN: eax = socket pointer |
; ecx = number of bytes to send |
; esi = pointer to data |
; |
;-------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; pppoe_discovery_output ; |
; ; |
; IN: eax = socket pointer ; |
; ecx = number of bytes to send ; |
; esi = pointer to data ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
PPPoE_discovery_output: |
pppoe_discovery_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_discovery_output: socket=%x buffer=%x size=%d\n", eax, esi, ecx |
147,7 → 142,7 |
; Create packet. |
push ecx esi |
stdcall kernel_alloc, 1500 |
;;;; FIXME stdcall kernel_alloc, 1500 |
pop esi ecx |
test eax, eax |
jz .bad |
185,23 → 180,21 |
ret |
;----------------------------------------------------------------- |
; |
; PPPoE session input |
; |
; Handler of received Ethernet packet with type = Session |
; |
; |
; IN: Pointer to buffer in [esp] |
; size of buffer in [esp+4] |
; pointer to device struct in ebx |
; pointer to PPP header in edx |
; size of PPP packet in ecx |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; pppoe_session_input ; |
; ; |
; IN: [esp] = ptr to buffer ; |
; [esp+4] = size of buffer ; |
; ebx = ptr to device struct ; |
; edx = ptr to PPP header ; |
; ecx = size of PPP packet ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
PPPoE_session_input: |
pppoe_session_input: |
cmp [edx + PPPoE_frame.VersionAndType], 0x11 |
jne .dump |
221,38 → 214,39 |
add edx, PPPoE_frame.Payload + 2 |
cmp ax, PPP_PROTO_IPv4 |
je IPv4_input |
je ipv4_input |
; cmp ax, PPP_PROTO_IPv6 |
; je IPv6_input |
; je ipv6_input |
jmp PPPoE_discovery_input ; Send LCP,CHAP,CBCP,... packets to the PPP dialer |
jmp pppoe_discovery_input ; Send LCP,CHAP,CBCP,... packets to the PPP dialer |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_input: Unknown protocol=%x\n", ax |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_input: dumping\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
;----------------------------------------------------------------- |
; |
; PPPoE_output |
; |
; IN: ax = protocol |
; ebx = device ptr |
; ecx = packet size |
; |
; OUT: eax = buffer start / 0 on error |
; ebx = device ptr |
; ecx = packet size |
; edx = size of complete buffer |
; edi = start of PPP payload |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; pppoe_output ; |
; ; |
; IN: ax = protocol ; |
; ebx = device ptr ; |
; ecx = packet size ; |
; ; |
; OUT: eax = buffer start ; |
; eax = 0 on error ; |
; ebx = device ptr ; |
; ecx = packet size ; |
; edx = size of complete buffer ; |
; edi = start of PPP payload ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
PPPoE_output: |
pppoe_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_output: size=%u device=%x\n", ecx, ebx |
262,7 → 256,7 |
mov ax, ETHER_PROTO_PPP_SESSION |
add ecx, PPPoE_frame.Payload + 2 |
lea edx, [PPPoE_MAC] |
call ETH_output |
call eth_output |
jz .eth_error |
sub ecx, PPPoE_frame.Payload |
287,9 → 281,9 |
xor eax, eax |
ret |
align 4 |
pppoe_start_connection: |
PPPoE_start_connection: |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_start_connection: %x\n", cx |
cmp [PPPoE_SID], 0 |
308,7 → 302,7 |
align 4 |
PPPoE_stop_connection: |
pppoe_stop_connection: |
DEBUGF DEBUG_NETWORK_VERBOSE, "PPPoE_stop_connection\n" |
320,21 → 314,19 |
ret |
;--------------------------------------------------------------------------- |
; |
; PPPoE API |
; |
; This function is called by system function 75 |
; |
; IN: subfunction number in bl |
; device number in bh |
; ecx, edx, .. depends on subfunction |
; |
; OUT: |
; |
;--------------------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; pppoe_api: Part of system function 76 ; |
; ; |
; IN: subfunction number in bl ; |
; device number in bh ; |
; ecx, edx, .. depends on subfunction ; |
; ; |
; OUT: ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
PPPoE_api: |
pppoe_api: |
movzx eax, bh |
shl eax, 2 |
345,8 → 337,8 |
jmp dword [.table + 4*ebx] |
.table: |
dd PPPoE_start_connection ; 0 |
dd PPPoE_stop_connection ; 1 |
dd pppoe_start_connection ; 0 |
dd pppoe_stop_connection ; 1 |
.number = ($ - .table) / 4 - 1 |
.error: |
/kernel/branches/Kolibri-acpi/network/ethernet.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5522 $ |
$Revision: 6011 $ |
ETH_FRAME_MINIMUM = 60 |
ETH_QUEUE_SIZE = 255 |
50,10 → 50,10 |
ETH_input_event dd ? |
endg |
macro ETH_init { |
macro eth_init { |
movi ebx, 1 |
mov ecx, ETH_process_input |
mov ecx, eth_process_input |
call new_sys_threads |
test eax, eax |
jns @f |
62,20 → 62,18 |
} |
;----------------------------------------------------------------- |
; |
; ETH_input |
; |
; This function is called by ethernet drivers, |
; It pushes the received ethernet packets onto the ethernet input queue |
; |
; IN: [esp] = Pointer to buffer |
; |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; eth_input: This function is called by ethernet drivers. ; |
; Push the received ethernet packet onto the ethernet input queue.; |
; ; |
; IN: [esp] = Pointer to buffer ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ETH_input: |
eth_input: |
pop eax |
pushf |
109,14 → 107,22 |
DEBUGF DEBUG_NETWORK_ERROR, "ETH incoming queue is full, discarding packet!\n" |
popf |
push eax |
call NET_BUFF_free |
call net_buff_free |
ret |
;-----------------------------------------------------------------; |
; ; |
; eth_process_input: Process packets from ethernet input queue. ; |
; ; |
; IN: / ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ETH_process_input: |
eth_process_input: |
xor esi, esi |
mov ecx, MANUAL_DESTROY |
163,44 → 169,46 |
; Place protocol handlers here |
cmp ax, ETHER_PROTO_IPv4 |
je IPv4_input |
je ipv4_input |
cmp ax, ETHER_PROTO_ARP |
je ARP_input |
je arp_input |
; cmp ax, ETHER_PROTO_IPv6 |
; je IPv6_input |
; je ipv6_input |
; cmp ax, ETHER_PROTO_PPP_DISCOVERY |
; je PPPoE_discovery_input |
; je pppoe_discovery_input |
; cmp ax, ETHER_PROTO_PPP_SESSION |
; je PPPoE_session_input |
; je pppoe_session_input |
DEBUGF DEBUG_NETWORK_VERBOSE, "ETH_input: Unknown packet type=%x\n", ax |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ETH_input: dumping\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
;----------------------------------------------------------------- |
; |
; ETH_output |
; |
; IN: ax = protocol |
; ebx = device ptr |
; ecx = payload size |
; edx = pointer to destination mac |
; |
; OUT: eax = start of net frame / 0 on error |
; ebx = device ptr |
; ecx = payload size |
; edi = start of payload |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; eth_output ; |
; ; |
; IN: ax = protocol ; |
; ebx = device ptr ; |
; ecx = payload size ; |
; edx = pointer to destination mac ; |
; ; |
; OUT: eax = start of net frame / 0 on error ; |
; ebx = device ptr ; |
; ecx = payload size ; |
; edi = start of payload ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ETH_output: |
eth_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ETH_output: size=%u device=%x\n", ecx, ebx |
211,7 → 219,7 |
push ax edx |
add ecx, sizeof.ETH_header + NET_BUFF.data |
stdcall NET_BUFF_alloc, ecx |
stdcall net_buff_alloc, ecx |
test eax, eax |
jz .out_of_ram |
mov [eax + NET_BUFF.type], NET_BUFF_ETH |
257,21 → 265,19 |
;----------------------------------------------------------------- |
; |
; ETH_API |
; |
; This function is called by system function 76 |
; |
; IN: subfunction number in bl |
; device number in bh |
; ecx, edx, .. depends on subfunction |
; |
; OUT: |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; eth_api: Part of system function 76. ; |
; ; |
; IN: bl = subfunction number ; |
; bh = device number ; |
; ecx, edx, .. depends on subfunction ; |
; ; |
; OUT: depends on subfunction ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ETH_api: |
eth_api: |
cmp bh, NET_DEVICES_MAX |
ja .error |
/kernel/branches/Kolibri-acpi/network/icmp.inc |
---|
85,7 → 85,6 |
ICMP_PHOTURIS_DECRYPT_FAILED = 3 ; decrypt failed |
struct ICMP_header |
Type db ? |
107,13 → 106,13 |
;----------------------------------------------------------------- |
; |
; ICMP_init |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; ICMP_init ; |
; ; |
;-----------------------------------------------------------------; |
macro ICMP_init { |
macro icmp_init { |
xor eax, eax |
mov edi, ICMP_PACKETS_TX |
123,25 → 122,23 |
} |
;----------------------------------------------------------------- |
; |
; ICMP_input: |
; |
; This procedure will send reply's to ICMP echo's |
; and insert packets into sockets when needed |
; |
; IN: Pointer to buffer in [esp] |
; ebx = pointer to device struct |
; ecx = ICMP Packet size |
; edx = ptr to IPv4 header |
; esi = ptr to ICMP Packet data |
; edi = interface number*4 |
; |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; icmp_input: Send a reply's to an ICMP echo or insert packets ; |
; into socket. ; |
; ; |
; IN: [esp] = ptr to buffer ; |
; ebx = ptr to device struct ; |
; ecx = ICMP Packet size ; |
; edx = ptr to IPv4 header ; |
; esi = ptr to ICMP Packet data ; |
; edi = interface number*4 ; |
; ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ICMP_input: |
icmp_input: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ICMP_input\n" |
204,7 → 201,7 |
call mutex_lock |
popa |
jmp SOCKET_input |
jmp socket_input |
274,7 → 271,7 |
test eax, eax |
jnz @f |
DEBUGF DEBUG_NETWORK_VERBOSE, "ICMP transmit failed\n" |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [ICMP_PACKETS_TX + edi] |
@@: |
ret |
293,26 → 290,26 |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "ICMP_input: dumping\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
if 0 |
;----------------------------------------------------------------- |
; |
; ICMP_output |
; |
; IN: eax = dest ip |
; bh = type |
; bl = code |
; ecx = data length |
; edx = source ip |
; esi = data offset |
; edi = identifier shl 16 + sequence number |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; icmp_output ; |
; ; |
; IN: eax = dest ip ; |
; bh = type ; |
; bl = code ; |
; ecx = data length ; |
; edx = source ip ; |
; esi = data offset ; |
; edi = identifier shl 16 + sequence number ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ICMP_output: |
icmp_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "Creating ICMP Packet\n" |
364,17 → 361,17 |
;----------------------------------------------------------------- |
; |
; ICMP_output_raw |
; |
; IN: eax = socket ptr |
; ecx = data length |
; edx = data pointer |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; icmp_output_raw ; |
; ; |
; IN: eax = socket ptr ; |
; ecx = data length ; |
; edx = data pointer ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ICMP_output_raw: |
icmp_output_raw: |
DEBUGF DEBUG_NETWORK_VERBOSE, "Creating ICMP Packet for socket %x, data ptr=%x\n", eax, edx |
384,7 → 381,7 |
mov edi, [eax + IP_SOCKET.RemoteIP] |
mov al, [eax + IP_SOCKET.ttl] |
mov ah, IP_PROTO_ICMP |
call IPv4_output |
call ipv4_output |
jz .fail |
pop esi |
407,7 → 404,7 |
call [ebx + NET_DEVICE.transmit] |
test eax, eax |
jnz @f |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [ICMP_PACKETS_TX + edi] |
@@: |
ret |
422,21 → 419,19 |
;----------------------------------------------------------------- |
; |
; ICMP_API |
; |
; This function is called by system function 75 |
; |
; IN: subfunction number in bl |
; device number in bh |
; ecx, edx, .. depends on subfunction |
; |
; OUT: |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; icmp_api: Part of system function 76. ; |
; ; |
; IN: bl = subfunction number ; |
; bh = device number ; |
; ecx, edx, .. depends on subfunction ; |
; ; |
; OUT: depends on subfunction ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
ICMP_api: |
icmp_api: |
movzx eax, bh |
shl eax, 2 |
/kernel/branches/Kolibri-acpi/network/loopback.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5976 $ |
$Revision: 6011 $ |
iglobal |
align 4 |
27,7 → 27,7 |
.unload dd .dummy_fn |
.reset dd .dummy_fn |
.transmit dd LOOP_input |
.transmit dd loop_input |
.bytes_tx dq 0 |
.bytes_rx dq 0 |
45,11 → 45,11 |
endg |
macro LOOP_init { |
macro loop_init { |
local .fail |
mov ebx, LOOPBACK_DEVICE |
call NET_add_device |
call net_add_device |
cmp eax, -1 |
je .fail |
63,7 → 63,7 |
;-----------------------------------------------------------------; |
; ; |
; LOOP_input ; |
; loop_input ; |
; ; |
; IN: [esp+4] = Pointer to buffer ; |
; ; |
71,7 → 71,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
LOOP_input: |
loop_input: |
mov eax, [esp+4] |
95,19 → 95,19 |
; Place protocol handlers here |
cmp eax, AF_INET4 |
je IPv4_input |
je ipv4_input |
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_input: Unknown packet type=%x\n", eax |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_input: dumping\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
;-----------------------------------------------------------------; |
; ; |
; LOOP_output ; |
; loop_output ; |
; ; |
; IN: ecx = packet size ; |
; edi = address family ; |
119,7 → 119,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
LOOP_output: |
loop_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "LOOP_output\n" |
128,7 → 128,7 |
push ecx edi |
add ecx, NET_BUFF.data |
stdcall NET_BUFF_alloc, ecx |
stdcall net_buff_alloc, ecx |
test eax, eax |
jz .out_of_ram |
/kernel/branches/Kolibri-acpi/network/socket.inc |
---|
207,10 → 207,10 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_init ; |
; socket_init ; |
; ; |
;-----------------------------------------------------------------; |
macro SOCKET_init { |
macro socket_init { |
xor eax, eax |
mov edi, net_sockets |
251,7 → 251,7 |
mov dword[esp+20], 0 ; Set error code to 0 |
cmp ebx, 255 |
jz SOCKET_debug |
jz socket_debug |
cmp ebx, .number |
ja .error |
258,17 → 258,17 |
jmp dword [.table + 4*ebx] |
.table: |
dd SOCKET_open ; 0 |
dd SOCKET_close ; 1 |
dd SOCKET_bind ; 2 |
dd SOCKET_listen ; 3 |
dd SOCKET_connect ; 4 |
dd SOCKET_accept ; 5 |
dd SOCKET_send ; 6 |
dd SOCKET_receive ; 7 |
dd SOCKET_set_opt ; 8 |
dd SOCKET_get_opt ; 9 |
dd SOCKET_pair ; 10 |
dd socket_open ; 0 |
dd socket_close ; 1 |
dd socket_bind ; 2 |
dd socket_listen ; 3 |
dd socket_connect ; 4 |
dd socket_accept ; 5 |
dd socket_send ; 6 |
dd socket_receive ; 7 |
dd socket_set_opt ; 8 |
dd socket_get_opt ; 9 |
dd socket_pair ; 10 |
.number = ($ - .table) / 4 - 1 |
.error: |
279,7 → 279,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_open: Create a new socket. ; |
; socket_open: Create a new socket. ; |
; ; |
; IN: ecx = domain ; |
; edx = type ; |
291,12 → 291,12 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_open: |
socket_open: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_open: domain=%u type=%u protocol=%x ", ecx, edx, esi |
push ecx edx esi |
call SOCKET_alloc |
call socket_alloc |
pop esi edx ecx |
test eax, eax |
jz .nobuffs |
339,7 → 339,7 |
.no_ppp: |
.unsupported: |
push eax |
call SOCKET_free |
call socket_free |
pop eax |
mov dword[esp+20], EOPNOTSUPP |
mov dword[esp+32], -1 |
366,19 → 366,19 |
pop eax |
mov [eax + SOCKET.Protocol], IP_PROTO_UDP |
mov [eax + SOCKET.snd_proc], SOCKET_send_udp |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram |
mov [eax + SOCKET.connect_proc], UDP_connect |
mov [eax + SOCKET.snd_proc], socket_send_udp |
mov [eax + SOCKET.rcv_proc], socket_receive_dgram |
mov [eax + SOCKET.connect_proc], udp_connect |
ret |
align 4 |
.tcp: |
mov [eax + SOCKET.Protocol], IP_PROTO_TCP |
mov [eax + SOCKET.snd_proc], SOCKET_send_tcp |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_stream |
mov [eax + SOCKET.connect_proc], TCP_connect |
mov [eax + SOCKET.snd_proc], socket_send_tcp |
mov [eax + SOCKET.rcv_proc], socket_receive_stream |
mov [eax + SOCKET.connect_proc], tcp_connect |
TCP_init_socket eax |
tcp_init_socket eax |
ret |
388,9 → 388,9 |
init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue |
pop eax |
mov [eax + SOCKET.snd_proc], SOCKET_send_ip |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram |
mov [eax + SOCKET.connect_proc], IPv4_connect |
mov [eax + SOCKET.snd_proc], socket_send_ip |
mov [eax + SOCKET.rcv_proc], socket_receive_dgram |
mov [eax + SOCKET.connect_proc], ipv4_connect |
ret |
400,9 → 400,9 |
init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue |
pop eax |
mov [eax + SOCKET.snd_proc], SOCKET_send_icmp |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram |
mov [eax + SOCKET.connect_proc], IPv4_connect |
mov [eax + SOCKET.snd_proc], socket_send_icmp |
mov [eax + SOCKET.rcv_proc], socket_receive_dgram |
mov [eax + SOCKET.connect_proc], ipv4_connect |
ret |
align 4 |
411,14 → 411,14 |
init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue |
pop eax |
mov [eax + SOCKET.snd_proc], SOCKET_send_pppoe |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram |
mov [eax + SOCKET.snd_proc], socket_send_pppoe |
mov [eax + SOCKET.rcv_proc], socket_receive_dgram |
ret |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_bind: Bind to a local port. ; |
; socket_bind: Bind to a local port. ; |
; ; |
; IN: ecx = socket number ; |
; edx = pointer to sockaddr struct ; |
430,11 → 430,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_bind: |
socket_bind: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
479,7 → 479,6 |
.tcp: |
.udp: |
pushd [edx + 4] ; First, fill in the IP |
popd [eax + IP_SOCKET.LocalIP] |
486,11 → 485,11 |
mov bx, [edx + 2] ; Did caller specify a local port? |
test bx, bx |
jnz .just_check |
call SOCKET_find_port ; Nope, find an ephemeral one |
call socket_find_port ; Nope, find an ephemeral one |
jmp .done |
.just_check: |
call SOCKET_check_port ; Yes, check if it's still available |
call socket_check_port ; Yes, check if it's still available |
jz .addrinuse ; ZF is set by socket_check_port on error |
.done: |
511,7 → 510,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_connect: Connect to the remote host. ; |
; socket_connect: Connect to the remote host. ; |
; ; |
; IN: ecx = socket number ; |
; edx = pointer to sockaddr struct ; |
523,11 → 522,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_connect: |
socket_connect: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
572,7 → 571,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_listen: Listen for incoming connections. ; |
; socket_listen: Listen for incoming connections. ; |
; ; |
; IN: ecx = socket number ; |
; edx = backlog in edx ; |
583,11 → 582,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_listen: |
socket_listen: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_listen: socknum=%u backlog=%u\n", ecx, edx |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
641,7 → 640,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_accept: Accept an incoming connection. ; |
; socket_accept: Accept an incoming connection. ; |
; ; |
; IN: ecx = socket number (of listening socket) ; |
; edx = ptr to sockaddr struct ; |
653,11 → 652,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_accept: |
socket_accept: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_accept: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
677,7 → 676,7 |
mov eax, [esi] |
; Verify that it is (still) a valid socket |
call SOCKET_check |
call socket_check |
jz .invalid |
; Change sockets thread owner ID to that of the current thread |
694,7 → 693,7 |
test [eax + SOCKET.options], SO_NONBLOCK |
jnz .wouldblock |
call SOCKET_block |
call socket_block |
jmp .loop |
.wouldblock: |
714,7 → 713,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_close: Close the socket (and connection). ; |
; socket_close: Close the socket (and connection). ; |
; ; |
; IN: ecx = socket number ; |
; ; |
724,11 → 723,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_close: |
socket_close: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_close: socknum=%u\n", ecx |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
738,7 → 737,7 |
test [eax + SOCKET.state], SS_BLOCKED ; Is the socket still in blocked state? |
jz @f |
call SOCKET_notify ; Unblock it. |
call socket_notify ; Unblock it. |
@@: |
cmp [eax + SOCKET.Domain], AF_INET4 |
748,15 → 747,15 |
je .tcp |
.free: |
call SOCKET_free |
call socket_free |
ret |
.tcp: |
call TCP_usrclosed |
call tcp_usrclosed |
test eax, eax |
jz @f |
call TCP_output ; If connection is not closed yet, send the FIN |
call tcp_output ; If connection is not closed yet, send the FIN |
@@: |
ret |
769,7 → 768,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_receive: Receive some data from the remote end. ; |
; socket_receive: Receive some data from the remote end. ; |
; ; |
; IN: ecx = socket number ; |
; edx = addr to application buffer ; |
783,11 → 782,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_receive: |
socket_receive: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_receive: socknum=%u bufaddr=%x buflength=%u flags=%x\n", ecx, edx, esi, edi |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
808,7 → 807,7 |
test [eax + SOCKET.options], SO_NONBLOCK |
jnz .return_err |
call SOCKET_block |
call socket_block |
jmp .loop |
825,7 → 824,7 |
.last_data: |
test ecx, ecx |
jz .return |
call SOCKET_notify ; Call me again! |
call socket_notify ; Call me again! |
jmp .return |
832,7 → 831,7 |
align 4 |
SOCKET_receive_dgram: |
socket_receive_dgram: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_receive: DGRAM\n" |
868,11 → 867,11 |
rep movsd |
.nd: |
call NET_BUFF_free |
call net_buff_free |
pop ecx eax ; return number of bytes copied to application |
cmp [eax + SOCKET_QUEUE_LOCATION + queue.size], 0 |
je @f |
call SOCKET_notify ; Queue another network event |
call socket_notify ; Queue another network event |
@@: |
xor ebx, ebx ; errorcode = 0 (no error) |
ret |
900,7 → 899,7 |
align 4 |
SOCKET_receive_local: |
socket_receive_local: |
; does this socket have a PID yet? |
cmp [eax + SOCKET.PID], 0 |
913,12 → 912,12 |
mov [eax + SOCKET.TID], ebx ; currently TID = PID in kolibrios :( |
@@: |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_stream |
mov [eax + SOCKET.rcv_proc], socket_receive_stream |
; ... continue to SOCKET_receive_stream |
align 4 |
SOCKET_receive_stream: |
socket_receive_stream: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_receive: STREAM\n" |
934,8 → 933,8 |
push eax |
add eax, STREAM_SOCKET.rcv |
call SOCKET_ring_read ; copy data from kernel buffer to application buffer |
call SOCKET_ring_free ; free read memory |
call socket_ring_read ; copy data from kernel buffer to application buffer |
call socket_ring_free ; free read memory |
pop eax |
cmp [eax + STREAM_SOCKET.rcv + RING_BUFFER.size], 0 |
944,7 → 943,7 |
ret |
.more_data: |
call SOCKET_notify ; Queue another network event |
call socket_notify ; Queue another network event |
xor ebx, ebx ; errorcode = 0 (no error) |
ret |
962,7 → 961,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_send: Send some data to the remote end. ; |
; socket_send: Send some data to the remote end. ; |
; ; |
; IN: ecx = socket number ; |
; edx = pointer to data ; |
975,11 → 974,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_send: |
socket_send: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: socknum=%u data ptr=%x length=%u flags=%x\n", ecx, edx, esi, edi |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
995,12 → 994,12 |
align 4 |
SOCKET_send_udp: |
socket_send_udp: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: UDP\n" |
mov [esp+32], ecx |
call UDP_output |
call udp_output |
cmp eax, -1 |
je .error |
ret |
1012,19 → 1011,19 |
align 4 |
SOCKET_send_tcp: |
socket_send_tcp: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: TCP\n" |
push eax |
add eax, STREAM_SOCKET.snd |
call SOCKET_ring_write |
call socket_ring_write |
pop eax |
mov [esp+32], ecx |
mov [eax + SOCKET.errorcode], 0 |
push eax |
call TCP_output ; FIXME: this doesnt look pretty, does it? |
call tcp_output ; FIXME: this doesnt look pretty, does it? |
pop eax |
mov eax, [eax + SOCKET.errorcode] |
mov [esp+20], eax |
1032,12 → 1031,12 |
align 4 |
SOCKET_send_ip: |
socket_send_ip: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: IPv4\n" |
mov [esp+32], ecx |
call IPv4_output_raw |
call ipv4_output_raw |
cmp eax, -1 |
je .error |
ret |
1049,12 → 1048,12 |
align 4 |
SOCKET_send_icmp: |
socket_send_icmp: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: ICMP\n" |
mov [esp+32], ecx |
call ICMP_output_raw |
call icmp_output_raw |
cmp eax, -1 |
je .error |
ret |
1066,7 → 1065,7 |
align 4 |
SOCKET_send_pppoe: |
socket_send_pppoe: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: PPPoE\n" |
1073,7 → 1072,7 |
mov [esp+32], ecx |
mov ebx, [eax + SOCKET.device] |
call PPPoE_discovery_output ; FIXME: errorcodes |
call pppoe_discovery_output ; FIXME: errorcodes |
cmp eax, -1 |
je .error |
ret |
1086,7 → 1085,7 |
align 4 |
SOCKET_send_local: |
socket_send_local: |
; does this socket have a PID yet? |
cmp [eax + SOCKET.PID], 0 |
1098,22 → 1097,22 |
mov [eax + SOCKET.PID], ebx |
mov [eax + SOCKET.TID], ebx ; currently TID = PID in kolibrios :( |
@@: |
mov [eax + SOCKET.snd_proc], SOCKET_send_local_ |
mov [eax + SOCKET.snd_proc], socket_send_local_initialized |
align 4 |
SOCKET_send_local_: |
socket_send_local_initialized: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_send: LOCAL\n" |
; get the other side's socket and check if it still exists |
mov eax, [eax + SOCKET.device] |
call SOCKET_check |
call socket_check |
jz .invalid |
; allright, shove in the data! |
push eax |
add eax, STREAM_SOCKET.rcv |
call SOCKET_ring_write |
call socket_ring_write |
pop eax |
; return the number of written bytes (or errorcode) to application |
1120,7 → 1119,7 |
mov [esp+32], ecx |
; and notify the other end |
call SOCKET_notify |
call socket_notify |
ret |
1132,7 → 1131,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_get_options: Read a socket option ; |
; socket_get_opt: Read a socket option ; |
; ; |
; IN: ecx = socket number ; |
; edx = pointer to socket options struct ; |
1143,7 → 1142,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_get_opt: |
socket_get_opt: |
; FIXME: |
; At moment, uses only pseudo-optname -2 for get last_ack_number for TCP. |
1152,7 → 1151,7 |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_get_opt\n" |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
1194,7 → 1193,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_set_options: Set a socket option. ; |
; socket_set_options: Set a socket option. ; |
; ; |
; IN: ecx = socket number ; |
; edx = pointer to socket options struct ; |
1205,11 → 1204,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_set_opt: |
socket_set_opt: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt\n" |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
1272,7 → 1271,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_pair: Allocate a pair of linked local sockets. ; |
; socket_pair: Allocate a pair of linked local sockets. ; |
; ; |
; IN: / ; |
; ; |
1283,11 → 1282,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_pair: |
socket_pair: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_pair\n" |
call SOCKET_alloc |
call socket_alloc |
test eax, eax |
jz .nomem1 |
mov [esp+32], edi ; application's eax |
1295,12 → 1294,12 |
mov [eax + SOCKET.Domain], AF_LOCAL |
mov [eax + SOCKET.Type], SOCK_STREAM |
mov [eax + SOCKET.Protocol], 0 ;;; CHECKME |
mov [eax + SOCKET.snd_proc], SOCKET_send_local |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_local |
mov [eax + SOCKET.snd_proc], socket_send_local |
mov [eax + SOCKET.rcv_proc], socket_receive_local |
mov [eax + SOCKET.PID], 0 |
mov ebx, eax |
call SOCKET_alloc |
call socket_alloc |
test eax, eax |
jz .nomem2 |
mov [esp+20], edi ; application's ebx |
1308,8 → 1307,8 |
mov [eax + SOCKET.Domain], AF_LOCAL |
mov [eax + SOCKET.Type], SOCK_STREAM |
mov [eax + SOCKET.Protocol], 0 ;;; CHECKME |
mov [eax + SOCKET.snd_proc], SOCKET_send_local |
mov [eax + SOCKET.rcv_proc], SOCKET_receive_local |
mov [eax + SOCKET.snd_proc], socket_send_local |
mov [eax + SOCKET.rcv_proc], socket_receive_local |
mov [eax + SOCKET.PID], 0 |
; Link the two sockets to eachother |
1317,12 → 1316,12 |
mov [ebx + SOCKET.device], eax |
lea eax, [eax + STREAM_SOCKET.rcv] |
call SOCKET_ring_create |
call socket_ring_create |
test eax, eax |
jz .nomem2 |
lea eax, [ebx + STREAM_SOCKET.rcv] |
call SOCKET_ring_create |
call socket_ring_create |
test eax, eax |
jz .nomem2 |
1330,11 → 1329,11 |
.nomem2: |
mov eax, [esp+20] |
call SOCKET_free |
call socket_free |
.nomem1: |
mov eax, [esp+32] |
call SOCKET_free |
call socket_free |
mov dword[esp+32], -1 |
mov dword[esp+20], ENOMEM |
1344,7 → 1343,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_debug: Copy socket variables to application buffer. ; |
; socket_debug: Copy socket variables to application buffer. ; |
; ; |
; IN: ecx = socket number ; |
; edx = pointer to application buffer ; |
1355,7 → 1354,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_debug: |
socket_debug: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_debug\n" |
1364,7 → 1363,7 |
test ecx, ecx |
jz .returnall |
call SOCKET_num_to_ptr |
call socket_num_to_ptr |
test eax, eax |
jz .invalid |
1407,7 → 1406,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_find_port: ; |
; socket_find_port: ; |
; Fill in the local port number for TCP and UDP sockets ; |
; This procedure always works because the number of sockets is ; |
; limited to a smaller number then the number of possible ports ; |
1418,7 → 1417,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_find_port: |
socket_find_port: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_find_port\n" |
1459,7 → 1458,7 |
add bh, 1 |
adc bl, 0 |
call SOCKET_check_port |
call socket_check_port |
jz .findit |
ret |
1467,11 → 1466,10 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_check_port (to be used with AF_INET only!) ; |
; ; |
; socket_check_port: (to be used with AF_INET only!) ; |
; Checks if a local port number is unused ; |
; If the proposed port number is unused, it is filled in in the ; |
; socket structure ; |
; socket structure. ; |
; ; |
; IN: eax = socket ptr ; |
; bx = proposed socket number (network byte order) ; |
1480,7 → 1478,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_check_port: |
socket_check_port: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_check_port: " |
1530,7 → 1528,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_input: Update a (stateless) socket with received data. ; |
; socket_input: Update a (stateless) socket with received data. ; |
; ; |
; Note: The socket's mutex should already be set ! ; |
; ; |
1543,7 → 1541,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_input: |
socket_input: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_input: socket=%x, data=%x size=%u\n", eax, esi, ecx |
1551,7 → 1549,7 |
push esi |
mov esi, esp |
add_to_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, SOCKET_input.full |
add_to_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, .full |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_input: success\n" |
add esp, sizeof.socket_queue_entry |
1561,7 → 1559,7 |
call mutex_unlock |
popa |
jmp SOCKET_notify |
jmp socket_notify |
.full: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_input: socket %x is full!\n", eax |
1572,13 → 1570,13 |
popa |
add esp, 8 |
call NET_BUFF_free |
call net_buff_free |
ret |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_ring_create: Create a ringbuffer for sockets. ; |
; socket_ring_create: Create a ringbuffer for sockets. ; |
; ; |
; IN: eax = ptr to ring struct ; |
; ; |
1587,7 → 1585,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_ring_create: |
socket_ring_create: |
push esi |
mov esi, eax |
1623,7 → 1621,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_ring_write: Write data to ring buffer. ; |
; socket_ring_write: Write data to ring buffer. ; |
; ; |
; IN: eax = ptr to ring struct ; |
; ecx = data size ; |
1633,7 → 1631,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_ring_write: |
socket_ring_write: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_ring_write: ringbuff=%x ptr=%x size=%u\n", eax, esi, ecx |
1693,7 → 1691,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_ring_read: Read from ring buffer ; |
; socket_ring_read: Read from ring buffer ; |
; ; |
; IN: eax = ring struct ptr ; |
; ecx = bytes to read ; |
1708,7 → 1706,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_ring_read: |
socket_ring_read: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_ring_read: ringbuff=%x ptr=%x size=%u offset=%x\n", eax, edi, ecx, edx |
1767,7 → 1765,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_ring_free: Free data from a ringbuffer ; |
; socket_ring_free: Free data from a ringbuffer. ; |
; ; |
; IN: eax = ptr to ring struct ; |
; ecx = data size ; |
1776,7 → 1774,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_ring_free: |
socket_ring_free: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_ring_free: %u bytes from ring %x\n", ecx, eax |
1817,7 → 1815,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_block: Suspend the thread attached to a socket. ; |
; socket_block: Suspend the thread attached to a socket. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
1825,7 → 1823,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_block: |
socket_block: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_block: %x\n", eax |
1859,7 → 1857,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_notify: Wake up socket owner thread. ; |
; socket_notify: Wake up socket owner thread. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
1867,11 → 1865,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_notify: |
socket_notify: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_notify: %x\n", eax |
call SOCKET_check |
call socket_check |
jz .error |
; Find the associated thread's TASK_DATA |
1927,10 → 1925,9 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_alloc: ; |
; Allocate memory for socket and put new socket into the list. ; |
; Newly created socket is initialized with calling PID and socket ; |
; number. ; |
; socket_alloc: Allocate memory for socket and put new socket ; |
; into the list. Newly created socket is initialized with calling ; |
; PID and given a socket number. ; |
; ; |
; IN: / ; |
; ; |
1940,7 → 1937,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_alloc: |
socket_alloc: |
push ebx |
2045,9 → 2042,8 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_free: ; |
; Free socket data memory and remove socket from the list. ; |
; Caller should lock and unlock socket_mutex. ; |
; socket_free: Free socket data memory and remove socket from ; |
; the list. Caller should lock and unlock socket_mutex. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2055,11 → 2051,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_free: |
socket_free: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_free: %x\n", eax |
call SOCKET_check |
call socket_check |
jz .error |
push ebx |
2117,7 → 2113,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_fork: Create a child socket. ; |
; socket_fork: Create a child socket. ; |
; ; |
; IN: ebx = socket number ; |
; ; |
2126,7 → 2122,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_fork: |
socket_fork: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_fork: %x\n", ebx |
2137,7 → 2133,7 |
; Allocate new socket |
push ebx |
call SOCKET_alloc |
call socket_alloc |
pop ebx |
test eax, eax |
jz .fail |
2160,7 → 2156,7 |
; Notify owner of parent socket |
push eax |
mov eax, ebx |
call SOCKET_notify |
call socket_notify |
pop eax |
ret |
2175,7 → 2171,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_num_to_ptr: Get socket structure address by its number. ; |
; socket_num_to_ptr: Get socket structure address by its number. ; |
; ; |
; IN: ecx = socket number ; |
; ; |
2184,7 → 2180,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_num_to_ptr: |
socket_num_to_ptr: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_num_to_ptr: num=%u ", ecx |
2222,7 → 2218,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_ptr_to_num: Get socket number by its address. ; |
; socket_ptr_to_num: Get socket number by its address. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2232,11 → 2228,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_ptr_to_num: |
socket_ptr_to_num: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_ptr_to_num: ptr=%x ", eax |
call SOCKET_check |
call socket_check |
jz .error |
mov eax, [eax + SOCKET.Number] |
2251,7 → 2247,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_check: Checks if the given ptr is really a socket ptr. ; |
; socket_check: Checks if the given ptr is really a socket ptr. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2260,7 → 2256,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_check: |
socket_check: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_check: %x\n", eax |
2291,7 → 2287,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_check_owner: Check if the caller app owns the socket. ; |
; socket_check_owner: Check if the caller app owns the socket. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2299,7 → 2295,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_check_owner: |
socket_check_owner: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_check_owner: %x\n", eax |
2316,10 → 2312,9 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_process_end: ; |
; Kernel calls this function when a certain process ends. ; |
; This function will check if the process had any open sockets, ; |
; and update them accordingly (clean up). ; |
; socket_process_end: Kernel calls this function when a certain ; |
; process ends. This function will check if the process had any ; |
; open sockets and update them accordingly (clean up). ; |
; ; |
; IN: edx = pid ; |
; ; |
2327,7 → 2322,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_process_end: |
socket_process_end: |
ret ; FIXME |
2368,11 → 2363,11 |
cmp [eax + SOCKET.Protocol], IP_PROTO_TCP |
jne .free |
call TCP_disconnect |
call tcp_disconnect |
jmp .closed |
.free: |
call SOCKET_free |
call socket_free |
.closed: |
popa |
2394,7 → 2389,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_is_connecting: Update socket state. ; |
; socket_is_connecting: Update socket state. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2402,7 → 2397,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_is_connecting: |
socket_is_connecting: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_is_connecting: %x\n", eax |
2414,7 → 2409,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_is_connected: Update socket state. ; |
; socket_is_connected: Update socket state. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2422,13 → 2417,13 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_is_connected: |
socket_is_connected: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_is_connected: %x\n", eax |
and [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING) |
or [eax + SOCKET.state], SS_ISCONNECTED |
jmp SOCKET_notify |
jmp socket_notify |
2435,7 → 2430,7 |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_is_disconnecting: Update socket state. ; |
; socket_is_disconnecting: Update socket state. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2443,19 → 2438,19 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_is_disconnecting: |
socket_is_disconnecting: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnecting: %x\n", eax |
and [eax + SOCKET.state], not (SS_ISCONNECTING) |
or [eax + SOCKET.state], SS_ISDISCONNECTING + SS_CANTRCVMORE + SS_CANTSENDMORE |
jmp SOCKET_notify |
jmp socket_notify |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_is_disconnected: Update socket state. ; |
; socket_is_disconnected: Update socket state. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2463,19 → 2458,19 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_is_disconnected: |
socket_is_disconnected: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnected: %x\n", eax |
and [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING) |
or [eax + SOCKET.state], SS_CANTRCVMORE + SS_CANTSENDMORE |
jmp SOCKET_notify |
jmp socket_notify |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_cant_recv_more: Update socket state. ; |
; socket_cant_recv_more: Update socket state. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2483,18 → 2478,18 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_cant_recv_more: |
socket_cant_recv_more: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_cant_recv_more: %x\n", eax |
or [eax + SOCKET.state], SS_CANTRCVMORE |
jmp SOCKET_notify |
jmp socket_notify |
;-----------------------------------------------------------------; |
; ; |
; SOCKET_cant_send_more: Update socket state. ; |
; socket_cant_send_more: Update socket state. ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
2502,13 → 2497,13 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
SOCKET_cant_send_more: |
socket_cant_send_more: |
DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_cant_send_more: %x\n", eax |
or [eax + SOCKET.state], SS_CANTSENDMORE |
mov [eax + SOCKET.snd_proc], .notconn |
jmp SOCKET_notify |
jmp socket_notify |
.notconn: |
mov dword[esp+20], ENOTCONN |
/kernel/branches/Kolibri-acpi/network/stack.inc |
---|
258,16 → 258,14 |
endg |
;----------------------------------------------------------------- |
; |
; stack_init |
; |
; This function calls all network init procedures |
; |
; IN: / |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; stack_init: Initialize all network variables ; |
; ; |
; IN: / ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
stack_init: |
294,21 → 292,21 |
mov ecx, (NET_DEVICES_MAX + 1) |
rep stosd |
ETH_init |
eth_init |
PPPoE_init |
pppoe_init |
IPv4_init |
; IPv6_init |
ICMP_init |
ipv4_init |
; ipv6_init |
icmp_init |
ARP_init |
UDP_init |
TCP_init |
arp_init |
udp_init |
tcp_init |
SOCKET_init |
socket_init |
LOOP_init |
loop_init |
mov [net_tmr_count], 0 |
ret |
329,16 → 327,14 |
endp |
;----------------------------------------------------------------- |
; |
; stack_handler |
; |
; This function is called in kernel loop |
; |
; IN: / |
; OUT: / |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; stack_handler: Network handlers called from os_loop. ; |
; ; |
; IN: / ; |
; OUT: / ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
stack_handler: |
354,13 → 350,13 |
test [net_10ms], 0x0f ; 160ms |
jnz .exit |
TCP_timer_160ms |
tcp_timer_160ms |
test [net_10ms], 0x3f ; 640ms |
jnz .exit |
ARP_decrease_entry_ttls |
IPv4_decrease_fragment_ttls |
arp_decrease_entry_ttls |
ipv4_decrease_fragment_ttls |
xor edx, edx |
mov eax, [TCP_timer1_event] |
373,7 → 369,8 |
align 4 |
proc NET_BUFF_alloc stdcall, buffersize |
proc net_buff_alloc stdcall, buffersize |
cmp [buffersize], NET_BUFFER_SIZE |
ja .too_large |
387,7 → 384,7 |
spin_unlock_irqrestore |
DEBUGF DEBUG_NETWORK_VERBOSE, "net alloc: 0x%x\n", eax |
DEBUGF DEBUG_NETWORK_VERBOSE, "net_buff_alloc: 0x%x\n", eax |
ret |
.out_of_mem: |
394,20 → 391,20 |
spin_unlock_irqrestore |
xor eax, eax |
DEBUGF DEBUG_NETWORK_ERROR, "NET_BUFF_alloc: out of mem!\n" |
DEBUGF DEBUG_NETWORK_ERROR, "net_buff_alloc: out of mem!\n" |
ret |
.too_large: |
xor eax, eax |
DEBUGF DEBUG_NETWORK_ERROR, "NET_BUFF_alloc: too large!\n" |
DEBUGF DEBUG_NETWORK_ERROR, "net_buff_alloc: too large!\n" |
ret |
endp |
align 4 |
proc NET_BUFF_free stdcall, buffer |
proc net_buff_free stdcall, buffer |
DEBUGF DEBUG_NETWORK_VERBOSE, "net free: 0x%x\n", [buffer] |
DEBUGF DEBUG_NETWORK_VERBOSE, "net_buff_free: 0x%x\n", [buffer] |
spin_lock_irqsave |
423,14 → 420,14 |
align 4 |
NET_link_changed: |
net_link_changed: |
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.link_state] |
DEBUGF DEBUG_NETWORK_VERBOSE, "net_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.link_state] |
align 4 |
NET_send_event: |
net_send_event: |
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_send_event\n" |
DEBUGF DEBUG_NETWORK_VERBOSE, "net_send_event\n" |
; Send event to all applications |
push edi ecx |
446,21 → 443,20 |
;----------------------------------------------------------------- |
; |
; NET_add_device: |
; |
; This function is called by the network drivers, |
; to register each running NIC to the kernel |
; |
; IN: Pointer to device structure in ebx |
; OUT: Device num in eax, -1 on error |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; net_add_device: Called by network driver to register interface. ; |
; ; |
; IN: ebx = ptr to device structure ; |
; ; |
; OUT: eax = device num on success ; |
; eax = -1 on error ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
NET_add_device: |
net_add_device: |
DEBUGF DEBUG_NETWORK_VERBOSE, "NET_Add_Device: %x\n", ebx ;;; TODO: use mutex to lock net device list |
DEBUGF DEBUG_NETWORK_VERBOSE, "net_add_device: %x\n", ebx ;;; TODO: use mutex to lock net device list |
cmp [NET_RUNNING], NET_DEVICES_MAX |
jae .error |
495,7 → 491,7 |
inc [NET_RUNNING] ; Indicate that one more network device is up and running |
call NET_send_event |
call net_send_event |
DEBUGF DEBUG_NETWORK_VERBOSE, "Device number: %u\n", eax |
ret |
507,19 → 503,17 |
;----------------------------------------------------------------- |
; |
; NET_Remove_Device: |
; |
; This function is called by network drivers, |
; to unregister network devices from the kernel |
; |
; IN: Pointer to device structure in ebx |
; OUT: eax: -1 on error |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; net_remove_device: Called by network driver to unregister dev. ; |
; ; |
; IN: ebx = ptr to device ; |
; ; |
; OUT: eax: -1 on error ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
NET_remove_device: |
net_remove_device: |
cmp [NET_RUNNING], 0 |
je .error |
541,7 → 535,7 |
mov dword [edi-4], eax |
dec [NET_RUNNING] |
call NET_send_event |
call net_send_event |
xor eax, eax |
ret |
552,18 → 546,20 |
;----------------------------------------------------------------- |
; |
; NET_ptr_to_num |
; |
; IN: ebx = ptr to device struct |
; OUT: edi = -1 on error, device number otherwise |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; net_ptr_to_num ; |
; ; |
; IN: ebx = ptr to device struct ; |
; ; |
; OUT: edi = device number ; |
; edi = -1 on error ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
NET_ptr_to_num: |
net_ptr_to_num: |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
ror edi, 2 ; If -1, stay -1 |
; valid device numbers have last two bits 0, so do just shr |
570,7 → 566,7 |
ret |
align 4 |
NET_ptr_to_num4: ; Todo, place number in device structure so we only need to verify? |
net_ptr_to_num4: ; Todo, place number in device structure so we only need to verify? |
test ebx, ebx |
jz .fail |
595,21 → 591,17 |
pop ecx |
ret |
;----------------------------------------------------------------- |
; |
; checksum_1 |
; |
; This is the first of two functions needed to calculate a checksum. |
; |
; IN: edx = start offset for semi-checksum |
; esi = pointer to data |
; ecx = data size |
; OUT: edx = semi-checksum |
; |
; |
; Code was optimized by diamond |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; checksum_1: Calculate semi-checksum for network packets. ; |
; ; |
; IN: edx = start offset for semi-checksum ; |
; esi = pointer to data ; |
; ecx = data size ; |
; ; |
; OUT: edx = semi-checksum ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
checksum_1: |
679,16 → 671,15 |
.end: |
ret |
;----------------------------------------------------------------- |
; |
; checksum_2 |
; |
; This function calculates the final ip/tcp/udp checksum for you |
; |
; IN: edx = semi-checksum |
; OUT: dx = checksum (in INET byte order) |
; |
;----------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; checksum_2: Calculate the final ip/tcp/udp checksum. ; |
; ; |
; IN: edx = semi-checksum ; |
; ; |
; OUT: dx = checksum (in INET byte order) ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
checksum_2: |
713,11 → 704,11 |
;---------------------------------------------------------------- |
; |
; System function to work with network devices (74) |
; |
;---------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; System function 74: Low level access to network devices. ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
sys_network: |
834,11 → 825,11 |
;---------------------------------------------------------------- |
; |
; System function to work with protocols (76) |
; |
;---------------------------------------------------------------- |
;-----------------------------------------------------------------; |
; ; |
; System function 76: Low level access to protocol handlers. ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
sys_protocols: |
cmp bh, NET_DEVICES_MAX ; Check if device number exists |
856,28 → 847,28 |
shr eax, 16 ; |
cmp ax, API_ETH |
je ETH_api |
je eth_api |
cmp ax, API_IPv4 |
je IPv4_api |
je ipv4_api |
cmp ax, API_ICMP |
je ICMP_api |
je icmp_api |
cmp ax, API_UDP |
je UDP_api |
je udp_api |
cmp ax, API_TCP |
je TCP_api |
je tcp_api |
cmp ax, API_ARP |
je ARP_api |
je arp_api |
cmp ax, API_PPPOE |
je PPPoE_api |
je pppoe_api |
cmp ax, API_IPv6 |
je IPv6_api |
je ipv6_api |
add esp, 4 ; if we reached here, no function was called, so we need to balance stack |
/kernel/branches/Kolibri-acpi/network/tcp.inc |
---|
206,7 → 206,7 |
; TCP_init: Resets all TCP variables. ; |
; ; |
;-----------------------------------------------------------------; |
macro TCP_init { |
macro tcp_init { |
xor eax, eax |
mov edi, TCP_segments_tx |
219,7 → 219,7 |
init_queue TCP_queue |
movi ebx, 1 |
mov ecx, TCP_process_input |
mov ecx, tcp_process_input |
call new_sys_threads |
test eax, eax |
jns @f |
227,7 → 227,7 |
@@: |
movi ebx, 1 |
mov ecx, TCP_timer_640ms |
mov ecx, tcp_timer_640ms |
call new_sys_threads |
test eax, eax |
jns @f |
246,7 → 246,7 |
;------------------------------------------------------------------; |
; ; |
; TCP_api: This function is called by system function 76 ; |
; tcp_api: Part of system function 76 ; |
; ; |
; IN: bl = subfunction number ; |
; bh = device number ; |
256,7 → 256,7 |
; ; |
;------------------------------------------------------------------; |
align 4 |
TCP_api: |
tcp_api: |
movzx eax, bh |
shl eax, 2 |
/kernel/branches/Kolibri-acpi/network/tcp_input.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5976 $ |
$Revision: 6011 $ |
;-----------------------------------------------------------------; |
; ; |
31,7 → 31,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_input: |
tcp_input: |
; record the current time |
push [timer_ticks] ; in 1/100 seconds |
57,17 → 57,17 |
pop edi |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP incoming queue is full, discarding packet!\n" |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [TCP_segments_missed + edi] |
add esp, sizeof.TCP_queue_entry - 4 |
call NET_BUFF_free |
call net_buff_free |
ret |
align 4 |
proc TCP_process_input |
proc tcp_process_input |
locals |
dataoffset dd ? |
111,7 → 111,7 |
push ecx esi |
pushw [esi + TCP_header.Checksum] |
mov [esi + TCP_header.Checksum], 0 |
TCP_checksum (edi+IPv4_header.SourceAddress), (edi+IPv4_header.DestinationAddress) |
tcp_checksum (edi+IPv4_header.SourceAddress), (edi+IPv4_header.DestinationAddress) |
pop cx ; previous checksum |
cmp cx, dx |
pop edx ecx |
234,7 → 234,7 |
popa |
push ecx edx esi edi |
call SOCKET_fork |
call socket_fork |
pop edi esi edx ecx |
test eax, eax |
312,7 → 312,7 |
lodsw |
rol ax, 8 |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Maxseg=%u\n", eax |
call TCP_mss |
call tcp_mss |
@@: |
jmp .opt_loop |
473,7 → 473,7 |
pusha |
mov ecx, eax |
lea eax, [ebx + STREAM_SOCKET.snd] |
call SOCKET_ring_free |
call socket_ring_free |
popa |
; Update RTT estimators |
483,7 → 483,7 |
mov eax, [timestamp] |
sub eax, [ebx + TCP_SOCKET.ts_ecr] |
inc eax |
call TCP_xmit_timer |
call tcp_xmit_timer |
jmp .rtt_done |
.no_timestamp_rtt: |
493,7 → 493,7 |
cmp eax, [ebx + TCP_SOCKET.t_rtseq] |
jbe .rtt_done |
mov eax, [ebx + TCP_SOCKET.t_rtt] |
call TCP_xmit_timer |
call tcp_xmit_timer |
.rtt_done: |
; update window pointers |
511,10 → 511,10 |
; Awaken waiting processes |
mov eax, ebx |
call SOCKET_notify |
call socket_notify |
; Generate more output |
call TCP_output |
call tcp_output |
jmp .drop_no_socket |
540,11 → 540,11 |
mov esi, [dataoffset] |
add esi, edx |
lea eax, [ebx + STREAM_SOCKET.rcv] |
call SOCKET_ring_write ; Add the data to the socket buffer |
call socket_ring_write ; Add the data to the socket buffer |
add [ebx + TCP_SOCKET.RCV_NXT], ecx ; Update sequence number with number of bytes we have copied |
mov eax, ebx |
call SOCKET_notify |
call socket_notify |
or [ebx + TCP_SOCKET.t_flags], TF_DELACK ; Set delayed ack flag |
661,7 → 661,7 |
jz .not_terminated |
mov eax, ebx |
call TCP_close |
call tcp_close |
inc [TCPS_rcvafterclose] |
jmp .respond_seg_reset |
691,7 → 691,7 |
; cmp edx, [edx + TCP_header.SequenceNumber] |
; add edx, 64000 ; TCP_ISSINCR FIXME |
mov eax, ebx |
call TCP_close |
call tcp_close |
jmp .findpcb ; FIXME: skip code for unscaling window, ... |
.no_new_request: |
779,7 → 779,7 |
mov [ebx + TCP_SOCKET.t_state], TCPS_CLOSED |
;;; TODO: update stats (tcp drops) |
mov eax, ebx |
call TCP_close |
call tcp_close |
jmp .drop_no_socket |
.rst_close: |
786,7 → 786,7 |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Closing with reset\n" |
mov eax, ebx |
call TCP_close |
call tcp_close |
jmp .drop_no_socket |
.no_rst: |
799,7 → 799,7 |
mov eax, ebx |
mov ebx, ECONNRESET |
call TCP_drop |
call tcp_drop |
jmp .drop_with_reset |
.not_syn_full: |
824,7 → 824,7 |
;;; TODO: update stats |
mov eax, ebx |
call SOCKET_is_connected |
call socket_is_connected |
mov [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED |
; Do window scaling? |
838,7 → 838,7 |
pop word [ebx + TCP_SOCKET.SND_SCALE] |
@@: |
call TCP_reassemble |
call tcp_reassemble |
mov eax, [edx + TCP_header.SequenceNumber] |
dec eax |
916,7 → 916,7 |
; retransmit missing segment |
mov eax, [esp] |
call TCP_output |
call tcp_output |
; Lock the socket again |
mov ecx, [esp] |
955,7 → 955,7 |
; retransmit missing segment |
mov eax, [esp] |
call TCP_output |
call tcp_output |
; Lock the socket again |
mov ecx, [esp] |
1005,7 → 1005,7 |
mov eax, [timestamp] |
sub eax, [ebx + TCP_SOCKET.ts_ecr] |
inc eax |
call TCP_xmit_timer |
call tcp_xmit_timer |
jmp .rtt_done_ |
; If no timestamp but transmit timer is running and timed sequence number was acked, |
1020,7 → 1020,7 |
mov eax, [ebx + TCP_SOCKET.t_rtt] |
test eax, eax |
jz .rtt_done_ |
call TCP_xmit_timer |
call tcp_xmit_timer |
.rtt_done_: |
1085,7 → 1085,7 |
mov ecx, [ebx + STREAM_SOCKET.snd.size] |
lea eax, [ebx + STREAM_SOCKET.snd] |
sub [ebx + TCP_SOCKET.SND_WND], ecx |
call SOCKET_ring_free |
call socket_ring_free |
pop ebx edx ecx |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: our FIN is acked\n" |
1097,7 → 1097,7 |
push ecx edx ebx |
mov ecx, edi |
lea eax, [ebx + STREAM_SOCKET.snd] |
call SOCKET_ring_free |
call socket_ring_free |
pop ebx |
sub [ebx + TCP_SOCKET.SND_WND], ecx |
pop edx ecx |
1109,7 → 1109,7 |
.wakeup: |
mov eax, ebx |
call SOCKET_notify |
call socket_notify |
; Update TCPS |
mov eax, [edx + TCP_header.AckNumber] |
1147,7 → 1147,7 |
test [ebx + SOCKET.state], SS_CANTRCVMORE |
jnz @f |
mov eax, ebx |
call SOCKET_is_disconnected |
call socket_is_disconnected |
mov [ebx + TCP_SOCKET.timer_timed_wait], TCP_time_max_idle |
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait |
@@: |
1160,11 → 1160,11 |
mov [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT |
mov eax, ebx |
call TCP_cancel_timers |
call tcp_cancel_timers |
mov [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL |
or [ebx + TCP_SOCKET.timer_flags], timer_flag_wait |
mov eax, ebx |
call SOCKET_is_disconnected |
call socket_is_disconnected |
jmp .ack_processed |
.ack_la: |
1177,7 → 1177,7 |
pop ebx |
mov eax, ebx |
call TCP_close |
call tcp_close |
jmp .drop_no_socket |
.ack_tw: |
1224,8 → 1224,8 |
mov [ebx + TCP_SOCKET.ISS], eax |
mov [ebx + TCP_SOCKET.SND_NXT], eax |
TCP_sendseqinit ebx |
TCP_rcvseqinit ebx |
tcp_sendseqinit ebx |
tcp_rcvseqinit ebx |
mov [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED |
or [ebx + TCP_SOCKET.t_flags], TF_ACKNOW |
1233,12 → 1233,12 |
or [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive |
lea eax, [ebx + STREAM_SOCKET.snd] |
call SOCKET_ring_create |
call socket_ring_create |
test eax, eax |
jz .drop |
lea eax, [ebx + STREAM_SOCKET.rcv] |
call SOCKET_ring_create |
call socket_ring_create |
test eax, eax |
jz .drop |
1246,7 → 1246,7 |
pusha |
mov eax, ebx |
call SOCKET_notify |
call socket_notify |
popa |
jmp .trim |
1278,7 → 1278,7 |
mov eax, ebx |
mov ebx, ECONNREFUSED |
call TCP_drop |
call tcp_drop |
jmp .drop |
@@: |
1306,7 → 1306,7 |
push [edx + TCP_header.SequenceNumber] |
pop [ebx + TCP_SOCKET.IRS] |
TCP_rcvseqinit ebx |
tcp_rcvseqinit ebx |
or [ebx + TCP_SOCKET.t_flags], TF_ACKNOW |
1324,7 → 1324,7 |
; set socket state to connected |
push eax |
mov eax, ebx |
call SOCKET_is_connected |
call socket_is_connected |
pop eax |
mov [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED |
1343,7 → 1343,7 |
mov eax, [ebx + TCP_SOCKET.t_rtt] |
test eax, eax |
je .trim |
call TCP_xmit_timer |
call tcp_xmit_timer |
jmp .trim |
.simultaneous_open: |
1485,13 → 1485,13 |
mov esi, [dataoffset] |
add esi, edx |
lea eax, [ebx + STREAM_SOCKET.rcv] |
call SOCKET_ring_write ; Add the data to the socket buffer |
call socket_ring_write ; Add the data to the socket buffer |
add [ebx + TCP_SOCKET.RCV_NXT], ecx ; Update sequence number with number of bytes we have copied |
popa |
; Wake up the sleeping process |
mov eax, ebx |
call SOCKET_notify |
call socket_notify |
jmp .data_done |
1501,7 → 1501,7 |
; Uh-oh, some data is out of order, lets call TCP reassemble for help |
call TCP_reassemble |
call tcp_reassemble |
; Generate ACK immediately, to let the other end know that a segment was received out of order, |
; and to tell it what sequence number is expected. This aids the fast-retransmit algorithm. |
1522,7 → 1522,7 |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: First FIN for this connection\n" |
mov eax, ebx |
call SOCKET_cant_recv_more |
call socket_cant_recv_more |
or [ebx + TCP_SOCKET.t_flags], TF_ACKNOW |
inc [ebx + TCP_SOCKET.RCV_NXT] |
1556,8 → 1556,8 |
.fin_wait2: |
mov [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT |
mov eax, ebx |
call TCP_cancel_timers |
call SOCKET_is_disconnected |
call tcp_cancel_timers |
call socket_is_disconnected |
.fin_timed: |
mov [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL |
1583,12 → 1583,12 |
.need_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: need output\n" |
call TCP_output |
call tcp_output |
.done: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: dumping\n" |
call NET_BUFF_free |
call net_buff_free |
jmp .loop |
1621,7 → 1621,7 |
test [edx + TCP_header.Flags], TH_RST |
jnz .done |
;;; if its a multicast/broadcast, also drop |
; TODO: if its a multicast/broadcast, also drop |
test [edx + TCP_header.Flags], TH_ACK |
jnz .respond_ack |
1636,7 → 1636,7 |
.respond_ack: |
push ebx |
mov cl, TH_RST |
call TCP_respond |
call tcp_respond |
pop ebx |
jmp .destroy_new_socket |
1643,7 → 1643,7 |
.respond_syn: |
push ebx |
mov cl, TH_RST + TH_ACK |
call TCP_respond |
call tcp_respond |
pop ebx |
jmp .destroy_new_socket |
1660,7 → 1660,7 |
test [edx + TCP_header.Flags], TH_RST |
jnz .drop_no_socket |
;;; TODO: if its a multicast/broadcast, also drop |
; TODO: if its a multicast/broadcast, also drop |
test [edx + TCP_header.Flags], TH_ACK |
jnz .respond_seg_ack |
1673,13 → 1673,13 |
.respond_seg_ack: |
mov cl, TH_RST |
xor ebx, ebx ; FIXME: find a way to get the receiving device ptr |
call TCP_respond_segment |
call tcp_respond_segment |
jmp .drop_no_socket |
.respond_seg_syn: |
mov cl, TH_RST + TH_ACK |
xor ebx, ebx ; FIXME: find a way to get the receiving device ptr |
call TCP_respond_segment |
call tcp_respond_segment |
jmp .drop_no_socket |
;------------------------------------------------ |
1701,7 → 1701,7 |
jz .drop_no_socket |
mov eax, ebx |
call SOCKET_free |
call socket_free |
;------------------ |
; Drop the segment |
1709,7 → 1709,7 |
.drop_no_socket: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_input: Drop (no socket)\n" |
call NET_BUFF_free |
call net_buff_free |
jmp .loop |
endp |
/kernel/branches/Kolibri-acpi/network/tcp_output.inc |
---|
14,11 → 14,11 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5584 $ |
$Revision: 6011 $ |
;-----------------------------------------------------------------; |
; ; |
; TCP_output ; |
; tcp_output ; |
; ; |
; IN: eax = socket pointer ; |
; ; |
26,7 → 26,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
proc TCP_output |
proc tcp_output |
locals |
temp_bits db ? |
72,7 → 72,7 |
mov ecx, [eax + TCP_SOCKET.SND_CWND] ; |
@@: ; |
call TCP_outflags ; flags in dl |
call tcp_outflags ; flags in dl |
;------------------------ |
; data being forced out ? |
279,7 → 279,7 |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_output: Entering persist state\n" |
mov [eax + TCP_SOCKET.t_rxtshift], 0 |
call TCP_set_persist |
call tcp_set_persist |
@@: |
;---------------------------- |
509,7 → 509,7 |
mov edi, [eax + IP_SOCKET.RemoteIP] ; dest ip |
mov al, [eax + IP_SOCKET.ttl] |
mov ah, IP_PROTO_TCP |
call IPv4_output |
call ipv4_output |
jz .ip_error |
;------------------------------------------ |
549,7 → 549,7 |
add [eax + TCP_SOCKET.SND_NXT], ecx ; update sequence number |
sub edx, [eax + TCP_SOCKET.SND_UNA] ; offset |
add eax, STREAM_SOCKET.snd |
call SOCKET_ring_read |
call socket_ring_read |
.nodata: |
pop edi |
pop esi ; begin of data |
606,7 → 606,7 |
test [ebx + NET_DEVICE.hwacc], NET_HWACC_TCP_IPv4_OUT |
jnz .checksum_ok |
TCP_checksum (eax + IP_SOCKET.LocalIP), (eax + IP_SOCKET.RemoteIP) |
tcp_checksum (eax + IP_SOCKET.LocalIP), (eax + IP_SOCKET.RemoteIP) |
.checksum_ok: |
mov [esi + TCP_header.Checksum], dx |
624,7 → 624,7 |
pop ecx |
pop eax |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [TCP_segments_tx + edi] |
inc [TCPS_sndtotal] |
658,7 → 658,7 |
; Check if we need more output |
test [temp_bits], TCP_BIT_SENDALOT |
jnz TCP_output.again |
jnz tcp_output.again |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_send: success!\n" |
/kernel/branches/Kolibri-acpi/network/tcp_subr.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5584 $ |
$Revision: 6011 $ |
align 4 |
iglobal |
21,7 → 21,7 |
TCP_backoff db 0,1,2,3,4,5,6,6,6,6,6,6,6 |
endg |
macro TCP_checksum IP1, IP2 { |
macro tcp_checksum IP1, IP2 { |
;------------- |
; Pseudoheader |
60,9 → 60,9 |
macro TCP_sendseqinit ptr { |
macro tcp_sendseqinit ptr { |
push edi ;;;; i dont like this static use of edi |
push edi ;;;; FIXME: i dont like this static use of edi |
mov edi, [ptr + TCP_SOCKET.ISS] |
mov [ptr + TCP_SOCKET.SND_UP], edi |
mov [ptr + TCP_SOCKET.SND_MAX], edi |
74,7 → 74,7 |
macro TCP_rcvseqinit ptr { |
macro tcp_rcvseqinit ptr { |
push edi |
mov edi, [ptr + TCP_SOCKET.IRS] |
87,7 → 87,7 |
macro TCP_init_socket socket { |
macro tcp_init_socket socket { |
mov [socket + TCP_SOCKET.t_maxseg], TCP_mss_default |
mov [socket + TCP_SOCKET.t_flags], TF_REQ_SCALE or TF_REQ_TSTMP |
106,7 → 106,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_pull_out_of_band ; |
; tcp_pull_out_of_band ; |
; ; |
; IN: eax = ? ; |
; ebx = socket ptr ; |
116,9 → 116,9 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_pull_out_of_band: |
tcp_pull_out_of_band: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_pull_out_of_band\n" |
DEBUGF DEBUG_NETWORK_VERBOSE, "tcp_pull_out_of_band\n" |
;;;; 1282-1305 |
128,7 → 128,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_drop ; |
; tcp_drop ; |
; ; |
; IN: eax = socket ptr ; |
; ebx = error number ; |
137,9 → 137,9 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_drop: ; FIXME CHECKME TODO |
tcp_drop: ; FIXME CHECKME TODO |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_drop: %x\n", eax |
DEBUGF DEBUG_NETWORK_VERBOSE, "tcp_drop: %x\n", eax |
cmp [eax + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED |
jb .no_syn_received |
147,12 → 147,12 |
mov [eax + TCP_SOCKET.t_state], TCPS_CLOSED |
push eax |
call TCP_output |
call tcp_output |
pop eax |
;;; TODO: update stats |
jmp TCP_close |
jmp tcp_close |
.no_syn_received: |
167,7 → 167,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_disconnect ; |
; tcp_disconnect ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
175,22 → 175,22 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_disconnect: |
tcp_disconnect: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_disconnect: %x\n", eax |
cmp [eax + TCP_SOCKET.t_state], TCPS_ESTABLISHED |
jb TCP_close ; Connection not yet synchronised, just get rid of the socket |
jb tcp_close ; Connection not yet synchronised, just get rid of the socket |
; TODO: implement LINGER |
call SOCKET_is_disconnecting |
call TCP_usrclosed |
call socket_is_disconnecting |
call tcp_usrclosed |
test eax, eax |
jz @f |
push eax |
call TCP_output |
call tcp_output |
pop eax |
@@: |
ret |
198,7 → 198,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_close ; |
; tcp_close ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
206,7 → 206,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_close: |
tcp_close: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_close: %x\n", eax |
213,8 → 213,8 |
;;; TODO: update RTT and mean deviation |
;;; TODO: update slow start threshold |
call SOCKET_is_disconnected |
call SOCKET_free |
call socket_is_disconnected |
call socket_free |
xor eax, eax |
ret |
223,7 → 223,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_outflags ; |
; tcp_outflags ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
231,7 → 231,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_outflags: |
tcp_outflags: |
mov edx, [eax + TCP_SOCKET.t_state] |
movzx edx, byte [edx + .flaglist] |
270,7 → 270,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_respond: |
tcp_respond: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_respond_socket: socket=%x flags=%x\n", ebx, cl |
284,7 → 284,7 |
mov ah, IP_PROTO_TCP |
mov ecx, sizeof.TCP_header |
mov ebx, [ebx + IP_SOCKET.device] |
call IPv4_output |
call ipv4_output |
jz .error |
pop esi cx |
push eax |
320,7 → 320,7 |
sub edi, sizeof.TCP_header |
mov ecx, sizeof.TCP_header |
xchg esi, edi |
TCP_checksum (edi + IP_SOCKET.LocalIP), (edi + IP_SOCKET.RemoteIP) |
tcp_checksum (edi + IP_SOCKET.LocalIP), (edi + IP_SOCKET.RemoteIP) |
mov [esi+TCP_header.Checksum], dx |
;-------------------- |
329,7 → 329,7 |
call [ebx + NET_DEVICE.transmit] |
test eax, eax |
jnz @f |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [TCP_segments_tx + edi] |
@@: |
ret |
343,7 → 343,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_respond_segment ; |
; tcp_respond_segment ; |
; ; |
; IN: ebx = device ptr ; |
; edx = segment ptr (a previously received segment) ; |
354,7 → 354,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_respond_segment: |
tcp_respond_segment: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_respond_segment: frame=%x flags=%x\n", edx, cl |
366,7 → 366,7 |
mov edi, [edi + IPv4_header.SourceAddress] |
mov ecx, sizeof.TCP_header |
mov ax, IP_PROTO_TCP shl 8 + 128 |
call IPv4_output |
call ipv4_output |
jz .error |
pop esi cx |
399,7 → 399,7 |
lea esi, [edi - sizeof.TCP_header] |
mov ecx, sizeof.TCP_header |
TCP_checksum (esi - sizeof.IPv4_header + IPv4_header.DestinationAddress),\ ; FIXME |
tcp_checksum (esi - sizeof.IPv4_header + IPv4_header.DestinationAddress),\ ; FIXME |
(esi - sizeof.IPv4_header + IPv4_header.SourceAddress) |
mov [esi + TCP_header.Checksum], dx |
409,7 → 409,7 |
call [ebx + NET_DEVICE.transmit] |
test eax, eax |
jnz @f |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [TCP_segments_tx + edi] |
@@: |
ret |
421,7 → 421,7 |
ret |
macro TCPT_RANGESET timer, value, min, max { |
macro tcpt_rangeset timer, value, min, max { |
local .min |
local .max |
448,11 → 448,11 |
;-----------------------------------------------------------------; |
; ; |
; TCP_set_persist ; |
; tcp_set_persist ; |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_set_persist: |
tcp_set_persist: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_set_persist\n" |
473,7 → 473,7 |
; Start/restart persistance timer. |
TCPT_RANGESET [eax + TCP_SOCKET.timer_persist], ebx, TCP_time_pers_min, TCP_time_pers_max |
tcpt_rangeset [eax + TCP_SOCKET.timer_persist], ebx, TCP_time_pers_min, TCP_time_pers_max |
or [ebx + TCP_SOCKET.timer_flags], timer_flag_persist |
pop ebx |
489,7 → 489,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_xmit_timer: Calculate new smoothed RTT. ; |
; tcp_xmit_timer: Calculate new smoothed RTT. ; |
; ; |
; IN: eax = rtt ; |
; ebx = socket ptr ; |
498,7 → 498,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_xmit_timer: |
tcp_xmit_timer: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_xmit_timer: socket=0x%x rtt=%d0ms\n", ebx, eax |
563,7 → 563,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_mss: Update maximum segment size ; |
; tcp_mss: Update maximum segment size ; |
; ; |
; IN: eax = max segment size ; |
; ebx = socket ptr ; |
572,7 → 572,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_mss: |
tcp_mss: |
cmp eax, 1420 ; FIXME |
jbe @f |
587,7 → 587,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_reassemble ; |
; tcp_reassemble ; |
; ; |
; IN: ebx = socket ptr ; |
; edx = segment ptr ; |
596,7 → 596,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_reassemble: |
tcp_reassemble: |
;;;;; TODO |
/kernel/branches/Kolibri-acpi/network/tcp_timer.inc |
---|
14,7 → 14,7 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5442 $ |
$Revision: 6011 $ |
timer_flag_retransmission = 1 shl 0 |
timer_flag_keepalive = 1 shl 1 |
23,7 → 23,7 |
timer_flag_wait = 1 shl 4 |
macro TCP_timer_160ms { |
macro tcp_timer_160ms { |
local .loop |
local .exit |
45,10 → 45,7 |
push ebx |
mov cl, TH_ACK |
call TCP_respond |
; and [ebx + TCP_SOCKET.t_flags], TF_ACKNOW ;; |
; mov eax, ebx ;; |
; call TCP_output ;; |
call tcp_respond |
pop ebx |
inc [TCPS_delack] ; update stats |
61,7 → 58,7 |
align 4 |
proc TCP_timer_640ms ; TODO: implement timed wait timer! |
proc tcp_timer_640ms |
xor esi, esi |
mov ecx, MANUAL_DESTROY |
77,8 → 74,8 |
add [TCP_sequence_num], 64000 |
; scan through all the active TCP sockets, decrementing ALL timers |
; When a timer reaches zero, we'll check wheter it was active or not |
; Scan through all the active TCP sockets, decrementing all active timers |
; When a timer reaches zero, run its handler. |
mov eax, net_sockets |
.loop: |
95,22 → 92,22 |
inc [eax + TCP_SOCKET.t_idle] |
test [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission |
jz .check_more2 |
dec [eax + TCP_SOCKET.timer_retransmission] |
jnz .check_more2 |
test [eax + TCP_SOCKET.timer_flags], timer_flag_retransmission |
jz .check_more2 |
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: Retransmission timer expired\n", eax |
push eax |
call TCP_output |
call tcp_output |
pop eax |
.check_more2: |
test [eax + TCP_SOCKET.timer_flags], timer_flag_keepalive |
jz .check_more3 |
dec [eax + TCP_SOCKET.timer_keepalive] |
jnz .check_more3 |
test [eax + TCP_SOCKET.timer_flags], timer_flag_keepalive |
jz .check_more3 |
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: Keepalive expired\n", eax |
118,7 → 115,7 |
ja .dont_kill |
push eax |
call TCP_disconnect |
call tcp_disconnect |
pop eax |
jmp .loop |
129,7 → 126,7 |
push eax |
mov ebx, eax |
xor cl, cl |
call TCP_respond ; send keepalive |
call tcp_respond ; send keepalive |
pop eax |
mov [eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_interval |
jmp .check_more3 |
138,38 → 135,38 |
mov [eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_idle |
.check_more3: |
test [eax + TCP_SOCKET.timer_flags], timer_flag_2msl |
jz .check_more5 |
dec [eax + TCP_SOCKET.timer_timed_wait] |
jnz .check_more5 |
test [eax + TCP_SOCKET.timer_flags], timer_flag_2msl |
jz .check_more5 |
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: 2MSL timer expired\n", eax |
.check_more5: |
test [eax + TCP_SOCKET.timer_flags], timer_flag_persist |
jz .check_more6 |
dec [eax + TCP_SOCKET.timer_persist] |
jnz .check_more6 |
test [eax + TCP_SOCKET.timer_flags], timer_flag_persist |
jz .check_more6 |
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: persist timer expired\n", eax |
call TCP_set_persist |
call tcp_set_persist |
mov [eax + TCP_SOCKET.t_force], 1 |
push eax |
call TCP_output |
call tcp_output |
pop eax |
mov [eax + TCP_SOCKET.t_force], 0 |
.check_more6: |
test [eax + TCP_SOCKET.timer_flags], timer_flag_wait |
jz .loop |
dec [eax + TCP_SOCKET.timer_timed_wait] |
jnz .loop |
test [eax + TCP_SOCKET.timer_flags], timer_flag_wait |
jz .loop |
DEBUGF DEBUG_NETWORK_VERBOSE, "socket %x: timed wait timer expired\n", eax |
push [eax + SOCKET.NextPtr] |
call TCP_close |
call tcp_close |
pop eax |
jmp .check_only |
187,7 → 184,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_cancel_timers: |
tcp_cancel_timers: |
mov [eax + TCP_SOCKET.timer_flags], 0 |
/kernel/branches/Kolibri-acpi/network/tcp_usreq.inc |
---|
14,12 → 14,12 |
;; ;; |
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
$Revision: 5442 $ |
$Revision: 6011 $ |
;-----------------------------------------------------------------; |
; ; |
; TCP_usrclosed ; |
; tcp_usrclosed ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
27,7 → 27,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_usrclosed: |
tcp_usrclosed: |
DEBUGF DEBUG_NETWORK_VERBOSE, "TCP_usrclosed: %x\n", eax |
51,7 → 51,7 |
.close: |
mov [eax + TCP_SOCKET.t_state], TCPS_CLOSED |
call TCP_close |
call tcp_close |
pop ebx |
ret |
66,7 → 66,7 |
ret |
.disc: |
call SOCKET_is_disconnected |
call socket_is_disconnected |
.ret: |
pop ebx |
ret |
74,7 → 74,7 |
;-----------------------------------------------------------------; |
; ; |
; TCP_connect ; |
; tcp_connect ; |
; ; |
; IN: eax = socket ptr ; |
; ; |
84,7 → 84,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
TCP_connect: |
tcp_connect: |
test [eax + SOCKET.state], SS_ISCONNECTED |
jnz .eisconn |
112,7 → 112,7 |
; Find a local port, if user didnt define one |
cmp [eax + TCP_SOCKET.LocalPort], 0 |
jne @f |
call SOCKET_find_port |
call socket_find_port |
@@: |
; Start the TCP sequence |
124,16 → 124,16 |
pop [eax + TCP_SOCKET.ISS] |
mov [eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_init |
TCP_sendseqinit eax |
tcp_sendseqinit eax |
mov ebx, eax |
lea eax, [ebx + STREAM_SOCKET.snd] |
call SOCKET_ring_create |
call socket_ring_create |
test eax, eax |
jz .nomem |
lea eax, [ebx + STREAM_SOCKET.rcv] |
call SOCKET_ring_create |
call socket_ring_create |
test eax, eax |
jz .nomem |
142,11 → 142,11 |
call mutex_unlock |
pop eax |
call SOCKET_is_connecting |
call socket_is_connecting |
; Now send the SYN packet to remote end |
push eax |
call TCP_output |
call tcp_output |
pop eax |
.block: |
183,7 → 183,7 |
cmp [eax + TCP_SOCKET.t_state], TCPS_ESTABLISHED |
je .established |
call SOCKET_block |
call socket_block |
jmp .loop |
.timeout: |
190,7 → 190,7 |
mov eax, [esp+4] |
mov [eax + SOCKET.errorcode], ETIMEDOUT |
and [eax + SOCKET.state], not SS_ISCONNECTING |
call SOCKET_notify |
call socket_notify |
ret 4 |
.fail: |
/kernel/branches/Kolibri-acpi/network/udp.inc |
---|
38,10 → 38,10 |
;-----------------------------------------------------------------; |
; ; |
; UDP_init: This function resets all UDP variables ; |
; udp_init: This function resets all UDP variables ; |
; ; |
;-----------------------------------------------------------------; |
macro UDP_init { |
macro udp_init { |
xor eax, eax |
mov edi, UDP_PACKETS_TX |
50,7 → 50,7 |
} |
macro UDP_checksum IP1, IP2 { ; esi = ptr to udp packet, ecx = packet size, destroys: ecx, edx |
macro udp_checksum IP1, IP2 { ; esi = ptr to udp packet, ecx = packet size, destroys: ecx, edx |
; Pseudoheader |
mov edx, IP_PROTO_UDP |
98,7 → 98,7 |
;-----------------------------------------------------------------; |
; ; |
; UDP_input: Inject the UDP data in the application sockets. ; |
; udp_input: Inject the UDP data in the application sockets. ; |
; ; |
; IN: [esp] = ptr to buffer ; |
; ebx = ptr to device struct ; |
111,7 → 111,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
UDP_input: |
udp_input: |
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: size=%u\n", ecx |
123,7 → 123,7 |
; otherwise, we will re-calculate the checksum and add it to this value, thus creating 0 when it is correct |
mov eax, edx |
UDP_checksum (eax+IPv4_header.SourceAddress), (eax+IPv4_header.DestinationAddress) |
udp_checksum (eax+IPv4_header.SourceAddress), (eax+IPv4_header.DestinationAddress) |
jnz .checksum_mismatch |
.no_checksum: |
194,7 → 194,7 |
sub ecx, sizeof.UDP_header |
add esi, sizeof.UDP_header |
jmp SOCKET_input |
jmp socket_input |
.updateport: |
pusha |
220,7 → 220,7 |
.dump: |
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_input: dumping\n" |
call NET_BUFF_free |
call net_buff_free |
ret |
227,7 → 227,7 |
;-----------------------------------------------------------------; |
; ; |
; UDP_output: Create an UDP packet. ; |
; udp_output: Create an UDP packet. ; |
; ; |
; IN: eax = socket pointer ; |
; ecx = number of bytes to send ; |
238,7 → 238,7 |
;-----------------------------------------------------------------; |
align 4 |
UDP_output: |
udp_output: |
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: socket=%x bytes=%u data_ptr=%x\n", eax, ecx, esi |
256,7 → 256,7 |
mov al, [eax + IP_SOCKET.ttl] |
mov ah, IP_PROTO_UDP |
add ecx, sizeof.UDP_header |
call IPv4_output |
call ipv4_output |
jz .fail |
mov [esp + 8], eax ; pointer to buffer start |
279,13 → 279,13 |
; Checksum |
mov esi, edi |
mov [edi + UDP_header.Checksum], 0 |
UDP_checksum (edi-4), (edi-8) ; FIXME: IPv4 packet could have options.. |
udp_checksum (edi-4), (edi-8) ; FIXME: IPv4 packet could have options.. |
DEBUGF DEBUG_NETWORK_VERBOSE, "UDP_output: sending with device %x\n", ebx |
call [ebx + NET_DEVICE.transmit] |
test eax, eax |
jnz @f |
call NET_ptr_to_num4 |
call net_ptr_to_num4 |
inc [UDP_PACKETS_TX + edi] |
@@: |
302,7 → 302,7 |
;-----------------------------------------------------------------; |
; ; |
; UDP_connect ; |
; udp_connect ; |
; ; |
; IN: eax = socket pointer ; |
; ; |
312,11 → 312,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
UDP_connect: |
udp_connect: |
test [eax + SOCKET.state], SS_ISCONNECTED |
jz @f |
call UDP_disconnect |
call udp_disconnect |
@@: |
push eax edx |
340,7 → 340,7 |
; Find a local port, if user didnt define one |
cmp [eax + UDP_SOCKET.LocalPort], 0 |
jne @f |
call SOCKET_find_port |
call socket_find_port |
@@: |
push eax |
348,7 → 348,7 |
call mutex_unlock |
pop eax |
call SOCKET_is_connected |
call socket_is_connected |
xor eax, eax |
ret |
364,11 → 364,11 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
UDP_disconnect: |
udp_disconnect: |
; TODO: remove the pending received data |
call SOCKET_is_disconnected |
call socket_is_disconnected |
ret |
378,7 → 378,7 |
;-----------------------------------------------------------------; |
; ; |
; UDP_api: This function is called by system function 76 ; |
; UDP_api: Part of system function 76 ; |
; ; |
; IN: bl = subfunction number in bl ; |
; bh = device number in bh ; |
388,7 → 388,7 |
; ; |
;-----------------------------------------------------------------; |
align 4 |
UDP_api: |
udp_api: |
movzx eax, bh |
shl eax, 2 |