roy.marples.name Git - dhcpcd-ui/blob - src/dhcpcd-gtk/main.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 <locale.h>
  28 #include <poll.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #ifdef NOTIFY
  33 #  include <libnotify/notify.h>
  34 static NotifyNotification *nn;
  35 #endif
  36
  37 #include "config.h"
  38 #include "dhcpcd-gtk.h"
  39
  40 static GtkStatusIcon *status_icon;
  41 static int ani_timer;
  42 static int ani_counter;
  43 static bool online;
  44 static bool carrier;
  45
  46 struct watch {
  47         struct pollfd pollfd;
  48         int eventid;
  49         GIOChannel *gio;
  50         struct watch *next;
  51 };
  52 static struct watch *watches;
  53
  54 WI_SCAN *wi_scans;
  55
  56 WI_SCAN *
  57 wi_scan_find(DHCPCD_WI_SCAN *scan)
  58 {
  59         WI_SCAN *w;
  60         DHCPCD_WI_SCAN *dw;
  61
  62         for (w = wi_scans; w; w = w->next) {
  63                 for (dw = w->scans; dw; dw = dw->next)
  64                         if (dw == scan)
  65                                 break;
  66                 if (dw)
  67                         return w;
  68         }
  69         return NULL;
  70 }
  71
  72 static gboolean
  73 animate_carrier(_unused gpointer data)
  74 {
  75         const char *icon;
  76
  77         if (ani_timer == 0)
  78                 return false;
  79
  80         switch(ani_counter++) {
  81         case 0:
  82                 icon = "network-transmit";
  83                 break;
  84         case 1:
  85                 icon = "network-receive";
  86                 break;
  87         default:
  88                 icon = "network-idle";
  89                 ani_counter = 0;
  90                 break;
  91         }
  92         gtk_status_icon_set_from_icon_name(status_icon, icon);
  93         return true;
  94 }
  95
  96 static gboolean
  97 animate_online(_unused gpointer data)
  98 {
  99         const char *icon;
 100
 101         if (ani_timer == 0)
 102                 return false;
 103
 104         if (ani_counter++ > 6) {
 105                 ani_timer = 0;
 106                 ani_counter = 0;
 107                 return false;
 108         }
 109
 110         if (ani_counter % 2 == 0)
 111                 icon = "network-idle";
 112         else
 113                 icon = "network-transmit-receive";
 114         gtk_status_icon_set_from_icon_name(status_icon, icon);
 115         return true;
 116 }
 117
 118 static void
 119 update_online(DHCPCD_CONNECTION *con, bool showif)
 120 {
 121         bool ison, iscarrier;
 122         char *msg, *msgs, *tmp;
 123         DHCPCD_IF *ifs, *i;
 124
 125         ison = iscarrier = false;
 126         msgs = NULL;
 127         ifs = dhcpcd_interfaces(con);
 128         for (i = ifs; i; i = i->next) {
 129                 if (showif)
 130                         g_message("%s: %s", i->ifname, i->reason);
 131                 if (strcmp(i->reason, "RELEASE") == 0 ||
 132                     strcmp(i->reason, "STOP") == 0)
 133                         continue;
 134                 if (dhcpcd_if_up(i))
 135                         ison = iscarrier = true;
 136                 if (!iscarrier && g_strcmp0(i->reason, "CARRIER") == 0)
 137                         iscarrier = true;
 138                 msg = dhcpcd_if_message(i);
 139                 if (msgs) {
 140                         tmp = g_strconcat(msgs, "\n", msg, NULL);
 141                         g_free(msgs);
 142                         g_free(msg);
 143                         msgs = tmp;
 144                 } else
 145                         msgs = msg;
 146         }
 147
 148         if (online != ison || carrier != iscarrier) {
 149                 online = ison;
 150                 if (ani_timer != 0) {
 151                         g_source_remove(ani_timer);
 152                         ani_timer = 0;
 153                         ani_counter = 0;
 154                 }
 155                 if (ison) {
 156                         animate_online(NULL);
 157                         ani_timer = g_timeout_add(300, animate_online, NULL);
 158                 } else if (iscarrier) {
 159                         animate_carrier(NULL);
 160                         ani_timer = g_timeout_add(500, animate_carrier, NULL);
 161                 } else {
 162                         gtk_status_icon_set_from_icon_name(status_icon,
 163                             "network-offline");
 164                 }
 165         }
 166         gtk_status_icon_set_tooltip(status_icon, msgs);
 167         g_free(msgs);
 168 }
 169
 170 void
 171 notify_close(void)
 172 {
 173 #ifdef NOTIFY
 174         if (nn != NULL)
 175                 notify_notification_close(nn, NULL);
 176 #endif
 177 }
 178
 179 #ifdef NOTIFY
 180 static void
 181 notify_closed(void)
 182 {
 183         nn = NULL;
 184 }
 185
 186 static void
 187 notify(const char *title, const char *msg, const char *icon)
 188 {
 189         char **msgs, **m;
 190
 191         msgs = g_strsplit(msg, "\n", 0);
 192         for (m = msgs; *m; m++)
 193                 g_message("%s", *m);
 194         g_strfreev(msgs);
 195         if (nn != NULL)
 196                 notify_notification_close(nn, NULL);
 197         if (gtk_status_icon_get_visible(status_icon))
 198                 nn = notify_notification_new_with_status_icon(title,
 199                     msg, icon, status_icon);
 200         else
 201                 nn = notify_notification_new(title, msg, icon, NULL);
 202         notify_notification_set_timeout(nn, 5000);
 203         g_signal_connect(nn, "closed", G_CALLBACK(notify_closed), NULL);
 204         notify_notification_show(nn, NULL);
 205 }
 206 #else
 207 #  define notify(a, b, c)
 208 #endif
 209
 210 static void
 211 event_cb(DHCPCD_CONNECTION *con, DHCPCD_IF *i, _unused void *data)
 212 {
 213         char *msg;
 214         const char *icon;
 215
 216         g_message("%s: %s", i->ifname, i->reason);
 217         update_online(con, false);
 218
 219         /* We should ignore renew and stop so we don't annoy the user */
 220         if (g_strcmp0(i->reason, "RENEW") == 0 ||
 221             g_strcmp0(i->reason, "STOP") == 0)
 222                 return;
 223
 224         msg = dhcpcd_if_message(i);
 225         if (dhcpcd_if_up(i))
 226                 icon = "network-transmit-receive";
 227         else
 228                 icon = "network-transmit";
 229         if (dhcpcd_if_down(i))
 230                 icon = "network-offline";
 231         notify(_("Network event"), msg, icon);
 232         g_free(msg);
 233 }
 234
 235 static void
 236 status_cb(DHCPCD_CONNECTION *con, const char *status, _unused void *data)
 237 {
 238         static char *last = NULL;
 239         char *version;
 240         const char *msg;
 241         bool refresh;
 242         WI_SCAN *w;
 243
 244         g_message("Status changed to %s", status);
 245         if (g_strcmp0(status, "down") == 0) {
 246                 msg = N_(last ?
 247                     "Connection to dhcpcd lost" : "dhcpcd not running");
 248                 gtk_status_icon_set_tooltip(status_icon, msg);
 249                 notify(_("No network"), msg, "network-offline");
 250                 dhcpcd_prefs_abort();
 251                 while (wi_scans) {
 252                         w = wi_scans->next;
 253                         dhcpcd_wi_scans_free(wi_scans->scans);
 254                         g_free(wi_scans);
 255                         wi_scans = w;
 256                 }
 257         } else {
 258                 if ((last == NULL || g_strcmp0(last, "down") == 0) &&
 259                     dhcpcd_command(con, "GetDhcpcdVersion", NULL, &version))
 260                 {
 261                         g_message(_("Connected to %s-%s"), "dhcpcd", version);
 262                         g_free(version);
 263                         refresh = true;
 264                 } else
 265                         refresh = false;
 266                 update_online(con, refresh);
 267         }
 268         last = g_strdup(status);
 269 }
 270
 271 static void
 272 scan_cb(DHCPCD_CONNECTION *con, DHCPCD_IF *i, _unused void *data)
 273 {
 274         WI_SCAN *w;
 275         DHCPCD_WI_SCAN *scans, *s1, *s2;
 276         char *txt, *t;
 277         const char *msg;
 278
 279         g_message(_("%s: Received scan results"), i->ifname);
 280         scans = dhcpcd_wi_scans(con, i);
 281         if (scans == NULL) {
 282                 g_warning("%s: %s", i->ifname, dhcpcd_error(con));
 283                 dhcpcd_error_clear(con);
 284         }
 285         for (w = wi_scans; w; w = w->next)
 286                 if (w->connection == con && w->interface == i)
 287                         break;
 288         if (w == NULL) {
 289                 w = g_malloc(sizeof(*w));
 290                 w->connection = con;
 291                 w->interface = i;
 292                 w->next = wi_scans;
 293                 wi_scans = w;
 294         } else {
 295                 txt = NULL;
 296                 msg = N_("New Access Point");
 297                 for (s1 = scans; s1; s1 = s1->next) {
 298                         for (s2 = w->scans; s2; s2 = s2->next)
 299                                 if (g_strcmp0(s1->ssid, s2->ssid) == 0)
 300                                         break;
 301                         if (s2 == NULL) {
 302                                 if (txt == NULL)
 303                                         txt = g_strdup(s1->ssid);
 304                                 else {
 305                                         msg = N_("New Access Points");
 306                                         t = g_strconcat(txt, "\n",
 307                                             s1->ssid, NULL);
 308                                         g_free(txt);
 309                                         txt = t;
 310                                 }
 311                         }
 312                 }
 313                 if (txt) {
 314                         notify(msg, txt, "network-wireless");
 315                         g_free(txt);
 316                 }
 317                 dhcpcd_wi_scans_free(w->scans);
 318         }
 319         w->scans = scans;
 320 }
 321
 322 static gboolean
 323 gio_callback(GIOChannel *gio, _unused GIOCondition c, _unused gpointer d)
 324 {
 325         int fd;
 326
 327         fd = g_io_channel_unix_get_fd(gio);
 328         dhcpcd_dispatch(fd);
 329         return true;
 330 }
 331
 332 static void
 333 delete_watch_cb(_unused DHCPCD_CONNECTION *con, const struct pollfd *fd,
 334     _unused void *data)
 335 {
 336         struct watch *w, *l;
 337
 338         l = NULL;
 339         for (w = watches; w; w = w->next) {
 340                 if (w->pollfd.fd == fd->fd) {
 341                         if (l == NULL)
 342                                 watches = w->next;
 343                         else
 344                                 l->next = w->next;
 345                         g_source_remove(w->eventid);
 346                         g_io_channel_unref(w->gio);
 347                         g_free(w);
 348                         break;
 349                 }
 350         }
 351 }
 352
 353 static void
 354 add_watch_cb(DHCPCD_CONNECTION *con, const struct pollfd *fd,
 355     _unused void *data)
 356 {
 357         struct watch *w;
 358         GIOChannel *gio;
 359         int flags, eventid;
 360
 361         /* Remove any existing watch */
 362         delete_watch_cb(con, fd, data);
 363
 364         gio = g_io_channel_unix_new(fd->fd);
 365         if (gio == NULL) {
 366                 g_error(_("Error creating new GIO Channel\n"));
 367                 return;
 368         }
 369         flags = 0;
 370         if (fd->events & POLLIN)
 371                 flags |= G_IO_IN;
 372         if (fd->events & POLLOUT)
 373                 flags |= G_IO_OUT;
 374         if (fd->events & POLLERR)
 375                 flags |= G_IO_ERR;
 376         if (fd->events & POLLHUP)
 377                 flags |= G_IO_HUP;
 378         if ((eventid = g_io_add_watch(gio, flags, gio_callback, con)) == 0) {
 379                 g_io_channel_unref(gio);
 380                 g_error(_("Error creating watch\n"));
 381                 return;
 382         }
 383         w = g_malloc(sizeof(*w));
 384         memcpy(&w->pollfd, fd, sizeof(w->pollfd));
 385         w->eventid = eventid;
 386         w->gio = gio;
 387         w->next = watches;
 388         watches = w;
 389 }
 390
 391 int
 392 main(int argc, char *argv[])
 393 {
 394         char *error = NULL;
 395         char *version = NULL;
 396         DHCPCD_CONNECTION *con;
 397
 398         setlocale(LC_ALL, "");
 399         bindtextdomain(PACKAGE, NULL);
 400         bind_textdomain_codeset(PACKAGE, "UTF-8");
 401         textdomain(PACKAGE);
 402
 403         gtk_init(&argc, &argv);
 404         g_set_application_name("Network Configurator");
 405         gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(),
 406             ICONDIR);
 407         status_icon = gtk_status_icon_new_from_icon_name("network-offline");
 408
 409         gtk_status_icon_set_tooltip(status_icon,
 410             _("Connecting to dhcpcd ..."));
 411         gtk_status_icon_set_visible(status_icon, true);
 412
 413 #ifdef NOTIFY
 414         notify_init(PACKAGE);
 415 #endif
 416
 417         g_message(_("Connecting ..."));
 418         con = dhcpcd_open(&error);
 419         if (con ==  NULL) {
 420                 g_critical("libdhcpcd: %s", error);
 421                 exit(EXIT_FAILURE);
 422         }
 423
 424         gtk_status_icon_set_tooltip(status_icon, _("Triggering dhcpcd ..."));
 425         online = false;
 426
 427         if (!dhcpcd_command(con, "GetVersion", NULL, &version)) {
 428                 g_critical("libdhcpcd: GetVersion: %s", dhcpcd_error(con));
 429                 exit(EXIT_FAILURE);
 430         }
 431         g_message(_("Connected to %s-%s"), "dhcpcd-dbus", version);
 432         g_free(version);
 433
 434         dhcpcd_set_watch_functions(con, add_watch_cb, delete_watch_cb, NULL);
 435         dhcpcd_set_signal_functions(con, event_cb, status_cb, scan_cb, NULL);
 436         if (dhcpcd_error(con))
 437                 g_error("libdhcpcd: %s", dhcpcd_error(con));
 438
 439         menu_init(status_icon, con);
 440
 441         gtk_main();
 442         dhcpcd_close(con);
 443         return 0;
 444 }