Subversion Repositories HelenOS

Rev

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