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

 ;;         GNU GENERAL PUBLIC LICENSE                              ;;
 ;;          Version 2, June 1991                                   ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 5594 $
+$Revision: 5984 $
 struct  SOCKET
         mutex                   MUTEX
-        PID                     dd ? ; process ID
+        PID                     dd ?    ; process ID
-        TID                     dd ? ; thread ID
+        TID                     dd ?    ; thread ID
-        Domain                  dd ? ; INET/LOCAL/..
+        Domain                  dd ?    ; INET4/INET6/LOCAL/..
-        Type                    dd ? ; RAW/STREAM/DGRAM
+        Type                    dd ?    ; RAW/STREAM/DGRAM
-        Protocol                dd ? ; ICMP/IPv4/ARP/TCP/UDP
+        Protocol                dd ?    ; UDP/TCP/ARP/ICMP
         errorcode               dd ?
-        device                  dd ? ; driver pointer, socket pointer if it's an LOCAL socket
+        device                  dd ?    ; device pointer, paired socket pointer if it's a local socket
         options                 dd ?
         state                   dd ?
-        backlog                 dw ? ; how many incoming connections that can be queued
+        backlog                 dw ?    ; number of incoming connections that can be queued
 struct  IP_SOCKET               SOCKET
+        LocalIP                 rd 4    ; network byte order
+        RemoteIP                rd 4    ; network byte order
-        LocalIP                 rd 4 ; network byte order
+        ttl                     db ?
-        RemoteIP                rd 4 ; network byte order
+                                rb 3    ; align
 ends
 struct  UDP_SOCKET              IP_SOCKET
-        LocalPort               dw ? ; network byte order
-        RemotePort              dw ? ; network byte order
-ends
 struct  ICMP_SOCKET             IP_SOCKET
-        Identifier              dw ?
+        LocalPort               dw ?    ; in network byte order
         RemotePort              dw ?    ; in network byte order
 ends
 ends
         data_size               dd ?
         buf_ptr                 dd ?
+ends
+struct  socket_options
+        level                   dd ?
+        optname                 dd ?
+        optlen                  dd ?
+        optval                  dd ?
 ends
 ends
 uglobal
 align 4
         net_sockets     rd 4
         last_socket_num dd ?
-        last_UDP_port   dw ? ; These values give the number of the last used ephemeral port
+        last_UDP_port   dw ?            ; last used ephemeral port
-        last_TCP_port   dw ? ;
+        last_TCP_port   dw ?            ;
         socket_mutex    MUTEX
-endg
+endg
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 ;                                                                 ;
-; SOCKET_init
+; SOCKET_init                                                     ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
         mov     ecx, socket_mutex
         call    mutex_init
 }
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; Socket API (function 74)
+; Sockets API (system function 75)                                ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
         mov     dword[esp+32], -1
         mov     dword[esp+20], EINVAL
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_open
+; SOCKET_open: Create a new socket.                               ;
-;
+;                                                                 ;
-;  IN:  domain in ecx
+;   IN: ecx = domain                                              ;
+;       edx = type                                                ;
-;       type in edx
+;       esi = protocol                                            ;
-;       protocol in esi
+;                                                                 ;
+;  OUT: eax = socket number                                       ;
+;       eax = -1 on error                                         ;
-;  OUT: eax is socket num, -1 on error
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
         mov     [eax + SOCKET.connect_proc], connect_notsupp
         cmp     ecx, AF_INET4
+        jne     .no_inet4
-        jne     .no_inet4
+        mov     [eax + IP_SOCKET.ttl], 128
         cmp     edx, SOCK_DGRAM
         je      .udp
         jmp     .unsupported
+align 4
+  .udp:
+        push    eax
+        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
-align 4
+        pop     eax
   .udp:
         mov     [eax + SOCKET.Protocol], IP_PROTO_UDP
         mov     [eax + SOCKET.snd_proc], SOCKET_send_udp
         mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
         ret
+align 4
+  .raw_ip:
+        push    eax
+        init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
-align 4
+        pop     eax
   .raw_ip:
         mov     [eax + SOCKET.snd_proc], SOCKET_send_ip
         mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
         mov     [eax + SOCKET.connect_proc], IPv4_connect
         ret
+align 4
+  .raw_icmp:
         push    eax
         init_queue (eax + SOCKET_QUEUE_LOCATION)        ; Set up data receiving queue
-align 4
+        pop     eax
   .raw_icmp:
         mov     [eax + SOCKET.snd_proc], SOCKET_send_pppoe
         mov     [eax + SOCKET.rcv_proc], SOCKET_receive_dgram
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_bind
+; SOCKET_bind: Bind to a local port.                              ;
-;
+;                                                                 ;
-;  IN:  socket number in ecx
+;   IN: ecx = socket number                                       ;
+;       edx = pointer to sockaddr struct                          ;
-;       pointer to sockaddr struct in edx
+;       esi = length of sockaddr struct                           ;
-;       length of that struct in esi
+;                                                                 ;
+;  OUT: eax = 0 on success                                        ;
+;       eax = -1 on error                                         ;
-;  OUT: 0 on success
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_bind:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_bind: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         call    SOCKET_num_to_ptr
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_connect
+; SOCKET_connect: Connect to the remote host.                     ;
+;                                                                 ;
-;
+;   IN: ecx = socket number                                       ;
-;  IN:  socket number in ecx
+;       edx = pointer to sockaddr struct                          ;
+;       esi = length of sockaddr struct                           ;
+;                                                                 ;
-;       pointer to sockaddr struct in edx
+;  OUT: eax = 0 on success                                        ;
-;       length of that struct in esi
+;       eax = -1 on error                                         ;
-;  OUT: 0 on success
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
+align 4
-align 4
+SOCKET_connect:
 SOCKET_connect:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_connect: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         dec     eax
         mov     ebx, EOPNOTSUPP
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_listen
+; SOCKET_listen: Listen for incoming connections.                 ;
-;
+;                                                                 ;
+;   IN: ecx = socket number                                       ;
-;  IN:  socket number in ecx
+;       edx = backlog in edx                                      ;
-;       backlog in edx
+;                                                                 ;
+;  OUT: eax = 0 on success                                        ;
+;       eax = -1 on error                                         ;
-;  OUT: eax is socket num, -1 on error
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_listen:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_listen: socknum=%u backlog=%u\n", ecx, edx
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_listen: socknum=%u backlog=%u\n", ecx, edx
         call    SOCKET_num_to_ptr
         mov     dword[esp+20], EALREADY
         mov     dword[esp+32], -1
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_accept
+; SOCKET_accept: Accept an incoming connection.                   ;
-;
+;                                                                 ;
-;  IN:  socket number in ecx
+;   IN: ecx = socket number (of listening socket)                 ;
+;       edx = ptr to sockaddr struct                              ;
-;       addr in edx
+;       esi = length of sockaddr struct                           ;
-;       addrlen in esi
+;                                                                 ;
+;  OUT: eax = newly created socket num                            ;
+;       eax = -1 on error                                         ;
-;  OUT: eax is socket num, -1 on error
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_accept:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_accept: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_accept: socknum=%u sockaddr=%x length=%u\n", ecx, edx, esi
         call    SOCKET_num_to_ptr
         get_from_queue (eax + SOCKET_QUEUE_LOCATION), MAX_backlog, 4, .block
 ; Ok, we got a socket ptr
+        mov     eax, [esi]
+; Verify that it is (still) a valid socket
+        call    SOCKET_check
-        mov     eax, [esi]
+        jz      .invalid
-; Change thread ID to that of the current thread
+; Change sockets thread owner ID to that of the current thread
         mov     ebx, [TASK_BASE]
         mov     ebx, [ebx + TASKDATA.pid]
-        mov     [eax + SOCKET.TID], ebx
+        mov     [eax + SOCKET.TID], ebx
-; Convert it to a socket number
-        call    SOCKET_ptr_to_num
         jz      .invalid        ; FIXME ?
 ; Return socket number to caller
-; and return it to caller
+        mov     eax, [eax + SOCKET.Number]
         mov     [esp+32], eax
   .notsupp:
         mov     dword[esp+20], EOPNOTSUPP
         mov     dword[esp+32], -1
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_close
+; SOCKET_close: Close the socket (and connection).                ;
-;
+;                                                                 ;
+;   IN: ecx = socket number                                       ;
-;  IN:  socket number in ecx
+;                                                                 ;
-;  OUT: eax is socket num, -1 on error
+;  OUT: eax = 0 on success                                        ;
+;       eax = -1 on error                                         ;
+;       ebx = errorcode on error                                  ;
-;
+;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_close:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_close: socknum=%u\n", ecx
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_close: socknum=%u\n", ecx
         call    SOCKET_num_to_ptr
-        call    SOCKET_num_to_ptr
+        test    eax, eax
   .free:
         call    SOCKET_free
         ret
-  .tcp:
   .tcp:
         call    TCP_usrclosed
         test    eax, eax
         jz      @f
-        call    TCP_output                                      ; If connection is not closed yet, send the FIN
-  @@:
+        call    TCP_output                                      ; If connection is not closed yet, send the FIN
   @@:
         ret
   .invalid:
-        mov     dword[esp+20], EINVAL
+        mov     dword[esp+20], EINVAL
         mov     dword[esp+32], -1
-        ret
+        ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
+; SOCKET_receive: Receive some data from the remote end.          ;
-; SOCKET_receive
+;                                                                 ;
-;
+;   IN: ecx = socket number                                       ;
+;       edx = addr to application buffer                          ;
+;       edx = length of application buffer                        ;
+;       edi = flags                                               ;
-;  IN:  socket number in ecx
+;                                                                 ;
-;       addr to buffer in edx
+;  OUT: eax = number of bytes copied                              ;
-;       length of buffer in esi
+;       eax = -1 on error                                         ;
-;       flags in edi
+;       eax = 0 when socket has been closed by the remote end     ;
-;  OUT: eax is number of bytes copied, -1 on error
+;       ebx = errorcode on error                                  ;
+;                                                                 ;
 ;-----------------------------------------------------------------;
-;-----------------------------------------------------------------
+align 4
-align 4
+SOCKET_receive:
 SOCKET_receive:
         jne     .return
         test    edi, MSG_DONTWAIT
         jnz     .return_err
-;        test    [eax + SOCKET.options], SO_NONBLOCK
+        test    [eax + SOCKET.options], SO_NONBLOCK
-;        jnz     .return_err
+        jnz     .return_err
         ret
   .last_data:
         test    ecx, ecx
         jz      .return
-        call    SOCKET_notify
+        call    SOCKET_notify                                   ; Call me again!
         jmp     .return
+align 4
 SOCKET_receive_dgram:
-align 4
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_receive: DGRAM\n"
 SOCKET_receive_dgram:
         rep movsd
   .nd:
         call    NET_BUFF_free
+        pop     ecx eax                                         ; return number of bytes copied to application
-        pop     ecx eax                                         ; return number of bytes copied to application
+        cmp     [eax + SOCKET_QUEUE_LOCATION + queue.size], 0
+        je      @f
+        call    SOCKET_notify                                   ; Queue another network event
+  @@:
-        xor     ebx, ebx
+        xor     ebx, ebx                                        ; errorcode = 0 (no error)
         ret
   .too_small:
   .wouldblock:
         push    EWOULDBLOCK
         pop     ebx
         ret
+  .peek:
+        xor     ebx, ebx
+        xor     ecx, ecx
+        cmp     [eax + SOCKET_QUEUE_LOCATION + queue.size], 0
+        je      @f
+        mov     esi, [eax + SOCKET_QUEUE_LOCATION + queue.r_ptr]
+        mov     ecx, [esi + socket_queue_entry.data_size]
+  @@:
         ret
         mov     ecx, [eax + STREAM_SOCKET.rcv + RING_BUFFER.size]
         xor     ebx, ebx
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
-; SOCKET_send
+;                                                                 ;
-;
+; SOCKET_send: Send some data to the remote end.                  ;
-;
+;                                                                 ;
-;  IN:  socket number in ecx
+;   IN: ecx = socket number                                       ;
-;       pointer to data in edx
+;       edx = pointer to data                                     ;
+;       esi = data length                                         ;
+;       edi = flags                                               ;
-;       datalength in esi
+;                                                                 ;
-;       flags in edi
+;  OUT: eax = number of bytes sent                                ;
+;       eax = -1 on error                                         ;
-;  OUT: -1 on error
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_send:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: socknum=%u data ptr=%x length=%u flags=%x\n", ecx, edx, esi, edi
         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
 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!
+        call    IPv4_output_raw
         cmp     eax, -1
         je      .error
         ret
   .error:
-        mov     dword[esp+32], -1
+        mov     dword[esp+32], eax
-        mov     dword[esp+20], EMSGSIZE
+        mov     dword[esp+20], ebx
         ret
 align 4
 SOCKET_send_icmp:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_send: ICMP\n"
         mov     [esp+32], ecx
-        call    ICMP_output_raw         ; FIXME: errorcodes
+        call    ICMP_output_raw
         cmp     eax, -1
         je      .error
         mov     dword[esp+32], -1
         mov     dword[esp+20], EINVAL
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_get_options
+; SOCKET_get_options: Read a socket option                        ;
-;
+;                                                                 ;
+;   IN: ecx = socket number                                       ;
+;       edx = pointer to socket options struct                    ;
+;                                                                 ;
+;  OUT: eax = 0 on success                                        ;
-;  IN:  ecx = socket number
+;       eax = -1 on error                                         ;
+;       ebx = errorcode on error                                  ;
+;                                                                 ;
-;       edx = pointer to the options:
+;-----------------------------------------------------------------;
-;               dd      level, optname, optval, optlen
+align 4
+SOCKET_get_opt:
 ;  OUT: -1 on error
 ; FIXME:
 ; At moment, uses only pseudo-optname -2 for get last_ack_number for TCP.
-; TODO: find best way to notify that send()'ed data were acknowledged
-; Also pseudo-optname -3 is valid and returns socket state, one of TCPS_*.
-;
-;-----------------------------------------------------------------
-align 4
+; TODO: find best way to notify that send()'ed data were acknowledged
-SOCKET_get_opt:
+; Also pseudo-optname -3 is valid and returns socket state, one of TCPS_*.
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_get_opt\n"
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_get_opt\n"
         call    SOCKET_num_to_ptr
-        call    SOCKET_num_to_ptr
+        test    eax, eax
         mov     dword[esp+32], -1
         mov     dword[esp+20], EINVAL
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_set_options
+; SOCKET_set_options: Set a socket option.                        ;
-;
+;                                                                 ;
-;  IN:  ecx = socket number
+;   IN: ecx = socket number                                       ;
+;       edx = pointer to socket options struct                    ;
-;       edx = pointer to the options:
+;                                                                 ;
-;               dd      level, optname, optlen, optval
+;  OUT: eax = 0 on success                                        ;
+;       eax = -1 on error                                         ;
-;  OUT: -1 on error
+;       ebx = errorcode on error                                  ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_set_opt:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt\n"
+        call    SOCKET_num_to_ptr
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_set_opt\n"
+        test    eax, eax
         jz      .invalid
-        call    SOCKET_num_to_ptr
-        jz      .invalid
-        cmp     dword [edx], SOL_SOCKET
-        jne     .invalid
+        cmp     [edx + socket_options.level], IP_PROTO_IP
-        cmp     dword [edx+4], SO_BINDTODEVICE
+        je      .ip
-        je      .bind
+        cmp     [edx + socket_options.level], SOL_SOCKET
+        jne     .invalid
   .invalid:
-        mov     dword[esp+32], -1
+  .socket:
-        mov     dword[esp+20], EINVAL
+        cmp     [edx + socket_options.optname], SO_BINDTODEVICE
-        ret
+        jne     .invalid
   .bind:
         mov     [eax + SOCKET.device], 0
         mov     dword[esp+32], 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!
         ret
   .already:
         mov     dword[esp+20], EALREADY
+        mov     dword[esp+32], -1
+        ret
+  .invalid:
+        mov     dword[esp+20], EINVAL
         mov     dword[esp+32], -1
-        ret
+        ret
-;-----------------------------------------------------------------
-;
+;-----------------------------------------------------------------;
+;                                                                 ;
-; SOCKET_pair
+; SOCKET_pair: Allocate a pair of linked local sockets.           ;
-;
+;                                                                 ;
+;  IN: /                                                          ;
-; Allocates a pair of linked LOCAL domain sockets
+;                                                                 ;
 ; OUT: eax = socket1 num on success                               ;
-; IN: /
+;      eax = -1 on error                                          ;
-; OUT: eax is socket1 num, -1 on error
+;      ebx = socket2 num on success                               ;
         mov     [ebx + SOCKET.device], eax
         lea     eax, [eax + STREAM_SOCKET.rcv]
         call    SOCKET_ring_create
         test    eax, eax
-        jz      .nomem1
+        jz      .nomem2
         lea     eax, [ebx + STREAM_SOCKET.rcv]
         call    SOCKET_ring_create
         test    eax, eax
         jz      .nomem2
         ret
   .nomem2:
+        mov     eax, [esp+20]
+        call    SOCKET_free
-  .nomem2:
+  .nomem1:
-        mov     eax, ebx
+        mov     eax, [esp+32]
         call    SOCKET_free
-  .nomem1:
-        mov     dword[esp+32], -1
-        mov     dword[esp+28], ENOMEM
+        mov     dword[esp+32], -1
-        ret
+        mov     dword[esp+20], ENOMEM
+        ret
-;-----------------------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_debug
+;                                                                 ;
+; SOCKET_debug: Copy socket variables to application buffer.      ;
+;                                                                 ;
-;
+;   IN: ecx = socket number                                       ;
-;  Copies socket variables to application buffer
+;       edx = pointer to application buffer                       ;
 ;                                                                 ;
-;  IN:  ecx = socket number
+;  OUT: eax = 0 on success                                        ;
         test    ecx, ecx
         jz      .returnall
         call    SOCKET_num_to_ptr
-        call    SOCKET_num_to_ptr
+        test    eax, eax
         jz      .invalid
         mov     dword[esp+32], eax
         ret
   .invalid:
         mov     dword[esp+32], -1
-        mov     dword[esp+28], EINVAL
+        mov     dword[esp+20], EINVAL
         ret
+;-----------------------------------------------------------------;
+;   ____                                                 ____     ;
+;   \  /              End of sockets API                 \  /     ;
+;    \/                                                   \/      ;
+;    ()        Internally used functions follow           ()      ;
-;-----------------------------------------------------------------
+;                                                                 ;
+;-----------------------------------------------------------------;
-;
+;-----------------------------------------------------------------;
-; SOCKET_find_port
+;                                                                 ;
-;
+; SOCKET_find_port:                                               ;
-; Fills in the local port number for TCP and UDP sockets
+; Fill in the local port number for TCP and UDP sockets           ;
-; This procedure always works because the number of sockets is
+; This procedure always works because the number of sockets is    ;
+; limited to a smaller number then the number of possible ports   ;
-; limited to a smaller number then the number of possible ports
+;                                                                 ;
-;
+;  IN:  eax = socket pointer                                      ;
-;  IN:  eax = socket pointer
+;                                                                 ;
-;  OUT: /
+;  OUT: /                                                         ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
         jz      .findit
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_check_port (to be used with AF_INET only!)
+; SOCKET_check_port (to be used with AF_INET only!)               ;
-;
+;                                                                 ;
+; Checks if a local port number is unused                         ;
-; Checks if a local port number is unused
+; If the proposed port number is unused, it is filled in in the   ;
-; If the proposed port number is unused, it is filled in in the socket structure
+; socket structure                                                ;
-;
+;                                                                 ;
-;  IN:  eax = socket ptr (to find out if its a TCP/UDP socket)
+;   IN: eax = socket ptr                                          ;
-;        bx = proposed socket number (network byte order)
+;       bx = proposed socket number (network byte order)          ;
-;
+;                                                                 ;
-;  OUT:  ZF = set on error
+;  OUT: ZF = set on error                                         ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
         or      bx, bx                                  ; clear the zero-flag
         ret
-;-----------------------------------------------------------------
-;
-; SOCKET_input
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; Updates a (stateless) socket with received data
+; SOCKET_input: Update a (stateless) socket with received data.   ;
-;
+;                                                                 ;
-; Note: the mutex should already be set !
+; Note: The socket's mutex should already be set !                ;
-;
+;                                                                 ;
-;  IN:  eax = socket ptr
+;   IN: eax = socket ptr                                          ;
-;       ecx = data size
+;       ecx = data size                                           ;
-;       esi = ptr to data
+;       esi = ptr to data                                         ;
-;       [esp] = ptr to buf
+;       [esp] = ptr to buf                                        ;
-;
+;                                                                 ;
-;  OUT: /
+;  OUT: /                                                         ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
         pusha
         lea     ecx, [eax + SOCKET.mutex]
         call    mutex_unlock
         popa
         add     esp, 8
         call    NET_BUFF_free
         ret
+;-----------------------------------------------------------------;
+;                                                                 ;
-;--------------------------
+; SOCKET_ring_create: Create a ringbuffer for sockets.            ;
+;                                                                 ;
+;   IN: eax = ptr to ring struct                                  ;
+;                                                                 ;
+;  OUT: eax = 0 on error                                          ;
 ;       eax = start ptr                                           ;
-; eax = ptr to ring struct (just a buffer of the right size)
+;                                                                 ;
 ;-----------------------------------------------------------------;
 align 4
         stdcall create_ring_buffer, SOCKET_MAXDATA, PG_SWR
         pop     edx
         test    eax, eax
         jz      .fail
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_created: %x\n", eax
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_ring_create: %x\n", eax
         pusha
         lea     ecx, [esi + RING_BUFFER.mutex]
         mov     [esi + RING_BUFFER.size], 0
         add     eax, SOCKET_MAXDATA
         mov     [esi + RING_BUFFER.end_ptr], eax
         mov     eax, esi
+        pop     esi
+        ret
+  .fail:
-  .fail:
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_ring_create: Out of memory!\n"
         pop     esi
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
-; SOCKET_ring_write
+;                                                                 ;
-;
-; Adds data to a stream socket, and updates write pointer and size
+; SOCKET_ring_write: Write data to ring buffer.                   ;
-;
+;                                                                 ;
-;  IN:  eax = ptr to ring struct
+;   IN: eax = ptr to ring struct                                  ;
-;       ecx = data size
+;       ecx = data size                                           ;
-;       esi = ptr to data
+;       esi = ptr to data                                         ;
-;
+;                                                                 ;
-;  OUT: ecx = number of bytes stored
+;  OUT: ecx = number of bytes stored                              ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
         call    mutex_unlock                                    ; TODO: check what registers this function actually destroys
         popa
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; SOCKET_ring_read
+; SOCKET_ring_read: Read from ring buffer                         ;
-;
+;                                                                 ;
-;  IN:  eax = ring struct ptr
+;   IN: eax = ring struct ptr                                     ;
-;       ecx = bytes to read
+;       ecx = bytes to read                                       ;
-;       edx = offset
+;       edx = offset                                              ;
-;       edi = ptr to buffer start
+;       edi = ptr to buffer start                                 ;
-;
+;                                                                 ;
-;  OUT: eax = unchanged
+;  OUT: eax = unchanged                                           ;
-;       ecx = number of bytes read (0 on error)
+;       ecx = number of bytes read (0 on error)                   ;
-;       edx = destroyed
+;       edx = destroyed                                           ;
-;       esi = destroyed
+;       esi = destroyed                                           ;
-;       edi = ptr to buffer end
+;       edi = ptr to buffer end                                   ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
   .less_data:
         mov     ecx, edx
         jmp     .copy
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
-;
-; SOCKET_ring_free
+;                                                                 ;
-;
-; Free's some bytes from the ringbuffer
+; SOCKET_ring_free: Free data from a ringbuffer                   ;
-;
+;                                                                 ;
-;  IN:  eax = ptr to ring struct
+;   IN: eax = ptr to ring struct                                  ;
-;       ecx = data size
+;       ecx = data size                                           ;
-;
+;                                                                 ;
-;  OUT: ecx = number of bytes free-ed
+;  OUT: ecx = number of freed bytes                               ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
         xor     ecx, ecx
         ret
-;-----------------------------------------------------------------
-;
-; SOCKET_block
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
+; SOCKET_block: Suspend the thread attached to a socket.          ;
-; Suspends the thread attached to a socket
+;                                                                 ;
-;
+;   IN: eax = socket ptr                                          ;
-;  IN:  eax = socket ptr
+;                                                                 ;
-;  OUT: eax = unchanged
+;  OUT: eax = unchanged                                           ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_block: continuing\n"
         ret
-;-----------------------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_notify
-;
+;                                                                 ;
+; SOCKET_notify: Wake up socket owner thread.                     ;
-; notify's the owner of a socket that something happened
+;                                                                 ;
-;
+;   IN: eax = socket ptr                                          ;
-;  IN:  eax = socket ptr
+;                                                                 ;
-;  OUT: eax = unchanged
+;  OUT: eax = unchanged                                           ;
 ;                                                                 ;
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
   .found:
         test    [eax + SOCKET.state], SS_BLOCKED
         jnz     .un_block
-; socket and thread exists and socket is of non blocking type.
+; Socket and thread exists and socket is of non blocking type.
 ; We'll try to flag an event to the thread.
         shl     ecx, 8
         or      [ecx + SLOT_BASE + APPDATA.event_mask], EVENT_NETWORK
         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
+; 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
-        mov     [esi + TASKDATA.state], 0               ; Run the thread
+        mov     [esi + TASKDATA.state], 0               ; Run the thread
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: Unblocked socket!\n"
-        pop     esi ecx ebx
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_notify: Unblocked socket!\n"
-        ret
+        pop     esi ecx ebx
+        ret
-;--------------------------------------------------------------------
+;-----------------------------------------------------------------;
+;                                                                 ;
-;
+; SOCKET_alloc:                                                   ;
-; SOCKET_alloc
+; Allocate memory for socket and put new socket into the list.    ;
-;
+; Newly created socket is initialized with calling PID and socket ;
-; Allocate memory for socket data and put new socket into the list
+; number.                                                         ;
-; Newly created socket is initialized with calling PID and number and
+;                                                                 ;
-; put into beginning of list (which is a fastest way).
+;  IN:  /                                                         ;
 ;                                                                 ;
-; IN:  /
+; OUT:  eax = socket ptr on success                               ;
-; OUT: eax = 0 on error, socket ptr otherwise
-;      edi = socket number
+;       eax = 0 on error                                          ;
-;
+;       edi = socket number on success                            ;
+;                                                                 ;
-;--------------------------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
 SOCKET_alloc:
         pusha
         mov     ecx, socket_mutex
         call    mutex_unlock
-        popa
-  .exit:
+        popa
         pop     ebx
+        ret
+  .nomem:
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_alloc: Out of memory!\n"
         pop     ebx
         ret
   .not_yet:
         mov     dword[esp+20], ENOTCONN
-        mov     dword[esp+32], -1
+        mov     dword[esp+32], -1
         ret
-;----------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_free
+;                                                                 ;
+; SOCKET_free:                                                    ;
-;
+; Free socket data memory and remove socket from the list.        ;
-; Free socket data memory and remove socket from the list
+; Caller should lock and unlock socket_mutex.                     ;
-; Caller should lock and unlock socket_mutex
+;                                                                 ;
 ;  IN:  eax = socket ptr                                          ;
-; IN:  eax = socket ptr
+;                                                                 ;
-; OUT: /
+; OUT:  /                                                         ;
         pusha
         lea     ecx, [eax + SOCKET.mutex]
         call    mutex_lock
         popa
-        cmp     [eax + SOCKET.Domain], AF_INET4
-        jnz     .no_tcp
-        cmp     [eax + SOCKET.Protocol], IP_PROTO_TCP
+        cmp     [eax + SOCKET.Type], SOCK_STREAM
-        jnz     .no_tcp
+        jne     .no_stream
+        mov     ebx, eax
+        cmp     [eax + STREAM_SOCKET.rcv.start_ptr], 0
+        je      @f
+        stdcall free_kernel_space, [eax + 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 free_kernel_space, [ebx + STREAM_SOCKET.snd.start_ptr]
-        stdcall kernel_free, [ebx + STREAM_SOCKET.snd.start_ptr]
+  @@:
         mov     eax, ebx
-  .no_tcp:
+  .no_stream:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: freeing socket %x\n", eax
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_free: success!\n"
   .error:
+        ret
-        ret
+  .error1:
+        pop     ebx
-;------------------------------------
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_free: error!\n"
-;
+        DEBUGF  DEBUG_NETWORK_ERROR, "socket ptr=0x%x caller=0x%x\n", eax, [esp]
+        ret
-; SOCKET_fork
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; Create a child socket
+; SOCKET_fork: Create a child socket.                             ;
+;                                                                 ;
-;
+;  IN:  ebx = socket number                                       ;
-; IN:  socket nr in ebx
+;                                                                 ;
+; OUT:  eax = child socket number on success                      ;
-; OUT: child socket nr in eax
+;       eax = 0 on error                                          ;
 ;                                                                 ;
-;-----------------------------------
+;-----------------------------------------------------------------;
 align 4
         DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_fork: failed\n"
         xor     eax, eax
         ret
-;---------------------------------------------------
-;
-; SOCKET_num_to_ptr
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; Get socket structure address by its number
+; SOCKET_num_to_ptr: Get socket structure address by its number.  ;
+;                                                                 ;
-;
+;  IN:  ecx = socket number                                       ;
-; IN:  ecx = socket number
+;                                                                 ;
-; OUT: eax = 0 on error, socket ptr otherwise
+; OUT:  eax = socket ptr                                          ;
-;       ZF = set on error
+;       eax = 0 on error                                          ;
 ;                                                                 ;
-;---------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
         mov     ecx, socket_mutex
         call    mutex_lock
         popa
-        mov     eax, net_sockets
         mov     eax, net_sockets
   .next_socket:
         mov     eax, [eax + SOCKET.NextPtr]
-        or      eax, eax
+        test    eax, eax
         jz      .error
         cmp     [eax + SOCKET.Number], ecx
-        jne     .next_socket
-        test    eax, eax
+        jne     .next_socket
         pusha
         mov     ecx, socket_mutex
         DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: socket %u not found!\n", eax
         DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_num_to_ptr: caller = 0x%x\n", [esp]
         ret
-;---------------------------------------------------
-;
-; SOCKET_ptr_to_num
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; Get socket number by its address
+; SOCKET_ptr_to_num: Get socket number by its address.            ;
+;                                                                 ;
+;  IN:  eax = socket ptr                                          ;
-;
+;                                                                 ;
-; IN:  eax = socket ptr
+; OUT:  eax = socket number                                       ;
-; OUT: eax = 0 on error, socket num otherwise
+;       eax = 0 on error                                          ;
-;       ZF = set on error
+;       ZF = set on error                                         ;
 ;                                                                 ;
-;---------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
   .error:
         DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_ptr_to_num: not found\n", eax
         ret
-;---------------------------------------------------
-;
-; SOCKET_check
+;-----------------------------------------------------------------;
-;
+;                                                                 ;
-; checks if the given value is really a socket ptr
+; SOCKET_check: Checks if the given ptr is really a socket ptr.   ;
+;                                                                 ;
-;
+;  IN:  eax = socket ptr                                          ;
-; IN:  eax = socket ptr
+;                                                                 ;
-; OUT: eax = 0 on error, unchanged otherwise
+; OUT:  eax = 0 on error                                          ;
-;       ZF = set on error
+;       ZF = set on error                                         ;
 ;                                                                 ;
-;---------------------------------------------------
+;-----------------------------------------------------------------;
 align 4
+SOCKET_check:
-SOCKET_check:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check: %x\n", eax
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_check: %x\n", eax
+        test    eax, eax
         jz      .error
   .done:
         mov     eax, ebx
         test    eax, eax
+        pop     ebx
+        ret
+  .error:
-        pop     ebx
+        DEBUGF  DEBUG_NETWORK_ERROR, "SOCKET_check: called with argument 0\n"
+        DEBUGF  DEBUG_NETWORK_ERROR, "stack: 0x%x, 0x%x, 0x%x\n", [esp], [esp+4], [esp+8]
-        ret
+        ret
-;---------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_check_owner
+;                                                                 ;
-;
+; SOCKET_check_owner: Check if the caller app owns the socket.    ;
-; checks if the caller application owns the socket
+;                                                                 ;
 ;  IN:  eax = socket ptr                                          ;
-; IN:  eax = socket ptr
+;                                                                 ;
-; OUT:  ZF = true/false
+; OUT:  ZF = true/false                                           ;
         ret
-;------------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_process_end
+;                                                                 ;
-;
+; SOCKET_process_end:                                             ;
-; Kernel calls this function when a certain process ends
+; Kernel calls this function when a certain process ends.         ;
+; This function will check if the process had any open sockets,   ;
-; This function will check if the process had any open sockets
+; and update them accordingly (clean up).                         ;
-; And update them accordingly (clean up)
+;                                                                 ;
-;
+;  IN:  edx = pid                                                 ;
-; IN:  edx = pid
+;                                                                 ;
-; OUT: /
+; OUT:  /                                                         ;
 ;                                                                 ;
         ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
+;                                                                 ;
-;
+; SOCKET_is_connecting: Update socket state.                      ;
-; SOCKET_is_connecting
+;                                                                 ;
-;
+;  IN:  eax = socket ptr                                          ;
-;  IN:  eax = socket ptr
-;  OUT: /
+;                                                                 ;
 ;  OUT: /                                                         ;
-;-----------------------------------------------------------------
+;                                                                 ;
 ;-----------------------------------------------------------------;
 align 4
-SOCKET_is_connecting:
 SOCKET_is_connecting:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connecting: %x\n", eax
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connecting: %x\n", eax
-        and     [eax + SOCKET.state], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
-        or      [eax + SOCKET.state], SS_ISCONNECTING
+        and     [eax + SOCKET.state], not (SS_ISCONNECTED + SS_ISDISCONNECTING + SS_ISCONFIRMING)
+        or      [eax + SOCKET.state], SS_ISCONNECTING
+        ret
-        ret
-;-----------------------------------------------------------------
+;-----------------------------------------------------------------;
 ;                                                                 ;
-; SOCKET_is_connected
+; SOCKET_is_connected: Update socket state.                       ;
 ;                                                                 ;
-;  IN:  eax = socket ptr
+;  IN:  eax = socket ptr                                          ;
-;  OUT: /
 ;                                                                 ;
-;-----------------------------------------------------------------
+;  OUT: /                                                         ;
+;                                                                 ;
-align 4
+;-----------------------------------------------------------------;
-SOCKET_is_connected:
+align 4
+SOCKET_is_connected:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_connected: %x\n", eax
         and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISDISCONNECTING + SS_ISCONFIRMING)
-        or      [eax + SOCKET.state], SS_ISCONNECTED
         or      [eax + SOCKET.state], SS_ISCONNECTED
         jmp     SOCKET_notify
 ;-----------------------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_is_disconnecting
+;                                                                 ;
-;
+; SOCKET_is_disconnecting: Update socket state.                   ;
-;  IN:  eax = socket ptr
+;                                                                 ;
-;  OUT: /
+;  IN:  eax = socket ptr                                          ;
+;                                                                 ;
-;
+;  OUT: /                                                         ;
-;-----------------------------------------------------------------
+;                                                                 ;
+;-----------------------------------------------------------------;
-align 4
-SOCKET_is_disconnecting:
+align 4
 SOCKET_is_disconnecting:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnecting: %x\n", eax
         DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnecting: %x\n", eax
         and     [eax + SOCKET.state], not (SS_ISCONNECTING)
-        or      [eax + SOCKET.state], SS_ISDISCONNECTING + SS_CANTRCVMORE + SS_CANTSENDMORE
-        jmp     SOCKET_notify
+        and     [eax + SOCKET.state], not (SS_ISCONNECTING)
+        or      [eax + SOCKET.state], SS_ISDISCONNECTING + SS_CANTRCVMORE + SS_CANTSENDMORE
+        jmp     SOCKET_notify
-;-----------------------------------------------------------------
-;
+;-----------------------------------------------------------------;
-; SOCKET_is_disconnected
+;                                                                 ;
-;
+; SOCKET_is_disconnected: Update socket state.                    ;
-;  IN:  eax = socket ptr
+;                                                                 ;
-;  OUT: /
 ;  IN:  eax = socket ptr                                          ;
-;-----------------------------------------------------------------
+;                                                                 ;
 ;  OUT: /                                                         ;
-align 4
+;                                                                 ;
-SOCKET_is_disconnected:
+;-----------------------------------------------------------------;
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnected: %x\n", eax
-        and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
-        or      [eax + SOCKET.state], SS_CANTRCVMORE + SS_CANTSENDMORE
-        jmp     SOCKET_notify
-;-----------------------------------------------------------------
+align 4
+SOCKET_is_disconnected:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_is_disconnected: %x\n", eax
+        and     [eax + SOCKET.state], not (SS_ISCONNECTING + SS_ISCONNECTED + SS_ISDISCONNECTING)
+        or      [eax + SOCKET.state], SS_CANTRCVMORE + SS_CANTSENDMORE
+        jmp     SOCKET_notify
 ; SOCKET_cant_recv_more
 ;-----------------------------------------------------------------;
-;  IN:  eax = socket ptr
+;                                                                 ;
-;  OUT: /
+; SOCKET_cant_recv_more: Update socket state.                     ;
-;
-;-----------------------------------------------------------------
+;                                                                 ;
-align 4
-SOCKET_cant_recv_more:
+;  IN:  eax = socket ptr                                          ;
 ;                                                                 ;
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "SOCKET_cant_recv_more: %x\n", eax
+;  OUT: /                                                         ;
 ;                                                                 ;

Subversion Repositories Kolibri OS

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