scripts/settings-test.c

   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", indent);
  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  * FIXME: Doesn't work properly if any of the keys contain dots
  85  */
  86 static void print_settings_section(settings_t *settings, char *section,
  87                                                                    int level)
  88 {
  89         enumerator_t *enumerator;
  90         char indent[BUF_LEN], buf[BUF_LEN], *key, *value;
  91
  92         get_indent(indent, level);
  93
  94         enumerator = settings->create_key_value_enumerator(settings, section);
  95         while (enumerator->enumerate(enumerator, &key, &value))
  96         {
  97                 printf("%s%s = %s\n", indent, key, value);
  98
  99         }
 100         enumerator->destroy(enumerator);
 101
 102         enumerator = settings->create_section_enumerator(settings, section);
 103         while (enumerator->enumerate(enumerator, &key))
 104         {
 105                 printf("%s%s {\n", indent, key);
 106                 snprintf(buf, sizeof(buf), "%s%s%s", section,
 107                                  strlen(section) ? "." : "", key);
 108                 print_settings_section(settings, buf, level + 1);
 109                 printf("%s}\n", indent);
 110         }
 111         enumerator->destroy(enumerator);
 112 }
 113
 114 static void usage(FILE *out, char *name)
 115 {
 116         fprintf(out, "Test strongswan.conf parser\n\n");
 117         fprintf(out, "%s [OPTIONS]\n\n", name);
 118         fprintf(out, "Options:\n");
 119         fprintf(out, "  -h, --help          print this help.\n");
 120         fprintf(out, "  -d, --debug         enables debugging of the parser.\n");
 121         fprintf(out, "  -r, --resolve       displays the settings with references/redefines resolved.\n");
 122         fprintf(out, "  -f, --file=FILE     config file to load (default STDIN).\n");
 123         fprintf(out, "\n");
 124 }
 125
 126 int main(int argc, char *argv[])
 127 {
 128         char *file = NULL;
 129         bool resolve = FALSE;
 130
 131         while (true)
 132         {
 133                 struct option long_opts[] = {
 134                         {"help",                no_argument,            NULL,   'h' },
 135                         {"debug",               no_argument,            NULL,   'd' },
 136                         {"file",                required_argument,      NULL,   'f' },
 137                         {"resolve",             no_argument,            NULL,   'r' },
 138                         {0,0,0,0 },
 139                 };
 140                 switch (getopt_long(argc, argv, "hdf:r", long_opts, NULL))
 141                 {
 142                         case EOF:
 143                                 break;
 144                         case 'h':
 145                                 usage(stdout, argv[0]);
 146                                 return 0;
 147                         case 'd':
 148                                 setenv("DEBUG_SETTINGS_PARSER", "1", TRUE);
 149                                 continue;
 150                         case 'f':
 151                                 file = optarg;
 152                                 continue;
 153                         case 'r':
 154                                 resolve = TRUE;
 155                                 continue;
 156                         default:
 157                                 usage(stderr, argv[0]);
 158                                 return 1;
 159                 }
 160                 break;
 161         }
 162
 163         /* don't load strongswan.conf */
 164         library_init("", "settings-test");
 165         atexit(library_deinit);
 166
 167         dbg_default_set_level(3);
 168
 169         if (file)
 170         {
 171                 if (resolve)
 172                 {
 173                         settings_t *settings = settings_create(file);
 174
 175                         print_settings_section(settings, "", 0);
 176
 177                         settings->destroy(settings);
 178                 }
 179                 else
 180                 {
 181                         section_t *root = settings_section_create(strdup("root"));
 182
 183                         settings_parser_parse_file(root, file);
 184
 185                         print_section(root, 0);
 186
 187                         settings_section_destroy(root, NULL);
 188                 }
 189         }
 190         else
 191         {
 192                 usage(stderr, argv[0]);
 193         }
 194         return 0;
 195 }