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 load_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 static 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_config(GPtrArray *config, const char *opt, const char **value)
  98 {
  99
 100         return _get_config(config, 0, opt, value);
 101 }
 102
 103 int
 104 get_config_static(GPtrArray *config, const char *var, const char **value)
 105 {
 106         int idx;
 107         const char *val;
 108
 109         idx = -1;
 110         while ((idx = _get_config(config, idx + 1, "static", &val)) != -1) {
 111                 if (g_str_has_prefix(val, var)) {
 112                         if (value)
 113                                 *value = val + strlen(var);
 114                         return idx;
 115                 }
 116         }
 117         if (value)
 118                 *value = NULL;
 119         return -1;
 120 }
 121
 122 void
 123 set_option(GPtrArray *config, bool sopt, const char *var, const char *val)
 124 {
 125         int i;
 126         GValueArray *va;
 127         GValue nv, *v;
 128         char *n;
 129
 130         if (sopt)
 131                 i = get_config_static(config, var, NULL);
 132         else
 133                 i = get_config(config, var, NULL);
 134         if (val == NULL) {
 135                 if (i != -1) {
 136                         va = g_ptr_array_remove_index(config, i);
 137                         g_value_array_free(va);
 138                 }
 139         } else {
 140                 if (sopt)
 141                         n = g_strconcat(var, val, NULL);
 142                 else
 143                         n = NULL;
 144                 memset(&nv, 0, sizeof(v));
 145                 g_value_init(&nv, G_TYPE_STRING);
 146                 if (i == -1) {
 147                         va = g_value_array_new(2);
 148                         g_ptr_array_add(config, va);
 149                         g_value_set_static_string(&nv, sopt ? "static" : var);
 150                         va = g_value_array_append(va, &nv);
 151                 } else {
 152                         va = g_ptr_array_index(config, i);
 153                         va = g_value_array_remove(va, 1);
 154                 }
 155                 g_value_set_static_string(&nv, sopt ? n : val);
 156                 va = g_value_array_append(va, &nv);
 157                 g_free(n);
 158         }
 159 }
 160
 161 bool
 162 save_config(const char *block, const char *name, GPtrArray *config)
 163 {
 164         GError *error;
 165         GType otype;
 166
 167         error = NULL;
 168         otype = dbus_g_type_get_struct("GValueArray",
 169             G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
 170         otype = dbus_g_type_get_collection("GPtrArray", otype);
 171         if (!dbus_g_proxy_call(dbus, "SetConfig", &error,
 172                 G_TYPE_STRING, block,
 173                 G_TYPE_STRING, name,
 174                 otype, config,
 175                 G_TYPE_INVALID,
 176                 G_TYPE_INVALID))
 177         {
 178                 g_critical("SetConfig: %s", error->message);
 179                 g_clear_error(&error);
 180                 return false;
 181         }
 182         return true;
 183 }