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

 ;;         GNU GENERAL PUBLIC LICENSE                              ;;
 ;;          Version 2, June 1991                                   ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 3626 $
 $Revision: 3725 $
 struct  SOCKET
 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   = (SOCKETBUFFSIZE - SOCKET_QUEUE_SIZE*sizeof.socket_queue_entry - sizeof.queue)
+uglobal
+align 4
 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 ? ;
+        socket_mutex    MUTEX
         last_TCP_port   dw ? ;
 endg
         cmp     ax, EPHEMERAL_PORT_MAX
         ja      @r
         xchg    al, ah
         mov     [last_TCP_port], ax
+        mov     ecx, socket_mutex
+        call    mutex_init
+}
 ;-----------------------------------------------------------------
+;
 ; Socket API (function 74)
+;
 ;-----------------------------------------------------------------
+align 4
+sys_socket:
 align 4
-sys_socket:
+        mov     dword[esp+20], 0        ; Set error code to 0
         cmp     ebx, 255
         jz      SOCKET_debug
         cmp     ebx, .number
-        ja      s_error
+        ja      .error
         dd      SOCKET_set_opt  ; 8
         dd      SOCKET_get_opt  ; 9
         dd      SOCKET_pair     ; 10
   .number = ($ - .table) / 4 - 1
-s_error:
-        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET: error\n"
+  .error:
+        mov     dword[esp+32], -1
-        mov     dword [esp+32], -1
+        mov     dword[esp+20], EINVAL
         ret
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_open: domain=%u type=%u protocol=%x ", ecx, edx, esi
         push    ecx edx esi
         call    SOCKET_alloc
         pop     esi edx ecx
-        jz      s_error
+        jz      .nobuffs
         mov     [esp+32], edi                   ; return socketnumber
         DEBUGF  DEBUG_NETWORK_VERBOSE, "socknum=%u\n", edi
-;        push    edx
-;        and     edx, SO_NONBLOCK
+        test    edx, SO_NONBLOCK
+        jz      @f
-        or      [eax + SOCKET.options], SO_NONBLOCK ;edx
+        or      [eax + SOCKET.options], SO_NONBLOCK
-;        pop     edx
+        and     edx, not SO_NONBLOCK
-;        and     edx, not SO_NONBLOCK
+  @@:
         cmp     esi, PPP_PROTO_ETHERNET
         je      .pppoe
+  .no_ppp:
+  .unsupported:
+        push    eax
+        call    SOCKET_free
+        pop     eax
+        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp+32], -1
+        ret
+  .nobuffs:
-  .no_ppp:
+        mov     dword[esp+20], ENOBUFS
-        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_open: Unknown socket family/protocol\n"
-        ret
+        mov     dword[esp+32], -1
         ret
-align 4
   .raw:
         test    esi, esi       ; IP_PROTO_IP
-        jz      .ip
+        jz      .raw_ip
-        cmp     esi, IP_PROTO_ICMP
-        je      .icmp
-        cmp     esi, IP_PROTO_UDP
-        je      .udp
-        cmp     esi, IP_PROTO_TCP
+        cmp     esi, IP_PROTO_ICMP
-        je      .tcp
+        je      .raw_icmp
         TCP_init_socket eax
         ret
 align 4
-  .ip:
+  .raw_ip:
         mov     [eax + SOCKET.snd_proc], SOCKET_send_ip
         mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
         ret
 align 4
-  .icmp:
+  .raw_icmp:
 SOCKET_bind:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         cmp     esi, 2
-        jb      s_error
+        jb      .invalid
+        cmp     word [edx], AF_INET4
+        je      .af_inet4
-        cmp     word [edx], AF_INET4
+        cmp     word [edx], AF_LOCAL
+        je      .af_local
+  .notsupp:
+        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp+32], -1
-        je      .af_inet4
+        ret
-        cmp     word [edx], AF_LOCAL
-        je      .af_local
+  .invalid:
         mov     dword[esp+20], EINVAL
-        jmp     s_error
+        mov     dword[esp+32], -1
-  .af_local:
+        ret
-        ; TODO: write code here
   .af_local:
-        mov     dword [esp+32], 0
+        ; TODO: write code here
-        ret
+        mov     dword[esp+32], 0
         ret
-  .af_inet4:
   .af_inet4:
         cmp     esi, 6
-        jb      s_error
+        jb      .invalid
         cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
-        je      .udp
+        cmp     [eax + SOCKET.Protocol], IP_PROTO_UDP
         je      .udp
         cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
-        je      .tcp
+        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
         je      .tcp
         jmp     s_error
+        jmp     .notsupp
   .tcp:
-  .udp:
+  .tcp:
   .udp:
-        cmp     ebx, [edx + 4]                  ; First, fill in the IP
+        mov     ebx, [edx + 4]                  ; First, fill in the IP
         test    ebx, ebx                        ; If IP is 0, use default
+        jnz     @f
+        mov     ebx, [IP_LIST + 4]      ;;;;; FIXME !i!i!i
+       @@:
+        mov     [eax + IP_SOCKET.LocalIP], ebx
-        jnz     @f
+        mov     bx, [edx + 2]                   ; Now fill in the local port if it's still available
-        mov     ebx, [IP_LIST + 4]      ;;;;; FIXME !i!i!i
+        call    SOCKET_check_port
 SOCKET_connect:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         cmp     esi, 8
+        jb      .invalid
-        jb      s_error
+        cmp     word [edx], AF_INET4
+        je      .af_inet4
+  .notsupp:
+        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp+32], -1
+        ret
-        cmp     word [edx], AF_INET4
+  .invalid:
-        je      .af_inet4
+        mov     dword[esp+20], EINVAL
         mov     dword[esp+32], -1
         je      .ip
         cmp     [eax + SOCKET.Protocol], IP_PROTO_ICMP
         je      .ip
-        jmp     s_error
+        jmp     .notsupp
 align 4
         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
         TCP_sendseqinit eax
 ;        mov     [ebx + TCP_SOCKET.timer_retransmission],   ;; todo: create macro to set retransmission timer
         mov     ebx, eax
+        mov     ebx, eax
         lea     eax, [ebx + STREAM_SOCKET.snd]
-        call    SOCKET_ring_create
+        call    SOCKET_ring_create              ; TODO: check if memory was available or not
         lea     eax, [ebx + STREAM_SOCKET.rcv]
-        call    SOCKET_ring_create
+        call    SOCKET_ring_create              ; TODO: same here
+        pusha
-        pusha
+        lea     ecx, [ebx + SOCKET.mutex]
-        lea     ecx, [ebx + SOCKET.mutex]
+        call    mutex_unlock
+        popa
-        call    mutex_unlock
+        push    ebx
+        mov     eax, ebx
+        call    TCP_output
+        pop     eax
+  .block:
+        test    [eax + SOCKET.options], SO_NONBLOCK
+        jz      .loop
+        mov     dword[esp+20], EWOULDBLOCK
+        mov     dword[esp+32], -1
+        ret
+  .loop:
+        cmp     [eax + TCP_SOCKET.t_state], TCPS_CLOSED
+        je      .fail
+        cmp     [eax + TCP_SOCKET.t_state], TCPS_ESTABLISHED
+        je      .established
+        ja      .fail
+        call    SOCKET_block
+        jmp     .loop
-        popa
+  .fail:
         mov     eax, [eax + SOCKET.errorcode]
+        mov     [esp+20], eax
-        mov     eax, ebx
+        mov     dword[esp+32], -1
-        call    TCP_output
+        ret
-;;; TODO: wait for successfull connection if blocking socket
+  .established:
         mov     dword[esp+32], 0
 SOCKET_listen:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_listen: socknum=%u backlog=%u\n", ecx, edx
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         cmp     [eax + SOCKET.Domain], AF_INET4
-        jne     s_error
+        jne     .notsupp
         cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
-        jne     s_error
+        jne     .invalid
         cmp     [eax + TCP_SOCKET.LocalPort], 0
         push    eax
         init_queue (eax + SOCKET_QUEUE_LOCATION)                ; Set up sockets queue
         pop     eax
+        mov     dword[esp+32], 0
+        ret
+  .notsupp:
+        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp+32], -1
+        ret
+  .invalid:
+        mov     dword[esp+20], EINVAL
+        mov     dword[esp+32], -1
+        ret
+  .already:
-        mov     dword [esp+32], 0
+        mov     dword[esp+20], EALREADY
         mov     dword[esp+32], -1
         ret
 SOCKET_accept:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_accept: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         test    [eax + SOCKET.options], SO_ACCEPTCON
-        jz      s_error
+        jz      .invalid
         cmp     [eax + SOCKET.Domain], AF_INET4
-        jne     s_error
+        jne     .notsupp
         cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
+        jne     .invalid
+  .loop:
+        get_from_queue (eax + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, .block
         jne     s_error
 ; Ok, we got a socket ptr
-  .loop:
+        mov     eax, [esi]
         get_from_queue (eax + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, .block
-; Ok, we got a socket ptr
-        mov     eax, [esi]
 ; Convert it to a socket number
-; Change thread ID to that of the current thread
+        call    SOCKET_ptr_to_num
-        mov     ebx, [TASK_BASE]
+        jz      .invalid        ; FIXME ?
         mov     ebx, [ebx + TASKDATA.pid]
-        mov     [eax + SOCKET.TID], ebx
+; Change thread ID to that of the current thread
+        mov     ebx, [TASK_BASE]
-; Convert it to a socket number
+        mov     ebx, [ebx + TASKDATA.pid]
-        call    SOCKET_ptr_to_num
+        mov     [eax + SOCKET.TID], ebx
+; and return it to caller
+        mov     [esp+32], eax
+        ret
+  .block:
+        test    [eax + SOCKET.options], SO_NONBLOCK
+        jnz     .wouldblock
+        call    SOCKET_block
+        jmp     .loop
+  .wouldblock:
+        mov     dword[esp+20], EWOULDBLOCK
+        mov     dword[esp+32], -1
-        jz      s_error
+        ret
 ; and return it to caller
-        mov     [esp+32], eax
+  .invalid:
-        ret
+        mov     dword[esp+20], EINVAL
         mov     dword[esp+32], -1
 SOCKET_close:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_close: socknum=%u\n", ecx
         call    SOCKET_num_to_ptr
-        jz      s_error
         jz      .invalid
         mov     dword [esp+32], 0                               ; The socket exists, so we will succeed in closing it.
         mov     dword[esp+32], 0                                ; The socket exists, so we will succeed in closing it.
   .socket:
         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??
-        call    TCP_output      ;;;; Fixme: is this nescessary??
+        call    SOCKET_free
+        ret
+  .invalid:
+        mov     dword[esp+20], EINVAL
         mov     dword[esp+32], -1
         ret
 ;-----------------------------------------------------------------
 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
+        jz      .invalid
         call    SOCKET_num_to_ptr
+  .loop:
+        push    edi
+        call    [eax + SOCKET.rcv_proc]
+        pop     edi
+        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
-        jz      s_error
+  .return_err:
         mov     eax, -1
+  .return:
+        mov     [esp+20], ebx
+        mov     [esp+32], eax
-        call    [eax + SOCKET.rcv_proc]
+        ret
         mov     [esp+32], eax
-        ret
-align 4
-SOCKET_receive_dgram:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: DGRAM\n"
+align 4
+SOCKET_receive_dgram:
         mov     ebx, esi
-        mov     edi, edx                                        ; addr to buffer
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: DGRAM\n"
-  .loop:
+        mov     ebx, esi                                        ; bufferlength
         get_from_queue (eax + SOCKET_QUEUE_LOCATION), SOCKET_QUEUE_SIZE, sizeof.socket_queue_entry, .block      ; destroys esi and ecx
+        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]
-        mov     ecx, [esi + socket_queue_entry.data_size]
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: %u bytes data\n", ecx
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: %u bytes data\n", ecx
         cmp     ecx, ebx                                        ; If data segment does not fit in applications buffer, abort
-        cmp     ecx, ebx
+        ja      .too_small
         ja      .too_small
         test    ecx, ecx
         jz      .nd
-        rep     movsd
+        rep movsd
   .nd:
+        call    kernel_free                                     ; free kernel buffer
-        call    kernel_free                                     ; remove the packet
+        pop     eax                                             ; return number of bytes copied to application
-        pop     eax
         xor     ebx, ebx
         ret
-  .too_small:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: Buffer too small\n"
+  .too_small:
+        mov     eax, -1
-  .fail:
+        push    EMSGSIZE
-        mov     eax, -1
+        pop     ebx
         ret
+  .wouldblock:
-  .block:
-        test    [eax + SOCKET.options], SO_NONBLOCK
-        jnz     .fail
+        push    EWOULDBLOCK
         pop     ebx
-        mov     [eax + SOCKET.TID], ebx         ; currently TID = PID in kolibrios :(
+        mov     [eax + SOCKET.TID], ebx                         ; currently TID = PID in kolibrios :(
       @@:
+        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_stream
-        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"
-SOCKET_receive_stream:
+        cmp     [eax + STREAM_SOCKET.rcv + RING_BUFFER.size], 0
+        je      .wouldblock
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: STREAM\n"
+        test    edi, MSG_PEEK
         jnz     .peek
-        mov     ebx, edi
-        mov     ecx, esi
-        mov     edi, edx
-        xor     edx, edx
-        test    ebx, MSG_DONTWAIT
-        jnz     .dontwait
-  .loop:
-        cmp     [eax + STREAM_SOCKET.rcv + RING_BUFFER.size], 0
         je      .block
-  .dontwait:
+        mov     ecx, esi
-        test    ebx, MSG_PEEK
+        mov     edi, edx
-        jnz     .peek
+        xor     edx, edx
         add     eax, STREAM_SOCKET.rcv
-        add     eax, STREAM_SOCKET.rcv
-        call    SOCKET_ring_read
-        call    SOCKET_ring_free
-        mov     eax, ecx                ; return number of bytes copied
+        call    SOCKET_ring_read                                ; copy data from kernel buffer to application buffer
-        ret
-  .peek:
-        mov     eax, [eax + STREAM_SOCKET.rcv + RING_BUFFER.size]
+        call    SOCKET_ring_free                                ; free read memory
-        ret
-  .block:
-        test    [eax + SOCKET.options], SO_NONBLOCK
-        jnz     .return0
-        call    SOCKET_block
-        jmp     .loop
         mov     eax, ecx                                        ; return number of bytes copied
-  .return0:
+        xor     ebx, ebx                                        ; errorcode = 0 (no error)
+        ret
-        test    [eax + SOCKET.options], SS_CANTRCVMORE
-        jz      .ok
+  .wouldblock:
         push    EWOULDBLOCK
-        xor     eax, eax
+        pop     ebx
 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
-        jz      s_error
+        jz      .invalid
+        mov     ecx, esi
+        mov     esi, edx
+        jmp     [eax + SOCKET.snd_proc]
-        mov     ecx, esi
+  .invalid:
-        mov     esi, edx
+        mov     dword[esp+20], EINVAL
         mov     dword[esp+32], -1
-        jmp     [eax + SOCKET.snd_proc]
+        ret
 align 4
+SOCKET_send_udp:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: UDP\n"
+        mov     [esp+32], ecx
-SOCKET_send_udp:
+        call    UDP_output
         cmp     eax, -1
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: UDP\n"
+        je      .error
         add     eax, STREAM_SOCKET.snd
         call    SOCKET_ring_write
         pop     eax
-        mov     [esp+32], ecx
+        mov     [esp+32], 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]
-        call    TCP_output
+        mov     [esp+20], eax
         ret
 align 4
 SOCKET_send_ip:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: IPv4\n"
+        mov     [esp+32], ecx
+        call    IPv4_output_raw         ; FIXME: IPv4_output_raw should return error codes!
+        cmp     eax, -1
+        je      .error
         ret
         mov     [esp+32], ecx
-        call    IPv4_output_raw
+  .error:
-        cmp     eax, -1
+        mov     dword[esp+32], -1
-        je      s_error
+        mov     dword[esp+20], EMSGSIZE
         ret
+align 4
+SOCKET_send_icmp:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: ICMP\n"
-align 4
+        mov     [esp+32], ecx
-SOCKET_send_icmp:
+        call    ICMP_output_raw         ; FIXME: errorcodes
         cmp     eax, -1
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: PPPoE\n"
         mov     [esp+32], ecx
         mov     ebx, [eax + SOCKET.device]
-        call    PPPoE_discovery_output
+        call    PPPoE_discovery_output  ; FIXME: errorcodes
+        cmp     eax, -1
+        je      .error
+        ret
+  .error:
-        cmp     eax, -1
+        mov     dword[esp+32], -1
-        je      s_error
+        mov     dword[esp+20], EMSGSIZE
         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      s_error
+        jz      .invalid
         ; allright, shove in the data!
         push    eax
         ; and notify the other end
         call    SOCKET_notify
+        ret
+  .invalid:
+        mov     dword[esp+32], -1
+        mov     dword[esp+20], EINVAL
         ret
 ;-----------------------------------------------------------------
 SOCKET_get_opt:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_get_opt\n"
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         cmp     dword [edx], IP_PROTO_TCP
-        jne     s_error
+        jne     .invalid
         cmp     dword [edx+4], -2
         je      @f
         cmp     dword [edx+4], -3
-        jne     s_error
+        jne     .invalid
 @@:
 ;        mov     eax, [edx+12]
         mov     [eax], ecx
 @@:
         mov     dword [esp+32], 0
         ret
+  .invalid:
+        mov     dword[esp+32], -1
+        mov     dword[esp+20], EINVAL
+        ret
 SOCKET_set_opt:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt\n"
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         cmp     dword [edx], SOL_SOCKET
+        jne     .invalid
-        jne     s_error
+        cmp     dword [edx+4], SO_BINDTODEVICE
-        cmp     dword [edx+4], SO_BINDTODEVICE
         je      .bind
-        cmp     dword [edx+4], SO_BLOCK
+  .invalid:
-        je      .block
+        mov     dword[esp+32], -1
         mov     dword[esp+20], EINVAL
-        jmp     s_error
+        ret
   .bind:
-        cmp     dword [edx+8], 0
+        cmp     dword[edx+8], 0
         je      .unbind
-        movzx   edx, byte [edx + 9]
+        movzx   edx, byte[edx + 9]
         cmp     edx, NET_DEVICES_MAX
         mov     [eax + SOCKET.device], 0
-        mov     dword [esp+32], 0       ; success!
+        mov     dword[esp+32], 0        ; success!
         ret
-  .block:
-        cmp     dword [edx+8], 0
-        je      .unblock
-        and     [eax + SOCKET.options], not SO_NONBLOCK
+  .already:
         mov     dword[esp+20], EALREADY
-        mov     dword [esp+32], 0       ; success!
-        ret
-  .unblock:
-        or      [eax + SOCKET.options], SO_NONBLOCK
         mov     dword[esp+32], -1
-        mov     dword [esp+32], 0       ; success!
+        ret
 SOCKET_pair:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_pair\n"
         call    SOCKET_alloc
-        jz      s_error
+        jz      .nomem1
         mov     [esp+32], edi   ; application's eax
         mov     [eax + SOCKET.rcv_proc], SOCKET_receive_local
         mov     [eax + SOCKET.PID], 0
         mov     ebx, eax
         call    SOCKET_alloc
-        jz      .error
+        jz      .nomem2
-        mov     [esp+24], edi   ; application's ebx
+        mov     [esp+20], edi   ; application's ebx
         mov     [eax + SOCKET.Domain], AF_LOCAL
         mov     [eax + SOCKET.Type], SOCK_STREAM
         call    SOCKET_ring_create
         pop     eax
         ret
-  .error:
+  .nomem2:
+        mov     eax, ebx
-        mov     eax, ebx
+        call    SOCKET_free
+  .nomem1:
+        mov     dword[esp+32], -1
-        call    SOCKET_free
+        mov     dword[esp+28], ENOMEM
-        jmp     s_error
+        ret
         test    ecx, ecx
         jz      .returnall
         call    SOCKET_num_to_ptr
-        jz      s_error
+        jz      .invalid
         stosd
         jmp     .next_socket
   .done:
         xor     eax, eax
         stosd
+        mov     dword[esp+32], eax
+        ret
+  .invalid:
+        mov     dword[esp+32], -1
-        mov     dword [esp+32], 0
+        mov     dword[esp+28], EINVAL
         ret
 align 4
 SOCKET_check_port:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check_port: "
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_lock
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check_port: "
+        popa
         mov     ecx, [eax + SOCKET.Protocol]
         mov     edx, [eax + IP_SOCKET.LocalIP]
         jne     .next_socket
         cmp     [esi + UDP_SOCKET.LocalPort], bx
+        jne     .next_socket
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_unlock
-        jne     .next_socket
+        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
-        ret
+        call    mutex_unlock
         popa
   .port_ok:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "local port %x is free\n", bx         ; FIXME: find a way to print big endian values with debugf
 ; SOCKET_block
+;
 ; Suspends the thread attached to a socket
+;
 ;  IN:  eax = socket ptr
-;  OUT: /
+;  OUT: eax = unchanged
+;
 ;-----------------------------------------------------------------
 align 4
 SOCKET_block:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: %x\n", eax
         pushf
-        pushf
+        push    eax
         cli
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: suspending thread: %u\n", edx
         mov     [eax + SOCKET.TID], edx
         pop     edx
+        call    change_task
-        call    change_task
+        pop     eax
         popf
 ; SOCKET_notify
+;
 ; notify's the owner of a socket that something happened
+;
 ;  IN:  eax = socket ptr
-;  OUT: /
+;  OUT: eax = unchanged
+;
 ;-----------------------------------------------------------------
 align 4
 SOCKET_notify:
         jz      .error
         test    [eax + SOCKET.state], SS_BLOCKED
         jnz     .unblock
-        test    [eax + SOCKET.options], SO_NONBLOCK
+;        test    [eax + SOCKET.options], SO_NONBLOCK
-        jz      .error
+;        jz      .error
         xor     eax, eax
-        rep     stosd
+        rep stosd
         pop     eax
 ; set send-and receive procedures to return -1
-        mov     [eax + SOCKET.snd_proc], s_error
+        mov     [eax + SOCKET.snd_proc], .not_yet
+        mov     [eax + SOCKET.rcv_proc], .not_yet
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_lock
-        mov     [eax + SOCKET.rcv_proc], s_error
+        popa
 ; find first free socket number and use it
         mov     edi, [last_socket_num]
         popa
        @@:
         mov     [net_sockets + SOCKET.NextPtr], eax
+        or      eax, eax                ; used to clear zero flag
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_unlock
+        popa
         or      eax, eax                ; used to clear zero flag
   .exit:
         pop     ebx
+        ret
+  .not_yet:
+        mov     dword[esp+20], ENOTCONN
         mov     dword[esp+32], -1
         ret
 align 4
 SOCKET_free:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: %x\n", eax
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_lock
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: %x\n", eax
+        popa
         call    SOCKET_check
         stdcall kernel_free, [ebx + STREAM_SOCKET.rcv.start_ptr]
         stdcall kernel_free, [ebx + STREAM_SOCKET.snd.start_ptr]
         mov     eax, ebx
   .no_tcp:
         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]
         pop     ebx
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: success!\n"
+  .error:
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_unlock
         popa
   .error:
         ret
 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
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_num_to_ptr: num=%u ", ecx
+        popa
         mov     eax, net_sockets
         cmp     [eax + SOCKET.Number], ecx
         jne     .next_socket
+        test    eax, eax
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_unlock
-        test    eax, eax
+        popa
         DEBUGF  DEBUG_NETWORK_VERBOSE, "ptr=%x\n", eax
+        ret
+  .error:
+        pusha
+        mov     ecx, socket_mutex
-        ret
+        call    mutex_unlock
         popa
   .error:
-        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_nuto_ptr: not found\n", eax
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: not found\n", eax
+;
 ;------------------------------------------------------
 align 4
 SOCKET_process_end:
+        pushf
+        cli     ; FIXME
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_process_end: %x\n", edx
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_lock
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_process_end: %x\n", edx
+        popa
         push    ebx
         mov     ebx, net_sockets
         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]
         mov     ebx, [ebx + SOCKET.NextPtr]
+        pusha
-        pusha
+        mov     ecx, socket_mutex
-        call    SOCKET_close.socket
+        call    mutex_unlock
+        popa
+        pusha
+        cmp     [eax + SOCKET.Domain], AF_INET4
+        jne     .free
+        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
+        jne     .free
+        call    TCP_close
+        jmp     .closed
+  .free:
+        call    SOCKET_free
+  .closed:
+        popa
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_lock
+        popa
         popa
         jmp     .next_socket_test
+  .done:
+        pop     ebx
+        pusha
+        mov     ecx, socket_mutex
+        call    mutex_unlock
+        popa
   .done:
 align 4
 SOCKET_is_connected:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connected: %x\n", eax
-        and     [eax + SOCKET.options], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING)
+        and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING)
 align 4
 SOCKET_is_disconnecting:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnecting: %x\n", eax
-        and     [eax + SOCKET.options], not (SS_ISCONNECTING)
+        and     [eax + SOCKET.state], not (SS_ISCONNECTING)
 align 4
 SOCKET_is_disconnected:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnected: %x\n", eax
-        and     [eax + SOCKET.options], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
+        and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
-        or      [eax + SOCKET.options], SS_CANTRCVMORE + SS_CANTSENDMORE
+        or      [eax + SOCKET.state], SS_CANTRCVMORE + SS_CANTSENDMORE
 align 4
 SOCKET_cant_recv_more:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_cant_recv_more: %x\n", eax
-        or      [eax + SOCKET.options], SS_CANTRCVMORE
+        or      [eax + SOCKET.state], SS_CANTRCVMORE
 align 4
 SOCKET_cant_send_more:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_cant_send_more: %x\n", eax
-        or      [eax + SOCKET.options], SS_CANTSENDMORE
+        or      [eax + SOCKET.state], SS_CANTSENDMORE
-        mov     [eax + SOCKET.snd_proc], s_error
+        mov     [eax + SOCKET.snd_proc], .notconn
+        call    SOCKET_notify
+        ret
+  .notconn:
-        call    SOCKET_notify
+        mov     dword[esp+20], ENOTCONN

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/network/socket.inc – Rev 3626 → 3725