src/libgdbus/dbus-system.h

   1 /*
   2  * libsyscommon
   3  *
   4  * Copyright (c) 2019 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License);
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #ifndef __DBUS_SYSTEM_H__
  20 #define __DBUS_SYSTEM_H__
  21
  22 #include <glib.h>
  23 #include <gio/gio.h>
  24 #include <glib-unix.h>
  25 #include <gio/gunixfdlist.h>
  26 #include <stdarg.h>
  27 #include <assert.h>
  28
  29 #include "dbus-system-iface.h"
  30
  31 typedef struct {
  32         const unsigned char *data;
  33         int size;
  34 } dbus_byte;
  35
  36
  37 typedef void *dbus_handle_h;
  38
  39 typedef void *dbus_object_handle_h;
  40
  41 typedef struct {
  42         const char *member;
  43         const char *signature_in;
  44         const char *signature_out;
  45         GVariant *(*func)       (GDBusConnection *conn,
  46                                 const gchar *sender,
  47                                 const gchar *path,
  48                                 const gchar *iface,
  49                                 const gchar *name,
  50                                 GVariant *param,
  51                                 GDBusMethodInvocation *invocation,
  52                                 gpointer user_data);
  53 } dbus_method_s;
  54
  55 typedef struct {
  56         dbus_object_handle_h oh;
  57         const char *name;
  58         const dbus_method_s *methods;
  59         int nr_methods;
  60 } dbus_interface_u;
  61
  62 typedef struct {
  63         guint   pid;
  64         guint   uid;
  65         gchar  *unique_name;
  66         gchar  *sec_label;
  67 } GDBusCredentials;
  68
  69 #define g_variant_get_safe(gvar, signature, ...) ((g_strcmp0(signature, g_variant_get_type_string(gvar)) == 0) ? g_variant_get(gvar, signature, __VA_ARGS__), TRUE : FALSE)
  70
  71 #define dbus_handle_new_g_variant_tuple() g_variant_new_tuple(NULL, 0)
  72
  73 typedef void (*destroy_notified)(void *data);
  74
  75 typedef void (*dbus_pending_cb)(GVariant *var, void *user_data, GError *err);
  76
  77 typedef struct {
  78         dbus_pending_cb func;
  79         void *data;
  80 } pending_call_data;
  81
  82 dbus_handle_h dbus_handle_get_connection        (GBusType bus_type,
  83                                                 gboolean priv);
  84
  85 int dbus_handle_request_bus_name                (dbus_handle_h handle,
  86                                                 const char *bus_name,
  87                                                 GBusNameAcquiredCallback acquired_handler,
  88                                                 GBusNameLostCallback lost_handler);
  89
  90 int dbus_handle_register_dbus_object            (dbus_handle_h handle,
  91                                                 const char *obj_path,
  92                                                 const dbus_interface_u *iface);
  93
  94 int dbus_handle_unregister_dbus_object          (dbus_handle_h handle,
  95                                                 const char *obj_path);
  96
  97 int dbus_handle_add_dbus_object                 (dbus_handle_h handle,
  98                                                 const char *obj_path,
  99                                                 const dbus_interface_u *iface_u);
 100
 101 int dbus_handle_register_dbus_object_all        (dbus_handle_h handle);
 102
 103
 104 int dbus_handle_method_sync                     (const char *dest,
 105                                                 const char *path,
 106                                                 const char *interface,
 107                                                 const char *method,
 108                                                 const char *sig,
 109                                                 const char *param[]);
 110
 111 int dbus_handle_method_sync_var                 (const char *dest,
 112                                                 const char *path,
 113                                                 const char *iface,
 114                                                 const char *method,
 115                                                 GVariant *param);
 116
 117 int dbus_handle_method_sync_timeout             (const char *dest,
 118                                                 const char *path,
 119                                                 const char *interface,
 120                                                 const char *method,
 121                                                 const char *sig,
 122                                                 const char *param[],
 123                                                 int timeout);
 124
 125 int dbus_handle_method_async                    (const char *dest,
 126                                                 const char *path,
 127                                                 const char *interface,
 128                                                 const char *method,
 129                                                 const char *sig,
 130                                                 const char *param[]);
 131
 132 int dbus_handle_method_async_var                (const char *dest,
 133                                                 const char *path,
 134                                                 const char *iface,
 135                                                 const char *method,
 136                                                 GVariant *param);
 137
 138 int dbus_handle_method_async_with_reply         (const char *dest,
 139                                                 const char *path,
 140                                                 const char *iface,
 141                                                 const char *method,
 142                                                 const char *signature,
 143                                                 const char *param[],
 144                                                 dbus_pending_cb cb,
 145                                                 int timeout_msec,
 146                                                 void *data);
 147
 148 int dbus_handle_method_async_with_reply_var     (const char *dest,
 149                                                 const char *path,
 150                                                 const char *iface,
 151                                                 const char *method,
 152                                                 GVariant *param,
 153                                                 dbus_pending_cb cb,
 154                                                 int timeout_msec,
 155                                                 void *data);
 156
 157 GVariant *dbus_handle_method_sync_with_reply_var                (const char *dest,
 158                                                                 const char *path,
 159                                                                 const char *iface,
 160                                                                 const char *method,
 161                                                                 GVariant *var);
 162
 163 GVariant *dbus_handle_method_sync_with_reply_var_timeout        (const char *dest,
 164                                                                 const char *path,
 165                                                                 const char *iface,
 166                                                                 const char *method,
 167                                                                 GVariant *var,
 168                                                                 int timeout);
 169
 170 gint* dbus_handle_get_unix_fd_list                              (GDBusMethodInvocation *invocation,
 171                                                                 int *size);
 172
 173 GVariant *dbus_handle_method_with_unix_fd_list_sync_with_reply  (const char *dest,
 174                                                                 const char *path,
 175                                                                 const char *iface,
 176                                                                 const char *method,
 177                                                                 const char *signature,
 178                                                                 const char *param[],
 179                                                                 int *in_fdlist,
 180                                                                 int in_size,
 181                                                                 int **out_fdlist,
 182                                                                 int *out_size);
 183
 184 GVariant *dbus_handle_method_with_unix_fd_list_sync_with_reply_var(const char *dest,
 185                                                                 const char *path,
 186                                                                 const char *iface,
 187                                                                 const char *method,
 188                                                                 GVariant *param,
 189                                                                 int *in_fdlist,
 190                                                                 int in_size,
 191                                                                 int **out_fdlist,
 192                                                                 int *out_size);
 193
 194
 195 guint subscribe_dbus_signal                     (dbus_handle_h handle,
 196                                                 const char *path,
 197                                                 const char *iface,
 198                                                 const char *name,
 199                                                 GDBusSignalCallback cb,
 200                                                 void *data,
 201                                                 destroy_notified free_func);
 202
 203 void unsubscribe_dbus_signal                    (dbus_handle_h handle,
 204                                                 guint id);
 205
 206 int dbus_handle_emit_dbus_signal                (const char *dest,
 207                                                 const char *path,
 208                                                 const char *iface,
 209                                                 const char *name,
 210                                                 GVariant *param);
 211
 212 int dbus_handle_emit_dbus_signal_sync(const char *dest,
 213                                         const char *path,
 214                                         const char *iface,
 215                                         const char *name,
 216                                         GVariant *param);
 217
 218 int dbus_handle_flush_sync(dbus_handle_h handle);
 219
 220 enum ctx_quit_reason {CTX_QUIT_UNKNOWN, CTX_QUIT_NORMAL, CTX_QUIT_TIMEOUT};
 221
 222 typedef struct {
 223         guint sig_id;
 224         GMainContext *context;
 225         GMainLoop *loop;
 226         GSource *timeout_src;
 227         GVariant *param;
 228         enum ctx_quit_reason quit_reason;
 229         void *user_data;
 230 } sig_ctx;
 231
 232 sig_ctx *dbus_handle_new_signal_ctx             (void);
 233
 234 void dbus_handle_free_signal_ctx                (sig_ctx *ctx);
 235
 236 guint subscribe_dbus_signal_ctx                 (dbus_handle_h handle,
 237                                                 sig_ctx *ctx,
 238                                                 const char *sender,
 239                                                 const char *path,
 240                                                 const char *iface,
 241                                                 const char *name,
 242                                                 GDBusSignalCallback cb);
 243
 244 int dbus_handle_signal_ctx_wait                 (sig_ctx *ctx);
 245
 246 int dbus_handle_signal_ctx_add_timeout          (sig_ctx *ctx,
 247                                                 int timeout);
 248
 249
 250
 251
 252 int dbus_connection_get_sender_pid              (GDBusConnection *conn,
 253                                                 const char * sender);
 254
 255 int dbus_handle_get_sender_pid                  (dbus_handle_h handle,
 256                                                 const char * sender);
 257
 258 int dbus_handle_get_sender_credentials          (dbus_handle_h handle,
 259                                                 const char *name,
 260                                                 GDBusCredentials *creds);
 261
 262 int dbus_handle_watch_name                      (const char *name,
 263                                                 GBusNameAppearedCallback name_appeared_handler,
 264                                                 GBusNameVanishedCallback name_vanished_handler,
 265                                                 void *user_data,
 266                                                 GDestroyNotify user_data_free_func);
 267
 268 void dbus_handle_unwatch_name                   (guint id);
 269
 270 char** dbus_handle_get_owner_list               (dbus_handle_h handle,
 271                                                 const char *bus_name);
 272
 273 void dbus_handle_check_owner_name               (dbus_handle_h handle,
 274                                                 const char *owner_name);
 275
 276 int check_systemd_active                        (void);
 277
 278 GVariant *dbus_handle_make_simple_array         (const char *sig,
 279                                                 int *param);
 280
 281
 282 #endif