WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/structures/packet/packet_client.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 packet
 *  @{
 */
 
/** @file
 *  Packet client implementation.
 */
 
#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"
 
/** Obtains the packet from the packet server as the shared memory block.
 *  Creates the local packet mapping as well.
 *  @param phone The packet server module phone. Input parameter.
 *  @param packet The packet reference pointer to store the received packet reference. Output parameter.
 *  @param packet_id The packet identifier. Input parameter.
 *  @param size The packet total size in bytes. Input parameter.
 *  @returns EOK on success.
 *  \todo ipc_share_in_start() error?
 *  @returns Other error codes as defined for the pm_add() function.
 */
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_prefix( 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_suffix( 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 suffix ){
    if( ! packet_is_valid( packet )) return EINVAL;
    if( prefix + suffix > packet->data_end - packet->data_start ) return ENOMEM;
    packet->data_start += prefix;
    packet->data_end -= suffix;
    return EOK;
}
 
packet_id_t packet_get_id( const 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 EINVAL;
    if( ! packet->addr_len ) 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_ONE_WAY;
}
 
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 )) return EINVAL;
    if( packet->addr_len >= addr_len ) return ENOMEM;
    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;
    ipcarg_t    result;
 
    message = async_send_1( phone, NET_PACKET_GET, packet_id, & answer );
    * packet = ( packet_t ) as_get_mappable_page( size );
    if( ERROR_OCCURRED( ipc_share_in_start_0_0( phone, * packet, size ))
    || ERROR_OCCURRED( pm_add( * packet ))){
        munmap( * packet, size );
        async_wait_for( message, NULL );
        return ERROR_CODE;
    }
    async_wait_for( message, & result );
    return result;
}
 
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_suffix ){
    ERROR_DECLARE;
 
    packet_id_t packet_id;
    unsigned int size;
    packet_t packet;
 
    if( ERROR_OCCURRED( async_req_5_2( phone, NET_PACKET_CREATE_5, owner, max_content, addr_len, max_prefix, max_suffix, & packet_id, & size ))
    || ERROR_OCCURRED( 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_OCCURRED( async_req_2_2( phone, NET_PACKET_CREATE_1, owner, content, & packet_id, & size ))
    || ERROR_OCCURRED( 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 );
}
 
/** @}
 */
 

Rev 3901	Rev 3912
1	/*	1	/*
2	* Copyright (c) 2008 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 net	29	/** @addtogroup packet
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
-		34	* Packet client implementation.
34	*/	35	*/
35		36
36	#include <async.h>	37	#include <async.h>
37	#include <errno.h>	38	#include <errno.h>
38	#include <unistd.h>	39	#include <unistd.h>
39	//#include <stdio.h>	40	//#include <stdio.h>
40	#include <string.h>	41	#include <string.h>
41		42
42	#include <ipc/ipc.h>	43	#include <ipc/ipc.h>
43	#include <ipc/services.h>	44	#include <ipc/services.h>
44	#include <sys/mman.h>	45	#include <sys/mman.h>
45		46
46	#include "../../err.h"	47	#include "../../err.h"
47	#include "../../messages.h"	48	#include "../../messages.h"
48		49
49	#include "packet.h"	50	#include "packet.h"
50	#include "packet_header.h"	51	#include "packet_header.h"
51	#include "packet_client.h"	52	#include "packet_client.h"
52		53
-		54	/** Obtains the packet from the packet server as the shared memory block.
-		55	* Creates the local packet mapping as well.
-		56	* @param phone The packet server module phone. Input parameter.
-		57	* @param packet The packet reference pointer to store the received packet reference. Output parameter.
-		58	* @param packet_id The packet identifier. Input parameter.
-		59	* @param size The packet total size in bytes. Input parameter.
-		60	* @returns EOK on success.
-		61	* \todo ipc_share_in_start() error?
-		62	* @returns Other error codes as defined for the pm_add() function.
-		63	*/
53	int packet_return( int phone, packet_ref packet, packet_id_t packet_id, size_t size );	64	int packet_return( int phone, packet_ref packet, packet_id_t packet_id, size_t size );
54		65
55	packet_t packet_copy( int phone, services_t owner, const packet_t packet ){	66	packet_t packet_copy( int phone, services_t owner, const packet_t packet ){
56	packet_t new;	67	packet_t new;
57		68
58	if( ! packet_is_valid( packet )) return NULL;	69	if( ! packet_is_valid( packet )) return NULL;
59	// new = ( packet_t ) mmap( NULL, packet->length, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0 );	70	// new = ( packet_t ) mmap( NULL, packet->length, PROTO_READ \| PROTO_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0, 0 );
60	// if( new == MAP_FAILED ) return NULL;	71	// if( new == MAP_FAILED ) return NULL;
61	// memcpy( new, packet, packet->length );	72	// memcpy( new, packet, packet->length );
62	new = packet_get_1( phone, owner, packet_get_data_length( packet ));	73	new = packet_get_1( phone, owner, packet_get_data_length( packet ));
63	packet_copy_data( new, packet_get_data( packet ), packet_get_data_length( packet ));	74	packet_copy_data( new, packet_get_data( packet ), packet_get_data_length( packet ));
64	return new;	75	return new;
65	}	76	}
66		77
67	int packet_copy_data( packet_t packet, const void * data, size_t length ){	78	int packet_copy_data( packet_t packet, const void * data, size_t length ){
68	if( ! packet_is_valid( packet )) return EINVAL;	79	if( ! packet_is_valid( packet )) return EINVAL;
69	if( packet->data_start + length >= packet->length ) return ENOMEM;	80	if( packet->data_start + length >= packet->length ) return ENOMEM;
70	memcpy(( void * ) packet + packet->data_start, data, length );	81	memcpy(( void * ) packet + packet->data_start, data, length );
71	if( packet->data_start + length > packet->data_end ){	82	if( packet->data_start + length > packet->data_end ){
72	packet->data_end = packet->data_start + length;	83	packet->data_end = packet->data_start + length;
73	}	84	}
74	return EOK;	85	return EOK;
75	}	86	}
76		87
77	void * packet_prepend( packet_t packet, size_t length ){	88	void * packet_prefix( packet_t packet, size_t length ){
78	if(( ! packet_is_valid( packet )) \|\| ( packet->data_start - sizeof( struct packet ) - 2 * packet->addr_len < length )) return NULL;	89	if(( ! packet_is_valid( packet )) \|\| ( packet->data_start - sizeof( struct packet ) - 2 * packet->addr_len < length )) return NULL;
79	packet->data_start -= length;	90	packet->data_start -= length;
80	return ( void * ) packet + packet->data_start;	91	return ( void * ) packet + packet->data_start;
81	}	92	}
82		93
83	void * packet_append( packet_t packet, size_t length ){	94	void * packet_suffix( packet_t packet, size_t length ){
84	if(( ! packet_is_valid( packet )) \|\| ( packet->data_end + length >= packet->length )) return NULL;	95	if(( ! packet_is_valid( packet )) \|\| ( packet->data_end + length >= packet->length )) return NULL;
85	packet->data_end += length;	96	packet->data_end += length;
86	return ( void * ) packet + packet->data_end - length;	97	return ( void * ) packet + packet->data_end - length;
87	}	98	}
88		99
89	int packet_trim( packet_t packet, size_t prefix, size_t sufix ){	100	int packet_trim( packet_t packet, size_t prefix, size_t suffix ){
-		101	if( ! packet_is_valid( packet )) return EINVAL;
90	if(( ! packet_is_valid( packet )) \|\| ( prefix + sufix > packet->data_end - packet->data_start )) return EINVAL;	102	if( prefix + suffix > packet->data_end - packet->data_start ) return ENOMEM;
91	packet->data_start += prefix;	103	packet->data_start += prefix;
92	packet->data_end -= sufix;	104	packet->data_end -= suffix;
93	return EOK;	105	return EOK;
94	}	106	}
95		107
96	packet_id_t packet_get_id( packet_t packet ){	108	packet_id_t packet_get_id( const packet_t packet ){
97	return packet_is_valid( packet ) ? packet->packet_id : 0;	109	return packet_is_valid( packet ) ? packet->packet_id : 0;
98	}	110	}
99		111
100	int packet_get_addr( const packet_t packet, uint8_t src, uint8_t dest ){	112	int packet_get_addr( const packet_t packet, uint8_t src, uint8_t dest ){
101	if( !( packet_is_valid( packet ) && src && dest )) return 0;	113	if( !( packet_is_valid( packet ) && src && dest )) return EINVAL;
-		114	if( ! packet->addr_len ) return 0;
102	* src = ( void * ) packet + packet->src_addr;	115	* src = ( void * ) packet + packet->src_addr;
103	* dest = ( void * ) packet + packet->dest_addr;	116	* dest = ( void * ) packet + packet->dest_addr;
104	return packet->addr_len;	117	return packet->addr_len;
105	}	118	}
106		119
107	size_t packet_get_data_length( const packet_t packet ){	120	size_t packet_get_data_length( const packet_t packet ){
108	if( ! packet_is_valid( packet )) return 0;	121	if( ! packet_is_valid( packet )) return 0;
109	return packet->data_end - packet->data_start;	122	return packet->data_end - packet->data_start;
110	}	123	}
111		124
112	void * packet_get_data( const packet_t packet ){	125	void * packet_get_data( const packet_t packet ){
113	if( ! packet_is_valid( packet )) return NULL;	126	if( ! packet_is_valid( packet )) return NULL;
114	return ( void * ) packet + packet->data_start;	127	return ( void * ) packet + packet->data_start;
115	}	128	}
116		129
117	packet_mode_t packet_get_mode( const packet_t packet ){	130	packet_mode_t packet_get_mode( const packet_t packet ){
118	if( packet_is_valid( packet )) return packet->mode;	131	if( packet_is_valid( packet )) return packet->mode;
119	return PM_ONEWAY;	132	return PM_ONE_WAY;
120	}	133	}
121		134
122	int packet_set_addr( packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len ){	135	int packet_set_addr( packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len ){
123	size_t padding;	136	size_t padding;
124		137
125	if( !( packet_is_valid( packet ) && ( packet->addr_len >= addr_len ))) return EINVAL;	138	if( ! packet_is_valid( packet )) return EINVAL;
-		139	if( packet->addr_len >= addr_len ) return ENOMEM;
126	padding = packet->addr_len - addr_len;	140	padding = packet->addr_len - addr_len;
127	if( src ){	141	if( src ){
128	memcpy(( void * ) packet + packet->src_addr, src, addr_len );	142	memcpy(( void * ) packet + packet->src_addr, src, addr_len );
129	memset(( void * ) packet + packet->src_addr + addr_len, 0, padding );	143	memset(( void * ) packet + packet->src_addr + addr_len, 0, padding );
130	}else{	144	}else{
131	memset(( void * ) packet + packet->src_addr + addr_len, 0, packet->addr_len );	145	memset(( void * ) packet + packet->src_addr + addr_len, 0, packet->addr_len );
132	}	146	}
133	if( dest ){	147	if( dest ){
134	memcpy(( void * ) packet + packet->dest_addr, dest, addr_len );	148	memcpy(( void * ) packet + packet->dest_addr, dest, addr_len );
135	memset(( void * ) packet + packet->dest_addr + addr_len, 0, padding );	149	memset(( void * ) packet + packet->dest_addr + addr_len, 0, padding );
136	}else{	150	}else{
137	memset(( void * ) packet + packet->dest_addr + addr_len, 0, packet->addr_len );	151	memset(( void * ) packet + packet->dest_addr + addr_len, 0, packet->addr_len );
138	}	152	}
139	return EOK;	153	return EOK;
140	}	154	}
141		155
142	int packet_set_mode( packet_t packet, packet_mode_t mode ){	156	int packet_set_mode( packet_t packet, packet_mode_t mode ){
143	if( ! packet_is_valid( packet )) return EINVAL;	157	if( ! packet_is_valid( packet )) return EINVAL;
144	packet->mode = mode;	158	packet->mode = mode;
145	return EOK;	159	return EOK;
146	}	160	}
147		161
148	int packet_set_owner( packet_t packet, services_t owner ){	162	int packet_set_owner( packet_t packet, services_t owner ){
149	if( ! packet_is_valid( packet )) return EINVAL;	163	if( ! packet_is_valid( packet )) return EINVAL;
150	packet->owner = owner;	164	packet->owner = owner;
151	return EOK;	165	return EOK;
152	}	166	}
153		167
154	int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){	168	int packet_translate( int phone, packet_ref packet, packet_id_t packet_id ){
155	ERROR_DECLARE;	169	ERROR_DECLARE;
156		170
157	unsigned int size;	171	unsigned int size;
158		172
159	if( ! packet ) return EINVAL;	173	if( ! packet ) return EINVAL;
160	* packet = pm_find( packet_id );	174	* packet = pm_find( packet_id );
161	if( * packet ) return EOK;	175	if( * packet ) return EOK;
162	ERROR_PROPAGATE( async_req_1_1( phone, NET_PACKET_GET_SIZE, packet_id, & size ));	176	ERROR_PROPAGATE( async_req_1_1( phone, NET_PACKET_GET_SIZE, packet_id, & size ));
163	return packet_return( phone, packet, packet_id, size );	177	return packet_return( phone, packet, packet_id, size );
164	}	178	}
165		179
166	int packet_return( int phone, packet_ref packet, packet_id_t packet_id, size_t size ){	180	int packet_return( int phone, packet_ref packet, packet_id_t packet_id, size_t size ){
167	ERROR_DECLARE;	181	ERROR_DECLARE;
168		182
169	aid_t message;	183	aid_t message;
170	ipc_call_t answer;	184	ipc_call_t answer;
-		185	ipcarg_t result;
171		186
172	message = async_send_1( phone, NET_PACKET_GET, packet_id, & answer );	187	message = async_send_1( phone, NET_PACKET_GET, packet_id, & answer );
173	* packet = ( packet_t ) as_get_mappable_page( size );	188	* packet = ( packet_t ) as_get_mappable_page( size );
174	if( ERROR_OCCURED( ipc_share_in_start_0_0( phone, * packet, size ))	189	if( ERROR_OCCURRED( ipc_share_in_start_0_0( phone, * packet, size ))
175	\|\| ERROR_OCCURED( pm_add( * packet ))){	190	\|\| ERROR_OCCURRED( pm_add( * packet ))){
176	munmap( * packet, size );	191	munmap( * packet, size );
177	async_wait_for( message, NULL );	192	async_wait_for( message, NULL );
178	return ERROR_CODE;	193	return ERROR_CODE;
179	}	194	}
180	async_wait_for( message, NULL );	195	async_wait_for( message, & result );
181	return EOK;	196	return result;
182	}	197	}
183		198
184	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 ){	199	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_suffix ){
185	ERROR_DECLARE;	200	ERROR_DECLARE;
186		201
187	packet_id_t packet_id;	202	packet_id_t packet_id;
188	unsigned int size;	203	unsigned int size;
189	packet_t packet;	204	packet_t packet;
190		205
191	if( ERROR_OCCURED( async_req_5_2( phone, NET_PACKET_CREATE_5, owner, max_content, addr_len, max_prefix, max_sufix, & packet_id, & size ))	206	if( ERROR_OCCURRED( async_req_5_2( phone, NET_PACKET_CREATE_5, owner, max_content, addr_len, max_prefix, max_suffix, & packet_id, & size ))
192	\|\| ERROR_OCCURED( packet_return( phone, & packet, packet_id, size ))){	207	\|\| ERROR_OCCURRED( packet_return( phone, & packet, packet_id, size ))){
193	return NULL;	208	return NULL;
194	}	209	}
195	return packet;	210	return packet;
196	}	211	}
197		212
198	packet_t packet_get_1( int phone, services_t owner, size_t content ){	213	packet_t packet_get_1( int phone, services_t owner, size_t content ){
199	ERROR_DECLARE;	214	ERROR_DECLARE;
200		215
201	packet_id_t packet_id;	216	packet_id_t packet_id;
202	unsigned int size;	217	unsigned int size;
203	packet_t packet;	218	packet_t packet;
204		219
205	if( ERROR_OCCURED( async_req_2_2( phone, NET_PACKET_CREATE_1, owner, content, & packet_id, & size ))	220	if( ERROR_OCCURRED( async_req_2_2( phone, NET_PACKET_CREATE_1, owner, content, & packet_id, & size ))
206	\|\| ERROR_OCCURED( packet_return( phone, & packet, packet_id, size ))){	221	\|\| ERROR_OCCURRED( packet_return( phone, & packet, packet_id, size ))){
207	return NULL;	222	return NULL;
208	}	223	}
209	return packet;	224	return packet;
210	}	225	}
211		226
212	void packet_release( int phone, packet_id_t packet_id ){	227	void packet_release( int phone, packet_id_t packet_id ){
213	async_msg_1( phone, NET_PACKET_RELEASE, packet_id );	228	async_msg_1( phone, NET_PACKET_RELEASE, packet_id );
214	}	229	}
215		230
216	/** @}	231	/** @}
217	*/	232	*/
218		233

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/structures/packet/packet_client.c – Rev 3901 → 3912