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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2012. 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: 3249 $
 
uglobal
        net_10ms        dd ?
        net_tmr_count   dw ?
endg
 
MAX_NET_DEVICES         = 16
 
MIN_EPHEMERAL_PORT      = 49152
MIN_EPHEMERAL_PORT_N    = 0x00C0        ; same in Network byte order (FIXME)
MAX_EPHEMERAL_PORT      = 61000
MAX_EPHEMERAL_PORT_N    = 0x48EE        ; same in Network byte order (FIXME)
 
; Ethernet protocol numbers
ETHER_ARP               = 0x0608
ETHER_IPv4              = 0x0008
ETHER_IPv6              = 0xDD86
ETHER_PPP_DISCOVERY     = 0x6388
ETHER_PPP_SESSION       = 0x6488
 
; PPP protocol numbers
PPP_IPv4                = 0x2100
PPP_IPV6                = 0x5780
 
;Protocol family
AF_UNSPEC               = 0
AF_UNIX                 = 1
AF_INET4                = 2
AF_INET6                = 10
AF_PPP                  = 777
 
; Internet protocol numbers
IP_PROTO_IP             = 0
IP_PROTO_ICMP           = 1
IP_PROTO_TCP            = 6
IP_PROTO_UDP            = 17
 
; PPP protocol number
PPP_PROTO_ETHERNET      = 666
 
; 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_BLOCK                = 1 shl 10
 
; Socket level
SOL_SOCKET              = 0
 
 
; Socket States
SS_NOFDREF              = 0x001       ; no file table ref any more
SS_ISCONNECTED          = 0x002       ; socket connected to a peer
SS_ISCONNECTING         = 0x004       ; in process of connecting to peer
SS_ISDISCONNECTING      = 0x008       ; in process of disconnecting
SS_CANTSENDMORE         = 0x010       ; can't send more data to peer
SS_CANTRCVMORE          = 0x020       ; can't receive more data from peer
SS_RCVATMARK            = 0x040       ; at mark on input
SS_ISABORTING           = 0x080       ; aborting fd references - close()
SS_RESTARTSYS           = 0x100       ; restart blocked system calls
SS_ISDISCONNECTED       = 0x800       ; socket disconnected from peer
 
SS_ASYNC                = 0x100       ; async i/o notify
SS_ISCONFIRMING         = 0x200       ; deciding to accept connection req
SS_MORETOCOME           = 0x400
 
 
SOCKET_MAXDATA          = 4096*32     ; must be 4096*(power of 2) where 'power of 2' is at least 8
 
; Network driver types
NET_TYPE_LOOPBACK       = 0
NET_TYPE_ETH            = 1
NET_TYPE_SLIP           = 2
 
MAX_backlog             = 20          ; maximum backlog for stream sockets
 
; Error Codes
ENOBUFS                 = 55
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
 
HWACC_TCP_IPv4          = 1 shl 0
 
struct  NET_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 ?    ;
 
;       hwacc           dd ?    ; bitmask stating available hardware 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"
 
 
 
align 4
uglobal
 
        NET_RUNNING     dd  ?
        NET_DEFAULT     dd  ?
        NET_DRV_LIST    rd  MAX_NET_DEVICES
 
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, (MAX_NET_DEVICES + 2)
        rep     stosd
 
        PPPoE_init
 
        IPv4_init
;        IPv6_init
        ICMP_init
 
        ARP_init
        UDP_init
        TCP_init
 
        SOCKET_init
 
        mov     [net_tmr_count], 0
 
        ret
 
 
;-----------------------------------------------------------------
;
; stack_handler
;
;  This function is called in kernel loop
;
;  IN:  /
;  OUT: /
;
;-----------------------------------------------------------------
align 4
stack_handler:
 
        cmp     [NET_RUNNING], 0
        je      .exit
 
        ; Test for 10ms tick
        mov     eax, [timer_ticks]
        cmp     eax, [net_10ms]
        je      .exit
        mov     [net_10ms], eax
 
        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
 
 
 
;-----------------------------------------------------------------
;
; 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  1,"NET_Add_Device: %x\n", ebx   ;;; TODO: use mutex to lock net device list
 
        mov     eax, [NET_RUNNING]
        cmp     eax, MAX_NET_DEVICES
        jae     .error
 
;----------------------------------
; Check if device is already listed
        mov     eax, ebx
        mov     ecx, MAX_NET_DEVICES    ; 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, MAX_NET_DEVICES
        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
 
        cmp     eax, 1                  ; If it's the first network device, try to set it as default
        jne     @f
        push    eax
        call    NET_set_default
        pop     eax
       @@:
 
        DEBUGF  1,"Device number: %u\n", eax
        ret
 
  .error:
        or      eax, -1
        DEBUGF  2,"Adding network device failed\n"
        ret
 
 
 
;-----------------------------------------------------------------
;
; NET_set_default
;
;  API to set the default interface
;
;  IN:  Device num in eax
;  OUT: Device num in eax, -1 on error
;
;-----------------------------------------------------------------
align 4
NET_set_default:
 
        DEBUGF  1,"NET_set_default: device=%x\n", eax
 
        cmp     eax, MAX_NET_DEVICES
        jae     .error
 
        cmp     [NET_DRV_LIST+eax*4], 0
        je      .error
 
        mov     [NET_DEFAULT], eax
 
        DEBUGF  1,"NET_set_default: succes\n"
        ret
 
  .error:
        or      eax, -1
        DEBUGF  1,"NET_set_default: failed\n"
        ret
 
 
;-----------------------------------------------------------------
;
; NET_Remove_Device:
;
;  This function is called by etwork 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
 
        cmp     [NET_DRV_LIST], ebx
        jne     @f
        mov     [NET_DRV_LIST], 0
        cmp     [NET_RUNNING], 1
        je      @f
        ; there are still active devices, find one and make it default
        xor     eax, eax
        mov     ecx, MAX_NET_DEVICES
        mov     edi, NET_DRV_LIST
        repe    scasd
        je      @f
        shr     edi, 2
        dec     edi
        mov     [NET_DEFAULT], edi
       @@:
 
;----------------------------
; Find the driver in the list
 
        mov     eax, ebx
        mov     ecx, MAX_NET_DEVICES
        mov     edi, NET_DRV_LIST+4
 
        repne   scasd
        jnz     .error
 
;------------------------
; Remove it from the list
 
        xor     eax, eax
        mov     dword [edi-4], eax
 
        dec     [NET_RUNNING]
        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:
        push    ecx
 
        mov     ecx, MAX_NET_DEVICES
        mov     edi, NET_DRV_LIST
 
  .loop:
        cmp     ebx, [edi]
        jz      .found
        add     edi, 4
        dec     ecx
        jnz     .loop
 
        ; repnz  scasd could work too if eax is used instead of ebx!
 
        or      edi, -1
 
        pop     ecx
        ret
 
  .found:
        sub     edi, NET_DRV_LIST
        shr     edi, 2
 
        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 1,"Checksum: %x\n", dx
 
        ret
 
 
 
;----------------------------------------------------------------
;
;  System function to work with network devices (75)
;
;----------------------------------------------------------------
align 4
sys_network:                    ; FIXME: make default device easily accessible
 
        cmp     ebx, -1
        jne     @f
 
        mov     eax, [NET_RUNNING]
        jmp     .return
 
   @@:
        cmp     bh, MAX_NET_DEVICES             ; 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      .set_default            ; 6
  .number = ($ - .table) / 4 - 1
 
  .get_type:                            ; 0 = Get device type (ethernet/token ring/...)
 
        mov     eax, [eax + NET_DEVICE.type]
        jmp     .return
 
 
  .get_dev_name:                        ; 1 = Get device name
 
        mov     esi, [eax + NET_DEVICE.name]
        mov     edi, ecx
 
        mov     ecx, 64/4 ; max length
        rep     movsd
 
        xor     eax, eax
        jmp     .return
 
  .reset:                               ; 2 = Reset the device
 
        call    [eax + NET_DEVICE.reset]
        jmp     .return
 
  .stop:                                ; 3 = Stop driver for this device
 
        call    [eax + NET_DEVICE.unload]
        jmp     .return
 
 
  .get_ptr:                             ; 4 = Get driver pointer
 
        jmp     .return
 
 
  .get_drv_name:                        ; 5 = Get driver name
 
        xor     eax, eax
        jmp     .return
 
 
  .set_default:                         ; 6 = Set default device
 
        call    NET_set_default
        jmp     .return
 
  .doesnt_exist:
        mov     eax, -1
 
  .return:
        mov     [esp+32], eax
        ret
 
 
;----------------------------------------------------------------
;
;  System function to work with protocols  (76)
;
;----------------------------------------------------------------
align 4
sys_protocols:
        cmp     bh, MAX_NET_DEVICES             ; 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 3185	Rev 3249
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2012. 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: 3185 $	-
25		-
26	__DEBUG_LEVEL_OLD__ equ __DEBUG_LEVEL__ ; use seperate debug level for network part of kernel	-
27	__DEBUG_LEVEL__ equ 1	24	$Revision: 3249 $
28		25
29	uglobal	26	uglobal
30	net_10ms dd ?	27	net_10ms dd ?
31	net_tmr_count dw ?	28	net_tmr_count dw ?
32	endg	29	endg
33		30
34	MAX_NET_DEVICES = 16	31	MAX_NET_DEVICES = 16
35		32
36	MIN_EPHEMERAL_PORT = 49152	33	MIN_EPHEMERAL_PORT = 49152
37	MIN_EPHEMERAL_PORT_N = 0x00C0 ; same in Network byte order (FIXME)	34	MIN_EPHEMERAL_PORT_N = 0x00C0 ; same in Network byte order (FIXME)
38	MAX_EPHEMERAL_PORT = 61000	35	MAX_EPHEMERAL_PORT = 61000
39	MAX_EPHEMERAL_PORT_N = 0x48EE ; same in Network byte order (FIXME)	36	MAX_EPHEMERAL_PORT_N = 0x48EE ; same in Network byte order (FIXME)
40		37
41	; Ethernet protocol numbers	38	; Ethernet protocol numbers
42	ETHER_ARP = 0x0608	39	ETHER_ARP = 0x0608
43	ETHER_IPv4 = 0x0008	40	ETHER_IPv4 = 0x0008
44	ETHER_IPv6 = 0xDD86	41	ETHER_IPv6 = 0xDD86
45	ETHER_PPP_DISCOVERY = 0x6388	42	ETHER_PPP_DISCOVERY = 0x6388
46	ETHER_PPP_SESSION = 0x6488	43	ETHER_PPP_SESSION = 0x6488
47		44
48	; PPP protocol numbers	45	; PPP protocol numbers
49	PPP_IPv4 = 0x2100	46	PPP_IPv4 = 0x2100
50	PPP_IPV6 = 0x5780	47	PPP_IPV6 = 0x5780
51		48
52	;Protocol family	49	;Protocol family
53	AF_UNSPEC = 0	50	AF_UNSPEC = 0
54	AF_UNIX = 1	51	AF_UNIX = 1
55	AF_INET4 = 2	52	AF_INET4 = 2
56	AF_INET6 = 10	53	AF_INET6 = 10
57	AF_PPP = 777	54	AF_PPP = 777
58		55
59	; Internet protocol numbers	56	; Internet protocol numbers
60	IP_PROTO_IP = 0	57	IP_PROTO_IP = 0
61	IP_PROTO_ICMP = 1	58	IP_PROTO_ICMP = 1
62	IP_PROTO_TCP = 6	59	IP_PROTO_TCP = 6
63	IP_PROTO_UDP = 17	60	IP_PROTO_UDP = 17
64		61
65	; PPP protocol number	62	; PPP protocol number
66	PPP_PROTO_ETHERNET = 666	63	PPP_PROTO_ETHERNET = 666
67		64
68	; Socket types	65	; Socket types
69	SOCK_STREAM = 1	66	SOCK_STREAM = 1
70	SOCK_DGRAM = 2	67	SOCK_DGRAM = 2
71	SOCK_RAW = 3	68	SOCK_RAW = 3
72		69
73	; Socket options	70	; Socket options
74	SO_ACCEPTCON = 1 shl 0	71	SO_ACCEPTCON = 1 shl 0
75	SO_BROADCAST = 1 shl 1	72	SO_BROADCAST = 1 shl 1
76	SO_DEBUG = 1 shl 2	73	SO_DEBUG = 1 shl 2
77	SO_DONTROUTE = 1 shl 3	74	SO_DONTROUTE = 1 shl 3
78	SO_KEEPALIVE = 1 shl 4	75	SO_KEEPALIVE = 1 shl 4
79	SO_OOBINLINE = 1 shl 5	76	SO_OOBINLINE = 1 shl 5
80	SO_REUSEADDR = 1 shl 6	77	SO_REUSEADDR = 1 shl 6
81	SO_REUSEPORT = 1 shl 7	78	SO_REUSEPORT = 1 shl 7
82	SO_USELOOPBACK = 1 shl 8	79	SO_USELOOPBACK = 1 shl 8
83	SO_BINDTODEVICE = 1 shl 9	80	SO_BINDTODEVICE = 1 shl 9
84		81
85	SO_BLOCK = 1 shl 10	82	SO_BLOCK = 1 shl 10
86		83
87	; Socket level	84	; Socket level
88	SOL_SOCKET = 0	85	SOL_SOCKET = 0
89		86
90		87
91	; Socket States	88	; Socket States
92	SS_NOFDREF = 0x001 ; no file table ref any more	89	SS_NOFDREF = 0x001 ; no file table ref any more
93	SS_ISCONNECTED = 0x002 ; socket connected to a peer	90	SS_ISCONNECTED = 0x002 ; socket connected to a peer
94	SS_ISCONNECTING = 0x004 ; in process of connecting to peer	91	SS_ISCONNECTING = 0x004 ; in process of connecting to peer
95	SS_ISDISCONNECTING = 0x008 ; in process of disconnecting	92	SS_ISDISCONNECTING = 0x008 ; in process of disconnecting
96	SS_CANTSENDMORE = 0x010 ; can't send more data to peer	93	SS_CANTSENDMORE = 0x010 ; can't send more data to peer
97	SS_CANTRCVMORE = 0x020 ; can't receive more data from peer	94	SS_CANTRCVMORE = 0x020 ; can't receive more data from peer
98	SS_RCVATMARK = 0x040 ; at mark on input	95	SS_RCVATMARK = 0x040 ; at mark on input
99	SS_ISABORTING = 0x080 ; aborting fd references - close()	96	SS_ISABORTING = 0x080 ; aborting fd references - close()
100	SS_RESTARTSYS = 0x100 ; restart blocked system calls	97	SS_RESTARTSYS = 0x100 ; restart blocked system calls
101	SS_ISDISCONNECTED = 0x800 ; socket disconnected from peer	98	SS_ISDISCONNECTED = 0x800 ; socket disconnected from peer
102		99
103	SS_ASYNC = 0x100 ; async i/o notify	100	SS_ASYNC = 0x100 ; async i/o notify
104	SS_ISCONFIRMING = 0x200 ; deciding to accept connection req	101	SS_ISCONFIRMING = 0x200 ; deciding to accept connection req
105	SS_MORETOCOME = 0x400	102	SS_MORETOCOME = 0x400
106		103
107		104
108	SOCKET_MAXDATA = 409632 ; must be 4096(power of 2) where 'power of 2' is at least 8	105	SOCKET_MAXDATA = 409632 ; must be 4096(power of 2) where 'power of 2' is at least 8
109		106
110	; Network driver types	107	; Network driver types
111	NET_TYPE_LOOPBACK = 0	108	NET_TYPE_LOOPBACK = 0
112	NET_TYPE_ETH = 1	109	NET_TYPE_ETH = 1
113	NET_TYPE_SLIP = 2	110	NET_TYPE_SLIP = 2
114		111
115	MAX_backlog = 20 ; maximum backlog for stream sockets	112	MAX_backlog = 20 ; maximum backlog for stream sockets
116		113
117	; Error Codes	114	; Error Codes
118	ENOBUFS = 55	115	ENOBUFS = 55
119	ECONNREFUSED = 61	116	ECONNREFUSED = 61
120	ECONNRESET = 52	117	ECONNRESET = 52
121	ETIMEDOUT = 60	118	ETIMEDOUT = 60
122	ECONNABORTED = 53	119	ECONNABORTED = 53
123		120
124	; Api protocol numbers	121	; Api protocol numbers
125	API_ETH = 0	122	API_ETH = 0
126	API_IPv4 = 1	123	API_IPv4 = 1
127	API_ICMP = 2	124	API_ICMP = 2
128	API_UDP = 3	125	API_UDP = 3
129	API_TCP = 4	126	API_TCP = 4
130	API_ARP = 5	127	API_ARP = 5
131	API_PPPOE = 6	128	API_PPPOE = 6
132	API_IPv6 = 7	129	API_IPv6 = 7
133		130
134	HWACC_TCP_IPv4 = 1 shl 0	131	HWACC_TCP_IPv4 = 1 shl 0
135		132
136	struct NET_DEVICE	133	struct NET_DEVICE
137		134
138	type dd ? ; Type field	135	type dd ? ; Type field
139	mtu dd ? ; Maximal Transmission Unit	136	mtu dd ? ; Maximal Transmission Unit
140	name dd ? ; Ptr to 0 terminated string	137	name dd ? ; Ptr to 0 terminated string
141		138
142	unload dd ? ; Ptrs to driver functions	139	unload dd ? ; Ptrs to driver functions
143	reset dd ? ;	140	reset dd ? ;
144	transmit dd ? ;	141	transmit dd ? ;
145		142
146	bytes_tx dq ? ; Statistics, updated by the driver	143	bytes_tx dq ? ; Statistics, updated by the driver
147	bytes_rx dq ? ;	144	bytes_rx dq ? ;
148	packets_tx dd ? ;	145	packets_tx dd ? ;
149	packets_rx dd ? ;	146	packets_rx dd ? ;
150		147
151	; hwacc dd ? ; bitmask stating available hardware accelerations (offload engines)	148	; hwacc dd ? ; bitmask stating available hardware accelerations (offload engines)
152		149
153	ends	150	ends
154		151
155		152
156	; Exactly as it says..	153	; Exactly as it says..
157	macro pseudo_random reg {	154	macro pseudo_random reg {
158	add reg, [esp]	155	add reg, [esp]
159	rol reg, 5	156	rol reg, 5
160	xor reg, [timer_ticks]	157	xor reg, [timer_ticks]
161	add reg, [CPU_FREQ]	158	add reg, [CPU_FREQ]
162	imul reg, 214013	159	imul reg, 214013
163	xor reg, 0xdeadbeef	160	xor reg, 0xdeadbeef
164	rol reg, 9	161	rol reg, 9
165	}	162	}
-		163
166		164	; Network to Hardware byte order (dword)
167	macro ntohd reg {	165	macro ntohd reg {
168		166
169	rol word reg, 8	167	rol word reg, 8
170	rol dword reg, 16	168	rol dword reg, 16
171	rol word reg , 8	169	rol word reg , 8
172		170
173	}	171	}
-		172
174		173	; Network to Hardware byte order (word)
175	macro ntohw reg {	174	macro ntohw reg {
176		175
177	rol word reg, 8	176	rol word reg, 8
178		177
179	}	178	}
180		179
181		180
182	include "queue.inc"	181	include "queue.inc"
183		182
184	include "loopback.inc"	183	include "loopback.inc"
185	include "ethernet.inc"	184	include "ethernet.inc"
186		185
187	include "PPPoE.inc"	186	include "PPPoE.inc"
188		187
189	include "ARP.inc"	188	include "ARP.inc"
190	include "IPv4.inc"	189	include "IPv4.inc"
191	include "IPv6.inc"	190	include "IPv6.inc"
192		191
193	include "icmp.inc"	192	include "icmp.inc"
194	include "udp.inc"	193	include "udp.inc"
195	include "tcp.inc"	194	include "tcp.inc"
196		195
197	include "socket.inc"	196	include "socket.inc"
198		197
199		198
200		199
201	align 4	200	align 4
202	uglobal	201	uglobal
203		202
204	NET_RUNNING dd ?	203	NET_RUNNING dd ?
205	NET_DEFAULT dd ?	204	NET_DEFAULT dd ?
206	NET_DRV_LIST rd MAX_NET_DEVICES	205	NET_DRV_LIST rd MAX_NET_DEVICES
207		206
208	endg	207	endg
209		208
210		209
211	;-----------------------------------------------------------------	210	;-----------------------------------------------------------------
212	;	211	;
213	; stack_init	212	; stack_init
214	;	213	;
215	; This function calls all network init procedures	214	; This function calls all network init procedures
216	;	215	;
217	; IN: /	216	; IN: /
218	; OUT: /	217	; OUT: /
219	;	218	;
220	;-----------------------------------------------------------------	219	;-----------------------------------------------------------------
221	align 4	220	align 4
222	stack_init:	221	stack_init:
223		222
224	; Init the network drivers list	223	; Init the network drivers list
225	xor eax, eax	224	xor eax, eax
226	mov edi, NET_RUNNING	225	mov edi, NET_RUNNING
227	mov ecx, (MAX_NET_DEVICES + 2)	226	mov ecx, (MAX_NET_DEVICES + 2)
228	rep stosd	227	rep stosd
229		228
230	PPPoE_init	229	PPPoE_init
231		230
232	IPv4_init	231	IPv4_init
233	; IPv6_init	232	; IPv6_init
234	ICMP_init	233	ICMP_init
235		234
236	ARP_init	235	ARP_init
237	UDP_init	236	UDP_init
238	TCP_init	237	TCP_init
239		238
240	SOCKET_init	239	SOCKET_init
241		240
242	mov [net_tmr_count], 0	241	mov [net_tmr_count], 0
243		242
244	ret	243	ret
245		244
246		245
247	;-----------------------------------------------------------------	246	;-----------------------------------------------------------------
248	;	247	;
249	; stack_handler	248	; stack_handler
250	;	249	;
251	; This function is called in kernel loop	250	; This function is called in kernel loop
252	;	251	;
253	; IN: /	252	; IN: /
254	; OUT: /	253	; OUT: /
255	;	254	;
256	;-----------------------------------------------------------------	255	;-----------------------------------------------------------------
257	align 4	256	align 4
258	stack_handler:	257	stack_handler:
259		258
260	cmp [NET_RUNNING], 0	259	cmp [NET_RUNNING], 0
261	je .exit	260	je .exit
262		261
263	; Test for 10ms tick	262	; Test for 10ms tick
264	mov eax, [timer_ticks]	263	mov eax, [timer_ticks]
265	cmp eax, [net_10ms]	264	cmp eax, [net_10ms]
266	je .exit	265	je .exit
267	mov [net_10ms], eax	266	mov [net_10ms], eax
268		267
269	test [net_10ms], 0x0f ; 160ms	268	test [net_10ms], 0x0f ; 160ms
270	jnz .exit	269	jnz .exit
271		270
272	TCP_timer_160ms	271	TCP_timer_160ms
273		272
274	test [net_10ms], 0x3f ; 640ms	273	test [net_10ms], 0x3f ; 640ms
275	jnz .exit	274	jnz .exit
276		275
277	TCP_timer_640ms	276	TCP_timer_640ms
278	ARP_decrease_entry_ttls	277	ARP_decrease_entry_ttls
279	IPv4_decrease_fragment_ttls	278	IPv4_decrease_fragment_ttls
280		279
281	.exit:	280	.exit:
282	ret	281	ret
283		282
284		283
285		284
286	;-----------------------------------------------------------------	285	;-----------------------------------------------------------------
287	;	286	;
288	; NET_add_device:	287	; NET_add_device:
289	;	288	;
290	; This function is called by the network drivers,	289	; This function is called by the network drivers,
291	; to register each running NIC to the kernel	290	; to register each running NIC to the kernel
292	;	291	;
293	; IN: Pointer to device structure in ebx	292	; IN: Pointer to device structure in ebx
294	; OUT: Device num in eax, -1 on error	293	; OUT: Device num in eax, -1 on error
295	;	294	;
296	;-----------------------------------------------------------------	295	;-----------------------------------------------------------------
297	align 4	296	align 4
298	NET_add_device:	297	NET_add_device:
299		298
300	DEBUGF 1,"NET_Add_Device: %x\n", ebx ;;; TODO: use mutex to lock net device list	299	DEBUGF 1,"NET_Add_Device: %x\n", ebx ;;; TODO: use mutex to lock net device list
301		300
302	mov eax, [NET_RUNNING]	301	mov eax, [NET_RUNNING]
303	cmp eax, MAX_NET_DEVICES	302	cmp eax, MAX_NET_DEVICES
304	jae .error	303	jae .error
305		304
306	;----------------------------------	305	;----------------------------------
307	; Check if device is already listed	306	; Check if device is already listed
308	mov eax, ebx	307	mov eax, ebx
309	mov ecx, MAX_NET_DEVICES ; We need to check whole list because a device may be removed without re-organizing list	308	mov ecx, MAX_NET_DEVICES ; We need to check whole list because a device may be removed without re-organizing list
310	mov edi, NET_DRV_LIST	309	mov edi, NET_DRV_LIST
311		310
312	repne scasd ; See if device is already in the list	311	repne scasd ; See if device is already in the list
313	jz .error	312	jz .error
314		313
315	;----------------------------	314	;----------------------------
316	; Find empty slot in the list	315	; Find empty slot in the list
317	xor eax, eax	316	xor eax, eax
318	mov ecx, MAX_NET_DEVICES	317	mov ecx, MAX_NET_DEVICES
319	mov edi, NET_DRV_LIST	318	mov edi, NET_DRV_LIST
320		319
321	repne scasd	320	repne scasd
322	jnz .error	321	jnz .error
323		322
324	sub edi, 4	323	sub edi, 4
325		324
326	;-----------------------------	325	;-----------------------------
327	; Add device to the found slot	326	; Add device to the found slot
328	mov [edi], ebx ; add device to list	327	mov [edi], ebx ; add device to list
329		328
330	mov eax, edi ; Calculate device number in eax	329	mov eax, edi ; Calculate device number in eax
331	sub eax, NET_DRV_LIST	330	sub eax, NET_DRV_LIST
332	shr eax, 2	331	shr eax, 2
333		332
334	inc [NET_RUNNING] ; Indicate that one more network device is up and running	333	inc [NET_RUNNING] ; Indicate that one more network device is up and running
335		334
336	cmp eax, 1 ; If it's the first network device, try to set it as default	335	cmp eax, 1 ; If it's the first network device, try to set it as default
337	jne @f	336	jne @f
338	push eax	337	push eax
339	call NET_set_default	338	call NET_set_default
340	pop eax	339	pop eax
341	@@:	340	@@:
342		341
343	DEBUGF 1,"Device number: %u\n", eax	342	DEBUGF 1,"Device number: %u\n", eax
344	ret	343	ret
345		344
346	.error:	345	.error:
347	or eax, -1	346	or eax, -1
348	DEBUGF 2,"Adding network device failed\n"	347	DEBUGF 2,"Adding network device failed\n"
349	ret	348	ret
350		349
351		350
352		351
353	;-----------------------------------------------------------------	352	;-----------------------------------------------------------------
354	;	353	;
355	; NET_set_default	354	; NET_set_default
356	;	355	;
357	; API to set the default interface	356	; API to set the default interface
358	;	357	;
359	; IN: Device num in eax	358	; IN: Device num in eax
360	; OUT: Device num in eax, -1 on error	359	; OUT: Device num in eax, -1 on error
361	;	360	;
362	;-----------------------------------------------------------------	361	;-----------------------------------------------------------------
363	align 4	362	align 4
364	NET_set_default:	363	NET_set_default:
365		364
366	DEBUGF 1,"NET_set_default: device=%x\n", eax	365	DEBUGF 1,"NET_set_default: device=%x\n", eax
367		366
368	cmp eax, MAX_NET_DEVICES	367	cmp eax, MAX_NET_DEVICES
369	jae .error	368	jae .error
370		369
371	cmp [NET_DRV_LIST+eax*4], 0	370	cmp [NET_DRV_LIST+eax*4], 0
372	je .error	371	je .error
373		372
374	mov [NET_DEFAULT], eax	373	mov [NET_DEFAULT], eax
375		374
376	DEBUGF 1,"NET_set_default: succes\n"	375	DEBUGF 1,"NET_set_default: succes\n"
377	ret	376	ret
378		377
379	.error:	378	.error:
380	or eax, -1	379	or eax, -1
381	DEBUGF 1,"NET_set_default: failed\n"	380	DEBUGF 1,"NET_set_default: failed\n"
382	ret	381	ret
383		382
384		383
385	;-----------------------------------------------------------------	384	;-----------------------------------------------------------------
386	;	385	;
387	; NET_Remove_Device:	386	; NET_Remove_Device:
388	;	387	;
389	; This function is called by etwork drivers,	388	; This function is called by etwork drivers,
390	; to unregister network devices from the kernel	389	; to unregister network devices from the kernel
391	;	390	;
392	; IN: Pointer to device structure in ebx	391	; IN: Pointer to device structure in ebx
393	; OUT: eax: -1 on error	392	; OUT: eax: -1 on error
394	;	393	;
395	;-----------------------------------------------------------------	394	;-----------------------------------------------------------------
396	align 4	395	align 4
397	NET_remove_device:	396	NET_remove_device:
398		397
399	cmp [NET_RUNNING], 0	398	cmp [NET_RUNNING], 0
400	je .error	399	je .error
401		400
402	cmp [NET_DRV_LIST], ebx	401	cmp [NET_DRV_LIST], ebx
403	jne @f	402	jne @f
404	mov [NET_DRV_LIST], 0	403	mov [NET_DRV_LIST], 0
405	cmp [NET_RUNNING], 1	404	cmp [NET_RUNNING], 1
406	je @f	405	je @f
407	; there are still active devices, find one and make it default	406	; there are still active devices, find one and make it default
408	xor eax, eax	407	xor eax, eax
409	mov ecx, MAX_NET_DEVICES	408	mov ecx, MAX_NET_DEVICES
410	mov edi, NET_DRV_LIST	409	mov edi, NET_DRV_LIST
411	repe scasd	410	repe scasd
412	je @f	411	je @f
413	shr edi, 2	412	shr edi, 2
414	dec edi	413	dec edi
415	mov [NET_DEFAULT], edi	414	mov [NET_DEFAULT], edi
416	@@:	415	@@:
417		416
418	;----------------------------	417	;----------------------------
419	; Find the driver in the list	418	; Find the driver in the list
420		419
421	mov eax, ebx	420	mov eax, ebx
422	mov ecx, MAX_NET_DEVICES	421	mov ecx, MAX_NET_DEVICES
423	mov edi, NET_DRV_LIST+4	422	mov edi, NET_DRV_LIST+4
424		423
425	repne scasd	424	repne scasd
426	jnz .error	425	jnz .error
427		426
428	;------------------------	427	;------------------------
429	; Remove it from the list	428	; Remove it from the list
430		429
431	xor eax, eax	430	xor eax, eax
432	mov dword [edi-4], eax	431	mov dword [edi-4], eax
433		432
434	dec [NET_RUNNING]	433	dec [NET_RUNNING]
435	ret	434	ret
436		435
437	.error:	436	.error:
438	or eax, -1	437	or eax, -1
439	ret	438	ret
440		439
441		440
442		441
443	;-----------------------------------------------------------------	442	;-----------------------------------------------------------------
444	;	443	;
445	; NET_ptr_to_num	444	; NET_ptr_to_num
446	;	445	;
447	; IN: ebx = ptr to device struct	446	; IN: ebx = ptr to device struct
448	; OUT: edi = -1 on error, device number otherwise	447	; OUT: edi = -1 on error, device number otherwise
449	;	448	;
450	;-----------------------------------------------------------------	449	;-----------------------------------------------------------------
451	align 4	450	align 4
452	NET_ptr_to_num:	451	NET_ptr_to_num:
453	push ecx	452	push ecx
454		453
455	mov ecx, MAX_NET_DEVICES	454	mov ecx, MAX_NET_DEVICES
456	mov edi, NET_DRV_LIST	455	mov edi, NET_DRV_LIST
457		456
458	.loop:	457	.loop:
459	cmp ebx, [edi]	458	cmp ebx, [edi]
460	jz .found	459	jz .found
461	add edi, 4	460	add edi, 4
462	dec ecx	461	dec ecx
463	jnz .loop	462	jnz .loop
464		463
465	; repnz scasd could work too if eax is used instead of ebx!	464	; repnz scasd could work too if eax is used instead of ebx!
466		465
467	or edi, -1	466	or edi, -1
468		467
469	pop ecx	468	pop ecx
470	ret	469	ret
471		470
472	.found:	471	.found:
473	sub edi, NET_DRV_LIST	472	sub edi, NET_DRV_LIST
474	shr edi, 2	473	shr edi, 2
475		474
476	pop ecx	475	pop ecx
477	ret	476	ret
478		477
479	;-----------------------------------------------------------------	478	;-----------------------------------------------------------------
480	;	479	;
481	; checksum_1	480	; checksum_1
482	;	481	;
483	; This is the first of two functions needed to calculate a checksum.	482	; This is the first of two functions needed to calculate a checksum.
484	;	483	;
485	; IN: edx = start offset for semi-checksum	484	; IN: edx = start offset for semi-checksum
486	; esi = pointer to data	485	; esi = pointer to data
487	; ecx = data size	486	; ecx = data size
488	; OUT: edx = semi-checksum	487	; OUT: edx = semi-checksum
489	;	488	;
490	;	489	;
491	; Code was optimized by diamond	490	; Code was optimized by diamond
492	;	491	;
493	;-----------------------------------------------------------------	492	;-----------------------------------------------------------------
494	align 4	493	align 4
495	checksum_1:	494	checksum_1:
496		495
497	shr ecx, 1	496	shr ecx, 1
498	pushf	497	pushf

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/stack.inc – Rev 3185 → 3249