Changeset 71b00dcc in mainline for uspace/srv/net/socket/socket_core.c


Ignore:
Timestamp:
2010-03-07T22:51:38Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
60ab6c3
Parents:
b5cbff4 (diff), 31c80a5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~lukasmejdrech/helenos/network.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rb5cbff4 r71b00dcc  
    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        }
Note: See TracChangeset for help on using the changeset viewer.