Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rffa2c8ef r6b82009  
    206206
    207207static 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);
     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);
    … …  
    299300                return tcp_release_and_return(packet, NO_DATA);
    300301
    301 //      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
    302 //          ntohs(header->destination_port));
    303 
     302#if 0
     303        printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
     304            ntohs(header->destination_port));
     305#endif
    304306        result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
    305307        if (result <= 0)
    … …  
    323325
    324326        if (!socket) {
    325                 if (tl_prepare_icmp_packet(tcp_globals.net_phone,
    326                     tcp_globals.icmp_phone, packet, error) == EOK) {
    327                         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,
    328330                            ICMP_PORT_UNREACH, 0, packet);
    329331                }
    … …  
    396398                fibril_rwlock_write_unlock(socket_data->local_lock);
    397399
    398                 rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
    399                     tcp_globals.icmp_phone, packet, error);
     400                rc = tl_prepare_icmp_packet(tcp_globals.net_sess,
     401                    tcp_globals.icmp_sess, packet, error);
    400402                if (rc == EOK) {
    401403                        /* Checksum error ICMP */
    402                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
     404                        icmp_parameter_problem_msg(tcp_globals.icmp_sess,
    403405                            ICMP_PARAM_POINTER,
    404406                            ((size_t) ((void *) &header->checksum)) -
    … …  
    438440                break;
    439441        default:
    440                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     442                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    441443        }
    442444
    … …  
    475477        old_incoming = socket_data->next_incoming;
    476478
    477         if (header->finalize) {
     479        if (GET_TCP_HEADER_FINALIZE(header)) {
    478480                socket_data->fin_incoming = new_sequence_number +
    479481                    total_length - TCP_HEADER_LENGTH(header);
    … …  
    501503                        /* Release the acknowledged packets */
    502504                        next_packet = pq_next(packet);
    503                         pq_release_remote(tcp_globals.net_phone,
     505                        pq_release_remote(tcp_globals.net_sess,
    504506                            packet_get_id(packet));
    505507                        packet = next_packet;
    … …  
    560562                        next_packet = pq_next(next_packet);
    561563                        pq_insert_after(tmp_packet, next_packet);
    562                         pq_release_remote(tcp_globals.net_phone,
     564                        pq_release_remote(tcp_globals.net_sess,
    563565                            packet_get_id(tmp_packet));
    564566                }
    … …  
    597599                                if (packet == socket_data->incoming)
    598600                                        socket_data->incoming = next_packet;
    599                                 pq_release_remote(tcp_globals.net_phone,
     601                                pq_release_remote(tcp_globals.net_sess,
    600602                                    packet_get_id(packet));
    601603                                packet = next_packet;
    … …  
    620622                                if (length <= 0) {
    621623                                        /* Remove the empty packet */
    622                                         pq_release_remote(tcp_globals.net_phone,
     624                                        pq_release_remote(tcp_globals.net_sess,
    623625                                            packet_get_id(packet));
    624626                                        packet = next_packet;
    … …  
    667669                                }
    668670                                /* Remove the duplicit or corrupted packet */
    669                                 pq_release_remote(tcp_globals.net_phone,
     671                                pq_release_remote(tcp_globals.net_sess,
    670672                                    packet_get_id(packet));
    671673                                packet = next_packet;
    … …  
    694696                if (rc != EOK) {
    695697                        /* Remove the corrupted packets */
    696                         pq_release_remote(tcp_globals.net_phone,
     698                        pq_release_remote(tcp_globals.net_sess,
    697699                            packet_get_id(packet));
    698                         pq_release_remote(tcp_globals.net_phone,
     700                        pq_release_remote(tcp_globals.net_sess,
    699701                            packet_get_id(next_packet));
    700702                } else {
    … …  
    707709                                    new_sequence_number, length);
    708710                                if (rc != EOK) {
    709                                         pq_release_remote(tcp_globals.net_phone,
     711                                        pq_release_remote(tcp_globals.net_sess,
    710712                                            packet_get_id(next_packet));
    711713                                }
    712714                                rc = pq_insert_after(packet, next_packet);
    713715                                if (rc != EOK) {
    714                                         pq_release_remote(tcp_globals.net_phone,
     716                                        pq_release_remote(tcp_globals.net_sess,
    715717                                            packet_get_id(next_packet));
    716718                                }
    … …  
    721723                printf("unexpected\n");
    722724                /* Release duplicite or restricted */
    723                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     725                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    724726                forced_ack = true;
    725727        }
    … …  
    789791        if (rc != EOK)
    790792                return tcp_release_and_return(packet, rc);
    791         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     793        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    792794            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    793795        if (rc != EOK)
    … …  
    798800
    799801        /* Notify the destination socket */
    800         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    801             (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,
    802804            ((packet_dimension->content < socket_data->data_fragment_size) ?
    803805            packet_dimension->content : socket_data->data_fragment_size), 0, 0,
    804806            (sysarg_t) fragments);
     807        async_exchange_end(exch);
    805808
    806809        return EOK;
    … …  
    819822
    820823        /* Notify the destination socket */
    821         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    822             (sysarg_t) socket->socket_id,
    823             0, 0, 0,
    824             (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);
    825828}
    826829
    … …  
    837840        assert(packet);
    838841
    839         if (!header->synchronize)
     842        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    840843                return tcp_release_and_return(packet, EINVAL);
    841844       
    … …  
    848851        next_packet = pq_detach(packet);
    849852        if (next_packet) {
    850                 pq_release_remote(tcp_globals.net_phone,
     853                pq_release_remote(tcp_globals.net_sess,
    851854                    packet_get_id(next_packet));
    852855        }
    … …  
    902905        assert(packet);
    903906
    904         if (!header->synchronize)
     907        if (!GET_TCP_HEADER_SYNCHRONIZE(header))
    905908                return tcp_release_and_return(packet, EINVAL);
    906909
    … …  
    935938        /* Create a socket */
    936939        socket_id = -1;
    937         rc = socket_create(socket_data->local_sockets, listening_socket->phone,
     940        rc = socket_create(socket_data->local_sockets, listening_socket->sess,
    938941            socket_data, &socket_id);
    939942        if (rc != EOK) {
    … …  
    988991        fibril_rwlock_write_unlock(&tcp_globals.lock);
    989992        if (rc != EOK) {
    990                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     993                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    991994                    socket_data->local_sockets, &tcp_globals.sockets,
    992995                    tcp_free_socket_data);
    … …  
    10001003        next_packet = pq_detach(packet);
    10011004        if (next_packet) {
    1002                 pq_release_remote(tcp_globals.net_phone,
     1005                pq_release_remote(tcp_globals.net_sess,
    10031006                    packet_get_id(next_packet));
    10041007        }
    … …  
    10091012                    packet_get_data_length(packet) - sizeof(*header));
    10101013                if (rc != EOK) {
    1011                         socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1014                        socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10121015                            socket_data->local_sockets, &tcp_globals.sockets,
    10131016                            tcp_free_socket_data);
    … …  
    10201023        rc = tcp_queue_packet(socket, socket_data, packet, 1);
    10211024        if (rc != EOK) {
    1022                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1025                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10231026                    socket_data->local_sockets, &tcp_globals.sockets,
    10241027                    tcp_free_socket_data);
    … …  
    10281031        packet = tcp_get_packets_to_send(socket, socket_data);
    10291032        if (!packet) {
    1030                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1033                socket_destroy(tcp_globals.net_sess, socket->socket_id,
    10311034                    socket_data->local_sockets, &tcp_globals.sockets,
    10321035                    tcp_free_socket_data);
    … …  
    10561059        assert(packet);
    10571060
    1058         if (!header->acknowledge)
     1061        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    10591062                return tcp_release_and_return(packet, EINVAL);
    10601063
    … …  
    10621065        tcp_process_acknowledgement(socket, socket_data, header);
    10631066
    1064         socket_data->next_incoming = ntohl(header->sequence_number);    // + 1;
    1065         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1067        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
     1068        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    10661069        socket_data->state = TCP_SOCKET_ESTABLISHED;
    10671070        listening_socket = socket_cores_find(socket_data->local_sockets,
    … …  
    10771080                if (rc == EOK) {
    10781081                        /* Notify the destination socket */
    1079                         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,
    10801084                            (sysarg_t) listening_socket->socket_id,
    10811085                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
    10821086                            0, (sysarg_t) socket->socket_id);
     1087                        async_exchange_end(exch);
    10831088
    10841089                        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    11251130        assert(header);
    11261131
    1127         if (!header->acknowledge)
     1132        if (!GET_TCP_HEADER_ACKNOWLEDGE(header))
    11281133                return;
    11291134
    … …  
    11761181                                /* Add to acknowledged or release */
    11771182                                if (pq_add(&acknowledged, packet, 0, 0) != EOK)
    1178                                         pq_release_remote(tcp_globals.net_phone,
     1183                                        pq_release_remote(tcp_globals.net_sess,
    11791184                                            packet_get_id(packet));
    11801185                                packet = next;
    … …  
    11851190                /* Release acknowledged */
    11861191                if (acknowledged) {
    1187                         pq_release_remote(tcp_globals.net_phone,
     1192                        pq_release_remote(tcp_globals.net_sess,
    11881193                            packet_get_id(acknowledged));
    11891194                }
    … …  
    12291234        assert(answer);
    12301235        assert(answer_count);
    1231 
     1236       
    12321237        *answer_count = 0;
    1233         switch (IPC_GET_IMETHOD(*call)) {
    1234         case IPC_M_CONNECT_TO_ME:
    1235                 return tcp_process_client_messages(callid, *call);
    1236         }
    1237 
     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       
    12381244        return ENOTSUP;
    12391245}
    … …  
    12651271}
    12661272
    1267 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)
    12681275{
    12691276        int res;
    1270         bool keep_on_going = true;
    12711277        socket_cores_t local_sockets;
    1272         int app_phone = IPC_GET_PHONE(call);
    12731278        struct sockaddr *addr;
    12741279        int socket_id;
    … …  
    12921297        fibril_rwlock_initialize(&lock);
    12931298
    1294         while (keep_on_going) {
     1299        while (true) {
    12951300
    12961301                /* Answer the call */
    … …  
    13001305                /* Get the next call */
    13011306                callid = async_get_call(&call);
     1307               
     1308                if (!IPC_GET_IMETHOD(call)) {
     1309                        res = EHANGUP;
     1310                        break;
     1311                }
    13021312
    13031313                /* Process the call */
    13041314                switch (IPC_GET_IMETHOD(call)) {
    1305                 case IPC_M_PHONE_HUNGUP:
    1306                         keep_on_going = false;
    1307                         res = EHANGUP;
    1308                         break;
    1309 
    13101315                case NET_SOCKET:
    13111316                        socket_data =
    … …  
    13211326                        fibril_rwlock_write_lock(&lock);
    13221327                        socket_id = SOCKET_GET_SOCKET_ID(call);
    1323                         res = socket_create(&local_sockets, app_phone,
     1328                        res = socket_create(&local_sockets, sess,
    13241329                            socket_data, &socket_id);
    13251330                        SOCKET_SET_SOCKET_ID(answer, socket_id);
    … …  
    13291334                                break;
    13301335                        }
    1331                         if (tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     1336                        if (tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    13321337                            &tcp_globals.dimensions, DEVICE_INVALID_ID,
    13331338                            &packet_dimension) == EOK) {
    … …  
    15041509        }
    15051510
    1506         /* Release the application phone */
    1507         async_hangup(app_phone);
     1511        /* Release the application session */
     1512        async_hangup(sess);
    15081513
    15091514        printf("release\n");
    15101515        /* Release all local sockets */
    1511         socket_cores_release(tcp_globals.net_phone, &local_sockets,
     1516        socket_cores_release(tcp_globals.net_sess, &local_sockets,
    15121517            &tcp_globals.sockets, tcp_free_socket_data);
    15131518
    … …  
    16171622                        local_lock = socket_data->local_lock;
    16181623                        fibril_rwlock_write_lock(local_lock);
    1619                         socket_destroy(tcp_globals.net_phone,
     1624                        socket_destroy(tcp_globals.net_sess,
    16201625                            timeout->socket_id, timeout->local_sockets,
    16211626                            &tcp_globals.sockets, tcp_free_socket_data);
    … …  
    17071712                if (socket->port > 0) {
    17081713                        socket_ports_exclude(&tcp_globals.sockets,
    1709                             socket->port);
     1714                            socket->port, free);
    17101715                        socket->port = 0;
    17111716                }
    … …  
    17501755        }
    17511756
    1752         rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
     1757        rc = ip_get_route_req(tcp_globals.ip_sess, IPPROTO_TCP,
    17531758            addr, addrlen, &socket_data->device_id,
    17541759            &socket_data->pseudo_header, &socket_data->headerlen);
    … …  
    18321837
    18331838        /* Remember the outgoing FIN */
    1834         if (header->finalize)
     1839        if (GET_TCP_HEADER_FINALIZE(header))
    18351840                socket_data->fin_outgoing = socket_data->next_outgoing;
    18361841       
    … …  
    18981903                        rc = pq_insert_after(previous, copy);
    18991904                        if (rc != EOK) {
    1900                                 pq_release_remote(tcp_globals.net_phone,
     1905                                pq_release_remote(tcp_globals.net_sess,
    19011906                                    packet_get_id(copy));
    19021907                                return sending;
    … …  
    19351940            socket_data->headerlen, packet_get_data_length(packet));
    19361941        if (rc != EOK) {
    1937                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1942                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19381943                return NULL;
    19391944        }
    … …  
    19421947        header = (tcp_header_t *) packet_get_data(packet);
    19431948        if (!header) {
    1944                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1949                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19451950                return NULL;
    19461951        }
    … …  
    19511956                header->acknowledgement_number =
    19521957                    htonl(socket_data->next_incoming);
    1953                 header->acknowledge = 1;
     1958                SET_TCP_HEADER_ACKNOWLEDGE(header, 1);
    19541959        }
    19551960        header->window = htons(socket_data->window);
    … …  
    19671972        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
    19681973        if (rc != EOK) {
    1969                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1974                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19701975                return NULL;
    19711976        }
    … …  
    19741979            sequence_number, socket_data->state, socket_data->timeout, true);
    19751980        if (rc != EOK) {
    1976                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1981                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    19771982                return NULL;
    19781983        }
    … …  
    19911996
    19921997        /* Make a copy of the packet */
    1993         copy = packet_get_copy(tcp_globals.net_phone, packet);
     1998        copy = packet_get_copy(tcp_globals.net_sess, packet);
    19941999        if (!copy)
    19952000                return NULL;
    … …  
    20052010        while (packet) {
    20062011                next = pq_detach(packet);
    2007                 ip_send_msg(tcp_globals.ip_phone, device_id, packet,
     2012                ip_send_msg(tcp_globals.ip_sess, device_id, packet,
    20082013                    SERVICE_TCP, 0);
    20092014                packet = next;
    … …  
    20232028        header->source_port = htons(socket->port);
    20242029        header->source_port = htons(socket_data->dest_port);
    2025         header->header_length = TCP_COMPUTE_HEADER_LENGTH(sizeof(*header));
    2026         header->synchronize = synchronize;
    2027         header->finalize = finalize;
     2030        SET_TCP_HEADER_LENGTH(header,
     2031            TCP_COMPUTE_HEADER_LENGTH(sizeof(*header)));
     2032        SET_TCP_HEADER_SYNCHRONIZE(header, synchronize);
     2033        SET_TCP_HEADER_FINALIZE(header, finalize);
    20282034}
    20292035
    … …  
    21172123                return NO_DATA;
    21182124
    2119         rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
     2125        rc = packet_translate_remote(tcp_globals.net_sess, &packet, packet_id);
    21202126        if (rc != EOK)
    21212127                return rc;
    … …  
    21282134        /* Release the packet */
    21292135        dyn_fifo_pop(&socket->received);
    2130         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     2136        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    21312137
    21322138        /* Return the total length */
    … …  
    21662172                return ENOTCONN;
    21672173
    2168         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2174        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    21692175            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    21702176        if (rc != EOK)
    … …  
    21772183        for (index = 0; index < fragments; index++) {
    21782184                /* Read the data fragment */
    2179                 result = tl_socket_read_packet_data(tcp_globals.net_phone,
     2185                result = tl_socket_read_packet_data(tcp_globals.net_sess,
    21802186                    &packet, TCP_HEADER_SIZE, packet_dimension,
    21812187                    socket_data->addr, socket_data->addrlen);
    … …  
    22402246        default:
    22412247                /* Just destroy */
    2242                 rc = socket_destroy(tcp_globals.net_phone, socket_id,
     2248                rc = socket_destroy(tcp_globals.net_sess, socket_id,
    22432249                    local_sockets, &tcp_globals.sockets,
    22442250                    tcp_free_socket_data);
    … …  
    22882294
    22892295        /* Get the device packet dimension */
    2290         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2296        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    22912297            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
    22922298        if (rc != EOK)
    … …  
    22942300
    22952301        /* Get a new packet */
    2296         *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,
    22972303            packet_dimension->addr_len, packet_dimension->prefix,
    22982304            packet_dimension->suffix);
    … …  
    23572363                        if (rc != EOK)
    23582364                                return rc;
    2359                         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2365                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
    23602366                            &tcp_globals.dimensions, socket_data->device_id,
    23612367                            &packet_dimension);
    … …  
    24292435int tcp_release_and_return(packet_t *packet, int result)
    24302436{
    2431         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     2437        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
    24322438        return result;
    24332439}
    … …  
    24372443 * @param[in]     iid   Message identifier.
    24382444 * @param[in,out] icall Message parameters.
     2445 * @param[in]     arg   Local argument.
    24392446 *
    24402447 */
    2441 static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall)
     2448static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    24422449{
    24432450        packet_t *packet;
    … …  
    24472454                switch (IPC_GET_IMETHOD(*icall)) {
    24482455                case NET_TL_RECEIVED:
    2449                         rc = packet_translate_remote(tcp_globals.net_phone, &packet,
     2456                        rc = packet_translate_remote(tcp_globals.net_sess, &packet,
    24502457                            IPC_GET_PACKET(*icall));
    24512458                        if (rc == EOK)
    … …  
    24652472/** Initialize the TCP module.
    24662473 *
    2467  * @param[in] net_phone Network module phone.
     2474 * @param[in] sess Network module session.
    24682475 *
    24692476 * @return EOK on success.
    … …  
    24712478 *
    24722479 */
    2473 int tl_initialize(int net_phone)
     2480int tl_initialize(async_sess_t *sess)
    24742481{
    24752482        fibril_rwlock_initialize(&tcp_globals.lock);
    24762483        fibril_rwlock_write_lock(&tcp_globals.lock);
    24772484       
    2478         tcp_globals.net_phone = net_phone;
     2485        tcp_globals.net_sess = sess;
    24792486       
    2480         tcp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
    2481         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,
    24822489            SERVICE_TCP, tcp_receiver);
    2483         if (tcp_globals.ip_phone < 0) {
     2490        if (tcp_globals.ip_sess == NULL) {
    24842491                fibril_rwlock_write_unlock(&tcp_globals.lock);
    2485                 return tcp_globals.ip_phone;
     2492                return ENOENT;
    24862493        }
    24872494       
    … …  
    24922499        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
    24932500        if (rc != EOK) {
    2494                 socket_ports_destroy(&tcp_globals.sockets);
     2501                socket_ports_destroy(&tcp_globals.sockets, free);
    24952502                goto out;
    24962503        }
Note: See TracChangeset for help on using the changeset viewer.