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

 ;;         GNU GENERAL PUBLIC LICENSE                              ;;
 ;;          Version 2, June 1991                                   ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 9739 $
+$Revision: 9917 $
 struct  SOCKET
         backlog                 dw ?    ; number of incoming connections that can be queued
         snd_proc                dd ?
         rcv_proc                dd ?
+        connect_proc            dd ?
+        ;sndto_proc              dd ?
-        connect_proc            dd ?
+        ;rcvfrom_proc            dd ?
 ;                                                                 ;
 ;-----------------------------------------------------------------;
 align 4
 sys_socket:
-        mov     dword[esp+20], 0        ; Set error code to 0
+        mov     dword[esp + SYSCALL_STACK.ebx], 0        ; Set error code to 0
         cmp     ebx, 255
         dd      socket_send             ; 6
         dd      socket_receive          ; 7
         dd      socket_set_opt          ; 8
         dd      socket_get_opt          ; 9
         dd      socket_pair             ; 10
+        ;dd      socket_sendto           ; 11
+        ;dd      socket_recvfrom         ; 12
   .number = ($ - .table) / 4 - 1
   .error:
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
         ret
         call    socket_alloc
         pop     esi edx ecx
         test    eax, eax
         jz      .nobuffs
-        mov     [esp+32], edi           ; return socketnumber
+        mov     [esp + SYSCALL_STACK.eax], edi    ; return socketnumber
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_open: socknum=%u\n", edi
         test    edx, SO_NONBLOCK
   .no_ppp:
   .unsupported:
         push    eax
         call    socket_free
         pop     eax
-        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .nobuffs:
-        mov     dword[esp+20], ENOBUFS
+        mov     dword[esp + SYSCALL_STACK.ebx], ENOBUFS
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .raw:
         cmp     word[edx], AF_LOCAL
         je      .af_local
   .notsupp:
-        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .af_local:
         ; TODO: write code here
-        mov     dword[esp+32], 0
+        mov     dword[esp + SYSCALL_STACK.eax], 0
   .done:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "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
+        mov     dword[esp + SYSCALL_STACK.eax], 0
         ret
   .addrinuse:
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         test    [eax + SOCKET.options], SO_ACCEPTCON
         jnz     .notsupp
         call    [eax + SOCKET.connect_proc]
-        mov     dword[esp+20], ebx
+        mov     dword[esp + SYSCALL_STACK.ebx], ebx
-        mov     dword[esp+32], eax
+        mov     dword[esp + SYSCALL_STACK.eax], eax
         ret
   .notsupp:
-        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
         push    eax
         init_queue (eax + SOCKET_QUEUE_LOCATION)                ; Set up sockets queue
         pop     eax
-        mov     dword[esp+32], 0
+        mov     dword[esp + SYSCALL_STACK.eax], 0
         ret
   .notsupp:
-        mov     dword[esp+20], EOPNOTSUPP
+        mov     dword[esp + SYSCALL_STACK.ebx], EOPNOTSUPP
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .already:
         mov     ebx, [ebx + APPDATA.tid]
         mov     [eax + SOCKET.TID], ebx
 ; Return socket number to caller
         mov     eax, [eax + SOCKET.Number]
-        mov     [esp+32], eax
+        mov     [esp + SYSCALL_STACK.eax], 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 + SYSCALL_STACK.ebx], EWOULDBLOCK
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
   .notsupp:
         call    socket_num_to_ptr
         test    eax, eax
         jz      .invalid
-        mov     dword[esp+32], 0                                ; The socket exists, so we will succeed in closing it.
+        mov     dword[esp + SYSCALL_STACK.eax], 0               ; The socket exists, so we will succeed in closing it.
 ;       call    socket_free
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
         push    EINVAL
         pop     ebx
   .return_err:
         mov     ecx, -1
   .return:
-        mov     [esp+20], ebx
+        mov     [esp + SYSCALL_STACK.ebx], ebx
-        mov     [esp+32], ecx
+        mov     [esp + SYSCALL_STACK.eax], ecx
         ret
   .last_data:
         test    ecx, ecx
         mov     esi, edx
         jmp     [eax + SOCKET.snd_proc]
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         ret
 align 4
 socket_send_udp:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: UDP\n"
-        mov     [esp+32], ecx
+        mov     [esp + SYSCALL_STACK.eax], ecx
         call    udp_output
         cmp     eax, -1
         je      .error
         ret
         push    eax
         add     eax, STREAM_SOCKET.snd
         call    socket_ring_write
         pop     eax
-        mov     [esp+32], ecx
+        mov     [esp + SYSCALL_STACK.eax], 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]
-        mov     [esp+20], eax
+        mov     [esp + SYSCALL_STACK.ebx], eax
         ret
 align 4
 socket_send_ip:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: IPv4\n"
-        mov     [esp+32], ecx
+        mov     [esp + SYSCALL_STACK.eax], ecx
         call    ipv4_output_raw
         cmp     eax, -1
         je      .error
         ret
   .error:
-        mov     dword[esp+32], eax
+        mov     dword[esp + SYSCALL_STACK.eax], eax
-        mov     dword[esp+20], ebx
+        mov     dword[esp + SYSCALL_STACK.ebx], ebx
         ret
 align 4
 socket_send_icmp:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: ICMP\n"
-        mov     [esp+32], ecx
+        mov     [esp + SYSCALL_STACK.eax], ecx
         call    icmp_output_raw
         cmp     eax, -1
         je      .error
         ret
   .error:
-        mov     dword[esp+32], eax
+        mov     dword[esp + SYSCALL_STACK.eax], eax
-        mov     dword[esp+20], ebx
+        mov     dword[esp + SYSCALL_STACK.ebx], ebx
         ret
 ;align 4
 ;socket_send_pppoe:
 ;
 ;        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: PPPoE\n"
+;
         add     eax, STREAM_SOCKET.rcv
         call    socket_ring_write
         pop     eax
         ; return the number of written bytes (or errorcode) to application
-        mov     [esp+32], ecx
+        mov     [esp + SYSCALL_STACK.eax], ecx
         ; and notify the other end
         call    socket_notify
         ret
   .invalid:
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
         mov     eax, [edx+8]
         test    eax, eax
         jz      @f
         mov     [eax], ecx
 @@:
-        mov     dword [esp+32], 0
+        mov     dword [esp + SYSCALL_STACK.eax], 0
         ret
   .invalid:
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
         ret
         jz      .already
         mov     [eax + SOCKET.device], edx
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt: Bound socket %x to device %x\n", eax, edx
-        mov     dword[esp+32], 0        ; success!
+        mov     dword[esp + SYSCALL_STACK.eax], 0        ; success!
         ret
   .unbind:
         mov     [eax + SOCKET.device], 0
-        mov     dword[esp+32], 0        ; success!
+        mov     dword[esp + SYSCALL_STACK.eax], 0        ; success!
         ret
   .ip:
         cmp     [edx + socket_options.optname], IP_TTL
         jne     .invalid
   .ttl:
         mov     bl, byte[edx + socket_options.optval]
         mov     [eax + IP_SOCKET.ttl], bl
-        mov     dword[esp+32], 0        ; success!
+        mov     dword[esp + SYSCALL_STACK.eax], 0        ; success!
         ret
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_pair\n"
         call    socket_alloc
         test    eax, eax
         jz      .nomem1
-        mov     [esp+32], edi   ; application's eax
+        mov     [esp + SYSCALL_STACK.eax], edi   ; application's eax
         mov     [eax + SOCKET.Domain], AF_LOCAL
         mov     [eax + SOCKET.Type], SOCK_STREAM
         mov     ebx, eax
         call    socket_alloc
         test    eax, eax
         jz      .nomem2
-        mov     [esp+20], edi   ; application's ebx
+        mov     [esp + SYSCALL_STACK.ebx], edi   ; application's ebx
         mov     [eax + SOCKET.Domain], AF_LOCAL
         mov     [eax + SOCKET.Type], SOCK_STREAM
         jz      .nomem2
         ret
   .nomem2:
-        mov     eax, [esp+20]
+        mov     eax, [esp + SYSCALL_STACK.ebx]
         call    socket_free
   .nomem1:
-        mov     eax, [esp+32]
+        mov     eax, [esp + SYSCALL_STACK.eax]
         call    socket_free
         stosd
         jmp     .next_socket
   .done:
         xor     eax, eax
         stosd
-        mov     dword[esp+32], eax
+        mov     dword[esp + SYSCALL_STACK.eax], eax
         ret
   .invalid:
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp + SYSCALL_STACK.ebx], EINVAL
         ret
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: %x\n", eax
         call    socket_check
         jz      .error
-; Find the associated thread's TASK_DATA
+; Find the associated thread's
         push    ebx ecx esi
         mov     ebx, [eax + SOCKET.TID]
         test    ebx, ebx
         test    [eax + SOCKET.state], SS_BLOCKED
         jnz     .un_block
 ; Socket and thread exists and socket is of non blocking type.
-; We'll try to flag an event to the thread.
-        shl     ecx, BSF sizeof.APPDATA
+; We'll try to flag an event to the thread.
-        or      [SLOT_BASE + ecx + APPDATA.occurred_events], EVENT_NETWORK
+        or      [esi + APPDATA.occurred_events], EVENT_NETWORK
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: poking thread %u!\n", ebx
         pop     esi ecx ebx
         ret
-  .un_block:
-; Socket and thread exists and socket is of blocking type
+  .un_block:
-; We'll try to unblock it.
+; Socket and thread exists and socket is of blocking type
-        and     [eax + SOCKET.state], not SS_BLOCKED    ; Clear the 'socket is blocked' flag
+; We'll try to unblock it.
-        shl     ecx, BSF sizeof.APPDATA
+        and     [eax + SOCKET.state], not SS_BLOCKED    ; Clear the 'socket is blocked' flag
         or      [eax + SOCKET.state], SS_CANTSENDMORE
         mov     [eax + SOCKET.snd_proc], .notconn
         jmp     socket_notify
   .notconn:
-        mov     dword[esp+20], ENOTCONN
+        mov     dword[esp + SYSCALL_STACK.ebx], ENOTCONN
-        mov     dword[esp+32], -1
+        mov     dword[esp + SYSCALL_STACK.eax], -1

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/socket.inc – Rev 9739 → 9917