static int ldbus_connection_has_messages_to_send(lua_State *L) {
DBusConnection *connection = check_DBusConnection(L, 1);
lua_pushboolean(L, dbus_connection_has_messages_to_send(connection));
return 1;
}
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;
}
/*
* 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);
}
/**
* 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 );
}
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;
}
