/**
* wpas_dbus_global_add_interface - Request registration of a network interface
* @message: Pointer to incoming dbus message
* @global: %wpa_supplicant global data structure
* Returns: The object path of the new interface object,
* or a dbus error message with more information
*
* Handler function for "addInterface" method call. Handles requests
* by dbus clients to register a network interface that wpa_supplicant
* will manage.
*/
DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
struct wpa_global *global)
{
char *ifname = NULL;
char *driver = NULL;
char *driver_param = NULL;
char *confname = NULL;
char *bridge_ifname = NULL;
DBusMessage *reply = NULL;
DBusMessageIter iter;
dbus_message_iter_init(message, &iter);
/* First argument: interface name (DBUS_TYPE_STRING)
* Required; must be non-zero length
*/
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
goto error;
dbus_message_iter_get_basic(&iter, &ifname);
if (!os_strlen(ifname))
goto error;
/* Second argument: dict of options */
if (dbus_message_iter_next(&iter)) {
DBusMessageIter iter_dict;
struct wpa_dbus_dict_entry entry;
if (!wpa_dbus_dict_open_read(&iter, &iter_dict))
goto error;
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!strcmp(entry.key, "driver") &&
(entry.type == DBUS_TYPE_STRING)) {
driver = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver == NULL)
goto error;
} else if (!strcmp(entry.key, "driver-params") &&
(entry.type == DBUS_TYPE_STRING)) {
driver_param = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver_param == NULL)
goto error;
} else if (!strcmp(entry.key, "config-file") &&
(entry.type == DBUS_TYPE_STRING)) {
confname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (confname == NULL)
goto error;
} else if (!strcmp(entry.key, "bridge-ifname") &&
(entry.type == DBUS_TYPE_STRING)) {
bridge_ifname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (bridge_ifname == NULL)
goto error;
} else {
wpa_dbus_dict_entry_clear(&entry);
goto error;
}
}
}
/*
* Try to get the wpa_supplicant record for this iface, return
* an error if we already control it.
*/
if (wpa_supplicant_get_iface(global, ifname) != NULL) {
reply = dbus_message_new_error(message,
WPAS_ERROR_EXISTS_ERROR,
"wpa_supplicant already "
"controls this interface.");
} else {
struct wpa_supplicant *wpa_s;
struct wpa_interface iface;
os_memset(&iface, 0, sizeof(iface));
iface.ifname = ifname;
iface.driver = driver;
iface.driver_param = driver_param;
iface.confname = confname;
iface.bridge_ifname = bridge_ifname;
/* Otherwise, have wpa_supplicant attach to it. */
if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
const char *path = wpa_s->dbus_path;
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
&path, DBUS_TYPE_INVALID);
} else {
reply = dbus_message_new_error(message,
WPAS_ERROR_ADD_ERROR,
"wpa_supplicant "
"couldn't grab this "
"interface.");
}
}
out:
os_free(driver);
os_free(driver_param);
os_free(confname);
os_free(bridge_ifname);
return reply;
error:
reply = wpas_dbus_new_invalid_opts_error(message, NULL);
goto out;
}
static DBusMessage *radio_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_radio_settings *rs = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (rs->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_strcmp0(property, "TechnologyPreference") == 0) {
const char *value;
enum ofono_radio_access_mode mode;
if (rs->driver->set_rat_mode == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (radio_access_mode_from_string(value, &mode) == FALSE)
return __ofono_error_invalid_args(msg);
if (rs->mode == mode)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->pending_mode = mode;
rs->driver->set_rat_mode(rs, mode, radio_mode_set_callback, rs);
return NULL;
} else if (g_strcmp0(property, "GsmBand") == 0) {
const char *value;
enum ofono_radio_band_gsm band;
if (rs->driver->set_band == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (radio_band_gsm_from_string(value, &band) == FALSE)
return __ofono_error_invalid_args(msg);
if (rs->band_gsm == band)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->pending_band_gsm = band;
rs->driver->set_band(rs, band, rs->band_umts,
radio_band_set_callback, rs);
return NULL;
} else if (g_strcmp0(property, "UmtsBand") == 0) {
const char *value;
enum ofono_radio_band_umts band;
if (rs->driver->set_band == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (radio_band_umts_from_string(value, &band) == FALSE)
return __ofono_error_invalid_args(msg);
if (rs->band_umts == band)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->pending_band_umts = band;
rs->driver->set_band(rs, rs->band_gsm, band,
radio_band_set_callback, rs);
return NULL;
} else if (g_strcmp0(property, "FastDormancy") == 0) {
dbus_bool_t value;
int target;
if (rs->driver->set_fast_dormancy == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
target = value;
if (rs->fast_dormancy_pending == target)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->fast_dormancy_pending = target;
rs->driver->set_fast_dormancy(rs, target,
radio_fast_dormancy_set_callback, rs);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
static DBusHandlerResult
on_prompt_signal (DBusConnection *connection, DBusMessage *message, void *user_data)
{
on_prompt_args *args = user_data;
DBusMessageIter iter;
dbus_bool_t dismissed;
GkrOperation *op;
const char *object_name;
const char *new_owner;
const char *old_owner;
g_assert (args);
if (!args->path || !args->op->prompting)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
/* org.freedesktop.Secret.Prompt.Completed(BOOLEAN dismissed, VARIANT result) */
if (dbus_message_has_path (message, args->path) &&
dbus_message_is_signal (message, PROMPT_INTERFACE, "Completed")) {
/* Only one call, even if daemon decides to be strange */
g_free (args->path);
args->path = NULL;
if (!dbus_message_iter_init (message, &iter) ||
dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_BOOLEAN)
g_return_val_if_reached (BROKEN);
dbus_message_iter_get_basic (&iter, &dismissed);
op = gkr_operation_ref (args->op);
if (dismissed)
gkr_operation_complete (op, MATE_KEYRING_RESULT_CANCELLED);
else
callback_with_message (op, message);
if (op->prompting)
dbus_connection_remove_filter (args->op->conn, on_prompt_signal, args);
gkr_operation_unref (op);
return DBUS_HANDLER_RESULT_HANDLED;
}
/* org.freedesktop.DBus.NameOwnerChanged(STRING name, STRING old_owner, STRING new_owner) */
if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS, "NameOwnerChanged") &&
dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &object_name,
DBUS_TYPE_STRING, &old_owner, DBUS_TYPE_STRING, &new_owner,
DBUS_TYPE_INVALID)) {
/* See if it's the secret service going away */
if (object_name && g_str_equal (gkr_service_name (), object_name) &&
new_owner && g_str_equal ("", new_owner)) {
g_message ("Secret service disappeared while waiting for prompt");
op = gkr_operation_ref (args->op);
gkr_operation_complete (op, MATE_KEYRING_RESULT_IO_ERROR);
if (op->prompting)
dbus_connection_remove_filter (args->op->conn, on_prompt_signal, args);
gkr_operation_unref (op);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/**
* @brief Signal handler for technology changed signal from qmi-dbus
*/
static gboolean
on_handle_technology_changed(DBusConnection *conn, DBusMessage *message, gpointer unused) {
DBusMessageIter message_iter;
GHashTableIter hash_iter;
gpointer key, value;
struct qmi_data *qmi = NULL;
/* Get object path of this message */
const gchar *object_path = dbus_message_get_path(message);;
DBG("Object path %s", object_path);
if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
const char *dbus_error = dbus_message_get_error_name(message);
connman_error("%s", dbus_error);
return FALSE;
}
if(dbus_message_iter_init(message, &message_iter) == FALSE) {
connman_error("Failure init ITER");
return FALSE;
}
if(dbus_message_iter_get_arg_type(&message_iter) == DBUS_TYPE_INVALID) {
connman_error("Invalid D-Bus type");
return FALSE;
}
if(object_path) {
/* Find qmi device data to object path */
g_hash_table_iter_init (&hash_iter, qmi_hash);
while (g_hash_table_iter_next (&hash_iter, &key, &value)) {
qmi = (struct qmi_data *)value;
if(g_strcmp0(object_path, qmi->object_path) == 0) {
break;
}
else {
qmi = NULL;
}
}
}
if(qmi == NULL) {
connman_error("No qmi device to object path %s", object_path);
return FALSE;
}
/* Update new property value */
update_network(qmi, &message_iter);
return TRUE;
}
void listen_signal()
{
DBusMessage * msg;
DBusMessageIter arg;
DBusConnection * connection;
DBusError err;
int ret;
char * sigvalue;
//步骤1:建立与D-Bus后台的连接
dbus_error_init(&err);
connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Connection Error %s/n",err.message);
dbus_error_free(&err);
}
if(connection == NULL){
printf("connection is NULL.\n");
return;
}
//步骤2:给连接名分配一个可记忆名字test.singal.dest作为Bus name，这个步骤不是必须的,但推荐这样处理
/*
ret = dbus_bus_request_name(connection,"test.singal.dest",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Name Error %s/n",err.message);
dbus_error_free(&err);
}
if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER){
printf("dbus request name is not primary owner.\n");
return;
}
*/
//步骤3:通知D-Bus daemon，希望监听来行接口test.signal.Type的信号
dbus_bus_add_match(connection,"type='signal',interface='test.signal.Type'",&err);
//实际需要发送东西给daemon来通知希望监听的内容，所以需要flush
dbus_connection_flush(connection);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Match Error %s/n",err.message);
dbus_error_free(&err);
}
//步骤4:在循环中监听，每隔开1秒，就去试图自己的连接中获取这个信号。这里给出的是中连接中获取任何消息的方式，所以获取后去检查一下这个消息是否我们期望的信号，并获取内容。我们也可以通过这个方式来获取method call消息。
gint cnt = 0;
while(1){
dbus_connection_read_write(connection,0);
msg = dbus_connection_pop_message (connection);
if(msg == NULL){
sleep(1);
//printf("cnt:%d\n", cnt++);
continue;
}
printf("message type: %d\n", dbus_message_get_type(msg));
printf("message member: %s\n", dbus_message_get_member(msg));
if(dbus_message_is_signal(msg,"test.signal.Type","Test") ){
if(!dbus_message_iter_init(msg,&arg) )
fprintf(stderr,"Message Has no Param");
else if(dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_STRING)
g_printerr("Param is not string");
else
dbus_message_iter_get_basic(&arg,&sigvalue);
printf("Got Singal with value : %s\n",sigvalue);
}
dbus_message_unref(msg);
}//End of while
printf("end of receiver.");
}
static DBusMessage* dbus_read_servers_ex(DBusMessage *message, int strings)
{
DBusMessageIter iter, array_iter, string_iter;
DBusMessage *error = NULL;
const char *addr_err;
char *dup = NULL;
if (!dbus_message_iter_init(message, &iter))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
}
/* check that the message contains an array of arrays */
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != (strings ? DBUS_TYPE_STRING : DBUS_TYPE_ARRAY)))
{
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
strings ? "Expected array of string" : "Expected array of string arrays");
}
mark_servers(SERV_FROM_DBUS);
/* array_iter points to each "as" element in the outer array */
dbus_message_iter_recurse(&iter, &array_iter);
while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID)
{
const char *str = NULL;
union mysockaddr addr, source_addr;
int flags = 0;
char interface[IF_NAMESIZE];
char *str_addr, *str_domain = NULL;
if (strings)
{
dbus_message_iter_get_basic(&array_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty string");
break;
}
/* dup the string because it gets modified during parsing */
if (dup)
free(dup);
if (!(dup = str_domain = whine_malloc(strlen(str)+1)))
break;
strcpy(str_domain, str);
/* point to address part of old string for error message */
if ((str_addr = strrchr(str, '/')))
str = str_addr+1;
if ((str_addr = strrchr(str_domain, '/')))
{
if (*str_domain != '/' || str_addr == str_domain)
{
error = dbus_message_new_error_printf(message,
DBUS_ERROR_INVALID_ARGS,
"No domain terminator '%s'",
str);
break;
}
*str_addr++ = 0;
str_domain++;
}
else
{
str_addr = str_domain;
str_domain = NULL;
}
}
else
{
/* check the types of the struct and its elements */
if ((dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_STRING))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected inner array of strings");
break;
}
/* string_iter points to each "s" element in the inner array */
dbus_message_iter_recurse(&array_iter, &string_iter);
if (dbus_message_iter_get_arg_type(&string_iter) != DBUS_TYPE_STRING)
{
/* no IP address given */
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected IP address");
break;
}
dbus_message_iter_get_basic(&string_iter, &str);
if (!str || !strlen (str))
{
error = dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Empty IP address");
break;
}
/* dup the string because it gets modified during parsing */
if (dup)
free(dup);
if (!(dup = str_addr = whine_malloc(strlen(str)+1)))
break;
strcpy(str_addr, str);
}
memset(&addr, 0, sizeof(addr));
memset(&source_addr, 0, sizeof(source_addr));
memset(&interface, 0, sizeof(interface));
/* parse the IP address */
if ((addr_err = parse_server(str_addr, &addr, &source_addr, (char *) &interface, &flags)))
{
error = dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s': %s",
str, addr_err);
break;
}
/* 0.0.0.0 for server address == NULL, for Dbus */
if (addr.in.sin_family == AF_INET &&
addr.in.sin_addr.s_addr == 0)
flags |= SERV_NO_ADDR;
if (strings)
{
char *p;
do {
if (str_domain)
{
if ((p = strchr(str_domain, '/')))
*p++ = 0;
}
else
p = NULL;
add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str_domain);
} while ((str_domain = p));
}
else
{
/* jump past the address to the domain list (if any) */
dbus_message_iter_next (&string_iter);
/* parse domains and add each server/domain pair to the list */
do {
str = NULL;
if (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING)
dbus_message_iter_get_basic(&string_iter, &str);
dbus_message_iter_next (&string_iter);
add_update_server(flags | SERV_FROM_DBUS, &addr, &source_addr, interface, str);
} while (dbus_message_iter_get_arg_type(&string_iter) == DBUS_TYPE_STRING);
}
/* jump to next element in outer array */
dbus_message_iter_next(&array_iter);
}
cleanup_servers();
if (dup)
free(dup);
return error;
}
static int print_inhibitors(DBusConnection *bus, DBusError *error) {
DBusMessage *m, *reply;
unsigned n = 0;
DBusMessageIter iter, sub, sub2;
int r;
assert(bus);
m = dbus_message_new_method_call(
"org.freedesktop.login1",
"/org/freedesktop/login1",
"org.freedesktop.login1.Manager",
"ListInhibitors");
if (!m)
return -ENOMEM;
reply = dbus_connection_send_with_reply_and_block(bus, m, -1, error);
if (!reply) {
r = -EIO;
goto finish;
}
if (!dbus_message_iter_init(reply, &iter)) {
r = -ENOMEM;
goto finish;
}
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
r = -EIO;
goto finish;
}
dbus_message_iter_recurse(&iter, &sub);
printf("%-21s %-20s %-20s %-5s %6s %6s\n",
"WHAT",
"WHO",
"WHY",
"MODE",
"UID",
"PID");
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
const char *what, *who, *why, *mode;
char *ewho, *ewhy;
dbus_uint32_t uid, pid;
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
r = -EIO;
goto finish;
}
dbus_message_iter_recurse(&sub, &sub2);
if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &what, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &who, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &why, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &mode, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, false) < 0) {
r = -EIO;
goto finish;
}
ewho = ellipsize(who, 20, 66);
ewhy = ellipsize(why, 20, 66);
printf("%-21s %-20s %-20s %-5s %6lu %6lu\n",
what, ewho ? ewho : who, ewhy ? ewhy : why, mode, (unsigned long) uid, (unsigned long) pid);
free(ewho);
free(ewhy);
dbus_message_iter_next(&sub);
n++;
}
printf("\n%u inhibitors listed.\n", n);
r = 0;
finish:
if (m)
dbus_message_unref(m);
if (reply)
dbus_message_unref(reply);
return r;
}
static DBusMessage *cv_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_call_volume *cv = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (cv->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(property, "SpeakerVolume") == TRUE) {
unsigned char percent;
if (cv->driver->speaker_volume == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BYTE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &percent);
if (percent > 100)
return __ofono_error_invalid_format(msg);
if (percent == cv->speaker_volume)
return dbus_message_new_method_return(msg);
cv->pending_volume = percent;
cv->pending = dbus_message_ref(msg);
cv->driver->speaker_volume(cv, percent, sv_set_callback, cv);
return NULL;
} else if (g_str_equal(property, "MicrophoneVolume") == TRUE) {
unsigned char percent;
if (cv->driver->microphone_volume == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BYTE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &percent);
if (percent > 100)
return __ofono_error_invalid_format(msg);
if (percent == cv->microphone_volume)
return dbus_message_new_method_return(msg);
cv->pending_volume = percent;
cv->pending = dbus_message_ref(msg);
cv->driver->microphone_volume(cv, percent, mv_set_callback, cv);
return NULL;
} else if (g_str_equal(property, "Muted") == TRUE) {
dbus_bool_t muted;
if (cv->driver->mute == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &muted);
if (muted == (dbus_bool_t) cv->muted)
return dbus_message_new_method_return(msg);
cv->muted_pending = muted;
cv->pending = dbus_message_ref(msg);
cv->driver->mute(cv, muted, muted_set_callback, cv);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *modem_set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_modem *modem = data;
DBusMessageIter iter, var;
const char *name;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
if (powering_down == TRUE)
return __ofono_error_failed(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(name, "Online"))
return set_property_online(modem, msg, &var);
if (g_str_equal(name, "Powered") == TRUE) {
ofono_bool_t powered;
int err;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &powered);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
if (modem->powered == powered)
return dbus_message_new_method_return(msg);
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
if (modem->lockdown)
return __ofono_error_access_denied(msg);
err = set_powered(modem, powered);
if (err < 0) {
if (err != -EINPROGRESS)
return __ofono_error_failed(msg);
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
if (powered) {
modem_change_state(modem, MODEM_STATE_PRE_SIM);
/* Force SIM Ready for devies with no sim atom */
if (modem_has_sim(modem) == FALSE)
sim_state_watch(OFONO_SIM_STATE_READY, modem);
} else {
set_online(modem, FALSE);
modem_change_state(modem, MODEM_STATE_POWER_OFF);
}
return NULL;
}
if (g_str_equal(name, "Lockdown"))
return set_property_lockdown(modem, msg, &var);
return __ofono_error_invalid_args(msg);
}
char* get_entry_group_path()
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
char *entry_group_path;
// initialiset the errors
printf("Calling remote method: %s\n", "org.freedesktop.Avahi");
// connect to the system bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call
"/", // object to call on
"org.freedesktop.Avahi.Server", // interface to call on
"EntryGroupNew"); // method nameResolveHostName
if (NULL == msg)
{
fprintf(stderr, "Message Null\n");
exit(1);
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
}
dbus_connection_flush(conn);
printf("Request Sent\n");
// free message
dbus_message_unref(msg);
// block until we recieve a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_ERROR) {
fprintf("message returned error: %s", dbus_message_get_error_name(msg));
}
// free the pending message handle
dbus_pending_call_unref(pending);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_OBJECT_PATH != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not DBUS_TYPE_OBJECT_PATH!\n");
else
dbus_message_iter_get_basic(&args, &entry_group_path);
printf("Got Reply: %s\n", entry_group_path);
dbus_message_unref(msg);
return entry_group_path;
}
void method_GetState(char *path){
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
// connect to the system bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
//char *path = malloc(sizeof(char) * strlen(mpath));
//strcpy(path, mpath);
//printf("*0mpath: %s / %s\n", path, mpath);
msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call
path, // object to call on
"org.freedesktop.Avahi.EntryGroup", // interface to call on
"GetState"); // method nameResolveHostName
//printf("*1mpath: %s / %s\n", path, mpath);
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
//printf("*2mpath: %s / %s\n", path, mpath);
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
}
dbus_connection_flush(conn);
printf("Request Sent\n");
// free message
dbus_message_unref(msg);
// block until we recieve a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
dbus_uint32_t m_state;
if (!dbus_message_iter_init(msg, &args)){
g_message("dbus_message_iter_init fail\n");
}
if(dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_ERROR){
char *result;
g_message("arg type: %d", dbus_message_iter_get_arg_type(&args));
dbus_message_iter_get_basic(&args, &result);
g_message("error: %s", result);
}else{
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not DBUS_TYPE_INT32!\n");
else{
dbus_message_iter_get_basic(&args, &m_state);
printf("m_state : %d\n", m_state);
}
}
dbus_message_unref(msg);
}
void signal_ServiceBrowser_item(char *path){
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
gchar* filter_itemnew = g_new(gchar, strlen("type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemNew', path=''") + strlen(path) + 2);
sprintf(filter_itemnew, "type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemNew', path='%s'", path);
gchar* filter_itemremove = g_new(gchar, strlen("type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemRemove', path=''") + strlen(path) + 2);
sprintf(filter_itemremove, "type='signal',interface='org.freedesktop.Avahi.ServiceBrowser',member='ItemRemove', path='%s'", path);
//printf("signal_filter:%s", signal_filter);
// add a rule for which messages we want to see
dbus_bus_add_match(conn, filter_itemnew, &err);
dbus_bus_add_match(conn, filter_itemremove, &err);
dbus_connection_flush(conn);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Match Error (%s)\n", err.message);
exit(1);
}
printf("Match rule sent\n");
int interface;
int protocol;
char *name;
char *stype;
char *domain;
unsigned int flags;
//int cnt = 0;
// loop listening for signals being emmitted
while (true) {
// non blocking read of the next available message
dbus_connection_read_write(conn, 0);
msg = dbus_connection_pop_message(conn);
// loop again if we haven't read a message
if (NULL == msg) {
//g_message("cnt: %d", cnt++);
sleep(1);
continue;
}
// check if the message is a signal from the correct interface and with the correct name
if (dbus_message_is_signal(msg, "org.freedesktop.Avahi.ServiceBrowser", "ItemNew")) {
// read the parameters
//g_message("is the message we need.%d", cnt++);
//g_message("Message Has No Parameters\n");
if (!dbus_message_iter_init(msg, &args))
g_message("dbus_message_iter_init fail\n");
else
{
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message( "Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &interface);
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &protocol);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &name);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &stype);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &domain);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &flags);
printf("\n");
printf("discovered:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, stype, domain, flags);
resolve_service(interface, protocol, name, stype, domain);
//printf("Got Signal with value %s\n", sigvalue);
}
}else if(dbus_message_is_signal(msg, "org.freedesktop.Avahi.ServiceBrowser", "ItemRemove")){
if (!dbus_message_iter_init(msg, &args))
g_message("dbus_message_iter_init fail\n");
else
{
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message( "Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &interface);
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &protocol);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &name);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &stype);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &domain);
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &flags);
printf("\n");
printf("removed:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, stype, domain, flags);
//resolve_service(interface, protocol, name, stype, domain);
//printf("Got Signal with value %s\n", sigvalue);
}
}
// free the message
dbus_message_unref(msg);
}
}
char* resolve_service(int interface, int protocol, char *name, char *type, char *domain)
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
//dbus_int32_t interface = 2;
//dbus_int32_t protocol = 1;
//char *name = "TestService";
//char *type = "_http._tcp";
//char *domain = "local";
dbus_int32_t aprotocol = -1;
dbus_uint32_t flags = 0;
printf ("parameter for ResolvesService:%d, %d, %s, %s, %s, %d, %d.\n", interface, protocol, name, type, domain, aprotocol, flags);
// initialiset the errors
printf("Calling remote method: %s\n", "org.freedesktop.Avahi");
// connect to the system bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call
"/", // object to call on
"org.freedesktop.Avahi.Server", // interface to call on
"ResolveService"); // method nameResolveHostName
if (NULL == msg)
{
fprintf(stderr, "Message Null\n");
exit(1);
}
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &interface))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &protocol))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &name))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &type))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &domain))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &aprotocol))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &flags))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
}
dbus_connection_flush(conn);
printf("Request Sent\n");
// free message
dbus_message_unref(msg);
// block until we recieve a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
char *address;
char *host;
dbus_uint16_t port;//gint16
GPtrArray *byte_arraies;
dbus_uint32_t m_flags;
if (!dbus_message_iter_init(msg, &args))
g_message("dbus_message_iter_init fail\n");
else
{
//g_message("signature of container args: %s", dbus_message_iter_get_signature(&args));
//g_message("first type: %d", dbus_message_iter_get_arg_type(&args));
//g_message("DBUS_TYPE_INT32: %d", DBUS_TYPE_INT32);
//g_message("DBUS_TYPE_STRING: %d", DBUS_TYPE_STRING);
//char *value;
//dbus_message_iter_get_basic(&args, &value);
//g_message("DBUS_TYPE_STRING: %s", value);
if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message( "Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &interface);
printf("interface : %d\n", interface);
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &protocol);
printf("protocol : %d\n", protocol);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &name);
printf("name : %s\n", name);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &type);
printf("type : %s\n", type);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &domain);
printf("domain : %s\n", domain);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &host);
printf("host : %s\n", host);
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_INT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &aprotocol);
printf("aprotocol : %d\n", aprotocol);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &address);
printf("address : %s\n", address);
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_UINT16 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &port);
printf("port : %d\n", port);
}
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (strcmp("aay", dbus_message_iter_get_signature(&args)))
g_message("Argument is not error!\n");
else{
DBusMessageIter container_ay, container_y;
unsigned char *values;int size;
//dbus_message_iter_get_basic(&args, &flags);
//dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY, "ay", &container_ay);
//dbus_message_iter_open_container(&container_ay, DBUS_TYPE_BYTE, "y", &container_y);
dbus_message_iter_recurse(&args, &container_ay);
dbus_message_iter_recurse(&container_ay, &container_y);
dbus_message_iter_get_fixed_array(&container_y, &values, &size);
g_message("size: %d, %s", size, values);
/*
g_message("container args: %s", dbus_message_iter_get_signature(&args));
g_message("container_ay: %s", dbus_message_iter_get_signature(&container_ay));
g_message("container_y: %s", dbus_message_iter_get_signature(&container_y));
g_message("type of container_y: %d", dbus_message_iter_get_arg_type(&container_y));
g_message("value of DBUS_TYPE_BYTE: %d", DBUS_TYPE_BYTE);
*/
// && strcmp("ay", dbus_message_iter_get_signature(&container_ay))
while(dbus_message_iter_next(&container_ay)){
dbus_message_iter_recurse(&container_ay, &container_y);
dbus_message_iter_get_fixed_array(&container_y, &values, &size);
g_message("size: %d, %s", size, values);
}
}
if (!dbus_message_iter_next(&args))
g_message( "Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else{
dbus_message_iter_get_basic(&args, &m_flags);
printf("m_flags : %d\n", m_flags);
}
/*
dbus_message_iter_next(&args);
g_message("g_message_iter_get_signature: %s", dbus_message_iter_get_signature(&args));
*/
/*
if (!dbus_message_iter_next(&args))
g_message("Message has too few arguments!\n");
else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args))
g_message("Argument is not error!\n");
else
dbus_message_iter_get_basic(&args, &flags);
*/
// printf("discovered:%d, %d, %s, %s, %s, %d.\n", interface, protocol, name, type, domain, flags);
}
dbus_message_unref(msg);
}
char* get_service_browser_path()
{
DBusMessage* msg;
DBusMessageIter args;
DBusConnection* conn;
DBusError err;
dbus_error_init(&err);
DBusPendingCall* pending;
dbus_int32_t interface = -1;
dbus_int32_t protocol = -1;
char *type = "_http._tcp";
char *domain = "local";
dbus_uint32_t flags = 0;
char *service_browser_path;
// initialiset the errors
printf("Calling remote method: %s\n", "org.freedesktop.Avahi");
// connect to the system bus and check for errors
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error (%s)\n", err.message);
dbus_error_free(&err);
}
if (NULL == conn) {
exit(1);
}
msg = dbus_message_new_method_call("org.freedesktop.Avahi",// target for the method call
"/", // object to call on
"org.freedesktop.Avahi.Server", // interface to call on
"ServiceBrowserNew"); // method nameResolveHostName
if (NULL == msg)
{
fprintf(stderr, "Message Null\n");
exit(1);
}
// append arguments
dbus_message_iter_init_append(msg, &args);
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &interface))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &protocol))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &type))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &domain))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &flags))
{
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
// send message and get a handle for a reply
if (!dbus_connection_send_with_reply (conn, msg, &pending, -1)) { // -1 is default timeout
fprintf(stderr, "Out Of Memory!\n");
exit(1);
}
if (NULL == pending) {
fprintf(stderr, "Pending Call Null\n");
exit(1);
}
dbus_connection_flush(conn);
printf("Request Sent\n");
// free message
dbus_message_unref(msg);
// block until we recieve a reply
dbus_pending_call_block(pending);
// get the reply message
msg = dbus_pending_call_steal_reply(pending);
if (NULL == msg) {
fprintf(stderr, "Reply Null\n");
exit(1);
}
// free the pending message handle
dbus_pending_call_unref(pending);
// read the parameters
if (!dbus_message_iter_init(msg, &args))
fprintf(stderr, "Message has no arguments!\n");
else if (DBUS_TYPE_OBJECT_PATH != dbus_message_iter_get_arg_type(&args))
fprintf(stderr, "Argument is not boolean!\n");
else
dbus_message_iter_get_basic(&args, &service_browser_path);
printf("Got Reply: %s\n", service_browser_path);
dbus_message_unref(msg);
return service_browser_path;
}
static void
print_iter (DBusMessageIter *iter, dbus_bool_t literal, int depth)
{
do
{
int type = dbus_message_iter_get_arg_type (iter);
const char *str;
dbus_uint32_t uint32;
dbus_int32_t int32;
double d;
unsigned char byte;
dbus_bool_t boolean;
if (type == DBUS_TYPE_INVALID)
break;
while (depth-- > 0)
putc (' ', stdout);
switch (type)
{
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic (iter, &str);
if (!literal)
printf ("string \"");
printf ("%s", str);
if (!literal)
printf ("\"\n");
break;
case DBUS_TYPE_INT32:
dbus_message_iter_get_basic (iter, &int32);
printf ("int32 %d\n", int32);
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic (iter, &uint32);
printf ("uint32 %u\n", uint32);
break;
case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_basic (iter, &d);
printf ("double %g\n", d);
break;
case DBUS_TYPE_BYTE:
dbus_message_iter_get_basic (iter, &byte);
printf ("byte %d\n", byte);
break;
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic (iter, &boolean);
printf ("boolean %s\n", boolean ? "true" : "false");
break;
case DBUS_TYPE_VARIANT:
{
DBusMessageIter subiter;
dbus_message_iter_recurse (iter, &subiter);
printf ("variant:");
print_iter (&subiter, literal, depth);
break;
}
case DBUS_TYPE_ARRAY:
{
int current_type;
DBusMessageIter subiter;
dbus_message_iter_recurse (iter, &subiter);
printf("[");
while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID)
{
print_iter (&subiter, literal, depth);
dbus_message_iter_next (&subiter);
if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID)
printf (",");
}
printf("]");
break;
}
case DBUS_TYPE_DICT_ENTRY:
{
DBusMessageIter subiter;
dbus_message_iter_recurse (iter, &subiter);
printf("{");
print_iter (&subiter, literal, depth);
dbus_message_iter_next (&subiter);
print_iter (&subiter, literal, depth);
printf("}");
break;
}
default:
printf (" (dbus-monitor too dumb to decipher arg type '%c')\n", type);
break;
}
} while (dbus_message_iter_next (iter));
}
static DBusMessage *set_property_lockdown(struct ofono_modem *modem,
DBusMessage *msg,
DBusMessageIter *var)
{
DBusConnection *conn = ofono_dbus_get_connection();
ofono_bool_t lockdown;
dbus_bool_t powered;
const char *caller;
int err;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(var, &lockdown);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
caller = dbus_message_get_sender(msg);
if (modem->lockdown && g_strcmp0(caller, modem->lock_owner))
return __ofono_error_access_denied(msg);
if (modem->lockdown == lockdown)
return dbus_message_new_method_return(msg);
if (lockdown == FALSE) {
lockdown_remove(modem);
goto done;
}
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
modem->lock_owner = g_strdup(caller);
modem->lock_watch = g_dbus_add_disconnect_watch(conn,
modem->lock_owner, lockdown_disconnect,
modem, NULL);
if (modem->lock_watch == 0) {
g_free(modem->lock_owner);
modem->lock_owner = NULL;
return __ofono_error_failed(msg);
}
modem->lockdown = lockdown;
if (modem->powered == FALSE)
goto done;
err = set_powered(modem, FALSE);
if (err < 0) {
if (err != -EINPROGRESS) {
lockdown_remove(modem);
return __ofono_error_failed(msg);
}
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
set_online(modem, FALSE);
powered = FALSE;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
done:
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Lockdown", DBUS_TYPE_BOOLEAN,
&lockdown);
return NULL;
}
static void dbus_read_servers(DBusMessage *message)
{
DBusMessageIter iter;
union mysockaddr addr, source_addr;
char *domain;
dbus_message_iter_init(message, &iter);
mark_servers(SERV_FROM_DBUS);
while (1)
{
int skip = 0;
if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_UINT32)
{
u32 a;
dbus_message_iter_get_basic(&iter, &a);
dbus_message_iter_next (&iter);
#ifdef HAVE_SOCKADDR_SA_LEN
source_addr.in.sin_len = addr.in.sin_len = sizeof(struct sockaddr_in);
#endif
addr.in.sin_addr.s_addr = ntohl(a);
source_addr.in.sin_family = addr.in.sin_family = AF_INET;
addr.in.sin_port = htons(NAMESERVER_PORT);
source_addr.in.sin_addr.s_addr = INADDR_ANY;
source_addr.in.sin_port = htons(daemon->query_port);
}
else if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_BYTE)
{
unsigned char p[sizeof(struct in6_addr)];
unsigned int i;
skip = 1;
for(i = 0; i < sizeof(struct in6_addr); i++)
{
dbus_message_iter_get_basic(&iter, &p[i]);
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
{
i++;
break;
}
}
#ifndef HAVE_IPV6
my_syslog(LOG_WARNING, _("attempt to set an IPv6 server address via DBus - no IPv6 support"));
#else
if (i == sizeof(struct in6_addr))
{
memcpy(&addr.in6.sin6_addr, p, sizeof(struct in6_addr));
#ifdef HAVE_SOCKADDR_SA_LEN
source_addr.in6.sin6_len = addr.in6.sin6_len = sizeof(struct sockaddr_in6);
#endif
source_addr.in6.sin6_family = addr.in6.sin6_family = AF_INET6;
addr.in6.sin6_port = htons(NAMESERVER_PORT);
source_addr.in6.sin6_flowinfo = addr.in6.sin6_flowinfo = 0;
source_addr.in6.sin6_scope_id = addr.in6.sin6_scope_id = 0;
source_addr.in6.sin6_addr = in6addr_any;
source_addr.in6.sin6_port = htons(daemon->query_port);
skip = 0;
}
#endif
}
else
/* At the end */
break;
/* process each domain */
do {
if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
{
dbus_message_iter_get_basic(&iter, &domain);
dbus_message_iter_next (&iter);
}
else
domain = NULL;
if (!skip)
add_update_server(SERV_FROM_DBUS, &addr, &source_addr, NULL, domain);
} while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING);
}
/* unlink and free anything still marked. */
cleanup_servers();
}
void *
unmarshal_device_get_all_properties(DBusMessage *msg, DBusError *err)
{
E_Ukit_Get_All_Properties_Return *ret = NULL;
DBusMessageIter iter, a_iter, s_iter, v_iter;
int type;
char *tmp;
/* a{sv} = array of string+variants */
if (!dbus_message_has_signature(msg, "a{sv}"))
{
dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
return NULL;
}
ret = calloc(1, sizeof(E_Ukit_Get_All_Properties_Return));
if (!ret)
{
dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
return NULL;
}
ret->properties = eina_hash_string_small_new(EINA_FREE_CB(e_ukit_property_free));
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &a_iter);
while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
{
const char *name;
E_Ukit_Property *prop = calloc(1, sizeof(E_Ukit_Property));
dbus_message_iter_recurse(&a_iter, &s_iter);
dbus_message_iter_get_basic(&s_iter, &name);
dbus_message_iter_next(&s_iter);
dbus_message_iter_recurse(&s_iter, &v_iter);
type = dbus_message_iter_get_arg_type(&v_iter);
switch(type)
{
case DBUS_TYPE_STRING:
prop->type = E_UKIT_PROPERTY_TYPE_STRING;
dbus_message_iter_get_basic(&v_iter, &tmp);
prop->val.s = eina_stringshare_add(tmp);
break;
case DBUS_TYPE_INT32:
prop->type = E_UKIT_PROPERTY_TYPE_INT;
dbus_message_iter_get_basic(&v_iter, &(prop->val.i));
break;
case DBUS_TYPE_UINT32:
prop->type = E_UKIT_PROPERTY_TYPE_UINT32;
dbus_message_iter_get_basic(&v_iter, &(prop->val.u));
break;
case DBUS_TYPE_UINT64:
prop->type = E_UKIT_PROPERTY_TYPE_UINT64;
dbus_message_iter_get_basic(&v_iter, &(prop->val.t));
break;
case DBUS_TYPE_INT64:
prop->type = E_UKIT_PROPERTY_TYPE_INT64;
dbus_message_iter_get_basic(&v_iter, &(prop->val.x));
break;
case DBUS_TYPE_BOOLEAN:
prop->type = E_UKIT_PROPERTY_TYPE_BOOL;
dbus_message_iter_get_basic(&v_iter, &(prop->val.b));
break;
case DBUS_TYPE_DOUBLE:
prop->type = E_UKIT_PROPERTY_TYPE_DOUBLE;
dbus_message_iter_get_basic(&v_iter, &(prop->val.d));
break;
case DBUS_TYPE_ARRAY:
prop->type = E_UKIT_PROPERTY_TYPE_STRLIST;
{
DBusMessageIter list_iter;
prop->val.strlist = NULL;
dbus_message_iter_recurse(&v_iter, &list_iter);
while (dbus_message_iter_get_arg_type(&list_iter) != DBUS_TYPE_INVALID)
{
char *str;
dbus_message_iter_get_basic(&list_iter, &str);
tmp = (char*)eina_stringshare_add(str);
prop->val.strlist = eina_list_append(prop->val.strlist, tmp);
dbus_message_iter_next(&list_iter);
}
}
break;
default:
WARN("EUkit Error: unexpected property type (%s): %c", name, dbus_message_iter_get_arg_type(&v_iter));
break;
}
eina_hash_add(ret->properties, name, prop);
dbus_message_iter_next(&a_iter);
}
return ret;
}
static void
_dbus_cb_tracklist_metadata(void *data, DBusMessage *reply, DBusError *error)
{
DBusMessageIter array, item, iter, iter_val;
Instance *inst = data;
int type, cnt = 0;
char *key, *tmp, *location = NULL;
int title = 0;
Evas_Object *empris = inst->empris;
Evas_Object *o_popup = inst->o_popup;
if (error)
{
if (!_dbus_check_msg(reply, error))
{
printf("dbus garbage!\n");
goto error;
}
}
edje_object_part_text_set (empris, "empris.artist", "");
edje_object_part_text_set (o_popup, "empris.artist", "");
edje_object_part_text_set (empris, "empris.title", "");
edje_object_part_text_set (o_popup, "empris.title", "");
edje_object_part_text_set (empris, "empris.album", "");
edje_object_part_text_set (o_popup, "empris.album", "");
dbus_message_iter_init(reply, &array);
if(dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_ARRAY)
{
dbus_message_iter_recurse(&array, &item);
while(dbus_message_iter_get_arg_type(&item) == DBUS_TYPE_DICT_ENTRY)
{
dbus_message_iter_recurse(&item, &iter);
if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
{
dbus_message_iter_get_basic(&iter, &key);
}
else
{
printf("not string{n");
goto error;
}
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
{
printf("not variant\n");
goto error;
}
if (!strcmp(key, "artist"))
{
dbus_message_iter_recurse (&iter, &iter_val);
dbus_message_iter_get_basic (&iter_val, &tmp);
if (tmp && tmp[0])
{
edje_object_part_text_set (empris, "empris.artist", tmp);
edje_object_part_text_set (o_popup, "empris.artist", tmp);
}
}
else if (!strcmp(key, "title"))
{
dbus_message_iter_recurse (&iter, &iter_val);
dbus_message_iter_get_basic (&iter_val, &tmp);
if (tmp && tmp[0])
{
edje_object_part_text_set (empris, "empris.title", tmp);
edje_object_part_text_set (o_popup, "empris.title", tmp);
title = 1;
}
}
else if (!strcmp(key, "location"))
{
dbus_message_iter_recurse (&iter, &iter_val);
dbus_message_iter_get_basic (&iter_val, &tmp);
if (tmp && tmp[0])
{
location = strdup(tmp);
}
}
else if (!strcmp(key, "album"))
{
dbus_message_iter_recurse (&iter, &iter_val);
dbus_message_iter_get_basic (&iter_val, &tmp);
if (tmp && tmp[0])
{
edje_object_part_text_set (empris, "empris.album", tmp);
edje_object_part_text_set (o_popup, "empris.album", tmp);
}
}
/* else if (!strcmp(key, "mtime"))
* {
* dbus_message_iter_recurse (&iter, &iter_val);
* dbus_message_iter_get_basic (&iter_val, &(t->length));
* } */
dbus_message_iter_next(&item);
}
}
if (!title && location)
{
char *tmp = _util_unescape(ecore_file_file_get(location), 0);
if (tmp)
{
edje_object_part_text_set (empris, "empris.title", tmp);
edje_object_part_text_set (o_popup, "empris.title", tmp);
free(tmp);
}
free(location);
}
error:
return;
}
void *
unmarshal_property(DBusMessage *msg, DBusError *err)
{
E_Ukit_Get_Property_Return *ret = NULL;
DBusMessageIter iter, a_iter;
int type;
char *tmp;
if (!dbus_message_iter_init(msg, &iter)) return NULL; /* no params in message */
ret = calloc(1, sizeof(E_Ukit_Get_Property_Return));
if (!ret)
{
dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
return NULL;
}
dbus_message_iter_recurse(&iter, &a_iter);
if (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
{
type = dbus_message_iter_get_arg_type(&a_iter);
switch(type)
{
case DBUS_TYPE_STRING:
ret->type = E_UKIT_PROPERTY_TYPE_STRING;
dbus_message_iter_get_basic(&a_iter, &tmp);
ret->val.s = eina_stringshare_add(tmp);
break;
case DBUS_TYPE_INT32:
ret->type = E_UKIT_PROPERTY_TYPE_INT;
dbus_message_iter_get_basic(&a_iter, &(ret->val.i));
break;
case DBUS_TYPE_UINT32:
ret->type = E_UKIT_PROPERTY_TYPE_UINT32;
dbus_message_iter_get_basic(&a_iter, &(ret->val.u));
break;
case DBUS_TYPE_UINT64:
ret->type = E_UKIT_PROPERTY_TYPE_UINT64;
dbus_message_iter_get_basic(&a_iter, &(ret->val.t));
break;
case DBUS_TYPE_INT64:
ret->type = E_UKIT_PROPERTY_TYPE_INT64;
dbus_message_iter_get_basic(&a_iter, &(ret->val.x));
break;
case DBUS_TYPE_BOOLEAN:
ret->type = E_UKIT_PROPERTY_TYPE_BOOL;
dbus_message_iter_get_basic(&a_iter, &(ret->val.b));
break;
case DBUS_TYPE_DOUBLE:
ret->type = E_UKIT_PROPERTY_TYPE_DOUBLE;
dbus_message_iter_get_basic(&a_iter, &(ret->val.d));
break;
case DBUS_TYPE_ARRAY:
ret->type = E_UKIT_PROPERTY_TYPE_STRLIST;
{
DBusMessageIter list_iter;
ret->val.strlist = NULL;
dbus_message_iter_recurse(&a_iter, &list_iter);
while (dbus_message_iter_get_arg_type(&list_iter) != DBUS_TYPE_INVALID)
{
char *str;
dbus_message_iter_get_basic(&list_iter, &str);
tmp = (char*)eina_stringshare_add(str);
ret->val.strlist = eina_list_append(ret->val.strlist, tmp);
dbus_message_iter_next(&list_iter);
}
}
break;
default:
break;
}
}
return ret;
}
/**
* @brief Callback qmi device open modem
*/
static void
open_modem_callback(DBusMessage *message, void *user_data) {
DBusMessageIter iter;
struct qmi_data *qmi = (struct qmi_data *)user_data;
gchar *help;
DBG("qmi data %p DBusmessage %p", qmi, message);
if(qmi == NULL) {
connman_error("No QMI device");
qmi->modem_opening = FALSE;
return;
}
if(dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
const char *dbus_error = dbus_message_get_error_name(message);
connman_error("%s", dbus_error);
qmi->modem_opening = FALSE;
return;
}
if((dbus_message_iter_init(message, &iter) == TRUE) &&
(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_OBJECT_PATH)) {
dbus_message_iter_get_basic(&iter, &help);
qmi->object_path = g_strdup(help);
}
else {
connman_error("Return type invalid");
qmi->modem_opening = FALSE;
return;
}
DBG("Modem opened object path %s", qmi->object_path);
if(!qmi->qmi_proxy_device) {
qmi->qmi_proxy_device = g_dbus_proxy_new( qmi_client,
qmi->object_path,
QMI_DEVICE_INTERFACE);
}
if(qmi->qmi_proxy_device == NULL) {
connman_error("QMI proxy device not created");
/* Just return, if failure we have a memory issue, then. */
return;
}
g_dbus_proxy_method_call( qmi->qmi_proxy_device,
GET_PROPERTIES,
NULL,
open_modem_get_properties_callback,
qmi,
NULL);
}
static DBusMessage *set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct connman_technology *technology = data;
DBusMessageIter iter, value;
const char *name;
int type;
DBG("conn %p", conn);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __connman_error_invalid_arguments(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_recurse(&iter, &value);
type = dbus_message_iter_get_arg_type(&value);
DBG("property %s", name);
if (g_str_equal(name, "Tethering") == TRUE) {
int err;
connman_bool_t tethering;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
if (connman_technology_is_tethering_allowed(technology->type)
== FALSE) {
DBG("%s tethering not allowed by config file",
__connman_service_type2string(technology->type));
return __connman_error_not_supported(msg);
}
dbus_message_iter_get_basic(&value, &tethering);
if (technology->tethering == tethering) {
if (tethering == FALSE)
return __connman_error_already_disabled(msg);
else
return __connman_error_already_enabled(msg);
}
err = set_tethering(technology, tethering);
if (err < 0)
return __connman_error_failed(msg, -err);
technology->tethering_persistent = tethering;
technology_save(technology);
} else if (g_str_equal(name, "TetheringIdentifier") == TRUE) {
const char *str;
dbus_message_iter_get_basic(&value, &str);
if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
return __connman_error_not_supported(msg);
if (strlen(str) < 1 || strlen(str) > 32)
return __connman_error_invalid_arguments(msg);
if (g_strcmp0(technology->tethering_ident, str) != 0) {
g_free(technology->tethering_ident);
technology->tethering_ident = g_strdup(str);
technology_save(technology);
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE,
"TetheringIdentifier",
DBUS_TYPE_STRING,
&technology->tethering_ident);
}
} else if (g_str_equal(name, "TetheringPassphrase") == TRUE) {
const char *str;
dbus_message_iter_get_basic(&value, &str);
if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
return __connman_error_not_supported(msg);
if (strlen(str) < 8 || strlen(str) > 63)
return __connman_error_passphrase_required(msg);
if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
g_free(technology->tethering_passphrase);
technology->tethering_passphrase = g_strdup(str);
technology_save(technology);
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE,
"TetheringPassphrase",
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
}
} else if (g_str_equal(name, "Powered") == TRUE) {
connman_bool_t enable;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &enable);
return set_powered(technology, msg, enable);
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
/**
* @brief Set the newly replied key/ value properties
*/
static gboolean
update_network(struct qmi_data *qmi, DBusMessageIter *entry_iter) {
DBusMessageIter variant_iter;
gboolean updating_strength = FALSE;
gboolean updating_others = FALSE;
gchar *key;
gchar *help;
if(dbus_message_iter_get_arg_type(entry_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(entry_iter, &key);
DBG("Property %s", key);
if(key != NULL) {
dbus_message_iter_next(entry_iter);
if(dbus_message_iter_get_arg_type(entry_iter) != DBUS_TYPE_VARIANT)
return FALSE;
dbus_message_iter_recurse(entry_iter, &variant_iter);
if(g_strcmp0(key, "IMSI") == 0) {
/* Set new IMSI */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(qmi->imsi)
g_free(qmi->imsi);
qmi->imsi = g_strdup(help);
}
else if(g_strcmp0(key, "RSRQ") == 0) {
/* Set new RSRQ */
guint8 help = 0;
if(qmi->network == NULL)
return FALSE;
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_INT32)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &qmi->rsrq);
help = calculate_signal_strength(qmi->rsrq);
if(help != qmi->strength) {
qmi->strength = help;
/* Set new calculated strength */
connman_network_set_strength(qmi->network, qmi->strength);
updating_strength = TRUE;
}
}
else if(g_strcmp0(key, "PacketStatus") == 0) {
/* Set new packet status */
if(qmi->network == NULL)
return FALSE;
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->packet_status, help) != 0) {
if(qmi->packet_status)
g_free(qmi->packet_status);
qmi->packet_status = g_strdup(help);
/* Check new packet status and change network status if required */
if(g_strcmp0(qmi->packet_status, "connected") == 0) {
connman_network_set_connected(qmi->network, TRUE);
}
else {
connman_network_set_connected(qmi->network, FALSE);
}
}
}
else if(g_strcmp0(key, "NetworkType") == 0) {
/* Set new network type */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->network_type, help) != 0) {
if(qmi->network_type)
g_free(qmi->network_type);
qmi->network_type = g_strdup(help);
updating_others = TRUE;
}
}
else if(g_strcmp0(key, "MCC") == 0) {
/* Set new MCC */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->mcc, help) != 0) {
if(qmi->mcc)
g_free(qmi->mcc);
qmi->mcc = g_strdup(help);
updating_others = TRUE;
}
}
else if(g_strcmp0(key, "MNC") == 0) {
/* Set new MNC */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->mnc, help) != 0) {
if(qmi->mnc)
g_free(qmi->mnc);
qmi->mnc = g_strdup(help);
updating_others = TRUE;
}
}
else if(g_strcmp0(key, "RAT") == 0) {
/*Set new RAT */
if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING)
return FALSE;
dbus_message_iter_get_basic(&variant_iter, &help);
if(g_strcmp0(qmi->rat, help) != 0) {
if(qmi->rat)
g_free(qmi->rat);
qmi->rat = g_strdup(help);
updating_others = TRUE;
}
}
/* Check whether network already exists, because some properties as IMSI or IMEI are set before network is added */
if(qmi->network) {
if(updating_strength == TRUE) {
/* Just update new strength property */
connman_network_update(qmi->network);
}
else if(updating_others == TRUE) {
/* Build a new network name and update it */
if(qmi->provider)
g_free(qmi->provider);
qmi->provider = g_strdup_printf("%s-%s-%s", qmi->mnc, qmi->mcc, qmi->rat);
connman_network_set_name(qmi->network, qmi->provider);
connman_network_update(qmi->network);
}
}
}
return TRUE;
}
GList *
systemd_unit_listall(void)
{
int lpc = 0;
GList *units = NULL;
DBusMessageIter args;
DBusMessageIter unit;
DBusMessageIter elem;
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
const char *method = "ListUnits";
DBusError error;
if (systemd_init() == FALSE) {
return NULL;
}
/*
" <method name=\"ListUnits\">\n" \
" <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \
" </method>\n" \
*/
dbus_error_init(&error);
msg = systemd_new_method(BUS_NAME".Manager", method);
CRM_ASSERT(msg != NULL);
reply = pcmk_dbus_send_recv(msg, systemd_proxy, &error);
dbus_message_unref(msg);
if(error.name) {
crm_err("Call to %s failed: %s", method, error.name);
return NULL;
} else if (reply == NULL) {
crm_err("Call to %s failed: Message has no reply", method);
return NULL;
} else if (!dbus_message_iter_init(reply, &args)) {
crm_err("Call to %s failed: Message has no arguments", method);
dbus_message_unref(reply);
return NULL;
}
if(!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __FUNCTION__, __LINE__)) {
crm_err("Call to %s failed: Message has invalid arguments", method);
dbus_message_unref(reply);
return NULL;
}
dbus_message_iter_recurse(&args, &unit);
while (dbus_message_iter_get_arg_type (&unit) != DBUS_TYPE_INVALID) {
DBusBasicValue value;
if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_STRUCT, __FUNCTION__, __LINE__)) {
continue;
}
dbus_message_iter_recurse(&unit, &elem);
if(!pcmk_dbus_type_check(reply, &elem, DBUS_TYPE_STRING, __FUNCTION__, __LINE__)) {
continue;
}
dbus_message_iter_get_basic(&elem, &value);
crm_trace("Got: %s", value.str);
if(value.str) {
char *match = strstr(value.str, ".service");
if (match) {
lpc++;
match[0] = 0;
units = g_list_append(units, strdup(value.str));
}
}
dbus_message_iter_next (&unit);
}
dbus_message_unref(reply);
crm_trace("Found %d systemd services", lpc);
return units;
}
/**
* D-Bus callback for powerkey event triggering
*
* @param msg D-Bus message
* @return TRUE on success, FALSE on failure
*/
static gboolean trigger_powerkey_event_req_dbus_cb(DBusMessage *const msg)
{
dbus_bool_t no_reply = dbus_message_get_no_reply(msg);
DBusMessageIter iter;
dbus_uint32_t uintval;
dbus_bool_t boolval;
gint argcount = 0;
gint argtype;
gboolean status = FALSE;
DBusError error;
/* Register error channel */
dbus_error_init(&error);
mce_log(LL_DEBUG, "Received [power] button trigger request");
if (dbus_message_iter_init(msg, &iter) == FALSE) {
// XXX: should we return an error instead?
mce_log(LL_ERR,
"Failed to initialise D-Bus message iterator; "
"message has no arguments");
goto EXIT;
}
argtype = dbus_message_iter_get_arg_type(&iter);
argcount++;
switch (argtype) {
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(&iter, &boolval);
uintval = (boolval == TRUE) ? 1 : 0;
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic(&iter, &uintval);
if (uintval > 2) {
mce_log(LL_ERR,
"Incorrect powerkey event passed to %s.%s; "
"ignoring request",
MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ);
goto EXIT;
}
break;
default:
mce_log(LL_ERR,
"Argument %d passed to %s.%s has incorrect type",
argcount,
MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ);
goto EXIT;
}
while (dbus_message_iter_next(&iter) == TRUE)
argcount++;
if (argcount > 1) {
mce_log(LL_WARN,
"Too many arguments passed to %s.%s; "
"got %d, expected %d -- ignoring extra arguments",
MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ,
argcount, 1);
}
mce_log(LL_DEBUG, "[power] button event trigger value: %d", uintval);
cancel_powerkey_timeout();
cancel_doublepress_timeout();
switch (uintval) {
default:
case 0:
/* short press */
generic_powerkey_handler(shortpressaction,
shortpresssignal);
break;
case 1:
/* long press */
handle_longpress();
break;
case 2:
/* double press */
generic_powerkey_handler(doublepressaction,
doublepresssignal);
break;
}
if (no_reply == FALSE) {
DBusMessage *reply = dbus_new_method_reply(msg);
status = dbus_send_message(reply);
} else {
status = TRUE;
}
EXIT:
return status;
}
void listen_signal()
{
DBusMessage *msg;
DBusMessageIter arg;
DBusConnection *connection;
DBusError err;
int ret;
char *sigvalue;
//step 1. connect DBus
dbus_error_init(&err);
connection = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Connection Error %s\n", err.message);
dbus_error_free(&err);
}
if (connection == NULL) {
return;
}
//step 2. [OPTION] Assign a known name for connection
ret = dbus_bus_request_name(connection, "test.singal.dest", DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Name Error %s\n", err.message);
dbus_error_free(&err);
}
if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
return ;
}
//step 3. Notify DBus daemon, listen test.signal.Type signal
dbus_bus_add_match(connection, "type='signal', interface='test.signal.Type'", &err);
dbus_connection_flush(connection);
if (dbus_error_is_set(&err)) {
fprintf(stderr, "Match Error %s\n", err.message);
dbus_error_free(&err);
}
//step 4. listen in loop per 1s.
while (1) {
dbus_connection_read_write(connection, 0);
msg = dbus_connection_pop_message(connection);
if (msg == NULL) {
sleep(1);
continue;
}
if (dbus_message_is_signal(msg, "test.signal.Type", "Test")) {
if (!dbus_message_iter_init(msg, &arg)) {
fprintf(stderr, "Message Has no Param");
} else if (dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_STRING) {
g_printerr("Param is not string");
} else {
dbus_message_iter_get_basic(&arg, &sigvalue);
printf("Got singal with value: %s\n", sigvalue);
}
}
dbus_message_unref(msg);
}//End of while
}
bool
ShouldA11yBeEnabled()
{
static bool sChecked = false, sShouldEnable = false;
if (sChecked)
return sShouldEnable;
sChecked = true;
EPlatformDisabledState disabledState = PlatformDisabledState();
if (disabledState == ePlatformIsDisabled)
return sShouldEnable = false;
// check if accessibility enabled/disabled by environment variable
const char* envValue = PR_GetEnv(sAccEnv);
if (envValue)
return sShouldEnable = !!atoi(envValue);
#ifdef MOZ_ENABLE_DBUS
PreInit();
bool dbusSuccess = false;
DBusMessage *reply = nullptr;
if (!sPendingCall)
goto dbus_done;
dbus_pending_call_block(sPendingCall);
reply = dbus_pending_call_steal_reply(sPendingCall);
dbus_pending_call_unref(sPendingCall);
sPendingCall = nullptr;
if (!reply ||
dbus_message_get_type(reply) != DBUS_MESSAGE_TYPE_METHOD_RETURN ||
strcmp(dbus_message_get_signature (reply), DBUS_TYPE_VARIANT_AS_STRING))
goto dbus_done;
DBusMessageIter iter, iter_variant, iter_struct;
dbus_bool_t dResult;
dbus_message_iter_init(reply, &iter);
dbus_message_iter_recurse (&iter, &iter_variant);
switch (dbus_message_iter_get_arg_type(&iter_variant)) {
case DBUS_TYPE_STRUCT:
// at-spi2-core 2.2.0-2.2.1 had a bug where it returned a struct
dbus_message_iter_recurse(&iter_variant, &iter_struct);
if (dbus_message_iter_get_arg_type(&iter_struct) == DBUS_TYPE_BOOLEAN) {
dbus_message_iter_get_basic(&iter_struct, &dResult);
sShouldEnable = dResult;
dbusSuccess = true;
}
break;
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(&iter_variant, &dResult);
sShouldEnable = dResult;
dbusSuccess = true;
break;
default:
break;
}
dbus_done:
if (reply)
dbus_message_unref(reply);
if (dbusSuccess)
return sShouldEnable;
#endif
//check gconf-2 setting
static const char sGconfAccessibilityKey[] =
"/desktop/gnome/interface/accessibility";
nsresult rv = NS_OK;
nsCOMPtr<nsIGConfService> gconf =
do_GetService(NS_GCONFSERVICE_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv) && gconf)
gconf->GetBool(NS_LITERAL_CSTRING(sGconfAccessibilityKey), &sShouldEnable);
return sShouldEnable;
}
static DBusMessage *dbus_add_lease(DBusMessage* message)
{
struct dhcp_lease *lease;
const char *ipaddr, *hwaddr, *hostname, *tmp;
const unsigned char* clid;
int clid_len, hostname_len, hw_len, hw_type;
dbus_uint32_t expires, ia_id;
dbus_bool_t is_temporary;
struct all_addr addr;
time_t now = dnsmasq_time();
unsigned char dhcp_chaddr[DHCP_CHADDR_MAX];
DBusMessageIter iter, array_iter;
if (!dbus_message_iter_init(message, &iter))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Failed to initialize dbus message iter");
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected string as first argument");
dbus_message_iter_get_basic(&iter, &ipaddr);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected string as second argument");
dbus_message_iter_get_basic(&iter, &hwaddr);
dbus_message_iter_next(&iter);
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected byte array as third argument");
dbus_message_iter_recurse(&iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &hostname, &hostname_len);
tmp = memchr(hostname, '\0', hostname_len);
if (tmp)
{
if (tmp == &hostname[hostname_len - 1])
hostname_len--;
else
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Hostname contains an embedded NUL character");
}
dbus_message_iter_next(&iter);
if ((dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE))
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected byte array as fourth argument");
dbus_message_iter_recurse(&iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &clid, &clid_len);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected uint32 as fifth argument");
dbus_message_iter_get_basic(&iter, &expires);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected uint32 as sixth argument");
dbus_message_iter_get_basic(&iter, &ia_id);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"Expected uint32 as sixth argument");
dbus_message_iter_get_basic(&iter, &is_temporary);
if (inet_pton(AF_INET, ipaddr, &addr.addr.addr4))
{
if (ia_id != 0 || is_temporary)
return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS,
"ia_id and is_temporary must be zero for IPv4 lease");
if (!(lease = lease_find_by_addr(addr.addr.addr4)))
lease = lease4_allocate(addr.addr.addr4);
}
#ifdef HAVE_DHCP6
else if (inet_pton(AF_INET6, ipaddr, &addr.addr.addr6))
{
if (!(lease = lease6_find_by_addr(&addr.addr.addr6, 128, 0)))
lease = lease6_allocate(&addr.addr.addr6,
is_temporary ? LEASE_TA : LEASE_NA);
lease_set_iaid(lease, ia_id);
}
#endif
else
return dbus_message_new_error_printf(message, DBUS_ERROR_INVALID_ARGS,
"Invalid IP address '%s'", ipaddr);
hw_len = parse_hex((char*)hwaddr, dhcp_chaddr, DHCP_CHADDR_MAX, NULL,
&hw_type);
if (hw_type == 0 && hw_len != 0)
hw_type = ARPHRD_ETHER;
lease_set_hwaddr(lease, dhcp_chaddr, clid, hw_len, hw_type,
clid_len, now, 0);
lease_set_expires(lease, expires, now);
if (hostname_len != 0)
lease_set_hostname(lease, hostname, 0, get_domain(lease->addr), NULL);
lease_update_file(now);
lease_update_dns(0);
return NULL;
}
/**
* wpas_dbus_handler_wps_start - Start WPS configuration
* @message: Pointer to incoming dbus message
* @wpa_s: %wpa_supplicant data structure
* Returns: DBus message dictionary on success or DBus error on failure
*
* Handler for "Start" method call. DBus dictionary argument contains
* information about role (enrollee or registrar), authorization method
* (pin or push button) and optionally pin and bssid. Returned message
* has a dictionary argument which may contain newly generated pin (optional).
*/
DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
DBusMessageIter iter, dict_iter, entry_iter;
struct wps_start_params params;
char *key;
char npin[9] = { '\0' };
int ret;
os_memset(¶ms, 0, sizeof(params));
dbus_message_iter_init(message, &iter);
dbus_message_iter_recurse(&iter, &dict_iter);
while (dbus_message_iter_get_arg_type(&dict_iter) ==
DBUS_TYPE_DICT_ENTRY) {
dbus_message_iter_recurse(&dict_iter, &entry_iter);
dbus_message_iter_get_basic(&entry_iter, &key);
dbus_message_iter_next(&entry_iter);
if (wpas_dbus_handler_wps_start_entry(message, key,
&entry_iter,
¶ms, &reply))
return reply;
dbus_message_iter_next(&dict_iter);
}
#ifdef CONFIG_AP
if (wpa_s->ap_iface && params.type == 1) {
if (params.pin == NULL) {
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Pin required for registrar role");
return wpas_dbus_error_invalid_args(
message, "Pin required for registrar role.");
}
ret = wpa_supplicant_ap_wps_pin(wpa_s,
params.bssid,
params.pin,
npin, sizeof(npin), 0);
} else if (wpa_s->ap_iface) {
ret = wpa_supplicant_ap_wps_pbc(wpa_s,
params.bssid,
params.p2p_dev_addr);
} else
#endif /* CONFIG_AP */
if (params.role == 0) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Role not specified");
return wpas_dbus_error_invalid_args(message,
"Role not specified");
} else if (params.role == 2) {
if (params.pin == NULL) {
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Pin required for registrar role");
return wpas_dbus_error_invalid_args(
message, "Pin required for registrar role.");
}
ret = wpas_wps_start_reg(wpa_s, params.bssid, params.pin,
NULL);
} else if (params.type == 0) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Type not specified");
return wpas_dbus_error_invalid_args(message,
"Type not specified");
} else if (params.type == 1) {
ret = wpas_wps_start_pin(wpa_s, params.bssid,
params.pin, 0,
DEV_PW_DEFAULT);
if (ret > 0)
os_snprintf(npin, sizeof(npin), "%08d", ret);
} else {
ret = wpas_wps_start_pbc(wpa_s, params.bssid, 0);
}
if (ret < 0) {
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start wpas_wps_failed in role %s and key %s",
(params.role == 1 ? "enrollee" : "registrar"),
(params.type == 0 ? "" :
(params.type == 1 ? "pin" : "pbc")));
return wpas_dbus_error_unknown_error(message,
"WPS start failed");
}
reply = dbus_message_new_method_return(message);
if (!reply)
return wpas_dbus_error_no_memory(message);
dbus_message_iter_init_append(reply, &iter);
if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
(os_strlen(npin) > 0 &&
!wpa_dbus_dict_append_string(&dict_iter, "Pin", npin)) ||
!wpa_dbus_dict_close_write(&iter, &dict_iter)) {
dbus_message_unref(reply);
return wpas_dbus_error_no_memory(message);
}
return reply;
}
static int show_status(DBusConnection *bus, char **args, unsigned n) {
_cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
const char *interface = "";
int r;
DBusMessageIter iter, sub, sub2, sub3;
StatusInfo info;
assert(args);
r = bus_method_call_with_reply(
bus,
"org.freedesktop.timedate1",
"/org/freedesktop/timedate1",
"org.freedesktop.DBus.Properties",
"GetAll",
&reply,
NULL,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_INVALID);
if (r < 0)
return r;
if (!dbus_message_iter_init(reply, &iter) ||
dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {
log_error("Failed to parse reply.");
return -EIO;
}
zero(info);
dbus_message_iter_recurse(&iter, &sub);
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
const char *name;
if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
log_error("Failed to parse reply.");
return -EIO;
}
dbus_message_iter_recurse(&sub, &sub2);
if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
log_error("Failed to parse reply.");
return -EIO;
}
if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
log_error("Failed to parse reply.");
return -EIO;
}
dbus_message_iter_recurse(&sub2, &sub3);
r = status_property(name, &sub3, &info);
if (r < 0) {
log_error("Failed to parse reply.");
return r;
}
dbus_message_iter_next(&sub);
}
print_status_info(&info);
return 0;
}
