Changeset 6b82009 in mainline for uspace/srv/net/tl


Ignore:
Timestamp:
2011-06-22T20:41:41Z (14 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ef09a7a
Parents:
55091847
Message:

networking stack: convert to the new async framework

Location:
uspace/srv/net/tl
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/tl/icmp/icmp.c

    r55091847 r6b82009  
    118118
    119119/** Global data */
    120 static int phone_net = -1;
    121 static int phone_ip = -1;
     120static async_sess_t *net_sess = NULL;
     121static async_sess_t *ip_sess = NULL;
    122122static bool error_reporting = true;
    123123static bool echo_replying = true;
    … …  
    173173static void icmp_release(packet_t *packet)
    174174{
    175         pq_release_remote(phone_net, packet_get_id(packet));
     175        pq_release_remote(net_sess, packet_get_id(packet));
    176176}
    177177
    … …  
    225225        }
    226226       
    227         return ip_send_msg(phone_ip, -1, packet, SERVICE_ICMP, error);
     227        return ip_send_msg(ip_sess, -1, packet, SERVICE_ICMP, error);
    228228}
    229229
    … …  
    297297        size_t length = (size_t) addrlen;
    298298       
    299         packet_t *packet = packet_get_4_remote(phone_net, size,
     299        packet_t *packet = packet_get_4_remote(net_sess, size,
    300300            icmp_dimension.addr_len, ICMP_HEADER_SIZE + icmp_dimension.prefix,
    301301            icmp_dimension.suffix);
    … …  
    595595        case ICMP_SKIP:
    596596        case ICMP_PHOTURIS:
    597                 ip_received_error_msg(phone_ip, -1, packet,
     597                ip_received_error_msg(ip_sess, -1, packet,
    598598                    SERVICE_IP, SERVICE_ICMP);
    599599                return EOK;
    … …  
    609609 * @param[in,out] icall Message parameters.
    610610 * @param[in]     arg   Local argument.
     611 *
    611612 */
    612613static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    … …  
    621622                switch (IPC_GET_IMETHOD(*icall)) {
    622623                case NET_TL_RECEIVED:
    623                         rc = packet_translate_remote(phone_net, &packet,
     624                        rc = packet_translate_remote(net_sess, &packet,
    624625                            IPC_GET_PACKET(*icall));
    625626                        if (rc == EOK) {
    … …  
    641642/** Initialize the ICMP module.
    642643 *
    643  * @param[in] net_phone Network module phone.
     644 * @param[in] sess Network module session.
    644645 *
    645646 * @return EOK on success.
    … …  
    647648 *
    648649 */
    649 int tl_initialize(int net_phone)
     650int tl_initialize(async_sess_t *sess)
    650651{
    651652        measured_string_t names[] = {
    … …  
    669670        atomic_set(&icmp_client, 0);
    670671       
    671         phone_net = net_phone;
    672         phone_ip = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP,
     672        net_sess = sess;
     673        ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP,
    673674            icmp_receiver);
    674         if (phone_ip < 0)
    675                 return phone_ip;
    676        
    677         int rc = ip_packet_size_req(phone_ip, -1, &icmp_dimension);
     675        if (ip_sess == NULL)
     676                return ENOENT;
     677       
     678        int rc = ip_packet_size_req(ip_sess, -1, &icmp_dimension);
    678679        if (rc != EOK)
    679680                return rc;
    … …  
    684685        /* Get configuration */
    685686        configuration = &names[0];
    686         rc = net_get_conf_req(phone_net, &configuration, count, &data);
     687        rc = net_get_conf_req(net_sess, &configuration, count, &data);
    687688        if (rc != EOK)
    688689                return rc;
    … …  
    762763       
    763764        case NET_ICMP_DEST_UNREACH:
    764                 rc = packet_translate_remote(phone_net, &packet,
     765                rc = packet_translate_remote(net_sess, &packet,
    765766                    IPC_GET_PACKET(*call));
    766767                if (rc != EOK)
    … …  
    771772       
    772773        case NET_ICMP_SOURCE_QUENCH:
    773                 rc = packet_translate_remote(phone_net, &packet,
     774                rc = packet_translate_remote(net_sess, &packet,
    774775                    IPC_GET_PACKET(*call));
    775776                if (rc != EOK)
    … …  
    779780       
    780781        case NET_ICMP_TIME_EXCEEDED:
    781                 rc = packet_translate_remote(phone_net, &packet,
     782                rc = packet_translate_remote(net_sess, &packet,
    782783                    IPC_GET_PACKET(*call));
    783784                if (rc != EOK)
    … …  
    787788       
    788789        case NET_ICMP_PARAMETERPROB:
    789                 rc = packet_translate_remote(phone_net, &packet,
     790                rc = packet_translate_remote(net_sess, &packet,
    790791                    IPC_GET_PACKET(*call));
    791792                if (rc != EOK)

  • uspace/srv/net/tl/tcp/tcp.c

    r55091847 r6b82009  
    3838#include <assert.h>
    3939#include <async.h>
    40 #include <async_obsolete.h>
    4140#include <fibril_synch.h>
    4241#include <malloc.h>
    … …  
    7473#include "tcp_header.h"
    7574
    76 // FIXME: remove this header
    77 #include <kernel/ipc/ipc_methods.h>
    78 
    7975/** TCP module name. */
    8076#define NAME  "tcp"
    … …  
    210206
    211207static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
    212 static int tcp_process_client_messages(ipc_callid_t, ipc_call_t);
     208static int tcp_process_client_messages(async_sess_t *, ipc_callid_t,
     209    ipc_call_t);
    213210
    214211static int tcp_listen_message(socket_cores_t *, int, int);
    … …  
    328325
    329326        if (!socket) {
    330                 if (tl_prepare_icmp_packet(tcp_globals.net_phone,
    331                     tcp_globals.icmp_phone, packet, error) == EOK) {
    332                         icmp_destination_unreachable_msg(tcp_globals.icmp_phone,
     327                if (tl_prepare_icmp_packet(tcp_globals.net_sess,
     328                    tcp_globals.icmp_sess, packet, error) == EOK) {
     329                        icmp_destination_unreachable_msg(tcp_globals.icmp_sess,
    333330                            ICMP_PORT_UNREACH, 0, packet);
    334331                }
    … …  
    401398                fibril_rwlock_write_unlock(socket_data->local_lock);
    402399
    403                 rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
    404                     tcp_globals.icmp_phone, packet, error);
     400                rc = tl_prepare_icmp_packet(tcp_globals.net_sess,
     401                    tcp_globals.icmp_sess, packet, error);
    405402                if (rc == EOK) {
    406403                        /* Checksum error ICMP */
    407                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
     404                        icmp_parameter_problem_msg(tcp_globals.icmp_sess,
    408405                            ICMP_PARAM_POINTER,
    409406                            ((size_t) ((void *) &header->checksum)) -
    … …  
    443440                break;
    444441        default:
    445                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     442                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    446443        }
    447444
    … …  
    506503                        /* Release the acknowledged packets */
    507504                        next_packet = pq_next(packet);
    508                         pq_release_remote(tcp_globals.net_phone,
     505                        pq_release_remote(tcp_globals.net_sess,
    509506                            packet_get_id(packet));
    510507                        packet = next_packet;
    … …  
    565562                        next_packet = pq_next(next_packet);
    566563                        pq_insert_after(tmp_packet, next_packet);
    567                         pq_release_remote(tcp_globals.net_phone,
     564                        pq_release_remote(tcp_globals.net_sess,
    568565                            packet_get_id(tmp_packet));
    569566                }
    … …  
    602599                                if (packet == socket_data->incoming)
    603600                                        socket_data->incoming = next_packet;
    604                                 pq_release_remote(tcp_globals.net_phone,
     601                                pq_release_remote(tcp_globals.net_sess,
    605602                                    packet_get_id(packet));
    606603                                packet = next_packet;
    … …  
    625622                                if (length <= 0) {
    626623                                        /* Remove the empty packet */
    627                                         pq_release_remote(tcp_globals.net_phone,
     624                                        pq_release_remote(tcp_globals.net_sess,
    628625                                            packet_get_id(packet));
    629626                                        packet = next_packet;
    … …  
    672669                                }
    673670                                /* Remove the duplicit or corrupted packet */
    674                                 pq_release_remote(tcp_globals.net_phone,
     671                                pq_release_remote(tcp_globals.net_sess,
    675672                                    packet_get_id(packet));
    676673                                packet = next_packet;
    … …  
    699696                if (rc != EOK) {
    700697                        /* Remove the corrupted packets */
    701                         pq_release_remote(tcp_globals.net_phone,
     698                        pq_release_remote(tcp_globals.net_sess,
    702699                            packet_get_id(packet));
    703                         pq_release_remote(tcp_globals.net_phone,
     700                        pq_release_remote(tcp_globals.net_sess,
    704701                            packet_get_id(next_packet));
    705702                } else {
    … …  
    712709                                    new_sequence_number, length);
    713710                                if (rc != EOK) {
    714                                         pq_release_remote(tcp_globals.net_phone,
     711                                        pq_release_remote(tcp_globals.net_sess,
    715712                                            packet_get_id(next_packet));
    716713                                }
    717714                                rc = pq_insert_after(packet, next_packet);
    718715                                if (rc != EOK) {
    719                                         pq_release_remote(tcp_globals.net_phone,
     716                                        pq_release_remote(tcp_globals.net_sess,
    720717                                            packet_get_id(next_packet));
    721718                                }
    … …  
    726723                printf("unexpected\n");
    727724                /* Release duplicite or restricted */
    728                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     725                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    729726                forced_ack = true;
    730727        }
    … …  
    794791        if (rc != EOK)
    795792                return tcp_release_and_return(packet, rc);
    796         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     793        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    797794            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    798795        if (rc != EOK)
    … …  
    803800
    804801        /* Notify the destination socket */
    805         async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    806             (sysarg_t) socket->socket_id,
     802        async_exch_t *exch = async_exchange_begin(socket->sess);
     803        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
    807804            ((packet_dimension->content < socket_data->data_fragment_size) ?
    808805            packet_dimension->content : socket_data->data_fragment_size), 0, 0,
    809806            (sysarg_t) fragments);
     807        async_exchange_end(exch);
    810808
    811809        return EOK;
    … …  
    824822
    825823        /* Notify the destination socket */
    826         async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    827             (sysarg_t) socket->socket_id,
    828             0, 0, 0,
    829             (sysarg_t) 0 /* 0 fragments == no more data */);
     824        async_exch_t *exch = async_exchange_begin(socket->sess);
     825        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
     826            0, 0, 0, (sysarg_t) 0 /* 0 fragments == no more data */);
     827        async_exchange_end(exch);
    830828}
    831829
    … …  
    853851        next_packet = pq_detach(packet);
    854852        if (next_packet) {
    855                 pq_release_remote(tcp_globals.net_phone,
     853                pq_release_remote(tcp_globals.net_sess,
    856854                    packet_get_id(next_packet));
    857855        }
    … …  
    940938        /* Create a socket */
    941939        socket_id = -1;
    942         rc = socket_create(socket_data->local_sockets, listening_socket->phone,
     940        rc = socket_create(socket_data->local_sockets, listening_socket->sess,
    943941            socket_data, &socket_id);
    944942        if (rc != EOK) {
    … …  
    993991        fibril_rwlock_write_unlock(&tcp_globals.lock);
    994992        if (rc != EOK) {
    995                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     993                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    996994                    socket_data->local_sockets, &tcp_globals.sockets,
    997995                    tcp_free_socket_data);
    … …  
    10051003        next_packet = pq_detach(packet);
    10061004        if (next_packet) {
    1007                 pq_release_remote(tcp_globals.net_phone,
     1005                pq_release_remote(tcp_globals.net_sess,
    10081006                    packet_get_id(next_packet));
    10091007        }
    … …  
    10141012                    packet_get_data_length(packet) - sizeof(*header));
    10151013                if (rc != EOK) {
    1016                         socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1014                        socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10171015                            socket_data->local_sockets, &tcp_globals.sockets,
    10181016                            tcp_free_socket_data);
    … …  
    10251023        rc = tcp_queue_packet(socket, socket_data, packet, 1);
    10261024        if (rc != EOK) {
    1027                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1025                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10281026                    socket_data->local_sockets, &tcp_globals.sockets,
    10291027                    tcp_free_socket_data);
    … …  
    10331031        packet = tcp_get_packets_to_send(socket, socket_data);
    10341032        if (!packet) {
    1035                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1033                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10361034                    socket_data->local_sockets, &tcp_globals.sockets,
    10371035                    tcp_free_socket_data);
    … …  
    10681066
    10691067        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
    1070         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1068        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    10711069        socket_data->state = TCP_SOCKET_ESTABLISHED;
    10721070        listening_socket = socket_cores_find(socket_data->local_sockets,
    … …  
    10821080                if (rc == EOK) {
    10831081                        /* Notify the destination socket */
    1084                         async_obsolete_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
     1082                        async_exch_t *exch = async_exchange_begin(socket->sess);
     1083                        async_msg_5(exch, NET_SOCKET_ACCEPTED,
    10851084                            (sysarg_t) listening_socket->socket_id,
    10861085                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
    10871086                            0, (sysarg_t) socket->socket_id);
     1087                        async_exchange_end(exch);
    10881088
    10891089                        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    11811181                                /* Add to acknowledged or release */
    11821182                                if (pq_add(&acknowledged, packet, 0, 0) != EOK)
    1183                                         pq_release_remote(tcp_globals.net_phone,
     1183                                        pq_release_remote(tcp_globals.net_sess,
    11841184                                            packet_get_id(packet));
    11851185                                packet = next;
    … …  
    11901190                /* Release acknowledged */
    11911191                if (acknowledged) {
    1192                         pq_release_remote(tcp_globals.net_phone,
     1192                        pq_release_remote(tcp_globals.net_sess,
    11931193                            packet_get_id(acknowledged));
    11941194                }
    … …  
    12341234        assert(answer);
    12351235        assert(answer_count);
    1236 
     1236       
    12371237        *answer_count = 0;
    1238         switch (IPC_GET_IMETHOD(*call)) {
    1239         case IPC_M_CONNECT_TO_ME:
    1240                 return tcp_process_client_messages(callid, *call);
    1241         }
    1242 
     1238       
     1239        async_sess_t *callback =
     1240            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
     1241        if (callback)
     1242                return tcp_process_client_messages(callback, callid, *call);
     1243       
    12431244        return ENOTSUP;
    12441245}
    … …  
    12701271}
    12711272
    1272 int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
     1273int tcp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
     1274    ipc_call_t call)
    12731275{
    12741276        int res;
    12751277        socket_cores_t local_sockets;
    1276         int app_phone = IPC_GET_PHONE(call);
    12771278        struct sockaddr *addr;
    12781279        int socket_id;
    … …  
    13251326                        fibril_rwlock_write_lock(&lock);
    13261327                        socket_id = SOCKET_GET_SOCKET_ID(call);
    1327                         res = socket_create(&local_sockets, app_phone,
     1328                        res = socket_create(&local_sockets, sess,
    13281329                            socket_data, &socket_id);
    13291330                        SOCKET_SET_SOCKET_ID(answer, socket_id);
    … …  
    13331334                                break;
    13341335                        }
    1335                         if (tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     1336                        if (tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    13361337                            &tcp_globals.dimensions, DEVICE_INVALID_ID,
    13371338                            &packet_dimension) == EOK) {
    … …  
    15081509        }
    15091510
    1510         /* Release the application phone */
    1511         async_obsolete_hangup(app_phone);
     1511        /* Release the application session */
     1512        async_hangup(sess);
    15121513
    15131514        printf("release\n");
    15141515        /* Release all local sockets */
    1515         socket_cores_release(tcp_globals.net_phone, &local_sockets,
     1516        socket_cores_release(tcp_globals.net_sess, &local_sockets,
    15161517            &tcp_globals.sockets, tcp_free_socket_data);
    15171518
    … …  
    16211622                        local_lock = socket_data->local_lock;
    16221623                        fibril_rwlock_write_lock(local_lock);
    1623                         socket_destroy(tcp_globals.net_phone,
     1624                        socket_destroy(tcp_globals.net_sess,
    16241625                            timeout->socket_id, timeout->local_sockets,
    16251626                            &tcp_globals.sockets, tcp_free_socket_data);
    … …  
    17541755        }
    17551756
    1756         rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
     1757        rc = ip_get_route_req(tcp_globals.ip_sess, IPPROTO_TCP,
    17571758            addr, addrlen, &socket_data->device_id,
    17581759            &socket_data->pseudo_header, &socket_data->headerlen);
    … …  
    19021903                        rc = pq_insert_after(previous, copy);
    19031904                        if (rc != EOK) {
    1904                                 pq_release_remote(tcp_globals.net_phone,
     1905                                pq_release_remote(tcp_globals.net_sess,
    19051906                                    packet_get_id(copy));
    19061907                                return sending;
    … …  
    19391940            socket_data->headerlen, packet_get_data_length(packet));
    19401941        if (rc != EOK) {
    1941                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1942                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19421943                return NULL;
    19431944        }
    … …  
    19461947        header = (tcp_header_t *) packet_get_data(packet);
    19471948        if (!header) {
    1948                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1949                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19491950                return NULL;
    19501951        }
    … …  
    19711972        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
    19721973        if (rc != EOK) {
    1973                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1974                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19741975                return NULL;
    19751976        }
    … …  
    19781979            sequence_number, socket_data->state, socket_data->timeout, true);
    19791980        if (rc != EOK) {
    1980                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1981                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19811982                return NULL;
    19821983        }
    … …  
    19951996
    19961997        /* Make a copy of the packet */
    1997         copy = packet_get_copy(tcp_globals.net_phone, packet);
     1998        copy = packet_get_copy(tcp_globals.net_sess, packet);
    19981999        if (!copy)
    19992000                return NULL;
    … …  
    20092010        while (packet) {
    20102011                next = pq_detach(packet);
    2011                 ip_send_msg(tcp_globals.ip_phone, device_id, packet,
     2012                ip_send_msg(tcp_globals.ip_sess, device_id, packet,
    20122013                    SERVICE_TCP, 0);
    20132014                packet = next;
    … …  
    21222123                return NO_DATA;
    21232124
    2124         rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
     2125        rc = packet_translate_remote(tcp_globals.net_sess, &packet, packet_id);
    21252126        if (rc != EOK)
    21262127                return rc;
    … …  
    21332134        /* Release the packet */
    21342135        dyn_fifo_pop(&socket->received);
    2135         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     2136        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    21362137
    21372138        /* Return the total length */
    … …  
    21712172                return ENOTCONN;
    21722173
    2173         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2174        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    21742175            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    21752176        if (rc != EOK)
    … …  
    21822183        for (index = 0; index < fragments; index++) {
    21832184                /* Read the data fragment */
    2184                 result = tl_socket_read_packet_data(tcp_globals.net_phone,
     2185                result = tl_socket_read_packet_data(tcp_globals.net_sess,
    21852186                    &packet, TCP_HEADER_SIZE, packet_dimension,
    21862187                    socket_data->addr, socket_data->addrlen);
    … …  
    22452246        default:
    22462247                /* Just destroy */
    2247                 rc = socket_destroy(tcp_globals.net_phone, socket_id,
     2248                rc = socket_destroy(tcp_globals.net_sess, socket_id,
    22482249                    local_sockets, &tcp_globals.sockets,
    22492250                    tcp_free_socket_data);
    … …  
    22932294
    22942295        /* Get the device packet dimension */
    2295         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2296        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    22962297            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    22972298        if (rc != EOK)
    … …  
    22992300
    23002301        /* Get a new packet */
    2301         *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
     2302        *packet = packet_get_4_remote(tcp_globals.net_sess, TCP_HEADER_SIZE,
    23022303            packet_dimension->addr_len, packet_dimension->prefix,
    23032304            packet_dimension->suffix);
    … …  
    23622363                        if (rc != EOK)
    23632364                                return rc;
    2364                         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2365                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    23652366                            &tcp_globals.dimensions, socket_data->device_id,
    23662367                            &packet_dimension);
    … …  
    24342435int tcp_release_and_return(packet_t *packet, int result)
    24352436{
    2436         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     2437        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    24372438        return result;
    24382439}
    … …  
    24432444 * @param[in,out] icall Message parameters.
    24442445 * @param[in]     arg   Local argument.
     2446 *
    24452447 */
    24462448static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    … …  
    24522454                switch (IPC_GET_IMETHOD(*icall)) {
    24532455                case NET_TL_RECEIVED:
    2454                         rc = packet_translate_remote(tcp_globals.net_phone, &packet,
     2456                        rc = packet_translate_remote(tcp_globals.net_sess, &packet,
    24552457                            IPC_GET_PACKET(*icall));
    24562458                        if (rc == EOK)
    … …  
    24702472/** Initialize the TCP module.
    24712473 *
    2472  * @param[in] net_phone Network module phone.
     2474 * @param[in] sess Network module session.
    24732475 *
    24742476 * @return EOK on success.
    … …  
    24762478 *
    24772479 */
    2478 int tl_initialize(int net_phone)
     2480int tl_initialize(async_sess_t *sess)
    24792481{
    24802482        fibril_rwlock_initialize(&tcp_globals.lock);
    24812483        fibril_rwlock_write_lock(&tcp_globals.lock);
    24822484       
    2483         tcp_globals.net_phone = net_phone;
     2485        tcp_globals.net_sess = sess;
    24842486       
    2485         tcp_globals.icmp_phone = icmp_connect_module();
    2486         tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
     2487        tcp_globals.icmp_sess = icmp_connect_module();
     2488        tcp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
    24872489            SERVICE_TCP, tcp_receiver);
    2488         if (tcp_globals.ip_phone < 0) {
     2490        if (tcp_globals.ip_sess == NULL) {
    24892491                fibril_rwlock_write_unlock(&tcp_globals.lock);
    2490                 return tcp_globals.ip_phone;
     2492                return ENOENT;
    24912493        }
    24922494       

  • uspace/srv/net/tl/tcp/tcp.h

    r55091847 r6b82009  
    3838#define NET_TCP_H_
    3939
     40#include <async.h>
    4041#include <fibril_synch.h>
    41 
    4242#include <net/packet.h>
    4343#include <net/device.h>
    … …  
    284284/** TCP global data. */
    285285struct tcp_globals {
    286         /** Networking module phone. */
    287         int net_phone;
    288         /** IP module phone. */
    289         int ip_phone;
    290         /** ICMP module phone. */
    291         int icmp_phone;
     286        /** Networking module session. */
     287        async_sess_t *net_sess;
     288        /** IP module session. */
     289        async_sess_t *ip_sess;
     290        /** ICMP module session. */
     291        async_sess_t *icmp_sess;
    292292        /** Last used free port. */
    293293        int last_used_port;

  • uspace/srv/net/tl/udp/udp.c

    r55091847 r6b82009  
    3737
    3838#include <async.h>
    39 #include <async_obsolete.h>
    4039#include <fibril_synch.h>
    4140#include <malloc.h>
    … …  
    7170#include "udp_header.h"
    7271
    73 // FIXME: remove this header
    74 #include <kernel/ipc/ipc_methods.h>
    75 
    7672/** UDP module name. */
    7773#define NAME  "udp"
    … …  
    10399static int udp_release_and_return(packet_t *packet, int result)
    104100{
    105         pq_release_remote(udp_globals.net_phone, packet_get_id(packet));
     101        pq_release_remote(udp_globals.net_sess, packet_get_id(packet));
    106102        return result;
    107103}
    … …  
    196192            ntohs(header->destination_port), (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
    197193        if (!socket) {
    198                 if (tl_prepare_icmp_packet(udp_globals.net_phone,
    199                     udp_globals.icmp_phone, packet, error) == EOK) {
    200                         icmp_destination_unreachable_msg(udp_globals.icmp_phone,
     194                if (tl_prepare_icmp_packet(udp_globals.net_sess,
     195                    udp_globals.icmp_sess, packet, error) == EOK) {
     196                        icmp_destination_unreachable_msg(udp_globals.icmp_sess,
    201197                            ICMP_PORT_UNREACH, 0, packet);
    202198                }
    … …  
    255251                        while (tmp_packet) {
    256252                                next_packet = pq_detach(tmp_packet);
    257                                 pq_release_remote(udp_globals.net_phone,
     253                                pq_release_remote(udp_globals.net_sess,
    258254                                    packet_get_id(tmp_packet));
    259255                                tmp_packet = next_packet;
    … …  
    278274                if (flip_checksum(compact_checksum(checksum)) !=
    279275                    IP_CHECKSUM_ZERO) {
    280                         if (tl_prepare_icmp_packet(udp_globals.net_phone,
    281                             udp_globals.icmp_phone, packet, error) == EOK) {
     276                        if (tl_prepare_icmp_packet(udp_globals.net_sess,
     277                            udp_globals.icmp_sess, packet, error) == EOK) {
    282278                                /* Checksum error ICMP */
    283279                                icmp_parameter_problem_msg(
    284                                     udp_globals.icmp_phone, ICMP_PARAM_POINTER,
     280                                    udp_globals.icmp_sess, ICMP_PARAM_POINTER,
    285281                                    ((size_t) ((void *) &header->checksum)) -
    286282                                    ((size_t) ((void *) header)), packet);
    … …  
    296292                return udp_release_and_return(packet, rc);
    297293               
    298         rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
     294        rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
    299295            &udp_globals.dimensions, device_id, &packet_dimension);
    300296        if (rc != EOK)
    … …  
    303299        /* Notify the destination socket */
    304300        fibril_rwlock_write_unlock(&udp_globals.lock);
    305         async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    306             (sysarg_t) socket->socket_id, packet_dimension->content, 0, 0,
    307             (sysarg_t) fragments);
     301       
     302        async_exch_t *exch = async_exchange_begin(socket->sess);
     303        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
     304            packet_dimension->content, 0, 0, (sysarg_t) fragments);
     305        async_exchange_end(exch);
    308306
    309307        return EOK;
    … …  
    342340 * @param[in,out] icall Message parameters.
    343341 * @param[in]     arg   Local argument.
     342 *
    344343 */
    345344static void udp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    … …  
    351350                switch (IPC_GET_IMETHOD(*icall)) {
    352351                case NET_TL_RECEIVED:
    353                         rc = packet_translate_remote(udp_globals.net_phone, &packet,
     352                        rc = packet_translate_remote(udp_globals.net_sess, &packet,
    354353                            IPC_GET_PACKET(*icall));
    355354                        if (rc == EOK)
    … …  
    369368/** Initialize the UDP module.
    370369 *
    371  * @param[in] net_phone Network module phone.
     370 * @param[in] sess Network module session.
    372371 *
    373372 * @return EOK on success.
    … …  
    375374 *
    376375 */
    377 int tl_initialize(int net_phone)
     376int tl_initialize(async_sess_t *sess)
    378377{
    379378        measured_string_t names[] = {
    … …  
    394393        fibril_rwlock_write_lock(&udp_globals.lock);
    395394       
    396         udp_globals.net_phone = net_phone;
    397        
    398         udp_globals.icmp_phone = icmp_connect_module();
    399        
    400         udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
    401             SERVICE_UDP, udp_receiver);
    402         if (udp_globals.ip_phone < 0) {
    403                 fibril_rwlock_write_unlock(&udp_globals.lock);
    404                 return udp_globals.ip_phone;
     395        udp_globals.net_sess = sess;
     396        udp_globals.icmp_sess = icmp_connect_module();
     397       
     398        udp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
     399             SERVICE_UDP, udp_receiver);
     400        if (udp_globals.ip_sess == NULL) {
     401            fibril_rwlock_write_unlock(&udp_globals.lock);
     402            return ENOENT;
    405403        }
    406404       
    407405        /* Read default packet dimensions */
    408         int rc = ip_packet_size_req(udp_globals.ip_phone, -1,
     406        int rc = ip_packet_size_req(udp_globals.ip_sess, -1,
    409407            &udp_globals.packet_dimension);
    410408        if (rc != EOK) {
    … …  
    435433        /* Get configuration */
    436434        configuration = &names[0];
    437         rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
     435        rc = net_get_conf_req(udp_globals.net_sess, &configuration, count,
    438436            &data);
    439437        if (rc != EOK) {
    … …  
    529527
    530528        if (udp_globals.checksum_computing) {
    531                 rc = ip_get_route_req(udp_globals.ip_phone, IPPROTO_UDP, addr,
     529                rc = ip_get_route_req(udp_globals.ip_sess, IPPROTO_UDP, addr,
    532530                    addrlen, &device_id, &ip_header, &headerlen);
    533531                if (rc != EOK)
    534532                        return rc;
    535533                /* Get the device packet dimension */
    536 //              rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
     534//              rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
    537535//                  &udp_globals.dimensions, device_id, &packet_dimension);
    538536//              if (rc != EOK)
    … …  
    541539//      } else {
    542540                /* Do not ask all the time */
    543                 rc = ip_packet_size_req(udp_globals.ip_phone, -1,
     541                rc = ip_packet_size_req(udp_globals.ip_sess, -1,
    544542                    &udp_globals.packet_dimension);
    545543                if (rc != EOK)
    … …  
    559557
    560558        /* Read the first packet fragment */
    561         result = tl_socket_read_packet_data(udp_globals.net_phone, &packet,
     559        result = tl_socket_read_packet_data(udp_globals.net_sess, &packet,
    562560            UDP_HEADER_SIZE, packet_dimension, addr, addrlen);
    563561        if (result < 0)
    … …  
    580578        /* Read the rest of the packet fragments */
    581579        for (index = 1; index < fragments; index++) {
    582                 result = tl_socket_read_packet_data(udp_globals.net_phone,
     580                result = tl_socket_read_packet_data(udp_globals.net_sess,
    583581                    &next_packet, 0, packet_dimension, addr, addrlen);
    584582                if (result < 0)
    … …  
    632630
    633631        /* Send the packet */
    634         ip_send_msg(udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0);
     632        ip_send_msg(udp_globals.ip_sess, device_id, packet, SERVICE_UDP, 0);
    635633
    636634        return EOK;
    … …  
    679677                return NO_DATA;
    680678       
    681         rc = packet_translate_remote(udp_globals.net_phone, &packet, packet_id);
     679        rc = packet_translate_remote(udp_globals.net_sess, &packet, packet_id);
    682680        if (rc != EOK) {
    683681                (void) dyn_fifo_pop(&socket->received);
    … …  
    739737}
    740738
    741 /** Processes the socket client messages.
    742  *
    743  * Runs until the client module disconnects.
    744  *
    745  * @param[in] callid    The message identifier.
    746  * @param[in] call      The message parameters.
    747  * @return              EOK on success.
    748  *
    749  * @see socket.h
    750  */
    751 static int udp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
     739/** Process the socket client messages.
     740 *
     741 * Run until the client module disconnects.
     742 *
     743 * @see socket.h
     744 *
     745 * @param[in] sess   Callback session.
     746 * @param[in] callid Message identifier.
     747 * @param[in] call   Message parameters.
     748 *
     749 * @return EOK on success.
     750 *
     751 */
     752static int udp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
     753    ipc_call_t call)
    752754{
    753755        int res;
    754756        socket_cores_t local_sockets;
    755         int app_phone = IPC_GET_PHONE(call);
    756757        struct sockaddr *addr;
    757758        int socket_id;
    … …  
    786787                /* Get the next call */
    787788                callid = async_get_call(&call);
    788                
     789
     790                /* Process the call */
    789791                if (!IPC_GET_IMETHOD(call)) {
    790792                        res = EHANGUP;
    791793                        break;
    792794                }
    793 
    794                 /* Process the call */
     795               
    795796                switch (IPC_GET_IMETHOD(call)) {
    796797                case NET_SOCKET:
    797798                        socket_id = SOCKET_GET_SOCKET_ID(call);
    798                         res = socket_create(&local_sockets, app_phone, NULL,
     799                        res = socket_create(&local_sockets, sess, NULL,
    799800                            &socket_id);
    800801                        SOCKET_SET_SOCKET_ID(answer, socket_id);
    … …  
    804805                       
    805806                        size = MAX_UDP_FRAGMENT_SIZE;
    806                         if (tl_get_ip_packet_dimension(udp_globals.ip_phone,
     807                        if (tl_get_ip_packet_dimension(udp_globals.ip_sess,
    807808                            &udp_globals.dimensions, DEVICE_INVALID_ID,
    808809                            &packet_dimension) == EOK) {
    … …  
    868869                case NET_SOCKET_CLOSE:
    869870                        fibril_rwlock_write_lock(&udp_globals.lock);
    870                         res = socket_destroy(udp_globals.net_phone,
     871                        res = socket_destroy(udp_globals.net_sess,
    871872                            SOCKET_GET_SOCKET_ID(call), &local_sockets,
    872873                            &udp_globals.sockets, NULL);
    … …  
    882883        }
    883884
    884         /* Release the application phone */
    885         async_obsolete_hangup(app_phone);
     885        /* Release the application session */
     886        async_hangup(sess);
    886887
    887888        /* Release all local sockets */
    888         socket_cores_release(udp_globals.net_phone, &local_sockets,
     889        socket_cores_release(udp_globals.net_sess, &local_sockets,
    889890            &udp_globals.sockets, NULL);
    890891
    … …  
    916917{
    917918        *answer_count = 0;
    918 
    919         switch (IPC_GET_IMETHOD(*call)) {
    920         case IPC_M_CONNECT_TO_ME:
    921                 return udp_process_client_messages(callid, *call);
    922         }
    923 
     919       
     920        async_sess_t *callback =
     921            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
     922        if (callback)
     923                return udp_process_client_messages(callback, callid, *call);
     924       
    924925        return ENOTSUP;
    925926}

  • uspace/srv/net/tl/udp/udp.h

    r55091847 r6b82009  
    3838#define NET_UDP_H_
    3939
     40#include <async.h>
    4041#include <fibril_synch.h>
    4142#include <socket_core.h>
    … …  
    4950/** UDP global data. */
    5051struct udp_globals {
    51         /** Networking module phone. */
    52         int net_phone;
    53         /** IP module phone. */
    54         int ip_phone;
    55         /** ICMP module phone. */
    56         int icmp_phone;
     52        /** Networking module session. */
     53        async_sess_t *net_sess;
     54        /** IP module session. */
     55        async_sess_t *ip_sess;
     56        /** ICMP module session. */
     57        async_sess_t *icmp_sess;
    5758        /** Packet dimension. */
    5859        packet_dimension_t packet_dimension;
Note: See TracChangeset for help on using the changeset viewer.