Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    raadf01e r8ab2074  
    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                // drop the accept lock to avoid deadlock
     563                fibril_mutex_unlock( & socket->accept_lock );
     564                fibril_rwlock_write_lock( & socket_globals.lock );
     565                fibril_mutex_lock( & socket->accept_lock );
    583566        }
    584567        -- socket->blocked;
    585568
    586569        // 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);
     570        new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
     571        if( ! new_socket ){
     572                fibril_mutex_unlock( & socket->accept_lock );
     573                fibril_rwlock_write_unlock( & socket_globals.lock );
    591574                return ENOMEM;
    592575        }
    593         bzero(new_socket, sizeof(*new_socket));
     576        bzero( new_socket, sizeof( * new_socket ));
    594577        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);
     578        if( socket_id <= 0 ){
     579                fibril_mutex_unlock( & socket->accept_lock );
     580                fibril_rwlock_write_unlock( & socket_globals.lock );
     581                free( new_socket );
    599582                return socket_id;
    600583        }
    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);
     584        socket_initialize( new_socket, socket_id, socket->phone, socket->service );
     585        result = sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket );
     586        if( result < 0 ){
     587                fibril_mutex_unlock( & socket->accept_lock );
     588                fibril_rwlock_write_unlock( & socket_globals.lock );
     589                free( new_socket );
    607590                return result;
    608591        }
    609592
    610593        // 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);
     594        message_id = async_send_5( socket->phone, NET_SOCKET_ACCEPT, ( ipcarg_t ) socket->socket_id, 0, socket->service, 0, new_socket->socket_id, & answer );
    612595        // 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);
     596        ipc_data_read_start( socket->phone, cliaddr, * addrlen );
     597        fibril_rwlock_write_unlock( & socket_globals.lock );
     598        async_wait_for( message_id, & ipc_result );
    616599        result = (int) ipc_result;
    617         if(result > 0){
    618                 if(result != socket_id){
     600        if( result > 0 ){
     601                if( result != socket_id ){
    619602                        result = EINVAL;
    620603                }
    621604                // dequeue the accepted socket if successful
    622                 dyn_fifo_pop(&socket->accepted);
     605                dyn_fifo_pop( & socket->accepted );
    623606                // 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){
     607                * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer );
     608                new_socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( answer );
     609        }else if( result == ENOTSOCK ){
    627610                // empty the queue if no accepted sockets
    628                 while(dyn_fifo_pop(&socket->accepted) > 0);
    629         }
    630         fibril_mutex_unlock(&socket->accept_lock);
     611                while( dyn_fifo_pop( & socket->accepted ) > 0 );
     612        }
     613        fibril_mutex_unlock( & socket->accept_lock );
    631614        return result;
    632615}
    633616
    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         }
     617int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){
     618        if( ! serv_addr ) return EDESTADDRREQ;
     619        if( ! addrlen ) return EDESTADDRREQ;
    641620        // 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){
     621        return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );
     622}
     623
     624int closesocket( int socket_id ){
    646625        ERROR_DECLARE;
    647626
    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);
     627        socket_ref              socket;
     628
     629        fibril_rwlock_write_lock( & socket_globals.lock );
     630        socket = sockets_find( socket_get_sockets(), socket_id );
     631        if( ! socket ){
     632                fibril_rwlock_write_unlock( & socket_globals.lock );
    654633                return ENOTSOCK;
    655634        }
    656         if(socket->blocked){
    657                 fibril_rwlock_write_unlock(&socket_globals.lock);
     635        if( socket->blocked ){
     636                fibril_rwlock_write_unlock( & socket_globals.lock );
    658637                return EINPROGRESS;
    659638        }
    660639        // request close
    661         ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE, (ipcarg_t) socket->socket_id, 0, socket->service));
     640        ERROR_PROPAGATE(( int ) async_req_3_0( socket->phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket->socket_id, 0, socket->service ));
    662641        // free the socket structure
    663         socket_destroy(socket);
    664         fibril_rwlock_write_unlock(&socket_globals.lock);
     642        socket_destroy( socket );
     643        fibril_rwlock_write_unlock( & socket_globals.lock );
    665644        return EOK;
    666645}
    667646
    668 void socket_destroy(socket_ref socket){
    669         int accepted_id;
     647void socket_destroy( socket_ref socket ){
     648        int     accepted_id;
    670649
    671650        // 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){
     651        while(( accepted_id = dyn_fifo_pop( & socket->accepted )) >= 0 ){
     652                socket_destroy( sockets_find( socket_get_sockets(), accepted_id ));
     653        }
     654        dyn_fifo_destroy( & socket->received );
     655        dyn_fifo_destroy( & socket->accepted );
     656        sockets_exclude( socket_get_sockets(), socket->socket_id );
     657}
     658
     659int send( int socket_id, void * data, size_t datalength, int flags ){
    681660        // 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         }
     661        return sendto_core( NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0 );
     662}
     663
     664int sendto( int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ){
     665        if( ! toaddr ) return EDESTADDRREQ;
     666        if( ! addrlen ) return EDESTADDRREQ;
    692667        // 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);
     668        return sendto_core( NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen );
     669}
     670
     671int sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen ){
     672        socket_ref              socket;
     673        aid_t                   message_id;
     674        ipcarg_t                result;
     675        size_t                  fragments;
     676        ipc_call_t              answer;
     677
     678        if( ! data ) return EBADMEM;
     679        if( ! datalength ) return NO_DATA;
     680        fibril_rwlock_read_lock( & socket_globals.lock );
    710681        // find socket
    711         socket = sockets_find(socket_get_sockets(), socket_id);
    712         if(! socket){
    713                 fibril_rwlock_read_unlock(&socket_globals.lock);
     682        socket = sockets_find( socket_get_sockets(), socket_id );
     683        if( ! socket ){
     684                fibril_rwlock_read_unlock( & socket_globals.lock );
    714685                return ENOTSOCK;
    715686        }
    716         fibril_rwlock_read_lock(&socket->sending_lock);
     687        fibril_rwlock_read_lock( & socket->sending_lock );
    717688        // 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;
     689        if( socket->data_fragment_size > 0 ){
     690                fragments = ( datalength + socket->header_size ) / socket->data_fragment_size;
     691                if(( datalength + socket->header_size ) % socket->data_fragment_size ) ++ fragments;
    721692        }else{
    722693                fragments = 1;
    723694        }
    724695        // 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);
     696        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 );
    726697        // send the address if given
    727         if((! toaddr) || (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)){
    728                 if(fragments == 1){
     698        if(( ! toaddr ) || ( async_data_write_start( socket->phone, toaddr, addrlen ) == EOK )){
     699                if( fragments == 1 ){
    729700                        // send all if only one fragment
    730                         async_data_write_start(socket->phone, data, datalength);
     701                        async_data_write_start( socket->phone, data, datalength );
    731702                }else{
    732703                        // 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;
     704                        async_data_write_start( socket->phone, data, socket->data_fragment_size - socket->header_size );
     705                        data = (( const uint8_t * ) data ) + socket->data_fragment_size - socket->header_size;
    735706                        // 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;
     707                        while(( -- fragments ) > 1 ){
     708                                async_data_write_start( socket->phone, data, socket->data_fragment_size );
     709                                data = (( const uint8_t * ) data ) + socket->data_fragment_size;
    739710                        }
    740711                        // send the last fragment
    741                         async_data_write_start(socket->phone, data, (datalength + socket->header_size) % socket->data_fragment_size);
     712                        async_data_write_start( socket->phone, data, ( datalength + socket->header_size ) % socket->data_fragment_size );
    742713                }
    743714        }
    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)){
     715        async_wait_for( message_id, & result );
     716        if(( SOCKET_GET_DATA_FRAGMENT_SIZE( answer ) > 0 )
     717        && ( SOCKET_GET_DATA_FRAGMENT_SIZE( answer ) != socket->data_fragment_size )){
    747718                // 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){
     719                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( answer );
     720        }
     721        fibril_rwlock_read_unlock( & socket->sending_lock );
     722        fibril_rwlock_read_unlock( & socket_globals.lock );
     723        return ( int ) result;
     724}
     725
     726int recv( int socket_id, void * data, size_t datalength, int flags ){
    756727        // 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         }
     728        return recvfrom_core( NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL );
     729}
     730
     731int recvfrom( int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ){
     732        if( ! fromaddr ) return EBADMEM;
     733        if( ! addrlen ) return NO_DATA;
    767734        // 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);
     735        return recvfrom_core( NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen );
     736}
     737
     738int recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen ){
     739        socket_ref              socket;
     740        aid_t                   message_id;
     741        ipcarg_t                ipc_result;
     742        int                     result;
     743        size_t                  fragments;
     744        size_t *                lengths;
     745        size_t                  index;
     746        ipc_call_t              answer;
     747
     748        if( ! data ) return EBADMEM;
     749        if( ! datalength ) return NO_DATA;
     750        if( fromaddr && ( ! addrlen )) return EINVAL;
     751        fibril_rwlock_read_lock( & socket_globals.lock );
    791752        // find the socket
    792         socket = sockets_find(socket_get_sockets(), socket_id);
    793         if(! socket){
    794                 fibril_rwlock_read_unlock(&socket_globals.lock);
     753        socket = sockets_find( socket_get_sockets(), socket_id );
     754        if( ! socket ){
     755                fibril_rwlock_read_unlock( & socket_globals.lock );
    795756                return ENOTSOCK;
    796757        }
    797         fibril_mutex_lock(&socket->receive_lock);
     758        fibril_mutex_lock( & socket->receive_lock );
    798759        // wait for a received packet
    799760        ++ 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);
     761        while(( result = dyn_fifo_value( & socket->received )) <= 0 ){
     762                fibril_rwlock_read_unlock( & socket_globals.lock );
     763                fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
     764                // drop the receive lock to avoid deadlock
     765                fibril_mutex_unlock( & socket->receive_lock );
     766                fibril_rwlock_read_lock( & socket_globals.lock );
     767                fibril_mutex_lock( & socket->receive_lock );
    804768        }
    805769        -- socket->blocked;
    806         fragments = (size_t) result;
     770        fragments = ( size_t ) result;
    807771        // 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);
     772        if( fragments > 1 ){
     773                lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
     774                if( ! lengths ){
     775                        fibril_mutex_unlock( & socket->receive_lock );
     776                        fibril_rwlock_read_unlock( & socket_globals.lock );
    813777                        return ENOMEM;
    814778                }
    815779                // request packet data
    816                 message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
     780                message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer );
    817781                // read the address if desired
    818                 if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
     782                if(( ! fromaddr ) || ( async_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
    819783                // read the fragment lengths
    820                         if(async_data_read_start(socket->phone, lengths, sizeof(int) * (fragments + 1)) == EOK){
    821                                 if(lengths[fragments] <= datalength){
     784                        if( async_data_read_start( socket->phone, lengths, sizeof( int ) * ( fragments + 1 )) == EOK ){
     785                                if( lengths[ fragments ] <= datalength ){
    822786                                        // 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];
     787                                        for( index = 0; index < fragments; ++ index ){
     788                                                async_data_read_start( socket->phone, data, lengths[ index ] );
     789                                                data = (( uint8_t * ) data ) + lengths[ index ];
    826790                                        }
    827791                                }
    828792                        }
    829793                }
    830                 free(lengths);
     794                free( lengths );
    831795        }else{
    832796                // request packet data
    833                 message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
     797                message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer );
    834798                // read the address if desired
    835                 if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
     799                if(( ! fromaddr ) || ( async_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
    836800                        // read all if only one fragment
    837                         async_data_read_start(socket->phone, data, datalength);
     801                        async_data_read_start( socket->phone, data, datalength );
    838802                }
    839803        }
    840         async_wait_for(message_id, &ipc_result);
     804        async_wait_for( message_id, & ipc_result );
    841805        result = (int) ipc_result;
    842806        // if successful
    843         if(result == EOK){
     807        if( result == EOK ){
    844808                // dequeue the received packet
    845                 dyn_fifo_pop(&socket->received);
     809                dyn_fifo_pop( & socket->received );
    846810                // return read data length
    847                 result = SOCKET_GET_READ_DATA_LENGTH(answer);
     811                result = SOCKET_GET_READ_DATA_LENGTH( answer );
    848812                // 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);
     813                if( fromaddr && addrlen ) * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer );
     814        }
     815        fibril_mutex_unlock( & socket->receive_lock );
     816        fibril_rwlock_read_unlock( & socket_globals.lock );
    855817        return result;
    856818}
    857819
    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);
     820int getsockopt( int socket_id, int level, int optname, void * value, size_t * optlen ){
     821        socket_ref              socket;
     822        aid_t                   message_id;
     823        ipcarg_t                result;
     824
     825        if( !( value && optlen )) return EBADMEM;
     826        if( !( * optlen )) return NO_DATA;
     827        fibril_rwlock_read_lock( & socket_globals.lock );
    870828        // find the socket
    871         socket = sockets_find(socket_get_sockets(), socket_id);
    872         if(! socket){
    873                 fibril_rwlock_read_unlock(&socket_globals.lock);
     829        socket = sockets_find( socket_get_sockets(), socket_id );
     830        if( ! socket ){
     831                fibril_rwlock_read_unlock( & socket_globals.lock );
    874832                return ENOTSOCK;
    875833        }
    876834        // 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);
     835        message_id = async_send_3( socket->phone, NET_SOCKET_GETSOCKOPT, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) optname, socket->service, NULL );
    878836        // read the length
    879         if(async_data_read_start(socket->phone, optlen, sizeof(*optlen)) == EOK){
     837        if( async_data_read_start( socket->phone, optlen, sizeof( * optlen )) == EOK ){
    880838                // 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){
     839                async_data_read_start( socket->phone, value, * optlen );
     840        }
     841        fibril_rwlock_read_unlock( & socket_globals.lock );
     842        async_wait_for( message_id, & result );
     843        return ( int ) result;
     844}
     845
     846int setsockopt( int socket_id, int level, int optname, const void * value, size_t optlen ){
    889847        // send the value
    890         return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT, (ipcarg_t) optname, value, optlen);
     848        return socket_send_data( socket_id, NET_SOCKET_SETSOCKOPT, ( ipcarg_t ) optname, value, optlen );
    891849
    892850}
Note: See TracChangeset for help on using the changeset viewer.