Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r28a3e74 r49bd793b  
    169169static int tcp_release_after_timeout(void *);
    170170
    171 static int tcp_process_packet(device_id_t, packet_t *, services_t);
     171static int tcp_process_packet(nic_device_id_t, packet_t *, services_t);
    172172static int tcp_connect_core(socket_core_t *, socket_cores_t *,
    173173    struct sockaddr *, socklen_t);
    … …  
    177177    size_t);
    178178static packet_t *tcp_get_packets_to_send(socket_core_t *, tcp_socket_data_t *);
    179 static void tcp_send_packets(device_id_t, packet_t *);
     179static void tcp_send_packets(nic_device_id_t, packet_t *);
    180180
    181181static void tcp_process_acknowledgement(socket_core_t *, tcp_socket_data_t *,
    … …  
    205205static void tcp_queue_received_end_of_data(socket_core_t *socket);
    206206
    207 static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
    208 static int tcp_process_client_messages(ipc_callid_t, ipc_call_t);
     207static int tcp_received_msg(nic_device_id_t, packet_t *, services_t, services_t);
     208static int tcp_process_client_messages(async_sess_t *, ipc_callid_t,
     209    ipc_call_t);
    209210
    210211static int tcp_listen_message(socket_cores_t *, int, int);
    … …  
    219220tcp_globals_t tcp_globals;
    220221
    221 int tcp_received_msg(device_id_t device_id, packet_t *packet,
     222int tcp_received_msg(nic_device_id_t device_id, packet_t *packet,
    222223    services_t receiver, services_t error)
    223224{
    … …  
    237238}
    238239
    239 int tcp_process_packet(device_id_t device_id, packet_t *packet, services_t error)
     240int tcp_process_packet(nic_device_id_t device_id, packet_t *packet, services_t error)
    240241{
    241242        size_t length;
    … …  
    324325
    325326        if (!socket) {
    326                 if (tl_prepare_icmp_packet(tcp_globals.net_phone,
    327                     tcp_globals.icmp_phone, packet, error) == EOK) {
    328                         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,
    329330                            ICMP_PORT_UNREACH, 0, packet);
    330331                }
    … …  
    397398                fibril_rwlock_write_unlock(socket_data->local_lock);
    398399
    399                 rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
    400                     tcp_globals.icmp_phone, packet, error);
     400                rc = tl_prepare_icmp_packet(tcp_globals.net_sess,
     401                    tcp_globals.icmp_sess, packet, error);
    401402                if (rc == EOK) {
    402403                        /* Checksum error ICMP */
    403                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
     404                        icmp_parameter_problem_msg(tcp_globals.icmp_sess,
    404405                            ICMP_PARAM_POINTER,
    405406                            ((size_t) ((void *) &header->checksum)) -
    … …  
    439440                break;
    440441        default:
    441                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     442                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    442443        }
    443444
    … …  
    476477        old_incoming = socket_data->next_incoming;
    477478
    478         if (header->finalize) {
     479        if (GET_TCP_HEADER_FINALIZE(header)) {
    479480                socket_data->fin_incoming = new_sequence_number +
    480481                    total_length - TCP_HEADER_LENGTH(header);
    … …  
    502503                        /* Release the acknowledged packets */
    503504                        next_packet = pq_next(packet);
    504                         pq_release_remote(tcp_globals.net_phone,
     505                        pq_release_remote(tcp_globals.net_sess,
    505506                            packet_get_id(packet));
    506507                        packet = next_packet;
    … …  
    561562                        next_packet = pq_next(next_packet);
    562563                        pq_insert_after(tmp_packet, next_packet);
    563                         pq_release_remote(tcp_globals.net_phone,
     564                        pq_release_remote(tcp_globals.net_sess,
    564565                            packet_get_id(tmp_packet));
    565566                }
    … …  
    598599                                if (packet == socket_data->incoming)
    599600                                        socket_data->incoming = next_packet;
    600                                 pq_release_remote(tcp_globals.net_phone,
     601                                pq_release_remote(tcp_globals.net_sess,
    601602                                    packet_get_id(packet));
    602603                                packet = next_packet;
    … …  
    621622                                if (length <= 0) {
    622623                                        /* Remove the empty packet */
    623                                         pq_release_remote(tcp_globals.net_phone,
     624                                        pq_release_remote(tcp_globals.net_sess,
    624625                                            packet_get_id(packet));
    625626                                        packet = next_packet;
    … …  
    668669                                }
    669670                                /* Remove the duplicit or corrupted packet */
    670                                 pq_release_remote(tcp_globals.net_phone,
     671                                pq_release_remote(tcp_globals.net_sess,
    671672                                    packet_get_id(packet));
    672673                                packet = next_packet;
    … …  
    695696                if (rc != EOK) {
    696697                        /* Remove the corrupted packets */
    697                         pq_release_remote(tcp_globals.net_phone,
     698                        pq_release_remote(tcp_globals.net_sess,
    698699                            packet_get_id(packet));
    699                         pq_release_remote(tcp_globals.net_phone,
     700                        pq_release_remote(tcp_globals.net_sess,
    700701                            packet_get_id(next_packet));
    701702                } else {
    … …  
    708709                                    new_sequence_number, length);
    709710                                if (rc != EOK) {
    710                                         pq_release_remote(tcp_globals.net_phone,
     711                                        pq_release_remote(tcp_globals.net_sess,
    711712                                            packet_get_id(next_packet));
    712713                                }
    713714                                rc = pq_insert_after(packet, next_packet);
    714715                                if (rc != EOK) {
    715                                         pq_release_remote(tcp_globals.net_phone,
     716                                        pq_release_remote(tcp_globals.net_sess,
    716717                                            packet_get_id(next_packet));
    717718                                }
    … …  
    722723                printf("unexpected\n");
    723724                /* Release duplicite or restricted */
    724                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     725                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    725726                forced_ack = true;
    726727        }
    … …  
    790791        if (rc != EOK)
    791792                return tcp_release_and_return(packet, rc);
    792         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     793        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    793794            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    794795        if (rc != EOK)
    … …  
    799800
    800801        /* Notify the destination socket */
    801         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    802             (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,
    803804            ((packet_dimension->content < socket_data->data_fragment_size) ?
    804805            packet_dimension->content : socket_data->data_fragment_size), 0, 0,
    805806            (sysarg_t) fragments);
     807        async_exchange_end(exch);
    806808
    807809        return EOK;
    … …  
    820822
    821823        /* Notify the destination socket */
    822         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    823             (sysarg_t) socket->socket_id,
    824             0, 0, 0,
    825             (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);
    826828}
    827829
    … …  
    838840        assert(packet);
    839841
    840         if (!header->synchronize)
     842        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    841843                return tcp_release_and_return(packet, EINVAL);
    842844       
    … …  
    849851        next_packet = pq_detach(packet);
    850852        if (next_packet) {
    851                 pq_release_remote(tcp_globals.net_phone,
     853                pq_release_remote(tcp_globals.net_sess,
    852854                    packet_get_id(next_packet));
    853855        }
    … …  
    903905        assert(packet);
    904906
    905         if (!header->synchronize)
     907        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    906908                return tcp_release_and_return(packet, EINVAL);
    907909
    … …  
    936938        /* Create a socket */
    937939        socket_id = -1;
    938         rc = socket_create(socket_data->local_sockets, listening_socket->phone,
     940        rc = socket_create(socket_data->local_sockets, listening_socket->sess,
    939941            socket_data, &socket_id);
    940942        if (rc != EOK) {
    … …  
    989991        fibril_rwlock_write_unlock(&tcp_globals.lock);
    990992        if (rc != EOK) {
    991                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     993                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    992994                    socket_data->local_sockets, &tcp_globals.sockets,
    993995                    tcp_free_socket_data);
    … …  
    10011003        next_packet = pq_detach(packet);
    10021004        if (next_packet) {
    1003                 pq_release_remote(tcp_globals.net_phone,
     1005                pq_release_remote(tcp_globals.net_sess,
    10041006                    packet_get_id(next_packet));
    10051007        }
    … …  
    10101012                    packet_get_data_length(packet) - sizeof(*header));
    10111013                if (rc != EOK) {
    1012                         socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1014                        socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10131015                            socket_data->local_sockets, &tcp_globals.sockets,
    10141016                            tcp_free_socket_data);
    … …  
    10211023        rc = tcp_queue_packet(socket, socket_data, packet, 1);
    10221024        if (rc != EOK) {
    1023                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1025                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10241026                    socket_data->local_sockets, &tcp_globals.sockets,
    10251027                    tcp_free_socket_data);
    … …  
    10291031        packet = tcp_get_packets_to_send(socket, socket_data);
    10301032        if (!packet) {
    1031                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1033                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10321034                    socket_data->local_sockets, &tcp_globals.sockets,
    10331035                    tcp_free_socket_data);
    … …  
    10571059        assert(packet);
    10581060
    1059         if (!header->acknowledge)
     1061        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    10601062                return tcp_release_and_return(packet, EINVAL);
    10611063
    … …  
    10641066
    10651067        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
    1066         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1068        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    10671069        socket_data->state = TCP_SOCKET_ESTABLISHED;
    10681070        listening_socket = socket_cores_find(socket_data->local_sockets,
    … …  
    10781080                if (rc == EOK) {
    10791081                        /* Notify the destination socket */
    1080                         async_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,
    10811084                            (sysarg_t) listening_socket->socket_id,
    10821085                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
    10831086                            0, (sysarg_t) socket->socket_id);
     1087                        async_exchange_end(exch);
    10841088
    10851089                        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    11261130        assert(header);
    11271131
    1128         if (!header->acknowledge)
     1132        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    11291133                return;
    11301134
    … …  
    11771181                                /* Add to acknowledged or release */
    11781182                                if (pq_add(&acknowledged, packet, 0, 0) != EOK)
    1179                                         pq_release_remote(tcp_globals.net_phone,
     1183                                        pq_release_remote(tcp_globals.net_sess,
    11801184                                            packet_get_id(packet));
    11811185                                packet = next;
    … …  
    11861190                /* Release acknowledged */
    11871191                if (acknowledged) {
    1188                         pq_release_remote(tcp_globals.net_phone,
     1192                        pq_release_remote(tcp_globals.net_sess,
    11891193                            packet_get_id(acknowledged));
    11901194                }
    … …  
    12301234        assert(answer);
    12311235        assert(answer_count);
    1232 
     1236       
    12331237        *answer_count = 0;
    1234         switch (IPC_GET_IMETHOD(*call)) {
    1235         case IPC_M_CONNECT_TO_ME:
    1236                 return tcp_process_client_messages(callid, *call);
    1237         }
    1238 
     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       
    12391244        return ENOTSUP;
    12401245}
    … …  
    12461251        bzero(socket_data, sizeof(*socket_data));
    12471252        socket_data->state = TCP_SOCKET_INITIAL;
    1248         socket_data->device_id = DEVICE_INVALID_ID;
     1253        socket_data->device_id = NIC_DEVICE_INVALID_ID;
    12491254        socket_data->window = NET_DEFAULT_TCP_WINDOW;
    12501255        socket_data->treshold = socket_data->window;
    … …  
    12661271}
    12671272
    1268 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)
    12691275{
    12701276        int res;
    1271         bool keep_on_going = true;
    12721277        socket_cores_t local_sockets;
    1273         int app_phone = IPC_GET_PHONE(call);
    12741278        struct sockaddr *addr;
    12751279        int socket_id;
    … …  
    12931297        fibril_rwlock_initialize(&lock);
    12941298
    1295         while (keep_on_going) {
     1299        while (true) {
    12961300
    12971301                /* Answer the call */
    … …  
    13011305                /* Get the next call */
    13021306                callid = async_get_call(&call);
     1307               
     1308                if (!IPC_GET_IMETHOD(call)) {
     1309                        res = EHANGUP;
     1310                        break;
     1311                }
    13031312
    13041313                /* Process the call */
    13051314                switch (IPC_GET_IMETHOD(call)) {
    1306                 case IPC_M_PHONE_HUNGUP:
    1307                         keep_on_going = false;
    1308                         res = EHANGUP;
    1309                         break;
    1310 
    13111315                case NET_SOCKET:
    13121316                        socket_data =
    … …  
    13221326                        fibril_rwlock_write_lock(&lock);
    13231327                        socket_id = SOCKET_GET_SOCKET_ID(call);
    1324                         res = socket_create(&local_sockets, app_phone,
     1328                        res = socket_create(&local_sockets, sess,
    13251329                            socket_data, &socket_id);
    13261330                        SOCKET_SET_SOCKET_ID(answer, socket_id);
    … …  
    13301334                                break;
    13311335                        }
    1332                         if (tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    1333                             &tcp_globals.dimensions, DEVICE_INVALID_ID,
     1336                        if (tl_get_ip_packet_dimension(tcp_globals.ip_sess,
     1337                            &tcp_globals.dimensions, NIC_DEVICE_INVALID_ID,
    13341338                            &packet_dimension) == EOK) {
    13351339                                SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
    … …  
    15051509        }
    15061510
    1507         /* Release the application phone */
    1508         async_hangup(app_phone);
     1511        /* Release the application session */
     1512        async_hangup(sess);
    15091513
    15101514        printf("release\n");
    15111515        /* Release all local sockets */
    1512         socket_cores_release(tcp_globals.net_phone, &local_sockets,
     1516        socket_cores_release(tcp_globals.net_sess, &local_sockets,
    15131517            &tcp_globals.sockets, tcp_free_socket_data);
    15141518
    … …  
    16181622                        local_lock = socket_data->local_lock;
    16191623                        fibril_rwlock_write_lock(local_lock);
    1620                         socket_destroy(tcp_globals.net_phone,
     1624                        socket_destroy(tcp_globals.net_sess,
    16211625                            timeout->socket_id, timeout->local_sockets,
    16221626                            &tcp_globals.sockets, tcp_free_socket_data);
    … …  
    16471651        /* Sent packet? */
    16481652        packet = pq_find(socket_data->outgoing, sequence_number);
    1649         printf("retransmit %d\n", packet_get_id(packet));
    16501653        if (packet) {
    16511654                pq_get_order(packet, NULL, &data_length);
    … …  
    17511754        }
    17521755
    1753         rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
     1756        rc = ip_get_route_req(tcp_globals.ip_sess, IPPROTO_TCP,
    17541757            addr, addrlen, &socket_data->device_id,
    17551758            &socket_data->pseudo_header, &socket_data->headerlen);
    … …  
    17861789
    17871790                        /* Send the packet */
    1788                         printf("connecting %d\n", packet_get_id(packet));
    17891791                        tcp_send_packets(socket_data->device_id, packet);
    17901792
    … …  
    18331835
    18341836        /* Remember the outgoing FIN */
    1835         if (header->finalize)
     1837        if (GET_TCP_HEADER_FINALIZE(header))
    18361838                socket_data->fin_outgoing = socket_data->next_outgoing;
    18371839       
    … …  
    18991901                        rc = pq_insert_after(previous, copy);
    19001902                        if (rc != EOK) {
    1901                                 pq_release_remote(tcp_globals.net_phone,
     1903                                pq_release_remote(tcp_globals.net_sess,
    19021904                                    packet_get_id(copy));
    19031905                                return sending;
    … …  
    19361938            socket_data->headerlen, packet_get_data_length(packet));
    19371939        if (rc != EOK) {
    1938                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1940                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19391941                return NULL;
    19401942        }
    … …  
    19431945        header = (tcp_header_t *) packet_get_data(packet);
    19441946        if (!header) {
    1945                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1947                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19461948                return NULL;
    19471949        }
    … …  
    19521954                header->acknowledgement_number =
    19531955                    htonl(socket_data->next_incoming);
    1954                 header->acknowledge = 1;
     1956                SET_TCP_HEADER_ACKNOWLEDGE(header, 1);
    19551957        }
    19561958        header->window = htons(socket_data->window);
    … …  
    19681970        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
    19691971        if (rc != EOK) {
    1970                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1972                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19711973                return NULL;
    19721974        }
    … …  
    19751977            sequence_number, socket_data->state, socket_data->timeout, true);
    19761978        if (rc != EOK) {
    1977                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1979                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19781980                return NULL;
    19791981        }
    … …  
    19921994
    19931995        /* Make a copy of the packet */
    1994         copy = packet_get_copy(tcp_globals.net_phone, packet);
     1996        copy = packet_get_copy(tcp_globals.net_sess, packet);
    19951997        if (!copy)
    19961998                return NULL;
    … …  
    20002002}
    20012003
    2002 void tcp_send_packets(device_id_t device_id, packet_t *packet)
     2004void tcp_send_packets(nic_device_id_t device_id, packet_t *packet)
    20032005{
    20042006        packet_t *next;
    … …  
    20062008        while (packet) {
    20072009                next = pq_detach(packet);
    2008                 ip_send_msg(tcp_globals.ip_phone, device_id, packet,
     2010                ip_send_msg(tcp_globals.ip_sess, device_id, packet,
    20092011                    SERVICE_TCP, 0);
    20102012                packet = next;
    … …  
    20242026        header->source_port = htons(socket->port);
    20252027        header->source_port = htons(socket_data->dest_port);
    2026         header->header_length = TCP_COMPUTE_HEADER_LENGTH(sizeof(*header));
    2027         header->synchronize = synchronize;
    2028         header->finalize = finalize;
     2028        SET_TCP_HEADER_LENGTH(header,
     2029            TCP_COMPUTE_HEADER_LENGTH(sizeof(*header)));
     2030        SET_TCP_HEADER_SYNCHRONIZE(header, synchronize);
     2031        SET_TCP_HEADER_FINALIZE(header, finalize);
    20292032}
    20302033
    … …  
    21182121                return NO_DATA;
    21192122
    2120         rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
     2123        rc = packet_translate_remote(tcp_globals.net_sess, &packet, packet_id);
    21212124        if (rc != EOK)
    21222125                return rc;
    … …  
    21292132        /* Release the packet */
    21302133        dyn_fifo_pop(&socket->received);
    2131         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     2134        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    21322135
    21332136        /* Return the total length */
    … …  
    21672170                return ENOTCONN;
    21682171
    2169         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2172        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    21702173            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    21712174        if (rc != EOK)
    … …  
    21782181        for (index = 0; index < fragments; index++) {
    21792182                /* Read the data fragment */
    2180                 result = tl_socket_read_packet_data(tcp_globals.net_phone,
     2183                result = tl_socket_read_packet_data(tcp_globals.net_sess,
    21812184                    &packet, TCP_HEADER_SIZE, packet_dimension,
    21822185                    socket_data->addr, socket_data->addrlen);
    … …  
    22412244        default:
    22422245                /* Just destroy */
    2243                 rc = socket_destroy(tcp_globals.net_phone, socket_id,
     2246                rc = socket_destroy(tcp_globals.net_sess, socket_id,
    22442247                    local_sockets, &tcp_globals.sockets,
    22452248                    tcp_free_socket_data);
    … …  
    22892292
    22902293        /* Get the device packet dimension */
    2291         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2294        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    22922295            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    22932296        if (rc != EOK)
    … …  
    22952298
    22962299        /* Get a new packet */
    2297         *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
     2300        *packet = packet_get_4_remote(tcp_globals.net_sess, TCP_HEADER_SIZE,
    22982301            packet_dimension->addr_len, packet_dimension->prefix,
    22992302            packet_dimension->suffix);
    … …  
    23582361                        if (rc != EOK)
    23592362                                return rc;
    2360                         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2363                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    23612364                            &tcp_globals.dimensions, socket_data->device_id,
    23622365                            &packet_dimension);
    … …  
    24302433int tcp_release_and_return(packet_t *packet, int result)
    24312434{
    2432         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     2435        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    24332436        return result;
    24342437}
    … …  
    24382441 * @param[in]     iid   Message identifier.
    24392442 * @param[in,out] icall Message parameters.
     2443 * @param[in]     arg   Local argument.
    24402444 *
    24412445 */
    2442 static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall)
     2446static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    24432447{
    24442448        packet_t *packet;
    … …  
    24482452                switch (IPC_GET_IMETHOD(*icall)) {
    24492453                case NET_TL_RECEIVED:
    2450                         rc = packet_translate_remote(tcp_globals.net_phone, &packet,
     2454                        rc = packet_translate_remote(tcp_globals.net_sess, &packet,
    24512455                            IPC_GET_PACKET(*icall));
    24522456                        if (rc == EOK)
    … …  
    24662470/** Initialize the TCP module.
    24672471 *
    2468  * @param[in] net_phone Network module phone.
     2472 * @param[in] sess Network module session.
    24692473 *
    24702474 * @return EOK on success.
    … …  
    24722476 *
    24732477 */
    2474 int tl_initialize(int net_phone)
     2478int tl_initialize(async_sess_t *sess)
    24752479{
    24762480        fibril_rwlock_initialize(&tcp_globals.lock);
    24772481        fibril_rwlock_write_lock(&tcp_globals.lock);
    24782482       
    2479         tcp_globals.net_phone = net_phone;
     2483        tcp_globals.net_sess = sess;
    24802484       
    2481         tcp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
    2482         tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
     2485        tcp_globals.icmp_sess = icmp_connect_module();
     2486        tcp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
    24832487            SERVICE_TCP, tcp_receiver);
    2484         if (tcp_globals.ip_phone < 0) {
     2488        if (tcp_globals.ip_sess == NULL) {
    24852489                fibril_rwlock_write_unlock(&tcp_globals.lock);
    2486                 return tcp_globals.ip_phone;
     2490                return ENOENT;
    24872491        }
    24882492       
Note: See TracChangeset for help on using the changeset viewer.