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


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

Subversion Repositories Kolibri OS

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