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

 ;;         GNU GENERAL PUBLIC LICENSE                              ;;
 ;;          Version 2, June 1991                                   ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 3908 $
+$Revision: 4265 $
 struct  SOCKET
         state                   dd ?
         backlog                 dw ? ; how many incoming connections that can be queued
         snd_proc                dd ?
+        rcv_proc                dd ?
-        rcv_proc                dd ?
+        connect_proc            dd ?
         timer_flags             dd ?
         timer_retransmission    dd ? ; rexmt
         timer_persist           dd ?
         timer_keepalive         dd ? ; keepalive/syn timeout
         timer_timed_wait        dd ? ; also used as 2msl timer
+        timer_connect           dd ?
 ; extra
         seg_next                dd ? ; re-assembly queue
         temp_bits               db ?
+                                rb 3 ; align
                                 rb 3 ; align
 ends
-struct  UDP_SOCKET              IP_SOCKET
 struct  UDP_SOCKET              IP_SOCKET
         LocalPort               dw ? ; network byte order
   @@:
         mov     [eax + SOCKET.Domain], ecx
         mov     [eax + SOCKET.Type], edx
+        mov     [eax + SOCKET.Protocol], esi
-        mov     [eax + SOCKET.Protocol], esi
+        mov     [eax + SOCKET.connect_proc], connect_notsupp
         cmp     ecx, AF_INET4
 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
+        mov     [eax + SOCKET.connect_proc], UDP_connect
         ret
 align 4
   .tcp:
         mov     [eax + SOCKET.Protocol], IP_PROTO_TCP
         mov     [eax + SOCKET.snd_proc], SOCKET_send_tcp
+        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_stream
-        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_stream
+        mov     [eax + SOCKET.connect_proc], TCP_connect
         TCP_init_socket eax
         ret
+align 4
-align 4
+  .raw_ip:
-  .raw_ip:
+        mov     [eax + SOCKET.snd_proc], SOCKET_send_ip
-        mov     [eax + SOCKET.snd_proc], SOCKET_send_ip
+        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
-        mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
+        mov     [eax + SOCKET.connect_proc], IPv4_connect
         ret
 align 4
-align 4
+  .raw_icmp:
-  .raw_icmp:
+        mov     [eax + SOCKET.snd_proc], SOCKET_send_icmp
         jz      .invalid
         cmp     esi, 2
+        jb      .invalid
+        cmp     [eax + UDP_SOCKET.LocalPort], 0         ; Socket can only be bound once
-        jb      .invalid
+        jnz     .invalid
         cmp     word [edx], AF_INET4
         je      .af_inet4
         jmp     .notsupp
-  .tcp:
-  .udp:
-        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
-       @@:
+  .tcp:
-        mov     [eax + IP_SOCKET.LocalIP], ebx
+  .udp:
+        pushd   [edx + 4]                       ; First, fill in the IP
+        popd    [eax + IP_SOCKET.LocalIP]
+        mov     bx, [edx + 2]                   ; Did caller specify a local port?
+        test    bx, bx
+        jnz     .just_check
+        call    SOCKET_find_port                ; Nope, find an ephemeral one
+        jmp     .done
+  .just_check:
-        mov     bx, [edx + 2]                   ; Now fill in the local port if it's still available
+        call    SOCKET_check_port               ; Yes, check if it's still available
-        call    SOCKET_check_port
+        jz      .addrinuse                      ; ZF is set by socket_check_port on error
         jz      .addrinuse                      ; ZF is set by socket_check_port, on error
   .done:
         jz      .invalid
         cmp     esi, 8
-        jb      .invalid
-        cmp     word [edx], AF_INET4
-        je      .af_inet4
-  .notsupp:
-        mov     dword[esp+20], EOPNOTSUPP
-        mov     dword[esp+32], -1
-        ret
-  .invalid:
-        mov     dword[esp+20], EINVAL
-        mov     dword[esp+32], -1
-        ret
-  .af_inet4:
-        cmp     [eax + IP_SOCKET.LocalIP], 0
-        jne     @f
-        push    [IP_LIST + 4]                               ; FIXME !i!i!i!
-        pop     [eax + IP_SOCKET.LocalIP]
-       @@:
+        jb      .invalid
-        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     .notsupp
-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
+        cmp     [eax + SOCKET.state], SS_ISCONNECTING
+        je      .already
-        push    eax
-        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
+        test    [eax + SOCKET.options], SO_ACCEPTCON
-        pop     eax
+        jnz     .notsupp
-        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              ; TODO: check if memory was available or not
-        lea     eax, [ebx + STREAM_SOCKET.rcv]
-        call    SOCKET_ring_create              ; TODO: same here
-        pusha
-        lea     ecx, [ebx + SOCKET.mutex]
-        call    mutex_unlock
-        popa
+        call    [eax + SOCKET.connect_proc]
-        push    ebx
-        mov     eax, ebx
-        call    TCP_output
-        pop     eax
+        mov     dword[esp+20], ebx
         mov     dword[esp+32], 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
+        ret
-        cmp     [eax + TCP_SOCKET.t_state], TCPS_ESTABLISHED
-        je      .established
         ja      .fail
   .notsupp:
-        call    SOCKET_block
+        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp+32], -1
-        jmp     .loop
+        ret
-  .fail:
-        mov     eax, [eax + SOCKET.errorcode]
-        mov     [esp+20], eax
-        mov     dword[esp+32], -1
-        ret
+  .invalid:
-  .established:
-        mov     dword[esp+32], 0
-        ret
+        mov     dword[esp+20], EINVAL
-align 4
-  .ip:
+        mov     dword[esp+32], -1
-        pusha
-        lea     ecx, [eax + SOCKET.mutex]
-        call    mutex_lock
-        popa
+        ret
         pushd   [edx + 4]
-        pop     [eax + IP_SOCKET.RemoteIP]
+  .already:
         mov     dword[esp+20], EALREADY
   .loop:
         push    edi
         call    [eax + SOCKET.rcv_proc]
         pop     edi
+        test    [eax + SOCKET.state], SS_CANTRCVMORE
+        jnz     .return
         cmp     ebx, EWOULDBLOCK
         jne     .return
-        test    edi, MSG_DONTWAIT
-        jnz     .return_err
-        test    [eax + SOCKET.state], SS_CANTRCVMORE
+        test    edi, MSG_DONTWAIT
         jnz     .return_err
 ;        test    [eax + SOCKET.options], SO_NONBLOCK
   .invalid:
         push    EINVAL
         pop     ebx
   .return_err:
-        mov     eax, -1
+        mov     ecx, -1
   .return:
         mov     [esp+20], ebx
-        mov     [esp+32], eax
+        mov     [esp+32], 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
         ja      .too_small
-        push    ecx
+        push    eax ecx
         push    [esi + socket_queue_entry.buf_ptr]              ; save the buffer addr so we can clear it later
         mov     esi, [esi + socket_queue_entry.data_ptr]
         jz      .nd
         rep movsd
   .nd:
         call    NET_packet_free
-        pop     eax                                             ; return number of bytes copied to application
+        pop     ecx eax                                         ; return number of bytes copied to application
         xor     ebx, ebx
         ret
   .too_small:
-        mov     eax, -1
+        mov     ecx, -1
         push    EMSGSIZE
         pop     ebx
         mov     ecx, esi
         mov     edi, edx
+        xor     edx, edx
         xor     edx, edx
         push    eax
         add     eax, STREAM_SOCKET.rcv
+        call    SOCKET_ring_read                                ; copy data from kernel buffer to application buffer
-        call    SOCKET_ring_read                                ; copy data from kernel buffer to application buffer
         call    SOCKET_ring_free                                ; free read memory
         pop     eax
         mov     eax, ecx                                        ; return number of bytes copied
         xor     ebx, ebx                                        ; errorcode = 0 (no error)
         ret
   .wouldblock:
-  .wouldblock:
+        push    EWOULDBLOCK
-        push    EWOULDBLOCK
+        pop     ebx
-        pop     ebx
+        xor     ecx, ecx
         ret
   .next_socket:
         mov     eax, [eax + SOCKET.NextPtr]
         or      eax, eax
+        jz      .error
-        jz      .error
+                diff16 "tetten", 0, $
         cmp     [eax + SOCKET.Number], ecx
         jne     .next_socket
+;
 ;------------------------------------------------------
 align 4
 SOCKET_process_end:
+        cmp     [net_sockets + SOCKET.NextPtr], 0       ; Are there any active sockets at all?
+        je      .quickret                               ; nope, exit immediately
+; TODO: run the following code in another thread, to avoid deadlock
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_process_end: %x\n", edx
         pusha
         pusha
         mov     ecx, socket_mutex
         call    mutex_unlock
         popa
   .quickret:
 align 4
 SOCKET_is_connecting:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connecting: %x\n", eax
-        and     [eax + SOCKET.options], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
+        and     [eax + SOCKET.state], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
-        or      [eax + SOCKET.options], SS_ISCONNECTING
+        or      [eax + SOCKET.state], SS_ISCONNECTING

Subversion Repositories Kolibri OS

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