WebSVN – Kolibri OS – Diff – /kernel/trunk/network/stack.inc


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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/stack.inc – Rev 6413 → 6476