Subversion Repositories HelenOS

Rev

Rev 4700 | Rev 4708 | 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/in.h"
  54. #include "../../include/inet.h"
  55. #include "../../include/ip_client.h"
  56. #include "../../include/ip_interface.h"
  57. #include "../../include/ip_protocols.h"
  58. #include "../../include/socket.h"
  59. #include "../../include/socket_errno.h"
  60.  
  61. #include "../../socket/socket_core.h"
  62. #include "../../socket/socket_messages.h"
  63.  
  64. #include "../tl_messages.h"
  65.  
  66. #include "udp.h"
  67. #include "udp_header.h"
  68. #include "udp_module.h"
  69.  
  70. /** Maximum UDP fragment size.
  71.  */
  72. #define MAX_UDP_FRAGMENT_SIZE   65535
  73.  
  74. /** Free ports pool start.
  75.  */
  76. #define UDP_FREE_PORTS_START    1025
  77.  
  78. /** Free ports pool end.
  79.  */
  80. #define UDP_FREE_PORTS_END      65535
  81.  
  82. /** Processes the received UDP packet.
  83.  *  Is used as an entry point from the underlying IP module.
  84.  *  Releases the packet on error.
  85.  *  @param device_id The device identifier. Ignored parameter.
  86.  *  @param packet The received packet. Input/output parameter.
  87.  *  @param receiver The target service. Ignored parameter.
  88.  *  @returns EOK on success.
  89.  *  @returns Other error codes as defined for the udp_process_packet() function.
  90.  */
  91. int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver );
  92.  
  93. /** Processes the received UDP packet.
  94.  *  Notifies the destination socket application.
  95.  *  @param packet The received packet. Input/output parameter.
  96.  *  @returns EOK on success.
  97.  *  @returns EINVAL if the packet is not valid.
  98.  *  @returns EINVAL if the stored packet address is not the an_addr_t.
  99.  *  @returns EINVAL if the packet does not contain any data.
  100.  *  @returns NO_DATA if the packet content is shorter than the user datagram header.
  101.  *  @returns ENOMEM if there is not enough memory left.
  102.  *  @returns EADDRNOTAVAIL if the destination socket does not exist.
  103.  *  @returns Other error codes as defined for the ip_client_process_packet() function.
  104.  */
  105. int udp_process_packet( packet_t packet );
  106.  
  107. /** @name Socket messages processing functions
  108.  */
  109. /*@{*/
  110.  
  111. /** Processes the socket client messages.
  112.  *  Runs until the client module disconnects.
  113.  *  @param callid The message identifier. Input parameter.
  114.  *  @param call The message parameters. Input parameter.
  115.  *  @returns EOK on success.
  116.  *  @see socket.h
  117.  */
  118. int process_client_messages( ipc_callid_t callid, ipc_call_t call );
  119.  
  120. /** Sends data from the socket to the remote address.
  121.  *  Binds the socket to a free port if not already connected/bound.
  122.  *  Handles the NET_SOCKET_SENDTO message.
  123.  *  @param local_sockets The application local sockets. Input/output parameter.
  124.  *  @param socket_id Socket identifier. Input parameter.
  125.  *  @param addr The destination address. Input parameter.
  126.  *  @param addrlen The address length. Input parameter.
  127.  *  @param fragments The number of data fragments. Input parameter.
  128.  *  @param flags Various send flags. Input parameter.
  129.  *  @returns EOK on success.
  130.  *  @returns EAFNOTSUPPORT if the address family is not supported.
  131.  *  @returns ENOTSOCK if the socket is not found.
  132.  *  @returns EINVAL if the address is invalid.
  133.  *  @returns ENOTCONN if the sending socket is not and cannot be bound.
  134.  *  @returns ENOMEM if there is not enough memory left.
  135.  *  @returns Other error codes as defined for the socket_read_packet_data() function.
  136.  *  @returns Other error codes as defined for the ip_client_prepare_packet() function.
  137.  *  @returns Other error codes as defined for the ip_send_msg() function.
  138.  */
  139. int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, void * addr, size_t addrlen, int fragments, int flags );
  140.  
  141. /** Receives data to the socket.
  142.  *  Handles the NET_SOCKET_RECVFROM message.
  143.  *  @param local_sockets The application local sockets. Input parameter.
  144.  *  @param socket_id Socket identifier. Input parameter.
  145.  *  @param flags Various receive flags. Input parameter.
  146.  *  @returns The number of bytes received.
  147.  *  @returns ENOTSOCK if the socket is not found.
  148.  *  @returns NO_DATA if there are no received packets or data.
  149.  *  @returns ENOMEM if there is not enough memory left.
  150.  *  @returns EINVAL if the received address is not an IP address.
  151.  *  @returns Other error codes as defined for the packet_translate() function.
  152.  *  @returns Other error codes as defined for the socket_write_data() function.
  153.  */
  154. int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags );
  155.  
  156. /*@}*/
  157.  
  158. /** Receives data from the socket.
  159.  *  The received data buffer is allocated and returned.
  160.  *  @param data The data buffer to be filled. Output parameter.
  161.  *  @param length The buffer length. Output parameter.
  162.  *  @returns EOK on success.
  163.  *  @returns EBADMEM if the data or the length parameter is NULL.
  164.  *  @returns EINVAL if the client does not send data.
  165.  *  @returns ENOMEM if there is not enough memory left.
  166.  *  @returns Other error codes as defined for the ipc_data_write_finalize() function.
  167.  */
  168. int socket_read_data( void ** data, size_t * length );
  169.  
  170. /** Receives data from the socket into a packet.
  171.  *  @param packet The new created packet. Output parameter.
  172.  *  @param prefix Reserved packet data prefix length. Input parameter.
  173.  *  @param address_in The destination address to be set. Input parameter.
  174.  *  @returns Number of bytes received.
  175.  *  @returns EINVAL if the client does not send data.
  176.  *  @returns ENOMEM if there is not enough memory left.
  177.  *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
  178.  */
  179. int socket_read_packet_data( packet_ref packet, size_t prefix, struct sockaddr_in * address_in );
  180.  
  181. /** Replies the data to the socket.
  182.  *  @param data The data buffer to be sent. Input parameter.
  183.  *  @param data_length The buffer length. Input parameter.
  184.  *  @returns EOK on success.
  185.  *  @returns EINVAL if the client does not expect all the data.
  186.  *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
  187.  */
  188. int socket_write_data( void * data, size_t data_length );
  189.  
  190. /** UDP global data.
  191.  */
  192. udp_globals_t   udp_globals;
  193.  
  194. int udp_initialize( async_client_conn_t client_connection ){
  195.     ERROR_DECLARE;
  196.  
  197.     fibril_rwlock_initialize( & udp_globals.lock );
  198.     fibril_rwlock_write_lock( & udp_globals.lock );
  199.     udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );
  200.     if( udp_globals.ip_phone < 0 ){
  201.         return udp_globals.ip_phone;
  202.     }
  203.     ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
  204.     ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
  205.     udp_globals.prefix += sizeof( udp_header_t );
  206.     udp_globals.content -= sizeof( udp_header_t );
  207.     udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
  208.     fibril_rwlock_write_unlock( & udp_globals.lock );
  209.     return EOK;
  210. }
  211.  
  212. int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver ){
  213.     ERROR_DECLARE;
  214.  
  215.     if( ERROR_OCCURRED( udp_process_packet( packet ))){
  216.         pq_release( udp_globals.net_phone, packet_get_id( packet ));
  217.         return ERROR_CODE;
  218.     }
  219.  
  220.     return EOK;
  221. }
  222.  
  223. int udp_process_packet( packet_t packet ){
  224.     ERROR_DECLARE;
  225.  
  226.     uint8_t *       src;
  227.     uint8_t *       dest;
  228.     int             length;
  229.     void *          data;
  230.     udp_header_ref  header;
  231.     socket_core_ref *   socket;
  232.     packet_t        next_packet;
  233.     int             total_length;
  234. //  uint16_t        checksum;
  235.     int             fragments;
  236.     packet_t        tmp_packet;
  237.  
  238.     // get packet data
  239.     length = packet_get_addr( packet, & src, & dest );
  240.     if( length != sizeof( in_addr_t )) return EINVAL;
  241.     // TODO process received ipopts?
  242.     ERROR_PROPAGATE( ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL ));
  243.  
  244.     length = packet_get_data_length( packet );
  245.     if( length <= 0 ) return EINVAL;
  246.     if( length < sizeof( udp_header_t )) return NO_DATA;
  247.     data = packet_get_data( packet );
  248.     if( ! data ) return NO_DATA;
  249.     // get udp header
  250.     header = ( udp_header_ref ) data;
  251.     // find the destination socket
  252.     socket = socket_ports_find( & udp_globals.sockets, ntohs( header->dest ));
  253.     if( ! socket ) return EADDRNOTAVAIL;
  254.     // count the received packet fragments
  255.     next_packet = packet;
  256.     fragments = 0;
  257.     total_length = ntohs( header->len );
  258.     do{
  259.         ++ fragments;
  260.         length = packet_get_data_length( packet );
  261.         if( ! length ) return NO_DATA;
  262.         if( total_length < length ){
  263.             // cut of the suffix if too long
  264.             ERROR_PROPAGATE( packet_trim( next_packet, 0, length - total_length ));
  265.             // relese the rest of the packet fragments
  266.             tmp_packet = pq_next( next_packet );
  267.             while( tmp_packet ){
  268.                 next_packet = pq_detach( tmp_packet );
  269.                 pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
  270.                 tmp_packet = next_packet;
  271.             }
  272.             break;
  273.         }
  274.         total_length -= length;
  275.     /*  if( header->header_checksum ){
  276.         }
  277.     */
  278.     }while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
  279.     // queue the received packet
  280.     ERROR_PROPAGATE( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ));
  281.  
  282.     // notify the destination socket
  283.     async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ** socket ).socket_id, fragments );
  284.     return EOK;
  285. }
  286.  
  287. int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
  288.     ERROR_DECLARE;
  289.  
  290.     packet_t    packet;
  291.  
  292.     * answer_count = 0;
  293.     switch( IPC_GET_METHOD( * call )){
  294.         case NET_TL_RECEIVED:
  295.             fibril_rwlock_read_lock( & udp_globals.lock );
  296.             if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
  297.                 ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_UDP );
  298.             }
  299.             fibril_rwlock_read_unlock( & udp_globals.lock );
  300.             return ERROR_CODE;
  301.         case IPC_M_CONNECT_TO_ME:
  302.             return process_client_messages( callid, * call );
  303.     }
  304.     return ENOTSUP;
  305. }
  306.  
  307. int process_client_messages( ipc_callid_t callid, ipc_call_t call ){
  308.     ERROR_DECLARE;
  309.  
  310.     int                     res;
  311.     bool                    keep_on_going = true;
  312.     socket_cores_t          local_sockets;
  313.     int                     app_phone = IPC_GET_PHONE( & call );
  314.     void *                  addr;
  315.     size_t                  addrlen;
  316.     fibril_rwlock_t         lock;
  317.     ipc_call_t              answer;
  318.     int                     answer_count;
  319.  
  320.     /*
  321.      * Accept the connection
  322.      *  - Answer the first IPC_M_CONNECT_ME_TO call.
  323.      */
  324.     ipc_answer_0( callid, EOK );
  325.  
  326.     socket_cores_initialize( & local_sockets );
  327.     fibril_rwlock_initialize( & lock );
  328.  
  329.     while( keep_on_going ){
  330.         // refresh data
  331.         answer_count = 0;
  332.         IPC_SET_RETVAL( answer, 0 );
  333.         // just to be precize
  334.         IPC_SET_METHOD( answer, 0 );
  335.         IPC_SET_ARG1( answer, 0 );
  336.         IPC_SET_ARG2( answer, 0 );
  337.         IPC_SET_ARG3( answer, 0 );
  338.         IPC_SET_ARG4( answer, 0 );
  339.         IPC_SET_ARG5( answer, 0 );
  340.  
  341.         callid = async_get_call( & call );
  342. //      printf( "message %d\n", IPC_GET_METHOD( * call ));
  343.  
  344.         switch( IPC_GET_METHOD( call )){
  345.             case IPC_M_PHONE_HUNGUP:
  346.                 keep_on_going = false;
  347.                 res = EOK;
  348.                 break;
  349.             case NET_SOCKET:
  350.                 fibril_rwlock_write_lock( & lock );
  351.                 res = socket_create( & local_sockets, app_phone, SOCKET_SET_SOCKET_ID( answer ));
  352.                 fibril_rwlock_write_unlock( & lock );
  353.                 * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
  354.                 * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
  355.                 answer_count = 3;
  356.                 break;
  357.             case NET_SOCKET_BIND:
  358.                 if( ERROR_OCCURRED( socket_read_data( & addr, & addrlen ))){
  359.                     res = ERROR_CODE;
  360.                     break;
  361.                 }
  362.                 fibril_rwlock_write_lock( & lock );
  363.                 fibril_rwlock_write_lock( & udp_globals.lock );
  364.                 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 );
  365.                 fibril_rwlock_write_unlock( & udp_globals.lock );
  366.                 fibril_rwlock_write_unlock( & lock );
  367.                 free( addr );
  368.                 break; 
  369.             case NET_SOCKET_SENDTO:
  370.                 if( ERROR_OCCURRED( socket_read_data( & addr, & addrlen ))){
  371.                     res = ERROR_CODE;
  372.                     break;
  373.                 }
  374.                 fibril_rwlock_read_lock( & lock );
  375.                 fibril_rwlock_read_lock( & udp_globals.lock );
  376.                 res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
  377.                 fibril_rwlock_read_unlock( & udp_globals.lock );
  378.                 fibril_rwlock_read_unlock( & lock );
  379.                 free( addr );
  380.                 break;
  381.             case NET_SOCKET_RECVFROM:
  382.                 fibril_rwlock_read_lock( & lock );
  383.                 fibril_rwlock_read_lock( & udp_globals.lock );
  384.                 res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ));
  385.                 fibril_rwlock_read_unlock( & udp_globals.lock );
  386.                 fibril_rwlock_read_unlock( & lock );
  387.                 if( res > 0 ){
  388.                     * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
  389.                     * SOCKET_SET_ADDRESS_LENGTH( answer ) = sizeof( struct sockaddr_in );
  390.                     answer_count = 2;
  391.                     res = EOK;
  392.                 }
  393.                 break;
  394.             case NET_SOCKET_CLOSE:
  395.                 fibril_rwlock_write_lock( & lock );
  396.                 fibril_rwlock_write_lock( & udp_globals.lock );
  397.                 res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets );
  398.                 fibril_rwlock_write_unlock( & udp_globals.lock );
  399.                 fibril_rwlock_write_unlock( & lock );
  400.                 break;
  401.             case NET_SOCKET_GETSOCKOPT:
  402.             case NET_SOCKET_SETSOCKOPT:
  403.             default:
  404.                 res = ENOTSUP;
  405.                 break;
  406.         }
  407.  
  408. //      printf( "res = %d\n", res );
  409.  
  410.         switch( answer_count ){
  411.             case 0:     ipc_answer_0( callid, res );
  412.                     continue;
  413.             case 1:     ipc_answer_1( callid, res, IPC_GET_ARG1( answer ));
  414.                     continue;
  415.             case 2:     ipc_answer_2( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ));
  416.                     continue;
  417.             case 3:     ipc_answer_3( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ));
  418.                     continue;
  419.             case 4:     ipc_answer_4( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ));
  420.                     continue;
  421.             default:    ipc_answer_5( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ), IPC_GET_ARG5( answer ));
  422.                     continue;
  423.         }
  424.     }
  425.  
  426.     socket_cores_destroy( & local_sockets );
  427.  
  428.     return EOK;
  429. }
  430.  
  431. int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, void * addr, size_t addrlen, int fragments, int flags ){
  432.     ERROR_DECLARE;
  433.  
  434.     socket_core_ref         socket;
  435.     struct sockaddr *       address;
  436.     struct sockaddr_in *    address_in;
  437.     packet_t                packet;
  438.     packet_t                next_packet;
  439.     udp_header_ref          header;
  440.     int                     index;
  441.     int                     total_length;
  442.     int                     length;
  443.  
  444.     if( addrlen < sizeof( struct sockaddr )) return EINVAL;
  445.     address = ( struct sockaddr * ) addr;
  446.     switch( address->sa_family ){
  447.         case AF_INET:
  448.             if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
  449.             address_in = ( struct sockaddr_in * ) addr;
  450.             socket = socket_cores_find( local_sockets, socket_id );
  451.             if( ! socket ) return ENOTSOCK;
  452.  
  453.             // bind the socket to a random free port if not bound
  454.             if( socket->port <= 0 ){
  455.                 // try to find a free port
  456.                 fibril_rwlock_read_unlock( & udp_globals.lock );
  457.                 fibril_rwlock_write_lock( & udp_globals.lock );
  458.                 ERROR_PROPAGATE( socket_bind_free_port( & udp_globals.sockets, socket, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port ));
  459.                 fibril_rwlock_write_unlock( & udp_globals.lock );
  460.                 fibril_rwlock_read_lock( & udp_globals.lock );
  461.                 // set the next port as the search starting port number
  462.                 udp_globals.last_used_port = socket->port;
  463.             }
  464.             // TODO do not ask all the time
  465.             ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
  466.  
  467.             // read the first packet fragment
  468.             total_length = socket_read_packet_data( & packet, sizeof( udp_header_t ), address_in );
  469.             if( total_length < 0 ) return total_length;
  470.             // prefix the udp header
  471.             header = PACKET_PREFIX( packet, udp_header_t );
  472.             if( ! header ){
  473.                 pq_release( udp_globals.net_phone, packet_get_id( packet ));
  474.                 return ENOMEM;
  475.             }
  476.             // read the rest of the packet fragments
  477.             for( index = 1; index < fragments; ++ index ){
  478.                 length = socket_read_packet_data( & next_packet, 0, address_in );
  479.                 if( length < 0 ){
  480.                     pq_release( udp_globals.net_phone, packet_get_id( packet ));
  481.                     return length;
  482.                 }
  483.                 packet = pq_add( packet, next_packet, index, 0 );
  484.                 total_length += length;
  485.             }
  486.             // set the udp header
  487.             header->source = ( socket->port < 0 ) ? 0 : htons( socket->port );
  488.             header->dest = htons( address_in->sin_port );
  489.             header->len = htons( total_length + sizeof( udp_header_t ));
  490.             // TODO my ip address for the pseudo header checksum
  491.             header->check = 0;
  492.             // prepare the first packet fragment
  493.             if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_UDP, 0, 0, 0, 0 ))){
  494.                 pq_release( udp_globals.net_phone, packet_get_id( packet ));
  495.                 return ERROR_CODE;
  496.             }
  497.             // send the packet
  498.             return ip_send_msg( udp_globals.ip_phone, socket->device_id, packet, SERVICE_UDP );
  499.         // TODO IPv6
  500.         default:
  501.             return EAFNOSUPPORT;
  502.     }
  503.     return EOK;
  504. }
  505.  
  506. int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags ){
  507.     ERROR_DECLARE;
  508.  
  509.     socket_core_ref socket;
  510.     int             packet_id;
  511.     packet_t        packet;
  512.     udp_header_ref  header;
  513.     struct sockaddr_in      address;
  514.     int             length;
  515.     packet_t        next_packet;
  516.     void *          data;
  517.     int             fragments;
  518.     int *           lengths;
  519.     int             index;
  520.     uint8_t *       addr;
  521.  
  522.     // find the socket
  523.     socket = socket_cores_find( local_sockets, socket_id );
  524.     if( ! socket ) return ENOTSOCK;
  525.     // get the next received packet
  526.     packet_id = dyn_fifo_value( & socket->received );
  527.     if( packet_id < 0 ) return NO_DATA;
  528.     ERROR_PROPAGATE( packet_translate( udp_globals.net_phone, & packet, packet_id ));
  529.     // get udp header
  530.     data = packet_get_data( packet );
  531.     if( ! data ){
  532.         pq_release( udp_globals.net_phone, packet_id );
  533.         return NO_DATA;
  534.     }
  535.     header = ( udp_header_ref ) data;
  536.     // set the source address
  537.     address.sin_family = PF_INET;
  538.     address.sin_port = ntohs( header->source );
  539.     length = packet_get_addr( packet, & addr, NULL );
  540.     if( length != sizeof( address.sin_addr.s_addr )){
  541.         pq_release( udp_globals.net_phone, packet_id );
  542.         return EINVAL;
  543.     }
  544.     address.sin_addr.s_addr = *(( uint32_t * ) addr );
  545.     bzero( & address.sin_zero, sizeof( address.sin_zero ));
  546.     // send the source address
  547.     ERROR_PROPAGATE( socket_write_data( & address, sizeof( address )));
  548.     next_packet = pq_next( packet );
  549.     if( ! next_packet ){
  550.         // write all if only one fragment
  551.         ERROR_PROPAGATE( socket_write_data( data + sizeof( udp_header_t ), packet_get_data_length( packet ) - sizeof( udp_header_t )));
  552.         // store the total length
  553.         length = packet_get_data_length( packet ) - sizeof( udp_header_t );
  554.     }else{
  555.         // count the packet fragments
  556.         fragments = 1;
  557.         next_packet = pq_next( packet );
  558.         while(( next_packet = pq_next( next_packet ))){
  559.             ++ fragments;
  560.         }
  561.         // compute and store the fragment lengths
  562.         lengths = ( int * ) malloc( sizeof( int ) * ( fragments + 1 ));
  563.         if( ! lengths ) return ENOMEM;
  564.         lengths[ 0 ] = packet_get_data_length( packet ) - sizeof( udp_header_t );
  565.         lengths[ fragments ] = lengths[ 0 ];
  566.         next_packet = pq_next( packet );
  567.         for( index = 1; index < fragments; ++ index ){
  568.             lengths[ index ] = packet_get_data_length( next_packet );
  569.             lengths[ fragments ] += lengths[ index ];
  570.             next_packet = pq_next( packet );
  571.         }while( next_packet );
  572.         // write the fragment lengths
  573.         ERROR_PROPAGATE( socket_write_data( lengths, sizeof( int ) * ( fragments + 1 )));
  574.         // write the first fragment
  575.         ERROR_PROPAGATE( socket_write_data( data + sizeof( udp_header_t ), lengths[ 0 ] ));
  576.         next_packet = pq_next( packet );
  577.         // write the rest of the fragments
  578.         for( index = 1; index < fragments; ++ index ){
  579.             ERROR_PROPAGATE( socket_write_data( packet_get_data( next_packet ), lengths[ index ] ));
  580.             next_packet = pq_next( packet );
  581.         }while( next_packet );
  582.         // store the total length
  583.         length = lengths[ fragments ];
  584.         free( lengths );
  585.     }
  586.     // release the packet
  587.     dyn_fifo_pop( & socket->received );
  588.     pq_release( udp_globals.net_phone, packet_get_id( packet ));
  589.     // return the total length
  590.     return length;
  591. }
  592.  
  593. int socket_write_data( void * data, size_t data_length ){
  594.     size_t          length;
  595.     ipc_callid_t    callid;
  596.  
  597.     if(( ! ipc_data_read_receive( & callid, & length ))
  598.     || ( length < data_length )){
  599.         return EINVAL;
  600.     }
  601.     return ipc_data_read_finalize( callid, data, data_length );
  602. }
  603.  
  604. int socket_read_data( void ** data, size_t * length ){
  605.     ERROR_DECLARE;
  606.  
  607.     ipc_callid_t    callid;
  608.  
  609.     if( !( data && length )) return EBADMEM;
  610.     if( ! ipc_data_write_receive( & callid, length )) return EINVAL;
  611.     * data = malloc( * length );
  612.     if( !( * data )) return ENOMEM;
  613.     if( ERROR_OCCURRED( ipc_data_write_finalize( callid, * data, * length ))){
  614.         free( data );
  615.         return ERROR_CODE;
  616.     }
  617.     return EOK;
  618. }
  619.  
  620. int socket_read_packet_data( packet_ref packet, size_t prefix, struct sockaddr_in * address_in ){
  621.     ERROR_DECLARE;
  622.  
  623.     ipc_callid_t    callid;
  624.     size_t          length;
  625.     void *          data;
  626.  
  627.     // get the data length
  628.     if( ! ipc_data_write_receive( & callid, & length )) return EINVAL;
  629.     // get a new packet
  630.     * packet = packet_get_4( udp_globals.net_phone, length, udp_globals.addr_len, prefix + udp_globals.prefix, udp_globals.suffix );
  631.     if( ! packet ) return ENOMEM;
  632.     // allocate space in the packet
  633.     data = packet_suffix( * packet, length );
  634.     if( ! data ){
  635.         pq_release( udp_globals.net_phone, packet_get_id( * packet ));
  636.         return ENOMEM;
  637.     }
  638.     // read the data into the packet
  639.     if( ERROR_OCCURRED( ipc_data_write_finalize( callid, data, length ))
  640.     // set the packet destination address
  641.     || ERROR_OCCURRED( packet_set_addr( * packet, NULL, ( uint8_t * ) & address_in->sin_addr.s_addr, sizeof( address_in->sin_addr.s_addr )))){
  642.         pq_release( udp_globals.net_phone, packet_get_id( * packet ));
  643.         return ERROR_CODE;
  644.     }
  645.     return length;
  646. }
  647.  
  648. /** @}
  649.  */
  650.