Subversion Repositories HelenOS

Rev

Rev 4720 | Rev 4728 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4720 Rev 4722
Line 47... Line 47...
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/crc.h"
52
#include "../../include/in.h"
53
#include "../../include/in.h"
53
#include "../../include/in6.h"
54
#include "../../include/in6.h"
54
#include "../../include/inet.h"
55
#include "../../include/inet.h"
55
#include "../../include/ip_client.h"
56
#include "../../include/ip_client.h"
56
#include "../../include/ip_interface.h"
57
#include "../../include/ip_interface.h"
57
#include "../../include/ip_protocols.h"
58
#include "../../include/ip_protocols.h"
58
#include "../../include/icmp_client.h"
59
#include "../../include/icmp_client.h"
59
#include "../../include/icmp_interface.h"
60
#include "../../include/icmp_interface.h"
-
 
61
#include "../../include/net_interface.h"
60
#include "../../include/socket_codes.h"
62
#include "../../include/socket_codes.h"
61
#include "../../include/socket_errno.h"
63
#include "../../include/socket_errno.h"
62
 
64
 
63
#include "../../socket/socket_core.h"
65
#include "../../socket/socket_core.h"
64
#include "../../socket/socket_messages.h"
66
#include "../../socket/socket_messages.h"
Line 67... Line 69...
67
 
69
 
68
#include "udp.h"
70
#include "udp.h"
69
#include "udp_header.h"
71
#include "udp_header.h"
70
#include "udp_module.h"
72
#include "udp_module.h"
71
 
73
 
-
 
74
/** Default UDP checksum computing.
-
 
75
 */
-
 
76
#define NET_DEFAULT_UDP_CHECKSUM_COMPUTING  true
-
 
77
 
72
/** Maximum UDP fragment size.
78
/** Maximum UDP fragment size.
73
 */
79
 */
74
#define MAX_UDP_FRAGMENT_SIZE   65535
80
#define MAX_UDP_FRAGMENT_SIZE   65535
75
 
81
 
76
/** Free ports pool start.
82
/** Free ports pool start.
Line 161... Line 167...
161
 *  @returns ENOTSOCK if the socket is not found.
167
 *  @returns ENOTSOCK if the socket is not found.
162
 *  @returns NO_DATA if there are no received packets or data.
168
 *  @returns NO_DATA if there are no received packets or data.
163
 *  @returns ENOMEM if there is not enough memory left.
169
 *  @returns ENOMEM if there is not enough memory left.
164
 *  @returns EINVAL if the received address is not an IP address.
170
 *  @returns EINVAL if the received address is not an IP address.
165
 *  @returns Other error codes as defined for the packet_translate() function.
171
 *  @returns Other error codes as defined for the packet_translate() function.
166
 *  @returns Other error codes as defined for the socket_write_data() function.
172
 *  @returns Other error codes as defined for the data_reply() function.
167
 */
173
 */
168
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
174
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
169
 
175
 
170
/*@}*/
176
/*@}*/
171
 
177
 
172
/** Receives data from the socket.
-
 
173
 *  The received data buffer is allocated and returned.
-
 
174
 *  @param data The data buffer to be filled. Output parameter.
-
 
175
 *  @param length The buffer length. Output parameter.
-
 
176
 *  @returns EOK on success.
-
 
177
 *  @returns EBADMEM if the data or the length parameter is NULL.
-
 
178
 *  @returns EINVAL if the client does not send data.
-
 
179
 *  @returns ENOMEM if there is not enough memory left.
-
 
180
 *  @returns Other error codes as defined for the ipc_data_write_finalize() function.
-
 
181
 */
-
 
182
int socket_read_data( void ** data, size_t * length );
-
 
183
 
-
 
184
/** Receives data from the socket into a packet.
178
/** Receives data from the socket into a packet.
185
 *  @param packet The new created packet. Output parameter.
179
 *  @param packet The new created packet. Output parameter.
186
 *  @param prefix Reserved packet data prefix length. Input parameter.
180
 *  @param prefix Reserved packet data prefix length. Input parameter.
187
 *  @param addr The destination address. Input parameter.
181
 *  @param addr The destination address. Input parameter.
188
 *  @param addrlen The address length. Input parameter.
182
 *  @param addrlen The address length. Input parameter.
Line 191... Line 185...
191
 *  @returns ENOMEM if there is not enough memory left.
185
 *  @returns ENOMEM if there is not enough memory left.
192
 *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
186
 *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
193
 */
187
 */
194
int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen );
188
int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen );
195
 
189
 
196
/** Replies the data to the socket.
-
 
197
 *  @param data The data buffer to be sent. Input parameter.
-
 
198
 *  @param data_length The buffer length. Input parameter.
-
 
199
 *  @returns EOK on success.
-
 
200
 *  @returns EINVAL if the client does not expect all the data.
-
 
201
 *  @returns Other error codes as defined for the ipc_data_read_finalize() function.
-
 
202
 */
-
 
203
int socket_write_data( void * data, size_t data_length );
-
 
204
 
-
 
205
/** Sets the address port.
190
/** Sets the address port.
206
 *  Supports AF_INET and AF_INET6 address families.
191
 *  Supports AF_INET and AF_INET6 address families.
207
 *  @param addr The address to be updated. Input/output parameter.
192
 *  @param addr The address to be updated. Input/output parameter.
208
 *  @param addrlen The address length. Input parameter.
193
 *  @param addrlen The address length. Input parameter.
209
 *  @param port The port to be set. Input parameter.
194
 *  @param port The port to be set. Input parameter.
Line 218... Line 203...
218
udp_globals_t   udp_globals;
203
udp_globals_t   udp_globals;
219
 
204
 
220
int udp_initialize( async_client_conn_t client_connection ){
205
int udp_initialize( async_client_conn_t client_connection ){
221
    ERROR_DECLARE;
206
    ERROR_DECLARE;
222
 
207
 
-
 
208
    measured_string_t   names[] = {{ "UDP_CHECKSUM_COMPUTING", 22 }};
-
 
209
    measured_string_ref configuration;
-
 
210
    size_t              count = sizeof( names ) / sizeof( measured_string_t );
-
 
211
    char *              data;
-
 
212
 
223
    fibril_rwlock_initialize( & udp_globals.lock );
213
    fibril_rwlock_initialize( & udp_globals.lock );
224
    fibril_rwlock_write_lock( & udp_globals.lock );
214
    fibril_rwlock_write_lock( & udp_globals.lock );
225
    udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
215
    udp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
226
    if( udp_globals.icmp_phone < 0 ){
216
    if( udp_globals.icmp_phone < 0 ){
227
        return udp_globals.icmp_phone;
217
        return udp_globals.icmp_phone;
Line 233... Line 223...
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 ));
223
    ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
234
    ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
224
    ERROR_PROPAGATE( socket_ports_initialize( & udp_globals.sockets ));
235
    udp_globals.prefix += sizeof( udp_header_t );
225
    udp_globals.prefix += sizeof( udp_header_t );
236
    udp_globals.content -= sizeof( udp_header_t );
226
    udp_globals.content -= sizeof( udp_header_t );
237
    udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
227
    udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
-
 
228
    // get configuration
-
 
229
    udp_globals.checksum_computing = NET_DEFAULT_UDP_CHECKSUM_COMPUTING;
-
 
230
    configuration = & names[ 0 ];
-
 
231
    ERROR_PROPAGATE( net_get_conf_req( udp_globals.net_phone, & configuration, count, & data ));
-
 
232
    if( configuration ){
-
 
233
        if( configuration[ 0 ].value ){
-
 
234
            udp_globals.checksum_computing = ( configuration[ 0 ].value[ 0 ] == 'y' );
-
 
235
        }
-
 
236
        net_free_settings( configuration, data );
-
 
237
    }
238
    fibril_rwlock_write_unlock( & udp_globals.lock );
238
    fibril_rwlock_write_unlock( & udp_globals.lock );
239
    return EOK;
239
    return EOK;
240
}
240
}
241
 
241
 
242
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 ){
Line 248... Line 248...
248
    uint8_t *       data;
248
    uint8_t *       data;
249
    udp_header_ref  header;
249
    udp_header_ref  header;
250
    socket_core_ref *   socket;
250
    socket_core_ref *   socket;
251
    packet_t        next_packet;
251
    packet_t        next_packet;
252
    size_t          total_length;
252
    size_t          total_length;
253
//  uint16_t        checksum;
253
    uint32_t        checksum;
254
    int             fragments;
254
    int             fragments;
255
    packet_t        tmp_packet;
255
    packet_t        tmp_packet;
256
    icmp_type_t     type;
256
    icmp_type_t     type;
257
    icmp_code_t     code;
257
    icmp_code_t     code;
-
 
258
    ip_pseudo_header_ref    ip_header;
-
 
259
    struct sockaddr *       src;
-
 
260
    struct sockaddr *       dest;
258
 
261
 
259
    if( error ){
262
    if( error ){
260
        switch( error ){
263
        switch( error ){
261
            case SERVICE_ICMP:
264
            case SERVICE_ICMP:
262
                // process error
265
                // process error
Line 306... Line 309...
306
    ERROR_PROPAGATE( packet_trim( packet, offset, 0 ));
309
    ERROR_PROPAGATE( packet_trim( packet, offset, 0 ));
307
    // count the received packet fragments
310
    // count the received packet fragments
308
    next_packet = packet;
311
    next_packet = packet;
309
    fragments = 0;
312
    fragments = 0;
310
    total_length = ntohs( header->len );
313
    total_length = ntohs( header->len );
-
 
314
    // compute header checksum if set
-
 
315
    if( header->check && ( ! error )){
-
 
316
        result = packet_get_addr( packet, ( uint8_t ** ) & src, ( uint8_t ** ) & dest );
-
 
317
        if( result <= 0 ){
-
 
318
            return udp_release_and_return( packet, result );
-
 
319
        }
-
 
320
        if( ERROR_OCCURRED( ip_client_get_pseudo_header( IPPROTO_UDP, src, result, dest, result, total_length, & ip_header, & length ))){
-
 
321
            return udp_release_and_return( packet, ERROR_CODE );
-
 
322
        }else{
-
 
323
            checksum = compute_checksum( 0, ip_header, length );
-
 
324
            // the udp header checksum will be added with the first fragment later
-
 
325
            free( ip_header );
-
 
326
        }
-
 
327
    }else{
-
 
328
        header->check = 0;
-
 
329
        checksum = 0;
-
 
330
    }
311
    do{
331
    do{
312
        ++ fragments;
332
        ++ fragments;
313
        length = packet_get_data_length( packet );
333
        length = packet_get_data_length( next_packet );
314
        if( length <= 0 ){
334
        if( length <= 0 ){
315
            return udp_release_and_return( packet, NO_DATA );
335
            return udp_release_and_return( packet, NO_DATA );
316
        }
336
        }
317
        if( total_length < length ){
337
        if( total_length < length ){
318
            // cut of the suffix if too long
-
 
319
            if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
338
            if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - total_length ))){
320
                return udp_release_and_return( packet, ERROR_CODE );
339
                return udp_release_and_return( packet, ERROR_CODE );
321
            }
340
            }
-
 
341
            // add partial checksum if set
-
 
342
            if( header->check ){
-
 
343
                checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
-
 
344
            }
322
            // relese the rest of the packet fragments
345
            // relese the rest of the packet fragments
323
            tmp_packet = pq_next( next_packet );
346
            tmp_packet = pq_next( next_packet );
324
            while( tmp_packet ){
347
            while( tmp_packet ){
325
                next_packet = pq_detach( tmp_packet );
348
                next_packet = pq_detach( tmp_packet );
326
                pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
349
                pq_release( udp_globals.net_phone, packet_get_id( tmp_packet ));
327
                tmp_packet = next_packet;
350
                tmp_packet = next_packet;
328
            }
351
            }
-
 
352
            // exit the loop
329
            break;
353
            break;
330
        }
354
        }
331
        total_length -= length;
355
        total_length -= length;
-
 
356
        // add partial checksum if set
332
    /*  if( header->header_checksum ){
357
        if( header->check ){
-
 
358
            checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
333
        }
359
        }
334
    */
-
 
335
    }while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
360
    }while(( next_packet = pq_next( next_packet )) && ( total_length > 0 ));
-
 
361
    // check checksum
-
 
362
    if( header->check ){
-
 
363
        if( flip_checksum( compact_checksum( checksum ))){
-
 
364
            // TODO checksum error ICMP?
-
 
365
            // TODO remove debug dump
-
 
366
            printf("udp check failed %x => %x\n", header->check, flip_checksum( compact_checksum( checksum )));
-
 
367
            return udp_release_and_return( packet, EINVAL );
-
 
368
        }
-
 
369
    }
336
    // queue the received packet
370
    // queue the received packet
337
    if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
371
    if( ERROR_OCCURRED( dyn_fifo_push( &( ** socket ).received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
338
        return udp_release_and_return( packet, ERROR_CODE );
372
        return udp_release_and_return( packet, ERROR_CODE );
339
    }
373
    }
340
 
374
 
Line 402... Line 436...
402
                * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
436
                * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( udp_header_t );
403
                * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
437
                * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_UDP_FRAGMENT_SIZE;
404
                answer_count = 3;
438
                answer_count = 3;
405
                break;
439
                break;
406
            case NET_SOCKET_BIND:
440
            case NET_SOCKET_BIND:
407
                res = socket_read_data(( void ** ) & addr, & addrlen );
441
                res = data_receive(( void ** ) & addr, & addrlen );
408
                if( res == EOK ){
442
                if( res == EOK ){
409
                    fibril_rwlock_write_lock( & lock );
443
                    fibril_rwlock_write_lock( & lock );
410
                    fibril_rwlock_write_lock( & udp_globals.lock );
444
                    fibril_rwlock_write_lock( & udp_globals.lock );
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 );
445
                    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 );
412
                    fibril_rwlock_write_unlock( & udp_globals.lock );
446
                    fibril_rwlock_write_unlock( & udp_globals.lock );
413
                    fibril_rwlock_write_unlock( & lock );
447
                    fibril_rwlock_write_unlock( & lock );
414
                    free( addr );
448
                    free( addr );
415
                }
449
                }
416
                break;
450
                break;
417
            case NET_SOCKET_SENDTO:
451
            case NET_SOCKET_SENDTO:
418
                res = socket_read_data(( void ** ) & addr, & addrlen );
452
                res = data_receive(( void ** ) & addr, & addrlen );
419
                if( res == EOK ){
453
                if( res == EOK ){
420
                    fibril_rwlock_read_lock( & lock );
454
                    fibril_rwlock_read_lock( & lock );
421
                    fibril_rwlock_read_lock( & udp_globals.lock );
455
                    fibril_rwlock_read_lock( & udp_globals.lock );
422
                    res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
456
                    res = udp_sendto_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_FLAGS( call ));
423
                    fibril_rwlock_read_unlock( & udp_globals.lock );
457
                    fibril_rwlock_read_unlock( & udp_globals.lock );
Line 473... Line 507...
473
    udp_header_ref          header;
507
    udp_header_ref          header;
474
    int                     index;
508
    int                     index;
475
    size_t                  total_length;
509
    size_t                  total_length;
476
    int                     result;
510
    int                     result;
477
    uint16_t                dest_port;
511
    uint16_t                dest_port;
-
 
512
    uint32_t                checksum;
-
 
513
    ip_pseudo_header_ref    ip_header;
-
 
514
    size_t                  headerlen;
-
 
515
    device_id_t             device_id;
478
 
516
 
479
    if( addrlen < sizeof( struct sockaddr )) return EINVAL;
517
    if( addrlen < sizeof( struct sockaddr )) return EINVAL;
480
    switch( addr->sa_family ){
518
    switch( addr->sa_family ){
481
        case AF_INET:
519
        case AF_INET:
482
            if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
520
            if( addrlen != sizeof( struct sockaddr_in )) return EINVAL;
Line 508... Line 546...
508
        fibril_rwlock_write_unlock( & udp_globals.lock );
546
        fibril_rwlock_write_unlock( & udp_globals.lock );
509
        fibril_rwlock_read_lock( & udp_globals.lock );
547
        fibril_rwlock_read_lock( & udp_globals.lock );
510
    }
548
    }
511
 
549
 
512
    // TODO do not ask all the time
550
    // TODO do not ask all the time
513
    ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
551
    ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, socket->device_id, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
514
 
552
 
515
    // read the first packet fragment
553
    // read the first packet fragment
516
    result = socket_read_packet_data( & packet, sizeof( udp_header_t ), addr, addrlen );
554
    result = socket_read_packet_data( & packet, sizeof( udp_header_t ), addr, addrlen );
517
    if( result < 0 ) return result;
555
    if( result < 0 ) return result;
518
    total_length = ( size_t ) result;
556
    total_length = ( size_t ) result;
-
 
557
    if( udp_globals.checksum_computing ){
-
 
558
        checksum = compute_checksum( 0, packet_get_data( packet ), packet_get_data_length( packet ));
-
 
559
    }else{
-
 
560
        checksum = 0;
-
 
561
    }
519
    // prefix the udp header
562
    // prefix the udp header
520
    header = PACKET_PREFIX( packet, udp_header_t );
563
    header = PACKET_PREFIX( packet, udp_header_t );
521
    if( ! header ){
564
    if( ! header ){
522
        pq_release( udp_globals.net_phone, packet_get_id( packet ));
565
        return udp_release_and_return( packet, ENOMEM );
523
        return ENOMEM;
-
 
524
    }
566
    }
-
 
567
    bzero( header, sizeof( * header ));
525
    // read the rest of the packet fragments
568
    // read the rest of the packet fragments
526
    for( index = 1; index < fragments; ++ index ){
569
    for( index = 1; index < fragments; ++ index ){
527
        result = socket_read_packet_data( & next_packet, 0, addr, addrlen );
570
        result = socket_read_packet_data( & next_packet, 0, addr, addrlen );
528
        if( result < 0 ){
571
        if( result < 0 ){
529
            return udp_release_and_return( packet, result );
572
            return udp_release_and_return( packet, result );
530
        }
573
        }
531
        packet = pq_add( packet, next_packet, index, 0 );
574
        packet = pq_add( packet, next_packet, index, 0 );
532
        total_length += ( size_t ) result;
575
        total_length += ( size_t ) result;
-
 
576
        if( udp_globals.checksum_computing ){
-
 
577
            checksum = compute_checksum( checksum, packet_get_data( next_packet ), packet_get_data_length( next_packet ));
-
 
578
        }
533
    }
579
    }
534
    // set the udp header
580
    // set the udp header
535
    header->source = htons( socket->port );
581
    header->source = htons( socket->port );
536
    header->dest = htons( dest_port );
582
    header->dest = htons( dest_port );
537
    header->len = htons( total_length + sizeof( udp_header_t ));
583
    header->len = htons( total_length + sizeof( udp_header_t ));
538
    // TODO my ip address for the pseudo header checksum
-
 
539
    header->check = 0;
584
    header->check = 0;
-
 
585
    if( udp_globals.checksum_computing ){
-
 
586
        if( ERROR_OCCURRED( ip_get_route_req( udp_globals.ip_phone, IPPROTO_UDP, addr, addrlen, & device_id, & ip_header, & headerlen ))){
-
 
587
            return udp_release_and_return( packet, ERROR_CODE );
-
 
588
        }
-
 
589
        if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( ip_header, headerlen, total_length + sizeof( udp_header_t )))){
-
 
590
            free( ip_header );
-
 
591
            return udp_release_and_return( packet, ERROR_CODE );
-
 
592
        }
-
 
593
/*//        TODO remove debug dump:
-
 
594
        uint8_t *   data;
-
 
595
        data = ip_header;
-
 
596
        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 ] );
-
 
597
*/      checksum = compute_checksum( checksum, ip_header, headerlen );
-
 
598
        checksum = compute_checksum( checksum, ( uint8_t * ) header, sizeof( * header ));
-
 
599
        header->check = htons( flip_checksum( compact_checksum( checksum )));
-
 
600
        free( ip_header );
-
 
601
    }else{
-
 
602
        device_id = socket->device_id;
-
 
603
    }
540
    // prepare the first packet fragment
604
    // prepare the first packet fragment
541
    if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_UDP, 0, 0, 0, 0 ))){
605
    if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_UDP, 0, 0, 0, 0 ))){
542
        pq_release( udp_globals.net_phone, packet_get_id( packet ));
606
        return udp_release_and_return( packet, ERROR_CODE );
543
        return ERROR_CODE;
-
 
544
    }
607
    }
545
    // send the packet
608
    // send the packet
546
    return ip_send_msg( udp_globals.ip_phone, socket->device_id, packet, SERVICE_UDP, 0 );
609
    return ip_send_msg( udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0 );
547
}
610
}
548
 
611
 
549
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen ){
612
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen ){
550
    ERROR_DECLARE;
613
    ERROR_DECLARE;
551
 
614
 
Line 583... Line 646...
583
        pq_release( udp_globals.net_phone, packet_id );
646
        pq_release( udp_globals.net_phone, packet_id );
584
        return ERROR_CODE;
647
        return ERROR_CODE;
585
    }
648
    }
586
    * addrlen = ( size_t ) result;
649
    * addrlen = ( size_t ) result;
587
    // send the source address
650
    // send the source address
588
    ERROR_PROPAGATE( socket_write_data( addr, * addrlen ));
651
    ERROR_PROPAGATE( data_reply( addr, * addrlen ));
589
 
652
 
590
    next_packet = pq_next( packet );
653
    next_packet = pq_next( packet );
591
    if( ! next_packet ){
654
    if( ! next_packet ){
592
        // write all if only one fragment
655
        // write all if only one fragment
593
        ERROR_PROPAGATE( socket_write_data( data + sizeof( udp_header_t ), packet_get_data_length( packet ) - sizeof( udp_header_t )));
656
        ERROR_PROPAGATE( data_reply( data + sizeof( udp_header_t ), packet_get_data_length( packet ) - sizeof( udp_header_t )));
594
        // store the total length
657
        // store the total length
595
        length = packet_get_data_length( packet ) - sizeof( udp_header_t );
658
        length = packet_get_data_length( packet ) - sizeof( udp_header_t );
596
    }else{
659
    }else{
597
        // count the packet fragments
660
        // count the packet fragments
598
        fragments = 1;
661
        fragments = 1;
Line 610... Line 673...
610
            lengths[ index ] = packet_get_data_length( next_packet );
673
            lengths[ index ] = packet_get_data_length( next_packet );
611
            lengths[ fragments ] += lengths[ index ];
674
            lengths[ fragments ] += lengths[ index ];
612
            next_packet = pq_next( packet );
675
            next_packet = pq_next( packet );
613
        }while( next_packet );
676
        }while( next_packet );
614
        // write the fragment lengths
677
        // write the fragment lengths
615
        ERROR_PROPAGATE( socket_write_data( lengths, sizeof( int ) * ( fragments + 1 )));
678
        ERROR_PROPAGATE( data_reply( lengths, sizeof( int ) * ( fragments + 1 )));
616
        // write the first fragment
679
        // write the first fragment
617
        ERROR_PROPAGATE( socket_write_data( data + sizeof( udp_header_t ), lengths[ 0 ] ));
680
        ERROR_PROPAGATE( data_reply( data + sizeof( udp_header_t ), lengths[ 0 ] ));
618
        next_packet = pq_next( packet );
681
        next_packet = pq_next( packet );
619
        // write the rest of the fragments
682
        // write the rest of the fragments
620
        for( index = 1; index < fragments; ++ index ){
683
        for( index = 1; index < fragments; ++ index ){
621
            ERROR_PROPAGATE( socket_write_data( packet_get_data( next_packet ), lengths[ index ] ));
684
            ERROR_PROPAGATE( data_reply( packet_get_data( next_packet ), lengths[ index ] ));
622
            next_packet = pq_next( packet );
685
            next_packet = pq_next( packet );
623
        }while( next_packet );
686
        }while( next_packet );
624
        // store the total length
687
        // store the total length
625
        length = lengths[ fragments ];
688
        length = lengths[ fragments ];
626
        free( lengths );
689
        free( lengths );
Line 630... Line 693...
630
    pq_release( udp_globals.net_phone, packet_get_id( packet ));
693
    pq_release( udp_globals.net_phone, packet_get_id( packet ));
631
    // return the total length
694
    // return the total length
632
    return ( int ) length;
695
    return ( int ) length;
633
}
696
}
634
 
697
 
635
int socket_write_data( void * data, size_t data_length ){
-
 
636
    size_t          length;
-
 
637
    ipc_callid_t    callid;
-
 
638
 
-
 
639
    if(( ! ipc_data_read_receive( & callid, & length ))
-
 
640
    || ( length < data_length )){
-
 
641
        return EINVAL;
-
 
642
    }
-
 
643
    return ipc_data_read_finalize( callid, data, data_length );
-
 
644
}
-
 
645
 
-
 
646
int socket_read_data( void ** data, size_t * length ){
-
 
647
    ERROR_DECLARE;
-
 
648
 
-
 
649
    ipc_callid_t    callid;
-
 
650
 
-
 
651
    if( !( data && length )) return EBADMEM;
-
 
652
    if( ! ipc_data_write_receive( & callid, length )) return EINVAL;
-
 
653
    * data = malloc( * length );
-
 
654
    if( !( * data )) return ENOMEM;
-
 
655
    if( ERROR_OCCURRED( ipc_data_write_finalize( callid, * data, * length ))){
-
 
656
        free( data );
-
 
657
        return ERROR_CODE;
-
 
658
    }
-
 
659
    return EOK;
-
 
660
}
-
 
661
 
-
 
662
int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen ){
698
int socket_read_packet_data( packet_ref packet, size_t prefix, const struct sockaddr * addr, socklen_t addrlen ){
663
    ERROR_DECLARE;
699
    ERROR_DECLARE;
664
 
700
 
665
    ipc_callid_t    callid;
701
    ipc_callid_t    callid;
666
    size_t          length;
702
    size_t          length;
Line 672... Line 708...
672
    * packet = packet_get_4( udp_globals.net_phone, length, udp_globals.addr_len, prefix + udp_globals.prefix, udp_globals.suffix );
708
    * packet = packet_get_4( udp_globals.net_phone, length, udp_globals.addr_len, prefix + udp_globals.prefix, udp_globals.suffix );
673
    if( ! packet ) return ENOMEM;
709
    if( ! packet ) return ENOMEM;
674
    // allocate space in the packet
710
    // allocate space in the packet
675
    data = packet_suffix( * packet, length );
711
    data = packet_suffix( * packet, length );
676
    if( ! data ){
712
    if( ! data ){
677
        pq_release( udp_globals.net_phone, packet_get_id( * packet ));
713
        return udp_release_and_return( * packet, ENOMEM );
678
        return ENOMEM;
-
 
679
    }
714
    }
680
    // read the data into the packet
715
    // read the data into the packet
681
    if( ERROR_OCCURRED( ipc_data_write_finalize( callid, data, length ))
716
    if( ERROR_OCCURRED( ipc_data_write_finalize( callid, data, length ))
682
    // set the packet destination address
717
    // set the packet destination address
683
    || ERROR_OCCURRED( packet_set_addr( * packet, NULL, ( uint8_t * ) addr, addrlen ))){
718
    || ERROR_OCCURRED( packet_set_addr( * packet, NULL, ( uint8_t * ) addr, addrlen ))){
684
        pq_release( udp_globals.net_phone, packet_get_id( * packet ));
719
        return udp_release_and_return( * packet, ERROR_CODE );
685
        return ERROR_CODE;
-
 
686
    }
720
    }
687
    return ( int ) length;
721
    return ( int ) length;
688
}
722
}
689
 
723
 
690
int udp_release_and_return( packet_t packet, int result ){
724
int udp_release_and_return( packet_t packet, int result ){