WebSVN – Kolibri OS – Diff – /kernel/branches/net/network/socket.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                                 ;;
;; Copyright (C) KolibriOS team 2004-2012. 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: 2924 $
 
 
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 ? ; application process id
        Domain                  dd ? ; INET/UNIX/..
        Type                    dd ? ; RAW/STREAM/DGRAP
        Protocol                dd ? ; ICMP/IPv4/ARP/TCP/UDP
        errorcode               dd ?
        device                  dd ?
 
        options                 dd ?
        state                   dd ?
        backlog                 dw ? ; how many incomming connections that can be queued
 
        snd_proc                dd ?
        rcv_proc                dd ?
 
ends
 
struct  IP_SOCKET               SOCKET
 
        LocalIP                 rd 4
        RemoteIP                rd 4
 
ends
 
struct  TCP_SOCKET              IP_SOCKET
 
        LocalPort               dw ?
        RemotePort              dw ?
 
        t_state                 dd ? ; TCB state
        t_rxtshift              dd ?
        t_rxtcur                dd ?
        t_dupacks               dd ?
        t_maxseg                dd ?
        t_force                 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 ? ; window minus one
        SND_WL2                 dd ? ;
        ISS                     dd ? ; initial send sequence number
        SND_WND                 dd ? ; send window
 
; receive sequence
        RCV_WND                 dw ? ; 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 ?
        SND_SSTHRESH            dd ?
 
;----------------------
; Transmit timing stuff
        t_idle                  dd ?
        t_rtt                   dd ?
        t_rtseq                 dd ?
        t_srtt                  dd ?
        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_retransmission    dw ? ; rexmt
        timer_persist           dw ?
        timer_keepalive         dw ? ; keepalive/syn timeout
        timer_timed_wait        dw ? ; also used as 2msl timer
 
; extra
 
        sendalot                db ? ; also used as 'need output'
        ts_ecr                  dd ? ; timestamp echo reply
 
ends
 
struct  UDP_SOCKET              IP_SOCKET
 
        LocalPort               dw ?
        RemotePort              dw ?
        firstpacket             db ?
 
ends
 
 
struct  ICMP_SOCKET             IP_SOCKET
 
        Identifier              dw ?
 
ends
 
 
struct  RING_BUFFER
 
        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  socket_queue_entry
 
        data_ptr                dd ?
        buf_ptr                 dd ?
        data_size               dd ?
 
ends
 
 
SOCKETBUFFSIZE          = 4096     ; in bytes
 
SOCKET_QUEUE_SIZE       = 10       ; maximum number ofincoming 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   = (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)
 
uglobal
        net_sockets     rd 4
        last_socket_num dd ?
        last_UDP_port   dw ? ; These values give the number of the last used ephemeral port
        last_TCP_port   dw ? ;
endg
 
 
;-----------------------------------------------------------------
;
; SOCKET_init
;
;-----------------------------------------------------------------
macro   SOCKET_init {
 
        xor     eax, eax
        mov     edi, net_sockets
        mov     ecx, 5
        rep     stosd
 
       @@:
        pseudo_random eax
        cmp     ax, MIN_EPHEMERAL_PORT
        jb      @r
        cmp     ax, MAX_EPHEMERAL_PORT
        ja      @r
        mov     [last_UDP_port], ax
 
       @@:
        pseudo_random eax
        cmp     ax, MIN_EPHEMERAL_PORT
        jb      @r
        cmp     ax, MAX_EPHEMERAL_PORT
        ja      @r
        mov     [last_TCP_port], ax
 
}
 
 
;-----------------------------------------------------------------
;
; Socket API (function 74)
;
;-----------------------------------------------------------------
align 4
sys_socket:
 
        cmp     ebx, 255
        jz      SOCKET_debug
 
        cmp     ebx, .number
        ja      s_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
  .number = ($ - .table) / 4 - 1
 
s_error:
        DEBUGF  1,"socket error\n"
        mov     dword [esp+32], -1
 
        ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_open
;
;  IN:  domain in ecx
;       type in edx
;       protocol in esi
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_open:
 
        DEBUGF  1,"SOCKET_open: domain=%u type=%u protocol=%x\n", ecx, edx, esi
 
        push    ecx edx esi
        call    SOCKET_alloc
        pop     esi edx ecx
        jz      s_error
 
        mov     [esp+32], edi                   ; return socketnumber
 
        mov     [eax + SOCKET.Domain], ecx
        mov     [eax + SOCKET.Type], edx
        mov     [eax + SOCKET.Protocol], esi
 
        cmp     ecx, AF_INET4
        jne     .no_inet4
 
        cmp     edx, SOCK_DGRAM
        je      .udp
 
        cmp     edx, SOCK_STREAM
        je      .tcp
 
        cmp     edx, SOCK_RAW
        je      .raw
 
  .no_inet4:
        ret
 
align 4
  .raw:
        test    esi, esi       ; IP_PROTO_IP
        jz      .ip
 
        cmp     esi, IP_PROTO_ICMP
        je      .icmp
 
        cmp     esi, IP_PROTO_UDP
        je      .udp
 
        cmp     esi, IP_PROTO_TCP
        je      .tcp
 
        ret
 
align 4
  .udp:
        mov     [eax + SOCKET.Protocol], IP_PROTO_UDP
        mov     [eax + SOCKET.snd_proc], SOCKET_send_udp
        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
        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
 
        TCP_init_socket eax
        ret
 
 
align 4
  .ip:
        mov     [eax + SOCKET.snd_proc], SOCKET_send_ip
        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
        ret
 
 
align 4
  .icmp:
        mov     [eax + SOCKET.snd_proc], SOCKET_send_icmp
        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
        ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_bind
;
;  IN:  socket number in ecx
;       pointer to sockaddr struct in edx
;       length of that struct in esi
;  OUT: 0 on success
;
;-----------------------------------------------------------------
align 4
SOCKET_bind:
 
        DEBUGF  1,"SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        cmp     esi, 2
        jb      s_error
 
        cmp     word [edx], AF_INET4
        je      .af_inet4
 
        cmp     word [edx], AF_UNIX
        je      .af_unix
 
        jmp     s_error
 
  .af_unix:
        ; TODO: write code here
 
        mov     dword [esp+32], 0
        ret
 
  .af_inet4:
 
        cmp     esi, 6
        jb      s_error
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
        je      .udp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        je      .tcp
 
        jmp     s_error
 
  .tcp:
  .udp:
 
        mov     ebx, [edx + 4]                  ; First, fill in the IP
        test    ebx, ebx                        ; If IP is 0, use default
        jnz     @f
        mov     ebx, [NET_DEFAULT]
        mov     ebx, [IP_LIST + 4*ebx]
       @@:
        mov     [eax + IP_SOCKET.LocalIP], ebx
 
        mov     bx, [edx + 2]                   ; Now fill in the port if it's still available
        call    SOCKET_check_port
        jz      s_error                         ; ZF is set by socket_check_port, on error
 
        DEBUGF  1,"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+32], 0
        ret
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_connect
;
;  IN:  socket number in ecx
;       pointer to sockaddr struct in edx
;       length of that struct in esi
;  OUT: 0 on success
;
;-----------------------------------------------------------------
align 4
SOCKET_connect:
 
        DEBUGF  1,"SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        cmp     esi, 8
        jb      s_error
 
        cmp     word [edx], AF_INET4
        je      .af_inet4
 
        jmp     s_error
 
  .af_inet4:
        cmp     [eax + IP_SOCKET.LocalIP], 0
        jne     @f
        push    [IP_LIST]
        pop     [eax + IP_SOCKET.LocalIP]
       @@:
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
        je      .udp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        je      .tcp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_IP
        je      .ip
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_ICMP
        je      .ip
 
        jmp     s_error
 
align 4
  .udp:
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_lock
        popa
 
        pushw   [edx + 2]
        pop     [eax + UDP_SOCKET.RemotePort]
 
        pushd   [edx + 4]
        pop     [eax + IP_SOCKET.RemoteIP]
 
        cmp     [eax + UDP_SOCKET.LocalPort], 0
        jne     @f
        call    SOCKET_find_port
       @@:
 
        mov     [eax + UDP_SOCKET.firstpacket], 0
 
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
        pop     eax
 
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
 
        mov     dword [esp+32], 0
        ret
 
align 4
  .tcp:
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_lock
        popa
 
        pushw   [edx + 2]
        pop     [eax + TCP_SOCKET.RemotePort]
 
        pushd   [edx + 4]
        pop     [eax + IP_SOCKET.RemoteIP]
 
        cmp     [eax + TCP_SOCKET.LocalPort], 0
        jne     @f
        call    SOCKET_find_port
       @@:
 
        mov     [eax + TCP_SOCKET.timer_persist], 0
        mov     [eax + TCP_SOCKET.t_state], TCPS_SYN_SENT
 
        push    [TCP_sequence_num]
        add     [TCP_sequence_num], 6400
        pop     [eax + TCP_SOCKET.ISS]
        mov     [eax + TCP_SOCKET.timer_keepalive], TCP_time_keep_init
 
 
        TCP_sendseqinit eax
 
;        mov     [ebx + TCP_SOCKET.timer_retransmission],   ;; todo: create macro to set retransmission timer
 
        mov     ebx, eax
 
        lea     eax, [ebx + STREAM_SOCKET.snd]
        call    SOCKET_ring_create
 
        lea     eax, [ebx + STREAM_SOCKET.rcv]
        call    SOCKET_ring_create
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        mov     eax, ebx
        call    TCP_output
 
        mov     dword [esp+32], 0
        ret
 
align 4
  .ip:
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_lock
        popa
 
        pushd   [edx + 4]
        pop     [eax + IP_SOCKET.RemoteIP]
 
        push    eax
        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
        pop     eax
 
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
 
        mov     dword [esp+32], 0
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_listen
;
;  IN:  socket number in ecx
;       backlog in edx
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_listen:
 
        DEBUGF  1,"SOCKET_listen: socknum=%u backlog=%u\n", ecx, edx
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     s_error
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jne     s_error
 
        cmp     [eax + TCP_SOCKET.LocalPort], 0
        je      s_error
 
        cmp     [eax + IP_SOCKET.LocalIP], 0
        jne     @f
        push    [IP_LIST]
        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+32], 0
 
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_accept
;
;  IN:  socket number in ecx
;       addr in edx
;       addrlen in esi
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_accept:
 
        DEBUGF  1,"SOCKET_accept: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        test    [eax + SOCKET.options], SO_ACCEPTCON
        jz      s_error
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     s_error
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jne     s_error
 
        get_from_queue (eax + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, s_error
        mov     eax, [esi]
 
; Change PID to that of the current process
        mov     ebx, [TASK_BASE]
        mov     ebx, [ebx + TASKDATA.pid]
        mov     [eax + SOCKET.PID], ebx
 
        call    SOCKET_ptr_to_num
        jz      s_error
        mov     [esp+32], eax
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_close
;
;  IN:  socket number in ecx
;  OUT: eax is socket num, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_close:
 
        DEBUGF  1,"SOCKET_close: %u\n", ecx
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        cmp     [eax + SOCKET.Domain], AF_INET4
        jne     s_error
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
        je      .free
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_ICMP
        je      .free
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_IP
        je      .free
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        je      .tcp
 
        jmp     s_error
 
  .tcp:
        cmp     [eax + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED    ; state must be LISTEN, SYN_SENT or CLOSED
        jb      .free
 
        call    TCP_usrclosed
        call    TCP_output      ;;;; Fixme: is this nescessary??
        mov     dword [esp+32], 0
 
        ret
 
  .free:
        call    SOCKET_free
        mov     dword [esp+32], 0
 
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_receive
;
;  IN:  socket number in ecx
;       addr to buffer in edx
;       length of buffer in esi
;       flags in edi
;  OUT: eax is number of bytes copied, -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_receive:
 
        DEBUGF  1,"SOCKET_receive: socknum=%u bufaddr=%x buflength=%u flags=%x\n", ecx, edx, esi, edi
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        jmp     [eax + SOCKET.rcv_proc]
 
 
align 4
SOCKET_receive_dgram:
 
        DEBUGF  1,"SOCKET_receive: DGRAM\n"
 
        mov     ebx, esi
        mov     edi, edx                                        ; addr to buffer
 
        get_from_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, s_error       ; destroys esi and ecx
 
        mov     ecx, [esi + socket_queue_entry.data_size]
        DEBUGF  1,"SOCKET_receive: %u bytes data\n", ecx
 
        cmp     ecx, ebx
        ja      .too_small
 
        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  1,"SOCKET_receive: Source buffer=%x real addr=%x\n", [esp], esi
        mov     [esp+32+4], ecx                                 ; return number of bytes copied
 
; copy the data
        shr     ecx, 1
        jnc     .nb
        movsb
  .nb:
        shr     ecx, 1
        jnc     .nw
        movsw
  .nw:
        test    ecx, ecx
        jz      .nd
        rep     movsd
  .nd:
 
        call    kernel_free                                     ; remove the packet
        ret
 
  .too_small:
 
        DEBUGF  1,"SOCKET_receive: Buffer too small\n"
        jmp     s_error
 
align 4
SOCKET_receive_tcp:
 
        DEBUGF  1,"SOCKET_receive: TCP\n"
 
        mov     ecx, esi
        mov     edi, edx
        add     eax, STREAM_SOCKET.rcv
        xor     edx, edx
        call    SOCKET_ring_read
        call    SOCKET_ring_free
 
        mov     [esp+32], ecx                                   ; return number of bytes copied
 
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_send
;
;
;  IN:  socket number in ecx
;       pointer to data in edx
;       datalength in esi
;       flags in edi
;  OUT: -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_send:
 
        DEBUGF  1,"SOCKET_send: socknum=%u data ptr=%x length=%u flags=%x\n", ecx, edx, esi, edi
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        mov     ecx, esi
        mov     esi, edx
 
        jmp     [eax + SOCKET.snd_proc]
 
 
align 4
SOCKET_send_udp:
 
        DEBUGF  1,"SOCKET_send: UDP\n"
 
        mov     [esp+32], ecx
        call    UDP_output
        cmp     eax, -1
        je      s_error
        ret
 
 
align 4
SOCKET_send_tcp:
 
        DEBUGF  1,"SOCKET_send: TCP\n"
 
        push    eax
        add     eax, STREAM_SOCKET.snd
        call    SOCKET_ring_write
        pop     eax
 
        mov     [esp+32], ecx
 
        call    TCP_output
        ret
 
 
align 4
SOCKET_send_ip:
 
        DEBUGF  1,"SOCKET_send: IPv4\n"
 
        mov     [esp+32], ecx
        call    IPv4_output_raw
        cmp     eax, -1
        je      s_error
        ret
 
 
align 4
SOCKET_send_icmp:
 
        DEBUGF  1,"SOCKET_send: ICMP\n"
 
        mov     [esp+32], ecx
        call    ICMP_output_raw
        cmp     eax, -1
        je      s_error
        ret
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_get_options
;
;  IN:  ecx = socket number
;       edx = pointer to the options:
;               dd      level, optname, optval, optlen
;  OUT: -1 on error
;
; 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_*.
;
;-----------------------------------------------------------------
align 4
SOCKET_get_opt:
 
        DEBUGF  1,"SOCKET_get_opt\n"
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        cmp     dword [edx], IP_PROTO_TCP
        jne     s_error
        cmp     dword [edx+4], -2
        je      @f
        cmp     dword [edx+4], -3
        jne     s_error
@@:
;        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+32], 0
        ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_set_options
;
;  IN:  ecx = socket number
;       edx = pointer to the options:
;               dd      level, optname, optlen, optval
;  OUT: -1 on error
;
;-----------------------------------------------------------------
align 4
SOCKET_set_opt:
 
        DEBUGF  1,"SOCKET_set_opt\n"
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        cmp     dword [edx], SOL_SOCKET
        jne     s_error
 
        cmp     dword [edx+4], SO_BINDTODEVICE
        je      .bind
 
        jmp     s_error
 
  .bind:
        cmp     dword [edx+8], 0
        je      .unbind
 
        movzx   edx, byte [edx + 9]
        cmp     edx, MAX_NET_DEVICES
        ja      s_error
 
        mov     edx, [NET_DRV_LIST + 4*edx]
        test    edx, edx
        jz      s_error
        mov     [eax + SOCKET.device], edx
 
        DEBUGF  1,"SOCKET_set_opt: Bound socket %x to device %x\n",eax, edx
 
        mov     dword [esp+32], 0       ; success!
        ret
 
  .unbind:
        mov     [eax + SOCKET.device], 0
 
        mov     dword [esp+32], 0       ; success!
        ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_debug
;
;  Copies socket variables to application buffer
;
;  IN:  ecx = socket number
;       edx = pointer to buffer
;
;  OUT: -1 on error
;-----------------------------------------------------------------
align 4
SOCKET_debug:
 
        DEBUGF  1,"SOCKET_debug\n"
 
        call    SOCKET_num_to_ptr
        jz      s_error
 
        mov     esi, eax
        mov     edi, edx
        mov     ecx, SOCKETBUFFSIZE/4
        rep     movsd
 
        mov     dword [esp+32], 0
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_find_port
;
; Fills 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  1,"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
 
        jmp     .error
 
  .done:
        mov     [eax + UDP_SOCKET.LocalPort], bx
  .error:
        pop     ecx esi ebx
        ret
 
  .udp:
        mov     bx, [last_UDP_port]
        call    .findit
        mov     [last_UDP_port], bx
        jmp     .done
 
  .tcp:
        mov     bx, [last_TCP_port]
        call    .findit
        mov     [last_TCP_port], bx
        jmp     .done
 
 
  .restart:
        mov     bx, MIN_EPHEMERAL_PORT
  .findit:
        inc     bx
 
        cmp     bx, MAX_EPHEMERAL_PORT
        jz      .restart
 
        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 (to find out if its a TCP/UDP socket)
;        bx = proposed socket number
;
;  OUT:  ZF = cleared on error
;
;-----------------------------------------------------------------
align 4
SOCKET_check_port:
 
        DEBUGF  1,"SOCKET_check_port: "
 
        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
 
        DEBUGF  1,"local port %u already in use\n", bx
        ret
 
  .port_ok:
        DEBUGF  1,"local port %u is free\n", bx
        mov     [eax + UDP_SOCKET.LocalPort], bx
        or      bx, bx                                  ; set the zero-flag
 
        ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_input
;
; Updates a (stateless) socket with received data
;
; Note: the mutex should already be set !
;
;  IN:  eax = socket ptr
;       ebx = pointer to device struct
;       ecx = data size
;       esi = ptr to data
;       [esp] = ptr to buf
;       [esp + 4] = buf size
;
;  OUT: /
;
;-----------------------------------------------------------------
align 4
SOCKET_input:
 
        DEBUGF  1,"SOCKET_input: socket=%x, data=%x size=%u\n", eax, esi, ecx
 
        mov     [esp+4], ecx
        push    esi
        mov     esi, esp
 
        add_to_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, SOCKET_input.full
 
        DEBUGF  1,"SOCKET_input: queued packet successfully\n"
        add     esp, sizeof.socket_queue_entry
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        jmp     SOCKET_notify_owner
 
  .full:
        DEBUGF  2,"SOCKET_input: socket %x is full!\n", eax
 
        pusha
        lea     ecx, [eax + SOCKET.mutex]
        call    mutex_unlock
        popa
 
        call    kernel_free
        add     esp, 8
 
        ret
 
 
;--------------------------
;
; eax = ptr to ring struct (just a buffer of the right size)
;
align 4
SOCKET_ring_create:
 
        push    esi
        mov     esi, eax
 
        push    edx
        stdcall create_ring_buffer, SOCKET_MAXDATA, PG_SW
        pop     edx
 
        DEBUGF  1,"SOCKET_ring_created: %x\n", eax
        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_MAXDATA
        mov     [esi + RING_BUFFER.end_ptr], eax
        mov     eax, esi
        pop     esi
 
        ret
 
;-----------------------------------------------------------------
;
; SOCKET_ring_write
;
; Adds data to a stream socket, and updates write pointer and size
;
;  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  1,"SOCKET_ring_write: ringbuff=%x ptr=%x size=%u\n", eax, esi, ecx
 
        add     [eax + RING_BUFFER.size], ecx
        jc      .way_too_large
        cmp     [eax + RING_BUFFER.size], SOCKET_MAXDATA
        ja      .too_large
 
  .copy:
        mov     edi, [eax + RING_BUFFER.write_ptr]
        DEBUGF  2,"SOCKET_ring_write: %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
 
        cmp     edi, [eax + RING_BUFFER.end_ptr]
        jae     .wrap
        mov     [eax + RING_BUFFER.write_ptr], edi
 
        ret
 
  .wrap:
        sub     edi, SOCKET_MAXDATA
        mov     [eax + RING_BUFFER.write_ptr], edi
 
        ret
 
  .too_large:                                                           ; update size, we will fill buffer completely
        sub     [eax + RING_BUFFER.size], SOCKET_MAXDATA
        sub     ecx, [eax + RING_BUFFER.size]
        mov     [eax + RING_BUFFER.size], SOCKET_MAXDATA
        ja      .copy
 
  .full:
        DEBUGF  2,"SOCKET_ring_write: ring buffer is full!\n"
        xor     ecx, ecx
        ret
 
  .way_too_large:
        sub     [eax + RING_BUFFER.size], ecx
        mov     ecx, SOCKET_MAXDATA
        sub     ecx, [eax + RING_BUFFER.size]
        ja      .copy
        jmp     .full
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_ring_read
;
;  IN:  eax = ring struct ptr
;       ecx = bytes to read
;       edx = offset
;       edi = ptr to buffer
;
;  OUT: ecx = number of bytes read (0 on error)
;
;-----------------------------------------------------------------
align 4
SOCKET_ring_read:
 
        DEBUGF  1,"SOCKET_ring_read: ringbuff=%x ptr=%x size=%u offset=%x\n", eax, edi, ecx, edx
 
        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
 
        cmp     ecx, edx
        ja      .less_data
 
  .copy:
        DEBUGF  2,"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:
        DEBUGF  1,"SOCKET_ring_read: no data at all!\n"
        ret
 
  .less_data:
        mov     ecx, edx
        jmp     .copy
 
 
;-----------------------------------------------------------------
;
; SOCKET_ring_free
;
; Free's some bytes from the ringbuffer
;
;  IN:  eax = ptr to ring struct
;       ecx = data size
;
;  OUT: ecx = number of bytes free-ed
;
;-----------------------------------------------------------------
align 4
SOCKET_ring_free:
 
        DEBUGF  1,"SOCKET_ring_free: %u bytes from ring %x\n", 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_MAXDATA
       @@:
        ret
 
  .error:       ; we could free all available bytes, but that would be stupid, i guess..
        DEBUGF  1,"SOCKET_ring_free: buffer=%x error!\n", eax
        add     [eax + RING_BUFFER.size], ecx
        xor     ecx, ecx
        ret
 
 
;-----------------------------------------------------------------
;
; SOCKET_notify_owner
;
; notify's the owner of a socket that something happened
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
align 4
SOCKET_notify_owner:
 
        DEBUGF  1,"SOCKET_notify_owner: %x\n", eax
 
        call    SOCKET_check
        jz      .error
 
        push    eax ecx esi
 
; socket exists, now try to flag an event to the application
 
        mov     eax, [eax + SOCKET.PID]
        test    eax, eax
        jz      .error2
        mov     ecx, 1
        mov     esi, TASK_DATA + TASKDATA.pid
 
       .next_pid:
        cmp     [esi], eax
        je      .found_pid
        inc     ecx
        add     esi, 0x20
        cmp     ecx, [TASK_COUNT]
        jbe     .next_pid
 
; PID not found, TODO: close socket!
 
        jmp     .error2
 
       .found_pid:
        shl     ecx, 8
        or      [ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK
        mov     [check_idle_semaphore], 200
 
        DEBUGF  1,"SOCKET_notify_owner: succes!\n"
 
  .error2:
        pop     esi ecx eax
 
  .error:
 
        ret
 
 
;--------------------------------------------------------------------
;
; SOCKET_alloc
;
; Allocate memory for socket data and put new socket into the list
; Newly created socket is initialized with calling PID and number and
; put into beginning of list (which is a fastest way).
;
; IN:  /
; OUT: eax = 0 on error, socket ptr otherwise
;      edi = socket number
;       ZF = cleared on error
;
;--------------------------------------------------------------------
align 4
SOCKET_alloc:
 
        push    ebx
 
        stdcall kernel_alloc, SOCKETBUFFSIZE
        DEBUGF  1, "SOCKET_alloc: ptr=%x\n", eax
        or      eax, eax
        jz      .exit
 
; zero-initialize allocated memory
        push    eax
        mov     edi, eax
        mov     ecx, SOCKETBUFFSIZE / 4
        xor     eax, eax
        rep     stosd
        pop     eax
 
; set send-and receive procedures to return -1
        mov     [eax + SOCKET.snd_proc], s_error
        mov     [eax + SOCKET.rcv_proc], s_error
 
; 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  1, "SOCKET_alloc: number=%u\n", edi
 
; Fill in PID
        mov     ebx, [TASK_BASE]
        mov     ebx, [ebx + TASKDATA.pid]
        mov     [eax + SOCKET.PID], ebx
 
; 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
        or      eax, eax                ; used to clear zero flag
  .exit:
        pop     ebx
 
        ret
 
 
;----------------------------------------------------
;
; SOCKET_free
;
; Free socket data memory and remove socket from the list
;
; IN:  eax = socket ptr
; OUT: /
;
;----------------------------------------------------
align 4
SOCKET_free:
 
        DEBUGF  1, "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.Domain], AF_INET4
        jnz     .no_tcp
 
        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
        jnz     .no_tcp
 
        mov     ebx, eax
        stdcall kernel_free, [ebx + STREAM_SOCKET.rcv.start_ptr]
        stdcall kernel_free, [ebx + STREAM_SOCKET.snd.start_ptr]
        mov     eax, ebx
  .no_tcp:
 
        push    eax                             ; this will be passed to kernel_free
        mov     ebx, [eax + SOCKET.NextPtr]
        mov     eax, [eax + SOCKET.PrevPtr]
 
        DEBUGF  1, "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  1, "SOCKET_free: success!\n"
 
  .error:
        ret
 
;------------------------------------
;
; SOCKET_fork
;
; Create a child socket
;
; IN:  socket nr in ebx
; OUT: child socket nr in eax
;
;-----------------------------------
align 4
SOCKET_fork:
 
        DEBUGF  1,"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
        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, and the 2 pointers at beginning of socket
        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
 
        ret
 
  .fail2:
        add     esp, 4+4+4
  .fail:
        DEBUGF  1,"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 = 0 on error, socket ptr otherwise
;       ZF = set on error
;
;---------------------------------------------------
align 4
SOCKET_num_to_ptr:
 
        DEBUGF  1,"SOCKET_num_to_ptr: num=%u ", ecx
 
        mov     eax, net_sockets
 
  .next_socket:
        mov     eax, [eax + SOCKET.NextPtr]
        or      eax, eax
        jz      .error
        cmp     [eax + SOCKET.Number], ecx
        jne     .next_socket
 
        test    eax, eax
 
        DEBUGF  1,"ptr=%x\n", eax
        ret
 
  .error:
        DEBUGF  1,"not found\n", eax
        ret
 
 
;---------------------------------------------------
;
; SOCKET_ptr_to_num
;
; Get socket number by its address
;
; IN:  eax = socket ptr
; OUT: eax = 0 on error, socket num otherwise
;       ZF = set on error
;
;---------------------------------------------------
align 4
SOCKET_ptr_to_num:
 
        DEBUGF  1,"SOCKET_ptr_to_num: ptr=%x ", eax
 
        call    SOCKET_check
        jz      .error
 
        mov     eax, [eax + SOCKET.Number]
 
        DEBUGF  1,"num=%u\n", eax
        ret
 
  .error:
        DEBUGF  1,"not found\n", eax
        ret
 
 
;---------------------------------------------------
;
; SOCKET_check
;
; checks if the given value is really a socket ptr
;
; IN:  eax = socket ptr
; OUT: eax = 0 on error, unchanged otherwise
;       ZF = set on error
;
;---------------------------------------------------
align 4
SOCKET_check:
 
        DEBUGF  1,"SOCKET_check: %x\n", eax
 
        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
 
 
 
;---------------------------------------------------
;
; SOCKET_check_owner
;
; checks if the caller application owns the socket
;
; IN:  eax = socket ptr
; OUT:  ZF = true/false
;
;---------------------------------------------------
align 4
SOCKET_check_owner:
 
        DEBUGF  1,"SOCKET_check_owner: %x\n", eax
 
        push    ebx
        mov     ebx, [TASK_BASE]
        mov     ebx, [ecx + TASKDATA.pid]
        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
;
; IN:  edx = pid
; OUT: /
;
;------------------------------------------------------
align 4
SOCKET_process_end:
 
        DEBUGF  1,"SOCKET_process_end: %x\n", edx
 
        push    ebx
        mov     ebx, net_sockets
 
  .next_socket:
        mov     ebx, [ebx + SOCKET.NextPtr]
  .test_socket:
        test    ebx, ebx
        jz      .done
 
        cmp     [ebx + SOCKET.PID], edx
        jne     .next_socket
 
        DEBUGF  1,"SOCKET_process_end: killing socket %x\n", ebx
 
        mov     [ebx + SOCKET.PID], 0
 
        cmp     [ebx + SOCKET.Protocol], IP_PROTO_TCP
        je      .tcp
 
; The socket is stateless, just kill it right away!
 
        mov     eax, ebx
        mov     ebx, [ebx + SOCKET.NextPtr]
        call    SOCKET_free
        jmp     .test_socket
 
  .tcp:
        push    [ebx + SOCKET.NextPtr]
        mov     eax, ebx
        call    TCP_disconnect
        pop     ebx
        jmp     .test_socket
 
  .done:
        pop     ebx
 
        ret
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_connecting
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_connecting:
 
        DEBUGF  1,"SOCKET_is_connecting: %x\n", eax
 
        and     [eax + SOCKET.options], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
        or      [eax + SOCKET.options], SS_ISCONNECTING
 
        jmp     SOCKET_notify_owner
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_connected
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_connected:
 
        DEBUGF  1,"SOCKET_is_connected: %x\n", eax
 
        and     [eax + SOCKET.options], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING)
        or      [eax + SOCKET.options], SS_ISCONNECTED
 
        jmp     SOCKET_notify_owner
 
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_disconnecting
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_disconnecting:
 
        DEBUGF  1,"SOCKET_is_disconnecting: %x\n", eax
 
        and     [eax + SOCKET.options], not (SS_ISCONNECTING)
        or      [eax + SOCKET.options], SS_ISDISCONNECTING + SS_CANTRCVMORE + SS_CANTSENDMORE
 
        jmp     SOCKET_notify_owner
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_is_disconnected
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_is_disconnected:
 
        DEBUGF  1,"SOCKET_is_disconnected: %x\n", eax
 
        and     [eax + SOCKET.options], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
        or      [eax + SOCKET.options], SS_CANTRCVMORE + SS_CANTSENDMORE
 
        jmp     SOCKET_notify_owner
 
 
;-----------------------------------------------------------------
;
; SOCKET_cant_recv_more
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_cant_recv_more:
 
        DEBUGF  1,"SOCKET_cant_recv_more: %x\n", eax
 
        or      [eax + SOCKET.options], SS_CANTRCVMORE
 
        ret
 
 
 
;-----------------------------------------------------------------
;
; SOCKET_cant_send_more
;
;  IN:  eax = socket ptr
;  OUT: /
;
;-----------------------------------------------------------------
 
align 4
SOCKET_cant_send_more:
 
        DEBUGF  1,"SOCKET_cant_send_more: %x\n", eax
 
        or      [eax + SOCKET.options], SS_CANTSENDMORE
 
        ret

Rev 2894	Rev 2924
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2012. 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: 2894 $	18	$Revision: 2924 $
19		19
20		20
21	struct SOCKET	21	struct SOCKET
22		22
23	NextPtr dd ? ; pointer to next socket in list	23	NextPtr dd ? ; pointer to next socket in list
24	PrevPtr dd ? ; pointer to previous socket in list	24	PrevPtr dd ? ; pointer to previous socket in list
25	Number dd ? ; socket number	25	Number dd ? ; socket number
26		26
27	mutex MUTEX	27	mutex MUTEX
28		28
29	PID dd ? ; application process id	29	PID dd ? ; application process id
30	Domain dd ? ; INET/UNIX/..	30	Domain dd ? ; INET/UNIX/..
31	Type dd ? ; RAW/STREAM/DGRAP	31	Type dd ? ; RAW/STREAM/DGRAP
32	Protocol dd ? ; ICMP/IPv4/ARP/TCP/UDP	32	Protocol dd ? ; ICMP/IPv4/ARP/TCP/UDP
33	errorcode dd ?	33	errorcode dd ?
34	device dd ?	34	device dd ?
35		35
36	options dd ?	36	options dd ?
37	state dd ?	37	state dd ?
38	backlog dw ? ; how many incomming connections that can be queued	38	backlog dw ? ; how many incomming connections that can be queued
39		39
40	snd_proc dd ?	40	snd_proc dd ?
41	rcv_proc dd ?	41	rcv_proc dd ?
42		42
43	ends	43	ends
44		44
45	struct IP_SOCKET SOCKET	45	struct IP_SOCKET SOCKET
46		46
47	LocalIP rd 4	47	LocalIP rd 4
48	RemoteIP rd 4	48	RemoteIP rd 4
49		49
50	ends	50	ends
51		51
52	struct TCP_SOCKET IP_SOCKET	52	struct TCP_SOCKET IP_SOCKET
53		53
54	LocalPort dw ?	54	LocalPort dw ?
55	RemotePort dw ?	55	RemotePort dw ?
56		56
57	t_state dd ? ; TCB state	57	t_state dd ? ; TCB state
58	t_rxtshift dd ?	58	t_rxtshift dd ?
59	t_rxtcur dd ?	59	t_rxtcur dd ?
60	t_dupacks dd ?	60	t_dupacks dd ?
61	t_maxseg dd ?	61	t_maxseg dd ?
62	t_force dd ?	62	t_force dd ?
63	t_flags dd ?	63	t_flags dd ?
64		64
65	;---------------	65	;---------------
66	; RFC783 page 21	66	; RFC783 page 21
67		67
68	; send sequence	68	; send sequence
69	SND_UNA dd ? ; sequence number of unack'ed sent Packets	69	SND_UNA dd ? ; sequence number of unack'ed sent Packets
70	SND_NXT dd ? ; next send sequence number to use	70	SND_NXT dd ? ; next send sequence number to use
71	SND_UP dd ? ; urgent pointer	71	SND_UP dd ? ; urgent pointer
72	SND_WL1 dd ? ; window minus one	72	SND_WL1 dd ? ; window minus one
73	SND_WL2 dd ? ;	73	SND_WL2 dd ? ;
74	ISS dd ? ; initial send sequence number	74	ISS dd ? ; initial send sequence number
75	SND_WND dd ? ; send window	75	SND_WND dd ? ; send window
76		76
77	; receive sequence	77	; receive sequence
78	RCV_WND dw ? ; receive window	78	RCV_WND dw ? ; receive window
79	RCV_NXT dd ? ; next receive sequence number to use	79	RCV_NXT dd ? ; next receive sequence number to use
80	RCV_UP dd ? ; urgent pointer	80	RCV_UP dd ? ; urgent pointer
81	IRS dd ? ; initial receive sequence number	81	IRS dd ? ; initial receive sequence number
82		82
83	;---------------------	83	;---------------------
84	; Additional variables	84	; Additional variables
85		85
86	; receive variables	86	; receive variables
87	RCV_ADV dd ?	87	RCV_ADV dd ?
88		88
89	; retransmit variables	89	; retransmit variables
90	SND_MAX dd ?	90	SND_MAX dd ?
91		91
92	; congestion control	92	; congestion control
93	SND_CWND dd ?	93	SND_CWND dd ?
94	SND_SSTHRESH dd ?	94	SND_SSTHRESH dd ?
95		95
96	;----------------------	96	;----------------------
97	; Transmit timing stuff	97	; Transmit timing stuff
98	t_idle dd ?	98	t_idle dd ?
99	t_rtt dd ?	99	t_rtt dd ?
100	t_rtseq dd ?	100	t_rtseq dd ?
101	t_srtt dd ?	101	t_srtt dd ?
102	t_rttvar dd ?	102	t_rttvar dd ?
103	t_rttmin dd ?	103	t_rttmin dd ?
104	max_sndwnd dd ?	104	max_sndwnd dd ?
105		105
106	;-----------------	106	;-----------------
107	; Out-of-band data	107	; Out-of-band data
108	t_oobflags dd ?	108	t_oobflags dd ?
109	t_iobc dd ?	109	t_iobc dd ?
110	t_softerror dd ?	110	t_softerror dd ?
111		111
112		112
113	;---------	113	;---------
114	; RFC 1323 ; the order of next 4 elements may not change	114	; RFC 1323 ; the order of next 4 elements may not change
115		115
116	SND_SCALE db ?	116	SND_SCALE db ?
117	RCV_SCALE db ?	117	RCV_SCALE db ?
118	requested_s_scale db ?	118	requested_s_scale db ?
119	request_r_scale db ?	119	request_r_scale db ?
120		120
121	ts_recent dd ?	121	ts_recent dd ? ; a copy of the most-recent valid timestamp from the other end
122	ts_recent_age dd ?	122	ts_recent_age dd ?
123	last_ack_sent dd ?	123	last_ack_sent dd ?
124		124
125		125
126	;-------	126	;-------
127	; Timers	127	; Timers
128	timer_retransmission dw ? ; rexmt	128	timer_retransmission dw ? ; rexmt
129	timer_persist dw ?	129	timer_persist dw ?
130	timer_keepalive dw ? ; keepalive/syn timeout	130	timer_keepalive dw ? ; keepalive/syn timeout
131	timer_timed_wait dw ? ; also used as 2msl timer	131	timer_timed_wait dw ? ; also used as 2msl timer
132		132
133	; extra	133	; extra
134		134
135	sendalot db ? ; also used as 'need output'	135	sendalot db ? ; also used as 'need output'
-		136	ts_ecr dd ? ; timestamp echo reply
136		137
137	ends	138	ends
138		139
139	struct UDP_SOCKET IP_SOCKET	140	struct UDP_SOCKET IP_SOCKET
140		141
141	LocalPort dw ?	142	LocalPort dw ?
142	RemotePort dw ?	143	RemotePort dw ?
143	firstpacket db ?	144	firstpacket db ?
144		145
145	ends	146	ends
146		147
147		148
148	struct ICMP_SOCKET IP_SOCKET	149	struct ICMP_SOCKET IP_SOCKET
149		150
150	Identifier dw ?	151	Identifier dw ?
151		152
152	ends	153	ends
153		154
154		155
155	struct RING_BUFFER	156	struct RING_BUFFER
156		157
157	start_ptr dd ? ; Pointer to start of buffer	158	start_ptr dd ? ; Pointer to start of buffer
158	end_ptr dd ? ; pointer to end of buffer	159	end_ptr dd ? ; pointer to end of buffer
159	read_ptr dd ? ; Read pointer	160	read_ptr dd ? ; Read pointer
160	write_ptr dd ? ; Write pointer	161	write_ptr dd ? ; Write pointer
161	size dd ? ; Number of bytes buffered	162	size dd ? ; Number of bytes buffered
162		163
163	ends	164	ends
164		165
165	struct STREAM_SOCKET TCP_SOCKET	166	struct STREAM_SOCKET TCP_SOCKET
166		167
167	rcv RING_BUFFER	168	rcv RING_BUFFER
168	snd RING_BUFFER	169	snd RING_BUFFER
169		170
170	ends	171	ends
171		172
172	struct socket_queue_entry	173	struct socket_queue_entry
173		174
174	data_ptr dd ?	175	data_ptr dd ?
175	buf_ptr dd ?	176	buf_ptr dd ?
176	data_size dd ?	177	data_size dd ?
177		178
178	ends	179	ends
179		180
180		181
181	SOCKETBUFFSIZE = 4096 ; in bytes	182	SOCKETBUFFSIZE = 4096 ; in bytes
182		183
183	SOCKET_QUEUE_SIZE = 10 ; maximum number ofincoming packets queued for 1 socket	184	SOCKET_QUEUE_SIZE = 10 ; maximum number ofincoming packets queued for 1 socket
184	; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start	185	; the incoming packet queue for sockets is placed in the socket struct itself, at this location from start
185	SOCKET_QUEUE_LOCATION = (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)	186	SOCKET_QUEUE_LOCATION = (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)
186		187
187	uglobal	188	uglobal
188	net_sockets rd 4	189	net_sockets rd 4
189	last_socket_num dd ?	190	last_socket_num dd ?
190	last_UDP_port dw ? ; These values give the number of the last used ephemeral port	191	last_UDP_port dw ? ; These values give the number of the last used ephemeral port
191	last_TCP_port dw ? ;	192	last_TCP_port dw ? ;
192	endg	193	endg
193		194
194		195
195	;-----------------------------------------------------------------	196	;-----------------------------------------------------------------
196	;	197	;
197	; SOCKET_init	198	; SOCKET_init
198	;	199	;
199	;-----------------------------------------------------------------	200	;-----------------------------------------------------------------
200	macro SOCKET_init {	201	macro SOCKET_init {
201		202
202	xor eax, eax	203	xor eax, eax
203	mov edi, net_sockets	204	mov edi, net_sockets
204	mov ecx, 5	205	mov ecx, 5
205	rep stosd	206	rep stosd
206		207
207	@@:	208	@@:
208	pseudo_random eax	209	pseudo_random eax
209	cmp ax, MIN_EPHEMERAL_PORT	210	cmp ax, MIN_EPHEMERAL_PORT
210	jb @r	211	jb @r
211	cmp ax, MAX_EPHEMERAL_PORT	212	cmp ax, MAX_EPHEMERAL_PORT
212	ja @r	213	ja @r
213	mov [last_UDP_port], ax	214	mov [last_UDP_port], ax
214		215
215	@@:	216	@@:
216	pseudo_random eax	217	pseudo_random eax
217	cmp ax, MIN_EPHEMERAL_PORT	218	cmp ax, MIN_EPHEMERAL_PORT
218	jb @r	219	jb @r
219	cmp ax, MAX_EPHEMERAL_PORT	220	cmp ax, MAX_EPHEMERAL_PORT
220	ja @r	221	ja @r
221	mov [last_TCP_port], ax	222	mov [last_TCP_port], ax
222		223
223	}	224	}
224		225
225		226
226	;-----------------------------------------------------------------	227	;-----------------------------------------------------------------
227	;	228	;
228	; Socket API (function 74)	229	; Socket API (function 74)
229	;	230	;
230	;-----------------------------------------------------------------	231	;-----------------------------------------------------------------
231	align 4	232	align 4
232	sys_socket:	233	sys_socket:
233		234
234	cmp ebx, 255	235	cmp ebx, 255
235	jz SOCKET_debug	236	jz SOCKET_debug
236		237
237	cmp ebx, .number	238	cmp ebx, .number
238	ja s_error	239	ja s_error
239	jmp dword [.table + 4*ebx]	240	jmp dword [.table + 4*ebx]
240		241
241	.table:	242	.table:
242	dd SOCKET_open ; 0	243	dd SOCKET_open ; 0
243	dd SOCKET_close ; 1	244	dd SOCKET_close ; 1
244	dd SOCKET_bind ; 2	245	dd SOCKET_bind ; 2
245	dd SOCKET_listen ; 3	246	dd SOCKET_listen ; 3
246	dd SOCKET_connect ; 4	247	dd SOCKET_connect ; 4
247	dd SOCKET_accept ; 5	248	dd SOCKET_accept ; 5
248	dd SOCKET_send ; 6	249	dd SOCKET_send ; 6
249	dd SOCKET_receive ; 7	250	dd SOCKET_receive ; 7
250	dd SOCKET_set_opt ; 8	251	dd SOCKET_set_opt ; 8
251	dd SOCKET_get_opt ; 9	252	dd SOCKET_get_opt ; 9
252	.number = ($ - .table) / 4 - 1	253	.number = ($ - .table) / 4 - 1
253		254
254	s_error:	255	s_error:
255	DEBUGF 1,"socket error\n"	256	DEBUGF 1,"socket error\n"
256	mov dword [esp+32], -1	257	mov dword [esp+32], -1
257		258
258	ret	259	ret
259		260
260		261
261		262
262	;-----------------------------------------------------------------	263	;-----------------------------------------------------------------
263	;	264	;
264	; SOCKET_open	265	; SOCKET_open
265	;	266	;
266	; IN: domain in ecx	267	; IN: domain in ecx
267	; type in edx	268	; type in edx
268	; protocol in esi	269	; protocol in esi
269	; OUT: eax is socket num, -1 on error	270	; OUT: eax is socket num, -1 on error
270	;	271	;
271	;-----------------------------------------------------------------	272	;-----------------------------------------------------------------
272	align 4	273	align 4
273	SOCKET_open:	274	SOCKET_open:
274		275
275	DEBUGF 1,"SOCKET_open: domain=%u type=%u protocol=%x\n", ecx, edx, esi	276	DEBUGF 1,"SOCKET_open: domain=%u type=%u protocol=%x\n", ecx, edx, esi
276		277
277	push ecx edx esi	278	push ecx edx esi
278	call SOCKET_alloc	279	call SOCKET_alloc
279	pop esi edx ecx	280	pop esi edx ecx
280	jz s_error	281	jz s_error
281		282
282	mov [esp+32], edi ; return socketnumber	283	mov [esp+32], edi ; return socketnumber
283		284
284	mov [eax + SOCKET.Domain], ecx	285	mov [eax + SOCKET.Domain], ecx
285	mov [eax + SOCKET.Type], edx	286	mov [eax + SOCKET.Type], edx
286	mov [eax + SOCKET.Protocol], esi	287	mov [eax + SOCKET.Protocol], esi
287		288
288	cmp ecx, AF_INET4	289	cmp ecx, AF_INET4
289	jne .no_inet4	290	jne .no_inet4
290		291
291	cmp edx, SOCK_DGRAM	292	cmp edx, SOCK_DGRAM
292	je .udp	293	je .udp
293		294
294	cmp edx, SOCK_STREAM	295	cmp edx, SOCK_STREAM
295	je .tcp	296	je .tcp
296		297
297	cmp edx, SOCK_RAW	298	cmp edx, SOCK_RAW
298	je .raw	299	je .raw
299		300
300	.no_inet4:	301	.no_inet4:
301	ret	302	ret
302		303
303	align 4	304	align 4
304	.raw:	305	.raw:
305	test esi, esi ; IP_PROTO_IP	306	test esi, esi ; IP_PROTO_IP
306	jz .ip	307	jz .ip
307		308
308	cmp esi, IP_PROTO_ICMP	309	cmp esi, IP_PROTO_ICMP
309	je .icmp	310	je .icmp
310		311
311	cmp esi, IP_PROTO_UDP	312	cmp esi, IP_PROTO_UDP
312	je .udp	313	je .udp
313		314
314	cmp esi, IP_PROTO_TCP	315	cmp esi, IP_PROTO_TCP
315	je .tcp	316	je .tcp
316		317
317	ret	318	ret
318		319
319	align 4	320	align 4
320	.udp:	321	.udp:
321	mov [eax + SOCKET.Protocol], IP_PROTO_UDP	322	mov [eax + SOCKET.Protocol], IP_PROTO_UDP
322	mov [eax + SOCKET.snd_proc], SOCKET_send_udp	323	mov [eax + SOCKET.snd_proc], SOCKET_send_udp
323	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram	324	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
324	ret	325	ret
325		326
326	align 4	327	align 4
327	.tcp:	328	.tcp:
328	mov [eax + SOCKET.Protocol], IP_PROTO_TCP	329	mov [eax + SOCKET.Protocol], IP_PROTO_TCP
329	mov [eax + SOCKET.snd_proc], SOCKET_send_tcp	330	mov [eax + SOCKET.snd_proc], SOCKET_send_tcp
330	mov [eax + SOCKET.rcv_proc], SOCKET_receive_tcp	331	mov [eax + SOCKET.rcv_proc], SOCKET_receive_tcp
331		332
332	TCP_init_socket eax	333	TCP_init_socket eax
333	ret	334	ret
334		335
335		336
336	align 4	337	align 4
337	.ip:	338	.ip:
338	mov [eax + SOCKET.snd_proc], SOCKET_send_ip	339	mov [eax + SOCKET.snd_proc], SOCKET_send_ip
339	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram	340	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
340	ret	341	ret
341		342
342		343
343	align 4	344	align 4
344	.icmp:	345	.icmp:
345	mov [eax + SOCKET.snd_proc], SOCKET_send_icmp	346	mov [eax + SOCKET.snd_proc], SOCKET_send_icmp
346	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram	347	mov [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
347	ret	348	ret
348		349
349		350
350		351
351	;-----------------------------------------------------------------	352	;-----------------------------------------------------------------
352	;	353	;
353	; SOCKET_bind	354	; SOCKET_bind
354	;	355	;
355	; IN: socket number in ecx	356	; IN: socket number in ecx
356	; pointer to sockaddr struct in edx	357	; pointer to sockaddr struct in edx
357	; length of that struct in esi	358	; length of that struct in esi
358	; OUT: 0 on success	359	; OUT: 0 on success
359	;	360	;
360	;-----------------------------------------------------------------	361	;-----------------------------------------------------------------
361	align 4	362	align 4
362	SOCKET_bind:	363	SOCKET_bind:
363		364
364	DEBUGF 1,"SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi	365	DEBUGF 1,"SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
365		366
366	call SOCKET_num_to_ptr	367	call SOCKET_num_to_ptr
367	jz s_error	368	jz s_error
368		369
369	cmp esi, 2	370	cmp esi, 2
370	jb s_error	371	jb s_error
371		372
372	cmp word [edx], AF_INET4	373	cmp word [edx], AF_INET4
373	je .af_inet4	374	je .af_inet4
374		375
375	cmp word [edx], AF_UNIX	376	cmp word [edx], AF_UNIX
376	je .af_unix	377	je .af_unix
377		378
378	jmp s_error	379	jmp s_error
379		380
380	.af_unix:	381	.af_unix:
381	; TODO: write code here	382	; TODO: write code here
382		383
383	mov dword [esp+32], 0	384	mov dword [esp+32], 0
384	ret	385	ret
385		386
386	.af_inet4:	387	.af_inet4:
387		388
388	cmp esi, 6	389	cmp esi, 6
389	jb s_error	390	jb s_error
390		391
391	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP	392	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
392	je .udp	393	je .udp
393		394
394	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP	395	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP
395	je .tcp	396	je .tcp
396		397
397	jmp s_error	398	jmp s_error
398		399
399	.tcp:	400	.tcp:
400	.udp:	401	.udp:
401		402
402	mov ebx, [edx + 4] ; First, fill in the IP	403	mov ebx, [edx + 4] ; First, fill in the IP
403	test ebx, ebx ; If IP is 0, use default	404	test ebx, ebx ; If IP is 0, use default
404	jnz @f	405	jnz @f
405	mov ebx, [NET_DEFAULT]	406	mov ebx, [NET_DEFAULT]
406	mov ebx, [IP_LIST + 4*ebx]	407	mov ebx, [IP_LIST + 4*ebx]
407	@@:	408	@@:
408	mov [eax + IP_SOCKET.LocalIP], ebx	409	mov [eax + IP_SOCKET.LocalIP], ebx
409		410
410	mov bx, [edx + 2] ; Now fill in the port if it's still available	411	mov bx, [edx + 2] ; Now fill in the port if it's still available
411	call SOCKET_check_port	412	call SOCKET_check_port
412	jz s_error ; ZF is set by socket_check_port, on error	413	jz s_error ; ZF is set by socket_check_port, on error
413		414
414	DEBUGF 1,"SOCKET_bind: local ip=%u.%u.%u.%u\n",\	415	DEBUGF 1,"SOCKET_bind: local ip=%u.%u.%u.%u\n",\
415	[eax + IP_SOCKET.LocalIP + 0]:1,[eax + IP_SOCKET.LocalIP + 1]:1,\	416	[eax + IP_SOCKET.LocalIP + 0]:1,[eax + IP_SOCKET.LocalIP + 1]:1,\
416	[eax + IP_SOCKET.LocalIP + 2]:1,[eax + IP_SOCKET.LocalIP + 3]:1	417	[eax + IP_SOCKET.LocalIP + 2]:1,[eax + IP_SOCKET.LocalIP + 3]:1
417		418
418	mov dword [esp+32], 0	419	mov dword [esp+32], 0
419	ret	420	ret
420		421
421		422
422		423
423		424
424	;-----------------------------------------------------------------	425	;-----------------------------------------------------------------
425	;	426	;
426	; SOCKET_connect	427	; SOCKET_connect
427	;	428	;
428	; IN: socket number in ecx	429	; IN: socket number in ecx
429	; pointer to sockaddr struct in edx	430	; pointer to sockaddr struct in edx
430	; length of that struct in esi	431	; length of that struct in esi
431	; OUT: 0 on success	432	; OUT: 0 on success
432	;	433	;
433	;-----------------------------------------------------------------	434	;-----------------------------------------------------------------
434	align 4	435	align 4
435	SOCKET_connect:	436	SOCKET_connect:
436		437
437	DEBUGF 1,"SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi	438	DEBUGF 1,"SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
438		439
439	call SOCKET_num_to_ptr	440	call SOCKET_num_to_ptr
440	jz s_error	441	jz s_error
441		442
442	cmp esi, 8	443	cmp esi, 8
443	jb s_error	444	jb s_error
444		445
445	cmp word [edx], AF_INET4	446	cmp word [edx], AF_INET4
446	je .af_inet4	447	je .af_inet4
447		448
448	jmp s_error	449	jmp s_error
449		450
450	.af_inet4:	451	.af_inet4:
451	cmp [eax + IP_SOCKET.LocalIP], 0	452	cmp [eax + IP_SOCKET.LocalIP], 0
452	jne @f	453	jne @f
453	push [IP_LIST]	454	push [IP_LIST]
454	pop [eax + IP_SOCKET.LocalIP]	455	pop [eax + IP_SOCKET.LocalIP]
455	@@:	456	@@:
456		457
457	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP	458	cmp [eax + SOCKET.Protocol], IP_PROTO_UDP
458	je .udp	459	je .udp
459		460
460	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP	461	cmp [eax + SOCKET.Protocol], IP_PROTO_TCP
461	je .tcp	462	je .tcp
462		463
463	cmp [eax + SOCKET.Protocol], IP_PROTO_IP	464	cmp [eax + SOCKET.Protocol], IP_PROTO_IP
464	je .ip	465	je .ip
465		466
466	cmp [eax + SOCKET.Protocol], IP_PROTO_ICMP	467	cmp [eax + SOCKET.Protocol], IP_PROTO_ICMP
467	je .ip	468	je .ip
468		469
469	jmp s_error	470	jmp s_error
470		471
471	align 4	472	align 4
472	.udp:	473	.udp:
473	pusha	474	pusha
474	lea ecx, [eax + SOCKET.mutex]	475	lea ecx, [eax + SOCKET.mutex]
475	call mutex_lock	476	call mutex_lock
476	popa	477	popa
477		478
478	pushw [edx + 2]	479	pushw [edx + 2]
479	pop [eax + UDP_SOCKET.RemotePort]	480	pop [eax + UDP_SOCKET.RemotePort]
480		481
481	pushd [edx + 4]	482	pushd [edx + 4]
482	pop [eax + IP_SOCKET.RemoteIP]	483	pop [eax + IP_SOCKET.RemoteIP]
483		484
484	cmp [eax + UDP_SOCKET.LocalPort], 0	485	cmp [eax + UDP_SOCKET.LocalPort], 0
485	jne @f	486	jne @f
486	call SOCKET_find_port	487	call SOCKET_find_port
487	@@:	488	@@:
488		489
489	mov [eax + UDP_SOCKET.firstpacket], 0	490	mov [eax + UDP_SOCKET.firstpacket], 0
490		491
491	push eax	492	push eax
492	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue	493	init_queue (eax + SOCKET_QUEUE_LOCATION) ; Set up data receiving queue
493	pop eax	494	pop eax
494		495
495	lea ecx, [eax + SOCKET.mutex]	496	lea ecx, [eax + SOCKET.mutex]
496	call mutex_unlock	497	call mutex_unlock
497		498
498	mov dword [esp+32], 0	499	mov dword [esp+32], 0
499	ret	500	ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/net/network/socket.inc – Rev 2894 → 2924