DBUS_AUTH_STATE_AUTHENTICATED
} DBusAuthState;
+DBUS_PRIVATE_EXPORT
DBusAuth* _dbus_auth_server_new (const DBusString *guid);
+DBUS_PRIVATE_EXPORT
DBusAuth* _dbus_auth_client_new (void);
+DBUS_PRIVATE_EXPORT
DBusAuth* _dbus_auth_ref (DBusAuth *auth);
+DBUS_PRIVATE_EXPORT
void _dbus_auth_unref (DBusAuth *auth);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_auth_set_mechanisms (DBusAuth *auth,
const char **mechanisms);
+DBUS_PRIVATE_EXPORT
DBusAuthState _dbus_auth_do_work (DBusAuth *auth);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_auth_get_bytes_to_send (DBusAuth *auth,
const DBusString **str);
+DBUS_PRIVATE_EXPORT
void _dbus_auth_bytes_sent (DBusAuth *auth,
int bytes_sent);
+DBUS_PRIVATE_EXPORT
void _dbus_auth_get_buffer (DBusAuth *auth,
DBusString **buffer);
+DBUS_PRIVATE_EXPORT
void _dbus_auth_return_buffer (DBusAuth *auth,
DBusString *buffer);
+DBUS_PRIVATE_EXPORT
void _dbus_auth_get_unused_bytes (DBusAuth *auth,
const DBusString **str);
+DBUS_PRIVATE_EXPORT
void _dbus_auth_delete_unused_bytes (DBusAuth *auth);
dbus_bool_t _dbus_auth_needs_encoding (DBusAuth *auth);
dbus_bool_t _dbus_auth_encode_data (DBusAuth *auth,
dbus_bool_t _dbus_auth_decode_data (DBusAuth *auth,
const DBusString *encoded,
DBusString *plaintext);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_auth_set_credentials (DBusAuth *auth,
DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
DBusCredentials* _dbus_auth_get_identity (DBusAuth *auth);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_auth_set_context (DBusAuth *auth,
const DBusString *context);
const char* _dbus_auth_get_guid_from_server(DBusAuth *auth);
typedef void (* DBusPendingFdsChangeFunction) (void *data);
+DBUS_PRIVATE_EXPORT
void _dbus_connection_lock (DBusConnection *connection);
+DBUS_PRIVATE_EXPORT
void _dbus_connection_unlock (DBusConnection *connection);
+DBUS_PRIVATE_EXPORT
DBusConnection * _dbus_connection_ref_unlocked (DBusConnection *connection);
+DBUS_PRIVATE_EXPORT
void _dbus_connection_unref_unlocked (DBusConnection *connection);
void _dbus_connection_queue_received_message_link (DBusConnection *connection,
DBusList *link);
void _dbus_connection_queue_synthesized_message_link (DBusConnection *connection,
DBusList *link);
+DBUS_PRIVATE_EXPORT
void _dbus_connection_test_get_locks (DBusConnection *conn,
DBusMutex **mutex_loc,
DBusMutex **dispatch_mutex_loc,
DBusMutex **io_path_mutex_loc,
DBusCondVar **dispatch_cond_loc,
DBusCondVar **io_path_cond_loc);
+DBUS_PRIVATE_EXPORT
int _dbus_connection_get_pending_fds_count (DBusConnection *connection);
+DBUS_PRIVATE_EXPORT
void _dbus_connection_set_pending_fds_function (DBusConnection *connection,
DBusPendingFdsChangeFunction callback,
void *data);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_connection_get_linux_security_label (DBusConnection *connection,
char **label_p);
/* if DBUS_ENABLE_STATS */
+DBUS_PRIVATE_EXPORT
void _dbus_connection_get_stats (DBusConnection *connection,
dbus_uint32_t *in_messages,
dbus_uint32_t *in_bytes,
DBUS_CREDENTIAL_WINDOWS_SID
} DBusCredentialType;
+DBUS_PRIVATE_EXPORT
DBusCredentials* _dbus_credentials_new_from_current_process (void);
+DBUS_PRIVATE_EXPORT
DBusCredentials* _dbus_credentials_new (void);
+DBUS_PRIVATE_EXPORT
void _dbus_credentials_ref (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
void _dbus_credentials_unref (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_add_pid (DBusCredentials *credentials,
dbus_pid_t pid);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_add_unix_uid (DBusCredentials *credentials,
dbus_uid_t uid);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_add_windows_sid (DBusCredentials *credentials,
const char *windows_sid);
dbus_bool_t _dbus_credentials_add_linux_security_label (DBusCredentials *credentials,
dbus_bool_t _dbus_credentials_add_adt_audit_data (DBusCredentials *credentials,
void *audit_data,
dbus_int32_t size);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_include (DBusCredentials *credentials,
DBusCredentialType type);
+DBUS_PRIVATE_EXPORT
dbus_pid_t _dbus_credentials_get_pid (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
dbus_uid_t _dbus_credentials_get_unix_uid (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
const char* _dbus_credentials_get_windows_sid (DBusCredentials *credentials);
const char * _dbus_credentials_get_linux_security_label (DBusCredentials *credentials);
void * _dbus_credentials_get_adt_audit_data (DBusCredentials *credentials);
dbus_int32_t _dbus_credentials_get_adt_audit_data_size (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_are_superset (DBusCredentials *credentials,
DBusCredentials *possible_subset);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_are_empty (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_are_anonymous (DBusCredentials *credentials);
dbus_bool_t _dbus_credentials_add_credentials (DBusCredentials *credentials,
DBusCredentials *other_credentials);
dbus_bool_t _dbus_credentials_add_credential (DBusCredentials *credentials,
DBusCredentialType which,
DBusCredentials *other_credentials);
+DBUS_PRIVATE_EXPORT
void _dbus_credentials_clear (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
DBusCredentials* _dbus_credentials_copy (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_same_user (DBusCredentials *credentials,
DBusCredentials *other_credentials);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_credentials_to_string_append (DBusCredentials *credentials,
DBusString *string);
* File interface
*/
dbus_bool_t _dbus_file_exists (const char *file);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_file_get_contents (DBusString *str,
const DBusString *filename,
DBusError *error);
dbus_bool_t _dbus_create_file_exclusively (const DBusString *filename,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_delete_file (const DBusString *filename,
DBusError *error);
DBUS_HASH_UINTPTR /**< Hash keys are integer capable to hold a pointer. */
} DBusHashType;
+DBUS_PRIVATE_EXPORT
DBusHashTable* _dbus_hash_table_new (DBusHashType type,
DBusFreeFunction key_free_function,
DBusFreeFunction value_free_function);
DBusHashTable* _dbus_hash_table_ref (DBusHashTable *table);
+DBUS_PRIVATE_EXPORT
void _dbus_hash_table_unref (DBusHashTable *table);
void _dbus_hash_table_remove_all (DBusHashTable *table);
+DBUS_PRIVATE_EXPORT
void _dbus_hash_iter_init (DBusHashTable *table,
DBusHashIter *iter);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_iter_next (DBusHashIter *iter);
+DBUS_PRIVATE_EXPORT
void _dbus_hash_iter_remove_entry (DBusHashIter *iter);
+DBUS_PRIVATE_EXPORT
void* _dbus_hash_iter_get_value (DBusHashIter *iter);
void _dbus_hash_iter_set_value (DBusHashIter *iter,
void *value);
+DBUS_PRIVATE_EXPORT
int _dbus_hash_iter_get_int_key (DBusHashIter *iter);
+DBUS_PRIVATE_EXPORT
const char* _dbus_hash_iter_get_string_key (DBusHashIter *iter);
+DBUS_PRIVATE_EXPORT
uintptr_t _dbus_hash_iter_get_uintptr_key (DBusHashIter *iter);
dbus_bool_t _dbus_hash_iter_lookup (DBusHashTable *table,
void *key,
dbus_bool_t create_if_not_found,
DBusHashIter *iter);
+DBUS_PRIVATE_EXPORT
void* _dbus_hash_table_lookup_string (DBusHashTable *table,
const char *key);
+DBUS_PRIVATE_EXPORT
void* _dbus_hash_table_lookup_int (DBusHashTable *table,
int key);
+DBUS_PRIVATE_EXPORT
void* _dbus_hash_table_lookup_uintptr (DBusHashTable *table,
uintptr_t key);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_remove_string (DBusHashTable *table,
const char *key);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_remove_int (DBusHashTable *table,
int key);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_remove_uintptr (DBusHashTable *table,
uintptr_t key);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_insert_string (DBusHashTable *table,
char *key,
void *value);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_insert_int (DBusHashTable *table,
int key,
void *value);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_table_insert_uintptr (DBusHashTable *table,
uintptr_t key,
void *value);
+DBUS_PRIVATE_EXPORT
int _dbus_hash_table_get_n_entries (DBusHashTable *table);
/* Preallocation */
/** A preallocated hash entry */
typedef struct DBusPreallocatedHash DBusPreallocatedHash;
+DBUS_PRIVATE_EXPORT
DBusPreallocatedHash *_dbus_hash_table_preallocate_entry (DBusHashTable *table);
+DBUS_PRIVATE_EXPORT
void _dbus_hash_table_free_preallocated_entry (DBusHashTable *table,
DBusPreallocatedHash *preallocated);
+DBUS_PRIVATE_EXPORT
void _dbus_hash_table_insert_string_preallocated (DBusHashTable *table,
DBusPreallocatedHash *preallocated,
char *key,
DBUS_BEGIN_DECLS
+DBUS_PRIVATE_EXPORT
void _dbus_warn (const char *format,
...) _DBUS_GNUC_PRINTF (1, 2);
+DBUS_PRIVATE_EXPORT
void _dbus_warn_check_failed (const char *format,
...) _DBUS_GNUC_PRINTF (1, 2);
#endif
#ifdef DBUS_CPP_SUPPORTS_VARIABLE_MACRO_ARGUMENTS
+DBUS_PRIVATE_EXPORT
void _dbus_verbose_real (const char *file, const int line, const char *function,
const char *format,...) _DBUS_GNUC_PRINTF (4, 5);
# define _dbus_verbose(fmt,...) _dbus_verbose_real( __FILE__,__LINE__,__FUNCTION__,fmt, ## __VA_ARGS__)
#else
+DBUS_PRIVATE_EXPORT
void _dbus_verbose_real (const char *format,
...) _DBUS_GNUC_PRINTF (1, 2);
# define _dbus_verbose _dbus_verbose_real
#endif
+DBUS_PRIVATE_EXPORT
void _dbus_verbose_reset_real (void);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_is_verbose_real (void);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_get_verbose (void);
+DBUS_PRIVATE_EXPORT
void _dbus_set_verbose (dbus_bool_t state);
# define _dbus_verbose_reset _dbus_verbose_reset_real
const char *env_var,
int *enabled);
+DBUS_PRIVATE_EXPORT
const char* _dbus_strerror (int error_number);
#ifdef DBUS_DISABLE_ASSERT
#define _dbus_assert(condition) do { } while (0)
#else
+DBUS_PRIVATE_EXPORT
void _dbus_real_assert (dbus_bool_t condition,
const char *condition_text,
const char *file,
#ifdef DBUS_DISABLE_ASSERT
#define _dbus_assert_not_reached(explanation) do { } while (0)
#else
+DBUS_PRIVATE_EXPORT
void _dbus_real_assert_not_reached (const char *explanation,
const char *file,
int line) _DBUS_GNUC_NORETURN;
#define _dbus_return_val_if_fail(condition, val)
#else
+DBUS_PRIVATE_EXPORT
extern const char *_dbus_return_if_fail_warning_format;
#define _dbus_return_if_fail(condition) do { \
((void*)_DBUS_ALIGN_VALUE(this, boundary))
+DBUS_PRIVATE_EXPORT
char* _dbus_strdup (const char *str);
void* _dbus_memdup (const void *mem,
size_t n_bytes);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_array_contains (const char **array,
const char *str);
char** _dbus_dup_string_array (const char **array);
void _dbus_verbose_bytes (const unsigned char *data,
int len,
int offset);
+DBUS_PRIVATE_EXPORT
void _dbus_verbose_bytes_of_string (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
extern const char *_dbus_no_memory_message;
#define _DBUS_SET_OOM(error) dbus_set_error_const ((error), DBUS_ERROR_NO_MEMORY, _dbus_no_memory_message)
+DBUS_PRIVATE_EXPORT
void _dbus_set_error_valist (DBusError *error,
const char *name,
const char *format,
int _dbus_get_fail_alloc_failures (void);
dbus_bool_t _dbus_decrement_fail_alloc_counter (void);
dbus_bool_t _dbus_disable_mem_pools (void);
+DBUS_PRIVATE_EXPORT
int _dbus_get_malloc_blocks_outstanding (void);
typedef dbus_bool_t (* DBusTestMemoryFunction) (void *data);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_test_oom_handling (const char *description,
DBusTestMemoryFunction func,
void *data);
#endif /* !DBUS_ENABLE_EMBEDDED_TESTS */
typedef void (* DBusShutdownFunction) (void *data);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_register_shutdown_func (DBusShutdownFunction function,
void *data);
dbus_bool_t _dbus_register_shutdown_func_unlocked (DBusShutdownFunction function,
#define _DBUS_LOCK(name) _dbus_lock (_DBUS_LOCK_##name)
#define _DBUS_UNLOCK(name) _dbus_unlock (_DBUS_LOCK_##name)
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_threads_init_debug (void);
dbus_bool_t _dbus_address_append_escaped (DBusString *escaped,
char as_bytes[DBUS_UUID_LENGTH_BYTES]; /**< guid as 16 single-byte values */
};
+DBUS_PRIVATE_EXPORT
void _dbus_generate_uuid (DBusGUID *uuid);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_uuid_encode (const DBusGUID *uuid,
DBusString *encoded);
dbus_bool_t _dbus_read_uuid_file (const DBusString *filename,
DBusList *next; /**< Next list node. */
void *data; /**< Data stored at this element. */
};
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_append (DBusList **list,
void *data);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_prepend (DBusList **list,
void *data);
dbus_bool_t _dbus_list_insert_before (DBusList **list,
DBusList *before_this_link,
void *data);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_insert_after (DBusList **list,
DBusList *after_this_link,
void *data);
+DBUS_PRIVATE_EXPORT
void _dbus_list_insert_before_link (DBusList **list,
DBusList *before_this_link,
DBusList *link);
+DBUS_PRIVATE_EXPORT
void _dbus_list_insert_after_link (DBusList **list,
DBusList *after_this_link,
DBusList *link);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_remove (DBusList **list,
void *data);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_remove_last (DBusList **list,
void *data);
+DBUS_PRIVATE_EXPORT
void _dbus_list_remove_link (DBusList **list,
DBusList *link);
+DBUS_PRIVATE_EXPORT
DBusList* _dbus_list_find_last (DBusList **list,
void *data);
+DBUS_PRIVATE_EXPORT
void _dbus_list_clear (DBusList **list);
+DBUS_PRIVATE_EXPORT
DBusList* _dbus_list_get_first_link (DBusList **list);
+DBUS_PRIVATE_EXPORT
DBusList* _dbus_list_get_last_link (DBusList **list);
+DBUS_PRIVATE_EXPORT
void* _dbus_list_get_last (DBusList **list);
+DBUS_PRIVATE_EXPORT
void* _dbus_list_get_first (DBusList **list);
+DBUS_PRIVATE_EXPORT
void* _dbus_list_pop_first (DBusList **list);
+DBUS_PRIVATE_EXPORT
void* _dbus_list_pop_last (DBusList **list);
+DBUS_PRIVATE_EXPORT
DBusList* _dbus_list_pop_first_link (DBusList **list);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_copy (DBusList **list,
DBusList **dest);
+DBUS_PRIVATE_EXPORT
int _dbus_list_get_length (DBusList **list);
+DBUS_PRIVATE_EXPORT
DBusList* _dbus_list_alloc_link (void *data);
+DBUS_PRIVATE_EXPORT
void _dbus_list_free_link (DBusList *link);
+DBUS_PRIVATE_EXPORT
void _dbus_list_unlink (DBusList **list,
DBusList *link);
+DBUS_PRIVATE_EXPORT
void _dbus_list_append_link (DBusList **list,
DBusList *link);
+DBUS_PRIVATE_EXPORT
void _dbus_list_prepend_link (DBusList **list,
DBusList *link);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_length_is_one (DBusList **list);
+DBUS_PRIVATE_EXPORT
void _dbus_list_foreach (DBusList **list,
DBusForeachFunction function,
void *data);
#define _dbus_list_get_prev_link(list, link) ((link) == *(list) ? NULL : (link)->prev)
/* if DBUS_ENABLE_STATS */
+DBUS_PRIVATE_EXPORT
void _dbus_list_get_stats (dbus_uint32_t *in_use_p,
dbus_uint32_t *in_free_list_p,
dbus_uint32_t *allocated_p);
* platforms other than Windows.
*/
-#if defined(_WIN32)
+#if defined(DBUS_EXPORT)
+ /* value forced by compiler command line, don't redefine */
+#elif defined(_WIN32)
# if defined(DBUS_STATIC_BUILD)
# define DBUS_EXPORT
# elif defined(dbus_1_EXPORTS)
# else
# define DBUS_EXPORT __declspec(dllimport)
# endif
+#elif defined(__GNUC__) && __GNUC__ >= 4
+# define DBUS_EXPORT __attribute__ ((__visibility__ ("default")))
#else
#define DBUS_EXPORT
#endif
+#if defined(DBUS_PRIVATE_EXPORT)
+ /* value forced by compiler command line, don't redefine */
+#elif defined(_WIN32)
+# if defined(DBUS_STATIC_BUILD)
+# define DBUS_PRIVATE_EXPORT /* no decoration */
+# elif defined(dbus_1_EXPORTS)
+# define DBUS_PRIVATE_EXPORT __declspec(dllexport)
+# else
+# define DBUS_PRIVATE_EXPORT __declspec(dllimport)
+# endif
+#elif defined(__GNUC__) && __GNUC__ >= 4
+# define DBUS_PRIVATE_EXPORT __attribute__ ((__visibility__ ("default")))
+#else
+# define DBUS_PRIVATE_EXPORT /* no decoration */
+#endif
+
/** @} */
#endif /* DBUS_MACROS_H */
#endif
#ifndef _dbus_unpack_uint16
+DBUS_PRIVATE_EXPORT
dbus_uint16_t _dbus_unpack_uint16 (int byte_order,
const unsigned char *data);
#endif
int byte_order,
unsigned char *data);
#ifndef _dbus_unpack_uint32
+DBUS_PRIVATE_EXPORT
dbus_uint32_t _dbus_unpack_uint32 (int byte_order,
const unsigned char *data);
#endif
int element_type,
int byte_order,
int *pos);
+DBUS_PRIVATE_EXPORT
void _dbus_marshal_set_uint32 (DBusString *str,
int pos,
dbus_uint32_t value,
int byte_order);
+DBUS_PRIVATE_EXPORT
dbus_uint32_t _dbus_marshal_read_uint32 (const DBusString *str,
int pos,
int byte_order,
int *new_pos);
int _dbus_type_get_alignment (int typecode);
int _dbus_type_get_alignment (int typecode);
+DBUS_PRIVATE_EXPORT
const char* _dbus_type_to_string (int typecode);
+DBUS_PRIVATE_EXPORT
int _dbus_first_type_in_signature (const DBusString *str,
int pos);
#include <dbus/dbus-protocol.h>
#include <dbus/dbus-marshal-recursive.h>
+DBUS_PRIVATE_EXPORT
void _dbus_marshal_byteswap (const DBusString *signature,
int signature_start,
int old_byte_order,
dbus_uint32_t _dbus_header_get_serial (DBusHeader *header);
void _dbus_header_update_lengths (DBusHeader *header,
int body_len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_header_set_field_basic (DBusHeader *header,
int field,
int type,
int field,
int type,
void *value);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_header_get_field_raw (DBusHeader *header,
int field,
const DBusString **str,
int *pos);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_header_delete_field (DBusHeader *header,
int field);
void _dbus_header_toggle_flag (DBusHeader *header,
int len);
void _dbus_header_byteswap (DBusHeader *header,
int new_order);
+DBUS_PRIVATE_EXPORT
char _dbus_header_get_byte_order (const DBusHeader *header);
int new_len; /**< the new value of the length in the written-out block */
};
+DBUS_PRIVATE_EXPORT
void _dbus_type_reader_init (DBusTypeReader *reader,
int byte_order,
const DBusString *type_str,
int type_pos,
const DBusString *value_str,
int value_pos);
+DBUS_PRIVATE_EXPORT
void _dbus_type_reader_init_types_only (DBusTypeReader *reader,
const DBusString *type_str,
int type_pos);
+DBUS_PRIVATE_EXPORT
int _dbus_type_reader_get_current_type (const DBusTypeReader *reader);
+DBUS_PRIVATE_EXPORT
int _dbus_type_reader_get_element_type (const DBusTypeReader *reader);
int _dbus_type_reader_get_value_pos (const DBusTypeReader *reader);
+DBUS_PRIVATE_EXPORT
void _dbus_type_reader_read_basic (const DBusTypeReader *reader,
void *value);
int _dbus_type_reader_get_array_length (const DBusTypeReader *reader);
+DBUS_PRIVATE_EXPORT
void _dbus_type_reader_read_fixed_multi (const DBusTypeReader *reader,
void *value,
int *n_elements);
void _dbus_type_reader_read_raw (const DBusTypeReader *reader,
const unsigned char **value_location);
+DBUS_PRIVATE_EXPORT
void _dbus_type_reader_recurse (DBusTypeReader *reader,
DBusTypeReader *subreader);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_reader_next (DBusTypeReader *reader);
dbus_bool_t _dbus_type_reader_has_next (const DBusTypeReader *reader);
+DBUS_PRIVATE_EXPORT
void _dbus_type_reader_get_signature (const DBusTypeReader *reader,
const DBusString **str_p,
int *start_p,
int *len_p);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_reader_set_basic (DBusTypeReader *reader,
const void *value,
const DBusTypeReader *realign_root);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_reader_delete (DBusTypeReader *reader,
const DBusTypeReader *realign_root);
void _dbus_type_signature_next (const char *signature,
int *type_pos);
+DBUS_PRIVATE_EXPORT
void _dbus_type_writer_init (DBusTypeWriter *writer,
int byte_order,
DBusString *type_str,
DBusString *type_str,
int type_pos);
void _dbus_type_writer_remove_types (DBusTypeWriter *writer);
+DBUS_PRIVATE_EXPORT
void _dbus_type_writer_init_values_only (DBusTypeWriter *writer,
int byte_order,
const DBusString *type_str,
int type_pos,
DBusString *value_str,
int value_pos);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_writer_write_basic (DBusTypeWriter *writer,
int type,
const void *value);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_writer_write_fixed_multi (DBusTypeWriter *writer,
int element_type,
const void *value,
int n_elements);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_writer_recurse (DBusTypeWriter *writer,
int container_type,
const DBusString *contained_type,
int contained_type_start,
DBusTypeWriter *sub);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_writer_unrecurse (DBusTypeWriter *writer,
DBusTypeWriter *sub);
dbus_bool_t _dbus_type_writer_append_array (DBusTypeWriter *writer,
const DBusString *contained_type,
int contained_type_start,
DBusTypeWriter *sub);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_type_writer_write_reader (DBusTypeWriter *writer,
DBusTypeReader *reader);
DBUS_VALIDITY_LAST
} DBusValidity;
+DBUS_PRIVATE_EXPORT
DBusValidity _dbus_validate_signature_with_reason (const DBusString *type_str,
int type_pos,
int len);
+DBUS_PRIVATE_EXPORT
DBusValidity _dbus_validate_body_with_reason (const DBusString *expected_signature,
int expected_signature_start,
int byte_order,
const char *_dbus_validity_to_error_message (DBusValidity validity);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_path (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_interface (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_member (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_error_name (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_bus_name (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_bus_namespace (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_validate_signature (const DBusString *str,
int start,
int len);
typedef struct DBusMemPool DBusMemPool;
+DBUS_PRIVATE_EXPORT
DBusMemPool* _dbus_mem_pool_new (int element_size,
dbus_bool_t zero_elements);
+DBUS_PRIVATE_EXPORT
void _dbus_mem_pool_free (DBusMemPool *pool);
+DBUS_PRIVATE_EXPORT
void* _dbus_mem_pool_alloc (DBusMemPool *pool);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_mem_pool_dealloc (DBusMemPool *pool,
void *element);
void _dbus_message_get_network_data (DBusMessage *message,
const DBusString **header,
const DBusString **body);
+DBUS_PRIVATE_EXPORT
void _dbus_message_get_unix_fds (DBusMessage *message,
const int **fds,
unsigned *n_fds);
void _dbus_message_remove_counter (DBusMessage *message,
DBusCounter *counter);
+DBUS_PRIVATE_EXPORT
DBusMessageLoader* _dbus_message_loader_new (void);
+DBUS_PRIVATE_EXPORT
DBusMessageLoader* _dbus_message_loader_ref (DBusMessageLoader *loader);
+DBUS_PRIVATE_EXPORT
void _dbus_message_loader_unref (DBusMessageLoader *loader);
+DBUS_PRIVATE_EXPORT
void _dbus_message_loader_get_buffer (DBusMessageLoader *loader,
DBusString **buffer);
+DBUS_PRIVATE_EXPORT
void _dbus_message_loader_return_buffer (DBusMessageLoader *loader,
DBusString *buffer);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_message_loader_get_unix_fds (DBusMessageLoader *loader,
int **fds,
unsigned *max_n_fds);
+DBUS_PRIVATE_EXPORT
void _dbus_message_loader_return_unix_fds (DBusMessageLoader *loader,
int *fds,
unsigned n_fds);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_message_loader_queue_messages (DBusMessageLoader *loader);
DBusMessage* _dbus_message_loader_peek_message (DBusMessageLoader *loader);
+DBUS_PRIVATE_EXPORT
DBusMessage* _dbus_message_loader_pop_message (DBusMessageLoader *loader);
DBusList* _dbus_message_loader_pop_message_link (DBusMessageLoader *loader);
void _dbus_message_loader_putback_message_link (DBusMessageLoader *loader,
DBusList *link);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_message_loader_get_is_corrupted (DBusMessageLoader *loader);
DBusValidity _dbus_message_loader_get_corruption_reason (DBusMessageLoader *loader);
void _dbus_message_loader_set_max_message_size (DBusMessageLoader *loader,
long size);
+DBUS_PRIVATE_EXPORT
long _dbus_message_loader_get_max_message_size (DBusMessageLoader *loader);
void _dbus_message_loader_set_max_message_unix_fds(DBusMessageLoader *loader,
#endif
};
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_message_iter_get_args_valist (DBusMessageIter *iter,
DBusError *error,
int first_arg_type,
dbus_bool_t _dbus_pending_call_set_timeout_error_unlocked (DBusPendingCall *pending,
DBusMessage *message,
dbus_uint32_t serial);
+DBUS_PRIVATE_EXPORT
DBusPendingCall* _dbus_pending_call_new_unlocked (DBusConnection *connection,
int timeout_milliseconds,
DBusTimeoutHandler timeout_handler);
+DBUS_PRIVATE_EXPORT
DBusPendingCall* _dbus_pending_call_ref_unlocked (DBusPendingCall *pending);
+DBUS_PRIVATE_EXPORT
void _dbus_pending_call_unref_and_unlock (DBusPendingCall *pending);
dbus_bool_t _dbus_pending_call_set_data_unlocked (DBusPendingCall *pending,
dbus_int32_t slot,
int fd;
};
+DBUS_PRIVATE_EXPORT
void _dbus_pipe_init (DBusPipe *pipe,
int fd);
+DBUS_PRIVATE_EXPORT
void _dbus_pipe_init_stdout (DBusPipe *pipe);
+DBUS_PRIVATE_EXPORT
int _dbus_pipe_write (DBusPipe *pipe,
const DBusString *buffer,
int start,
int len,
DBusError *error);
+DBUS_PRIVATE_EXPORT
int _dbus_pipe_close (DBusPipe *pipe,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_pipe_is_valid (DBusPipe *pipe);
+DBUS_PRIVATE_EXPORT
void _dbus_pipe_invalidate (DBusPipe *pipe);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_pipe_is_stdout_or_stderr (DBusPipe *pipe);
#endif
DBusWatch *watch);
void _dbus_server_remove_watch (DBusServer *server,
DBusWatch *watch);
+DBUS_PRIVATE_EXPORT
void _dbus_server_toggle_all_watches (DBusServer *server,
dbus_bool_t enabled);
dbus_bool_t _dbus_server_add_timeout (DBusServer *server,
DBusTimeout *timeout,
dbus_bool_t enabled);
+DBUS_PRIVATE_EXPORT
void _dbus_server_ref_unlocked (DBusServer *server);
+DBUS_PRIVATE_EXPORT
void _dbus_server_unref_unlocked (DBusServer *server);
typedef enum
DBusNonceFile *noncefile);
DBusServer* _dbus_server_new_for_autolaunch (const DBusString *address,
DBusError *error);
+DBUS_PRIVATE_EXPORT
DBusServer* _dbus_server_new_for_tcp_socket (const char *host,
const char *bind,
const char *port,
#define _dbus_string_get_const_data_len(s,start,len) (((const char*)(((DBusString*)(s))->dummy1)) + (start))
#endif
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_init (DBusString *str);
+DBUS_PRIVATE_EXPORT
void _dbus_string_init_const (DBusString *str,
const char *value);
+DBUS_PRIVATE_EXPORT
void _dbus_string_init_const_len (DBusString *str,
const char *value,
int len);
dbus_bool_t _dbus_string_init_preallocated (DBusString *str,
int allocate_size);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_init_from_string (DBusString *str,
const DBusString *from);
+DBUS_PRIVATE_EXPORT
void _dbus_string_free (DBusString *str);
void _dbus_string_lock (DBusString *str);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_compact (DBusString *str,
int max_waste);
#ifndef _dbus_string_get_data
+DBUS_PRIVATE_EXPORT
char* _dbus_string_get_data (DBusString *str);
#endif /* _dbus_string_get_data */
#ifndef _dbus_string_get_const_data
+DBUS_PRIVATE_EXPORT
const char* _dbus_string_get_const_data (const DBusString *str);
#endif /* _dbus_string_get_const_data */
char* _dbus_string_get_data_len (DBusString *str,
int start,
int len);
#ifndef _dbus_string_get_const_data_len
+DBUS_PRIVATE_EXPORT
const char* _dbus_string_get_const_data_len (const DBusString *str,
int start,
int len);
#endif
#ifndef _dbus_string_set_byte
+DBUS_PRIVATE_EXPORT
void _dbus_string_set_byte (DBusString *str,
int i,
unsigned char byte);
#endif
#ifndef _dbus_string_get_byte
+DBUS_PRIVATE_EXPORT
unsigned char _dbus_string_get_byte (const DBusString *str,
int start);
#endif /* _dbus_string_get_byte */
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_insert_bytes (DBusString *str,
int i,
int n_bytes,
unsigned char byte);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_insert_byte (DBusString *str,
int i,
unsigned char byte);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_steal_data (DBusString *str,
char **data_return);
dbus_bool_t _dbus_string_steal_data_len (DBusString *str,
char **data_return,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_copy_data (const DBusString *str,
char **data_return);
dbus_bool_t _dbus_string_copy_data_len (const DBusString *str,
void _dbus_string_copy_to_buffer (const DBusString *str,
char *buffer,
int len);
+DBUS_PRIVATE_EXPORT
void _dbus_string_copy_to_buffer_with_nul (const DBusString *str,
char *buffer,
int avail_len);
#ifndef _dbus_string_get_length
+DBUS_PRIVATE_EXPORT
int _dbus_string_get_length (const DBusString *str);
#endif /* !_dbus_string_get_length */
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_lengthen (DBusString *str,
int additional_length);
+DBUS_PRIVATE_EXPORT
void _dbus_string_shorten (DBusString *str,
int length_to_remove);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_set_length (DBusString *str,
int length);
dbus_bool_t _dbus_string_align_length (DBusString *str,
int alignment);
dbus_bool_t _dbus_string_alloc_space (DBusString *str,
int extra_bytes);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append (DBusString *str,
const char *buffer);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append_len (DBusString *str,
const char *buffer,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append_int (DBusString *str,
long value);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append_uint (DBusString *str,
unsigned long value);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append_byte (DBusString *str,
unsigned char byte);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append_printf (DBusString *str,
const char *format,
...) _DBUS_GNUC_PRINTF (2, 3);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_append_printf_valist (DBusString *str,
const char *format,
va_list args);
dbus_bool_t _dbus_string_insert_alignment (DBusString *str,
int *insert_at,
int alignment);
+DBUS_PRIVATE_EXPORT
void _dbus_string_delete (DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_move (DBusString *source,
int start,
DBusString *dest,
int insert_at);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_copy (const DBusString *source,
int start,
DBusString *dest,
int len,
DBusString *dest,
int insert_at);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_copy_len (const DBusString *source,
int start,
int len,
DBusString *dest,
int insert_at);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_replace_len (const DBusString *source,
int start,
int len,
DBusString *dest,
int replace_at,
int replace_len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_split_on_byte (DBusString *source,
unsigned char byte,
DBusString *tail);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_parse_int (const DBusString *str,
int start,
long *value_return,
int *end_return);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_parse_uint (const DBusString *str,
int start,
unsigned long *value_return,
int *end_return);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_find (const DBusString *str,
int start,
const char *substr,
int *found);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_find_eol (const DBusString *str,
int start,
int *found,
int *found_len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_find_to (const DBusString *str,
int start,
int end,
int start,
unsigned char byte,
int *found);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_find_blank (const DBusString *str,
int start,
int *found);
+DBUS_PRIVATE_EXPORT
void _dbus_string_skip_blank (const DBusString *str,
int start,
int *end);
+DBUS_PRIVATE_EXPORT
void _dbus_string_skip_white (const DBusString *str,
int start,
int *end);
void _dbus_string_skip_white_reverse (const DBusString *str,
int end,
int *start);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_equal (const DBusString *a,
const DBusString *b);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_equal_c_str (const DBusString *a,
const char *c_str);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_equal_len (const DBusString *a,
const DBusString *b,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_equal_substring (const DBusString *a,
int a_start,
int a_len,
const DBusString *b,
int b_start);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_starts_with_c_str (const DBusString *a,
const char *c_str);
dbus_bool_t _dbus_string_ends_with_c_str (const DBusString *a,
const char *c_str);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_pop_line (DBusString *source,
DBusString *dest);
+DBUS_PRIVATE_EXPORT
void _dbus_string_delete_first_word (DBusString *str);
+DBUS_PRIVATE_EXPORT
void _dbus_string_delete_leading_blanks (DBusString *str);
+DBUS_PRIVATE_EXPORT
void _dbus_string_chop_white (DBusString *str);
dbus_bool_t _dbus_string_append_byte_as_hex (DBusString *str,
unsigned char byte);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_hex_encode (const DBusString *source,
int start,
DBusString *dest,
int insert_at);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_hex_decode (const DBusString *source,
int start,
int *end_return,
DBusString *dest,
int insert_at);
+DBUS_PRIVATE_EXPORT
void _dbus_string_tolower_ascii (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
void _dbus_string_toupper_ascii (const DBusString *str,
int start,
int len);
dbus_bool_t _dbus_string_validate_ascii (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_validate_utf8 (const DBusString *str,
int start,
int len);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_string_validate_nul (const DBusString *str,
int start,
int len);
* @{
*/
+DBUS_PRIVATE_EXPORT
dbus_bool_t
_dbus_close (int fd,
DBusError *error);
+DBUS_PRIVATE_EXPORT
int _dbus_dup (int fd,
DBusError *error);
+DBUS_PRIVATE_EXPORT
int
_dbus_read (int fd,
DBusString *buffer,
void _dbus_group_info_free (DBusGroupInfo *info);
dbus_uid_t _dbus_getuid (void);
+DBUS_PRIVATE_EXPORT
dbus_uid_t _dbus_geteuid (void);
dbus_bool_t _dbus_parse_uid (const DBusString *uid_str,
dbus_uid_t *uid);
+DBUS_PRIVATE_EXPORT
void _dbus_close_all (void);
dbus_bool_t _dbus_append_address_from_socket (int fd,
DBusString *address,
DBusError *error);
+DBUS_PRIVATE_EXPORT
void _dbus_fd_set_close_on_exec (int fd);
/** @} */
void _dbus_win_set_errno (int err);
+DBUS_PRIVATE_EXPORT
const char* _dbus_win_error_from_last_error (void);
dbus_bool_t _dbus_win_startup_winsock (void);
void _dbus_win_warn_win_error (const char *message,
unsigned long code);
+DBUS_PRIVATE_EXPORT
char * _dbus_win_error_string (int error_number);
+DBUS_PRIVATE_EXPORT
void _dbus_win_free_error_string (char *string);
extern const char* _dbus_lm_strerror (int error_number);
char *_dbus_win_utf16_to_utf8 (const wchar_t *str,
DBusError *error);
+DBUS_PRIVATE_EXPORT
void _dbus_win_set_error_from_win_error (DBusError *error, int code);
dbus_bool_t
dbus_bool_t _dbus_file_exists (const char *filename);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_get_config_file_name(DBusString *config_file,
char *s);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_get_install_root(char *prefix, int len);
void _dbus_threads_windows_init_global (void);
void _dbus_threads_windows_ensure_ctor_linked (void);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_getsid(char **sid, dbus_pid_t process_id);
#endif
void _dbus_abort (void) _DBUS_GNUC_NORETURN;
dbus_bool_t _dbus_check_setuid (void);
+DBUS_PRIVATE_EXPORT
const char* _dbus_getenv (const char *varname);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_clearenv (void);
char ** _dbus_get_environment (void);
*
*/
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_close_socket (int fd,
DBusError *error);
+DBUS_PRIVATE_EXPORT
int _dbus_read_socket (int fd,
DBusString *buffer,
int count);
+DBUS_PRIVATE_EXPORT
int _dbus_write_socket (int fd,
const DBusString *buffer,
int start,
int count,
int *fds,
int *n_fds);
+DBUS_PRIVATE_EXPORT
int _dbus_write_socket_with_unix_fds (int fd,
const DBusString *buffer,
int start,
dbus_bool_t _dbus_credentials_add_from_user (DBusCredentials *credentials,
const DBusString *username);
dbus_bool_t _dbus_credentials_add_from_current_process (DBusCredentials *credentials);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_append_user_from_current_process (DBusString *str);
dbus_bool_t _dbus_parse_unix_user_from_config (const DBusString *username,
short revents; /**< Events that occurred */
} DBusPollFD;
+DBUS_PRIVATE_EXPORT
int _dbus_poll (DBusPollFD *fds,
int n_fds,
int timeout_milliseconds);
+DBUS_PRIVATE_EXPORT
void _dbus_sleep_milliseconds (int milliseconds);
+DBUS_PRIVATE_EXPORT
void _dbus_get_monotonic_time (long *tv_sec,
long *tv_usec);
/**
* directory interface
*/
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_create_directory (const DBusString *filename,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_delete_directory (const DBusString *filename,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_concat_dir_and_file (DBusString *dir,
const DBusString *next_component);
dbus_bool_t _dbus_string_get_dirname (const DBusString *filename,
DBusString *dirname);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_path_is_absolute (const DBusString *filename);
dbus_bool_t _dbus_get_standard_session_servicedirs (DBusList **dirs);
dbus_bool_t _dbus_check_dir_is_private_to_user (DBusString *dir,
DBusError *error);
+DBUS_PRIVATE_EXPORT
const char* _dbus_get_tmpdir (void);
/**
int n_bytes);
dbus_bool_t _dbus_generate_random_bytes (DBusString *str,
int n_bytes);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_generate_random_ascii (DBusString *str,
int n_bytes);
+DBUS_PRIVATE_EXPORT
const char* _dbus_error_from_errno (int error_number);
+DBUS_PRIVATE_EXPORT
const char* _dbus_error_from_system_errno (void);
int _dbus_save_socket_errno (void);
dbus_bool_t _dbus_get_is_errno_eintr (int e);
dbus_bool_t _dbus_get_is_errno_epipe (int e);
dbus_bool_t _dbus_get_is_errno_etoomanyrefs (int e);
+DBUS_PRIVATE_EXPORT
const char* _dbus_strerror_from_errno (void);
void _dbus_disable_sigpipe (void);
-
+DBUS_PRIVATE_EXPORT
void _dbus_exit (int code) _DBUS_GNUC_NORETURN;
+DBUS_PRIVATE_EXPORT
int _dbus_printf_string_upper_bound (const char *format,
va_list args);
dbus_bool_t _dbus_stat (const DBusString *filename,
DBusStat *statbuf,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_full_duplex_pipe (int *fd1,
int *fd2,
dbus_bool_t blocking,
*/
void _dbus_threads_unlock_platform_specific (void);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_split_paths_and_append (DBusString *dirs,
const char *suffix,
DBusList **dir_list);
* the PID file handling just needs a little more abstraction
* in the bus daemon first.
*/
+DBUS_PRIVATE_EXPORT
dbus_pid_t _dbus_getpid (void);
dbus_bool_t _dbus_change_to_daemon_user (const char *user,
DBusError *error);
+DBUS_PRIVATE_EXPORT
void _dbus_flush_caches (void);
/*
#include <dbus/dbus-string.h>
#include <dbus/dbus-marshal-validate.h>
+/* Only things that are in libdbus-1.la and used from libdbus-internal.la
+ * need to have DBUS_PRIVATE_EXPORT. If you get
+ *
+ * warning: 'foo' redeclared without dllimport attribute: previous
+ * dllimport ignored [-Wattributes]
+ *
+ * then you have added too many.
+ */
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_hash_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_list_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_marshal_test (void);
+
dbus_bool_t _dbus_marshal_recursive_test (void);
dbus_bool_t _dbus_marshal_byteswap_test (void);
dbus_bool_t _dbus_marshal_validate_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_misc_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_signature_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_mem_pool_test (void);
+
dbus_bool_t _dbus_string_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_address_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_server_test (void);
+
dbus_bool_t _dbus_message_test (const char *test_data_dir);
dbus_bool_t _dbus_auth_test (const char *test_data_dir);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_sha_test (const char *test_data_dir);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_keyring_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_data_slot_test (void);
+
dbus_bool_t _dbus_sysdeps_test (void);
dbus_bool_t _dbus_spawn_test (const char *test_data_dir);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_userdb_test (const char *test_data_dir);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_transport_unix_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_memory_test (void);
+
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_object_tree_test (void);
+
dbus_bool_t _dbus_credentials_test (const char *test_data_dir);
void dbus_internal_do_not_use_run_tests (const char *test_data_dir,
DBUS_BEGIN_DECLS
+DBUS_PRIVATE_EXPORT
void _dbus_rmutex_lock (DBusRMutex *mutex);
+DBUS_PRIVATE_EXPORT
void _dbus_rmutex_unlock (DBusRMutex *mutex);
void _dbus_rmutex_new_at_location (DBusRMutex **location_p);
void _dbus_rmutex_free_at_location (DBusRMutex **location_p);
/** function to run when the timeout is handled */
typedef dbus_bool_t (* DBusTimeoutHandler) (void *data);
+DBUS_PRIVATE_EXPORT
DBusTimeout* _dbus_timeout_new (int interval,
DBusTimeoutHandler handler,
void *data,
DBusFreeFunction free_data_function);
DBusTimeout* _dbus_timeout_ref (DBusTimeout *timeout);
+DBUS_PRIVATE_EXPORT
void _dbus_timeout_unref (DBusTimeout *timeout);
+DBUS_PRIVATE_EXPORT
void _dbus_timeout_set_interval (DBusTimeout *timeout,
int interval);
+DBUS_PRIVATE_EXPORT
void _dbus_timeout_set_enabled (DBusTimeout *timeout,
dbus_bool_t enabled);
DBusUserDatabase* _dbus_user_database_ref (DBusUserDatabase *db);
void _dbus_user_database_flush (DBusUserDatabase *db);
void _dbus_user_database_unref (DBusUserDatabase *db);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_user_database_get_uid (DBusUserDatabase *db,
dbus_uid_t uid,
const DBusUserInfo **info,
dbus_gid_t gid,
const DBusGroupInfo **info,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_user_database_get_username (DBusUserDatabase *db,
const DBusString *username,
const DBusUserInfo **info,
const DBusGroupInfo **info,
DBusError *error);
+DBUS_PRIVATE_EXPORT
DBusUserInfo* _dbus_user_database_lookup (DBusUserDatabase *db,
dbus_uid_t uid,
const DBusString *username,
DBusError *error);
+DBUS_PRIVATE_EXPORT
DBusGroupInfo* _dbus_user_database_lookup_group (DBusUserDatabase *db,
dbus_gid_t gid,
const DBusString *groupname,
DBusError *error);
+DBUS_PRIVATE_EXPORT
void _dbus_user_info_free_allocated (DBusUserInfo *info);
+DBUS_PRIVATE_EXPORT
void _dbus_group_info_free_allocated (DBusGroupInfo *info);
#endif /* DBUS_USERDB_INCLUDES_PRIVATE */
+DBUS_PRIVATE_EXPORT
DBusUserDatabase* _dbus_user_database_get_system (void);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_user_database_lock_system (void) _DBUS_GNUC_WARN_UNUSED_RESULT;
+DBUS_PRIVATE_EXPORT
void _dbus_user_database_unlock_system (void);
void _dbus_user_database_flush_system (void);
dbus_uid_t *uid);
dbus_bool_t _dbus_get_group_id (const DBusString *group_name,
dbus_gid_t *gid);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_get_user_id_and_primary_group (const DBusString *username,
dbus_uid_t *uid_p,
dbus_gid_t *gid_p);
dbus_bool_t _dbus_groups_from_uid (dbus_uid_t uid,
dbus_gid_t **group_ids,
int *n_group_ids);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_is_console_user (dbus_uid_t uid,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_is_a_number (const DBusString *str,
unsigned long *num);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_username_from_current_process (const DBusString **username);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_homedir_from_current_process (const DBusString **homedir);
dbus_bool_t _dbus_homedir_from_username (const DBusString *username,
DBusString *homedir);
DBUS_BEGIN_DECLS
+DBUS_PRIVATE_EXPORT
dbus_bool_t dbus_internal_do_not_use_get_uuid (const char *filename,
char **uuid_p,
dbus_bool_t create_if_not_found,
dbus_bool_t dbus_internal_do_not_use_ensure_uuid (const char *filename,
char **uuid_p,
DBusError *error);
+DBUS_PRIVATE_EXPORT
dbus_bool_t dbus_internal_do_not_use_create_uuid (char **uuid_p);
unsigned int flags,
void *data);
+DBUS_PRIVATE_EXPORT
DBusWatch* _dbus_watch_new (int fd,
unsigned int flags,
dbus_bool_t enabled,
DBusWatchHandler handler,
void *data,
DBusFreeFunction free_data_function);
+DBUS_PRIVATE_EXPORT
DBusWatch* _dbus_watch_ref (DBusWatch *watch);
+DBUS_PRIVATE_EXPORT
void _dbus_watch_unref (DBusWatch *watch);
+DBUS_PRIVATE_EXPORT
void _dbus_watch_invalidate (DBusWatch *watch);
void _dbus_watch_sanitize_condition (DBusWatch *watch,
unsigned int *condition);
DBusFreeFunction free_data_function);
+DBUS_PRIVATE_EXPORT
DBusWatchList* _dbus_watch_list_new (void);
+DBUS_PRIVATE_EXPORT
void _dbus_watch_list_free (DBusWatchList *watch_list);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_watch_list_set_functions (DBusWatchList *watch_list,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_watch_list_add_watch (DBusWatchList *watch_list,
DBusWatch *watch);
+DBUS_PRIVATE_EXPORT
void _dbus_watch_list_remove_watch (DBusWatchList *watch_list,
DBusWatch *watch);
void _dbus_watch_list_toggle_watch (DBusWatchList *watch_list,
dbus_bool_t enabled);
dbus_bool_t _dbus_watch_get_enabled (DBusWatch *watch);
+DBUS_PRIVATE_EXPORT
dbus_bool_t _dbus_watch_get_oom_last_time (DBusWatch *watch);
+DBUS_PRIVATE_EXPORT
void _dbus_watch_set_oom_last_time (DBusWatch *watch,
dbus_bool_t oom);
projects / thirdparty / dbus.git / commitdiff
