2 * Copyright (C) 2013-2014 Intel Corporation.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 * José Bollo <jose.bollo@open.eurogiciel.org>
20 * Stéphane Desneux <stephane.desneux@open.eurogiciel.org>
21 * Jean-Benoit Martin <jean-benoit.martin@open.eurogiciel.org>
35 #include <sys/types.h>
44 #ifndef NOT_MULTI_THREAD_SAFE
49 #define CONFIGPATH "/etc/tizen-platform.conf"
52 #include "tzplatform_variables.h"
53 #include "tzplatform_config.h"
64 #define _HAS_IDS_ ( _FOREIGN_HAS_(UID) \
65 || _FOREIGN_HAS_(EUID) \
66 || _FOREIGN_HAS_(GID) )
68 #define _HAS_PWS_ ( _FOREIGN_HAS_(HOME) \
69 || _FOREIGN_HAS_(USER) \
70 || _FOREIGN_HAS_(EHOME) \
71 || _FOREIGN_HAS_(EUSER) )
73 /* local and static variables */
74 static const char metafilepath[] = CONFIGPATH;
75 static const char emptystring[] = "";
77 /* structure for reading config files */
80 struct tzplatform_context *context;
81 size_t dynvars[_FOREIGN_COUNT_];
82 size_t offsets[_TZPLATFORM_VARIABLES_COUNT_];
85 /* write the error message */
86 static void writerror( const char *format, ...)
89 fprintf( stderr, "tzplatform_config ERROR: ");
91 vfprintf(stderr, format, ap);
93 fprintf( stderr, "\n");
97 /* fill the foreign variables for ids */
98 static void foreignid( struct reading *reading)
103 #if _FOREIGN_HAS_(UID)
105 if (reading->dynvars[UID] == HNULL) {
106 n = snprintf( buffer, sizeof buffer, "%d", (int)get_uid(reading->context));
107 if (0 < n && n < (int)(sizeof buffer))
108 reading->dynvars[UID] = heap_strndup( &reading->context->heap, buffer, (size_t)n);
112 #if _FOREIGN_HAS_(EUID)
114 if (reading->dynvars[EUID] == HNULL) {
115 n = snprintf( buffer, sizeof buffer, "%d", (int)get_euid(reading->context));
116 if (0 < n && n < (int)(sizeof buffer))
117 reading->dynvars[EUID] = heap_strndup( &reading->context->heap, buffer, (size_t)n);
121 #if _FOREIGN_HAS_(GID)
123 if (reading->dynvars[GID] == HNULL) {
124 n = snprintf( buffer, sizeof buffer, "%d", (int)get_gid(reading->context));
125 if (0 < n && n < (int)(sizeof buffer))
126 reading->dynvars[GID] = heap_strndup( &reading->context->heap, buffer, (size_t)n);
133 /* fill the foreign variables for home and user */
134 static void foreignpw( struct reading *reading)
137 struct pwget *array[3];
138 #if _FOREIGN_HAS_(HOME) || _FOREIGN_HAS_(USER)
142 #if _FOREIGN_HAS_(EHOME) || _FOREIGN_HAS_(EUSER)
147 #if _FOREIGN_HAS_(HOME) || _FOREIGN_HAS_(USER)
149 #if _FOREIGN_HAS_(HOME)
150 reading->dynvars[HOME] == HNULL
152 #if _FOREIGN_HAS_(HOME) && _FOREIGN_HAS_(USER)
155 #if _FOREIGN_HAS_(USER)
156 reading->dynvars[USER] == HNULL
159 snprintf( suid, sizeof suid, "%u", (unsigned)get_uid(reading->context));
168 #if _FOREIGN_HAS_(EHOME) || _FOREIGN_HAS_(EUSER)
170 #if _FOREIGN_HAS_(EHOME)
171 reading->dynvars[EHOME] == HNULL
173 #if _FOREIGN_HAS_(EHOME) && _FOREIGN_HAS_(USER)
176 #if _FOREIGN_HAS_(EUSER)
177 reading->dynvars[EUSER] == HNULL
180 snprintf( seuid, sizeof seuid, "%u", (unsigned)get_euid(reading->context));
191 if (pw_get( &reading->context->heap, array) == 0) {
192 #if _FOREIGN_HAS_(HOME)
194 reading->dynvars[HOME] = uid.home;
196 #if _FOREIGN_HAS_(USER)
198 reading->dynvars[USER] = uid.user;
200 #if _FOREIGN_HAS_(EHOME)
202 reading->dynvars[EHOME] = euid.home;
204 #if _FOREIGN_HAS_(EUSER)
206 reading->dynvars[EUSER] = euid.user;
213 /* get the foreign variable */
214 static const char *foreignvar( struct reading *reading,
215 const char *name, size_t length)
217 enum fkey key = foreign( name, length);
222 #if _FOREIGN_HAS_(HOME)
225 #if _FOREIGN_HAS_(USER)
228 #if _FOREIGN_HAS_(EHOME)
231 #if _FOREIGN_HAS_(EUSER)
239 #if _FOREIGN_HAS_(UID)
242 #if _FOREIGN_HAS_(GID)
245 #if _FOREIGN_HAS_(EUID)
255 offset = reading->dynvars[key];
256 return offset==HNULL ? NULL : heap_address( &reading->context->heap, offset);
259 /* callback for parsing errors */
260 static int errcb( struct parsing *parsing,
261 size_t position, const char *message)
263 struct parsinfo info;
264 struct reading *reading = parsing->data;
266 /* count the error */
269 /* print the error */
270 parse_utf8_info( parsing, &info, position);
271 writerror( "%s (file %s line %d)", message, metafilepath, info.lino);
273 /* continue to parse */
277 /* callback for solving variables */
278 static const char *getcb( struct parsing *parsing,
279 const char *key, size_t length,
280 size_t begin_pos, size_t end_pos)
282 struct parsinfo info;
285 struct reading *reading = parsing->data;
288 /* try to find a tzplatform variable */
289 id = hashid(key, length);
291 /* found: try to use it */
292 offset = reading->offsets[id];
294 result = heap_address( &reading->context->heap, offset);
299 /* that is a foreign variable */
300 result = foreignvar( reading, key, length);
303 /* emit the error and then return */
304 if (result == NULL) {
306 parse_utf8_info( parsing, &info, begin_pos);
307 writerror( "undefined value for %.*s (file %s line %d)",
308 length, key, metafilepath, info.lino);
309 result = emptystring; /* avoid error of the parser */
314 /* callback to define variables */
315 static int putcb( struct parsing *parsing,
316 const char *key, size_t key_length,
317 const char *value, size_t value_length,
318 size_t begin_pos, size_t end_pos)
320 struct parsinfo info;
323 struct reading *reading = parsing->data;
326 /* try to find a tzplatform variable */
327 id = hashid( key, key_length);
329 /* check that the variable isn't already defined */
330 offset = reading->offsets[id];
331 if (offset != HNULL) {
333 parse_utf8_info( parsing, &info, begin_pos);
334 writerror( "redefinition of variable %.*s (file %s line %d)",
335 key_length, key, metafilepath, info.lino);
338 /* allocate the variable value */
339 offset = heap_alloc( &reading->context->heap, value_length+1);
340 if (offset == HNULL) {
341 /* error of allocation */
343 writerror( "out of memory");
346 /* record the variable value */
347 reading->offsets[id] = offset;
348 string = heap_address( &reading->context->heap, offset);
349 memcpy( string, value, value_length);
350 string[value_length] = 0;
354 /* forbidden variable */
355 parse_utf8_info( parsing, &info, begin_pos);
356 writerror( "forbidden variable name %.*s (file %s line %d)",
357 key_length, key, metafilepath, info.lino);
361 /* continue to parse */
365 /* initialize the environment */
366 void initialize(struct tzplatform_context *context)
368 struct buffer buffer;
369 struct parsing parsing;
370 struct reading reading;
374 /* clear the variables */
375 reading.errcount = 0;
376 reading.context = context;
377 for (i = 0 ; i < (int)_FOREIGN_COUNT_ ; i++) {
378 reading.dynvars[i] = HNULL;
380 for (i = 0 ; i < (int)_TZPLATFORM_VARIABLES_COUNT_ ; i++) {
381 context->values[i] = NULL;
382 reading.offsets[i] = HNULL;
385 /* read the configuration file */
386 result = buffer_create( &buffer, metafilepath);
388 writerror( "can't read file %s",metafilepath);
389 context->state = ERROR;
393 /* create the heap */
394 result = heap_create( &context->heap, 1);
396 buffer_destroy( &buffer);
397 writerror( "out of memory");
398 context->state = ERROR;
403 parsing.buffer = buffer.buffer;
404 parsing.length = buffer.length;
405 parsing.maximum_data_size = 0;
406 parsing.should_escape = 0;
407 parsing.data = &reading;
410 parsing.error = errcb;
411 result = parse_utf8_config( &parsing);
412 buffer_destroy( &buffer);
413 if (result != 0 || reading.errcount != 0) {
414 writerror( "%d errors while parsing file %s",
415 reading.errcount, metafilepath);
418 /* set the variables */
419 heap_read_only( &context->heap);
420 for (i = 0 ; i < (int)_TZPLATFORM_VARIABLES_COUNT_ ; i++) {
421 offset = reading.offsets[i];
423 context->values[i] = heap_address( &context->heap, offset);
425 writerror( "the variable %s isn't defined in file %s",
426 keyname(i), metafilepath);
427 /* TODO undefined variable */;
429 context->state = VALID;