Ignore:
Timestamp:
2011-07-12T03:00:14Z (13 years ago)
Author:
Petr Koupy <petr.koupy@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6817eba
Parents:
eca52a8 (diff), 026793d (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/c/generic/net/socket_client.c

    reca52a8 rf51f193  
    3939#include <assert.h>
    4040#include <async.h>
    41 #include <async_obsolete.h>
    4241#include <fibril_synch.h>
    4342#include <stdint.h>
    … …  
    8483        /** Socket identifier. */
    8584        int socket_id;
    86         /** Parent module phone. */
    87         int phone;
     85        /** Parent module session. */
     86        async_sess_t *sess;
    8887        /** Parent module service. */
    8988        services_t service;
    … …  
    144143/** Socket client library global data. */
    145144static struct socket_client_globals {
    146         /** TCP module phone. */
    147         int tcp_phone;
    148         /** UDP module phone. */
    149         int udp_phone;
    150 
    151 //      /** The last socket identifier.
    152 //       */
    153 //      int last_id;
     145        /** TCP module session. */
     146        async_sess_t *tcp_sess;
     147        /** UDP module session. */
     148        async_sess_t *udp_sess;
    154149
    155150        /** Active sockets. */
    … …  
    164159        fibril_rwlock_t lock;
    165160} socket_globals = {
    166         .tcp_phone = -1,
    167         .udp_phone = -1,
    168 //      .last_id = 0,
     161        .tcp_sess = NULL,
     162        .udp_sess = NULL,
    169163        .sockets = NULL,
    170164        .lock = FIBRIL_RWLOCK_INITIALIZER(socket_globals.lock)
    … …  
    280274}
    281275
    282 /** Returns the TCP module phone.
    283  *
    284  * Connects to the TCP module if necessary.
    285  *
    286  * @return              The TCP module phone.
    287  * @return              Other error codes as defined for the
    288  *                      bind_service() function.
    289  */
    290 static int socket_get_tcp_phone(void)
    291 {
    292         if (socket_globals.tcp_phone < 0) {
    293                 socket_globals.tcp_phone = bind_service(SERVICE_TCP,
     276/** Return the TCP module session.
     277 *
     278 * Connect to the TCP module if necessary.
     279 *
     280 * @return The TCP module session.
     281 *
     282 */
     283static async_sess_t *socket_get_tcp_sess(void)
     284{
     285        if (socket_globals.tcp_sess == NULL) {
     286                socket_globals.tcp_sess = bind_service(SERVICE_TCP,
    294287                    0, 0, SERVICE_TCP, socket_connection);
    295288        }
    296289
    297         return socket_globals.tcp_phone;
    298 }
    299 
    300 /** Returns the UDP module phone.
    301  *
    302  * Connects to the UDP module if necessary.
    303  *
    304  * @return              The UDP module phone.
    305  * @return              Other error codes as defined for the
    306  *                      bind_service() function.
    307  */
    308 static int socket_get_udp_phone(void)
    309 {
    310         if (socket_globals.udp_phone < 0) {
    311                 socket_globals.udp_phone = bind_service(SERVICE_UDP,
     290        return socket_globals.tcp_sess;
     291}
     292
     293/** Return the UDP module session.
     294 *
     295 * Connect to the UDP module if necessary.
     296 *
     297 * @return The UDP module session.
     298 *
     299 */
     300static async_sess_t *socket_get_udp_sess(void)
     301{
     302        if (socket_globals.udp_sess == NULL) {
     303                socket_globals.udp_sess = bind_service(SERVICE_UDP,
    312304                    0, 0, SERVICE_UDP, socket_connection);
    313305        }
    314306
    315         return socket_globals.udp_phone;
     307        return socket_globals.udp_sess;
    316308}
    317309
    … …  
    329321        sockets = socket_get_sockets();
    330322        count = 0;
    331 //      socket_id = socket_globals.last_id;
    332323
    333324        do {
    … …  
    342333                        if (socket_id < INT_MAX) {
    343334                                ++socket_id;
    344 /*                      } else if(socket_globals.last_id) {
    345  *                              socket_globals.last_id = 0;
    346  *                              socket_id = 1;
    347  */                     } else {
     335                        } else {
    348336                                return ELIMIT;
    349337                        }
    350338                }
    351339        } while (sockets_find(sockets, socket_id));
    352 
    353 //      last_id = socket_id
     340       
    354341        return socket_id;
    355342}
    … …  
    358345 *
    359346 * @param[in,out] socket The socket to be initialized.
    360  * @param[in] socket_id The new socket identifier.
    361  * @param[in] phone     The parent module phone.
    362  * @param[in] service   The parent module service.
    363  */
    364 static void
    365 socket_initialize(socket_t *socket, int socket_id, int phone,
    366     services_t service)
     347 * @param[in] socket_id  The new socket identifier.
     348 * @param[in] sess       The parent module session.
     349 * @param[in] service    The parent module service.
     350 */
     351static void socket_initialize(socket_t *socket, int socket_id,
     352    async_sess_t *sess, services_t service)
    367353{
    368354        socket->socket_id = socket_id;
    369         socket->phone = phone;
     355        socket->sess = sess;
    370356        socket->service = service;
    371357        dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
    … …  
    397383{
    398384        socket_t *socket;
    399         int phone;
     385        async_sess_t *sess;
    400386        int socket_id;
    401387        services_t service;
    … …  
    414400                        switch (protocol) {
    415401                        case IPPROTO_TCP:
    416                                 phone = socket_get_tcp_phone();
     402                                sess = socket_get_tcp_sess();
    417403                                service = SERVICE_TCP;
    418404                                break;
    … …  
    429415                        switch (protocol) {
    430416                        case IPPROTO_UDP:
    431                                 phone = socket_get_udp_phone();
     417                                sess = socket_get_udp_sess();
    432418                                service = SERVICE_UDP;
    433419                                break;
    … …  
    450436        }
    451437
    452         if (phone < 0)
    453                 return phone;
     438        if (sess == NULL)
     439                return ENOENT;
    454440
    455441        /* Create a new socket structure */
    … …  
    468454                return socket_id;
    469455        }
    470 
    471         rc = (int) async_obsolete_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL,
     456       
     457        async_exch_t *exch = async_exchange_begin(sess);
     458        rc = (int) async_req_3_3(exch, NET_SOCKET, socket_id, 0, service, NULL,
    472459            &fragment_size, &header_size);
     460        async_exchange_end(exch);
     461       
    473462        if (rc != EOK) {
    474463                fibril_rwlock_write_unlock(&socket_globals.lock);
    … …  
    481470
    482471        /* Finish the new socket initialization */
    483         socket_initialize(socket, socket_id, phone, service);
     472        socket_initialize(socket, socket_id, sess, service);
    484473        /* Store the new socket */
    485474        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    … …  
    490479                dyn_fifo_destroy(&socket->accepted);
    491480                free(socket);
    492                 async_obsolete_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
     481               
     482                exch = async_exchange_begin(sess);
     483                async_msg_3(exch, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
    493484                    service);
     485                async_exchange_end(exch);
     486               
    494487                return rc;
    495488        }
    … …  
    535528
    536529        /* Request the message */
    537         message_id = async_obsolete_send_3(socket->phone, message,
     530        async_exch_t *exch = async_exchange_begin(socket->sess);
     531        message_id = async_send_3(exch, message,
    538532            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
    539533        /* Send the address */
    540         async_obsolete_data_write_start(socket->phone, data, datalength);
     534        async_data_write_start(exch, data, datalength);
     535        async_exchange_end(exch);
    541536
    542537        fibril_rwlock_read_unlock(&socket_globals.lock);
    … …  
    595590
    596591        /* Request listen backlog change */
    597         result = (int) async_obsolete_req_3_0(socket->phone, NET_SOCKET_LISTEN,
     592        async_exch_t *exch = async_exchange_begin(socket->sess);
     593        result = (int) async_req_3_0(exch, NET_SOCKET_LISTEN,
    598594            (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
     595        async_exchange_end(exch);
    599596
    600597        fibril_rwlock_read_unlock(&socket_globals.lock);
    … …  
    666663                return socket_id;
    667664        }
    668         socket_initialize(new_socket, socket_id, socket->phone,
     665        socket_initialize(new_socket, socket_id, socket->sess,
    669666            socket->service);
    670667        result = sockets_add(socket_get_sockets(), new_socket->socket_id,
    … …  
    678675
    679676        /* Request accept */
    680         message_id = async_obsolete_send_5(socket->phone, NET_SOCKET_ACCEPT,
     677        async_exch_t *exch = async_exchange_begin(socket->sess);
     678        message_id = async_send_5(exch, NET_SOCKET_ACCEPT,
    681679            (sysarg_t) socket->socket_id, 0, socket->service, 0,
    682680            new_socket->socket_id, &answer);
    683681
    684682        /* Read address */
    685         async_obsolete_data_read_start(socket->phone, cliaddr, *addrlen);
     683        async_data_read_start(exch, cliaddr, *addrlen);
     684        async_exchange_end(exch);
     685       
    686686        fibril_rwlock_write_unlock(&socket_globals.lock);
    687687        async_wait_for(message_id, &ipc_result);
    … …  
    777777
    778778        /* Request close */
    779         rc = (int) async_obsolete_req_3_0(socket->phone, NET_SOCKET_CLOSE,
     779        async_exch_t *exch = async_exchange_begin(socket->sess);
     780        rc = (int) async_req_3_0(exch, NET_SOCKET_CLOSE,
    780781            (sysarg_t) socket->socket_id, 0, socket->service);
     782        async_exchange_end(exch);
     783       
    781784        if (rc != EOK) {
    782785                fibril_rwlock_write_unlock(&socket_globals.lock);
    … …  
    850853
    851854        /* Request send */
    852         message_id = async_obsolete_send_5(socket->phone, message,
     855        async_exch_t *exch = async_exchange_begin(socket->sess);
     856       
     857        message_id = async_send_5(exch, message,
    853858            (sysarg_t) socket->socket_id,
    854859            (fragments == 1 ? datalength : socket->data_fragment_size),
    … …  
    857862        /* Send the address if given */
    858863        if (!toaddr ||
    859             (async_obsolete_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
     864            (async_data_write_start(exch, toaddr, addrlen) == EOK)) {
    860865                if (fragments == 1) {
    861866                        /* Send all if only one fragment */
    862                         async_obsolete_data_write_start(socket->phone, data, datalength);
     867                        async_data_write_start(exch, data, datalength);
    863868                } else {
    864869                        /* Send the first fragment */
    865                         async_obsolete_data_write_start(socket->phone, data,
     870                        async_data_write_start(exch, data,
    866871                            socket->data_fragment_size - socket->header_size);
    867872                        data = ((const uint8_t *) data) +
    … …  
    870875                        /* Send the middle fragments */
    871876                        while (--fragments > 1) {
    872                                 async_obsolete_data_write_start(socket->phone, data,
     877                                async_data_write_start(exch, data,
    873878                                    socket->data_fragment_size);
    874879                                data = ((const uint8_t *) data) +
    … …  
    877882
    878883                        /* Send the last fragment */
    879                         async_obsolete_data_write_start(socket->phone, data,
     884                        async_data_write_start(exch, data,
    880885                            (datalength + socket->header_size) %
    881886                            socket->data_fragment_size);
    882887                }
    883888        }
     889       
     890        async_exchange_end(exch);
    884891
    885892        async_wait_for(message_id, &result);
    … …  
    10231030                return 0;
    10241031        }
     1032       
     1033        async_exch_t *exch = async_exchange_begin(socket->sess);
    10251034
    10261035        /* Prepare lengths if more fragments */
    … …  
    10351044
    10361045                /* Request packet data */
    1037                 message_id = async_obsolete_send_4(socket->phone, message,
     1046                message_id = async_send_4(exch, message,
    10381047                    (sysarg_t) socket->socket_id, 0, socket->service,
    10391048                    (sysarg_t) flags, &answer);
    … …  
    10411050                /* Read the address if desired */
    10421051                if(!fromaddr ||
    1043                     (async_obsolete_data_read_start(socket->phone, fromaddr,
     1052                    (async_data_read_start(exch, fromaddr,
    10441053                    *addrlen) == EOK)) {
    10451054                        /* Read the fragment lengths */
    1046                         if (async_obsolete_data_read_start(socket->phone, lengths,
     1055                        if (async_data_read_start(exch, lengths,
    10471056                            sizeof(int) * (fragments + 1)) == EOK) {
    10481057                                if (lengths[fragments] <= datalength) {
    … …  
    10511060                                        for (index = 0; index < fragments;
    10521061                                            ++index) {
    1053                                                 async_obsolete_data_read_start(
    1054                                                     socket->phone, data,
     1062                                                async_data_read_start(exch, data,
    10551063                                                    lengths[index]);
    10561064                                                data = ((uint8_t *) data) +
    … …  
    10641072        } else { /* fragments == 1 */
    10651073                /* Request packet data */
    1066                 message_id = async_obsolete_send_4(socket->phone, message,
     1074                message_id = async_send_4(exch, message,
    10671075                    (sysarg_t) socket->socket_id, 0, socket->service,
    10681076                    (sysarg_t) flags, &answer);
    … …  
    10701078                /* Read the address if desired */
    10711079                if (!fromaddr ||
    1072                     (async_obsolete_data_read_start(socket->phone, fromaddr,
    1073                         *addrlen) == EOK)) {
     1080                    (async_data_read_start(exch, fromaddr, *addrlen) == EOK)) {
    10741081                        /* Read all if only one fragment */
    1075                         async_obsolete_data_read_start(socket->phone, data, datalength);
     1082                        async_data_read_start(exch, data, datalength);
    10761083                }
    10771084        }
     1085       
     1086        async_exchange_end(exch);
    10781087
    10791088        async_wait_for(message_id, &ipc_result);
    … …  
    11871196
    11881197        /* Request option value */
    1189         message_id = async_obsolete_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
     1198        async_exch_t *exch = async_exchange_begin(socket->sess);
     1199       
     1200        message_id = async_send_3(exch, NET_SOCKET_GETSOCKOPT,
    11901201            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11911202            NULL);
    11921203
    11931204        /* Read the length */
    1194         if (async_obsolete_data_read_start(socket->phone, optlen,
     1205        if (async_data_read_start(exch, optlen,
    11951206            sizeof(*optlen)) == EOK) {
    11961207                /* Read the value */
    1197                 async_obsolete_data_read_start(socket->phone, value, *optlen);
    1198         }
     1208                async_data_read_start(exch, value, *optlen);
     1209        }
     1210       
     1211        async_exchange_end(exch);
    11991212
    12001213        fibril_rwlock_read_unlock(&socket_globals.lock);
Note: See TracChangeset for help on using the changeset viewer.