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

 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$Revision: 3514 $
+ENOBUFS         = 1
+EOPNOTSUPP      = 4
+EWOULDBLOCK     = 6
+ENOTCONN        = 9
+EALREADY        = 10
+EINVAL          = 11
+EMSGSIZE        = 12
+ENOMEM          = 18
-$Revision: 3514 $
+EADDRINUSE      = 20
         cmp     ebx, 255
         jz      SOCKET_debug
         cmp     ebx, .number
-        ja      s_error
+        ja      .error
         jmp     dword [.table + 4*ebx]
         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+24], 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
         cmp     esi, PPP_PROTO_ETHERNET
         je      .pppoe
+  .no_ppp:
+  .unsupported:
+        push    eax
+        call    SOCKET_free
+        pop     eax
+        mov     dword[esp+24], EOPNOTSUPP
+        mov     dword[esp+32], -1
+        ret
+  .nobuffs:
-  .no_ppp:
+        mov     dword[esp+24], 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
-        cmp     esi, IP_PROTO_ICMP
-        je      .icmp
+        jz      .raw_ip
-        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+24], EOPNOTSUPP
+        mov     dword[esp+32], -1
-        je      .af_inet4
+        ret
-        cmp     word [edx], AF_LOCAL
-        je      .af_local
+  .invalid:
         mov     dword[esp+24], 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:
         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+24], EOPNOTSUPP
+        mov     dword[esp+32], -1
+        ret
-        cmp     word [edx], AF_INET4
+  .invalid:
-        je      .af_inet4
+        mov     dword[esp+24], EINVAL
         mov     dword[esp+32], -1
         je      .ip
         cmp     [eax + SOCKET.Protocol], IP_PROTO_ICMP
         je      .ip
-        jmp     s_error
+        jmp     .notsupp
 align 4
 ;        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
+        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
 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+24], EOPNOTSUPP
+        mov     dword[esp+32], -1
+        ret
+  .invalid:
+        mov     dword[esp+24], EINVAL
+        mov     dword[esp+32], -1
+        ret
+  .already:
-        mov     dword [esp+32], 0
+        mov     dword[esp+24], 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+24], EWOULDBLOCK
+        mov     dword[esp+32], -1
-        jz      s_error
+        ret
 ; and return it to caller
-        mov     [esp+32], eax
+  .invalid:
-        ret
+        mov     dword[esp+24], 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
         call    SOCKET_free
+        ret
+  .invalid:
+        mov     dword[esp+24], 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
         jz      s_error
         call    [eax + SOCKET.rcv_proc]
+        mov     [esp+24], ebx
+        mov     [esp+32], eax
+        ret
         call    [eax + SOCKET.rcv_proc]
   .invalid:
-        mov     [esp+32], eax
-        ret
+        mov     dword[esp+24], EINVAL
         mov     dword[esp+32], -1
         ret
         rep     movsd
   .nd:
         call    kernel_free                                     ; remove the packet
-        pop     eax
         pop     eax
         ret
-  .too_small:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: Buffer too small\n"
+  .too_small:
-  .fail:
+        mov     eax, -1
-        mov     eax, -1
+        mov     ebx, EMSGSIZE
         ret
   .block:
         test    [eax + SOCKET.options], SO_NONBLOCK
+        jnz     .wouldblock
+        call    SOCKET_block
+        jmp     .loop
-        jnz     .fail
+  .wouldblock:
         mov     eax, -1
-        call    SOCKET_block
+        mov     ebx, EWOULDBLOCK
         mov     eax, [eax + STREAM_SOCKET.rcv + RING_BUFFER.size]
         ret
   .block:
         test    [eax + SOCKET.options], SO_NONBLOCK
-        jnz     .return0
+        jnz     .wouldblock
         call    SOCKET_block
   .ok:
         xor     eax, eax
+        ret
+  .wouldblock:
+        mov     eax, -1
+        mov     ebx, EWOULDBLOCK
+        ret
         ret
 ;-----------------------------------------------------------------
 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+24], 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+24], 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+24], 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+24], 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+24], 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+24], 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     s_error
+        jne     .invalid
+        cmp     dword [edx+4], SO_BINDTODEVICE
-        cmp     dword [edx+4], SO_BINDTODEVICE
+        je      .bind
+        cmp     dword [edx+4], SO_BLOCK
-        je      .bind
+        je      .block
-        cmp     dword [edx+4], SO_BLOCK
+  .invalid:
-        je      .block
+        mov     dword[esp+32], -1
         mov     dword[esp+24], 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]
         or      [eax + SOCKET.options], SO_NONBLOCK
-        mov     dword [esp+32], 0       ; success!
+        mov     dword[esp+32], 0        ; success!
+        ret
+  .already:
+        mov     dword[esp+24], EALREADY
+        mov     dword[esp+32], -1
+        ret
         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     [eax + SOCKET.Domain], AF_LOCAL
         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
         xor     eax, eax
         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], s_error
+        mov     [eax + SOCKET.rcv_proc], .not_yet
         pusha
         mov     ecx, socket_mutex
   .exit:
         pop     ebx
+        ret
+  .not_yet:
+        mov     dword[esp+24], ENOTCONN
+        mov     dword[esp+32], -1
         ret
 ;----------------------------------------------------
 SOCKET_cant_send_more:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_cant_send_more: %x\n", eax
         or      [eax + SOCKET.options], 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+24], ENOTCONN

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/socket.inc @ 5442 – Rev 3652 → 3658