Subversion Repositories HelenOS

Rev

Rev 4722 | Rev 4728 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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