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 "../../include/device.h"
 
#include "../netif.h"
#include "../netif_interface.h"
 
#define DEFAULT_MTU 1500
 
#define DEFAULT_ADDR        "\0\0\0\0\0\0"
#define DEFAULT_ADDR_LEN    ( sizeof( DEFAULT_ADDR ) / sizeof( char ))
 
#define NAME    "lo - loopback interface"
 
netif_globals_t netif_globals;
 
static struct lo_globals{
    int mtu;
} lo_globals;
 
static int  change_state_message( device_id_t device_id, device_state_t state );
static int  create( device_id_t device_id, device_ref * device );
void    netif_print_name( void );
 
int netif_specific_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    //TODO nil send message
    return ENOTSUP;
}
 
int netif_get_addr_message( device_id_t device_id, measured_string_ref address ){
    if( ! address ) return EBADMEM;
    address->value = DEFAULT_ADDR;
    address->length = DEFAULT_ADDR_LEN;
    return EOK;
}
 
int netif_get_device_stats( device_id_t device_id, device_stats_ref stats ){
    ERROR_DECLARE;
 
    device_ref  device;
 
    if( ! stats ) return EBADMEM;
    ERROR_PROPAGATE( find_device( device_id, & device ));
    memcpy( stats, ( device_stats_ref ) device->specific, sizeof( device_stats_t ));
    return EOK;
}
 
static 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 );
        printf( "\nState changed to %s", ( state == NETIF_ACTIVE ) ? "ACTIVE" : "STOPPED" );
    }
    return EOK;
}
 
static int create( device_id_t device_id, device_ref * device ){
    int index;
 
    if( device_map_count( & netif_globals.device_map ) > 0 ){
        return EXDEV;
    }else{
        * device = ( device_ref ) malloc( sizeof( device_t ));
        if( !( * device )) return ENOMEM;
        ( ** device ).specific = malloc( sizeof( device_stats_t ));
        if( ! ( ** device ).specific ){
            free( * device );
            return ENOMEM;
        }
        null_device_stats(( device_stats_ref )( ** device ).specific );
        ( ** device ).device_id = device_id;
        ( ** device ).nil_phone = -1;
        ( ** device ).state = NETIF_STOPPED;
        index = device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device );
        if( index < 0 ){
            free( * device );
            free(( ** device ).specific );
            * device = NULL;
            return index;
        }
    }
    return EOK;
}
 
int netif_initialize( void ){
    ipcarg_t    phonehash;
 
    return REGISTER_ME( SERVICE_LO, & phonehash );
}
 
void netif_print_name( void ){
    printf( "%s", NAME );
}
 
int netif_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 netif_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;
    ipcarg_t        result;
 
    // 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;
    }
    // end request
    async_wait_for( message, & result );
    if( ERROR_OCCURRED( result )){
        if( settings ){
            free( settings );
            free( data );
        }
        return ERROR_CODE;
    }
    // MTU is the first one
    if( settings && ( settings[ 0 ].value )){
        lo_globals.mtu = strtoul( settings[ 0 ].value, NULL, 0 );
        free( settings );
        free( data );
    }else{
        lo_globals.mtu = DEFAULT_MTU;
    }
    // print the settings
    printf("\nNew device registered:\n\tid\t= %d\n\tMTU\t= %d", device->device_id, lo_globals.mtu );
    return EOK;
}
 
int netif_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_ref ) device->specific )->tx_packets;
        ++ (( device_stats_ref ) device->specific )->rx_packets;
        length = packet_get_data_length( next );
        (( device_stats_ref ) device->specific )->tx_bytes += length;
        (( device_stats_ref ) device->specific )->rx_bytes += length;
        next = pq_next( next );
    }while( next );
    nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );
    return EOK;
}
 
int netif_start_message( device_id_t device_id ){
    return change_state_message( device_id, NETIF_ACTIVE );
}
 
int netif_stop_message( device_id_t device_id ){
    return change_state_message( device_id, NETIF_STOPPED );
}
 
/** @}
 */
 

Rev 4197	Rev 4243
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 "../../include/device.h"
-		51
50	#include "../netif.h"	52	#include "../netif.h"
51	#include "../netif_interface.h"	53	#include "../netif_interface.h"
52		54
53	#define DEFAULT_MTU 1500	55	#define DEFAULT_MTU 1500
54		56
55	#define DEFAULT_ADDR "\0\0\0\0\0\0"	57	#define DEFAULT_ADDR "\0\0\0\0\0\0"
56	#define DEFAULT_ADDR_LEN ( sizeof( DEFAULT_ADDR ) / sizeof( char ))	58	#define DEFAULT_ADDR_LEN ( sizeof( DEFAULT_ADDR ) / sizeof( char ))
57		59
58	#define NAME "lo - loopback interface"	60	#define NAME "lo - loopback interface"
59		61
60	netif_globals_t netif_globals;	62	netif_globals_t netif_globals;
61		63
62	static struct lo_globals{	64	static struct lo_globals{
63	int mtu;	65	int mtu;
64	} lo_globals;	66	} lo_globals;
65		67
66	int change_state_message( device_id_t device_id, device_state_t state );	68	static int change_state_message( device_id_t device_id, device_state_t state );
67	int create( device_id_t device_id, device_ref * device );	69	static int create( device_id_t device_id, device_ref * device );
68	void netif_print_name( void );	70	void netif_print_name( void );
69		71
70	int specific_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	72	int netif_specific_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
-		73	//TODO nil send message
71	return ENOTSUP;	74	return ENOTSUP;
72	}	75	}
73		76
74	int get_addr_message( device_id_t device_id, measured_string_ref address ){	77	int netif_get_addr_message( device_id_t device_id, measured_string_ref address ){
75	if( ! address ) return EBADMEM;	78	if( ! address ) return EBADMEM;
76	address->value = DEFAULT_ADDR;	79	address->value = DEFAULT_ADDR;
77	address->length = DEFAULT_ADDR_LEN;	80	address->length = DEFAULT_ADDR_LEN;
-		81	return EOK;
78	}	82	}
79		83
80	int get_device_stats( device_id_t device_id, device_stats_ref stats ){	84	int netif_get_device_stats( device_id_t device_id, device_stats_ref stats ){
81	ERROR_DECLARE;	85	ERROR_DECLARE;
82		86
83	device_ref device;	87	device_ref device;
84		88
85	if( ! stats ) return EBADMEM;	89	if( ! stats ) return EBADMEM;
86	ERROR_PROPAGATE( find_device( device_id, & device ));	90	ERROR_PROPAGATE( find_device( device_id, & device ));
87	memcpy( stats, ( device_stats_ref ) device->specific, sizeof( device_stats_t ));	91	memcpy( stats, ( device_stats_ref ) device->specific, sizeof( device_stats_t ));
88	return EOK;	92	return EOK;
89	}	93	}
90		94
91	int change_state_message( device_id_t device_id, device_state_t state ){	95	static int change_state_message( device_id_t device_id, device_state_t state ){
92	ERROR_DECLARE;	96	ERROR_DECLARE;
93		97
94	device_ref device;	98	device_ref device;
95		99
96	ERROR_PROPAGATE( find_device( device_id, & device ));	100	ERROR_PROPAGATE( find_device( device_id, & device ));
97	if( device->state != state ){	101	if( device->state != state ){
98	device->state = state;	102	device->state = state;
99	nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );	103	nil_message( device, NET_NIL_DEVICE_STATE, device->state, NULL );
100	printf( "\nState changed to %s", ( state == NETIF_ACTIVE ) ? "ACTIVE" : "STOPPED" );	104	printf( "\nState changed to %s", ( state == NETIF_ACTIVE ) ? "ACTIVE" : "STOPPED" );
101	}	105	}
102	return EOK;	106	return EOK;
103	}	107	}
104		108
105	int create( device_id_t device_id, device_ref * device ){	109	static int create( device_id_t device_id, device_ref * device ){
106	int index;	110	int index;
107		111
108	if( device_map_count( & netif_globals.device_map ) > 0 ){	112	if( device_map_count( & netif_globals.device_map ) > 0 ){
109	return EXDEV;	113	return EXDEV;
110	}else{	114	}else{
111	* device = ( device_ref ) malloc( sizeof( device_t ));	115	* device = ( device_ref ) malloc( sizeof( device_t ));
112	if( !( * device )) return ENOMEM;	116	if( !( * device )) return ENOMEM;
113	( ** device ).specific = malloc( sizeof( device_stats_t ));	117	( ** device ).specific = malloc( sizeof( device_stats_t ));
114	if( ! ( ** device ).specific ){	118	if( ! ( ** device ).specific ){
115	free( * device );	119	free( * device );
116	return ENOMEM;	120	return ENOMEM;
117	}	121	}
118	null_device_stats(( device_stats_ref )( ** device ).specific );	122	null_device_stats(( device_stats_ref )( ** device ).specific );
119	( ** device ).device_id = device_id;	123	( ** device ).device_id = device_id;
120	( ** device ).nil_phone = -1;	124	( ** device ).nil_phone = -1;
121	( ** device ).state = NETIF_STOPPED;	125	( ** device ).state = NETIF_STOPPED;
122	index = device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device );	126	index = device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device );
123	if( index < 0 ){	127	if( index < 0 ){
124	free( * device );	128	free( * device );
125	free(( ** device ).specific );	129	free(( ** device ).specific );
126	* device = NULL;	130	* device = NULL;
127	return index;	131	return index;
128	}	132	}
129	}	133	}
130	return EOK;	134	return EOK;
131	}	135	}
132		136
133	int initialize( void ){	137	int netif_initialize( void ){
134	ipcarg_t phonehash;	138	ipcarg_t phonehash;
135		139
136	return REGISTER_ME( SERVICE_LO, & phonehash );	140	return REGISTER_ME( SERVICE_LO, & phonehash );
137	}	141	}
138		142
139	void netif_print_name( void ){	143	void netif_print_name( void ){
140	printf( "%s", NAME );	144	printf( "%s", NAME );
141	}	145	}
142		146
143	int probe_auto_message( void ){	147	int netif_probe_auto_message( void ){
144	/* ERROR_DECLARE;	148	/* ERROR_DECLARE;
145		149
146	device_ref device;	150	device_ref device;
147		151
148	ERROR_PROPAGATE( create( arg1, & device ));	152	ERROR_PROPAGATE( create( arg1, & device ));
149	ipc_call_sync_3_3( netif_globals.networking_phone, NET_NET_DEVICE, device->device_id, NULL, NULL, NULL, NULL, NULL );	153	ipc_call_sync_3_3( netif_globals.networking_phone, NET_NET_DEVICE, device->device_id, NULL, NULL, NULL, NULL, NULL );
150	*/ return ENOTSUP;	154	*/ return ENOTSUP;
151	}	155	}
152		156
153	int probe_message( device_id_t device_id, int irq, int io ){	157	int netif_probe_message( device_id_t device_id, int irq, int io ){
154	ERROR_DECLARE;	158	ERROR_DECLARE;
155		159
156	device_ref device;	160	device_ref device;
157	aid_t message;	161	aid_t message;
158	ipc_call_t answer;	162	ipc_call_t answer;
159	measured_string_t configuration[ 1 ] = {{ "MTU", 3 }};	163	measured_string_t configuration[ 1 ] = {{ "MTU", 3 }};
160	int count = 1;	164	int count = 1;
161	measured_string_ref settings;	165	measured_string_ref settings;
162	char * data;	166	char * data;
163	ipcarg_t result;	167	ipcarg_t result;
164		168
165	// create a new device	169	// create a new device
166	ERROR_PROPAGATE( create( device_id, & device ));	170	ERROR_PROPAGATE( create( device_id, & device ));
167	// get configuration	171	// get configuration
168	message = async_send_2( netif_globals.networking_phone, NET_NET_GET_DEVICE_CONF, device->device_id, count, & answer );	172	message = async_send_2( netif_globals.networking_phone, NET_NET_GET_DEVICE_CONF, device->device_id, count, & answer );
169	// send names and get settings	173	// send names and get settings
170	if( ERROR_OCCURRED( measured_strings_send( netif_globals.networking_phone, configuration, count ))	174	if( ERROR_OCCURRED( measured_strings_send( netif_globals.networking_phone, configuration, count ))
171	\|\| ERROR_OCCURRED( measured_strings_return( netif_globals.networking_phone, & settings, & data, count ))){	175	\|\| ERROR_OCCURRED( measured_strings_return( netif_globals.networking_phone, & settings, & data, count ))){
172	async_wait_for( message, NULL );	176	async_wait_for( message, NULL );
173	return ERROR_CODE;	177	return ERROR_CODE;
174	}	178	}
175	// end request	179	// end request
176	async_wait_for( message, & result );	180	async_wait_for( message, & result );
177	if( ERROR_OCCURRED( result )){	181	if( ERROR_OCCURRED( result )){
178	if( settings ){	182	if( settings ){
179	free( settings );	183	free( settings );
180	free( data );	184	free( data );
181	}	185	}
182	return ERROR_CODE;	186	return ERROR_CODE;
183	}	187	}
184	// MTU is the first one	188	// MTU is the first one
185	if( settings && ( settings[ 0 ].value )){	189	if( settings && ( settings[ 0 ].value )){
186	lo_globals.mtu = strtoul( settings[ 0 ].value, NULL, 0 );	190	lo_globals.mtu = strtoul( settings[ 0 ].value, NULL, 0 );
187	free( settings );	191	free( settings );
188	free( data );	192	free( data );
189	}else{	193	}else{
190	lo_globals.mtu = DEFAULT_MTU;	194	lo_globals.mtu = DEFAULT_MTU;
191	}	195	}
192	// print the settings	196	// print the settings
193	printf("\nNew device registered:\n\tid\t= %d\n\tMTU\t= %d", device->device_id, lo_globals.mtu );	197	printf("\nNew device registered:\n\tid\t= %d\n\tMTU\t= %d", device->device_id, lo_globals.mtu );
194	return EOK;	198	return EOK;
195	}	199	}
196		200
197	int send_message( device_id_t device_id, packet_t packet ){	201	int netif_send_message( device_id_t device_id, packet_t packet ){
198	ERROR_DECLARE;	202	ERROR_DECLARE;
199		203
200	device_ref device;	204	device_ref device;
201	size_t length;	205	size_t length;
202	packet_t next;	206	packet_t next;
203		207
204	ERROR_PROPAGATE( find_device( device_id, & device ));	208	ERROR_PROPAGATE( find_device( device_id, & device ));
205	if( device->state != NETIF_ACTIVE ) return EPERM;	209	if( device->state != NETIF_ACTIVE ) return EPERM;
206	next = packet;	210	next = packet;
207	do{	211	do{
208	++ (( device_stats_ref ) device->specific )->tx_packets;	212	++ (( device_stats_ref ) device->specific )->tx_packets;
209	++ (( device_stats_ref ) device->specific )->rx_packets;	213	++ (( device_stats_ref ) device->specific )->rx_packets;
210	length = packet_get_data_length( next );	214	length = packet_get_data_length( next );
211	(( device_stats_ref ) device->specific )->tx_bytes += length;	215	(( device_stats_ref ) device->specific )->tx_bytes += length;
212	(( device_stats_ref ) device->specific )->rx_bytes += length;	216	(( device_stats_ref ) device->specific )->rx_bytes += length;
213	next = pq_next( next );	217	next = pq_next( next );
214	}while( next );	218	}while( next );
215	nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );	219	nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );
216	return EOK;	220	return EOK;
217	}	221	}
218		222
219	int start_message( device_id_t device_id ){	223	int netif_start_message( device_id_t device_id ){
220	return change_state_message( device_id, NETIF_ACTIVE );	224	return change_state_message( device_id, NETIF_ACTIVE );
221	}	225	}
222		226
223	int stop_message( device_id_t device_id ){	227	int netif_stop_message( device_id_t device_id ){
224	return change_state_message( device_id, NETIF_STOPPED );	228	return change_state_message( device_id, NETIF_STOPPED );
225	}	229	}
226		230
227	/** @}	231	/** @}
228	*/	232	*/
229		233

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/netif/lo/lo.c @ 4261 – Rev 4197 → 4243