WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/tl/udp/udp.c


/*
 * Copyright (c) 2008 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup udp
 *  @{
 */
 
/** @file
 *  UDP module implementation.
 *  @see udp.h
 */
 
#include <async.h>
#include <fibril_sync.h>
#include <malloc.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../structures/dynamic_fifo.h"
#include "../../structures/packet/packet_client.h"
 
#include "../../include/in.h"
#include "../../include/in6.h"
#include "../../include/inet.h"
#include "../../include/ip_client.h"
#include "../../include/ip_interface.h"
#include "../../include/ip_protocols.h"
#include "../../include/icmp_client.h"
#include "../../include/icmp_interface.h"
#include "../../include/socket_codes.h"
#include "../../include/socket_errno.h"
 
#include "../../socket/socket_core.h"
#include "../../socket/socket_messages.h"
 
#include "../tl_messages.h"
 
#include "udp.h"
#include "udp_header.h"
#include "udp_module.h"
 
/** Maximum UDP fragment size.
 */
#define MAX_UDP_FRAGMENT_SIZE   65535
 
/** Free ports pool start.
 */
#define UDP_FREE_PORTS_START    1025
 
/** Free ports pool end.
 */
#define UDP_FREE_PORTS_END      65535
 
/** Processes the received UDP packet queue.
 *  Is used as an entry point from the underlying IP module.
 *  Notifies the destination socket application.
 *  Releases the packet on error or send an ICMP error notification..
 *  @param device_id The device identifier. Ignored parameter.
 *  @param packet The received packet queue. Input/output parameter.
 *  @param receiver The target service. Ignored parameter.
 *  @param error The packet error reporting service. Prefixes the received packet. Input parameter.
 *  @returns EOK on success.
 *  @returns EINVAL if the packet is not valid.
 *  @returns EINVAL if the stored packet address is not the an_addr_t.
 *  @returns EINVAL if the packet does not contain any data.
 *  @returns NO_DATA if the packet content is shorter than the user datagram header.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns EADDRNOTAVAIL if the destination socket does not exist.
 *  @returns Other error codes as defined for the ip_client_process_packet() function.
 */
int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );
 
/** Releases the packet and returns the result.
 *  @param packet The packet queue to be released. Input parameter.
 *  @param result The result to be returned. Input parameter.
 *  @return The result parameter.
 */
int udp_release_and_return( packet_t packet, int result );
 
/** Sends the port unreachable ICMP notification.
 *  Sends the first packet and releases all the others.
 *  Releases the packet queu on error.
 *  @param packet The packet to be send. Input parameter.
 *  @param error The packet error reporting service. Prefixes the received packet. Input parameter.
 */
void    udp_send_icmp_port_unreachable( packet_t packet, services_t error );
 
/** @name Socket messages processing functions
 */
/*@{*/
 
/** Processes the socket client messages.
 *  Runs until the client module disconnects.
 *  @param callid The message identifier. Input parameter.
 *  @param call The message parameters. Input parameter.
 *  @returns EOK on success.
 *  @see socket.h
 */
int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call );
 
/** Sends data from the socket to the remote address.
 *  Binds the socket to a free port if not already connected/bound.
 *  Handles the NET_SOCKET_SENDTO message.
 *  Supports AF_INET and AF_INET6 address families.
 *  @param local_sockets The application local sockets. Input/output parameter.
 *  @param socket_id Socket identifier. Input parameter.
 *  @param addr The destination address. Input parameter.
 *  @param addrlen The address length. Input parameter.
 *  @param fragments The number of data fragments. Input parameter.
 *  @param flags Various send flags. Input parameter.
 *  @returns EOK on success.
 *  @returns EAFNOTSUPPORT if the address family is not supported.
 *  @returns ENOTSOCK if the socket is not found.
 *  @returns EINVAL if the address is invalid.
 *  @returns ENOTCONN if the sending socket is not and cannot be bound.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns Other error codes as defined for the socket_read_packet_data() function.
 *  @returns Other error codes as defined for the ip_client_prepare_packet() function.
 *  @returns Other error codes as defined for the ip_send_msg() function.
 */
int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, int flags );
 
/** Receives data to the socket.
 *  Handles the NET_SOCKET_RECVFROM message.
 *  Replies the source address as well.
 *  @param local_sockets The application local sockets. Input parameter.
 *  @param socket_id Socket identifier. Input parameter.
 *  @param flags Various receive flags. Input parameter.
 *  @param addrlen The source address length. Output parameter.
 *  @returns The number of bytes received.
 *  @returns ENOTSOCK if the socket is not found.
 *  @returns NO_DATA if there are no received packets or data.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns EINVAL if the received address is not an IP address.
 *  @returns Other error codes as defined for the packet_translate() function.
 *  @returns Other error codes as defined for the socket_write_data() function.
 */
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
 
/*@}*/
 
/** Receives data from the socket.
 *  The received data buffer is allocated and returned.
 *  @param data The data buffer to be filled. Output parameter.
 *  @param length The buffer length. Output parameter.
 *  @returns EOK on success.
 *  @returns EBADMEM if the data or the length parameter is NULL.
 *  @returns EINVAL if the client does not send data.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns Other error codes as defined for the ipc_data_write_finalize() function.
 */
int socket_read_data( void ** data, size_t * length );
 
/** Receives data from the socket into a packet.
 *  @param packet The new created packet. Output parameter.
 *  @param prefix Reserved packet data prefix length. Input parameter.
 *  @param addr The destination address. Input parameter.
 *  @param addrlen The address length. Input parameter.
 *  @returns Number of bytes received.
 *  @returns EINVAL if the client does not send data.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
 */
int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen );
 
/** Replies the data to the socket.
 *  @param data The data buffer to be sent. Input parameter.
 *  @param data_length The buffer length. Input parameter.
 *  @returns EOK on success.
 *  @returns EINVAL if the client does not expect all the data.
 *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
 */
int socket_write_data( void * data, size_t data_length );
 
/** Sets the address port.
 *  Supports AF_INET and AF_INET6 address families.
 *  @param addr The address to be updated. Input/output parameter.
 *  @param addrlen The address length. Input parameter.
 *  @param port The port to be set. Input parameter.
 *  @returns EOK on success.
 *  @returns EINVAL if the address length does not match the address family.
 *  @returns EAFNOSUPPORT if the address family is not supported.
 */
int udp_set_address_port( struct sockaddr * addr, int addrlen, uint16_t port );
 
/** UDP global data.
 */
udp_globals_t   udp_globals;
 
int udp_initialize( async_client_conn_t client_connection ){
    ERROR_DECLARE;
 
    fibril_rwlock_initialize( & udp_globals.lock );
    fibril_rwlock_write_lock( & udp_globals.lock );
    udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
    if( udp_globals.icmp_phone < 0 ){
        return udp_globals.icmp_phone;
    }
    udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );
    if( udp_globals.ip_phone < 0 ){
        return udp_globals.ip_phone;
    }
    ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
    ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
    udp_globals.prefix += sizeof( udp_header_t );
    udp_globals.content -= sizeof( udp_header_t );
    udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
    fibril_rwlock_write_unlock( & udp_globals.lock );
    return EOK;
}
 
int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
    ERROR_DECLARE;
 
    size_t          length;
    size_t          offset;
    int             result;
    uint8_t *       data;
    udp_header_ref  header;
    socket_core_ref *   socket;
    packet_t        next_packet;
    size_t          total_length;
//  uint16_t        checksum;
    int             fragments;
    packet_t        tmp_packet;
    icmp_type_t     type;
    icmp_code_t     code;
 
    if( error ){
        switch( error ){
            case SERVICE_ICMP:
                // process error
                // TODO remove debug dump
                // length = icmp_client_header_length( packet );
                result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
                if( result < 0 ){
                    return udp_release_and_return( packet, result );
                }
                printf( "ICMP error %d (%d) in packet %d\n", type, code, packet_get_id( packet ) );
                length = ( size_t ) result;
                if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
                    return udp_release_and_return( packet, ERROR_CODE );
                }
                break;
            default:
                return udp_release_and_return( packet, ENOTSUP );
        }
    }
    // TODO process received ipopts?
    result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
    if( result < 0 ){
        return udp_release_and_return( packet, result );
    }
    offset = ( size_t ) result;
 
    length = packet_get_data_length( packet );
    if( length <= 0 ){
        return udp_release_and_return( packet, EINVAL );
    }
    if( length < sizeof( udp_header_t ) + offset ){
        return udp_release_and_return( packet, NO_DATA );
    }
    data = packet_get_data( packet );
    if( ! data ){
        return udp_release_and_return( packet, NO_DATA );
    }
    // get udp header
    header = ( udp_header_ref )( data + offset );
    // find the destination socket
    socket = socket_ports_find( & udp_globals.sockets, ntohs( header->dest ));
    if( ! socket ){
        udp_send_icmp_port_unreachable( packet, error );
        return EADDRNOTAVAIL;
    }
    // trim after successful processing to be able to send an ICMP error message!
    ERROR_PROPAGATE( packet_trim( packet, offset, 0 ));
    // count the received packet fragments
    next_packet = packet;
    fragments = 0;
    total_length = ntohs( header->len );
    do{
        ++ fragments;
        length = packet_get_data_length( packet );
        if( length <= 0 ){
            return udp_release_and_return( packet, NO_DATA );
        }
        if( total_length < length ){
            // cut of the suffix if too long
            if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
                return udp_release_and_return( packet, ERROR_CODE );
            }
            // relese the rest of the packet fragments
            tmp_packet = pq_next( next_packet );
            while( tmp_packet ){
                next_packet = pq_detach( tmp_packet );
                pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
                tmp_packet = next_packet;
            }
            break;
        }
        total_length -= length;
    /*  if( header->header_checksum ){
        }
    */
    }while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
    // queue the received packet
    if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
        return udp_release_and_return( packet, ERROR_CODE );
    }
 
    // notify the destination socket
    async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) ( ** socket ).socket_id, ( ipcarg_t ) fragments );
    return EOK;
}
 
int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    ERROR_DECLARE;
 
    packet_t    packet;
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case NET_TL_RECEIVED:
            fibril_rwlock_read_lock( & udp_globals.lock );
            if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
                ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_UDP, IPC_GET_ERROR( call ));
            }
            fibril_rwlock_read_unlock( & udp_globals.lock );
            return ERROR_CODE;
        case IPC_M_CONNECT_TO_ME:
            return udp_process_client_messages( callid, * call );
    }
    return ENOTSUP;
}
 
int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call ){
    int                     res;
    bool                    keep_on_going = true;
    socket_cores_t          local_sockets;
    int                     app_phone = IPC_GET_PHONE( & call );
    struct sockaddr *       addr;
    size_t                  addrlen;
    fibril_rwlock_t         lock;
    ipc_call_t              answer;
    int                     answer_count;
 
    /*
     * Accept the connection
     *  - Answer the first IPC_M_CONNECT_ME_TO call.
     */
    ipc_answer_0( callid, EOK );
 
    socket_cores_initialize( & local_sockets );
    fibril_rwlock_initialize( & lock );
 
    while( keep_on_going ){
        // refresh data
        refresh_answer( & answer, & answer_count );
 
        callid = async_get_call( & call );
//      printf( "message %d\n", IPC_GET_METHOD( * call ));
 
        switch( IPC_GET_METHOD( call )){
            case IPC_M_PHONE_HUNGUP:
                keep_on_going = false;
                res = EOK;
                break;
            case NET_SOCKET:
                fibril_rwlock_write_lock( & lock );
                res = socket_create( & local_sockets, app_phone, SOCKET_SET_SOCKET_ID( answer ));
                fibril_rwlock_write_unlock( & lock );
                * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
                * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
                answer_count = 3;
                break;
            case NET_SOCKET_BIND:
                res = socket_read_data(( void ** ) & addr, & addrlen );
                if( res == EOK ){
                    fibril_rwlock_write_lock( & lock );
                    fibril_rwlock_write_lock( & udp_globals.lock );
                    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 );
                    fibril_rwlock_write_unlock( & udp_globals.lock );
                    fibril_rwlock_write_unlock( & lock );
                    free( addr );
                }
                break;
            case NET_SOCKET_SENDTO:
                res = socket_read_data(( void ** ) & addr, & addrlen );
                if( res == EOK ){
                    fibril_rwlock_read_lock( & lock );
                    fibril_rwlock_read_lock( & udp_globals.lock );
                    res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
                    fibril_rwlock_read_unlock( & udp_globals.lock );
                    fibril_rwlock_read_unlock( & lock );
                    free( addr );
                }
                break;
            case NET_SOCKET_RECVFROM:
                fibril_rwlock_read_lock( & lock );
                fibril_rwlock_read_lock( & udp_globals.lock );
                res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ), & addrlen );
                fibril_rwlock_read_unlock( & udp_globals.lock );
                fibril_rwlock_read_unlock( & lock );
                if( res > 0 ){
                    * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
                    * SOCKET_SET_ADDRESS_LENGTH( answer ) = addrlen;
                    answer_count = 2;
                    res = EOK;
                }
                break;
            case NET_SOCKET_CLOSE:
                fibril_rwlock_write_lock( & lock );
                fibril_rwlock_write_lock( & udp_globals.lock );
                res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets );
                fibril_rwlock_write_unlock( & udp_globals.lock );
                fibril_rwlock_write_unlock( & lock );
                break;
            case NET_SOCKET_GETSOCKOPT:
            case NET_SOCKET_SETSOCKOPT:
            default:
                res = ENOTSUP;
                break;
        }
 
//      printf( "res = %d\n", res );
 
        answer_call( callid, res, & answer, answer_count );
    }
 
    socket_cores_destroy( & local_sockets );
 
    return EOK;
}
 
int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, int flags ){
    ERROR_DECLARE;
 
    socket_core_ref         socket;
 
    struct sockaddr_in *    address_in;
    struct sockaddr_in6 *   address_in6;
    packet_t                packet;
    packet_t                next_packet;
    udp_header_ref          header;
    int                     index;
    size_t                  total_length;
    int                     result;
    uint16_t                dest_port;
 
    if( addrlen < sizeof( struct sockaddr )) return EINVAL;
 
    switch( addr->sa_family ){
        case AF_INET:
            if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
            address_in = ( struct sockaddr_in * ) addr;
            dest_port = address_in->sin_port;
            break;
        case AF_INET6:
            if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
            address_in6 = ( struct sockaddr_in6 * ) addr;
            dest_port = address_in6->sin6_port;
            break;
        default:
            return EAFNOSUPPORT;
    }
 
 
 
 
 
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
 
 
 
 
 
 
 
 
 
 
    // bind the socket to a random free port if not bound
 
    while( socket->port <= 0 ){
        // try to find a free port
        fibril_rwlock_read_unlock( & udp_globals.lock );
        fibril_rwlock_write_lock( & udp_globals.lock );
        if( socket->port <= 0 ){
            ERROR_PROPAGATE( socket_bind_free_port( & udp_globals.sockets, socket, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END, udp_globals.last_used_port ));
 
 
            // set the next port as the search starting port number
 
 
 
            udp_globals.last_used_port = socket->port;
        }
        fibril_rwlock_write_unlock( & udp_globals.lock );
        fibril_rwlock_read_lock( & udp_globals.lock );
    }
 
    // TODO do not ask all the time
    ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
 
    // read the first packet fragment
    result = socket_read_packet_data( & packet, sizeof( udp_header_t ), addr, addrlen );
    if( result < 0 ) return result;
    total_length = ( size_t ) result;
    // prefix the udp header
 
    header = PACKET_PREFIX( packet, udp_header_t );
 
 
    if( ! header ){
        pq_release( udp_globals.net_phone, packet_get_id( packet ));
        return ENOMEM;
    }
    // read the rest of the packet fragments
    for( index = 1; index < fragments; ++ index ){
        result = socket_read_packet_data( & next_packet, 0, addr, addrlen );
        if( result < 0 ){
            return udp_release_and_return( packet, result );
        }
        packet = pq_add( packet, next_packet, index, 0 );
        total_length += ( size_t ) result;
    }
    // set the udp header
    header->source = htons( socket->port );
    header->dest = htons( dest_port );
    header->len = htons( total_length + sizeof( udp_header_t ));
    // TODO my ip address for the pseudo header checksum
    header->check = 0;
    // prepare the first packet fragment
    if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_UDP, 0, 0, 0, 0 ))){
        pq_release( udp_globals.net_phone, packet_get_id( packet ));
        return ERROR_CODE;
    }
    // send the packet
    return ip_send_msg( udp_globals.ip_phone, socket->device_id, packet, SERVICE_UDP, 0 );
}
 
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen ){
    ERROR_DECLARE;
 
    socket_core_ref socket;
    int             packet_id;
    packet_t        packet;
    udp_header_ref  header;
    struct sockaddr *   addr;
    size_t          length;
    packet_t        next_packet;
    uint8_t *       data;
    size_t          fragments;
    size_t *        lengths;
 
    size_t          index;
    int             result;
 
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    // get the next received packet
    packet_id = dyn_fifo_value( & socket->received );
    if( packet_id < 0 ) return NO_DATA;
    ERROR_PROPAGATE( packet_translate( udp_globals.net_phone, & packet, packet_id ));
    // get udp header
    data = packet_get_data( packet );
    if( ! data ){
        pq_release( udp_globals.net_phone, packet_id );
        return NO_DATA;
    }
    header = ( udp_header_ref ) data;
 
    // set the source address port
 
 
    result = packet_get_addr( packet, ( uint8_t ** ) & addr, NULL );
    if( ERROR_OCCURRED( udp_set_address_port( addr, result, ntohs( header->source )))){
        pq_release( udp_globals.net_phone, packet_id );
        return ERROR_CODE;
    }
    * addrlen = ( size_t ) result;
 
    // send the source address
    ERROR_PROPAGATE( socket_write_data( addr, * addrlen ));
 
    next_packet = pq_next( packet );
    if( ! next_packet ){
        // write all if only one fragment
        ERROR_PROPAGATE( socket_write_data( data + sizeof( udp_header_t ), packet_get_data_length( packet ) - sizeof( udp_header_t )));
        // store the total length
        length = packet_get_data_length( packet ) - sizeof( udp_header_t );
    }else{
        // count the packet fragments
        fragments = 1;
        next_packet = pq_next( packet );
        while(( next_packet = pq_next( next_packet ))){
            ++ fragments;
        }
        // compute and store the fragment lengths
        lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
        if( ! lengths ) return ENOMEM;
        lengths[ 0 ] = packet_get_data_length( packet ) - sizeof( udp_header_t );
        lengths[ fragments ] = lengths[ 0 ];
        next_packet = pq_next( packet );
        for( index = 1; index < fragments; ++ index ){
            lengths[ index ] = packet_get_data_length( next_packet );
            lengths[ fragments ] += lengths[ index ];
            next_packet = pq_next( packet );
        }while( next_packet );
        // write the fragment lengths
        ERROR_PROPAGATE( socket_write_data( lengths, sizeof( int ) * ( fragments + 1 )));
        // write the first fragment
        ERROR_PROPAGATE( socket_write_data( data + sizeof( udp_header_t ), lengths[ 0 ] ));
        next_packet = pq_next( packet );
        // write the rest of the fragments
        for( index = 1; index < fragments; ++ index ){
            ERROR_PROPAGATE( socket_write_data( packet_get_data( next_packet ), lengths[ index ] ));
            next_packet = pq_next( packet );
        }while( next_packet );
        // store the total length
        length = lengths[ fragments ];
        free( lengths );
    }
    // release the packet
    dyn_fifo_pop( & socket->received );
    pq_release( udp_globals.net_phone, packet_get_id( packet ));
    // return the total length
    return ( int ) length;
}
 
int socket_write_data( void * data, size_t data_length ){
    size_t          length;
    ipc_callid_t    callid;
 
    if(( ! ipc_data_read_receive( & callid, & length ))
    || ( length < data_length )){
        return EINVAL;
    }
    return ipc_data_read_finalize( callid, data, data_length );
}
 
int socket_read_data( void ** data, size_t * length ){
    ERROR_DECLARE;
 
    ipc_callid_t    callid;
 
    if( !( data && length )) return EBADMEM;
    if( ! ipc_data_write_receive( & callid, length )) return EINVAL;
    * data = malloc( * length );
    if( !( * data )) return ENOMEM;
    if( ERROR_OCCURRED( ipc_data_write_finalize( callid, * data, * length ))){
        free( data );
        return ERROR_CODE;
    }
    return EOK;
}
 
int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen ){
    ERROR_DECLARE;
 
    ipc_callid_t    callid;
    size_t          length;
    void *          data;
 
    // get the data length
    if( ! ipc_data_write_receive( & callid, & length )) return EINVAL;
    // get a new packet
    * packet = packet_get_4( udp_globals.net_phone, length, udp_globals.addr_len, prefix + udp_globals.prefix, udp_globals.suffix );
    if( ! packet ) return ENOMEM;
    // allocate space in the packet
    data = packet_suffix( * packet, length );
    if( ! data ){
        pq_release( udp_globals.net_phone, packet_get_id( * packet ));
        return ENOMEM;
    }
    // read the data into the packet
    if( ERROR_OCCURRED( ipc_data_write_finalize( callid, data, length ))
    // set the packet destination address
    || ERROR_OCCURRED( packet_set_addr( * packet, NULL, ( uint8_t * ) addr, addrlen ))){
        pq_release( udp_globals.net_phone, packet_get_id( * packet ));
        return ERROR_CODE;
    }
    return ( int ) length;
}
 
int udp_release_and_return( packet_t packet, int result ){
    pq_release( udp_globals.net_phone, packet_get_id( packet ));
    return result;
}
 
void udp_send_icmp_port_unreachable( packet_t packet, services_t error ){
    packet_t    next;
    uint8_t *   src;
    int         length;
 
    // detach the first packet and release the others
    next = pq_detach( packet );
    if( next ){
        pq_release( udp_globals.net_phone, packet_get_id( next ));
    }
    length = packet_get_addr( packet, & src, NULL );
    if(( length > 0 )
    && ( ! error )
    && ( udp_globals.icmp_phone >= 0 )
    // set both addresses to the source one (avoids the source address deletion before setting the destination one)
    && ( packet_set_addr( packet, src, src, ( size_t ) length ) == EOK )){
        icmp_destination_unreachable_msg( udp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
    }else{
        udp_release_and_return( packet, EINVAL );
    }
}
 
int udp_set_address_port( struct sockaddr * addr, int addrlen, uint16_t port ){
    struct sockaddr_in *    address_in;
    struct sockaddr_in6 *   address_in6;
    size_t                  length;
 
    if( addrlen < 0 ) return EINVAL;
    length = ( size_t ) addrlen;
    if( length < sizeof( struct sockaddr )) return EINVAL;
    switch( addr->sa_family ){
        case AF_INET:
            if( length != sizeof( struct sockaddr_in )) return EINVAL;
            address_in = ( struct sockaddr_in * ) addr;
            address_in->sin_port = port;
            return EOK;
        case AF_INET6:
            if( length != sizeof( struct sockaddr_in6 )) return EINVAL;
            address_in6 = ( struct sockaddr_in6 * ) addr;
            address_in6->sin6_port = port;
            return EOK;
        default:
            return EAFNOSUPPORT;
    }
}
 
/** @}
 */
 

Rev 4713	Rev 4720
1	/*	1	/*
2	* Copyright (c) 2008 Lukas Mejdrech	2	* Copyright (c) 2008 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup udp	29	/** @addtogroup udp
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* UDP module implementation.	34	* UDP module implementation.
35	* @see udp.h	35	* @see udp.h
36	*/	36	*/
37		37
38	#include <async.h>	38	#include <async.h>
39	#include <fibril_sync.h>	39	#include <fibril_sync.h>
40	#include <malloc.h>	40	#include <malloc.h>
41		41
42	#include <ipc/ipc.h>	42	#include <ipc/ipc.h>
43	#include <ipc/services.h>	43	#include <ipc/services.h>
44		44
45	#include "../../err.h"	45	#include "../../err.h"
46	#include "../../messages.h"	46	#include "../../messages.h"
47	#include "../../modules.h"	47	#include "../../modules.h"
48		48
49	#include "../../structures/dynamic_fifo.h"	49	#include "../../structures/dynamic_fifo.h"
50	#include "../../structures/packet/packet_client.h"	50	#include "../../structures/packet/packet_client.h"
51		51
52	#include "../../include/in.h"	52	#include "../../include/in.h"
-		53	#include "../../include/in6.h"
53	#include "../../include/inet.h"	54	#include "../../include/inet.h"
54	#include "../../include/ip_client.h"	55	#include "../../include/ip_client.h"
55	#include "../../include/ip_interface.h"	56	#include "../../include/ip_interface.h"
56	#include "../../include/ip_protocols.h"	57	#include "../../include/ip_protocols.h"
57	#include "../../include/icmp_client.h"	58	#include "../../include/icmp_client.h"
58	#include "../../include/icmp_interface.h"	59	#include "../../include/icmp_interface.h"
59	#include "../../include/socket_codes.h"	60	#include "../../include/socket_codes.h"
60	#include "../../include/socket_errno.h"	61	#include "../../include/socket_errno.h"
61		62
62	#include "../../socket/socket_core.h"	63	#include "../../socket/socket_core.h"
63	#include "../../socket/socket_messages.h"	64	#include "../../socket/socket_messages.h"
64		65
65	#include "../tl_messages.h"	66	#include "../tl_messages.h"
66		67
67	#include "udp.h"	68	#include "udp.h"
68	#include "udp_header.h"	69	#include "udp_header.h"
69	#include "udp_module.h"	70	#include "udp_module.h"
70		71
71	/** Maximum UDP fragment size.	72	/** Maximum UDP fragment size.
72	*/	73	*/
73	#define MAX_UDP_FRAGMENT_SIZE 65535	74	#define MAX_UDP_FRAGMENT_SIZE 65535
74		75
75	/** Free ports pool start.	76	/** Free ports pool start.
76	*/	77	*/
77	#define UDP_FREE_PORTS_START 1025	78	#define UDP_FREE_PORTS_START 1025
78		79
79	/** Free ports pool end.	80	/** Free ports pool end.
80	*/	81	*/
81	#define UDP_FREE_PORTS_END 65535	82	#define UDP_FREE_PORTS_END 65535
82		83
83	/** Processes the received UDP packet queue.	84	/** Processes the received UDP packet queue.
84	* Is used as an entry point from the underlying IP module.	85	* Is used as an entry point from the underlying IP module.
85	* Notifies the destination socket application.	86	* Notifies the destination socket application.
86	* Releases the packet on error or send an ICMP error notification..	87	* Releases the packet on error or send an ICMP error notification..
87	* @param device_id The device identifier. Ignored parameter.	88	* @param device_id The device identifier. Ignored parameter.
88	* @param packet The received packet queue. Input/output parameter.	89	* @param packet The received packet queue. Input/output parameter.
89	* @param receiver The target service. Ignored parameter.	90	* @param receiver The target service. Ignored parameter.
90	* @param error The packet error reporting service. Prefixes the received packet. Input parameter.	91	* @param error The packet error reporting service. Prefixes the received packet. Input parameter.
91	* @returns EOK on success.	92	* @returns EOK on success.
92	* @returns EINVAL if the packet is not valid.	93	* @returns EINVAL if the packet is not valid.
93	* @returns EINVAL if the stored packet address is not the an_addr_t.	94	* @returns EINVAL if the stored packet address is not the an_addr_t.
94	* @returns EINVAL if the packet does not contain any data.	95	* @returns EINVAL if the packet does not contain any data.
95	* @returns NO_DATA if the packet content is shorter than the user datagram header.	96	* @returns NO_DATA if the packet content is shorter than the user datagram header.
96	* @returns ENOMEM if there is not enough memory left.	97	* @returns ENOMEM if there is not enough memory left.
97	* @returns EADDRNOTAVAIL if the destination socket does not exist.	98	* @returns EADDRNOTAVAIL if the destination socket does not exist.
98	* @returns Other error codes as defined for the ip_client_process_packet() function.	99	* @returns Other error codes as defined for the ip_client_process_packet() function.
99	*/	100	*/
100	int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );	101	int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );
101		102
102	/** Releases the packet and returns the result.	103	/** Releases the packet and returns the result.
103	* @param packet The packet queue to be released. Input parameter.	104	* @param packet The packet queue to be released. Input parameter.
104	* @param result The result to be returned. Input parameter.	105	* @param result The result to be returned. Input parameter.
105	* @return The result parameter.	106	* @return The result parameter.
106	*/	107	*/
107	int udp_release_and_return( packet_t packet, int result );	108	int udp_release_and_return( packet_t packet, int result );
108		109
109	/** Sends the port unreachable ICMP notification.	110	/** Sends the port unreachable ICMP notification.
110	* Sends the first packet and releases all the others.	111	* Sends the first packet and releases all the others.
111	* Releases the packet queu on error.	112	* Releases the packet queu on error.
112	* @param packet The packet to be send. Input parameter.	113	* @param packet The packet to be send. Input parameter.
113	* @param error The packet error reporting service. Prefixes the received packet. Input parameter.	114	* @param error The packet error reporting service. Prefixes the received packet. Input parameter.
114	*/	115	*/
115	void udp_send_icmp_port_unreachable( packet_t packet, services_t error );	116	void udp_send_icmp_port_unreachable( packet_t packet, services_t error );
116		117
117	/** @name Socket messages processing functions	118	/** @name Socket messages processing functions
118	*/	119	*/
119	/@{/	120	/@{/
120		121
121	/** Processes the socket client messages.	122	/** Processes the socket client messages.
122	* Runs until the client module disconnects.	123	* Runs until the client module disconnects.
123	* @param callid The message identifier. Input parameter.	124	* @param callid The message identifier. Input parameter.
124	* @param call The message parameters. Input parameter.	125	* @param call The message parameters. Input parameter.
125	* @returns EOK on success.	126	* @returns EOK on success.
126	* @see socket.h	127	* @see socket.h
127	*/	128	*/
128	int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call );	129	int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call );
129		130
130	/** Sends data from the socket to the remote address.	131	/** Sends data from the socket to the remote address.
131	* Binds the socket to a free port if not already connected/bound.	132	* Binds the socket to a free port if not already connected/bound.
132	* Handles the NET_SOCKET_SENDTO message.	133	* Handles the NET_SOCKET_SENDTO message.
-		134	* Supports AF_INET and AF_INET6 address families.
133	* @param local_sockets The application local sockets. Input/output parameter.	135	* @param local_sockets The application local sockets. Input/output parameter.
134	* @param socket_id Socket identifier. Input parameter.	136	* @param socket_id Socket identifier. Input parameter.
135	* @param addr The destination address. Input parameter.	137	* @param addr The destination address. Input parameter.
136	* @param addrlen The address length. Input parameter.	138	* @param addrlen The address length. Input parameter.
137	* @param fragments The number of data fragments. Input parameter.	139	* @param fragments The number of data fragments. Input parameter.
138	* @param flags Various send flags. Input parameter.	140	* @param flags Various send flags. Input parameter.
139	* @returns EOK on success.	141	* @returns EOK on success.
140	* @returns EAFNOTSUPPORT if the address family is not supported.	142	* @returns EAFNOTSUPPORT if the address family is not supported.
141	* @returns ENOTSOCK if the socket is not found.	143	* @returns ENOTSOCK if the socket is not found.
142	* @returns EINVAL if the address is invalid.	144	* @returns EINVAL if the address is invalid.
143	* @returns ENOTCONN if the sending socket is not and cannot be bound.	145	* @returns ENOTCONN if the sending socket is not and cannot be bound.
144	* @returns ENOMEM if there is not enough memory left.	146	* @returns ENOMEM if there is not enough memory left.
145	* @returns Other error codes as defined for the socket_read_packet_data() function.	147	* @returns Other error codes as defined for the socket_read_packet_data() function.
146	* @returns Other error codes as defined for the ip_client_prepare_packet() function.	148	* @returns Other error codes as defined for the ip_client_prepare_packet() function.
147	* @returns Other error codes as defined for the ip_send_msg() function.	149	* @returns Other error codes as defined for the ip_send_msg() function.
148	*/	150	*/
149	int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, void * addr, size_t addrlen, int fragments, int flags );	151	int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, int flags );
150		152
151	/** Receives data to the socket.	153	/** Receives data to the socket.
152	* Handles the NET_SOCKET_RECVFROM message.	154	* Handles the NET_SOCKET_RECVFROM message.
-		155	* Replies the source address as well.
153	* @param local_sockets The application local sockets. Input parameter.	156	* @param local_sockets The application local sockets. Input parameter.
154	* @param socket_id Socket identifier. Input parameter.	157	* @param socket_id Socket identifier. Input parameter.
155	* @param flags Various receive flags. Input parameter.	158	* @param flags Various receive flags. Input parameter.
-		159	* @param addrlen The source address length. Output parameter.
156	* @returns The number of bytes received.	160	* @returns The number of bytes received.
157	* @returns ENOTSOCK if the socket is not found.	161	* @returns ENOTSOCK if the socket is not found.
158	* @returns NO_DATA if there are no received packets or data.	162	* @returns NO_DATA if there are no received packets or data.
159	* @returns ENOMEM if there is not enough memory left.	163	* @returns ENOMEM if there is not enough memory left.
160	* @returns EINVAL if the received address is not an IP address.	164	* @returns EINVAL if the received address is not an IP address.
161	* @returns Other error codes as defined for the packet_translate() function.	165	* @returns Other error codes as defined for the packet_translate() function.
162	* @returns Other error codes as defined for the socket_write_data() function.	166	* @returns Other error codes as defined for the socket_write_data() function.
163	*/	167	*/
164	int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags );	168	int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
165		169
166	/@}/	170	/@}/
167		171
168	/** Receives data from the socket.	172	/** Receives data from the socket.
169	* The received data buffer is allocated and returned.	173	* The received data buffer is allocated and returned.
170	* @param data The data buffer to be filled. Output parameter.	174	* @param data The data buffer to be filled. Output parameter.
171	* @param length The buffer length. Output parameter.	175	* @param length The buffer length. Output parameter.
172	* @returns EOK on success.	176	* @returns EOK on success.
173	* @returns EBADMEM if the data or the length parameter is NULL.	177	* @returns EBADMEM if the data or the length parameter is NULL.
174	* @returns EINVAL if the client does not send data.	178	* @returns EINVAL if the client does not send data.
175	* @returns ENOMEM if there is not enough memory left.	179	* @returns ENOMEM if there is not enough memory left.
176	* @returns Other error codes as defined for the ipc_data_write_finalize() function.	180	* @returns Other error codes as defined for the ipc_data_write_finalize() function.
177	*/	181	*/
178	int socket_read_data( void ** data, size_t * length );	182	int socket_read_data( void ** data, size_t * length );
179		183
180	/** Receives data from the socket into a packet.	184	/** Receives data from the socket into a packet.
181	* @param packet The new created packet. Output parameter.	185	* @param packet The new created packet. Output parameter.
182	* @param prefix Reserved packet data prefix length. Input parameter.	186	* @param prefix Reserved packet data prefix length. Input parameter.
183	* @param address_in The destination address to be set. Input parameter.	187	* @param addr The destination address. Input parameter.
-		188	* @param addrlen The address length. Input parameter.
184	* @returns Number of bytes received.	189	* @returns Number of bytes received.
185	* @returns EINVAL if the client does not send data.	190	* @returns EINVAL if the client does not send data.
186	* @returns ENOMEM if there is not enough memory left.	191	* @returns ENOMEM if there is not enough memory left.
187	* @returns Other error codes as defined for the ipc_data_read_finalize() function.	192	* @returns Other error codes as defined for the ipc_data_read_finalize() function.
188	*/	193	*/
189	int socket_read_packet_data( packet_ref packet, size_t prefix, struct sockaddr_in * address_in );	194	int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen );
190		195
191	/** Replies the data to the socket.	196	/** Replies the data to the socket.
192	* @param data The data buffer to be sent. Input parameter.	197	* @param data The data buffer to be sent. Input parameter.
193	* @param data_length The buffer length. Input parameter.	198	* @param data_length The buffer length. Input parameter.
194	* @returns EOK on success.	199	* @returns EOK on success.
195	* @returns EINVAL if the client does not expect all the data.	200	* @returns EINVAL if the client does not expect all the data.
196	* @returns Other error codes as defined for the ipc_data_read_finalize() function.	201	* @returns Other error codes as defined for the ipc_data_read_finalize() function.
197	*/	202	*/
198	int socket_write_data( void * data, size_t data_length );	203	int socket_write_data( void * data, size_t data_length );
199		204
-		205	/** Sets the address port.
-		206	* Supports AF_INET and AF_INET6 address families.
-		207	* @param addr The address to be updated. Input/output parameter.
-		208	* @param addrlen The address length. Input parameter.
-		209	* @param port The port to be set. Input parameter.
-		210	* @returns EOK on success.
-		211	* @returns EINVAL if the address length does not match the address family.
-		212	* @returns EAFNOSUPPORT if the address family is not supported.
-		213	*/
-		214	int udp_set_address_port( struct sockaddr * addr, int addrlen, uint16_t port );
-		215
200	/** UDP global data.	216	/** UDP global data.
201	*/	217	*/
202	udp_globals_t udp_globals;	218	udp_globals_t udp_globals;
203		219
204	int udp_initialize( async_client_conn_t client_connection ){	220	int udp_initialize( async_client_conn_t client_connection ){
205	ERROR_DECLARE;	221	ERROR_DECLARE;
206		222
207	fibril_rwlock_initialize( & udp_globals.lock );	223	fibril_rwlock_initialize( & udp_globals.lock );
208	fibril_rwlock_write_lock( & udp_globals.lock );	224	fibril_rwlock_write_lock( & udp_globals.lock );
209	udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );	225	udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
210	if( udp_globals.icmp_phone < 0 ){	226	if( udp_globals.icmp_phone < 0 ){
211	return udp_globals.icmp_phone;	227	return udp_globals.icmp_phone;
212	}	228	}
213	udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );	229	udp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_UDP, SERVICE_UDP, client_connection, udp_received_msg );
214	if( udp_globals.ip_phone < 0 ){	230	if( udp_globals.ip_phone < 0 ){
215	return udp_globals.ip_phone;	231	return udp_globals.ip_phone;
216	}	232	}
217	ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));	233	ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
218	ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));	234	ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
219	udp_globals.prefix += sizeof( udp_header_t );	235	udp_globals.prefix += sizeof( udp_header_t );
220	udp_globals.content -= sizeof( udp_header_t );	236	udp_globals.content -= sizeof( udp_header_t );
221	udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;	237	udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
222	fibril_rwlock_write_unlock( & udp_globals.lock );	238	fibril_rwlock_write_unlock( & udp_globals.lock );
223	return EOK;	239	return EOK;
224	}	240	}
225		241
226	int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){	242	int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
227	ERROR_DECLARE;	243	ERROR_DECLARE;
228		244
229	size_t length;	245	size_t length;
230	size_t offset;	246	size_t offset;
231	int result;	247	int result;
232	uint8_t * data;	248	uint8_t * data;
233	udp_header_ref header;	249	udp_header_ref header;
234	socket_core_ref * socket;	250	socket_core_ref * socket;
235	packet_t next_packet;	251	packet_t next_packet;
236	size_t total_length;	252	size_t total_length;
237	// uint16_t checksum;	253	// uint16_t checksum;
238	int fragments;	254	int fragments;
239	packet_t tmp_packet;	255	packet_t tmp_packet;
240	icmp_type_t type;	256	icmp_type_t type;
241	icmp_code_t code;	257	icmp_code_t code;
242		258
243	if( error ){	259	if( error ){
244	switch( error ){	260	switch( error ){
245	case SERVICE_ICMP:	261	case SERVICE_ICMP:
246	// process error	262	// process error
247	// TODO remove debug dump	263	// TODO remove debug dump
248	// length = icmp_client_header_length( packet );	264	// length = icmp_client_header_length( packet );
249	result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );	265	result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
250	if( result < 0 ){	266	if( result < 0 ){
251	return udp_release_and_return( packet, result );	267	return udp_release_and_return( packet, result );
252	}	268	}
253	printf( "ICMP error %d (%d) in packet %d\n", type, code, packet_get_id( packet ) );	269	printf( "ICMP error %d (%d) in packet %d\n", type, code, packet_get_id( packet ) );
254	length = ( size_t ) result;	270	length = ( size_t ) result;
255	if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){	271	if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
256	return udp_release_and_return( packet, ERROR_CODE );	272	return udp_release_and_return( packet, ERROR_CODE );
257	}	273	}
258	break;	274	break;
259	default:	275	default:
260	return udp_release_and_return( packet, ENOTSUP );	276	return udp_release_and_return( packet, ENOTSUP );
261	}	277	}
262	}	278	}
263	// TODO process received ipopts?	279	// TODO process received ipopts?
264	result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );	280	result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
265	if( result < 0 ){	281	if( result < 0 ){
266	return udp_release_and_return( packet, result );	282	return udp_release_and_return( packet, result );
267	}	283	}
268	offset = ( size_t ) result;	284	offset = ( size_t ) result;
269		285
270	length = packet_get_data_length( packet );	286	length = packet_get_data_length( packet );
271	if( length <= 0 ){	287	if( length <= 0 ){
272	return udp_release_and_return( packet, EINVAL );	288	return udp_release_and_return( packet, EINVAL );
273	}	289	}
274	if( length < sizeof( udp_header_t ) + offset ){	290	if( length < sizeof( udp_header_t ) + offset ){
275	return udp_release_and_return( packet, NO_DATA );	291	return udp_release_and_return( packet, NO_DATA );
276	}	292	}
277	data = packet_get_data( packet );	293	data = packet_get_data( packet );
278	if( ! data ){	294	if( ! data ){
279	return udp_release_and_return( packet, NO_DATA );	295	return udp_release_and_return( packet, NO_DATA );
280	}	296	}
281	// get udp header	297	// get udp header
282	header = ( udp_header_ref )( data + offset );	298	header = ( udp_header_ref )( data + offset );
283	// find the destination socket	299	// find the destination socket
284	socket = socket_ports_find( & udp_globals.sockets, ntohs( header->dest ));	300	socket = socket_ports_find( & udp_globals.sockets, ntohs( header->dest ));
285	if( ! socket ){	301	if( ! socket ){
286	udp_send_icmp_port_unreachable( packet, error );	302	udp_send_icmp_port_unreachable( packet, error );
287	return EADDRNOTAVAIL;	303	return EADDRNOTAVAIL;
288	}	304	}
289	// trim after successful processing to be able to send an ICMP error message!	305	// trim after successful processing to be able to send an ICMP error message!
290	ERROR_PROPAGATE( packet_trim( packet, offset, 0 ));	306	ERROR_PROPAGATE( packet_trim( packet, offset, 0 ));
291	// count the received packet fragments	307	// count the received packet fragments
292	next_packet = packet;	308	next_packet = packet;
293	fragments = 0;	309	fragments = 0;
294	total_length = ntohs( header->len );	310	total_length = ntohs( header->len );
295	do{	311	do{
296	++ fragments;	312	++ fragments;
297	length = packet_get_data_length( packet );	313	length = packet_get_data_length( packet );
298	if( length <= 0 ){	314	if( length <= 0 ){
299	return udp_release_and_return( packet, NO_DATA );	315	return udp_release_and_return( packet, NO_DATA );
300	}	316	}
301	if( total_length < length ){	317	if( total_length < length ){
302	// cut of the suffix if too long	318	// cut of the suffix if too long
303	if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){	319	if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
304	return udp_release_and_return( packet, ERROR_CODE );	320	return udp_release_and_return( packet, ERROR_CODE );
305	}	321	}
306	// relese the rest of the packet fragments	322	// relese the rest of the packet fragments
307	tmp_packet = pq_next( next_packet );	323	tmp_packet = pq_next( next_packet );
308	while( tmp_packet ){	324	while( tmp_packet ){
309	next_packet = pq_detach( tmp_packet );	325	next_packet = pq_detach( tmp_packet );
310	pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));	326	pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
311	tmp_packet = next_packet;	327	tmp_packet = next_packet;
312	}	328	}
313	break;	329	break;
314	}	330	}
315	total_length -= length;	331	total_length -= length;
316	/* if( header->header_checksum ){	332	/* if( header->header_checksum ){
317	}	333	}
318	*/	334	*/
319	}while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));	335	}while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
320	// queue the received packet	336	// queue the received packet
321	if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){	337	if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
322	return udp_release_and_return( packet, ERROR_CODE );	338	return udp_release_and_return( packet, ERROR_CODE );
323	}	339	}
324		340
325	// notify the destination socket	341	// notify the destination socket
326	async_msg_2(( socket ).phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) ( socket ).socket_id, ( ipcarg_t ) fragments );	342	async_msg_2(( socket ).phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) ( socket ).socket_id, ( ipcarg_t ) fragments );
327	return EOK;	343	return EOK;
328	}	344	}
329		345
330	int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	346	int udp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
331	ERROR_DECLARE;	347	ERROR_DECLARE;
332		348
333	packet_t packet;	349	packet_t packet;
334		350
335	* answer_count = 0;	351	* answer_count = 0;
336	switch( IPC_GET_METHOD( * call )){	352	switch( IPC_GET_METHOD( * call )){
337	case NET_TL_RECEIVED:	353	case NET_TL_RECEIVED:
338	fibril_rwlock_read_lock( & udp_globals.lock );	354	fibril_rwlock_read_lock( & udp_globals.lock );
339	if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){	355	if( ! ERROR_OCCURRED( packet_translate( udp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
340	ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_UDP, IPC_GET_ERROR( call ));	356	ERROR_CODE = udp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_UDP, IPC_GET_ERROR( call ));
341	}	357	}
342	fibril_rwlock_read_unlock( & udp_globals.lock );	358	fibril_rwlock_read_unlock( & udp_globals.lock );
343	return ERROR_CODE;	359	return ERROR_CODE;
344	case IPC_M_CONNECT_TO_ME:	360	case IPC_M_CONNECT_TO_ME:
345	return udp_process_client_messages( callid, * call );	361	return udp_process_client_messages( callid, * call );
346	}	362	}
347	return ENOTSUP;	363	return ENOTSUP;
348	}	364	}
349		365
350	int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call ){	366	int udp_process_client_messages( ipc_callid_t callid, ipc_call_t call ){
351	int res;	367	int res;
352	bool keep_on_going = true;	368	bool keep_on_going = true;
353	socket_cores_t local_sockets;	369	socket_cores_t local_sockets;
354	int app_phone = IPC_GET_PHONE( & call );	370	int app_phone = IPC_GET_PHONE( & call );
355	void * addr;	371	struct sockaddr * addr;
356	size_t addrlen;	372	size_t addrlen;
357	fibril_rwlock_t lock;	373	fibril_rwlock_t lock;
358	ipc_call_t answer;	374	ipc_call_t answer;
359	int answer_count;	375	int answer_count;
360		376
361	/*	377	/*
362	* Accept the connection	378	* Accept the connection
363	* - Answer the first IPC_M_CONNECT_ME_TO call.	379	* - Answer the first IPC_M_CONNECT_ME_TO call.
364	*/	380	*/
365	ipc_answer_0( callid, EOK );	381	ipc_answer_0( callid, EOK );
366		382
367	socket_cores_initialize( & local_sockets );	383	socket_cores_initialize( & local_sockets );
368	fibril_rwlock_initialize( & lock );	384	fibril_rwlock_initialize( & lock );
369		385
370	while( keep_on_going ){	386	while( keep_on_going ){
371	// refresh data	387	// refresh data
372	refresh_answer( & answer, & answer_count );	388	refresh_answer( & answer, & answer_count );
373		389
374	callid = async_get_call( & call );	390	callid = async_get_call( & call );
375	// printf( "message %d\n", IPC_GET_METHOD( * call ));	391	// printf( "message %d\n", IPC_GET_METHOD( * call ));
376		392
377	switch( IPC_GET_METHOD( call )){	393	switch( IPC_GET_METHOD( call )){
378	case IPC_M_PHONE_HUNGUP:	394	case IPC_M_PHONE_HUNGUP:
379	keep_on_going = false;	395	keep_on_going = false;
380	res = EOK;	396	res = EOK;
381	break;	397	break;
382	case NET_SOCKET:	398	case NET_SOCKET:
383	fibril_rwlock_write_lock( & lock );	399	fibril_rwlock_write_lock( & lock );
384	res = socket_create( & local_sockets, app_phone, SOCKET_SET_SOCKET_ID( answer ));	400	res = socket_create( & local_sockets, app_phone, SOCKET_SET_SOCKET_ID( answer ));
385	fibril_rwlock_write_unlock( & lock );	401	fibril_rwlock_write_unlock( & lock );
386	* SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );	402	* SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
387	* SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;	403	* SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
388	answer_count = 3;	404	answer_count = 3;
389	break;	405	break;
390	case NET_SOCKET_BIND:	406	case NET_SOCKET_BIND:
391	res = socket_read_data( & addr, & addrlen );	407	res = socket_read_data(( void ** ) & addr, & addrlen );
392	if( res == EOK ){	408	if( res == EOK ){
393	fibril_rwlock_write_lock( & lock );	409	fibril_rwlock_write_lock( & lock );
394	fibril_rwlock_write_lock( & udp_globals.lock );	410	fibril_rwlock_write_lock( & udp_globals.lock );
395	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 );	411	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 );
396	fibril_rwlock_write_unlock( & udp_globals.lock );	412	fibril_rwlock_write_unlock( & udp_globals.lock );
397	fibril_rwlock_write_unlock( & lock );	413	fibril_rwlock_write_unlock( & lock );
398	free( addr );	414	free( addr );
399	}	415	}
400	break;	416	break;
401	case NET_SOCKET_SENDTO:	417	case NET_SOCKET_SENDTO:
402	res = socket_read_data( & addr, & addrlen );	418	res = socket_read_data(( void ** ) & addr, & addrlen );
403	if( res == EOK ){	419	if( res == EOK ){
404	fibril_rwlock_read_lock( & lock );	420	fibril_rwlock_read_lock( & lock );
405	fibril_rwlock_read_lock( & udp_globals.lock );	421	fibril_rwlock_read_lock( & udp_globals.lock );
406	res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));	422	res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
407	fibril_rwlock_read_unlock( & udp_globals.lock );	423	fibril_rwlock_read_unlock( & udp_globals.lock );
408	fibril_rwlock_read_unlock( & lock );	424	fibril_rwlock_read_unlock( & lock );
409	free( addr );	425	free( addr );
410	}	426	}
411	break;	427	break;
412	case NET_SOCKET_RECVFROM:	428	case NET_SOCKET_RECVFROM:
413	fibril_rwlock_read_lock( & lock );	429	fibril_rwlock_read_lock( & lock );
414	fibril_rwlock_read_lock( & udp_globals.lock );	430	fibril_rwlock_read_lock( & udp_globals.lock );
415	res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ));	431	res = udp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ), & addrlen );
416	fibril_rwlock_read_unlock( & udp_globals.lock );	432	fibril_rwlock_read_unlock( & udp_globals.lock );
417	fibril_rwlock_read_unlock( & lock );	433	fibril_rwlock_read_unlock( & lock );
418	if( res > 0 ){	434	if( res > 0 ){
419	* SOCKET_SET_READ_DATA_LENGTH( answer ) = res;	435	* SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
420	* SOCKET_SET_ADDRESS_LENGTH( answer ) = sizeof( struct sockaddr_in );	436	* SOCKET_SET_ADDRESS_LENGTH( answer ) = addrlen;
421	answer_count = 2;	437	answer_count = 2;
422	res = EOK;	438	res = EOK;
423	}	439	}
424	break;	440	break;
425	case NET_SOCKET_CLOSE:	441	case NET_SOCKET_CLOSE:
426	fibril_rwlock_write_lock( & lock );	442	fibril_rwlock_write_lock( & lock );
427	fibril_rwlock_write_lock( & udp_globals.lock );	443	fibril_rwlock_write_lock( & udp_globals.lock );
428	res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets );	444	res = socket_destroy( udp_globals.net_phone, SOCKET_GET_SOCKET_ID( call ), & local_sockets, & udp_globals.sockets );
429	fibril_rwlock_write_unlock( & udp_globals.lock );	445	fibril_rwlock_write_unlock( & udp_globals.lock );
430	fibril_rwlock_write_unlock( & lock );	446	fibril_rwlock_write_unlock( & lock );
431	break;	447	break;
432	case NET_SOCKET_GETSOCKOPT:	448	case NET_SOCKET_GETSOCKOPT:
433	case NET_SOCKET_SETSOCKOPT:	449	case NET_SOCKET_SETSOCKOPT:
434	default:	450	default:
435	res = ENOTSUP;	451	res = ENOTSUP;
436	break;	452	break;
437	}	453	}
438		454
439	// printf( "res = %d\n", res );	455	// printf( "res = %d\n", res );
440		456
441	answer_call( callid, res, & answer, answer_count );	457	answer_call( callid, res, & answer, answer_count );
442	}	458	}
443		459
444	socket_cores_destroy( & local_sockets );	460	socket_cores_destroy( & local_sockets );
445		461
446	return EOK;	462	return EOK;
447	}	463	}
448		464
449	int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, void * addr, size_t addrlen, int fragments, int flags ){	465	int udp_sendto_message( socket_cores_ref local_sockets, int socket_id, const struct sockaddr * addr, socklen_t addrlen, int fragments, int flags ){
450	ERROR_DECLARE;	466	ERROR_DECLARE;
451		467
452	socket_core_ref socket;	468	socket_core_ref socket;
453	struct sockaddr * address;	-
454	struct sockaddr_in * address_in;	469	struct sockaddr_in * address_in;
-		470	struct sockaddr_in6 * address_in6;
455	packet_t packet;	471	packet_t packet;
456	packet_t next_packet;	472	packet_t next_packet;
457	udp_header_ref header;	473	udp_header_ref header;
458	int index;	474	int index;
459	size_t total_length;	475	size_t total_length;
460	int result;	476	int result;
-		477	uint16_t dest_port;
461		478
462	if( addrlen < sizeof( struct sockaddr )) return EINVAL;	479	if( addrlen < sizeof( struct sockaddr )) return EINVAL;
463	address = ( struct sockaddr * ) addr;	-
464	switch( address->sa_family ){	480	switch( addr->sa_family ){
465	case AF_INET:	481	case AF_INET:
466	if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;	482	if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
467	address_in = ( struct sockaddr_in * ) addr;	483	address_in = ( struct sockaddr_in * ) addr;
-		484	dest_port = address_in->sin_port;
-		485	break;
-		486	case AF_INET6:
468	socket = socket_cores_find( local_sockets, socket_id );	487	if( addrlen != sizeof( struct sockaddr_in6 )) return EINVAL;
-		488	address_in6 = ( struct sockaddr_in6 * ) addr;
-		489	dest_port = address_in6->sin6_port;
-		490	break;
-		491	default:
469	if( ! socket ) return ENOTSOCK;	492	return EAFNOSUPPORT;
-		493	}
470		494
471	// bind the socket to a random free port if not bound	-
472	while( socket->port <= 0 ){	-
473	// try to find a free port	-
474	fibril_rwlock_read_unlock( & udp_globals.lock );	-

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/tl/udp/udp.c – Rev 4713 → 4720