Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r49bd793b r28a3e74  
    169169static int tcp_release_after_timeout(void *);
    170170
    171 static int tcp_process_packet(nic_device_id_t, packet_t *, services_t);
     171static int tcp_process_packet(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(nic_device_id_t, packet_t *);
     179static void tcp_send_packets(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(nic_device_id_t, packet_t *, services_t, services_t);
    208 static int tcp_process_client_messages(async_sess_t *, ipc_callid_t,
    209     ipc_call_t);
     207static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
     208static int tcp_process_client_messages(ipc_callid_t, ipc_call_t);
    210209
    211210static int tcp_listen_message(socket_cores_t *, int, int);
    … …  
    220219tcp_globals_t tcp_globals;
    221220
    222 int tcp_received_msg(nic_device_id_t device_id, packet_t *packet,
     221int tcp_received_msg(device_id_t device_id, packet_t *packet,
    223222    services_t receiver, services_t error)
    224223{
    … …  
    238237}
    239238
    240 int tcp_process_packet(nic_device_id_t device_id, packet_t *packet, services_t error)
     239int tcp_process_packet(device_id_t device_id, packet_t *packet, services_t error)
    241240{
    242241        size_t length;
    … …  
    325324
    326325        if (!socket) {
    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,
     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,
    330329                            ICMP_PORT_UNREACH, 0, packet);
    331330                }
    … …  
    398397                fibril_rwlock_write_unlock(socket_data->local_lock);
    399398
    400                 rc = tl_prepare_icmp_packet(tcp_globals.net_sess,
    401                     tcp_globals.icmp_sess, packet, error);
     399                rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
     400                    tcp_globals.icmp_phone, packet, error);
    402401                if (rc == EOK) {
    403402                        /* Checksum error ICMP */
    404                         icmp_parameter_problem_msg(tcp_globals.icmp_sess,
     403                        icmp_parameter_problem_msg(tcp_globals.icmp_phone,
    405404                            ICMP_PARAM_POINTER,
    406405                            ((size_t) ((void *) &header->checksum)) -
    … …  
    440439                break;
    441440        default:
    442                 pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     441                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    443442        }
    444443
    … …  
    477476        old_incoming = socket_data->next_incoming;
    478477
    479         if (GET_TCP_HEADER_FINALIZE(header)) {
     478        if (header->finalize) {
    480479                socket_data->fin_incoming = new_sequence_number +
    481480                    total_length - TCP_HEADER_LENGTH(header);
    … …  
    503502                        /* Release the acknowledged packets */
    504503                        next_packet = pq_next(packet);
    505                         pq_release_remote(tcp_globals.net_sess,
     504                        pq_release_remote(tcp_globals.net_phone,
    506505                            packet_get_id(packet));
    507506                        packet = next_packet;
    … …  
    562561                        next_packet = pq_next(next_packet);
    563562                        pq_insert_after(tmp_packet, next_packet);
    564                         pq_release_remote(tcp_globals.net_sess,
     563                        pq_release_remote(tcp_globals.net_phone,
    565564                            packet_get_id(tmp_packet));
    566565                }
    … …  
    599598                                if (packet == socket_data->incoming)
    600599                                        socket_data->incoming = next_packet;
    601                                 pq_release_remote(tcp_globals.net_sess,
     600                                pq_release_remote(tcp_globals.net_phone,
    602601                                    packet_get_id(packet));
    603602                                packet = next_packet;
    … …  
    622621                                if (length <= 0) {
    623622                                        /* Remove the empty packet */
    624                                         pq_release_remote(tcp_globals.net_sess,
     623                                        pq_release_remote(tcp_globals.net_phone,
    625624                                            packet_get_id(packet));
    626625                                        packet = next_packet;
    … …  
    669668                                }
    670669                                /* Remove the duplicit or corrupted packet */
    671                                 pq_release_remote(tcp_globals.net_sess,
     670                                pq_release_remote(tcp_globals.net_phone,
    672671                                    packet_get_id(packet));
    673672                                packet = next_packet;
    … …  
    696695                if (rc != EOK) {
    697696                        /* Remove the corrupted packets */
    698                         pq_release_remote(tcp_globals.net_sess,
     697                        pq_release_remote(tcp_globals.net_phone,
    699698                            packet_get_id(packet));
    700                         pq_release_remote(tcp_globals.net_sess,
     699                        pq_release_remote(tcp_globals.net_phone,
    701700                            packet_get_id(next_packet));
    702701                } else {
    … …  
    709708                                    new_sequence_number, length);
    710709                                if (rc != EOK) {
    711                                         pq_release_remote(tcp_globals.net_sess,
     710                                        pq_release_remote(tcp_globals.net_phone,
    712711                                            packet_get_id(next_packet));
    713712                                }
    714713                                rc = pq_insert_after(packet, next_packet);
    715714                                if (rc != EOK) {
    716                                         pq_release_remote(tcp_globals.net_sess,
     715                                        pq_release_remote(tcp_globals.net_phone,
    717716                                            packet_get_id(next_packet));
    718717                                }
    … …  
    723722                printf("unexpected\n");
    724723                /* Release duplicite or restricted */
    725                 pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     724                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    726725                forced_ack = true;
    727726        }
    … …  
    791790        if (rc != EOK)
    792791                return tcp_release_and_return(packet, rc);
    793         rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
     792        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    794793            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    795794        if (rc != EOK)
    … …  
    800799
    801800        /* Notify the destination socket */
    802         async_exch_t *exch = async_exchange_begin(socket->sess);
    803         async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
     801        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
     802            (sysarg_t) socket->socket_id,
    804803            ((packet_dimension->content < socket_data->data_fragment_size) ?
    805804            packet_dimension->content : socket_data->data_fragment_size), 0, 0,
    806805            (sysarg_t) fragments);
    807         async_exchange_end(exch);
    808806
    809807        return EOK;
    … …  
    822820
    823821        /* Notify the destination socket */
    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);
     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 */);
    828826}
    829827
    … …  
    840838        assert(packet);
    841839
    842         if (!GET_TCP_HEADER_SYNCHRONIZE(header))
     840        if (!header->synchronize)
    843841                return tcp_release_and_return(packet, EINVAL);
    844842       
    … …  
    851849        next_packet = pq_detach(packet);
    852850        if (next_packet) {
    853                 pq_release_remote(tcp_globals.net_sess,
     851                pq_release_remote(tcp_globals.net_phone,
    854852                    packet_get_id(next_packet));
    855853        }
    … …  
    905903        assert(packet);
    906904
    907         if (!GET_TCP_HEADER_SYNCHRONIZE(header))
     905        if (!header->synchronize)
    908906                return tcp_release_and_return(packet, EINVAL);
    909907
    … …  
    938936        /* Create a socket */
    939937        socket_id = -1;
    940         rc = socket_create(socket_data->local_sockets, listening_socket->sess,
     938        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
    941939            socket_data, &socket_id);
    942940        if (rc != EOK) {
    … …  
    991989        fibril_rwlock_write_unlock(&tcp_globals.lock);
    992990        if (rc != EOK) {
    993                 socket_destroy(tcp_globals.net_sess, socket->socket_id,
     991                socket_destroy(tcp_globals.net_phone, socket->socket_id,
    994992                    socket_data->local_sockets, &tcp_globals.sockets,
    995993                    tcp_free_socket_data);
    … …  
    10031001        next_packet = pq_detach(packet);
    10041002        if (next_packet) {
    1005                 pq_release_remote(tcp_globals.net_sess,
     1003                pq_release_remote(tcp_globals.net_phone,
    10061004                    packet_get_id(next_packet));
    10071005        }
    … …  
    10121010                    packet_get_data_length(packet) - sizeof(*header));
    10131011                if (rc != EOK) {
    1014                         socket_destroy(tcp_globals.net_sess, socket->socket_id,
     1012                        socket_destroy(tcp_globals.net_phone, socket->socket_id,
    10151013                            socket_data->local_sockets, &tcp_globals.sockets,
    10161014                            tcp_free_socket_data);
    … …  
    10231021        rc = tcp_queue_packet(socket, socket_data, packet, 1);
    10241022        if (rc != EOK) {
    1025                 socket_destroy(tcp_globals.net_sess, socket->socket_id,
     1023                socket_destroy(tcp_globals.net_phone, socket->socket_id,
    10261024                    socket_data->local_sockets, &tcp_globals.sockets,
    10271025                    tcp_free_socket_data);
    … …  
    10311029        packet = tcp_get_packets_to_send(socket, socket_data);
    10321030        if (!packet) {
    1033                 socket_destroy(tcp_globals.net_sess, socket->socket_id,
     1031                socket_destroy(tcp_globals.net_phone, socket->socket_id,
    10341032                    socket_data->local_sockets, &tcp_globals.sockets,
    10351033                    tcp_free_socket_data);
    … …  
    10591057        assert(packet);
    10601058
    1061         if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
     1059        if (!header->acknowledge)
    10621060                return tcp_release_and_return(packet, EINVAL);
    10631061
    … …  
    10661064
    10671065        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
    1068         pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     1066        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    10691067        socket_data->state = TCP_SOCKET_ESTABLISHED;
    10701068        listening_socket = socket_cores_find(socket_data->local_sockets,
    … …  
    10801078                if (rc == EOK) {
    10811079                        /* Notify the destination socket */
    1082                         async_exch_t *exch = async_exchange_begin(socket->sess);
    1083                         async_msg_5(exch, NET_SOCKET_ACCEPTED,
     1080                        async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
    10841081                            (sysarg_t) listening_socket->socket_id,
    10851082                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
    10861083                            0, (sysarg_t) socket->socket_id);
    1087                         async_exchange_end(exch);
    10881084
    10891085                        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    11301126        assert(header);
    11311127
    1132         if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
     1128        if (!header->acknowledge)
    11331129                return;
    11341130
    … …  
    11811177                                /* Add to acknowledged or release */
    11821178                                if (pq_add(&acknowledged, packet, 0, 0) != EOK)
    1183                                         pq_release_remote(tcp_globals.net_sess,
     1179                                        pq_release_remote(tcp_globals.net_phone,
    11841180                                            packet_get_id(packet));
    11851181                                packet = next;
    … …  
    11901186                /* Release acknowledged */
    11911187                if (acknowledged) {
    1192                         pq_release_remote(tcp_globals.net_sess,
     1188                        pq_release_remote(tcp_globals.net_phone,
    11931189                            packet_get_id(acknowledged));
    11941190                }
    … …  
    12341230        assert(answer);
    12351231        assert(answer_count);
    1236        
     1232
    12371233        *answer_count = 0;
    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        
     1234        switch (IPC_GET_IMETHOD(*call)) {
     1235        case IPC_M_CONNECT_TO_ME:
     1236                return tcp_process_client_messages(callid, *call);
     1237        }
     1238
    12441239        return ENOTSUP;
    12451240}
    … …  
    12511246        bzero(socket_data, sizeof(*socket_data));
    12521247        socket_data->state = TCP_SOCKET_INITIAL;
    1253         socket_data->device_id = NIC_DEVICE_INVALID_ID;
     1248        socket_data->device_id = DEVICE_INVALID_ID;
    12541249        socket_data->window = NET_DEFAULT_TCP_WINDOW;
    12551250        socket_data->treshold = socket_data->window;
    … …  
    12711266}
    12721267
    1273 int tcp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
    1274     ipc_call_t call)
     1268int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
    12751269{
    12761270        int res;
     1271        bool keep_on_going = true;
    12771272        socket_cores_t local_sockets;
     1273        int app_phone = IPC_GET_PHONE(call);
    12781274        struct sockaddr *addr;
    12791275        int socket_id;
    … …  
    12971293        fibril_rwlock_initialize(&lock);
    12981294
    1299         while (true) {
     1295        while (keep_on_going) {
    13001296
    13011297                /* Answer the call */
    … …  
    13051301                /* Get the next call */
    13061302                callid = async_get_call(&call);
    1307                
    1308                 if (!IPC_GET_IMETHOD(call)) {
     1303
     1304                /* Process the call */
     1305                switch (IPC_GET_IMETHOD(call)) {
     1306                case IPC_M_PHONE_HUNGUP:
     1307                        keep_on_going = false;
    13091308                        res = EHANGUP;
    13101309                        break;
    1311                 }
    1312 
    1313                 /* Process the call */
    1314                 switch (IPC_GET_IMETHOD(call)) {
     1310
    13151311                case NET_SOCKET:
    13161312                        socket_data =
    … …  
    13261322                        fibril_rwlock_write_lock(&lock);
    13271323                        socket_id = SOCKET_GET_SOCKET_ID(call);
    1328                         res = socket_create(&local_sockets, sess,
     1324                        res = socket_create(&local_sockets, app_phone,
    13291325                            socket_data, &socket_id);
    13301326                        SOCKET_SET_SOCKET_ID(answer, socket_id);
    … …  
    13341330                                break;
    13351331                        }
    1336                         if (tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    1337                             &tcp_globals.dimensions, NIC_DEVICE_INVALID_ID,
     1332                        if (tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     1333                            &tcp_globals.dimensions, DEVICE_INVALID_ID,
    13381334                            &packet_dimension) == EOK) {
    13391335                                SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
    … …  
    15091505        }
    15101506
    1511         /* Release the application session */
    1512         async_hangup(sess);
     1507        /* Release the application phone */
     1508        async_hangup(app_phone);
    15131509
    15141510        printf("release\n");
    15151511        /* Release all local sockets */
    1516         socket_cores_release(tcp_globals.net_sess, &local_sockets,
     1512        socket_cores_release(tcp_globals.net_phone, &local_sockets,
    15171513            &tcp_globals.sockets, tcp_free_socket_data);
    15181514
    … …  
    16221618                        local_lock = socket_data->local_lock;
    16231619                        fibril_rwlock_write_lock(local_lock);
    1624                         socket_destroy(tcp_globals.net_sess,
     1620                        socket_destroy(tcp_globals.net_phone,
    16251621                            timeout->socket_id, timeout->local_sockets,
    16261622                            &tcp_globals.sockets, tcp_free_socket_data);
    … …  
    16511647        /* Sent packet? */
    16521648        packet = pq_find(socket_data->outgoing, sequence_number);
     1649        printf("retransmit %d\n", packet_get_id(packet));
    16531650        if (packet) {
    16541651                pq_get_order(packet, NULL, &data_length);
    … …  
    17541751        }
    17551752
    1756         rc = ip_get_route_req(tcp_globals.ip_sess, IPPROTO_TCP,
     1753        rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
    17571754            addr, addrlen, &socket_data->device_id,
    17581755            &socket_data->pseudo_header, &socket_data->headerlen);
    … …  
    17891786
    17901787                        /* Send the packet */
     1788                        printf("connecting %d\n", packet_get_id(packet));
    17911789                        tcp_send_packets(socket_data->device_id, packet);
    17921790
    … …  
    18351833
    18361834        /* Remember the outgoing FIN */
    1837         if (GET_TCP_HEADER_FINALIZE(header))
     1835        if (header->finalize)
    18381836                socket_data->fin_outgoing = socket_data->next_outgoing;
    18391837       
    … …  
    19011899                        rc = pq_insert_after(previous, copy);
    19021900                        if (rc != EOK) {
    1903                                 pq_release_remote(tcp_globals.net_sess,
     1901                                pq_release_remote(tcp_globals.net_phone,
    19041902                                    packet_get_id(copy));
    19051903                                return sending;
    … …  
    19381936            socket_data->headerlen, packet_get_data_length(packet));
    19391937        if (rc != EOK) {
    1940                 pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     1938                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19411939                return NULL;
    19421940        }
    … …  
    19451943        header = (tcp_header_t *) packet_get_data(packet);
    19461944        if (!header) {
    1947                 pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     1945                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19481946                return NULL;
    19491947        }
    … …  
    19541952                header->acknowledgement_number =
    19551953                    htonl(socket_data->next_incoming);
    1956                 SET_TCP_HEADER_ACKNOWLEDGE(header, 1);
     1954                header->acknowledge = 1;
    19571955        }
    19581956        header->window = htons(socket_data->window);
    … …  
    19701968        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
    19711969        if (rc != EOK) {
    1972                 pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     1970                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19731971                return NULL;
    19741972        }
    … …  
    19771975            sequence_number, socket_data->state, socket_data->timeout, true);
    19781976        if (rc != EOK) {
    1979                 pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     1977                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19801978                return NULL;
    19811979        }
    … …  
    19941992
    19951993        /* Make a copy of the packet */
    1996         copy = packet_get_copy(tcp_globals.net_sess, packet);
     1994        copy = packet_get_copy(tcp_globals.net_phone, packet);
    19971995        if (!copy)
    19981996                return NULL;
    … …  
    20022000}
    20032001
    2004 void tcp_send_packets(nic_device_id_t device_id, packet_t *packet)
     2002void tcp_send_packets(device_id_t device_id, packet_t *packet)
    20052003{
    20062004        packet_t *next;
    … …  
    20082006        while (packet) {
    20092007                next = pq_detach(packet);
    2010                 ip_send_msg(tcp_globals.ip_sess, device_id, packet,
     2008                ip_send_msg(tcp_globals.ip_phone, device_id, packet,
    20112009                    SERVICE_TCP, 0);
    20122010                packet = next;
    … …  
    20262024        header->source_port = htons(socket->port);
    20272025        header->source_port = htons(socket_data->dest_port);
    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);
     2026        header->header_length = TCP_COMPUTE_HEADER_LENGTH(sizeof(*header));
     2027        header->synchronize = synchronize;
     2028        header->finalize = finalize;
    20322029}
    20332030
    … …  
    21212118                return NO_DATA;
    21222119
    2123         rc = packet_translate_remote(tcp_globals.net_sess, &packet, packet_id);
     2120        rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
    21242121        if (rc != EOK)
    21252122                return rc;
    … …  
    21322129        /* Release the packet */
    21332130        dyn_fifo_pop(&socket->received);
    2134         pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     2131        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    21352132
    21362133        /* Return the total length */
    … …  
    21702167                return ENOTCONN;
    21712168
    2172         rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
     2169        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    21732170            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    21742171        if (rc != EOK)
    … …  
    21812178        for (index = 0; index < fragments; index++) {
    21822179                /* Read the data fragment */
    2183                 result = tl_socket_read_packet_data(tcp_globals.net_sess,
     2180                result = tl_socket_read_packet_data(tcp_globals.net_phone,
    21842181                    &packet, TCP_HEADER_SIZE, packet_dimension,
    21852182                    socket_data->addr, socket_data->addrlen);
    … …  
    22442241        default:
    22452242                /* Just destroy */
    2246                 rc = socket_destroy(tcp_globals.net_sess, socket_id,
     2243                rc = socket_destroy(tcp_globals.net_phone, socket_id,
    22472244                    local_sockets, &tcp_globals.sockets,
    22482245                    tcp_free_socket_data);
    … …  
    22922289
    22932290        /* Get the device packet dimension */
    2294         rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
     2291        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    22952292            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    22962293        if (rc != EOK)
    … …  
    22982295
    22992296        /* Get a new packet */
    2300         *packet = packet_get_4_remote(tcp_globals.net_sess, TCP_HEADER_SIZE,
     2297        *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
    23012298            packet_dimension->addr_len, packet_dimension->prefix,
    23022299            packet_dimension->suffix);
    … …  
    23612358                        if (rc != EOK)
    23622359                                return rc;
    2363                         rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
     2360                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
    23642361                            &tcp_globals.dimensions, socket_data->device_id,
    23652362                            &packet_dimension);
    … …  
    24332430int tcp_release_and_return(packet_t *packet, int result)
    24342431{
    2435         pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
     2432        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    24362433        return result;
    24372434}
    … …  
    24412438 * @param[in]     iid   Message identifier.
    24422439 * @param[in,out] icall Message parameters.
    2443  * @param[in]     arg   Local argument.
    24442440 *
    24452441 */
    2446 static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     2442static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall)
    24472443{
    24482444        packet_t *packet;
    … …  
    24522448                switch (IPC_GET_IMETHOD(*icall)) {
    24532449                case NET_TL_RECEIVED:
    2454                         rc = packet_translate_remote(tcp_globals.net_sess, &packet,
     2450                        rc = packet_translate_remote(tcp_globals.net_phone, &packet,
    24552451                            IPC_GET_PACKET(*icall));
    24562452                        if (rc == EOK)
    … …  
    24702466/** Initialize the TCP module.
    24712467 *
    2472  * @param[in] sess Network module session.
     2468 * @param[in] net_phone Network module phone.
    24732469 *
    24742470 * @return EOK on success.
    … …  
    24762472 *
    24772473 */
    2478 int tl_initialize(async_sess_t *sess)
     2474int tl_initialize(int net_phone)
    24792475{
    24802476        fibril_rwlock_initialize(&tcp_globals.lock);
    24812477        fibril_rwlock_write_lock(&tcp_globals.lock);
    24822478       
    2483         tcp_globals.net_sess = sess;
     2479        tcp_globals.net_phone = net_phone;
    24842480       
    2485         tcp_globals.icmp_sess = icmp_connect_module();
    2486         tcp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
     2481        tcp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
     2482        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
    24872483            SERVICE_TCP, tcp_receiver);
    2488         if (tcp_globals.ip_sess == NULL) {
     2484        if (tcp_globals.ip_phone < 0) {
    24892485                fibril_rwlock_write_unlock(&tcp_globals.lock);
    2490                 return ENOENT;
     2486                return tcp_globals.ip_phone;
    24912487        }
    24922488       
Note: See TracChangeset for help on using the changeset viewer.