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


Ignore:
Timestamp:
2011-06-01T08:43:42Z (14 years ago)
Author:
Lubos Slovak <lubos.slovak@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8d6c1f1
Parents:
9e2e715 (diff), e51a514 (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:

Huuuuuge merge from development - all the work actually :)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r9e2e715 reb522e8  
    6868INT_MAP_IMPLEMENT(socket_cores, socket_core_t);
    6969
    70 GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_ref);
     70GENERIC_CHAR_MAP_IMPLEMENT(socket_port_map, socket_core_t *);
    7171
    7272INT_MAP_IMPLEMENT(socket_ports, socket_port_t);
    … …  
    8585 */
    8686static void
    87 socket_destroy_core(int packet_phone, socket_core_ref socket,
    88     socket_cores_ref local_sockets, socket_ports_ref global_sockets,
    89     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))
    9090{
    9191        int packet_id;
    9292
    93         // if bound
     93        /* If bound */
    9494        if (socket->port) {
    95                 // release the port
     95                /* Release the port */
    9696                socket_port_release(global_sockets, socket);
    9797        }
    9898       
    99         // release all received packets
     99        /* Release all received packets */
    100100        while ((packet_id = dyn_fifo_pop(&socket->received)) >= 0)
    101101                pq_release_remote(packet_phone, packet_id);
    … …  
    107107                socket_release(socket);
    108108
    109         socket_cores_exclude(local_sockets, socket->socket_id);
     109        socket_cores_exclude(local_sockets, socket->socket_id, free);
    110110}
    111111
    … …  
    121121 */
    122122void
    123 socket_cores_release(int packet_phone, socket_cores_ref local_sockets,
    124     socket_ports_ref global_sockets,
    125     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))
    126126{
    127127        int index;
    … …  
    156156 * @param[in] key       The socket key identifier.
    157157 * @param[in] key_length The socket key length.
    158  * @returns             EOK on success.
    159  * @returns             ENOMEM if there is not enough memory left.
     158 * @return              EOK on success.
     159 * @return              ENOMEM if there is not enough memory left.
    160160 */
    161161static int
    162 socket_port_add_core(socket_port_ref socket_port, socket_core_ref socket,
    163     const char *key, size_t key_length)
    164 {
    165         socket_core_ref *socket_ref;
     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;
    166166        int rc;
    167167
    168         // create a wrapper
     168        /* Create a wrapper */
    169169        socket_ref = malloc(sizeof(*socket_ref));
    170170        if (!socket_ref)
    … …  
    172172
    173173        *socket_ref = socket;
    174         // add the wrapper
     174        /* Add the wrapper */
    175175        rc = socket_port_map_add(&socket_port->map, key, key_length,
    176176            socket_ref);
    … …  
    194194 * @param[in] socket    The socket to be added.
    195195 * @param[in] port      The port number to be bound to.
    196  * @returns             EOK on success.
    197  * @returns             ENOMEM if there is not enough memory left.
    198  * @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
    199199 *                       socket_ports_add() function.
    200200 */
    201201static int
    202 socket_bind_insert(socket_ports_ref global_sockets, socket_core_ref socket,
     202socket_bind_insert(socket_ports_t *global_sockets, socket_core_t *socket,
    203203    int port)
    204204{
    205         socket_port_ref socket_port;
     205        socket_port_t *socket_port;
    206206        int rc;
    207207
    208         // create a wrapper
     208        /* Create a wrapper */
    209209        socket_port = malloc(sizeof(*socket_port));
    210210        if (!socket_port)
    … …  
    216216                goto fail;
    217217       
    218         rc = socket_port_add_core(socket_port, socket, SOCKET_MAP_KEY_LISTENING,
    219             0);
     218        rc = socket_port_add_core(socket_port, socket,
     219            (const uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
    220220        if (rc != EOK)
    221221                goto fail;
    222222       
    223         // register the incomming port
     223        /* Register the incoming port */
    224224        rc = socket_ports_add(global_sockets, port, socket_port);
    225225        if (rc < 0)
    … …  
    230230
    231231fail:
    232         socket_port_map_destroy(&socket_port->map);
     232        socket_port_map_destroy(&socket_port->map, free);
    233233        free(socket_port);
    234234        return rc;
    … …  
    248248 * @param[in] free_ports_end The maximum free port.
    249249 * @param[in] last_used_port The last used free port.
    250  * @returns             EOK on success.
    251  * @returns             ENOTSOCK if the socket was not found.
    252  * @returns             EAFNOSUPPORT if the address family is not supported.
    253  * @returns             EADDRINUSE if the port is already in use.
    254  * @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
    255255 *                      socket_bind_free_port() function.
    256  * @returns             Other error codes as defined for the
     256 * @return              Other error codes as defined for the
    257257 *                      socket_bind_insert() function.
    258258 */
    259259int
    260 socket_bind(socket_cores_ref local_sockets, socket_ports_ref global_sockets,
     260socket_bind(socket_cores_t *local_sockets, socket_ports_t *global_sockets,
    261261    int socket_id, void *addr, size_t addrlen, int free_ports_start,
    262262    int free_ports_end, int last_used_port)
    263263{
    264         socket_core_ref socket;
    265         socket_port_ref socket_port;
     264        socket_core_t *socket;
     265        socket_port_t *socket_port;
    266266        struct sockaddr *address;
    267267        struct sockaddr_in *address_in;
    … …  
    277277               
    278278                address_in = (struct sockaddr_in *) addr;
    279                 // find the socket
     279                /* Find the socket */
    280280                socket = socket_cores_find(local_sockets, socket_id);
    281281                if (!socket)
    282282                        return ENOTSOCK;
    283283               
    284                 // bind a free port?
     284                /* Bind a free port? */
    285285                if (address_in->sin_port <= 0)
    286286                        return socket_bind_free_port(global_sockets, socket,
    287287                             free_ports_start, free_ports_end, last_used_port);
    288288               
    289                 // try to find the port
     289                /* Try to find the port */
    290290                socket_port = socket_ports_find(global_sockets,
    291291                    ntohs(address_in->sin_port));
    292292                if (socket_port) {
    293                         // already used
     293                        /* Already used */
    294294                        return EADDRINUSE;
    295295                }
    296296               
    297                 // if bound
     297                /* If bound */
    298298                if (socket->port) {
    299                         // release the port
     299                        /* Release the port */
    300300                        socket_port_release(global_sockets, socket);
    301301                }
    … …  
    322322 * @param[in] free_ports_end The maximum free port.
    323323 * @param[in] last_used_port The last used free port.
    324  * @returns             EOK on success.
    325  * @returns             ENOTCONN if no free port was found.
    326  * @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
    327327 *                      socket_bind_insert() function.
    328328 */
    329329int
    330 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,
    331331    int free_ports_start, int free_ports_end, int last_used_port)
    332332{
    333333        int index;
    334334
    335         // from the last used one
     335        /* From the last used one */
    336336        index = last_used_port;
    337337       
    … …  
    339339                ++index;
    340340               
    341                 // til the range end
     341                /* Till the range end */
    342342                if (index >= free_ports_end) {
    343                         // start from the range beginning
     343                        /* Start from the range beginning */
    344344                        index = free_ports_start - 1;
    345345                        do {
    346346                                ++index;
    347                                 // til the last used one
     347                                /* Till the last used one */
    348348                                if (index >= last_used_port) {
    349                                         // none found
     349                                        /* None found */
    350350                                        return ENOTCONN;
    351351                                }
    352352                        } while (socket_ports_find(global_sockets, index));
    353353                       
    354                         // found, break immediately
     354                        /* Found, break immediately */
    355355                        break;
    356356                }
    … …  
    367367 *                      requested. A negative identifier is requested if set to
    368368 *                      false.
    369  * @returns             The new socket identifier.
    370  * @returns             ELIMIT if there is no socket identifier available.
    371  */
    372 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)
    373373{
    374374        int socket_id;
    … …  
    376376
    377377        count = 0;
    378 //      socket_id = socket_globals.last_id;
     378#if 0
     379        socket_id = socket_globals.last_id;
     380#endif
    379381        do {
    380382                if (count < SOCKET_ID_TRIES) {
    … …  
    384386                        socket_id = 1;
    385387                        ++count;
    386                 // only this branch for last_id
     388                /* Only this branch for last_id */
    387389                } else {
    388390                        if (socket_id < INT_MAX) {
    389391                                ++ socket_id;
    390 /*                      } else if(socket_globals.last_id) {
    391 *                               socket_globals.last_id = 0;
    392 *                               socket_id = 1;
    393 */                      } 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 {
    394398                                return ELIMIT;
    395399                        }
    … …  
    410414 *                      chosen if set to zero or negative. A negative identifier
    411415 *                      is chosen if set to negative.
    412  * @returns             EOK on success.
    413  * @returns             EINVAL if the socket_id parameter is NULL.
    414  * @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.
    415419 */
    416420int
    417 socket_create(socket_cores_ref local_sockets, int app_phone,
     421socket_create(socket_cores_t *local_sockets, int app_phone,
    418422    void *specific_data, int *socket_id)
    419423{
    420         socket_core_ref socket;
     424        socket_core_t *socket;
    421425        int positive;
    422426        int rc;
    … …  
    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;
    … …  
    482486 * @param[in,out] global_sockets The global sockets to be updated.
    483487 * @param[in] socket_release The client release callback function.
    484  * @returns             EOK on success.
    485  * @returns             ENOTSOCK if the socket is not found.
     488 * @return              EOK on success.
     489 * @return              ENOTSOCK if the socket is not found.
    486490 */
    487491int
    488 socket_destroy(int packet_phone, int socket_id, socket_cores_ref local_sockets,
    489     socket_ports_ref global_sockets,
    490     void (*socket_release)(socket_core_ref socket))
    491 {
    492         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;
    493497        int accepted_id;
    494498
    495         // find the socket
     499        /* Find the socket */
    496500        socket = socket_cores_find(local_sockets, socket_id);
    497501        if (!socket)
    498502                return ENOTSOCK;
    499503       
    500         // destroy all accepted sockets
     504        /* Destroy all accepted sockets */
    501505        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    502506                socket_destroy(packet_phone, accepted_id, local_sockets,
    … …  
    516520 * @param[in] packet    The packet to be transfered.
    517521 * @param[out] length   The total data length.
    518  * @returns             EOK on success.
    519  * @returns             EBADMEM if the length parameter is NULL.
    520  * @returns             ENOMEM if there is not enough memory left.
    521  * @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()
    522526 *                      function.
    523527 */
    524 int socket_reply_packets(packet_t packet, size_t *length)
    525 {
    526         packet_t next_packet;
     528int socket_reply_packets(packet_t *packet, size_t *length)
     529{
     530        packet_t *next_packet;
    527531        size_t fragments;
    528532        size_t *lengths;
    … …  
    535539        next_packet = pq_next(packet);
    536540        if (!next_packet) {
    537                 // write all if only one fragment
     541                /* Write all if only one fragment */
    538542                rc = data_reply(packet_get_data(packet),
    539543                    packet_get_data_length(packet));
    540544                if (rc != EOK)
    541545                        return rc;
    542                 // store the total length
     546                /* Store the total length */
    543547                *length = packet_get_data_length(packet);
    544548        } else {
    545                 // count the packet fragments
     549                /* Count the packet fragments */
    546550                fragments = 1;
    547551                next_packet = pq_next(packet);
    … …  
    549553                        ++fragments;
    550554               
    551                 // compute and store the fragment lengths
     555                /* Compute and store the fragment lengths */
    552556                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    553557                    sizeof(size_t));
    … …  
    565569                }
    566570               
    567                 // write the fragment lengths
     571                /* Write the fragment lengths */
    568572                rc = data_reply(lengths, sizeof(int) * (fragments + 1));
    569573                if (rc != EOK) {
    … …  
    573577                next_packet = packet;
    574578               
    575                 // write the fragments
     579                /* Write the fragments */
    576580                for (index = 0; index < fragments; ++index) {
    577581                        rc = data_reply(packet_get_data(next_packet),
    … …  
    584588                }
    585589               
    586                 // store the total length
     590                /* Store the total length */
    587591                *length = lengths[fragments];
    588592                free(lengths);
    … …  
    598602 * @param[in] key       The socket key identifier.
    599603 * @param[in] key_length The socket key length.
    600  * @returns             The found socket.
    601  * @returns             NULL if no socket was found.
    602  */
    603 socket_core_ref
    604 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,
    605609    size_t key_length)
    606610{
    607         socket_port_ref socket_port;
    608         socket_core_ref *socket_ref;
     611        socket_port_t *socket_port;
     612        socket_core_t **socket_ref;
    609613
    610614        socket_port = socket_ports_find(global_sockets, port);
    … …  
    628632 */
    629633void
    630 socket_port_release(socket_ports_ref global_sockets, socket_core_ref socket)
    631 {
    632         socket_port_ref socket_port;
    633         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;
    634638
    635639        if (!socket->port)
    636640                return;
    637641       
    638         // find ports
     642        /* Find ports */
    639643        socket_port = socket_ports_find(global_sockets, socket->port);
    640644        if (socket_port) {
    641                 // find the socket
     645                /* Find the socket */
    642646                socket_ref = socket_port_map_find(&socket_port->map,
    643647                    socket->key, socket->key_length);
    … …  
    646650                        --socket_port->count;
    647651                       
    648                         // release if empty
     652                        /* Release if empty */
    649653                        if (socket_port->count <= 0) {
    650                                 // destroy the map
    651                                 socket_port_map_destroy(&socket_port->map);
    652                                 // release the port
     654                                /* Destroy the map */
     655                                socket_port_map_destroy(&socket_port->map, free);
     656                                /* Release the port */
    653657                                socket_ports_exclude(global_sockets,
    654                                     socket->port);
     658                                    socket->port, free);
    655659                        } else {
    656                                 // remove
     660                                /* Remove */
    657661                                socket_port_map_exclude(&socket_port->map,
    658                                     socket->key, socket->key_length);
     662                                    socket->key, socket->key_length, free);
    659663                        }
    660664                }
    … …  
    673677 * @param[in] key       The socket key identifier.
    674678 * @param[in] key_length The socket key length.
    675  * @returns             EOK on success.
    676  * @returns             ENOENT if the port is not already used.
    677  * @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
    678682 *                      socket_port_add_core() function.
    679683 */
    680684int
    681 socket_port_add(socket_ports_ref global_sockets, int port,
    682     socket_core_ref socket, const char *key, size_t key_length)
    683 {
    684         socket_port_ref socket_port;
     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;
    685689        int rc;
    686690
    687         // find ports
     691        /* Find ports */
    688692        socket_port = socket_ports_find(global_sockets, port);
    689693        if (!socket_port)
    690694                return ENOENT;
    691695       
    692         // add the socket
     696        /* Add the socket */
    693697        rc = socket_port_add_core(socket_port, socket, key, key_length);
    694698        if (rc != EOK)
Note: See TracChangeset for help on using the changeset viewer.