gdbus.h 13 KB
Newer Older
1 2 3 4
/*
 *
 *  D-Bus helper library
 *
5
 *  Copyright (C) 2004-2011  Marcel Holtmann <marcel@holtmann.org>
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifndef __GDBUS_H
#define __GDBUS_H

#ifdef __cplusplus
extern "C" {
#endif

#include <dbus/dbus.h>
#include <glib.h>

Lucas De Marchi's avatar
Lucas De Marchi committed
34 35 36 37 38 39 40 41 42 43 44
typedef enum GDBusMethodFlags GDBusMethodFlags;
typedef enum GDBusSignalFlags GDBusSignalFlags;
typedef enum GDBusPropertyFlags GDBusPropertyFlags;
typedef enum GDBusSecurityFlags GDBusSecurityFlags;

typedef struct GDBusArgInfo GDBusArgInfo;
typedef struct GDBusMethodTable GDBusMethodTable;
typedef struct GDBusSignalTable GDBusSignalTable;
typedef struct GDBusPropertyTable GDBusPropertyTable;
typedef struct GDBusSecurityTable GDBusSecurityTable;

45 46 47
typedef void (* GDBusWatchFunction) (DBusConnection *connection,
							void *user_data);

48 49 50
typedef void (* GDBusMessageFunction) (DBusConnection *connection,
					 DBusMessage *message, void *user_data);

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
typedef gboolean (* GDBusSignalFunction) (DBusConnection *connection,
					DBusMessage *message, void *user_data);

DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name,
							DBusError *error);

DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name,
							DBusError *error);

gboolean g_dbus_request_name(DBusConnection *connection, const char *name,
							DBusError *error);

gboolean g_dbus_set_disconnect_function(DBusConnection *connection,
				GDBusWatchFunction function,
				void *user_data, DBusFreeFunction destroy);

typedef void (* GDBusDestroyFunction) (void *user_data);

typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection,
					DBusMessage *message, void *user_data);

72 73 74
typedef gboolean (*GDBusPropertyGetter)(const GDBusPropertyTable *property,
					DBusMessageIter *iter, void *data);

75 76 77 78 79 80
typedef guint32 GDBusPendingPropertySet;

typedef void (*GDBusPropertySetter)(const GDBusPropertyTable *property,
			DBusMessageIter *value, GDBusPendingPropertySet id,
			void *data);

81 82 83
typedef gboolean (*GDBusPropertyExists)(const GDBusPropertyTable *property,
								void *data);

84 85 86 87 88 89 90
typedef guint32 GDBusPendingReply;

typedef void (* GDBusSecurityFunction) (DBusConnection *connection,
						const char *action,
						gboolean interaction,
						GDBusPendingReply pending);

91 92 93 94
enum GDBusFlags {
	G_DBUS_FLAG_ENABLE_EXPERIMENTAL = (1 << 0),
};

Lucas De Marchi's avatar
Lucas De Marchi committed
95
enum GDBusMethodFlags {
96 97 98 99
	G_DBUS_METHOD_FLAG_DEPRECATED   = (1 << 0),
	G_DBUS_METHOD_FLAG_NOREPLY      = (1 << 1),
	G_DBUS_METHOD_FLAG_ASYNC        = (1 << 2),
	G_DBUS_METHOD_FLAG_EXPERIMENTAL = (1 << 3),
Lucas De Marchi's avatar
Lucas De Marchi committed
100
};
101

Lucas De Marchi's avatar
Lucas De Marchi committed
102
enum GDBusSignalFlags {
103 104
	G_DBUS_SIGNAL_FLAG_DEPRECATED   = (1 << 0),
	G_DBUS_SIGNAL_FLAG_EXPERIMENTAL = (1 << 1),
Lucas De Marchi's avatar
Lucas De Marchi committed
105
};
106

Lucas De Marchi's avatar
Lucas De Marchi committed
107
enum GDBusPropertyFlags {
108 109
	G_DBUS_PROPERTY_FLAG_DEPRECATED   = (1 << 0),
	G_DBUS_PROPERTY_FLAG_EXPERIMENTAL = (1 << 1),
Lucas De Marchi's avatar
Lucas De Marchi committed
110
};
111

Lucas De Marchi's avatar
Lucas De Marchi committed
112
enum GDBusSecurityFlags {
113 114 115
	G_DBUS_SECURITY_FLAG_DEPRECATED        = (1 << 0),
	G_DBUS_SECURITY_FLAG_BUILTIN           = (1 << 1),
	G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION = (1 << 2),
Lucas De Marchi's avatar
Lucas De Marchi committed
116
};
117

Lucas De Marchi's avatar
Lucas De Marchi committed
118
struct GDBusArgInfo {
119 120
	const char *name;
	const char *signature;
Lucas De Marchi's avatar
Lucas De Marchi committed
121
};
122

Lucas De Marchi's avatar
Lucas De Marchi committed
123
struct GDBusMethodTable {
124 125 126 127
	const char *name;
	GDBusMethodFunction function;
	GDBusMethodFlags flags;
	unsigned int privilege;
128 129
	const GDBusArgInfo *in_args;
	const GDBusArgInfo *out_args;
Lucas De Marchi's avatar
Lucas De Marchi committed
130
};
131

Lucas De Marchi's avatar
Lucas De Marchi committed
132
struct GDBusSignalTable {
133 134
	const char *name;
	GDBusSignalFlags flags;
135
	const GDBusArgInfo *args;
Lucas De Marchi's avatar
Lucas De Marchi committed
136
};
137

Lucas De Marchi's avatar
Lucas De Marchi committed
138
struct GDBusPropertyTable {
139 140
	const char *name;
	const char *type;
141
	GDBusPropertyGetter get;
142
	GDBusPropertySetter set;
143
	GDBusPropertyExists exists;
144
	GDBusPropertyFlags flags;
Lucas De Marchi's avatar
Lucas De Marchi committed
145
};
146

Lucas De Marchi's avatar
Lucas De Marchi committed
147
struct GDBusSecurityTable {
148 149 150 151
	unsigned int privilege;
	const char *action;
	GDBusSecurityFlags flags;
	GDBusSecurityFunction function;
Lucas De Marchi's avatar
Lucas De Marchi committed
152
};
153

154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
#define GDBUS_ARGS(args...) (const GDBusArgInfo[]) { args, { } }

#define GDBUS_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function

#define GDBUS_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function, \
	.flags = G_DBUS_METHOD_FLAG_ASYNC

#define GDBUS_DEPRECATED_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function, \
	.flags = G_DBUS_METHOD_FLAG_DEPRECATED

#define GDBUS_DEPRECATED_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function, \
	.flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_DEPRECATED

183 184 185 186 187 188 189 190 191 192 193 194 195 196
#define GDBUS_EXPERIMENTAL_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function, \
	.flags = G_DBUS_METHOD_FLAG_EXPERIMENTAL

#define GDBUS_EXPERIMENTAL_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function, \
	.flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_EXPERIMENTAL

197 198 199 200 201 202 203
#define GDBUS_NOREPLY_METHOD(_name, _in_args, _out_args, _function) \
	.name = _name, \
	.in_args = _in_args, \
	.out_args = _out_args, \
	.function = _function, \
	.flags = G_DBUS_METHOD_FLAG_NOREPLY

204 205 206 207 208 209 210 211 212
#define GDBUS_SIGNAL(_name, _args) \
	.name = _name, \
	.args = _args

#define GDBUS_DEPRECATED_SIGNAL(_name, _args) \
	.name = _name, \
	.args = _args, \
	.flags = G_DBUS_SIGNAL_FLAG_DEPRECATED

213 214 215 216 217
#define GDBUS_EXPERIMENTAL_SIGNAL(_name, _args) \
	.name = _name, \
	.args = _args, \
	.flags = G_DBUS_SIGNAL_FLAG_EXPERIMENTAL

218
void g_dbus_set_flags(int flags);
219
int g_dbus_get_flags(void);
220

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
gboolean g_dbus_register_interface(DBusConnection *connection,
					const char *path, const char *name,
					const GDBusMethodTable *methods,
					const GDBusSignalTable *signals,
					const GDBusPropertyTable *properties,
					void *user_data,
					GDBusDestroyFunction destroy);
gboolean g_dbus_unregister_interface(DBusConnection *connection,
					const char *path, const char *name);

gboolean g_dbus_register_security(const GDBusSecurityTable *security);
gboolean g_dbus_unregister_security(const GDBusSecurityTable *security);

void g_dbus_pending_success(DBusConnection *connection,
					GDBusPendingReply pending);
void g_dbus_pending_error(DBusConnection *connection,
				GDBusPendingReply pending,
				const char *name, const char *format, ...)
					__attribute__((format(printf, 4, 5)));
void g_dbus_pending_error_valist(DBusConnection *connection,
				GDBusPendingReply pending, const char *name,
					const char *format, va_list args);

DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name,
						const char *format, ...)
					__attribute__((format(printf, 3, 4)));
DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name,
					const char *format, va_list args);
DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...);
DBusMessage *g_dbus_create_reply_valist(DBusMessage *message,
						int type, va_list args);

gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message);
254 255 256
gboolean g_dbus_send_message_with_reply(DBusConnection *connection,
					DBusMessage *message,
					DBusPendingCall **call, int timeout);
257 258 259 260 261 262
gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message,
				const char *name, const char *format, ...)
					 __attribute__((format(printf, 4, 5)));
gboolean g_dbus_send_error_valist(DBusConnection *connection,
					DBusMessage *message, const char *name,
					const char *format, va_list args);
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286
gboolean g_dbus_send_reply(DBusConnection *connection,
				DBusMessage *message, int type, ...);
gboolean g_dbus_send_reply_valist(DBusConnection *connection,
				DBusMessage *message, int type, va_list args);

gboolean g_dbus_emit_signal(DBusConnection *connection,
				const char *path, const char *interface,
				const char *name, int type, ...);
gboolean g_dbus_emit_signal_valist(DBusConnection *connection,
				const char *path, const char *interface,
				const char *name, int type, va_list args);

guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
				GDBusWatchFunction connect,
				GDBusWatchFunction disconnect,
				void *user_data, GDBusDestroyFunction destroy);
guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
				GDBusWatchFunction function,
				void *user_data, GDBusDestroyFunction destroy);
guint g_dbus_add_signal_watch(DBusConnection *connection,
				const char *sender, const char *path,
				const char *interface, const char *member,
				GDBusSignalFunction function, void *user_data,
				GDBusDestroyFunction destroy);
287 288 289 290 291
guint g_dbus_add_properties_watch(DBusConnection *connection,
				const char *sender, const char *path,
				const char *interface,
				GDBusSignalFunction function, void *user_data,
				GDBusDestroyFunction destroy);
292 293 294
gboolean g_dbus_remove_watch(DBusConnection *connection, guint tag);
void g_dbus_remove_all_watches(DBusConnection *connection);

295 296 297 298 299
void g_dbus_pending_property_success(GDBusPendingPropertySet id);
void g_dbus_pending_property_error_valist(GDBusPendingReply id,
			const char *name, const char *format, va_list args);
void g_dbus_pending_property_error(GDBusPendingReply id, const char *name,
						const char *format, ...);
300 301 302
void g_dbus_emit_property_changed(DBusConnection *connection,
				const char *path, const char *interface,
				const char *name);
303 304
gboolean g_dbus_get_properties(DBusConnection *connection, const char *path,
				const char *interface, DBusMessageIter *iter);
305

306 307 308
gboolean g_dbus_attach_object_manager(DBusConnection *connection);
gboolean g_dbus_detach_object_manager(DBusConnection *connection);

309
typedef struct GDBusClient GDBusClient;
310 311
typedef struct GDBusProxy GDBusProxy;

312 313 314
GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path,
							const char *interface);

315 316 317 318 319 320
GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy);
void g_dbus_proxy_unref(GDBusProxy *proxy);

const char *g_dbus_proxy_get_path(GDBusProxy *proxy);
const char *g_dbus_proxy_get_interface(GDBusProxy *proxy);

321 322 323
gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name,
							DBusMessageIter *iter);

324 325
gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name);

326 327 328 329 330 331 332
typedef void (* GDBusResultFunction) (const DBusError *error, void *user_data);

gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
				const char *name, int type, const void *value,
				GDBusResultFunction function, void *user_data,
				GDBusDestroyFunction destroy);

333 334 335 336 337
gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
				const char *name, int type, const void *value,
				size_t size, GDBusResultFunction function,
				void *user_data, GDBusDestroyFunction destroy);

338 339 340 341 342 343 344 345
typedef void (* GDBusSetupFunction) (DBusMessageIter *iter, void *user_data);
typedef void (* GDBusReturnFunction) (DBusMessage *message, void *user_data);

gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method,
				GDBusSetupFunction setup,
				GDBusReturnFunction function, void *user_data,
				GDBusDestroyFunction destroy);

346
typedef void (* GDBusClientFunction) (GDBusClient *client, void *user_data);
347 348 349 350 351 352 353
typedef void (* GDBusProxyFunction) (GDBusProxy *proxy, void *user_data);
typedef void (* GDBusPropertyFunction) (GDBusProxy *proxy, const char *name,
					DBusMessageIter *iter, void *user_data);

gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy,
			GDBusPropertyFunction function, void *user_data);

354 355 356
gboolean g_dbus_proxy_set_removed_watch(GDBusProxy *proxy,
			GDBusProxyFunction destroy, void *user_data);

357 358
GDBusClient *g_dbus_client_new(DBusConnection *connection,
					const char *service, const char *path);
359 360 361 362
GDBusClient *g_dbus_client_new_full(DBusConnection *connection,
							const char *service,
							const char *path,
							const char *root_path);
363 364 365 366 367 368 369 370 371 372

GDBusClient *g_dbus_client_ref(GDBusClient *client);
void g_dbus_client_unref(GDBusClient *client);

gboolean g_dbus_client_set_connect_watch(GDBusClient *client,
				GDBusWatchFunction function, void *user_data);
gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client,
				GDBusWatchFunction function, void *user_data);
gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
				GDBusMessageFunction function, void *user_data);
373 374
gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
				GDBusClientFunction ready, void *user_data);
375
gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
376 377 378 379
					GDBusProxyFunction proxy_added,
					GDBusProxyFunction proxy_removed,
					GDBusPropertyFunction property_changed,
					void *user_data);
380

381 382 383 384 385
#ifdef __cplusplus
}
#endif

#endif /* __GDBUS_H */