Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/tl/udp/udp.c

    r6b82009 rafe1d1e  
    9999static int udp_release_and_return(packet_t *packet, int result)
    100100{
    101         pq_release_remote(udp_globals.net_sess, packet_get_id(packet));
     101        pq_release_remote(udp_globals.net_phone, packet_get_id(packet));
    102102        return result;
    103103}
     
    192192            ntohs(header->destination_port), (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
    193193        if (!socket) {
    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,
     194                if (tl_prepare_icmp_packet(udp_globals.net_phone,
     195                    udp_globals.icmp_phone, packet, error) == EOK) {
     196                        icmp_destination_unreachable_msg(udp_globals.icmp_phone,
    197197                            ICMP_PORT_UNREACH, 0, packet);
    198198                }
     
    251251                        while (tmp_packet) {
    252252                                next_packet = pq_detach(tmp_packet);
    253                                 pq_release_remote(udp_globals.net_sess,
     253                                pq_release_remote(udp_globals.net_phone,
    254254                                    packet_get_id(tmp_packet));
    255255                                tmp_packet = next_packet;
     
    274274                if (flip_checksum(compact_checksum(checksum)) !=
    275275                    IP_CHECKSUM_ZERO) {
    276                         if (tl_prepare_icmp_packet(udp_globals.net_sess,
    277                             udp_globals.icmp_sess, packet, error) == EOK) {
     276                        if (tl_prepare_icmp_packet(udp_globals.net_phone,
     277                            udp_globals.icmp_phone, packet, error) == EOK) {
    278278                                /* Checksum error ICMP */
    279279                                icmp_parameter_problem_msg(
    280                                     udp_globals.icmp_sess, ICMP_PARAM_POINTER,
     280                                    udp_globals.icmp_phone, ICMP_PARAM_POINTER,
    281281                                    ((size_t) ((void *) &header->checksum)) -
    282282                                    ((size_t) ((void *) header)), packet);
     
    292292                return udp_release_and_return(packet, rc);
    293293               
    294         rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
     294        rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
    295295            &udp_globals.dimensions, device_id, &packet_dimension);
    296296        if (rc != EOK)
     
    299299        /* Notify the destination socket */
    300300        fibril_rwlock_write_unlock(&udp_globals.lock);
    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);
     301        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
     302            (sysarg_t) socket->socket_id, packet_dimension->content, 0, 0,
     303            (sysarg_t) fragments);
    306304
    307305        return EOK;
     
    339337 * @param[in]     iid   Message identifier.
    340338 * @param[in,out] icall Message parameters.
    341  * @param[in]     arg   Local argument.
    342  *
    343  */
    344 static void udp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
     339 *
     340 */
     341static void udp_receiver(ipc_callid_t iid, ipc_call_t *icall)
    345342{
    346343        packet_t *packet;
     
    350347                switch (IPC_GET_IMETHOD(*icall)) {
    351348                case NET_TL_RECEIVED:
    352                         rc = packet_translate_remote(udp_globals.net_sess, &packet,
     349                        rc = packet_translate_remote(udp_globals.net_phone, &packet,
    353350                            IPC_GET_PACKET(*icall));
    354351                        if (rc == EOK)
     
    368365/** Initialize the UDP module.
    369366 *
    370  * @param[in] sess Network module session.
     367 * @param[in] net_phone Network module phone.
    371368 *
    372369 * @return EOK on success.
     
    374371 *
    375372 */
    376 int tl_initialize(async_sess_t *sess)
     373int tl_initialize(int net_phone)
    377374{
    378375        measured_string_t names[] = {
     
    393390        fibril_rwlock_write_lock(&udp_globals.lock);
    394391       
    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;
     392        udp_globals.net_phone = net_phone;
     393       
     394        udp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
     395       
     396        udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
     397            SERVICE_UDP, udp_receiver);
     398        if (udp_globals.ip_phone < 0) {
     399                fibril_rwlock_write_unlock(&udp_globals.lock);
     400                return udp_globals.ip_phone;
    403401        }
    404402       
    405403        /* Read default packet dimensions */
    406         int rc = ip_packet_size_req(udp_globals.ip_sess, -1,
     404        int rc = ip_packet_size_req(udp_globals.ip_phone, -1,
    407405            &udp_globals.packet_dimension);
    408406        if (rc != EOK) {
     
    419417        rc = packet_dimensions_initialize(&udp_globals.dimensions);
    420418        if (rc != EOK) {
    421                 socket_ports_destroy(&udp_globals.sockets, free);
     419                socket_ports_destroy(&udp_globals.sockets);
    422420                fibril_rwlock_write_unlock(&udp_globals.lock);
    423421                return rc;
     
    433431        /* Get configuration */
    434432        configuration = &names[0];
    435         rc = net_get_conf_req(udp_globals.net_sess, &configuration, count,
     433        rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
    436434            &data);
    437435        if (rc != EOK) {
    438                 socket_ports_destroy(&udp_globals.sockets, free);
     436                socket_ports_destroy(&udp_globals.sockets);
    439437                fibril_rwlock_write_unlock(&udp_globals.lock);
    440438                return rc;
     
    501499        device_id_t device_id;
    502500        packet_dimension_t *packet_dimension;
    503         size_t size;
    504501        int rc;
    505 
    506         /* In case of error, do not update the data fragment size. */
    507         *data_fragment_size = 0;
    508502       
    509503        rc = tl_get_address_port(addr, addrlen, &dest_port);
     
    527521
    528522        if (udp_globals.checksum_computing) {
    529                 rc = ip_get_route_req(udp_globals.ip_sess, IPPROTO_UDP, addr,
     523                rc = ip_get_route_req(udp_globals.ip_phone, IPPROTO_UDP, addr,
    530524                    addrlen, &device_id, &ip_header, &headerlen);
    531525                if (rc != EOK)
    532526                        return rc;
    533527                /* Get the device packet dimension */
    534 //              rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
     528//              rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
    535529//                  &udp_globals.dimensions, device_id, &packet_dimension);
    536530//              if (rc != EOK)
     
    539533//      } else {
    540534                /* Do not ask all the time */
    541                 rc = ip_packet_size_req(udp_globals.ip_sess, -1,
     535                rc = ip_packet_size_req(udp_globals.ip_phone, -1,
    542536                    &udp_globals.packet_dimension);
    543537                if (rc != EOK)
     
    546540//      }
    547541
    548         /*
    549          * Update the data fragment size based on what the lower layers can
    550          * handle without fragmentation, but not more than the maximum allowed
    551          * for UDP.
    552          */
    553         size = MAX_UDP_FRAGMENT_SIZE;
    554         if (packet_dimension->content < size)
    555             size = packet_dimension->content;
    556         *data_fragment_size = size;
    557 
    558542        /* Read the first packet fragment */
    559         result = tl_socket_read_packet_data(udp_globals.net_sess, &packet,
     543        result = tl_socket_read_packet_data(udp_globals.net_phone, &packet,
    560544            UDP_HEADER_SIZE, packet_dimension, addr, addrlen);
    561545        if (result < 0)
     
    578562        /* Read the rest of the packet fragments */
    579563        for (index = 1; index < fragments; index++) {
    580                 result = tl_socket_read_packet_data(udp_globals.net_sess,
     564                result = tl_socket_read_packet_data(udp_globals.net_phone,
    581565                    &next_packet, 0, packet_dimension, addr, addrlen);
    582566                if (result < 0)
     
    630614
    631615        /* Send the packet */
    632         ip_send_msg(udp_globals.ip_sess, device_id, packet, SERVICE_UDP, 0);
     616        ip_send_msg(udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0);
    633617
    634618        return EOK;
     
    677661                return NO_DATA;
    678662       
    679         rc = packet_translate_remote(udp_globals.net_sess, &packet, packet_id);
     663        rc = packet_translate_remote(udp_globals.net_phone, &packet, packet_id);
    680664        if (rc != EOK) {
    681665                (void) dyn_fifo_pop(&socket->received);
     
    737721}
    738722
    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  */
    752 static int udp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
    753     ipc_call_t call)
     723/** Processes the socket client messages.
     724 *
     725 * Runs until the client module disconnects.
     726 *
     727 * @param[in] callid    The message identifier.
     728 * @param[in] call      The message parameters.
     729 * @return              EOK on success.
     730 *
     731 * @see socket.h
     732 */
     733static int udp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
    754734{
    755735        int res;
     736        bool keep_on_going = true;
    756737        socket_cores_t local_sockets;
     738        int app_phone = IPC_GET_PHONE(call);
    757739        struct sockaddr *addr;
    758740        int socket_id;
    759741        size_t addrlen;
    760         size_t size;
     742        size_t size = 0;
    761743        ipc_call_t answer;
    762744        size_t answer_count;
     
    777759        socket_cores_initialize(&local_sockets);
    778760
    779         while (true) {
     761        while (keep_on_going) {
    780762
    781763                /* Answer the call */
     
    789771
    790772                /* Process the call */
    791                 if (!IPC_GET_IMETHOD(call)) {
     773                switch (IPC_GET_IMETHOD(call)) {
     774                case IPC_M_PHONE_HUNGUP:
     775                        keep_on_going = false;
    792776                        res = EHANGUP;
    793777                        break;
    794                 }
    795                
    796                 switch (IPC_GET_IMETHOD(call)) {
     778
    797779                case NET_SOCKET:
    798780                        socket_id = SOCKET_GET_SOCKET_ID(call);
    799                         res = socket_create(&local_sockets, sess, NULL,
     781                        res = socket_create(&local_sockets, app_phone, NULL,
    800782                            &socket_id);
    801783                        SOCKET_SET_SOCKET_ID(answer, socket_id);
     
    804786                                break;
    805787                       
    806                         size = MAX_UDP_FRAGMENT_SIZE;
    807                         if (tl_get_ip_packet_dimension(udp_globals.ip_sess,
     788                        if (tl_get_ip_packet_dimension(udp_globals.ip_phone,
    808789                            &udp_globals.dimensions, DEVICE_INVALID_ID,
    809790                            &packet_dimension) == EOK) {
    810                                 if (packet_dimension->content < size)
    811                                         size = packet_dimension->content;
     791                                SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
     792                                    packet_dimension->content);
    812793                        }
    813                         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
     794
     795//                      SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
     796//                          MAX_UDP_FRAGMENT_SIZE);
    814797                        SOCKET_SET_HEADER_SIZE(answer, UDP_HEADER_SIZE);
    815798                        answer_count = 3;
     
    869852                case NET_SOCKET_CLOSE:
    870853                        fibril_rwlock_write_lock(&udp_globals.lock);
    871                         res = socket_destroy(udp_globals.net_sess,
     854                        res = socket_destroy(udp_globals.net_phone,
    872855                            SOCKET_GET_SOCKET_ID(call), &local_sockets,
    873856                            &udp_globals.sockets, NULL);
     
    883866        }
    884867
    885         /* Release the application session */
    886         async_hangup(sess);
     868        /* Release the application phone */
     869        async_hangup(app_phone);
    887870
    888871        /* Release all local sockets */
    889         socket_cores_release(udp_globals.net_sess, &local_sockets,
     872        socket_cores_release(udp_globals.net_phone, &local_sockets,
    890873            &udp_globals.sockets, NULL);
    891874
     
    917900{
    918901        *answer_count = 0;
    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        
     902
     903        switch (IPC_GET_IMETHOD(*call)) {
     904        case IPC_M_CONNECT_TO_ME:
     905                return udp_process_client_messages(callid, *call);
     906        }
     907
    925908        return ENOTSUP;
    926909}
Note: See TracChangeset for help on using the changeset viewer.