/branches/network/uspace/srv/net/tl/tcp/tcp.c |
---|
42,7 → 42,7 |
#include "../../err.h" |
#include "../../messages.h" |
#include "../../modules.h" |
#include "../../structures/packet/packet.h" |
#include "../../structures/packet/packet_client.h" |
#include "../../il/ip/ip_messages.h" |
65,10 → 65,10 |
printf( "OK\n" ); |
printf( "\nTCP - testing to send packet to IP:\t" ); |
packet = packet_create( 20, 30, 20 ); |
packet = packet_get_5( tcp_globals.networking_phone, SERVICE_TCP, 6, 20, 30, 20 ); |
if( ! packet ) return ENOMEM; |
packet_copy_data( packet, "Hi, this is TCP", 16 ); |
ERROR_PROPAGATE( ip_send( tcp_globals.ip_phone, -1, packet )); |
ip_send( tcp_globals.ip_phone, -1, packet ); |
printf( "\tOK\n" ); |
return EOK; |
} |
/branches/network/uspace/srv/net/tl/tcp/tcp_module.c |
---|
42,6 → 42,8 |
#include "../../err.h" |
#include "../../modules.h" |
#include "../../structures/packet/packet.h" |
#include "../../include/protocols.h" |
#include "tcp.h" |
66,6 → 68,7 |
async_set_client_connection( client_connection ); |
tcp_globals.networking_phone = connect_to_service( SERVICE_NETWORKING ); |
tcp_globals.ip_phone = bind_service( SERVICE_IP, IPPROTO_TCP, 0, 0, client_connection ); |
ERROR_PROPAGATE( pm_init()); |
ERROR_PROPAGATE( tcp_initialize()); |
ERROR_PROPAGATE( REGISTER_ME( SERVICE_TCP, & phonehash )); |
/branches/network/uspace/srv/net/tl/tcp/Makefile |
---|
46,7 → 46,8 |
$(NAME).c \ |
../../module.c \ |
../../modules.c \ |
../../structures/packet/packet.c |
../../structures/packet/packet.c \ |
../../structures/packet/packet_client.c |
DEFS += -D TCP_BUNDLE=1 -D $(NAME)_message=module_message -D $(NAME)_start_module=module_start -D $(NAME)_print_name=module_print_name |
/branches/network/uspace/srv/net/structures/generic_field.h |
---|
128,12 → 128,12 |
field->items = ( type ** ) malloc( sizeof( type * ) * field->size ); \ |
if( ! field->items ) return ENOMEM; \ |
field->items[ field->next ] = NULL; \ |
field->magic = INT_MAP_MAGIC_VALUE; \ |
field->magic = GENERIC_FIELD_MAGIC_VALUE; \ |
return EOK; \ |
} \ |
\ |
int name##_is_valid( name##_ref field ){ \ |
return field && ( field->magic == INT_MAP_MAGIC_VALUE ); \ |
return field && ( field->magic == GENERIC_FIELD_MAGIC_VALUE ); \ |
} |
#endif |
/branches/network/uspace/srv/net/structures/packet/packet_queue.c |
---|
File deleted |
/branches/network/uspace/srv/net/structures/packet/packet_queue.h |
---|
File deleted |
/branches/network/uspace/srv/net/structures/packet/packet_server.h |
---|
0,0 → 1,46 |
/* |
* Copyright (c) 2008 Lukas Mejdrech |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
/** @addtogroup net |
* @{ |
*/ |
/** @file |
*/ |
#ifndef __NET_PACKET_SERVER_H__ |
#define __NET_PACKET_SERVER_H__ |
#include <ipc/ipc.h> |
int packet_server_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ); |
#endif |
/** @} |
*/ |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/branches/network/uspace/srv/net/structures/packet/packet_header.h |
---|
0,0 → 1,71 |
/* |
* Copyright (c) 2008 Lukas Mejdrech |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
/** @addtogroup net |
* @{ |
*/ |
/** @file |
*/ |
#ifndef __NET_PACKET_HEADER_H__ |
#define __NET_PACKET_HEADER_H__ |
#include <ipc/services.h> |
#include "packet.h" |
#define PACKET_MAGIC_VALUE 0x11227788 |
struct packet{ |
packet_id_t packet_id; |
services_t owner; |
packet_mode_t mode; |
int order; |
size_t metric; |
packet_id_t previous; |
packet_id_t next; |
size_t length; |
size_t addr_len; |
size_t src_addr; |
size_t dest_addr; |
size_t max_prefix; |
size_t max_content; |
size_t data_start; |
size_t data_end; |
int magic_value; |
}; |
static inline int packet_is_valid( const packet_t packet ){ |
return packet && ( packet->magic_value == PACKET_MAGIC_VALUE ); |
} |
#endif |
/** @} |
*/ |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/branches/network/uspace/srv/net/structures/packet/packet_client.c |
---|
0,0 → 1,217 |
/* |
* Copyright (c) 2008 Lukas Mejdrech |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
/** @addtogroup net |
* @{ |
*/ |
/** @file |
*/ |
#include <async.h> |
#include <errno.h> |
#include <unistd.h> |
//#include <stdio.h> |
#include <string.h> |
#include <ipc/ipc.h> |
#include <ipc/services.h> |
#include <sys/mman.h> |
#include "../../err.h" |
#include "../../messages.h" |
#include "packet.h" |
#include "packet_header.h" |
#include "packet_client.h" |
int packet_return( int phone, packet_ref packet, packet_id_t packet_id, size_t size ); |
packet_t packet_copy( int phone, services_t owner, const packet_t packet ){ |
packet_t new; |
if( ! packet_is_valid( packet )) return NULL; |
// new = ( packet_t ) mmap( NULL, packet->length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 ); |
// if( new == MAP_FAILED ) return NULL; |
// memcpy( new, packet, packet->length ); |
new = packet_get_1( phone, owner, packet_get_data_length( packet )); |
packet_copy_data( new, packet_get_data( packet ), packet_get_data_length( packet )); |
return new; |
} |
int packet_copy_data( packet_t packet, const void * data, size_t length ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
if( packet->data_start + length >= packet->length ) return ENOMEM; |
memcpy(( void * ) packet + packet->data_start, data, length ); |
if( packet->data_start + length > packet->data_end ){ |
packet->data_end = packet->data_start + length; |
} |
return EOK; |
} |
void * packet_prepend( packet_t packet, size_t length ){ |
if(( ! packet_is_valid( packet )) || ( packet->data_start - sizeof( struct packet ) - 2 * packet->addr_len < length )) return NULL; |
packet->data_start -= length; |
return ( void * ) packet + packet->data_start; |
} |
void * packet_append( packet_t packet, size_t length ){ |
if(( ! packet_is_valid( packet )) || ( packet->data_end + length >= packet->length )) return NULL; |
packet->data_end += length; |
return ( void * ) packet + packet->data_end - length; |
} |
int packet_trim( packet_t packet, size_t prefix, size_t sufix ){ |
if(( ! packet_is_valid( packet )) || ( prefix + sufix > packet->data_end - packet->data_start )) return EINVAL; |
packet->data_start += prefix; |
packet->data_end -= sufix; |
return EOK; |
} |
packet_id_t packet_get_id( packet_t packet ){ |
return packet_is_valid( packet ) ? packet->packet_id : 0; |
} |
int packet_get_addr( const packet_t packet, uint8_t ** src, uint8_t ** dest ){ |
if( !( packet_is_valid( packet ) && src && dest )) return 0; |
* src = ( void * ) packet + packet->src_addr; |
* dest = ( void * ) packet + packet->dest_addr; |
return packet->addr_len; |
} |
size_t packet_get_data_length( const packet_t packet ){ |
if( ! packet_is_valid( packet )) return 0; |
return packet->data_end - packet->data_start; |
} |
void * packet_get_data( const packet_t packet ){ |
if( ! packet_is_valid( packet )) return NULL; |
return ( void * ) packet + packet->data_start; |
} |
packet_mode_t packet_get_mode( const packet_t packet ){ |
if( packet_is_valid( packet )) return packet->mode; |
return PM_ONEWAY; |
} |
int packet_set_addr( packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len ){ |
size_t padding; |
if( !( packet_is_valid( packet ) && ( packet->addr_len >= addr_len ))) return EINVAL; |
padding = packet->addr_len - addr_len; |
if( src ){ |
memcpy(( void * ) packet + packet->src_addr, src, addr_len ); |
memset(( void * ) packet + packet->src_addr + addr_len, 0, padding ); |
}else{ |
memset(( void * ) packet + packet->src_addr + addr_len, 0, packet->addr_len ); |
} |
if( dest ){ |
memcpy(( void * ) packet + packet->dest_addr, dest, addr_len ); |
memset(( void * ) packet + packet->dest_addr + addr_len, 0, padding ); |
}else{ |
memset(( void * ) packet + packet->dest_addr + addr_len, 0, packet->addr_len ); |
} |
return EOK; |
} |
int packet_set_mode( packet_t packet, packet_mode_t mode ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
packet->mode = mode; |
return EOK; |
} |
int packet_set_owner( packet_t packet, services_t owner ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
packet->owner = owner; |
return EOK; |
} |
int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){ |
ERROR_DECLARE; |
unsigned int size; |
if( ! packet ) return EINVAL; |
* packet = pm_find( packet_id ); |
if( * packet ) return EOK; |
ERROR_PROPAGATE( async_req_1_1( phone, NET_PACKET_GET_SIZE, packet_id, & size )); |
return packet_return( phone, packet, packet_id, size ); |
} |
int packet_return( int phone, packet_ref packet, packet_id_t packet_id, size_t size ){ |
ERROR_DECLARE; |
aid_t message; |
ipc_call_t answer; |
message = async_send_1( phone, NET_PACKET_GET, packet_id, & answer ); |
* packet = ( packet_t ) as_get_mappable_page( size ); |
if( ERROR_OCCURED( ipc_share_in_start_0_0( phone, * packet, size )) |
|| ERROR_OCCURED( pm_add( * packet ))){ |
munmap( * packet, size ); |
async_wait_for( message, NULL ); |
return ERROR_CODE; |
} |
async_wait_for( message, NULL ); |
return EOK; |
} |
packet_t packet_get_5( int phone, services_t owner, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_sufix ){ |
ERROR_DECLARE; |
packet_id_t packet_id; |
unsigned int size; |
packet_t packet; |
if( ERROR_OCCURED( async_req_5_2( phone, NET_PACKET_CREATE_5, owner, max_content, addr_len, max_prefix, max_sufix, & packet_id, & size )) |
|| ERROR_OCCURED( packet_return( phone, & packet, packet_id, size ))){ |
return NULL; |
} |
return packet; |
} |
packet_t packet_get_1( int phone, services_t owner, size_t content ){ |
ERROR_DECLARE; |
packet_id_t packet_id; |
unsigned int size; |
packet_t packet; |
if( ERROR_OCCURED( async_req_2_2( phone, NET_PACKET_CREATE_1, owner, content, & packet_id, & size )) |
|| ERROR_OCCURED( packet_return( phone, & packet, packet_id, size ))){ |
return NULL; |
} |
return packet; |
} |
void packet_release( int phone, packet_id_t packet_id ){ |
async_msg_1( phone, NET_PACKET_RELEASE, packet_id ); |
} |
/** @} |
*/ |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/branches/network/uspace/srv/net/structures/packet/packet.c |
---|
27,7 → 27,7 |
*/ |
/** @addtogroup net |
* @{ |
* @{ |
*/ |
/** @file |
34,124 → 34,167 |
*/ |
#include <errno.h> |
#include <unistd.h> |
#include <malloc.h> |
//#include <stdio.h> |
#include <string.h> |
#include <ipc/ipc.h> |
#include <sys/mman.h> |
#include "../../err.h" |
#include "../generic_field.h" |
#include "packet_header.h" |
#include "packet.h" |
#define PACKET_MAGIC_VALUE 0x11227788 |
// TODO power of 2 aritmetic => div and mod speedup? |
#define PACKET_MAP_SIZE 100 |
struct packet{ |
size_t length; |
size_t max_prefix; |
size_t max_content; |
size_t data_start; |
size_t data_end; |
int magic_value; |
}; |
#define PACKET_MAP_PAGE( packet_id ) ((( packet_id ) - 1 ) / PACKET_MAP_SIZE ) |
#define PACKET_MAP_INDEX( packet_id ) ((( packet_id ) - 1 ) % PACKET_MAP_SIZE ) |
int packet_is_valid( packet_t packet ); |
packet_t packet_create( size_t max_prefix, size_t max_content, size_t max_sufix ){ |
size_t length; |
packet_t packet; |
int packet_destroy( packet_t packet ); |
length = max_prefix + max_content + max_sufix; |
packet = ( packet_t ) mmap( NULL, sizeof( struct packet ) + length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 ); |
if( packet == MAP_FAILED ) return NULL; |
packet->length = length; |
packet->max_prefix = max_prefix; |
packet->max_content = max_content; |
packet->data_start = sizeof( struct packet ) + packet->max_prefix; |
packet->data_end = packet->data_start; |
packet->magic_value = PACKET_MAGIC_VALUE; |
return packet; |
typedef packet_t packet_map_t[ PACKET_MAP_SIZE ]; |
typedef packet_map_t * packet_map_ref; |
GENERIC_FIELD_DECLARE( gpm, packet_map_t ); |
GENERIC_FIELD_IMPLEMENT( gpm, packet_map_t ); |
static struct{ |
// TODO lock |
gpm_t map; |
} pm_globals; |
int packet_destroy( packet_t packet ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
return munmap( packet, packet->length ); |
} |
int packet_is_valid( packet_t packet ){ |
return packet && ( packet->magic_value == PACKET_MAGIC_VALUE ); |
int pm_init( void ){ |
return gpm_initialize( & pm_globals.map ); |
} |
packet_t packet_copy( packet_t packet ){ |
packet_t new; |
packet_t pm_find( packet_id_t packet_id ){ |
packet_map_ref map; |
if( ! packet_is_valid( packet )) return NULL; |
new = ( packet_t ) mmap( NULL, packet->length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 ); |
if( new == MAP_FAILED ) return NULL; |
memcpy( new, packet, packet->length ); |
return new; |
if( ! packet_id ) return NULL; |
if( packet_id > PACKET_MAP_SIZE * gpm_count( & pm_globals.map )) return NULL; |
map = gpm_get_index( & pm_globals.map, PACKET_MAP_PAGE( packet_id )); |
if( ! map ) return NULL; |
return ( * map )[ PACKET_MAP_INDEX( packet_id ) ]; |
} |
int packet_copy_data( packet_t packet, void * data, size_t length ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
if( packet->data_start + length >= (( size_t ) packet ) + packet->length ) return ENOMEM; |
memcpy( packet + packet->data_start, data, length ); |
if( packet->data_start + length > packet->data_end ){ |
packet->data_end = packet->data_start + length; |
int pm_add( packet_t packet ){ |
ERROR_DECLARE; |
packet_map_ref map; |
if(( ! packet_is_valid( packet )) || ( gpm_count( & pm_globals.map ) < -1 )) return EINVAL; |
if( PACKET_MAP_PAGE( packet->packet_id ) < gpm_count( & pm_globals.map )){ |
map = gpm_get_index( & pm_globals.map, PACKET_MAP_PAGE( packet->packet_id )); |
}else{ |
do{ |
map = ( packet_map_ref ) malloc( sizeof( packet_map_t )); |
if( ! map ) return ENOMEM; |
memset( map, 0, sizeof( packet_map_t )); |
if(( ERROR_CODE = gpm_add( & pm_globals.map, map )) < 0 ){ |
free( map ); |
return ERROR_CODE; |
} |
}while( PACKET_MAP_PAGE( packet->packet_id ) >= gpm_count( & pm_globals.map )); |
} |
( * map )[ PACKET_MAP_INDEX( packet->packet_id ) ] = packet; |
return EOK; |
} |
void * packet_prepend( packet_t packet, size_t length ){ |
if(( ! packet_is_valid( packet )) || ( packet->data_start - sizeof( struct packet ) < length )) return NULL; |
packet->data_start -= length; |
return packet + packet->data_start; |
} |
void pm_destroy( void ){ |
int count; |
int index; |
packet_map_ref map; |
packet_t packet; |
void * packet_append( packet_t packet, size_t length ){ |
if(( ! packet_is_valid( packet )) || ( packet->data_end + length >= (( size_t ) packet ) + packet->length )) return NULL; |
packet->data_end += length; |
return packet + packet->data_end - length; |
count = gpm_count( & pm_globals.map ); |
while( count > 0 ){ |
map = gpm_get_index( & pm_globals.map, count - 1 ); |
for( index = PACKET_MAP_SIZE - 1; index >= 0; -- index ){ |
packet = ( * map )[ index ]; |
if( packet_is_valid( packet )){ |
munmap( packet, packet->length ); |
} |
} |
} |
gpm_destroy( & pm_globals.map ); |
} |
int packet_trim( packet_t packet, size_t prefix, size_t sufix ){ |
if(( ! packet_is_valid( packet )) || ( prefix + sufix > packet->data_end - packet->data_start )) return EINVAL; |
packet->data_start += prefix; |
packet->data_end -= sufix; |
return EOK; |
} |
packet_t pq_add( packet_t first, packet_t packet, int order, size_t metric ){ |
packet_t item; |
int packet_send( packet_t packet, int phone ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
return ipc_share_out_start( phone, packet, PROTO_READ | PROTO_WRITE ); |
if( ! packet_is_valid( packet )) return NULL; |
pq_set( packet, order, metric ); |
if( packet_is_valid( first )){ |
item = first; |
do{ |
if( item->order < order ){ |
if( item->next ){ |
item = pm_find( item->next ); |
}else{ |
item->next = packet->packet_id; |
packet->previous = item->packet_id; |
return first; |
} |
}else{ |
packet->previous = item->previous; |
packet->next = item->packet_id; |
item->previous = packet->packet_id; |
item = pm_find( packet->previous ); |
if( item ) item->next = packet->packet_id; |
return item; |
} |
}while( packet_is_valid( item )); |
} |
return packet; |
} |
int packet_receive( packet_ref packet ){ |
ERROR_DECLARE; |
packet_t pq_detach( packet_t packet ){ |
packet_t next; |
packet_t previous; |
ipc_callid_t callid; |
size_t size; |
int flags; |
if( ! packet ) return EINVAL; |
if( ! ipc_share_out_receive( & callid, & size, & flags )) return EINVAL; |
* packet = ( packet_t ) as_get_mappable_page( size ); |
if( !( * packet )) return ENOMEM; |
if( ERROR_OCCURED( ipc_share_out_finalize( callid, * packet ))){ |
munmap( * packet, size ); |
return ERROR_CODE; |
if( ! packet_is_valid( packet )) return NULL; |
next = pm_find( packet->next ); |
if( next ){ |
next->previous = packet->previous; |
previous = pm_find( next->previous ); |
if( previous ){ |
previous->next = next->packet_id; |
} |
} |
return EOK; |
packet->previous = 0; |
packet->next = 0; |
return next; |
} |
int packet_destroy( packet_t packet ){ |
int pq_set( packet_t packet, int order, size_t metric ){ |
if( ! packet_is_valid( packet )) return EINVAL; |
return munmap( packet, sizeof( struct packet ) + packet->length ); |
packet->order = order; |
packet->metric = metric; |
return EOK; |
} |
size_t packet_get_data_length( packet_t packet ){ |
if( ! packet_is_valid( packet )) return 0; |
return packet->data_end - packet->data_start; |
} |
void pq_destroy( packet_t first, void ( * packet_release )( packet_t packet )){ |
packet_t actual; |
packet_t next; |
void * packet_get_data( packet_t packet ){ |
if( ! packet_is_valid( packet )) return NULL; |
return packet + packet->data_start; |
actual = first; |
while( packet_is_valid( actual )){ |
next = pm_find( actual->next ); |
actual->next = 0; |
actual->previous = 0; |
if( packet_release ) packet_release( actual ); |
actual = next; |
} |
} |
/** @} |
/branches/network/uspace/srv/net/structures/packet/packet_client.h |
---|
0,0 → 1,68 |
/* |
* Copyright (c) 2008 Lukas Mejdrech |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
/** @addtogroup net |
* @{ |
*/ |
/** @file |
*/ |
#ifndef __NET_PACKET_CLIENT_H__ |
#define __NET_PACKET_CLIENT_H__ |
#include "packet.h" |
#define PACKET_PREPEND( packet, type ) ( type * ) packet_prepend(( packet ), sizeof( type )) |
#define PACKET_APPEND( packet, type ) ( type * ) packet_append(( packet ), sizeof( type )) |
#define PACKET_TRIM( packet, prefix, sufix ) packet_trim(( packet ), sizeof( prefix ), sizeof( sufix )) |
void * packet_prepend( packet_t packet, size_t length ); |
void * packet_append( packet_t packet, size_t length ); |
packet_t packet_copy( int phone, services_t owner, const packet_t packet ); |
int packet_copy_data( packet_t packet, const void * data, size_t length ); |
int packet_trim( packet_t packet, size_t prefix, size_t sufix ); |
int packet_destroy( packet_t packet ); |
packet_id_t packet_get_id( packet_t packet ); |
size_t packet_get_data_length( const packet_t packet ); |
void * packet_get_data( const packet_t packet ); |
int packet_get_addr( const packet_t packet, uint8_t ** src, uint8_t ** dest ); |
packet_mode_t packet_get_mode( const packet_t packet ); |
int packet_set_addr( packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len ); |
int packet_set_mode( packet_t packet, packet_mode_t mode ); |
int packet_set_owner( packet_t packet, services_t owner ); |
int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ); |
packet_t packet_get_5( int phone, services_t owner, size_t max_content, size_t addr_len, size_t max_prefix, size_t max_sufix ); |
packet_t packet_get_1( int phone, services_t owner, size_t content ); |
void packet_release( int phone, packet_id_t packet_id ); |
#endif |
/** @} |
*/ |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/branches/network/uspace/srv/net/structures/packet/packet.h |
---|
27,7 → 27,7 |
*/ |
/** @addtogroup net |
* @{ |
* @{ |
*/ |
/** @file |
36,26 → 36,28 |
#ifndef __NET_PACKET_H__ |
#define __NET_PACKET_H__ |
#define PACKET_PREPEND( packet, type ) ( type * ) packet_prepend(( packet ), sizeof( type )) |
#define PACKET_APPEND( packet, type ) ( type * ) packet_append(( packet ), sizeof( type )) |
#define PACKET_TRIM( packet, prefix, sufix ) packet_trim(( packet ), sizeof( prefix ), sizeof( sufix )) |
typedef unsigned int packet_id_t; |
typedef struct packet * packet_t; |
typedef packet_t * packet_ref; |
packet_t packet_create( size_t max_prefix, size_t max_content, size_t max_sufix ); |
void * packet_prepend( packet_t packet, size_t length ); |
void * packet_append( packet_t packet, size_t length ); |
packet_t packet_copy( packet_t packet ); |
int packet_copy_data( packet_t packet, void * data, size_t length ); |
// TODO protocol identification? |
int packet_send( packet_t packet, int phone ); |
int packet_receive( packet_ref packet ); |
int packet_trim( packet_t packet, size_t prefix, size_t sufix ); |
int packet_destroy( packet_t packet ); |
size_t packet_get_data_length( packet_t packet ); |
void * packet_get_data( packet_t packet ); |
typedef enum packet_mode packet_mode_t; |
enum packet_mode{ |
PM_ONEWAY, |
PM_RETURN |
}; |
packet_t pm_find( packet_id_t packet_id ); |
int pm_add( packet_t packet ); |
int pm_init( void ); |
void pm_destroy( void ); |
packet_t pq_add( packet_t first, packet_t packet, int order, size_t metric ); |
packet_t pq_detach( packet_t packet ); |
int pq_set( packet_t packet, int order, size_t metric ); |
void pq_destroy( packet_t first, void ( * packet_release )( packet_t packet )); |
#endif |
/** @} |
/branches/network/uspace/srv/net/structures/packet/packet_server.c |
---|
0,0 → 1,193 |
/* |
* Copyright (c) 2008 Lukas Mejdrech |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms, with or without |
* modification, are permitted provided that the following conditions |
* are met: |
* |
* - Redistributions of source code must retain the above copyright |
* notice, this list of conditions and the following disclaimer. |
* - Redistributions in binary form must reproduce the above copyright |
* notice, this list of conditions and the following disclaimer in the |
* documentation and/or other materials provided with the distribution. |
* - The name of the author may not be used to endorse or promote products |
* derived from this software without specific prior written permission. |
* |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
*/ |
/** @addtogroup net |
* @{ |
*/ |
/** @file |
*/ |
#include <async.h> |
#include <align.h> |
#include <errno.h> |
//#include <stdio.h> |
#include <unistd.h> |
#include <ipc/ipc.h> |
#include <ipc/services.h> |
#include <sys/mman.h> |
#include "../../err.h" |
#include "../../messages.h" |
#include "packet.h" |
#include "packet_header.h" |
#include "packet_server.h" |
#define IPC_GET_ID( call ) ( packet_id_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_OWNER( call ) ( services_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_CONTENT( call ) ( size_t ) IPC_GET_ARG2( * call ) |
#define IPC_GET_ADDR_LEN( call ) ( size_t ) IPC_GET_ARG3( * call ) |
#define IPC_GET_PREFIX( call ) ( size_t ) IPC_GET_ARG4( * call ) |
#define IPC_GET_SUFIX( call ) ( size_t ) IPC_GET_ARG5( * call ) |
#define FREE_QUEUES_COUNT 7 |
static struct{ |
packet_t free[ FREE_QUEUES_COUNT ]; |
int sizes[ FREE_QUEUES_COUNT ]; |
unsigned int count; |
} ps_globals = { |
{ NULL, NULL, NULL, NULL, NULL, NULL, NULL }, |
{ PAGE_SIZE, PAGE_SIZE * 2, PAGE_SIZE * 4, PAGE_SIZE * 8, PAGE_SIZE * 16, PAGE_SIZE * 32, PAGE_SIZE * 64 }, |
0 |
}; |
void packet_release( packet_t packet ); |
packet_t packet_get( services_t owner, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_sufix ); |
packet_t packet_create( size_t length, services_t owner, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_sufix ); |
void packet_init( packet_t packet, services_t owner, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_sufix ); |
int packet_reply( const packet_t packet ); |
int packet_server_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){ |
packet_t packet; |
* answer_count = 0; |
switch( IPC_GET_METHOD( * call )){ |
case IPC_M_PHONE_HUNGUP: |
return EOK; |
case NET_PACKET_CREATE_1: |
packet = packet_get( IPC_GET_OWNER( call ), 0, 0, IPC_GET_CONTENT( call ), 0 ); |
if( ! packet ) return ENOMEM; |
* answer_count = 2; |
IPC_SET_ARG1( * answer, packet->packet_id ); |
IPC_SET_ARG2( * answer, packet->length ); |
return EOK; |
case NET_PACKET_CREATE_5: |
packet = packet_get( IPC_GET_OWNER( call ), IPC_GET_ADDR_LEN( call ), IPC_GET_PREFIX( call ), IPC_GET_CONTENT( call ), IPC_GET_SUFIX( call )); |
if( ! packet ) return ENOMEM; |
* answer_count = 2; |
IPC_SET_ARG1( * answer, packet->packet_id ); |
IPC_SET_ARG2( * answer, packet->length ); |
return EOK; |
case NET_PACKET_GET: |
packet = pm_find( IPC_GET_ID( call )); |
if( ! packet_is_valid( packet )) return ENOENT; |
return packet_reply( packet ); |
case NET_PACKET_GET_SIZE: |
packet = pm_find( IPC_GET_ID( call )); |
if( ! packet_is_valid( packet )) return ENOENT; |
* answer_count = 1; |
IPC_SET_ARG1( * answer, packet->length ); |
return EOK; |
case NET_PACKET_RELEASE: |
packet = pm_find( IPC_GET_ID( call )); |
if( ! packet_is_valid( packet )) return ENOENT; |
pq_destroy( packet, packet_release ); |
return EOK; |
} |
return ENOTSUP; |
} |
void packet_release( packet_t packet ){ |
int index; |
for( index = 0; ( index < FREE_QUEUES_COUNT - 1 ) && ( packet->length > ps_globals.sizes[ index ] ); ++ index ); |
ps_globals.free[ index ] = pq_add( ps_globals.free[ index ], packet, packet->length, packet->length ); |
} |
packet_t packet_get( services_t owner, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_sufix ){ |
int index; |
packet_t packet; |
size_t length; |
length = ALIGN_UP( sizeof( struct packet ) + 2 * addr_len + max_prefix + max_content + max_sufix, PAGE_SIZE ); |
for( index = 0; index < FREE_QUEUES_COUNT - 1; ++ index ){ |
if( length <= ps_globals.sizes[ index ] ){ |
packet = ps_globals.free[ index ]; |
while( packet_is_valid( packet ) && ( packet->length < length )){ |
packet = pm_find( packet->next ); |
} |
if( packet ){ |
packet_init( packet, owner, addr_len, max_prefix, max_content, max_sufix ); |
return packet; |
} |
} |
} |
return packet_create( length, owner, addr_len, max_prefix, max_content, max_sufix ); |
} |
packet_t packet_create( size_t length, services_t owner, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_sufix ){ |
ERROR_DECLARE; |
packet_t packet; |
packet = ( packet_t ) mmap( NULL, length, PROTO_READ | PROTO_WRITE, MAP_SHARED | MAP_ANONYMOUS, 0, 0 ); |
if( packet == MAP_FAILED ) return NULL; |
++ ps_globals.count; |
packet->packet_id = ps_globals.count; |
packet->mode = PM_ONEWAY; |
packet->length = length; |
packet_init( packet, owner, addr_len, max_prefix, max_content, max_sufix ); |
packet->magic_value = PACKET_MAGIC_VALUE; |
if( ERROR_OCCURED( pm_add( packet ))){ |
munmap( packet, packet->length ); |
return NULL; |
} |
packet_release( packet ); |
return packet; |
} |
void packet_init( packet_t packet, services_t owner, size_t addr_len, size_t max_prefix, size_t max_content, size_t max_sufix ){ |
packet->owner = owner; |
packet->order = 0; |
packet->metric = 0; |
packet->previous = 0; |
packet->next = 0; |
packet->addr_len = addr_len; |
packet->src_addr = sizeof( struct packet ); |
packet->dest_addr = packet->src_addr + packet->addr_len; |
packet->max_prefix = max_prefix; |
packet->max_content = max_content; |
packet->data_start = packet->dest_addr + packet->addr_len + packet->max_prefix; |
packet->data_end = packet->data_start; |
} |
int packet_reply( const packet_t packet ){ |
ipc_callid_t callid; |
size_t size; |
if( ! packet_is_valid( packet )) return EINVAL; |
if( ipc_share_in_receive( & callid, & size ) <= 0 ) return EINVAL; |
if( size != packet->length ) return ENOMEM; |
return ipc_share_in_finalize( callid, packet, PROTO_READ | PROTO_WRITE ); |
} |
/** @} |
*/ |
Property changes: |
Added: svn:eol-style |
+native |
\ No newline at end of property |
/branches/network/uspace/srv/net/networking/networking.c |
---|
52,6 → 52,8 |
#include "../structures/char_map.h" |
#include "../structures/generic_char_map.h" |
#include "../structures/measured_strings.h" |
#include "../structures/packet/packet.h" |
#include "../structures/packet/packet_server.h" |
#include "../il/ip/ip_messages.h" |
#include "../netif/device.h" |
68,6 → 70,8 |
#endif |
#define NAME "Networking" |
#define LO_NAME "lo" |
#define LO_FILENAME "/sbin/lo" |
#define DP8390_ISA_NAME "dp8390_isa" |
77,6 → 81,9 |
#define IP_NAME "ip" |
#define IP_FILENAME "/sbin/ip" |
#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_COUNT( call ) ( int ) IPC_GET_ARG2( * call ) |
typedef struct module_struct module_t; |
typedef module_t * module_ref; |
140,12 → 147,14 |
measured_strings_t configuration; |
}; |
void networking_print_name( void ); |
int add_module( module_ref * module, modules_ref modules, const char const * name, const char const * filename, services_t service, task_id_t task_id ); |
static void client_connection( ipc_callid_t iid, ipc_call_t * icall ); |
measured_string_ref configuration_find( measured_strings_ref configuration, const char * name ); |
int main( int argc, char * argv[] ); |
int networking_start_module( async_client_conn_t client_connection ); |
int networking_initialize( void ); |
int networking_message( ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t * result1, ipcarg_t * result2, ipcarg_t * result3 ); |
int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ); |
int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ); |
//int parse_line( measured_strings_ref configuration, char * line ); |
int add_configuration( measured_strings_ref configuration, const char * name, const char * value ); |
int read_configuration( void ); |
161,6 → 170,10 |
GENERIC_CHAR_MAP_IMPLEMENT( modules, module_t ) |
void networking_print_name( void ){ |
printf( NAME ); |
} |
int add_module( module_ref * module, modules_ref modules, const char * name, const char * filename, services_t service, task_id_t task_id ){ |
ERROR_DECLARE; |
182,63 → 195,46 |
return EOK; |
} |
static void client_connection( ipc_callid_t iid, ipc_call_t * icall ){ |
ipc_callid_t callid; |
ipc_call_t call; |
ipcarg_t arg1, arg2, arg3; |
int res; |
/* |
* Accept the connection |
* - Answer the first IPC_M_CONNECT_ME_TO call. |
*/ |
// printf( "\nNET-%d got %d on %x from %x", fibril_get_id(), IPC_GET_METHOD( * icall ), icall->in_phone_hash, iid ); |
ipc_answer_0( iid, EOK ); |
while( true ){ |
callid = async_get_call( & call ); |
arg1 = 0; |
arg2 = 0; |
arg3 = 0; |
// printf( "\nNET-%d got %d on %x from %x", fibril_get_id(), IPC_GET_METHOD( call ), call.in_phone_hash, callid ); |
int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){ |
#ifdef NETWORKING_module |
//TODO map to *_message |
if( IS_NET_IL_MESSAGE( call ) || IS_NET_IP_MESSAGE( call )){ |
res = ip_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return ip_message( callid, call, answer, answer_count ); |
/* }else if( IS_NET_ARP_MESSAGE( call )){ |
res = arp_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return arp_message( callid, call, answer, answer_count ); |
*//* }else if( IS_NET_RARP_MESSAGE( call )){ |
res = rarp_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return rarp_message( callid, call, answer, answer_count ); |
*//* }else if( IS_NET_ICMP_MESSAGE( call )){ |
res = icmp_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return icmp_message( callid, call, answer, answer_count ); |
*//* }else if( IS_NET_UDP_MESSAGE( call )){ |
res = udp_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return udp_message( callid, call, answer, answer_count ); |
*/ }else if( IS_NET_TCP_MESSAGE( call )){ |
res = tcp_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return tcp_message( callid, call, answer, answer_count ); |
/* }else if( IS_NET_SOCKET_MESSAGE( call )){ |
res = socket_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return socket_message( callid, call, answer, answer_count ); |
*//* }else if( IS_NET_NIL_MESSAGE( call ) || IS_NET_ETHERNET_MESSAGE( call )){ |
res = ethernet_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
return ethernet_message( callid, call, answer, answer_count ); |
*/ }else{ |
#endif |
res = networking_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 ); |
if( IS_NET_PACKET_MESSAGE( call )){ |
return packet_server_message( callid, call, answer, answer_count ); |
}else{ |
return net_message( callid, call, answer, answer_count ); |
} |
#ifdef NETWORKING_module |
} |
#endif |
ipc_answer_2( callid, res, arg1, arg2 ); |
} |
} |
int main( int argc, char * argv[] ){ |
int networking_start_module( async_client_conn_t client_connection ){ |
ERROR_DECLARE; |
ipcarg_t phonehash; |
printf("\nTask %d - HelenOS Networking subsystem", task_get_id()); |
async_set_client_connection( client_connection ); |
ERROR_PROPAGATE( networking_initialize()); |
ERROR_PROPAGATE( REGISTER_ME( SERVICE_NETWORKING, & phonehash )); |
ERROR_PROPAGATE( pm_init()); |
async_manager(); |
return EOK; |
300,7 → 296,8 |
return EOK; |
} |
int networking_message( ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t * result1, ipcarg_t * result2, ipcarg_t * result3 ){ |
//TODO as ip.c |
int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){ |
ERROR_DECLARE; |
measured_string_ref strings; |
310,25 → 307,23 |
measured_strings_ref configuration; |
netif_ref netif; |
switch( method ){ |
* answer_count = 0; |
switch( IPC_GET_METHOD( * call )){ |
case IPC_M_PHONE_HUNGUP: |
return EOK; |
case NET_NET_DEVICE: |
// TODO configure, register |
// arg1 = netif id |
printf( "\nNetworking: new netif %d", arg1 ); |
printf( "\nNetworking: new netif %d", IPC_GET_DEVICE( call )); |
return EOK; |
case NET_NET_GET_DEVICE_CONF: |
// arg1 = netif id |
// arg2 = count |
ERROR_PROPAGATE( measured_strings_receive( & strings, & data, arg2 )); |
netif = netifs_find( & networking_globals.netifs, arg1 ); |
ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call ))); |
netif = netifs_find( & networking_globals.netifs, IPC_GET_DEVICE( call )); |
if( netif ){ |
configuration = & netif->configuration; |
}else{ |
configuration = NULL; |
} |
for( index = 0; index < arg2; ++ index ){ |
for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){ |
setting = measured_strings_find( configuration, strings[ index ].value, 0 ); |
if( ! setting ){ |
setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 ); |
343,13 → 338,13 |
} |
// strings should not contain received data anymore |
free( data ); |
ERROR_CODE = measured_strings_reply( strings, arg2 ); |
ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call )); |
free( strings ); |
return ERROR_CODE; |
case NET_NET_GET_CONF: |
// arg1 = count |
ERROR_PROPAGATE( measured_strings_receive( & strings, & data, arg1 )); |
for( index = 0; index < arg1; ++ index ){ |
ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call ))); |
for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){ |
setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 ); |
if( setting ){ |
strings[ index ].length = setting->length; |
361,7 → 356,7 |
} |
// strings should not contain received data anymore |
free( data ); |
ERROR_CODE = measured_strings_reply( strings, arg1 ); |
ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call )); |
free( strings ); |
return ERROR_CODE; |
case NET_NET_STARTUP: |
/branches/network/uspace/srv/net/networking/Makefile |
---|
26,6 → 26,8 |
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
# |
NAME = networking |
## Setup toolchain |
# |
39,14 → 41,19 |
## Sources |
# |
OUTPUT = networking |
OUTPUT = $(NAME) |
SOURCES = \ |
networking.c \ |
$(NAME).c \ |
../module.c \ |
../modules.c \ |
../structures/char_map.c \ |
../structures/measured_strings.c |
../structures/measured_strings.c \ |
../structures/packet/packet.c \ |
../structures/packet/packet_server.c |
# ../self_test.c |
DEFS += -D $(NAME)_message=module_message -D $(NAME)_start_module=module_start -D $(NAME)_print_name=module_print_name |
DEFS += -D NETWORKING_$(NETWORKING) |
ifeq ($(NETWORKING), module) |
/branches/network/uspace/srv/net/messages.h |
---|
47,6 → 47,7 |
#define NET_ICMP_COUNT 0 |
#define NET_UDP_COUNT 0 |
#define NET_TCP_COUNT 0 |
#define NET_PACKET_COUNT 5 |
#define NET_SOCKET_COUNT 0 |
#define NET_FIRST 2000 |
81,23 → 82,27 |
#define NET_SOCKET_FIRST ( NET_TCP_LAST + 0 ) |
#define NET_SOCKET_LAST ( NET_SOCKET_FIRST + NET_SOCKET_COUNT ) |
#define NET_LAST NET_SOCKET_LAST |
#define NET_PACKET_FIRST ( NET_SOCKET_LAST + 0 ) |
#define NET_PACKET_LAST ( NET_PACKET_FIRST + NET_PACKET_COUNT ) |
#define NET_LAST NET_PACKET_LAST |
#define NET_COUNT ( NET_LAST - NET_FIRST ) |
#define IS_IN_INTERVAL( item, first_inclusive, last_exclusive ) ((( item ) >= ( first_inclusive )) && (( item ) < ( last_exclusive ))) |
#define IS_NET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_FIRST, NET_LAST ) |
#define IS_NET_NET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_NET_FIRST, NET_NET_LAST ) |
#define IS_NET_NIL_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_NIL_FIRST, NET_NIL_LAST ) |
#define IS_NET_ETH_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_ETH_FIRST, NET_ETH_LAST ) |
#define IS_NET_IL_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_IL_FIRST, NET_IL_LAST ) |
#define IS_NET_IP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_IP_FIRST, NET_IP_LAST ) |
#define IS_NET_ARP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_ARP_FIRST, NET_ARP_LAST ) |
#define IS_NET_RARP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_RARP_FIRST, NET_RARP_LAST ) |
#define IS_NET_UDP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_UDP_FIRST, NET_UDP_LAST ) |
#define IS_NET_TCP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_TCP_FIRST, NET_TCP_LAST ) |
#define IS_NET_SOCKET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_SOCKET_FIRST, NET_SOCKET_LAST ) |
#define IS_NET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_FIRST, NET_LAST ) |
#define IS_NET_NET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_NET_FIRST, NET_NET_LAST ) |
#define IS_NET_NIL_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_NIL_FIRST, NET_NIL_LAST ) |
#define IS_NET_ETH_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_ETH_FIRST, NET_ETH_LAST ) |
#define IS_NET_IL_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_IL_FIRST, NET_IL_LAST ) |
#define IS_NET_IP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_IP_FIRST, NET_IP_LAST ) |
#define IS_NET_ARP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_ARP_FIRST, NET_ARP_LAST ) |
#define IS_NET_RARP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_RARP_FIRST, NET_RARP_LAST ) |
#define IS_NET_UDP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_UDP_FIRST, NET_UDP_LAST ) |
#define IS_NET_TCP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_TCP_FIRST, NET_TCP_LAST ) |
#define IS_NET_SOCKET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_SOCKET_FIRST, NET_SOCKET_LAST ) |
#define IS_NET_PACKET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( * call ), NET_PACKET_FIRST, NET_PACKET_LAST ) |
typedef enum { |
/* ( device_id, irq, io ) */ |
104,7 → 109,7 |
NET_NETIF_PROBE = NET_NETIF_FIRST, |
/* () not supported, should ask networking for a name and register device */ |
NET_NETIF_PROBE_AUTO, |
/* ( device_id ), packet_send */ |
/* ( device_id, packet_id ) */ |
NET_NETIF_SEND, |
/* ( device_id ) */ |
NET_NETIF_START, |
114,13 → 119,13 |
NET_NETIF_STOP, |
/* () not supported, registers new device */ |
NET_NET_DEVICE = NET_NET_FIRST, |
/* (), measured_strings_send( names ), measured_strings_return( values ) */ |
/* ( NULL, count ), measured_strings_send( names ), measured_strings_return( values ) */ |
NET_NET_GET_CONF, |
/* ( device_id ), measured_strings_send( names ), measured_strings_return( values ) */ |
/* ( device_id, count ), measured_strings_send( names ), measured_strings_return( values ) */ |
NET_NET_GET_DEVICE_CONF, |
/* () not supported, measured_strings_send( names ), measured_strings_send( values ) */ |
NET_NET_SET_CONF, |
/* ( device_id ) not supported, measured_strings_send( names ), measured_strings_send( values ) */ |
/* ( device_id, count ) not supported, measured_strings_send( names ), measured_strings_send( values ) */ |
NET_NET_SET_DEVICE_CONF, |
/* () */ |
NET_NET_STARTUP, |
157,6 → 162,7 |
/* ( device_id ), measured_strings_send( address ) */ |
// NET_IL_MY_ADDR, |
NET_IP_ECHO = NET_IP_FIRST, |
/* ( packet_id ) */ |
NET_IP_SEND, |
/* ( device_id, nil_service, proto ), measured_strings_send( proto_addr ) */ |
NET_ARP_DEVICE = NET_ARP_FIRST, |
165,8 → 171,13 |
/* ( device_id ) */ |
NET_ARP_CLEAR_DEVICE, |
/* () */ |
NET_ARP_CLEAN_CACHE |
} net_message; |
NET_ARP_CLEAN_CACHE, |
NET_PACKET_CREATE_1 = NET_PACKET_FIRST, |
NET_PACKET_CREATE_5, |
NET_PACKET_GET, |
NET_PACKET_GET_SIZE, |
NET_PACKET_RELEASE |
} net_messages; |
#endif |
/branches/network/uspace/srv/net/il/arp/arp.c |
---|
51,6 → 51,7 |
#include "../../structures/measured_strings.h" |
#include "../../structures/packet/packet.h" |
#include "../../structures/packet/packet_client.h" |
#include "arp.h" |
#include "arp_header.h" |
59,6 → 60,7 |
#include "arp_module.h" |
#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG2( * call ) |
#define IPC_GET_PROTO( call ) ( services_t ) IPC_GET_ARG2( * call ) |
#define IPC_GET_SERVICE( call ) ( services_t ) IPC_GET_ARG3( * call ) |
147,7 → 149,7 |
// bind the new one |
device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_receiver ); |
// get packet dimensions |
if( ERROR_OCCURED( async_req_1_3( device->phone, NET_NIL_PACKET_SPACE, device_id, & device->prefix, & device->content, & device->sufix ))){ |
if( ERROR_OCCURED( async_req_1_4( device->phone, NET_NIL_PACKET_SPACE, device_id, & device->addr_len, & device->prefix, & device->content, & device->sufix ))){ |
arp_protos_destroy( & device->protos ); |
free( device ); |
return ERROR_CODE; |
216,7 → 218,7 |
if( length > device->content ){ |
return NULL; |
} |
packet = packet_create( device->prefix, length, device->sufix ); |
packet = packet_get_5( arp_globals.networking_phone, SERVICE_ARP, device->addr_len, device->prefix, length, device->sufix ); |
if( ! packet ) return NULL; |
header = ( arp_header_ref ) packet_append( packet, length ); |
header->hardware = device->hardware; |
233,7 → 235,7 |
length += device->addr->length; |
memcpy((( uint8_t * ) header ) + length, target->value, target->length ); |
// TODO send to the device->broadcast_addr as arp protocol |
packet_send( packet, device->phone ); |
async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet )); |
return NULL; |
} |
311,7 → 313,9 |
memcpy( src_hw, des_hw, header->hardware_length ); |
memcpy( des_hw, hw_source->value, hw_source->length ); |
// TODO send to the hw_source as arp protocol |
packet_send( packet, device->phone ); |
async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet )); |
}else{ |
packet_release( arp_globals.networking_phone, packet_get_id( packet )); |
} |
} |
return EOK; |
414,7 → 418,7 |
//TODO clear device if off? |
break; |
case NET_IL_RECEIVED: |
if( ! ERROR_OCCURED( packet_receive( & packet ))){ |
if( ! ERROR_OCCURED( packet_translate( arp_globals.networking_phone, & packet, IPC_GET_PACKET( & call )))){ |
ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( & call ), packet ); |
} |
ipc_answer_0( callid, ERROR_CODE ); |
/branches/network/uspace/srv/net/il/arp/arp.h |
---|
64,6 → 64,7 |
ipcarg_t prefix; |
ipcarg_t content; |
ipcarg_t sufix; |
ipcarg_t addr_len; |
measured_string_ref addr; |
char * addr_data; |
measured_string_ref broadcast_addr; |
/branches/network/uspace/srv/net/il/arp/Makefile |
---|
48,7 → 48,8 |
../../modules.c \ |
../../structures/char_map.c \ |
../../structures/measured_strings.c \ |
../../structures/packet/packet.c |
../../structures/packet/packet.c \ |
../../structures/packet/packet_client.c |
DEFS += -D ARP_BUNDLE=1 -D $(NAME)_message=module_message -D $(NAME)_start_module=module_start -D $(NAME)_print_name=module_print_name |
/branches/network/uspace/srv/net/il/ip/ip_messages.h |
---|
37,6 → 37,8 |
#ifndef __NET_IP_MESSAGES_H__ |
#define __NET_IP_MESSAGES_H__ |
#include <async.h> |
#include <ipc/ipc.h> |
#include "../../err.h" |
67,22 → 69,7 |
async_req_5_5( ip_phone, NET_IP_ECHO, ( arg1 ), ( arg2 ), ( arg3 ), ( arg4 ), ( arg5 ), ( answer1 ), ( answer2 ), ( answer3 ), ( answer4 ), ( answer5 )) |
#define ip_send( ip_phone, device_id, packet ) \ |
{ \ |
ERROR_DECLARE; \ |
\ |
aid_t message; \ |
ipc_call_t answer; \ |
ipcarg_t result; \ |
\ |
message = async_send_1(( ip_phone ), NET_IP_SEND, ( device_id ), & answer ); \ |
if( ERROR_OCCURED( packet_send(( packet ), ( ip_phone )))){ \ |
async_wait_for( message, NULL ); \ |
result = ERROR_CODE; \ |
}else{ \ |
async_wait_for( message, & result ); \ |
} \ |
result; \ |
} |
async_msg_1( ip_phone, NET_IP_SEND, packet_get_id( packet )) |
#endif |
/branches/network/uspace/srv/net/il/ip/ip.c |
---|
49,7 → 49,7 |
#include "../../include/socket.h" |
#include "../../netif/device.h" |
#include "../../structures/measured_strings.h" |
#include "../../structures/packet/packet.h" |
#include "../../structures/packet/packet_client.h" |
#include "ip.h" |
#include "ip_messages.h" |
58,6 → 58,7 |
#define DEFAULT_IPV 4 |
#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_PROTO( call ) ( int ) IPC_GET_ARG1( * call ) |
#define IPC_GET_SERVICE( call ) ( services_t ) IPC_GET_ARG2( * call ) |
#define IPC_GET_STATE( call ) ( device_state_t ) IPC_GET_ARG2( * call ) |
213,12 → 214,9 |
// TODO packer received |
case NET_IL_RECEIVED: |
case NET_NIL_RECEIVED: |
if( ERROR_OCCURED( result = packet_receive( & packet ))){ |
ipc_answer_0( callid, ERROR_CODE ); |
continue; |
if( ! ERROR_OCCURED( result = packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( & call )))){ |
//result = ip_receive_message( IPC_GET_DEVICE( call ), packet ); |
} |
//result = ip_receive_message( IPC_GET_DEVICE( call ), packet ); |
packet_destroy( packet ); |
ipc_answer_0( callid, result ); |
} |
} |
249,6 → 247,7 |
int ip_send_message( device_id_t device_id, packet_t packet ){ |
// TODO send packet |
printf( "Packet to send via %d: %s", device_id, packet_get_data( packet )); |
packet_release( ip_globals.networking_phone, packet_get_id( packet )); |
return EOK; |
} |
269,7 → 268,10 |
case IPC_M_CONNECT_TO_ME: |
return ip_register_message( IPC_GET_PROTO( call ), IPC_GET_PHONE( call )); |
case NET_IP_SEND: |
ERROR_PROPAGATE( packet_receive( & packet )); |
if( ERROR_OCCURED( packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( call )))){ |
printf( "\nIP send E %d", ERROR_CODE ); |
return ERROR_CODE; |
} |
return ip_send_message( IPC_GET_DEVICE( call ), packet ); |
} |
return ENOTSUP; |
/branches/network/uspace/srv/net/il/ip/Makefile |
---|
48,6 → 48,7 |
../../modules.c \ |
../../structures/measured_strings.c \ |
../../structures/packet/packet.c \ |
../../structures/packet/packet_client.c \ |
../../sockaddr.c |
DEFS += -D IP_BUNDLE=1 -D $(NAME)_message=module_message -D $(NAME)_start_module=module_start -D $(NAME)_print_name=module_print_name |
/branches/network/uspace/srv/net/il/ip/ip_module.c |
---|
42,6 → 42,8 |
#include "../../err.h" |
#include "../../modules.h" |
#include "../../structures/packet/packet.h" |
#include "ip.h" |
#include "ip_module.h" |
63,6 → 65,7 |
async_set_client_connection( client_connection ); |
ip_globals.networking_phone = connect_to_service( SERVICE_NETWORKING ); |
ERROR_PROPAGATE( pm_init()); |
ERROR_PROPAGATE( ip_initialize()); |
ERROR_PROPAGATE( REGISTER_ME( SERVICE_IP, & phonehash )); |
/branches/network/uspace/srv/net/netif/netif.c |
---|
45,11 → 45,13 |
#include "../modules.h" |
#include "../structures/packet/packet.h" |
#include "../structures/packet/packet_client.h" |
#include "device.h" |
#include "netif.h" |
#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call ) |
#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG2( * call ) |
#define IPC_GET_IRQ( call ) ( int ) IPC_GET_ARG2( * call ) |
#define IPC_GET_IO( call ) ( int ) IPC_GET_ARG3( * call ) |
#define IPC_GET_PHONE( call ) ( int ) IPC_GET_ARG5( * call ) |
146,7 → 148,7 |
case IPC_M_CONNECT_TO_ME: |
return register_message( IPC_GET_DEVICE( call ), IPC_GET_PHONE( call )); |
case NET_NETIF_SEND: |
ERROR_PROPAGATE( packet_receive( & packet )); |
ERROR_PROPAGATE( packet_translate( netif_globals.networking_phone, & packet, IPC_GET_PACKET( call ))); |
return send_message( IPC_GET_DEVICE( call ), packet ); |
case NET_NETIF_START: |
return start_message( IPC_GET_DEVICE( call )); |
168,7 → 170,7 |
netif_globals.networking_phone = connect_to_service( SERVICE_NETWORKING ); |
device_map_initialize( & netif_globals.device_map ); |
ERROR_PROPAGATE( initialize()); |
ERROR_PROPAGATE( pm_init()); |
async_manager(); |
return EOK; |
/branches/network/uspace/srv/net/netif/lo/lo.c |
---|
45,7 → 45,7 |
#include "../../modules.h" |
#include "../../structures/measured_strings.h" |
#include "../../structures/packet/packet.h" |
#include "../../structures/packet/packet_client.h" |
#include "../netif.h" |
163,9 → 163,6 |
device_ref device; |
size_t length; |
aid_t message; |
ipc_call_t answer; |
ipcarg_t result; |
packet_t received; |
ERROR_PROPAGATE( find_device( device_id, & device )); |
175,18 → 172,18 |
length = packet_get_data_length( packet ); |
device->stats.tx_bytes += length; |
device->stats.rx_bytes += length; |
received = packet_copy( packet ); |
packet_destroy( packet ); |
received = packet_copy( netif_globals.networking_phone, SERVICE_LO, packet ); |
packet_release( netif_globals.networking_phone, packet_get_id( packet )); |
if( ! received ){ |
++ device->stats.rx_dropped; |
return EOK; |
} |
message = async_send_1( device->nil_phone, NET_NIL_RECEIVED, ( device_id ), & answer ); |
if( ERROR_OCCURED( packet_send( received, device->nil_phone ))){ |
++ device->stats.rx_dropped; |
} |
async_wait_for( message, & result ); |
if( result != EOK ) ++ device->stats.rx_dropped; |
async_msg_2( device->nil_phone, NET_NIL_RECEIVED, device_id, packet_get_id( received )); |
// message = async_send_1( device->nil_phone, NET_NIL_RECEIVED, ( device_id ), & answer ); |
// if( ERROR_OCCURED( packet_send( received, device->nil_phone ))){ |
// ++ device->stats.rx_dropped; |
// } |
// if( result != EOK ) ++ device->stats.rx_dropped; |
return EOK; |
} |
/branches/network/uspace/srv/net/netif/lo/Makefile |
---|
46,6 → 46,7 |
../../module.c \ |
../../modules.c \ |
../../structures/measured_strings.h \ |
../../structures/packet/packet_client.c \ |
../../structures/packet/packet.c |
DEFS += -D $(NETIF)_message=module_message -D $(NETIF)_start_module=module_start -D $(NETIF)_print_name=module_print_name |