Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/socket/socket_client.c

    raadf01e r7fb2ce3  
    7575/** Default timeout for connections in microseconds.
    7676 */
    77 #define SOCKET_CONNECT_TIMEOUT  (1 * 1000 * 1000)
     77#define SOCKET_CONNECT_TIMEOUT  ( 1 * 1000 * 1000 )
    7878
    7979/** Maximum number of random attempts to find a new socket identifier before switching to the sequence.
    … …  
    9797        /** Socket identifier.
    9898         */
    99         int socket_id;
     99        int                                     socket_id;
    100100        /** Parent module phone.
    101101         */
    102         int phone;
     102        int                                     phone;
    103103        /** Parent module service.
    104104         */
    105         services_t service;
     105        services_t                      service;
    106106        /** Underlying protocol header size.
    107107         *  Sending and receiving optimalization.
    108108         */
    109         size_t header_size;
     109        size_t                          header_size;
    110110        /** Packet data fragment size.
    111111         *  Sending optimalization.
    112112         */
    113         size_t data_fragment_size;
     113        size_t                          data_fragment_size;
    114114        /** Sending safety lock.
    115115         *  Locks the header_size and data_fragment_size attributes.
    116116         */
    117         fibril_rwlock_t sending_lock;
     117        fibril_rwlock_t         sending_lock;
    118118        /** Received packets queue.
    119119         */
    120         dyn_fifo_t received;
     120        dyn_fifo_t                      received;
    121121        /** Received packets safety lock.
    122122         *  Used for receiving and receive notifications.
    123123         *  Locks the received attribute.
    124124         */
    125         fibril_mutex_t receive_lock;
     125        fibril_mutex_t          receive_lock;
    126126        /** Received packets signaling.
    127127         *  Signaled upon receive notification.
    128128         */
    129         fibril_condvar_t receive_signal;
     129        fibril_condvar_t        receive_signal;
    130130        /** Waiting sockets queue.
    131131         */
    132         dyn_fifo_t accepted;
     132        dyn_fifo_t                      accepted;
    133133        /** Waiting sockets safety lock.
    134134         *  Used for accepting and accept notifications.
    135135         *  Locks the accepted attribute.
    136136         */
    137         fibril_mutex_t accept_lock;
     137        fibril_mutex_t          accept_lock;
    138138        /** Waiting sockets signaling.
    139139         *  Signaled upon accept notification.
    140140         */
    141         fibril_condvar_t accept_signal;
     141        fibril_condvar_t        accept_signal;
    142142        /** The number of blocked functions called.
    143143         *  Used while waiting for the received packets or accepted sockets.
    144144         */
    145         int blocked;
     145        int                                     blocked;
    146146};
    147147
    … …  
    150150 *  @see int_map.h
    151151 */
    152 INT_MAP_DECLARE(sockets, socket_t);
     152INT_MAP_DECLARE( sockets, socket_t );
    153153
    154154/** Socket client library global data.
    … …  
    157157        /** TCP module phone.
    158158         */
    159         int tcp_phone;
     159        int     tcp_phone;
    160160        /** UDP module phone.
    161161         */
    162         int udp_phone;
     162        int     udp_phone;
    163163//      /** The last socket identifier.
    164164//       */
    … …  
    166166        /** Active sockets.
    167167         */
    168         sockets_ref sockets;
     168        sockets_ref     sockets;
    169169        /** Safety lock.
    170170         *  Write lock is used only for adding or removing sockets.
    … …  
    173173         *  No socket lock may be locked if this lock is unlocked.
    174174         */
    175         fibril_rwlock_t lock;
     175        fibril_rwlock_t lock;
    176176} socket_globals = {
    177177        .tcp_phone = -1,
    … …  
    183183                .writers = 0,
    184184                .waiters = {
    185                         .prev = &socket_globals.lock.waiters,
    186                         .next = &socket_globals.lock.waiters
     185                        .prev = & socket_globals.lock.waiters,
     186                        .next = & socket_globals.lock.waiters
    187187                }
    188188        }
    189189};
    190190
    191 INT_MAP_IMPLEMENT(sockets, socket_t);
     191INT_MAP_IMPLEMENT( sockets, socket_t );
    192192
    193193/** Returns the TCP module phone.
    … …  
    196196 *  @returns Other error codes as defined for the bind_service_timeout() function.
    197197 */
    198 static int socket_get_tcp_phone(void);
     198static int      socket_get_tcp_phone( void );
    199199
    200200/** Returns the UDP module phone.
    … …  
    203203 *  @returns Other error codes as defined for the bind_service_timeout() function.
    204204 */
    205 static int socket_get_udp_phone(void);
     205static int      socket_get_udp_phone( void );
    206206
    207207/** Returns the active sockets.
    208208 *  @returns The active sockets.
    209209 */
    210 static sockets_ref socket_get_sockets(void);
     210static sockets_ref      socket_get_sockets( void );
    211211
    212212/** Tries to find a new free socket identifier.
    … …  
    214214 *  @returns ELIMIT if there is no socket identifier available.
    215215 */
    216 static int socket_generate_new_id(void);
     216static int      socket_generate_new_id( void );
    217217
    218218/** Default thread for new connections.
    … …  
    220220 *  @param[in] icall The initial message call structure.
    221221 */
    222 void socket_connection(ipc_callid_t iid, ipc_call_t * icall);
     222void    socket_connection( ipc_callid_t iid, ipc_call_t * icall );
    223223
    224224/** Sends message to the socket parent module with specified data.
    … …  
    234234 *  @returns Other error codes as defined for the spcific message.
    235235 */
    236 int socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength);
     236int     socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength );
    237237
    238238/** Initializes a new socket specific data.
    … …  
    242242 *  @param[in] service The parent module service.
    243243 */
    244 void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service);
     244void    socket_initialize( socket_ref socket, int socket_id, int phone, services_t service );
    245245
    246246/** Clears and destroys the socket.
    247247 *  @param[in] socket The socket to be destroyed.
    248248 */
    249 void socket_destroy(socket_ref socket);
     249void    socket_destroy( socket_ref socket );
    250250
    251251/** Receives data via the socket.
    … …  
    263263 *  @returns Other error codes as defined for the spcific message.
    264264 */
    265 int recvfrom_core(ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen);
     265int     recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen );
    266266
    267267/** Sends data via the socket to the remote address.
    … …  
    280280 *  @returns Other error codes as defined for the NET_SOCKET_SENDTO message.
    281281 */
    282 int sendto_core(ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen);
    283 
    284 static int socket_get_tcp_phone(void){
    285         if(socket_globals.tcp_phone < 0){
    286                 socket_globals.tcp_phone = bind_service_timeout(SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection, SOCKET_CONNECT_TIMEOUT);
     282int     sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen );
     283
     284static int socket_get_tcp_phone( void ){
     285        if( socket_globals.tcp_phone < 0 ){
     286                socket_globals.tcp_phone = bind_service_timeout( SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection, SOCKET_CONNECT_TIMEOUT );
    287287        }
    288288        return socket_globals.tcp_phone;
    289289}
    290290
    291 static int socket_get_udp_phone(void){
    292         if(socket_globals.udp_phone < 0){
    293                 socket_globals.udp_phone = bind_service_timeout(SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection, SOCKET_CONNECT_TIMEOUT);
     291static int socket_get_udp_phone( void ){
     292        if( socket_globals.udp_phone < 0 ){
     293                socket_globals.udp_phone = bind_service_timeout( SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection, SOCKET_CONNECT_TIMEOUT );
    294294        }
    295295        return socket_globals.udp_phone;
    296296}
    297297
    298 static sockets_ref socket_get_sockets(void){
    299         if(! socket_globals.sockets){
    300                 socket_globals.sockets = (sockets_ref) malloc(sizeof(sockets_t));
    301                 if(! socket_globals.sockets){
    302                         return NULL;
    303                 }
    304                 if(sockets_initialize(socket_globals.sockets) != EOK){
    305                         free(socket_globals.sockets);
     298static sockets_ref socket_get_sockets( void ){
     299        if( ! socket_globals.sockets ){
     300                socket_globals.sockets = ( sockets_ref ) malloc( sizeof( sockets_t ));
     301                if( ! socket_globals.sockets ) return NULL;
     302                if( sockets_initialize( socket_globals.sockets ) != EOK ){
     303                        free( socket_globals.sockets );
    306304                        socket_globals.sockets = NULL;
    307305                }
    308                 srand(task_get_id());
     306                srand( task_get_id());
    309307        }
    310308        return socket_globals.sockets;
    311309}
    312310
    313 static int socket_generate_new_id(void){
    314         sockets_ref sockets;
    315         int socket_id;
    316         int count;
     311static int socket_generate_new_id( void ){
     312        sockets_ref     sockets;
     313        int                     socket_id;
     314        int                     count;
    317315
    318316        sockets = socket_get_sockets();
    … …  
    320318//      socket_id = socket_globals.last_id;
    321319        do{
    322                 if(count < SOCKET_ID_TRIES){
     320                if( count < SOCKET_ID_TRIES ){
    323321                        socket_id = rand() % INT_MAX;
    324322                        ++ count;
    325                 }else if(count == SOCKET_ID_TRIES){
     323                }else if( count == SOCKET_ID_TRIES ){
    326324                        socket_id = 1;
    327325                        ++ count;
    328326                // only this branch for last_id
    329327                }else{
    330                         if(socket_id < INT_MAX){
     328                        if( socket_id < INT_MAX ){
    331329                                ++ socket_id;
    332 /*                      }else if(socket_globals.last_id){
     330/*                      }else if( socket_globals.last_id ){
    333331*                               socket_globals.last_id = 0;
    334332*                               socket_id = 1;
    … …  
    337335                        }
    338336                }
    339         }while(sockets_find(sockets, socket_id));
     337        }while( sockets_find( sockets, socket_id ));
    340338//      last_id = socket_id
    341339        return socket_id;
    342340}
    343341
    344 void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service){
     342void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service ){
    345343        socket->socket_id = socket_id;
    346344        socket->phone = phone;
    347345        socket->service = service;
    348         dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
    349         dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
    350         fibril_mutex_initialize(&socket->receive_lock);
    351         fibril_condvar_initialize(&socket->receive_signal);
    352         fibril_mutex_initialize(&socket->accept_lock);
    353         fibril_condvar_initialize(&socket->accept_signal);
    354         fibril_rwlock_initialize(&socket->sending_lock);
    355 }
    356 
    357 void socket_connection(ipc_callid_t iid, ipc_call_t * icall){
     346        dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE );
     347        dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE );
     348        fibril_mutex_initialize( & socket->receive_lock );
     349        fibril_condvar_initialize( & socket->receive_signal );
     350        fibril_mutex_initialize( & socket->accept_lock );
     351        fibril_condvar_initialize( & socket->accept_signal );
     352        fibril_rwlock_initialize( & socket->sending_lock );
     353}
     354
     355void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){
    358356        ERROR_DECLARE;
    359357
    360         ipc_callid_t callid;
    361         ipc_call_t call;
    362         socket_ref socket;
    363 
    364         while(true){
    365 
    366                 callid = async_get_call(&call);
    367                 switch(IPC_GET_METHOD(call)){
     358        ipc_callid_t    callid;
     359        ipc_call_t              call;
     360        socket_ref              socket;
     361
     362        while( true ){
     363
     364                callid = async_get_call( & call );
     365                switch( IPC_GET_METHOD( call )){
    368366                        case NET_SOCKET_RECEIVED:
    369367                        case NET_SOCKET_ACCEPTED:
    370368                        case NET_SOCKET_DATA_FRAGMENT_SIZE:
    371                                 fibril_rwlock_read_lock(&socket_globals.lock);
     369                                fibril_rwlock_read_lock( & socket_globals.lock );
    372370                                // find the socket
    373                                 socket = sockets_find(socket_get_sockets(), SOCKET_GET_SOCKET_ID(call));
    374                                 if(! socket){
     371                                socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
     372                                if( ! socket ){
    375373                                        ERROR_CODE = ENOTSOCK;
    376374                                }else{
    377                                         switch(IPC_GET_METHOD(call)){
     375                                        switch( IPC_GET_METHOD( call )){
    378376                                                case NET_SOCKET_RECEIVED:
    379                                                         fibril_mutex_lock(&socket->receive_lock);
     377                                                        fibril_mutex_lock( & socket->receive_lock );
    380378                                                        // push the number of received packet fragments
    381                                                         if(! ERROR_OCCURRED(dyn_fifo_push(&socket->received, SOCKET_GET_DATA_FRAGMENTS(call), SOCKET_MAX_RECEIVED_SIZE))){
     379                                                        if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->received, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_MAX_RECEIVED_SIZE ))){
    382380                                                                // signal the received packet
    383                                                                 fibril_condvar_signal(&socket->receive_signal);
     381                                                                fibril_condvar_signal( & socket->receive_signal );
    384382                                                        }
    385                                                         fibril_mutex_unlock(&socket->receive_lock);
     383                                                        fibril_mutex_unlock( & socket->receive_lock );
    386384                                                        break;
    387385                                                case NET_SOCKET_ACCEPTED:
    388386                                                        // push the new socket identifier
    389                                                         fibril_mutex_lock(&socket->accept_lock);
    390                                                         if(! ERROR_OCCURRED(dyn_fifo_push(&socket->accepted, 1, SOCKET_MAX_ACCEPTED_SIZE))){
     387                                                        fibril_mutex_lock( & socket->accept_lock );
     388                                                        if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->accepted, 1, SOCKET_MAX_ACCEPTED_SIZE ))){
    391389                                                                // signal the accepted socket
    392                                                                 fibril_condvar_signal(&socket->accept_signal);
     390                                                                fibril_condvar_signal( & socket->accept_signal );
    393391                                                        }
    394                                                         fibril_mutex_unlock(&socket->accept_lock);
     392                                                        fibril_mutex_unlock( & socket->accept_lock );
    395393                                                        break;
    396394                                                default:
    397395                                                        ERROR_CODE = ENOTSUP;
    398396                                        }
    399                                         if((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0)
    400                                                 && (SOCKET_GET_DATA_FRAGMENT_SIZE(call) != socket->data_fragment_size)){
    401                                                 fibril_rwlock_write_lock(&socket->sending_lock);
     397                                        if(( SOCKET_GET_DATA_FRAGMENT_SIZE( call ) > 0 )
     398                                        && ( SOCKET_GET_DATA_FRAGMENT_SIZE( call ) != socket->data_fragment_size )){
     399                                                fibril_rwlock_write_lock( & socket->sending_lock );
    402400                                                // set the data fragment size
    403                                                 socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    404                                                 fibril_rwlock_write_unlock(&socket->sending_lock);
     401                                                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( call );
     402                                                fibril_rwlock_write_unlock( & socket->sending_lock );
    405403                                        }
    406404                                }
    407                                 fibril_rwlock_read_unlock(&socket_globals.lock);
     405                                fibril_rwlock_read_unlock( & socket_globals.lock );
    408406                                break;
    409407                        default:
    410408                                ERROR_CODE = ENOTSUP;
    411409                }
    412                 ipc_answer_0(callid, (ipcarg_t) ERROR_CODE);
    413         }
    414 }
    415 
    416 int socket(int domain, int type, int protocol){
     410                ipc_answer_0( callid, ( ipcarg_t ) ERROR_CODE );
     411        }
     412}
     413
     414int socket( int domain, int type, int protocol ){
    417415        ERROR_DECLARE;
    418416
    419         socket_ref socket;
    420         int phone;
    421         int socket_id;
    422         services_t service;
     417        socket_ref      socket;
     418        int                     phone;
     419        int                     socket_id;
     420        services_t      service;
    423421
    424422        // find the appropriate service
    425         switch(domain){
     423        switch( domain ){
    426424                case PF_INET:
    427                         switch(type){
     425                        switch( type ){
    428426                                case SOCK_STREAM:
    429                                         if(! protocol){
    430                                                 protocol = IPPROTO_TCP;
    431                                         }
    432                                         switch(protocol){
     427                                        if( ! protocol ) protocol = IPPROTO_TCP;
     428                                        switch( protocol ){
    433429                                                case IPPROTO_TCP:
    434430                                                        phone = socket_get_tcp_phone();
    … …  
    440436                                        break;
    441437                                case SOCK_DGRAM:
    442                                         if(! protocol){
    443                                                 protocol = IPPROTO_UDP;
    444                                         }
    445                                         switch(protocol){
     438                                        if( ! protocol ) protocol = IPPROTO_UDP;
     439                                        switch( protocol ){
    446440                                                case IPPROTO_UDP:
    447441                                                        phone = socket_get_udp_phone();
    … …  
    461455                        return EPFNOSUPPORT;
    462456        }
    463         if(phone < 0){
    464                 return phone;
    465         }
     457        if( phone < 0 ) return phone;
    466458        // create a new socket structure
    467         socket = (socket_ref) malloc(sizeof(socket_t));
    468         if(! socket){
    469                 return ENOMEM;
    470         }
    471         bzero(socket, sizeof(*socket));
    472         fibril_rwlock_write_lock(&socket_globals.lock);
     459        socket = ( socket_ref ) malloc( sizeof( socket_t ));
     460        if( ! socket ) return ENOMEM;
     461        bzero( socket, sizeof( * socket ));
     462        fibril_rwlock_write_lock( & socket_globals.lock );
    473463        // request a new socket
    474464        socket_id = socket_generate_new_id();
    475         if(socket_id <= 0){
    476                 fibril_rwlock_write_unlock(&socket_globals.lock);
    477                 free(socket);
     465        if( socket_id <= 0 ){
     466                fibril_rwlock_write_unlock( & socket_globals.lock );
     467                free( socket );
    478468                return socket_id;
    479469        }
    480         if(ERROR_OCCURRED((int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL, (ipcarg_t *) &socket->data_fragment_size, (ipcarg_t *) &socket->header_size))){
    481                 fibril_rwlock_write_unlock(&socket_globals.lock);
    482                 free(socket);
     470        if( ERROR_OCCURRED(( int ) async_req_3_3( phone, NET_SOCKET, socket_id, 0, service, NULL, ( ipcarg_t * ) & socket->data_fragment_size, ( ipcarg_t * ) & socket->header_size ))){
     471                fibril_rwlock_write_unlock( & socket_globals.lock );
     472                free( socket );
    483473                return ERROR_CODE;
    484474        }
    485475        // finish the new socket initialization
    486         socket_initialize(socket, socket_id, phone, service);
     476        socket_initialize( socket, socket_id, phone, service );
    487477        // store the new socket
    488         ERROR_CODE = sockets_add(socket_get_sockets(), socket_id, socket);
    489         fibril_rwlock_write_unlock(&socket_globals.lock);
    490         if(ERROR_CODE < 0){
    491                 dyn_fifo_destroy(&socket->received);
    492                 dyn_fifo_destroy(&socket->accepted);
    493                 free(socket);
    494                 async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0, service);
     478        ERROR_CODE = sockets_add( socket_get_sockets(), socket_id, socket );
     479        fibril_rwlock_write_unlock( & socket_globals.lock );
     480        if( ERROR_CODE < 0 ){
     481                dyn_fifo_destroy( & socket->received );
     482                dyn_fifo_destroy( & socket->accepted );
     483                free( socket );
     484                async_msg_3( phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket_id, 0, service );
    495485                return ERROR_CODE;
    496486        }
    … …  
    499489}
    500490
    501 int socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength){
    502         socket_ref socket;
    503         aid_t message_id;
    504         ipcarg_t result;
    505 
    506         if(! data){
    507                 return EBADMEM;
    508         }
    509         if(! datalength){
    510                 return NO_DATA;
    511         }
    512 
    513         fibril_rwlock_read_lock(&socket_globals.lock);
     491int socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength ){
     492        socket_ref              socket;
     493        aid_t                   message_id;
     494        ipcarg_t                result;
     495
     496        if( ! data ) return EBADMEM;
     497        if( ! datalength ) return NO_DATA;
     498
     499        fibril_rwlock_read_lock( & socket_globals.lock );
    514500        // find the socket
    515         socket = sockets_find(socket_get_sockets(), socket_id);
    516         if(! socket){
    517                 fibril_rwlock_read_unlock(&socket_globals.lock);
     501        socket = sockets_find( socket_get_sockets(), socket_id );
     502        if( ! socket ){
     503                fibril_rwlock_read_unlock( & socket_globals.lock );
    518504                return ENOTSOCK;
    519505        }
    520506        // request the message
    521         message_id = async_send_3(socket->phone, message, (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
     507        message_id = async_send_3( socket->phone, message, ( ipcarg_t ) socket->socket_id, arg2, socket->service, NULL );
    522508        // send the address
    523         async_data_write_start(socket->phone, data, datalength);
    524         fibril_rwlock_read_unlock(&socket_globals.lock);
    525         async_wait_for(message_id, &result);
    526         return (int) result;
    527 }
    528 
    529 int bind(int socket_id, const struct sockaddr * my_addr, socklen_t addrlen){
    530         if(addrlen <= 0){
    531                 return EINVAL;
    532         }
     509        async_data_write_start( socket->phone, data, datalength );
     510        fibril_rwlock_read_unlock( & socket_globals.lock );
     511        async_wait_for( message_id, & result );
     512        return ( int ) result;
     513}
     514
     515int bind( int socket_id, const struct sockaddr * my_addr, socklen_t addrlen ){
     516        if( addrlen <= 0 ) return EINVAL;
    533517        // send the address
    534         return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr, (size_t) addrlen);
    535 }
    536 
    537 int listen(int socket_id, int backlog){
    538         socket_ref socket;
    539         int result;
    540 
    541         if(backlog <= 0){
    542                 return EINVAL;
    543         }
    544         fibril_rwlock_read_lock(&socket_globals.lock);
     518        return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, ( size_t ) addrlen );
     519}
     520
     521int listen( int socket_id, int backlog ){
     522        socket_ref      socket;
     523        int                     result;
     524
     525        if( backlog <= 0 ) return EINVAL;
     526        fibril_rwlock_read_lock( & socket_globals.lock );
    545527        // find the socket
    546         socket = sockets_find(socket_get_sockets(), socket_id);
    547         if(! socket){
    548                 fibril_rwlock_read_unlock(&socket_globals.lock);
     528        socket = sockets_find( socket_get_sockets(), socket_id );
     529        if( ! socket ){
     530                fibril_rwlock_read_unlock( & socket_globals.lock );
    549531                return ENOTSOCK;
    550532        }
    551533        // request listen backlog change
    552         result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN, (ipcarg_t) socket->socket_id, (ipcarg_t) backlog, socket->service);
    553         fibril_rwlock_read_unlock(&socket_globals.lock);
     534        result = ( int ) async_req_3_0( socket->phone, NET_SOCKET_LISTEN, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) backlog, socket->service );
     535        fibril_rwlock_read_unlock( & socket_globals.lock );
    554536        return result;
    555537}
    556538
    557 int accept(int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen){
    558         socket_ref socket;
    559         socket_ref new_socket;
    560         aid_t message_id;
    561         ipcarg_t ipc_result;
    562         int result;
    563         ipc_call_t answer;
    564 
    565         if((! cliaddr) || (! addrlen)){
    566                 return EBADMEM;
    567         }
    568 
    569         fibril_rwlock_write_lock(&socket_globals.lock);
     539int accept( int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen ){
     540        socket_ref              socket;
     541        socket_ref              new_socket;
     542        aid_t                   message_id;
     543        ipcarg_t                ipc_result;
     544        int                     result;
     545        ipc_call_t              answer;
     546
     547        if(( ! cliaddr ) || ( ! addrlen )) return EBADMEM;
     548
     549        fibril_rwlock_write_lock( & socket_globals.lock );
    570550        // find the socket
    571         socket = sockets_find(socket_get_sockets(), socket_id);
    572         if(! socket){
    573                 fibril_rwlock_write_unlock(&socket_globals.lock);
     551        socket = sockets_find( socket_get_sockets(), socket_id );
     552        if( ! socket ){
     553                fibril_rwlock_write_unlock( & socket_globals.lock );
    574554                return ENOTSOCK;
    575555        }
    576         fibril_mutex_lock(&socket->accept_lock);
     556        fibril_mutex_lock( & socket->accept_lock );
    577557        // wait for an accepted socket
    578558        ++ socket->blocked;
    579         while(dyn_fifo_value(&socket->accepted) <= 0){
    580                 fibril_rwlock_write_unlock(&socket_globals.lock);
    581                 fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
    582                 fibril_rwlock_write_lock(&socket_globals.lock);
     559        while( dyn_fifo_value( & socket->accepted ) <= 0 ){
     560                fibril_rwlock_write_unlock( & socket_globals.lock );
     561                fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
     562                fibril_rwlock_write_lock( & socket_globals.lock );
    583563        }
    584564        -- socket->blocked;
    585565
    586566        // create a new scoket
    587         new_socket = (socket_ref) malloc(sizeof(socket_t));
    588         if(! new_socket){
    589                 fibril_mutex_unlock(&socket->accept_lock);
    590                 fibril_rwlock_write_unlock(&socket_globals.lock);
     567        new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
     568        if( ! new_socket ){
     569                fibril_mutex_unlock( & socket->accept_lock );
     570                fibril_rwlock_write_unlock( & socket_globals.lock );
    591571                return ENOMEM;
    592572        }
    593         bzero(new_socket, sizeof(*new_socket));
     573        bzero( new_socket, sizeof( * new_socket ));
    594574        socket_id = socket_generate_new_id();
    595         if(socket_id <= 0){
    596                 fibril_mutex_unlock(&socket->accept_lock);
    597                 fibril_rwlock_write_unlock(&socket_globals.lock);
    598                 free(new_socket);
     575        if( socket_id <= 0 ){
     576                fibril_mutex_unlock( & socket->accept_lock );
     577                fibril_rwlock_write_unlock( & socket_globals.lock );
     578                free( new_socket );
    599579                return socket_id;
    600580        }
    601         socket_initialize(new_socket, socket_id, socket->phone, socket->service);
    602         result = sockets_add(socket_get_sockets(), new_socket->socket_id, new_socket);
    603         if(result < 0){
    604                 fibril_mutex_unlock(&socket->accept_lock);
    605                 fibril_rwlock_write_unlock(&socket_globals.lock);
    606                 free(new_socket);
     581        socket_initialize( new_socket, socket_id, socket->phone, socket->service );
     582        result = sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket );
     583        if( result < 0 ){
     584                fibril_mutex_unlock( & socket->accept_lock );
     585                fibril_rwlock_write_unlock( & socket_globals.lock );
     586                free( new_socket );
    607587                return result;
    608588        }
    609589
    610590        // request accept
    611         message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT, (ipcarg_t) socket->socket_id, 0, socket->service, 0, new_socket->socket_id, &answer);
     591        message_id = async_send_5( socket->phone, NET_SOCKET_ACCEPT, ( ipcarg_t ) socket->socket_id, 0, socket->service, 0, new_socket->socket_id, & answer );
    612592        // read address
    613         ipc_data_read_start(socket->phone, cliaddr, * addrlen);
    614         fibril_rwlock_write_unlock(&socket_globals.lock);
    615         async_wait_for(message_id, &ipc_result);
     593        ipc_data_read_start( socket->phone, cliaddr, * addrlen );
     594        fibril_rwlock_write_unlock( & socket_globals.lock );
     595        async_wait_for( message_id, & ipc_result );
    616596        result = (int) ipc_result;
    617         if(result > 0){
    618                 if(result != socket_id){
     597        if( result > 0 ){
     598                if( result != socket_id ){
    619599                        result = EINVAL;
    620600                }
    621601                // dequeue the accepted socket if successful
    622                 dyn_fifo_pop(&socket->accepted);
     602                dyn_fifo_pop( & socket->accepted );
    623603                // set address length
    624                 *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    625                 new_socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    626         }else if(result == ENOTSOCK){
     604                * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer );
     605                new_socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( answer );
     606        }else if( result == ENOTSOCK ){
    627607                // empty the queue if no accepted sockets
    628                 while(dyn_fifo_pop(&socket->accepted) > 0);
    629         }
    630         fibril_mutex_unlock(&socket->accept_lock);
     608                while( dyn_fifo_pop( & socket->accepted ) > 0 );
     609        }
     610        fibril_mutex_unlock( & socket->accept_lock );
    631611        return result;
    632612}
    633613
    634 int connect(int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen){
    635         if(! serv_addr){
    636                 return EDESTADDRREQ;
    637         }
    638         if(! addrlen){
    639                 return EDESTADDRREQ;
    640         }
     614int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){
     615        if( ! serv_addr ) return EDESTADDRREQ;
     616        if( ! addrlen ) return EDESTADDRREQ;
    641617        // send the address
    642         return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen);
    643 }
    644 
    645 int closesocket(int socket_id){
     618        return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );
     619}
     620
     621int closesocket( int socket_id ){
    646622        ERROR_DECLARE;
    647623
    648         socket_ref socket;
    649 
    650         fibril_rwlock_write_lock(&socket_globals.lock);
    651         socket = sockets_find(socket_get_sockets(), socket_id);
    652         if(! socket){
    653                 fibril_rwlock_write_unlock(&socket_globals.lock);
     624        socket_ref              socket;
     625
     626        fibril_rwlock_write_lock( & socket_globals.lock );
     627        socket = sockets_find( socket_get_sockets(), socket_id );
     628        if( ! socket ){
     629                fibril_rwlock_write_unlock( & socket_globals.lock );
    654630                return ENOTSOCK;
    655631        }
    656         if(socket->blocked){
    657                 fibril_rwlock_write_unlock(&socket_globals.lock);
     632        if( socket->blocked ){
     633                fibril_rwlock_write_unlock( & socket_globals.lock );
    658634                return EINPROGRESS;
    659635        }
    660636        // request close
    661         ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE, (ipcarg_t) socket->socket_id, 0, socket->service));
     637        ERROR_PROPAGATE(( int ) async_req_3_0( socket->phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket->socket_id, 0, socket->service ));
    662638        // free the socket structure
    663         socket_destroy(socket);
    664         fibril_rwlock_write_unlock(&socket_globals.lock);
     639        socket_destroy( socket );
     640        fibril_rwlock_write_unlock( & socket_globals.lock );
    665641        return EOK;
    666642}
    667643
    668 void socket_destroy(socket_ref socket){
    669         int accepted_id;
     644void socket_destroy( socket_ref socket ){
     645        int     accepted_id;
    670646
    671647        // destroy all accepted sockets
    672         while((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0){
    673                 socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    674         }
    675         dyn_fifo_destroy(&socket->received);
    676         dyn_fifo_destroy(&socket->accepted);
    677         sockets_exclude(socket_get_sockets(), socket->socket_id);
    678 }
    679 
    680 int send(int socket_id, void * data, size_t datalength, int flags){
     648        while(( accepted_id = dyn_fifo_pop( & socket->accepted )) >= 0 ){
     649                socket_destroy( sockets_find( socket_get_sockets(), accepted_id ));
     650        }
     651        dyn_fifo_destroy( & socket->received );
     652        dyn_fifo_destroy( & socket->accepted );
     653        sockets_exclude( socket_get_sockets(), socket->socket_id );
     654}
     655
     656int send( int socket_id, void * data, size_t datalength, int flags ){
    681657        // without the address
    682         return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0);
    683 }
    684 
    685 int sendto(int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
    686         if(! toaddr){
    687                 return EDESTADDRREQ;
    688         }
    689         if(! addrlen){
    690                 return EDESTADDRREQ;
    691         }
     658        return sendto_core( NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0 );
     659}
     660
     661int sendto( int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ){
     662        if( ! toaddr ) return EDESTADDRREQ;
     663        if( ! addrlen ) return EDESTADDRREQ;
    692664        // with the address
    693         return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen);
    694 }
    695 
    696 int sendto_core(ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
    697         socket_ref socket;
    698         aid_t message_id;
    699         ipcarg_t result;
    700         size_t fragments;
    701         ipc_call_t answer;
    702 
    703         if(! data){
    704                 return EBADMEM;
    705         }
    706         if(! datalength){
    707                 return NO_DATA;
    708         }
    709         fibril_rwlock_read_lock(&socket_globals.lock);
     665        return sendto_core( NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen );
     666}
     667
     668int sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ){
     669        socket_ref              socket;
     670        aid_t                   message_id;
     671        ipcarg_t                result;
     672        size_t                  fragments;
     673        ipc_call_t              answer;
     674
     675        if( ! data ) return EBADMEM;
     676        if( ! datalength ) return NO_DATA;
     677        fibril_rwlock_read_lock( & socket_globals.lock );
    710678        // find socket
    711         socket = sockets_find(socket_get_sockets(), socket_id);
    712         if(! socket){
    713                 fibril_rwlock_read_unlock(&socket_globals.lock);
     679        socket = sockets_find( socket_get_sockets(), socket_id );
     680        if( ! socket ){
     681                fibril_rwlock_read_unlock( & socket_globals.lock );
    714682                return ENOTSOCK;
    715683        }
    716         fibril_rwlock_read_lock(&socket->sending_lock);
     684        fibril_rwlock_read_lock( & socket->sending_lock );
    717685        // compute data fragment count
    718         if(socket->data_fragment_size > 0){
    719                 fragments = (datalength + socket->header_size) / socket->data_fragment_size;
    720                 if((datalength + socket->header_size) % socket->data_fragment_size) ++ fragments;
     686        if( socket->data_fragment_size > 0 ){
     687                fragments = ( datalength + socket->header_size ) / socket->data_fragment_size;
     688                if(( datalength + socket->header_size ) % socket->data_fragment_size ) ++ fragments;
    721689        }else{
    722690                fragments = 1;
    723691        }
    724692        // request send
    725         message_id = async_send_5(socket->phone, message, (ipcarg_t) socket->socket_id, (fragments == 1 ? datalength : socket->data_fragment_size), socket->service, (ipcarg_t) flags, fragments, &answer);
     693        message_id = async_send_5( socket->phone, message, ( ipcarg_t ) socket->socket_id, ( fragments == 1 ? datalength : socket->data_fragment_size ), socket->service, ( ipcarg_t ) flags, fragments, & answer );
    726694        // send the address if given
    727         if((! toaddr) || (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)){
    728                 if(fragments == 1){
     695        if(( ! toaddr ) || ( async_data_write_start( socket->phone, toaddr, addrlen ) == EOK )){
     696                if( fragments == 1 ){
    729697                        // send all if only one fragment
    730                         async_data_write_start(socket->phone, data, datalength);
     698                        async_data_write_start( socket->phone, data, datalength );
    731699                }else{
    732700                        // send the first fragment
    733                         async_data_write_start(socket->phone, data, socket->data_fragment_size - socket->header_size);
    734                         data = ((const uint8_t *) data) + socket->data_fragment_size - socket->header_size;
     701                        async_data_write_start( socket->phone, data, socket->data_fragment_size - socket->header_size );
     702                        data = (( const uint8_t * ) data ) + socket->data_fragment_size - socket->header_size;
    735703                        // send the middle fragments
    736                         while((-- fragments) > 1){
    737                                 async_data_write_start(socket->phone, data, socket->data_fragment_size);
    738                                 data = ((const uint8_t *) data) + socket->data_fragment_size;
     704                        while(( -- fragments ) > 1 ){
     705                                async_data_write_start( socket->phone, data, socket->data_fragment_size );
     706                                data = (( const uint8_t * ) data ) + socket->data_fragment_size;
    739707                        }
    740708                        // send the last fragment
    741                         async_data_write_start(socket->phone, data, (datalength + socket->header_size) % socket->data_fragment_size);
     709                        async_data_write_start( socket->phone, data, ( datalength + socket->header_size ) % socket->data_fragment_size );
    742710                }
    743711        }
    744         async_wait_for(message_id, &result);
    745         if((SOCKET_GET_DATA_FRAGMENT_SIZE(answer) > 0)
    746                 && (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) != socket->data_fragment_size)){
     712        async_wait_for( message_id, & result );
     713        if(( SOCKET_GET_DATA_FRAGMENT_SIZE( answer ) > 0 )
     714        && ( SOCKET_GET_DATA_FRAGMENT_SIZE( answer ) != socket->data_fragment_size )){
    747715                // set the data fragment size
    748                 socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    749         }
    750         fibril_rwlock_read_unlock(&socket->sending_lock);
    751         fibril_rwlock_read_unlock(&socket_globals.lock);
    752         return (int) result;
    753 }
    754 
    755 int recv(int socket_id, void * data, size_t datalength, int flags){
     716                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( answer );
     717        }
     718        fibril_rwlock_read_unlock( & socket->sending_lock );
     719        fibril_rwlock_read_unlock( & socket_globals.lock );
     720        return ( int ) result;
     721}
     722
     723int recv( int socket_id, void * data, size_t datalength, int flags ){
    756724        // without the address
    757         return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL);
    758 }
    759 
    760 int recvfrom(int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
    761         if(! fromaddr){
    762                 return EBADMEM;
    763         }
    764         if(! addrlen){
    765                 return NO_DATA;
    766         }
     725        return recvfrom_core( NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL );
     726}
     727
     728int recvfrom( int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ){
     729        if( ! fromaddr ) return EBADMEM;
     730        if( ! addrlen ) return NO_DATA;
    767731        // with the address
    768         return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen);
    769 }
    770 
    771 int recvfrom_core(ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
    772         socket_ref socket;
    773         aid_t message_id;
    774         ipcarg_t ipc_result;
    775         int result;
    776         size_t fragments;
    777         size_t * lengths;
    778         size_t index;
    779         ipc_call_t answer;
    780 
    781         if(! data){
    782                 return EBADMEM;
    783         }
    784         if(! datalength){
    785                 return NO_DATA;
    786         }
    787         if(fromaddr && (! addrlen)){
    788                 return EINVAL;
    789         }
    790         fibril_rwlock_read_lock(&socket_globals.lock);
     732        return recvfrom_core( NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen );
     733}
     734
     735int recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ){
     736        socket_ref              socket;
     737        aid_t                   message_id;
     738        ipcarg_t                ipc_result;
     739        int                     result;
     740        size_t                  fragments;
     741        size_t *                lengths;
     742        size_t                  index;
     743        ipc_call_t              answer;
     744
     745        if( ! data ) return EBADMEM;
     746        if( ! datalength ) return NO_DATA;
     747        if( fromaddr && ( ! addrlen )) return EINVAL;
     748        fibril_rwlock_read_lock( & socket_globals.lock );
    791749        // find the socket
    792         socket = sockets_find(socket_get_sockets(), socket_id);
    793         if(! socket){
    794                 fibril_rwlock_read_unlock(&socket_globals.lock);
     750        socket = sockets_find( socket_get_sockets(), socket_id );
     751        if( ! socket ){
     752                fibril_rwlock_read_unlock( & socket_globals.lock );
    795753                return ENOTSOCK;
    796754        }
    797         fibril_mutex_lock(&socket->receive_lock);
     755        fibril_mutex_lock( & socket->receive_lock );
    798756        // wait for a received packet
    799757        ++ socket->blocked;
    800         while((result = dyn_fifo_value(&socket->received)) <= 0){
    801                 fibril_rwlock_read_unlock(&socket_globals.lock);
    802                 fibril_condvar_wait(&socket->receive_signal, &socket->receive_lock);
    803                 fibril_rwlock_read_lock(&socket_globals.lock);
     758        while(( result = dyn_fifo_value( & socket->received )) <= 0 ){
     759                fibril_rwlock_read_unlock( & socket_globals.lock );
     760                fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
     761                fibril_rwlock_read_lock( & socket_globals.lock );
    804762        }
    805763        -- socket->blocked;
    806         fragments = (size_t) result;
     764        fragments = ( size_t ) result;
    807765        // prepare lengths if more fragments
    808         if(fragments > 1){
    809                 lengths = (size_t *) malloc(sizeof(size_t) * fragments + sizeof(size_t));
    810                 if(! lengths){
    811                         fibril_mutex_unlock(&socket->receive_lock);
    812                         fibril_rwlock_read_unlock(&socket_globals.lock);
     766        if( fragments > 1 ){
     767                lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
     768                if( ! lengths ){
     769                        fibril_mutex_unlock( & socket->receive_lock );
     770                        fibril_rwlock_read_unlock( & socket_globals.lock );
    813771                        return ENOMEM;
    814772                }
    815773                // request packet data
    816                 message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
     774                message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer );
    817775                // read the address if desired
    818                 if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
     776                if(( ! fromaddr ) || ( async_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
    819777                // read the fragment lengths
    820                         if(async_data_read_start(socket->phone, lengths, sizeof(int) * (fragments + 1)) == EOK){
    821                                 if(lengths[fragments] <= datalength){
     778                        if( async_data_read_start( socket->phone, lengths, sizeof( int ) * ( fragments + 1 )) == EOK ){
     779                                if( lengths[ fragments ] <= datalength ){
    822780                                        // read all fragments if long enough
    823                                         for(index = 0; index < fragments; ++ index){
    824                                                 async_data_read_start(socket->phone, data, lengths[index]);
    825                                                 data = ((uint8_t *) data) + lengths[index];
     781                                        for( index = 0; index < fragments; ++ index ){
     782                                                async_data_read_start( socket->phone, data, lengths[ index ] );
     783                                                data = (( uint8_t * ) data ) + lengths[ index ];
    826784                                        }
    827785                                }
    828786                        }
    829787                }
    830                 free(lengths);
     788                free( lengths );
    831789        }else{
    832790                // request packet data
    833                 message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
     791                message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer );
    834792                // read the address if desired
    835                 if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
     793                if(( ! fromaddr ) || ( async_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
    836794                        // read all if only one fragment
    837                         async_data_read_start(socket->phone, data, datalength);
     795                        async_data_read_start( socket->phone, data, datalength );
    838796                }
    839797        }
    840         async_wait_for(message_id, &ipc_result);
     798        async_wait_for( message_id, & ipc_result );
    841799        result = (int) ipc_result;
    842800        // if successful
    843         if(result == EOK){
     801        if( result == EOK ){
    844802                // dequeue the received packet
    845                 dyn_fifo_pop(&socket->received);
     803                dyn_fifo_pop( & socket->received );
    846804                // return read data length
    847                 result = SOCKET_GET_READ_DATA_LENGTH(answer);
     805                result = SOCKET_GET_READ_DATA_LENGTH( answer );
    848806                // set address length
    849                 if(fromaddr && addrlen){
    850                         *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    851                 }
    852         }
    853         fibril_mutex_unlock(&socket->receive_lock);
    854         fibril_rwlock_read_unlock(&socket_globals.lock);
     807                if( fromaddr && addrlen ) * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer );
     808        }
     809        fibril_mutex_unlock( & socket->receive_lock );
     810        fibril_rwlock_read_unlock( & socket_globals.lock );
    855811        return result;
    856812}
    857813
    858 int getsockopt(int socket_id, int level, int optname, void * value, size_t * optlen){
    859         socket_ref socket;
    860         aid_t message_id;
    861         ipcarg_t result;
    862 
    863         if(!(value && optlen)){
    864                 return EBADMEM;
    865         }
    866         if(!(*optlen)){
    867                 return NO_DATA;
    868         }
    869         fibril_rwlock_read_lock(&socket_globals.lock);
     814int getsockopt( int socket_id, int level, int optname, void * value, size_t * optlen ){
     815        socket_ref              socket;
     816        aid_t                   message_id;
     817        ipcarg_t                result;
     818
     819        if( !( value && optlen )) return EBADMEM;
     820        if( !( * optlen )) return NO_DATA;
     821        fibril_rwlock_read_lock( & socket_globals.lock );
    870822        // find the socket
    871         socket = sockets_find(socket_get_sockets(), socket_id);
    872         if(! socket){
    873                 fibril_rwlock_read_unlock(&socket_globals.lock);
     823        socket = sockets_find( socket_get_sockets(), socket_id );
     824        if( ! socket ){
     825                fibril_rwlock_read_unlock( & socket_globals.lock );
    874826                return ENOTSOCK;
    875827        }
    876828        // request option value
    877         message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT, (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service, NULL);
     829        message_id = async_send_3( socket->phone, NET_SOCKET_GETSOCKOPT, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) optname, socket->service, NULL );
    878830        // read the length
    879         if(async_data_read_start(socket->phone, optlen, sizeof(*optlen)) == EOK){
     831        if( async_data_read_start( socket->phone, optlen, sizeof( * optlen )) == EOK ){
    880832                // read the value
    881                 async_data_read_start(socket->phone, value, * optlen);
    882         }
    883         fibril_rwlock_read_unlock(&socket_globals.lock);
    884         async_wait_for(message_id, &result);
    885         return (int) result;
    886 }
    887 
    888 int setsockopt(int socket_id, int level, int optname, const void * value, size_t optlen){
     833                async_data_read_start( socket->phone, value, * optlen );
     834        }
     835        fibril_rwlock_read_unlock( & socket_globals.lock );
     836        async_wait_for( message_id, & result );
     837        return ( int ) result;
     838}
     839
     840int setsockopt( int socket_id, int level, int optname, const void * value, size_t optlen ){
    889841        // send the value
    890         return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT, (ipcarg_t) optname, value, optlen);
     842        return socket_send_data( socket_id, NET_SOCKET_SETSOCKOPT, ( ipcarg_t ) optname, value, optlen );
    891843
    892844}
Note: See TracChangeset for help on using the changeset viewer.