roy.marples.name Git - dhcpcd-ui/blob - dhcpcd-config.c

   1 /*
   2  * dhcpcd-gtk
   3  * Copyright 2009 Roy Marples <roy@marples.name>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include "config.h"
  28 #include "dhcpcd-config.h"
  29 #include "dhcpcd-gtk.h"
  30
  31 void
  32 free_config(GPtrArray **config)
  33 {
  34         unsigned int i;
  35
  36         if (config == NULL || *config == NULL)
  37                 return;
  38         for (i = 0; i < (*config)->len; i++)
  39                 g_value_array_free(g_ptr_array_index(*config, i));
  40         g_ptr_array_free(*config, TRUE);
  41         *config = NULL;
  42 }
  43
  44 GPtrArray *
  45 read_config(const char *block, const char *name)
  46 {
  47         GType otype;
  48         GError *error;
  49         GPtrArray *config;
  50
  51         error = NULL;
  52         otype = dbus_g_type_get_struct("GValueArray",
  53             G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
  54         otype = dbus_g_type_get_collection("GPtrArray", otype);
  55         if (!dbus_g_proxy_call(dbus, "GetConfig", &error,
  56                 G_TYPE_STRING, block, G_TYPE_STRING, name, G_TYPE_INVALID,
  57                 otype, &config, G_TYPE_INVALID))
  58         {
  59                 g_critical("GetConfig: %s", error->message);
  60                 g_clear_error(&error);
  61                 return NULL;
  62         }
  63         return config;
  64 }
  65
  66 int
  67 get_config(GPtrArray *config, int idx, const char *opt, const char **value)
  68 {
  69         GValueArray *c;
  70         GValue *val;
  71         const char *str;
  72
  73         if (config == NULL)
  74                 return -1;
  75         for (; (uint)idx < config->len; idx++) {
  76                 c = g_ptr_array_index(config, idx);
  77                 val = g_value_array_get_nth(c, 0);
  78                 str = g_value_get_string(val);
  79                 if (strcmp(str, opt) != 0)
  80                         continue;
  81                 if (value != NULL) {
  82                         val = g_value_array_get_nth(c, 1);
  83                         str = g_value_get_string(val);
  84                         if (*str == '\0')
  85                                 *value = NULL;
  86                         else
  87                                 *value = str;
  88                 }
  89                 return idx;
  90         }
  91         if (value != NULL)
  92                 *value = NULL;
  93         return -1;
  94 }
  95
  96 int
  97 get_static_config(GPtrArray *config, const char *var, const char **value)
  98 {
  99         int idx;
 100         const char *val;
 101
 102         idx = -1;
 103         while ((idx = get_config(config, idx + 1, "static", &val)) != -1) {
 104                 if (g_str_has_prefix(val, var)) {
 105                         if (value)
 106                                 *value = val + strlen(var);
 107                         return idx;
 108                 }
 109         }
 110         if (value)
 111                 *value = NULL;
 112         return -1;
 113 }
 114
 115 GPtrArray *
 116 save_config(const char *block, const char *name, GPtrArray *config)
 117 {
 118         GError *error;
 119         GType otype;
 120
 121         error = NULL;
 122         otype = dbus_g_type_get_struct("GValueArray",
 123             G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
 124         otype = dbus_g_type_get_collection("GPtrArray", otype);
 125         if (!dbus_g_proxy_call(dbus, "SetConfig", &error,
 126                 G_TYPE_STRING, block,
 127                 G_TYPE_STRING, name,
 128                 otype, config,
 129                 G_TYPE_INVALID,
 130                 G_TYPE_INVALID))
 131         {
 132                 g_critical("SetConfig: %s", error->message);
 133                 g_clear_error(&error);
 134                 return NULL;
 135         }
 136         return config;
 137 }
 138
 139 GPtrArray *
 140 load_config(const char *block, const char *name, GPtrArray *array)
 141 {
 142
 143         free_config(&array);
 144         return read_config(block, name);
 145 }
 146
 147 void
 148 set_option(GPtrArray *array, bool sopt, const char *var, const char *val)
 149 {
 150         int i;
 151         GValueArray *va;
 152         GValue nv, *v;
 153         char *n;
 154
 155         if (sopt)
 156                 i = get_static_config(array, var, NULL);
 157         else
 158                 i = get_config(array, 0, var, NULL);
 159         if (val == NULL) {
 160                 if (i != -1) {
 161                         va = g_ptr_array_remove_index(array, i);
 162                         g_value_array_free(va);
 163                 }
 164         } else {
 165                 if (sopt)
 166                         n = g_strconcat(var, val, NULL);
 167                 else
 168                         n = NULL;
 169                 if (i == -1) {
 170                         va = g_value_array_new(2);
 171                         memset(&nv, 0, sizeof(v));
 172                         g_value_init(&nv, G_TYPE_STRING);
 173                         g_value_set_static_string(&nv, sopt ? "static" : var);
 174                         va = g_value_array_append(va, &nv);
 175                         g_value_set_static_string(&nv, sopt ? n : val);
 176                         va = g_value_array_append(va, &nv);
 177                         g_ptr_array_add(array, va);
 178                 } else if (val != NULL) {
 179                         va = g_ptr_array_index(array, i);
 180                         v = g_value_array_get_nth(va, 1);
 181                         g_value_unset(v);
 182                         g_value_init(v, G_TYPE_STRING);
 183                         g_value_set_static_string(v, sopt ? n : val);
 184                 }
 185                 g_free(n);
 186         }
 187 }