Changeset aadf01e in mainline for uspace/srv/net/socket


Ignore:
Timestamp:
2010-03-07T15:13:28Z (15 years ago)
Author:
Lukas Mejdrech <lukasmejdrech@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
936835e
Parents:
aa85487
Message:

Coding style (no functional change)

Location:
uspace/srv/net/socket
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    raa85487 raadf01e  
    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 ) return NULL;
    302                 if( sockets_initialize( socket_globals.sockets ) != EOK ){
    303                         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){
     302                        return NULL;
     303                }
     304                if(sockets_initialize(socket_globals.sockets) != EOK){
     305                        free(socket_globals.sockets);
    304306                        socket_globals.sockets = NULL;
    305307                }
    306                 srand( task_get_id());
     308                srand(task_get_id());
    307309        }
    308310        return socket_globals.sockets;
    309311}
    310312
    311 static int socket_generate_new_id( void ){
    312         sockets_ref     sockets;
    313         int                     socket_id;
    314         int                     count;
     313static int socket_generate_new_id(void){
     314        sockets_ref sockets;
     315        int socket_id;
     316        int count;
    315317
    316318        sockets = socket_get_sockets();
    … …  
    318320//      socket_id = socket_globals.last_id;
    319321        do{
    320                 if( count < SOCKET_ID_TRIES ){
     322                if(count < SOCKET_ID_TRIES){
    321323                        socket_id = rand() % INT_MAX;
    322324                        ++ count;
    323                 }else if( count == SOCKET_ID_TRIES ){
     325                }else if(count == SOCKET_ID_TRIES){
    324326                        socket_id = 1;
    325327                        ++ count;
    326328                // only this branch for last_id
    327329                }else{
    328                         if( socket_id < INT_MAX ){
     330                        if(socket_id < INT_MAX){
    329331                                ++ socket_id;
    330 /*                      }else if( socket_globals.last_id ){
     332/*                      }else if(socket_globals.last_id){
    331333*                               socket_globals.last_id = 0;
    332334*                               socket_id = 1;
    … …  
    335337                        }
    336338                }
    337         }while( sockets_find( sockets, socket_id ));
     339        }while(sockets_find(sockets, socket_id));
    338340//      last_id = socket_id
    339341        return socket_id;
    340342}
    341343
    342 void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service ){
     344void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service){
    343345        socket->socket_id = socket_id;
    344346        socket->phone = phone;
    345347        socket->service = service;
    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 
    355 void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){
     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
     357void socket_connection(ipc_callid_t iid, ipc_call_t * icall){
    356358        ERROR_DECLARE;
    357359
    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 )){
     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)){
    366368                        case NET_SOCKET_RECEIVED:
    367369                        case NET_SOCKET_ACCEPTED:
    368370                        case NET_SOCKET_DATA_FRAGMENT_SIZE:
    369                                 fibril_rwlock_read_lock( & socket_globals.lock );
     371                                fibril_rwlock_read_lock(&socket_globals.lock);
    370372                                // find the socket
    371                                 socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
    372                                 if( ! socket ){
     373                                socket = sockets_find(socket_get_sockets(), SOCKET_GET_SOCKET_ID(call));
     374                                if(! socket){
    373375                                        ERROR_CODE = ENOTSOCK;
    374376                                }else{
    375                                         switch( IPC_GET_METHOD( call )){
     377                                        switch(IPC_GET_METHOD(call)){
    376378                                                case NET_SOCKET_RECEIVED:
    377                                                         fibril_mutex_lock( & socket->receive_lock );
     379                                                        fibril_mutex_lock(&socket->receive_lock);
    378380                                                        // push the number of received packet fragments
    379                                                         if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->received, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_MAX_RECEIVED_SIZE ))){
     381                                                        if(! ERROR_OCCURRED(dyn_fifo_push(&socket->received, SOCKET_GET_DATA_FRAGMENTS(call), SOCKET_MAX_RECEIVED_SIZE))){
    380382                                                                // signal the received packet
    381                                                                 fibril_condvar_signal( & socket->receive_signal );
     383                                                                fibril_condvar_signal(&socket->receive_signal);
    382384                                                        }
    383                                                         fibril_mutex_unlock( & socket->receive_lock );
     385                                                        fibril_mutex_unlock(&socket->receive_lock);
    384386                                                        break;
    385387                                                case NET_SOCKET_ACCEPTED:
    386388                                                        // push the new socket identifier
    387                                                         fibril_mutex_lock( & socket->accept_lock );
    388                                                         if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->accepted, 1, SOCKET_MAX_ACCEPTED_SIZE ))){
     389                                                        fibril_mutex_lock(&socket->accept_lock);
     390                                                        if(! ERROR_OCCURRED(dyn_fifo_push(&socket->accepted, 1, SOCKET_MAX_ACCEPTED_SIZE))){
    389391                                                                // signal the accepted socket
    390                                                                 fibril_condvar_signal( & socket->accept_signal );
     392                                                                fibril_condvar_signal(&socket->accept_signal);
    391393                                                        }
    392                                                         fibril_mutex_unlock( & socket->accept_lock );
     394                                                        fibril_mutex_unlock(&socket->accept_lock);
    393395                                                        break;
    394396                                                default:
    395397                                                        ERROR_CODE = ENOTSUP;
    396398                                        }
    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 );
     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);
    400402                                                // set the data fragment size
    401                                                 socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( call );
    402                                                 fibril_rwlock_write_unlock( & socket->sending_lock );
     403                                                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(call);
     404                                                fibril_rwlock_write_unlock(&socket->sending_lock);
    403405                                        }
    404406                                }
    405                                 fibril_rwlock_read_unlock( & socket_globals.lock );
     407                                fibril_rwlock_read_unlock(&socket_globals.lock);
    406408                                break;
    407409                        default:
    408410                                ERROR_CODE = ENOTSUP;
    409411                }
    410                 ipc_answer_0( callid, ( ipcarg_t ) ERROR_CODE );
    411         }
    412 }
    413 
    414 int socket( int domain, int type, int protocol ){
     412                ipc_answer_0(callid, (ipcarg_t) ERROR_CODE);
     413        }
     414}
     415
     416int socket(int domain, int type, int protocol){
    415417        ERROR_DECLARE;
    416418
    417         socket_ref      socket;
    418         int                     phone;
    419         int                     socket_id;
    420         services_t      service;
     419        socket_ref socket;
     420        int phone;
     421        int socket_id;
     422        services_t service;
    421423
    422424        // find the appropriate service
    423         switch( domain ){
     425        switch(domain){
    424426                case PF_INET:
    425                         switch( type ){
     427                        switch(type){
    426428                                case SOCK_STREAM:
    427                                         if( ! protocol ) protocol = IPPROTO_TCP;
    428                                         switch( protocol ){
     429                                        if(! protocol){
     430                                                protocol = IPPROTO_TCP;
     431                                        }
     432                                        switch(protocol){
    429433                                                case IPPROTO_TCP:
    430434                                                        phone = socket_get_tcp_phone();
    … …  
    436440                                        break;
    437441                                case SOCK_DGRAM:
    438                                         if( ! protocol ) protocol = IPPROTO_UDP;
    439                                         switch( protocol ){
     442                                        if(! protocol){
     443                                                protocol = IPPROTO_UDP;
     444                                        }
     445                                        switch(protocol){
    440446                                                case IPPROTO_UDP:
    441447                                                        phone = socket_get_udp_phone();
    … …  
    455461                        return EPFNOSUPPORT;
    456462        }
    457         if( phone < 0 ) return phone;
     463        if(phone < 0){
     464                return phone;
     465        }
    458466        // create a new socket structure
    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 );
     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);
    463473        // request a new socket
    464474        socket_id = socket_generate_new_id();
    465         if( socket_id <= 0 ){
    466                 fibril_rwlock_write_unlock( & socket_globals.lock );
    467                 free( socket );
     475        if(socket_id <= 0){
     476                fibril_rwlock_write_unlock(&socket_globals.lock);
     477                free(socket);
    468478                return socket_id;
    469479        }
    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 );
     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);
    473483                return ERROR_CODE;
    474484        }
    475485        // finish the new socket initialization
    476         socket_initialize( socket, socket_id, phone, service );
     486        socket_initialize(socket, socket_id, phone, service);
    477487        // store the new socket
    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 );
     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);
    485495                return ERROR_CODE;
    486496        }
    … …  
    489499}
    490500
    491 int 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 );
     501int 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);
    500514        // find the socket
    501         socket = sockets_find( socket_get_sockets(), socket_id );
    502         if( ! socket ){
    503                 fibril_rwlock_read_unlock( & socket_globals.lock );
     515        socket = sockets_find(socket_get_sockets(), socket_id);
     516        if(! socket){
     517                fibril_rwlock_read_unlock(&socket_globals.lock);
    504518                return ENOTSOCK;
    505519        }
    506520        // request the message
    507         message_id = async_send_3( socket->phone, message, ( ipcarg_t ) socket->socket_id, arg2, socket->service, NULL );
     521        message_id = async_send_3(socket->phone, message, (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
    508522        // send the address
    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 
    515 int bind( int socket_id, const struct sockaddr * my_addr, socklen_t addrlen ){
    516         if( addrlen <= 0 ) return EINVAL;
     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
     529int bind(int socket_id, const struct sockaddr * my_addr, socklen_t addrlen){
     530        if(addrlen <= 0){
     531                return EINVAL;
     532        }
    517533        // send the address
    518         return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, ( size_t ) addrlen );
    519 }
    520 
    521 int 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 );
     534        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr, (size_t) addrlen);
     535}
     536
     537int 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);
    527545        // find the socket
    528         socket = sockets_find( socket_get_sockets(), socket_id );
    529         if( ! socket ){
    530                 fibril_rwlock_read_unlock( & socket_globals.lock );
     546        socket = sockets_find(socket_get_sockets(), socket_id);
     547        if(! socket){
     548                fibril_rwlock_read_unlock(&socket_globals.lock);
    531549                return ENOTSOCK;
    532550        }
    533551        // request listen backlog change
    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 );
     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);
    536554        return result;
    537555}
    538556
    539 int 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 );
     557int 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);
    550570        // find the socket
    551         socket = sockets_find( socket_get_sockets(), socket_id );
    552         if( ! socket ){
    553                 fibril_rwlock_write_unlock( & socket_globals.lock );
     571        socket = sockets_find(socket_get_sockets(), socket_id);
     572        if(! socket){
     573                fibril_rwlock_write_unlock(&socket_globals.lock);
    554574                return ENOTSOCK;
    555575        }
    556         fibril_mutex_lock( & socket->accept_lock );
     576        fibril_mutex_lock(&socket->accept_lock);
    557577        // wait for an accepted socket
    558578        ++ socket->blocked;
    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 );
     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);
    563583        }
    564584        -- socket->blocked;
    565585
    566586        // create a new scoket
    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 );
     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);
    571591                return ENOMEM;
    572592        }
    573         bzero( new_socket, sizeof( * new_socket ));
     593        bzero(new_socket, sizeof(*new_socket));
    574594        socket_id = socket_generate_new_id();
    575         if( socket_id <= 0 ){
    576                 fibril_mutex_unlock( & socket->accept_lock );
    577                 fibril_rwlock_write_unlock( & socket_globals.lock );
    578                 free( new_socket );
     595        if(socket_id <= 0){
     596                fibril_mutex_unlock(&socket->accept_lock);
     597                fibril_rwlock_write_unlock(&socket_globals.lock);
     598                free(new_socket);
    579599                return socket_id;
    580600        }
    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 );
     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);
    587607                return result;
    588608        }
    589609
    590610        // request accept
    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 );
     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);
    592612        // read address
    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 );
     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);
    596616        result = (int) ipc_result;
    597         if( result > 0 ){
    598                 if( result != socket_id ){
     617        if(result > 0){
     618                if(result != socket_id){
    599619                        result = EINVAL;
    600620                }
    601621                // dequeue the accepted socket if successful
    602                 dyn_fifo_pop( & socket->accepted );
     622                dyn_fifo_pop(&socket->accepted);
    603623                // set address length
    604                 * addrlen = SOCKET_GET_ADDRESS_LENGTH( answer );
    605                 new_socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( answer );
    606         }else if( result == ENOTSOCK ){
     624                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
     625                new_socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
     626        }else if(result == ENOTSOCK){
    607627                // empty the queue if no accepted sockets
    608                 while( dyn_fifo_pop( & socket->accepted ) > 0 );
    609         }
    610         fibril_mutex_unlock( & socket->accept_lock );
     628                while(dyn_fifo_pop(&socket->accepted) > 0);
     629        }
     630        fibril_mutex_unlock(&socket->accept_lock);
    611631        return result;
    612632}
    613633
    614 int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){
    615         if( ! serv_addr ) return EDESTADDRREQ;
    616         if( ! addrlen ) return EDESTADDRREQ;
     634int 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        }
    617641        // send the address
    618         return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );
    619 }
    620 
    621 int closesocket( int socket_id ){
     642        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen);
     643}
     644
     645int closesocket(int socket_id){
    622646        ERROR_DECLARE;
    623647
    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 );
     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);
    630654                return ENOTSOCK;
    631655        }
    632         if( socket->blocked ){
    633                 fibril_rwlock_write_unlock( & socket_globals.lock );
     656        if(socket->blocked){
     657                fibril_rwlock_write_unlock(&socket_globals.lock);
    634658                return EINPROGRESS;
    635659        }
    636660        // request close
    637         ERROR_PROPAGATE(( int ) async_req_3_0( socket->phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket->socket_id, 0, socket->service ));
     661        ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE, (ipcarg_t) socket->socket_id, 0, socket->service));
    638662        // free the socket structure
    639         socket_destroy( socket );
    640         fibril_rwlock_write_unlock( & socket_globals.lock );
     663        socket_destroy(socket);
     664        fibril_rwlock_write_unlock(&socket_globals.lock);
    641665        return EOK;
    642666}
    643667
    644 void socket_destroy( socket_ref socket ){
    645         int     accepted_id;
     668void socket_destroy(socket_ref socket){
     669        int accepted_id;
    646670
    647671        // destroy all accepted sockets
    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 
    656 int send( int socket_id, void * data, size_t datalength, int flags ){
     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
     680int send(int socket_id, void * data, size_t datalength, int flags){
    657681        // without the address
    658         return sendto_core( NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0 );
    659 }
    660 
    661 int 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;
     682        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0);
     683}
     684
     685int 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        }
    664692        // with the address
    665         return sendto_core( NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen );
    666 }
    667 
    668 int 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 );
     693        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen);
     694}
     695
     696int 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);
    678710        // find socket
    679         socket = sockets_find( socket_get_sockets(), socket_id );
    680         if( ! socket ){
    681                 fibril_rwlock_read_unlock( & socket_globals.lock );
     711        socket = sockets_find(socket_get_sockets(), socket_id);
     712        if(! socket){
     713                fibril_rwlock_read_unlock(&socket_globals.lock);
    682714                return ENOTSOCK;
    683715        }
    684         fibril_rwlock_read_lock( & socket->sending_lock );
     716        fibril_rwlock_read_lock(&socket->sending_lock);
    685717        // compute data fragment count
    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;
     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;
    689721        }else{
    690722                fragments = 1;
    691723        }
    692724        // request send
    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 );
     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);
    694726        // send the address if given
    695         if(( ! toaddr ) || ( async_data_write_start( socket->phone, toaddr, addrlen ) == EOK )){
    696                 if( fragments == 1 ){
     727        if((! toaddr) || (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)){
     728                if(fragments == 1){
    697729                        // send all if only one fragment
    698                         async_data_write_start( socket->phone, data, datalength );
     730                        async_data_write_start(socket->phone, data, datalength);
    699731                }else{
    700732                        // send the first fragment
    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;
     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;
    703735                        // send the middle fragments
    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;
     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;
    707739                        }
    708740                        // send the last fragment
    709                         async_data_write_start( socket->phone, data, ( datalength + socket->header_size ) % socket->data_fragment_size );
    710                 }
    711         }
    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 )){
     741                        async_data_write_start(socket->phone, data, (datalength + socket->header_size) % socket->data_fragment_size);
     742                }
     743        }
     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)){
    715747                // set the data fragment size
    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 
    723 int recv( int socket_id, void * data, size_t datalength, int flags ){
     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
     755int recv(int socket_id, void * data, size_t datalength, int flags){
    724756        // without the address
    725         return recvfrom_core( NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL );
    726 }
    727 
    728 int 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;
     757        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL);
     758}
     759
     760int 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        }
    731767        // with the address
    732         return recvfrom_core( NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen );
    733 }
    734 
    735 int 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 );
     768        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen);
     769}
     770
     771int 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);
    749791        // find the socket
    750         socket = sockets_find( socket_get_sockets(), socket_id );
    751         if( ! socket ){
    752                 fibril_rwlock_read_unlock( & socket_globals.lock );
     792        socket = sockets_find(socket_get_sockets(), socket_id);
     793        if(! socket){
     794                fibril_rwlock_read_unlock(&socket_globals.lock);
    753795                return ENOTSOCK;
    754796        }
    755         fibril_mutex_lock( & socket->receive_lock );
     797        fibril_mutex_lock(&socket->receive_lock);
    756798        // wait for a received packet
    757799        ++ socket->blocked;
    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 );
     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);
    762804        }
    763805        -- socket->blocked;
    764         fragments = ( size_t ) result;
     806        fragments = (size_t) result;
    765807        // prepare lengths if more fragments
    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 );
     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);
    771813                        return ENOMEM;
    772814                }
    773815                // request packet data
    774                 message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer );
     816                message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
    775817                // read the address if desired
    776                 if(( ! fromaddr ) || ( async_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
     818                if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
    777819                // read the fragment lengths
    778                         if( async_data_read_start( socket->phone, lengths, sizeof( int ) * ( fragments + 1 )) == EOK ){
    779                                 if( lengths[ fragments ] <= datalength ){
     820                        if(async_data_read_start(socket->phone, lengths, sizeof(int) * (fragments + 1)) == EOK){
     821                                if(lengths[fragments] <= datalength){
    780822                                        // read all fragments if long enough
    781                                         for( index = 0; index < fragments; ++ index ){
    782                                                 async_data_read_start( socket->phone, data, lengths[ index ] );
    783                                                 data = (( uint8_t * ) data ) + lengths[ index ];
     823                                        for(index = 0; index < fragments; ++ index){
     824                                                async_data_read_start(socket->phone, data, lengths[index]);
     825                                                data = ((uint8_t *) data) + lengths[index];
    784826                                        }
    785827                                }
    786828                        }
    787829                }
    788                 free( lengths );
     830                free(lengths);
    789831        }else{
    790832                // request packet data
    791                 message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, 0, socket->service, ( ipcarg_t ) flags, & answer );
     833                message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
    792834                // read the address if desired
    793                 if(( ! fromaddr ) || ( async_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
     835                if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
    794836                        // read all if only one fragment
    795                         async_data_read_start( socket->phone, data, datalength );
    796                 }
    797         }
    798         async_wait_for( message_id, & ipc_result );
     837                        async_data_read_start(socket->phone, data, datalength);
     838                }
     839        }
     840        async_wait_for(message_id, &ipc_result);
    799841        result = (int) ipc_result;
    800842        // if successful
    801         if( result == EOK ){
     843        if(result == EOK){
    802844                // dequeue the received packet
    803                 dyn_fifo_pop( & socket->received );
     845                dyn_fifo_pop(&socket->received);
    804846                // return read data length
    805                 result = SOCKET_GET_READ_DATA_LENGTH( answer );
     847                result = SOCKET_GET_READ_DATA_LENGTH(answer);
    806848                // set address length
    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 );
     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);
    811855        return result;
    812856}
    813857
    814 int 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 );
     858int 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);
    822870        // find the socket
    823         socket = sockets_find( socket_get_sockets(), socket_id );
    824         if( ! socket ){
    825                 fibril_rwlock_read_unlock( & socket_globals.lock );
     871        socket = sockets_find(socket_get_sockets(), socket_id);
     872        if(! socket){
     873                fibril_rwlock_read_unlock(&socket_globals.lock);
    826874                return ENOTSOCK;
    827875        }
    828876        // request option value
    829         message_id = async_send_3( socket->phone, NET_SOCKET_GETSOCKOPT, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) optname, socket->service, NULL );
     877        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT, (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service, NULL);
    830878        // read the length
    831         if( async_data_read_start( socket->phone, optlen, sizeof( * optlen )) == EOK ){
     879        if(async_data_read_start(socket->phone, optlen, sizeof(*optlen)) == EOK){
    832880                // read the value
    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 
    840 int setsockopt( int socket_id, int level, int optname, const void * value, size_t optlen ){
     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
     888int setsockopt(int socket_id, int level, int optname, const void * value, size_t optlen){
    841889        // send the value
    842         return socket_send_data( socket_id, NET_SOCKET_SETSOCKOPT, ( ipcarg_t ) optname, value, optlen );
     890        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT, (ipcarg_t) optname, value, optlen);
    843891
    844892}

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

    raa85487 raadf01e  
    6464        /** The bound sockets map.
    6565         */
    66         socket_port_map_t       map;
     66        socket_port_map_t map;
    6767        /** The bound sockets count.
    6868         */
    69         int                                     count;
     69        int count;
    7070};
    7171
    … …  
    7979 *  @returns Other error codes as defined for the socket_ports_add() function.
    8080 */
    81 int     socket_bind_insert( socket_ports_ref global_sockets, socket_core_ref socket, int port );
     81int socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket, int port);
    8282
    8383/** Destroys the socket.
    … …  
    9090 *  @param[in] socket_release The client release callback function.
    9191 */
    92 void    socket_destroy_core( int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket ));
     92void socket_destroy_core(int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
    9393
    9494/** Adds the socket to a socket port.
    … …  
    100100 *  @returns ENOMEM if there is not enough memory left.
    101101 */
    102 int     socket_port_add_core( socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length );
     102int socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length);
    103103
    104104/** Tries to find a new free socket identifier.
    … …  
    108108 *  @returns ELIMIT if there is no socket identifier available.
    109109 */
    110 static int      socket_generate_new_id( socket_cores_ref local_sockets, int positive );
    111 
    112 INT_MAP_IMPLEMENT( socket_cores, socket_core_t );
    113 
    114 GENERIC_CHAR_MAP_IMPLEMENT( socket_port_map, socket_core_ref );
    115 
    116 INT_MAP_IMPLEMENT( socket_ports, socket_port_t );
    117 
    118 void socket_cores_release( int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket )){
    119         if( socket_cores_is_valid( local_sockets )){
    120                 int     index;
     110static int socket_generate_new_id(socket_cores_ref local_sockets, int positive);
     111
     112INT_MAP_IMPLEMENT(socket_cores, socket_core_t);
     113
     114GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_ref);
     115
     116INT_MAP_IMPLEMENT(socket_ports, socket_port_t);
     117
     118void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
     119        if(socket_cores_is_valid(local_sockets)){
     120                int index;
    121121
    122122                local_sockets->magic = 0;
    123                 for( index = 0; index < local_sockets->next; ++ index ){
    124                         if( socket_cores_item_is_valid( &( local_sockets->items[ index ] ))){
    125                                 local_sockets->items[ index ].magic = 0;
    126                                 if( local_sockets->items[ index ].value ){
    127                                         socket_destroy_core( packet_phone, local_sockets->items[ index ].value, local_sockets, global_sockets, socket_release );
    128                                         free( local_sockets->items[ index ].value );
    129                                         local_sockets->items[ index ].value = NULL;
     123                for(index = 0; index < local_sockets->next; ++ index){
     124                        if(socket_cores_item_is_valid(&(local_sockets->items[index]))){
     125                                local_sockets->items[index].magic = 0;
     126                                if(local_sockets->items[index].value){
     127                                        socket_destroy_core(packet_phone, local_sockets->items[index].value, local_sockets, global_sockets, socket_release);
     128                                        free(local_sockets->items[index].value);
     129                                        local_sockets->items[index].value = NULL;
    130130                                }
    131131                        }
    132132                }
    133                 free( local_sockets->items );
    134         }
    135 }
    136 
    137 void socket_destroy_core( int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket )){
    138         int     packet_id;
     133                free(local_sockets->items);
     134        }
     135}
     136
     137void socket_destroy_core(int packet_phone, socket_core_ref socket, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
     138        int packet_id;
    139139
    140140        // if bound
    141         if( socket->port ){
     141        if(socket->port){
    142142                // release the port
    143                 socket_port_release( global_sockets, socket );
     143                socket_port_release(global_sockets, socket);
    144144        }
    145145        // release all received packets
    146         while(( packet_id = dyn_fifo_pop( & socket->received )) >= 0 ){
    147                 pq_release( packet_phone, packet_id );
    148         }
    149         dyn_fifo_destroy( & socket->received );
    150         dyn_fifo_destroy( & socket->accepted );
    151         if( socket_release ){
    152                 socket_release( socket );
    153         }
    154         socket_cores_exclude( local_sockets, socket->socket_id );
    155 }
    156 
    157 int socket_bind( socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port ){
    158         socket_core_ref                 socket;
    159         socket_port_ref                 socket_port;
    160         struct sockaddr *               address;
    161         struct sockaddr_in *    address_in;
    162 
    163         if( addrlen < sizeof( struct sockaddr )) return EINVAL;
    164         address = ( struct sockaddr * ) addr;
    165         switch( address->sa_family ){
     146        while((packet_id = dyn_fifo_pop(&socket->received)) >= 0){
     147                pq_release(packet_phone, packet_id);
     148        }
     149        dyn_fifo_destroy(&socket->received);
     150        dyn_fifo_destroy(&socket->accepted);
     151        if(socket_release){
     152                socket_release(socket);
     153        }
     154        socket_cores_exclude(local_sockets, socket->socket_id);
     155}
     156
     157int socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port){
     158        socket_core_ref socket;
     159        socket_port_ref socket_port;
     160        struct sockaddr * address;
     161        struct sockaddr_in * address_in;
     162
     163        if(addrlen < sizeof(struct sockaddr)){
     164                return EINVAL;
     165        }
     166        address = (struct sockaddr *) addr;
     167        switch(address->sa_family){
    166168                case AF_INET:
    167                         if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
    168                         address_in = ( struct sockaddr_in * ) addr;
     169                        if(addrlen != sizeof(struct sockaddr_in)){
     170                                return EINVAL;
     171                        }
     172                        address_in = (struct sockaddr_in *) addr;
    169173                        // find the socket
    170                         socket = socket_cores_find( local_sockets, socket_id );
    171                         if( ! socket ) return ENOTSOCK;
     174                        socket = socket_cores_find(local_sockets, socket_id);
     175                        if(! socket){
     176                                return ENOTSOCK;
     177                        }
    172178                        // bind a free port?
    173                         if( address_in->sin_port <= 0 ){
    174                                 return socket_bind_free_port( global_sockets, socket, free_ports_start, free_ports_end, last_used_port );
     179                        if(address_in->sin_port <= 0){
     180                                return socket_bind_free_port(global_sockets, socket, free_ports_start, free_ports_end, last_used_port);
    175181                        }
    176182                        // try to find the port
    177                         socket_port = socket_ports_find( global_sockets, ntohs( address_in->sin_port ));
    178                         if( socket_port ){
     183                        socket_port = socket_ports_find(global_sockets, ntohs(address_in->sin_port));
     184                        if(socket_port){
    179185                                // already used
    180186                                return EADDRINUSE;
    181187                        }
    182188                        // if bound
    183                         if( socket->port ){
     189                        if(socket->port){
    184190                                // release the port
    185                                 socket_port_release( global_sockets, socket );
     191                                socket_port_release(global_sockets, socket);
    186192                        }
    187193                        socket->port = -1;
    188                         return socket_bind_insert( global_sockets, socket, ntohs( address_in->sin_port ));
     194                        return socket_bind_insert(global_sockets, socket, ntohs(address_in->sin_port));
    189195                        break;
    190196                // TODO IPv6
    … …  
    193199}
    194200
    195 int socket_bind_free_port( socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port ){
    196         int     index;
     201int socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port){
     202        int index;
    197203
    198204        // from the last used one
    … …  
    201207                ++ index;
    202208                // til the range end
    203                 if( index >= free_ports_end ){
     209                if(index >= free_ports_end){
    204210                        // start from the range beginning
    205211                        index = free_ports_start - 1;
    … …  
    207213                                ++ index;
    208214                                // til the last used one
    209                                 if( index >= last_used_port ){
     215                                if(index >= last_used_port){
    210216                                        // none found
    211217                                        return ENOTCONN;
    212218                                }
    213                         }while( socket_ports_find( global_sockets, index ) != NULL );
     219                        }while(socket_ports_find(global_sockets, index) != NULL);
    214220                        // found, break immediately
    215221                        break;
    216222                }
    217         }while( socket_ports_find( global_sockets, index ) != NULL );
    218         return socket_bind_insert( global_sockets, socket, index );
    219 }
    220 
    221 int socket_bind_insert( socket_ports_ref global_sockets, socket_core_ref socket, int port ){
     223        }while(socket_ports_find(global_sockets, index) != NULL);
     224        return socket_bind_insert(global_sockets, socket, index);
     225}
     226
     227int socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket, int port){
    222228        ERROR_DECLARE;
    223229
    224         socket_port_ref socket_port;
     230        socket_port_ref socket_port;
    225231
    226232        // create a wrapper
    227         socket_port = malloc( sizeof( * socket_port ));
    228         if( ! socket_port ) return ENOMEM;
     233        socket_port = malloc(sizeof(*socket_port));
     234        if(! socket_port){
     235                return ENOMEM;
     236        }
    229237        socket_port->count = 0;
    230         if( ERROR_OCCURRED( socket_port_map_initialize( & socket_port->map ))
    231         || ERROR_OCCURRED( socket_port_add_core( socket_port, socket, SOCKET_MAP_KEY_LISTENING, 0 ))){
    232                 socket_port_map_destroy( & socket_port->map );
    233                 free( socket_port );
     238        if(ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map))
     239                || ERROR_OCCURRED(socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING, 0))){
     240                socket_port_map_destroy(&socket_port->map);
     241                free(socket_port);
    234242                return ERROR_CODE;
    235243        }
    236244        // register the incomming port
    237         ERROR_CODE = socket_ports_add( global_sockets, port, socket_port );
    238         if( ERROR_CODE < 0 ){
    239                 socket_port_map_destroy( & socket_port->map );
    240                 free( socket_port );
     245        ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
     246        if(ERROR_CODE < 0){
     247                socket_port_map_destroy(&socket_port->map);
     248                free(socket_port);
    241249                return ERROR_CODE;
    242250        }
    … …  
    246254
    247255
    248 static int socket_generate_new_id( socket_cores_ref local_sockets, int positive ){
    249         int                     socket_id;
    250         int                     count;
     256static int socket_generate_new_id(socket_cores_ref local_sockets, int positive){
     257        int socket_id;
     258        int count;
    251259
    252260        count = 0;
    253261//      socket_id = socket_globals.last_id;
    254262        do{
    255                 if( count < SOCKET_ID_TRIES ){
     263                if(count < SOCKET_ID_TRIES){
    256264                        socket_id = rand() % INT_MAX;
    257265                        ++ count;
    258                 }else if( count == SOCKET_ID_TRIES ){
     266                }else if(count == SOCKET_ID_TRIES){
    259267                        socket_id = 1;
    260268                        ++ count;
    261269                // only this branch for last_id
    262270                }else{
    263                         if( socket_id < INT_MAX ){
     271                        if(socket_id < INT_MAX){
    264272                                ++ socket_id;
    265 /*                      }else if( socket_globals.last_id ){
     273/*                      }else if(socket_globals.last_id){
    266274*                               socket_globals.last_id = 0;
    267275*                               socket_id = 1;
    … …  
    270278                        }
    271279                }
    272         }while( socket_cores_find( local_sockets, (( positive ? 1 : -1 ) * socket_id )));
     280        }while(socket_cores_find(local_sockets, ((positive ? 1 : -1) * socket_id)));
    273281//      last_id = socket_id
    274282        return socket_id;
    275283}
    276284
    277 int socket_create( socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id ){
     285int socket_create(socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id){
    278286        ERROR_DECLARE;
    279287
    280         socket_core_ref socket;
    281         int                             res;
    282         int                             positive;
    283 
    284         if( ! socket_id ) return EINVAL;
     288        socket_core_ref socket;
     289        int res;
     290        int positive;
     291
     292        if(! socket_id){
     293                return EINVAL;
     294        }
    285295        // store the socket
    286         if( * socket_id <= 0 ){
    287                 positive = ( * socket_id == 0 );
    288                 * socket_id = socket_generate_new_id( local_sockets, positive );
    289                 if( * socket_id <= 0 ){
     296        if(*socket_id <= 0){
     297                positive = (*socket_id == 0);
     298                *socket_id = socket_generate_new_id(local_sockets, positive);
     299                if(*socket_id <= 0){
    290300                        return * socket_id;
    291301                }
    292                 if( ! positive ){
    293                         * socket_id *= -1;
    294                 }
    295         }else if( socket_cores_find( local_sockets, * socket_id )){
     302                if(! positive){
     303                        *socket_id *= -1;
     304                }
     305        }else if(socket_cores_find(local_sockets, * socket_id)){
    296306                return EEXIST;
    297307        }
    298         socket = ( socket_core_ref ) malloc( sizeof( * socket ));
    299         if( ! socket ) return ENOMEM;
     308        socket = (socket_core_ref) malloc(sizeof(*socket));
     309        if(! socket){
     310                return ENOMEM;
     311        }
    300312        // initialize
    301313        socket->phone = app_phone;
    … …  
    304316        socket->key_length = 0;
    305317        socket->specific_data = specific_data;
    306         if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE ))){
    307                 free( socket );
     318        if(ERROR_OCCURRED(dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE))){
     319                free(socket);
    308320                return ERROR_CODE;
    309321        }
    310         if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE ))){
    311                 dyn_fifo_destroy( & socket->received );
    312                 free( socket );
     322        if(ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE))){
     323                dyn_fifo_destroy(&socket->received);
     324                free(socket);
    313325                return ERROR_CODE;
    314326        }
    315327        socket->socket_id = * socket_id;
    316         res = socket_cores_add( local_sockets, socket->socket_id, socket );
    317         if( res < 0 ){
    318                 dyn_fifo_destroy( & socket->received );
    319                 dyn_fifo_destroy( & socket->accepted );
    320                 free( socket );
     328        res = socket_cores_add(local_sockets, socket->socket_id, socket);
     329        if(res < 0){
     330                dyn_fifo_destroy(&socket->received);
     331                dyn_fifo_destroy(&socket->accepted);
     332                free(socket);
    321333                return res;
    322334        }
    … …  
    324336}
    325337
    326 int socket_destroy( int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket )){
    327         socket_core_ref socket;
    328         int                             accepted_id;
     338int socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket)){
     339        socket_core_ref socket;
     340        int accepted_id;
    329341
    330342        // find the socket
    331         socket = socket_cores_find( local_sockets, socket_id );
    332         if( ! socket ) return ENOTSOCK;
     343        socket = socket_cores_find(local_sockets, socket_id);
     344        if(! socket){
     345                return ENOTSOCK;
     346        }
    333347        // destroy all accepted sockets
    334         while(( accepted_id = dyn_fifo_pop( & socket->accepted )) >= 0 ){
    335                 socket_destroy( packet_phone, accepted_id, local_sockets, global_sockets, socket_release );
    336         }
    337         socket_destroy_core( packet_phone, socket, local_sockets, global_sockets, socket_release );
    338         return EOK;
    339 }
    340 
    341 int socket_reply_packets( packet_t packet, size_t * length ){
     348        while((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0){
     349                socket_destroy(packet_phone, accepted_id, local_sockets, global_sockets, socket_release);
     350        }
     351        socket_destroy_core(packet_phone, socket, local_sockets, global_sockets, socket_release);
     352        return EOK;
     353}
     354
     355int socket_reply_packets(packet_t packet, size_t * length){
    342356        ERROR_DECLARE;
    343357
    344         packet_t                next_packet;
    345         size_t                  fragments;
    346         size_t *                lengths;
    347         size_t                  index;
    348 
    349         if( ! length ) return EBADMEM;
    350         next_packet = pq_next( packet );
    351         if( ! next_packet ){
     358        packet_t next_packet;
     359        size_t fragments;
     360        size_t * lengths;
     361        size_t index;
     362
     363        if(! length){
     364                return EBADMEM;
     365        }
     366        next_packet = pq_next(packet);
     367        if(! next_packet){
    352368                // write all if only one fragment
    353                 ERROR_PROPAGATE( data_reply( packet_get_data( packet ), packet_get_data_length( packet )));
     369                ERROR_PROPAGATE(data_reply(packet_get_data(packet), packet_get_data_length(packet)));
    354370                // store the total length
    355                 * length = packet_get_data_length( packet );
     371                *length = packet_get_data_length(packet);
    356372        }else{
    357373                // count the packet fragments
    358374                fragments = 1;
    359                 next_packet = pq_next( packet );
    360                 while(( next_packet = pq_next( next_packet ))){
     375                next_packet = pq_next(packet);
     376                while((next_packet = pq_next(next_packet))){
    361377                        ++ fragments;
    362378                }
    363379                // compute and store the fragment lengths
    364                 lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
    365                 if( ! lengths ) return ENOMEM;
    366                 lengths[ 0 ] = packet_get_data_length( packet );
    367                 lengths[ fragments ] = lengths[ 0 ];
    368                 next_packet = pq_next( packet );
    369                 for( index = 1; index < fragments; ++ index ){
    370                         lengths[ index ] = packet_get_data_length( next_packet );
    371                         lengths[ fragments ] += lengths[ index ];
    372                         next_packet = pq_next( packet );
    373                 }while( next_packet );
     380                lengths = (size_t *) malloc(sizeof(size_t) * fragments + sizeof(size_t));
     381                if(! lengths){
     382                        return ENOMEM;
     383                }
     384                lengths[0] = packet_get_data_length(packet);
     385                lengths[fragments] = lengths[0];
     386                next_packet = pq_next(packet);
     387                for(index = 1; index < fragments; ++ index){
     388                        lengths[index] = packet_get_data_length(next_packet);
     389                        lengths[fragments] += lengths[index];
     390                        next_packet = pq_next(packet);
     391                }while(next_packet);
    374392                // write the fragment lengths
    375                 ERROR_PROPAGATE( data_reply( lengths, sizeof( int ) * ( fragments + 1 )));
     393                ERROR_PROPAGATE(data_reply(lengths, sizeof(int) * (fragments + 1)));
    376394                next_packet = packet;
    377395                // write the fragments
    378                 for( index = 0; index < fragments; ++ index ){
    379                         ERROR_PROPAGATE( data_reply( packet_get_data( next_packet ), lengths[ index ] ));
    380                         next_packet = pq_next( next_packet );
    381                 }while( next_packet );
     396                for(index = 0; index < fragments; ++ index){
     397                        ERROR_PROPAGATE(data_reply(packet_get_data(next_packet), lengths[index]));
     398                        next_packet = pq_next(next_packet);
     399                }while(next_packet);
    382400                // store the total length
    383                 * length = lengths[ fragments ];
    384                 free( lengths );
    385         }
    386         return EOK;
    387 }
    388 
    389 socket_core_ref socket_port_find( socket_ports_ref global_sockets, int port, const char * key, size_t key_length ){
    390         socket_port_ref         socket_port;
    391         socket_core_ref *       socket_ref;
    392 
    393         socket_port = socket_ports_find( global_sockets, port );
    394         if( socket_port && ( socket_port->count > 0 )){
    395                 socket_ref = socket_port_map_find( & socket_port->map, key, key_length );
    396                 if( socket_ref ){
     401                *length = lengths[fragments];
     402                free(lengths);
     403        }
     404        return EOK;
     405}
     406
     407socket_core_ref socket_port_find(socket_ports_ref global_sockets, int port, const char * key, size_t key_length){
     408        socket_port_ref socket_port;
     409        socket_core_ref * socket_ref;
     410
     411        socket_port = socket_ports_find(global_sockets, port);
     412        if(socket_port && (socket_port->count > 0)){
     413                socket_ref = socket_port_map_find(&socket_port->map, key, key_length);
     414                if(socket_ref){
    397415                        return * socket_ref;
    398416                }
    … …  
    401419}
    402420
    403 void socket_port_release( socket_ports_ref global_sockets, socket_core_ref socket ){
    404         socket_port_ref socket_port;
    405         socket_core_ref *       socket_ref;
    406 
    407         if( socket->port ){
     421void socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket){
     422        socket_port_ref socket_port;
     423        socket_core_ref * socket_ref;
     424
     425        if(socket->port){
    408426                // find ports
    409                 socket_port = socket_ports_find( global_sockets, socket->port );
    410                 if( socket_port ){
     427                socket_port = socket_ports_find(global_sockets, socket->port);
     428                if(socket_port){
    411429                        // find the socket
    412                         socket_ref = socket_port_map_find( & socket_port->map, socket->key, socket->key_length );
    413                         if( socket_ref ){
     430                        socket_ref = socket_port_map_find(&socket_port->map, socket->key, socket->key_length);
     431                        if(socket_ref){
    414432                                -- socket_port->count;
    415433                                // release if empty
    416                                 if( socket_port->count <= 0 ){
     434                                if(socket_port->count <= 0){
    417435                                        // destroy the map
    418                                         socket_port_map_destroy( & socket_port->map );
     436                                        socket_port_map_destroy(&socket_port->map);
    419437                                        // release the port
    420                                         socket_ports_exclude( global_sockets, socket->port );
     438                                        socket_ports_exclude(global_sockets, socket->port);
    421439                                }else{
    422440                                        // remove
    423                                         socket_port_map_exclude( & socket_port->map, socket->key, socket->key_length );
     441                                        socket_port_map_exclude(&socket_port->map, socket->key, socket->key_length);
    424442                                }
    425443                        }
    … …  
    431449}
    432450
    433 int socket_port_add( socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length ){
     451int socket_port_add(socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length){
    434452        ERROR_DECLARE;
    435453
    436         socket_port_ref         socket_port;
     454        socket_port_ref socket_port;
    437455
    438456        // find ports
    439         socket_port = socket_ports_find( global_sockets, port );
    440         if( ! socket_port ) return ENOENT;
     457        socket_port = socket_ports_find(global_sockets, port);
     458        if(! socket_port){
     459                return ENOENT;
     460        }
    441461        // add the socket
    442         ERROR_PROPAGATE( socket_port_add_core( socket_port, socket, key, key_length ));
     462        ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key, key_length));
    443463        socket->port = port;
    444464        return EOK;
    445465}
    446466
    447 int socket_port_add_core( socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length ){
     467int socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket, const char * key, size_t key_length){
    448468        ERROR_DECLARE;
    449469
    450         socket_core_ref *       socket_ref;
     470        socket_core_ref * socket_ref;
    451471
    452472        // create a wrapper
    453         socket_ref = malloc( sizeof( * socket_ref ));
    454         if( ! socket_ref ) return ENOMEM;
    455         * socket_ref = socket;
     473        socket_ref = malloc(sizeof(*socket_ref));
     474        if(! socket_ref){
     475                return ENOMEM;
     476        }
     477        *socket_ref = socket;
    456478        // add the wrapper
    457         if( ERROR_OCCURRED( socket_port_map_add( & socket_port->map, key, key_length, socket_ref ))){
    458                 free( socket_ref );
     479        if(ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key, key_length, socket_ref))){
     480                free(socket_ref);
    459481                return ERROR_CODE;
    460482        }

  • uspace/srv/net/socket/socket_core.h

    raa85487 raadf01e  
    9393        /** Socket identifier.
    9494         */
    95         int                             socket_id;
     95        int socket_id;
    9696        /** Client application phone.
    9797         */
    98         int                             phone;
     98        int phone;
    9999        /** Bound port.
    100100         */
    101         int                             port;
     101        int port;
    102102        /** Received packets queue.
    103103         */
    104         dyn_fifo_t              received;
     104        dyn_fifo_t received;
    105105        /** Sockets for acceptance queue.
    106106         */
    107         dyn_fifo_t              accepted;
     107        dyn_fifo_t accepted;
    108108        /** Protocol specific data.
    109109         */
    110         void *                  specific_data;
     110        void * specific_data;
    111111        /** Socket ports map key.
    112112         */
    113         const char *    key;
     113        const char * key;
    114114        /** Length of the Socket ports map key.
    115115         */
    116         size_t                  key_length;
     116        size_t key_length;
    117117};
    118118
    … …  
    120120 *  The key is the socket identifier.
    121121 */
    122 INT_MAP_DECLARE( socket_cores, socket_core_t );
     122INT_MAP_DECLARE(socket_cores, socket_core_t);
    123123
    124124/** Bount port sockets map.
    125125 *  The listening socket has the SOCKET_MAP_KEY_LISTENING key identifier whereas the other use the remote addresses.
    126126 */
    127 GENERIC_CHAR_MAP_DECLARE( socket_port_map, socket_core_ref );
     127GENERIC_CHAR_MAP_DECLARE(socket_port_map, socket_core_ref);
    128128
    129129/** Ports map.
    130130 *  The key is the port number.
    131131 */
    132 INT_MAP_DECLARE( socket_ports, socket_port_t );
     132INT_MAP_DECLARE(socket_ports, socket_port_t);
    133133
    134134/** Destroys local sockets.
    … …  
    139139 *  @param[in] socket_release The client release callback function.
    140140 */
    141 void    socket_cores_release( int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket ));
     141void socket_cores_release(int packet_phone, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
    142142
    143143/** Binds the socket to the port.
    … …  
    158158 *  @returns Other error codes as defined for the socket_bind_insert() function.
    159159 */
    160 int socket_bind( socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port );
     160int socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets, int socket_id, void * addr, size_t addrlen, int free_ports_start, int free_ports_end, int last_used_port);
    161161
    162162/** Binds the socket to a free port.
    … …  
    171171 *  @returns Other error codes as defined for the socket_bind_insert() function.
    172172 */
    173 int     socket_bind_free_port( socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port );
     173int socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port);
    174174
    175175/** Creates a new socket.
    … …  
    182182 *  @returns ENOMEM if there is not enough memory left.
    183183 */
    184 int socket_create( socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id );
     184int socket_create(socket_cores_ref local_sockets, int app_phone, void * specific_data, int * socket_id);
    185185
    186186/** Destroys the socket.
    … …  
    195195 *  @returns ENOTSOCK if the socket is not found.
    196196 */
    197 int socket_destroy( int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void ( * socket_release )( socket_core_ref socket ));
     197int socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets, socket_ports_ref global_sockets, void (*socket_release)(socket_core_ref socket));
    198198
    199199/** Replies the packet or the packet queue data to the application via the socket.
    … …  
    206206 *  @returns Other error codes as defined for the data_reply() function.
    207207 */
    208 int     socket_reply_packets( packet_t packet, size_t * length );
     208int socket_reply_packets(packet_t packet, size_t * length);
    209209
    210210/** Finds the bound port socket.
    … …  
    216216 *  @returns NULL if no socket was found.
    217217 */
    218 socket_core_ref socket_port_find( socket_ports_ref global_sockets, int port, const char * key, size_t key_length );
     218socket_core_ref socket_port_find(socket_ports_ref global_sockets, int port, const char * key, size_t key_length);
    219219
    220220/** Releases the socket port.
    … …  
    224224 *  @param[in] socket The socket to be unbound.
    225225 */
    226 void    socket_port_release( socket_ports_ref global_sockets, socket_core_ref socket );
     226void socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket);
    227227
    228228/** Adds the socket to an already bound port.
    … …  
    236236 *  @returns Other error codes as defined for the socket_port_add_core() function.
    237237 */
    238 int     socket_port_add( socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length );
     238int socket_port_add(socket_ports_ref global_sockets, int port, socket_core_ref socket, const char * key, size_t key_length);
    239239
    240240#endif

  • uspace/srv/net/socket/socket_messages.h

    raa85487 raadf01e  
    115115 *  @param[out] answer The message answer structure.
    116116 */
    117 #define SOCKET_SET_SOCKET_ID( answer )                  ( int * ) & IPC_GET_ARG1( answer )
     117#define SOCKET_SET_SOCKET_ID(answer)                    (int *) &IPC_GET_ARG1(answer)
    118118
    119119/** Returns the socket identifier message parameter.
    120120 *  @param[in] call The message call structure.
    121121 */
    122 #define SOCKET_GET_SOCKET_ID( call )                    ( int ) IPC_GET_ARG1( call )
     122#define SOCKET_GET_SOCKET_ID(call)                      (int) IPC_GET_ARG1(call)
    123123
    124124/** Sets the read data length in the message answer.
    125125 *  @param[out] answer The message answer structure.
    126126 */
    127 #define SOCKET_SET_READ_DATA_LENGTH( answer )   ( int * ) & IPC_GET_ARG1( answer )
     127#define SOCKET_SET_READ_DATA_LENGTH(answer)     (int *) &IPC_GET_ARG1(answer)
    128128
    129129/** Returns the read data length message parameter.
    130130 *  @param[in] call The message call structure.
    131131 */
    132 #define SOCKET_GET_READ_DATA_LENGTH( call )             ( int ) IPC_GET_ARG1( call )
     132#define SOCKET_GET_READ_DATA_LENGTH(call)               (int) IPC_GET_ARG1(call)
    133133
    134134/** Returns the backlog message parameter.
    135135 *  @param[in] call The message call structure.
    136136 */
    137 #define SOCKET_GET_BACKLOG( call )                              ( int ) IPC_GET_ARG2( call )
     137#define SOCKET_GET_BACKLOG(call)                                (int) IPC_GET_ARG2(call)
    138138
    139139/** Returns the option level message parameter.
    140140 *  @param[in] call The message call structure.
    141141 */
    142 #define SOCKET_GET_OPT_LEVEL( call )                    ( int ) IPC_GET_ARG2( call )
     142#define SOCKET_GET_OPT_LEVEL(call)                      (int) IPC_GET_ARG2(call)
    143143
    144144/** Returns the data fragment size message parameter.
    145145 *  @param[in] call The message call structure.
    146146 */
    147 #define SOCKET_GET_DATA_FRAGMENT_SIZE( call )   ( size_t ) IPC_GET_ARG2( call )
     147#define SOCKET_GET_DATA_FRAGMENT_SIZE(call)     (size_t) IPC_GET_ARG2(call)
    148148
    149149/** Sets the data fragment size in the message answer.
    150150 *  @param[out] answer The message answer structure.
    151151 */
    152 #define SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) ( size_t * ) & IPC_GET_ARG2( answer )
     152#define SOCKET_SET_DATA_FRAGMENT_SIZE(answer)   (size_t *) &IPC_GET_ARG2(answer)
    153153
    154154/** Sets the address length in the message answer.
    155155 *  @param[out] answer The message answer structure.
    156156 */
    157 #define SOCKET_SET_ADDRESS_LENGTH( answer )             ( socklen_t * ) & IPC_GET_ARG3( answer )
     157#define SOCKET_SET_ADDRESS_LENGTH(answer)               (socklen_t *) &IPC_GET_ARG3(answer)
    158158
    159159/** Returns the address length message parameter.
    160160 *  @param[in] call The message call structure.
    161161 */
    162 #define SOCKET_GET_ADDRESS_LENGTH( call )               ( socklen_t ) IPC_GET_ARG3( call )
     162#define SOCKET_GET_ADDRESS_LENGTH(call)         (socklen_t) IPC_GET_ARG3(call)
    163163
    164164/** Sets the header size in the message answer.
    165165 *  @param[out] answer The message answer structure.
    166166 */
    167 #define SOCKET_SET_HEADER_SIZE( answer )                ( int * ) & IPC_GET_ARG3( answer )
     167#define SOCKET_SET_HEADER_SIZE(answer)          (int *) &IPC_GET_ARG3(answer)
    168168
    169169/** Returns the header size message parameter.
    170170 *  @param[in] call The message call structure.
    171171 */
    172 #define SOCKET_GET_HEADER_SIZE( call )                  ( int ) IPC_GET_ARG3( call )
     172#define SOCKET_GET_HEADER_SIZE(call)                    (int) IPC_GET_ARG3(call)
    173173
    174174/** Returns the flags message parameter.
    175175 *  @param[in] call The message call structure.
    176176 */
    177 #define SOCKET_GET_FLAGS( call )                                ( int ) IPC_GET_ARG4( call )
     177#define SOCKET_GET_FLAGS(call)                          (int) IPC_GET_ARG4(call)
    178178
    179179/** Returns the option name message parameter.
    180180 *  @param[in] call The message call structure.
    181181 */
    182 #define SOCKET_GET_OPT_NAME( call )                             ( int ) IPC_GET_ARG4( call )
     182#define SOCKET_GET_OPT_NAME(call)                               (int) IPC_GET_ARG4(call)
    183183
    184184/** Returns the data fragments message parameter.
    185185 *  @param[in] call The message call structure.
    186186 */
    187 #define SOCKET_GET_DATA_FRAGMENTS( call )               ( int ) IPC_GET_ARG5( call )
     187#define SOCKET_GET_DATA_FRAGMENTS(call)         (int) IPC_GET_ARG5(call)
    188188
    189189/** Returns the new socket identifier message parameter.
    190190 *  @param[in] call The message call structure.
    191191 */
    192 #define SOCKET_GET_NEW_SOCKET_ID( call )                ( int ) IPC_GET_ARG5( call )
     192#define SOCKET_GET_NEW_SOCKET_ID(call)          (int) IPC_GET_ARG5(call)
    193193
    194194/*@}*/
Note: See TracChangeset for help on using the changeset viewer.