roy.marples.name Git - dhcpcd-ui/blob - src/dhcpcd-gtk/prefs.c

   1 /*
   2  * dhcpcd-gtk
   3  * Copyright 2009-2012 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 <sys/types.h>
  28 #include <net/if.h>
  29
  30 #include <errno.h>
  31
  32 #include "dhcpcd-gtk.h"
  33
  34 static GtkWidget *dialog, *blocks, *names, *controls, *clear, *rebind;
  35 static GtkWidget *autoconf, *address, *router, *dns_servers, *dns_search;
  36 static DHCPCD_CONFIG *config;
  37 static char *block, *name;
  38 static DHCPCD_IF *iface;
  39
  40 static void
  41 show_config(DHCPCD_CONFIG *conf)
  42 {
  43         const char *val;
  44         bool autocnf;
  45
  46         if ((val = dhcpcd_config_get_static(conf, "ip_address=")) != NULL)
  47                 autocnf = false;
  48         else {
  49                 if ((val = dhcpcd_config_get(conf, "inform")) == NULL &&
  50                     (iface && iface->flags & IFF_POINTOPOINT))
  51                         autocnf = false;
  52                 else
  53                         autocnf = true;
  54         }
  55         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(autoconf), autocnf);
  56         gtk_entry_set_text(GTK_ENTRY(address), val ? val : "");
  57         val = dhcpcd_config_get_static(conf, "routers=");
  58         gtk_entry_set_text(GTK_ENTRY(router), val ? val : "");
  59         val = dhcpcd_config_get_static(conf, "domain_name_servers=");
  60         gtk_entry_set_text(GTK_ENTRY(dns_servers), val ? val : "");
  61         val = dhcpcd_config_get_static(conf, "domain_search=");
  62         gtk_entry_set_text(GTK_ENTRY(dns_search), val ? val : "");
  63 }
  64
  65 static char *
  66 combo_active_text(GtkWidget *widget)
  67 {
  68         GtkListStore *store;
  69         GtkTreeIter iter;
  70         GValue val;
  71         char *text;
  72
  73         store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(widget)));
  74         if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(widget), &iter))
  75                 return NULL;
  76         memset(&val, 0, sizeof(val));
  77         gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, 1, &val);
  78         text = g_strdup(g_value_get_string(&val));
  79         g_value_unset(&val);
  80         return text;
  81 }
  82
  83 static bool
  84 set_option(DHCPCD_CONFIG **conf, bool s, const char *opt, const char *val,
  85         bool *ret)
  86 {
  87         bool r;
  88
  89         if (s)
  90                 r = dhcpcd_config_set_static(conf, opt, val);
  91         else
  92                 r = dhcpcd_config_set(conf, opt, val);
  93         if (r)
  94                 return true;
  95         g_error("libdhcpcd: %s", strerror(errno));
  96         if (ret)
  97                 *ret = false;
  98         return false;
  99 }
 100
 101 static bool
 102 make_config(DHCPCD_CONFIG **conf)
 103 {
 104         const char *val, ns[] = "";
 105         bool a, ret;
 106
 107         ret = true;
 108         a = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(autoconf));
 109         if (iface && iface->flags & IFF_POINTOPOINT)
 110                 set_option(conf, true, "ip_address=", a ? NULL : ns, &ret);
 111         else {
 112                 val = gtk_entry_get_text(GTK_ENTRY(address));
 113                 if (*val == '\0')
 114                         val = NULL;
 115                 set_option(conf, false, "inform", a ? val : NULL, &ret);
 116                 set_option(conf, true, "ip_address=", a ? NULL : val, &ret);
 117         }
 118
 119         val = gtk_entry_get_text(GTK_ENTRY(router));
 120         if (a && *val == '\0')
 121                 val = NULL;
 122         set_option(conf, true, "routers=", val, &ret);
 123
 124         val = gtk_entry_get_text(GTK_ENTRY(dns_servers));
 125         if (a && *val == '\0')
 126                 val = NULL;
 127         set_option(conf, true, "domain_name_servers=", val, &ret);
 128
 129         val = gtk_entry_get_text(GTK_ENTRY(dns_search));
 130         if (a && *val == '\0')
 131                 val = NULL;
 132         set_option(conf, true, "domain_search=", val, &ret);
 133
 134         return ret;
 135 }
 136
 137 static GdkPixbuf *
 138 load_icon(const char *iname)
 139 {
 140         int width, height;
 141
 142         if (!gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &width, &height))
 143                 return NULL;
 144         return gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),
 145             iname, MIN(width, height), 0, NULL);
 146 }
 147
 148 static void
 149 set_name_active_icon(const char *iname)
 150 {
 151         GtkListStore *store;
 152         GtkTreeIter iter;
 153         GtkTreePath *path;
 154         GdkPixbuf *pb;
 155
 156         store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(names)));
 157         if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(names), &iter))
 158                 return;
 159         pb = load_icon(iname);
 160         if (pb) {
 161                 path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
 162                 gtk_list_store_set(store, &iter, 0, pb, -1);
 163                 g_object_unref(pb);
 164                 gtk_tree_model_row_changed(GTK_TREE_MODEL(store), path, &iter);
 165                 gtk_tree_path_free(path);
 166         }
 167 }
 168
 169 static GSList *
 170 list_interfaces(DHCPCD_CONNECTION *con)
 171 {
 172         GSList *list;
 173         DHCPCD_IF *i;
 174
 175         list = NULL;
 176         for (i = dhcpcd_interfaces(con); i; i = i->next)
 177                 if (strcmp(i->type, "ipv4") == 0)
 178                         list = g_slist_append(list, i->ifname);
 179         return list;
 180 }
 181
 182 static GSList *
 183 list_ssids(WI_SCAN *scans)
 184 {
 185         GSList *list, *l;
 186         WI_SCAN *w;
 187         DHCPCD_WI_SCAN *wis;
 188
 189         list = NULL;
 190         for (w = scans; w; w = w->next) {
 191                 for (wis = w->scans; wis; wis = wis->next) {
 192                         for (l = list; l; l = l->next)
 193                                 if (g_strcmp0((const char *)l->data,
 194                                         wis->ssid) == 0)
 195                                         break;
 196                         if (l == NULL)
 197                                 list = g_slist_append(list, wis->ssid);
 198                 }
 199         }
 200         return list;
 201 }
 202
 203 static void
 204 blocks_on_change(GtkWidget *widget, gpointer data)
 205 {
 206         DHCPCD_CONNECTION *con;
 207         GtkListStore *store;
 208         GtkTreeIter iter;
 209         char **list, **lp;
 210         const char *iname, *nn;
 211         GSList *l, *new_names;
 212         GdkPixbuf *pb;
 213         int n;
 214
 215         con = (DHCPCD_CONNECTION *)data;
 216         if (name) {
 217                 if (make_config(&config))
 218                         dhcpcd_config_save(con, block, name, config);
 219                 dhcpcd_config_free(config);
 220                 config = NULL;
 221                 show_config(config);
 222                 g_free(block);
 223                 g_free(name);
 224                 name = NULL;
 225         }
 226         block = combo_active_text(widget);
 227         store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(names)));
 228         gtk_list_store_clear(store);
 229         list = dhcpcd_config_blocks_get(con, block);
 230
 231         if (g_strcmp0(block, "interface") == 0)
 232                 new_names = list_interfaces(con);
 233         else
 234                 new_names = list_ssids(wi_scans);
 235
 236         n = 0;
 237         for (l = new_names; l; l = l->next) {
 238                 nn = (const char *)l->data;
 239                 for (lp = list; *lp; lp++)
 240                         if (g_strcmp0(nn, *lp) == 0)
 241                                 break;
 242                 if (*lp)
 243                         iname = "document-save";
 244                 else
 245                         iname = "document-new";
 246                 pb = load_icon(iname);
 247                 gtk_list_store_append(store, &iter);
 248                 gtk_list_store_set(store, &iter, 0, pb, 1, nn, -1);
 249                 g_object_unref(pb);
 250                 n++;
 251         }
 252
 253         for (lp = list; *lp; lp++) {
 254                 for (l = new_names; l; l = l->next)
 255                         if (g_strcmp0((const char *)l->data, *lp) == 0)
 256                                 break;
 257                 if (l != NULL)
 258                         continue;
 259                 pb = load_icon("document-save");
 260                 gtk_list_store_append(store, &iter);
 261                 gtk_list_store_set(store, &iter, 0, pb, 1, *lp, -1);
 262                 g_object_unref(pb);
 263                 n++;
 264         }
 265         gtk_widget_set_sensitive(names, n);
 266         g_slist_free(new_names);
 267         g_strfreev(list);
 268 }
 269
 270 static void
 271 names_on_change(_unused GtkWidget *widget, gpointer data)
 272 {
 273         DHCPCD_CONNECTION *con;
 274         DHCPCD_IF *i;
 275
 276         con = (DHCPCD_CONNECTION *)data;
 277         if (name) {
 278                 if (make_config(&config))
 279                         dhcpcd_config_save(con, block, name, config);
 280                 g_free(name);
 281         }
 282         name = combo_active_text(names);
 283         dhcpcd_config_free(config);
 284         iface = NULL;
 285         if (g_strcmp0(block, "interface") == 0) {
 286                 for (i = dhcpcd_interfaces(con); i; i = i->next)
 287                         if (g_strcmp0(name, i->ifname) == 0) {
 288                                 iface = i;
 289                                 break;
 290                         }
 291         }
 292         gtk_widget_set_sensitive(address,
 293             iface && (iface->flags & IFF_POINTOPOINT) == 0);
 294         if (block && name) {
 295                 config = dhcpcd_config_load(con, block, name);
 296                 if (config == NULL && dhcpcd_error(con))
 297                         g_error("libdhcpcd: %s", dhcpcd_error(con));
 298         } else
 299                 config = NULL;
 300         show_config(config);
 301         gtk_widget_set_sensitive(controls, name ? true : false);
 302         gtk_widget_set_sensitive(clear, name ? true : false);
 303         gtk_widget_set_sensitive(rebind, name ? true : false);
 304 }
 305
 306 static bool
 307 valid_address(const char *val, bool allow_cidr)
 308 {
 309         char *addr, *p, *e;
 310         struct in_addr in;
 311         gint64 cidr;
 312         bool retval;
 313
 314         addr = g_strdup(val);
 315         if (allow_cidr) {
 316                 p = strchr(addr, '/');
 317                 if (p != NULL) {
 318                         *p++ = '\0';
 319                         errno = 0;
 320                         e = NULL;
 321                         cidr = g_ascii_strtoll(p, &e, 10);
 322                         if (cidr < 0 || cidr > 32 ||
 323                             errno != 0 || *e != '\0')
 324                         {
 325                                 retval = false;
 326                                 goto out;
 327                         }
 328                 }
 329         }
 330         retval = inet_aton(addr, &in) == 0 ? false : true;
 331
 332 out:
 333         g_free(addr);
 334         return retval;
 335 }
 336
 337
 338 static bool
 339 address_lost_focus(GtkEntry *entry)
 340 {
 341         const char *val;
 342
 343         val = gtk_entry_get_text(entry);
 344         if (*val != '\0' && !valid_address(val, true))
 345                 gtk_entry_set_text(entry, "");
 346         return false;
 347 }
 348
 349 static bool
 350 entry_lost_focus(GtkEntry *entry)
 351 {
 352         const char *val;
 353         char **a, **p;
 354
 355         val = gtk_entry_get_text(entry);
 356         a = g_strsplit(val, " ", 0);
 357         for (p = a; *p; p++) {
 358                 if (**p != '\0' && !valid_address(*p, false)) {
 359                         gtk_entry_set_text(entry, "");
 360                         break;
 361                 }
 362         }
 363         g_strfreev(a);
 364         return false;
 365 }
 366
 367 static void
 368 on_clear(_unused GtkObject *o, gpointer data)
 369 {
 370         DHCPCD_CONNECTION *con;
 371
 372         con = (DHCPCD_CONNECTION *)data;
 373         dhcpcd_config_free(config);
 374         config = NULL;
 375         if (dhcpcd_config_save(con, block, name, config)) {
 376                 set_name_active_icon("document-new");
 377                 show_config(config);
 378         }
 379 }
 380
 381 static void
 382 on_rebind(_unused GtkWidget *widget, gpointer data)
 383 {
 384         DHCPCD_CONNECTION *con;
 385         DHCPCD_IF *i;
 386
 387         con = (DHCPCD_CONNECTION *)data;
 388         if (make_config(&config) &&
 389             dhcpcd_config_save(con, block, name, config)) {
 390                 set_name_active_icon(config == NULL ?
 391                     "document-new" : "document-save");
 392                 show_config(config);
 393                 if (g_strcmp0(block, "interface") == 0)
 394                         dhcpcd_rebind(con, iface);
 395                 else {
 396                         for (i = dhcpcd_interfaces(con); i; i = i->next) {
 397                                 if (g_strcmp0(i->ssid, name) == 0)
 398                                         dhcpcd_rebind(con, i);
 399                         }
 400                 }
 401                 if (dhcpcd_error(con))
 402                         g_warning("libdhcpcd: %s", dhcpcd_error(con));
 403         }
 404 }
 405
 406 static void
 407 on_destroy(_unused GtkObject *o, gpointer data)
 408 {
 409         if (name != NULL) {
 410                 if (make_config(&config))
 411                         dhcpcd_config_save((DHCPCD_CONNECTION *)data,
 412                             block, name, config);
 413                 g_free(block);
 414                 g_free(name);
 415                 block = name = NULL;
 416         }
 417         dhcpcd_config_free(config);
 418         config = NULL;
 419         dialog = NULL;
 420 }
 421
 422 static void
 423 dhcpcd_prefs_close(void)
 424 {
 425         if (dialog != NULL) {
 426                 gtk_widget_destroy(dialog);
 427                 dialog = NULL;
 428         }
 429 }
 430
 431 void
 432 dhcpcd_prefs_abort(void)
 433 {
 434         g_free(name);
 435         name = NULL;
 436         dhcpcd_prefs_close();
 437 }
 438
 439 void
 440 dhcpcd_prefs_show(DHCPCD_CONNECTION *con)
 441 {
 442         GtkWidget *dialog_vbox, *hbox, *vbox, *table, *w;
 443         GtkListStore *store;
 444         GtkTreeIter iter;
 445         GtkCellRenderer *rend;
 446         GdkPixbuf *pb;
 447
 448         if (dialog) {
 449                 gtk_window_present(GTK_WINDOW(dialog));
 450                 return;
 451         }
 452
 453         if (g_strcmp0(dhcpcd_status(con), "down") == 0)
 454                 return;
 455
 456         dialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 457         g_signal_connect(G_OBJECT(dialog), "destroy",
 458             G_CALLBACK(on_destroy), con);
 459
 460         gtk_window_set_title(GTK_WINDOW(dialog), _("Network Preferences"));
 461         gtk_window_set_resizable(GTK_WINDOW(dialog), false);
 462         gtk_window_set_icon_name(GTK_WINDOW(dialog),
 463             "network-transmit-receive");
 464         gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
 465         gtk_window_set_type_hint(GTK_WINDOW(dialog),
 466             GDK_WINDOW_TYPE_HINT_DIALOG);
 467
 468         dialog_vbox = gtk_vbox_new(false, 10);
 469         gtk_container_set_border_width(GTK_CONTAINER(dialog), 10);
 470         gtk_container_add(GTK_CONTAINER(dialog), dialog_vbox);
 471
 472         hbox = gtk_hbox_new(false, 0);
 473         gtk_box_pack_start(GTK_BOX(dialog_vbox), hbox, false, false, 3);
 474         w = gtk_label_new("Configure:");
 475         gtk_box_pack_start(GTK_BOX(hbox), w, false, false, 3);
 476         store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
 477         pb = load_icon("network-wired");
 478         gtk_list_store_append(store, &iter);
 479         gtk_list_store_set(store, &iter, 0, pb, 1, "interface", -1);
 480         g_object_unref(pb);
 481         pb = load_icon("network-wireless");
 482         gtk_list_store_append(store, &iter);
 483         gtk_list_store_set(store, &iter, 0, pb, 1, "ssid", -1);
 484         g_object_unref(pb);
 485         blocks = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
 486         rend = gtk_cell_renderer_pixbuf_new();
 487         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(blocks), rend, false);
 488         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(blocks),
 489             rend, "pixbuf", 0);
 490         rend = gtk_cell_renderer_text_new();
 491         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(blocks), rend, true);
 492         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(blocks),
 493             rend, "text", 1);
 494         gtk_combo_box_set_active(GTK_COMBO_BOX(blocks), 0);
 495         gtk_box_pack_start(GTK_BOX(hbox), blocks, false, false, 3);
 496         store = gtk_list_store_new(2, GDK_TYPE_PIXBUF, G_TYPE_STRING);
 497         names = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
 498         rend = gtk_cell_renderer_pixbuf_new();
 499         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(names), rend, false);
 500         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(names),
 501             rend, "pixbuf", 0);
 502         rend = gtk_cell_renderer_text_new();
 503         gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(names), rend, true);
 504         gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(names), rend, "text", 1);
 505         gtk_widget_set_sensitive(names, false);
 506         gtk_box_pack_start(GTK_BOX(hbox), names, false, false, 3);
 507         g_signal_connect(G_OBJECT(blocks), "changed",
 508             G_CALLBACK(blocks_on_change), con);
 509         g_signal_connect(G_OBJECT(names), "changed",
 510             G_CALLBACK(names_on_change), con);
 511
 512         w = gtk_hseparator_new();
 513         gtk_box_pack_start(GTK_BOX(dialog_vbox), w, true, false, 3);
 514         controls = gtk_vbox_new(false, 10);
 515         gtk_widget_set_sensitive(controls, false);
 516         gtk_box_pack_start(GTK_BOX(dialog_vbox), controls, true, true, 0);
 517         vbox = gtk_vbox_new(false, 3);
 518         gtk_box_pack_start(GTK_BOX(controls), vbox, false, false, 0);
 519         autoconf = gtk_check_button_new_with_label(
 520                 _("Automatically configure empty options"));
 521         gtk_box_pack_start(GTK_BOX(vbox), autoconf, false, false, 3);
 522         table = gtk_table_new(6, 2, false);
 523         gtk_box_pack_start(GTK_BOX(controls), table, false, false, 0);
 524
 525 #define attach_label(a, b, c, d, e)                                           \
 526         do {                                                                  \
 527                 gtk_misc_set_alignment(GTK_MISC(a), 0.0, 0.5);                \
 528                 gtk_table_attach(GTK_TABLE(table), a, b, c, d, e,             \
 529                     GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 3, 3);      \
 530         } while (0)
 531 #define attach_entry(a, b, c, d, e)                                           \
 532         gtk_table_attach(GTK_TABLE(table), a, b, c, d, e,                     \
 533             GTK_EXPAND | GTK_FILL | GTK_SHRINK, GTK_FILL | GTK_SHRINK, 3, 3);
 534
 535         w = gtk_label_new(_("IP Address:"));
 536         address = gtk_entry_new();
 537         gtk_entry_set_max_length(GTK_ENTRY(address), 18);
 538         g_signal_connect(G_OBJECT(address), "focus-out-event",
 539             G_CALLBACK(address_lost_focus), NULL);
 540         attach_label(w, 0, 1, 0, 1);
 541         attach_entry(address, 1, 2, 0, 1);
 542
 543         w = gtk_label_new(_("Router:"));
 544         router = gtk_entry_new();
 545         gtk_entry_set_max_length(GTK_ENTRY(router), 15);
 546         g_signal_connect(G_OBJECT(router), "focus-out-event",
 547             G_CALLBACK(entry_lost_focus), NULL);
 548         attach_label(w, 0, 1, 2, 3);
 549         attach_entry(router, 1, 2, 2, 3);
 550
 551         w = gtk_label_new(_("DNS Servers:"));
 552         dns_servers = gtk_entry_new();
 553         g_signal_connect(G_OBJECT(dns_servers), "focus-out-event",
 554             G_CALLBACK(entry_lost_focus), NULL);
 555         attach_label(w, 0, 1, 3, 4);
 556         attach_entry(dns_servers, 1, 2, 3, 4);
 557
 558         w = gtk_label_new(_("DNS Search:"));
 559         dns_search = gtk_entry_new();
 560         attach_label(w, 0, 1, 4, 5);
 561         attach_entry(dns_search, 1, 2, 4, 5);
 562
 563         hbox = gtk_hbox_new(false, 10);
 564         gtk_box_pack_start(GTK_BOX(dialog_vbox), hbox, true, true, 3);
 565         clear = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
 566         gtk_widget_set_sensitive(clear, false);
 567         gtk_box_pack_start(GTK_BOX(hbox), clear, false, false, 0);
 568         g_signal_connect(G_OBJECT(clear), "clicked",
 569             G_CALLBACK(on_clear), con);
 570         rebind = gtk_button_new_with_mnemonic(_("_Rebind"));
 571         gtk_widget_set_sensitive(rebind, false);
 572         w = gtk_image_new_from_stock(GTK_STOCK_EXECUTE,
 573             GTK_ICON_SIZE_BUTTON);
 574         gtk_button_set_image(GTK_BUTTON(rebind), w);
 575         gtk_box_pack_start(GTK_BOX(hbox), rebind, false, false, 0);
 576         g_signal_connect(G_OBJECT(rebind), "clicked",
 577             G_CALLBACK(on_rebind), con);
 578         w = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
 579         gtk_box_pack_end(GTK_BOX(hbox), w, false, false, 0);
 580         g_signal_connect(G_OBJECT(w), "clicked",
 581             G_CALLBACK(dhcpcd_prefs_close), NULL);
 582
 583         blocks_on_change(blocks, con);
 584         show_config(NULL);
 585         gtk_widget_show_all(dialog);
 586 }