WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/netif/lo/lo.c


/*
 * Copyright (c) 2009 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 lo
 *  @{
 */
 
/** @file
 */
 
#include <async.h>
#include <errno.h>
#include <stdio.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../structures/measured_strings.h"
#include "../../structures/packet/packet_client.h"
 
#include "../netif.h"
 
#define DEFAULT_MTU 1500
 
#define NAME    "lo - loopback interface"
 
netif_globals_t netif_globals;
 
int change_state_message( device_id_t device_id, device_state_t state );
int create( device_id_t device_id, device_ref * device );
int initialize( void );
void    netif_print_name( void );
int probe_auto_message( void );
int probe_message( device_id_t device_id, int irq, int io );
int send_message( device_id_t device_id, packet_t packet );
int start_message( device_id_t device_id );
int stop_message( device_id_t device_id );
 
int change_state_message( device_id_t device_id, device_state_t state ){
    ERROR_DECLARE;
 
    device_ref  device;
 
    ERROR_PROPAGATE( find_device( device_id, & device ));
    if( device->state != state ){
        device->state = state;
        nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );
    }
    return EOK;
}
 
int create( device_id_t device_id, device_ref * device ){
    ERROR_DECLARE;
 
    if( device_map_count( & netif_globals.device_map ) > 0 ){
        return EXDEV;
    }else{
        * device = ( device_ref ) malloc( sizeof( device_t ));
        if( !( * device )) return ENOMEM;
        ( ** device ).device_id = device_id;
        ( ** device ).nil_phone = -1;
        ( ** device ).specific = NULL;
        null_device_stats( &(( ** device ).stats ));
        ( ** device ).state = NETIF_STOPPED;
        ( ** device ).flags = NULL;
        ( ** device ).mtu = DEFAULT_MTU;
        if( ERROR_OCCURRED( device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device ))){
            free( * device );
            * device = NULL;
            return ERROR_CODE;
        }
    }
    return EOK;
}
 
int initialize( void ){
    ipcarg_t    phonehash;
 
    return REGISTER_ME( SERVICE_LO, & phonehash );
}
 
void netif_print_name( void ){
    printf( NAME );
}
 
int probe_auto_message( void ){
/*  ERROR_DECLARE;
 
    device_ref  device;
 
    ERROR_PROPAGATE( create( arg1, & device ));
    ipc_call_sync_3_3( netif_globals.networking_phone, NET_NET_DEVICE, device->device_id, NULL, NULL, NULL, NULL, NULL );
*/  return ENOTSUP;
}
 
int probe_message( device_id_t device_id, int irq, int io ){
    ERROR_DECLARE;
 
    device_ref      device;
    aid_t           message;
    ipc_call_t      answer;
    measured_string_t   configuration[ 1 ] = {{ "MTU", 3 }};
    int         count = 1;
    measured_string_ref settings;
    char *          data;
 
    // create a new device
    ERROR_PROPAGATE( create( device_id, & device ));
    // get configuration
    message = async_send_2( netif_globals.networking_phone, NET_NET_GET_DEVICE_CONF, device->device_id, count, & answer );
    // send names and get settings
    if( ERROR_OCCURRED( measured_strings_send( netif_globals.networking_phone, configuration, count ))
    || ERROR_OCCURRED( measured_strings_return( netif_globals.networking_phone, & settings, & data, count ))){
        async_wait_for( message, NULL );
        return ERROR_CODE;
    }
    // MTU is the first one
    if( settings && ( settings[ 0 ].value )){
        device->mtu = strtoul( settings[ 0 ].value, NULL, 0 );
    }else{
        device->mtu = DEFAULT_MTU;
    }
    // print the settings
    printf("\n -MTU =\t%d", device->mtu );
    free( settings );
    free( data );
    // end request
    async_wait_for( message, NULL );
    return EOK;
}
 
int send_message( device_id_t device_id, packet_t packet ){
    ERROR_DECLARE;
 
    device_ref  device;
    size_t      length;
    packet_t    next;
 
    ERROR_PROPAGATE( find_device( device_id, & device ));
    if( device->state != NETIF_ACTIVE ) return EPERM;
    next = packet;
    do{
        ++ device->stats.tx_packets;
        ++ device->stats.rx_packets;
        length = packet_get_data_length( next );
        device->stats.tx_bytes += length;
        device->stats.rx_bytes += length;
        next = pq_next( next );
    }while( next );
    nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );
 
 
    return EOK;
}
 
int start_message( device_id_t device_id ){
    return change_state_message( device_id, NETIF_ACTIVE );
}
 
int stop_message( device_id_t device_id ){
    return change_state_message( device_id, NETIF_STOPPED );
}
 
/** @}
 */
 

Rev 3991	Rev 4075
1	/*	1	/*
2	* Copyright (c) 2009 Lukas Mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup lo	29	/** @addtogroup lo
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	*/	34	*/
35		35
36	#include <async.h>	36	#include <async.h>
37	#include <errno.h>	37	#include <errno.h>
38	#include <stdio.h>	38	#include <stdio.h>
39		39
40	#include <ipc/ipc.h>	40	#include <ipc/ipc.h>
41	#include <ipc/services.h>	41	#include <ipc/services.h>
42		42
43	#include "../../err.h"	43	#include "../../err.h"
44	#include "../../messages.h"	44	#include "../../messages.h"
45	#include "../../modules.h"	45	#include "../../modules.h"
46		46
47	#include "../../structures/measured_strings.h"	47	#include "../../structures/measured_strings.h"
48	#include "../../structures/packet/packet_client.h"	48	#include "../../structures/packet/packet_client.h"
49		49
50	#include "../netif.h"	50	#include "../netif.h"
51		51
52	#define DEFAULT_MTU 1500	52	#define DEFAULT_MTU 1500
53		53
54	#define NAME "lo - loopback interface"	54	#define NAME "lo - loopback interface"
55		55
56	netif_globals_t netif_globals;	56	netif_globals_t netif_globals;
57		57
58	int change_state_message( device_id_t device_id, device_state_t state );	58	int change_state_message( device_id_t device_id, device_state_t state );
59	int create( device_id_t device_id, device_ref * device );	59	int create( device_id_t device_id, device_ref * device );
60	int initialize( void );	60	int initialize( void );
61	void netif_print_name( void );	61	void netif_print_name( void );
62	int probe_auto_message( void );	62	int probe_auto_message( void );
63	int probe_message( device_id_t device_id, int irq, int io );	63	int probe_message( device_id_t device_id, int irq, int io );
64	int send_message( device_id_t device_id, packet_t packet );	64	int send_message( device_id_t device_id, packet_t packet );
65	int start_message( device_id_t device_id );	65	int start_message( device_id_t device_id );
66	int stop_message( device_id_t device_id );	66	int stop_message( device_id_t device_id );
67		67
68	int change_state_message( device_id_t device_id, device_state_t state ){	68	int change_state_message( device_id_t device_id, device_state_t state ){
69	ERROR_DECLARE;	69	ERROR_DECLARE;
70		70
71	device_ref device;	71	device_ref device;
72		72
73	ERROR_PROPAGATE( find_device( device_id, & device ));	73	ERROR_PROPAGATE( find_device( device_id, & device ));
74	if( device->state != state ){	74	if( device->state != state ){
75	device->state = state;	75	device->state = state;
76	nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );	76	nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );
77	}	77	}
78	return EOK;	78	return EOK;
79	}	79	}
80		80
81	int create( device_id_t device_id, device_ref * device ){	81	int create( device_id_t device_id, device_ref * device ){
82	ERROR_DECLARE;	82	ERROR_DECLARE;
83		83
84	if( device_map_count( & netif_globals.device_map ) > 0 ){	84	if( device_map_count( & netif_globals.device_map ) > 0 ){
85	return EXDEV;	85	return EXDEV;
86	}else{	86	}else{
87	* device = ( device_ref ) malloc( sizeof( device_t ));	87	* device = ( device_ref ) malloc( sizeof( device_t ));
88	if( !( * device )) return ENOMEM;	88	if( !( * device )) return ENOMEM;
89	( ** device ).device_id = device_id;	89	( ** device ).device_id = device_id;
90	( ** device ).nil_phone = -1;	90	( ** device ).nil_phone = -1;
91	( ** device ).specific = NULL;	91	( ** device ).specific = NULL;
92	null_device_stats( &(( ** device ).stats ));	92	null_device_stats( &(( ** device ).stats ));
93	( ** device ).state = NETIF_STOPPED;	93	( ** device ).state = NETIF_STOPPED;
94	( ** device ).flags = NULL;	94	( ** device ).flags = NULL;
95	( ** device ).mtu = DEFAULT_MTU;	95	( ** device ).mtu = DEFAULT_MTU;
96	if( ERROR_OCCURRED( device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device ))){	96	if( ERROR_OCCURRED( device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device ))){
97	free( * device );	97	free( * device );
98	* device = NULL;	98	* device = NULL;
99	return ERROR_CODE;	99	return ERROR_CODE;
100	}	100	}
101	}	101	}
102	return EOK;	102	return EOK;
103	}	103	}
104		104
105	int initialize( void ){	105	int initialize( void ){
106	ipcarg_t phonehash;	106	ipcarg_t phonehash;
107		107
108	return REGISTER_ME( SERVICE_LO, & phonehash );	108	return REGISTER_ME( SERVICE_LO, & phonehash );
109	}	109	}
110		110
111	void netif_print_name( void ){	111	void netif_print_name( void ){
112	printf( NAME );	112	printf( NAME );
113	}	113	}
114		114
115	int probe_auto_message( void ){	115	int probe_auto_message( void ){
116	/* ERROR_DECLARE;	116	/* ERROR_DECLARE;
117		117
118	device_ref device;	118	device_ref device;
119		119
120	ERROR_PROPAGATE( create( arg1, & device ));	120	ERROR_PROPAGATE( create( arg1, & device ));
121	ipc_call_sync_3_3( netif_globals.networking_phone, NET_NET_DEVICE, device->device_id, NULL, NULL, NULL, NULL, NULL );	121	ipc_call_sync_3_3( netif_globals.networking_phone, NET_NET_DEVICE, device->device_id, NULL, NULL, NULL, NULL, NULL );
122	*/ return ENOTSUP;	122	*/ return ENOTSUP;
123	}	123	}
124		124
125	int probe_message( device_id_t device_id, int irq, int io ){	125	int probe_message( device_id_t device_id, int irq, int io ){
126	ERROR_DECLARE;	126	ERROR_DECLARE;
127		127
128	device_ref device;	128	device_ref device;
129	aid_t message;	129	aid_t message;
130	ipc_call_t answer;	130	ipc_call_t answer;
131	measured_string_t configuration[ 1 ] = {{ "MTU", 3 }};	131	measured_string_t configuration[ 1 ] = {{ "MTU", 3 }};
132	int count = 1;	132	int count = 1;
133	measured_string_ref settings;	133	measured_string_ref settings;
134	char * data;	134	char * data;
135		135
136	// create a new device	136	// create a new device
137	ERROR_PROPAGATE( create( device_id, & device ));	137	ERROR_PROPAGATE( create( device_id, & device ));
138	// get configuration	138	// get configuration
139	message = async_send_2( netif_globals.networking_phone, NET_NET_GET_DEVICE_CONF, device->device_id, count, & answer );	139	message = async_send_2( netif_globals.networking_phone, NET_NET_GET_DEVICE_CONF, device->device_id, count, & answer );
140	// send names and get settings	140	// send names and get settings
141	if( ERROR_OCCURRED( measured_strings_send( netif_globals.networking_phone, configuration, count ))	141	if( ERROR_OCCURRED( measured_strings_send( netif_globals.networking_phone, configuration, count ))
142	\|\| ERROR_OCCURRED( measured_strings_return( netif_globals.networking_phone, & settings, & data, count ))){	142	\|\| ERROR_OCCURRED( measured_strings_return( netif_globals.networking_phone, & settings, & data, count ))){
143	async_wait_for( message, NULL );	143	async_wait_for( message, NULL );
144	return ERROR_CODE;	144	return ERROR_CODE;
145	}	145	}
146	// MTU is the first one	146	// MTU is the first one
147	if( settings && ( settings[ 0 ].value )){	147	if( settings && ( settings[ 0 ].value )){
148	device->mtu = strtoul( settings[ 0 ].value, NULL, 0 );	148	device->mtu = strtoul( settings[ 0 ].value, NULL, 0 );
149	}else{	149	}else{
150	device->mtu = DEFAULT_MTU;	150	device->mtu = DEFAULT_MTU;
151	}	151	}
152	// print the settings	152	// print the settings
153	printf("\n -MTU =\t%d", device->mtu );	153	printf("\n -MTU =\t%d", device->mtu );
154	free( settings );	154	free( settings );
155	free( data );	155	free( data );
156	// end request	156	// end request
157	async_wait_for( message, NULL );	157	async_wait_for( message, NULL );
158	return EOK;	158	return EOK;
159	}	159	}
160		160
161	int send_message( device_id_t device_id, packet_t packet ){	161	int send_message( device_id_t device_id, packet_t packet ){
162	ERROR_DECLARE;	162	ERROR_DECLARE;
163		163
164	device_ref device;	164	device_ref device;
165	size_t length;	165	size_t length;
166	packet_t next;	166	packet_t next;
167		167
168	ERROR_PROPAGATE( find_device( device_id, & device ));	168	ERROR_PROPAGATE( find_device( device_id, & device ));
169	if( device->state != NETIF_ACTIVE ) return EPERM;	169	if( device->state != NETIF_ACTIVE ) return EPERM;
-		170	next = packet;
170	do{	171	do{
171	++ device->stats.tx_packets;	172	++ device->stats.tx_packets;
172	++ device->stats.rx_packets;	173	++ device->stats.rx_packets;
173	length = packet_get_data_length( packet );	174	length = packet_get_data_length( next );
174	device->stats.tx_bytes += length;	175	device->stats.tx_bytes += length;
175	device->stats.rx_bytes += length;	176	device->stats.rx_bytes += length;
176	next = pq_detach( packet );	177	next = pq_next( next );
-		178	}while( next );
177	nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );	179	nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );
178	packet = next;	-
179	}while( packet );	-
180	return EOK;	180	return EOK;
181	}	181	}
182		182
183	int start_message( device_id_t device_id ){	183	int start_message( device_id_t device_id ){
184	return change_state_message( device_id, NETIF_ACTIVE );	184	return change_state_message( device_id, NETIF_ACTIVE );
185	}	185	}
186		186
187	int stop_message( device_id_t device_id ){	187	int stop_message( device_id_t device_id ){
188	return change_state_message( device_id, NETIF_STOPPED );	188	return change_state_message( device_id, NETIF_STOPPED );
189	}	189	}
190		190
191	/** @}	191	/** @}
192	*/	192	*/
193		193

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/netif/lo/lo.c – Rev 3991 → 4075