WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/structures/measured_strings.c


/*
 * 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
 *  A&nbsp;character string with measured length implementation file.
 *  @see measured_strings.h
 */
 
#include <errno.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
 
#include <ipc/ipc.h>
 
#include "../err.h"
#include "../modules.h"
 
#include "measured_strings.h"
 
 
/** Computes the lengths of the measured strings in the given array.
 *  @param strings The measured strings array to be processed. Input parameter.
 *  @param count The measured strings array size. Input parameter.
 *  @returns The computed sizes array.
 *  @returns NULL if there is no memory left.
 */
size_t *    prepare_lengths( const measured_string_ref strings, size_t count );
 
measured_string_ref measured_string_create_bulk( const char * string, size_t length ){
    measured_string_ref new;
 
    if( length == 0 ){
        while( string[ length ] ) ++ length;
    }
    new = ( measured_string_ref ) malloc( sizeof( measured_string_t ) + ( sizeof( char ) * ( length + 1 )));
    if( ! new ) return NULL;
    new->length = length;
    new->value = (( char * ) new ) + sizeof( measured_string_t );
    // append terminating zero explicitly - to be safe
    memcpy( new->value, string, new->length );
    new->value[ new->length ] = '\0';
    return new;
}
 
int measured_strings_receive( measured_string_ref * strings, char ** data, size_t count ){
    ERROR_DECLARE;
 
    size_t *        lengths;
    int             index;
    size_t          length;
    char *          next;
    ipc_callid_t    callid;
 
    if(( ! strings ) || ( ! data ) || ( count <= 0 )){
        return EINVAL;
    }
    lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
    if( ! lengths ) return ENOMEM;
    if(( ! ipc_data_write_receive( & callid, & length ))
    || ( length != sizeof( size_t ) * ( count + 1 ))){
        free( lengths );
        return EINVAL;
    }
    if( ERROR_OCCURED( ipc_data_write_finalize( callid, lengths, sizeof( size_t ) * ( count + 1 )))){
        free( lengths );
        return ERROR_CODE;
    }
    * data = malloc( lengths[ count ] );
    if( !( * data )) return ENOMEM;
    ( * data )[ lengths[ count ] - 1 ] = '\0';
    * strings = ( measured_string_ref ) malloc( sizeof( measured_string_t ) * count );
    if( !( * strings )){
        free( lengths );
        free( * data );
        return ENOMEM;
    }
    next = * data;
    for( index = 0; index < count; ++ index ){
        ( * strings)[ index ].length = lengths[ index ];
        if( lengths[ index ] > 0 ){
            if(( ! ipc_data_write_receive( & callid, & length ))
            || ( length != lengths[ index ] )){
                free( * data );
                free( * strings );
                free( lengths );
                return EINVAL;
            }
            ERROR_PROPAGATE( ipc_data_write_finalize( callid, next, lengths[ index ] ));
            ( * strings)[ index ].value = next;
            next += lengths[ index ];
            * next = '\0';
            ++ next;
        }else{
            ( * strings )[ index ].value = NULL;
        }
    }
    free( lengths );
    return EOK;
}
 
int measured_strings_reply( const measured_string_ref strings, size_t count ){
    ERROR_DECLARE;
 
    size_t *        lengths;
    int             index;
    size_t          length;
    ipc_callid_t    callid;
 
    if(( ! strings ) || ( count <= 0 )){
        return EINVAL;
    }
    lengths = prepare_lengths( strings, count );
    if( ! lengths ) return ENOMEM;
    if(( ! ipc_data_read_receive( & callid, & length ))
    || ( length != sizeof( size_t ) * ( count + 1 ))){
        free( lengths );
        return EINVAL;
    }
    if( ERROR_OCCURED( ipc_data_read_finalize( callid, lengths, sizeof( size_t ) * ( count + 1 )))){
        free( lengths );
        return ERROR_CODE;
    }
    free( lengths );
    for( index = 0; index < count; ++ index ){
        if( strings[ index ].length > 0 ){
            if(( ! ipc_data_read_receive( & callid, & length ))
            || ( length != strings[ index ].length )){
                return EINVAL;
            }
            ERROR_PROPAGATE( ipc_data_read_finalize( callid, strings[ index ].value, strings[ index ].length ));
        }
    }
    return EOK;
}
 
int measured_strings_return( int phone, measured_string_ref * strings, char ** data, size_t count ){
    ERROR_DECLARE;
 
    size_t *    lengths;
    int         index;
    char *      next;
 
    if(( phone <= 0 ) || ( ! strings ) || ( ! data ) || ( count <= 0 )){
        return EINVAL;
    }
    lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
    if( ! lengths ) return ENOMEM;
    if( ERROR_OCCURED( ipc_data_read_start( phone, lengths, sizeof( size_t ) * ( count + 1 )))){
        free( lengths );
        return ERROR_CODE;
    }
    * data = malloc( lengths[ count ] );
    if( !( * data )) return ENOMEM;
    * strings = ( measured_string_ref ) malloc( sizeof( measured_string_t ) * count );
    if( !( * strings )){
        free( lengths );
        free( * data );
        return ENOMEM;
    }
    next = * data;
    for( index = 0; index < count; ++ index ){
        ( * strings )[ index ].length = lengths[ index ];
        if( lengths[ index ] > 0 ){
            ERROR_PROPAGATE( ipc_data_read_start( phone, next, lengths[ index ] ));
            ( * strings )[ index ].value = next;
            next += lengths[ index ];
            * next = '\0';
            ++ next;
        }else{
            ( * strings )[ index ].value = NULL;
        }
    }
    free( lengths );
    return EOK;
}
 
int measured_strings_send( int phone, const measured_string_ref strings, size_t count ){
    ERROR_DECLARE;
 
    size_t *    lengths;
    int         index;
 
    if(( phone <= 0 ) || ( ! strings ) || ( count <= 0 )){
        return EINVAL;
    }
    lengths = prepare_lengths( strings, count );
    if( ! lengths ) return ENOMEM;
    if( ERROR_OCCURED( ipc_data_write_start( phone, lengths, sizeof( size_t ) * ( count + 1 )))){
        free( lengths );
        return ERROR_CODE;
    }
    free( lengths );
    for( index = 0; index < count; ++ index ){
        if( strings[ index ].length > 0 ){
            ERROR_PROPAGATE( ipc_data_write_start( phone, strings[ index ].value, strings[ index ].length ));
        }
    }
    return EOK;
}
 
size_t * prepare_lengths( const measured_string_ref strings, size_t count ){
    size_t *    lengths;
    int         index;
    size_t      length;
 
    lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
    if( ! lengths ) return NULL;
    length = 0;
    for( index = 0; index < count; ++ index ){
        lengths[ index ] = strings[ index ].length;
        length += lengths[ index ] + 1;
    }
    lengths[ count ] = length;
    return lengths;
}
 
/** @}
 */
 
 

Rev 3846	Rev 3886
1	/*	1	/*
2	* Copyright (c) 2008 Lukas Mejdrech	2	* Copyright (c) 2008 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 net
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* A character string with measured length implementation file.	34	* A character string with measured length implementation file.
35	* @see measured_strings.h	35	* @see measured_strings.h
36	*/	36	*/
37		37
38	#include <errno.h>	38	#include <errno.h>
39	#include <malloc.h>	39	#include <malloc.h>
40	#include <stdio.h>	40	#include <stdio.h>
41	#include <string.h>	41	#include <string.h>
42	#include <unistd.h>	42	#include <unistd.h>
43		43
44	#include <ipc/ipc.h>	44	#include <ipc/ipc.h>
45		45
46	#include "err.h"	46	#include "../err.h"
-		47	#include "../modules.h"
-		48
47	#include "measured_strings.h"	49	#include "measured_strings.h"
48	#include "modules.h"	-
49		50
50	/** Computes the lengths of the measured strings in the given array.	51	/** Computes the lengths of the measured strings in the given array.
51	* @param strings The measured strings array to be processed. Input parameter.	52	* @param strings The measured strings array to be processed. Input parameter.
52	* @param count The measured strings array size. Input parameter.	53	* @param count The measured strings array size. Input parameter.
53	* @returns The computed sizes array.	54	* @returns The computed sizes array.
54	* @returns NULL if there is no memory left.	55	* @returns NULL if there is no memory left.
55	*/	56	*/
56	size_t * prepare_lengths( const measured_string_ref strings, size_t count );	57	size_t * prepare_lengths( const measured_string_ref strings, size_t count );
57		58
58	measured_string_ref measured_string_create_bulk( const char * string, size_t length ){	59	measured_string_ref measured_string_create_bulk( const char * string, size_t length ){
59	measured_string_ref new;	60	measured_string_ref new;
60		61
61	if( length == 0 ){	62	if( length == 0 ){
62	while( string[ length ] ) ++ length;	63	while( string[ length ] ) ++ length;
63	}	64	}
64	new = ( measured_string_ref ) malloc( sizeof( measured_string_t ) + ( sizeof( char ) * ( length + 1 )));	65	new = ( measured_string_ref ) malloc( sizeof( measured_string_t ) + ( sizeof( char ) * ( length + 1 )));
65	if( ! new ) return NULL;	66	if( ! new ) return NULL;
66	new->length = length;	67	new->length = length;
67	new->value = (( char * ) new ) + sizeof( measured_string_t );	68	new->value = (( char * ) new ) + sizeof( measured_string_t );
68	// append terminating zero explicitly - to be safe	69	// append terminating zero explicitly - to be safe
69	memcpy( new->value, string, new->length );	70	memcpy( new->value, string, new->length );
70	new->value[ new->length ] = '\0';	71	new->value[ new->length ] = '\0';
71	return new;	72	return new;
72	}	73	}
73		74
74	int measured_strings_receive( measured_string_ref * strings, char ** data, size_t count ){	75	int measured_strings_receive( measured_string_ref * strings, char ** data, size_t count ){
75	ERROR_DECLARE;	76	ERROR_DECLARE;
76		77
77	size_t * lengths;	78	size_t * lengths;
78	int index;	79	int index;
79	size_t length;	80	size_t length;
80	char * next;	81	char * next;
81	ipc_callid_t callid;	82	ipc_callid_t callid;
82		83
83	if(( ! strings ) \|\| ( ! data ) \|\| ( count <= 0 )){	84	if(( ! strings ) \|\| ( ! data ) \|\| ( count <= 0 )){
84	return EINVAL;	85	return EINVAL;
85	}	86	}
86	lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));	87	lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
87	if( ! lengths ) return ENOMEM;	88	if( ! lengths ) return ENOMEM;
88	if(( ! ipc_data_write_receive( & callid, & length ))	89	if(( ! ipc_data_write_receive( & callid, & length ))
89	\|\| ( length != sizeof( size_t ) * ( count + 1 ))){	90	\|\| ( length != sizeof( size_t ) * ( count + 1 ))){
90	free( lengths );	91	free( lengths );
91	return EINVAL;	92	return EINVAL;
92	}	93	}
93	if( ERROR_OCCURED( ipc_data_write_finalize( callid, lengths, sizeof( size_t ) * ( count + 1 )))){	94	if( ERROR_OCCURED( ipc_data_write_finalize( callid, lengths, sizeof( size_t ) * ( count + 1 )))){
94	free( lengths );	95	free( lengths );
95	return ERROR_CODE;	96	return ERROR_CODE;
96	}	97	}
97	* data = malloc( lengths[ count ] );	98	* data = malloc( lengths[ count ] );
98	if( !( * data )) return ENOMEM;	99	if( !( * data )) return ENOMEM;
99	( * data )[ lengths[ count ] - 1 ] = '\0';	100	( * data )[ lengths[ count ] - 1 ] = '\0';
100	* strings = ( measured_string_ref ) malloc( sizeof( measured_string_t ) * count );	101	* strings = ( measured_string_ref ) malloc( sizeof( measured_string_t ) * count );
101	if( !( * strings )){	102	if( !( * strings )){
102	free( lengths );	103	free( lengths );
103	free( * data );	104	free( * data );
104	return ENOMEM;	105	return ENOMEM;
105	}	106	}
106	next = * data;	107	next = * data;
107	for( index = 0; index < count; ++ index ){	108	for( index = 0; index < count; ++ index ){
108	( * strings)[ index ].length = lengths[ index ];	109	( * strings)[ index ].length = lengths[ index ];
109	if( lengths[ index ] > 0 ){	110	if( lengths[ index ] > 0 ){
110	if(( ! ipc_data_write_receive( & callid, & length ))	111	if(( ! ipc_data_write_receive( & callid, & length ))
111	\|\| ( length != lengths[ index ] )){	112	\|\| ( length != lengths[ index ] )){
112	free( * data );	113	free( * data );
113	free( * strings );	114	free( * strings );
114	free( lengths );	115	free( lengths );
115	return EINVAL;	116	return EINVAL;
116	}	117	}
117	ERROR_PROPAGATE( ipc_data_write_finalize( callid, next, lengths[ index ] ));	118	ERROR_PROPAGATE( ipc_data_write_finalize( callid, next, lengths[ index ] ));
118	( * strings)[ index ].value = next;	119	( * strings)[ index ].value = next;
119	next += lengths[ index ];	120	next += lengths[ index ];
120	* next = '\0';	121	* next = '\0';
121	++ next;	122	++ next;
122	}else{	123	}else{
123	( * strings )[ index ].value = NULL;	124	( * strings )[ index ].value = NULL;
124	}	125	}
125	}	126	}
126	free( lengths );	127	free( lengths );
127	return EOK;	128	return EOK;
128	}	129	}
129		130
130	int measured_strings_reply( const measured_string_ref strings, size_t count ){	131	int measured_strings_reply( const measured_string_ref strings, size_t count ){
131	ERROR_DECLARE;	132	ERROR_DECLARE;
132		133
133	size_t * lengths;	134	size_t * lengths;
134	int index;	135	int index;
135	size_t length;	136	size_t length;
136	ipc_callid_t callid;	137	ipc_callid_t callid;
137		138
138	if(( ! strings ) \|\| ( count <= 0 )){	139	if(( ! strings ) \|\| ( count <= 0 )){
139	return EINVAL;	140	return EINVAL;
140	}	141	}
141	lengths = prepare_lengths( strings, count );	142	lengths = prepare_lengths( strings, count );
142	if( ! lengths ) return ENOMEM;	143	if( ! lengths ) return ENOMEM;
143	if(( ! ipc_data_read_receive( & callid, & length ))	144	if(( ! ipc_data_read_receive( & callid, & length ))
144	\|\| ( length != sizeof( size_t ) * ( count + 1 ))){	145	\|\| ( length != sizeof( size_t ) * ( count + 1 ))){
145	free( lengths );	146	free( lengths );
146	return EINVAL;	147	return EINVAL;
147	}	148	}
148	if( ERROR_OCCURED( ipc_data_read_finalize( callid, lengths, sizeof( size_t ) * ( count + 1 )))){	149	if( ERROR_OCCURED( ipc_data_read_finalize( callid, lengths, sizeof( size_t ) * ( count + 1 )))){
149	free( lengths );	150	free( lengths );
150	return ERROR_CODE;	151	return ERROR_CODE;
151	}	152	}
152	free( lengths );	153	free( lengths );
153	for( index = 0; index < count; ++ index ){	154	for( index = 0; index < count; ++ index ){
154	if( strings[ index ].length > 0 ){	155	if( strings[ index ].length > 0 ){
155	if(( ! ipc_data_read_receive( & callid, & length ))	156	if(( ! ipc_data_read_receive( & callid, & length ))
156	\|\| ( length != strings[ index ].length )){	157	\|\| ( length != strings[ index ].length )){
157	return EINVAL;	158	return EINVAL;
158	}	159	}
159	ERROR_PROPAGATE( ipc_data_read_finalize( callid, strings[ index ].value, strings[ index ].length ));	160	ERROR_PROPAGATE( ipc_data_read_finalize( callid, strings[ index ].value, strings[ index ].length ));
160	}	161	}
161	}	162	}
162	return EOK;	163	return EOK;
163	}	164	}
164		165
165	int measured_strings_return( int phone, measured_string_ref * strings, char ** data, size_t count ){	166	int measured_strings_return( int phone, measured_string_ref * strings, char ** data, size_t count ){
166	ERROR_DECLARE;	167	ERROR_DECLARE;
167		168
168	size_t * lengths;	169	size_t * lengths;
169	int index;	170	int index;
170	char * next;	171	char * next;
171		172
172	if(( phone <= 0 ) \|\| ( ! strings ) \|\| ( ! data ) \|\| ( count <= 0 )){	173	if(( phone <= 0 ) \|\| ( ! strings ) \|\| ( ! data ) \|\| ( count <= 0 )){
173	return EINVAL;	174	return EINVAL;
174	}	175	}
175	lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));	176	lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
176	if( ! lengths ) return ENOMEM;	177	if( ! lengths ) return ENOMEM;
177	if( ERROR_OCCURED( ipc_data_read_start( phone, lengths, sizeof( size_t ) * ( count + 1 )))){	178	if( ERROR_OCCURED( ipc_data_read_start( phone, lengths, sizeof( size_t ) * ( count + 1 )))){
178	free( lengths );	179	free( lengths );
179	return ERROR_CODE;	180	return ERROR_CODE;
180	}	181	}
181	* data = malloc( lengths[ count ] );	182	* data = malloc( lengths[ count ] );
182	if( !( * data )) return ENOMEM;	183	if( !( * data )) return ENOMEM;
183	* strings = ( measured_string_ref ) malloc( sizeof( measured_string_t ) * count );	184	* strings = ( measured_string_ref ) malloc( sizeof( measured_string_t ) * count );
184	if( !( * strings )){	185	if( !( * strings )){
185	free( lengths );	186	free( lengths );
186	free( * data );	187	free( * data );
187	return ENOMEM;	188	return ENOMEM;
188	}	189	}
189	next = * data;	190	next = * data;
190	for( index = 0; index < count; ++ index ){	191	for( index = 0; index < count; ++ index ){
191	( * strings )[ index ].length = lengths[ index ];	192	( * strings )[ index ].length = lengths[ index ];
192	if( lengths[ index ] > 0 ){	193	if( lengths[ index ] > 0 ){
193	ERROR_PROPAGATE( ipc_data_read_start( phone, next, lengths[ index ] ));	194	ERROR_PROPAGATE( ipc_data_read_start( phone, next, lengths[ index ] ));
194	( * strings )[ index ].value = next;	195	( * strings )[ index ].value = next;
195	next += lengths[ index ];	196	next += lengths[ index ];
196	* next = '\0';	197	* next = '\0';
197	++ next;	198	++ next;
198	}else{	199	}else{
199	( * strings )[ index ].value = NULL;	200	( * strings )[ index ].value = NULL;
200	}	201	}
201	}	202	}
202	free( lengths );	203	free( lengths );
203	return EOK;	204	return EOK;
204	}	205	}
205		206
206	int measured_strings_send( int phone, const measured_string_ref strings, size_t count ){	207	int measured_strings_send( int phone, const measured_string_ref strings, size_t count ){
207	ERROR_DECLARE;	208	ERROR_DECLARE;
208		209
209	size_t * lengths;	210	size_t * lengths;
210	int index;	211	int index;
211		212
212	if(( phone <= 0 ) \|\| ( ! strings ) \|\| ( count <= 0 )){	213	if(( phone <= 0 ) \|\| ( ! strings ) \|\| ( count <= 0 )){
213	return EINVAL;	214	return EINVAL;
214	}	215	}
215	lengths = prepare_lengths( strings, count );	216	lengths = prepare_lengths( strings, count );
216	if( ! lengths ) return ENOMEM;	217	if( ! lengths ) return ENOMEM;
217	if( ERROR_OCCURED( ipc_data_write_start( phone, lengths, sizeof( size_t ) * ( count + 1 )))){	218	if( ERROR_OCCURED( ipc_data_write_start( phone, lengths, sizeof( size_t ) * ( count + 1 )))){
218	free( lengths );	219	free( lengths );
219	return ERROR_CODE;	220	return ERROR_CODE;
220	}	221	}
221	free( lengths );	222	free( lengths );
222	for( index = 0; index < count; ++ index ){	223	for( index = 0; index < count; ++ index ){
223	if( strings[ index ].length > 0 ){	224	if( strings[ index ].length > 0 ){
224	ERROR_PROPAGATE( ipc_data_write_start( phone, strings[ index ].value, strings[ index ].length ));	225	ERROR_PROPAGATE( ipc_data_write_start( phone, strings[ index ].value, strings[ index ].length ));
225	}	226	}
226	}	227	}
227	return EOK;	228	return EOK;
228	}	229	}
229		230
230	size_t * prepare_lengths( const measured_string_ref strings, size_t count ){	231	size_t * prepare_lengths( const measured_string_ref strings, size_t count ){
231	size_t * lengths;	232	size_t * lengths;
232	int index;	233	int index;
233	size_t length;	234	size_t length;
234		235
235	lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));	236	lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
236	if( ! lengths ) return NULL;	237	if( ! lengths ) return NULL;
237	length = 0;	238	length = 0;
238	for( index = 0; index < count; ++ index ){	239	for( index = 0; index < count; ++ index ){
239	lengths[ index ] = strings[ index ].length;	240	lengths[ index ] = strings[ index ].length;
240	length += lengths[ index ] + 1;	241	length += lengths[ index ] + 1;
241	}	242	}
242	lengths[ count ] = length;	243	lengths[ count ] = length;
243	return lengths;	244	return lengths;
244	}	245	}
245		246
246	/** @}	247	/** @}
247	*/	248	*/
248		249
249		250

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/structures/measured_strings.c – Rev 3846 → 3886