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

         mov     [esp+32], edi                   ; return socketnumber
         DEBUGF  DEBUG_NETWORK_VERBOSE, "socknum=%u\n", edi
 ;        push    edx
 ;        and     edx, SO_NONBLOCK
-        or      [eax + SOCKET.options], SO_NONBLOCK ;edx        ; HACK: make all sockets non-blocking untill API and applications are fixed
+;        or      [eax + SOCKET.options], SO_NONBLOCK ;edx        ; HACK: make all sockets non-blocking untill API and applications are fixed
 ;        pop     edx
 ;        and     edx, not SO_NONBLOCK
   .block:
         test    [eax + SOCKET.options], SO_NONBLOCK
         jz      .loop
         mov     dword[esp+20], EWOULDBLOCK
-        mov     dword[esp+32], 0                 ; Should be -1? or not?
+        mov     dword[esp+32], -1
         ret
   .loop:
         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
-        jz      .invalid
+  .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
   .return_err:
-        call    [eax + SOCKET.rcv_proc]
+        mov     eax, -1
   .return:
         mov     [esp+20], ebx
-        mov     [esp+32], eax
-        ret
+        mov     [esp+32], eax
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
-        mov     dword[esp+32], -1
-        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
   .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:
+        mov     eax, -1
-        mov     eax, -1
+        push    EMSGSIZE
-        mov     ebx, EMSGSIZE
-        ret
-  .block:
-        test    [eax + SOCKET.options], SO_NONBLOCK
-        jnz     .wouldblock
-        call    SOCKET_block
+        pop     ebx
-        jmp     .loop
+        ret
   .wouldblock:
+        push    EWOULDBLOCK
-        mov     eax, -1
+        pop     ebx
-        mov     ebx, EWOULDBLOCK
+        ret
         ret
-        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
-        call    SOCKET_ring_read
-        call    SOCKET_ring_free
-        mov     eax, ecx                ; return number of bytes copied
-        ret
-  .peek:
-        mov     eax, [eax + STREAM_SOCKET.rcv + RING_BUFFER.size]
-        ret
-  .block:
-        test    [eax + SOCKET.options], SO_NONBLOCK
-        jnz     .wouldblock
-        call    SOCKET_block
-        jmp     .loop
-  .return0:
-        test    [eax + SOCKET.options], SS_CANTRCVMORE
-        jz      .ok
-        xor     eax, eax
+        add     eax, STREAM_SOCKET.rcv
-        dec     eax
+        call    SOCKET_ring_read                                ; copy data from kernel buffer to application buffer
-        ret
+        call    SOCKET_ring_free                                ; free read memory
-  .ok:
+        mov     eax, ecx                                        ; return number of bytes copied
+        xor     ebx, ebx                                        ; errorcode = 0 (no error)
+        ret
+  .wouldblock:
-        xor     eax, eax
+        push    EWOULDBLOCK
-        ret
+        pop     ebx
         ret
         jne     .invalid
         cmp     dword [edx+4], SO_BINDTODEVICE
-        je      .bind
-        cmp     dword [edx+4], SO_BLOCK
-        je      .block
+        je      .bind
   .invalid:
         mov     dword[esp+32], -1
         mov     [eax + SOCKET.device], 0
         mov     dword[esp+32], 0        ; success!
-        ret
-  .block:
-        cmp     dword[edx+8], 0
-        je      .unblock
-        and     [eax + SOCKET.options], not SO_NONBLOCK
-        mov     dword[esp+32], 0        ; success!
-        ret
-  .unblock:
-        or      [eax + SOCKET.options], SO_NONBLOCK
-        mov     dword[esp+32], 0        ; success!
         ret
   .already:
         mov     dword[esp+20], EALREADY
         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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/socket.inc – Rev 3698 → 3704