Subversion Repositories HelenOS

Rev

Rev 4743 | 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. #include <stdio.h>
  42.  
  43. #include <ipc/ipc.h>
  44. #include <ipc/services.h>
  45.  
  46. #include "../../err.h"
  47. #include "../../messages.h"
  48. #include "../../modules.h"
  49.  
  50. #include "../../structures/dynamic_fifo.h"
  51. #include "../../structures/packet/packet_client.h"
  52.  
  53. #include "../../include/checksum.h"
  54. #include "../../include/in.h"
  55. #include "../../include/in6.h"
  56. #include "../../include/inet.h"
  57. #include "../../include/ip_client.h"
  58. #include "../../include/ip_interface.h"
  59. #include "../../include/ip_protocols.h"
  60. #include "../../include/icmp_client.h"
  61. #include "../../include/icmp_interface.h"
  62. #include "../../include/net_interface.h"
  63. #include "../../include/socket_codes.h"
  64. #include "../../include/socket_errno.h"
  65.  
  66. #include "../../socket/socket_core.h"
  67. #include "../../socket/socket_messages.h"
  68.  
  69. #include "../tl_common.h"
  70. #include "../tl_messages.h"
  71.  
  72. #include "udp.h"
  73. #include "udp_header.h"
  74. #include "udp_module.h"
  75.  
  76. /** Default UDP checksum computing.
  77.  */
  78. #define NET_DEFAULT_UDP_CHECKSUM_COMPUTING  true
  79.  
  80. /** Default UDP autobind when sending via unbound sockets.
  81.  */
  82. #define NET_DEFAULT_UDP_AUTOBINDING true
  83.  
  84. /** Maximum UDP fragment size.
  85.  */
  86. #define MAX_UDP_FRAGMENT_SIZE   65535
  87.  
  88. /** Free ports pool start.
  89.  */
  90. #define UDP_FREE_PORTS_START    1025
  91.  
  92. /** Free ports pool end.
  93.  */
  94. #define UDP_FREE_PORTS_END      65535
  95.  
  96. /** Processes the received UDP packet queue.
  97.  *  Is used as an entry point from the underlying IP module.
  98.  *  Locks the global lock and calls udp_process_packet() function.
  99.  *  @param device_id The device identifier. Ignored parameter.
  100.  *  @param packet The received packet queue. Input/output parameter.
  101.  *  @param receiver The target service. Ignored parameter.
  102.  *  @param error The packet error reporting service. Prefixes the received packet. Input parameter.
  103.  *  @returns EOK on success.
  104.  *  @returns Other error codes as defined for the udp_process_packet() function.
  105.  */
  106. int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );
  107.  
  108. /** Processes the received UDP packet queue.
  109.  *  Notifies the destination socket application.
  110.  *  Releases the packet on error or sends an ICMP error notification..
  111.  *  @param packet The received packet queue. Input/output parameter.
  112.  *  @param error The packet error reporting service. Prefixes the received packet. Input parameter.
  113.  *  @returns EOK on success.
  114.  *  @returns EINVAL if the packet is not valid.
  115.  *  @returns EINVAL if the stored packet address is not the an_addr_t.
  116.  *  @returns EINVAL if the packet does not contain any data.
  117.  *  @returns NO_DATA if the packet content is shorter than the user datagram header.
  118.  *  @returns ENOMEM if there is not enough memory left.
  119.  *  @returns EADDRNOTAVAIL if the destination socket does not exist.
  120.  *  @returns Other error codes as defined for the ip_client_process_packet() function.
  121.  */
  122. int udp_process_packet( packet_t packet, services_t error );
  123.  
  124. /** Releases the packet and returns the result.
  125.  *  @param packet The packet queue to be released. Input parameter.
  126.  *  @param result The result to be returned. Input parameter.
  127.  *  @return The result parameter.
  128.  */
  129. int udp_release_and_return( packet_t packet, int result );
  130.  
  131. /** @name Socket messages processing functions
  132.  */
  133. /*@{*/
  134.  
  135. /** Processes the socket client messages.
  136.  *  Runs until the client module disconnects.
  137.  *  @param callid The message identifier. Input parameter.
  138.  *  @param call The message parameters. Input parameter.
  139.  *  @returns EOK on success.
  140.  *  @see socket.h
  141.  */
  142. int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call );
  143.  
  144. /** Sends data from the socket to the remote address.
  145.  *  Binds the socket to a free port if not already connected/bound.
  146.  *  Handles the NET_SOCKET_SENDTO message.
  147.  *  Supports AF_INET and AF_INET6 address families.
  148.  *  @param local_sockets The application local sockets. Input/output parameter.
  149.  *  @param socket_id Socket identifier. Input parameter.
  150.  *  @param addr The destination address. Input parameter.
  151.  *  @param addrlen The address length. Input parameter.
  152.  *  @param fragments The number of data fragments. Input parameter.
  153.  *  @param data_fragment_size The data fragment size in bytes. Input parameter.
  154.  *  @param flags Various send flags. Input parameter.
  155.  *  @returns EOK on success.
  156.  *  @returns EAFNOTSUPPORT if the address family is not supported.
  157.  *  @returns ENOTSOCK if the socket is not found.
  158.  *  @returns EINVAL if the address is invalid.
  159.  *  @returns ENOTCONN if the sending socket is not and cannot be bound.
  160.  *  @returns ENOMEM if there is not enough memory left.
  161.  *  @returns Other error codes as defined for the socket_read_packet_data() function.
  162.  *  @returns Other error codes as defined for the ip_client_prepare_packet() function.
  163.  *  @returns Other error codes as defined for the ip_send_msg() function.
  164.  */
  165. int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, size_t data_fragment_size, int flags );
  166.  
  167. /** Receives data to the socket.
  168.  *  Handles the NET_SOCKET_RECVFROM message.
  169.  *  Replies the source address as well.
  170.  *  @param local_sockets The application local sockets. Input parameter.
  171.  *  @param socket_id Socket identifier. Input parameter.
  172.  *  @param flags Various receive flags. Input parameter.
  173.  *  @param addrlen The source address length. Output parameter.
  174.  *  @returns The number of bytes received.
  175.  *  @returns ENOTSOCK if the socket is not found.
  176.  *  @returns NO_DATA if there are no received packets or data.
  177.  *  @returns ENOMEM if there is not enough memory left.
  178.  *  @returns EINVAL if the received address is not an IP address.
  179.  *  @returns Other error codes as defined for the packet_translate() function.
  180.  *  @returns Other error codes as defined for the data_reply() function.
  181.  */
  182. int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
  183.  
  184. /*@}*/
  185.  
  186. /** UDP global data.
  187.  */
  188. udp_globals_t   udp_globals;
  189.  
  190. int udp_initialize( async_client_conn_t client_connection ){
  191.     ERROR_DECLARE;
  192.  
  193.     measured_string_t   names[] = {{ "UDP_CHECKSUM_COMPUTING", 22 }, { "UDP_AUTOBINDING", 15 }};
  194.     measured_string_ref configuration;
  195.     size_t              count = sizeof( names ) / sizeof( measured_string_t );
  196.     char *              data;
  197.  
  198.     fibril_rwlock_initialize( & udp_globals.lock );
  199.     fibril_rwlock_write_lock( & udp_globals.lock );
  200.     udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
  201.     if( udp_globals.icmp_phone < 0 ){
  202.         return udp_globals.icmp_phone;
  203.     }
  204.     udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );
  205.     if( udp_globals.ip_phone < 0 ){
  206.         return udp_globals.ip_phone;
  207.     }
  208.     // read default packet dimensions
  209.     ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.packet_dimension.addr_len, & udp_globals.packet_dimension.prefix, & udp_globals.packet_dimension.content, & udp_globals.packet_dimension.suffix ));
  210.     ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
  211.     if( ERROR_OCCURRED( packet_dimensions_initialize( & udp_globals.dimensions ))){
  212.         socket_ports_destroy( & udp_globals.sockets );
  213.         return ERROR_CODE;
  214.     }
  215.     udp_globals.packet_dimension.prefix += sizeof( udp_header_t );
  216.     udp_globals.packet_dimension.content -= sizeof( udp_header_t );
  217.     udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
  218.     // get configuration
  219.     udp_globals.checksum_computing = NET_DEFAULT_UDP_CHECKSUM_COMPUTING;
  220.     udp_globals.autobinding = NET_DEFAULT_UDP_AUTOBINDING;
  221.     configuration = & names[ 0 ];
  222.     ERROR_PROPAGATE( net_get_conf_req( udp_globals.net_phone, & configuration, count, & data ));
  223.     if( configuration ){
  224.         if( configuration[ 0 ].value ){
  225.             udp_globals.checksum_computing = ( configuration[ 0 ].value[ 0 ] == 'y' );
  226.         }
  227.         if( configuration[ 1 ].value ){
  228.             udp_globals.autobinding = ( configuration[ 1 ].value[ 0 ] == 'y' );
  229.         }
  230.         net_free_settings( configuration, data );
  231.     }
  232.     fibril_rwlock_write_unlock( & udp_globals.lock );
  233.     return EOK;
  234. }
  235.  
  236. int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
  237.     int result;
  238.  
  239.     fibril_rwlock_write_lock( & udp_globals.lock );
  240.     result = udp_process_packet( packet, error );
  241.     if( result != EOK ){
  242.         fibril_rwlock_write_unlock( & udp_globals.lock );
  243.     }
  244.  
  245.     return result;
  246. }
  247.  
  248. int udp_process_packet( packet_t packet, services_t error ){
  249.     ERROR_DECLARE;
  250.  
  251.     size_t          length;
  252.     size_t          offset;
  253.     int             result;
  254.     udp_header_ref  header;
  255.     socket_core_ref socket;
  256.     packet_t        next_packet;
  257.     size_t          total_length;
  258.     uint32_t        checksum;
  259.     int             fragments;
  260.     packet_t        tmp_packet;
  261.     icmp_type_t     type;
  262.     icmp_code_t     code;
  263.     ip_pseudo_header_ref    ip_header;
  264.     struct sockaddr *       src;
  265.     struct sockaddr *       dest;
  266.  
  267.     if( error ){
  268.         switch( error ){
  269.             case SERVICE_ICMP:
  270.                 // ignore error
  271.                 // length = icmp_client_header_length( packet );
  272.                 // process error
  273.                 result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
  274.                 if( result < 0 ){
  275.                     return udp_release_and_return( packet, result );
  276.                 }
  277.                 length = ( size_t ) result;
  278.                 if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
  279.                     return udp_release_and_return( packet, ERROR_CODE );
  280.                 }
  281.                 break;
  282.             default:
  283.                 return udp_release_and_return( packet, ENOTSUP );
  284.         }
  285.     }
  286.     // TODO process received ipopts?
  287.     result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
  288.     if( result < 0 ){
  289.         return udp_release_and_return( packet, result );
  290.     }
  291.     offset = ( size_t ) result;
  292.  
  293.     length = packet_get_data_length( packet );
  294.     if( length <= 0 ){
  295.         return udp_release_and_return( packet, EINVAL );
  296.     }
  297.     if( length < sizeof( udp_header_t ) + offset ){
  298.         return udp_release_and_return( packet, NO_DATA );
  299.     }
  300.  
  301.     // trim all but UDP header
  302.     if( ERROR_OCCURRED( packet_trim( packet, offset, 0 ))){
  303.         return udp_release_and_return( packet, ERROR_CODE );
  304.     }
  305.  
  306.     // get udp header
  307.     header = ( udp_header_ref ) packet_get_data( packet );
  308.     if( ! header ){
  309.         return udp_release_and_return( packet, NO_DATA );
  310.     }
  311.     // find the destination socket
  312.     socket = socket_port_find( & udp_globals.sockets, ntohs( header->destination_port ), SOCKET_MAP_KEY_LISTENING, 0 );
  313.     if( ! socket ){
  314.         if( tl_prepare_icmp_packet( udp_globals.net_phone, udp_globals.icmp_phone, packet, error ) == EOK ){
  315.             icmp_destination_unreachable_msg( udp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
  316.         }
  317.         return EADDRNOTAVAIL;
  318.     }
  319.  
  320.     // count the received packet fragments
  321.     next_packet = packet;
  322.     fragments = 0;
  323.     total_length = ntohs( header->total_length );
  324.     // compute header checksum if set
  325.     if( header->checksum && ( ! error )){
  326.         result = packet_get_addr( packet, ( uint8_t ** ) & src, ( uint8_t ** ) & dest );
  327.         if( result <= 0 ){
  328.             return udp_release_and_return( packet, result );
  329.         }
  330.         if( ERROR_OCCURRED( ip_client_get_pseudo_header( IPPROTO_UDP, src, result, dest, result, total_length, & ip_header, & length ))){
  331.             return udp_release_and_return( packet, ERROR_CODE );
  332.         }else{
  333.             checksum = compute_checksum( 0, ip_header, length );
  334.             // the udp header checksum will be added with the first fragment later
  335.             free( ip_header );
  336.         }
  337.     }else{
  338.         header->checksum = 0;
  339.         checksum = 0;
  340.     }
  341.  
  342.     do{
  343.         ++ fragments;
  344.         length = packet_get_data_length( next_packet );
  345.         if( length <= 0 ){
  346.             return udp_release_and_return( packet, NO_DATA );
  347.         }
  348.         if( total_length < length ){
  349.             if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
  350.                 return udp_release_and_return( packet, ERROR_CODE );
  351.             }
  352.             // add partial checksum if set
  353.             if( header->checksum ){
  354.                 checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
  355.             }
  356.             // relese the rest of the packet fragments
  357.             tmp_packet = pq_next( next_packet );
  358.             while( tmp_packet ){
  359.                 next_packet = pq_detach( tmp_packet );
  360.                 pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
  361.                 tmp_packet = next_packet;
  362.             }
  363.             // exit the loop
  364.             break;
  365.         }
  366.         total_length -= length;
  367.         // add partial checksum if set
  368.         if( header->checksum ){
  369.             checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
  370.         }
  371.     }while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
  372.  
  373.     // check checksum
  374.     if( header->checksum ){
  375.         if( flip_checksum( compact_checksum( checksum ))){
  376.             if( tl_prepare_icmp_packet( udp_globals.net_phone, udp_globals.icmp_phone, packet, error ) == EOK ){
  377.                 // checksum error ICMP
  378.                 icmp_parameter_problem_msg( udp_globals.icmp_phone, ICMP_PARAM_POINTER, (( size_t ) (( void * ) & header->checksum )) - (( size_t ) (( void * ) header )), packet );
  379.             }
  380.             return EINVAL;
  381.         }
  382.     }
  383.  
  384.     // queue the received packet
  385.     if( ERROR_OCCURRED( dyn_fifo_push( & socket->received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
  386.         return udp_release_and_return( packet, ERROR_CODE );
  387.     }
  388.  
  389.     // notify the destination socket
  390.     fibril_rwlock_write_unlock( & udp_globals.lock );
  391.     async_msg_5( socket->phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) socket->socket_id, 0, 0, 0, ( ipcarg_t ) fragments );
  392.     return EOK;
  393. }
  394.  
  395. int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
  396.     ERROR_DECLARE;
  397.  
  398.     packet_t    packet;
  399.  
  400.     * answer_count = 0;
  401.     switch( IPC_GET_METHOD( * call )){
  402.         case NET_TL_RECEIVED:
  403.             if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
  404.                 ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_UDP, IPC_GET_ERROR( call ));
  405.             }
  406.             return ERROR_CODE;
  407.         case IPC_M_CONNECT_TO_ME:
  408.             return udp_process_client_messages( callid, * call );
  409.     }
  410.     return ENOTSUP;
  411. }
  412.  
  413. int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call ){
  414.     int                     res;
  415.     bool                    keep_on_going = true;
  416.     socket_cores_t          local_sockets;
  417.     int                     app_phone = IPC_GET_PHONE( & call );
  418.     struct sockaddr *       addr;
  419.     size_t                  addrlen;
  420.     fibril_rwlock_t         lock;
  421.     ipc_call_t              answer;
  422.     int                     answer_count;
  423.  
  424.     /*
  425.      * Accept the connection
  426.      *  - Answer the first IPC_M_CONNECT_TO_ME call.
  427.      */
  428.     ipc_answer_0( callid, EOK );
  429.  
  430.     // The client connection is only in one fibril and therefore no additional locks are needed.
  431.  
  432.     socket_cores_initialize( & local_sockets );
  433.     fibril_rwlock_initialize( & lock );
  434.  
  435.     while( keep_on_going ){
  436.         // refresh data
  437.         refresh_answer( & answer, & answer_count );
  438.  
  439.         callid = async_get_call( & call );
  440. //      printf( "message %d\n", IPC_GET_METHOD( * call ));
  441.  
  442.         switch( IPC_GET_METHOD( call )){
  443.             case IPC_M_PHONE_HUNGUP:
  444.                 keep_on_going = false;
  445.                 res = EOK;
  446.                 break;
  447.             case NET_SOCKET:
  448.                 fibril_rwlock_write_lock( & lock );
  449.                 res = socket_create( & local_sockets, app_phone, NULL, SOCKET_SET_SOCKET_ID( answer ));
  450.                 fibril_rwlock_write_unlock( & lock );
  451.                 // TODO max fragment size
  452.                 * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
  453.                 * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
  454.                 answer_count = 3;
  455.                 break;
  456.             case NET_SOCKET_BIND:
  457.                 res = data_receive(( void ** ) & addr, & addrlen );
  458.                 if( res == EOK ){
  459.                     fibril_rwlock_read_lock( & lock );
  460.                     fibril_rwlock_write_lock( & udp_globals.lock );
  461.                     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 );
  462.                     fibril_rwlock_write_unlock( & udp_globals.lock );
  463.                     fibril_rwlock_read_unlock( & lock );
  464.                     free( addr );
  465.                 }
  466.                 break;
  467.             case NET_SOCKET_SENDTO:
  468.                 res = data_receive(( void ** ) & addr, & addrlen );
  469.                 if( res == EOK ){
  470.                     fibril_rwlock_read_lock( & lock );
  471.                     fibril_rwlock_write_lock( & udp_globals.lock );
  472.                     res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_DATA_FRAGMENT_SIZE( call ), SOCKET_GET_FLAGS( call ));
  473.                     if( res != EOK ){
  474.                         fibril_rwlock_write_unlock( & udp_globals.lock );
  475.                     }
  476.                     fibril_rwlock_read_unlock( & lock );
  477.                     free( addr );
  478.                 }
  479.                 break;
  480.             case NET_SOCKET_RECVFROM:
  481.                 fibril_rwlock_read_lock( & lock );
  482.                 fibril_rwlock_write_lock( & udp_globals.lock );
  483.                 res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ), & addrlen );
  484.                 fibril_rwlock_write_unlock( & udp_globals.lock );
  485.                 fibril_rwlock_read_unlock( & lock );
  486.                 if( res > 0 ){
  487.                     * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
  488.                     * SOCKET_SET_ADDRESS_LENGTH( answer ) = addrlen;
  489.                     answer_count = 2;
  490.                     res = EOK;
  491.                 }
  492.                 break;
  493.             case NET_SOCKET_CLOSE:
  494.                 fibril_rwlock_write_lock( & lock );
  495.                 fibril_rwlock_write_lock( & udp_globals.lock );
  496.                 res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets, NULL );
  497.                 fibril_rwlock_write_unlock( & udp_globals.lock );
  498.                 fibril_rwlock_write_unlock( & lock );
  499.                 break;
  500.             case NET_SOCKET_GETSOCKOPT:
  501.             case NET_SOCKET_SETSOCKOPT:
  502.             default:
  503.                 res = ENOTSUP;
  504.                 break;
  505.         }
  506.  
  507. //      printf( "res = %d\n", res );
  508.  
  509.         answer_call( callid, res, & answer, answer_count );
  510.     }
  511.  
  512.     // release all local sockets
  513.     socket_cores_release( udp_globals.net_phone, & local_sockets, & udp_globals.sockets, NULL );
  514.  
  515.     return EOK;
  516. }
  517.  
  518. int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, size_t data_fragment_size, int flags ){
  519.     ERROR_DECLARE;
  520.  
  521.     socket_core_ref         socket;
  522.     packet_t                packet;
  523.     packet_t                next_packet;
  524.     udp_header_ref          header;
  525.     int                     index;
  526.     size_t                  total_length;
  527.     int                     result;
  528.     uint16_t                dest_port;
  529.     uint32_t                checksum;
  530.     ip_pseudo_header_ref    ip_header;
  531.     size_t                  headerlen;
  532.     device_id_t             device_id;
  533.     packet_dimension_ref    packet_dimension;
  534.  
  535.     ERROR_PROPAGATE( tl_get_address_port( addr, addrlen, & dest_port ));
  536.  
  537.     socket = socket_cores_find( local_sockets, socket_id );
  538.     if( ! socket ) return ENOTSOCK;
  539.  
  540.     if(( socket->port <= 0 ) && udp_globals.autobinding ){
  541.         // bind the socket to a random free port if not bound
  542. //      do{
  543.             // try to find a free port
  544. //          fibril_rwlock_read_unlock( & udp_globals.lock );
  545. //          fibril_rwlock_write_lock( & udp_globals.lock );
  546.             // might be changed in the meantime
  547. //          if( socket->port <= 0 ){
  548.                 if( ERROR_OCCURRED( socket_bind_free_port( & udp_globals.sockets, socket, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port ))){
  549. //                  fibril_rwlock_write_unlock( & udp_globals.lock );
  550. //                  fibril_rwlock_read_lock( & udp_globals.lock );
  551.                     return ERROR_CODE;
  552.                 }
  553.                 // set the next port as the search starting port number
  554.                 udp_globals.last_used_port = socket->port;
  555. //          }
  556. //          fibril_rwlock_write_unlock( & udp_globals.lock );
  557. //          fibril_rwlock_read_lock( & udp_globals.lock );
  558.             // might be changed in the meantime
  559. //      }while( socket->port <= 0 );
  560.     }
  561.  
  562.     if( udp_globals.checksum_computing ){
  563.         if( ERROR_OCCURRED( ip_get_route_req( udp_globals.ip_phone, IPPROTO_UDP, addr, addrlen, & device_id, & ip_header, & headerlen ))){
  564.             return udp_release_and_return( packet, ERROR_CODE );
  565.         }
  566.         // get the device packet dimension
  567. //      ERROR_PROPAGATE( tl_get_ip_packet_dimension( udp_globals.ip_phone, & udp_globals.dimensions, device_id, & packet_dimension ));
  568.     }
  569. //  }else{
  570.         // do not ask all the time
  571.         ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.packet_dimension.addr_len, & udp_globals.packet_dimension.prefix, & udp_globals.packet_dimension.content, & udp_globals.packet_dimension.suffix ));
  572.         packet_dimension = & udp_globals.packet_dimension;
  573. //  }
  574.  
  575.     // read the first packet fragment
  576.     result = tl_socket_read_packet_data( udp_globals.net_phone, & packet, sizeof( udp_header_t ), packet_dimension, addr, addrlen );
  577.     if( result < 0 ) return result;
  578.     total_length = ( size_t ) result;
  579.     if( udp_globals.checksum_computing ){
  580.         checksum = compute_checksum( 0, packet_get_data( packet ), packet_get_data_length( packet ));
  581.     }else{
  582.         checksum = 0;
  583.     }
  584.     // prefix the udp header
  585.     header = PACKET_PREFIX( packet, udp_header_t );
  586.     if( ! header ){
  587.         return udp_release_and_return( packet, ENOMEM );
  588.     }
  589.     bzero( header, sizeof( * header ));
  590.     // read the rest of the packet fragments
  591.     for( index = 1; index < fragments; ++ index ){
  592.         result = tl_socket_read_packet_data( udp_globals.net_phone, & next_packet, 0, packet_dimension, addr, addrlen );
  593.         if( result < 0 ){
  594.             return udp_release_and_return( packet, result );
  595.         }
  596.         packet = pq_add( packet, next_packet, index, 0 );
  597.         total_length += ( size_t ) result;
  598.         if( udp_globals.checksum_computing ){
  599.             checksum = compute_checksum( checksum, packet_get_data( next_packet ), packet_get_data_length( next_packet ));
  600.         }
  601.     }
  602.     // set the udp header
  603.     header->source_port = htons(( socket->port > 0 ) ? socket->port : 0 );
  604.     header->destination_port = htons( dest_port );
  605.     header->total_length = htons( total_length + sizeof( * header ));
  606.     header->checksum = 0;
  607.     if( udp_globals.checksum_computing ){
  608. //      if( ERROR_OCCURRED( ip_get_route_req( udp_globals.ip_phone, IPPROTO_UDP, addr, addrlen, & device_id, & ip_header, & headerlen ))){
  609. //          return udp_release_and_return( packet, ERROR_CODE );
  610. //      }
  611.         if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( ip_header, headerlen, total_length + sizeof( udp_header_t )))){
  612.             free( ip_header );
  613.             return udp_release_and_return( packet, ERROR_CODE );
  614.         }
  615.         checksum = compute_checksum( checksum, ip_header, headerlen );
  616.         checksum = compute_checksum( checksum, ( uint8_t * ) header, sizeof( * header ));
  617.         header->checksum = htons( flip_checksum( compact_checksum( checksum )));
  618.         free( ip_header );
  619.     }else{
  620.         device_id = -1;
  621.     }
  622.     // prepare the first packet fragment
  623.     if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_UDP, 0, 0, 0, 0 ))){
  624.         return udp_release_and_return( packet, ERROR_CODE );
  625.     }
  626.     // send the packet
  627.     fibril_rwlock_write_unlock( & udp_globals.lock );
  628.     ip_send_msg( udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0 );
  629.     return EOK;
  630. }
  631.  
  632. int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen ){
  633.     ERROR_DECLARE;
  634.  
  635.     socket_core_ref socket;
  636.     int             packet_id;
  637.     packet_t        packet;
  638.     udp_header_ref  header;
  639.     struct sockaddr *   addr;
  640.     size_t          length;
  641.     uint8_t *       data;
  642.     int             result;
  643.  
  644.     // find the socket
  645.     socket = socket_cores_find( local_sockets, socket_id );
  646.     if( ! socket ) return ENOTSOCK;
  647.     // get the next received packet
  648.     packet_id = dyn_fifo_value( & socket->received );
  649.     if( packet_id < 0 ) return NO_DATA;
  650.     ERROR_PROPAGATE( packet_translate( udp_globals.net_phone, & packet, packet_id ));
  651.     // get udp header
  652.     data = packet_get_data( packet );
  653.     if( ! data ){
  654.         pq_release( udp_globals.net_phone, packet_id );
  655.         return NO_DATA;
  656.     }
  657.     header = ( udp_header_ref ) data;
  658.  
  659.     // set the source address port
  660.     result = packet_get_addr( packet, ( uint8_t ** ) & addr, NULL );
  661.     if( ERROR_OCCURRED( tl_set_address_port( addr, result, ntohs( header->source_port )))){
  662.         pq_release( udp_globals.net_phone, packet_id );
  663.         return ERROR_CODE;
  664.     }
  665.     * addrlen = ( size_t ) result;
  666.     // send the source address
  667.     ERROR_PROPAGATE( data_reply( addr, * addrlen ));
  668.  
  669.     // trim the header
  670.     ERROR_PROPAGATE( packet_trim( packet, sizeof( udp_header_t ), 0 ));
  671.  
  672.     // reply the packets
  673.     ERROR_PROPAGATE( socket_reply_packets( packet, & length ));
  674.  
  675.     // release the packet
  676.     dyn_fifo_pop( & socket->received );
  677.     pq_release( udp_globals.net_phone, packet_get_id( packet ));
  678.     // return the total length
  679.     return ( int ) length;
  680. }
  681.  
  682. int udp_release_and_return( packet_t packet, int result ){
  683.     pq_release( udp_globals.net_phone, packet_get_id( packet ));
  684.     return result;
  685. }
  686.  
  687. /** @}
  688.  */
  689.