├── .gitignore ├── LICENSE ├── Makefile ├── README ├── dbus-1.pc.in └── dbus ├── dbus-address.c ├── dbus-address.h ├── dbus-bus.c ├── dbus-bus.h ├── dbus-connection.c ├── dbus-connection.h ├── dbus-errors.c ├── dbus-errors.h ├── dbus-macros.h ├── dbus-memory.c ├── dbus-memory.h ├── dbus-message.c ├── dbus-message.h ├── dbus-misc.c ├── dbus-misc.h ├── dbus-pending-call.c ├── dbus-pending-call.h ├── dbus-protocol.h ├── dbus-server.c ├── dbus-server.h ├── dbus-shared.h ├── dbus-signature.c ├── dbus-signature.h ├── dbus-syntax.c ├── dbus-syntax.h ├── dbus-threads.c ├── dbus-threads.h ├── dbus-types.h └── dbus.h /.gitignore: -------------------------------------------------------------------------------- 1 | *.so 2 | *.a 3 | dbus/*.o 4 | dbus-1.pc 5 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2020 Dylan Araps 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | .POSIX: 2 | 3 | PREFIX = /usr/local 4 | LIBDIR = ${PREFIX}/lib 5 | INCLUDEDIR = ${PREFIX}/include 6 | 7 | XCFLAGS = \ 8 | -std=c99 -O3 -DDBUS_COMPILATION -I. \ 9 | -Wall -Wextra -pedantic -Wmissing-prototypes -Wstrict-prototypes \ 10 | -Wno-unused-parameter $(CFLAGS) $(CPPFLAGS) 11 | 12 | OBJ = \ 13 | dbus/dbus-address.o \ 14 | dbus/dbus-bus.o \ 15 | dbus/dbus-connection.o \ 16 | dbus/dbus-errors.o \ 17 | dbus/dbus-memory.o \ 18 | dbus/dbus-message.o \ 19 | dbus/dbus-misc.o \ 20 | dbus/dbus-pending-call.o \ 21 | dbus/dbus-server.o \ 22 | dbus/dbus-signature.o \ 23 | dbus/dbus-syntax.o \ 24 | dbus/dbus-threads.o 25 | 26 | all: libdbus-1.so libdbus-1.a 27 | 28 | .c.o: 29 | $(CC) $(XCFLAGS) -c -o $@ $< 30 | 31 | libdbus-1.so: $(OBJ) 32 | $(CC) $(XCFLAGS) -o $@ $(OBJ) $(LDFLAGS) -shared 33 | 34 | libdbus-1.a: $(OBJ) 35 | $(AR) -rc $@ $(OBJ) 36 | 37 | dbus-1.pc: dbus-1.pc.in 38 | sed \ 39 | -e 's|@libdir@|${LIBDIR}|g' \ 40 | -e 's|@includedir@|${INCLUDEDIR}|g' \ 41 | dbus-1.pc.in > dbus-1.pc 42 | 43 | clean: 44 | rm -f libdbus-1.* $(OBJ) 45 | 46 | install: dbus-1.pc 47 | mkdir -p $(DESTDIR)$(INCLUDEDIR)/dbus-1.0/dbus 48 | mkdir -p $(DESTDIR)$(LIBDIR)/pkgconfig 49 | cp -f dbus/*.h $(DESTDIR)$(INCLUDEDIR)/dbus-1.0/dbus 50 | cp -f libdbus-1.* $(DESTDIR)$(LIBDIR) 51 | cp -f dbus-1.pc $(DESTDIR)$(LIBDIR)/pkgconfig 52 | ln -sf libdbus-1.so $(DESTDIR)$(LIBDIR)/libdbus-1.so.3 53 | 54 | .PHONY: all clean install 55 | -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | dbus stub library for software that depends on dbus but is largely 2 | functional without it. 3 | 4 | TODO: 5 | 6 | - [x] Go through ./symbols and implement stubs for everything. 7 | - [x] Finalize headers for dbus.h. 8 | - [x] Make pkg-config file configurable. 9 | - [ ] Figure out where we want to spoof return values. 10 | - [ ] Figure out what else is missing. 11 | 12 | -------------------------------------------------------------------------------- /dbus-1.pc.in: -------------------------------------------------------------------------------- 1 | original_prefix=/usr 2 | prefix=${original_prefix} 3 | exec_prefix=${prefix} 4 | bindir=${exec_prefix}/bin 5 | libdir=@libdir@ 6 | includedir=@includedir@ 7 | system_bus_default_address=unix:path=/usr/var/run/dbus/system_bus_socket 8 | datarootdir=${prefix}/share 9 | datadir=${datarootdir} 10 | sysconfdir=${prefix}/etc 11 | session_bus_services_dir=${datadir}/dbus-1/services 12 | system_bus_services_dir=${datadir}/dbus-1/system-services 13 | interfaces_dir=${datadir}/dbus-1/interfaces 14 | daemondir=${bindir} 15 | 16 | Name: dbus 17 | Description: Free desktop message bus 18 | Version: 1.13.18 19 | Libs: -L${libdir} -ldbus-1 20 | Libs.private: 21 | Cflags: -I${includedir}/dbus-1.0 -I${libdir}/dbus-1.0/include 22 | -------------------------------------------------------------------------------- /dbus/dbus-address.c: -------------------------------------------------------------------------------- 1 | #include "dbus-address.h" 2 | 3 | dbus_bool_t dbus_parse_address( 4 | const char *address, 5 | DBusAddressEntry ***entry_result, 6 | int *array_len, 7 | DBusError *error 8 | ) { 9 | return TRUE; 10 | } 11 | 12 | const char *dbus_address_entry_get_value( 13 | DBusAddressEntry *entry, 14 | const char *key 15 | ) { 16 | return NULL; 17 | } 18 | 19 | const char *dbus_address_entry_get_method( 20 | DBusAddressEntry *entry 21 | ) { 22 | return NULL; 23 | } 24 | 25 | void dbus_address_entries_free( 26 | DBusAddressEntry **entries 27 | ) { 28 | return; 29 | } 30 | 31 | char* dbus_address_escape_value( 32 | const char *value 33 | ) { 34 | return NULL; 35 | } 36 | 37 | char* dbus_address_unescape_value( 38 | const char *value, 39 | DBusError *error 40 | ) { 41 | error->name = DBUS_ERROR_FAILED; 42 | error->message = "stub"; 43 | 44 | return NULL; // no memory. 45 | } 46 | -------------------------------------------------------------------------------- /dbus/dbus-address.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_ADDRESS_H 6 | #define DBUS_ADDRESS_H 7 | 8 | #include 9 | #include 10 | 11 | #ifdef __cplusplus 12 | extern "C" { 13 | #endif 14 | 15 | typedef struct DBusAddressEntry DBusAddressEntry; 16 | 17 | dbus_bool_t dbus_parse_address( 18 | const char *address, 19 | DBusAddressEntry ***entry_result, 20 | int *array_len, 21 | DBusError *error 22 | ); 23 | 24 | const char *dbus_address_entry_get_value( 25 | DBusAddressEntry *entry, 26 | const char *key 27 | ); 28 | 29 | const char *dbus_address_entry_get_method( 30 | DBusAddressEntry *entry 31 | ); 32 | 33 | void dbus_address_entries_free( 34 | DBusAddressEntry **entries 35 | ); 36 | 37 | char* dbus_address_escape_value( 38 | const char *value 39 | ); 40 | 41 | char* dbus_address_unescape_value( 42 | const char *value, 43 | DBusError *error 44 | ); 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /dbus/dbus-bus.c: -------------------------------------------------------------------------------- 1 | #include "dbus-bus.h" 2 | 3 | DBusConnection *dbus_bus_get( 4 | DBusBusType type, 5 | DBusError *error 6 | ) { 7 | error->name = DBUS_ERROR_FAILED; 8 | error->message = "stub"; 9 | 10 | return NULL; 11 | } 12 | 13 | DBusConnection *dbus_bus_get_private( 14 | DBusBusType type, 15 | DBusError *error 16 | ) { 17 | error->name = DBUS_ERROR_FAILED; 18 | error->message = "stub"; 19 | 20 | return NULL; 21 | } 22 | 23 | dbus_bool_t dbus_bus_register( 24 | DBusConnection *connection, 25 | DBusError *error 26 | ) { 27 | return TRUE; 28 | } 29 | 30 | dbus_bool_t dbus_bus_set_unique_name( 31 | DBusConnection *connection, 32 | const char *unique_name 33 | ) { 34 | return TRUE; 35 | } 36 | 37 | const char* dbus_bus_get_unique_name( 38 | DBusConnection *connection 39 | ) { 40 | return NULL; 41 | } 42 | 43 | unsigned long dbus_bus_get_unix_user( 44 | DBusConnection *connection, 45 | const char *name, 46 | DBusError *error 47 | ) { 48 | error->name = DBUS_ERROR_FAILED; 49 | error->message = "stub"; 50 | 51 | return ((unsigned)-1); 52 | } 53 | 54 | char* dbus_bus_get_id( 55 | DBusConnection *connection, 56 | DBusError *error 57 | ) { 58 | error->name = DBUS_ERROR_FAILED; 59 | error->message = "stub"; 60 | 61 | return NULL; 62 | } 63 | 64 | int dbus_bus_request_name( 65 | DBusConnection *connection, 66 | const char *name, 67 | unsigned int flags, 68 | DBusError *error 69 | ) { 70 | error->name = DBUS_ERROR_FAILED; 71 | error->message = "stub"; 72 | 73 | return -1; 74 | } 75 | 76 | int dbus_bus_release_name( 77 | DBusConnection *connection, 78 | const char *name, 79 | DBusError *error 80 | ) { 81 | error->name = DBUS_ERROR_FAILED; 82 | error->message = "stub"; 83 | 84 | return -1; 85 | } 86 | 87 | dbus_bool_t dbus_bus_name_has_owner( 88 | DBusConnection *connection, 89 | const char *name, 90 | DBusError *error 91 | ) { 92 | return TRUE; 93 | } 94 | 95 | dbus_bool_t dbus_bus_start_service_by_name( 96 | DBusConnection *connection, 97 | const char *name, 98 | uint32_t flags, 99 | uint32_t *reply, 100 | DBusError *error 101 | ) { 102 | return TRUE; 103 | } 104 | 105 | void dbus_bus_add_match( 106 | DBusConnection *connection, 107 | const char *rule, 108 | DBusError *error 109 | ) { 110 | error->name = DBUS_ERROR_FAILED; 111 | error->message = "stub"; 112 | } 113 | 114 | void dbus_bus_remove_match( 115 | DBusConnection *connection, 116 | const char *rule, 117 | DBusError *error 118 | ) { 119 | error->name = DBUS_ERROR_FAILED; 120 | error->message = "stub"; 121 | } 122 | -------------------------------------------------------------------------------- /dbus/dbus-bus.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_BUS_H 6 | #define DBUS_BUS_H 7 | 8 | #include 9 | 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | DBusConnection *dbus_bus_get( 15 | DBusBusType type, 16 | DBusError *error 17 | ); 18 | 19 | DBusConnection *dbus_bus_get_private( 20 | DBusBusType type, 21 | DBusError *error 22 | ); 23 | 24 | dbus_bool_t dbus_bus_register( 25 | DBusConnection *connection, 26 | DBusError *error 27 | ); 28 | 29 | dbus_bool_t dbus_bus_set_unique_name( 30 | DBusConnection *connection, 31 | const char *unique_name 32 | ); 33 | 34 | const char* dbus_bus_get_unique_name( 35 | DBusConnection *connection 36 | ); 37 | 38 | unsigned long dbus_bus_get_unix_user( 39 | DBusConnection *connection, 40 | const char *name, 41 | DBusError *error 42 | ); 43 | 44 | char* dbus_bus_get_id( 45 | DBusConnection *connection, 46 | DBusError *error 47 | ); 48 | 49 | int dbus_bus_request_name( 50 | DBusConnection *connection, 51 | const char *name, 52 | unsigned int flags, 53 | DBusError *error 54 | ); 55 | 56 | int dbus_bus_release_name( 57 | DBusConnection *connection, 58 | const char *name, 59 | DBusError *error 60 | ); 61 | 62 | dbus_bool_t dbus_bus_name_has_owner( 63 | DBusConnection *connection, 64 | const char *name, 65 | DBusError *error 66 | ); 67 | 68 | dbus_bool_t dbus_bus_start_service_by_name( 69 | DBusConnection *connection, 70 | const char *name, 71 | uint32_t flags, 72 | uint32_t *reply, 73 | DBusError *error 74 | ); 75 | 76 | void dbus_bus_add_match( 77 | DBusConnection *connection, 78 | const char *rule, 79 | DBusError *error 80 | ); 81 | 82 | void dbus_bus_remove_match( 83 | DBusConnection *connection, 84 | const char *rule, 85 | DBusError *error 86 | ); 87 | 88 | #ifdef __cplusplus 89 | } 90 | #endif 91 | 92 | #endif 93 | -------------------------------------------------------------------------------- /dbus/dbus-connection.c: -------------------------------------------------------------------------------- 1 | #include "dbus-connection.h" 2 | 3 | DBusConnection *dbus_connection_open( 4 | const char *address, 5 | DBusError *error 6 | ) { 7 | error->name = DBUS_ERROR_FAILED; 8 | error->message = "stub"; 9 | 10 | return NULL; 11 | } 12 | 13 | DBusConnection* dbus_connection_open_private( 14 | const char *address, 15 | DBusError *error 16 | ) { 17 | error->name = DBUS_ERROR_FAILED; 18 | error->message = "stub"; 19 | 20 | return NULL; 21 | } 22 | 23 | DBusConnection* dbus_connection_ref( 24 | DBusConnection *connection 25 | ) { 26 | return connection; 27 | } 28 | 29 | void dbus_connection_unref( 30 | DBusConnection *connection 31 | ) { 32 | 33 | } 34 | 35 | void dbus_connection_close( 36 | DBusConnection *connection 37 | ) { 38 | 39 | } 40 | 41 | dbus_bool_t dbus_connection_get_is_connected( 42 | DBusConnection *connection 43 | ) { 44 | return TRUE; 45 | } 46 | 47 | dbus_bool_t dbus_connection_get_is_authenticated( 48 | DBusConnection *connection 49 | ) { 50 | return TRUE; 51 | } 52 | 53 | dbus_bool_t dbus_connection_get_is_anonymous( 54 | DBusConnection *connection 55 | ) { 56 | return TRUE; 57 | } 58 | 59 | char* dbus_connection_get_server_id( 60 | DBusConnection *connection 61 | ) { 62 | return "org_freedesktop_general"; 63 | } 64 | 65 | dbus_bool_t dbus_connection_can_send_type( 66 | DBusConnection *connection, 67 | int type 68 | ) { 69 | return TRUE; 70 | } 71 | 72 | void dbus_connection_set_exit_on_disconnect( 73 | DBusConnection *connection, 74 | dbus_bool_t exit_on_disconnect 75 | ) { 76 | 77 | } 78 | 79 | void dbus_connection_flush( 80 | DBusConnection *connection 81 | ) { 82 | 83 | } 84 | 85 | dbus_bool_t dbus_connection_read_write_dispatch( 86 | DBusConnection *connection, 87 | int timeout_milliseconds 88 | ) { 89 | return TRUE; 90 | } 91 | 92 | dbus_bool_t dbus_connection_read_write( 93 | DBusConnection *connection, 94 | int timeout_milliseconds 95 | ) { 96 | return TRUE; 97 | } 98 | 99 | DBusMessage* dbus_connection_borrow_message( 100 | DBusConnection *connection 101 | ) { 102 | return NULL; 103 | } 104 | 105 | void dbus_connection_return_message( 106 | DBusConnection *connection, 107 | DBusMessage *message 108 | ) { 109 | 110 | } 111 | 112 | void dbus_connection_steal_borrowed_message( 113 | DBusConnection *connection, 114 | DBusMessage *message 115 | ) { 116 | 117 | } 118 | 119 | DBusMessage* dbus_connection_pop_message( 120 | DBusConnection *connection 121 | ) { 122 | return NULL; 123 | } 124 | 125 | DBusDispatchStatus dbus_connection_get_dispatch_status( 126 | DBusConnection *connection 127 | ) { 128 | return DBUS_DISPATCH_COMPLETE; 129 | } 130 | 131 | DBusDispatchStatus dbus_connection_dispatch( 132 | DBusConnection *connection 133 | ) { 134 | return DBUS_DISPATCH_COMPLETE; 135 | } 136 | 137 | dbus_bool_t dbus_connection_has_messages_to_send( 138 | DBusConnection *connection 139 | ) { 140 | return TRUE; 141 | } 142 | 143 | dbus_bool_t dbus_connection_send( 144 | DBusConnection *connection, 145 | DBusMessage *message, 146 | dbus_uint32_t *client_serial 147 | ) { 148 | return TRUE; /* TRUE? */ 149 | } 150 | 151 | dbus_bool_t dbus_connection_send_with_reply( 152 | DBusConnection *connection, 153 | DBusMessage *message, 154 | DBusPendingCall **pending_return, 155 | int timeout_milliseconds 156 | ) { 157 | return TRUE; /* TRUE? */ 158 | } 159 | 160 | DBusMessage *dbus_connection_send_with_reply_and_block( 161 | DBusConnection *connection, 162 | DBusMessage *message, 163 | int timeout_milliseconds, 164 | DBusError *error 165 | ) { 166 | error->name = DBUS_ERROR_FAILED; 167 | error->message = "stub"; 168 | 169 | return NULL; 170 | } 171 | 172 | dbus_bool_t dbus_connection_set_watch_functions( 173 | DBusConnection *connection, 174 | DBusAddWatchFunction add_function, 175 | DBusRemoveWatchFunction remove_function, 176 | DBusWatchToggledFunction toggled_function, 177 | void *data, 178 | DBusFreeFunction free_data_function 179 | ) { 180 | return TRUE; 181 | } 182 | 183 | dbus_bool_t dbus_connection_set_timeout_functions( 184 | DBusConnection *connection, 185 | DBusAddTimeoutFunction add_function, 186 | DBusRemoveTimeoutFunction remove_function, 187 | DBusTimeoutToggledFunction toggled_function, 188 | void *data, 189 | DBusFreeFunction free_data_function 190 | ) { 191 | return TRUE; 192 | } 193 | 194 | void dbus_connection_set_wakeup_main_function( 195 | DBusConnection *connection, 196 | DBusWakeupMainFunction wakeup_main_function, 197 | void *data, 198 | DBusFreeFunction free_data_function 199 | ) { 200 | 201 | } 202 | 203 | void dbus_connection_set_dispatch_status_function( 204 | DBusConnection *connection, 205 | DBusDispatchStatusFunction function, 206 | void *data, 207 | DBusFreeFunction free_data_function 208 | ) { 209 | 210 | } 211 | 212 | dbus_bool_t dbus_connection_get_unix_user( 213 | DBusConnection *connection, 214 | unsigned long *uid 215 | ) { 216 | return TRUE; 217 | } 218 | 219 | dbus_bool_t dbus_connection_get_unix_process_id( 220 | DBusConnection *connection, 221 | unsigned long *pid 222 | ) { 223 | return TRUE; 224 | } 225 | 226 | dbus_bool_t dbus_connection_get_adt_audit_session_data( 227 | DBusConnection *connection, 228 | void **data, 229 | dbus_int32_t *data_size 230 | ) { 231 | return TRUE; 232 | } 233 | 234 | void dbus_connection_set_unix_user_function( 235 | DBusConnection *connection, 236 | DBusAllowUnixUserFunction function, 237 | void *data, 238 | DBusFreeFunction free_data_function 239 | ) { 240 | 241 | } 242 | 243 | dbus_bool_t dbus_connection_get_windows_user( 244 | DBusConnection *connection, 245 | char **windows_sid_p 246 | ) { 247 | return TRUE; 248 | } 249 | 250 | void dbus_connection_set_windows_user_function( 251 | DBusConnection *connection, 252 | DBusAllowWindowsUserFunction function, 253 | void *data, 254 | DBusFreeFunction free_data_function 255 | ) { 256 | 257 | } 258 | 259 | void dbus_connection_set_allow_anonymous( 260 | DBusConnection *connection, 261 | dbus_bool_t value 262 | ) { 263 | 264 | } 265 | 266 | void dbus_connection_set_route_peer_messages( 267 | DBusConnection *connection, 268 | dbus_bool_t value 269 | ) { 270 | 271 | } 272 | 273 | dbus_bool_t dbus_connection_add_filter( 274 | DBusConnection *connection, 275 | DBusHandleMessageFunction function, 276 | void *user_data, 277 | DBusFreeFunction free_data_function 278 | ) { 279 | return TRUE; 280 | } 281 | 282 | void dbus_connection_remove_filter( 283 | DBusConnection *connection, 284 | DBusHandleMessageFunction function, 285 | void *user_data 286 | ) { 287 | 288 | } 289 | 290 | dbus_bool_t dbus_connection_allocate_data_slot( 291 | dbus_int32_t *slot_p 292 | ) { 293 | return TRUE; 294 | } 295 | 296 | void dbus_connection_free_data_slot( 297 | dbus_int32_t *slot_p 298 | ) { 299 | 300 | } 301 | 302 | dbus_bool_t dbus_connection_set_data( 303 | DBusConnection *connection, 304 | dbus_int32_t slot, 305 | void *data, 306 | DBusFreeFunction free_data_func 307 | ) { 308 | return TRUE; 309 | } 310 | 311 | void* dbus_connection_get_data( 312 | DBusConnection *connection, 313 | dbus_int32_t slot 314 | ) { 315 | return NULL; 316 | } 317 | 318 | void dbus_connection_set_change_sigpipe( 319 | dbus_bool_t will_modify_sigpipe 320 | ) { 321 | 322 | } 323 | 324 | void dbus_connection_set_max_message_size( 325 | DBusConnection *connection, 326 | long size 327 | ) { 328 | 329 | } 330 | 331 | long dbus_connection_get_max_message_size( 332 | DBusConnection *connection 333 | ) { 334 | return 0; 335 | } 336 | 337 | void dbus_connection_set_max_received_size( 338 | DBusConnection *connection, 339 | long size 340 | ) { 341 | 342 | } 343 | 344 | long dbus_connection_get_max_received_size( 345 | DBusConnection *connection 346 | ) { 347 | return 0; 348 | } 349 | 350 | void dbus_connection_set_max_message_unix_fds( 351 | DBusConnection *connection, 352 | long n 353 | ) { 354 | 355 | } 356 | 357 | long dbus_connection_get_max_message_unix_fds( 358 | DBusConnection *connection 359 | ) { 360 | return 0; 361 | } 362 | 363 | void dbus_connection_set_max_received_unix_fds( 364 | DBusConnection *connection, 365 | long n 366 | ) { 367 | 368 | } 369 | 370 | long dbus_connection_get_max_received_unix_fds( 371 | DBusConnection *connection 372 | ) { 373 | return 0; 374 | } 375 | 376 | long dbus_connection_get_outgoing_size( 377 | DBusConnection *connection 378 | ) { 379 | return 0; 380 | } 381 | 382 | long dbus_connection_get_outgoing_unix_fds( 383 | DBusConnection *connection 384 | ) { 385 | return 0; 386 | } 387 | 388 | DBusPreallocatedSend* dbus_connection_preallocate_send( 389 | DBusConnection *connection 390 | ) { 391 | return NULL; 392 | } 393 | 394 | void dbus_connection_free_preallocated_send( 395 | DBusConnection *connection, 396 | DBusPreallocatedSend *preallocated 397 | ) { 398 | 399 | } 400 | 401 | void dbus_connection_send_preallocated( 402 | DBusConnection *connection, 403 | DBusPreallocatedSend *preallocated, 404 | DBusMessage *message, 405 | dbus_uint32_t *client_serial 406 | ) { 407 | 408 | } 409 | 410 | dbus_bool_t dbus_connection_try_register_object_path( 411 | DBusConnection *connection, 412 | const char *path, 413 | const DBusObjectPathVTable *vtable, 414 | void *user_data, 415 | DBusError *error 416 | ) { 417 | return TRUE; 418 | } 419 | 420 | dbus_bool_t dbus_connection_register_object_path( 421 | DBusConnection *connection, 422 | const char *path, 423 | const DBusObjectPathVTable *vtable, 424 | void *user_data 425 | ) { 426 | return TRUE; 427 | } 428 | 429 | dbus_bool_t dbus_connection_try_register_fallback( 430 | DBusConnection *connection, 431 | const char *path, 432 | const DBusObjectPathVTable *vtable, 433 | void *user_data, 434 | DBusError *error 435 | ) { 436 | return TRUE; 437 | } 438 | 439 | dbus_bool_t dbus_connection_register_fallback( 440 | DBusConnection *connection, 441 | const char *path, 442 | const DBusObjectPathVTable *vtable, 443 | void *user_data 444 | ) { 445 | return TRUE; 446 | } 447 | 448 | dbus_bool_t dbus_connection_unregister_object_path( 449 | DBusConnection *connection, 450 | const char *path 451 | ) { 452 | return TRUE; 453 | } 454 | 455 | dbus_bool_t dbus_connection_get_object_path_data( 456 | DBusConnection *connection, 457 | const char *path, 458 | void **data_p 459 | ) { 460 | return TRUE; 461 | } 462 | 463 | dbus_bool_t dbus_connection_list_registered( 464 | DBusConnection *connection, 465 | const char *parent_path, 466 | char ***child_entries 467 | ) { 468 | return TRUE; 469 | } 470 | 471 | dbus_bool_t dbus_connection_get_unix_fd( 472 | DBusConnection *connection, 473 | int *fd 474 | ) { 475 | return TRUE; 476 | } 477 | 478 | dbus_bool_t dbus_connection_get_socket( 479 | DBusConnection *connection, 480 | int *fd 481 | ) { 482 | return TRUE; 483 | } 484 | 485 | int dbus_watch_get_unix_fd( 486 | DBusWatch *watch 487 | ) { 488 | return -1; 489 | } 490 | 491 | int dbus_watch_get_socket( 492 | DBusWatch *watch 493 | ) { 494 | return -1; 495 | } 496 | 497 | unsigned int dbus_watch_get_flags( 498 | DBusWatch *watch 499 | ) { 500 | return 0; 501 | } 502 | 503 | void* dbus_watch_get_data( 504 | DBusWatch *watch 505 | ) { 506 | return NULL; 507 | } 508 | 509 | void dbus_watch_set_data( 510 | DBusWatch *watch, 511 | void *data, 512 | DBusFreeFunction free_data_function 513 | ) { 514 | 515 | } 516 | 517 | dbus_bool_t dbus_watch_handle( 518 | DBusWatch *watch, 519 | unsigned int flags 520 | ) { 521 | return TRUE; 522 | } 523 | 524 | dbus_bool_t dbus_watch_get_enabled( 525 | DBusWatch *watch 526 | ) { 527 | return TRUE; 528 | } 529 | 530 | int dbus_timeout_get_interval( 531 | DBusTimeout *timeout 532 | ) { 533 | return 0; 534 | } 535 | 536 | void* dbus_timeout_get_data( 537 | DBusTimeout *timeout 538 | ) { 539 | return NULL; 540 | } 541 | 542 | void dbus_timeout_set_data( 543 | DBusTimeout *timeout, 544 | void *data, 545 | DBusFreeFunction free_data_function 546 | ) { 547 | 548 | } 549 | 550 | dbus_bool_t dbus_timeout_handle( 551 | DBusTimeout *timeout 552 | ) { 553 | return TRUE; 554 | } 555 | 556 | dbus_bool_t dbus_timeout_get_enabled( 557 | DBusTimeout *timeout 558 | ) { 559 | return TRUE; 560 | } 561 | 562 | -------------------------------------------------------------------------------- /dbus/dbus-connection.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_CONNECTION_H 6 | #define DBUS_CONNECTION_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | typedef enum { 19 | DBUS_WATCH_READABLE = 1 << 0, 20 | DBUS_WATCH_WRITABLE = 1 << 1, 21 | DBUS_WATCH_ERROR = 1 << 2, 22 | DBUS_WATCH_HANGUP = 1 << 3 23 | } DBusWatchFlags; 24 | 25 | typedef enum { 26 | DBUS_DISPATCH_DATA_REMAINS, 27 | DBUS_DISPATCH_COMPLETE, 28 | DBUS_DISPATCH_NEED_MEMORY 29 | } DBusDispatchStatus; 30 | 31 | typedef struct DBusWatch DBusWatch; 32 | typedef struct DBusTimeout DBusTimeout; 33 | typedef struct DBusPreallocatedSend DBusPreallocatedSend; 34 | typedef struct DBusPendingCall DBusPendingCall; 35 | typedef struct DBusConnection DBusConnection; 36 | typedef struct DBusObjectPathVTable DBusObjectPathVTable; 37 | 38 | typedef void (* DBusObjectPathUnregisterFunction) ( 39 | DBusConnection *connection, 40 | void *user_data 41 | ); 42 | 43 | typedef DBusHandlerResult (* DBusObjectPathMessageFunction) ( 44 | DBusConnection *connection, 45 | DBusMessage *message, 46 | void *user_data 47 | ); 48 | 49 | struct DBusObjectPathVTable { 50 | DBusObjectPathUnregisterFunction unregister_function; 51 | DBusObjectPathMessageFunction message_function; 52 | void (* dbus_internal_pad1) (void *); 53 | void (* dbus_internal_pad2) (void *); 54 | void (* dbus_internal_pad3) (void *); 55 | void (* dbus_internal_pad4) (void *); 56 | }; 57 | 58 | typedef dbus_bool_t (* DBusAddWatchFunction) ( 59 | DBusWatch *watch, 60 | void *data 61 | ); 62 | 63 | typedef void (* DBusWatchToggledFunction) ( 64 | DBusWatch *watch, 65 | void *data 66 | ); 67 | 68 | typedef void (* DBusRemoveWatchFunction) ( 69 | DBusWatch *watch, 70 | void *data 71 | ); 72 | 73 | typedef dbus_bool_t (* DBusAddTimeoutFunction) ( 74 | DBusTimeout *timeout, 75 | void *data 76 | ); 77 | 78 | typedef void (* DBusTimeoutToggledFunction) ( 79 | DBusTimeout *timeout, 80 | void *data 81 | ); 82 | 83 | typedef void (* DBusRemoveTimeoutFunction) ( 84 | DBusTimeout *timeout, 85 | void *data 86 | ); 87 | 88 | typedef void (* DBusDispatchStatusFunction) ( 89 | DBusConnection *connection, 90 | DBusDispatchStatus new_status, 91 | void *data 92 | ); 93 | 94 | typedef void (* DBusWakeupMainFunction) ( 95 | void *data 96 | ); 97 | 98 | typedef dbus_bool_t (* DBusAllowUnixUserFunction) ( 99 | DBusConnection *connection, 100 | unsigned long uid, 101 | void *data 102 | ); 103 | 104 | typedef dbus_bool_t (* DBusAllowWindowsUserFunction) ( 105 | DBusConnection *connection, 106 | const char *user_sid, 107 | void *data 108 | ); 109 | 110 | typedef void (* DBusPendingCallNotifyFunction) ( 111 | DBusPendingCall *pending, 112 | void *user_data 113 | ); 114 | 115 | typedef DBusHandlerResult (* DBusHandleMessageFunction) ( 116 | DBusConnection *connection, 117 | DBusMessage *message, 118 | void *user_data 119 | ); 120 | 121 | DBusConnection *dbus_connection_open( 122 | const char *address, 123 | DBusError *error 124 | ); 125 | 126 | DBusConnection* dbus_connection_open_private( 127 | const char *address, 128 | DBusError *error 129 | ); 130 | 131 | DBusConnection* dbus_connection_ref( 132 | DBusConnection *connection 133 | ); 134 | 135 | void dbus_connection_unref( 136 | DBusConnection *connection 137 | ); 138 | 139 | void dbus_connection_close( 140 | DBusConnection *connection 141 | ); 142 | 143 | dbus_bool_t dbus_connection_get_is_connected( 144 | DBusConnection *connection 145 | ); 146 | 147 | dbus_bool_t dbus_connection_get_is_authenticated( 148 | DBusConnection *connection 149 | ); 150 | 151 | dbus_bool_t dbus_connection_get_is_anonymous( 152 | DBusConnection *connection 153 | ); 154 | 155 | char* dbus_connection_get_server_id( 156 | DBusConnection *connection 157 | ); 158 | 159 | dbus_bool_t dbus_connection_can_send_type( 160 | DBusConnection *connection, 161 | int type 162 | ); 163 | 164 | void dbus_connection_set_exit_on_disconnect( 165 | DBusConnection *connection, 166 | dbus_bool_t exit_on_disconnect 167 | ); 168 | 169 | void dbus_connection_flush( 170 | DBusConnection *connection 171 | ); 172 | 173 | dbus_bool_t dbus_connection_read_write_dispatch( 174 | DBusConnection *connection, 175 | int timeout_milliseconds 176 | ); 177 | 178 | dbus_bool_t dbus_connection_read_write( 179 | DBusConnection *connection, 180 | int timeout_milliseconds 181 | ); 182 | 183 | DBusMessage* dbus_connection_borrow_message( 184 | DBusConnection *connection 185 | ); 186 | 187 | void dbus_connection_return_message( 188 | DBusConnection *connection, 189 | DBusMessage *message 190 | ); 191 | 192 | void dbus_connection_steal_borrowed_message( 193 | DBusConnection *connection, 194 | DBusMessage *message 195 | ); 196 | 197 | DBusMessage* dbus_connection_pop_message( 198 | DBusConnection *connection 199 | ); 200 | 201 | DBusDispatchStatus dbus_connection_get_dispatch_status( 202 | DBusConnection *connection 203 | ); 204 | 205 | DBusDispatchStatus dbus_connection_dispatch( 206 | DBusConnection *connection 207 | ); 208 | 209 | dbus_bool_t dbus_connection_has_messages_to_send( 210 | DBusConnection *connection 211 | ); 212 | 213 | dbus_bool_t dbus_connection_send( 214 | DBusConnection *connection, 215 | DBusMessage *message, 216 | dbus_uint32_t *client_serial 217 | ); 218 | 219 | dbus_bool_t dbus_connection_send_with_reply( 220 | DBusConnection *connection, 221 | DBusMessage *message, 222 | DBusPendingCall **pending_return, 223 | int timeout_milliseconds 224 | ); 225 | 226 | DBusMessage *dbus_connection_send_with_reply_and_block( 227 | DBusConnection *connection, 228 | DBusMessage *message, 229 | int timeout_milliseconds, 230 | DBusError *error 231 | ); 232 | 233 | dbus_bool_t dbus_connection_set_watch_functions( 234 | DBusConnection *connection, 235 | DBusAddWatchFunction add_function, 236 | DBusRemoveWatchFunction remove_function, 237 | DBusWatchToggledFunction toggled_function, 238 | void *data, 239 | DBusFreeFunction free_data_function 240 | ); 241 | 242 | dbus_bool_t dbus_connection_set_timeout_functions( 243 | DBusConnection *connection, 244 | DBusAddTimeoutFunction add_function, 245 | DBusRemoveTimeoutFunction remove_function, 246 | DBusTimeoutToggledFunction toggled_function, 247 | void *data, 248 | DBusFreeFunction free_data_function 249 | ); 250 | 251 | void dbus_connection_set_wakeup_main_function( 252 | DBusConnection *connection, 253 | DBusWakeupMainFunction wakeup_main_function, 254 | void *data, 255 | DBusFreeFunction free_data_function 256 | ); 257 | 258 | void dbus_connection_set_dispatch_status_function( 259 | DBusConnection *connection, 260 | DBusDispatchStatusFunction function, 261 | void *data, 262 | DBusFreeFunction free_data_function 263 | ); 264 | 265 | dbus_bool_t dbus_connection_get_unix_user( 266 | DBusConnection *connection, 267 | unsigned long *uid 268 | ); 269 | 270 | dbus_bool_t dbus_connection_get_unix_process_id( 271 | DBusConnection *connection, 272 | unsigned long *pid 273 | ); 274 | 275 | dbus_bool_t dbus_connection_get_adt_audit_session_data( 276 | DBusConnection *connection, 277 | void **data, 278 | dbus_int32_t *data_size 279 | ); 280 | 281 | void dbus_connection_set_unix_user_function( 282 | DBusConnection *connection, 283 | DBusAllowUnixUserFunction function, 284 | void *data, 285 | DBusFreeFunction free_data_function 286 | ); 287 | 288 | dbus_bool_t dbus_connection_get_windows_user( 289 | DBusConnection *connection, 290 | char **windows_sid_p 291 | ); 292 | 293 | void dbus_connection_set_windows_user_function( 294 | DBusConnection *connection, 295 | DBusAllowWindowsUserFunction function, 296 | void *data, 297 | DBusFreeFunction free_data_function 298 | ); 299 | 300 | void dbus_connection_set_allow_anonymous( 301 | DBusConnection *connection, 302 | dbus_bool_t value 303 | ); 304 | 305 | void dbus_connection_set_route_peer_messages( 306 | DBusConnection *connection, 307 | dbus_bool_t value 308 | ); 309 | 310 | dbus_bool_t dbus_connection_add_filter( 311 | DBusConnection *connection, 312 | DBusHandleMessageFunction function, 313 | void *user_data, 314 | DBusFreeFunction free_data_function 315 | ); 316 | 317 | void dbus_connection_remove_filter( 318 | DBusConnection *connection, 319 | DBusHandleMessageFunction function, 320 | void *user_data 321 | ); 322 | 323 | dbus_bool_t dbus_connection_allocate_data_slot( 324 | dbus_int32_t *slot_p 325 | ); 326 | 327 | void dbus_connection_free_data_slot( 328 | dbus_int32_t *slot_p 329 | ); 330 | 331 | dbus_bool_t dbus_connection_set_data( 332 | DBusConnection *connection, 333 | dbus_int32_t slot, 334 | void *data, 335 | DBusFreeFunction free_data_func 336 | ); 337 | 338 | void* dbus_connection_get_data( 339 | DBusConnection *connection, 340 | dbus_int32_t slot 341 | ); 342 | 343 | void dbus_connection_set_change_sigpipe( 344 | dbus_bool_t will_modify_sigpipe 345 | ); 346 | 347 | void dbus_connection_set_max_message_size( 348 | DBusConnection *connection, 349 | long size 350 | ); 351 | 352 | long dbus_connection_get_max_message_size( 353 | DBusConnection *connection 354 | ); 355 | 356 | void dbus_connection_set_max_received_size( 357 | DBusConnection *connection, 358 | long size 359 | ); 360 | 361 | long dbus_connection_get_max_received_size( 362 | DBusConnection *connection 363 | ); 364 | 365 | void dbus_connection_set_max_message_unix_fds( 366 | DBusConnection *connection, 367 | long n 368 | ); 369 | 370 | long dbus_connection_get_max_message_unix_fds( 371 | DBusConnection *connection 372 | ); 373 | 374 | void dbus_connection_set_max_received_unix_fds( 375 | DBusConnection *connection, 376 | long n 377 | ); 378 | 379 | long dbus_connection_get_max_received_unix_fds( 380 | DBusConnection *connection 381 | ); 382 | 383 | long dbus_connection_get_outgoing_size( 384 | DBusConnection *connection 385 | ); 386 | 387 | long dbus_connection_get_outgoing_unix_fds( 388 | DBusConnection *connection 389 | ); 390 | 391 | DBusPreallocatedSend* dbus_connection_preallocate_send( 392 | DBusConnection *connection 393 | ); 394 | 395 | void dbus_connection_free_preallocated_send( 396 | DBusConnection *connection, 397 | DBusPreallocatedSend *preallocated 398 | ); 399 | 400 | void dbus_connection_send_preallocated( 401 | DBusConnection *connection, 402 | DBusPreallocatedSend *preallocated, 403 | DBusMessage *message, 404 | dbus_uint32_t *client_serial 405 | ); 406 | 407 | dbus_bool_t dbus_connection_try_register_object_path( 408 | DBusConnection *connection, 409 | const char *path, 410 | const DBusObjectPathVTable *vtable, 411 | void *user_data, 412 | DBusError *error 413 | ); 414 | 415 | dbus_bool_t dbus_connection_register_object_path( 416 | DBusConnection *connection, 417 | const char *path, 418 | const DBusObjectPathVTable *vtable, 419 | void *user_data 420 | ); 421 | 422 | dbus_bool_t dbus_connection_try_register_fallback( 423 | DBusConnection *connection, 424 | const char *path, 425 | const DBusObjectPathVTable *vtable, 426 | void *user_data, 427 | DBusError *error 428 | ); 429 | 430 | dbus_bool_t dbus_connection_register_fallback( 431 | DBusConnection *connection, 432 | const char *path, 433 | const DBusObjectPathVTable *vtable, 434 | void *user_data 435 | ); 436 | 437 | dbus_bool_t dbus_connection_unregister_object_path( 438 | DBusConnection *connection, 439 | const char *path 440 | ); 441 | 442 | dbus_bool_t dbus_connection_get_object_path_data( 443 | DBusConnection *connection, 444 | const char *path, 445 | void **data_p 446 | ); 447 | 448 | dbus_bool_t dbus_connection_list_registered( 449 | DBusConnection *connection, 450 | const char *parent_path, 451 | char ***child_entries 452 | ); 453 | 454 | dbus_bool_t dbus_connection_get_unix_fd( 455 | DBusConnection *connection, 456 | int *fd 457 | ); 458 | 459 | dbus_bool_t dbus_connection_get_socket( 460 | DBusConnection *connection, 461 | int *fd 462 | ); 463 | 464 | int dbus_watch_get_unix_fd( 465 | DBusWatch *watch 466 | ); 467 | 468 | int dbus_watch_get_socket( 469 | DBusWatch *watch 470 | ); 471 | 472 | unsigned int dbus_watch_get_flags( 473 | DBusWatch *watch 474 | ); 475 | 476 | void* dbus_watch_get_data( 477 | DBusWatch *watch 478 | ); 479 | 480 | void dbus_watch_set_data( 481 | DBusWatch *watch, 482 | void *data, 483 | DBusFreeFunction free_data_function 484 | ); 485 | 486 | dbus_bool_t dbus_watch_handle( 487 | DBusWatch *watch, 488 | unsigned int flags 489 | ); 490 | 491 | dbus_bool_t dbus_watch_get_enabled( 492 | DBusWatch *watch 493 | ); 494 | 495 | int dbus_timeout_get_interval( 496 | DBusTimeout *timeout 497 | ); 498 | 499 | void* dbus_timeout_get_data( 500 | DBusTimeout *timeout 501 | ); 502 | 503 | void dbus_timeout_set_data( 504 | DBusTimeout *timeout, 505 | void *data, 506 | DBusFreeFunction free_data_function 507 | ); 508 | 509 | dbus_bool_t dbus_timeout_handle( 510 | DBusTimeout *timeout 511 | ); 512 | 513 | dbus_bool_t dbus_timeout_get_enabled( 514 | DBusTimeout *timeout 515 | ); 516 | 517 | #ifdef __cplusplus 518 | } 519 | #endif 520 | 521 | #endif 522 | -------------------------------------------------------------------------------- /dbus/dbus-errors.c: -------------------------------------------------------------------------------- 1 | #include "dbus-errors.h" 2 | 3 | void dbus_error_init( 4 | DBusError *error 5 | ) { 6 | 7 | } 8 | 9 | void dbus_error_free( 10 | DBusError *error 11 | ) { 12 | 13 | } 14 | 15 | void dbus_set_error( 16 | DBusError *error, 17 | const char *name, 18 | const char *message, 19 | ... 20 | ) { 21 | 22 | } 23 | 24 | void dbus_set_error_const( 25 | DBusError *error, 26 | const char *name, 27 | const char *message 28 | ) { 29 | 30 | } 31 | 32 | void dbus_move_error( 33 | DBusError *src, 34 | DBusError *dest 35 | ) { 36 | 37 | } 38 | 39 | dbus_bool_t dbus_error_has_name( 40 | const DBusError *error, 41 | const char *name 42 | ) { 43 | return FALSE; 44 | } 45 | 46 | dbus_bool_t dbus_error_is_set( 47 | const DBusError *error 48 | ) { 49 | return FALSE; 50 | } 51 | -------------------------------------------------------------------------------- /dbus/dbus-errors.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_ERROR_H 6 | #define DBUS_ERROR_H 7 | 8 | #include "dbus-macros.h" 9 | #include "dbus-types.h" 10 | #include "dbus-protocol.h" 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | typedef struct DBusError DBusError; 17 | 18 | struct DBusError { 19 | const char *name; 20 | const char *message; 21 | unsigned int dummy1 : 1; 22 | unsigned int dummy2 : 1; 23 | unsigned int dummy3 : 1; 24 | unsigned int dummy4 : 1; 25 | unsigned int dummy5 : 1; 26 | void *padding1; 27 | }; 28 | 29 | #define DBUS_ERROR_INIT { NULL, NULL, TRUE, 0, 0, 0, 0, NULL } 30 | 31 | void dbus_error_init( 32 | DBusError *error 33 | ); 34 | 35 | void dbus_error_free( 36 | DBusError *error 37 | ); 38 | 39 | void dbus_set_error( 40 | DBusError *error, 41 | const char *name, 42 | const char *message, 43 | ... 44 | ); 45 | 46 | void dbus_set_error_const( 47 | DBusError *error, 48 | const char *name, 49 | const char *message 50 | ); 51 | 52 | void dbus_move_error( 53 | DBusError *src, 54 | DBusError *dest 55 | ); 56 | 57 | dbus_bool_t dbus_error_has_name( 58 | const DBusError *error, 59 | const char *name 60 | ); 61 | 62 | dbus_bool_t dbus_error_is_set( 63 | const DBusError *error 64 | ); 65 | 66 | #ifdef __cplusplus 67 | } 68 | #endif 69 | 70 | #endif 71 | -------------------------------------------------------------------------------- /dbus/dbus-macros.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_MACROS_H 6 | #define DBUS_MACROS_H 7 | 8 | #ifndef TRUE 9 | # define TRUE 1 10 | #endif 11 | 12 | #ifndef FALSE 13 | # define FALSE 0 14 | #endif 15 | 16 | #ifndef NULL 17 | # ifdef __cplusplus 18 | # define NULL (0L) 19 | # else 20 | # define NULL ((void*) 0) 21 | # endif 22 | #endif 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /dbus/dbus-memory.c: -------------------------------------------------------------------------------- 1 | #include "dbus-memory.h" 2 | 3 | void* dbus_malloc( 4 | size_t bytes 5 | ) { 6 | return NULL; 7 | } 8 | 9 | void* dbus_malloc0( 10 | size_t bytes 11 | ) { 12 | return NULL; 13 | } 14 | 15 | void* dbus_realloc( 16 | void *memory, 17 | size_t bytes 18 | ) { 19 | return NULL; 20 | } 21 | 22 | void dbus_free( 23 | void *memory 24 | ) { 25 | 26 | } 27 | 28 | void dbus_free_string_array( 29 | char **str_array 30 | ) { 31 | 32 | } 33 | 34 | void dbus_shutdown( 35 | void 36 | ) { 37 | 38 | } 39 | 40 | 41 | -------------------------------------------------------------------------------- /dbus/dbus-memory.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_MEMORY_H 6 | #define DBUS_MEMORY_H 7 | 8 | #include 9 | #include 10 | 11 | #ifdef __cplusplus 12 | extern "C" { 13 | #endif 14 | 15 | typedef void(* DBusFreeFunction)(void *memory); 16 | 17 | // TODO: __attribute__ malloc? 18 | void* dbus_malloc( 19 | size_t bytes 20 | ); 21 | 22 | // TODO: __attribute__ malloc? 23 | // TODO: alloc size? 24 | void* dbus_malloc0( 25 | size_t bytes 26 | ); 27 | 28 | // TODO: alloc size? 29 | void* dbus_realloc( 30 | void *memory, 31 | size_t bytes 32 | ); 33 | 34 | void dbus_free( 35 | void *memory 36 | ); 37 | 38 | #define dbus_new(type, count) ((type*)dbus_malloc (sizeof (type) * (count))) 39 | #define dbus_new0(type, count) ((type*)dbus_malloc0 (sizeof (type) * (count))) 40 | 41 | void dbus_free_string_array( 42 | char **str_array 43 | ); 44 | 45 | void dbus_shutdown( 46 | void 47 | ); 48 | 49 | #ifdef __cplusplus 50 | } 51 | #endif 52 | 53 | #endif 54 | -------------------------------------------------------------------------------- /dbus/dbus-message.c: -------------------------------------------------------------------------------- 1 | #include "dbus-message.h" 2 | 3 | DBusMessage* dbus_message_new( 4 | int message_type 5 | ) { 6 | return NULL; 7 | } 8 | 9 | DBusMessage* dbus_message_new_method_call( 10 | const char *bus_name, 11 | const char *path, 12 | const char *iface, 13 | const char *method 14 | ) { 15 | return NULL; 16 | } 17 | 18 | DBusMessage* dbus_message_new_method_return( 19 | DBusMessage *method_call 20 | ) { 21 | return NULL; 22 | } 23 | 24 | DBusMessage* dbus_message_new_signal( 25 | const char *path, 26 | const char *iface, 27 | const char *name 28 | ) { 29 | return NULL; 30 | } 31 | 32 | DBusMessage* dbus_message_new_error( 33 | DBusMessage *reply_to, 34 | const char *error_name, 35 | const char *error_message 36 | ) { 37 | return NULL; 38 | } 39 | 40 | DBusMessage* dbus_message_new_error_printf( 41 | DBusMessage *reply_to, 42 | const char *error_name, 43 | const char *error_format, 44 | ... 45 | ) { 46 | return NULL; 47 | } 48 | 49 | DBusMessage* dbus_message_copy( 50 | const DBusMessage *message 51 | ) { 52 | return NULL; 53 | } 54 | 55 | DBusMessage* dbus_message_ref( 56 | DBusMessage *message 57 | ) { 58 | return NULL; 59 | } 60 | 61 | void dbus_message_unref( 62 | DBusMessage *message 63 | ) { 64 | 65 | } 66 | 67 | int dbus_message_get_type( 68 | DBusMessage *message 69 | ) { 70 | return DBUS_MESSAGE_TYPE_INVALID; 71 | } 72 | 73 | dbus_bool_t dbus_message_set_path( 74 | DBusMessage *message, 75 | const char *object_path 76 | ) { 77 | return TRUE; 78 | } 79 | 80 | const char* dbus_message_get_path( 81 | DBusMessage *message 82 | ) { 83 | return NULL; 84 | } 85 | 86 | dbus_bool_t dbus_message_has_path( 87 | DBusMessage *message, 88 | const char *object_path 89 | ) { 90 | return TRUE; 91 | } 92 | 93 | dbus_bool_t dbus_message_set_interface( 94 | DBusMessage *message, 95 | const char *iface 96 | ) { 97 | return TRUE; 98 | } 99 | 100 | const char* dbus_message_get_interface( 101 | DBusMessage *message 102 | ) { 103 | return NULL; 104 | } 105 | 106 | dbus_bool_t dbus_message_has_interface( 107 | DBusMessage *message, 108 | const char *iface 109 | ) { 110 | return TRUE; 111 | } 112 | 113 | dbus_bool_t dbus_message_set_member( 114 | DBusMessage *message, 115 | const char *member 116 | ) { 117 | return TRUE; 118 | } 119 | 120 | const char* dbus_message_get_member( 121 | DBusMessage *message 122 | ) { 123 | return NULL; 124 | } 125 | 126 | dbus_bool_t dbus_message_has_member( 127 | DBusMessage *message, 128 | const char *member 129 | ) { 130 | return TRUE; 131 | } 132 | 133 | dbus_bool_t dbus_message_set_error_name( 134 | DBusMessage *message, 135 | const char *name 136 | ) { 137 | return TRUE; 138 | } 139 | 140 | const char* dbus_message_get_error_name( 141 | DBusMessage *message 142 | ) { 143 | return NULL; 144 | } 145 | 146 | dbus_bool_t dbus_message_set_destination( 147 | DBusMessage *message, 148 | const char *destination 149 | ) { 150 | return TRUE; 151 | } 152 | 153 | const char* dbus_message_get_destination( 154 | DBusMessage *message 155 | ) { 156 | return NULL; 157 | } 158 | 159 | dbus_bool_t dbus_message_set_sender( 160 | DBusMessage *message, 161 | const char *sender 162 | ) { 163 | return TRUE; 164 | } 165 | 166 | const char* dbus_message_get_sender( 167 | DBusMessage *message 168 | ) { 169 | return NULL; 170 | } 171 | 172 | const char* dbus_message_get_signature( 173 | DBusMessage *message 174 | ) { 175 | return NULL; 176 | } 177 | 178 | void dbus_message_set_no_reply( 179 | DBusMessage *message, 180 | dbus_bool_t no_reply 181 | ) { 182 | 183 | } 184 | 185 | dbus_bool_t dbus_message_get_no_reply( 186 | DBusMessage *message 187 | ) { 188 | return TRUE; 189 | } 190 | 191 | dbus_bool_t dbus_message_is_method_call( 192 | DBusMessage *message, 193 | const char *iface, 194 | const char *method 195 | ) { 196 | return TRUE; 197 | } 198 | 199 | dbus_bool_t dbus_message_is_signal( 200 | DBusMessage *message, 201 | const char *iface, 202 | const char *signal_name 203 | ) { 204 | return TRUE; 205 | } 206 | 207 | dbus_bool_t dbus_message_is_error( 208 | DBusMessage *message, 209 | const char *error_name 210 | ) { 211 | return TRUE; 212 | } 213 | 214 | dbus_bool_t dbus_message_has_destination( 215 | DBusMessage *message, 216 | const char *bus_name 217 | ) { 218 | return TRUE; 219 | } 220 | 221 | dbus_bool_t dbus_message_has_sender( 222 | DBusMessage *message, 223 | const char *unique_bus_name 224 | ) { 225 | return TRUE; 226 | } 227 | 228 | dbus_bool_t dbus_message_has_signature( 229 | DBusMessage *message, 230 | const char *signature 231 | ) { 232 | return TRUE; 233 | } 234 | 235 | dbus_uint32_t dbus_message_get_serial( 236 | DBusMessage *message 237 | ) { 238 | return 0; 239 | } 240 | 241 | void dbus_message_set_serial( 242 | DBusMessage *message, 243 | dbus_uint32_t serial 244 | ) { 245 | 246 | } 247 | 248 | dbus_bool_t dbus_message_set_reply_serial( 249 | DBusMessage *message, 250 | dbus_uint32_t reply_serial 251 | ) { 252 | return TRUE; 253 | } 254 | 255 | dbus_uint32_t dbus_message_get_reply_serial( 256 | DBusMessage *message 257 | ) { 258 | return 0; 259 | } 260 | 261 | void dbus_message_set_auto_start( 262 | DBusMessage *message, 263 | dbus_bool_t auto_start 264 | ); 265 | 266 | dbus_bool_t dbus_message_get_auto_start( 267 | DBusMessage *message 268 | ) { 269 | return TRUE; 270 | } 271 | 272 | dbus_bool_t dbus_message_get_path_decomposed( 273 | DBusMessage *message, 274 | char ***path 275 | ) { 276 | return TRUE; 277 | } 278 | 279 | const char *dbus_message_get_container_instance( 280 | DBusMessage *message 281 | ) { 282 | return NULL; 283 | } 284 | 285 | dbus_bool_t dbus_message_set_container_instance( 286 | DBusMessage *message, 287 | const char *object_path 288 | ) { 289 | return TRUE; 290 | } 291 | 292 | dbus_bool_t dbus_message_append_args( 293 | DBusMessage *message, 294 | int first_arg_type, 295 | ... 296 | ) { 297 | return TRUE; 298 | } 299 | 300 | dbus_bool_t dbus_message_append_args_valist( 301 | DBusMessage *message, 302 | int first_arg_type, 303 | va_list var_args 304 | ) { 305 | return TRUE; 306 | } 307 | 308 | dbus_bool_t dbus_message_get_args( 309 | DBusMessage *message, 310 | DBusError *error, 311 | int first_arg_type, 312 | ... 313 | ) { 314 | return TRUE; 315 | } 316 | 317 | dbus_bool_t dbus_message_get_args_valist( 318 | DBusMessage *message, 319 | DBusError *error, 320 | int first_arg_type, 321 | va_list var_args 322 | ) { 323 | return TRUE; 324 | } 325 | 326 | dbus_bool_t dbus_message_contains_unix_fds( 327 | DBusMessage *message 328 | ) { 329 | return TRUE; 330 | } 331 | 332 | void dbus_message_iter_init_closed( 333 | DBusMessageIter *iter 334 | ) { 335 | 336 | } 337 | 338 | dbus_bool_t dbus_message_iter_init( 339 | DBusMessage *message, 340 | DBusMessageIter *iter 341 | ) { 342 | return TRUE; 343 | } 344 | 345 | dbus_bool_t dbus_message_iter_has_next( 346 | DBusMessageIter *iter 347 | ) { 348 | return TRUE; 349 | } 350 | 351 | dbus_bool_t dbus_message_iter_next( 352 | DBusMessageIter *iter 353 | ) { 354 | return TRUE; 355 | } 356 | 357 | char* dbus_message_iter_get_signature( 358 | DBusMessageIter *iter 359 | ) { 360 | return NULL; 361 | } 362 | 363 | int dbus_message_iter_get_arg_type( 364 | DBusMessageIter *iter 365 | ) { 366 | return DBUS_TYPE_INVALID; 367 | } 368 | 369 | int dbus_message_iter_get_element_type( 370 | DBusMessageIter *iter 371 | ) { 372 | return DBUS_TYPE_INVALID; 373 | } 374 | 375 | void dbus_message_iter_recurse( 376 | DBusMessageIter *iter, 377 | DBusMessageIter *sub 378 | ) { 379 | 380 | } 381 | 382 | void dbus_message_iter_get_basic( 383 | DBusMessageIter *iter, 384 | void *value 385 | ) { 386 | 387 | } 388 | 389 | int dbus_message_iter_get_element_count( 390 | DBusMessageIter *iter 391 | ) { 392 | return 0; 393 | } 394 | 395 | void dbus_message_iter_get_fixed_array( 396 | DBusMessageIter *iter, 397 | void *value, 398 | int *n_elements 399 | ) { 400 | 401 | } 402 | 403 | void dbus_message_iter_init_append( 404 | DBusMessage *message, 405 | DBusMessageIter *iter 406 | ) { 407 | 408 | } 409 | 410 | dbus_bool_t dbus_message_iter_append_basic( 411 | DBusMessageIter *iter, 412 | int type, 413 | const void *value 414 | ) { 415 | return TRUE; 416 | } 417 | 418 | dbus_bool_t dbus_message_iter_append_fixed_array( 419 | DBusMessageIter *iter, 420 | int element_type, 421 | const void *value, 422 | int n_elements 423 | ) { 424 | return TRUE; 425 | } 426 | 427 | dbus_bool_t dbus_message_iter_open_container( 428 | DBusMessageIter *iter, 429 | int type, 430 | const char *contained_signature, 431 | DBusMessageIter *sub 432 | ) { 433 | return TRUE; 434 | } 435 | 436 | dbus_bool_t dbus_message_iter_close_container( 437 | DBusMessageIter *iter, 438 | DBusMessageIter *sub 439 | ) { 440 | return TRUE; 441 | } 442 | 443 | void dbus_message_iter_abandon_container( 444 | DBusMessageIter *iter, 445 | DBusMessageIter *sub 446 | ) { 447 | 448 | } 449 | 450 | void dbus_message_iter_abandon_container_if_open( 451 | DBusMessageIter *iter, 452 | DBusMessageIter *sub 453 | ) { 454 | 455 | } 456 | 457 | void dbus_message_lock( 458 | DBusMessage *message 459 | ) { 460 | 461 | } 462 | 463 | dbus_bool_t dbus_set_error_from_message( 464 | DBusError *error, 465 | DBusMessage *message 466 | ) { 467 | return TRUE; 468 | } 469 | 470 | dbus_bool_t dbus_message_allocate_data_slot( 471 | dbus_int32_t *slot_p 472 | ) { 473 | return TRUE; 474 | } 475 | 476 | void dbus_message_free_data_slot( 477 | dbus_int32_t *slot_p 478 | ) { 479 | 480 | } 481 | 482 | dbus_bool_t dbus_message_set_data( 483 | DBusMessage *message, 484 | dbus_int32_t slot, 485 | void *data, 486 | DBusFreeFunction free_data_func 487 | ) { 488 | return TRUE; 489 | } 490 | 491 | void* dbus_message_get_data( 492 | DBusMessage *message, 493 | dbus_int32_t slot 494 | ) { 495 | return NULL; 496 | } 497 | 498 | int dbus_message_type_from_string( 499 | const char *type_str 500 | ) { 501 | return DBUS_MESSAGE_TYPE_INVALID; 502 | } 503 | 504 | const char* dbus_message_type_to_string( 505 | int type 506 | ) { 507 | return NULL; 508 | } 509 | 510 | dbus_bool_t dbus_message_marshal( 511 | DBusMessage *msg, 512 | char **marshalled_data_p, 513 | int *len_p 514 | ) { 515 | return TRUE; 516 | } 517 | 518 | DBusMessage* dbus_message_demarshal( 519 | const char *str, 520 | int len, 521 | DBusError *error 522 | ) { 523 | error->name = DBUS_ERROR_FAILED; 524 | error->message = "stub"; 525 | 526 | return NULL; 527 | } 528 | 529 | int dbus_message_demarshal_bytes_needed( 530 | const char *str, 531 | int len 532 | ) { 533 | return 0; 534 | } 535 | 536 | void dbus_message_set_allow_interactive_authorization( 537 | DBusMessage *message, 538 | dbus_bool_t allow 539 | ) { 540 | 541 | } 542 | 543 | dbus_bool_t dbus_message_get_allow_interactive_authorization( 544 | DBusMessage *message 545 | ) { 546 | return TRUE; 547 | } 548 | -------------------------------------------------------------------------------- /dbus/dbus-message.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_MESSAGE_H 6 | #define DBUS_MESSAGE_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #ifdef __cplusplus 16 | extern "C" { 17 | #endif 18 | 19 | typedef struct DBusMessage DBusMessage; 20 | typedef struct DBusMessageIter DBusMessageIter; 21 | 22 | struct DBusMessageIter { 23 | void *dummy1; 24 | void *dummy2; 25 | dbus_uint32_t dummy3; 26 | int dummy4; 27 | int dummy5; 28 | int dummy6; 29 | int dummy7; 30 | int dummy8; 31 | int dummy9; 32 | int dummy10; 33 | int dummy11; 34 | int pad1; 35 | void *pad2; 36 | void *pad3; 37 | }; 38 | 39 | #define DBUS_MESSAGE_ITER_INIT_CLOSED { \ 40 | NULL, /* dummy1 */ \ 41 | NULL, /* dummy2 */ \ 42 | 0, /* dummy3 */ \ 43 | 0, /* dummy4 */ \ 44 | 0, /* dummy5 */ \ 45 | 0, /* dummy6 */ \ 46 | 0, /* dummy7 */ \ 47 | 0, /* dummy8 */ \ 48 | 0, /* dummy9 */ \ 49 | 0, /* dummy10 */ \ 50 | 0, /* dummy11 */ \ 51 | 0, /* pad1 */ \ 52 | NULL, /* pad2 */ \ 53 | NULL /* pad3 */ \ 54 | } 55 | 56 | DBusMessage* dbus_message_new( 57 | int message_type 58 | ); 59 | 60 | DBusMessage* dbus_message_new_method_call( 61 | const char *bus_name, 62 | const char *path, 63 | const char *iface, 64 | const char *method 65 | ); 66 | 67 | DBusMessage* dbus_message_new_method_return( 68 | DBusMessage *method_call 69 | ); 70 | 71 | DBusMessage* dbus_message_new_signal( 72 | const char *path, 73 | const char *iface, 74 | const char *name 75 | ); 76 | 77 | DBusMessage* dbus_message_new_error( 78 | DBusMessage *reply_to, 79 | const char *error_name, 80 | const char *error_message 81 | ); 82 | 83 | DBusMessage* dbus_message_new_error_printf( 84 | DBusMessage *reply_to, 85 | const char *error_name, 86 | const char *error_format, 87 | ... 88 | ); 89 | 90 | DBusMessage* dbus_message_copy( 91 | const DBusMessage *message 92 | ); 93 | 94 | DBusMessage* dbus_message_ref( 95 | DBusMessage *message 96 | ); 97 | 98 | void dbus_message_unref( 99 | DBusMessage *message 100 | ); 101 | 102 | int dbus_message_get_type( 103 | DBusMessage *message 104 | ); 105 | 106 | dbus_bool_t dbus_message_set_path( 107 | DBusMessage *message, 108 | const char *object_path 109 | ); 110 | 111 | const char* dbus_message_get_path( 112 | DBusMessage *message 113 | ); 114 | 115 | dbus_bool_t dbus_message_has_path( 116 | DBusMessage *message, 117 | const char *object_path 118 | ); 119 | 120 | dbus_bool_t dbus_message_set_interface( 121 | DBusMessage *message, 122 | const char *iface 123 | ); 124 | 125 | const char* dbus_message_get_interface( 126 | DBusMessage *message 127 | ); 128 | 129 | dbus_bool_t dbus_message_has_interface( 130 | DBusMessage *message, 131 | const char *iface 132 | ); 133 | 134 | dbus_bool_t dbus_message_set_member( 135 | DBusMessage *message, 136 | const char *member 137 | ); 138 | 139 | const char* dbus_message_get_member( 140 | DBusMessage *message 141 | ); 142 | 143 | dbus_bool_t dbus_message_has_member( 144 | DBusMessage *message, 145 | const char *member 146 | ); 147 | 148 | dbus_bool_t dbus_message_set_error_name( 149 | DBusMessage *message, 150 | const char *name 151 | ); 152 | 153 | const char* dbus_message_get_error_name( 154 | DBusMessage *message 155 | ); 156 | 157 | dbus_bool_t dbus_message_set_destination( 158 | DBusMessage *message, 159 | const char *destination 160 | ); 161 | 162 | const char* dbus_message_get_destination( 163 | DBusMessage *message 164 | ); 165 | 166 | dbus_bool_t dbus_message_set_sender( 167 | DBusMessage *message, 168 | const char *sender 169 | ); 170 | 171 | const char* dbus_message_get_sender( 172 | DBusMessage *message 173 | ); 174 | 175 | const char* dbus_message_get_signature( 176 | DBusMessage *message 177 | ); 178 | 179 | void dbus_message_set_no_reply( 180 | DBusMessage *message, 181 | dbus_bool_t no_reply 182 | ); 183 | 184 | dbus_bool_t dbus_message_get_no_reply( 185 | DBusMessage *message 186 | ); 187 | 188 | dbus_bool_t dbus_message_is_method_call( 189 | DBusMessage *message, 190 | const char *iface, 191 | const char *method 192 | ); 193 | 194 | dbus_bool_t dbus_message_is_signal( 195 | DBusMessage *message, 196 | const char *iface, 197 | const char *signal_name 198 | ); 199 | 200 | dbus_bool_t dbus_message_is_error( 201 | DBusMessage *message, 202 | const char *error_name 203 | ); 204 | 205 | dbus_bool_t dbus_message_has_destination( 206 | DBusMessage *message, 207 | const char *bus_name 208 | ); 209 | 210 | dbus_bool_t dbus_message_has_sender( 211 | DBusMessage *message, 212 | const char *unique_bus_name 213 | ); 214 | 215 | dbus_bool_t dbus_message_has_signature( 216 | DBusMessage *message, 217 | const char *signature 218 | ); 219 | 220 | dbus_uint32_t dbus_message_get_serial( 221 | DBusMessage *message 222 | ); 223 | 224 | void dbus_message_set_serial( 225 | DBusMessage *message, 226 | dbus_uint32_t serial 227 | ); 228 | 229 | dbus_bool_t dbus_message_set_reply_serial( 230 | DBusMessage *message, 231 | dbus_uint32_t reply_serial 232 | ); 233 | 234 | dbus_uint32_t dbus_message_get_reply_serial( 235 | DBusMessage *message 236 | ); 237 | 238 | void dbus_message_set_auto_start( 239 | DBusMessage *message, 240 | dbus_bool_t auto_start 241 | ); 242 | 243 | dbus_bool_t dbus_message_get_auto_start( 244 | DBusMessage *message 245 | ); 246 | 247 | dbus_bool_t dbus_message_get_path_decomposed( 248 | DBusMessage *message, 249 | char ***path 250 | ); 251 | 252 | const char *dbus_message_get_container_instance( 253 | DBusMessage *message 254 | ); 255 | 256 | dbus_bool_t dbus_message_set_container_instance( 257 | DBusMessage *message, 258 | const char *object_path 259 | ); 260 | 261 | dbus_bool_t dbus_message_append_args( 262 | DBusMessage *message, 263 | int first_arg_type, 264 | ... 265 | ); 266 | 267 | dbus_bool_t dbus_message_append_args_valist( 268 | DBusMessage *message, 269 | int first_arg_type, 270 | va_list var_args 271 | ); 272 | 273 | dbus_bool_t dbus_message_get_args( 274 | DBusMessage *message, 275 | DBusError *error, 276 | int first_arg_type, 277 | ... 278 | ); 279 | 280 | dbus_bool_t dbus_message_get_args_valist( 281 | DBusMessage *message, 282 | DBusError *error, 283 | int first_arg_type, 284 | va_list var_args 285 | ); 286 | 287 | dbus_bool_t dbus_message_contains_unix_fds( 288 | DBusMessage *message 289 | ); 290 | 291 | void dbus_message_iter_init_closed( 292 | DBusMessageIter *iter 293 | ); 294 | 295 | dbus_bool_t dbus_message_iter_init( 296 | DBusMessage *message, 297 | DBusMessageIter *iter 298 | ); 299 | 300 | dbus_bool_t dbus_message_iter_has_next( 301 | DBusMessageIter *iter 302 | ); 303 | 304 | dbus_bool_t dbus_message_iter_next( 305 | DBusMessageIter *iter 306 | ); 307 | 308 | char* dbus_message_iter_get_signature( 309 | DBusMessageIter *iter 310 | ); 311 | 312 | int dbus_message_iter_get_arg_type( 313 | DBusMessageIter *iter 314 | ); 315 | 316 | int dbus_message_iter_get_element_type( 317 | DBusMessageIter *iter 318 | ); 319 | 320 | void dbus_message_iter_recurse( 321 | DBusMessageIter *iter, 322 | DBusMessageIter *sub 323 | ); 324 | 325 | void dbus_message_iter_get_basic( 326 | DBusMessageIter *iter, 327 | void *value 328 | ); 329 | 330 | int dbus_message_iter_get_element_count( 331 | DBusMessageIter *iter 332 | ); 333 | 334 | 335 | void dbus_message_iter_get_fixed_array( 336 | DBusMessageIter *iter, 337 | void *value, 338 | int *n_elements 339 | ); 340 | 341 | void dbus_message_iter_init_append( 342 | DBusMessage *message, 343 | DBusMessageIter *iter 344 | ); 345 | 346 | dbus_bool_t dbus_message_iter_append_basic( 347 | DBusMessageIter *iter, 348 | int type, 349 | const void *value 350 | ); 351 | 352 | dbus_bool_t dbus_message_iter_append_fixed_array( 353 | DBusMessageIter *iter, 354 | int element_type, 355 | const void *value, 356 | int n_elements 357 | ); 358 | 359 | dbus_bool_t dbus_message_iter_open_container( 360 | DBusMessageIter *iter, 361 | int type, 362 | const char *contained_signature, 363 | DBusMessageIter *sub 364 | ); 365 | 366 | dbus_bool_t dbus_message_iter_close_container( 367 | DBusMessageIter *iter, 368 | DBusMessageIter *sub 369 | ); 370 | 371 | void dbus_message_iter_abandon_container( 372 | DBusMessageIter *iter, 373 | DBusMessageIter *sub 374 | ); 375 | 376 | void dbus_message_iter_abandon_container_if_open( 377 | DBusMessageIter *iter, 378 | DBusMessageIter *sub 379 | ); 380 | 381 | void dbus_message_lock( 382 | DBusMessage *message 383 | ); 384 | 385 | dbus_bool_t dbus_set_error_from_message( 386 | DBusError *error, 387 | DBusMessage *message 388 | ); 389 | 390 | dbus_bool_t dbus_message_allocate_data_slot( 391 | dbus_int32_t *slot_p 392 | ); 393 | 394 | void dbus_message_free_data_slot( 395 | dbus_int32_t *slot_p 396 | ); 397 | 398 | dbus_bool_t dbus_message_set_data( 399 | DBusMessage *message, 400 | dbus_int32_t slot, 401 | void *data, 402 | DBusFreeFunction free_data_func 403 | ); 404 | 405 | void* dbus_message_get_data( 406 | DBusMessage *message, 407 | dbus_int32_t slot 408 | ); 409 | 410 | int dbus_message_type_from_string( 411 | const char *type_str 412 | ); 413 | 414 | const char* dbus_message_type_to_string( 415 | int type 416 | ); 417 | 418 | dbus_bool_t dbus_message_marshal( 419 | DBusMessage *msg, 420 | char **marshalled_data_p, 421 | int *len_p 422 | ); 423 | 424 | DBusMessage* dbus_message_demarshal( 425 | const char *str, 426 | int len, 427 | DBusError *error 428 | ); 429 | 430 | int dbus_message_demarshal_bytes_needed( 431 | const char *str, 432 | int len 433 | ); 434 | 435 | void dbus_message_set_allow_interactive_authorization( 436 | DBusMessage *message, 437 | dbus_bool_t allow 438 | ); 439 | 440 | dbus_bool_t dbus_message_get_allow_interactive_authorization( 441 | DBusMessage *message 442 | ); 443 | 444 | #ifdef __cplusplus 445 | } 446 | #endif 447 | 448 | #endif 449 | -------------------------------------------------------------------------------- /dbus/dbus-misc.c: -------------------------------------------------------------------------------- 1 | #include "dbus-misc.h" 2 | 3 | char* dbus_get_local_machine_id( 4 | void 5 | ) { 6 | return "00000000000000000000000000000001"; 7 | } 8 | 9 | void dbus_get_version( 10 | int *major_version_p, 11 | int *minor_version_p, 12 | int *micro_version_p 13 | ) { 14 | // TODO: Set these? 15 | } 16 | 17 | dbus_bool_t dbus_setenv( 18 | const char *variable, 19 | const char *value 20 | ) { 21 | return TRUE; 22 | } 23 | 24 | char *dbus_try_get_local_machine_id( 25 | DBusError *error 26 | ) { 27 | return dbus_get_local_machine_id(); 28 | } 29 | -------------------------------------------------------------------------------- /dbus/dbus-misc.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_MISC_H 6 | #define DBUS_MISC_H 7 | 8 | #include 9 | #include 10 | 11 | #ifdef __cplusplus 12 | extern "C" { 13 | #endif 14 | 15 | char* dbus_get_local_machine_id( 16 | void 17 | ); 18 | 19 | void dbus_get_version( 20 | int *major_version_p, 21 | int *minor_version_p, 22 | int *micro_version_p 23 | ); 24 | 25 | dbus_bool_t dbus_setenv( 26 | const char *variable, 27 | const char *value 28 | ); 29 | 30 | char *dbus_try_get_local_machine_id( 31 | DBusError *error 32 | ); 33 | 34 | #ifdef __cplusplus 35 | } 36 | #endif 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /dbus/dbus-pending-call.c: -------------------------------------------------------------------------------- 1 | #include "dbus-pending-call.h" 2 | 3 | DBusPendingCall* dbus_pending_call_ref( 4 | DBusPendingCall *pending 5 | ) { 6 | return NULL; 7 | } 8 | 9 | void dbus_pending_call_unref( 10 | DBusPendingCall *pending 11 | ) { 12 | 13 | } 14 | 15 | dbus_bool_t dbus_pending_call_set_notify( 16 | DBusPendingCall *pending, 17 | DBusPendingCallNotifyFunction function, 18 | void *user_data, 19 | DBusFreeFunction free_user_data 20 | ) { 21 | return TRUE; 22 | } 23 | 24 | void dbus_pending_call_cancel( 25 | DBusPendingCall *pending 26 | ) { 27 | 28 | } 29 | 30 | dbus_bool_t dbus_pending_call_get_completed( 31 | DBusPendingCall *pending 32 | ) { 33 | return TRUE; 34 | } 35 | 36 | DBusMessage* dbus_pending_call_steal_reply( 37 | DBusPendingCall *pending 38 | ) { 39 | return NULL; 40 | } 41 | 42 | void dbus_pending_call_block( 43 | DBusPendingCall *pending 44 | ) { 45 | 46 | } 47 | 48 | dbus_bool_t dbus_pending_call_allocate_data_slot( 49 | dbus_int32_t *slot_p 50 | ) { 51 | return TRUE; 52 | } 53 | 54 | void dbus_pending_call_free_data_slot( 55 | dbus_int32_t *slot_p 56 | ) { 57 | 58 | } 59 | 60 | dbus_bool_t dbus_pending_call_set_data( 61 | DBusPendingCall *pending, 62 | dbus_int32_t slot, 63 | void *data, 64 | DBusFreeFunction free_data_func 65 | ) { 66 | return TRUE; 67 | } 68 | 69 | void* dbus_pending_call_get_data( 70 | DBusPendingCall *pending, 71 | dbus_int32_t slot 72 | ) { 73 | return NULL; 74 | } 75 | -------------------------------------------------------------------------------- /dbus/dbus-pending-call.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_PENDING_CALL_H 6 | #define DBUS_PENDING_CALL_H 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | #define DBUS_TIMEOUT_INFINITE ((int) 0x7fffffff) 17 | #define DBUS_TIMEOUT_USE_DEFAULT (-1) 18 | 19 | DBusPendingCall* dbus_pending_call_ref( 20 | DBusPendingCall *pending 21 | ); 22 | 23 | void dbus_pending_call_unref( 24 | DBusPendingCall *pending 25 | ); 26 | 27 | dbus_bool_t dbus_pending_call_set_notify( 28 | DBusPendingCall *pending, 29 | DBusPendingCallNotifyFunction function, 30 | void *user_data, 31 | DBusFreeFunction free_user_data 32 | ); 33 | 34 | void dbus_pending_call_cancel( 35 | DBusPendingCall *pending 36 | ); 37 | 38 | dbus_bool_t dbus_pending_call_get_completed( 39 | DBusPendingCall *pending 40 | ); 41 | 42 | DBusMessage* dbus_pending_call_steal_reply( 43 | DBusPendingCall *pending 44 | ); 45 | 46 | void dbus_pending_call_block( 47 | DBusPendingCall *pending 48 | ); 49 | 50 | dbus_bool_t dbus_pending_call_allocate_data_slot( 51 | dbus_int32_t *slot_p 52 | ); 53 | 54 | void dbus_pending_call_free_data_slot( 55 | dbus_int32_t *slot_p 56 | ); 57 | 58 | dbus_bool_t dbus_pending_call_set_data( 59 | DBusPendingCall *pending, 60 | dbus_int32_t slot, 61 | void *data, 62 | DBusFreeFunction free_data_func 63 | ); 64 | 65 | void* dbus_pending_call_get_data( 66 | DBusPendingCall *pending, 67 | dbus_int32_t slot 68 | ); 69 | 70 | #ifdef __cplusplus 71 | } 72 | #endif 73 | 74 | #endif 75 | -------------------------------------------------------------------------------- /dbus/dbus-protocol.h: -------------------------------------------------------------------------------- 1 | #ifndef DBUS_PROTOCOL_H 2 | #define DBUS_PROTOCOL_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #define DBUS_LITTLE_ENDIAN ('l') 9 | #define DBUS_BIG_ENDIAN ('B') 10 | #define DBUS_MAJOR_PROTOCOL_VERSION 1 11 | #define DBUS_TYPE_INVALID ((int) '\0') 12 | #define DBUS_TYPE_INVALID_AS_STRING "\0" 13 | #define DBUS_TYPE_BYTE ((int) 'y') 14 | #define DBUS_TYPE_BYTE_AS_STRING "y" 15 | #define DBUS_TYPE_BOOLEAN ((int) 'b') 16 | #define DBUS_TYPE_BOOLEAN_AS_STRING "b" 17 | #define DBUS_TYPE_INT16 ((int) 'n') 18 | #define DBUS_TYPE_INT16_AS_STRING "n" 19 | #define DBUS_TYPE_UINT16 ((int) 'q') 20 | #define DBUS_TYPE_UINT16_AS_STRING "q" 21 | #define DBUS_TYPE_INT32 ((int) 'i') 22 | #define DBUS_TYPE_INT32_AS_STRING "i" 23 | #define DBUS_TYPE_UINT32 ((int) 'u') 24 | #define DBUS_TYPE_UINT32_AS_STRING "u" 25 | #define DBUS_TYPE_INT64 ((int) 'x') 26 | #define DBUS_TYPE_INT64_AS_STRING "x" 27 | #define DBUS_TYPE_UINT64 ((int) 't') 28 | #define DBUS_TYPE_UINT64_AS_STRING "t" 29 | #define DBUS_TYPE_DOUBLE ((int) 'd') 30 | #define DBUS_TYPE_DOUBLE_AS_STRING "d" 31 | #define DBUS_TYPE_STRING ((int) 's') 32 | #define DBUS_TYPE_STRING_AS_STRING "s" 33 | #define DBUS_TYPE_OBJECT_PATH ((int) 'o') 34 | #define DBUS_TYPE_OBJECT_PATH_AS_STRING "o" 35 | #define DBUS_TYPE_SIGNATURE ((int) 'g') 36 | #define DBUS_TYPE_SIGNATURE_AS_STRING "g" 37 | #define DBUS_TYPE_UNIX_FD ((int) 'h') 38 | #define DBUS_TYPE_UNIX_FD_AS_STRING "h" 39 | #define DBUS_TYPE_ARRAY ((int) 'a') 40 | #define DBUS_TYPE_ARRAY_AS_STRING "a" 41 | #define DBUS_TYPE_VARIANT ((int) 'v') 42 | #define DBUS_TYPE_VARIANT_AS_STRING "v" 43 | #define DBUS_TYPE_STRUCT ((int) 'r') 44 | #define DBUS_TYPE_STRUCT_AS_STRING "r" 45 | #define DBUS_TYPE_DICT_ENTRY ((int) 'e') 46 | #define DBUS_TYPE_DICT_ENTRY_AS_STRING "e" 47 | #define DBUS_NUMBER_OF_TYPES (16) 48 | #define DBUS_STRUCT_BEGIN_CHAR ((int) '(') 49 | #define DBUS_STRUCT_BEGIN_CHAR_AS_STRING "(" 50 | #define DBUS_STRUCT_END_CHAR ((int) ')') 51 | #define DBUS_STRUCT_END_CHAR_AS_STRING ")" 52 | #define DBUS_DICT_ENTRY_BEGIN_CHAR ((int) '{') 53 | #define DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING "{" 54 | #define DBUS_DICT_ENTRY_END_CHAR ((int) '}') 55 | #define DBUS_DICT_ENTRY_END_CHAR_AS_STRING "}" 56 | #define DBUS_MAXIMUM_NAME_LENGTH 255 57 | #define DBUS_MAXIMUM_SIGNATURE_LENGTH 255 58 | #define DBUS_MAXIMUM_MATCH_RULE_LENGTH 1024 59 | #define DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER 63 60 | #define DBUS_MAXIMUM_ARRAY_LENGTH (67108864) 61 | #define DBUS_MAXIMUM_ARRAY_LENGTH_BITS 26 62 | #define DBUS_MAXIMUM_MESSAGE_LENGTH (DBUS_MAXIMUM_ARRAY_LENGTH * 2) 63 | #define DBUS_MAXIMUM_MESSAGE_LENGTH_BITS 27 64 | #define DBUS_MAXIMUM_MESSAGE_UNIX_FDS (DBUS_MAXIMUM_MESSAGE_LENGTH/4) 65 | #define DBUS_MAXIMUM_MESSAGE_UNIX_FDS_BITS (DBUS_MAXIMUM_MESSAGE_LENGTH_BITS-2) 66 | #define DBUS_MAXIMUM_TYPE_RECURSION_DEPTH 32 67 | #define DBUS_MESSAGE_TYPE_INVALID 0 68 | #define DBUS_MESSAGE_TYPE_METHOD_CALL 1 69 | #define DBUS_MESSAGE_TYPE_METHOD_RETURN 2 70 | #define DBUS_MESSAGE_TYPE_ERROR 3 71 | #define DBUS_MESSAGE_TYPE_SIGNAL 4 72 | #define DBUS_NUM_MESSAGE_TYPES 5 73 | #define DBUS_HEADER_FLAG_NO_REPLY_EXPECTED 0x1 74 | #define DBUS_HEADER_FLAG_NO_AUTO_START 0x2 75 | #define DBUS_HEADER_FLAG_ALLOW_INTERACTIVE_AUTHORIZATION 0x4 76 | #define DBUS_HEADER_FIELD_INVALID 0 77 | #define DBUS_HEADER_FIELD_PATH 1 78 | #define DBUS_HEADER_FIELD_INTERFACE 2 79 | #define DBUS_HEADER_FIELD_MEMBER 3 80 | #define DBUS_HEADER_FIELD_ERROR_NAME 4 81 | #define DBUS_HEADER_FIELD_REPLY_SERIAL 5 82 | #define DBUS_HEADER_FIELD_DESTINATION 6 83 | #define DBUS_HEADER_FIELD_SENDER 7 84 | #define DBUS_HEADER_FIELD_SIGNATURE 8 85 | #define DBUS_HEADER_FIELD_UNIX_FDS 9 86 | #define DBUS_HEADER_FIELD_CONTAINER_INSTANCE 10 87 | #define DBUS_HEADER_FIELD_LAST DBUS_HEADER_FIELD_CONTAINER_INSTANCE 88 | 89 | #define DBUS_HEADER_SIGNATURE \ 90 | DBUS_TYPE_BYTE_AS_STRING \ 91 | DBUS_TYPE_BYTE_AS_STRING \ 92 | DBUS_TYPE_BYTE_AS_STRING \ 93 | DBUS_TYPE_BYTE_AS_STRING \ 94 | DBUS_TYPE_UINT32_AS_STRING \ 95 | DBUS_TYPE_UINT32_AS_STRING \ 96 | DBUS_TYPE_ARRAY_AS_STRING \ 97 | DBUS_STRUCT_BEGIN_CHAR_AS_STRING \ 98 | DBUS_TYPE_BYTE_AS_STRING \ 99 | DBUS_TYPE_VARIANT_AS_STRING \ 100 | DBUS_STRUCT_END_CHAR_AS_STRING 101 | 102 | #define DBUS_MINIMUM_HEADER_SIZE 16 103 | 104 | #define DBUS_ERROR_FAILED "org.freedesktop.DBus.Error.Failed" 105 | #define DBUS_ERROR_NO_MEMORY "org.freedesktop.DBus.Error.NoMemory" 106 | #define DBUS_ERROR_SERVICE_UNKNOWN "org.freedesktop.DBus.Error.ServiceUnknown" 107 | #define DBUS_ERROR_NAME_HAS_NO_OWNER "org.freedesktop.DBus.Error.NameHasNoOwner" 108 | #define DBUS_ERROR_NO_REPLY "org.freedesktop.DBus.Error.NoReply" 109 | #define DBUS_ERROR_IO_ERROR "org.freedesktop.DBus.Error.IOError" 110 | #define DBUS_ERROR_BAD_ADDRESS "org.freedesktop.DBus.Error.BadAddress" 111 | #define DBUS_ERROR_NOT_SUPPORTED "org.freedesktop.DBus.Error.NotSupported" 112 | #define DBUS_ERROR_LIMITS_EXCEEDED "org.freedesktop.DBus.Error.LimitsExceeded" 113 | #define DBUS_ERROR_ACCESS_DENIED "org.freedesktop.DBus.Error.AccessDenied" 114 | #define DBUS_ERROR_AUTH_FAILED "org.freedesktop.DBus.Error.AuthFailed" 115 | #define DBUS_ERROR_NO_SERVER "org.freedesktop.DBus.Error.NoServer" 116 | #define DBUS_ERROR_TIMEOUT "org.freedesktop.DBus.Error.Timeout" 117 | #define DBUS_ERROR_NO_NETWORK "org.freedesktop.DBus.Error.NoNetwork" 118 | #define DBUS_ERROR_ADDRESS_IN_USE "org.freedesktop.DBus.Error.AddressInUse" 119 | #define DBUS_ERROR_DISCONNECTED "org.freedesktop.DBus.Error.Disconnected" 120 | #define DBUS_ERROR_INVALID_ARGS "org.freedesktop.DBus.Error.InvalidArgs" 121 | #define DBUS_ERROR_FILE_NOT_FOUND "org.freedesktop.DBus.Error.FileNotFound" 122 | #define DBUS_ERROR_FILE_EXISTS "org.freedesktop.DBus.Error.FileExists" 123 | #define DBUS_ERROR_UNKNOWN_METHOD "org.freedesktop.DBus.Error.UnknownMethod" 124 | #define DBUS_ERROR_UNKNOWN_OBJECT "org.freedesktop.DBus.Error.UnknownObject" 125 | 126 | #define DBUS_ERROR_UNKNOWN_INTERFACE \ 127 | "org.freedesktop.DBus.Error.UnknownInterface" 128 | 129 | #define DBUS_ERROR_UNKNOWN_PROPERTY \ 130 | "org.freedesktop.DBus.Error.UnknownProperty" 131 | 132 | #define DBUS_ERROR_PROPERTY_READ_ONLY \ 133 | "org.freedesktop.DBus.Error.PropertyReadOnly" 134 | 135 | #define DBUS_ERROR_TIMED_OUT \ 136 | "org.freedesktop.DBus.Error.TimedOut" 137 | 138 | #define DBUS_ERROR_MATCH_RULE_NOT_FOUND \ 139 | "org.freedesktop.DBus.Error.MatchRuleNotFound" 140 | 141 | #define DBUS_ERROR_MATCH_RULE_INVALID \ 142 | "org.freedesktop.DBus.Error.MatchRuleInvalid" 143 | 144 | #define DBUS_ERROR_SPAWN_EXEC_FAILED \ 145 | "org.freedesktop.DBus.Error.Spawn.ExecFailed" 146 | 147 | #define DBUS_ERROR_SPAWN_FORK_FAILED \ 148 | "org.freedesktop.DBus.Error.Spawn.ForkFailed" 149 | 150 | #define DBUS_ERROR_SPAWN_CHILD_EXITED \ 151 | "org.freedesktop.DBus.Error.Spawn.ChildExited" 152 | 153 | #define DBUS_ERROR_SPAWN_CHILD_SIGNALED \ 154 | "org.freedesktop.DBus.Error.Spawn.ChildSignaled" 155 | 156 | #define DBUS_ERROR_SPAWN_FAILED \ 157 | "org.freedesktop.DBus.Error.Spawn.Failed" 158 | 159 | #define DBUS_ERROR_SPAWN_SETUP_FAILED \ 160 | "org.freedesktop.DBus.Error.Spawn.FailedToSetup" 161 | 162 | #define DBUS_ERROR_SPAWN_CONFIG_INVALID \ 163 | "org.freedesktop.DBus.Error.Spawn.ConfigInvalid" 164 | 165 | #define DBUS_ERROR_SPAWN_SERVICE_INVALID \ 166 | "org.freedesktop.DBus.Error.Spawn.ServiceNotValid" 167 | 168 | #define DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND \ 169 | "org.freedesktop.DBus.Error.Spawn.ServiceNotFound" 170 | 171 | #define DBUS_ERROR_SPAWN_PERMISSIONS_INVALID \ 172 | "org.freedesktop.DBus.Error.Spawn.PermissionsInvalid" 173 | 174 | #define DBUS_ERROR_SPAWN_FILE_INVALID \ 175 | "org.freedesktop.DBus.Error.Spawn.FileInvalid" 176 | 177 | #define DBUS_ERROR_SPAWN_NO_MEMORY \ 178 | "org.freedesktop.DBus.Error.Spawn.NoMemory" 179 | 180 | #define DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN \ 181 | "org.freedesktop.DBus.Error.UnixProcessIdUnknown" 182 | 183 | #define DBUS_ERROR_INVALID_SIGNATURE \ 184 | "org.freedesktop.DBus.Error.InvalidSignature" 185 | 186 | #define DBUS_ERROR_INVALID_FILE_CONTENT \ 187 | "org.freedesktop.DBus.Error.InvalidFileContent" 188 | 189 | #define DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN \ 190 | "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown" 191 | 192 | #define DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN \ 193 | "org.freedesktop.DBus.Error.AdtAuditDataUnknown" 194 | 195 | #define DBUS_ERROR_OBJECT_PATH_IN_USE \ 196 | "org.freedesktop.DBus.Error.ObjectPathInUse" 197 | 198 | #define DBUS_ERROR_INCONSISTENT_MESSAGE \ 199 | "org.freedesktop.DBus.Error.InconsistentMessage" 200 | 201 | #define DBUS_ERROR_INTERACTIVE_AUTHORIZATION_REQUIRED \ 202 | "org.freedesktop.DBus.Error.InteractiveAuthorizationRequired" 203 | 204 | #define DBUS_ERROR_NOT_CONTAINER \ 205 | "org.freedesktop.DBus.Error.NotContainer" 206 | 207 | #define DBUS_INTROSPECT_1_0_XML_NAMESPACE \ 208 | "http://www.freedesktop.org/standards/dbus" 209 | 210 | #define DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER \ 211 | "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" 212 | 213 | #define DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER \ 214 | "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd" 215 | 216 | #define DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE \ 217 | "\n" 218 | 219 | #ifdef __cplusplus 220 | } 221 | #endif 222 | 223 | #endif 224 | -------------------------------------------------------------------------------- /dbus/dbus-server.c: -------------------------------------------------------------------------------- 1 | #include "dbus-server.h" 2 | 3 | DBusServer* dbus_server_listen( 4 | const char *address, 5 | DBusError *error 6 | ) { 7 | error->name = DBUS_ERROR_FAILED; 8 | error->message = "stub"; 9 | 10 | return NULL; 11 | } 12 | 13 | DBusServer* dbus_server_ref( 14 | DBusServer *server 15 | ) { 16 | return NULL; 17 | } 18 | 19 | void dbus_server_unref( 20 | DBusServer *server 21 | ) { 22 | 23 | } 24 | 25 | void dbus_server_disconnect( 26 | DBusServer *server 27 | ) { 28 | 29 | } 30 | 31 | dbus_bool_t dbus_server_get_is_connected( 32 | DBusServer *server 33 | ) { 34 | return TRUE; // Spoof 35 | } 36 | 37 | char* dbus_server_get_address( 38 | DBusServer *server 39 | ) { 40 | return NULL; 41 | } 42 | 43 | char* dbus_server_get_id( 44 | DBusServer *server 45 | ) { 46 | return NULL; 47 | } 48 | 49 | void dbus_server_set_new_connection_function( 50 | DBusServer *server, 51 | DBusNewConnectionFunction function, 52 | void *data, 53 | DBusFreeFunction free_data_function 54 | ) { 55 | 56 | } 57 | 58 | dbus_bool_t dbus_server_set_watch_functions( 59 | DBusServer *server, 60 | DBusAddWatchFunction add_function, 61 | DBusRemoveWatchFunction remove_function, 62 | DBusWatchToggledFunction toggled_function, 63 | void *data, 64 | DBusFreeFunction free_data_function 65 | ) { 66 | return TRUE; 67 | } 68 | 69 | dbus_bool_t dbus_server_set_timeout_functions( 70 | DBusServer *server, 71 | DBusAddTimeoutFunction add_function, 72 | DBusRemoveTimeoutFunction remove_function, 73 | DBusTimeoutToggledFunction toggled_function, 74 | void *data, 75 | DBusFreeFunction free_data_function 76 | ) { 77 | return TRUE; 78 | } 79 | 80 | dbus_bool_t dbus_server_set_auth_mechanisms( 81 | DBusServer *server, 82 | const char **mechanisms 83 | ) { 84 | return TRUE; 85 | } 86 | 87 | dbus_bool_t dbus_server_allocate_data_slot( 88 | dbus_int32_t *slot_p 89 | ) { 90 | return TRUE; 91 | } 92 | 93 | void dbus_server_free_data_slot( 94 | dbus_int32_t *slot_p 95 | ) { 96 | 97 | } 98 | 99 | dbus_bool_t dbus_server_set_data( 100 | DBusServer *server, 101 | int slot, 102 | void *data, 103 | DBusFreeFunction free_data_func 104 | ) { 105 | return TRUE; 106 | } 107 | 108 | void* dbus_server_get_data( 109 | DBusServer *server, 110 | int slot 111 | ) { 112 | return NULL; 113 | } 114 | 115 | -------------------------------------------------------------------------------- /dbus/dbus-server.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_SERVER_H 6 | #define DBUS_SERVER_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #ifdef __cplusplus 15 | extern "C" { 16 | #endif 17 | 18 | typedef struct DBusServer DBusServer; 19 | 20 | typedef void (* DBusNewConnectionFunction) ( 21 | DBusServer *server, 22 | DBusConnection *new_connection, 23 | void *data 24 | ); 25 | 26 | DBusServer* dbus_server_listen( 27 | const char *address, 28 | DBusError *error 29 | ); 30 | 31 | DBusServer* dbus_server_ref( 32 | DBusServer *server 33 | ); 34 | 35 | void dbus_server_unref( 36 | DBusServer *server 37 | ); 38 | 39 | void dbus_server_disconnect( 40 | DBusServer *server 41 | ); 42 | 43 | dbus_bool_t dbus_server_get_is_connected( 44 | DBusServer *server 45 | ); 46 | 47 | char* dbus_server_get_address( 48 | DBusServer *server 49 | ); 50 | 51 | char* dbus_server_get_id( 52 | DBusServer *server 53 | ); 54 | 55 | void dbus_server_set_new_connection_function( 56 | DBusServer *server, 57 | DBusNewConnectionFunction function, 58 | void *data, 59 | DBusFreeFunction free_data_function 60 | ); 61 | 62 | dbus_bool_t dbus_server_set_watch_functions( 63 | DBusServer *server, 64 | DBusAddWatchFunction add_function, 65 | DBusRemoveWatchFunction remove_function, 66 | DBusWatchToggledFunction toggled_function, 67 | void *data, 68 | DBusFreeFunction free_data_function 69 | ); 70 | 71 | dbus_bool_t dbus_server_set_timeout_functions( 72 | DBusServer *server, 73 | DBusAddTimeoutFunction add_function, 74 | DBusRemoveTimeoutFunction remove_function, 75 | DBusTimeoutToggledFunction toggled_function, 76 | void *data, 77 | DBusFreeFunction free_data_function 78 | ); 79 | 80 | dbus_bool_t dbus_server_set_auth_mechanisms( 81 | DBusServer *server, 82 | const char **mechanisms 83 | ); 84 | 85 | dbus_bool_t dbus_server_allocate_data_slot( 86 | dbus_int32_t *slot_p 87 | ); 88 | 89 | void dbus_server_free_data_slot( 90 | dbus_int32_t *slot_p 91 | ); 92 | 93 | dbus_bool_t dbus_server_set_data( 94 | DBusServer *server, 95 | int slot, 96 | void *data, 97 | DBusFreeFunction free_data_func 98 | ); 99 | 100 | void* dbus_server_get_data( 101 | DBusServer *server, 102 | int slot 103 | ); 104 | 105 | 106 | #ifdef __cplusplus 107 | } 108 | #endif 109 | 110 | #endif 111 | -------------------------------------------------------------------------------- /dbus/dbus-shared.h: -------------------------------------------------------------------------------- 1 | #ifndef DBUS_SHARED_H 2 | #define DBUS_SHARED_H 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | typedef enum { 9 | DBUS_BUS_SESSION, 10 | DBUS_BUS_SYSTEM, 11 | DBUS_BUS_STARTER 12 | } DBusBusType; 13 | 14 | typedef enum { 15 | DBUS_HANDLER_RESULT_HANDLED, 16 | DBUS_HANDLER_RESULT_NOT_YET_HANDLED, 17 | DBUS_HANDLER_RESULT_NEED_MEMORY 18 | } DBusHandlerResult; 19 | 20 | #define DBUS_SERVICE_DBUS "org.freedesktop.DBus" 21 | #define DBUS_PATH_DBUS "/org/freedesktop/DBus" 22 | #define DBUS_PATH_LOCAL "/org/freedesktop/DBus/Local" 23 | 24 | #define DBUS_INTERFACE_DBUS "org.freedesktop.DBus" 25 | #define DBUS_INTERFACE_CONTAINERS1 "org.freedesktop.DBus.Containers1" 26 | #define DBUS_INTERFACE_MONITORING "org.freedesktop.DBus.Monitoring" 27 | 28 | #define DBUS_INTERFACE_VERBOSE "org.freedesktop.DBus.Verbose" 29 | #define DBUS_INTERFACE_INTROSPECTABLE "org.freedesktop.DBus.Introspectable" 30 | #define DBUS_INTERFACE_PROPERTIES "org.freedesktop.DBus.Properties" 31 | #define DBUS_INTERFACE_PEER "org.freedesktop.DBus.Peer" 32 | 33 | #define DBUS_INTERFACE_LOCAL "org.freedesktop.DBus.Local" 34 | #define DBUS_NAME_FLAG_ALLOW_REPLACEMENT 0x1 35 | #define DBUS_NAME_FLAG_REPLACE_EXISTING 0x2 36 | #define DBUS_NAME_FLAG_DO_NOT_QUEUE 0x4 37 | 38 | #define DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER 1 39 | #define DBUS_REQUEST_NAME_REPLY_IN_QUEUE 2 40 | #define DBUS_REQUEST_NAME_REPLY_EXISTS 3 41 | #define DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER 4 42 | 43 | #define DBUS_RELEASE_NAME_REPLY_RELEASED 1 44 | #define DBUS_RELEASE_NAME_REPLY_NON_EXISTENT 2 45 | #define DBUS_RELEASE_NAME_REPLY_NOT_OWNER 3 46 | 47 | #define DBUS_START_REPLY_SUCCESS 1 48 | #define DBUS_START_REPLY_ALREADY_RUNNING 2 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | 54 | #endif 55 | -------------------------------------------------------------------------------- /dbus/dbus-signature.c: -------------------------------------------------------------------------------- 1 | #include "dbus-signature.h" 2 | 3 | void dbus_signature_iter_init( 4 | DBusSignatureIter *iter, 5 | const char *signature 6 | ) { 7 | 8 | } 9 | 10 | int dbus_signature_iter_get_current_type( 11 | const DBusSignatureIter *iter 12 | ) { 13 | return 0; 14 | } 15 | 16 | char *dbus_signature_iter_get_signature( 17 | const DBusSignatureIter *iter 18 | ) { 19 | return NULL; 20 | } 21 | 22 | int dbus_signature_iter_get_element_type( 23 | const DBusSignatureIter *iter 24 | ) { 25 | return DBUS_TYPE_INVALID; 26 | } 27 | 28 | dbus_bool_t dbus_signature_iter_next( 29 | DBusSignatureIter *iter 30 | ) { 31 | return TRUE; 32 | } 33 | 34 | void dbus_signature_iter_recurse( 35 | const DBusSignatureIter *iter, 36 | DBusSignatureIter *subiter 37 | ) { 38 | 39 | } 40 | 41 | dbus_bool_t dbus_signature_validate( 42 | const char *signature, 43 | DBusError*error 44 | ) { 45 | return TRUE; 46 | } 47 | 48 | dbus_bool_t dbus_signature_validate_single( 49 | const char *signature, 50 | DBusError*error 51 | ) { 52 | return TRUE; 53 | } 54 | 55 | dbus_bool_t dbus_type_is_valid( 56 | int typecode 57 | ) { 58 | return TRUE; 59 | } 60 | 61 | dbus_bool_t dbus_type_is_basic( 62 | int typecode 63 | ) { 64 | return TRUE; 65 | } 66 | 67 | dbus_bool_t dbus_type_is_container( 68 | int typecode 69 | ) { 70 | return TRUE; 71 | } 72 | 73 | dbus_bool_t dbus_type_is_fixed( 74 | int typecode 75 | ) { 76 | return TRUE; 77 | } 78 | -------------------------------------------------------------------------------- /dbus/dbus-signature.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_SIGNATURES_H 6 | #define DBUS_SIGNATURES_H 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | typedef struct { 17 | // no public fields. 18 | 19 | void *dummy1; // NOTE: real member of struct upstream. 20 | } DBusSignatureIter; 21 | 22 | void dbus_signature_iter_init( 23 | DBusSignatureIter *iter, 24 | const char *signature 25 | ); 26 | 27 | int dbus_signature_iter_get_current_type( 28 | const DBusSignatureIter *iter 29 | ); 30 | 31 | char *dbus_signature_iter_get_signature( 32 | const DBusSignatureIter *iter 33 | ); 34 | 35 | int dbus_signature_iter_get_element_type( 36 | const DBusSignatureIter *iter 37 | ); 38 | 39 | dbus_bool_t dbus_signature_iter_next( 40 | DBusSignatureIter *iter 41 | ); 42 | 43 | void dbus_signature_iter_recurse( 44 | const DBusSignatureIter *iter, 45 | DBusSignatureIter *subiter 46 | ); 47 | 48 | dbus_bool_t dbus_signature_validate( 49 | const char *signature, 50 | DBusError*error 51 | ); 52 | 53 | dbus_bool_t dbus_signature_validate_single( 54 | const char *signature, 55 | DBusError*error 56 | ); 57 | 58 | dbus_bool_t dbus_type_is_valid( 59 | int typecode 60 | ); 61 | 62 | dbus_bool_t dbus_type_is_basic( 63 | int typecode 64 | ); 65 | 66 | dbus_bool_t dbus_type_is_container( 67 | int typecode 68 | ); 69 | 70 | dbus_bool_t dbus_type_is_fixed( 71 | int typecode 72 | ); 73 | 74 | #ifdef __cplusplus 75 | } 76 | #endif 77 | 78 | #endif 79 | -------------------------------------------------------------------------------- /dbus/dbus-syntax.c: -------------------------------------------------------------------------------- 1 | #include "dbus-syntax.h" 2 | 3 | dbus_bool_t dbus_validate_path( 4 | const char *path, 5 | DBusError *error 6 | ) { 7 | return TRUE; 8 | } 9 | 10 | dbus_bool_t dbus_validate_interface( 11 | const char *name, 12 | DBusError *error 13 | ) { 14 | return TRUE; 15 | } 16 | 17 | dbus_bool_t dbus_validate_member( 18 | const char *name, 19 | DBusError *error 20 | ) { 21 | return TRUE; 22 | } 23 | 24 | dbus_bool_t dbus_validate_error_name( 25 | const char *name, 26 | DBusError *error 27 | ) { 28 | return TRUE; 29 | } 30 | 31 | dbus_bool_t dbus_validate_bus_name( 32 | const char *name, 33 | DBusError *error 34 | ) { 35 | return TRUE; 36 | } 37 | 38 | dbus_bool_t dbus_validate_utf8( 39 | const char *alleged_utf8, 40 | DBusError *error 41 | ) { 42 | return TRUE; 43 | } 44 | 45 | -------------------------------------------------------------------------------- /dbus/dbus-syntax.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_SYNTAX_H 6 | #define DBUS_SYNTAX_H 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | #ifdef __cplusplus 13 | extern "C" { 14 | #endif 15 | 16 | dbus_bool_t dbus_validate_path( 17 | const char *path, 18 | DBusError *error 19 | ); 20 | 21 | dbus_bool_t dbus_validate_interface( 22 | const char *name, 23 | DBusError *error 24 | ); 25 | 26 | dbus_bool_t dbus_validate_member( 27 | const char *name, 28 | DBusError *error 29 | ); 30 | 31 | dbus_bool_t dbus_validate_error_name( 32 | const char *name, 33 | DBusError *error 34 | ); 35 | 36 | dbus_bool_t dbus_validate_bus_name( 37 | const char *name, 38 | DBusError *error 39 | ); 40 | 41 | dbus_bool_t dbus_validate_utf8( 42 | const char *alleged_utf8, 43 | DBusError *error 44 | ); 45 | 46 | #ifdef __cplusplus 47 | } 48 | #endif 49 | 50 | #endif 51 | -------------------------------------------------------------------------------- /dbus/dbus-threads.c: -------------------------------------------------------------------------------- 1 | #include "dbus-threads.h" 2 | 3 | dbus_bool_t dbus_threads_init( 4 | const DBusThreadFunctions *functions 5 | ) { 6 | return TRUE; 7 | } 8 | 9 | dbus_bool_t dbus_threads_init_default( 10 | void 11 | ) { 12 | return TRUE; 13 | } 14 | -------------------------------------------------------------------------------- /dbus/dbus-threads.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_THREADS_H 6 | #define DBUS_THREADS_H 7 | 8 | #include 9 | #include 10 | 11 | #ifdef __cplusplus 12 | extern "C" { 13 | #endif 14 | 15 | typedef struct DBusMutex DBusMutex; 16 | typedef struct DBusCondVar DBusCondVar; 17 | typedef DBusMutex* (* DBusMutexNewFunction) (void); 18 | typedef void (* DBusMutexFreeFunction) (DBusMutex *mutex); 19 | typedef dbus_bool_t (* DBusMutexLockFunction) (DBusMutex *mutex); 20 | typedef dbus_bool_t (* DBusMutexUnlockFunction) (DBusMutex *mutex); 21 | typedef DBusMutex* (* DBusRecursiveMutexNewFunction) (void); 22 | typedef void (* DBusRecursiveMutexFreeFunction) (DBusMutex *mutex); 23 | typedef void (* DBusRecursiveMutexLockFunction) (DBusMutex *mutex); 24 | typedef void (* DBusRecursiveMutexUnlockFunction) (DBusMutex *mutex); 25 | typedef DBusCondVar* (* DBusCondVarNewFunction) (void); 26 | typedef void (* DBusCondVarFreeFunction) (DBusCondVar *cond); 27 | 28 | typedef void (* DBusCondVarWaitFunction) ( 29 | DBusCondVar *cond, 30 | DBusMutex *mutex 31 | ); 32 | 33 | typedef dbus_bool_t (* DBusCondVarWaitTimeoutFunction) ( 34 | DBusCondVar *cond, 35 | DBusMutex *mutex, 36 | int timeout_milliseconds 37 | ); 38 | 39 | typedef void (* DBusCondVarWakeOneFunction) (DBusCondVar *cond); 40 | typedef void (* DBusCondVarWakeAllFunction) (DBusCondVar *cond); 41 | 42 | typedef enum { 43 | DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK = 1 << 0, 44 | DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK = 1 << 1, 45 | DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK = 1 << 2, 46 | DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK = 1 << 3, 47 | DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK = 1 << 4, 48 | DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK = 1 << 5, 49 | DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK = 1 << 6, 50 | DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK = 1 << 7, 51 | DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK = 1 << 8, 52 | DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK = 1 << 9, 53 | DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_NEW_MASK = 1 << 10, 54 | DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_FREE_MASK = 1 << 11, 55 | DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_LOCK_MASK = 1 << 12, 56 | DBUS_THREAD_FUNCTIONS_RECURSIVE_MUTEX_UNLOCK_MASK = 1 << 13, 57 | DBUS_THREAD_FUNCTIONS_ALL_MASK = (1 << 14) - 1 58 | } DBusThreadFunctionsMask; 59 | 60 | typedef struct { 61 | unsigned int mask; 62 | 63 | DBusMutexNewFunction mutex_new; 64 | DBusMutexFreeFunction mutex_free; 65 | DBusMutexLockFunction mutex_lock; 66 | DBusMutexUnlockFunction mutex_unlock; 67 | 68 | DBusCondVarNewFunction condvar_new; 69 | DBusCondVarFreeFunction condvar_free; 70 | DBusCondVarWaitFunction condvar_wait; 71 | DBusCondVarWaitTimeoutFunction condvar_wait_timeout; 72 | DBusCondVarWakeOneFunction condvar_wake_one; 73 | DBusCondVarWakeAllFunction condvar_wake_all; 74 | 75 | DBusRecursiveMutexNewFunction recursive_mutex_new; 76 | DBusRecursiveMutexFreeFunction recursive_mutex_free; 77 | DBusRecursiveMutexLockFunction recursive_mutex_lock; 78 | DBusRecursiveMutexUnlockFunction recursive_mutex_unlock; 79 | 80 | void (* padding1) (void); 81 | void (* padding2) (void); 82 | void (* padding3) (void); 83 | void (* padding4) (void); 84 | } DBusThreadFunctions; 85 | 86 | dbus_bool_t dbus_threads_init( 87 | const DBusThreadFunctions *functions 88 | ); 89 | 90 | dbus_bool_t dbus_threads_init_default( 91 | void 92 | ); 93 | 94 | #ifdef __cplusplus 95 | } 96 | #endif 97 | 98 | #endif 99 | -------------------------------------------------------------------------------- /dbus/dbus-types.h: -------------------------------------------------------------------------------- 1 | #if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION) 2 | # error "Only can be included directly." 3 | #endif 4 | 5 | #ifndef DBUS_TYPES_H 6 | #define DBUS_TYPES_H 7 | 8 | #include 9 | 10 | typedef int32_t dbus_int32_t; 11 | typedef uint32_t dbus_uint32_t; 12 | typedef uint32_t dbus_unichar_t; 13 | typedef uint32_t dbus_bool_t; 14 | typedef short dbus_int16_t; 15 | typedef unsigned short dbus_uint16_t; 16 | typedef long long dbus_int64_t; 17 | typedef unsigned long long dbus_uint64_t; 18 | 19 | #endif 20 | -------------------------------------------------------------------------------- /dbus/dbus.h: -------------------------------------------------------------------------------- 1 | #ifndef DBUS_H 2 | #define DBUS_H 3 | #define DBUS_INSIDE_DBUS_H 1 4 | 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #undef DBUS_INSIDE_DBUS_H 22 | #endif 23 | --------------------------------------------------------------------------------