gio/gkdbus.c

   1 /*  GIO - GLib Input, Output and Streaming Library
   2  *
   3  * Copyright (C) 2013 Samsung Electronics
   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  * Author: Michal Eljasiewicz   <m.eljasiewic@samsung.com>
  21  * Author: Lukasz Skalski       <l.skalski@samsung.com>
  22  */
  23
  24 #include "config.h"
  25 #include "gkdbus.h"
  26 #include "glib-unix.h"
  27 #include "glibintl.h"
  28 #include "kdbus.h"
  29 #include "gkdbusconnection.h"
  30
  31 #include <gio/gio.h>
  32 #include <errno.h>
  33 #include <string.h>
  34 #include <sys/mman.h>
  35 #include <sys/ioctl.h>
  36 #include <stdio.h>
  37 #include <stdint.h>
  38
  39 #ifdef HAVE_SYS_FILIO_H
  40 # include <sys/filio.h>
  41 #endif
  42
  43 #ifdef HAVE_SYS_UIO_H
  44 #include <sys/uio.h>
  45 #endif
  46
  47 #include <glib/gstdio.h>
  48 #include <gio/gio.h>
  49 #include <gio/gunixfdlist.h>
  50
  51 #include "glibintl.h"
  52 #include "gunixfdmessage.h"
  53
  54 #define KDBUS_POOL_SIZE (16 * 1024LU * 1024LU)
  55 #define KDBUS_ALIGN8(l) (((l) + 7) & ~7)
  56 #define KDBUS_ALIGN8_PTR(p) ((void*) (uintptr_t)(p))
  57
  58 #define KDBUS_ITEM_HEADER_SIZE G_STRUCT_OFFSET(struct kdbus_item, data)
  59 #define KDBUS_ITEM_SIZE(s) KDBUS_ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE)
  60
  61 #define KDBUS_ITEM_NEXT(item) \
  62         (typeof(item))(((guint8 *)item) + KDBUS_ALIGN8((item)->size))
  63 #define KDBUS_ITEM_FOREACH(item, head, first)                    \
  64         for (item = (head)->first;                               \
  65              (guint8 *)(item) < (guint8 *)(head) + (head)->size; \
  66              item = KDBUS_ITEM_NEXT(item))
  67
  68 #define g_alloca0(x) memset(g_alloca(x), '\0', (x))
  69
  70 static void     g_kdbus_initable_iface_init (GInitableIface  *iface);
  71 static gboolean g_kdbus_initable_init       (GInitable       *initable,
  72                                              GCancellable    *cancellable,
  73                                              GError         **error);
  74
  75 #define g_kdbus_get_type _g_kdbus_get_type
  76 G_DEFINE_TYPE_WITH_CODE (GKdbus, g_kdbus, G_TYPE_OBJECT,
  77                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
  78                                                 g_kdbus_initable_iface_init));
  79
  80 /* GBusCredentialsFlags */
  81 typedef enum
  82 {
  83   G_BUS_CREDS_PID              = 1,
  84   G_BUS_CREDS_UID              = 2,
  85   G_BUS_CREDS_UNIQUE_NAME      = 3,
  86   G_BUS_CREDS_SELINUX_CONTEXT  = 4
  87 } GBusCredentialsFlags;
  88
  89 /* GKdbusPrivate struct */
  90 struct _GKdbusPrivate
  91 {
  92   gint               fd;
  93
  94   gchar             *kdbus_buffer;
  95   struct kdbus_msg  *kmsg;
  96
  97   gchar             *unique_name;
  98   guint64            unique_id;
  99
 100   guint64            flags;
 101   guint64            attach_flags_send;
 102   guint64            attach_flags_recv;
 103
 104   GString           *msg_sender;
 105   GString           *msg_destination;
 106   GSList            *kdbus_msg_items;
 107
 108   gint              *fds;
 109   gint               num_fds;
 110
 111   gsize              bloom_size;
 112   guint              bloom_n_hash;
 113
 114   guint              closed : 1;
 115   guint              inited : 1;
 116   guint              timeout;
 117   guint              timed_out : 1;
 118
 119   guchar             bus_id[16];
 120 };
 121
 122 /* GKdbusSource struct */
 123 typedef struct {
 124   GSource        source;
 125   GPollFD        pollfd;
 126   GKdbus        *kdbus;
 127   GIOCondition   condition;
 128   GCancellable  *cancellable;
 129   GPollFD        cancel_pollfd;
 130   gint64         timeout_time;
 131 } GKdbusSource;
 132
 133
 134 typedef gboolean (*GKdbusSourceFunc) (GKdbus *kdbus,
 135                                       GIOCondition condition,
 136                                       gpointer user_data);
 137
 138 /* Hash keys for bloom filters*/
 139 const guint8 hash_keys[8][16] =
 140 {
 141   {0xb9,0x66,0x0b,0xf0,0x46,0x70,0x47,0xc1,0x88,0x75,0xc4,0x9c,0x54,0xb9,0xbd,0x15},
 142   {0xaa,0xa1,0x54,0xa2,0xe0,0x71,0x4b,0x39,0xbf,0xe1,0xdd,0x2e,0x9f,0xc5,0x4a,0x3b},
 143   {0x63,0xfd,0xae,0xbe,0xcd,0x82,0x48,0x12,0xa1,0x6e,0x41,0x26,0xcb,0xfa,0xa0,0xc8},
 144   {0x23,0xbe,0x45,0x29,0x32,0xd2,0x46,0x2d,0x82,0x03,0x52,0x28,0xfe,0x37,0x17,0xf5},
 145   {0x56,0x3b,0xbf,0xee,0x5a,0x4f,0x43,0x39,0xaf,0xaa,0x94,0x08,0xdf,0xf0,0xfc,0x10},
 146   {0x31,0x80,0xc8,0x73,0xc7,0xea,0x46,0xd3,0xaa,0x25,0x75,0x0f,0x9e,0x4c,0x09,0x29},
 147   {0x7d,0xf7,0x18,0x4b,0x7b,0xa4,0x44,0xd5,0x85,0x3c,0x06,0xe0,0x65,0x53,0x96,0x6d},
 148   {0xf2,0x77,0xe9,0x6f,0x93,0xb5,0x4e,0x71,0x9a,0x0c,0x34,0x88,0x39,0x25,0xbf,0x35}
 149 };
 150
 151
 152 /**
 153  * _g_kdbus_get_last_msg_sender
 154  *
 155  */
 156 gchar *
 157 _g_kdbus_get_last_msg_sender (GKdbus  *kdbus)
 158 {
 159   return kdbus->priv->msg_sender->str;
 160 }
 161
 162
 163 /**
 164  * _g_kdbus_get_last_msg_destination
 165  *
 166  */
 167 gchar *
 168 _g_kdbus_get_last_msg_destination (GKdbus  *kdbus)
 169 {
 170   return kdbus->priv->msg_destination->str;
 171 }
 172
 173
 174 /**
 175  * _g_kdbus_get_last_msg_items:
 176  *
 177  */
 178 GSList *
 179 _g_kdbus_get_last_msg_items (GKdbus  *kdbus)
 180 {
 181   return kdbus->priv->kdbus_msg_items;
 182 }
 183
 184
 185 /**
 186  * g_kdbus_add_msg_part:
 187  *
 188  */
 189 static void
 190 g_kdbus_add_msg_part (GKdbus  *kdbus,
 191                       gchar   *data,
 192                       gsize    size)
 193 {
 194   msg_part* part = g_new (msg_part, 1);
 195   part->data = data;
 196   part->size = size;
 197   kdbus->priv->kdbus_msg_items = g_slist_append (kdbus->priv->kdbus_msg_items, part);
 198 }
 199
 200
 201 /**
 202  * _g_kdbus_hexdump_all_items:
 203  *
 204  */
 205 gchar *
 206 _g_kdbus_hexdump_all_items (GSList  *kdbus_msg_items)
 207 {
 208
 209   GString *ret;
 210   gint item = 1;
 211   ret = g_string_new (NULL);
 212
 213   while (kdbus_msg_items != NULL)
 214     {
 215       g_string_append_printf (ret, "\n  Item %d\n", item);
 216       g_string_append (ret, _g_dbus_hexdump (((msg_part*)kdbus_msg_items->data)->data, ((msg_part*)kdbus_msg_items->data)->size, 2));
 217
 218       kdbus_msg_items = g_slist_next(kdbus_msg_items);
 219       item++;
 220     }
 221
 222   return g_string_free (ret, FALSE);
 223 }
 224
 225
 226 /**
 227  * g_kdbus_finalize:
 228  *
 229  */
 230 static void
 231 g_kdbus_finalize (GObject  *object)
 232 {
 233   GKdbus *kdbus = G_KDBUS (object);
 234
 235   if (kdbus->priv->kdbus_buffer != NULL)
 236     munmap (kdbus->priv->kdbus_buffer, KDBUS_POOL_SIZE);
 237
 238   kdbus->priv->kdbus_buffer = NULL;
 239
 240   if (kdbus->priv->fd != -1 && !kdbus->priv->closed)
 241     _g_kdbus_close (kdbus, NULL);
 242
 243   g_string_free (kdbus->priv->msg_sender, TRUE);
 244   g_string_free (kdbus->priv->msg_destination, TRUE);
 245
 246   if (G_OBJECT_CLASS (g_kdbus_parent_class)->finalize)
 247     (*G_OBJECT_CLASS (g_kdbus_parent_class)->finalize) (object);
 248 }
 249
 250
 251 /**
 252  * g_kdbus_class_init:
 253  *
 254  */
 255 static void
 256 g_kdbus_class_init (GKdbusClass  *klass)
 257 {
 258   GObjectClass *gobject_class G_GNUC_UNUSED = G_OBJECT_CLASS (klass);
 259
 260   g_type_class_add_private (klass, sizeof (GKdbusPrivate));
 261   gobject_class->finalize = g_kdbus_finalize;
 262 }
 263
 264
 265 /**
 266  * g_kdbus_initable_iface_init:
 267  *
 268  */
 269 static void
 270 g_kdbus_initable_iface_init (GInitableIface  *iface)
 271 {
 272   iface->init = g_kdbus_initable_init;
 273 }
 274
 275
 276 /**
 277  * g_kdbus_init:
 278  *
 279  */
 280 static void
 281 g_kdbus_init (GKdbus  *kdbus)
 282 {
 283   kdbus->priv = G_TYPE_INSTANCE_GET_PRIVATE (kdbus, G_TYPE_KDBUS, GKdbusPrivate);
 284
 285   kdbus->priv->fd = -1;
 286
 287   kdbus->priv->unique_id = -1;
 288   kdbus->priv->unique_name = NULL;
 289
 290   kdbus->priv->kdbus_buffer = NULL;
 291   kdbus->priv->kdbus_msg_items = NULL;
 292
 293   kdbus->priv->msg_sender = g_string_new (NULL);
 294   kdbus->priv->msg_destination = g_string_new (NULL);
 295
 296   kdbus->priv->flags = 0; /* KDBUS_HELLO_ACCEPT_FD */
 297   kdbus->priv->attach_flags_send = _KDBUS_ATTACH_ALL;
 298   kdbus->priv->attach_flags_recv = _KDBUS_ATTACH_ALL;
 299
 300   kdbus->priv->fds = NULL;
 301   kdbus->priv->num_fds = 0;
 302 }
 303
 304
 305 /**
 306  * g_kdbus_initable_init:
 307  *
 308  */
 309 static gboolean
 310 g_kdbus_initable_init (GInitable     *initable,
 311                        GCancellable  *cancellable,
 312                        GError       **error)
 313 {
 314   GKdbus *kdbus;
 315
 316   g_return_val_if_fail (G_IS_KDBUS (initable), FALSE);
 317
 318   kdbus = G_KDBUS (initable);
 319
 320   if (cancellable != NULL)
 321     {
 322       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
 323                            _("Cancellable initialization not supported"));
 324       return FALSE;
 325     }
 326
 327   kdbus->priv->inited = TRUE;
 328
 329   return TRUE;
 330 }
 331
 332
 333 /**
 334  * kdbus_source_prepare:
 335  *
 336  */
 337 static gboolean
 338 kdbus_source_prepare (GSource  *source,
 339                       gint     *timeout)
 340 {
 341   GKdbusSource *kdbus_source = (GKdbusSource *)source;
 342
 343   if (g_cancellable_is_cancelled (kdbus_source->cancellable))
 344     return TRUE;
 345
 346   if (kdbus_source->timeout_time)
 347     {
 348       gint64 now;
 349
 350       now = g_source_get_time (source);
 351
 352       *timeout = (kdbus_source->timeout_time - now + 999) / 1000;
 353       if (*timeout < 0)
 354         {
 355           kdbus_source->kdbus->priv->timed_out = TRUE;
 356           *timeout = 0;
 357           return TRUE;
 358         }
 359     }
 360   else
 361     *timeout = -1;
 362
 363   if ((kdbus_source->condition & kdbus_source->pollfd.revents) != 0)
 364     return TRUE;
 365
 366   return FALSE;
 367 }
 368
 369
 370 /**
 371  * kdbus_source_check:
 372  *
 373  */
 374 static gboolean
 375 kdbus_source_check (GSource  *source)
 376 {
 377   gint timeout;
 378
 379   return kdbus_source_prepare (source, &timeout);
 380 }
 381
 382
 383 /**
 384  * kdbus_source_dispatch
 385  *
 386  */
 387 static gboolean
 388 kdbus_source_dispatch  (GSource      *source,
 389                         GSourceFunc   callback,
 390                         gpointer      user_data)
 391 {
 392   GKdbusSourceFunc func = (GKdbusSourceFunc)callback;
 393   GKdbusSource *kdbus_source = (GKdbusSource *)source;
 394   GKdbus *kdbus = kdbus_source->kdbus;
 395   gboolean ret;
 396
 397   if (kdbus_source->kdbus->priv->timed_out)
 398     kdbus_source->pollfd.revents |= kdbus_source->condition & (G_IO_IN | G_IO_OUT);
 399
 400   ret = (*func) (kdbus,
 401                  kdbus_source->pollfd.revents & kdbus_source->condition,
 402                  user_data);
 403
 404   if (kdbus->priv->timeout)
 405     kdbus_source->timeout_time = g_get_monotonic_time ()
 406                                + kdbus->priv->timeout * 1000000;
 407   else
 408     kdbus_source->timeout_time = 0;
 409
 410   return ret;
 411 }
 412
 413
 414 /**
 415  * kdbus_source_finalize
 416  *
 417  */
 418 static void
 419 kdbus_source_finalize (GSource  *source)
 420 {
 421   GKdbusSource *kdbus_source = (GKdbusSource *)source;
 422   GKdbus *kdbus;
 423
 424   kdbus = kdbus_source->kdbus;
 425
 426   g_object_unref (kdbus);
 427
 428   if (kdbus_source->cancellable)
 429     {
 430       g_cancellable_release_fd (kdbus_source->cancellable);
 431       g_object_unref (kdbus_source->cancellable);
 432     }
 433 }
 434
 435
 436 /**
 437  * kdbus_source_closure_callback:
 438  *
 439  */
 440 static gboolean
 441 kdbus_source_closure_callback (GKdbus        *kdbus,
 442                                GIOCondition   condition,
 443                                gpointer       data)
 444 {
 445   GClosure *closure = data;
 446   GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
 447   GValue result_value = G_VALUE_INIT;
 448   gboolean result;
 449
 450   g_value_init (&result_value, G_TYPE_BOOLEAN);
 451
 452   g_value_init (&params[0], G_TYPE_KDBUS);
 453   g_value_set_object (&params[0], kdbus);
 454   g_value_init (&params[1], G_TYPE_IO_CONDITION);
 455   g_value_set_flags (&params[1], condition);
 456
 457   g_closure_invoke (closure, &result_value, 2, params, NULL);
 458
 459   result = g_value_get_boolean (&result_value);
 460   g_value_unset (&result_value);
 461   g_value_unset (&params[0]);
 462   g_value_unset (&params[1]);
 463
 464   return result;
 465 }
 466
 467
 468 static GSourceFuncs kdbus_source_funcs =
 469 {
 470   kdbus_source_prepare,
 471   kdbus_source_check,
 472   kdbus_source_dispatch,
 473   kdbus_source_finalize,
 474   (GSourceFunc)kdbus_source_closure_callback,
 475 };
 476
 477
 478 /**
 479  * kdbus_source_new:
 480  *
 481  */
 482 static GSource *
 483 kdbus_source_new (GKdbus        *kdbus,
 484                   GIOCondition   condition,
 485                   GCancellable  *cancellable)
 486 {
 487   GSource *source;
 488   GKdbusSource *kdbus_source;
 489
 490   source = g_source_new (&kdbus_source_funcs, sizeof (GKdbusSource));
 491   g_source_set_name (source, "GKdbus");
 492   kdbus_source = (GKdbusSource *)source;
 493
 494   kdbus_source->kdbus = g_object_ref (kdbus);
 495   kdbus_source->condition = condition;
 496
 497   if (g_cancellable_make_pollfd (cancellable,
 498                                  &kdbus_source->cancel_pollfd))
 499     {
 500       kdbus_source->cancellable = g_object_ref (cancellable);
 501       g_source_add_poll (source, &kdbus_source->cancel_pollfd);
 502     }
 503
 504   kdbus_source->pollfd.fd = kdbus->priv->fd;
 505   kdbus_source->pollfd.events = condition;
 506   kdbus_source->pollfd.revents = 0;
 507   g_source_add_poll (source, &kdbus_source->pollfd);
 508
 509   if (kdbus->priv->timeout)
 510     kdbus_source->timeout_time = g_get_monotonic_time ()
 511                                + kdbus->priv->timeout * 1000000;
 512   else
 513     kdbus_source->timeout_time = 0;
 514
 515   return source;
 516 }
 517
 518
 519 /**
 520  * _g_kdbus_create_source:
 521  *
 522  */
 523 GSource *
 524 _g_kdbus_create_source (GKdbus        *kdbus,
 525                         GIOCondition   condition,
 526                         GCancellable  *cancellable)
 527 {
 528   g_return_val_if_fail (G_IS_KDBUS (kdbus) && (cancellable == NULL || G_IS_CANCELLABLE (cancellable)), NULL);
 529
 530   return kdbus_source_new (kdbus, condition, cancellable);
 531 }
 532
 533
 534 /**
 535  * _g_kdbus_open:
 536  *
 537  */
 538 gboolean
 539 _g_kdbus_open (GKdbus       *kdbus,
 540                const gchar  *address,
 541                GError      **error)
 542 {
 543   g_return_val_if_fail (G_IS_KDBUS (kdbus), FALSE);
 544
 545   kdbus->priv->fd = open(address, O_RDWR|O_NOCTTY|O_CLOEXEC);
 546   if (kdbus->priv->fd<0)
 547     {
 548       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Can't open kdbus endpoint"));
 549       return FALSE;
 550     }
 551
 552   kdbus->priv->closed = FALSE;
 553
 554   return TRUE;
 555 }
 556
 557
 558 /**
 559  * g_kdbus_free_data:
 560  *
 561  */
 562 static gboolean
 563 g_kdbus_free_data (GKdbus      *kdbus,
 564                    guint64      offset)
 565 {
 566   struct kdbus_cmd_free cmd;
 567   int ret;
 568
 569   cmd.offset = offset;
 570   cmd.flags = 0;
 571
 572   ret = ioctl (kdbus->priv->fd, KDBUS_CMD_FREE, &cmd);
 573   if (ret < 0)
 574       return FALSE;
 575
 576   return TRUE;
 577 }
 578
 579
 580 /**
 581  * g_kdbus_translate_nameowner_flags:
 582  *
 583  */
 584 static void
 585 g_kdbus_translate_nameowner_flags (GBusNameOwnerFlags   flags,
 586                                    guint64             *kdbus_flags)
 587 {
 588   guint64 new_flags;
 589
 590   new_flags = 0;
 591
 592   if (flags & G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT)
 593     new_flags |= KDBUS_NAME_ALLOW_REPLACEMENT;
 594
 595   if (flags & G_BUS_NAME_OWNER_FLAGS_REPLACE)
 596     new_flags |= KDBUS_NAME_REPLACE_EXISTING;
 597
 598   if (!(flags & G_BUS_NAME_OWNER_FLAGS_DO_NOT_QUEUE))
 599     new_flags |= KDBUS_NAME_QUEUE;
 600
 601   *kdbus_flags = new_flags;
 602 }
 603
 604
 605 /**
 606  * _g_kdbus_close:
 607  *
 608  */
 609 gboolean
 610 _g_kdbus_close (GKdbus  *kdbus,
 611                 GError **error)
 612 {
 613   gint res;
 614
 615   g_return_val_if_fail (G_IS_KDBUS (kdbus), FALSE);
 616
 617   if (kdbus->priv->closed)
 618     return TRUE;
 619
 620   while (1)
 621     {
 622       res = close (kdbus->priv->fd);
 623
 624       if (res == -1)
 625         {
 626           if (errno == EINTR)
 627             continue;
 628
 629           g_set_error (error, G_IO_ERROR,
 630                        g_io_error_from_errno (errno),
 631                        _("Error closing kdbus fd: %s"),
 632                        g_strerror (errno));
 633           return FALSE;
 634         }
 635       break;
 636     }
 637
 638   kdbus->priv->closed = TRUE;
 639   kdbus->priv->fd = -1;
 640
 641   return TRUE;
 642 }
 643
 644
 645 /**
 646  * _g_kdbus_is_closed:
 647  *
 648  */
 649 gboolean
 650 _g_kdbus_is_closed (GKdbus  *kdbus)
 651 {
 652   g_return_val_if_fail (G_IS_KDBUS (kdbus), FALSE);
 653
 654   return kdbus->priv->closed;
 655 }
 656
 657
 658 /**
 659  * _g_kdbus_Hello:
 660  *
 661  */
 662 GVariant *
 663 _g_kdbus_Hello (GIOStream  *stream,
 664                 GError    **error)
 665 {
 666   GKdbus *kdbus;
 667   struct kdbus_cmd_hello *hello;
 668   struct kdbus_item *item;
 669
 670   gchar *conn_name;
 671   size_t size, conn_name_size;
 672
 673   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (stream));
 674
 675   conn_name = "gdbus-kdbus";
 676   conn_name_size = strlen (conn_name);
 677
 678   size = KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_cmd_hello, items)) +
 679          KDBUS_ALIGN8 (G_STRUCT_OFFSET (struct kdbus_item, str) + conn_name_size + 1);
 680
 681   hello = g_alloca0 (size);
 682   hello->flags = kdbus->priv->flags;
 683   hello->attach_flags_send = kdbus->priv->attach_flags_send;
 684   hello->attach_flags_recv = kdbus->priv->attach_flags_recv;
 685   hello->size = size;
 686   hello->pool_size = KDBUS_POOL_SIZE;
 687
 688   item = hello->items;
 689   item->size = G_STRUCT_OFFSET (struct kdbus_item, str) + conn_name_size + 1;
 690   item->type = KDBUS_ITEM_CONN_DESCRIPTION;
 691   memcpy (item->str, conn_name, conn_name_size+1);
 692   item = KDBUS_ITEM_NEXT (item);
 693
 694   if (ioctl(kdbus->priv->fd, KDBUS_CMD_HELLO, hello))
 695     {
 696       g_set_error (error, G_IO_ERROR,
 697                    g_io_error_from_errno (errno),
 698                    _("Failed to send HELLO: %s"),
 699                    g_strerror (errno));
 700       return NULL;
 701     }
 702
 703   kdbus->priv->kdbus_buffer = mmap(NULL, KDBUS_POOL_SIZE, PROT_READ, MAP_SHARED, kdbus->priv->fd, 0);
 704   if (kdbus->priv->kdbus_buffer == MAP_FAILED)
 705     {
 706       g_set_error (error, G_IO_ERROR,
 707                    g_io_error_from_errno (errno),
 708                    _("mmap error: %s"),
 709                    g_strerror (errno));
 710       return NULL;
 711     }
 712
 713   if (hello->bus_flags > 0xFFFFFFFFULL)
 714     {
 715       g_set_error_literal (error,
 716                            G_IO_ERROR,
 717                            G_IO_ERROR_FAILED,
 718                            _("Incompatible HELLO flags"));
 719       return NULL;
 720     }
 721
 722   memcpy (kdbus->priv->bus_id, hello->id128, 16);
 723
 724   kdbus->priv->unique_id = hello->id;
 725   asprintf(&kdbus->priv->unique_name, ":1.%llu", (unsigned long long) hello->id);
 726
 727   /* read bloom filters parameters */
 728   kdbus->priv->bloom_size = (gsize) hello->bloom.size;
 729   kdbus->priv->bloom_n_hash = (guint) hello->bloom.n_hash;
 730
 731   return g_variant_new ("(s)", kdbus->priv->unique_name);
 732 }
 733
 734
 735 /**
 736  * _g_kdbus_RequestName:
 737  *
 738  */
 739 GVariant *
 740 _g_kdbus_RequestName (GDBusConnection     *connection,
 741                       const gchar         *name,
 742                       GBusNameOwnerFlags   flags,
 743                       GError             **error)
 744 {
 745   GKdbus *kdbus;
 746   GVariant *result;
 747   struct kdbus_cmd_name *kdbus_name;
 748   guint64 kdbus_flags;
 749   gssize len, size;
 750   gint status, ret;
 751
 752   status = G_BUS_REQUEST_NAME_FLAGS_PRIMARY_OWNER;
 753
 754   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
 755   if (kdbus == NULL)
 756     {
 757       g_set_error_literal (error,
 758                            G_DBUS_ERROR,
 759                            G_DBUS_ERROR_IO_ERROR,
 760                            _("The connection is closed"));
 761       return NULL;
 762     }
 763
 764   if (!g_dbus_is_name (name))
 765     {
 766       g_set_error (error,
 767                    G_DBUS_ERROR,
 768                    G_DBUS_ERROR_INVALID_ARGS,
 769                    "Given bus name \"%s\" is not valid", name);
 770       return NULL;
 771     }
 772
 773   if (*name == ':')
 774     {
 775       g_set_error (error,
 776                    G_DBUS_ERROR,
 777                    G_DBUS_ERROR_INVALID_ARGS,
 778                    "Cannot acquire a service starting with ':' such as \"%s\"", name);
 779       return NULL;
 780     }
 781
 782   g_kdbus_translate_nameowner_flags (flags, &kdbus_flags);
 783
 784   len = strlen(name) + 1;
 785   size = G_STRUCT_OFFSET (struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(len);
 786   kdbus_name = g_alloca0 (size);
 787   kdbus_name->size = size;
 788   kdbus_name->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
 789   kdbus_name->items[0].type = KDBUS_ITEM_NAME;
 790   kdbus_name->flags = kdbus_flags;
 791   memcpy (kdbus_name->items[0].str, name, len);
 792
 793   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_NAME_ACQUIRE, kdbus_name);
 794   if (ret < 0)
 795     {
 796       if (errno == EEXIST)
 797         status = G_BUS_REQUEST_NAME_FLAGS_EXISTS;
 798       else if (errno == EALREADY)
 799         status = G_BUS_REQUEST_NAME_FLAGS_ALREADY_OWNER;
 800       else
 801         {
 802           g_set_error (error, G_IO_ERROR,
 803                        g_io_error_from_errno (errno),
 804                        _("Error while acquiring name: %s"),
 805                        g_strerror (errno));
 806           return NULL;
 807         }
 808     }
 809
 810   if (kdbus_name->flags & KDBUS_NAME_IN_QUEUE)
 811     status = G_BUS_REQUEST_NAME_FLAGS_IN_QUEUE;
 812
 813   result = g_variant_new ("(u)", status);
 814
 815   return result;
 816 }
 817
 818
 819 /**
 820  * _g_kdbus_ReleaseName:
 821  *
 822  */
 823 GVariant *
 824 _g_kdbus_ReleaseName (GDBusConnection     *connection,
 825                       const gchar         *name,
 826                       GError             **error)
 827 {
 828   GKdbus *kdbus;
 829   GVariant *result;
 830   struct kdbus_cmd_name *kdbus_name;
 831   gssize len, size;
 832   gint status, ret;
 833
 834   status = G_BUS_RELEASE_NAME_FLAGS_RELEASED;
 835
 836   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
 837   if (kdbus == NULL)
 838     {
 839       g_set_error_literal (error,
 840                            G_DBUS_ERROR,
 841                            G_DBUS_ERROR_IO_ERROR,
 842                            _("The connection is closed"));
 843       return NULL;
 844     }
 845
 846   if (!g_dbus_is_name (name))
 847     {
 848       g_set_error (error,
 849                    G_DBUS_ERROR,
 850                    G_DBUS_ERROR_INVALID_ARGS,
 851                    "Given bus name \"%s\" is not valid", name);
 852       return NULL;
 853     }
 854
 855   if (*name == ':')
 856     {
 857       g_set_error (error,
 858                    G_DBUS_ERROR,
 859                    G_DBUS_ERROR_INVALID_ARGS,
 860                    "Cannot release a service starting with ':' such as \"%s\"", name);
 861       return NULL;
 862     }
 863
 864   len = strlen(name) + 1;
 865   size = G_STRUCT_OFFSET (struct kdbus_cmd_name, items) + KDBUS_ITEM_SIZE(len);
 866   kdbus_name = g_alloca0 (size);
 867   kdbus_name->size = size;
 868   kdbus_name->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
 869   kdbus_name->items[0].type = KDBUS_ITEM_NAME;
 870   memcpy (kdbus_name->items[0].str, name, len);
 871
 872   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_NAME_RELEASE, kdbus_name);
 873   if (ret < 0)
 874     {
 875       if (errno == ESRCH)
 876         status = G_BUS_RELEASE_NAME_FLAGS_NON_EXISTENT;
 877       else if (errno == EADDRINUSE)
 878         status = G_BUS_RELEASE_NAME_FLAGS_NOT_OWNER;
 879       else
 880         {
 881           g_set_error (error, G_IO_ERROR,
 882                        g_io_error_from_errno (errno),
 883                        _("Error while releasing name: %s"),
 884                        g_strerror (errno));
 885           return NULL;
 886         }
 887     }
 888
 889   result = g_variant_new ("(u)", status);
 890
 891   return result;
 892 }
 893
 894
 895 /**
 896  * _g_kdbus_GetBusId:
 897  *
 898  */
 899 GVariant *
 900 _g_kdbus_GetBusId (GDBusConnection  *connection,
 901                    GError          **error)
 902 {
 903   GKdbus   *kdbus;
 904   GVariant *result;
 905   GString  *result_str;
 906   guint     cnt;
 907
 908   result_str = g_string_new (NULL);
 909   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
 910   if (kdbus == NULL)
 911     {
 912       g_set_error_literal (error,
 913                            G_DBUS_ERROR,
 914                            G_DBUS_ERROR_IO_ERROR,
 915                            _("The connection is closed"));
 916       g_string_free (result_str, TRUE);
 917       return NULL;
 918     }
 919
 920   for (cnt=0; cnt<16; cnt++)
 921     g_string_append_printf (result_str, "%02x", kdbus->priv->bus_id[cnt]);
 922
 923   result = g_variant_new ("(s)", result_str->str);
 924   g_string_free (result_str, TRUE);
 925
 926   return result;
 927 }
 928
 929
 930 /**
 931  * _g_kdbus_GetListNames:
 932  *
 933  */
 934 GVariant *
 935 _g_kdbus_GetListNames (GDBusConnection  *connection,
 936                        guint             list_name_type,
 937                        GError          **error)
 938 {
 939   GKdbus *kdbus;
 940   GVariant *result;
 941   GVariantBuilder *builder;
 942
 943   struct kdbus_cmd_name_list cmd = {};
 944   struct kdbus_name_list *name_list;
 945   struct kdbus_name_info *name;
 946
 947   guint64 prev_id;
 948   gint ret;
 949
 950   prev_id = 0;
 951   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
 952   if (kdbus == NULL)
 953     {
 954       g_set_error_literal (error,
 955                            G_DBUS_ERROR,
 956                            G_DBUS_ERROR_IO_ERROR,
 957                            _("The connection is closed"));
 958       return NULL;
 959     }
 960
 961   if (list_name_type)
 962     cmd.flags = KDBUS_NAME_LIST_ACTIVATORS;                     /* ListActivatableNames */
 963   else
 964     cmd.flags = KDBUS_NAME_LIST_UNIQUE | KDBUS_NAME_LIST_NAMES; /* ListNames */
 965
 966   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_NAME_LIST, &cmd);
 967   if (ret < 0)
 968     {
 969       g_set_error (error,
 970                    G_DBUS_ERROR,
 971                    G_DBUS_ERROR_FAILED,
 972                    _("Error listing names"));
 973       return NULL;
 974     }
 975
 976   name_list = (struct kdbus_name_list *) ((guint8 *) kdbus->priv->kdbus_buffer + cmd.offset);
 977   builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
 978
 979   KDBUS_ITEM_FOREACH(name, name_list, names)
 980     {
 981       struct kdbus_item *item;
 982       const gchar *item_name = "";
 983
 984       if ((cmd.flags & KDBUS_NAME_LIST_UNIQUE) && name->owner_id != prev_id)
 985         {
 986           GString *unique_name;
 987
 988           unique_name = g_string_new (NULL);
 989           g_string_printf (unique_name, ":1.%llu", name->owner_id);
 990           g_variant_builder_add (builder, "s", unique_name->str);
 991           g_string_free (unique_name,TRUE);
 992           prev_id = name->owner_id;
 993         }
 994
 995        KDBUS_ITEM_FOREACH(item, name, items)
 996          if (item->type == KDBUS_ITEM_OWNED_NAME)
 997            item_name = item->name.name;
 998
 999         if (g_dbus_is_name (item_name))
1000           g_variant_builder_add (builder, "s", item_name);
1001     }
1002
1003   result = g_variant_new ("(as)", builder);
1004   g_variant_builder_unref (builder);
1005
1006   g_kdbus_free_data (kdbus, cmd.offset);
1007   return result;
1008 }
1009
1010
1011 /**
1012  * _g_kdbus_NameHasOwner_internal:
1013  *
1014  */
1015 static gboolean
1016 g_kdbus_NameHasOwner_internal (GKdbus       *kdbus,
1017                                const gchar  *name,
1018                                GError      **error)
1019 {
1020   struct kdbus_cmd_info *cmd;
1021   gssize size, len;
1022   gint ret;
1023
1024   if (g_dbus_is_unique_name(name))
1025     {
1026        size = G_STRUCT_OFFSET (struct kdbus_cmd_info, items);
1027        cmd = g_alloca0 (size);
1028        cmd->id = g_ascii_strtoull (name+3, NULL, 10);
1029     }
1030   else
1031     {
1032        len = strlen(name) + 1;
1033        size = G_STRUCT_OFFSET (struct kdbus_cmd_info, items) + KDBUS_ITEM_SIZE(len);
1034        cmd = g_alloca0 (size);
1035        cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
1036        cmd->items[0].type = KDBUS_ITEM_NAME;
1037        memcpy (cmd->items[0].str, name, len);
1038     }
1039   cmd->size = size;
1040
1041   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_CONN_INFO, cmd);
1042   g_kdbus_free_data (kdbus, cmd->offset);
1043
1044   if (ret < 0)
1045     return FALSE;
1046   else
1047     return TRUE;
1048 }
1049
1050
1051 /**
1052  * _g_kdbus_GetListQueuedOwners:
1053  *
1054  */
1055 GVariant *
1056 _g_kdbus_GetListQueuedOwners (GDBusConnection  *connection,
1057                               const gchar      *name,
1058                               GError          **error)
1059 {
1060   GKdbus *kdbus;
1061   GVariant *result;
1062   GVariantBuilder *builder;
1063   GString *unique_name;
1064   gint ret;
1065
1066   struct kdbus_cmd_name_list cmd = {};
1067   struct kdbus_name_list *name_list;
1068   struct kdbus_name_info *kname;
1069
1070   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
1071   if (kdbus == NULL)
1072     {
1073       g_set_error_literal (error,
1074                            G_DBUS_ERROR,
1075                            G_DBUS_ERROR_IO_ERROR,
1076                            _("The connection is closed"));
1077       return NULL;
1078     }
1079
1080   if (!g_dbus_is_name (name))
1081     {
1082       g_set_error (error,
1083                    G_DBUS_ERROR,
1084                    G_DBUS_ERROR_INVALID_ARGS,
1085                    "Given bus name \"%s\" is not valid", name);
1086       return NULL;
1087     }
1088
1089   if (!g_kdbus_NameHasOwner_internal (kdbus, name, error))
1090     {
1091       g_set_error (error,
1092                    G_DBUS_ERROR,
1093                    G_DBUS_ERROR_NAME_HAS_NO_OWNER,
1094                    "Could not get owner of name '%s': no such name", name);
1095       return NULL;
1096     }
1097
1098   cmd.flags = KDBUS_NAME_LIST_QUEUED;
1099   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_NAME_LIST, &cmd);
1100   if (ret < 0)
1101     {
1102       g_set_error (error,
1103                    G_DBUS_ERROR,
1104                    G_DBUS_ERROR_FAILED,
1105                    _("Error listing names"));
1106       return NULL;
1107     }
1108
1109   name_list = (struct kdbus_name_list *) ((guint8 *) kdbus->priv->kdbus_buffer + cmd.offset);
1110
1111   unique_name = g_string_new (NULL);
1112   builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
1113   KDBUS_ITEM_FOREACH(kname, name_list, names)
1114     {
1115       struct kdbus_item *item;
1116       const char *item_name = "";
1117
1118       KDBUS_ITEM_FOREACH(item, kname, items)
1119         if (item->type == KDBUS_ITEM_NAME)
1120           item_name = item->str;
1121
1122       if (strcmp(item_name, name))
1123         continue;
1124
1125       g_string_printf (unique_name, ":1.%llu", kname->owner_id);
1126       g_variant_builder_add (builder, "s", item_name);
1127     }
1128
1129   result = g_variant_new ("(as)", builder);
1130   g_variant_builder_unref (builder);
1131   g_string_free (unique_name,TRUE);
1132
1133   g_kdbus_free_data (kdbus, cmd.offset);
1134   return result;
1135 }
1136
1137
1138 /**
1139  * g_kdbus_GetConnInfo_internal:
1140  *
1141  */
1142 static GVariant *
1143 g_kdbus_GetConnInfo_internal (GDBusConnection  *connection,
1144                               const gchar      *name,
1145                               guint64           flag,
1146                               GError          **error)
1147 {
1148   GKdbus *kdbus;
1149   GVariant *result;
1150
1151   struct kdbus_cmd_info *cmd;
1152   struct kdbus_info *conn_info;
1153   struct kdbus_item *item;
1154   gssize size, len;
1155   gint ret;
1156
1157   result = NULL;
1158   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
1159   if (kdbus == NULL)
1160     {
1161       g_set_error_literal (error,
1162                            G_DBUS_ERROR,
1163                            G_DBUS_ERROR_IO_ERROR,
1164                            _("The connection is closed"));
1165       return NULL;
1166     }
1167
1168   if (!g_dbus_is_name (name))
1169     {
1170       g_set_error (error,
1171                    G_DBUS_ERROR,
1172                    G_DBUS_ERROR_INVALID_ARGS,
1173                    "Given bus name \"%s\" is not valid", name);
1174       return NULL;
1175     }
1176
1177   if (!g_kdbus_NameHasOwner_internal (kdbus, name, error))
1178     {
1179       g_set_error (error,
1180                    G_DBUS_ERROR,
1181                    G_DBUS_ERROR_NAME_HAS_NO_OWNER,
1182                    "Could not get owner of name '%s': no such name", name);
1183       return NULL;
1184     }
1185
1186   if (g_dbus_is_unique_name(name))
1187     {
1188        size = G_STRUCT_OFFSET (struct kdbus_cmd_info, items);
1189        cmd = g_alloca0 (size);
1190        cmd->id = g_ascii_strtoull (name+3, NULL, 10);
1191     }
1192   else
1193     {
1194        len = strlen(name) + 1;
1195        size = G_STRUCT_OFFSET (struct kdbus_cmd_info, items) + KDBUS_ITEM_SIZE(len);
1196        cmd = g_alloca0 (size);
1197        cmd->items[0].size = KDBUS_ITEM_HEADER_SIZE + len;
1198        cmd->items[0].type = KDBUS_ITEM_NAME;
1199        memcpy (cmd->items[0].str, name, len);
1200     }
1201
1202   cmd->flags = _KDBUS_ATTACH_ALL;
1203   cmd->size = size;
1204
1205   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_CONN_INFO, cmd);
1206   if (ret < 0)
1207     {
1208       g_set_error (error,
1209                    G_DBUS_ERROR,
1210                    G_DBUS_ERROR_FAILED,
1211                    _("Could not get connection info"));
1212       return NULL;
1213     }
1214
1215   conn_info = (struct kdbus_info *) ((guint8 *) kdbus->priv->kdbus_buffer + cmd->offset);
1216
1217   /*
1218   if (conn_info->flags & KDBUS_HELLO_ACTIVATOR)
1219     {}
1220   */
1221
1222   if (flag == G_BUS_CREDS_UNIQUE_NAME)
1223     {
1224        GString *unique_name;
1225
1226        unique_name = g_string_new (NULL);
1227        g_string_printf (unique_name, ":1.%llu", (unsigned long long) conn_info->id);
1228        result = g_variant_new ("(s)", unique_name->str);
1229        g_string_free (unique_name,TRUE);
1230        goto exit;
1231     }
1232
1233   KDBUS_ITEM_FOREACH(item, conn_info, items)
1234    {
1235       switch (item->type)
1236         {
1237           case KDBUS_ITEM_CREDS:
1238
1239             if (flag == G_BUS_CREDS_PID)
1240               {
1241                 guint pid = item->creds.pid;
1242                 result = g_variant_new ("(u)", pid);
1243                 goto exit;
1244                }
1245
1246             if (flag == G_BUS_CREDS_UID)
1247               {
1248                 guint uid = item->creds.uid;
1249                 result = g_variant_new ("(u)", uid);
1250                 goto exit;
1251               }
1252
1253           case KDBUS_ITEM_SECLABEL:
1254           case KDBUS_ITEM_PID_COMM:
1255           case KDBUS_ITEM_TID_COMM:
1256           case KDBUS_ITEM_EXE:
1257           case KDBUS_ITEM_CMDLINE:
1258           case KDBUS_ITEM_CGROUP:
1259           case KDBUS_ITEM_CAPS:
1260           case KDBUS_ITEM_NAME:
1261           case KDBUS_ITEM_AUDIT:
1262             break;
1263         }
1264    }
1265
1266 exit:
1267   g_kdbus_free_data (kdbus, cmd->offset);
1268   return result;
1269 }
1270
1271
1272 /**
1273  * _g_kdbus_GetNameOwner:
1274  *
1275  */
1276 GVariant *
1277 _g_kdbus_GetNameOwner (GDBusConnection  *connection,
1278                        const gchar      *name,
1279                        GError          **error)
1280 {
1281   return g_kdbus_GetConnInfo_internal (connection,
1282                                        name,
1283                                        G_BUS_CREDS_UNIQUE_NAME,
1284                                        error);
1285 }
1286
1287
1288 /**
1289  * _g_kdbus_GetConnectionUnixProcessID:
1290  *
1291  */
1292 GVariant *
1293 _g_kdbus_GetConnectionUnixProcessID (GDBusConnection  *connection,
1294                                      const gchar      *name,
1295                                      GError          **error)
1296 {
1297   return g_kdbus_GetConnInfo_internal (connection,
1298                                        name,
1299                                        G_BUS_CREDS_PID,
1300                                        error);
1301 }
1302
1303
1304 /**
1305  * _g_kdbus_GetConnectionUnixUser:
1306  *
1307  */
1308 GVariant *
1309 _g_kdbus_GetConnectionUnixUser (GDBusConnection  *connection,
1310                                 const gchar      *name,
1311                                 GError          **error)
1312 {
1313   return g_kdbus_GetConnInfo_internal (connection,
1314                                        name,
1315                                        G_BUS_CREDS_UID,
1316                                        error);
1317 }
1318
1319
1320 /**
1321  * _g_kdbus_match_remove:
1322  *
1323  */
1324 static void
1325 _g_kdbus_match_remove (GDBusConnection  *connection,
1326                        guint             cookie)
1327 {
1328   GKdbus *kdbus;
1329   struct kdbus_cmd_match cmd_match = {};
1330   gint ret;
1331
1332   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
1333
1334   cmd_match.size = sizeof (cmd_match);
1335   cmd_match.cookie = cookie;
1336
1337   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_MATCH_REMOVE, &cmd_match);
1338   if (ret < 0)
1339     g_warning ("ERROR - %d\n", (int) errno);
1340 }
1341
1342
1343 /**
1344  * _g_kdbus_subscribe_name_acquired:
1345  *
1346  */
1347 static void
1348 _g_kdbus_subscribe_name_owner_changed (GDBusConnection  *connection,
1349                                        const gchar      *name,
1350                                        const gchar      *old_name,
1351                                        const gchar      *new_name,
1352                                        guint             cookie)
1353 {
1354   GKdbus *kdbus;
1355   struct kdbus_item *item;
1356   struct kdbus_cmd_match *cmd_match;
1357   gssize size, len;
1358   gint ret;
1359   guint64 old_id;
1360   guint64 new_id = KDBUS_MATCH_ID_ANY;
1361
1362   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
1363
1364   len = strlen(name) + 1;
1365   size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
1366                       G_STRUCT_OFFSET (struct kdbus_item, name_change) +
1367                       G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
1368
1369   cmd_match = g_alloca0 (size);
1370   cmd_match->size = size;
1371   cmd_match->cookie = cookie;
1372   item = cmd_match->items;
1373
1374   if (old_name[0] == 0)
1375     {
1376       old_id = KDBUS_MATCH_ID_ANY;
1377     }
1378   else
1379     {
1380       if (g_dbus_is_unique_name(old_name))
1381         old_id = old_id+3;
1382       else
1383         return;
1384     }
1385
1386   if (new_name[0] == 0)
1387     {
1388       new_id = KDBUS_MATCH_ID_ANY;
1389     }
1390   else
1391     {
1392       if (g_dbus_is_unique_name(new_name))
1393         new_id = new_id+3;
1394       else
1395         return;
1396     }
1397
1398   cmd_match = g_alloca0 (size);
1399   cmd_match->size = size;
1400   cmd_match->cookie = cookie;
1401   item = cmd_match->items;
1402
1403   /* KDBUS_ITEM_NAME_CHANGE */
1404   item->type = KDBUS_ITEM_NAME_CHANGE;
1405   item->name_change.old_id.id = old_id;
1406   item->name_change.new_id.id = new_id;
1407   memcpy(item->name_change.name, name, len);
1408   item->size = G_STRUCT_OFFSET (struct kdbus_item, name_change) +
1409                G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
1410   item = KDBUS_ITEM_NEXT(item);
1411
1412   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_MATCH_ADD, cmd_match);
1413   if (ret < 0)
1414     g_warning ("ERROR - %d\n", (int) errno);
1415 }
1416
1417
1418 /**
1419  * _g_kdbus_subscribe_name_acquired:
1420  *
1421  */
1422 void
1423 _g_kdbus_subscribe_name_acquired (GDBusConnection  *connection,
1424                                   const gchar      *name)
1425 {
1426   GKdbus *kdbus;
1427   struct kdbus_item *item;
1428   struct kdbus_cmd_match *cmd_match;
1429   gssize size, len;
1430   guint64 cookie;
1431   gint ret;
1432
1433   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
1434
1435   len = strlen(name) + 1;
1436   size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
1437                       G_STRUCT_OFFSET (struct kdbus_item, name_change) +
1438                       G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
1439
1440   cookie = 0xbeefbeefbeefbeef;
1441   cmd_match = g_alloca0 (size);
1442   cmd_match->size = size;
1443   cmd_match->cookie = cookie;
1444   item = cmd_match->items;
1445
1446   /* KDBUS_ITEM_NAME_ADD */
1447   item->type = KDBUS_ITEM_NAME_ADD;
1448   item->name_change.old_id.id = KDBUS_MATCH_ID_ANY;
1449   item->name_change.new_id.id = kdbus->priv->unique_id;
1450   memcpy(item->name_change.name, name, len);
1451   item->size = G_STRUCT_OFFSET (struct kdbus_item, name_change) +
1452                G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
1453   item = KDBUS_ITEM_NEXT(item);
1454
1455   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_MATCH_ADD, cmd_match);
1456   if (ret < 0)
1457     g_warning ("ERROR - %d\n", (int) errno);
1458
1459   _g_kdbus_subscribe_name_owner_changed (connection, name, "", kdbus->priv->unique_name, cookie);
1460 }
1461
1462
1463 /**
1464  * _g_kdbus_subscribe_name_lost:
1465  *
1466  */
1467 void
1468 _g_kdbus_subscribe_name_lost (GDBusConnection  *connection,
1469                               const gchar      *name)
1470 {
1471   GKdbus *kdbus;
1472   struct kdbus_item *item;
1473   struct kdbus_cmd_match *cmd_match;
1474   gssize size, len;
1475   guint64 cookie;
1476   gint ret;
1477
1478   kdbus = _g_kdbus_connection_get_kdbus (G_KDBUS_CONNECTION (g_dbus_connection_get_stream (connection)));
1479
1480   len = strlen(name) + 1;
1481   size = KDBUS_ALIGN8(G_STRUCT_OFFSET (struct kdbus_cmd_match, items) +
1482                       G_STRUCT_OFFSET (struct kdbus_item, name_change) +
1483                       G_STRUCT_OFFSET (struct kdbus_notify_name_change, name) + len);
1484
1485   cookie = 0xdeafdeafdeafdeaf;
1486   cmd_match = g_alloca0 (size);
1487   cmd_match->size = size;
1488   cmd_match->cookie = cookie;
1489   item = cmd_match->items;
1490
1491   /* KDBUS_ITEM_NAME_REMOVE */
1492   item->type = KDBUS_ITEM_NAME_REMOVE;
1493   item->name_change.old_id.id = kdbus->priv->unique_id;
1494   item->name_change.new_id.id = KDBUS_MATCH_ID_ANY;
1495   memcpy(item->name_change.name, name, len);
1496   item->size = G_STRUCT_OFFSET (struct kdbus_item, name_change) +
1497                G_STRUCT_OFFSET(struct kdbus_notify_name_change, name) + len;
1498   item = KDBUS_ITEM_NEXT(item);
1499
1500   ret = ioctl(kdbus->priv->fd, KDBUS_CMD_MATCH_ADD, cmd_match);
1501   if (ret < 0)
1502     g_warning ("ERROR - %d\n", (int) errno);
1503
1504   _g_kdbus_subscribe_name_owner_changed (connection, name, kdbus->priv->unique_name, "", cookie);
1505 }
1506
1507
1508 /**
1509  * _g_kdbus_unsubscribe_name_acquired:
1510  *
1511  */
1512 void
1513 _g_kdbus_unsubscribe_name_acquired (GDBusConnection  *connection)
1514 {
1515   guint64 cookie;
1516
1517   cookie = 0xbeefbeefbeefbeef;
1518   _g_kdbus_match_remove (connection, cookie);
1519 }
1520
1521
1522 /**
1523  * _g_kdbus_unsubscribe_name_lost:
1524  *
1525  */
1526 void
1527 _g_kdbus_unsubscribe_name_lost (GDBusConnection  *connection)
1528 {
1529   guint64 cookie;
1530
1531   cookie = 0xdeafdeafdeafdeaf;
1532   _g_kdbus_match_remove (connection, cookie);
1533 }
1534
1535
1536 /**
1537  * _g_kdbus_release_msg:
1538  *
1539  */
1540 void
1541 _g_kdbus_release_kmsg (GKdbus  *kdbus)
1542 {
1543   struct kdbus_item *item = NULL;
1544   GSList *iterator = NULL;
1545   guint64 offset;
1546
1547   offset = (guint8 *)kdbus->priv->kmsg - (guint8 *)kdbus->priv->kdbus_buffer;
1548   ioctl(kdbus->priv->fd, KDBUS_CMD_FREE, &offset);
1549
1550   for (iterator = kdbus->priv->kdbus_msg_items; iterator; iterator = iterator->next)
1551     g_free ((msg_part*)iterator->data);
1552
1553   g_slist_free (kdbus->priv->kdbus_msg_items);
1554   kdbus->priv->kdbus_msg_items = NULL;
1555
1556   KDBUS_ITEM_FOREACH (item, kdbus->priv->kmsg, items)
1557     {
1558       if (item->type == KDBUS_ITEM_PAYLOAD_MEMFD)
1559         close(item->memfd.fd);
1560       else if (item->type == KDBUS_ITEM_FDS)
1561         {
1562           gint i;
1563           gint num_fds = (item->size - G_STRUCT_OFFSET(struct kdbus_item, fds)) / sizeof(int);
1564
1565           for (i = 0; i < num_fds; i++)
1566             close(item->fds[i]);
1567         }
1568     }
1569 }
1570
1571
1572 /**
1573  * g_kdbus_append_payload_vec:
1574  *
1575  */
1576 static void
1577 g_kdbus_append_payload_vec (struct kdbus_item **item,
1578                             const void         *data_ptr,
1579                             gssize              size)
1580 {
1581   *item = KDBUS_ALIGN8_PTR(*item);
1582   (*item)->size = G_STRUCT_OFFSET (struct kdbus_item, vec) + sizeof(struct kdbus_vec);
1583   (*item)->type = KDBUS_ITEM_PAYLOAD_VEC;
1584   (*item)->vec.address = (guint64)((guintptr)data_ptr);
1585   (*item)->vec.size = size;
1586   *item = KDBUS_ITEM_NEXT(*item);
1587 }
1588
1589
1590 /**
1591  * g_kdbus_append_payload_destiantion:
1592  *
1593  */
1594 static void
1595 g_kdbus_append_destination (struct kdbus_item **item,
1596                             const gchar        *destination,
1597                             gsize               size)
1598 {
1599   *item = KDBUS_ALIGN8_PTR(*item);
1600   (*item)->size = G_STRUCT_OFFSET (struct kdbus_item, str) + size + 1;
1601   (*item)->type = KDBUS_ITEM_DST_NAME;
1602   memcpy ((*item)->str, destination, size+1);
1603   *item = KDBUS_ITEM_NEXT(*item);
1604 }
1605
1606
1607 /**
1608  * g_kdbus_append_payload_bloom:
1609  *
1610  */
1611 static struct kdbus_bloom_filter *
1612 g_kdbus_append_bloom (struct kdbus_item **item,
1613                       gsize               size)
1614 {
1615   struct kdbus_item *bloom_item;
1616
1617   bloom_item = KDBUS_ALIGN8_PTR(*item);
1618   bloom_item->size = G_STRUCT_OFFSET (struct kdbus_item, bloom_filter) +
1619                      G_STRUCT_OFFSET (struct kdbus_bloom_filter, data) +
1620                      size;
1621
1622   bloom_item->type = KDBUS_ITEM_BLOOM_FILTER;
1623
1624   *item = KDBUS_ITEM_NEXT(bloom_item);
1625   return &bloom_item->bloom_filter;
1626 }
1627
1628
1629 /**
1630  * g_kdbus_append_fds:
1631  *
1632  */
1633 static void
1634 g_kdbus_append_fds (struct kdbus_item **item,
1635                     GUnixFDList        *fd_list)
1636 {
1637   *item = KDBUS_ALIGN8_PTR(*item);
1638   (*item)->size = G_STRUCT_OFFSET (struct kdbus_item, fds) + sizeof(int) * g_unix_fd_list_get_length(fd_list);
1639   (*item)->type = KDBUS_ITEM_FDS;
1640   memcpy ((*item)->fds, g_unix_fd_list_peek_fds(fd_list, NULL), sizeof(int) * g_unix_fd_list_get_length(fd_list));
1641
1642   *item = KDBUS_ITEM_NEXT(*item);
1643 }
1644
1645
1646 /**
1647  * _g_kdbus_attach_fds_to_msg:
1648  *
1649  */
1650 void
1651 _g_kdbus_attach_fds_to_msg (GKdbus       *kdbus,
1652                             GUnixFDList **fd_list)
1653 {
1654   if ((kdbus->priv->fds != NULL) && (kdbus->priv->num_fds > 0))
1655     {
1656       gint n;
1657
1658       if (*fd_list == NULL)
1659         *fd_list = g_unix_fd_list_new();
1660
1661       for (n = 0; n < kdbus->priv->num_fds; n++)
1662         {
1663           g_unix_fd_list_append (*fd_list, kdbus->priv->fds[n], NULL);
1664           (void) g_close (kdbus->priv->fds[n], NULL);
1665         }
1666
1667       g_free (kdbus->priv->fds);
1668       kdbus->priv->fds = NULL;
1669       kdbus->priv->num_fds = 0;
1670     }
1671 }
1672
1673 /**
1674  * g_kdbus_bloom_add_data:
1675  * Based on bus-bloom.c from systemd
1676  * http://cgit.freedesktop.org/systemd/systemd/tree/src/libsystemd/sd-bus/bus-bloom.c
1677  */
1678 static void
1679 g_kdbus_bloom_add_data (GKdbus      *kdbus,
1680                         guint64      bloom_data [],
1681                         const void  *data,
1682                         gsize        n)
1683 {
1684   guint8 hash[8];
1685   guint64 bit_num;
1686   guint bytes_num = 0;
1687   guint cnt_1, cnt_2;
1688
1689   guint c = 0;
1690   guint64 p = 0;
1691
1692   bit_num = kdbus->priv->bloom_size * 8;
1693
1694   if (bit_num > 1)
1695     bytes_num = ((__builtin_clzll(bit_num) ^ 63U) + 7) / 8;
1696
1697   for (cnt_1 = 0; cnt_1 < (kdbus->priv->bloom_n_hash); cnt_1++)
1698     {
1699       for (cnt_2 = 0; cnt_2 < bytes_num; cnt_2++)
1700         {
1701           if (c <= 0)
1702             {
1703               g_siphash24(hash, data, n, hash_keys[cnt_1++]);
1704               c += 8;
1705             }
1706
1707           p = (p << 8ULL) | (guint64) hash[8 - c];
1708           c--;
1709         }
1710
1711       p &= bit_num - 1;
1712       bloom_data[p >> 6] |= 1ULL << (p & 63);
1713     }
1714 }
1715
1716
1717 /**
1718  * g_kdbus_bloom_add_pair:
1719  *
1720  */
1721 static void
1722 g_kdbus_bloom_add_pair (GKdbus       *kdbus,
1723                         guint64       bloom_data [],
1724                         const gchar  *parameter,
1725                         const gchar  *value)
1726 {
1727   GString *data = g_string_new (NULL);
1728
1729   g_string_printf (data,"%s:%s",parameter,value);
1730   g_kdbus_bloom_add_data(kdbus, bloom_data, data->str, data->len);
1731   g_string_free (data, TRUE);
1732 }
1733
1734
1735 /**
1736  * g_kdbus_bloom_add_prefixes:
1737  *
1738  */
1739 static void
1740 g_kdbus_bloom_add_prefixes (GKdbus       *kdbus,
1741                             guint64       bloom_data [],
1742                             const gchar  *parameter,
1743                             const gchar  *value,
1744                             gchar         separator)
1745 {
1746   GString *data = g_string_new (NULL);
1747
1748   g_string_printf (data,"%s:%s",parameter,value);
1749
1750   for (;;)
1751     {
1752       gchar *last_sep;
1753       last_sep = strrchr(data->str, separator);
1754       if (!last_sep || last_sep == data->str)
1755         break;
1756
1757       *last_sep = 0;
1758       g_kdbus_bloom_add_data(kdbus, bloom_data, data->str, last_sep-(data->str));
1759     }
1760   g_string_free (data, TRUE);
1761 }
1762
1763
1764 /**
1765  * g_kdbus_setup_bloom:
1766  * Based on bus-bloom.c from systemd
1767  * http://cgit.freedesktop.org/systemd/systemd/tree/src/libsystemd/sd-bus/bus-bloom.c
1768  */
1769 static void
1770 g_kdbus_setup_bloom (GKdbus                     *kdbus,
1771                      GDBusMessage               *dbus_msg,
1772                      struct kdbus_bloom_filter  *bloom_filter)
1773 {
1774   GVariant *body;
1775   GVariantIter iter;
1776   GVariant *child;
1777
1778   const gchar *message_type;
1779   const gchar *interface;
1780   const gchar *member;
1781   const gchar *path;
1782
1783   void *bloom_data;
1784   gint cnt = 0;
1785
1786   body = g_dbus_message_get_body (dbus_msg);
1787   message_type = _g_dbus_enum_to_string (G_TYPE_DBUS_MESSAGE_TYPE, g_dbus_message_get_message_type (dbus_msg));
1788   interface = g_dbus_message_get_interface (dbus_msg);
1789   member = g_dbus_message_get_member (dbus_msg);
1790   path = g_dbus_message_get_path (dbus_msg);
1791
1792   bloom_data = bloom_filter->data;
1793   memset (bloom_data, 0, kdbus->priv->bloom_size);
1794   bloom_filter->generation = 0;
1795
1796   g_kdbus_bloom_add_pair(kdbus, bloom_data, "message-type", message_type);
1797
1798   if (interface)
1799     g_kdbus_bloom_add_pair(kdbus, bloom_data, "interface", interface);
1800
1801   if (member)
1802     g_kdbus_bloom_add_pair(kdbus, bloom_data, "member", member);
1803
1804   if (path)
1805     {
1806       g_kdbus_bloom_add_pair(kdbus, bloom_data, "path", path);
1807       g_kdbus_bloom_add_pair(kdbus, bloom_data, "path-slash-prefix", path);
1808       g_kdbus_bloom_add_prefixes(kdbus, bloom_data, "path-slash-prefix", path, '/');
1809     }
1810
1811   if (body != NULL)
1812     {
1813       g_variant_iter_init (&iter, body);
1814       while ((child = g_variant_iter_next_value (&iter)))
1815         {
1816           gchar buf[sizeof("arg")-1 + 2 + sizeof("-slash-prefix")];
1817           gchar *child_string;
1818           gchar *e;
1819
1820           /* Is it necessary? */
1821           //if (g_variant_is_container (child))
1822           //  iterate_container_recursive (child);
1823
1824           if (!(g_variant_is_of_type (child, G_VARIANT_TYPE_STRING)) &&
1825               !(g_variant_is_of_type (child, G_VARIANT_TYPE_OBJECT_PATH)) &&
1826               !(g_variant_is_of_type (child, G_VARIANT_TYPE_SIGNATURE)))
1827             break;
1828
1829           child_string = g_variant_dup_string (child, NULL);
1830
1831           e = stpcpy(buf, "arg");
1832           if (cnt < 10)
1833             *(e++) = '0' + (char) cnt;
1834           else
1835             {
1836               *(e++) = '0' + (char) (cnt / 10);
1837               *(e++) = '0' + (char) (cnt % 10);
1838             }
1839
1840           *e = 0;
1841           g_kdbus_bloom_add_pair(kdbus, bloom_data, buf, child_string);
1842
1843           strcpy(e, "-dot-prefix");
1844           g_kdbus_bloom_add_prefixes(kdbus, bloom_data, buf, child_string, '.');
1845
1846           strcpy(e, "-slash-prefix");
1847           g_kdbus_bloom_add_prefixes(kdbus, bloom_data, buf, child_string, '/');
1848
1849           g_free (child_string);
1850           g_variant_unref (child);
1851           cnt++;
1852         }
1853     }
1854 }
1855
1856
1857 /*
1858  * TODO: g_kdbus_NameOwnerChanged_generate, g_kdbus_KernelMethodError_generate
1859  */
1860
1861 /**
1862  * g_kdbus_decode_kernel_msg:
1863  *
1864  */
1865 static gssize
1866 g_kdbus_decode_kernel_msg (GKdbus  *kdbus)
1867 {
1868   struct kdbus_item *item = NULL;
1869   gssize size = 0;
1870
1871   KDBUS_ITEM_FOREACH(item, kdbus->priv->kmsg, items)
1872     {
1873      switch (item->type)
1874         {
1875           case KDBUS_ITEM_ID_ADD:
1876           case KDBUS_ITEM_ID_REMOVE:
1877           case KDBUS_ITEM_NAME_ADD:
1878           case KDBUS_ITEM_NAME_REMOVE:
1879           case KDBUS_ITEM_NAME_CHANGE:
1880             //size = g_kdbus_NameOwnerChanged_generate (kdbus, item);
1881             g_error ("'NameOwnerChanged'");
1882             break;
1883
1884           case KDBUS_ITEM_REPLY_TIMEOUT:
1885           case KDBUS_ITEM_REPLY_DEAD:
1886             //size = g_kdbus_KernelMethodError_generate (kdbus, item);
1887             g_error ("'KernelMethodError'");
1888             break;
1889
1890           default:
1891             g_warning ("Unknown field in kernel message - %lld", item->type);
1892        }
1893     }
1894
1895
1896   /* Override information from the user header with data from the kernel */
1897   g_string_printf (kdbus->priv->msg_sender, "org.freedesktop.DBus");
1898
1899   /* for destination */
1900   if (kdbus->priv->kmsg->dst_id == KDBUS_DST_ID_BROADCAST)
1901     /* for broadcast messages we don't have to set destination */
1902     ;
1903   else if (kdbus->priv->kmsg->dst_id == KDBUS_DST_ID_NAME)
1904     g_string_printf (kdbus->priv->msg_destination, ":1.%" G_GUINT64_FORMAT, (guint64) kdbus->priv->unique_id);
1905   else
1906    g_string_printf (kdbus->priv->msg_destination, ":1.%" G_GUINT64_FORMAT, (guint64) kdbus->priv->kmsg->dst_id);
1907
1908   return size;
1909 }
1910
1911
1912 /**
1913  * g_kdbus_decode_dbus_msg:
1914  *
1915  */
1916 static gssize
1917 g_kdbus_decode_dbus_msg (GKdbus  *kdbus)
1918 {
1919   struct kdbus_item *item;
1920   gchar *msg_ptr;
1921   gssize ret_size = 0;
1922   gssize data_size = 0;
1923   const gchar *destination = NULL;
1924
1925   KDBUS_ITEM_FOREACH(item, kdbus->priv->kmsg, items)
1926     {
1927       if (item->size <= KDBUS_ITEM_HEADER_SIZE)
1928         g_error("[KDBUS] %llu bytes - invalid data record\n", item->size);
1929
1930       data_size = item->size - KDBUS_ITEM_HEADER_SIZE;
1931
1932       switch (item->type)
1933         {
1934
1935          /* KDBUS_ITEM_DST_NAME */
1936          case KDBUS_ITEM_DST_NAME:
1937            destination = item->str;
1938            break;
1939
1940         /* KDBUS_ITEM_PALOAD_OFF */
1941         case KDBUS_ITEM_PAYLOAD_OFF:
1942
1943           msg_ptr = (gchar*) kdbus->priv->kmsg + item->vec.offset;
1944           g_kdbus_add_msg_part (kdbus, msg_ptr, item->vec.size);
1945           ret_size += item->vec.size;
1946
1947           break;
1948
1949         /* KDBUS_ITEM_PAYLOAD_MEMFD */
1950         case KDBUS_ITEM_PAYLOAD_MEMFD:
1951
1952           msg_ptr = mmap(NULL, item->memfd.size, PROT_READ, MAP_SHARED, item->memfd.fd, 0);
1953
1954           if (msg_ptr == MAP_FAILED)
1955             {
1956               g_print ("mmap() fd=%i failed:%m", item->memfd.fd);
1957               break;
1958             }
1959
1960           g_kdbus_add_msg_part (kdbus, msg_ptr, item->memfd.size);
1961           ret_size += item->memfd.size;
1962
1963           break;
1964
1965         /* KDBUS_ITEM_FDS */
1966         case KDBUS_ITEM_FDS:
1967
1968           kdbus->priv->num_fds = data_size / sizeof(int);
1969           kdbus->priv->fds = g_malloc0 (sizeof(int) * kdbus->priv->num_fds);
1970           memcpy(kdbus->priv->fds, item->fds, sizeof(int) * kdbus->priv->num_fds);
1971
1972           break;
1973
1974         /* All of the following items, like CMDLINE,
1975            CGROUP, etc. need some GDBUS API extensions and
1976            should be implemented in the future */
1977         case KDBUS_ITEM_CREDS:
1978         case KDBUS_ITEM_TIMESTAMP:
1979         case KDBUS_ITEM_PID_COMM:
1980         case KDBUS_ITEM_TID_COMM:
1981         case KDBUS_ITEM_EXE:
1982         case KDBUS_ITEM_CMDLINE:
1983         case KDBUS_ITEM_CGROUP:
1984         case KDBUS_ITEM_AUDIT:
1985         case KDBUS_ITEM_CAPS:
1986         case KDBUS_ITEM_SECLABEL:
1987         case KDBUS_ITEM_CONN_DESCRIPTION:
1988         case KDBUS_ITEM_AUXGROUPS:
1989         case KDBUS_ITEM_OWNED_NAME:
1990         case KDBUS_ITEM_NAME:
1991           break;
1992
1993         default:
1994           g_error ("[KDBUS] DBUS_PAYLOAD: Unknown filed - %lld", item->type);
1995           break;
1996         }
1997     }
1998
1999   /* Override information from the user header with data from the kernel */
2000
2001   if (kdbus->priv->kmsg->src_id == KDBUS_SRC_ID_KERNEL)
2002     g_string_printf (kdbus->priv->msg_sender, "org.freedesktop.DBus");
2003   else
2004     g_string_printf (kdbus->priv->msg_sender, ":1.%" G_GUINT64_FORMAT, (guint64) kdbus->priv->kmsg->src_id);
2005
2006   if (destination)
2007     g_string_printf (kdbus->priv->msg_destination, "%s", destination);
2008   else if (kdbus->priv->kmsg->dst_id == KDBUS_DST_ID_BROADCAST)
2009     /* for broadcast messages we don't have to set destination */
2010     ;
2011   else if (kdbus->priv->kmsg->dst_id == KDBUS_DST_ID_NAME)
2012     g_string_printf (kdbus->priv->msg_destination, ":1.%" G_GUINT64_FORMAT, (guint64) kdbus->priv->unique_id);
2013   else
2014     g_string_printf (kdbus->priv->msg_destination, ":1.%" G_GUINT64_FORMAT, (guint64) kdbus->priv->kmsg->dst_id);
2015
2016   return ret_size;
2017 }
2018
2019
2020 /**
2021  * _g_kdbus_receive:
2022  *
2023  */
2024 gssize
2025 _g_kdbus_receive (GKdbus        *kdbus,
2026                   GCancellable  *cancellable,
2027                   GError       **error)
2028 {
2029   struct kdbus_cmd_recv recv = {};
2030   gssize size = 0;
2031
2032   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2033     return -1;
2034
2035 again:
2036     if (ioctl(kdbus->priv->fd, KDBUS_CMD_MSG_RECV, &recv) < 0)
2037       {
2038         if (errno == EINTR || errno == EAGAIN)
2039           goto again;
2040
2041         g_set_error (error, G_IO_ERROR,
2042                      g_io_error_from_errno (errno),
2043                      _("Error while receiving message: %s"),
2044                      g_strerror (errno));
2045         return -1;
2046       }
2047
2048    kdbus->priv->kmsg = (struct kdbus_msg *)((guint8 *)kdbus->priv->kdbus_buffer + recv.offset);
2049
2050    if (kdbus->priv->kmsg->payload_type == KDBUS_PAYLOAD_DBUS)
2051      size = g_kdbus_decode_dbus_msg (kdbus);
2052    else if (kdbus->priv->kmsg->payload_type == KDBUS_PAYLOAD_KERNEL)
2053      size = g_kdbus_decode_kernel_msg (kdbus);
2054    else
2055      {
2056        g_set_error (error,
2057                     G_DBUS_ERROR,
2058                     G_DBUS_ERROR_FAILED,
2059                     _("Received unknown payload type"));
2060        return -1;
2061      }
2062
2063    return size;
2064 }
2065
2066
2067 /**
2068  * _g_kdbus_send:
2069  * Returns: size of data sent or -1 when error
2070  */
2071 gsize
2072 _g_kdbus_send (GDBusWorker   *worker,
2073                GKdbus        *kdbus,
2074                GDBusMessage  *dbus_msg,
2075                gchar         *blob,
2076                gsize          blob_size,
2077                GUnixFDList   *fd_list,
2078                GCancellable  *cancellable,
2079                GError       **error)
2080 {
2081   struct kdbus_msg* kmsg;
2082   struct kdbus_item *item;
2083   guint64 kmsg_size = 0;
2084   const gchar *name;
2085   guint64 dst_id = KDBUS_DST_ID_BROADCAST;
2086
2087   g_return_val_if_fail (G_IS_KDBUS (kdbus), -1);
2088
2089   if (g_cancellable_set_error_if_cancelled (cancellable, error))
2090     return -1;
2091
2092   /*
2093    * check destination
2094    */
2095   if ((name = g_dbus_message_get_destination(dbus_msg)))
2096     {
2097       dst_id = KDBUS_DST_ID_NAME;
2098       if ((name[0] == ':') && (name[1] == '1') && (name[2] == '.'))
2099         {
2100           dst_id = strtoull(&name[3], NULL, 10);
2101           name=NULL;
2102         }
2103     }
2104
2105   /*
2106    * check and set message size
2107    */
2108   kmsg_size = sizeof(struct kdbus_msg);
2109   kmsg_size += KDBUS_ITEM_SIZE(sizeof(struct kdbus_vec));   /* header + body */
2110
2111   if (fd_list != NULL && g_unix_fd_list_get_length (fd_list) > 0)
2112     kmsg_size += KDBUS_ALIGN8(G_STRUCT_OFFSET(struct kdbus_item, fds) + sizeof(int) * g_unix_fd_list_get_length(fd_list));
2113
2114   if (name)
2115     kmsg_size += KDBUS_ITEM_SIZE(strlen(name) + 1);
2116   else if (dst_id == KDBUS_DST_ID_BROADCAST)
2117     kmsg_size += KDBUS_ALIGN8(G_STRUCT_OFFSET(struct kdbus_item, bloom_filter) +
2118                         G_STRUCT_OFFSET(struct kdbus_bloom_filter, data) +
2119                         kdbus->priv->bloom_size);
2120
2121   kmsg = malloc(kmsg_size);
2122   if (!kmsg)
2123     g_error ("[KDBUS] kmsg malloc error");
2124
2125
2126   /*
2127    * set message header
2128    */
2129   memset(kmsg, 0, kmsg_size);
2130   kmsg->size = kmsg_size;
2131   kmsg->payload_type = KDBUS_PAYLOAD_DBUS;
2132   kmsg->dst_id = name ? 0 : dst_id;
2133   kmsg->src_id = kdbus->priv->unique_id;
2134   kmsg->cookie = g_dbus_message_get_serial(dbus_msg);
2135   kmsg->priority = 0;
2136
2137
2138   /*
2139    * set message flags
2140    */
2141   kmsg->flags = ((g_dbus_message_get_flags (dbus_msg) & G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED) ? 0 : KDBUS_MSG_FLAGS_EXPECT_REPLY) |
2142                 ((g_dbus_message_get_flags (dbus_msg) & G_DBUS_MESSAGE_FLAGS_NO_AUTO_START) ? KDBUS_MSG_FLAGS_NO_AUTO_START : 0);
2143
2144   if ((kmsg->flags) & KDBUS_MSG_FLAGS_EXPECT_REPLY)
2145     kmsg->timeout_ns = 2000000000;
2146   else
2147     kmsg->cookie_reply = g_dbus_message_get_reply_serial(dbus_msg);
2148
2149
2150   /*
2151    * append payload
2152    */
2153   item = kmsg->items;
2154
2155   /* if we don't use memfd, send whole message as a PAYLOAD_VEC item */
2156   g_kdbus_append_payload_vec (&item, blob, blob_size);
2157
2158
2159   /*
2160    * append destination or bloom filters
2161    */
2162   if (name)
2163     g_kdbus_append_destination (&item, name, strlen(name));
2164   else if (dst_id == KDBUS_DST_ID_BROADCAST)
2165     {
2166       struct kdbus_bloom_filter *bloom_filter;
2167
2168       bloom_filter = g_kdbus_append_bloom (&item, kdbus->priv->bloom_size);
2169       g_kdbus_setup_bloom (kdbus, dbus_msg, bloom_filter);
2170     }
2171
2172   /*
2173    * append fds if any
2174    */
2175   if (fd_list != NULL && g_unix_fd_list_get_length (fd_list) > 0)
2176     g_kdbus_append_fds (&item, fd_list);
2177
2178
2179   /*
2180    * send message
2181    */
2182 //again:
2183   if (ioctl(kdbus->priv->fd, KDBUS_CMD_MSG_SEND, kmsg))
2184     {
2185 /*
2186       GString *error_name;
2187       error_name = g_string_new (NULL);
2188
2189       if(errno == EINTR)
2190         {
2191           g_string_free (error_name,TRUE);
2192           goto again;
2193         }
2194       else if (errno == ENXIO)
2195         {
2196           g_string_printf (error_name, "Name %s does not exist", g_dbus_message_get_destination(dbus_msg));
2197           g_kdbus_generate_local_error (worker,
2198                                         dbus_msg,
2199                                         g_variant_new ("(s)",error_name->str),
2200                                         G_DBUS_ERROR_SERVICE_UNKNOWN);
2201           g_string_free (error_name,TRUE);
2202           return 0;
2203         }
2204       else if ((errno == ESRCH) || (errno == EADDRNOTAVAIL))
2205         {
2206           if (kmsg->flags & KDBUS_MSG_FLAGS_NO_AUTO_START)
2207             {
2208               g_string_printf (error_name, "Name %s does not exist", g_dbus_message_get_destination(dbus_msg));
2209               g_kdbus_generate_local_error (worker,
2210                                             dbus_msg,
2211                                             g_variant_new ("(s)",error_name->str),
2212                                             G_DBUS_ERROR_SERVICE_UNKNOWN);
2213               g_string_free (error_name,TRUE);
2214               return 0;
2215             }
2216           else
2217             {
2218               g_string_printf (error_name, "The name %s was not provided by any .service files", g_dbus_message_get_destination(dbus_msg));
2219               g_kdbus_generate_local_error (worker,
2220                                             dbus_msg,
2221                                             g_variant_new ("(s)",error_name->str),
2222                                             G_DBUS_ERROR_SERVICE_UNKNOWN);
2223               g_string_free (error_name,TRUE);
2224               return 0;
2225             }
2226         }
2227
2228       g_print ("[KDBUS] ioctl error sending kdbus message:%d (%m)\n",errno);
2229       g_set_error (error, G_IO_ERROR, g_io_error_from_errno(errno), _("Error sending message - KDBUS_CMD_MSG_SEND error"));
2230 */
2231       g_error ("IOCTL SEND: %d\n",errno);
2232       return -1;
2233     }
2234
2235   free(kmsg);
2236   return blob_size;
2237 }