Subversion Repositories HelenOS

Rev

Rev 4720 | Rev 4726 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2008 Lukas Mejdrech
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  *
  9.  * - Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * - Redistributions in binary form must reproduce the above copyright
  12.  *   notice, this list of conditions and the following disclaimer in the
  13.  *   documentation and/or other materials provided with the distribution.
  14.  * - The name of the author may not be used to endorse or promote products
  15.  *   derived from this software without specific prior written permission.
  16.  *
  17.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27.  */
  28.  
  29. /** @addtogroup udp
  30.  *  @{
  31.  */
  32.  
  33. /** @file
  34.  *  UDP module implementation.
  35.  *  @see udp.h
  36.  */
  37.  
  38. #include <async.h>
  39. #include <fibril_sync.h>
  40. #include <malloc.h>
  41.  
  42. #include <ipc/ipc.h>
  43. #include <ipc/services.h>
  44.  
  45. #include "../../err.h"
  46. #include "../../messages.h"
  47. #include "../../modules.h"
  48.  
  49. #include "../../structures/dynamic_fifo.h"
  50. #include "../../structures/packet/packet_client.h"
  51.  
  52. #include "../../include/crc.h"
  53. #include "../../include/in.h"
  54. #include "../../include/in6.h"
  55. #include "../../include/inet.h"
  56. #include "../../include/ip_client.h"
  57. #include "../../include/ip_interface.h"
  58. #include "../../include/ip_protocols.h"
  59. #include "../../include/icmp_client.h"
  60. #include "../../include/icmp_interface.h"
  61. #include "../../include/net_interface.h"
  62. #include "../../include/socket_codes.h"
  63. #include "../../include/socket_errno.h"
  64.  
  65. #include "../../socket/socket_core.h"
  66. #include "../../socket/socket_messages.h"
  67.  
  68. #include "../tl_messages.h"
  69.  
  70. #include "udp.h"
  71. #include "udp_header.h"
  72. #include "udp_module.h"
  73.  
  74. /** Default UDP checksum computing.
  75.  */
  76. #define NET_DEFAULT_UDP_CHECKSUM_COMPUTING  true
  77.  
  78. /** Maximum UDP fragment size.
  79.  */
  80. #define MAX_UDP_FRAGMENT_SIZE   65535
  81.  
  82. /** Free ports pool start.
  83.  */
  84. #define UDP_FREE_PORTS_START    1025
  85.  
  86. /** Free ports pool end.
  87.  */
  88. #define UDP_FREE_PORTS_END      65535
  89.  
  90. /** Processes the received UDP packet queue.
  91.  *  Is used as an entry point from the underlying IP module.
  92.  *  Notifies the destination socket application.
  93.  *  Releases the packet on error or send an ICMP error notification..
  94.  *  @param device_id The device identifier. Ignored parameter.
  95.  *  @param packet The received packet queue. Input/output parameter.
  96.  *  @param receiver The target service. Ignored parameter.
  97.  *  @param error The packet error reporting service. Prefixes the received packet. Input parameter.
  98.  *  @returns EOK on success.
  99.  *  @returns EINVAL if the packet is not valid.
  100.  *  @returns EINVAL if the stored packet address is not the an_addr_t.
  101.  *  @returns EINVAL if the packet does not contain any data.
  102.  *  @returns NO_DATA if the packet content is shorter than the user datagram header.
  103.  *  @returns ENOMEM if there is not enough memory left.
  104.  *  @returns EADDRNOTAVAIL if the destination socket does not exist.
  105.  *  @returns Other error codes as defined for the ip_client_process_packet() function.
  106.  */
  107. int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );
  108.  
  109. /** Releases the packet and returns the result.
  110.  *  @param packet The packet queue to be released. Input parameter.
  111.  *  @param result The result to be returned. Input parameter.
  112.  *  @return The result parameter.
  113.  */
  114. int udp_release_and_return( packet_t packet, int result );
  115.  
  116. /** Sends the port unreachable ICMP notification.
  117.  *  Sends the first packet and releases all the others.
  118.  *  Releases the packet queu on error.
  119.  *  @param packet The packet to be send. Input parameter.
  120.  *  @param error The packet error reporting service. Prefixes the received packet. Input parameter.
  121.  */
  122. void    udp_send_icmp_port_unreachable( packet_t packet, services_t error );
  123.  
  124. /** @name Socket messages processing functions
  125.  */
  126. /*@{*/
  127.  
  128. /** Processes the socket client messages.
  129.  *  Runs until the client module disconnects.
  130.  *  @param callid The message identifier. Input parameter.
  131.  *  @param call The message parameters. Input parameter.
  132.  *  @returns EOK on success.
  133.  *  @see socket.h
  134.  */
  135. int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call );
  136.  
  137. /** Sends data from the socket to the remote address.
  138.  *  Binds the socket to a free port if not already connected/bound.
  139.  *  Handles the NET_SOCKET_SENDTO message.
  140.  *  Supports AF_INET and AF_INET6 address families.
  141.  *  @param local_sockets The application local sockets. Input/output parameter.
  142.  *  @param socket_id Socket identifier. Input parameter.
  143.  *  @param addr The destination address. Input parameter.
  144.  *  @param addrlen The address length. Input parameter.
  145.  *  @param fragments The number of data fragments. Input parameter.
  146.  *  @param flags Various send flags. Input parameter.
  147.  *  @returns EOK on success.
  148.  *  @returns EAFNOTSUPPORT if the address family is not supported.
  149.  *  @returns ENOTSOCK if the socket is not found.
  150.  *  @returns EINVAL if the address is invalid.
  151.  *  @returns ENOTCONN if the sending socket is not and cannot be bound.
  152.  *  @returns ENOMEM if there is not enough memory left.
  153.  *  @returns Other error codes as defined for the socket_read_packet_data() function.
  154.  *  @returns Other error codes as defined for the ip_client_prepare_packet() function.
  155.  *  @returns Other error codes as defined for the ip_send_msg() function.
  156.  */
  157. int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, int flags );
  158.  
  159. /** Receives data to the socket.
  160.  *  Handles the NET_SOCKET_RECVFROM message.
  161.  *  Replies the source address as well.
  162.  *  @param local_sockets The application local sockets. Input parameter.
  163.  *  @param socket_id Socket identifier. Input parameter.
  164.  *  @param flags Various receive flags. Input parameter.
  165.  *  @param addrlen The source address length. Output parameter.
  166.  *  @returns The number of bytes received.
  167.  *  @returns ENOTSOCK if the socket is not found.
  168.  *  @returns NO_DATA if there are no received packets or data.
  169.  *  @returns ENOMEM if there is not enough memory left.
  170.  *  @returns EINVAL if the received address is not an IP address.
  171.  *  @returns Other error codes as defined for the packet_translate() function.
  172.  *  @returns Other error codes as defined for the data_reply() function.
  173.  */
  174. int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
  175.  
  176. /*@}*/
  177.  
  178. /** Receives data from the socket into a packet.
  179.  *  @param packet The new created packet. Output parameter.
  180.  *  @param prefix Reserved packet data prefix length. Input parameter.
  181.  *  @param addr The destination address. Input parameter.
  182.  *  @param addrlen The address length. Input parameter.
  183.  *  @returns Number of bytes received.
  184.  *  @returns EINVAL if the client does not send data.
  185.  *  @returns ENOMEM if there is not enough memory left.
  186.  *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
  187.  */
  188. int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen );
  189.  
  190. /** Sets the address port.
  191.  *  Supports AF_INET and AF_INET6 address families.
  192.  *  @param addr The address to be updated. Input/output parameter.
  193.  *  @param addrlen The address length. Input parameter.
  194.  *  @param port The port to be set. Input parameter.
  195.  *  @returns EOK on success.
  196.  *  @returns EINVAL if the address length does not match the address family.
  197.  *  @returns EAFNOSUPPORT if the address family is not supported.
  198.  */
  199. int udp_set_address_port( struct sockaddr * addr, int addrlen, uint16_t port );
  200.  
  201. /** UDP global data.
  202.  */
  203. udp_globals_t   udp_globals;
  204.  
  205. int udp_initialize( async_client_conn_t client_connection ){
  206.     ERROR_DECLARE;
  207.  
  208.     measured_string_t   names[] = {{ "UDP_CHECKSUM_COMPUTING", 22 }};
  209.     measured_string_ref configuration;
  210.     size_t              count = sizeof( names ) / sizeof( measured_string_t );
  211.     char *              data;
  212.  
  213.     fibril_rwlock_initialize( & udp_globals.lock );
  214.     fibril_rwlock_write_lock( & udp_globals.lock );
  215.     udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
  216.     if( udp_globals.icmp_phone < 0 ){
  217.         return udp_globals.icmp_phone;
  218.     }
  219.     udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );
  220.     if( udp_globals.ip_phone < 0 ){
  221.         return udp_globals.ip_phone;
  222.     }
  223.     ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
  224.     ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
  225.     udp_globals.prefix += sizeof( udp_header_t );
  226.     udp_globals.content -= sizeof( udp_header_t );
  227.     udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
  228.     // get configuration
  229.     udp_globals.checksum_computing = NET_DEFAULT_UDP_CHECKSUM_COMPUTING;
  230.     configuration = & names[ 0 ];
  231.     ERROR_PROPAGATE( net_get_conf_req( udp_globals.net_phone, & configuration, count, & data ));
  232.     if( configuration ){
  233.         if( configuration[ 0 ].value ){
  234.             udp_globals.checksum_computing = ( configuration[ 0 ].value[ 0 ] == 'y' );
  235.         }
  236.         net_free_settings( configuration, data );
  237.     }
  238.     fibril_rwlock_write_unlock( & udp_globals.lock );
  239.     return EOK;
  240. }
  241.  
  242. int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
  243.     ERROR_DECLARE;
  244.  
  245.     size_t          length;
  246.     size_t          offset;
  247.     int             result;
  248.     uint8_t *       data;
  249.     udp_header_ref  header;
  250.     socket_core_ref *   socket;
  251.     packet_t        next_packet;
  252.     size_t          total_length;
  253.     uint32_t        checksum;
  254.     int             fragments;
  255.     packet_t        tmp_packet;
  256.     icmp_type_t     type;
  257.     icmp_code_t     code;
  258.     ip_pseudo_header_ref    ip_header;
  259.     struct sockaddr *       src;
  260.     struct sockaddr *       dest;
  261.  
  262.     if( error ){
  263.         switch( error ){
  264.             case SERVICE_ICMP:
  265.                 // process error
  266.                 // TODO remove debug dump
  267.                 // length = icmp_client_header_length( packet );
  268.                 result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
  269.                 if( result < 0 ){
  270.                     return udp_release_and_return( packet, result );
  271.                 }
  272.                 printf( "ICMP error %d (%d) in packet %d\n", type, code, packet_get_id( packet ) );
  273.                 length = ( size_t ) result;
  274.                 if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
  275.                     return udp_release_and_return( packet, ERROR_CODE );
  276.                 }
  277.                 break;
  278.             default:
  279.                 return udp_release_and_return( packet, ENOTSUP );
  280.         }
  281.     }
  282.     // TODO process received ipopts?
  283.     result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
  284.     if( result < 0 ){
  285.         return udp_release_and_return( packet, result );
  286.     }
  287.     offset = ( size_t ) result;
  288.  
  289.     length = packet_get_data_length( packet );
  290.     if( length <= 0 ){
  291.         return udp_release_and_return( packet, EINVAL );
  292.     }
  293.     if( length < sizeof( udp_header_t ) + offset ){
  294.         return udp_release_and_return( packet, NO_DATA );
  295.     }
  296.     data = packet_get_data( packet );
  297.     if( ! data ){
  298.         return udp_release_and_return( packet, NO_DATA );
  299.     }
  300.     // get udp header
  301.     header = ( udp_header_ref )( data + offset );
  302.     // find the destination socket
  303.     socket = socket_ports_find( & udp_globals.sockets, ntohs( header->dest ));
  304.     if( ! socket ){
  305.         udp_send_icmp_port_unreachable( packet, error );
  306.         return EADDRNOTAVAIL;
  307.     }
  308.     // trim after successful processing to be able to send an ICMP error message!
  309.     ERROR_PROPAGATE( packet_trim( packet, offset, 0 ));
  310.     // count the received packet fragments
  311.     next_packet = packet;
  312.     fragments = 0;
  313.     total_length = ntohs( header->len );
  314.     // compute header checksum if set
  315.     if( header->check && ( ! error )){
  316.         result = packet_get_addr( packet, ( uint8_t ** ) & src, ( uint8_t ** ) & dest );
  317.         if( result <= 0 ){
  318.             return udp_release_and_return( packet, result );
  319.         }
  320.         if( ERROR_OCCURRED( ip_client_get_pseudo_header( IPPROTO_UDP, src, result, dest, result, total_length, & ip_header, & length ))){
  321.             return udp_release_and_return( packet, ERROR_CODE );
  322.         }else{
  323.             checksum = compute_checksum( 0, ip_header, length );
  324.             // the udp header checksum will be added with the first fragment later
  325.             free( ip_header );
  326.         }
  327.     }else{
  328.         header->check = 0;
  329.         checksum = 0;
  330.     }
  331.     do{
  332.         ++ fragments;
  333.         length = packet_get_data_length( next_packet );
  334.         if( length <= 0 ){
  335.             return udp_release_and_return( packet, NO_DATA );
  336.         }
  337.         if( total_length < length ){
  338.             if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
  339.                 return udp_release_and_return( packet, ERROR_CODE );
  340.             }
  341.             // add partial checksum if set
  342.             if( header->check ){
  343.                 checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
  344.             }
  345.             // relese the rest of the packet fragments
  346.             tmp_packet = pq_next( next_packet );
  347.             while( tmp_packet ){
  348.                 next_packet = pq_detach( tmp_packet );
  349.                 pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
  350.                 tmp_packet = next_packet;
  351.             }
  352.             // exit the loop
  353.             break;
  354.         }
  355.         total_length -= length;
  356.         // add partial checksum if set
  357.         if( header->check ){
  358.             checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
  359.         }
  360.     }while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
  361.     // check checksum
  362.     if( header->check ){
  363.         if( flip_checksum( compact_checksum( checksum ))){
  364.             // TODO checksum error ICMP?
  365.             // TODO remove debug dump
  366.             printf("udp check failed %x => %x\n", header->check, flip_checksum( compact_checksum( checksum )));
  367.             return udp_release_and_return( packet, EINVAL );
  368.         }
  369.     }
  370.     // queue the received packet
  371.     if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
  372.         return udp_release_and_return( packet, ERROR_CODE );
  373.     }
  374.  
  375.     // notify the destination socket
  376.     async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) ( ** socket ).socket_id, ( ipcarg_t ) fragments );
  377.     return EOK;
  378. }
  379.  
  380. int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
  381.     ERROR_DECLARE;
  382.  
  383.     packet_t    packet;
  384.  
  385.     * answer_count = 0;
  386.     switch( IPC_GET_METHOD( * call )){
  387.         case NET_TL_RECEIVED:
  388.             fibril_rwlock_read_lock( & udp_globals.lock );
  389.             if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
  390.                 ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_UDP, IPC_GET_ERROR( call ));
  391.             }
  392.             fibril_rwlock_read_unlock( & udp_globals.lock );
  393.             return ERROR_CODE;
  394.         case IPC_M_CONNECT_TO_ME:
  395.             return udp_process_client_messages( callid, * call );
  396.     }
  397.     return ENOTSUP;
  398. }
  399.  
  400. int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call ){
  401.     int                     res;
  402.     bool                    keep_on_going = true;
  403.     socket_cores_t          local_sockets;
  404.     int                     app_phone = IPC_GET_PHONE( & call );
  405.     struct sockaddr *       addr;
  406.     size_t                  addrlen;
  407.     fibril_rwlock_t         lock;
  408.     ipc_call_t              answer;
  409.     int                     answer_count;
  410.  
  411.     /*
  412.      * Accept the connection
  413.      *  - Answer the first IPC_M_CONNECT_ME_TO call.
  414.      */
  415.     ipc_answer_0( callid, EOK );
  416.  
  417.     socket_cores_initialize( & local_sockets );
  418.     fibril_rwlock_initialize( & lock );
  419.  
  420.     while( keep_on_going ){
  421.         // refresh data
  422.         refresh_answer( & answer, & answer_count );
  423.  
  424.         callid = async_get_call( & call );
  425. //      printf( "message %d\n", IPC_GET_METHOD( * call ));
  426.  
  427.         switch( IPC_GET_METHOD( call )){
  428.             case IPC_M_PHONE_HUNGUP:
  429.                 keep_on_going = false;
  430.                 res = EOK;
  431.                 break;
  432.             case NET_SOCKET:
  433.                 fibril_rwlock_write_lock( & lock );
  434.                 res = socket_create( & local_sockets, app_phone, SOCKET_SET_SOCKET_ID( answer ));
  435.                 fibril_rwlock_write_unlock( & lock );
  436.                 * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
  437.                 * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
  438.                 answer_count = 3;
  439.                 break;
  440.             case NET_SOCKET_BIND:
  441.                 res = data_receive(( void ** ) & addr, & addrlen );
  442.                 if( res == EOK ){
  443.                     fibril_rwlock_write_lock( & lock );
  444.                     fibril_rwlock_write_lock( & udp_globals.lock );
  445.                     res = socket_bind( & local_sockets, & udp_globals.sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port );
  446.                     fibril_rwlock_write_unlock( & udp_globals.lock );
  447.                     fibril_rwlock_write_unlock( & lock );
  448.                     free( addr );
  449.                 }
  450.                 break;
  451.             case NET_SOCKET_SENDTO:
  452.                 res = data_receive(( void ** ) & addr, & addrlen );
  453.                 if( res == EOK ){
  454.                     fibril_rwlock_read_lock( & lock );
  455.                     fibril_rwlock_read_lock( & udp_globals.lock );
  456.                     res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
  457.                     fibril_rwlock_read_unlock( & udp_globals.lock );
  458.                     fibril_rwlock_read_unlock( & lock );
  459.                     free( addr );
  460.                 }
  461.                 break;
  462.             case NET_SOCKET_RECVFROM:
  463.                 fibril_rwlock_read_lock( & lock );
  464.                 fibril_rwlock_read_lock( & udp_globals.lock );
  465.                 res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ), & addrlen );
  466.                 fibril_rwlock_read_unlock( & udp_globals.lock );
  467.                 fibril_rwlock_read_unlock( & lock );
  468.                 if( res > 0 ){
  469.                     * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
  470.                     * SOCKET_SET_ADDRESS_LENGTH( answer ) = addrlen;
  471.                     answer_count = 2;
  472.                     res = EOK;
  473.                 }
  474.                 break;
  475.             case NET_SOCKET_CLOSE:
  476.                 fibril_rwlock_write_lock( & lock );
  477.                 fibril_rwlock_write_lock( & udp_globals.lock );
  478.                 res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets );
  479.                 fibril_rwlock_write_unlock( & udp_globals.lock );
  480.                 fibril_rwlock_write_unlock( & lock );
  481.                 break;
  482.             case NET_SOCKET_GETSOCKOPT:
  483.             case NET_SOCKET_SETSOCKOPT:
  484.             default:
  485.                 res = ENOTSUP;
  486.                 break;
  487.         }
  488.  
  489. //      printf( "res = %d\n", res );
  490.  
  491.         answer_call( callid, res, & answer, answer_count );
  492.     }
  493.  
  494.     socket_cores_destroy( & local_sockets );
  495.  
  496.     return EOK;
  497. }
  498.  
  499. int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, int flags ){
  500.     ERROR_DECLARE;
  501.  
  502.     socket_core_ref         socket;
  503.     struct sockaddr_in *    address_in;
  504.     struct sockaddr_in6 *   address_in6;
  505.     packet_t                packet;
  506.     packet_t                next_packet;
  507.     udp_header_ref          header;
  508.     int                     index;
  509.     size_t                  total_length;
  510.     int                     result;
  511.     uint16_t                dest_port;
  512.     uint32_t                checksum;
  513.     ip_pseudo_header_ref    ip_header;
  514.     size_t                  headerlen;
  515.     device_id_t             device_id;
  516.  
  517.     if( addrlen < sizeof( struct sockaddr )) return EINVAL;
  518.     switch( addr->sa_family ){
  519.         case AF_INET:
  520.             if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
  521.             address_in = ( struct sockaddr_in * ) addr;
  522.             dest_port = address_in->sin_port;
  523.             break;
  524.         case AF_INET6:
  525.             if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
  526.             address_in6 = ( struct sockaddr_in6 * ) addr;
  527.             dest_port = address_in6->sin6_port;
  528.             break;
  529.         default:
  530.             return EAFNOSUPPORT;
  531.     }
  532.  
  533.     socket = socket_cores_find( local_sockets, socket_id );
  534.     if( ! socket ) return ENOTSOCK;
  535.  
  536.     // bind the socket to a random free port if not bound
  537.     while( socket->port <= 0 ){
  538.         // try to find a free port
  539.         fibril_rwlock_read_unlock( & udp_globals.lock );
  540.         fibril_rwlock_write_lock( & udp_globals.lock );
  541.         if( socket->port <= 0 ){
  542.             ERROR_PROPAGATE( socket_bind_free_port( & udp_globals.sockets, socket, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port ));
  543.             // set the next port as the search starting port number
  544.             udp_globals.last_used_port = socket->port;
  545.         }
  546.         fibril_rwlock_write_unlock( & udp_globals.lock );
  547.         fibril_rwlock_read_lock( & udp_globals.lock );
  548.     }
  549.  
  550.     // TODO do not ask all the time
  551.     ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, socket->device_id, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
  552.  
  553.     // read the first packet fragment
  554.     result = socket_read_packet_data( & packet, sizeof( udp_header_t ), addr, addrlen );
  555.     if( result < 0 ) return result;
  556.     total_length = ( size_t ) result;
  557.     if( udp_globals.checksum_computing ){
  558.         checksum = compute_checksum( 0, packet_get_data( packet ), packet_get_data_length( packet ));
  559.     }else{
  560.         checksum = 0;
  561.     }
  562.     // prefix the udp header
  563.     header = PACKET_PREFIX( packet, udp_header_t );
  564.     if( ! header ){
  565.         return udp_release_and_return( packet, ENOMEM );
  566.     }
  567.     bzero( header, sizeof( * header ));
  568.     // read the rest of the packet fragments
  569.     for( index = 1; index < fragments; ++ index ){
  570.         result = socket_read_packet_data( & next_packet, 0, addr, addrlen );
  571.         if( result < 0 ){
  572.             return udp_release_and_return( packet, result );
  573.         }
  574.         packet = pq_add( packet, next_packet, index, 0 );
  575.         total_length += ( size_t ) result;
  576.         if( udp_globals.checksum_computing ){
  577.             checksum = compute_checksum( checksum, packet_get_data( next_packet ), packet_get_data_length( next_packet ));
  578.         }
  579.     }
  580.     // set the udp header
  581.     header->source = htons( socket->port );
  582.     header->dest = htons( dest_port );
  583.     header->len = htons( total_length + sizeof( udp_header_t ));
  584.     header->check = 0;
  585.     if( udp_globals.checksum_computing ){
  586.         if( ERROR_OCCURRED( ip_get_route_req( udp_globals.ip_phone, IPPROTO_UDP, addr, addrlen, & device_id, & ip_header, & headerlen ))){
  587.             return udp_release_and_return( packet, ERROR_CODE );
  588.         }
  589.         if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( ip_header, headerlen, total_length + sizeof( udp_header_t )))){
  590.             free( ip_header );
  591.             return udp_release_and_return( packet, ERROR_CODE );
  592.         }
  593. /*//        TODO remove debug dump:
  594.         uint8_t *   data;
  595.         data = ip_header;
  596.         printf( "ip_header:\tlength\t= %d\n\tdata\t= %.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX\n", headerlen, data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ], data[ 6 ], data[ 7 ], data[ 8 ], data[ 9 ], data[ 10 ], data[ 11 ] );
  597. */      checksum = compute_checksum( checksum, ip_header, headerlen );
  598.         checksum = compute_checksum( checksum, ( uint8_t * ) header, sizeof( * header ));
  599.         header->check = htons( flip_checksum( compact_checksum( checksum )));
  600.         free( ip_header );
  601.     }else{
  602.         device_id = socket->device_id;
  603.     }
  604.     // prepare the first packet fragment
  605.     if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_UDP, 0, 0, 0, 0 ))){
  606.         return udp_release_and_return( packet, ERROR_CODE );
  607.     }
  608.     // send the packet
  609.     return ip_send_msg( udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0 );
  610. }
  611.  
  612. int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen ){
  613.     ERROR_DECLARE;
  614.  
  615.     socket_core_ref socket;
  616.     int             packet_id;
  617.     packet_t        packet;
  618.     udp_header_ref  header;
  619.     struct sockaddr *   addr;
  620.     size_t          length;
  621.     packet_t        next_packet;
  622.     uint8_t *       data;
  623.     size_t          fragments;
  624.     size_t *        lengths;
  625.     size_t          index;
  626.     int             result;
  627.  
  628.     // find the socket
  629.     socket = socket_cores_find( local_sockets, socket_id );
  630.     if( ! socket ) return ENOTSOCK;
  631.     // get the next received packet
  632.     packet_id = dyn_fifo_value( & socket->received );
  633.     if( packet_id < 0 ) return NO_DATA;
  634.     ERROR_PROPAGATE( packet_translate( udp_globals.net_phone, & packet, packet_id ));
  635.     // get udp header
  636.     data = packet_get_data( packet );
  637.     if( ! data ){
  638.         pq_release( udp_globals.net_phone, packet_id );
  639.         return NO_DATA;
  640.     }
  641.     header = ( udp_header_ref ) data;
  642.  
  643.     // set the source address port
  644.     result = packet_get_addr( packet, ( uint8_t ** ) & addr, NULL );
  645.     if( ERROR_OCCURRED( udp_set_address_port( addr, result, ntohs( header->source )))){
  646.         pq_release( udp_globals.net_phone, packet_id );
  647.         return ERROR_CODE;
  648.     }
  649.     * addrlen = ( size_t ) result;
  650.     // send the source address
  651.     ERROR_PROPAGATE( data_reply( addr, * addrlen ));
  652.  
  653.     next_packet = pq_next( packet );
  654.     if( ! next_packet ){
  655.         // write all if only one fragment
  656.         ERROR_PROPAGATE( data_reply( data + sizeof( udp_header_t ), packet_get_data_length( packet ) - sizeof( udp_header_t )));
  657.         // store the total length
  658.         length = packet_get_data_length( packet ) - sizeof( udp_header_t );
  659.     }else{
  660.         // count the packet fragments
  661.         fragments = 1;
  662.         next_packet = pq_next( packet );
  663.         while(( next_packet = pq_next( next_packet ))){
  664.             ++ fragments;
  665.         }
  666.         // compute and store the fragment lengths
  667.         lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
  668.         if( ! lengths ) return ENOMEM;
  669.         lengths[ 0 ] = packet_get_data_length( packet ) - sizeof( udp_header_t );
  670.         lengths[ fragments ] = lengths[ 0 ];
  671.         next_packet = pq_next( packet );
  672.         for( index = 1; index < fragments; ++ index ){
  673.             lengths[ index ] = packet_get_data_length( next_packet );
  674.             lengths[ fragments ] += lengths[ index ];
  675.             next_packet = pq_next( packet );
  676.         }while( next_packet );
  677.         // write the fragment lengths
  678.         ERROR_PROPAGATE( data_reply( lengths, sizeof( int ) * ( fragments + 1 )));
  679.         // write the first fragment
  680.         ERROR_PROPAGATE( data_reply( data + sizeof( udp_header_t ), lengths[ 0 ] ));
  681.         next_packet = pq_next( packet );
  682.         // write the rest of the fragments
  683.         for( index = 1; index < fragments; ++ index ){
  684.             ERROR_PROPAGATE( data_reply( packet_get_data( next_packet ), lengths[ index ] ));
  685.             next_packet = pq_next( packet );
  686.         }while( next_packet );
  687.         // store the total length
  688.         length = lengths[ fragments ];
  689.         free( lengths );
  690.     }
  691.     // release the packet
  692.     dyn_fifo_pop( & socket->received );
  693.     pq_release( udp_globals.net_phone, packet_get_id( packet ));
  694.     // return the total length
  695.     return ( int ) length;
  696. }
  697.  
  698. int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen ){
  699.     ERROR_DECLARE;
  700.  
  701.     ipc_callid_t    callid;
  702.     size_t          length;
  703.     void *          data;
  704.  
  705.     // get the data length
  706.     if( ! ipc_data_write_receive( & callid, & length )) return EINVAL;
  707.     // get a new packet
  708.     * packet = packet_get_4( udp_globals.net_phone, length, udp_globals.addr_len, prefix + udp_globals.prefix, udp_globals.suffix );
  709.     if( ! packet ) return ENOMEM;
  710.     // allocate space in the packet
  711.     data = packet_suffix( * packet, length );
  712.     if( ! data ){
  713.         return udp_release_and_return( * packet, ENOMEM );
  714.     }
  715.     // read the data into the packet
  716.     if( ERROR_OCCURRED( ipc_data_write_finalize( callid, data, length ))
  717.     // set the packet destination address
  718.     || ERROR_OCCURRED( packet_set_addr( * packet, NULL, ( uint8_t * ) addr, addrlen ))){
  719.         return udp_release_and_return( * packet, ERROR_CODE );
  720.     }
  721.     return ( int ) length;
  722. }
  723.  
  724. int udp_release_and_return( packet_t packet, int result ){
  725.     pq_release( udp_globals.net_phone, packet_get_id( packet ));
  726.     return result;
  727. }
  728.  
  729. void udp_send_icmp_port_unreachable( packet_t packet, services_t error ){
  730.     packet_t    next;
  731.     uint8_t *   src;
  732.     int         length;
  733.  
  734.     // detach the first packet and release the others
  735.     next = pq_detach( packet );
  736.     if( next ){
  737.         pq_release( udp_globals.net_phone, packet_get_id( next ));
  738.     }
  739.     length = packet_get_addr( packet, & src, NULL );
  740.     if(( length > 0 )
  741.     && ( ! error )
  742.     && ( udp_globals.icmp_phone >= 0 )
  743.     // set both addresses to the source one (avoids the source address deletion before setting the destination one)
  744.     && ( packet_set_addr( packet, src, src, ( size_t ) length ) == EOK )){
  745.         icmp_destination_unreachable_msg( udp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
  746.     }else{
  747.         udp_release_and_return( packet, EINVAL );
  748.     }
  749. }
  750.  
  751. int udp_set_address_port( struct sockaddr * addr, int addrlen, uint16_t port ){
  752.     struct sockaddr_in *    address_in;
  753.     struct sockaddr_in6 *   address_in6;
  754.     size_t                  length;
  755.  
  756.     if( addrlen < 0 ) return EINVAL;
  757.     length = ( size_t ) addrlen;
  758.     if( length < sizeof( struct sockaddr )) return EINVAL;
  759.     switch( addr->sa_family ){
  760.         case AF_INET:
  761.             if( length != sizeof( struct sockaddr_in )) return EINVAL;
  762.             address_in = ( struct sockaddr_in * ) addr;
  763.             address_in->sin_port = port;
  764.             return EOK;
  765.         case AF_INET6:
  766.             if( length != sizeof( struct sockaddr_in6 )) return EINVAL;
  767.             address_in6 = ( struct sockaddr_in6 * ) addr;
  768.             address_in6->sin6_port = port;
  769.             return EOK;
  770.         default:
  771.             return EAFNOSUPPORT;
  772.     }
  773. }
  774.  
  775. /** @}
  776.  */
  777.