WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/network/stack.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  STACK.INC                                                      ;;
;;                                                                 ;;
;;  TCP/IP stack for KolibriOS                                     ;;
;;                                                                 ;;
;;    Written by hidnplayr@kolibrios.org                           ;;
;;                                                                 ;;
;;     Some parts of code are based on the work of:                ;;
;;      Mike Hibbett (menuetos network stack)                      ;;
;;      Eugen Brasoveanu (solar os network stack and drivers)      ;;
;;      mike.dld (kolibrios socket code)                           ;;
;;                                                                 ;;
;;     TCP part is based on 4.4BSD                                 ;;
;;                                                                 ;;
;;          GNU GENERAL PUBLIC LICENSE                             ;;
;;             Version 2, June 1991                                ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 3908 $
 
uglobal
        net_10ms        dd ?
        net_tmr_count   dw ?
endg
 
DEBUG_NETWORK_ERROR     = 1
DEBUG_NETWORK_VERBOSE   = 0
 
NET_DEVICES_MAX         = 16
ARP_BLOCK               = 1             ; true or false
 
EPHEMERAL_PORT_MIN      = 49152
EPHEMERAL_PORT_MAX      = 61000
MIN_EPHEMERAL_PORT_N    = 0x00C0        ; same in Network byte order (FIXME)
MAX_EPHEMERAL_PORT_N    = 0x48EE        ; same in Network byte order (FIXME)
 
; Ethernet protocol numbers
ETHER_PROTO_ARP                 = 0x0608
ETHER_PROTO_IPv4                = 0x0008
ETHER_PROTO_IPv6                = 0xDD86
ETHER_PROTO_PPP_DISCOVERY       = 0x6388
ETHER_PROTO_PPP_SESSION         = 0x6488
 
; Internet protocol numbers
IP_PROTO_IP             = 0
IP_PROTO_ICMP           = 1
IP_PROTO_TCP            = 6
IP_PROTO_UDP            = 17
 
; PPP protocol numbers
PPP_PROTO_IPv4          = 0x2100
PPP_PROTO_IPV6          = 0x5780
PPP_PROTO_ETHERNET      = 666           ; FIXME
 
;Protocol family
AF_UNSPEC               = 0
AF_LOCAL                = 1
AF_INET4                = 2
AF_INET6                = 10
AF_PPP                  = 777           ; FIXME
 
; Socket types
SOCK_STREAM             = 1
SOCK_DGRAM              = 2
SOCK_RAW                = 3
 
; Socket options
SO_ACCEPTCON            = 1 shl 0
SO_BROADCAST            = 1 shl 1
SO_DEBUG                = 1 shl 2
SO_DONTROUTE            = 1 shl 3
SO_KEEPALIVE            = 1 shl 4
SO_OOBINLINE            = 1 shl 5
SO_REUSEADDR            = 1 shl 6
SO_REUSEPORT            = 1 shl 7
SO_USELOOPBACK          = 1 shl 8
SO_BINDTODEVICE         = 1 shl 9
 
SO_NONBLOCK             = 1 shl 31
 
; Socket flags for user calls
MSG_PEEK                = 0x02
MSG_DONTWAIT            = 0x40
 
; Socket level
SOL_SOCKET              = 0
 
 
; Socket States
SS_NOFDREF              = 0x0001        ; no file table ref any more
SS_ISCONNECTED          = 0x0002        ; socket connected to a peer
SS_ISCONNECTING         = 0x0004        ; in process of connecting to peer
SS_ISDISCONNECTING      = 0x0008        ; in process of disconnecting
SS_CANTSENDMORE         = 0x0010        ; can't send more data to peer
SS_CANTRCVMORE          = 0x0020        ; can't receive more data from peer
SS_RCVATMARK            = 0x0040        ; at mark on input
SS_ISABORTING           = 0x0080        ; aborting fd references - close()
SS_RESTARTSYS           = 0x0100        ; restart blocked system calls
SS_ISDISCONNECTED       = 0x0800        ; socket disconnected from peer
 
SS_ASYNC                = 0x1000        ; async i/o notify
SS_ISCONFIRMING         = 0x2000        ; deciding to accept connection req
SS_MORETOCOME           = 0x4000
 
SS_BLOCKED              = 0x8000
 
 
SOCKET_MAXDATA          = 4096*32       ; must be 4096*(power of 2) where 'power of 2' is at least 8
MAX_backlog             = 20            ; maximum backlog for stream sockets
 
; Error Codes
ENOBUFS                 = 1
EOPNOTSUPP              = 4
EWOULDBLOCK             = 6
ENOTCONN                = 9
EALREADY                = 10
EINVAL                  = 11
EMSGSIZE                = 12
ENOMEM                  = 18
EADDRINUSE              = 20
ECONNREFUSED            = 61
ECONNRESET              = 52
ETIMEDOUT               = 60
ECONNABORTED            = 53
 
; Api protocol numbers
API_ETH                 = 0
API_IPv4                = 1
API_ICMP                = 2
API_UDP                 = 3
API_TCP                 = 4
API_ARP                 = 5
API_PPPOE               = 6
API_IPv6                = 7
 
; Network device types
NET_DEVICE_LOOPBACK     = 0
NET_DEVICE_ETH          = 1
NET_DEVICE_SLIP         = 2
 
; Network link types (link protocols)
NET_LINK_LOOPBACK       = 0     ;;; Really a link type?
NET_LINK_MAC            = 1     ; Media access control (ethernet, isdn, ...)
NET_LINK_PPP            = 2     ; Point to Point Protocol (PPPoE, ...)
NET_LINK_IEEE802.11     = 3     ; IEEE 802.11 (WiFi)
 
; Hardware acceleration bits
HWACC_TCP_IPv4          = 1 shl 0
 
struct  NET_DEVICE
 
        device_type     dd ?    ; Type field
        mtu             dd ?    ; Maximal Transmission Unit
        name            dd ?    ; Ptr to 0 terminated string
 
        unload          dd ?    ; Ptrs to driver functions
        reset           dd ?    ;
        transmit        dd ?    ;
 
        bytes_tx        dq ?    ; Statistics, updated by the driver
        bytes_rx        dq ?    ;
        packets_tx      dd ?    ;
        packets_rx      dd ?    ;
 
        link_state      dd ?    ; link state (0 = no link)
        hwacc           dd ?    ; bitmask stating enabled HW accelerations (offload engines)
 
ends
 
 
; Exactly as it says..
macro pseudo_random reg {
        add     reg, [esp]
        rol     reg, 5
        xor     reg, [timer_ticks]
;        add     reg, [CPU_FREQ]
        imul    reg, 214013
        xor     reg, 0xdeadbeef
        rol     reg, 9
}
 
; Network to Hardware byte order (dword)
macro ntohd reg {
 
        rol     word reg, 8
        rol     dword reg, 16
        rol     word reg , 8
 
}
 
; Network to Hardware byte order (word)
macro ntohw reg {
 
        rol     word reg, 8
 
}
 
 
include "queue.inc"
 
include "loopback.inc"
include "ethernet.inc"
 
include "PPPoE.inc"
 
include "ARP.inc"
include "IPv4.inc"
include "IPv6.inc"
 
include "icmp.inc"
include "udp.inc"
include "tcp.inc"
 
include "socket.inc"
 
 
 
uglobal
align 4
 
        NET_RUNNING     dd  ?
        NET_DRV_LIST    rd  NET_DEVICES_MAX
 
endg
 
 
;-----------------------------------------------------------------
;
; stack_init
;
;  This function calls all network init procedures
;
;  IN:  /
;  OUT: /
;
;-----------------------------------------------------------------
align 4
stack_init:
 
; Init the network drivers list
        xor     eax, eax
        mov     edi, NET_RUNNING
        mov     ecx, (NET_DEVICES_MAX + 2)
        rep stosd
 
        PPPoE_init
 
        IPv4_init
;        IPv6_init
        ICMP_init
 
        ARP_init
        UDP_init
        TCP_init
 
        SOCKET_init
 
        LOOP_init
 
        mov     [net_tmr_count], 0
 
        ret
 
 
 
; Wakeup every tick.
proc stack_handler_has_work?
 
        mov     eax, [timer_ticks]
        cmp     eax, [net_10ms]
 
        ret
endp
 
 
;-----------------------------------------------------------------
;
; stack_handler
;
;  This function is called in kernel loop
;
;  IN:  /
;  OUT: /
;
;-----------------------------------------------------------------
align 4
stack_handler:
 
        ; Test for 10ms tick
        mov     eax, [timer_ticks]
        cmp     eax, [net_10ms]
        je      .exit
        mov     [net_10ms], eax
 
        cmp     [NET_RUNNING], 0
        je      .exit
 
        test    [net_10ms], 0x0f        ; 160ms
        jnz     .exit
 
        TCP_timer_160ms
 
        test    [net_10ms], 0x3f        ; 640ms
        jnz     .exit
 
        TCP_timer_640ms
        ARP_decrease_entry_ttls
        IPv4_decrease_fragment_ttls
 
  .exit:
        ret
 
 
align 4
NET_packet_free:
        and     dword[esp+4], not 0xfff
        jmp     kernel_free
 
 
align 4
NET_link_changed:
 
        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:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "NET_send_event\n"
 
; Send event to all applications
        push    edi ecx
        mov     edi, SLOT_BASE
        mov     ecx, [TASK_COUNT]
  .loop:
        add     edi, 256
        or      [edi + APPDATA.event_mask], EVENT_NETWORK2
        loop    .loop
        pop     ecx edi
 
        ret
 
 
 
;-----------------------------------------------------------------
;
; 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
;
;-----------------------------------------------------------------
align 4
NET_add_device:
 
        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
 
;----------------------------------
; Check if device is already listed
        mov     eax, ebx
        mov     ecx, NET_DEVICES_MAX    ; We need to check whole list because a device may be removed without re-organizing list
        mov     edi, NET_DRV_LIST
 
        repne scasd                     ; See if device is already in the list
        jz      .error
 
;----------------------------
; Find empty slot in the list
        xor     eax, eax
        mov     ecx, NET_DEVICES_MAX
        mov     edi, NET_DRV_LIST
 
        repne scasd
        jnz     .error
 
        sub     edi, 4
 
;-----------------------------
; Add device to the found slot
        mov     [edi], ebx              ; add device to list
 
        mov     eax, edi                ; Calculate device number in eax
        sub     eax, NET_DRV_LIST
        shr     eax, 2
 
        inc     [NET_RUNNING]           ; Indicate that one more network device is up and running
 
        call    NET_send_event
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Device number: %u\n", eax
        ret
 
  .error:
        or      eax, -1
        DEBUGF  DEBUG_NETWORK_ERROR, "Adding network device failed\n"
        ret
 
 
 
;-----------------------------------------------------------------
;
; 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
;
;-----------------------------------------------------------------
align 4
NET_remove_device:
 
        cmp     [NET_RUNNING], 0
        je      .error
 
;----------------------------
; Find the driver in the list
 
        mov     eax, ebx
        mov     ecx, NET_DEVICES_MAX
        mov     edi, NET_DRV_LIST
 
        repne scasd
        jnz     .error
 
;------------------------
; Remove it from the list
 
        xor     eax, eax
        mov     dword [edi-4], eax
        dec     [NET_RUNNING]
 
        call    NET_send_event
 
        xor     eax, eax
        ret
 
  .error:
        or      eax, -1
        ret
 
 
 
;-----------------------------------------------------------------
;
; NET_ptr_to_num
;
; IN:  ebx = ptr to device struct
; OUT: edi = -1 on error, device number otherwise
;
;-----------------------------------------------------------------
align 4
NET_ptr_to_num:
 
        call    NET_ptr_to_num4
        ror     edi, 2          ; If -1, stay -1
                                ; valid device numbers have last two bits 0, so do just shr
 
        ret
 
align 4
NET_ptr_to_num4:                ; Todo, place number in device structure so we only need to verify?
 
        push    ecx
 
        mov     ecx, NET_DEVICES_MAX
        mov     edi, NET_DRV_LIST
  .loop:
        cmp     ebx, [edi]
        je      .found
        add     edi, 4
        dec     ecx
        jnz     .loop
 
        or      edi, -1
        pop     ecx
        ret
 
  .found:
        sub     edi, NET_DRV_LIST
        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
;
;-----------------------------------------------------------------
align 4
checksum_1:
 
        shr     ecx, 1
        pushf
        jz      .no_2
 
        shr     ecx, 1
        pushf
        jz      .no_4
 
        shr     ecx, 1
        pushf
        jz      .no_8
 
  .loop:
        add     dl, [esi+1]
        adc     dh, [esi+0]
 
        adc     dl, [esi+3]
        adc     dh, [esi+2]
 
        adc     dl, [esi+5]
        adc     dh, [esi+4]
 
        adc     dl, [esi+7]
        adc     dh, [esi+6]
 
        adc     edx, 0
        add     esi, 8
 
        dec     ecx
        jnz     .loop
 
        adc     edx, 0
 
  .no_8:
        popf
        jnc     .no_4
 
        add     dl, [esi+1]
        adc     dh, [esi+0]
 
        adc     dl, [esi+3]
        adc     dh, [esi+2]
 
        adc     edx, 0
        add     esi, 4
 
  .no_4:
        popf
        jnc     .no_2
 
        add     dl, [esi+1]
        adc     dh, [esi+0]
 
        adc     edx, 0
        inc     esi
        inc     esi
 
  .no_2:
        popf
        jnc     .end
 
        add     dh, [esi+0]
        adc     edx, 0
  .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)
;
;-----------------------------------------------------------------
align 4
checksum_2:
 
        mov     ecx, edx
        shr     ecx, 16
        and     edx, 0xffff
        add     edx, ecx
 
        mov     ecx, edx
        shr     ecx, 16
        add     dx, cx
        test    dx, dx          ; it seems that ZF is not set when CF is set :(
        not     dx
        jnz     .not_zero
        dec     dx
  .not_zero:
        xchg    dl, dh
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "Checksum: %x\n", dx
 
        ret
 
 
 
;----------------------------------------------------------------
;
;  System function to work with network devices (74)
;
;----------------------------------------------------------------
align 4
sys_network:
 
        cmp     bl, 255
        jne     @f
 
        mov     eax, [NET_RUNNING]
        mov     [esp+32], eax
        ret
 
   @@:
        cmp     bh, NET_DEVICES_MAX             ; Check if device number exists
        jae     .doesnt_exist
 
        mov     esi, ebx
        and     esi, 0x0000ff00
        shr     esi, 6
 
        cmp     dword [esi + NET_DRV_LIST], 0   ; check if driver is running
        je      .doesnt_exist
 
        mov     eax, [esi + NET_DRV_LIST]
 
        and     ebx, 0x000000ff
        cmp     ebx, .number
        ja      .doesnt_exist
        jmp     dword [.table + 4*ebx]
 
  .table:
        dd      .get_type               ; 0
        dd      .get_dev_name           ; 1
        dd      .reset                  ; 2
        dd      .stop                   ; 3
        dd      .get_ptr                ; 4
        dd      .get_drv_name           ; 5
 
        dd      .packets_tx             ; 6
        dd      .packets_rx             ; 7
        dd      .bytes_tx               ; 8
        dd      .bytes_rx               ; 9
        dd      .state                  ; 10
  .number = ($ - .table) / 4 - 1
 
  .get_type:
        mov     eax, [eax + NET_DEVICE.device_type]
        mov     [esp+32], eax
        ret
 
  .get_dev_name:
        mov     esi, [eax + NET_DEVICE.name]
        mov     edi, ecx
 
        mov     ecx, 64/4 ; max length
        rep movsd
 
        xor     eax, eax
        mov     [esp+32], eax
        ret
 
  .reset:
        call    [eax + NET_DEVICE.reset]
        mov     [esp+32], eax
        ret
 
  .stop:
        call    [eax + NET_DEVICE.unload]
        mov     [esp+32], eax
        ret
 
 
  .get_ptr:
        mov     [esp+32], eax
        ret
 
 
  .get_drv_name:
        xor     eax, eax
        mov     [esp+32], eax
        ret
 
  .packets_tx:
        mov     eax, [eax + NET_DEVICE.packets_tx]
        mov     [esp+32], eax
        ret
 
  .packets_rx:
        mov     eax, [eax + NET_DEVICE.packets_rx]
        mov     [esp+32], eax
        ret
 
  .bytes_tx:
        mov     ebx, dword [eax + NET_DEVICE.bytes_tx + 4]
        mov     [esp+20], ebx
        mov     eax, dword [eax + NET_DEVICE.bytes_tx]
        mov     [esp+32], eax
        ret
 
  .bytes_rx:
        mov     ebx, dword [eax + NET_DEVICE.bytes_rx + 4]
        mov     [esp+20], ebx
        mov     eax, dword [eax + NET_DEVICE.bytes_rx]
        mov     [esp+32], eax
        ret
 
  .state:
        mov     eax, [eax + NET_DEVICE.link_state]
        mov     [esp+32], eax
        ret
 
 
  .doesnt_exist:
        mov     dword[esp+32], -1
        ret
 
 
 
;----------------------------------------------------------------
;
;  System function to work with protocols  (76)
;
;----------------------------------------------------------------
align 4
sys_protocols:
        cmp     bh, NET_DEVICES_MAX             ; Check if device number exists
        jae     .doesnt_exist
 
        mov     esi, ebx
        and     esi, 0x0000ff00
        shr     esi, 6                          ; now we have the device num * 4 in esi
        cmp     [esi + NET_DRV_LIST], 0         ; check if driver is running
        je      .doesnt_exist
 
        push    .return                         ; return address (we will be using jumps instead of calls)
 
        mov     eax, ebx                        ; set ax to protocol number
        shr     eax, 16                         ;
 
        cmp     ax, API_ETH
        je      ETH_api
 
        cmp     ax, API_IPv4
        je      IPv4_api
 
        cmp     ax, API_ICMP
        je      ICMP_api
 
        cmp     ax, API_UDP
        je      UDP_api
 
        cmp     ax, API_TCP
        je      TCP_api
 
        cmp     ax, API_ARP
        je      ARP_api
 
        cmp     ax, API_PPPOE
        je      PPPoE_api
 
        cmp     ax, API_IPv6
        je      IPv6_api
 
        add     esp, 4                           ; if we reached here, no function was called, so we need to balance stack
 
  .doesnt_exist:
        mov     eax, -1
 
  .return:
        mov     [esp+28+4], eax                 ; return eax value to the program
        ret

Rev 3725	Rev 3908
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2013. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;; STACK.INC ;;	6	;; STACK.INC ;;
7	;; ;;	7	;; ;;
8	;; TCP/IP stack for KolibriOS ;;	8	;; TCP/IP stack for KolibriOS ;;
9	;; ;;	9	;; ;;
10	;; Written by hidnplayr@kolibrios.org ;;	10	;; Written by hidnplayr@kolibrios.org ;;
11	;; ;;	11	;; ;;
12	;; Some parts of code are based on the work of: ;;	12	;; Some parts of code are based on the work of: ;;
13	;; Mike Hibbett (menuetos network stack) ;;	13	;; Mike Hibbett (menuetos network stack) ;;
14	;; Eugen Brasoveanu (solar os network stack and drivers) ;;	14	;; Eugen Brasoveanu (solar os network stack and drivers) ;;
15	;; mike.dld (kolibrios socket code) ;;	15	;; mike.dld (kolibrios socket code) ;;
16	;; ;;	16	;; ;;
17	;; TCP part is based on 4.4BSD ;;	17	;; TCP part is based on 4.4BSD ;;
18	;; ;;	18	;; ;;
19	;; GNU GENERAL PUBLIC LICENSE ;;	19	;; GNU GENERAL PUBLIC LICENSE ;;
20	;; Version 2, June 1991 ;;	20	;; Version 2, June 1991 ;;
21	;; ;;	21	;; ;;
22	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	22	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
23		23
24	$Revision: 3725 $	24	$Revision: 3908 $
25		25
26	uglobal	26	uglobal
27	net_10ms dd ?	27	net_10ms dd ?
28	net_tmr_count dw ?	28	net_tmr_count dw ?
29	endg	29	endg
30		30
31	DEBUG_NETWORK_ERROR = 1	31	DEBUG_NETWORK_ERROR = 1
32	DEBUG_NETWORK_VERBOSE = 0	32	DEBUG_NETWORK_VERBOSE = 0
33		33
34	NET_DEVICES_MAX = 16	34	NET_DEVICES_MAX = 16
35	ARP_BLOCK = 1 ; true or false	35	ARP_BLOCK = 1 ; true or false
36		36
37	EPHEMERAL_PORT_MIN = 49152	37	EPHEMERAL_PORT_MIN = 49152
38	EPHEMERAL_PORT_MAX = 61000	38	EPHEMERAL_PORT_MAX = 61000
39	MIN_EPHEMERAL_PORT_N = 0x00C0 ; same in Network byte order (FIXME)	39	MIN_EPHEMERAL_PORT_N = 0x00C0 ; same in Network byte order (FIXME)
40	MAX_EPHEMERAL_PORT_N = 0x48EE ; same in Network byte order (FIXME)	40	MAX_EPHEMERAL_PORT_N = 0x48EE ; same in Network byte order (FIXME)
41		41
42	; Ethernet protocol numbers	42	; Ethernet protocol numbers
43	ETHER_PROTO_ARP = 0x0608	43	ETHER_PROTO_ARP = 0x0608
44	ETHER_PROTO_IPv4 = 0x0008	44	ETHER_PROTO_IPv4 = 0x0008
45	ETHER_PROTO_IPv6 = 0xDD86	45	ETHER_PROTO_IPv6 = 0xDD86
46	ETHER_PROTO_PPP_DISCOVERY = 0x6388	46	ETHER_PROTO_PPP_DISCOVERY = 0x6388
47	ETHER_PROTO_PPP_SESSION = 0x6488	47	ETHER_PROTO_PPP_SESSION = 0x6488
48		48
49	; Internet protocol numbers	49	; Internet protocol numbers
50	IP_PROTO_IP = 0	50	IP_PROTO_IP = 0
51	IP_PROTO_ICMP = 1	51	IP_PROTO_ICMP = 1
52	IP_PROTO_TCP = 6	52	IP_PROTO_TCP = 6
53	IP_PROTO_UDP = 17	53	IP_PROTO_UDP = 17
54		54
55	; PPP protocol numbers	55	; PPP protocol numbers
56	PPP_PROTO_IPv4 = 0x2100	56	PPP_PROTO_IPv4 = 0x2100
57	PPP_PROTO_IPV6 = 0x5780	57	PPP_PROTO_IPV6 = 0x5780
58	PPP_PROTO_ETHERNET = 666 ; FIXME	58	PPP_PROTO_ETHERNET = 666 ; FIXME
59		59
60	;Protocol family	60	;Protocol family
61	AF_UNSPEC = 0	61	AF_UNSPEC = 0
62	AF_LOCAL = 1	62	AF_LOCAL = 1
63	AF_INET4 = 2	63	AF_INET4 = 2
64	AF_INET6 = 10	64	AF_INET6 = 10
65	AF_PPP = 777 ; FIXME	65	AF_PPP = 777 ; FIXME
66		66
67	; Socket types	67	; Socket types
68	SOCK_STREAM = 1	68	SOCK_STREAM = 1
69	SOCK_DGRAM = 2	69	SOCK_DGRAM = 2
70	SOCK_RAW = 3	70	SOCK_RAW = 3
71		71
72	; Socket options	72	; Socket options
73	SO_ACCEPTCON = 1 shl 0	73	SO_ACCEPTCON = 1 shl 0
74	SO_BROADCAST = 1 shl 1	74	SO_BROADCAST = 1 shl 1
75	SO_DEBUG = 1 shl 2	75	SO_DEBUG = 1 shl 2
76	SO_DONTROUTE = 1 shl 3	76	SO_DONTROUTE = 1 shl 3
77	SO_KEEPALIVE = 1 shl 4	77	SO_KEEPALIVE = 1 shl 4
78	SO_OOBINLINE = 1 shl 5	78	SO_OOBINLINE = 1 shl 5
79	SO_REUSEADDR = 1 shl 6	79	SO_REUSEADDR = 1 shl 6
80	SO_REUSEPORT = 1 shl 7	80	SO_REUSEPORT = 1 shl 7
81	SO_USELOOPBACK = 1 shl 8	81	SO_USELOOPBACK = 1 shl 8
82	SO_BINDTODEVICE = 1 shl 9	82	SO_BINDTODEVICE = 1 shl 9
83		83
84	SO_NONBLOCK = 1 shl 31	84	SO_NONBLOCK = 1 shl 31
85		85
86	; Socket flags for user calls	86	; Socket flags for user calls
87	MSG_PEEK = 0x02	87	MSG_PEEK = 0x02
88	MSG_DONTWAIT = 0x40	88	MSG_DONTWAIT = 0x40
89		89
90	; Socket level	90	; Socket level
91	SOL_SOCKET = 0	91	SOL_SOCKET = 0
92		92
93		93
94	; Socket States	94	; Socket States
95	SS_NOFDREF = 0x0001 ; no file table ref any more	95	SS_NOFDREF = 0x0001 ; no file table ref any more
96	SS_ISCONNECTED = 0x0002 ; socket connected to a peer	96	SS_ISCONNECTED = 0x0002 ; socket connected to a peer
97	SS_ISCONNECTING = 0x0004 ; in process of connecting to peer	97	SS_ISCONNECTING = 0x0004 ; in process of connecting to peer
98	SS_ISDISCONNECTING = 0x0008 ; in process of disconnecting	98	SS_ISDISCONNECTING = 0x0008 ; in process of disconnecting
99	SS_CANTSENDMORE = 0x0010 ; can't send more data to peer	99	SS_CANTSENDMORE = 0x0010 ; can't send more data to peer
100	SS_CANTRCVMORE = 0x0020 ; can't receive more data from peer	100	SS_CANTRCVMORE = 0x0020 ; can't receive more data from peer
101	SS_RCVATMARK = 0x0040 ; at mark on input	101	SS_RCVATMARK = 0x0040 ; at mark on input
102	SS_ISABORTING = 0x0080 ; aborting fd references - close()	102	SS_ISABORTING = 0x0080 ; aborting fd references - close()
103	SS_RESTARTSYS = 0x0100 ; restart blocked system calls	103	SS_RESTARTSYS = 0x0100 ; restart blocked system calls
104	SS_ISDISCONNECTED = 0x0800 ; socket disconnected from peer	104	SS_ISDISCONNECTED = 0x0800 ; socket disconnected from peer
105		105
106	SS_ASYNC = 0x1000 ; async i/o notify	106	SS_ASYNC = 0x1000 ; async i/o notify
107	SS_ISCONFIRMING = 0x2000 ; deciding to accept connection req	107	SS_ISCONFIRMING = 0x2000 ; deciding to accept connection req
108	SS_MORETOCOME = 0x4000	108	SS_MORETOCOME = 0x4000
109		109
110	SS_BLOCKED = 0x8000	110	SS_BLOCKED = 0x8000
111		111
112		112
113	SOCKET_MAXDATA = 409632 ; must be 4096(power of 2) where 'power of 2' is at least 8	113	SOCKET_MAXDATA = 409632 ; must be 4096(power of 2) where 'power of 2' is at least 8
114	MAX_backlog = 20 ; maximum backlog for stream sockets	114	MAX_backlog = 20 ; maximum backlog for stream sockets
115		115
116	; Error Codes	116	; Error Codes
117	ENOBUFS = 1	117	ENOBUFS = 1
118	EOPNOTSUPP = 4	118	EOPNOTSUPP = 4
119	EWOULDBLOCK = 6	119	EWOULDBLOCK = 6
120	ENOTCONN = 9	120	ENOTCONN = 9
121	EALREADY = 10	121	EALREADY = 10
122	EINVAL = 11	122	EINVAL = 11
123	EMSGSIZE = 12	123	EMSGSIZE = 12
124	ENOMEM = 18	124	ENOMEM = 18
125	EADDRINUSE = 20	125	EADDRINUSE = 20
126	ECONNREFUSED = 61	126	ECONNREFUSED = 61
127	ECONNRESET = 52	127	ECONNRESET = 52
128	ETIMEDOUT = 60	128	ETIMEDOUT = 60
129	ECONNABORTED = 53	129	ECONNABORTED = 53
130		130
131	; Api protocol numbers	131	; Api protocol numbers
132	API_ETH = 0	132	API_ETH = 0
133	API_IPv4 = 1	133	API_IPv4 = 1
134	API_ICMP = 2	134	API_ICMP = 2
135	API_UDP = 3	135	API_UDP = 3
136	API_TCP = 4	136	API_TCP = 4
137	API_ARP = 5	137	API_ARP = 5
138	API_PPPOE = 6	138	API_PPPOE = 6
139	API_IPv6 = 7	139	API_IPv6 = 7
140		140
141	; Network device types	141	; Network device types
142	NET_DEVICE_LOOPBACK = 0	142	NET_DEVICE_LOOPBACK = 0
143	NET_DEVICE_ETH = 1	143	NET_DEVICE_ETH = 1
144	NET_DEVICE_SLIP = 2	144	NET_DEVICE_SLIP = 2
145		145
146	; Network link types (link protocols)	146	; Network link types (link protocols)
147	NET_LINK_LOOPBACK = 0 ;;; Really a link type?	147	NET_LINK_LOOPBACK = 0 ;;; Really a link type?
148	NET_LINK_MAC = 1 ; Media access control (ethernet, isdn, ...)	148	NET_LINK_MAC = 1 ; Media access control (ethernet, isdn, ...)
149	NET_LINK_PPP = 2 ; Point to Point Protocol (PPPoE, ...)	149	NET_LINK_PPP = 2 ; Point to Point Protocol (PPPoE, ...)
150	NET_LINK_IEEE802.11 = 3 ; IEEE 802.11 (WiFi)	150	NET_LINK_IEEE802.11 = 3 ; IEEE 802.11 (WiFi)
151		151
152	; Hardware acceleration bits	152	; Hardware acceleration bits
153	HWACC_TCP_IPv4 = 1 shl 0	153	HWACC_TCP_IPv4 = 1 shl 0
154		154
155	struct NET_DEVICE	155	struct NET_DEVICE
156		156
157	device_type dd ? ; Type field	157	device_type dd ? ; Type field
158	mtu dd ? ; Maximal Transmission Unit	158	mtu dd ? ; Maximal Transmission Unit
159	name dd ? ; Ptr to 0 terminated string	159	name dd ? ; Ptr to 0 terminated string
160		160
161	unload dd ? ; Ptrs to driver functions	161	unload dd ? ; Ptrs to driver functions
162	reset dd ? ;	162	reset dd ? ;
163	transmit dd ? ;	163	transmit dd ? ;
164		164
165	bytes_tx dq ? ; Statistics, updated by the driver	165	bytes_tx dq ? ; Statistics, updated by the driver
166	bytes_rx dq ? ;	166	bytes_rx dq ? ;
167	packets_tx dd ? ;	167	packets_tx dd ? ;
168	packets_rx dd ? ;	168	packets_rx dd ? ;
169		169
170	link_state dd ? ; link state (0 = no link)	170	link_state dd ? ; link state (0 = no link)
171	hwacc dd ? ; bitmask stating enabled HW accelerations (offload engines)	171	hwacc dd ? ; bitmask stating enabled HW accelerations (offload engines)
172		172
173	ends	173	ends
174		174
175		175
176	; Exactly as it says..	176	; Exactly as it says..
177	macro pseudo_random reg {	177	macro pseudo_random reg {
178	add reg, [esp]	178	add reg, [esp]
179	rol reg, 5	179	rol reg, 5
180	xor reg, [timer_ticks]	180	xor reg, [timer_ticks]
181	; add reg, [CPU_FREQ]	181	; add reg, [CPU_FREQ]
182	imul reg, 214013	182	imul reg, 214013
183	xor reg, 0xdeadbeef	183	xor reg, 0xdeadbeef
184	rol reg, 9	184	rol reg, 9
185	}	185	}
186		186
187	; Network to Hardware byte order (dword)	187	; Network to Hardware byte order (dword)
188	macro ntohd reg {	188	macro ntohd reg {
189		189
190	rol word reg, 8	190	rol word reg, 8
191	rol dword reg, 16	191	rol dword reg, 16
192	rol word reg , 8	192	rol word reg , 8
193		193
194	}	194	}
195		195
196	; Network to Hardware byte order (word)	196	; Network to Hardware byte order (word)
197	macro ntohw reg {	197	macro ntohw reg {
198		198
199	rol word reg, 8	199	rol word reg, 8
200		200
201	}	201	}
202		202
203		203
204	include "queue.inc"	204	include "queue.inc"
205		205
206	include "loopback.inc"	206	include "loopback.inc"
207	include "ethernet.inc"	207	include "ethernet.inc"
208		208
209	include "PPPoE.inc"	209	include "PPPoE.inc"
210		210
211	include "ARP.inc"	211	include "ARP.inc"
212	include "IPv4.inc"	212	include "IPv4.inc"
213	include "IPv6.inc"	213	include "IPv6.inc"
214		214
215	include "icmp.inc"	215	include "icmp.inc"
216	include "udp.inc"	216	include "udp.inc"
217	include "tcp.inc"	217	include "tcp.inc"
218		218
219	include "socket.inc"	219	include "socket.inc"
220		220
221		221
222		222
223	uglobal	223	uglobal
224	align 4	224	align 4
225		225
226	NET_RUNNING dd ?	226	NET_RUNNING dd ?
227	NET_DRV_LIST rd NET_DEVICES_MAX	227	NET_DRV_LIST rd NET_DEVICES_MAX
228		228
229	endg	229	endg
230		230
231		231
232	;-----------------------------------------------------------------	232	;-----------------------------------------------------------------
233	;	233	;
234	; stack_init	234	; stack_init
235	;	235	;
236	; This function calls all network init procedures	236	; This function calls all network init procedures
237	;	237	;
238	; IN: /	238	; IN: /
239	; OUT: /	239	; OUT: /
240	;	240	;
241	;-----------------------------------------------------------------	241	;-----------------------------------------------------------------
242	align 4	242	align 4
243	stack_init:	243	stack_init:
244		244
245	; Init the network drivers list	245	; Init the network drivers list
246	xor eax, eax	246	xor eax, eax
247	mov edi, NET_RUNNING	247	mov edi, NET_RUNNING
248	mov ecx, (NET_DEVICES_MAX + 2)	248	mov ecx, (NET_DEVICES_MAX + 2)
249	rep stosd	249	rep stosd
250		250
251	PPPoE_init	251	PPPoE_init
252		252
253	IPv4_init	253	IPv4_init
254	; IPv6_init	254	; IPv6_init
255	ICMP_init	255	ICMP_init
256		256
257	ARP_init	257	ARP_init
258	UDP_init	258	UDP_init
259	TCP_init	259	TCP_init
260		260
261	SOCKET_init	261	SOCKET_init
262		262
263	LOOP_init	263	LOOP_init
264		264
265	mov [net_tmr_count], 0	265	mov [net_tmr_count], 0
266		266
267	ret	267	ret
268		268
269		269
270		270
271	; Wakeup every tick.	271	; Wakeup every tick.
272	proc stack_handler_has_work?	272	proc stack_handler_has_work?
273		273
274	mov eax, [timer_ticks]	274	mov eax, [timer_ticks]
275	cmp eax, [net_10ms]	275	cmp eax, [net_10ms]
276		276
277	ret	277	ret
278	endp	278	endp
279		279
280		280
281	;-----------------------------------------------------------------	281	;-----------------------------------------------------------------
282	;	282	;
283	; stack_handler	283	; stack_handler
284	;	284	;
285	; This function is called in kernel loop	285	; This function is called in kernel loop
286	;	286	;
287	; IN: /	287	; IN: /
288	; OUT: /	288	; OUT: /
289	;	289	;
290	;-----------------------------------------------------------------	290	;-----------------------------------------------------------------
291	align 4	291	align 4
292	stack_handler:	292	stack_handler:
293		293
294	; Test for 10ms tick	294	; Test for 10ms tick
295	mov eax, [timer_ticks]	295	mov eax, [timer_ticks]
296	cmp eax, [net_10ms]	296	cmp eax, [net_10ms]
297	je .exit	297	je .exit
298	mov [net_10ms], eax	298	mov [net_10ms], eax
299		299
300	cmp [NET_RUNNING], 0	300	cmp [NET_RUNNING], 0
301	je .exit	301	je .exit
302		302
303	test [net_10ms], 0x0f ; 160ms	303	test [net_10ms], 0x0f ; 160ms
304	jnz .exit	304	jnz .exit
305		305
306	TCP_timer_160ms	306	TCP_timer_160ms
307		307
308	test [net_10ms], 0x3f ; 640ms	308	test [net_10ms], 0x3f ; 640ms
309	jnz .exit	309	jnz .exit
310		310
311	TCP_timer_640ms	311	TCP_timer_640ms
312	ARP_decrease_entry_ttls	312	ARP_decrease_entry_ttls
313	IPv4_decrease_fragment_ttls	313	IPv4_decrease_fragment_ttls
314		314
315	.exit:	315	.exit:
316	ret	316	ret
317		317
-		318
-		319	align 4
-		320	NET_packet_free:
-		321	and dword[esp+4], not 0xfff
-		322	jmp kernel_free
318		323
319		324
320	align 4	325	align 4
321	NET_link_changed:	326	NET_link_changed:
322		327
323	DEBUGF DEBUG_NETWORK_VERBOSE, "NET_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.link_state]	328	DEBUGF DEBUG_NETWORK_VERBOSE, "NET_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.link_state]
324		329
325	align 4	330	align 4
326	NET_send_event:	331	NET_send_event:
327		332
328	DEBUGF DEBUG_NETWORK_VERBOSE, "NET_send_event\n"	333	DEBUGF DEBUG_NETWORK_VERBOSE, "NET_send_event\n"
329		334
330	; Send event to all applications	335	; Send event to all applications
331	push edi ecx	336	push edi ecx
332	mov edi, SLOT_BASE	337	mov edi, SLOT_BASE
333	mov ecx, [TASK_COUNT]	338	mov ecx, [TASK_COUNT]
334	.loop:	339	.loop:
335	add edi, 256	340	add edi, 256
336	or [edi + APPDATA.event_mask], EVENT_NETWORK2	341	or [edi + APPDATA.event_mask], EVENT_NETWORK2
337	loop .loop	342	loop .loop
338	pop ecx edi	343	pop ecx edi
339		344
340	ret	345	ret
341		346
342		347
343		348
344	;-----------------------------------------------------------------	349	;-----------------------------------------------------------------
345	;	350	;
346	; NET_add_device:	351	; NET_add_device:
347	;	352	;
348	; This function is called by the network drivers,	353	; This function is called by the network drivers,
349	; to register each running NIC to the kernel	354	; to register each running NIC to the kernel
350	;	355	;
351	; IN: Pointer to device structure in ebx	356	; IN: Pointer to device structure in ebx
352	; OUT: Device num in eax, -1 on error	357	; OUT: Device num in eax, -1 on error
353	;	358	;
354	;-----------------------------------------------------------------	359	;-----------------------------------------------------------------
355	align 4	360	align 4
356	NET_add_device:	361	NET_add_device:
357		362
358	DEBUGF DEBUG_NETWORK_VERBOSE, "NET_Add_Device: %x\n", ebx ;;; TODO: use mutex to lock net device list	363	DEBUGF DEBUG_NETWORK_VERBOSE, "NET_Add_Device: %x\n", ebx ;;; TODO: use mutex to lock net device list
359		364
360	cmp [NET_RUNNING], NET_DEVICES_MAX	365	cmp [NET_RUNNING], NET_DEVICES_MAX
361	jae .error	366	jae .error
362		367
363	;----------------------------------	368	;----------------------------------
364	; Check if device is already listed	369	; Check if device is already listed
365	mov eax, ebx	370	mov eax, ebx
366	mov ecx, NET_DEVICES_MAX ; We need to check whole list because a device may be removed without re-organizing list	371	mov ecx, NET_DEVICES_MAX ; We need to check whole list because a device may be removed without re-organizing list
367	mov edi, NET_DRV_LIST	372	mov edi, NET_DRV_LIST
368		373
369	repne scasd ; See if device is already in the list	374	repne scasd ; See if device is already in the list
370	jz .error	375	jz .error
371		376
372	;----------------------------	377	;----------------------------
373	; Find empty slot in the list	378	; Find empty slot in the list
374	xor eax, eax	379	xor eax, eax
375	mov ecx, NET_DEVICES_MAX	380	mov ecx, NET_DEVICES_MAX
376	mov edi, NET_DRV_LIST	381	mov edi, NET_DRV_LIST
377		382
378	repne scasd	383	repne scasd
379	jnz .error	384	jnz .error
380		385
381	sub edi, 4	386	sub edi, 4
382		387
383	;-----------------------------	388	;-----------------------------
384	; Add device to the found slot	389	; Add device to the found slot
385	mov [edi], ebx ; add device to list	390	mov [edi], ebx ; add device to list
386		391
387	mov eax, edi ; Calculate device number in eax	392	mov eax, edi ; Calculate device number in eax
388	sub eax, NET_DRV_LIST	393	sub eax, NET_DRV_LIST
389	shr eax, 2	394	shr eax, 2
390		395
391	inc [NET_RUNNING] ; Indicate that one more network device is up and running	396	inc [NET_RUNNING] ; Indicate that one more network device is up and running
392		397
393	call NET_send_event	398	call NET_send_event
394		399
395	DEBUGF DEBUG_NETWORK_VERBOSE, "Device number: %u\n", eax	400	DEBUGF DEBUG_NETWORK_VERBOSE, "Device number: %u\n", eax
396	ret	401	ret
397		402
398	.error:	403	.error:
399	or eax, -1	404	or eax, -1
400	DEBUGF DEBUG_NETWORK_ERROR, "Adding network device failed\n"	405	DEBUGF DEBUG_NETWORK_ERROR, "Adding network device failed\n"
401	ret	406	ret
402		407
403		408
404		409
405	;-----------------------------------------------------------------	410	;-----------------------------------------------------------------
406	;	411	;
407	; NET_Remove_Device:	412	; NET_Remove_Device:
408	;	413	;
409	; This function is called by network drivers,	414	; This function is called by network drivers,
410	; to unregister network devices from the kernel	415	; to unregister network devices from the kernel
411	;	416	;
412	; IN: Pointer to device structure in ebx	417	; IN: Pointer to device structure in ebx
413	; OUT: eax: -1 on error	418	; OUT: eax: -1 on error
414	;	419	;
415	;-----------------------------------------------------------------	420	;-----------------------------------------------------------------
416	align 4	421	align 4
417	NET_remove_device:	422	NET_remove_device:
418		423
419	cmp [NET_RUNNING], 0	424	cmp [NET_RUNNING], 0
420	je .error	425	je .error
421		426
422	;----------------------------	427	;----------------------------
423	; Find the driver in the list	428	; Find the driver in the list
424		429
425	mov eax, ebx	430	mov eax, ebx
426	mov ecx, NET_DEVICES_MAX	431	mov ecx, NET_DEVICES_MAX
427	mov edi, NET_DRV_LIST	432	mov edi, NET_DRV_LIST
428		433
429	repne scasd	434	repne scasd
430	jnz .error	435	jnz .error
431		436
432	;------------------------	437	;------------------------
433	; Remove it from the list	438	; Remove it from the list
434		439
435	xor eax, eax	440	xor eax, eax
436	mov dword [edi-4], eax	441	mov dword [edi-4], eax
437	dec [NET_RUNNING]	442	dec [NET_RUNNING]
438		443
439	call NET_send_event	444	call NET_send_event
440		445
441	xor eax, eax	446	xor eax, eax
442	ret	447	ret
443		448
444	.error:	449	.error:
445	or eax, -1	450	or eax, -1
446	ret	451	ret
447		452
448		453
449		454
450	;-----------------------------------------------------------------	455	;-----------------------------------------------------------------
451	;	456	;
452	; NET_ptr_to_num	457	; NET_ptr_to_num
453	;	458	;
454	; IN: ebx = ptr to device struct	459	; IN: ebx = ptr to device struct
455	; OUT: edi = -1 on error, device number otherwise	460	; OUT: edi = -1 on error, device number otherwise
456	;	461	;
457	;-----------------------------------------------------------------	462	;-----------------------------------------------------------------
458	align 4	463	align 4
459	NET_ptr_to_num:	464	NET_ptr_to_num:
460		465
461	call NET_ptr_to_num4	466	call NET_ptr_to_num4
462	ror edi, 2 ; If -1, stay -1	467	ror edi, 2 ; If -1, stay -1
463	; valid device numbers have last two bits 0, so do just shr	468	; valid device numbers have last two bits 0, so do just shr
464		469
465	ret	470	ret
466		471
467	align 4	472	align 4
468	NET_ptr_to_num4: ; Todo, place number in device structure so we only need to verify?	473	NET_ptr_to_num4: ; Todo, place number in device structure so we only need to verify?
469		474
470	push ecx	475	push ecx
471		476
472	mov ecx, NET_DEVICES_MAX	477	mov ecx, NET_DEVICES_MAX
473	mov edi, NET_DRV_LIST	478	mov edi, NET_DRV_LIST
474	.loop:	479	.loop:
475	cmp ebx, [edi]	480	cmp ebx, [edi]
476	je .found	481	je .found
477	add edi, 4	482	add edi, 4
478	dec ecx	483	dec ecx
479	jnz .loop	484	jnz .loop
480		485
481	or edi, -1	486	or edi, -1
482	pop ecx	487	pop ecx
483	ret	488	ret
484		489
485	.found:	490	.found:
486	sub edi, NET_DRV_LIST	491	sub edi, NET_DRV_LIST
487	pop ecx	492	pop ecx
488	ret	493	ret
489		494
490	;-----------------------------------------------------------------	495	;-----------------------------------------------------------------
491	;	496	;
492	; checksum_1	497	; checksum_1
493	;	498	;
494	; This is the first of two functions needed to calculate a checksum.	499	; This is the first of two functions needed to calculate a checksum.
495	;	500	;

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/stack.inc – Rev 3725 → 3908