Return to settings-test.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / scripts

Strongswan

    1: /*
    2:  * Copyright (C) 2014-2018 Tobias Brunner
    3:  * HSR Hochschule fuer Technik Rapperswil
    4:  *
    5:  * This program is free software; you can redistribute it and/or modify it
    6:  * under the terms of the GNU General Public License as published by the
    7:  * Free Software Foundation; either version 2 of the License, or (at your
    8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
    9:  *
   10:  * This program is distributed in the hope that it will be useful, but
   11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13:  * for more details.
   14:  */
   15: 
   16: #include <stdio.h>
   17: #include <stdlib.h>
   18: #include <string.h>
   19: #include <unistd.h>
   20: #include <getopt.h>
   21: #include <errno.h>
   22: 
   23: #include <library.h>
   24: #include <settings/settings_types.h>
   25: 
   26: /**
   27:  * Defined in libstrongswan but not part of the public API
   28:  */
   29: bool settings_parser_parse_file(void *this, char *name);
   30: 
   31: /**
   32:  * Produce indentation for the given level
   33:  */
   34: static void get_indent(char indent[BUF_LEN], int level)
   35: {
   36: 	int i;
   37: 
   38: 	for (i = 0; i < level * 2 && i < BUF_LEN - 2; i += 2)
   39: 	{
   40: 		indent[i  ] = ' ';
   41: 		indent[i+1] = ' ';
   42: 	}
   43: 	indent[i] = '\0';
   44: }
   45: 
   46: /**
   47:  * Recursively print the section and all subsections/settings
   48:  */
   49: static void print_section(section_t *section, int level)
   50: {
   51: 	section_t *sub;
   52: 	section_ref_t *ref;
   53: 	kv_t *kv;
   54: 	char indent[BUF_LEN];
   55: 	int i, j;
   56: 
   57: 	get_indent(indent, level);
   58: 
   59: 	for (i = 0; i < array_count(section->kv_order); i++)
   60: 	{
   61: 		array_get(section->kv_order, i, &kv);
   62: 		printf("%s%s = %s\n", indent, kv->key, kv->value);
   63: 	}
   64: 	for (i = 0; i < array_count(section->sections_order); i++)
   65: 	{
   66: 		array_get(section->sections_order, i, &sub);
   67: 		printf("%s%s", indent, sub->name);
   68: 		if (array_count(sub->references))
   69: 		{
   70: 			for (j = 0; j < array_count(sub->references); j++)
   71: 			{
   72: 				array_get(sub->references, j, &ref);
   73: 				printf("%s%s", j == 0 ? " : " : ", ", ref->name);
   74: 			}
   75: 		}
   76: 		printf(" {\n");
   77: 		print_section(sub, level + 1);
   78: 		printf("%s}\n", indent);
   79: 	}
   80: }
   81: 
   82: /**
   83:  * Recursively print a given section and all subsections/settings
   84:  */
   85: static void print_settings_section(settings_t *settings, char *section,
   86: 								   int level)
   87: {
   88: 	enumerator_t *enumerator;
   89: 	char indent[BUF_LEN], buf[BUF_LEN], *key, *value;
   90: 
   91: 	get_indent(indent, level);
   92: 
   93: 	enumerator = settings->create_key_value_enumerator(settings, section);
   94: 	while (enumerator->enumerate(enumerator, &key, &value))
   95: 	{
   96: 		printf("%s%s = %s\n", indent, key, value);
   97: 
   98: 	}
   99: 	enumerator->destroy(enumerator);
  100: 
  101: 	enumerator = settings->create_section_enumerator(settings, section);
  102: 	while (enumerator->enumerate(enumerator, &key))
  103: 	{
  104: 		printf("%s%s {\n", indent, key);
  105: 		snprintf(buf, sizeof(buf), "%s%s%s", section,
  106: 				 strlen(section) ? "." : "", key);
  107: 		print_settings_section(settings, buf, level + 1);
  108: 		printf("%s}\n", indent);
  109: 	}
  110: 	enumerator->destroy(enumerator);
  111: }
  112: 
  113: static void usage(FILE *out, char *name)
  114: {
  115: 	fprintf(out, "Test strongswan.conf parser\n\n");
  116: 	fprintf(out, "%s [OPTIONS]\n\n", name);
  117: 	fprintf(out, "Options:\n");
  118: 	fprintf(out, "  -h, --help          print this help.\n");
  119: 	fprintf(out, "  -d, --debug         enables debugging of the parser.\n");
  120: 	fprintf(out, "  -r, --resolve       displays the settings with references/redefines resolved.\n");
  121: 	fprintf(out, "  -f, --file=FILE     config file to load (default STDIN).\n");
  122: 	fprintf(out, "\n");
  123: }
  124: 
  125: int main(int argc, char *argv[])
  126: {
  127: 	char *file = NULL;
  128: 	bool resolve = FALSE;
  129: 
  130: 	while (true)
  131: 	{
  132: 		struct option long_opts[] = {
  133: 			{"help",		no_argument,		NULL,	'h' },
  134: 			{"debug",		no_argument,		NULL,	'd' },
  135: 			{"file",		required_argument,	NULL,	'f' },
  136: 			{"resolve",		no_argument,		NULL,	'r' },
  137: 			{0,0,0,0 },
  138: 		};
  139: 		switch (getopt_long(argc, argv, "hdf:r", long_opts, NULL))
  140: 		{
  141: 			case EOF:
  142: 				break;
  143: 			case 'h':
  144: 				usage(stdout, argv[0]);
  145: 				return 0;
  146: 			case 'd':
  147: 				setenv("DEBUG_SETTINGS_PARSER", "1", TRUE);
  148: 				continue;
  149: 			case 'f':
  150: 				file = optarg;
  151: 				continue;
  152: 			case 'r':
  153: 				resolve = TRUE;
  154: 				continue;
  155: 			default:
  156: 				usage(stderr, argv[0]);
  157: 				return 1;
  158: 		}
  159: 		break;
  160: 	}
  161: 
  162: 	/* don't load strongswan.conf */
  163: 	library_init("", "settings-test");
  164: 	atexit(library_deinit);
  165: 
  166: 	dbg_default_set_level(3);
  167: 
  168: 	if (file)
  169: 	{
  170: 		if (resolve)
  171: 		{
  172: 			settings_t *settings = settings_create(file);
  173: 
  174: 			print_settings_section(settings, "", 0);
  175: 
  176: 			settings->destroy(settings);
  177: 		}
  178: 		else
  179: 		{
  180: 			section_t *root = settings_section_create(strdup("root"));
  181: 
  182: 			settings_parser_parse_file(root, file);
  183: 
  184: 			print_section(root, 0);
  185: 
  186: 			settings_section_destroy(root, NULL);
  187: 		}
  188: 	}
  189: 	else
  190: 	{
  191: 		usage(stderr, argv[0]);
  192: 	}
  193: 	return 0;
  194: }