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


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2021. All rights reserved.    ;;
;; Distributed under terms of the GNU General Public License       ;;
;;                                                                 ;;
;;  Part of the TCP/IP network stack for KolibriOS                 ;;
;;                                                                 ;;
;;   Written by hidnplayr@kolibrios.org,                           ;;
;;     and Clevermouse.                                            ;;
;;                                                                 ;;
;;       Based on code by mike.dld                                 ;;
;;                                                                 ;;
;;         GNU GENERAL PUBLIC LICENSE                              ;;
;;          Version 2, June 1991                                   ;;
;;                                                                 ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 9993 $
 
struct  SOCKET
 
        NextPtr                 dd ?    ; pointer to next socket in list
        PrevPtr                 dd ?    ; pointer to previous socket in list
        Number                  dd ?    ; socket number
 
        mutex                   MUTEX
 
        PID                     dd ?    ; process ID
        TID                     dd ?    ; thread ID
        Domain                  dd ?    ; INET4/INET6/LOCAL/..
        Type                    dd ?    ; RAW/STREAM/DGRAM
        Protocol                dd ?    ; UDP/TCP/ARP/ICMP
        errorcode               dd ?
        device                  dd ?    ; device pointer, paired socket pointer if it's a local socket
 
        options                 dd ?
        state                   dd ?
        backlog                 dw ?    ; number of incoming connections that can be queued
 
        snd_proc                dd ?
        rcv_proc                dd ?
        connect_proc            dd ?
        ;sndto_proc              dd ?
        ;rcvfrom_proc            dd ?
 
ends
 
struct  IP_SOCKET               SOCKET
 
        LocalIP                 rd 4    ; network byte order
        RemoteIP                rd 4    ; network byte order
        ttl                     db ?
                                rb 3    ; align
 
ends
 
struct  TCP_SOCKET              IP_SOCKET
 
        LocalPort               dw ?    ; network byte order
        RemotePort              dw ?    ; network byte order
 
        t_state                 dd ?    ; TCB state
        t_rxtshift              db ?
                                rb 3    ; align
        t_rxtcur                dd ?
        t_dupacks               dd ?
        t_maxseg                dd ?
        t_flags                 dd ?
 
;---------------
; RFC783 page 21
 
; send sequence
        SND_UNA                 dd ?    ; sequence number of unack'ed sent Packets
        SND_NXT                 dd ?    ; next send sequence number to use
        SND_UP                  dd ?    ; urgent pointer
        SND_WL1                 dd ?    ; the sequence number of the last segment used to update the send window
        SND_WL2                 dd ?    ; the acknowledgment number of the last segment used to update the send window
        ISS                     dd ?    ; initial send sequence number
        SND_WND                 dd ?    ; send window
 
; receive sequence
        RCV_WND                 dd ?    ; receive window
        RCV_NXT                 dd ?    ; next receive sequence number to use
        RCV_UP                  dd ?    ; urgent pointer
        IRS                     dd ?    ; initial receive sequence number
 
;---------------------
; Additional variables
 
; receive variables
        RCV_ADV                 dd ?
 
; retransmit variables
        SND_MAX                 dd ?
 
; congestion control
        SND_CWND                dd ?    ; congestion window
        SND_SSTHRESH            dd ?    ; slow start threshold
 
;----------------------
; Transmit timing stuff
        t_idle                  dd ?
        t_rtt                   dd ?    ; round trip time
        t_rtseq                 dd ?
        t_srtt                  dd ?    ; smoothed round trip time
        t_rttvar                dd ?
        t_rttmin                dd ?
        max_sndwnd              dd ?
 
;-----------------
; Out-of-band data
        t_oobflags              dd ?
        t_iobc                  dd ?
        t_softerror             dd ?
 
 
;---------
; RFC 1323                              ; the order of next 4 elements may not change
 
        SND_SCALE               db ?
        RCV_SCALE               db ?
        requested_s_scale       db ?
        request_r_scale         db ?
 
        ts_recent               dd ?    ; a copy of the most-recent valid timestamp from the other end
        ts_recent_age           dd ?
        last_ack_sent           dd ?
 
 
;-------
; Timers
        timer_flags             dd ?
        timer_retransmission    dd ?    ; rexmt
        timer_persist           dd ?
        timer_keepalive         dd ?    ; keepalive/syn timeout
        timer_timed_wait        dd ?    ; also used as 2msl timer
        timer_connect           dd ?
 
; extra
 
        ts_ecr                  dd ?    ; timestamp echo reply
        ts_val                  dd ?
 
        seg_next                dd ?    ; re-assembly queue
 
ends
 
struct  UDP_SOCKET              IP_SOCKET
 
        LocalPort               dw ?    ; in network byte order
        RemotePort              dw ?    ; in network byte order
 
ends
 
struct  RING_BUFFER
 
        mutex                   MUTEX
        start_ptr               dd ?    ; Pointer to start of buffer
        end_ptr                 dd ?    ; pointer to end of buffer
        read_ptr                dd ?    ; Read pointer
        write_ptr               dd ?    ; Write pointer
        size                    dd ?    ; Number of bytes buffered
 
ends
 
struct  STREAM_SOCKET           TCP_SOCKET
 
        rcv                     RING_BUFFER
        snd                     RING_BUFFER
 
ends
 
struct sockaddr
 
        family                  dw ?    ; Address family
        port                    dw ?    ; 16 bit TCP/UDP port number
        ip                      dd ?    ; 32 bit IP address
        _zero                   rb 8    ; Not use, for align
 
ends
 
struct  socket_queue_entry
 
        data_ptr                dd ?
        data_size               dd ?
        buf_ptr                 dd ?
 
ends
 
struct  socket_options
 
        level                   dd ?
        optname                 dd ?
        optlen                  dd ?
        optval                  dd ?
 
ends
 
SOCKET_STRUCT_SIZE      = 4096          ; in bytes
 
SOCKET_QUEUE_SIZE       = 10            ; maximum number of incoming packets queued for 1 socket
; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start
SOCKET_QUEUE_LOCATION   = (SOCKET_STRUCT_SIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)
 
uglobal
align 4
 
        net_sockets     rd 4
        last_socket_num dd ?
        last_UDP_port   dw ?            ; last used ephemeral port
        last_TCP_port   dw ?            ;
        socket_mutex    MUTEX
 
endg
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_init                                                     ;
;                                                                 ;
;-----------------------------------------------------------------;
macro   socket_init {
 
        xor     eax, eax
        mov     edi, net_sockets
        mov     ecx, 5
        rep stosd
 
       @@:
        pseudo_random eax
        cmp     ax, EPHEMERAL_PORT_MIN
        jb      @r
        cmp     ax, EPHEMERAL_PORT_MAX
        ja      @r
        xchg    al, ah
        mov     [last_UDP_port], ax
 
       @@:
        pseudo_random eax
        cmp     ax, EPHEMERAL_PORT_MIN
        jb      @r
        cmp     ax, EPHEMERAL_PORT_MAX
        ja      @r
        xchg    al, ah
        mov     [last_TCP_port], ax
 
        mov     ecx, socket_mutex
        call    mutex_init
 
}
 
;-----------------------------------------------------------------;
;                                                                 ;
; Sockets API (system function 75)                                ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
sys_socket:
 
        mov     dword[esp + SYSCALL_STACK.ebx], 0        ; Set error code to 0
 
        cmp     ebx, 255
        jz      socket_debug
 
        cmp     ebx, .number
        ja      .error
        jmp     dword [.table + 4*ebx]
 
  .table:
        dd      socket_open             ; 0
        dd      socket_close            ; 1
        dd      socket_bind             ; 2
        dd      socket_listen           ; 3
        dd      socket_connect          ; 4
        dd      socket_accept           ; 5
        dd      socket_send             ; 6
        dd      socket_receive          ; 7
        dd      socket_set_opt          ; 8
        dd      socket_get_opt          ; 9
        dd      socket_pair             ; 10
 
        ;dd      socket_sendto           ; 11
        ;dd      socket_recvfrom         ; 12
  .number = ($ - .table) / 4 - 1
 
  .error:
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
 
        ret
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_open: Create a new socket.                               ;
;                                                                 ;
;   IN: ecx = domain                                              ;
;       edx = type                                                ;
;       esi = protocol                                            ;
;                                                                 ;
;  OUT: eax = socket number                                       ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_open:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_open: domain=%u type=%u protocol=%x\n", ecx, edx, esi
 
        push    ecx edx esi
        call    socket_alloc
        pop     esi edx ecx
        test    eax, eax
        jz      .nobuffs
 
        mov     [esp + SYSCALL_STACK.eax], edi    ; return socketnumber
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_open: socknum=%u\n", edi
 
        test    edx, SO_NONBLOCK
        jz      @f
        or      [eax + SOCKET.options], SO_NONBLOCK
        and     edx, not SO_NONBLOCK
  @@:
 
        mov     [eax + SOCKET.Domain], ecx
        mov     [eax + SOCKET.Type], edx
        mov     [eax + SOCKET.Protocol], esi
        mov     [eax + SOCKET.connect_proc], connect_notsupp
 
        cmp     ecx, AF_INET4
        jne     .no_inet4
 
        mov     [eax + IP_SOCKET.ttl], 128
 
        cmp     edx, SOCK_DGRAM
        je      .udp
 
        cmp     edx, SOCK_STREAM
        je      .tcp
 
        cmp     edx, SOCK_RAW
        je      .raw
 
  .no_inet4:
        cmp     ecx, AF_PPP
        jne     .no_ppp
 
;        cmp     esi, PPP_PROTO_ETHERNET
;        je      .pppoe
 
  .no_ppp:
  .unsupported:
        push    eax
        call    socket_free
        pop     eax
        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .nobuffs:
        mov     dword[esp + SYSCALL_STACK.ebx], ENOBUFS
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .raw:
        test    esi, esi        ; IP_PROTO_IP
        jz      .raw_ip
 
        cmp     esi, IP_PROTO_ICMP
        je      .raw_icmp
 
        jmp     .unsupported
 
align 4
  .udp:
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
        pop     eax
 
        mov     [eax + SOCKET.Protocol], IP_PROTO_UDP
        mov     [eax + SOCKET.snd_proc], socket_send_udp
        mov     [eax + SOCKET.rcv_proc], socket_receive_dgram
        mov     [eax + SOCKET.connect_proc], udp_connect
        ret
 
align 4
  .tcp:
        mov     [eax + SOCKET.Protocol], IP_PROTO_TCP
        mov     [eax + SOCKET.snd_proc], socket_send_tcp
        mov     [eax + SOCKET.rcv_proc], socket_receive_tcp
        mov     [eax + SOCKET.connect_proc], tcp_connect
 
        tcp_init_socket eax
        ret
 
 
align 4
  .raw_ip:
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
        pop     eax
 
        mov     [eax + SOCKET.snd_proc], socket_send_ip
        mov     [eax + SOCKET.rcv_proc], socket_receive_dgram
        mov     [eax + SOCKET.connect_proc], ipv4_connect
        ret
 
 
align 4
  .raw_icmp:
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
        pop     eax
 
        mov     [eax + SOCKET.snd_proc], socket_send_icmp
        mov     [eax + SOCKET.rcv_proc], socket_receive_dgram
        mov     [eax + SOCKET.connect_proc], ipv4_connect
        ret
 
;align 4
;  .pppoe:
;        push    eax
;        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
;        pop     eax
;
;        mov     [eax + SOCKET.snd_proc], socket_send_pppoe
;        mov     [eax + SOCKET.rcv_proc], socket_receive_dgram
;        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_bind: Bind to a local port.                              ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = pointer to sockaddr struct                          ;
;       esi = length of sockaddr struct                           ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_bind:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        cmp     esi, 2
        jb      .invalid
 
        cmp     [eax + UDP_SOCKET.LocalPort], 0 ; Socket can only be bound once
        jnz     .invalid
 
        cmp     word[edx], AF_INET4
        je      .af_inet4
 
        cmp     word[edx], AF_LOCAL
        je      .af_local
 
  .notsupp:
        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .af_local:
        ; TODO: write code here
        mov     dword[esp + SYSCALL_STACK.eax], 0
        ret
 
  .af_inet4:
        cmp     esi, 6
        jb      .invalid
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
        je      .udp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        je      .tcp
 
        jmp     .notsupp
 
  .tcp:
  .udp:
        pushd   [edx + 4]                       ; First, fill in the IP
        popd    [eax + IP_SOCKET.LocalIP]
 
        mov     bx, [edx + 2]                   ; Did caller specify a local port?
        test    bx, bx
        jnz     .just_check
        call    socket_find_port                ; Nope, find an ephemeral one
        jmp     .done
 
  .just_check:
        call    socket_check_port               ; Yes, check if it's still available
        jz      .addrinuse                      ; ZF is set by socket_check_port on error
 
  .done:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_bind: local ip=%u.%u.%u.%u\n",\
        [eax + IP_SOCKET.LocalIP + 0]:1,[eax + IP_SOCKET.LocalIP + 1]:1,\
        [eax + IP_SOCKET.LocalIP + 2]:1,[eax + IP_SOCKET.LocalIP + 3]:1
 
        mov     dword[esp + SYSCALL_STACK.eax], 0
        ret
 
  .addrinuse:
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], EADDRINUSE
        ret
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_connect: Connect to the remote host.                     ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = pointer to sockaddr struct                          ;
;       esi = length of sockaddr struct                           ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_connect:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        cmp     esi, 8
        jb      .invalid
 
        cmp     [eax + SOCKET.state], SS_ISCONNECTING
        je      .already
 
        test    [eax + SOCKET.options], SO_ACCEPTCON
        jnz     .notsupp
 
        call    [eax + SOCKET.connect_proc]
 
        mov     dword[esp + SYSCALL_STACK.ebx], ebx
        mov     dword[esp + SYSCALL_STACK.eax], eax
        ret
 
 
  .notsupp:
        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .already:
        mov     dword[esp + SYSCALL_STACK.ebx], EALREADY
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
 
connect_notsupp:
        xor     eax, eax
        dec     eax
        mov     ebx, EOPNOTSUPP
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_listen: Listen for incoming connections.                 ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = backlog in edx                                      ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_listen:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_listen: socknum=%u backlog=%u\n", ecx, edx
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     .notsupp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jne     .invalid
 
        cmp     [eax + TCP_SOCKET.LocalPort], 0
        je      .already
 
        cmp     [eax + IP_SOCKET.LocalIP], 0
        jne     @f
        push    [IPv4_address + 4]           ;;; fixme!!!!
        pop     [eax + IP_SOCKET.LocalIP]
       @@:
 
        cmp     edx, MAX_backlog
        jbe     @f
        mov     edx, MAX_backlog
       @@:
 
        mov     [eax + SOCKET.backlog], dx
        or      [eax + SOCKET.options], SO_ACCEPTCON
        mov     [eax + TCP_SOCKET.t_state], TCPS_LISTEN
        mov     [eax + TCP_SOCKET.timer_keepalive], 0           ; disable keepalive timer
 
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)                ; Set up sockets queue
        pop     eax
 
        mov     dword[esp + SYSCALL_STACK.eax], 0
        ret
 
  .notsupp:
        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .already:
        mov     dword[esp + SYSCALL_STACK.ebx], EALREADY
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_accept: Accept an incoming connection.                   ;
;                                                                 ;
;   IN: ecx = socket number (of listening socket)                 ;
;       edx = ptr to sockaddr struct                              ;
;       esi = length of sockaddr struct                           ;
;                                                                 ;
;  OUT: eax = newly created socket num                            ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_accept:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_accept: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        test    [eax + SOCKET.options], SO_ACCEPTCON
        jz      .invalid
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     .notsupp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jne     .invalid
 
  .loop:
        get_from_queue (eax + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, .block
 
; Ok, we got a socket ptr
        mov     eax, [esi]
 
; Verify that it is (still) a valid socket
        call    socket_check
        jz      .invalid
 
; Change sockets thread owner ID to that of the current thread
        mov     ebx, [current_slot]
        mov     ebx, [ebx + APPDATA.tid]
        mov     [eax + SOCKET.TID], ebx
 
; Return socket number to caller
        mov     eax, [eax + SOCKET.Number]
        mov     [esp + SYSCALL_STACK.eax], eax
        ret
 
  .block:
        test    [eax + SOCKET.options], SO_NONBLOCK
        jnz     .wouldblock
 
        call    socket_block
        jmp     .loop
 
  .wouldblock:
        mov     dword[esp + SYSCALL_STACK.ebx], EWOULDBLOCK
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .notsupp:
        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_close: Close the socket (and connection).                ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_close:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_close: socknum=%u\n", ecx
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        mov     dword[esp + SYSCALL_STACK.eax], 0               ; The socket exists, so we will succeed in closing it.
 
        or      [eax + SOCKET.options], SO_NONBLOCK             ; Mark the socket as non blocking, we dont want it to block any longer!
 
        test    [eax + SOCKET.state], SS_BLOCKED                ; Is the socket still in blocked state?
        jz      @f
        call    socket_notify                                   ; Unblock it.
  @@:
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     .free
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jne     .free
        test    [eax + SOCKET.state], SS_ISCONNECTED
        jz      @f
        test    [eax + SOCKET.state], SS_ISDISCONNECTING
        jnz     @f
        call    tcp_disconnect
@@:
        ret
;        test    eax, eax
;        jz      .end
  .free:
        call    socket_free
  .end:
        ret
 
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_receive: Receive some data from the remote end.          ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = addr to application buffer                          ;
;       esi = length of application buffer                        ;
;       edi = flags                                               ;
;                                                                 ;
;  OUT: eax = number of bytes copied                              ;
;       eax = -1 on error                                         ;
;       eax = 0 when socket has been closed by the remote end     ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_receive:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: socknum=%u bufaddr=%x buflength=%u flags=%x\n", ecx, edx, esi, edi
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        stdcall is_region_userspace, edx, esi
        jnz     .invalid
 
  .loop:
        push    edi
        call    [eax + SOCKET.rcv_proc]
        pop     edi
 
        test    [eax + SOCKET.state], SS_CANTRCVMORE
        jnz     .last_data
 
        cmp     ebx, EWOULDBLOCK
        jne     .return
 
        test    edi, MSG_DONTWAIT
        jnz     .return_err
 
        test    [eax + SOCKET.options], SO_NONBLOCK
        jnz     .return_err
 
        call    socket_block
        jmp     .loop
 
 
  .invalid:
        push    EINVAL
        pop     ebx
  .return_err:
        mov     ecx, -1
  .return:
        mov     [esp + SYSCALL_STACK.ebx], ebx
        mov     [esp + SYSCALL_STACK.eax], ecx
        ret
 
  .last_data:
        test    ecx, ecx
        jz      .return
        call    socket_notify                                   ; Call me again!
        jmp     .return
 
 
 
 
align 4
socket_receive_dgram:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: DGRAM\n"
 
        test    edi, MSG_PEEK
        jnz     .peek
 
        mov     ebx, esi                                        ; buffer length
 
        get_from_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, .wouldblock ; sets esi only on success.
        mov     ecx, [esi + socket_queue_entry.data_size]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: %u bytes data\n", ecx
 
        cmp     ecx, ebx                                        ; If data segment does not fit in applications buffer, abort
        ja      .too_small
 
        push    eax ecx
        push    [esi + socket_queue_entry.buf_ptr]              ; save the buffer addr so we can clear it later
        mov     esi, [esi + socket_queue_entry.data_ptr]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: Source buffer=%x real addr=%x\n", [esp], esi
 
; copy the data from kernel buffer to application buffer
        mov     edi, edx                                        ; bufferaddr
        shr     ecx, 1
        jnc     .nb
        movsb
  .nb:
        shr     ecx, 1
        jnc     .nw
        movsw
  .nw:
        test    ecx, ecx
        jz      .nd
        rep movsd
  .nd:
 
        call    net_buff_free
        pop     ecx eax                                         ; return number of bytes copied to application
        cmp     [eax + SOCKET_QUEUE_LOCATION + queue.size], 0
        je      @f
        call    socket_notify                                   ; Queue another network event
  @@:
        xor     ebx, ebx                                        ; errorcode = 0 (no error)
        ret
 
  .too_small:
        mov     ecx, -1
        push    EMSGSIZE
        pop     ebx
        ret
 
  .wouldblock:
        push    EWOULDBLOCK
        pop     ebx
        ret
 
  .peek:
        xor     ebx, ebx
        xor     ecx, ecx
        cmp     [eax + SOCKET_QUEUE_LOCATION + queue.size], 0
        je      @f
        mov     esi, [eax + SOCKET_QUEUE_LOCATION + queue.r_ptr]
        mov     ecx, [esi + socket_queue_entry.data_size]
  @@:
        ret
 
align 4
socket_receive_tcp:
 
        call    socket_receive_stream
 
        test    ecx, ecx
        jz      @f
        push    eax ebx ecx
        call    tcp_output
        pop     ecx ebx eax
  @@:
 
        ret
 
 
align 4
socket_receive_local:
 
        ; does this socket have a PID yet?
        cmp     [eax + SOCKET.PID], 0
        jne     @f
 
        ; Change PID to that of current process
        mov     ebx, [current_slot]
        mov     ebx, [ebx + APPDATA.tid]
        mov     [eax + SOCKET.PID], ebx
        mov     [eax + SOCKET.TID], ebx                         ; currently TID = PID in kolibrios :(
      @@:
 
        mov     [eax + SOCKET.rcv_proc], socket_receive_stream
 
; ... continue to SOCKET_receive_stream
 
align 4
socket_receive_stream:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: STREAM\n"
 
        cmp     [eax + STREAM_SOCKET.rcv.size], 0
        je      .wouldblock
 
        test    edi, MSG_PEEK
        jnz     .peek
 
        mov     ecx, esi
        mov     edi, edx
        xor     edx, edx
 
        push    eax
        add     eax, STREAM_SOCKET.rcv
        call    socket_ring_read                                ; copy data from kernel buffer to application buffer
        call    socket_ring_free                                ; free read memory
        pop     eax
 
        cmp     [eax + STREAM_SOCKET.rcv.size], 0
        jne     .more_data
        xor     ebx, ebx                                        ; errorcode = 0 (no error)
        ret
 
  .more_data:
        call    socket_notify                                   ; Queue another network event
        xor     ebx, ebx                                        ; errorcode = 0 (no error)
        ret
 
  .wouldblock:
        push    EWOULDBLOCK
        pop     ebx
        xor     ecx, ecx
        ret
 
  .peek:
        mov     ecx, [eax + STREAM_SOCKET.rcv.size]
        xor     ebx, ebx
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_send: Send some data to the remote end.                  ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = pointer to data                                     ;
;       esi = data length                                         ;
;       edi = flags                                               ;
;                                                                 ;
;  OUT: eax = number of bytes sent                                ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_send:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: socknum=%u data ptr=%x length=%u flags=%x\n", ecx, edx, esi, edi
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        stdcall is_region_userspace, edx, esi
        jnz     .invalid
 
        mov     ecx, esi
        mov     esi, edx
 
        jmp     [eax + SOCKET.snd_proc]
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
 
align 4
socket_send_udp:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: UDP\n"
 
        mov     [esp + SYSCALL_STACK.eax], ecx
        call    udp_output
        cmp     eax, -1
        je      .error
        ret
 
  .error:
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], EMSGSIZE ; FIXME: UDP_output should return error codes!
        ret
 
 
align 4
socket_send_tcp:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: TCP\n"
 
        push    eax
        add     eax, STREAM_SOCKET.snd
        call    socket_ring_write
        pop     eax
 
        mov     [esp + SYSCALL_STACK.eax], ecx
        mov     [eax + SOCKET.errorcode], 0
        push    eax
        call    tcp_output              ; FIXME: this doesnt look pretty, does it?
        pop     eax
        mov     eax, [eax + SOCKET.errorcode]
        mov     [esp + SYSCALL_STACK.ebx], eax
        ret
 
 
align 4
socket_send_ip:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: IPv4\n"
 
        mov     [esp + SYSCALL_STACK.eax], ecx
        call    ipv4_output_raw
        cmp     eax, -1
        je      .error
        ret
 
  .error:
        mov     dword[esp + SYSCALL_STACK.eax], eax
        mov     dword[esp + SYSCALL_STACK.ebx], ebx
        ret
 
 
align 4
socket_send_icmp:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: ICMP\n"
 
        mov     [esp + SYSCALL_STACK.eax], ecx
        call    icmp_output_raw
        cmp     eax, -1
        je      .error
        ret
 
  .error:
        mov     dword[esp + SYSCALL_STACK.eax], eax
        mov     dword[esp + SYSCALL_STACK.ebx], ebx
        ret
 
 
;align 4
;socket_send_pppoe:
;
;        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: PPPoE\n"
;
;        mov     [esp + SYSCALL_STACK.eax], ecx
;        mov     ebx, [eax + SOCKET.device]
;
;        call    pppoe_discovery_output  ; FIXME: errorcodes
;        cmp     eax, -1
;        je      .error
;        ret
;
;  .error:
;        mov     dword[esp + SYSCALL_STACK.eax], -1
;        mov     dword[esp + SYSCALL_STACK.ebx], EMSGSIZE
;        ret
 
 
 
align 4
socket_send_local:
 
        ; does this socket have a PID yet?
        cmp     [eax + SOCKET.PID], 0
        jne     @f
 
        ; Change PID to that of current process
        mov     ebx, [current_slot]
        mov     ebx, [ebx + APPDATA.tid]
        mov     [eax + SOCKET.PID], ebx
        mov     [eax + SOCKET.TID], ebx         ; currently TID = PID in kolibrios :(
      @@:
        mov     [eax + SOCKET.snd_proc], socket_send_local_initialized
 
align 4
socket_send_local_initialized:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: LOCAL\n"
 
        ; get the other side's socket and check if it still exists
        mov     eax, [eax + SOCKET.device]
        call    socket_check
        jz      .invalid
 
        ; allright, shove in the data!
        push    eax
        add     eax, STREAM_SOCKET.rcv
        call    socket_ring_write
        pop     eax
 
        ; return the number of written bytes (or errorcode) to application
        mov     [esp + SYSCALL_STACK.eax], ecx
 
        ; and notify the other end
        call    socket_notify
 
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_get_opt: Read a socket option                            ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = pointer to socket options struct                    ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_get_opt:
 
; FIXME:
; At moment, uses only pseudo-optname -2 for get last_ack_number for TCP.
; TODO: find best way to notify that send()'ed data were acknowledged
; Also pseudo-optname -3 is valid and returns socket state, one of TCPS_*.
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_get_opt\n"
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        cmp     dword [edx], IP_PROTO_TCP
        jne     .invalid
        cmp     dword [edx+4], -2
        je      @f
        cmp     dword [edx+4], -3
        jne     .invalid
@@:
;        mov     eax, [edx+12]
;        test    eax, eax
;        jz      .fail
;        cmp     dword [eax], 4
;        mov     dword [eax], 4
;        jb      .fail
;        stdcall net_socket_num_to_addr, ecx
;        test    eax, eax
;        jz      .fail
;        ; todo: check that eax is really TCP socket
;        mov     ecx, [eax + TCP_SOCKET.last_ack_number]
;        cmp     dword [edx+4], -2
;        jz      @f
;        mov     ecx, [eax + TCP_SOCKET.state]
@@:
        mov     eax, [edx+8]
        test    eax, eax
        jz      @f
        mov     [eax], ecx
@@:
        mov     dword [esp + SYSCALL_STACK.eax], 0
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_set_options: Set a socket option.                        ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = pointer to socket options struct                    ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_set_opt:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt\n"
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        cmp     [edx + socket_options.level], IP_PROTO_IP
        je      .ip
        cmp     [edx + socket_options.level], SOL_SOCKET
        jne     .invalid
 
  .socket:
        cmp     [edx + socket_options.optname], SO_BINDTODEVICE
        jne     .invalid
 
  .bind:
        cmp     [edx + socket_options.optlen], 0
        je      .unbind
 
        movzx   edx, byte[edx + socket_options.optval]
        cmp     edx, NET_DEVICES_MAX
        ja      .invalid
 
        mov     edx, [net_device_list + 4*edx]
        test    edx, edx
        jz      .already
        mov     [eax + SOCKET.device], edx
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt: Bound socket %x to device %x\n", eax, edx
 
        mov     dword[esp + SYSCALL_STACK.eax], 0        ; success!
        ret
 
  .unbind:
        mov     [eax + SOCKET.device], 0
 
        mov     dword[esp + SYSCALL_STACK.eax], 0        ; success!
        ret
 
  .ip:
        cmp     [edx + socket_options.optname], IP_TTL
        jne     .invalid
 
  .ttl:
        mov     bl, byte[edx + socket_options.optval]
        mov     [eax + IP_SOCKET.ttl], bl
 
        mov     dword[esp + SYSCALL_STACK.eax], 0        ; success!
        ret
 
  .already:
        mov     dword[esp + SYSCALL_STACK.ebx], EALREADY
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_pair: Allocate a pair of linked local sockets.           ;
;                                                                 ;
;  IN: /                                                          ;
;                                                                 ;
; OUT: eax = socket1 num on success                               ;
;      eax = -1 on error                                          ;
;      ebx = socket2 num on success                               ;
;      ebx = errorcode on error                                   ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_pair:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_pair\n"
 
        call    socket_alloc
        test    eax, eax
        jz      .nomem1
        mov     [esp + SYSCALL_STACK.eax], edi   ; application's eax
 
        mov     [eax + SOCKET.Domain], AF_LOCAL
        mov     [eax + SOCKET.Type], SOCK_STREAM
        mov     [eax + SOCKET.Protocol], 0              ;;; CHECKME
        mov     [eax + SOCKET.snd_proc], socket_send_local
        mov     [eax + SOCKET.rcv_proc], socket_receive_local
        mov     [eax + SOCKET.PID], 0
        mov     ebx, eax
 
        call    socket_alloc
        test    eax, eax
        jz      .nomem2
        mov     [esp + SYSCALL_STACK.ebx], edi   ; application's ebx
 
        mov     [eax + SOCKET.Domain], AF_LOCAL
        mov     [eax + SOCKET.Type], SOCK_STREAM
        mov     [eax + SOCKET.Protocol], 0              ;;; CHECKME
        mov     [eax + SOCKET.snd_proc], socket_send_local
        mov     [eax + SOCKET.rcv_proc], socket_receive_local
        mov     [eax + SOCKET.PID], 0
 
        ; Link the two sockets to eachother
        mov     [eax + SOCKET.device], ebx
        mov     [ebx + SOCKET.device], eax
 
        lea     eax, [eax + STREAM_SOCKET.rcv]
        call    socket_ring_create
        test    eax, eax
        jz      .nomem2
 
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        call    socket_ring_create
        test    eax, eax
        jz      .nomem2
 
        ret
 
  .nomem2:
        mov     eax, [esp + SYSCALL_STACK.ebx]
        call    socket_free
 
  .nomem1:
        mov     eax, [esp + SYSCALL_STACK.eax]
        call    socket_free
 
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], ENOMEM
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_debug: Copy socket variables to application buffer.      ;
;                                                                 ;
;   IN: ecx = socket number                                       ;
;       edx = pointer to application buffer                       ;
;                                                                 ;
;  OUT: eax = 0 on success                                        ;
;       eax = -1 on error                                         ;
;       ebx = errorcode on error                                  ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_debug:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_debug\n"
 
        mov     edi, edx
 
        test    ecx, ecx
        jz      .returnall
 
        call    socket_num_to_ptr
        test    eax, eax
        jz      .invalid
 
        stdcall is_region_userspace, edi, SOCKET_STRUCT_SIZE
        jnz     .invalid
 
        mov     esi, eax
        mov     ecx, SOCKET_STRUCT_SIZE/4
        rep movsd
 
        mov     dword[esp+32], 0
        ret
 
  .returnall:
        mov     ebx, net_sockets
  .next_socket:
        mov     ebx, [ebx + SOCKET.NextPtr]
        test    ebx, ebx
        jz      .done
        mov     eax, [ebx + SOCKET.Number]
        stosd
        jmp     .next_socket
  .done:
        xor     eax, eax
        stosd
        mov     dword[esp + SYSCALL_STACK.eax], eax
        ret
 
  .invalid:
        mov     dword[esp + SYSCALL_STACK.eax], -1
        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
        ret
 
 
;-----------------------------------------------------------------;
;   ____                                                 ____     ;
;   \  /              End of sockets API                 \  /     ;
;    \/                                                   \/      ;
;    ()        Internally used functions follow           ()      ;
;                                                                 ;
;-----------------------------------------------------------------;
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_find_port:                                               ;
; Fill in the local port number for TCP and UDP sockets           ;
; This procedure always works because the number of sockets is    ;
; limited to a smaller number then the number of possible ports   ;
;                                                                 ;
;  IN:  eax = socket pointer                                      ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_find_port:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_find_port\n"
 
        push    ebx esi ecx
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
        je      .udp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        je      .tcp
 
        pop     ecx esi ebx
        ret
 
  .udp:
        mov     bx, [last_UDP_port]
        call    .findit
        mov     [last_UDP_port], bx
 
        pop     ecx esi ebx
        ret
 
  .tcp:
        mov     bx, [last_TCP_port]
        call    .findit
        mov     [last_TCP_port], bx
 
        pop     ecx esi ebx
        ret
 
 
  .restart:
        mov     bx, MIN_EPHEMERAL_PORT_N
  .findit:
        cmp     bx, MAX_EPHEMERAL_PORT_N
        je      .restart
 
        add     bh, 1
        adc     bl, 0
 
        call    socket_check_port
        jz      .findit
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_check_port: (to be used with AF_INET only!)              ;
; Checks if a local port number is unused                         ;
; If the proposed port number is unused, it is filled in in the   ;
; socket structure.                                               ;
;                                                                 ;
;   IN: eax = socket ptr                                          ;
;       bx = proposed socket number (network byte order)          ;
;                                                                 ;
;  OUT: ZF = set on error                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_check_port:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check_port: "
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_lock
        popa
 
        mov     ecx, [eax + SOCKET.Protocol]
        mov     edx, [eax + IP_SOCKET.LocalIP]
        mov     esi, net_sockets
 
  .next_socket:
        mov     esi, [esi + SOCKET.NextPtr]
        or      esi, esi
        jz      .port_ok
 
        cmp     [esi + SOCKET.Protocol], ecx
        jne     .next_socket
 
        cmp     [esi + IP_SOCKET.LocalIP], edx
        jne     .next_socket
 
        cmp     [esi + UDP_SOCKET.LocalPort], bx
        jne     .next_socket
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "local port %x already in use\n", bx  ; FIXME: find a way to print big endian values with debugf
        ret
 
  .port_ok:
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "local port %x is free\n", bx         ; FIXME: find a way to print big endian values with debugf
        mov     [eax + UDP_SOCKET.LocalPort], bx
        or      bx, bx                                  ; clear the zero-flag
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_input: Update a (stateless) socket with received data.   ;
;                                                                 ;
; Note: The socket's mutex should already be set !                ;
;                                                                 ;
;   IN: eax = socket ptr                                          ;
;       ecx = data size                                           ;
;       esi = ptr to data                                         ;
;       [esp] = ptr to buf                                        ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_input:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_input: socket=%x, data=%x size=%u\n", eax, esi, ecx
 
        push    ecx
        push    esi
        mov     esi, esp
 
        add_to_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, .full
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_input: success\n"
        add     esp, sizeof.socket_queue_entry
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        jmp     socket_notify
 
  .full:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_input: socket %x is full!\n", eax
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        add     esp, 8
        call    net_buff_free
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_ring_create: Create a ringbuffer for sockets.            ;
;                                                                 ;
;   IN: eax = ptr to ring struct                                  ;
;                                                                 ;
;  OUT: eax = 0 on error                                          ;
;       eax = start ptr                                           ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_ring_create:
 
        push    esi
        mov     esi, eax
 
        push    edx
        stdcall create_ring_buffer, SOCKET_BUFFER_SIZE, PG_SWR
        pop     edx
        test    eax, eax
        jz      .fail
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_create: %x\n", eax
 
        pusha
        lea     ecx, [esi + RING_BUFFER.mutex]
        call    mutex_init
        popa
 
        mov     [esi + RING_BUFFER.start_ptr], eax
        mov     [esi + RING_BUFFER.write_ptr], eax
        mov     [esi + RING_BUFFER.read_ptr], eax
        mov     [esi + RING_BUFFER.size], 0
        add     eax, SOCKET_BUFFER_SIZE
        mov     [esi + RING_BUFFER.end_ptr], eax
        mov     eax, esi
 
        pop     esi
        ret
 
  .fail:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_ring_create: Out of memory!\n"
        pop     esi
        ret
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_ring_write: Write data to ring buffer.                   ;
;                                                                 ;
;   IN: eax = ptr to ring struct                                  ;
;       ecx = data size                                           ;
;       esi = ptr to data                                         ;
;                                                                 ;
;  OUT: ecx = number of bytes stored                              ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_ring_write:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_write: ringbuff=%x ptr=%x size=%u\n", eax, esi, ecx
 
; lock mutex
        pusha
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_lock                                      ; TODO: check what registers this function actually destroys
        popa
 
; calculate available size
        mov     edi, SOCKET_BUFFER_SIZE
        sub     edi, [eax + RING_BUFFER.size]                   ; available buffer size in edi
        cmp     ecx, edi
        jbe     .copy
        mov     ecx, edi
  .copy:
        mov     edi, [eax + RING_BUFFER.write_ptr]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_write: %u bytes from %x to %x\n", ecx, esi, edi
 
; update write ptr
        push    edi
        add     edi, ecx
        cmp     edi, [eax + RING_BUFFER.end_ptr]
        jb      @f
        sub     edi, SOCKET_BUFFER_SIZE                         ; WRAP
  @@:
        mov     [eax + RING_BUFFER.write_ptr], edi
        pop     edi
 
; update size
        add     [eax + RING_BUFFER.size], ecx
 
; copy the data
        push    ecx
        shr     ecx, 1
        jnc     .nb
        movsb
  .nb:
        shr     ecx, 1
        jnc     .nw
        movsw
  .nw:
        test    ecx, ecx
        jz      .nd
        rep movsd
  .nd:
        pop     ecx
 
; unlock mutex
        pusha
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_unlock                                    ; TODO: check what registers this function actually destroys
        popa
 
        ret
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_ring_read: Read from ring buffer                         ;
;                                                                 ;
;   IN: eax = ring struct ptr                                     ;
;       ecx = bytes to read                                       ;
;       edx = offset                                              ;
;       edi = ptr to buffer start                                 ;
;                                                                 ;
;  OUT: eax = unchanged                                           ;
;       ecx = number of bytes read (0 on error)                   ;
;       edx = destroyed                                           ;
;       esi = destroyed                                           ;
;       edi = ptr to buffer end                                   ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_ring_read:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_read: ringbuff=%x ptr=%x size=%u offset=%x\n", eax, edi, ecx, edx
 
        pusha
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_lock                                      ; TODO: check what registers this function actually destroys
        popa
 
        mov     esi, [eax + RING_BUFFER.read_ptr]
        add     esi, edx                                        ; esi = start_ptr + offset
 
        neg     edx
        add     edx, [eax + RING_BUFFER.size]                   ; edx = snd.size - offset
        jle     .no_data_at_all
 
        pusha
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_unlock                                    ; TODO: check what registers this function actually destroys
        popa
 
        cmp     ecx, edx
        ja      .less_data
 
  .copy:
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_read: %u bytes from %x to %x\n", ecx, esi, edi
        push    ecx
        shr     ecx, 1
        jnc     .nb
        movsb
  .nb:
        shr     ecx, 1
        jnc     .nw
        movsw
  .nw:
        test    ecx, ecx
        jz      .nd
        rep movsd
  .nd:
        pop     ecx
        ret
 
  .no_data_at_all:
        pusha
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_unlock                                    ; TODO: check what registers this function actually destroys
        popa
 
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_ring_read: no data at all!\n"
        xor     ecx, ecx
        ret
 
  .less_data:
        mov     ecx, edx
        jmp     .copy
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_ring_free: Free data from a ringbuffer.                  ;
;                                                                 ;
;   IN: eax = ptr to ring struct                                  ;
;       ecx = data size                                           ;
;                                                                 ;
;  OUT: ecx = number of freed bytes                               ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_ring_free:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_free: %u bytes from ring %x\n", ecx, eax
 
        push    eax ecx
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_lock                                      ; TODO: check what registers this function actually destroys
        pop     ecx eax
 
        sub     [eax + RING_BUFFER.size], ecx
        jb      .error
        add     [eax + RING_BUFFER.read_ptr], ecx
 
        mov     edx, [eax + RING_BUFFER.end_ptr]
        cmp     [eax + RING_BUFFER.read_ptr], edx
        jb      @f
        sub     [eax + RING_BUFFER.read_ptr], SOCKET_BUFFER_SIZE
       @@:
 
        push    eax ecx
        lea     ecx, [eax + RING_BUFFER.mutex]                  ; TODO: check what registers this function actually destroys
        call    mutex_unlock
        pop     ecx eax
 
        ret
 
  .error:       ; we could free all available bytes, but that would be stupid, i guess..
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_ring_free: buffer=%x error!\n", eax
        add     [eax + RING_BUFFER.size], ecx
 
        push    eax
        lea     ecx, [eax + RING_BUFFER.mutex]
        call    mutex_unlock                                    ; TODO: check what registers this function actually destroys
        pop     eax
 
        xor     ecx, ecx
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_block: Suspend the thread attached to a socket.          ;
;                                                                 ;
;   IN: eax = socket ptr                                          ;
;                                                                 ;
;  OUT: eax = unchanged                                           ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_block:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: %x\n", eax
 
        push    eax
 
        pushf
        cli
        ; Set the 'socket is blocked' flag
        or      [eax + SOCKET.state], SS_BLOCKED
 
        ; Suspend the thread
        push    edx
        mov     edx, [current_slot]
        mov     [edx + APPDATA.state], TSTATE_RUN_SUSPENDED
 
        ; Remember the thread ID so we can wake it up again
        mov     edx, [edx + APPDATA.tid]
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: suspending thread: %u\n", edx
        mov     [eax + SOCKET.TID], edx
        pop     edx
        popf
 
        call    change_task
        pop     eax
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: continuing\n"
 
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_notify: Wake up socket owner thread.                     ;
;                                                                 ;
;   IN: eax = socket ptr                                          ;
;                                                                 ;
;  OUT: eax = unchanged                                           ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_notify:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: %x\n", eax
 
        call    socket_check
        jz      .error
 
; Find the associated thread's
        push    ebx ecx esi
        mov     ebx, [eax + SOCKET.TID]
        test    ebx, ebx
        jz      .error2
        xor     ecx, ecx
        inc     ecx
        mov     esi, SLOT_BASE + sizeof.APPDATA
  .next:
        cmp     [esi + APPDATA.tid], ebx
        je      .found
        inc     ecx
        add     esi, sizeof.APPDATA
        cmp     ecx, [thread_count]
        jbe     .next
 
  .error2:
; PID not found, TODO: close socket!
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_notify: error finding thread 0x%x !\n", ebx
        pop     esi ecx ebx
        ret
 
  .error:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_notify: invalid socket ptr: 0x%x !\n", eax
        ret
 
  .found:
        test    [eax + SOCKET.state], SS_BLOCKED
        jnz     .un_block
 
; Socket and thread exists and socket is of non blocking type.
; We'll try to flag an event to the thread.
        or      [esi + APPDATA.occurred_events], EVENT_NETWORK
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: poking thread %u!\n", ebx
        pop     esi ecx ebx
        ret
 
 
  .un_block:
; Socket and thread exists and socket is of blocking type
; We'll try to unblock it.
        and     [eax + SOCKET.state], not SS_BLOCKED    ; Clear the 'socket is blocked' flag
        mov     [esi + APPDATA.state], TSTATE_RUNNING  ; Run the thread
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: Unblocked socket!\n"
        pop     esi ecx ebx
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_alloc: Allocate memory for socket and put new socket     ;
; into the list. Newly created socket is initialized with calling ;
; PID and given a socket number.                                  ;
;                                                                 ;
;  IN:  /                                                         ;
;                                                                 ;
; OUT:  eax = socket ptr on success                               ;
;       eax = 0 on error                                          ;
;       edi = socket number on success                            ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_alloc:
 
        push    ebx
 
        stdcall kernel_alloc, SOCKET_STRUCT_SIZE
        or      eax, eax
        jz      .nomem
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_alloc: ptr=%x\n", eax
 
; zero-initialize allocated memory
        push    eax
        mov     edi, eax
        mov     ecx, SOCKET_STRUCT_SIZE / 4
        xor     eax, eax
        rep stosd
        pop     eax
 
; set send-and receive procedures to return -1
        mov     [eax + SOCKET.snd_proc], .not_yet
        mov     [eax + SOCKET.rcv_proc], .not_yet
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_lock
        popa
 
; find first free socket number and use it
        mov     edi, [last_socket_num]
  .next_socket_number:
        inc     edi
        jz      .next_socket_number     ; avoid socket nr 0
        cmp     edi, -1
        je      .next_socket_number     ; avoid socket nr -1
        mov     ebx, net_sockets
  .next_socket:
        mov     ebx, [ebx + SOCKET.NextPtr]
        test    ebx, ebx
        jz      .last_socket
 
        cmp     [ebx + SOCKET.Number], edi
        jne     .next_socket
        jmp     .next_socket_number
 
  .last_socket:
        mov     [last_socket_num], edi
        mov     [eax + SOCKET.Number], edi
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_alloc: number=%u\n", edi
 
; Fill in PID
        mov     ebx, [current_slot]
        mov     ebx, [ebx + APPDATA.tid]
        mov     [eax + SOCKET.PID], ebx
        mov     [eax + SOCKET.TID], ebx         ; currently TID = PID in kolibrios :(
 
; init mutex
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_init
        popa
 
; add socket to the list by re-arranging some pointers
        mov     ebx, [net_sockets + SOCKET.NextPtr]
 
        mov     [eax + SOCKET.PrevPtr], net_sockets
        mov     [eax + SOCKET.NextPtr], ebx
 
        test    ebx, ebx
        jz      @f
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_lock
        popa
 
        mov     [ebx + SOCKET.PrevPtr], eax
 
        pusha
        lea     ecx, [ebx + SOCKET.mutex]
        call    mutex_unlock
        popa
       @@:
 
        mov     [net_sockets + SOCKET.NextPtr], eax
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
        pop     ebx
 
        ret
 
  .nomem:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_alloc: Out of memory!\n"
        pop     ebx
        ret
 
  .not_yet:
        mov     dword[esp+20], ENOTCONN
        mov     dword[esp+32], -1
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_free: Free socket data memory and remove socket from     ;
; the list. Caller should lock and unlock socket_mutex.           ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
; OUT:  /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_free:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: %x\n", eax
 
        call    socket_check
        jz      .error
 
        push    ebx
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_lock
        popa
 
        cmp     [eax + SOCKET.Type], SOCK_STREAM
        jne     .no_stream
 
        mov     ebx, eax
        cmp     [eax + STREAM_SOCKET.rcv.start_ptr], 0
        je      @f
        stdcall free_kernel_space, [eax + STREAM_SOCKET.rcv.start_ptr]
  @@:
        cmp     [ebx + STREAM_SOCKET.snd.start_ptr], 0
        je      @f
        stdcall free_kernel_space, [ebx + STREAM_SOCKET.snd.start_ptr]
  @@:
        mov     eax, ebx
  .no_stream:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: freeing socket %x\n", eax
        push    eax                             ; this will be passed to kernel_free
        mov     ebx, [eax + SOCKET.NextPtr]
        mov     eax, [eax + SOCKET.PrevPtr]
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: linking socket %x to socket %x\n", eax, ebx
 
        test    eax, eax
        jz      @f
        mov     [eax + SOCKET.NextPtr], ebx
       @@:
 
        test    ebx, ebx
        jz      @f
        mov     [ebx + SOCKET.PrevPtr], eax
       @@:
 
        call    kernel_free
        pop     ebx
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: success!\n"
 
  .error:
        ret
 
  .error1:
        pop     ebx
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_free: error!\n"
        DEBUGF  DEBUG_NETWORK_ERROR, "socket ptr=0x%x caller=0x%x\n", eax, [esp]
        ret
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_fork: Create a child socket.                             ;
;                                                                 ;
;  IN:  ebx = socket number                                       ;
;                                                                 ;
; OUT:  eax = child socket number on success                      ;
;       eax = 0 on error                                          ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_fork:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_fork: %x\n", ebx
 
; Exit if backlog queue is full
        mov     eax, [ebx + SOCKET_QUEUE_LOCATION + queue.size]
        cmp     ax, [ebx + SOCKET.backlog]
        jae     .fail
 
; Allocate new socket
        push    ebx
        call    socket_alloc
        pop     ebx
        test    eax, eax
        jz      .fail
 
        push    eax
        mov     esi, esp
        add_to_queue (ebx + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, .fail2
        pop     eax
 
; Copy structure from current socket to new
; We start at PID to preserve the socket num, 2 pointers and mutex
; TID will be filled in later
        lea     esi, [ebx + SOCKET.PID]
        lea     edi, [eax + SOCKET.PID]
        mov     ecx, (SOCKET_QUEUE_LOCATION - SOCKET.PID + 3)/4
        rep movsd
 
        and     [eax + SOCKET.options], not SO_ACCEPTCON
 
; Notify owner of parent socket
        push    eax
        mov     eax, ebx
        call    socket_notify
        pop     eax
 
        ret
 
  .fail2:
        add     esp, 4+4+4
  .fail:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_fork: failed\n"
        xor     eax, eax
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_num_to_ptr: Get socket structure address by its number.  ;
;                                                                 ;
;  IN:  ecx = socket number                                       ;
;                                                                 ;
; OUT:  eax = socket ptr                                          ;
;       eax = 0 on error                                          ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_num_to_ptr:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_num_to_ptr: num=%u ", ecx
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_lock
        popa
 
        mov     eax, net_sockets
  .next_socket:
        mov     eax, [eax + SOCKET.NextPtr]
        test    eax, eax
        jz      .error
        cmp     [eax + SOCKET.Number], ecx
        jne     .next_socket
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "ptr=%x\n", eax
        ret
 
  .error:
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: socket %u not found!\n", eax
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: caller = 0x%x\n", [esp]
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_ptr_to_num: Get socket number by its address.            ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
; OUT:  eax = socket number                                       ;
;       eax = 0 on error                                          ;
;       ZF = set on error                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_ptr_to_num:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ptr_to_num: ptr=%x ", eax
 
        call    socket_check
        jz      .error
 
        mov     eax, [eax + SOCKET.Number]
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "num=%u\n", eax
        ret
 
  .error:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_ptr_to_num: not found\n", eax
        ret
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_check: Checks if the given ptr is really a socket ptr.   ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
; OUT:  eax = 0 on error                                          ;
;       ZF = set on error                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_check:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check: %x\n", eax
 
        test    eax, eax
        jz      .error
        push    ebx
        mov     ebx, net_sockets
 
  .next_socket:
        mov     ebx, [ebx + SOCKET.NextPtr]
        or      ebx, ebx
        jz      .done
        cmp     ebx, eax
        jnz     .next_socket
 
  .done:
        mov     eax, ebx
        test    eax, eax
        pop     ebx
        ret
 
  .error:
        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_check: called with argument 0\n"
        DEBUGF  DEBUG_NETWORK_ERROR, "stack: 0x%x, 0x%x, 0x%x\n", [esp], [esp+4], [esp+8]
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_check_owner: Check if the caller app owns the socket.    ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
; OUT:  ZF = true/false                                           ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_check_owner:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check_owner: %x\n", eax
 
        push    ebx
        mov     ebx, [current_slot]
        mov     ebx, [ebx + APPDATA.tid]
        cmp     [eax + SOCKET.PID], ebx
        pop     ebx
 
        ret
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_process_end: Kernel calls this function when a certain   ;
; process ends. This function will check if the process had any   ;
; open sockets and update them accordingly (clean up).            ;
;                                                                 ;
;  IN:  edx = pid                                                 ;
;                                                                 ;
; OUT:  /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_process_end:
 
        ret     ; FIXME
 
        cmp     [net_sockets + SOCKET.NextPtr], 0       ; Are there any active sockets at all?
        je      .quickret                               ; nope, exit immediately
 
; TODO: run the following code in another thread, to avoid deadlock
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_process_end: %x\n", edx
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_lock
        popa
 
        push    ebx
        mov     ebx, net_sockets
 
  .next_socket:
        mov     ebx, [ebx + SOCKET.NextPtr]
  .next_socket_test:
        test    ebx, ebx
        jz      .done
 
        cmp     [ebx + SOCKET.PID], edx
        jne     .next_socket
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_process_end: killing socket %x\n", ebx
 
        mov     [ebx + SOCKET.PID], 0
        mov     eax, ebx
        mov     ebx, [ebx + SOCKET.NextPtr]
 
        pusha
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     .free
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jne     .free
 
        call    tcp_disconnect
        jmp     .closed
 
  .free:
        call    socket_free
 
  .closed:
        popa
        jmp     .next_socket_test
 
  .done:
        pop     ebx
 
        pusha
        mov     ecx, socket_mutex
        call    mutex_unlock
        popa
 
  .quickret:
        ret
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_is_connecting: Update socket state.                      ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_is_connecting:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connecting: %x\n", eax
 
        and     [eax + SOCKET.state], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
        or      [eax + SOCKET.state], SS_ISCONNECTING
        ret
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_is_connected: Update socket state.                       ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_is_connected:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connected: %x\n", eax
 
        and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING)
        or      [eax + SOCKET.state], SS_ISCONNECTED
        jmp     socket_notify
 
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_is_disconnecting: Update socket state.                   ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_is_disconnecting:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnecting: %x\n", eax
 
        and     [eax + SOCKET.state], not (SS_ISCONNECTING)
        or      [eax + SOCKET.state], SS_ISDISCONNECTING + SS_CANTRCVMORE + SS_CANTSENDMORE
        jmp     socket_notify
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_is_disconnected: Update socket state.                    ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_is_disconnected:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnected: %x\n", eax
 
        and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
        or      [eax + SOCKET.state], SS_CANTRCVMORE + SS_CANTSENDMORE
        jmp     socket_notify
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_cant_recv_more: Update socket state.                     ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_cant_recv_more:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_cant_recv_more: %x\n", eax
 
        or      [eax + SOCKET.state], SS_CANTRCVMORE
        jmp     socket_notify
 
 
 
;-----------------------------------------------------------------;
;                                                                 ;
; socket_cant_send_more: Update socket state.                     ;
;                                                                 ;
;  IN:  eax = socket ptr                                          ;
;                                                                 ;
;  OUT: /                                                         ;
;                                                                 ;
;-----------------------------------------------------------------;
align 4
socket_cant_send_more:
 
        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_cant_send_more: %x\n", eax
 
        or      [eax + SOCKET.state], SS_CANTSENDMORE
        mov     [eax + SOCKET.snd_proc], .notconn
        jmp     socket_notify
 
  .notconn:
        mov     dword[esp + SYSCALL_STACK.ebx], ENOTCONN
        mov     dword[esp + SYSCALL_STACK.eax], -1
        ret

Rev 9976	Rev 9993
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2021. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2021. 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	;; Part of the TCP/IP network stack for KolibriOS ;;	6	;; Part of the TCP/IP network stack for KolibriOS ;;
7	;; ;;	7	;; ;;
8	;; Written by hidnplayr@kolibrios.org, ;;	8	;; Written by hidnplayr@kolibrios.org, ;;
9	;; and Clevermouse. ;;	9	;; and Clevermouse. ;;
10	;; ;;	10	;; ;;
11	;; Based on code by mike.dld ;;	11	;; Based on code by mike.dld ;;
12	;; ;;	12	;; ;;
13	;; GNU GENERAL PUBLIC LICENSE ;;	13	;; GNU GENERAL PUBLIC LICENSE ;;
14	;; Version 2, June 1991 ;;	14	;; Version 2, June 1991 ;;
15	;; ;;	15	;; ;;
16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	16	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
17		17
18	$Revision: 9976 $	18	$Revision: 9993 $
19		19
20	struct SOCKET	20	struct SOCKET
21		21
22	NextPtr dd ? ; pointer to next socket in list	22	NextPtr dd ? ; pointer to next socket in list
23	PrevPtr dd ? ; pointer to previous socket in list	23	PrevPtr dd ? ; pointer to previous socket in list
24	Number dd ? ; socket number	24	Number dd ? ; socket number
25		25
26	mutex MUTEX	26	mutex MUTEX
27		27
28	PID dd ? ; process ID	28	PID dd ? ; process ID
29	TID dd ? ; thread ID	29	TID dd ? ; thread ID
30	Domain dd ? ; INET4/INET6/LOCAL/..	30	Domain dd ? ; INET4/INET6/LOCAL/..
31	Type dd ? ; RAW/STREAM/DGRAM	31	Type dd ? ; RAW/STREAM/DGRAM
32	Protocol dd ? ; UDP/TCP/ARP/ICMP	32	Protocol dd ? ; UDP/TCP/ARP/ICMP
33	errorcode dd ?	33	errorcode dd ?
34	device dd ? ; device pointer, paired socket pointer if it's a local socket	34	device dd ? ; device pointer, paired socket pointer if it's a local socket
35		35
36	options dd ?	36	options dd ?
37	state dd ?	37	state dd ?
38	backlog dw ? ; number of incoming connections that can be queued	38	backlog dw ? ; number of incoming connections that can be queued
39		39
40	snd_proc dd ?	40	snd_proc dd ?
41	rcv_proc dd ?	41	rcv_proc dd ?
42	connect_proc dd ?	42	connect_proc dd ?
43	;sndto_proc dd ?	43	;sndto_proc dd ?
44	;rcvfrom_proc dd ?	44	;rcvfrom_proc dd ?
45		45
46	ends	46	ends
47		47
48	struct IP_SOCKET SOCKET	48	struct IP_SOCKET SOCKET
49		49
50	LocalIP rd 4 ; network byte order	50	LocalIP rd 4 ; network byte order
51	RemoteIP rd 4 ; network byte order	51	RemoteIP rd 4 ; network byte order
52	ttl db ?	52	ttl db ?
53	rb 3 ; align	53	rb 3 ; align
54		54
55	ends	55	ends
56		56
57	struct TCP_SOCKET IP_SOCKET	57	struct TCP_SOCKET IP_SOCKET
58		58
59	LocalPort dw ? ; network byte order	59	LocalPort dw ? ; network byte order
60	RemotePort dw ? ; network byte order	60	RemotePort dw ? ; network byte order
61		61
62	t_state dd ? ; TCB state	62	t_state dd ? ; TCB state
63	t_rxtshift db ?	63	t_rxtshift db ?
64	rb 3 ; align	64	rb 3 ; align
65	t_rxtcur dd ?	65	t_rxtcur dd ?
66	t_dupacks dd ?	66	t_dupacks dd ?
67	t_maxseg dd ?	67	t_maxseg dd ?
68	t_flags dd ?	68	t_flags dd ?
69		69
70	;---------------	70	;---------------
71	; RFC783 page 21	71	; RFC783 page 21
72		72
73	; send sequence	73	; send sequence
74	SND_UNA dd ? ; sequence number of unack'ed sent Packets	74	SND_UNA dd ? ; sequence number of unack'ed sent Packets
75	SND_NXT dd ? ; next send sequence number to use	75	SND_NXT dd ? ; next send sequence number to use
76	SND_UP dd ? ; urgent pointer	76	SND_UP dd ? ; urgent pointer
77	SND_WL1 dd ? ; the sequence number of the last segment used to update the send window	77	SND_WL1 dd ? ; the sequence number of the last segment used to update the send window
78	SND_WL2 dd ? ; the acknowledgment number of the last segment used to update the send window	78	SND_WL2 dd ? ; the acknowledgment number of the last segment used to update the send window
79	ISS dd ? ; initial send sequence number	79	ISS dd ? ; initial send sequence number
80	SND_WND dd ? ; send window	80	SND_WND dd ? ; send window
81		81
82	; receive sequence	82	; receive sequence
83	RCV_WND dd ? ; receive window	83	RCV_WND dd ? ; receive window
84	RCV_NXT dd ? ; next receive sequence number to use	84	RCV_NXT dd ? ; next receive sequence number to use
85	RCV_UP dd ? ; urgent pointer	85	RCV_UP dd ? ; urgent pointer
86	IRS dd ? ; initial receive sequence number	86	IRS dd ? ; initial receive sequence number
87		87
88	;---------------------	88	;---------------------
89	; Additional variables	89	; Additional variables
90		90
91	; receive variables	91	; receive variables
92	RCV_ADV dd ?	92	RCV_ADV dd ?
93		93
94	; retransmit variables	94	; retransmit variables
95	SND_MAX dd ?	95	SND_MAX dd ?
96		96
97	; congestion control	97	; congestion control
98	SND_CWND dd ? ; congestion window	98	SND_CWND dd ? ; congestion window
99	SND_SSTHRESH dd ? ; slow start threshold	99	SND_SSTHRESH dd ? ; slow start threshold
100		100
101	;----------------------	101	;----------------------
102	; Transmit timing stuff	102	; Transmit timing stuff
103	t_idle dd ?	103	t_idle dd ?
104	t_rtt dd ? ; round trip time	104	t_rtt dd ? ; round trip time
105	t_rtseq dd ?	105	t_rtseq dd ?
106	t_srtt dd ? ; smoothed round trip time	106	t_srtt dd ? ; smoothed round trip time
107	t_rttvar dd ?	107	t_rttvar dd ?
108	t_rttmin dd ?	108	t_rttmin dd ?
109	max_sndwnd dd ?	109	max_sndwnd dd ?
110		110
111	;-----------------	111	;-----------------
112	; Out-of-band data	112	; Out-of-band data
113	t_oobflags dd ?	113	t_oobflags dd ?
114	t_iobc dd ?	114	t_iobc dd ?
115	t_softerror dd ?	115	t_softerror dd ?
116		116
117		117
118	;---------	118	;---------
119	; RFC 1323 ; the order of next 4 elements may not change	119	; RFC 1323 ; the order of next 4 elements may not change
120		120
121	SND_SCALE db ?	121	SND_SCALE db ?
122	RCV_SCALE db ?	122	RCV_SCALE db ?
123	requested_s_scale db ?	123	requested_s_scale db ?
124	request_r_scale db ?	124	request_r_scale db ?
125		125
126	ts_recent dd ? ; a copy of the most-recent valid timestamp from the other end	126	ts_recent dd ? ; a copy of the most-recent valid timestamp from the other end
127	ts_recent_age dd ?	127	ts_recent_age dd ?
128	last_ack_sent dd ?	128	last_ack_sent dd ?
129		129
130		130
131	;-------	131	;-------
132	; Timers	132	; Timers
133	timer_flags dd ?	133	timer_flags dd ?
134	timer_retransmission dd ? ; rexmt	134	timer_retransmission dd ? ; rexmt
135	timer_persist dd ?	135	timer_persist dd ?
136	timer_keepalive dd ? ; keepalive/syn timeout	136	timer_keepalive dd ? ; keepalive/syn timeout
137	timer_timed_wait dd ? ; also used as 2msl timer	137	timer_timed_wait dd ? ; also used as 2msl timer
138	timer_connect dd ?	138	timer_connect dd ?
139		139
140	; extra	140	; extra
141		141
142	ts_ecr dd ? ; timestamp echo reply	142	ts_ecr dd ? ; timestamp echo reply
143	ts_val dd ?	143	ts_val dd ?
144		144
145	seg_next dd ? ; re-assembly queue	145	seg_next dd ? ; re-assembly queue
146		146
147	ends	147	ends
148		148
149	struct UDP_SOCKET IP_SOCKET	149	struct UDP_SOCKET IP_SOCKET
150		150
151	LocalPort dw ? ; in network byte order	151	LocalPort dw ? ; in network byte order
152	RemotePort dw ? ; in network byte order	152	RemotePort dw ? ; in network byte order
153		153
154	ends	154	ends
155		155
156	struct RING_BUFFER	156	struct RING_BUFFER
157		157
158	mutex MUTEX	158	mutex MUTEX
159	start_ptr dd ? ; Pointer to start of buffer	159	start_ptr dd ? ; Pointer to start of buffer
160	end_ptr dd ? ; pointer to end of buffer	160	end_ptr dd ? ; pointer to end of buffer
161	read_ptr dd ? ; Read pointer	161	read_ptr dd ? ; Read pointer
162	write_ptr dd ? ; Write pointer	162	write_ptr dd ? ; Write pointer
163	size dd ? ; Number of bytes buffered	163	size dd ? ; Number of bytes buffered
164		164
165	ends	165	ends
166		166
167	struct STREAM_SOCKET TCP_SOCKET	167	struct STREAM_SOCKET TCP_SOCKET
168		168
169	rcv RING_BUFFER	169	rcv RING_BUFFER
170	snd RING_BUFFER	170	snd RING_BUFFER
171		171
172	ends	172	ends
173		173
174	struct sockaddr	174	struct sockaddr
175		175
176	family dw ? ; Address family	176	family dw ? ; Address family
177	port dw ? ; 16 bit TCP/UDP port number	177	port dw ? ; 16 bit TCP/UDP port number
178	ip dd ? ; 32 bit IP address	178	ip dd ? ; 32 bit IP address
179	_zero rb 8 ; Not use, for align	179	_zero rb 8 ; Not use, for align
180		180
181	ends	181	ends
182		182
183	struct socket_queue_entry	183	struct socket_queue_entry
184		184
185	data_ptr dd ?	185	data_ptr dd ?
186	data_size dd ?	186	data_size dd ?
187	buf_ptr dd ?	187	buf_ptr dd ?
188		188
189	ends	189	ends
190		190
191	struct socket_options	191	struct socket_options
192		192
193	level dd ?	193	level dd ?
194	optname dd ?	194	optname dd ?
195	optlen dd ?	195	optlen dd ?
196	optval dd ?	196	optval dd ?
197		197
198	ends	198	ends
199		199
200	SOCKET_STRUCT_SIZE = 4096 ; in bytes	200	SOCKET_STRUCT_SIZE = 4096 ; in bytes
201		201
202	SOCKET_QUEUE_SIZE = 10 ; maximum number of incoming packets queued for 1 socket	202	SOCKET_QUEUE_SIZE = 10 ; maximum number of incoming packets queued for 1 socket
203	; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start	203	; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start
204	SOCKET_QUEUE_LOCATION = (SOCKET_STRUCT_SIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)	204	SOCKET_QUEUE_LOCATION = (SOCKET_STRUCT_SIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)
205		205
206	uglobal	206	uglobal
207	align 4	207	align 4
208		208
209	net_sockets rd 4	209	net_sockets rd 4
210	last_socket_num dd ?	210	last_socket_num dd ?
211	last_UDP_port dw ? ; last used ephemeral port	211	last_UDP_port dw ? ; last used ephemeral port
212	last_TCP_port dw ? ;	212	last_TCP_port dw ? ;
213	socket_mutex MUTEX	213	socket_mutex MUTEX
214		214
215	endg	215	endg
216		216
217		217
218	;-----------------------------------------------------------------;	218	;-----------------------------------------------------------------;
219	; ;	219	; ;
220	; socket_init ;	220	; socket_init ;
221	; ;	221	; ;
222	;-----------------------------------------------------------------;	222	;-----------------------------------------------------------------;
223	macro socket_init {	223	macro socket_init {
224		224
225	xor eax, eax	225	xor eax, eax
226	mov edi, net_sockets	226	mov edi, net_sockets
227	mov ecx, 5	227	mov ecx, 5
228	rep stosd	228	rep stosd
229		229
230	@@:	230	@@:
231	pseudo_random eax	231	pseudo_random eax
232	cmp ax, EPHEMERAL_PORT_MIN	232	cmp ax, EPHEMERAL_PORT_MIN
233	jb @r	233	jb @r
234	cmp ax, EPHEMERAL_PORT_MAX	234	cmp ax, EPHEMERAL_PORT_MAX
235	ja @r	235	ja @r
236	xchg al, ah	236	xchg al, ah
237	mov [last_UDP_port], ax	237	mov [last_UDP_port], ax
238		238
239	@@:	239	@@:
240	pseudo_random eax	240	pseudo_random eax
241	cmp ax, EPHEMERAL_PORT_MIN	241	cmp ax, EPHEMERAL_PORT_MIN
242	jb @r	242	jb @r
243	cmp ax, EPHEMERAL_PORT_MAX	243	cmp ax, EPHEMERAL_PORT_MAX
244	ja @r	244	ja @r
245	xchg al, ah	245	xchg al, ah
246	mov [last_TCP_port], ax	246	mov [last_TCP_port], ax
247		247
248	mov ecx, socket_mutex	248	mov ecx, socket_mutex
249	call mutex_init	249	call mutex_init
250		250
251	}	251	}
252		252
253	;-----------------------------------------------------------------;	253	;-----------------------------------------------------------------;
254	; ;	254	; ;
255	; Sockets API (system function 75) ;	255	; Sockets API (system function 75) ;
256	; ;	256	; ;
257	;-----------------------------------------------------------------;	257	;-----------------------------------------------------------------;
258	align 4	258	align 4
259	sys_socket:	259	sys_socket:
260		260
261	mov dword[esp + SYSCALL_STACK.ebx], 0 ; Set error code to 0	261	mov dword[esp + SYSCALL_STACK.ebx], 0 ; Set error code to 0
262		262
263	cmp ebx, 255	263	cmp ebx, 255
264	jz socket_debug	264	jz socket_debug
265		265
266	cmp ebx, .number	266	cmp ebx, .number
267	ja .error	267	ja .error
268	jmp dword [.table + 4*ebx]	268	jmp dword [.table + 4*ebx]
269		269
270	.table:	270	.table:
271	dd socket_open ; 0	271	dd socket_open ; 0
272	dd socket_close ; 1	272	dd socket_close ; 1
273	dd socket_bind ; 2	273	dd socket_bind ; 2
274	dd socket_listen ; 3	274	dd socket_listen ; 3
275	dd socket_connect ; 4	275	dd socket_connect ; 4
276	dd socket_accept ; 5	276	dd socket_accept ; 5
277	dd socket_send ; 6	277	dd socket_send ; 6
278	dd socket_receive ; 7	278	dd socket_receive ; 7
279	dd socket_set_opt ; 8	279	dd socket_set_opt ; 8
280	dd socket_get_opt ; 9	280	dd socket_get_opt ; 9
281	dd socket_pair ; 10	281	dd socket_pair ; 10
282		282
283	;dd socket_sendto ; 11	283	;dd socket_sendto ; 11
284	;dd socket_recvfrom ; 12	284	;dd socket_recvfrom ; 12
285	.number = ($ - .table) / 4 - 1	285	.number = ($ - .table) / 4 - 1
286		286
287	.error:	287	.error:
288	mov dword[esp + SYSCALL_STACK.eax], -1	288	mov dword[esp + SYSCALL_STACK.eax], -1
289	mov dword[esp + SYSCALL_STACK.ebx], EINVAL	289	mov dword[esp + SYSCALL_STACK.ebx], EINVAL
290		290
291	ret	291	ret
292		292
293	;-----------------------------------------------------------------;	293	;-----------------------------------------------------------------;
294	; ;	294	; ;
295	; socket_open: Create a new socket. ;	295	; socket_open: Create a new socket. ;
296	; ;	296	; ;
297	; IN: ecx = domain ;	297	; IN: ecx = domain ;
298	; edx = type ;	298	; edx = type ;
299	; esi = protocol ;	299	; esi = protocol ;
300	; ;	300	; ;
301	; OUT: eax = socket number ;	301	; OUT: eax = socket number ;
302	; eax = -1 on error ;	302	; eax = -1 on error ;
303	; ebx = errorcode on error ;	303	; ebx = errorcode on error ;
304	; ;	304	; ;
305	;-----------------------------------------------------------------;	305	;-----------------------------------------------------------------;
306	align 4	306	align 4
307	socket_open:	307	socket_open:
308		308
309	DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_open: domain=%u type=%u protocol=%x\n", ecx, edx, esi	309	DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_open: domain=%u type=%u protocol=%x\n", ecx, edx, esi
310		310
311	push ecx edx esi	311	push ecx edx esi
312	call socket_alloc	312	call socket_alloc
313	pop esi edx ecx	313	pop esi edx ecx
314	test eax, eax	314	test eax, eax
315	jz .nobuffs	315	jz .nobuffs
316		316
317	mov [esp + SYSCALL_STACK.eax], edi ; return socketnumber	317	mov [esp + SYSCALL_STACK.eax], edi ; return socketnumber
318	DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_open: socknum=%u\n", edi	318	DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_open: socknum=%u\n", edi
319		319
320	test edx, SO_NONBLOCK	320	test edx, SO_NONBLOCK
321	jz @f	321	jz @f
322	or [eax + SOCKET.options], SO_NONBLOCK	322	or [eax + SOCKET.options], SO_NONBLOCK
323	and edx, not SO_NONBLOCK	323	and edx, not SO_NONBLOCK
324	@@:	324	@@:
325		325
326	mov [eax + SOCKET.Domain], ecx	326	mov [eax + SOCKET.Domain], ecx
327	mov [eax + SOCKET.Type], edx	327	mov [eax + SOCKET.Type], edx
328	mov [eax + SOCKET.Protocol], esi	328	mov [eax + SOCKET.Protocol], esi
329	mov [eax + SOCKET.connect_proc], connect_notsupp	329	mov [eax + SOCKET.connect_proc], connect_notsupp
330		330
331	cmp ecx, AF_INET4	331	cmp ecx, AF_INET4
332	jne .no_inet4	332	jne .no_inet4
333		333
334	mov [eax + IP_SOCKET.ttl], 128	334	mov [eax + IP_SOCKET.ttl], 128
335		335
336	cmp edx, SOCK_DGRAM	336	cmp edx, SOCK_DGRAM
337	je .udp	337	je .udp
338		338
339	cmp edx, SOCK_STREAM	339	cmp edx, SOCK_STREAM
340	je .tcp	340	je .tcp
341		341
342	cmp edx, SOCK_RAW	342	cmp edx, SOCK_RAW
343	je .raw	343	je .raw
344		344
345	.no_inet4:	345	.no_inet4:
346	cmp ecx, AF_PPP	346	cmp ecx, AF_PPP
347	jne .no_ppp	347	jne .no_ppp
348		348
349	; cmp esi, PPP_PROTO_ETHERNET	349	; cmp esi, PPP_PROTO_ETHERNET
350	; je .pppoe	350	; je .pppoe
351		351
352	.no_ppp:	352	.no_ppp:
353	.unsupported:	353	.unsupported:
354	push eax	354	push eax
355	call socket_free	355	call socket_free
356	pop eax	356	pop eax
357	mov dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP	357	mov dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
358	mov dword[esp + SYSCALL_STACK.eax], -1	358	mov dword[esp + SYSCALL_STACK.eax], -1
359	ret	359	ret
360		360
361	.nobuffs:	361	.nobuffs:
362	mov dword[esp + SYSCALL_STACK.ebx], ENOBUFS	362	mov dword[esp + SYSCALL_STACK.ebx], ENOBUFS
363	mov dword[esp + SYSCALL_STACK.eax], -1	363	mov dword[esp + SYSCALL_STACK.eax], -1
364	ret	364	ret
365		365
366	.raw:	366	.raw:
367	test esi, esi ; IP_PROTO_IP	367	test esi, esi ; IP_PROTO_IP
368	jz .raw_ip	368	jz .raw_ip
369		369
370	cmp esi, IP_PROTO_ICMP	370	cmp esi, IP_PROTO_ICMP
371	je .raw_icmp	371	je .raw_icmp
372		372
373	jmp .unsupported	373	jmp .unsupported
374		374
375	align 4	375	align 4
376	.udp:	376	.udp:
377	push eax	377	push eax
378	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue	378	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
379	pop eax	379	pop eax
380		380
381	mov [eax + SOCKET.Protocol], IP_PROTO_UDP	381	mov [eax + SOCKET.Protocol], IP_PROTO_UDP
382	mov [eax + SOCKET.snd_proc], socket_send_udp	382	mov [eax + SOCKET.snd_proc], socket_send_udp
383	mov [eax + SOCKET.rcv_proc], socket_receive_dgram	383	mov [eax + SOCKET.rcv_proc], socket_receive_dgram
384	mov [eax + SOCKET.connect_proc], udp_connect	384	mov [eax + SOCKET.connect_proc], udp_connect
385	ret	385	ret
386		386
387	align 4	387	align 4
388	.tcp:	388	.tcp:
389	mov [eax + SOCKET.Protocol], IP_PROTO_TCP	389	mov [eax + SOCKET.Protocol], IP_PROTO_TCP
390	mov [eax + SOCKET.snd_proc], socket_send_tcp	390	mov [eax + SOCKET.snd_proc], socket_send_tcp
391	mov [eax + SOCKET.rcv_proc], socket_receive_tcp	391	mov [eax + SOCKET.rcv_proc], socket_receive_tcp
392	mov [eax + SOCKET.connect_proc], tcp_connect	392	mov [eax + SOCKET.connect_proc], tcp_connect
393		393
394	tcp_init_socket eax	394	tcp_init_socket eax
395	ret	395	ret
396		396
397		397
398	align 4	398	align 4
399	.raw_ip:	399	.raw_ip:
400	push eax	400	push eax
401	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue	401	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
402	pop eax	402	pop eax
403		403
404	mov [eax + SOCKET.snd_proc], socket_send_ip	404	mov [eax + SOCKET.snd_proc], socket_send_ip
405	mov [eax + SOCKET.rcv_proc], socket_receive_dgram	405	mov [eax + SOCKET.rcv_proc], socket_receive_dgram
406	mov [eax + SOCKET.connect_proc], ipv4_connect	406	mov [eax + SOCKET.connect_proc], ipv4_connect
407	ret	407	ret
408		408
409		409
410	align 4	410	align 4
411	.raw_icmp:	411	.raw_icmp:
412	push eax	412	push eax
413	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue	413	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
414	pop eax	414	pop eax
415		415
416	mov [eax + SOCKET.snd_proc], socket_send_icmp	416	mov [eax + SOCKET.snd_proc], socket_send_icmp
417	mov [eax + SOCKET.rcv_proc], socket_receive_dgram	417	mov [eax + SOCKET.rcv_proc], socket_receive_dgram
418	mov [eax + SOCKET.connect_proc], ipv4_connect	418	mov [eax + SOCKET.connect_proc], ipv4_connect
419	ret	419	ret
420		420
421	;align 4	421	;align 4
422	; .pppoe:	422	; .pppoe:
423	; push eax	423	; push eax
424	; init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue	424	; init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
425	; pop eax	425	; pop eax
426	;	426	;
427	; mov [eax + SOCKET.snd_proc], socket_send_pppoe	427	; mov [eax + SOCKET.snd_proc], socket_send_pppoe
428	; mov [eax + SOCKET.rcv_proc], socket_receive_dgram	428	; mov [eax + SOCKET.rcv_proc], socket_receive_dgram
429	; ret	429	; ret
430		430
431		431
432	;-----------------------------------------------------------------;	432	;-----------------------------------------------------------------;
433	; ;	433	; ;
434	; socket_bind: Bind to a local port. ;	434	; socket_bind: Bind to a local port. ;
435	; ;	435	; ;
436	; IN: ecx = socket number ;	436	; IN: ecx = socket number ;
437	; edx = pointer to sockaddr struct ;	437	; edx = pointer to sockaddr struct ;
438	; esi = length of sockaddr struct ;	438	; esi = length of sockaddr struct ;
439	; ;	439	; ;
440	; OUT: eax = 0 on success ;	440	; OUT: eax = 0 on success ;
441	; eax = -1 on error ;	441	; eax = -1 on error ;
442	; ebx = errorcode on error ;	442	; ebx = errorcode on error ;
443	; ;	443	; ;
444	;-----------------------------------------------------------------;	444	;-----------------------------------------------------------------;
445	align 4	445	align 4
446	socket_bind:	446	socket_bind:
447		447
448	DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi	448	DEBUGF DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
449		449
450	call socket_num_to_ptr	450	call socket_num_to_ptr
451	test eax, eax	451	test eax, eax
452	jz .invalid	452	jz .invalid
453		453
454	cmp esi, 2	454	cmp esi, 2
455	jb .invalid	455	jb .invalid
456		456
457	cmp [eax + UDP_SOCKET.LocalPort], 0 ; Socket can only be bound once	457	cmp [eax + UDP_SOCKET.LocalPort], 0 ; Socket can only be bound once
458	jnz .invalid	458	jnz .invalid
459		459
460	cmp word[edx], AF_INET4	460	cmp word[edx], AF_INET4
461	je .af_inet4	461	je .af_inet4
462		462
463	cmp word[edx], AF_LOCAL	463	cmp word[edx], AF_LOCAL
464	je .af_local	464	je .af_local
465		465
466	.notsupp:	466	.notsupp:
467	mov dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP	467	mov dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
468	mov dword[esp + SYSCALL_STACK.eax], -1	468	mov dword[esp + SYSCALL_STACK.eax], -1
469	ret	469	ret
470		470
471	.invalid:	471	.invalid:
472	mov dword[esp + SYSCALL_STACK.ebx], EINVAL	472	mov dword[esp + SYSCALL_STACK.ebx], EINVAL
473	mov dword[esp + SYSCALL_STACK.eax], -1	473	mov dword[esp + SYSCALL_STACK.eax], -1
474	ret	474	ret
475		475
476	.af_local:	476	.af_local:
477	; TODO: write code here	477	; TODO: write code here
478	mov dword[esp + SYSCALL_STACK.eax], 0	478	mov dword[esp + SYSCALL_STACK.eax], 0
479	ret	479	ret
480		480
481	.af_inet4:	481	.af_inet4:
482	cmp esi, 6	482	cmp esi, 6
483	jb .invalid	483	jb .invalid
484		484
485	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP	485	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
486	je .udp	486	je .udp
487		487
488	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP	488	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP
489	je .tcp	489	je .tcp
490		490
491	jmp .notsupp	491	jmp .notsupp
492		492
493	.tcp:	493	.tcp:
494	.udp:	494	.udp:
495	pushd [edx + 4] ; First, fill in the IP	495	pushd [edx + 4] ; First, fill in the IP
496	popd [eax + IP_SOCKET.LocalIP]	496	popd [eax + IP_SOCKET.LocalIP]
497		497
498	mov bx, [edx + 2] ; Did caller specify a local port?	498	mov bx, [edx + 2] ; Did caller specify a local port?
499	test bx, bx	499	test bx, bx
500	jnz .just_check	500	jnz .just_check

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/socket.inc @ 8027 – Rev 9976 → 9993