Network Cofigurator sounds better
[dhcpcd-ui] / 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 }