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

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;                                                              ;;
+;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2004-2011. All rights reserved. ;;
+;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
-;; Distributed under terms of the GNU General Public License    ;;
+;; Distributed under terms of the GNU General Public License       ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  STACK.INC                                                   ;;
+;;  STACK.INC                                                      ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  TCP/IP stack for Menuet OS                                  ;;
+;;  TCP/IP stack for KolibriOS                                     ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;  Copyright 2002 Mike Hibbett, mikeh@oceanfree.net            ;;
+;;    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)      ;;
-;;  See file COPYING for details                                ;;
+;;      mike.dld (kolibrios socket code)                           ;;
-;;                                                              ;;
+;;                                                                 ;;
-;; Version 0.7                                                  ;;
-;;      Added a timer per socket to allow delays when rx window ;;
-;;      gets below 1KB                                          ;;
+;;     TCP part is based on 4.4BSD                                 ;;
-;;                                                              ;;
+;;                                                                 ;;
+;;          GNU GENERAL PUBLIC LICENSE                             ;;
-;;10.01.2007 Bugfix for checksum function from Paolo Franchetti ;;
+;;             Version 2, June 1991                                ;;
-;;                                                              ;;
+;;                                                                 ;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 2465 $
-;*******************************************************************
-;   Interface
-;      The interfaces defined in ETHERNET.INC plus:
-;      stack_init
-;      stack_handler
-;      app_stack_handler
-;      app_socket_handler
-;      checksum
-;
-;*******************************************************************
+$Revision: 3555 $
-uglobal
-StackCounters:
-  dumped_rx_count     dd  0
-  arp_tx_count:
-                      dd  0
-  arp_rx_count:
-                      dd  0
-  ip_rx_count:
-                      dd  0
+uglobal
-  ip_tx_count:
+        net_10ms        dd ?
-                      dd  0
-endg
-; socket buffers
-SOCKETBUFFSIZE     equ        4096  ; state + config + buffer.
-SOCKETHEADERSIZE   equ        SOCKET.rxData ; thus 4096 - SOCKETHEADERSIZE bytes data
-;NUM_SOCKETS        equ        16    ; Number of open sockets supported. Was 20
-; IPBUFF status values
-BUFF_EMPTY         equ     0
-BUFF_RX_FULL       equ     1
-BUFF_ALLOCATED     equ     2
-BUFF_TX_FULL       equ     3
-NUM_IPBUFFERS      equ     20    ; buffers allocated for TX/RX
-NUMQUEUES          equ        4
-EMPTY_QUEUE        equ        0
+        net_tmr_count   dw ?
-IPIN_QUEUE         equ        1
-IPOUT_QUEUE        equ        2
-NET1OUT_QUEUE      equ        3
+endg
-NO_BUFFER          equ        0xFFFF
-IPBUFFSIZE         equ        1500                ; MTU of an ethernet packet
-NUMQUEUEENTRIES    equ        NUM_IPBUFFERS
-NUMRESENDENTRIES    equ         18              ; Buffers for TCP resend packets
-; These are the 0x40 function codes for application access to the stack
-STACK_DRIVER_STATUS  equ   52
-SOCKET_INTERFACE     equ   53
-; 128KB allocated for the stack and network driver buffers and other
-; data requirements
-;stack_data_start     equ   0x700000
-;eth_data_start       equ   0x700000
-;stack_data           equ   0x704000
-;stack_data_end       equ   0x71ffff
-; 32 bit word
-stack_config         equ   stack_data
-; 32 bit word - IP Address in network format
-stack_ip             equ   stack_data + 4
-; 1 byte. 0 == inactive, 1 = active
-ethernet_active      equ   stack_data + 9
-; TODO :: empty memory area
-; Address of selected socket
-;sktAddr              equ   stack_data + 32
-; Parameter to checksum routine - data ptr
-checkAdd1            equ   stack_data + 36
-; Parameter to checksum routine - 2nd data ptr
-checkAdd2            equ   stack_data + 40
-; Parameter to checksum routine - data size
-checkSize1           equ   stack_data + 44
-; Parameter to checksum routine - 2nd data size
-checkSize2           equ   stack_data + 46
-; result of checksum routine
-checkResult          equ   stack_data + 48
-; holds the TCP/UDP pseudo header. SA|DA|0|prot|UDP len|
-pseudoHeader         equ   stack_data + 50
-; receive and transmit IP buffer allocation
-;sockets              equ   stack_data + 62
-Next_free2 equ stack_data + 62;Next_free2           equ   sockets + (SOCKETBUFFSIZE * NUM_SOCKETS)
-; 1560 byte buffer for rx / tx ethernet packets
-Ether_buffer         equ   Next_free2
-Next_free3           equ   Ether_buffer + 1518
-last_1sTick          equ   Next_free3
-IPbuffs              equ   Next_free3 + 1
-queues               equ   IPbuffs + ( NUM_IPBUFFERS * IPBUFFSIZE )
-queueList            equ   queues + (2 * NUMQUEUES)
-last_1hsTick         equ   queueList + ( 2 * NUMQUEUEENTRIES )
-;resendQ              equ   queueList + ( 2 * NUMQUEUEENTRIES )
-;resendBuffer         equ    resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP
-;                    equ    resendBuffer + ( IPBUFFSIZE * NUMRESENDENTRIES )
+MAX_NET_DEVICES         = 16
+ARP_BLOCK               = 1             ; true or false
+MIN_EPHEMERAL_PORT      = 49152
+MIN_EPHEMERAL_PORT_N    = 0x00C0        ; same in Network byte order (FIXME)
+MAX_EPHEMERAL_PORT      = 61000
+MAX_EPHEMERAL_PORT_N    = 0x48EE        ; same in Network byte order (FIXME)
+; Ethernet protocol numbers
+ETHER_ARP               = 0x0608
+ETHER_IPv4              = 0x0008
+ETHER_IPv6              = 0xDD86
+ETHER_PPP_DISCOVERY     = 0x6388
+ETHER_PPP_SESSION       = 0x6488
+; PPP protocol numbers
+PPP_IPv4                = 0x2100
+PPP_IPV6                = 0x5780
+;Protocol family
+AF_UNSPEC               = 0
+AF_LOCAL                = 1
+AF_INET4                = 2
+AF_INET6                = 10
+AF_PPP                  = 777
+; Internet protocol numbers
+IP_PROTO_IP             = 0
+IP_PROTO_ICMP           = 1
+IP_PROTO_TCP            = 6
+IP_PROTO_UDP            = 17
+; PPP protocol number
+PPP_PROTO_ETHERNET      = 666
+; Socket types
+SOCK_STREAM             = 1
+SOCK_DGRAM              = 2
+SOCK_RAW                = 3
+; Socket options
+SO_ACCEPTCON            = 1 shl 0
+SO_BROADCAST            = 1 shl 1
+SO_DEBUG                = 1 shl 2
+SO_DONTROUTE            = 1 shl 3
+SO_KEEPALIVE            = 1 shl 4
+SO_OOBINLINE            = 1 shl 5
+SO_REUSEADDR            = 1 shl 6
+SO_REUSEPORT            = 1 shl 7
+SO_USELOOPBACK          = 1 shl 8
+SO_BINDTODEVICE         = 1 shl 9
+SO_BLOCK                = 1 shl 10    ; TO BE REMOVED
+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                = 0x0100      ; async i/o notify
+SS_ISCONFIRMING         = 0x0200      ; deciding to accept connection req
+SS_MORETOCOME           = 0x0400
+SS_BLOCKED              = 0x8000
+SOCKET_MAXDATA          = 4096*32     ; must be 4096*(power of 2) where 'power of 2' is at least 8
+; Network driver types
+NET_TYPE_LOOPBACK       = 0
+NET_TYPE_ETH            = 1
+NET_TYPE_SLIP           = 2
+MAX_backlog             = 20          ; maximum backlog for stream sockets
+; Error Codes
+ENOBUFS                 = 55
+ECONNREFUSED            = 61
+ECONNRESET              = 52
+ETIMEDOUT               = 60
+ECONNABORTED            = 53
+; Api protocol numbers
+API_ETH                 = 0
+API_IPv4                = 1
+API_ICMP                = 2
+API_UDP                 = 3
+API_TCP                 = 4
+API_ARP                 = 5
+API_PPPOE               = 6
+API_IPv6                = 7
+HWACC_TCP_IPv4          = 1 shl 0
+struct  NET_DEVICE
+        type            dd ?    ; Type field
+        mtu             dd ?    ; Maximal Transmission Unit
+        name            dd ?    ; Ptr to 0 terminated string
+        unload          dd ?    ; Ptrs to driver functions
+        reset           dd ?    ;
+        transmit        dd ?    ;
+        bytes_tx        dq ?    ; Statistics, updated by the driver
+        bytes_rx        dq ?    ;
+        packets_tx      dd ?    ;
+        packets_rx      dd ?    ;
+        state           dd ?    ; link state (0 = no link)
+        hwacc           dd ?    ; bitmask stating enabled HW accelerations (offload engines)
+ends
+; Exactly as it says..
+macro pseudo_random reg {
+        add     reg, [esp]
+        rol     reg, 5
+        xor     reg, [timer_ticks]
+;        add     reg, [CPU_FREQ]
+        imul    reg, 214013
-;resendQ             equ     0x770000
+        xor     reg, 0xdeadbeef
+        rol     reg, 9
+}
+; Network to Hardware byte order (dword)
+macro ntohd reg {
+        rol     word reg, 8
+        rol     dword reg, 16
-;resendBuffer        equ     resendQ + ( 4 * NUMRESENDENTRIES ) ; for TCP        ; XTODO: validate size
+        rol     word reg , 8
-resendBuffer        equ     resendQ + ( 8 * NUMRESENDENTRIES ) ; for TCP
+}
-uglobal
-net_sockets rd 2
-endg
-; simple macro for memory set operation
-macro _memset_dw adr,value,amount
-{
-        mov     edi, adr
-        mov     ecx, amount
-        if value = 0
         xor     eax, eax
-        else
-        mov     eax, value
-        end if
+; Network to Hardware byte order (word)
+macro ntohw reg {
-        cld
+        rol     word reg, 8
+}
+include "queue.inc"
+include "loopback.inc"
-        rep stosd
+include "ethernet.inc"
+include "PPPoE.inc"
 include "ARP.inc"
+include "IPv4.inc"
+include "IPv6.inc"
+include "icmp.inc"
+include "udp.inc"
+include "tcp.inc"
+include "socket.inc"
+align 4
+uglobal
-; Below, the main network layer source code is included
+        NET_RUNNING     dd  ?
         NET_DEFAULT     dd  ?
-include "queue.inc"
-include "eth_drv/ethernet.inc"
-include "ip.inc"
-include "socket.inc"
+        NET_DRV_LIST    rd  MAX_NET_DEVICES
 ;***************************************************************************
-;   Function
+endg
-;      stack_init
+;-----------------------------------------------------------------
+;
 ; stack_init
-;   Description
-;      Clear all allocated memory to zero. This ensures that
-;       on startup, the stack is inactive, and consumes no resources
+;
+;  This function calls all network init procedures
-;       This is a kernel function, called prior to the OS main loop
+;
-;       in set_variables
+;  IN:  /
+;  OUT: /
+;
+;-----------------------------------------------------------------
+align 4
+stack_init:
+; Init the network drivers list
+        xor     eax, eax
+        mov     edi, NET_RUNNING
+        mov     ecx, (MAX_NET_DEVICES + 2)
+        rep     stosd
-;
+        PPPoE_init
-;***************************************************************************
-stack_init:
-        ; Init two address spaces with default values
-        _memset_dw      stack_data_start, 0, 0x20000/4
-        _memset_dw      resendQ, 0, NUMRESENDENTRIES * 2
         IPv4_init
+;        IPv6_init
+        ICMP_init
-        mov     [net_sockets], 0
+        ARP_init
+        UDP_init
+        TCP_init
-        mov     [net_sockets + 4], 0
+        SOCKET_init
+        mov     [net_tmr_count], 0
+        ret
         ; Queries initialization
-        call    queueInit
-        ; The following block sets up the 1s timer
-        mov     al, 0x0
+; Wakeup every tick.
+proc stack_handler_has_work?
+        mov eax, [timer_ticks]
-        out     0x70, al
+        cmp eax, [net_10ms]
         in      al, 0x71
-        mov     [last_1sTick], al
+        ret
+endp
-        ret
+;-----------------------------------------------------------------
+;
+; stack_handler
+;
+;  This function is called in kernel loop
-;***************************************************************************
-;   Function
-;      stack_handler
-;
-;   Description
-;       The kernel loop routine for the stack
-;       This is a kernel function, called in the main loop
-;
-;***************************************************************************
-align 4
-stack_handler:
-        call    ethernet_driver
-        call    ip_rx
+;
-    ; Test for 10ms tick, call tcp timer
-        mov     eax, [timer_ticks];[0xfdf0]
-        cmp     eax, [last_1hsTick]
-        je      sh_001
-        mov     [last_1hsTick], eax
-        call    tcp_tx_handler
-sh_001:
-    ; Test for 1 second event, call 1s timer functions
-        mov     al, 0x0;second
-        out     0x70, al
-        in      al, 0x71
-        cmp     al, [last_1sTick]
-        je      sh_exit
-        mov     [last_1sTick], al
+;  IN:  /
-        stdcall arp_table_manager, ARP_TABLE_TIMER, 0, 0
-        call    tcp_tcb_handler
-sh_exit:
-        ret
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Checksum [by Johnny_B]
-;;  IN:
-;;    buf_ptr=POINTER to buffer
-;;    buf_size=SIZE of buffer
+;  OUT: /
-;;  OUT:
-;;    AX=16-bit checksum
+;
-;;              Saves all used registers
+;-----------------------------------------------------------------
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+align 4
-proc checksum_jb stdcall uses ebx esi ecx,\
+stack_handler:
-     buf_ptr:DWORD, buf_size:DWORD
         ; Test for 10ms tick
-        xor     eax, eax
-        xor     ebx, ebx;accumulator
-        mov     esi, dword[buf_ptr]
-        mov     ecx, dword[buf_size]
-        shr     ecx, 1; ecx=ecx/2
-        jnc     @f  ; if CF==0 then size is even number
-        mov     bh, byte[esi + ecx*2]
-  @@:
-        cld
-  .loop:
-        lodsw   ;eax=word[esi],esi=esi+2
-        xchg    ah, al;cause must be a net byte-order
+        mov     eax, [timer_ticks]
-        add     ebx, eax
+        cmp     eax, [net_10ms]
-        loop    .loop
-        mov     eax, ebx
-        shr     eax, 16
-        add     ax, bx
-        not     ax
-        ret
-endp
+        je      .exit
+        mov     [net_10ms], eax
-;***************************************************************************
-;   Function
+        cmp     [NET_RUNNING], 0
+        je      .exit
+        test    [net_10ms], 0x0f        ; 160ms
+        jnz     .exit
-;      checksum
-;
+        TCP_timer_160ms
+        test    [net_10ms], 0x3f        ; 640ms
-;   Description
+        jnz     .exit
-;       checkAdd1,checkAdd2, checkSize1, checkSize2, checkResult
-;       Dont break anything; Most registers are used by the caller
-;       This code is derived from the 'C' source, cksum.c, in the book
-;       Internetworking with TCP/IP Volume II by D.E. Comer
-;
-;***************************************************************************
+        TCP_timer_640ms
+        ARP_decrease_entry_ttls
+        IPv4_decrease_fragment_ttls
+  .exit:
+        ret
+align 4
+NET_link_changed:
+        DEBUGF  1,"NET_link_changed device=0x%x status=0x%x\n", ebx, [ebx + NET_DEVICE.state]
-checksum:
-        pusha
-        mov     eax, [checkAdd1]
-        xor     edx, edx              ; edx is the accumulative checksum
+align 4
-        xor     ebx, ebx
+NET_send_event:
+        DEBUGF  1,"NET_send_event\n"
-        mov     cx, [checkSize1]
+; Send event to all applications
-        shr     cx, 1
+        push    edi ecx
+        mov     edi, SLOT_BASE
-        jz      cs1_1
+        mov     ecx, [TASK_COUNT]
+  .loop:
+        add     edi, 256
+        or      [edi + APPDATA.event_mask], EVENT_NETWORK2
-cs1:
+        loop    .loop
-        mov     bh, [eax]
+        pop     ecx edi
-        mov     bl, [eax + 1]
+        ret
-        add     eax, 2
-        add     edx, ebx
+;-----------------------------------------------------------------
-        loopw   cs1
-cs1_1:
+;
-        and     word [checkSize1], 0x01
+; NET_add_device:
-        jz      cs_test2
+;
+;  This function is called by the network drivers,
+;  to register each running NIC to the kernel
-        mov     bh, [eax]
+;
+;  IN:  Pointer to device structure in ebx
+;  OUT: Device num in eax, -1 on error
-        xor     bl, bl
+;
+;-----------------------------------------------------------------
+align 4
+NET_add_device:
+        DEBUGF  1,"NET_Add_Device: %x\n", ebx   ;;; TODO: use mutex to lock net device list
-        add     edx, ebx
+        cmp     [NET_RUNNING], MAX_NET_DEVICES
+        jae     .error
+;----------------------------------
+; Check if device is already listed
+        mov     eax, ebx
+        mov     ecx, MAX_NET_DEVICES    ; We need to check whole list because a device may be removed without re-organizing list
-cs_test2:
+        mov     edi, NET_DRV_LIST
-        mov     cx, [checkSize2]
+        repne   scasd                   ; See if device is already in the list
-        cmp     cx, 0
+        jz      .error
-        jz      cs_exit                 ; Finished if no 2nd buffer
-        mov     eax, [checkAdd2]
+;----------------------------
+; Find empty slot in the list
-        shr     cx, 1
+        xor     eax, eax
-        jz      cs2_1
+        mov     ecx, MAX_NET_DEVICES
-cs2:
+        mov     edi, NET_DRV_LIST
-        mov     bh, [eax]
-        mov     bl, [eax + 1]
-        add     eax, 2
-        add     edx, ebx
-        loopw   cs2
-cs2_1:
-        and     word [checkSize2], 0x01
-        jz      cs_exit
-        mov     bh, [eax]
-        xor     bl, bl
-        add     edx, ebx
-cs_exit:
-        mov     ebx, edx
-        shr     ebx, 16
-        and     edx, 0xffff
+        repne   scasd
-        add     edx, ebx
+        jnz     .error
+        sub     edi, 4
-        mov     eax, edx
-        shr     eax, 16
+;-----------------------------
+; Add device to the found slot
-        add     edx, eax
+        mov     [edi], ebx              ; add device to list
         not     dx
+        mov     eax, edi                ; Calculate device number in eax
-        mov     [checkResult], dx
+        sub     eax, NET_DRV_LIST
-        popa
+        shr     eax, 2
         ret
+        inc     [NET_RUNNING]           ; Indicate that one more network device is up and running
+        cmp     eax, 1                  ; If it's the first network device, try to set it as default
+        jne     @f
+        push    eax
-;***************************************************************************
+        call    NET_set_default
+        pop     eax
-;   Function
+       @@:
-;      app_stack_handler
+        call    NET_send_event
-;
+        DEBUGF  1,"Device number: %u\n", eax
-;   Description
+        ret
-;       This is an application service, called by int 0x40, function 52
-;       It provides application access to the network interface layer
-;
-;***************************************************************************
+  .error:
-iglobal
-align 4
-f52call:
-        dd      app_stack_handler.00
+        or      eax, -1
-        dd      app_stack_handler.01
+        DEBUGF  2,"Adding network device failed\n"
-        dd      app_stack_handler.02
+        ret
-        dd      app_stack_handler.03
-        dd      app_stack_handler.fail  ;04
+;-----------------------------------------------------------------
+;
+; NET_set_default
+;
-        dd      app_stack_handler.fail  ;05
+;  API to set the default interface
-        dd      stack_insert_packet     ;app_stack_handler.06
+;
+;  IN:  Device num in eax
-        dd      app_stack_handler.fail  ;07
+;  OUT: Device num in eax, -1 on error
-        dd      stack_get_packet        ;app_stack_handler.08
+;
+;-----------------------------------------------------------------
-        dd      app_stack_handler.09
+align 4
-        dd      app_stack_handler.10
-        dd      app_stack_handler.11
+NET_set_default:
-        dd      app_stack_handler.12
-        dd      app_stack_handler.13
+        DEBUGF  1,"NET_set_default: device=%x\n", eax
-        dd      app_stack_handler.14
-        dd      app_stack_handler.15
-endg
-app_stack_handler:
+        cmp     eax, MAX_NET_DEVICES
-;in ebx,ecx
-;out eax
+        jae     .error
-        cmp     ebx, 15
-        ja      .fail                   ;if more than 15 then exit
-        jmp     dword [f52call+ebx*4]
-.00:
-; Read the configuration word
+        cmp     [NET_DRV_LIST+eax*4], 0
-        mov     eax, [stack_config]
+        je      .error
-        ret
+        mov     [NET_DEFAULT], eax
-.01:
-; read the IP address
-        mov     eax, [stack_ip]
+        DEBUGF  1,"NET_set_default: succes\n"
         ret
-.02:
-; write the configuration word
+  .error:
-        mov     [stack_config], ecx
-;
-; If ethernet now enabled, probe for the card, reset it and empty
-; the packet buffer
-; If all successfull, enable the card.
-; If ethernet now disabled, set it as disabled. Should really
-; empty the tcpip data area too.
+        or      eax, -1
+        DEBUGF  1,"NET_set_default: failed\n"
-; ethernet interface is '3' in ls 7 bits
+        ret
-        and     cl, 0x7f
+;-----------------------------------------------------------------
+;
+; NET_Remove_Device:
+;
+;  This function is called by etwork drivers,
-        cmp     cl, 3
+;  to unregister network devices from the kernel
-        je      ash_eth_enable
-; Ethernet isn't enabled, so make sure that the card is disabled
-        mov     [ethernet_active], byte 0
-        ret
+;
-.03:
+;  IN:  Pointer to device structure in ebx
+;  OUT: eax: -1 on error
-; write the IP Address
+;
-        mov     [stack_ip], ecx
+;-----------------------------------------------------------------
-        ret
+align 4
-;old functions was deleted
+NET_remove_device:
-;.06:
-; Insert an IP packet into the stacks received packet queue
-;       call    stack_insert_packet
+        cmp     [NET_RUNNING], 0
-;       ret
-; Test for any packets queued for transmission over the network
-;.08:
-;       call    stack_get_packet
-; Extract a packet queued for transmission by the network
-;       ret
-.09:
-; read the gateway IP address
-        mov     eax, [gateway_ip]
-        ret
-.10:
-; read the subnet mask
-        mov     eax, [subnet_mask]
-        ret
-.11:
-; write the gateway IP Address
-        mov     [gateway_ip], ecx
-        ret
-.12:
-; write the subnet mask
-        mov     [subnet_mask], ecx
-        ret
-.13:
-; read the dns
-        mov     eax, [dns_ip]
-        ret
-.14:
-; write the dns IP Address
-        mov     [dns_ip], ecx
-        ret
-.15:
+        je      .error
-;
-; in ecx we need 4 to read the last 2 bytes
-; or we need 0 to read the first 4 bytes
-        cmp     ecx, 4
-        ja      .param_error
-; read MAC, returned (in mirrored byte order) in eax
-        mov     eax, [node_addr + ecx]
-        ret
-.param_error:
-        or      eax, -1         ; params not accepted
-        ret
-.16:
-; 0 -> arp_probe
-; 1 -> arp_announce
-; 2 -> arp_responce (not supported yet)
-        test    ecx, ecx
-        je      a_probe
-        dec     ebx
-        jz      a_ann                   ; arp announce
-.fail:
-        or      eax, -1
-        ret
-;       cmp     ebx,2
-;       jne     a_resp                  ; arp response
-; arp probe, sender IP must be set to 0.0.0.0, target IP is set to address being probed
-; ecx: pointer to target MAC, MAC should set to 0 by application
-; edx: target IP
-a_probe:
-        push    dword [stack_ip]
-        mov     edx, [stack_ip]
-        and     [stack_ip], dword 0
-        mov     esi, ecx                ; pointer to target MAC address
-        call    arp_request
-        pop     dword [stack_ip]
-        ret
-; arp announce, sender IP must be set to target IP
-; ecx: pointer to target MAC
-a_ann:
-        mov     edx, [stack_ip]
+        cmp     [NET_DRV_LIST], ebx
-        mov     esi, ecx                ; pointer to target MAC address
-        call    arp_request
-        ret
+        jne     @f
+        mov     [NET_DRV_LIST], 0
+        cmp     [NET_RUNNING], 1
+        je      @f
+        ; there are still active devices, find one and make it default
-.17:
+        xor     eax, eax
-;
-; modified by [smb]
-;
-; ARPTable manager interface
+        mov     ecx, MAX_NET_DEVICES
-    ;see "proc arp_table_manager" for more details
-        stdcall arp_table_manager, ecx, edx, esi;Opcode,Index,Extra
-        ret
+        mov     edi, NET_DRV_LIST
-;
+        repe    scasd
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-ash_eth_enable:
-; Probe for the card. This will reset it and enable the interface
-; if found
-        call    eth_probe
+        je      @f
-        test    eax, eax
-        jz      ash_eth_done            ; Abort if no hardware found
+        shr     edi, 2
+        dec     edi
-        mov     [ethernet_active], byte 1
+        mov     [NET_DEFAULT], edi
-ash_eth_done:
+       @@:
-        ret
-;***************************************************************************
+;----------------------------
+; Find the driver in the list
-;   Function
+        mov     eax, ebx
+        mov     ecx, MAX_NET_DEVICES
-;      app_socket_handler
+        mov     edi, NET_DRV_LIST+4
-;
-;   Description
+        repne   scasd
-;       This is an application service, called by int 0x40, function 53
-;       It provides application access to stack socket services
-;       such as opening sockets
-;
+        jnz     .error
+;------------------------
+; Remove it from the list
+        xor     eax, eax
+        mov     dword [edi-4], eax
+        call    NET_send_event
+        dec     [NET_RUNNING]
-;***************************************************************************
-iglobal
+        ret
-align 4
-f53call:
-        dd      socket_open                     ;00
+  .error:
-        dd      socket_close                    ;01
+        or      eax, -1
+        ret
-        dd      socket_poll                     ;02
-        dd      socket_read                     ;03
-        dd      socket_write                    ;04
-        dd      socket_open_tcp                 ;05
-        dd      socket_status                   ;06
-        dd      socket_write_tcp                ;07
+;-----------------------------------------------------------------
-        dd      socket_close_tcp                ;08
-        dd      is_localport_unused             ;09
-        dd      app_socket_handler.10
+;
-        dd      socket_read_packet              ;11
+; NET_ptr_to_num
-endg
+;
-app_socket_handler:
+; IN:  ebx = ptr to device struct
-;in ebx,ecx,edx,wsi
-;out eax
-        cmp     eax, 255
+; OUT: edi = -1 on error, device number otherwise
-        je      stack_internal_status
-        cmp     eax, 11
+;
-        ja      .fail                   ;if more than 15 then exit
+;-----------------------------------------------------------------
+align 4
-        jmp     dword [f53call+eax*4]
+NET_ptr_to_num:
-.10:
+        push    ecx
-        mov     eax, dword[drvr_cable]
-        test    eax, eax
-        jnz     @f                      ; if function is not implented, return -1
+        mov     ecx, MAX_NET_DEVICES
-        or      al, -1
-        ret
-@@:
+        mov     edi, NET_DRV_LIST
-        jmp     dword[drvr_cable]
+  .loop:
+        cmp     ebx, [edi]
+        jz      .found
+        add     edi, 4
+        dec     ecx
-.fail:
+        jnz     .loop
+        ; repnz  scasd could work too if eax is used instead of ebx!
-        or      eax, -1
+        or      edi, -1
-        ret
-uglobal
+        pop     ecx
-  ARPTmp:
+        ret
-  times 14 db 0
-endg
+  .found:
+        sub     edi, NET_DRV_LIST
         shr     edi, 2
+        pop     ecx
-;***************************************************************************
+        ret
+;-----------------------------------------------------------------
+;
-;   Function
+; checksum_1
-;      stack_internal_status
+;
+;  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
-;   Description
+;
+;
+; Code was optimized by diamond
-;       Returns information about the internal status of the stack
+;
+;-----------------------------------------------------------------
+align 4
+checksum_1:
+        shr     ecx, 1
+        pushf
+        jz      .no_2
-;       This is only useful for debugging
-;       It works with the ethernet driver
+        shr     ecx, 1
-;       sub function in ebx
-;       return requested data in eax
-;
-;***************************************************************************
-; This sub function allows access to debugging information on the stack
-; ecx holds the request:
-; 100 : return length of empty queue
-; 101 : return length of IPOUT QUEUE
-; 102 : return length of IPIN QUEUE
-; 103 : return length of NET1OUT QUEUE
+        pushf
-; 200 : return # of ARP entries
-; 201 : return size of ARP table ( max # entries )
-; 202 : select ARP table entry #
-; 203 : return IP of selected table entry
-; 204 : return High 4 bytes of MAC address of selected table entry
-; 205 : return low  2 bytes of MAC address of selected table entry
+        jz      .no_4
-; 206 : return status word of selected table entry
-; 207 : return Time to live of selected table entry
+        shr     ecx, 1
+        pushf
+        jz      .no_8
+  .loop:
-;  2 : return number of IP packets received
+        add     dl, [esi+1]
-;  3 : return number of packets transmitted
+        adc     dh, [esi+0]
-;  4 : return number of received packets dumped
-;  5 : return number of arp packets received
-;  6 : return status of packet driver
+        adc     dl, [esi+3]
-;  ( 0 == not active, FFFFFFFF = successful )
+        adc     dh, [esi+2]
+        adc     dl, [esi+5]
-stack_internal_status:
+        adc     dh, [esi+4]
-        cmp     ebx, 100
-        jnz     notsis100
+        adc     dl, [esi+7]
+        adc     dh, [esi+6]
-    ;  100 : return length of EMPTY QUEUE
-        mov     ebx, EMPTY_QUEUE
-        call    queueSize
-        ret
+        adc     edx, 0
-notsis100:
+        add     esi, 8
-        cmp     ebx, 101
-        jnz     notsis101
+        dec     ecx
+        jnz     .loop
+        adc     edx, 0
-    ;  101 : return length of IPOUT QUEUE
+  .no_8:
+        popf
+        jnc     .no_4
-        mov     ebx, IPOUT_QUEUE
+        add     dl, [esi+1]
+        adc     dh, [esi+0]
-        call    queueSize
-        ret
-notsis101:
-        cmp     ebx, 102
+        adc     dl, [esi+3]
-        jnz     notsis102
+        adc     dh, [esi+2]
-    ;  102 : return length of IPIN QUEUE
-        mov     ebx, IPIN_QUEUE
-        call    queueSize
-        ret
-notsis102:
-        cmp     ebx, 103
+        adc     edx, 0
-        jnz     notsis103
+        add     esi, 4
-    ;  103 : return length of NET1OUT QUEUE
-        mov     ebx, NET1OUT_QUEUE
+  .no_4:
-        call    queueSize
-        ret
+        popf
+        jnc     .no_2
-notsis103:
-        cmp     ebx, 200
-        jnz     notsis200
-    ; 200 : return num entries in arp table
-        movzx   eax, byte [NumARP]
+        add     dl, [esi+1]
-        ret
+        adc     dh, [esi+0]
-notsis200:
-        cmp     ebx, 201
+        adc     edx, 0
+        inc     esi
-        jnz     notsis201
-    ; 201 : return arp table size
-        mov     eax, 20; ARP_TABLE_SIZE
-        ret
-notsis201:
-        cmp     ebx, 202
-        jnz     notsis202
-    ; 202 - read the requested table entry
-    ; into a temporary buffer
-    ; ecx holds the entry number
-        mov     eax, ecx
-        mov     ecx, 14; ARP_ENTRY_SIZE
-        mul     ecx
-        mov     ecx, [eax + ARPTable]
-        mov     [ARPTmp], ecx
-        mov     ecx, [eax + ARPTable+4]
-        mov     [ARPTmp+4], ecx
-        mov     ecx, [eax + ARPTable+8]
-        mov     [ARPTmp+8], ecx
-        mov     cx, [eax + ARPTable+12]
-        mov     [ARPTmp+12], cx
-        ret
+        inc     esi
-notsis202:
-        cmp     ebx, 203
-        jnz     notsis203
-    ; 203 - return IP address
-        mov     eax, [ARPTmp]
-        ret
-notsis203:
-        cmp     ebx, 204
-        jnz     notsis204
-    ; 204 - return MAC high dword
-        mov     eax, [ARPTmp+4]
+  .no_2:
-        ret
-notsis204:
+        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
+;
-        cmp     ebx, 205
+;  IN:  edx = semi-checksum
+;  OUT: dx = checksum (in INET byte order)
+;
+;-----------------------------------------------------------------
+align 4
+checksum_2:
+        mov     ecx, edx
+        shr     ecx, 16
+        and     edx, 0xffff
-        jnz     notsis205
-    ; 205 - return MAC ls word
-        movzx   eax, word [ARPTmp+8]
-        ret
-notsis205:
+        add     edx, ecx
-        cmp     ebx, 206
-        jnz     notsis206
+        mov     ecx, edx
-    ; 206 - return status word
+        shr     ecx, 16
-        movzx   eax, word [ARPTmp+10]
-        ret
-notsis206:
-        cmp     ebx, 207
-        jnz     notsis207
+        add     dx, cx
+        test    dx, dx          ; it seems that ZF is not set when CF is set :(
-    ; 207 - return ttl word
+        not     dx
-        movzx   eax, word [ARPTmp+12]
-        ret
+        jnz     .not_zero
-notsis207:
+        dec     dx
-        cmp     ebx, 2
+  .not_zero:
-        jnz     notsis2
+        xchg    dl, dh
-    ;  2 : return number of IP packets received
+        DEBUGF  1,"Checksum: %x\n", dx
-        mov     eax, [ip_rx_count]
+        ret
-        ret
-notsis2:
-        cmp     ebx, 3
-        jnz     notsis3
-    ;  3 : return number of packets transmitted
-        mov     eax, [ip_tx_count]
+;----------------------------------------------------------------
-        ret
+;
+;  System function to work with network devices (75)
-notsis3:
+;
-        cmp     ebx, 4
+;----------------------------------------------------------------
-        jnz     notsis4
+align 4
+sys_network:                    ; FIXME: make default device easily accessible
-    ;  4 : return number of received packets dumped
-        mov     eax, [dumped_rx_count]
+        cmp     ebx, -1
-        ret
+        jne     @f
-notsis4:
+        mov     eax, [NET_RUNNING]
-        cmp     ebx, 5

Subversion Repositories Kolibri OS

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