gio/gnetworkmonitornetlink.c

   1 /* GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright 2011 Red Hat, Inc.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include "config.h"
  22
  23 #include <errno.h>
  24 #include <unistd.h>
  25
  26 #include "gnetworkmonitornetlink.h"
  27 #include "gcredentials.h"
  28 #include "ginetaddressmask.h"
  29 #include "ginitable.h"
  30 #include "giomodule-priv.h"
  31 #include "glibintl.h"
  32 #include "gnetworkingprivate.h"
  33 #include "gnetworkmonitor.h"
  34 #include "gsocket.h"
  35 #include "gunixcredentialsmessage.h"
  36
  37 /* must come at the end to pick system includes from
  38  * gnetworkingprivate.h */
  39 #include <linux/netlink.h>
  40 #include <linux/rtnetlink.h>
  41
  42 static void g_network_monitor_netlink_iface_init (GNetworkMonitorInterface *iface);
  43 static void g_network_monitor_netlink_initable_iface_init (GInitableIface *iface);
  44
  45 #define g_network_monitor_netlink_get_type _g_network_monitor_netlink_get_type
  46 G_DEFINE_TYPE_WITH_CODE (GNetworkMonitorNetlink, g_network_monitor_netlink, G_TYPE_NETWORK_MONITOR_BASE,
  47                          G_IMPLEMENT_INTERFACE (G_TYPE_NETWORK_MONITOR,
  48                                                 g_network_monitor_netlink_iface_init)
  49                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
  50                                                 g_network_monitor_netlink_initable_iface_init)
  51                          _g_io_modules_ensure_extension_points_registered ();
  52                          g_io_extension_point_implement (G_NETWORK_MONITOR_EXTENSION_POINT_NAME,
  53                                                          g_define_type_id,
  54                                                          "netlink",
  55                                                          20))
  56
  57 struct _GNetworkMonitorNetlinkPrivate
  58 {
  59   GSocket *sock;
  60   GSource *source, *dump_source;
  61
  62   GPtrArray *dump_networks;
  63 };
  64
  65 static gboolean read_netlink_messages (GSocket             *socket,
  66                                        GIOCondition         condition,
  67                                        gpointer             user_data);
  68 static gboolean request_dump (GNetworkMonitorNetlink  *nl,
  69                               GError                 **error);
  70
  71 static void
  72 g_network_monitor_netlink_init (GNetworkMonitorNetlink *nl)
  73 {
  74   nl->priv = G_TYPE_INSTANCE_GET_PRIVATE (nl,
  75                                           G_TYPE_NETWORK_MONITOR_NETLINK,
  76                                           GNetworkMonitorNetlinkPrivate);
  77 }
  78
  79
  80 static gboolean
  81 g_network_monitor_netlink_initable_init (GInitable     *initable,
  82                                          GCancellable  *cancellable,
  83                                          GError       **error)
  84 {
  85   GNetworkMonitorNetlink *nl = G_NETWORK_MONITOR_NETLINK (initable);
  86   gint sockfd, val;
  87   struct sockaddr_nl snl;
  88
  89   /* We create the socket the old-school way because sockaddr_netlink
  90    * can't be represented as a GSocketAddress
  91    */
  92   sockfd = socket (PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  93   if (sockfd == -1)
  94     {
  95       int errsv = errno;
  96       g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
  97                    _("Could not create network monitor: %s"),
  98                    g_strerror (errno));
  99       return FALSE;
 100     }
 101
 102   snl.nl_family = AF_NETLINK;
 103   snl.nl_pid = snl.nl_pad = 0;
 104   snl.nl_groups = RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_ROUTE;
 105   if (bind (sockfd, (struct sockaddr *)&snl, sizeof (snl)) != 0)
 106     {
 107       int errsv = errno;
 108       g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
 109                    _("Could not create network monitor: %s"),
 110                    g_strerror (errno));
 111       close (sockfd);
 112       return FALSE;
 113     }
 114
 115   val = 1;
 116   if (setsockopt (sockfd, SOL_SOCKET, SO_PASSCRED, &val, sizeof (val)) != 0)
 117     {
 118       int errsv = errno;
 119       g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errsv),
 120                    _("Could not create network monitor: %s"),
 121                    g_strerror (errno));
 122       close (sockfd);
 123       return FALSE;
 124     }
 125
 126   nl->priv->sock = g_socket_new_from_fd (sockfd, error);
 127   if (error)
 128     {
 129       g_prefix_error (error, "%s", _("Could not create network monitor: "));
 130       close (sockfd);
 131       return FALSE;
 132     }
 133
 134   /* Request the current state */
 135   if (!request_dump (nl, error))
 136     return FALSE;
 137
 138   /* And read responses; since we haven't yet marked the socket
 139    * non-blocking, each call will block until a message is received.
 140    */
 141   while (nl->priv->dump_networks)
 142     {
 143       if (!read_netlink_messages (NULL, G_IO_IN, nl))
 144         break;
 145     }
 146
 147   g_socket_set_blocking (nl->priv->sock, FALSE);
 148   nl->priv->source = g_socket_create_source (nl->priv->sock, G_IO_IN, NULL);
 149   g_source_set_callback (nl->priv->source,
 150                          (GSourceFunc) read_netlink_messages, nl, NULL);
 151   g_source_attach (nl->priv->source,
 152                    g_main_context_get_thread_default ());
 153
 154   return TRUE;
 155 }
 156
 157 static gboolean
 158 request_dump (GNetworkMonitorNetlink  *nl,
 159               GError                 **error)
 160 {
 161   struct nlmsghdr *n;
 162   struct rtgenmsg *gen;
 163   gchar buf[NLMSG_SPACE (sizeof (*gen))];
 164
 165   memset (buf, 0, sizeof (buf));
 166   n = (struct nlmsghdr*) buf;
 167   n->nlmsg_len = NLMSG_LENGTH (sizeof (*gen));
 168   n->nlmsg_type = RTM_GETROUTE;
 169   n->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
 170   n->nlmsg_pid = 0;
 171   gen = NLMSG_DATA (n);
 172   gen->rtgen_family = AF_UNSPEC;
 173
 174   if (g_socket_send (nl->priv->sock, buf, sizeof (buf),
 175                      NULL, error) < 0)
 176     {
 177       g_prefix_error (error, "%s", _("Could not get network status: "));
 178       return FALSE;
 179     }
 180
 181   nl->priv->dump_networks = g_ptr_array_new_with_free_func (g_object_unref);
 182   return TRUE;
 183 }
 184
 185 static gboolean
 186 timeout_request_dump (gpointer user_data)
 187 {
 188   GNetworkMonitorNetlink *nl = user_data;
 189
 190   g_source_destroy (nl->priv->dump_source);
 191   g_source_unref (nl->priv->dump_source);
 192   nl->priv->dump_source = NULL;
 193
 194   request_dump (nl, NULL);
 195
 196   return FALSE;
 197 }
 198
 199 static void
 200 queue_request_dump (GNetworkMonitorNetlink *nl)
 201 {
 202   if (nl->priv->dump_networks)
 203     return;
 204
 205   if (nl->priv->dump_source)
 206     {
 207       g_source_destroy (nl->priv->dump_source);
 208       g_source_unref (nl->priv->dump_source);
 209     }
 210
 211   nl->priv->dump_source = g_timeout_source_new (1000);
 212   g_source_set_callback (nl->priv->dump_source,
 213                          (GSourceFunc) timeout_request_dump, nl, NULL);
 214   g_source_attach (nl->priv->dump_source,
 215                    g_main_context_get_thread_default ());
 216 }
 217
 218 static void
 219 add_network (GNetworkMonitorNetlink *nl,
 220              GSocketFamily           family,
 221              gint                    dest_len,
 222              guint8                 *dest,
 223              guint8                 *gateway)
 224 {
 225   GInetAddress *dest_addr;
 226   GInetAddressMask *network;
 227
 228   if (dest)
 229     dest_addr = g_inet_address_new_from_bytes (dest, family);
 230   else
 231     dest_addr = g_inet_address_new_any (family);
 232   network = g_inet_address_mask_new (dest_addr, dest_len, NULL);
 233   g_object_unref (dest_addr);
 234   g_return_if_fail (network != NULL);
 235
 236   if (nl->priv->dump_networks)
 237     g_ptr_array_add (nl->priv->dump_networks, network);
 238   else
 239     {
 240       g_network_monitor_base_add_network (G_NETWORK_MONITOR_BASE (nl), network);
 241       g_object_unref (network);
 242     }
 243 }
 244
 245 static void
 246 remove_network (GNetworkMonitorNetlink *nl,
 247                 GSocketFamily           family,
 248                 gint                    dest_len,
 249                 guint8                 *dest,
 250                 guint8                 *gateway)
 251 {
 252   GInetAddress *dest_addr;
 253   GInetAddressMask *network;
 254
 255   if (dest)
 256     dest_addr = g_inet_address_new_from_bytes (dest, family);
 257   else
 258     dest_addr = g_inet_address_new_any (family);
 259   network = g_inet_address_mask_new (dest_addr, dest_len, NULL);
 260   g_object_unref (dest_addr);
 261   g_return_if_fail (network != NULL);
 262
 263   if (nl->priv->dump_networks)
 264     {
 265       GInetAddressMask **dump_networks = (GInetAddressMask **)nl->priv->dump_networks->pdata;
 266       int i;
 267
 268       for (i = 0; i < nl->priv->dump_networks->len; i++)
 269         {
 270           if (g_inet_address_mask_equal (network, dump_networks[i]))
 271             g_ptr_array_remove_index_fast (nl->priv->dump_networks, i--);
 272         }
 273       g_object_unref (network);
 274     }
 275   else
 276     {
 277       g_network_monitor_base_remove_network (G_NETWORK_MONITOR_BASE (nl), network);
 278       g_object_unref (network);
 279     }
 280 }
 281
 282 static void
 283 finish_dump (GNetworkMonitorNetlink *nl)
 284 {
 285   g_network_monitor_base_set_networks (G_NETWORK_MONITOR_BASE (nl),
 286                                        (GInetAddressMask **)nl->priv->dump_networks->pdata,
 287                                        nl->priv->dump_networks->len);
 288   g_ptr_array_free (nl->priv->dump_networks, FALSE);
 289   nl->priv->dump_networks = NULL;
 290 }
 291
 292 static gboolean
 293 read_netlink_messages (GSocket      *socket,
 294                        GIOCondition  condition,
 295                        gpointer      user_data)
 296 {
 297   GNetworkMonitorNetlink *nl = user_data;
 298   GInputVector iv;
 299   gssize len;
 300   GSocketControlMessage **cmsgs = NULL;
 301   gint num_cmsgs = 0, i, flags;
 302   GError *error = NULL;
 303   GCredentials *creds;
 304   uid_t sender;
 305   struct nlmsghdr *msg;
 306   struct rtmsg *rtmsg;
 307   struct rtattr *attr;
 308   gsize attrlen;
 309   guint8 *dest, *gateway;
 310   gboolean retval = TRUE;
 311
 312   iv.buffer = NULL;
 313   iv.size = 0;
 314
 315   flags = MSG_PEEK | MSG_TRUNC;
 316   len = g_socket_receive_message (nl->priv->sock, NULL, &iv, 1,
 317                                   NULL, NULL, &flags, NULL, &error);
 318   if (len < 0)
 319     {
 320       g_warning ("Error on netlink socket: %s", error->message);
 321       g_error_free (error);
 322       if (nl->priv->dump_networks)
 323         finish_dump (nl);
 324       return FALSE;
 325     }
 326
 327   iv.buffer = g_malloc (len);
 328   iv.size = len;
 329   len = g_socket_receive_message (nl->priv->sock, NULL, &iv, 1,
 330                                   &cmsgs, &num_cmsgs, NULL, NULL, &error);
 331   if (len < 0)
 332     {
 333       g_warning ("Error on netlink socket: %s", error->message);
 334       g_error_free (error);
 335       if (nl->priv->dump_networks)
 336         finish_dump (nl);
 337       return FALSE;
 338     }
 339
 340   if (num_cmsgs != 1 || !G_IS_UNIX_CREDENTIALS_MESSAGE (cmsgs[0]))
 341     goto done;
 342
 343   creds = g_unix_credentials_message_get_credentials (G_UNIX_CREDENTIALS_MESSAGE (cmsgs[0]));
 344   sender = g_credentials_get_unix_user (creds, NULL);
 345   if (sender != 0)
 346     goto done;
 347
 348   msg = (struct nlmsghdr *) iv.buffer;
 349   for (; len > 0; msg = NLMSG_NEXT (msg, len))
 350     {
 351       if (!NLMSG_OK (msg, (size_t) len))
 352         {
 353           g_warning ("netlink message was truncated; shouldn't happen...");
 354           retval = FALSE;
 355           goto done;
 356         }
 357
 358       switch (msg->nlmsg_type)
 359         {
 360         case RTM_NEWROUTE:
 361         case RTM_DELROUTE:
 362           rtmsg = NLMSG_DATA (msg);
 363
 364           if (rtmsg->rtm_family != AF_INET && rtmsg->rtm_family != AF_INET6)
 365             continue;
 366           if (rtmsg->rtm_type == RTN_UNREACHABLE)
 367             continue;
 368
 369           attrlen = NLMSG_PAYLOAD (msg, sizeof (struct rtmsg));
 370           attr = RTM_RTA (rtmsg);
 371           dest = gateway = NULL;
 372           while (RTA_OK (attr, attrlen))
 373             {
 374               if (attr->rta_type == RTA_DST)
 375                 dest = RTA_DATA (attr);
 376               else if (attr->rta_type == RTA_GATEWAY)
 377                 gateway = RTA_DATA (attr);
 378               attr = RTA_NEXT (attr, attrlen);
 379             }
 380
 381           if (dest || gateway)
 382             {
 383               if (msg->nlmsg_type == RTM_NEWROUTE)
 384                 add_network (nl, rtmsg->rtm_family, rtmsg->rtm_dst_len, dest, gateway);
 385               else
 386                 remove_network (nl, rtmsg->rtm_family, rtmsg->rtm_dst_len, dest, gateway);
 387               queue_request_dump (nl);
 388             }
 389           break;
 390
 391         case NLMSG_DONE:
 392           finish_dump (nl);
 393           goto done;
 394
 395         case NLMSG_ERROR:
 396           {
 397             struct nlmsgerr *e = NLMSG_DATA (msg);
 398
 399             g_warning ("netlink error: %s", g_strerror (-e->error));
 400           }
 401           retval = FALSE;
 402           goto done;
 403
 404         default:
 405           g_warning ("unexpected netlink message %d", msg->nlmsg_type);
 406           retval = FALSE;
 407           goto done;
 408         }
 409     }
 410
 411  done:
 412   for (i = 0; i < num_cmsgs; i++)
 413     g_object_unref (cmsgs[i]);
 414   g_free (cmsgs);
 415
 416   g_free (iv.buffer);
 417
 418   if (!retval && nl->priv->dump_networks)
 419     finish_dump (nl);
 420   return retval;
 421 }
 422
 423 static void
 424 g_network_monitor_netlink_finalize (GObject *object)
 425 {
 426   GNetworkMonitorNetlink *nl = G_NETWORK_MONITOR_NETLINK (object);
 427
 428   if (nl->priv->sock)
 429     {
 430       g_socket_close (nl->priv->sock, NULL);
 431       g_object_unref (nl->priv->sock);
 432     }
 433
 434   if (nl->priv->source)
 435     {
 436       g_source_destroy (nl->priv->source);
 437       g_source_unref (nl->priv->source);
 438     }
 439
 440   if (nl->priv->dump_source)
 441     {
 442       g_source_destroy (nl->priv->dump_source);
 443       g_source_unref (nl->priv->dump_source);
 444     }
 445
 446   G_OBJECT_CLASS (g_network_monitor_netlink_parent_class)->finalize (object);
 447 }
 448
 449 static void
 450 g_network_monitor_netlink_class_init (GNetworkMonitorNetlinkClass *nl_class)
 451 {
 452   GObjectClass *gobject_class = G_OBJECT_CLASS (nl_class);
 453
 454   g_type_class_add_private (nl_class, sizeof (GNetworkMonitorNetlinkPrivate));
 455
 456   gobject_class->finalize  = g_network_monitor_netlink_finalize;
 457 }
 458
 459 static void
 460 g_network_monitor_netlink_iface_init (GNetworkMonitorInterface *monitor_iface)
 461 {
 462 }
 463
 464 static void
 465 g_network_monitor_netlink_initable_iface_init (GInitableIface *iface)
 466 {
 467   iface->init = g_network_monitor_netlink_initable_init;
 468 }