Inter-Process Communication Library

Data Structures
struct	eripc_arg_t
struct	eripc_event_info_t
struct	eripc_client_context_t
struct	eripc_device_caps_t
struct	eripc_callback_function_t
struct	_osso_callback_data_t
struct	_osso_handler_t
struct	_osso_hash_value_t
struct	osso_af_context_t
struct	_eripc_context_t
Files
file	eripc.h
	Public header for liberipc.
file	eripc_support.h
	Public header for liberipc support functions.
file	init.h
	This file implements all initialisation and shutdown of the library.
file	internal.h
	This file contains internal definitions.
Defines
#define	DBUS_API_SUBJECT_TO_CHANGE
#define	OSSO_BUS_ROOT   "com.irexnet"
#define	OSSO_BUS_ROOT_PATH   "/com/irexnet"
#define	ERIPC_PATH_MATCH_ALL   "eripc_path_match_all"
#define	ERIPC_MEMBER_MATCH_ALL   "eripc_member_match_all"
#define	MAX_IF_LEN   255
#define	MAX_SVC_LEN   255
#define	MAX_OP_LEN   255
#define	MAX_MEMBER_LEN   255
#define	MAX_ERROR_LEN   255
#define	MAX_HASH_KEY_LEN   (MAX_IF_LEN + MAX_SVC_LEN + MAX_OP_LEN)
#define	MAX_OPM_HASH_KEY_LEN   (MAX_OP_LEN + MAX_MEMBER_LEN)
#define	MAX_MSGID_LEN   (MAX_SVC_LEN + 20 + 20 + 2)
#define	MAX_APP_NAME_LEN   50
#define	MAX_VERSION_LEN   30
#define	ERIPC_MAX_ARGS   256
#define	ERIPC_MAX_MATCH_SIZE   256
#define	dprint(f, a...)
#define	ULOG_CRIT(...)   do {} while (0)
#define	ULOG_ERR(...)   do {} while (0)
#define	ULOG_WARN(...)   do {} while (0)
#define	ULOG_INFO(...)   do {} while (0)
#define	ULOG_DEBUG(...)   do {} while (0)
#define	ULOG_CRIT_L(...)   do {} while (0)
#define	ULOG_ERR_L(...)   do {} while (0)
#define	ULOG_WARN_L(...)   do {} while (0)
#define	ULOG_INFO_L(...)   do {} while (0)
#define	ULOG_DEBUG_L(...)   do {} while (0)
#define	ULOG_CRIT_F(...)   do {} while (0)
#define	ULOG_ERR_F(...)   do {} while (0)
#define	ULOG_WARN_F(...)   do {} while (0)
#define	ULOG_INFO_F(...)   do {} while (0)
#define	ULOG_DEBUG_F(...)   do {} while (0)
#define	DLOG_CRIT(...)   do {} while (0)
#define	DLOG_ERR(...)   do {} while (0)
#define	DLOG_WARN(...)   do {} while (0)
#define	DLOG_INFO(...)   do {} while (0)
#define	DLOG_DEBUG(...)   do {} while (0)
#define	DLOG_CRIT_L(...)   do {} while (0)
#define	DLOG_ERR_L(...)   do {} while (0)
#define	DLOG_WARN_L(...)   do {} while (0)
#define	DLOG_INFO_L(...)   do {} while (0)
#define	DLOG_DEBUG_L(...)   do {} while (0)
#define	DLOG_CRIT_F(...)   do {} while (0)
#define	DLOG_ERR_F(...)   do {} while (0)
#define	DLOG_WARN_F(...)   do {} while (0)
#define	DLOG_INFO_F(...)   do {} while (0)
#define	DLOG_DEBUG_F(...)   do {} while (0)
#define	ULOG_OPEN(X)   do {} while (0)
#define	DLOG_OPEN(X)   do {} while (0)
#define	LOG_CLOSE()   do {} while (0)
Typedefs
typedef struct _eripc_context_t	eripc_context_t
typedef void(	eripc_handler_t )(eripc_context_t *context, const eripc_event_info_t *info, void *user_data)
typedef struct osso_af_context_t	osso_context_t
typedef void(	_osso_handler_f )(osso_context_t *osso, DBusMessage *msg, _osso_callback_data_t *data, eripc_bus_t bus_type)
typedef struct osso_af_context_t	_eripc_context_t
typedef struct _eripc_context_t	_eripc_this_type_is_not_used_t
Enumerations
enum	eripc_error_t {   ERIPC_ERROR_SUCCESS = 0, ERIPC_ERROR_INVALID, ERIPC_ERROR_OOM, ERIPC_ERROR,   ERIPC_ERROR_TIMEOUT }
enum	eripc_data_t {   ERIPC_TYPE_INVALID = 0, ERIPC_TYPE_BOOL, ERIPC_TYPE_BYTE, ERIPC_TYPE_INT,   ERIPC_TYPE_UINT, ERIPC_TYPE_DOUBLE, ERIPC_TYPE_STRING, ERIPC_TYPE_DATA }
enum	eripc_bus_t { ERIPC_BUS_IRRELEVANT = 0, ERIPC_BUS_SYSTEM, ERIPC_BUS_SESSION, ERIPC_BUS_BOTH }
enum	eripc_event_t {   ERIPC_EVENT_NONE = 0, ERIPC_EVENT_MESSAGE, ERIPC_EVENT_SIGNAL, ERIPC_EVENT_MESSAGE_OR_SIGNAL,   ERIPC_EVENT_REPLY, ERIPC_EVENT_ERROR, ERIPC_EVENT_REPLY_OR_ERROR }
Functions
void *	eripc_get_system_connection (eripc_context_t *context)
void *	eripc_get_session_connection (eripc_context_t *context)
eripc_context_t *	eripc_init (const char *program_name, const char *program_version, GMainContext *context)
eripc_error_t	eripc_set_signal_handler (eripc_context_t *context, eripc_handler_t *handler, void *user_data, eripc_bus_t bus_type, const char *source, const char *signal_name, int *handler_id)
eripc_error_t	eripc_set_message_handler (eripc_context_t *context, eripc_handler_t *handler, void *user_data, eripc_bus_t bus_type, const char *source, const char *message_name, int *handler_id)
eripc_error_t	eripc_set_event_handler (eripc_context_t *context, const eripc_event_info_t *info, eripc_handler_t *handler, void *user_data, int *handler_id)
eripc_error_t	eripc_unset_handler (eripc_context_t *context, int handler_id)
eripc_error_t	eripc_get_timeout (eripc_context_t *context, int *timeout)
eripc_error_t	eripc_set_timeout (eripc_context_t *context, int timeout)
eripc_error_t	eripc_send_varargs (eripc_context_t *context, eripc_handler_t *reply_handler, const void *user_data, eripc_bus_t bus_type, const char *destination, const char *message_name, eripc_data_t arg_type,...)
eripc_error_t	eripc_send_string (eripc_context_t *context, eripc_handler_t *reply_handler, const void *user_data, eripc_bus_t bus_type, const char *destination, const char *message_name, const char *string)
eripc_error_t	eripc_send_int (eripc_context_t *context, eripc_handler_t *reply_handler, const void *user_data, eripc_bus_t bus_type, const char *destination, const char *message_name, int value)
eripc_error_t	eripc_send_bool (eripc_context_t *context, eripc_handler_t *reply_handler, const void *user_data, eripc_bus_t bus_type, const char *destination, const char *message_name, gboolean value)
eripc_error_t	eripc_send_varargs_and_wait (eripc_context_t *context, eripc_event_info_t **reply, eripc_bus_t bus_type, const char *destination, const char *message_name, eripc_data_t arg_type,...)
eripc_error_t	eripc_send_string_and_wait (eripc_context_t *context, eripc_event_info_t **reply, eripc_bus_t bus_type, const char *destination, const char *message_name, const char *string)
eripc_error_t	eripc_send_int_and_wait (eripc_context_t *context, eripc_event_info_t **reply, eripc_bus_t bus_type, const char *destination, const char *message_name, int value)
eripc_error_t	eripc_send_bool_and_wait (eripc_context_t *context, eripc_event_info_t **reply, eripc_bus_t bus_type, const char *destination, const char *message_name, gboolean value)
eripc_error_t	eripc_send_signal (eripc_context_t *context, eripc_bus_t bus_type, const char *signal_name, const char *argument)
eripc_error_t	eripc_send_signal_varargs (eripc_context_t *context, eripc_bus_t bus_type, const char *signal_path, const char *signal_interface, const char *signal_name, eripc_data_t arg_type,...)
eripc_error_t	eripc_event_info_free (eripc_context_t *context, eripc_event_info_t *reply)
eripc_error_t	eripc_reply_varargs (eripc_context_t *context, const char *message_id, eripc_data_t arg_type,...)
eripc_error_t	eripc_reply_string (eripc_context_t *context, const char *message_id, const char *string)
eripc_error_t	eripc_reply_int (eripc_context_t *context, const char *message_id, int value)
eripc_error_t	eripc_reply_bool (eripc_context_t *context, const char *message_id, gboolean value)
eripc_error_t	eripc_reply_error (eripc_context_t *context, const char *message_id, const char *error_name, const char *error_message)
eripc_client_context_t *	eripc_client_context_new (const char *name, const char *version, const char *service, const char *path, const char *interface, eripc_callback_function_t *callbacks)
void	eripc_client_context_free (eripc_client_context_t *ccontext, eripc_callback_function_t *callbacks)
const gchar *	eripc_error_string (eripc_error_t errorcode)
gboolean	eripc_menu_add_menu (eripc_client_context_t *ccontext, const char *name, const char *group1, const char *group2, const char *group3, const char *group4)
gboolean	eripc_menu_remove_menu (eripc_client_context_t *ccontext, const char *name)
gboolean	eripc_menu_add_group (eripc_client_context_t *ccontext, const char *name, const char *parent, const char *image)
gboolean	eripc_menu_add_item (eripc_client_context_t *ccontext, const char *name, const char *parent, const char *image)
gboolean	eripc_menu_set_menu_label (eripc_client_context_t *ccontext, const char *name, const char *label)
gboolean	eripc_menu_set_group_label (eripc_client_context_t *ccontext, const char *name, const char *label)
gboolean	eripc_menu_set_item_label (eripc_client_context_t *ccontext, const char *name, const char *parent, const char *label)
gboolean	eripc_menu_show_menu (eripc_client_context_t *ccontext, const char *name)
gboolean	eripc_menu_set_group_state (eripc_client_context_t *ccontext, const char *name, const char *state)
gboolean	eripc_menu_set_item_state (eripc_client_context_t *ccontext, const char *name, const char *parent, const char *state)
gboolean	eripc_menu_set_pagecounter (eripc_client_context_t *ccontext, int cur_page, int num_pages, gboolean boundary_check)
gboolean	eripc_menu_set_statusitem_state (eripc_client_context_t *ccontext, const char *item, const char *state)
gboolean	eripc_sysd_set_menu_state (eripc_client_context_t *ccontext, const char *state)
gboolean	eripc_sysd_mount_sd_card (eripc_client_context_t *ccontext, gboolean show_index_splash)
gboolean	eripc_sysd_unmount_sd_card (eripc_client_context_t *ccontext)
gboolean	eripc_sysd_set_busy (eripc_client_context_t *ccontext, const char *state, const char *message)
gboolean	eripc_sysd_reset_busy (eripc_client_context_t *ccontext)
gboolean	eripc_sysd_set_bg_busy (eripc_client_context_t *ccontext)
gboolean	eripc_sysd_reset_bg_busy (eripc_client_context_t *ccontext)
gboolean	eripc_sysd_set_keyboard (eripc_client_context_t *ccontext, const char *state)
gboolean	eripc_sysd_startup_complete (eripc_client_context_t *ccontext, const int pid, const gboolean is_multidoc, const int xid)
gint	eripc_sysd_start_task (eripc_client_context_t *ccontext, const gchar *cmd_line, const gchar *work_dir, const gchar *label, const gchar *thumbnail_path, gchar **err_message)
gboolean	eripc_sysd_stop_task (eripc_client_context_t *ccontext, const char *cmd_line)
gint	eripc_sysd_open_url (eripc_client_context_t *ccontext, const gchar *url, const gchar *label, const gchar *back_text, gchar **err_message)
gboolean	eripc_sysd_get_device_capabilities (eripc_client_context_t *ccontext, eripc_device_caps_t *caps)
gboolean	eripc_sysd_conn_connect (eripc_client_context_t *ccontext, const char *medium, const char *profile)
gboolean	eripc_sysd_conn_disconnect (eripc_client_context_t *ccontext)
gboolean	eripc_sysd_conn_status_request (eripc_client_context_t *ccontext)
static gboolean	_validate (const gchar *application, const gchar *version)
static osso_context_t *	_init (const char *application, const char *version)
static void	_deinit (osso_context_t *osso)
static DBusConnection *	_dbus_setup (osso_context_t *osso, DBusBusType bus_type, GMainContext *context)
int	__attribute__ ((visibility("hidden"))) eripc_convert_msgtype(int t)
eripc_arg_t *	_get_args (DBusMessageIter *iter)
gboolean	validate_appname (const gchar *application)
Variables
DBusHandlerResult DBusMessage *	msg
DBusHandlerResult DBusMessage void *	data
void char *	interface
void char *	service
void char *	path
void const char *	name
void const char char *	ready_name
gboolean _osso_handler_f *	handler
gboolean _osso_handler_f _osso_callback_data_t int	handler_id
gboolean _osso_handler_f _osso_callback_data_t int gboolean	call_once_per_handler_id
void eripc_bus_t *	bus
void eripc_bus_t char *	sender
void eripc_bus_t char int *	serial
void const char int char *	id

---

Define Documentation

#define DBUS_API_SUBJECT_TO_CHANGE

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Based on code found in libosso library by Kimmo Hämäläinen <kimmo.hamalainen@nokia.com>

Definition at line 35 of file internal.h.

#define DLOG_CRIT

(

...

)

do {} while (0)

Definition at line 277 of file eripc/include/log.h.

#define DLOG_CRIT_F

(

...

)

do {} while (0)

Definition at line 287 of file eripc/include/log.h.

#define DLOG_CRIT_L

(

...

)

do {} while (0)

Definition at line 282 of file eripc/include/log.h.

#define DLOG_DEBUG

(

...

)

do {} while (0)

Definition at line 281 of file eripc/include/log.h.

#define DLOG_DEBUG_F

(

...

)

do {} while (0)

Definition at line 291 of file eripc/include/log.h.

#define DLOG_DEBUG_L

(

...

)

do {} while (0)

Definition at line 286 of file eripc/include/log.h.

#define DLOG_ERR

(

...

)

do {} while (0)

Definition at line 278 of file eripc/include/log.h.

#define DLOG_ERR_F

(

...

)

do {} while (0)

Definition at line 288 of file eripc/include/log.h.

#define DLOG_ERR_L

(

...

)

do {} while (0)

Definition at line 283 of file eripc/include/log.h.

#define DLOG_INFO

(

...

)

do {} while (0)

Definition at line 280 of file eripc/include/log.h.

#define DLOG_INFO_F

(

...

)

do {} while (0)

Definition at line 290 of file eripc/include/log.h.

#define DLOG_INFO_L

(

...

)

do {} while (0)

Definition at line 285 of file eripc/include/log.h.

#define DLOG_OPEN

(

X

)

do {} while (0)

Definition at line 294 of file eripc/include/log.h.

#define DLOG_WARN

(

...

)

do {} while (0)

Definition at line 279 of file eripc/include/log.h.

#define DLOG_WARN_F

(

...

)

do {} while (0)

Definition at line 289 of file eripc/include/log.h.

#define DLOG_WARN_L

(

...

)

do {} while (0)

Definition at line 284 of file eripc/include/log.h.

#define dprint	(	f,
		a...		)

Definition at line 174 of file internal.h.

Referenced by _dbus_setup().

#define ERIPC_MAX_ARGS   256

Definition at line 71 of file internal.h.

Referenced by _get_args().

#define ERIPC_MAX_MATCH_SIZE   256

Definition at line 72 of file internal.h.

Referenced by compose_match().

#define ERIPC_MEMBER_MATCH_ALL   "eripc_member_match_all"

Definition at line 56 of file internal.h.

Referenced by __attribute__(), _send_helper(), compose_opm_hash_key(), and opm_match().

#define ERIPC_PATH_MATCH_ALL   "eripc_path_match_all"

Definition at line 55 of file internal.h.

Referenced by __attribute__(), _send_helper(), compose_opm_hash_key(), and opm_match().

 

#define LOG_CLOSE

(

)

do {} while (0)

Definition at line 295 of file eripc/include/log.h.

#define MAX_APP_NAME_LEN   50

Definition at line 68 of file internal.h.

Referenced by _init().

#define MAX_ERROR_LEN   255

Definition at line 63 of file internal.h.

Referenced by eripc_reply_error().

#define MAX_HASH_KEY_LEN   (MAX_IF_LEN + MAX_SVC_LEN + MAX_OP_LEN)

Definition at line 64 of file internal.h.

#define MAX_IF_LEN   255

Definition at line 59 of file internal.h.

Referenced by __attribute__(), _send_helper(), and _send_sync_helper().

#define MAX_MEMBER_LEN   255

Definition at line 62 of file internal.h.

Referenced by compose_opm_hash_key(), and opm_match_helper().

#define MAX_MSGID_LEN   (MAX_SVC_LEN + 20 + 20 + 2)

Definition at line 66 of file internal.h.

Referenced by _make_id(), _send_sync_helper(), eripc_reply_handler(), and generic_signal_handler().

#define MAX_OP_LEN   255

Definition at line 61 of file internal.h.

Referenced by _send_helper(), _send_sync_helper(), compose_opm_hash_key(), and opm_match_helper().

#define MAX_OPM_HASH_KEY_LEN   (MAX_OP_LEN + MAX_MEMBER_LEN)

Definition at line 65 of file internal.h.

Referenced by __attribute__(), and opm_match().

#define MAX_SVC_LEN   255

Definition at line 60 of file internal.h.

Referenced by _parse_id(), _reply_helper(), _send_helper(), _send_sync_helper(), and eripc_reply_error().

#define MAX_VERSION_LEN   30

Definition at line 69 of file internal.h.

Referenced by _init().

#define OSSO_BUS_ROOT   "com.irexnet"

Definition at line 52 of file internal.h.

Referenced by __attribute__().

#define OSSO_BUS_ROOT_PATH   "/com/irexnet"

Definition at line 53 of file internal.h.

#define ULOG_CRIT

(

...

)

do {} while (0)

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Based on code found in libosso library by Kimmo Hämäläinen <kimmo.hamalainen@nokia.com>

Definition at line 261 of file eripc/include/log.h.

#define ULOG_CRIT_F

(

...

)

do {} while (0)

Definition at line 271 of file eripc/include/log.h.

Referenced by eripc_init(), and fix_name().

#define ULOG_CRIT_L

(

...

)

do {} while (0)

Definition at line 266 of file eripc/include/log.h.

#define ULOG_DEBUG

(

...

)

do {} while (0)

Definition at line 265 of file eripc/include/log.h.

#define ULOG_DEBUG_F

(

...

)

do {} while (0)

Definition at line 275 of file eripc/include/log.h.

Referenced by __attribute__(), _filter(), eripc_client_context_new(), eripc_init(), eripc_set_event_handler(), eripc_unset_handler(), generic_signal_handler(), parse_reply_capabilities(), parse_reply_start(), and remove_from_opm_hash().

#define ULOG_DEBUG_L

(

...

)

do {} while (0)

Definition at line 270 of file eripc/include/log.h.

#define ULOG_ERR

(

...

)

do {} while (0)

Definition at line 262 of file eripc/include/log.h.

Referenced by eripc_client_context_new().

#define ULOG_ERR_F

(

...

)

do {} while (0)

Definition at line 272 of file eripc/include/log.h.

Referenced by __attribute__(), _append_args(), _dbus_setup(), _get_args(), _init(), _reply_helper(), _send_helper(), _send_signal_helper(), _send_sync_helper(), _set_handler(), _validate(), add_to_opm_hash(), eripc_convert_msgtype(), eripc_reply_error(), eripc_set_event_handler(), and eripc_unset_handler().

#define ULOG_ERR_L

(

...

)

do {} while (0)

Definition at line 267 of file eripc/include/log.h.

#define ULOG_INFO

(

...

)

do {} while (0)

Definition at line 264 of file eripc/include/log.h.

#define ULOG_INFO_F

(

...

)

do {} while (0)

Definition at line 274 of file eripc/include/log.h.

#define ULOG_INFO_L

(

...

)

do {} while (0)

Definition at line 269 of file eripc/include/log.h.

#define ULOG_OPEN

(

X

)

do {} while (0)

Definition at line 293 of file eripc/include/log.h.

#define ULOG_WARN

(

...

)

do {} while (0)

Definition at line 263 of file eripc/include/log.h.

#define ULOG_WARN_F

(

...

)

do {} while (0)

Definition at line 273 of file eripc/include/log.h.

Referenced by __attribute__(), eripc_reply_handler(), and generic_signal_handler().

#define ULOG_WARN_L

(

...

)

do {} while (0)

Definition at line 268 of file eripc/include/log.h.

---

Typedef Documentation

typedef struct osso_af_context_t _eripc_context_t

This structure is used to store library specific stuff

typedef struct _eripc_context_t _eripc_this_type_is_not_used_t

typedef void( _osso_handler_f)(osso_context_t *osso, DBusMessage *msg, _osso_callback_data_t *data, eripc_bus_t bus_type)

Definition at line 92 of file internal.h.

typedef struct _eripc_context_t eripc_context_t

Definition at line 75 of file eripc.h.

typedef void( eripc_handler_t)(eripc_context_t *context, const eripc_event_info_t *info, void *user_data)

This is the type for the callback handlers of events and messages.

This function is called when the asynchronous function returns a reply or when a registered event occurs.

Parameters:

	context	IPC context returned by eripc_init.
	info	Structure specifying the type of event and its arguments.
	user_data	Optional user data passed when the handler was registered.

Definition at line 133 of file eripc.h.

typedef struct osso_af_context_t osso_context_t

Definition at line 137 of file eripc.h.

---

Enumeration Type Documentation

enum eripc_bus_t

Enumerator:

ERIPC_BUS_IRRELEVANT
ERIPC_BUS_SYSTEM
ERIPC_BUS_SESSION
ERIPC_BUS_BOTH

Definition at line 58 of file eripc.h.

             {
    ERIPC_BUS_IRRELEVANT = 0,
    ERIPC_BUS_SYSTEM,
    ERIPC_BUS_SESSION,
    ERIPC_BUS_BOTH
} eripc_bus_t;

enum eripc_data_t

Enumerator:

ERIPC_TYPE_INVALID
ERIPC_TYPE_BOOL
ERIPC_TYPE_BYTE
ERIPC_TYPE_INT
ERIPC_TYPE_UINT
ERIPC_TYPE_DOUBLE
ERIPC_TYPE_STRING
ERIPC_TYPE_DATA

Definition at line 47 of file eripc.h.

             {
    ERIPC_TYPE_INVALID = 0,
    ERIPC_TYPE_BOOL,
    ERIPC_TYPE_BYTE,
    ERIPC_TYPE_INT,
    ERIPC_TYPE_UINT,
    ERIPC_TYPE_DOUBLE,
    ERIPC_TYPE_STRING,
    ERIPC_TYPE_DATA
} eripc_data_t;

enum eripc_error_t

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Based on code found in libosso library by Kimmo Hämäläinen <kimmo.hamalainen@nokia.com>

Enumerator:

ERIPC_ERROR_SUCCESS
ERIPC_ERROR_INVALID
ERIPC_ERROR_OOM
ERIPC_ERROR
ERIPC_ERROR_TIMEOUT

Definition at line 39 of file eripc.h.

             {
    ERIPC_ERROR_SUCCESS =  0,   /* success (not an error) */
    ERIPC_ERROR_INVALID,        /* invalid arguments */ 
    ERIPC_ERROR_OOM,            /* out of memory */
    ERIPC_ERROR,                /* generic error code */
    ERIPC_ERROR_TIMEOUT,        /* timeout happened */
} eripc_error_t;

enum eripc_event_t

Enumerator:

ERIPC_EVENT_NONE
ERIPC_EVENT_MESSAGE
ERIPC_EVENT_SIGNAL
ERIPC_EVENT_MESSAGE_OR_SIGNAL
ERIPC_EVENT_REPLY
ERIPC_EVENT_ERROR
ERIPC_EVENT_REPLY_OR_ERROR

Definition at line 65 of file eripc.h.

             { 
    ERIPC_EVENT_NONE = 0,               /* non-event, event type is not relevant */
    ERIPC_EVENT_MESSAGE,                /* message received */
    ERIPC_EVENT_SIGNAL,                 /* signal received */
    ERIPC_EVENT_MESSAGE_OR_SIGNAL,      /* message or signal received */
    ERIPC_EVENT_REPLY,                  /* reply received */
    ERIPC_EVENT_ERROR,                  /* error reply received */
    ERIPC_EVENT_REPLY_OR_ERROR,         /* reply or error received */
} eripc_event_t;

---

Function Documentation

gboolean __attribute__

(

(visibility("hidden"))

)

Definition at line 145 of file init.c.

References MAX_IF_LEN, and OSSO_BUS_ROOT.

{
    assert(application != NULL);
    assert(interface != NULL);

    if (g_strrstr(application, ".") != NULL) {
        g_snprintf(interface, MAX_IF_LEN, "%s", application);
    } else {
        g_snprintf(interface, MAX_IF_LEN, OSSO_BUS_ROOT ".%s",
                   application);
    }
}

static DBusConnection* _dbus_setup	(	osso_context_t *	osso,
		DBusBusType	bus_type,
		GMainContext *	context
	)			[static]

This function connect to the given D-BUS bus and registers itself with the D-BUS daemon.

Parameters:

	osso	The osso_context_t for this connection.
	bus_type.	The DBusType to use.
	context	The GLib main-loop context to connect to, use NULL for the default context.

Returns:

The DBusConnection for the connection.

static void _deinit

(

osso_context_t *

osso

)

[static]

This function deinitializes the osso_type_t structure, but does not touch and D-BUS element. As a final thing it will destroy the osso_context_t structure.

Parameters:

osso

the disconnecte osso_context_t structure to destroy.

eripc_arg_t* _get_args

(

DBusMessageIter *

iter

)

Definition at line 62 of file hw.c.

References _get_byte_array(), eripc_arg_t::b, eripc_arg_t::by, eripc_arg_t::d, ERIPC_MAX_ARGS, ERIPC_TYPE_BOOL, ERIPC_TYPE_BYTE, ERIPC_TYPE_DOUBLE, ERIPC_TYPE_INT, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, ERIPC_TYPE_UINT, eripc_arg_t::i, eripc_arg_t::s, eripc_arg_t::type, eripc_arg_t::u, ULOG_ERR_F, and eripc_arg_t::value.

Referenced by _send_sync_helper(), eripc_reply_handler(), and generic_signal_handler().

{
    int type, idx = 0;
    eripc_arg_t *arg_array;

    arg_array = calloc(1, sizeof(eripc_arg_t) * (ERIPC_MAX_ARGS + 1));
    if (arg_array == NULL) {
            ULOG_ERR_F("calloc() failed: %s", strerror(errno));
            return NULL;
    }

    while ((type = dbus_message_iter_get_arg_type(iter))
           != DBUS_TYPE_INVALID) {

            int i;
            unsigned int u;
            double d;
            char c, *s;

            switch (type) {
                    case DBUS_TYPE_BOOLEAN:
                            arg_array[idx].type = ERIPC_TYPE_BOOL; 
                            dbus_message_iter_get_basic(iter, &i);
                            arg_array[idx].value.b = i ? 1 : 0;
                            ++idx;
                            break;
                    case DBUS_TYPE_INT32:
                            arg_array[idx].type = ERIPC_TYPE_INT; 
                            dbus_message_iter_get_basic(iter, &i);
                            arg_array[idx].value.i = i;
                            ++idx;
                            break;
                    case DBUS_TYPE_UINT32:
                            arg_array[idx].type = ERIPC_TYPE_UINT; 
                            dbus_message_iter_get_basic(iter, &u);
                            arg_array[idx].value.u = u;
                            ++idx;
                            break;
                    case DBUS_TYPE_DOUBLE:
                            arg_array[idx].type = ERIPC_TYPE_DOUBLE; 
                            dbus_message_iter_get_basic(iter, &d);
                            arg_array[idx].value.d = d;
                            ++idx;
                            break;
                    case DBUS_TYPE_BYTE:
                            arg_array[idx].type = ERIPC_TYPE_BYTE; 
                            dbus_message_iter_get_basic(iter, &c);
                            arg_array[idx].value.by = c;
                            ++idx;
                            break;
                    case DBUS_TYPE_STRING:
                            arg_array[idx].type = ERIPC_TYPE_STRING; 
                            dbus_message_iter_get_basic(iter, &s);
                            arg_array[idx].value.s = s;
                            ++idx;
                            break;
                    case DBUS_TYPE_ARRAY:
                            /* only byte arrays are supported */
                            if (dbus_message_iter_get_element_type(iter)
                                == DBUS_TYPE_BYTE) {
                                    _get_byte_array(iter,
                                                    &arg_array[idx]);
                                    ++idx;
                            } else {
                                    ULOG_ERR_F("arrays of type %d not"
                                               " supported",
                                    dbus_message_iter_get_element_type(iter));
                            }
                            break;
                    default:
                            ULOG_ERR_F("type %d not supported", type);
                            break;
            }

            dbus_message_iter_next(iter);
    }

    arg_array[idx].type = ERIPC_TYPE_INVALID;

    return arg_array;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static osso_context_t* _init	(	const char *	application,
		const char *	version
	)			[static]

This function allocates and initializes the osso_type_t structure

Parameters:

	application	The application name
	verson	The application version.

Returns:

the newly allocated osso_context_t structure, or NULL if there is an error.

static gboolean _validate	(	const gchar *	application,
		const gchar *	version
	)			[static]

Copyright (C) 2008 iRex Technologies B.V. All rights reserved.

Based on code found in libosso library by Kimmo Hämäläinen <kimmo.hamalainen@nokia.com> This internal function performs a simple validation for the application and version information of the osso_context regarding their validity as components of the filesystem (no slashes, value not NULL etc)

Parameters:

	application	The application name
	verson	The application version.

Returns:

TRUE if the context passes the validation, FALSE otherwise.

void eripc_client_context_free	(	eripc_client_context_t *	ccontext,
		eripc_callback_function_t *	callbacks
	)

Free a client context

Definition at line 269 of file support.c.

References eripc_client_context_t::context, eripc_unset_handler(), eripc_callback_function_t::handler_id, eripc_client_context_t::name, eripc_client_context_t::path, and eripc_client_context_t::service.

Referenced by notepad::ipc_unset_services(), and ipc_unset_services().

{
    if (callbacks != NULL)
    {
        for (int i = 0 ; callbacks[i].handler_id != 0 ; i++)
        {
            eripc_unset_handler(ccontext->context, callbacks[i].handler_id);
        }
    }

    if (ccontext)
    {
        free(ccontext->name);
        free(ccontext->service);
        free(ccontext->path);
        free(ccontext);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_client_context_t* eripc_client_context_new	(	const char *	name,
		const char *	version,
		const char *	service,
		const char *	path,
		const char *	interface,
		eripc_callback_function_t *	callbacks
	)

Create a new client context for a client application

Definition at line 189 of file support.c.

References eripc_client_context_t::context, ERIPC_BUS_SESSION, ERIPC_ERROR_SUCCESS, eripc_init(), eripc_set_message_handler(), eripc_set_signal_handler(), fix_name(), eripc_callback_function_t::handler, eripc_callback_function_t::handler_id, interface, eripc_callback_function_t::message_name, eripc_client_context_t::name, name, eripc_client_context_t::path, path, eripc_client_context_t::service, service, ULOG_DEBUG_F, and ULOG_ERR.

Referenced by ipc_init(), notepad::ipc_set_services(), ipc_set_services(), and main().

{
    int retval;
    eripc_client_context_t* ccontext;

    ccontext = (eripc_client_context_t*)malloc(sizeof(eripc_client_context_t));
    
    char *name      = fix_name(raw_name);
    char *service   = fix_name(raw_service);
    char *path      = fix_name(raw_path);
    char *interface = fix_name(raw_interface);
    
    ccontext->context = eripc_init(name, version, NULL);
    if (ccontext->context == NULL) 
    {
        // NOTE: MEMLEAK on name, service, path and interface!
        ULOG_ERR("Failed to initialize eripc context");
        free(ccontext);
        return NULL;
    }
    
    if (callbacks != NULL)
    {
        for (int i = 0 ; callbacks[i].handler != NULL ; i++)
        {
            if (callbacks[i].interface)
            {
                // install signal handler
                char *cb_interface = fix_name(callbacks[i].interface);
                retval = eripc_set_signal_handler( ccontext->context,
                                                   callbacks[i].handler,
                                                   NULL,
                                                   ERIPC_BUS_SESSION,
                                                   cb_interface,
                                                   callbacks[i].message_name,
                                                   &(callbacks[i].handler_id) );
                
                free(cb_interface);
                if (retval != ERIPC_ERROR_SUCCESS) 
                {
                    ULOG_DEBUG_F( "eripc_set_signal_handler %s returns %d",
                                 callbacks[i].message_name,
                                 retval );
                }
            }
            else
            {
                // install message handler
                retval = eripc_set_message_handler( ccontext->context,
                                                    callbacks[i].handler,
                                                    NULL,
                                                    ERIPC_BUS_SESSION,
                                                    interface,
                                                    callbacks[i].message_name,
                                                    &(callbacks[i].handler_id) );
                  
                if (retval != ERIPC_ERROR_SUCCESS) 
                {
                    ULOG_DEBUG_F( "eripc_set_message_handler %s returns %d",
                                 callbacks[i].message_name,
                                 retval );
                }
            }
        }
    }

    free(interface);
    
    ccontext->name = name;
    ccontext->service = service;
    ccontext->path = path;
    return ccontext;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const gchar* eripc_error_string

(

eripc_error_t

errorcode

)

Return error string for code

Definition at line 290 of file support.c.

References ERIPC_ERROR, ERIPC_ERROR_INVALID, ERIPC_ERROR_OOM, ERIPC_ERROR_SUCCESS, and ERIPC_ERROR_TIMEOUT.

Referenced by cb_sys_get_battery_state(), cb_sys_get_card_mountpoint(), cb_sys_get_device_capabilities(), cb_sys_get_orientation(), cb_sys_get_pageturn_inverted(), cb_sys_get_stylus(), ipc_add_profile(), ipc_confirm_install_drz(), ipc_confirm_install_update(), ipc_confirm_usbconnect(), ipc_connect(), ipc_ctb_goto(), ipc_disconnect(), ipc_edit_profile(), ipc_get_battery_state(), ipc_menu_add_task(), ipc_menu_remove_task(), ipc_menu_rename_task(), ipc_menu_set_first_task(), ipc_send_close(), ipc_send_conn_status(), ipc_send_item_activated(), ipc_send_open(), ipc_send_page_change(), ipc_send_ping(), ipc_send_reply(), ipc_send_reply_task_start(), ipc_send_status_item_activated(), ipc_send_store_metadata(), ipc_send_task_activated(), ipc_send_volume_mounted_to(), ipc_send_window_activated(), ipc_send_window_deactivated(), ipc_send_window_show(), ipc_set_orientation(), ipc_show_busy(), ipc_show_message(), ipc_show_popup(), and ipc_show_splash().

{
    switch (errorcode) 
    {
    case ERIPC_ERROR_SUCCESS:
        return "No error (ERIPC_ERROR_SUCCESS)";
    case ERIPC_ERROR:
        return "Some kind of error occurred (ERIPC_ERROR)";
    case ERIPC_ERROR_INVALID:
        return "At least one parameter is invalid (ERIPC_ERROR_INVALID)";
    case ERIPC_ERROR_OOM:
        return "Out of memory error (ERIPC_ERROR_OOM)";
    case ERIPC_ERROR_TIMEOUT:
        return "Timeout error (ERIPC_ERROR_TIMEOUT)";
    default:
        return "Unknown/Undefined";
    }
}

Here is the caller graph for this function:

eripc_error_t eripc_event_info_free	(	eripc_context_t *	context,
		eripc_event_info_t *	reply
	)

This function frees the event info structure and associated message.

Parameters:

	context	IPC context returned by eripc_init.
	reply	A pointer to the event info structure where the return info is stored.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 743 of file rpc.c.

References eripc_event_info_t::args, eripc_event_info_t::dbus_message, ERIPC_ERROR_SUCCESS, and UNUSED.

Referenced by ipc_get_battery_state(), notepad::ipc_get_mountpoint(), ipc_get_orientation(), notepad::ipc_sys_is_in_portrait_mode(), ipc_sys_is_in_portrait_mode(), notepad::ipc_sys_is_pageturn_inverted(), ipc_sys_is_pageturn_inverted(), and is_in_portrait_orientation().

{
    UNUSED(context);
    if (info != NULL) {
        if (info->args != NULL) {
            free((char*)info->args);
        }
    
        if (info->dbus_message != NULL) {
            dbus_message_unref((DBusMessage *)info->dbus_message);
        }
        
        free(info);        
    }
    
    return ERIPC_ERROR_SUCCESS;
}

Here is the caller graph for this function:

void* eripc_get_session_connection

(

eripc_context_t *

context

)

Definition at line 163 of file rpc.c.

References _eripc_context_t::conn.

{
    return (void *) context->conn;
}

void* eripc_get_system_connection

(

eripc_context_t *

context

)

Definition at line 158 of file rpc.c.

References _eripc_context_t::sys_conn.

Referenced by hal_set_services().

{
    return (void *) context->sys_conn;
}

Here is the caller graph for this function:

eripc_error_t eripc_get_timeout	(	eripc_context_t *	context,
		int *	timeout
	)

Returns the current RPC timeout value.

Parameters:

	context	IPC context returned by eripc_init.
	timeout	A pointer where to return the timeout value in milliseconds.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 150 of file rpc.c.

References ERIPC_ERROR_INVALID, ERIPC_ERROR_SUCCESS, and _eripc_context_t::timeout_ms.

Referenced by eripc_sysd_get_device_capabilities(), and ipc_sys_start_task().

{
    if(context == NULL) return ERIPC_ERROR_INVALID;
    *timeout = context->timeout_ms;
    return ERIPC_ERROR_SUCCESS;
}

Here is the caller graph for this function:

eripc_context_t* eripc_init	(	const char *	program_name,
		const char *	program_version,
		GMainContext *	context
	)

This function initialises the library, connects to both the D-Bus session and system busses, integrates with the GLib main loop, and initialises the library for use. eripc_init should be called only once by the program.

Parameters:

	program_name	The name of the program. This name forms the last part of the default (D-Bus) service name of the program. Note that the D-Bus service name will be 'com.irexnet.program_name', where 'program_name' is the value you gave as the parameter. The only valid characters that the name may contain are letters a-z and the underscore '_'. However, you can give a name such as 'org.foo.bar' to have 'bar' as your program's name and 'org.foo.bar' as the D-Bus service name.
	program_version	The version string of the application. This will be used to determine if a saved UI state is still valid for the program.
	context	The GLib main loop context to connect to, or NULL for the default context.

Returns:

A context to use in later calls to this library, or NULL if an error happened.

Definition at line 81 of file init.c.

References _dbus_setup(), _deinit(), _init(), osso_af_context_t::conn, osso_af_context_t::cur_conn, osso_af_context_t::eripc_filters_setup, name, osso_af_context_t::sys_conn, ULOG_CRIT_F, and ULOG_DEBUG_F.

Referenced by eripc_client_context_new(), ipc_set_services(), and main().

{
    osso_context_t *osso;

    char *name = strdup(program_name);
    if (name == NULL) {
        ULOG_CRIT_F("initialisation failed: out of memory");
        return NULL;
    }
    
    // replace dashes (-) with underscores (_) as dbus chokes on dashes
    unsigned int i;
    for (i=0; i<strlen(name); i++)
    {
        if (name[i] == '-')
            name[i] = '_';
    }

    ULOG_DEBUG_F("program '%s', version '%s'", name,
                 program_version);

    osso = _init(name, program_version);
    free(name);
    if (osso == NULL) {
        ULOG_CRIT_F("initialisation failed: out of memory");
        return NULL;
    }

    osso->conn = _dbus_setup(osso, DBUS_BUS_SESSION, context);
    if (osso->conn == NULL) {
        ULOG_CRIT_F("connecting to the session bus failed");
        _deinit(osso);
        return NULL;
    }
    osso->sys_conn = _dbus_setup(osso, DBUS_BUS_SYSTEM, context);
    if (osso->sys_conn == NULL) {
        ULOG_CRIT_F("connecting to the system bus failed");
      _deinit(osso);
        return NULL;
    }
    osso->eripc_filters_setup = TRUE;
    osso->cur_conn = NULL;
    return (eripc_context_t*)osso;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean eripc_menu_add_group	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	parent,
		const char *	image
	)

Add a new group to a popupmenu menu

Definition at line 340 of file support.c.

References DBUS_SERVICE_POPUP_MENU, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, and MAKE_VARARG_CALL.

Referenced by ipc_menu_add_group(), and notepad::menu_init().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "addGroup",
                     ERIPC_TYPE_STRING, name,
                     ERIPC_TYPE_STRING, parent,
                     ERIPC_TYPE_STRING, "",
                     ERIPC_TYPE_STRING, image,
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_menu_add_item	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	parent,
		const char *	image
	)

Add a new item to a popupmenu group

Definition at line 354 of file support.c.

References DBUS_SERVICE_POPUP_MENU, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, and MAKE_VARARG_CALL.

Referenced by ipc_menu_add_item(), and notepad::menu_init().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "addItem",
                     ERIPC_TYPE_STRING, name,
                     ERIPC_TYPE_STRING, parent,
                     ERIPC_TYPE_STRING, "",
                     ERIPC_TYPE_STRING, image,
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_menu_add_menu	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	group1,
		const char *	group2,
		const char *	group3,
		const char *	group4
	)

Add a new menu to the popupmenu

Definition at line 314 of file support.c.

References DBUS_SERVICE_POPUP_MENU, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, MAKE_VARARG_CALL, and eripc_client_context_t::service.

Referenced by ipc_menu_add_menu(), and notepad::menu_init().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "addMenu",
                     ERIPC_TYPE_STRING, name,
                     ERIPC_TYPE_STRING, "",
                     ERIPC_TYPE_STRING, ccontext->service,
                     ERIPC_TYPE_STRING, group1,
                     ERIPC_TYPE_STRING, group2,
                     ERIPC_TYPE_STRING, group3,
                     ERIPC_TYPE_STRING, group4,
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_menu_remove_menu	(	eripc_client_context_t *	ccontext,
		const char *	name
	)

Remove a menu from the popupmenu

Definition at line 333 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_1S.

Referenced by ipc_remove_menu(), and notepad::menu_destroy().

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_POPUP_MENU, "removeMenu", name);
}

Here is the caller graph for this function:

gboolean eripc_menu_set_group_label	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	label
	)

Set the label for a popupmenu group

Definition at line 376 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_2S.

Referenced by ipc_menu_set_group_label(), and notepad::menu_set_text().

{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setGroupLabel", name, label);
}

Here is the caller graph for this function:

gboolean eripc_menu_set_group_state	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	state
	)

Set a popupmenu group's state

Definition at line 401 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_2S.

Referenced by ipc_menu_set_group_state().

{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setGroupState", name, state);
}

Here is the caller graph for this function:

gboolean eripc_menu_set_item_label	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	parent,
		const char *	label
	)

Set the label for a popupmenu item

Definition at line 384 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_3S.

Referenced by ipc_menu_set_item_label(), and notepad::menu_set_text().

{
    MAKE_VARARG_CALL_3S(DBUS_SERVICE_POPUP_MENU, "setItemLabel",
                        name, parent, label);
}

Here is the caller graph for this function:

gboolean eripc_menu_set_item_state	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	parent,
		const char *	state
	)

Set a popupmenu item's state

Definition at line 409 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_3S.

Referenced by ipc_menu_set_item_state(), notepad::ipc_menu_set_pagecounter(), and notepad::menu_show().

{
    MAKE_VARARG_CALL_3S(DBUS_SERVICE_POPUP_MENU, "setItemState",
                        name, parent, state);
}

Here is the caller graph for this function:

gboolean eripc_menu_set_menu_label	(	eripc_client_context_t *	ccontext,
		const char *	name,
		const char *	label
	)

Set the label for a popupmenu menu

Definition at line 368 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_2S.

Referenced by ipc_menu_set_menu_label().

{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setMenuLabel", name, label);
}

Here is the caller graph for this function:

gboolean eripc_menu_set_pagecounter	(	eripc_client_context_t *	ccontext,
		int	cur_page,
		int	num_pages,
		gboolean	boundary_check
	)

Set the statusbar page counter

Definition at line 418 of file support.c.

References DBUS_SERVICE_POPUP_MENU, ERIPC_TYPE_BOOL, ERIPC_TYPE_INT, ERIPC_TYPE_INVALID, and MAKE_VARARG_CALL.

Referenced by notepad::ipc_menu_set_pagecounter(), and ipc_menu_set_pagecounter().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_POPUP_MENU, "updatePageCounter",
                     ERIPC_TYPE_INT, cur_page,
                     ERIPC_TYPE_INT, num_pages,
                     ERIPC_TYPE_BOOL, boundary_check,
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_menu_set_statusitem_state	(	eripc_client_context_t *	ccontext,
		const char *	item,
		const char *	state
	)

Set a statusbar item's state

Definition at line 431 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_2S.

Referenced by ipc_menu_set_statusitem_state(), ipc_set_stylus(), notepad::ipc_status_set_stylus(), and ipc_status_set_stylus().

{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_POPUP_MENU, "setStatusItemState", item, state);
}

Here is the caller graph for this function:

gboolean eripc_menu_show_menu	(	eripc_client_context_t *	ccontext,
		const char *	name
	)

Show a specific popupmenu menu

Definition at line 394 of file support.c.

References DBUS_SERVICE_POPUP_MENU, and MAKE_VARARG_CALL_1S.

Referenced by ipc_menu_show(), ipc_menu_show_menu(), and notepad::menu_show().

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_POPUP_MENU, "showMenu", name);
}

Here is the caller graph for this function:

eripc_error_t eripc_reply_bool	(	eripc_context_t *	context,
		const char *	message_id,
		gboolean	value
	)

This function returns a reply to a message with a boolean argument.

Instead of the variable arguments of eripc_reply_varargs, this function has single boolean as argument.

Parameters:

	context	IPC context returned by eripc_init.
	message_id	ID string of the received message to reply to.
	value	The argument value.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 868 of file rpc.c.

References eripc_reply_varargs(), ERIPC_TYPE_BOOL, and ERIPC_TYPE_INVALID.

Referenced by ipc_send_reply(), menuActivated_rh(), on_file_close(), on_ping(), on_window_activated(), and on_window_deactivated().

{
    eripc_error_t rc;
    rc = eripc_reply_varargs(context, message_id,
                             ERIPC_TYPE_BOOL, value,
                             ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_reply_error	(	eripc_context_t *	context,
		const char *	message_id,
		const char *	error_name,
		const char *	error_message
	)

This function return an error in reply to a message.

The error_name indicates the error which can be fully-qualitfied. When the service is omitted from the error name, the service of the given context is used.

Parameters:

	context	IPC context returned by eripc_init.
	message_id	ID string of the received message to reply to.
	error_name	The name of the error to return.
	error_message	Text string with error description.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 879 of file rpc.c.

References _parse_id(), _eripc_context_t::conn, ERIPC_BUS_SESSION, ERIPC_BUS_SYSTEM, ERIPC_ERROR, ERIPC_ERROR_INVALID, ERIPC_ERROR_OOM, ERIPC_ERROR_SUCCESS, _eripc_context_t::error_dummy, MAX_ERROR_LEN, MAX_SVC_LEN, sender, serial, _eripc_context_t::service, _eripc_context_t::sys_conn, and ULOG_ERR_F.

{
    DBusConnection *conn;
    DBusMessage *reply;
    dbus_bool_t ret;
    char sender[MAX_SVC_LEN + 1], error_name[MAX_ERROR_LEN + 1];
    int serial;
    eripc_bus_t bus_type;

    if (context == NULL || name == NULL || message_id == NULL) {
        return ERIPC_ERROR_INVALID;
    }
    if (context->error_dummy == NULL) {
        /* OOM has happened earlier in the handler, or
         * the context is invalid */
        ULOG_ERR_F("error_dummy has not been created");
        return ERIPC_ERROR;
    }

    _parse_id(message_id, &bus_type, sender, &serial);
    assert(bus_type == ERIPC_BUS_SYSTEM || bus_type == ERIPC_BUS_SESSION);

    if (bus_type == ERIPC_BUS_SYSTEM) {
        conn = context->sys_conn;
    } else {
        conn = context->conn;
    }
    if (!dbus_connection_get_is_connected(conn)) {
        ULOG_ERR_F("connection %p is not open", conn);
        return ERIPC_ERROR_INVALID;
    }

    make_default_error_name(context->service, name, error_name);

    /* make a copy of the error_dummy and modify the copy */
    reply = dbus_message_copy(context->error_dummy);
    if (reply == NULL) {
        ULOG_ERR_F("dbus_message_copy failed");
        return ERIPC_ERROR_OOM;
    }
    if (!dbus_message_set_destination(reply, sender)) {
        ULOG_ERR_F("dbus_message_set_destination failed");
        goto unref_and_exit;
    }
    if (!dbus_message_set_reply_serial(reply, serial)) {
        ULOG_ERR_F("dbus_message_set_reply_serial failed");
        goto unref_and_exit;
    }
    if (!dbus_message_set_error_name(reply, error_name)) {
        ULOG_ERR_F("dbus_message_set_error_name failed");
        goto unref_and_exit;
    }

    if (message != NULL) {
        ret = dbus_message_append_args(reply, DBUS_TYPE_STRING,
                                       &message,
                                       DBUS_TYPE_INVALID);
        if (!ret) {
            ULOG_ERR_F("dbus_message_append_args failed");
            goto unref_and_exit;
        }
    }

    if (!dbus_connection_send(conn, reply, NULL)) {
        ULOG_ERR_F("dbus_connection_send failed");
        goto unref_and_exit;
    }
    dbus_message_unref(reply);
    return ERIPC_ERROR_SUCCESS;

unref_and_exit:
    dbus_message_unref(reply);
    return ERIPC_ERROR_OOM;
}

Here is the call graph for this function:

eripc_error_t eripc_reply_int	(	eripc_context_t *	context,
		const char *	message_id,
		int	value
	)

This function returns a reply to a message with an integer argument.

Instead of the variable arguments of eripc_reply_varargs, this function has single integer as argument.

Parameters:

	context	IPC context returned by eripc_init.
	message_id	ID string of the received message to reply to.
	value	The argument value.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 857 of file rpc.c.

References eripc_reply_varargs(), ERIPC_TYPE_INT, and ERIPC_TYPE_INVALID.

{
    eripc_error_t rc;
    rc = eripc_reply_varargs(context, message_id,
                             ERIPC_TYPE_INT, value,
                             ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

eripc_error_t eripc_reply_string	(	eripc_context_t *	context,
		const char *	message_id,
		const char *	string
	)

This function returns a reply to a message with a string argument.

Instead of the variable arguments of eripc_reply_varargs, this function has single string as argument.

Parameters:

	context	IPC context returned by eripc_init.
	message_id	ID string of the received message to reply to.
	string	The argument string.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 846 of file rpc.c.

References eripc_reply_varargs(), ERIPC_TYPE_INVALID, and ERIPC_TYPE_STRING.

Referenced by cb_sys_get_card_mountpoint(), testing_list_menu_items_cb(), testing_list_tasks(), and testing_route_menu_item_cb().

{
    eripc_error_t rc;
    rc = eripc_reply_varargs(context, message_id,
                             ERIPC_TYPE_STRING, string,
                             ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_reply_varargs	(	eripc_context_t *	context,
		const char *	message_id,
		eripc_data_t	arg_type,
			...
	)

This function returns a reply to a message with variable arguments.

The variable arguments work in a type-value pairs. The type argument defines the type of the following value. If the type is G_TYPE_STRING, then the value is a pointer to a string. The list must end in a ERIPC_TYPE_INVALID. The supported types are:

• ERIPC_TYPE_BOOL
  • The value is a gboolean.
• ERIPC_TYPE_BYTE, ERIPC_TYPE_INT, ERIPC_TYPE_UINT
  • The value is an byte, int or an unsigned int.
• ERIPC_TYPE_DOUBLE
  • The value is a float.
• ERIPC_TYPE_STRING
  • The value is a pointer to a string.
• ERIPC_TYPE_DATA
  • Two values are expected: first an integer indicating length of the data block (e.g. array), second a pointer to the data block.

Parameters:

	context	IPC context returned by eripc_init.
	message_id	ID string of the received message to reply to.
	arg_type	The type of the first argument.
	...	The first argument value, and then a type-value list of other arguments. This list must end in a ERIPC_TYPE_INVALID type.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 832 of file rpc.c.

References _reply_helper().

Referenced by cb_sys_get_battery_state(), cb_sys_get_device_capabilities(), cb_sys_get_orientation(), cb_sys_get_pageturn_inverted(), cb_sys_get_stylus(), eripc_reply_bool(), eripc_reply_int(), eripc_reply_string(), ipc_send_reply_task_start(), and on_file_open().

{
    va_list va_args;
    eripc_error_t rc;

    va_start(va_args, arg_type);
    rc = _reply_helper(context, message_id,
                            arg_type, va_args);
    va_end(va_args);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_send_bool	(	eripc_context_t *	context,
		eripc_handler_t *	reply_handler,
		const void *	user_data,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		gboolean	value
	)

This function sends a boolean message and registers a reply handler.

Instead of the variable arguments of eripc_send_varargs, this function has single boolean as argument.

Parameters:

	context	IPC context returned by eripc_init.
	reply_handler	The handler function to call when a reply is returned. Set to NULL for no reply.
	user_data	Optional user data to pass to the handler when it is called.
	bus_type	The bus type (session or system bus).
	destination	Interface name to send message to.
	message_name	Name of the message/method to call.
	value	The argument value.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 727 of file rpc.c.

References eripc_send_varargs(), ERIPC_TYPE_BOOL, and ERIPC_TYPE_INVALID.

{
    eripc_error_t rc;
    rc = eripc_send_varargs(context, reply_handler, user_data,
                            bus_type, destination, message_name,
                            ERIPC_TYPE_BOOL, value_to_send,
                            ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

eripc_error_t eripc_send_bool_and_wait	(	eripc_context_t *	context,
		eripc_event_info_t **	reply,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		gboolean	value
	)

This function sends a boolean message and return reply immediately. This call is blocking.

Instead of the variable arguments of eripc_send_varargs_and_wait, this function has single boolean as argument.

Parameters:

[in]	context	IPC context returned by eripc_init.
[out]	reply	A pointer pointer to the event info structure where the return info goes. Set to NULL for no reply arguments. If the expected reply does not come within the RPC timeout value set with the eripc_set_timeout function. Caller must free the reply structure using eripc_event_info_free.
[in]	bus_type	The bus type (session or system bus).
[in]	destination	Interface name to send message to.
[in]	message_name	Name of the message/method to call.
[in]	value	The argument value.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 678 of file rpc.c.

References eripc_send_varargs_and_wait(), ERIPC_TYPE_BOOL, and ERIPC_TYPE_INVALID.

{
    eripc_error_t rc;
    rc = eripc_send_varargs_and_wait(context, reply,
                                     bus_type, destination, message_name,
                                     ERIPC_TYPE_BOOL, value_to_send,
                                     ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

eripc_error_t eripc_send_int	(	eripc_context_t *	context,
		eripc_handler_t *	reply_handler,
		const void *	user_data,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		int	value
	)

This function sends an integer message and registers a reply handler.

Instead of the variable arguments of eripc_send_varargs, this function has single integer as argument.

Parameters:

	context	IPC context returned by eripc_init.
	reply_handler	The handler function to call when a reply is returned. Set to NULL for no reply.
	user_data	Optional user data to pass to the handler when it is called.
	bus_type	The bus type (session or system bus).
	destination	Interface name to send message to.
	message_name	Name of the message/method to call.
	value	The argument value.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 711 of file rpc.c.

References eripc_send_varargs(), ERIPC_TYPE_INT, and ERIPC_TYPE_INVALID.

Referenced by ipc_menu_remove_task(), ipc_menu_set_first_task(), ipc_send_task_activated(), ipc_send_window_activated(), ipc_send_window_deactivated(), and ipc_send_window_show().

{
    eripc_error_t rc;
    rc = eripc_send_varargs(context, reply_handler, user_data,
                            bus_type, destination, message_name,
                            ERIPC_TYPE_INT, value_to_send,
                            ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_send_int_and_wait	(	eripc_context_t *	context,
		eripc_event_info_t **	reply,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		int	value
	)

This function sends an integer message and return reply immediately. This call is blocking.

Instead of the variable arguments of eripc_send_varargs_and_wait, this function has single integer as argument.

Parameters:

[in]	context	IPC context returned by eripc_init.
[out]	reply	A pointer pointer to the event info structure where the return info goes. Set to NULL for no reply arguments. If the expected reply does not come within the RPC timeout value set with the eripc_set_timeout function. Caller must free the reply structure using eripc_event_info_free.
[in]	bus_type	The bus type (session or system bus).
[in]	destination	Interface name to send message to.
[in]	message_name	Name of the message/method to call.
[in]	value	The argument value.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 661 of file rpc.c.

References eripc_send_varargs_and_wait(), ERIPC_TYPE_INT, and ERIPC_TYPE_INVALID.

{
    eripc_error_t rc;
    rc = eripc_send_varargs_and_wait(context, reply,
                                     bus_type, destination, message_name,
                                     ERIPC_TYPE_INT, value_to_send,
                                     ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

eripc_error_t eripc_send_signal	(	eripc_context_t *	context,
		eripc_bus_t	bus_type,
		const char *	signal_name,
		const char *	argument
	)

This function sends a signal with optional string argument.

The signal defaults to the path and interface in the context. For more flexibility, use eripc_send_signal_varargs.

Parameters:

	context	IPC context returned by eripc_init.
	bus_type	The bus type (session or system bus).
	signal_name	Name of the signal to send.
	argument	The argument string or NULL for no argument.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 329 of file rpc.c.

References eripc_send_signal_varargs(), ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, _eripc_context_t::interface, and _eripc_context_t::object_path.

{
    eripc_error_t rc;
    
    if (argument == NULL)
    {        
        rc = eripc_send_signal_varargs(context, bus_type, 
                                      context->object_path, context->interface, signal_name,
                                      ERIPC_TYPE_INVALID);
    }
    else 
    {
        rc = eripc_send_signal_varargs(context, bus_type, 
                                      context->object_path, context->interface, signal_name,
                                      ERIPC_TYPE_STRING, argument,
                                      ERIPC_TYPE_INVALID);
    }
    return rc;
}

Here is the call graph for this function:

eripc_error_t eripc_send_signal_varargs	(	eripc_context_t *	context,
		eripc_bus_t	bus_type,
		const char *	signal_path,
		const char *	signal_interface,
		const char *	signal_name,
		eripc_data_t	arg_type,
			...
	)

This function sends a signal with variable arguments.

The variable arguments work in a type-value pairs. The type argument defines the type of the following value. If the type is G_TYPE_STRING, then the value is a pointer to a string. The list must end in a ERIPC_TYPE_INVALID. The supported types are:

• ERIPC_TYPE_BOOL
  • The value is a gboolean.
• ERIPC_TYPE_BYTE, ERIPC_TYPE_INT, ERIPC_TYPE_UINT
  • The value is an byte, int or an unsigned int.
• ERIPC_TYPE_DOUBLE
  • The value is a float.
• ERIPC_TYPE_STRING
  • The value is a pointer to a string.
• ERIPC_TYPE_DATA
  • Two values are expected: first an integer indicating length of the data block (e.g. array), second a pointer to the data block.

Parameters:

	context	IPC context returned by eripc_init.
	bus_type	The bus type (session or system bus).
	signal_path	The object path of the signal to send.
	signal_interface	The interface name of the signal to send.
	signal_name	Name of the signal to send.
	arg_type	The type of the first argument.
	...	The first argument value, and then a type-value list of other arguments. This list must end in a ERIPC_TYPE_INVALID type.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 310 of file rpc.c.

References _send_signal_helper().

Referenced by eripc_send_signal(), ipc_broadcast_conn_signal(), ipc_broadcast_conn_status(), ipc_send_battery_state(), ipc_send_changed_locale(), ipc_send_changed_orientation(), ipc_send_changed_pageturn_inverted(), ipc_send_demo_mode(), ipc_send_prepare_standby(), ipc_send_prepare_unmount(), ipc_send_usb_state(), ipc_send_volume_mounted(), ipc_send_volume_unmounted(), and ipc_sys_startup_complete().

{
    va_list va_args;
    eripc_error_t rc;

    va_start(va_args, arg_type);
    rc = _send_signal_helper(context, bus_type,
                             signal_path, signal_interface, signal_name,
                             arg_type, va_args);
    va_end(va_args);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_send_string	(	eripc_context_t *	context,
		eripc_handler_t *	reply_handler,
		const void *	user_data,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		const char *	string
	)

This function sends a string message and registers a reply handler.

Instead of the variable arguments of eripc_send_varargs, this function has single string as argument.

Parameters:

	context	IPC context returned by eripc_init.
	reply_handler	The handler function to call when a reply is returned. Set to NULL for no reply.
	user_data	Optional user data to pass to the handler when it is called.
	bus_type	The bus type (session or system bus).
	destination	Interface name to send message to.
	message_name	Name of the message/method to call.
	string	The argument string.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 695 of file rpc.c.

References eripc_send_varargs(), ERIPC_TYPE_INVALID, and ERIPC_TYPE_STRING.

Referenced by ipc_confirm_install_drz(), ipc_confirm_install_update(), ipc_confirm_usbconnect(), ipc_ctb_goto(), ipc_send_close(), ipc_send_open(), ipc_send_volume_mounted_to(), ipc_show_message(), ipc_show_popup(), and ipc_show_splash().

{
    eripc_error_t rc;
    rc = eripc_send_varargs(context, reply_handler, user_data,
                            bus_type, destination, message_name,
                            ERIPC_TYPE_STRING, string_to_send,
                            ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_send_string_and_wait	(	eripc_context_t *	context,
		eripc_event_info_t **	reply,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		const char *	string
	)

This function sends a string message and return reply immediately. This call is blocking.

Instead of the variable arguments of eripc_send_varargs_and_wait, this function has single string as argument.

Parameters:

[in]	context	IPC context returned by eripc_init.
[out]	reply	A pointer pointer to the event info structure where the return info goes. Set to NULL for no reply arguments. If the expected reply does not come within the RPC timeout value set with the eripc_set_timeout function. Caller must free the reply structure using eripc_event_info_free.
[in]	bus_type	The bus type (session or system bus).
[in]	destination	Interface name to send message to.
[in]	message_name	Name of the message/method to call.
[in]	string	The argument string.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 644 of file rpc.c.

References eripc_send_varargs_and_wait(), ERIPC_TYPE_INVALID, and ERIPC_TYPE_STRING.

Referenced by ipc_send_store_metadata().

{
    eripc_error_t rc;
    rc = eripc_send_varargs_and_wait(context, reply,
                                     bus_type, destination, message_name,
                                     ERIPC_TYPE_STRING, string_to_send,
                                     ERIPC_TYPE_INVALID);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_send_varargs	(	eripc_context_t *	context,
		eripc_handler_t *	reply_handler,
		const void *	user_data,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		eripc_data_t	arg_type,
			...
	)

This function sends a variable message and registers a reply handler.

The variable arguments work in a type-value pairs. The type argument defines the type of the following value. If the type is G_TYPE_STRING, then the value is a pointer to a string. The list must end in a ERIPC_TYPE_INVALID. The supported types are:

• ERIPC_TYPE_BOOL
  • The value is a gboolean.
• ERIPC_TYPE_BYTE, ERIPC_TYPE_INT, ERIPC_TYPE_UINT
  • The value is an byte, int or an unsigned int.
• ERIPC_TYPE_DOUBLE
  • The value is a float.
• ERIPC_TYPE_STRING
  • The value is a pointer to a string.
• ERIPC_TYPE_DATA
  • Two values are expected: first an integer indicating length of the data block (e.g. array), second a pointer to the data block.

Parameters:

	context	IPC context returned by eripc_init.
	reply_handler	The handler function to call when a reply is returned. Set to NULL for no reply.
	user_data	Optional user data to pass to the handler when it is called.
	bus_type	The bus type (session or system bus).
	destination	Interface name to send message to.
	message_name	Name of the message/method to call.
	arg_type	The type of the first argument.
	...	The first argument value, and then a type-value list of other arguments. This list must end in a ERIPC_TYPE_INVALID type.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 607 of file rpc.c.

References _send_helper().

Referenced by add_group(), add_item(), add_menu(), eripc_send_bool(), eripc_send_int(), eripc_send_string(), ipc_add_profile(), notepad::ipc_change_filename(), ipc_connect(), ipc_disconnect(), ipc_edit_profile(), ipc_menu_add_group(), ipc_menu_add_item(), ipc_menu_add_menu(), ipc_menu_add_task(), ipc_menu_rename_task(), ipc_menu_set_group_label(), ipc_menu_set_group_state(), ipc_menu_set_item_label(), ipc_menu_set_item_state(), ipc_menu_set_menu_label(), ipc_menu_show_menu(), notepad::ipc_menu_update_toolbar(), ipc_menu_updates_finished(), ipc_refresh_ctb(), ipc_remove_menu(), ipc_send_conn_status(), ipc_send_item_activated(), ipc_send_page_change(), ipc_send_ping(), ipc_send_status_item_activated(), ipc_set_orientation(), ipc_show_busy(), ipc_sys_standby(), main(), notepad::menu_show(), remove_group(), and remove_menu().

{
    va_list va_args;
    eripc_error_t rc;

    va_start(va_args, arg_type);
    rc = _send_helper(context, reply_handler, user_data,
                      bus_type, destination, message_name,
                      arg_type, va_args);
    va_end(va_args);
    return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_send_varargs_and_wait	(	eripc_context_t *	context,
		eripc_event_info_t **	reply,
		eripc_bus_t	bus_type,
		const char *	destination,
		const char *	message_name,
		eripc_data_t	arg_type,
			...
	)

This function sends a variable message and return reply immediately. This call is blocking.

The variable arguments work in a type-value pairs. The type argument defines the type of the following value. If the type is G_TYPE_STRING, then the value is a pointer to a string. The list must end in a ERIPC_TYPE_INVALID. The supported types are:

• ERIPC_TYPE_BOOL
  • The value is a gboolean.
• ERIPC_TYPE_BYTE, ERIPC_TYPE_INT, ERIPC_TYPE_UINT
  • The value is an byte, int or an unsigned int.
• ERIPC_TYPE_DOUBLE
  • The value is a float.
• ERIPC_TYPE_STRING
  • The value is a pointer to a string.
• ERIPC_TYPE_DATA
  • Two values are expected: first an integer indicating length of the data block (e.g. array), second a pointer to the data block.

Parameters:

[in]	context	IPC context returned by eripc_init.
[out]	reply	A pointer pointer to the event info structure where the return info goes. Set to NULL for no reply arguments. If the expected reply does not come within the RPC timeout value set with the eripc_set_timeout function. Caller must free the reply structure using eripc_event_info_free.
[in]	bus_type	The bus type (session or system bus).
[in]	destination	Interface name to send message to.
[in]	message_name	Name of the message/method to call.
[in]	arg_type	The type of the first argument.
[in]	...	The first argument value, and then a type-value list of other arguments. This list must end in a ERIPC_TYPE_INVALID type.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 627 of file rpc.c.

References _send_sync_helper().

Referenced by eripc_send_bool_and_wait(), eripc_send_int_and_wait(), eripc_send_string_and_wait(), hide_statusitem(), ipc_get_battery_state(), notepad::ipc_get_mountpoint(), ipc_get_orientation(), notepad::ipc_get_rotation(), notepad::ipc_sys_is_in_portrait_mode(), ipc_sys_is_in_portrait_mode(), notepad::ipc_sys_is_pageturn_inverted(), ipc_sys_is_pageturn_inverted(), ipc_sys_start_task(), is_in_portrait_orientation(), remove_group(), remove_item(), remove_menu(), set_group_state(), set_item_state(), set_popup_state(), set_statusitem_state(), show_menu(), and show_statusitem().

{
    va_list va_args;
    eripc_error_t rc;
    
    va_start(va_args, arg_type);
    rc = _send_sync_helper(context, reply, bus_type, destination,
                           message_name, arg_type, va_args);
    va_end(va_args);
    return rc;   
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_set_event_handler	(	eripc_context_t *	context,
		const eripc_event_info_t *	info,
		eripc_handler_t *	handler,
		void *	user_data,
		int *	handler_id
	)

This function registers a custom handler for event, message, or signal.

Parameters:

	context	IPC context returned by eripc_init.
	info	Structure specifying the type of events to handle.
	handler	The handler function to call when the event happens.
	user_data	Optional user data to pass to the handler when it is called.
	handler_id	Return location for the handler ID, which is used to unregister the handler.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 463 of file hw.c.

References _set_handler(), eripc_event_info_t::bus_type, compose_match(), ERIPC_BUS_BOTH, ERIPC_BUS_IRRELEVANT, ERIPC_BUS_SESSION, ERIPC_BUS_SYSTEM, ERIPC_ERROR_INVALID, ERIPC_ERROR_OOM, ERIPC_ERROR_SUCCESS, eripc_event_info_t::event_type, generic_signal_handler(), eripc_event_info_t::interface, eripc_event_info_t::name, _eripc_context_t::next_handler_id, eripc_event_info_t::path, eripc_event_info_t::service, ULOG_DEBUG_F, and ULOG_ERR_F.

Referenced by eripc_set_message_handler(), and eripc_set_signal_handler().

{
        eripc_error_t error = ERIPC_ERROR_SUCCESS;
        _osso_handler_f *event_cb = NULL;
        char *tmp_match = NULL, *match = NULL, *sys_match = NULL;
        int new_handler_id;
        eripc_error_t ret;
        eripc_bus_t bus_type;

        ULOG_DEBUG_F("entered");

        if (context == NULL || handler == NULL) {
                ULOG_ERR_F("invalid arguments");
                return ERIPC_ERROR_INVALID;
        }

        if (info == NULL) {
                ULOG_ERR_F("info structure must be provided");
                return ERIPC_ERROR_INVALID;
        }

        if (info->bus_type == ERIPC_BUS_IRRELEVANT) {
                bus_type = ERIPC_BUS_BOTH;
        } else {
                bus_type = info->bus_type;
        }

        new_handler_id = context->next_handler_id++;

        event_cb = generic_signal_handler;

        ret = compose_match(info, &tmp_match);
        ULOG_DEBUG_F("match='%s'", tmp_match);
        
        if (ret == ERIPC_ERROR_SUCCESS) {
                if (bus_type == ERIPC_BUS_BOTH
                    || bus_type == ERIPC_BUS_SESSION) {
                        match = tmp_match;
                }
                if (bus_type == ERIPC_BUS_BOTH
                    || bus_type == ERIPC_BUS_SYSTEM) {
                        if (match == NULL) {
                                sys_match = tmp_match;
                        } else {
                                sys_match = strdup(tmp_match);
                                if (sys_match == NULL) {
                                        ULOG_ERR_F("strdup failed");
                                        free(tmp_match);
                                        error = ERIPC_ERROR_OOM;
                                        goto _oom_exit;
                                }
                        }
                }
                error = _set_handler(context,
                                     info->service,
                                     info->path,
                                     info->interface,
                                     info->name,
                                     match,
                                     sys_match,
                                     event_cb,
                                     info->event_type, // FIXME was 0, event_type ignored
                                     handler,
                                     user_data,
                                     new_handler_id,
                                     FALSE, bus_type);
        } else {
                error = ret;
        }

_oom_exit:
        if (handler_id != NULL) {
                if (error == ERIPC_ERROR_SUCCESS) {
                        *handler_id = new_handler_id;
                } else {
                        *handler_id = 0;
                }
        }
        return error;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_set_message_handler	(	eripc_context_t *	context,
		eripc_handler_t *	handler,
		void *	user_data,
		eripc_bus_t	bus_type,
		const char *	source,
		const char *	message_name,
		int *	handler_id
	)

This function registers a handler for a message.

Parameters:

	context	IPC context returned by eripc_init.
	handler	The handler function to call when the event happens.
	user_data	Optional user data to pass to the handler when it is called.
	bus_type	The bus type (session or system bus).
	source	Interface name of message to receive.
	message_name	Name of the message/method.
	handler_id	Return location for the handler ID, which is used to unregister the handler.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 436 of file hw.c.

References eripc_event_info_t::bus_type, ERIPC_ERROR_SUCCESS, ERIPC_EVENT_MESSAGE, eripc_set_event_handler(), eripc_event_info_t::event_type, fix_name(), eripc_event_info_t::interface, interface, and eripc_event_info_t::name.

Referenced by eripc_client_context_new(), install_activation_handler(), and ipc_set_services().

{
    eripc_error_t error = ERIPC_ERROR_SUCCESS;
    eripc_event_info_t info;
    
    char *interface = fix_name(source);
    memset(&info, 0, sizeof(info));
    info.event_type = ERIPC_EVENT_MESSAGE;
    info.bus_type = bus_type;
    info.interface = interface;
    info.name = name;
    
    error = eripc_set_event_handler(context, &info, 
                                    handler, user_data, handler_id);
    
    free(interface);
    
    return error;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_set_signal_handler	(	eripc_context_t *	context,
		eripc_handler_t *	handler,
		void *	user_data,
		eripc_bus_t	bus_type,
		const char *	source,
		const char *	signal_name,
		int *	handler_id
	)

This function registers a handler for a signal.

Parameters:

	context	IPC context returned by eripc_init.
	handler	The handler function to call when the event happens.
	user_data	Optional user data to pass to the handler when it is called.
	bus_type	The bus type (session or system bus).
	source	Interface name to receive signal/message from.
	signal_name	Name of the signal.
	handler_id	Return location for the handler ID, which is used to unregister the handler.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 409 of file hw.c.

References eripc_event_info_t::bus_type, ERIPC_ERROR_SUCCESS, ERIPC_EVENT_SIGNAL, eripc_set_event_handler(), eripc_event_info_t::event_type, fix_name(), eripc_event_info_t::interface, interface, and eripc_event_info_t::name.

Referenced by eripc_client_context_new(), and ipc_set_services().

{
    eripc_error_t error = ERIPC_ERROR_SUCCESS;
    eripc_event_info_t info;
    
    char *interface = fix_name(source);
    memset(&info, 0, sizeof(info));
    info.event_type = ERIPC_EVENT_SIGNAL;
    info.bus_type = bus_type;
    info.interface = interface;
    info.name = name;
    
    error = eripc_set_event_handler(context, &info, 
                                    handler, user_data, handler_id);
    
    free(interface);
    
    return error;
}

Here is the call graph for this function:

Here is the caller graph for this function:

eripc_error_t eripc_set_timeout	(	eripc_context_t *	context,
		int	timeout
	)

Sets the timeout value used by the RPC functions.

Parameters:

	context	IPC context returned by eripc_init.
	timeout	The new timeout value in milliseconds.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 169 of file rpc.c.

References ERIPC_ERROR_INVALID, ERIPC_ERROR_SUCCESS, and _eripc_context_t::timeout_ms.

Referenced by eripc_sysd_get_device_capabilities(), ipc_send_store_metadata(), ipc_set_services(), ipc_sys_start_task(), and main().

{
    if(context == NULL) return ERIPC_ERROR_INVALID;
    context->timeout_ms = timeout;
    return ERIPC_ERROR_SUCCESS;
}

Here is the caller graph for this function:

gboolean eripc_sysd_conn_connect	(	eripc_client_context_t *	ccontext,
		const char *	medium,
		const char *	profile
	)

Request a network connection

Definition at line 669 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, MAKE_VARARG_CALL_3S, and eripc_client_context_t::service.

Referenced by ipc_sys_connect().

{
    MAKE_VARARG_CALL_3S(DBUS_SERVICE_SYSTEM_CONTROL, "connConnect", 
                        ccontext->service, medium, profile);
}

Here is the caller graph for this function:

gboolean eripc_sysd_conn_disconnect

(

eripc_client_context_t *

ccontext

)

Release the network connection

Definition at line 677 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, MAKE_VARARG_CALL_1S, and eripc_client_context_t::service.

Referenced by ipc_sys_disconnect().

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "connDisconnect", ccontext->service);
}

Here is the caller graph for this function:

gboolean eripc_sysd_conn_status_request

(

eripc_client_context_t *

ccontext

)

Request the current network network status

Definition at line 682 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, MAKE_VARARG_CALL_1S, and eripc_client_context_t::name.

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "connConnectionStatusRequest", ccontext->name);
}

gboolean eripc_sysd_get_device_capabilities	(	eripc_client_context_t *	ccontext,
		eripc_device_caps_t *	caps
	)

Return the device's capabilities

Definition at line 638 of file support.c.

References eripc_client_context_t::context, DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_ERROR_SUCCESS, eripc_get_timeout(), eripc_set_timeout(), ERIPC_TYPE_INVALID, eripc_device_caps_t::has_3g, eripc_device_caps_t::has_bluetooth, eripc_device_caps_t::has_stylus, eripc_device_caps_t::has_wifi, MAKE_VARARG_WAIT_CALL, and parse_reply_capabilities().

Referenced by get_device_capabilities(), ipc_get_device_capabilities(), and ipc_sys_get_device_capabilities().

{
    int old_timeout;
    int timeout_set = 0;
    int retval = 0;
    eripc_error_t result;

    // set default reply
    caps->has_stylus    = FALSE;
    caps->has_wifi      = FALSE;
    caps->has_bluetooth = FALSE;
    caps->has_3g        = FALSE;
    
    result = eripc_get_timeout(ccontext->context, &old_timeout);
    if (result == ERIPC_ERROR_SUCCESS)
    {
        result = eripc_set_timeout(ccontext->context, 5*1000);
        timeout_set = (result == ERIPC_ERROR_SUCCESS);
    }
    
    MAKE_VARARG_WAIT_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysGetDeviceCapabilities",
                          parse_reply_capabilities(reply, caps),
                          ERIPC_TYPE_INVALID );
    
    if (timeout_set)
        eripc_set_timeout(ccontext->context, old_timeout);
    
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean eripc_sysd_mount_sd_card	(	eripc_client_context_t *	ccontext,
		gboolean	show_index_splash
	)

Request an SD card mount

Definition at line 449 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_BOOL, ERIPC_TYPE_INVALID, and MAKE_VARARG_CALL.

Referenced by mount_sd_card().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysCardMount",
                     ERIPC_TYPE_BOOL, show_index_splash, ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gint eripc_sysd_open_url	(	eripc_client_context_t *	ccontext,
		const gchar *	url,
		const gchar *	label,
		const gchar *	back_text,
		gchar **	err_message
	)

Request an url be opened

Definition at line 563 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, MAKE_BUSY_TIMEOUT_END, MAKE_BUSY_TIMEOUT_START, MAKE_VARARG_WAIT_CALL, and parse_reply_start().

Referenced by ipc_sys_open_url().

{
    int old_timeout;
    int timeout_set = 0;
    int retval = 0;
    eripc_error_t result;
    
    MAKE_BUSY_TIMEOUT_START(60);
    MAKE_VARARG_WAIT_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "openUrl",
                          parse_reply_start(reply, err_message),
                          ERIPC_TYPE_STRING, url,
                          ERIPC_TYPE_STRING, label,
                          ERIPC_TYPE_STRING, back_text,
                          ERIPC_TYPE_INVALID );
    MAKE_BUSY_TIMEOUT_END();
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean eripc_sysd_reset_bg_busy

(

eripc_client_context_t *

ccontext

)

Reset background busy state

Definition at line 482 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_INVALID, and MAKE_VARARG_CALL.

Referenced by notepad::ipc_sys_bg_busy(), and ipc_sys_bg_busy().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysResetBgBusy",
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_sysd_reset_busy

(

eripc_client_context_t *

ccontext

)

Reset busy state

Definition at line 470 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_INVALID, and MAKE_VARARG_CALL.

Referenced by notepad::ipc_sys_busy(), ipc_sys_busy(), ipc_sys_set_busy(), and ipc_sys_set_busy_nodialog().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysResetBusy",
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_sysd_set_bg_busy

(

eripc_client_context_t *

ccontext

)

Set background busy state

Definition at line 476 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_INVALID, and MAKE_VARARG_CALL.

Referenced by notepad::ipc_sys_bg_busy(), and ipc_sys_bg_busy().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysSetBgBusy",
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_sysd_set_busy	(	eripc_client_context_t *	ccontext,
		const char *	state,
		const char *	message
	)

Set busy state

Definition at line 463 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, and MAKE_VARARG_CALL_2S.

Referenced by notepad::ipc_sys_busy(), ipc_sys_busy(), ipc_sys_set_busy(), and ipc_sys_set_busy_nodialog().

{
    MAKE_VARARG_CALL_2S(DBUS_SERVICE_SYSTEM_CONTROL, "sysSetBusy", state, message);
}

Here is the caller graph for this function:

gboolean eripc_sysd_set_keyboard	(	eripc_client_context_t *	ccontext,
		const char *	state
	)

Set keyboard state

Definition at line 488 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, and MAKE_VARARG_CALL_1S.

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "sysSetKeyboard", state);
}

gboolean eripc_sysd_set_menu_state	(	eripc_client_context_t *	ccontext,
		const char *	state
	)

Set the popupmenu's state

Definition at line 442 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, and MAKE_VARARG_CALL_1S.

Referenced by ipc_menu_block(), ipc_menu_popup(), ipc_menu_unblock(), ipc_send_request_popup(), and notepad::menu_block().

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "menuRequestPopup", state);
}

Here is the caller graph for this function:

gint eripc_sysd_start_task	(	eripc_client_context_t *	ccontext,
		const gchar *	cmd_line,
		const gchar *	work_dir,
		const gchar *	label,
		const gchar *	thumbnail_path,
		gchar **	err_message
	)

Request a task be started

Definition at line 533 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, MAKE_BUSY_TIMEOUT_END, MAKE_BUSY_TIMEOUT_START, MAKE_VARARG_WAIT_CALL, and parse_reply_start().

Referenced by ipc_sys_start_task().

{
    int old_timeout;
    int timeout_set = 0;
    int retval = 0;
    eripc_error_t result;

    MAKE_BUSY_TIMEOUT_START(60);
    MAKE_VARARG_WAIT_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "startTask",
                          parse_reply_start(reply, err_message),
                          ERIPC_TYPE_STRING, cmd_line,
                          ERIPC_TYPE_STRING, work_dir,
                          ERIPC_TYPE_STRING, label,
                          ERIPC_TYPE_STRING, thumbnail_path,
                          ERIPC_TYPE_INVALID );
    MAKE_BUSY_TIMEOUT_END();
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gboolean eripc_sysd_startup_complete	(	eripc_client_context_t *	ccontext,
		const int	pid,
		const gboolean	is_multidoc,
		const int	xid
	)

Signal the application has completed startup

Definition at line 494 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_BOOL, ERIPC_TYPE_INT, ERIPC_TYPE_INVALID, ERIPC_TYPE_STRING, MAKE_SIGNAL_VARARG_CALL, eripc_client_context_t::name, and eripc_client_context_t::service.

Referenced by ipc_send_startup_complete(), and ipc_sys_startup_complete().

{
    MAKE_SIGNAL_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "startupComplete",
                            ERIPC_TYPE_STRING, ccontext->name,
                            ERIPC_TYPE_INT,    pid,
                            ERIPC_TYPE_BOOL,   is_multidoc,
                            ERIPC_TYPE_STRING, ccontext->service,
                            ERIPC_TYPE_INT,    xid,
                            ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

gboolean eripc_sysd_stop_task	(	eripc_client_context_t *	ccontext,
		const char *	cmd_line
	)

Request a task be stopped

Definition at line 557 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, and MAKE_VARARG_CALL_1S.

Referenced by ipc_sys_stop_task().

{
    MAKE_VARARG_CALL_1S(DBUS_SERVICE_SYSTEM_CONTROL, "stopTask", cmd_line);
}

Here is the caller graph for this function:

gboolean eripc_sysd_unmount_sd_card

(

eripc_client_context_t *

ccontext

)

Request an SD card unmount

Definition at line 456 of file support.c.

References DBUS_SERVICE_SYSTEM_CONTROL, ERIPC_TYPE_INVALID, and MAKE_VARARG_CALL.

Referenced by unmount_sd_card().

{
    MAKE_VARARG_CALL(DBUS_SERVICE_SYSTEM_CONTROL, "sysCardUnmount",
                     ERIPC_TYPE_INVALID );
}

Here is the caller graph for this function:

eripc_error_t eripc_unset_handler	(	eripc_context_t *	context,
		int	handler_id
	)

This function unregisters a handler for event, message, or signal.

Parameters:

	context	IPC context returned by eripc_init.
	handler_id	Handler to unregister. The handler will not be called after it has been successfully unregistered.

Returns:

ERIPC_ERROR_SUCCESS on success.

Definition at line 548 of file hw.c.

References ERIPC_ERROR_INVALID, ERIPC_ERROR_SUCCESS, ULOG_DEBUG_F, and ULOG_ERR_F.

Referenced by eripc_client_context_free(), ipc_unset_services(), and term_handler().

{
        ULOG_DEBUG_F("entered");

        if (context == NULL || handler_id == 0) {
                ULOG_ERR_F("invalid arguments");
                return ERIPC_ERROR_INVALID;
        }

        if (_unset_handler((_eripc_context_t*)context, handler_id)) {
                return ERIPC_ERROR_SUCCESS;
        } else {
                /* id was not found */
                return ERIPC_ERROR_INVALID;
        }
}

Here is the caller graph for this function:

gboolean validate_appname

(

const gchar *

application

)

Referenced by _validate().

Here is the caller graph for this function:

---

Variable Documentation

void eripc_bus_t* bus

Definition at line 213 of file internal.h.

gboolean _osso_handler_f _osso_callback_data_t int gboolean call_once_per_handler_id

Definition at line 202 of file internal.h.

gboolean _osso_handler_f _osso_callback_data_t * data

Definition at line 185 of file internal.h.

Referenced by utils::Listeners::add_listener(), chunk_program(), export_device_info(), get_application_window(), images::DataContainer< MarkerEntry * >::get_count(), text::DataContainer< T * >::get_count(), images::DataContainer< T * >::get_count(), images::DataContainer< MarkerEntry * >::get_first_element(), text::DataContainer< T * >::get_first_element(), images::DataContainer< T * >::get_first_element(), get_window_list(), link_html(), main(), micro_enter_mode(), micro_read_devicetype(), micro_write_devicetype(), page_html(), pagebar_load_bitmaps(), print_window_list(), images::DataContainer< MarkerEntry * >::ref(), text::DataContainer< T * >::ref(), images::DataContainer< T * >::ref(), render_single_line(), sector_erase(), single_instance_get_window(), sys_get_device_capabilities(), anonymous_namespace{utils_unittest.cpp}::TemplateImpl< T >::TemplateImpl(), view_show_error(), images::DataContainer< MarkerEntry * >::~DataContainer(), text::DataContainer< T * >::~DataContainer(), and images::DataContainer< T * >::~DataContainer().

gboolean _osso_handler_f* handler

Definition at line 202 of file internal.h.

Referenced by ipc_set_services().

gboolean int handler_id

Definition at line 202 of file internal.h.

Referenced by _filter(), _send_helper(), ipc_set_services(), and ipc_unset_services().

void const char int char* id

Definition at line 217 of file internal.h.

Referenced by testDoc().

void char* interface

Definition at line 188 of file internal.h.

Referenced by _send_helper(), _send_sync_helper(), eripc_client_context_new(), eripc_set_message_handler(), eripc_set_signal_handler(), notepad::ipc_set_services(), and ipc_set_services().

DBusHandlerResult DBusMessage* msg

Definition at line 185 of file internal.h.

Referenced by _send_helper(), _send_signal_helper(), _send_sync_helper(), da_expose(), display_flipbar_portrait(), display_view_type(), erscribble_driver_update_display(), main(), menu_on_item_activated(), navigation_requested_cb(), on_changed_orientation(), on_file_close(), on_file_open(), on_mounted(), on_page_change(), on_prepare_unmount(), on_sys_changed_pageturn_inverted(), on_unmounted(), on_window_activated(), on_window_deactivated(), run_error_dialog(), and send_message().

void const char* name

Definition at line 197 of file internal.h.

Referenced by utils::InterfaceTable::add_entry(), utils::ObjectTable< PluginRenderResultImpl >::add_interface(), cb_open_url(), cb_status_item_activated(), check_global_database_columns(), check_global_database_tables(), compare_func(), create_auto_shutdown_widgets(), create_result_table(), eripc_client_context_new(), eripc_init(), ermetadb_global_get_file(), ermetadb_local_get_annotations(), erscribble_doc_new(), erscribble_doc_open(), erscribble_line_style_from_str(), filemodel_get_first_alpha_index(), filemodel_scroll_to_letter(), fill_add_group(), find_route(), fix_name(), get_ext_name(), get_sorted_name(), notepad::ipc_set_services(), utils::InterfaceEntry< T >::is_name_equal(), main(), make_unique_filename(), parse_wm_messages(), printfunc(), scroll_to_filename(), pdf::PDFAnchor::set_end_anchor(), set_file_metadata_impl(), update_alpha_list(), and utils::ObjectTable< PluginRenderResultImpl >::~ObjectTable().

void char* path

Definition at line 194 of file internal.h.

Referenced by _send_helper(), _send_sync_helper(), create_registry(), create_screen_layout(), ergtk_icon_view_set_cursor(), ergtk_keyb_create_key_in_table(), ergtk_list_view_get_cursor(), ergtk_list_view_get_view_size(), ergtk_list_view_set_cursor(), eripc_client_context_new(), erscribble_doc_new(), erscribble_doc_open(), images::ImagesDocument::get_anchor_of_page(), get_entry_at_cursor(), images::ImagesDocument::get_page(), images::ImagesDocument::get_prev_page(), notepad::ipc_set_services(), magic_uri(), micro_sysfs_read(), on_button_press_event(), on_button_release_event(), on_pre_move_cursor(), parse_file_url(), parse_folder_path(), parse_shortcut_file(), test_ImagesScanner(), and write_properties_stringhash().

void const char char* ready_name

Definition at line 197 of file internal.h.

void const char * sender

Definition at line 213 of file internal.h.

Referenced by _reply_helper(), cb_sys_reset_bg_busy(), cb_sys_reset_fg_busy(), cb_sys_set_bg_busy(), cb_sys_set_busy_led(), cb_sys_set_fg_busy(), eripc_reply_error(), and sender_from_service().

void const char int serial

Definition at line 213 of file internal.h.

Referenced by _reply_helper(), eripc_reply_error(), get_ebook_mall_home(), and main().

void char* service

Definition at line 191 of file internal.h.

Referenced by _send_helper(), _send_sync_helper(), cb_conn_connect(), eripc_client_context_new(), handle_status_item(), ipc_send_page_change(), notepad::ipc_set_services(), and parse_wm_messages().