static gboolean
message_queue_prepare (GSource *source, gint *timeout)
{
DBusConnection *connection = ((DBusGMessageQueue *)source)->connection;
*timeout = -1;
return (dbus_connection_get_dispatch_status (connection) == DBUS_DISPATCH_DATA_REMAINS);
}
static gboolean setup_bus(DBusConnection *conn, const char *name,
DBusError *error)
{
gboolean result;
DBusDispatchStatus status;
if (name != NULL) {
result = g_dbus_request_name(conn, name, error);
if (error != NULL) {
if (dbus_error_is_set(error) == TRUE)
return FALSE;
}
if (result == FALSE)
return FALSE;
}
setup_dbus_with_main_loop(conn);
status = dbus_connection_get_dispatch_status(conn);
queue_dispatch(conn, status);
return TRUE;
}
static Eina_Bool watch_handler_dispatch(void *data,
Ecore_Fd_Handler *e_handler)
{
struct watch_handler *io_handler = data;
DBusDispatchStatus status;
unsigned int flags = 0;
if (ecore_main_fd_handler_active_get(e_handler, ECORE_FD_ERROR)
== EINA_TRUE)
flags |= DBUS_WATCH_ERROR;
if (ecore_main_fd_handler_active_get(e_handler, ECORE_FD_READ)
== EINA_TRUE)
flags |= DBUS_WATCH_READABLE;
if (ecore_main_fd_handler_active_get(e_handler, ECORE_FD_WRITE)
== EINA_TRUE)
flags |= DBUS_WATCH_WRITABLE;
dbus_watch_handle(io_handler->watch, flags);
status = dbus_connection_get_dispatch_status(io_handler->dbus_cnx);
if (status == DBUS_DISPATCH_DATA_REMAINS)
ecore_timer_add(0, efl_dispatch_dbus, io_handler->dbus_cnx);
dbus_connection_unref(io_handler->dbus_cnx);
return TRUE;
}
/**
* DispatchDBusMessages() dispatches incoming dbus messages
* (indirectly invoking the callbacks), then it sends outgoing
* messages which needs to be sent on the bus (method replies and signals)
*
* This function must be called with p_sys->lock unlocked
*
* @param intf_thread_t *p_intf This interface thread state
*/
static void DispatchDBusMessages( intf_thread_t *p_intf )
{
DBusDispatchStatus status;
intf_sys_t *p_sys = p_intf->p_sys;
/* Dispatch incoming messages */
status = dbus_connection_get_dispatch_status( p_sys->p_conn );
while( status != DBUS_DISPATCH_COMPLETE )
{
dbus_connection_dispatch( p_sys->p_conn );
status = dbus_connection_get_dispatch_status( p_sys->p_conn );
}
/* Send outgoing data */
if( dbus_connection_has_messages_to_send( p_sys->p_conn ) )
dbus_connection_flush( p_sys->p_conn );
}
/**
* dispatch_initial_dbus_messages - Dispatch initial dbus messages after
* claiming bus name
* @eloop_ctx: the DBusConnection to dispatch on
* @timeout_ctx: unused
*
* If clients are quick to notice that wpa_supplicant claimed its bus name,
* there may have been messages that came in before initialization was
* all finished. Dispatch those here.
*/
static void dispatch_initial_dbus_messages(void *eloop_ctx, void *timeout_ctx)
{
DBusConnection *con = eloop_ctx;
while (dbus_connection_get_dispatch_status(con) ==
DBUS_DISPATCH_DATA_REMAINS)
dbus_connection_dispatch(con);
}
void pcmk_dbus_connection_setup_with_select(DBusConnection *c){
dbus_connection_set_exit_on_disconnect (c, FALSE);
dbus_connection_set_timeout_functions(
c, pcmk_dbus_timeout_add, pcmk_dbus_timeout_remove, pcmk_dbus_timeout_toggle, NULL, NULL);
dbus_connection_set_watch_functions(c, pcmk_dbus_watch_add, pcmk_dbus_watch_remove, pcmk_dbus_watch_toggle, NULL, NULL);
dbus_connection_set_dispatch_status_function(c, pcmk_dbus_connection_dispatch, NULL, NULL);
pcmk_dbus_connection_dispatch(c, dbus_connection_get_dispatch_status(c), NULL);
}
static void Run ( intf_thread_t *p_intf )
{
for( ;; )
{
if( dbus_connection_get_dispatch_status(p_intf->p_sys->p_conn)
== DBUS_DISPATCH_COMPLETE )
msleep( INTF_IDLE_SLEEP );
int canc = vlc_savecancel();
dbus_connection_read_write_dispatch( p_intf->p_sys->p_conn, 0 );
/* Get the list of events to process
*
* We can't keep the lock on p_intf->p_sys->p_events, else we risk a
* deadlock:
* The signal functions could lock mutex X while p_events is locked;
* While some other function in vlc (playlist) might lock mutex X
* and then set a variable which would call AllCallback(), which itself
* needs to lock p_events to add a new event.
*/
vlc_mutex_lock( &p_intf->p_sys->lock );
int i_events = vlc_array_count( p_intf->p_sys->p_events );
callback_info_t* info[i_events];
for( int i = i_events - 1; i >= 0; i-- )
{
info[i] = vlc_array_item_at_index( p_intf->p_sys->p_events, i );
vlc_array_remove( p_intf->p_sys->p_events, i );
}
vlc_mutex_unlock( &p_intf->p_sys->lock );
for( int i = 0; i < i_events; i++ )
{
switch( info[i]->signal )
{
case SIGNAL_ITEM_CURRENT:
TrackChange( p_intf );
break;
case SIGNAL_INTF_CHANGE:
case SIGNAL_PLAYLIST_ITEM_APPEND:
case SIGNAL_PLAYLIST_ITEM_DELETED:
TrackListChangeEmit( p_intf, info[i]->signal, info[i]->i_node );
break;
case SIGNAL_RANDOM:
case SIGNAL_REPEAT:
case SIGNAL_LOOP:
StatusChangeEmit( p_intf );
break;
case SIGNAL_STATE:
StateChange( p_intf, info[i]->i_input_state );
break;
default:
assert(0);
}
free( info[i] );
}
vlc_restorecancel( canc );
}
}
void block_hook_cb( hidval data )
{
/* phantom */ DBusConnection *connection;
if ( dbus_connection_get_dispatch_status( &data.lval ) == 0 )
{
data = data;
}
return;
}
static void pcmk_dbus_connection_dispatch(DBusConnection *connection, DBusDispatchStatus new_status, void *data){
crm_trace("status %d for %p", new_status, data);
if (new_status == DBUS_DISPATCH_DATA_REMAINS){
dbus_connection_dispatch(connection);
while (dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS) {
dbus_connection_dispatch(connection);
}
}
}
static void request_dispatch(ConnectionData *d, int enable) {
static const struct timeval tv = { 0, 0 };
assert(d);
if (enable) {
assert(dbus_connection_get_dispatch_status(d->connection) == DBUS_DISPATCH_DATA_REMAINS);
d->poll_api->timeout_update(d->dispatch_timeout, &tv);
} else
d->poll_api->timeout_update(d->dispatch_timeout, NULL);
}
int dbus_update(struct dbus* dbus)
{
DBusDispatchStatus status;
// handle watches
Word_t watch_count = 0;
JLC(watch_count, dbus->watches, 0, -1);
struct pollfd* pollfds = (struct pollfd*)alloca(sizeof(struct pollfd) * watch_count);
int fdcount = get_pollfds(dbus, pollfds);
if(poll(pollfds, fdcount, 0) < 0) {
return -1;
}
// process the watches
DBusWatch** pwatch;
Word_t index = 0;
int c = 0;
JLF(pwatch, dbus->watches, index);
while(pwatch != NULL) {
struct pollfd* poll_result = &pollfds[c];
struct DBusWatch* watch = *pwatch;
if(dbus_watch_get_enabled(watch)) {
assert(poll_result->fd == dbus_watch_get_unix_fd(watch));
int flags = 0;
int revents = poll_result->revents;
if((revents & POLLIN) != 0) flags |= DBUS_WATCH_READABLE;
if((revents & POLLOUT) != 0) flags |= DBUS_WATCH_WRITABLE;
if((revents & POLLERR) != 0) flags |= DBUS_WATCH_ERROR;
if((revents & POLLHUP) != 0) flags |= DBUS_WATCH_HANGUP;
if(flags != 0) dbus_watch_handle(watch, flags);
c++;
}
JLN(pwatch, dbus->watches, index);
}
// dispatch incoming messages
while((status = dbus_connection_get_dispatch_status(dbus->conn)) != DBUS_DISPATCH_COMPLETE) {
dbus_connection_dispatch(dbus->conn);
}
// Send outgoing messages
if(dbus_connection_has_messages_to_send(dbus->conn)) {
dbus_connection_flush(dbus->conn);
}
return 0;
}
static void efl_dbus_dispatch_status(DBusConnection *connection,
DBusDispatchStatus new_status, void *data)
{
DBusDispatchStatus status;
if (dbus_connection_get_is_connected(connection) == FALSE)
return;
status = dbus_connection_get_dispatch_status(connection);
if (status == DBUS_DISPATCH_DATA_REMAINS)
ecore_timer_add(0, efl_dispatch_dbus, connection);
}
dbus_bool_t
test_connection_setup (DBusLoop *loop,
DBusConnection *connection)
{
CData *cd;
cd = NULL;
dbus_connection_set_dispatch_status_function (connection, dispatch_status_function,
loop, NULL);
cd = cdata_new (loop, connection);
if (cd == NULL)
goto nomem;
if (!dbus_connection_set_watch_functions (connection,
add_watch,
remove_watch,
toggle_watch,
cd, cdata_free))
goto nomem;
cd = cdata_new (loop, connection);
if (cd == NULL)
goto nomem;
if (!dbus_connection_set_timeout_functions (connection,
add_timeout,
remove_timeout,
NULL,
cd, cdata_free))
goto nomem;
if (dbus_connection_get_dispatch_status (connection) != DBUS_DISPATCH_COMPLETE)
{
if (!_dbus_loop_queue_dispatch (loop, connection))
goto nomem;
}
return TRUE;
nomem:
if (cd)
cdata_free (cd);
dbus_connection_set_dispatch_status_function (connection, NULL, NULL, NULL);
dbus_connection_set_watch_functions (connection, NULL, NULL, NULL, NULL, NULL);
dbus_connection_set_timeout_functions (connection, NULL, NULL, NULL, NULL, NULL);
return FALSE;
}
void asdbus_handleDispatches (){
#ifdef ASDBUS_DISPATCH
void *data;
while ((data = extract_first_bidirelem (ASDBus.dispatches)) != NULL){
ASDBusDispatch *d = (ASDBusDispatch*)data;
while (dbus_connection_get_dispatch_status(d->data) == DBUS_DISPATCH_DATA_REMAINS){
dbus_connection_dispatch(d->data);
show_debug(__FILE__,__FUNCTION__,__LINE__,"dispatching dbus data=%p\n", d->data);
}
free (d);
}
#endif
}
static void
wakeup_handler(void *data, int err, void *read_mask)
{
struct dbus_core_info *info = data;
if (info->connection && FD_ISSET(info->fd, (fd_set *) read_mask)) {
do {
dbus_connection_read_write_dispatch(info->connection, 0);
} while (info->connection &&
dbus_connection_get_is_connected(info->connection) &&
dbus_connection_get_dispatch_status(info->connection) ==
DBUS_DISPATCH_DATA_REMAINS);
}
}
/*
* dbus notifications
*/
static void
_cs_dbus_auto_flush(void)
{
dbus_connection_ref(db);
while (dbus_connection_get_dispatch_status(db) == DBUS_DISPATCH_DATA_REMAINS) {
dbus_connection_dispatch(db);
}
while (dbus_connection_has_messages_to_send(db)) {
dbus_connection_flush(db);
}
dbus_connection_unref(db);
}
static void process_wakeup_main(int sig, void *eloop_ctx, void *signal_ctx)
{
struct ctrl_iface_dbus_priv *iface = signal_ctx;
if (sig != SIGPOLL || !iface->con)
return;
if (dbus_connection_get_dispatch_status(iface->con) !=
DBUS_DISPATCH_DATA_REMAINS)
return;
/* Only dispatch once - we do not want to starve other events */
dbus_connection_ref(iface->con);
dbus_connection_dispatch(iface->con);
dbus_connection_unref(iface->con);
}
static void
block_hook_cb (hidval data) {
DBusConnection *connection = (DBusConnection *) data.ptr;
if (dbus_connection_get_dispatch_status (connection) !=
DBUS_DISPATCH_DATA_REMAINS) {
return;
}
// TODO: IS THIS NEEDED?
// dbus_connection_ref (connection);
/* Only dispatch once - we don't want to starve other mainloop users */
dbus_connection_dispatch (connection);
// dbus_connection_unref (connection);
return;
}
static void
timeout_handler(EV_P_ struct ev_timer *ev, int revents)
{
struct timeout *t = (struct timeout *)ev;
(void)revents;
lem_debug("timeout");
(void)dbus_timeout_handle(t->timeout);
if (dbus_connection_get_dispatch_status(t->conn)
== DBUS_DISPATCH_DATA_REMAINS) {
while (dbus_connection_dispatch(t->conn)
== DBUS_DISPATCH_DATA_REMAINS);
}
}
static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
{
DBusWatch *watch = data;
struct watch_info *info = dbus_watch_get_data(watch);
int flags = 0;
if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE;
if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE;
if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP;
if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR;
dbus_watch_handle(watch, flags);
if (dbus_connection_get_dispatch_status(info->conn) == DBUS_DISPATCH_DATA_REMAINS)
g_timeout_add(DISPATCH_TIMEOUT, message_dispatch_cb, info->conn);
return TRUE;
}
static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
{
struct watch_info *info = data;
unsigned int flags = 0;
DBusDispatchStatus status;
if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE;
if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE;
if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP;
if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR;
dbus_watch_handle(info->watch, flags);
status = dbus_connection_get_dispatch_status(info->conn);
queue_dispatch(info->conn, status);
return TRUE;
}
int avahi_dbus_connection_glue(DBusConnection *c, const AvahiPoll *poll_api) {
ConnectionData *d = NULL;
assert(c);
assert(poll_api);
if (!(d = avahi_new(ConnectionData, 1)))
goto fail;;
d->poll_api = poll_api;
d->connection = c;
d->ref = 1;
if (!(d->dispatch_timeout = poll_api->timeout_new(poll_api, NULL, dispatch_timeout_callback, d)))
goto fail;
if (!(dbus_connection_set_watch_functions(c, add_watch, remove_watch, watch_toggled, connection_data_ref(d), (DBusFreeFunction)connection_data_unref)))
goto fail;
if (!(dbus_connection_set_timeout_functions(c, add_timeout, remove_timeout, timeout_toggled, connection_data_ref(d), (DBusFreeFunction)connection_data_unref)))
goto fail;
dbus_connection_set_dispatch_status_function(c, dispatch_status, connection_data_ref(d), (DBusFreeFunction)connection_data_unref);
if (dbus_connection_get_dispatch_status(c) == DBUS_DISPATCH_DATA_REMAINS)
request_dispatch(d, 1);
connection_data_unref(d);
return 0;
fail:
if (d) {
d->poll_api->timeout_free(d->dispatch_timeout);
avahi_free(d);
}
return -1;
}
Bool asdbus_init ()
{ /* return connection unix fd */
char *tmp;
#ifdef ASDBUS_DISPATCH
if (!ASDBus.dispatches)
ASDBus.dispatches = create_asbidirlist(asdbus_dispatch_destroy);
#endif
if (!ASDBus.session_conn) {
ASDBus.session_conn = _asdbus_get_session_connection();
if (!dbus_connection_set_watch_functions(ASDBus.session_conn, add_watch, remove_watch, toggle_watch, ASDBus.session_conn, NULL)) {
show_error("dbus_connection_set_watch_functions() failed");
}
_asdbus_add_match (ASDBus.session_conn, SESSIONMANAGER_INTERFACE, NULL);
//_asdbus_add_match (ASDBus.session_conn, IFACE_SESSION_PRIVATE, "QueryEndSession");
//_asdbus_add_match (ASDBus.session_conn, IFACE_SESSION_PRIVATE, "EndSession");
//_asdbus_add_match (ASDBus.session_conn, IFACE_SESSION_PRIVATE, "Stop");
dbus_connection_set_timeout_functions(ASDBus.session_conn, add_timeout, remove_timeout, toggle_timeout, NULL, NULL);
#ifdef ASDBUS_DISPATCH
dbus_connection_set_dispatch_status_function(ASDBus.session_conn, queue_dispatch, NULL, NULL);
queue_dispatch(ASDBus.session_conn, dbus_connection_get_dispatch_status(ASDBus.session_conn), NULL);
#endif
}
if (!ASDBus.system_conn){
ASDBus.system_conn = _asdbus_get_system_connection();
/*if (!dbus_connection_set_watch_functions(ASDBus.system_conn, add_watch, remove_watch, toggle_watch, ASDBus.system_conn, NULL)) {
show_error("dbus_connection_set_watch_functions() failed");
}*/
}
/*if (ASDBus.session_conn && ASDBus.watchFds == NULL){
//dbus_connection_get_unix_fd (ASDBus.session_conn, &(ASDBus.watch_fd));
//dbus_whatch_get_unix_fd (ASDBus.session_conn, &(ASDBus.watch_fd));
}*/
if ((tmp = getenv ("KDE_SESSION_VERSION")) != NULL)
ASDBus.kdeSessionVersion = atoi(tmp);
return (ASDBus.session_conn != NULL);
}
static void process_watch(struct ctrl_iface_dbus_priv *iface,
DBusWatch *watch, eloop_event_type type)
{
dbus_connection_ref(iface->con);
iface->should_dispatch = 0;
if (type == EVENT_TYPE_READ)
dbus_watch_handle(watch, DBUS_WATCH_READABLE);
else if (type == EVENT_TYPE_WRITE)
dbus_watch_handle(watch, DBUS_WATCH_WRITABLE);
else if (type == EVENT_TYPE_EXCEPTION)
dbus_watch_handle(watch, DBUS_WATCH_ERROR);
if (iface->should_dispatch) {
while (dbus_connection_get_dispatch_status(iface->con) ==
DBUS_DISPATCH_DATA_REMAINS)
dbus_connection_dispatch(iface->con);
iface->should_dispatch = 0;
}
dbus_connection_unref(iface->con);
}
static dbus_bool_t setup_dbus_in_efl_mainloop(DBusConnection *dbus_cnx)
{
DBusDispatchStatus status;
if (dbus_connection_set_watch_functions(dbus_cnx,
efl_dbus_watch_add, efl_dbus_watch_remove,
efl_dbus_watch_toggled, dbus_cnx, NULL) == FALSE)
return FALSE;
if (dbus_connection_set_timeout_functions(dbus_cnx,
efl_dbus_timeout_add, efl_dbus_timeout_remove,
efl_dbus_timeout_toggled, dbus_cnx, NULL) == FALSE)
return FALSE;
dbus_connection_set_dispatch_status_function(dbus_cnx,
efl_dbus_dispatch_status, dbus_cnx, NULL);
status = dbus_connection_get_dispatch_status(dbus_cnx);
if (status == DBUS_DISPATCH_DATA_REMAINS)
ecore_timer_add(0, efl_dispatch_dbus, dbus_cnx);
return TRUE;
}
static void
watch_handler(EV_P_ struct ev_io *ev, int revents)
{
struct watch *w = (struct watch *)ev;
unsigned int flags = 0;
if (revents & EV_READ)
flags |= DBUS_WATCH_READABLE;
if (revents & EV_WRITE)
flags |= DBUS_WATCH_WRITABLE;
if (revents & EV_ERROR)
flags |= DBUS_WATCH_ERROR;
lem_debug("flags = %s", flags & DBUS_WATCH_ERROR ? "ERROR" :
flags & DBUS_WATCH_READABLE ? "READ" : "WRITE");
(void)dbus_watch_handle(w->watch, flags);
if (dbus_connection_get_dispatch_status(w->conn)
== DBUS_DISPATCH_DATA_REMAINS) {
while (dbus_connection_dispatch(w->conn)
== DBUS_DISPATCH_DATA_REMAINS);
}
}
void DBus_SetupProc(ClientData data, int flags)
{
Tcl_Time blockTime;
DBusDispatchStatus status;
Tcl_HashEntry *hPtr;
Tcl_HashSearch search;
Tcl_DBusBus *dbus;
blockTime.sec = 0;
blockTime.usec = 100000;
/* Check the incoming message queues */
for (hPtr = Tcl_FirstHashEntry(&bus, &search); hPtr != NULL;
hPtr = Tcl_NextHashEntry(&search)) {
dbus = (Tcl_DBusBus *) Tcl_GetHashValue(hPtr);
dbus_connection_read_write(dbus->conn, 0);
status = dbus_connection_get_dispatch_status(dbus->conn);
if (status == DBUS_DISPATCH_DATA_REMAINS) {
blockTime.sec = 0;
blockTime.usec = 0;
break;
}
}
Tcl_SetMaxBlockTime(&blockTime);
}
static void dispatch_data(DBusConnection *con)
{
while (dbus_connection_get_dispatch_status(con) ==
DBUS_DISPATCH_DATA_REMAINS)
dbus_connection_dispatch(con);
}
wxThread::ExitCode DBusThread::Entry()
{
while (!m_exit) {
EnterCriticalSection();
while (dbus_connection_get_dispatch_status(m_connection) == DBUS_DISPATCH_DATA_REMAINS)
dbus_connection_dispatch(m_connection);
// Prepare list of file descriptors to pull
struct pollfd *fd_array = new struct pollfd[bus_watches.size() + 1];
fd_array[0].fd = m_wakeup_pipe[0];
fd_array[0].events = POLLIN;
unsigned int nfds = 1;
for (auto it = bus_watches.begin(); it != bus_watches.end(); ++it) {
if (dbus_watch_get_enabled(*it))
{
#if WITH_LIBDBUS >= 2
fd_array[nfds].fd = dbus_watch_get_unix_fd(*it);
#else
fd_array[nfds].fd = dbus_watch_get_fd(*it);
#endif
int flags = dbus_watch_get_flags(*it);
fd_array[nfds].events = POLLHUP | POLLERR;
if (flags & DBUS_WATCH_READABLE)
fd_array[nfds].events |= POLLIN;
if (flags & DBUS_WATCH_WRITABLE)
fd_array[nfds].events |= POLLOUT;
++nfds;
}
}
LeaveCriticalSection();
if (poll(fd_array, nfds, -1) > 0) {
EnterCriticalSection();
m_thread_holds_lock = true;
char tmp;
if (read(m_wakeup_pipe[0], &tmp, 1) == 1) {
m_thread_holds_lock = false;
LeaveCriticalSection();
delete [] fd_array;
continue;
}
for (auto it = bus_watches.begin(); it != bus_watches.end(); ++it) {
if (!dbus_watch_get_enabled(*it))
continue;
#if WITH_LIBDBUS >= 2
int fd = dbus_watch_get_unix_fd(*it);
#else
int fd = dbus_watch_get_fd(*it);
#endif
unsigned int i;
for (i = 1; i < nfds; ++i) {
if (fd_array[i].fd == fd && fd_array[i].revents) {
int flags = 0;
if (fd_array[i].revents & POLLIN)
flags |= DBUS_WATCH_READABLE;
if (fd_array[i].revents & POLLOUT)
flags |= DBUS_WATCH_WRITABLE;
if (fd_array[i].revents & POLLERR)
flags |= DBUS_WATCH_ERROR;
if (fd_array[i].revents & POLLHUP)
flags |= DBUS_WATCH_HANGUP;
dbus_watch_handle(*it, flags);
break;
}
}
// Only handle a single watch in each poll iteration, bus_watches could change inside dbus_watch_handle
if (i != nfds)
break;
}
m_thread_holds_lock = false;
LeaveCriticalSection();
}
delete [] fd_array;
}
return 0;
}
int tool_cmd_scan(int argc, char *argv[])
{
int ret = 0;
int c;
int timeout = DEFAULT_TIMEOUT_IN_SECONDS * 1000;
DBusConnection* connection = NULL;
DBusMessage *message = NULL;
DBusMessage *reply = NULL;
DBusPendingCall *pending = NULL;
DBusError error;
int32_t scan_period = 0;
uint32_t channel_mask = 0;
dbus_error_init(&error);
while (1) {
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"timeout", required_argument, 0, 't'},
{"channel", required_argument, 0, 'c'},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long(argc, argv, "hc:t:", long_options,
&option_index);
if (c == -1)
break;
switch (c) {
case 'h':
print_arg_list_help(scan_option_list, argv[0],
scan_cmd_syntax);
ret = ERRORCODE_HELP;
goto bail;
case 't':
timeout = strtol(optarg, NULL, 0);
break;
case 'c':
channel_mask = strtomask_uint32(optarg);
break;
}
}
if (optind < argc) {
if (scan_period == 0) {
scan_period = strtol(argv[optind], NULL, 0);
optind++;
}
}
if (optind < argc) {
fprintf(stderr,
"%s: error: Unexpected extra argument: \"%s\"\n",
argv[0], argv[optind]);
ret = ERRORCODE_BADARG;
goto bail;
}
if (gInterfaceName[0] == 0) {
fprintf(stderr,
"%s: error: No WPAN interface set (use the `cd` command, or the `-I` argument for `wpanctl`).\n",
argv[0]);
ret = ERRORCODE_BADARG;
goto bail;
}
connection = dbus_bus_get(DBUS_BUS_STARTER, &error);
if (!connection) {
dbus_error_free(&error);
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
}
require_string(connection != NULL, bail, error.message);
dbus_bus_add_match(connection, gDBusObjectManagerMatchString, &error);
require_string(error.name == NULL, bail, error.message);
dbus_connection_add_filter(connection, &dbus_beacon_handler, NULL, NULL);
{
char path[DBUS_MAXIMUM_NAME_LENGTH+1];
char interface_dbus_name[DBUS_MAXIMUM_NAME_LENGTH+1];
DBusMessageIter iter;
ret = lookup_dbus_name_from_interface(interface_dbus_name, gInterfaceName);
if (ret != 0) {
goto bail;
}
snprintf(
path,
sizeof(path),
"%s/%s",
WPANTUND_DBUS_PATH,
gInterfaceName
);
message = dbus_message_new_method_call(
interface_dbus_name,
path,
WPANTUND_DBUS_APIv1_INTERFACE,
WPANTUND_IF_CMD_NET_SCAN_START
);
dbus_message_append_args(
message,
DBUS_TYPE_UINT32, &channel_mask,
DBUS_TYPE_INVALID
);
print_scan_header();
gScannedNetworkCount = 0;
if(!dbus_connection_send_with_reply(
connection,
message,
&pending,
timeout
)) {
fprintf(stderr, "%s: error: IPC failure\n", argv[0]);
ret = ERRORCODE_UNKNOWN;
goto bail;
}
while ((dbus_connection_get_dispatch_status(connection) == DBUS_DISPATCH_DATA_REMAINS)
|| dbus_connection_has_messages_to_send(connection)
|| !dbus_pending_call_get_completed(pending)
) {
dbus_connection_read_write_dispatch(connection, 5000 /*ms*/);
}
reply = dbus_pending_call_steal_reply(pending);
require(reply!=NULL, bail);
dbus_message_iter_init(reply, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_INT32) {
fprintf(stderr, "%s: error: Server returned a bad response ('%c')\n",
argv[0], dbus_message_iter_get_arg_type(&iter));
ret = ERRORCODE_UNKNOWN;
goto bail;
}
// Get return code
dbus_message_iter_get_basic(&iter, &ret);
if (ret) {
fprintf(stderr, "%s failed with error %d. %s\n", argv[0], ret, wpantund_status_to_cstr(ret));
print_error_diagnosis(ret);
goto bail;
}
}
bail:
if (reply) {
dbus_message_unref(reply);
}
if (pending != NULL) {
dbus_pending_call_unref(pending);
}
if (message) {
dbus_message_unref(message);
}
if (connection) {
dbus_bus_remove_match(connection, gDBusObjectManagerMatchString, NULL);
dbus_connection_remove_filter(connection,&dbus_beacon_handler,NULL);
dbus_connection_unref(connection);
}
dbus_error_free(&error);
return ret;
}