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

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2004-2013. All rights reserved.    ;;
+;; Copyright (C) KolibriOS team 2004-2014. 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,                           ;;
 ;;         GNU GENERAL PUBLIC LICENSE                              ;;
 ;;          Version 2, June 1991                                   ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 4423 $
+$Revision: 5201 $
 struct  SOCKET
         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
-        pop     esi edx ecx
+        test    eax, eax
         jz      .nobuffs
         or      [eax + SOCKET.options], SO_NONBLOCK             ; Mark the socket as non blocking, we dont want it to block any longer!
         test    [eax + SOCKET.state], SS_BLOCKED                ; Is the socket still in blocked state?
         jz      @f
-        call    SOCKET_notify.unblock                           ; Unblock it.
+        call    SOCKET_notify                                   ; Unblock it.
   @@:
 SOCKET_pair:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_pair\n"
         call    SOCKET_alloc
-        call    SOCKET_alloc
+        test    eax, eax
         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
-        call    SOCKET_alloc
+        test    eax, eax
         jz      .nomem2
         mov     [esp+20], edi   ; application's ebx
         mov     [eax + SOCKET.device], ebx
         mov     [ebx + SOCKET.device], eax
         lea     eax, [eax + STREAM_SOCKET.rcv]
+        call    SOCKET_ring_create
+        test    eax, eax
-        call    SOCKET_ring_create
+        jz      .nomem1
         lea     eax, [ebx + STREAM_SOCKET.rcv]
+        call    SOCKET_ring_create
-        call    SOCKET_ring_create
+        test    eax, eax
-        pop     eax
+        jz      .nomem2
         ret
 ;--------------------------
+;
 ; IN: eax = ptr to ring struct (just a buffer of the right size)
-; eax = ptr to ring struct (just a buffer of the right size)
+; OUT: eax = unchanged / 0 on error
+;
 align 4
 SOCKET_ring_create:
         push    esi
         mov     esi, eax
+        push    edx
         stdcall create_ring_buffer, SOCKET_MAXDATA, PG_SW
-        push    edx
+        pop     edx
-        stdcall create_ring_buffer, SOCKET_MAXDATA, PG_SW
+        test    eax, eax
         add     eax, SOCKET_MAXDATA
         mov     [esi + RING_BUFFER.end_ptr], eax
         mov     eax, esi
         pop     esi
   .fail:
         ret
 ;-----------------------------------------------------------------
         add     edi, ecx
         cmp     edi, [eax + RING_BUFFER.end_ptr]
         jb      @f
         sub     edi, SOCKET_MAXDATA                             ; WRAP
   @@:
         mov     [eax + RING_BUFFER.write_ptr], edi
         pop     edi
 ; update size
 align 4
 SOCKET_block:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: %x\n", eax
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: %x\n", eax
+        push    eax
         pushf
-        push    eax
+        pushf
         cli
         ; Remember the thread ID so we can wake it up again
         mov     edx, [edx + TASKDATA.pid]
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: suspending thread: %u\n", edx
         mov     [eax + SOCKET.TID], edx
         pop     edx
+        popf
         call    change_task
-        pop     eax
-        popf
+        pop     eax
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: continueing\n"
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: continuing\n"
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: %x\n", eax
         call    SOCKET_check
-        jz      .error
-        test    [eax + SOCKET.state], SS_BLOCKED
-        jnz     .unblock
-;        test    [eax + SOCKET.options], SO_NONBLOCK
-;        jz      .error
-        push    eax ecx esi
-; socket exists and is of non blocking type.
-; We'll try to flag an event to the thread
-        mov     eax, [eax + SOCKET.TID]
-        test    eax, eax
-        jz      .done
+        jz      .error
-        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     .done
-  .found_pid:
-        shl     ecx, 8
-        or      [ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: poking thread %u!\n", eax
-        jmp     .done
-  .unblock:
-        push    eax ecx esi
-        ; Clear the 'socket is blocked' flag
-        and     [eax + SOCKET.state], not SS_BLOCKED
+; Find the associated thread's TASK_DATA
-        ; Find the thread's TASK_DATA
+        push    ebx ecx esi
-        mov     eax, [eax + SOCKET.TID]
+        mov     ebx, [eax + SOCKET.TID]
-        test    eax, eax
+        test    ebx, ebx
-        jz      .error
+        jz      .error2
         xor     ecx, ecx
         inc     ecx
         mov     esi, TASK_DATA
   .next:
-        cmp     [esi + TASKDATA.pid], eax
+        cmp     [esi + TASKDATA.pid], ebx
         je      .found
         inc     ecx
         add     esi, 0x20
+        cmp     ecx, [TASK_COUNT]
+        jbe     .next
+  .error2:
-        cmp     ecx, [TASK_COUNT]
+; PID not found, TODO: close socket!
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_notify: error finding thread 0x%x !\n", ebx
+        pop     esi ecx ebx
+        ret
+  .error:
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_notify: invalid socket ptr: 0x%x !\n", eax
-        jbe     .next
+        ret
+  .found:
+        test    [eax + SOCKET.state], SS_BLOCKED
-        jmp     .error
+        jnz     .un_block
-  .found:
+; socket and thread exists and socket is of non blocking type.
-        ; Run the thread
+; We'll try to flag an event to the thread.
-        mov     [esi + TASKDATA.state], 0       ; Running
+        shl     ecx, 8
+        or      [ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: Unblocked socket!\n"
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: poking thread %u!\n", eax
+        pop     esi ecx ebx
+        ret
+  .un_block:
+; socket and thread exists and socket is of blocking type
+; We'll try to unblock it.
         and     [eax + SOCKET.state], not SS_BLOCKED    ; Clear the 'socket is blocked' flag
-  .done:
+        mov     [esi + TASKDATA.state], 0               ; Run the thread
         pop     esi ecx eax
 ; 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:
         call    mutex_unlock
         popa
        @@:
-        mov     [net_sockets + SOCKET.NextPtr], eax
-        or      eax, eax                ; used to clear zero flag
+        mov     [net_sockets + SOCKET.NextPtr], eax
         pusha
         mov     ecx, socket_mutex
         cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
         jnz     .no_tcp
+        mov     ebx, eax
         cmp     [ebx + STREAM_SOCKET.rcv.start_ptr], 0
+        je      @f
+        stdcall kernel_free, [ebx + STREAM_SOCKET.rcv.start_ptr]
+  @@:
-        mov     ebx, eax
+        cmp     [ebx + STREAM_SOCKET.snd.start_ptr], 0
+        je      @f
-        stdcall kernel_free, [ebx + STREAM_SOCKET.rcv.start_ptr]
+        stdcall kernel_free, [ebx + STREAM_SOCKET.snd.start_ptr]
-        stdcall kernel_free, [ebx + STREAM_SOCKET.snd.start_ptr]
+  @@:
         mov     eax, ebx
   .no_tcp:
 ; Allocate new socket
         push    ebx
         call    SOCKET_alloc
+        pop     ebx
-        pop     ebx
+        test    eax, eax
         jz      .fail
         push    eax
         pusha
         mov     ecx, socket_mutex
         call    mutex_unlock
         popa
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: socket %u not found!\n", eax
-        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: not found\n", eax
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: caller = 0x%x\n", [esp]
         ret
+;
 ;------------------------------------------------------
 align 4
 SOCKET_process_end:
+        ret     ; FIXME
         cmp     [net_sockets + SOCKET.NextPtr], 0       ; Are there any active sockets at all?
         je      .quickret                               ; nope, exit immediately

Subversion Repositories Kolibri OS

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