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

Subversion Repositories Kolibri OS

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