Changeset b5e68c8 in mainline for uspace/lib/net/tl/socket_core.c


Ignore:
Timestamp:
2011-05-12T16:49:44Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f36787d7
Parents:
e80329d6 (diff), 750636a (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 mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/net/tl/socket_core.c

    re80329d6 rb5e68c8  
    4848#include <stdlib.h>
    4949#include <errno.h>
    50 #include <err.h>
    5150
    5251#include <adt/dynamic_fifo.h>
    … …  
    6968INT_MAP_IMPLEMENT(socket_cores, socket_core_t);
    7069
    71 GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_ref);
     70GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_t *);
    7271
    7372INT_MAP_IMPLEMENT(socket_ports, socket_port_t);
    … …  
    8685 */
    8786static void
    88 socket_destroy_core(int packet_phone, socket_core_ref socket,
    89     socket_cores_ref local_sockets, socket_ports_ref global_sockets,
    90     void (* socket_release)(socket_core_ref socket))
     87socket_destroy_core(int packet_phone, socket_core_t *socket,
     88    socket_cores_t *local_sockets, socket_ports_t *global_sockets,
     89    void (* socket_release)(socket_core_t *socket))
    9190{
    9291        int packet_id;
    9392
    94         // if bound
     93        /* If bound */
    9594        if (socket->port) {
    96                 // release the port
     95                /* Release the port */
    9796                socket_port_release(global_sockets, socket);
    9897        }
    9998       
    100         // release all received packets
     99        /* Release all received packets */
    101100        while ((packet_id = dyn_fifo_pop(&socket->received)) >= 0)
    102101                pq_release_remote(packet_phone, packet_id);
    … …  
    108107                socket_release(socket);
    109108
    110         socket_cores_exclude(local_sockets, socket->socket_id);
     109        socket_cores_exclude(local_sockets, socket->socket_id, free);
    111110}
    112111
    … …  
    122121 */
    123122void
    124 socket_cores_release(int packet_phone, socket_cores_ref local_sockets,
    125     socket_ports_ref global_sockets,
    126     void (* socket_release)(socket_core_ref socket))
     123socket_cores_release(int packet_phone, socket_cores_t *local_sockets,
     124    socket_ports_t *global_sockets,
     125    void (* socket_release)(socket_core_t *socket))
    127126{
    128127        int index;
    … …  
    157156 * @param[in] key       The socket key identifier.
    158157 * @param[in] key_length The socket key length.
    159  * @returns             EOK on success.
    160  * @returns             ENOMEM if there is not enough memory left.
     158 * @return              EOK on success.
     159 * @return              ENOMEM if there is not enough memory left.
    161160 */
    162161static int
    163 socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket,
    164     const char *key, size_t key_length)
    165 {
    166         ERROR_DECLARE;
    167 
    168         socket_core_ref *socket_ref;
    169 
    170         // create a wrapper
     162socket_port_add_core(socket_port_t *socket_port, socket_core_t *socket,
     163    const uint8_t *key, size_t key_length)
     164{
     165        socket_core_t **socket_ref;
     166        int rc;
     167
     168        /* Create a wrapper */
    171169        socket_ref = malloc(sizeof(*socket_ref));
    172170        if (!socket_ref)
    … …  
    174172
    175173        *socket_ref = socket;
    176         // add the wrapper
    177         if (ERROR_OCCURRED(socket_port_map_add(&socket_port->map, key,
    178             key_length, socket_ref))) {
     174        /* Add the wrapper */
     175        rc = socket_port_map_add(&socket_port->map, key, key_length,
     176            socket_ref);
     177        if (rc != EOK) {
    179178                free(socket_ref);
    180                 return ERROR_CODE;
     179                return rc;
    181180        }
    182181       
    … …  
    195194 * @param[in] socket    The socket to be added.
    196195 * @param[in] port      The port number to be bound to.
    197  * @returns             EOK on success.
    198  * @returns             ENOMEM if there is not enough memory left.
    199  * @returns             Other error codes as defined for the
     196 * @return              EOK on success.
     197 * @return              ENOMEM if there is not enough memory left.
     198 * @return              Other error codes as defined for the
    200199 *                       socket_ports_add() function.
    201200 */
    202201static int
    203 socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket,
     202socket_bind_insert(socket_ports_t *global_sockets, socket_core_t *socket,
    204203    int port)
    205204{
    206         ERROR_DECLARE;
    207 
    208         socket_port_ref socket_port;
    209 
    210         // create a wrapper
     205        socket_port_t *socket_port;
     206        int rc;
     207
     208        /* Create a wrapper */
    211209        socket_port = malloc(sizeof(*socket_port));
    212210        if (!socket_port)
    … …  
    214212
    215213        socket_port->count = 0;
    216         if (ERROR_OCCURRED(socket_port_map_initialize(&socket_port->map)) ||
    217             ERROR_OCCURRED(socket_port_add_core(socket_port, socket,
    218             SOCKET_MAP_KEY_LISTENING, 0))) {
    219                 socket_port_map_destroy(&socket_port->map);
    220                 free(socket_port);
    221                 return ERROR_CODE;
    222         }
    223        
    224         // register the incomming port
    225         ERROR_CODE = socket_ports_add(global_sockets, port, socket_port);
    226         if (ERROR_CODE < 0) {
    227                 socket_port_map_destroy(&socket_port->map);
    228                 free(socket_port);
    229                 return ERROR_CODE;
    230         }
     214        rc = socket_port_map_initialize(&socket_port->map);
     215        if (rc != EOK)
     216                goto fail;
     217       
     218        rc = socket_port_add_core(socket_port, socket,
     219            (const uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
     220        if (rc != EOK)
     221                goto fail;
     222       
     223        /* Register the incoming port */
     224        rc = socket_ports_add(global_sockets, port, socket_port);
     225        if (rc < 0)
     226                goto fail;
    231227       
    232228        socket->port = port;
    233229        return EOK;
     230
     231fail:
     232        socket_port_map_destroy(&socket_port->map, free);
     233        free(socket_port);
     234        return rc;
     235       
    234236}
    235237
    … …  
    246248 * @param[in] free_ports_end The maximum free port.
    247249 * @param[in] last_used_port The last used free port.
    248  * @returns             EOK on success.
    249  * @returns             ENOTSOCK if the socket was not found.
    250  * @returns             EAFNOSUPPORT if the address family is not supported.
    251  * @returns             EADDRINUSE if the port is already in use.
    252  * @returns             Other error codes as defined for the
     250 * @return              EOK on success.
     251 * @return              ENOTSOCK if the socket was not found.
     252 * @return              EAFNOSUPPORT if the address family is not supported.
     253 * @return              EADDRINUSE if the port is already in use.
     254 * @return              Other error codes as defined for the
    253255 *                      socket_bind_free_port() function.
    254  * @returns             Other error codes as defined for the
     256 * @return              Other error codes as defined for the
    255257 *                      socket_bind_insert() function.
    256258 */
    257259int
    258 socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets,
     260socket_bind(socket_cores_t *local_sockets, socket_ports_t *global_sockets,
    259261    int socket_id, void *addr, size_t addrlen, int free_ports_start,
    260262    int free_ports_end, int last_used_port)
    261263{
    262         socket_core_ref socket;
    263         socket_port_ref socket_port;
     264        socket_core_t *socket;
     265        socket_port_t *socket_port;
    264266        struct sockaddr *address;
    265267        struct sockaddr_in *address_in;
    … …  
    275277               
    276278                address_in = (struct sockaddr_in *) addr;
    277                 // find the socket
     279                /* Find the socket */
    278280                socket = socket_cores_find(local_sockets, socket_id);
    279281                if (!socket)
    280282                        return ENOTSOCK;
    281283               
    282                 // bind a free port?
     284                /* Bind a free port? */
    283285                if (address_in->sin_port <= 0)
    284286                        return socket_bind_free_port(global_sockets, socket,
    285287                             free_ports_start, free_ports_end, last_used_port);
    286288               
    287                 // try to find the port
     289                /* Try to find the port */
    288290                socket_port = socket_ports_find(global_sockets,
    289291                    ntohs(address_in->sin_port));
    290292                if (socket_port) {
    291                         // already used
     293                        /* Already used */
    292294                        return EADDRINUSE;
    293295                }
    294296               
    295                 // if bound
     297                /* If bound */
    296298                if (socket->port) {
    297                         // release the port
     299                        /* Release the port */
    298300                        socket_port_release(global_sockets, socket);
    299301                }
    … …  
    320322 * @param[in] free_ports_end The maximum free port.
    321323 * @param[in] last_used_port The last used free port.
    322  * @returns             EOK on success.
    323  * @returns             ENOTCONN if no free port was found.
    324  * @returns             Other error codes as defined for the
     324 * @return              EOK on success.
     325 * @return              ENOTCONN if no free port was found.
     326 * @return              Other error codes as defined for the
    325327 *                      socket_bind_insert() function.
    326328 */
    327329int
    328 socket_bind_free_port(socket_ports_ref global_sockets, socket_core_ref socket,
     330socket_bind_free_port(socket_ports_t *global_sockets, socket_core_t *socket,
    329331    int free_ports_start, int free_ports_end, int last_used_port)
    330332{
    331333        int index;
    332334
    333         // from the last used one
     335        /* From the last used one */
    334336        index = last_used_port;
    335337       
    … …  
    337339                ++index;
    338340               
    339                 // til the range end
     341                /* Till the range end */
    340342                if (index >= free_ports_end) {
    341                         // start from the range beginning
     343                        /* Start from the range beginning */
    342344                        index = free_ports_start - 1;
    343345                        do {
    344346                                ++index;
    345                                 // til the last used one
     347                                /* Till the last used one */
    346348                                if (index >= last_used_port) {
    347                                         // none found
     349                                        /* None found */
    348350                                        return ENOTCONN;
    349351                                }
    350352                        } while (socket_ports_find(global_sockets, index));
    351353                       
    352                         // found, break immediately
     354                        /* Found, break immediately */
    353355                        break;
    354356                }
    … …  
    365367 *                      requested. A negative identifier is requested if set to
    366368 *                      false.
    367  * @returns             The new socket identifier.
    368  * @returns             ELIMIT if there is no socket identifier available.
    369  */
    370 static int socket_generate_new_id(socket_cores_ref local_sockets, int positive)
     369 * @return              The new socket identifier.
     370 * @return              ELIMIT if there is no socket identifier available.
     371 */
     372static int socket_generate_new_id(socket_cores_t *local_sockets, int positive)
    371373{
    372374        int socket_id;
    … …  
    374376
    375377        count = 0;
    376 //      socket_id = socket_globals.last_id;
     378#if 0
     379        socket_id = socket_globals.last_id;
     380#endif
    377381        do {
    378382                if (count < SOCKET_ID_TRIES) {
    … …  
    382386                        socket_id = 1;
    383387                        ++count;
    384                 // only this branch for last_id
     388                /* Only this branch for last_id */
    385389                } else {
    386390                        if (socket_id < INT_MAX) {
    387391                                ++ socket_id;
    388 /*                      } else if(socket_globals.last_id) {
    389 *                               socket_globals.last_id = 0;
    390 *                               socket_id = 1;
    391 */                      } else {
     392#if 0
     393                        } else if(socket_globals.last_id) {
     394                                socket_globals.last_id = 0;
     395                                socket_id = 1;
     396#endif
     397                        } else {
    392398                                return ELIMIT;
    393399                        }
    … …  
    408414 *                      chosen if set to zero or negative. A negative identifier
    409415 *                      is chosen if set to negative.
    410  * @returns             EOK on success.
    411  * @returns             EINVAL if the socket_id parameter is NULL.
    412  * @returns             ENOMEM if there is not enough memory left.
     416 * @return              EOK on success.
     417 * @return              EINVAL if the socket_id parameter is NULL.
     418 * @return              ENOMEM if there is not enough memory left.
    413419 */
    414420int
    415 socket_create(socket_cores_ref local_sockets, int app_phone,
     421socket_create(socket_cores_t *local_sockets, int app_phone,
    416422    void *specific_data, int *socket_id)
    417423{
    418         ERROR_DECLARE;
    419 
    420         socket_core_ref socket;
    421         int res;
     424        socket_core_t *socket;
    422425        int positive;
     426        int rc;
    423427
    424428        if (!socket_id)
    425429                return EINVAL;
    426430       
    427         // store the socket
     431        /* Store the socket */
    428432        if (*socket_id <= 0) {
    429433                positive = (*socket_id == 0);
    … …  
    437441        }
    438442       
    439         socket = (socket_core_ref) malloc(sizeof(*socket));
     443        socket = (socket_core_t *) malloc(sizeof(*socket));
    440444        if (!socket)
    441445                return ENOMEM;
    442446       
    443         // initialize
     447        /* Initialize */
    444448        socket->phone = app_phone;
    445449        socket->port = -1;
    … …  
    447451        socket->key_length = 0;
    448452        socket->specific_data = specific_data;
    449         if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->received,
    450             SOCKET_INITIAL_RECEIVED_SIZE))) {
     453        rc = dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
     454        if (rc != EOK) {
    451455                free(socket);
    452                 return ERROR_CODE;
    453         }
    454         if (ERROR_OCCURRED(dyn_fifo_initialize(&socket->accepted,
    455             SOCKET_INITIAL_ACCEPTED_SIZE))) {
     456                return rc;
     457        }
     458       
     459        rc = dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
     460        if (rc != EOK) {
    456461                dyn_fifo_destroy(&socket->received);
    457462                free(socket);
    458                 return ERROR_CODE;
     463                return rc;
    459464        }
    460465        socket->socket_id = *socket_id;
    461         res = socket_cores_add(local_sockets, socket->socket_id, socket);
    462         if (res < 0) {
     466        rc = socket_cores_add(local_sockets, socket->socket_id, socket);
     467        if (rc < 0) {
    463468                dyn_fifo_destroy(&socket->received);
    464469                dyn_fifo_destroy(&socket->accepted);
    465470                free(socket);
    466                 return res;
     471                return rc;
    467472        }
    468473       
    … …  
    481486 * @param[in,out] global_sockets The global sockets to be updated.
    482487 * @param[in] socket_release The client release callback function.
    483  * @returns             EOK on success.
    484  * @returns             ENOTSOCK if the socket is not found.
     488 * @return              EOK on success.
     489 * @return              ENOTSOCK if the socket is not found.
    485490 */
    486491int
    487 socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets,
    488     socket_ports_ref global_sockets,
    489     void (*socket_release)(socket_core_ref socket))
    490 {
    491         socket_core_ref socket;
     492socket_destroy(int packet_phone, int socket_id, socket_cores_t *local_sockets,
     493    socket_ports_t *global_sockets,
     494    void (*socket_release)(socket_core_t *socket))
     495{
     496        socket_core_t *socket;
    492497        int accepted_id;
    493498
    494         // find the socket
     499        /* Find the socket */
    495500        socket = socket_cores_find(local_sockets, socket_id);
    496501        if (!socket)
    497502                return ENOTSOCK;
    498503       
    499         // destroy all accepted sockets
     504        /* Destroy all accepted sockets */
    500505        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    501506                socket_destroy(packet_phone, accepted_id, local_sockets,
    … …  
    515520 * @param[in] packet    The packet to be transfered.
    516521 * @param[out] length   The total data length.
    517  * @returns             EOK on success.
    518  * @returns             EBADMEM if the length parameter is NULL.
    519  * @returns             ENOMEM if there is not enough memory left.
    520  * @returns             Other error codes as defined for the data_reply()
     522 * @return              EOK on success.
     523 * @return              EBADMEM if the length parameter is NULL.
     524 * @return              ENOMEM if there is not enough memory left.
     525 * @return              Other error codes as defined for the data_reply()
    521526 *                      function.
    522527 */
    523 int socket_reply_packets(packet_t packet, size_t *length)
    524 {
    525         ERROR_DECLARE;
    526 
    527         packet_t next_packet;
     528int socket_reply_packets(packet_t *packet, size_t *length)
     529{
     530        packet_t *next_packet;
    528531        size_t fragments;
    529532        size_t *lengths;
    530533        size_t index;
     534        int rc;
    531535
    532536        if (!length)
    … …  
    535539        next_packet = pq_next(packet);
    536540        if (!next_packet) {
    537                 // write all if only one fragment
    538                 ERROR_PROPAGATE(data_reply(packet_get_data(packet),
    539                     packet_get_data_length(packet)));
    540                 // store the total length
     541                /* Write all if only one fragment */
     542                rc = data_reply(packet_get_data(packet),
     543                    packet_get_data_length(packet));
     544                if (rc != EOK)
     545                        return rc;
     546                /* Store the total length */
    541547                *length = packet_get_data_length(packet);
    542548        } else {
    543                 // count the packet fragments
     549                /* Count the packet fragments */
    544550                fragments = 1;
    545551                next_packet = pq_next(packet);
    … …  
    547553                        ++fragments;
    548554               
    549                 // compute and store the fragment lengths
     555                /* Compute and store the fragment lengths */
    550556                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    551557                    sizeof(size_t));
    … …  
    563569                }
    564570               
    565                 // write the fragment lengths
    566                 if (ERROR_OCCURRED(data_reply(lengths,
    567                     sizeof(int) * (fragments + 1)))) {
     571                /* Write the fragment lengths */
     572                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
     573                if (rc != EOK) {
    568574                        free(lengths);
    569                         return ERROR_CODE;
     575                        return rc;
    570576                }
    571577                next_packet = packet;
    572578               
    573                 // write the fragments
     579                /* Write the fragments */
    574580                for (index = 0; index < fragments; ++index) {
    575                         ERROR_CODE = data_reply(packet_get_data(next_packet),
     581                        rc = data_reply(packet_get_data(next_packet),
    576582                            lengths[index]);
    577                         if (ERROR_OCCURRED(ERROR_CODE)) {
     583                        if (rc != EOK) {
    578584                                free(lengths);
    579                                 return ERROR_CODE;
     585                                return rc;
    580586                        }
    581587                        next_packet = pq_next(next_packet);
    582588                }
    583589               
    584                 // store the total length
     590                /* Store the total length */
    585591                *length = lengths[fragments];
    586592                free(lengths);
    … …  
    596602 * @param[in] key       The socket key identifier.
    597603 * @param[in] key_length The socket key length.
    598  * @returns             The found socket.
    599  * @returns             NULL if no socket was found.
    600  */
    601 socket_core_ref
    602 socket_port_find(socket_ports_ref global_sockets, int port, const char *key,
     604 * @return              The found socket.
     605 * @return              NULL if no socket was found.
     606 */
     607socket_core_t *
     608socket_port_find(socket_ports_t *global_sockets, int port, const uint8_t *key,
    603609    size_t key_length)
    604610{
    605         socket_port_ref socket_port;
    606         socket_core_ref *socket_ref;
     611        socket_port_t *socket_port;
     612        socket_core_t **socket_ref;
    607613
    608614        socket_port = socket_ports_find(global_sockets, port);
    … …  
    626632 */
    627633void
    628 socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket)
    629 {
    630         socket_port_ref socket_port;
    631         socket_core_ref *socket_ref;
     634socket_port_release(socket_ports_t *global_sockets, socket_core_t *socket)
     635{
     636        socket_port_t *socket_port;
     637        socket_core_t **socket_ref;
    632638
    633639        if (!socket->port)
    634640                return;
    635641       
    636         // find ports
     642        /* Find ports */
    637643        socket_port = socket_ports_find(global_sockets, socket->port);
    638644        if (socket_port) {
    639                 // find the socket
     645                /* Find the socket */
    640646                socket_ref = socket_port_map_find(&socket_port->map,
    641647                    socket->key, socket->key_length);
    … …  
    644650                        --socket_port->count;
    645651                       
    646                         // release if empty
     652                        /* Release if empty */
    647653                        if (socket_port->count <= 0) {
    648                                 // destroy the map
    649                                 socket_port_map_destroy(&socket_port->map);
    650                                 // release the port
     654                                /* Destroy the map */
     655                                socket_port_map_destroy(&socket_port->map, free);
     656                                /* Release the port */
    651657                                socket_ports_exclude(global_sockets,
    652                                     socket->port);
     658                                    socket->port, free);
    653659                        } else {
    654                                 // remove
     660                                /* Remove */
    655661                                socket_port_map_exclude(&socket_port->map,
    656                                     socket->key, socket->key_length);
     662                                    socket->key, socket->key_length, free);
    657663                        }
    658664                }
    … …  
    671677 * @param[in] key       The socket key identifier.
    672678 * @param[in] key_length The socket key length.
    673  * @returns             EOK on success.
    674  * @returns             ENOENT if the port is not already used.
    675  * @returns             Other error codes as defined for the
     679 * @return              EOK on success.
     680 * @return              ENOENT if the port is not already used.
     681 * @return              Other error codes as defined for the
    676682 *                      socket_port_add_core() function.
    677683 */
    678684int
    679 socket_port_add(socket_ports_ref global_sockets, int port,
    680     socket_core_ref socket, const char *key, size_t key_length)
    681 {
    682         ERROR_DECLARE;
    683 
    684         socket_port_ref socket_port;
    685 
    686         // find ports
     685socket_port_add(socket_ports_t *global_sockets, int port,
     686    socket_core_t *socket, const uint8_t *key, size_t key_length)
     687{
     688        socket_port_t *socket_port;
     689        int rc;
     690
     691        /* Find ports */
    687692        socket_port = socket_ports_find(global_sockets, port);
    688693        if (!socket_port)
    689694                return ENOENT;
    690695       
    691         // add the socket
    692         ERROR_PROPAGATE(socket_port_add_core(socket_port, socket, key,
    693             key_length));
     696        /* Add the socket */
     697        rc = socket_port_add_core(socket_port, socket, key, key_length);
     698        if (rc != EOK)
     699                return rc;
    694700       
    695701        socket->port = port;
Note: See TracChangeset for help on using the changeset viewer.