/**
 * get @a property via @a dbus_connection .
 * org.freedesktop.DBus.Properties
 * Get (String interface, String propname) -> (Variant value)
 */
static int networkmanager_get_property(DBusConnection* dbus_connection, networkmanager_property* property)
{
	DBusMessage* msg;
    DBusMessageIter iter, iter_variant;
	DBusPendingCall* pending;
	int success;
    char* value_str_ptr;

	msg = dbus_message_new_method_call(
									  "org.freedesktop.NetworkManager",
									  property->dbus_path,
									  "org.freedesktop.DBus.Properties",
									  "Get"
									  );

	if(msg == NULL)
	{
		printf("networkmanager_get_property msg error\n");
		return 0;
	}

    dbus_message_iter_init_append(msg, &iter);
    dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property->dbus_interface);
	dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property->dbus_property_name);

	// send dbus message
	// -1 is the default time out. Other time outs can be configured in milli seconds.
	success = dbus_connection_send_with_reply(dbus_connection, msg, &pending, -1);
	if(!success)
	{
		printf("networkmanager_get_property dbus send error\n");
		return 0;
	}
	if(pending == NULL)
	{
		printf ("networkmanager_get_property dbus calling error\n");
		return 0;
	}

	dbus_connection_flush(dbus_connection);
	dbus_message_unref(msg);
	dbus_pending_call_block(pending);
	msg = dbus_pending_call_steal_reply(pending);
	dbus_pending_call_unref(pending);

	if(msg == NULL)
	{
		printf("networkmanager_get_property msg error 2\n");
		return 0;
	}

	if(!dbus_message_iter_init(msg, &iter))
	{
		printf("networkmanager_get_property dbus_message_iter_init error\n");
		dbus_message_unref(msg);
		return 0;
	}

	if(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_VARIANT)
	{
		dbus_message_iter_recurse(&iter, &iter_variant);
		if(dbus_message_iter_get_arg_type(&iter_variant) == DBUS_TYPE_STRING)
		{
			dbus_message_iter_get_basic(&iter_variant, &value_str_ptr);
			strncpy(property->value_string, value_str_ptr, property->value_string_len);
			printf("networkmanager_get_property %s %s: %s\n", property->dbus_path, property->dbus_property_name, value_str_ptr);
		}
		else if(dbus_message_iter_get_arg_type(&iter_variant) == DBUS_TYPE_UINT32)
		{
			dbus_message_iter_get_basic(&iter_variant, &property->value_int);
			printf("networkmanager_get_property %s %s: %i\n", property->dbus_path, property->dbus_property_name, property->value_int);
		}
		else
		{
			printf("networkmanager_get_property dbus_message_iter_get_arg_type error\n");
			dbus_message_unref(msg);
			return 0;
		}
	}
	else
	{
		printf("networkmanager_get_property dbus_message_iter_get_arg_type not variant error\n");
		dbus_message_unref(msg);
		return 0;
	}

	dbus_message_unref(msg);

	return 1;
}

static int l2tp_notify(DBusMessage *msg, struct vpn_provider *provider)
{
	DBusMessageIter iter, dict;
	const char *reason, *key, *value;
	char *addressv4 = NULL, *netmask = NULL, *gateway = NULL;
	char *ifname = NULL, *nameservers = NULL;
	struct connman_ipaddress *ipaddress = NULL;

	dbus_message_iter_init(msg, &iter);

	dbus_message_iter_get_basic(&iter, &reason);
	dbus_message_iter_next(&iter);

	if (!provider) {
		connman_error("No provider found");
		return VPN_STATE_FAILURE;
	}

	if (strcmp(reason, "auth failed") == 0) {
		DBG("authentication failure");

		vpn_provider_set_string(provider, "L2TP.User", NULL);
		vpn_provider_set_string(provider, "L2TP.Password", NULL);

		return VPN_STATE_AUTH_FAILURE;
	}

	if (strcmp(reason, "connect"))
		return VPN_STATE_DISCONNECT;

	dbus_message_iter_recurse(&iter, &dict);

	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
		DBusMessageIter entry;

		dbus_message_iter_recurse(&dict, &entry);
		dbus_message_iter_get_basic(&entry, &key);
		dbus_message_iter_next(&entry);
		dbus_message_iter_get_basic(&entry, &value);

		DBG("%s = %s", key, value);

		if (!strcmp(key, "INTERNAL_IP4_ADDRESS"))
			addressv4 = g_strdup(value);

		if (!strcmp(key, "INTERNAL_IP4_NETMASK"))
			netmask = g_strdup(value);

		if (!strcmp(key, "INTERNAL_IP4_DNS"))
			nameservers = g_strdup(value);

		if (!strcmp(key, "INTERNAL_IFNAME"))
			ifname = g_strdup(value);

		dbus_message_iter_next(&dict);
	}

	if (vpn_set_ifname(provider, ifname) < 0) {
		g_free(ifname);
		g_free(addressv4);
		g_free(netmask);
		g_free(nameservers);
		return VPN_STATE_FAILURE;
	}

	if (addressv4)
		ipaddress = connman_ipaddress_alloc(AF_INET);

	g_free(ifname);

	if (!ipaddress) {
		connman_error("No IP address for provider");
		g_free(addressv4);
		g_free(netmask);
		g_free(nameservers);
		return VPN_STATE_FAILURE;
	}

	value = vpn_provider_get_string(provider, "HostIP");
	if (value) {
		vpn_provider_set_string(provider, "Gateway", value);
		gateway = g_strdup(value);
	}

	if (addressv4)
		connman_ipaddress_set_ipv4(ipaddress, addressv4, netmask,
					gateway);

	vpn_provider_set_ipaddress(provider, ipaddress);
	vpn_provider_set_nameservers(provider, nameservers);

	g_free(addressv4);
	g_free(netmask);
	g_free(gateway);
	g_free(nameservers);
	connman_ipaddress_free(ipaddress);

	return VPN_STATE_CONNECT;
}

static void properties_reply(DBusPendingCall *call, void *user_data)
{
	struct supplicant_task *task = user_data;
	struct supplicant_result result;
	struct connman_network *network;
	DBusMessage *reply;
	DBusMessageIter array, dict;
	unsigned char strength;
	unsigned short channel, frequency;
	const char *mode, *security;
	char *group = NULL;

	reply = dbus_pending_call_steal_reply(call);
	if (reply == NULL) {
		_DBG_SUPPLICANT("task %p no reply", task);
		get_properties(task);
		return;
	}

	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
		_DBG_SUPPLICANT("task %p ERROR", task);
		dbus_message_unref(reply);
		get_properties(task);
		return;
	}

	memset(&result, 0, sizeof(result));
	result.frequency = -1;
	result.quality = -1;
	result.level = 0;
	result.noise = 0;

	dbus_message_iter_init(reply, &array);

	dbus_message_iter_recurse(&array, &dict);

	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
		DBusMessageIter entry, value;
		const char *key;

		dbus_message_iter_recurse(&dict, &entry);
		dbus_message_iter_get_basic(&entry, &key);

		dbus_message_iter_next(&entry);

		dbus_message_iter_recurse(&entry, &value);

		//type = dbus_message_iter_get_arg_type(&value);
		//dbus_message_iter_get_basic(&value, &val);

		/* 
		 * bssid        : a (97)
		 * ssid         : a (97)
		 * wpaie        : a (97)
		 * rsnie        : a (97)
		 * wpsie        : a (97)
		 * frequency    : i (105)
		 * capabilities : q (113)
		 * quality      : i (105)
		 * noise        : i (105)
		 * level        : i (105)
		 * maxrate      : i (105)
		 */

		if (g_str_equal(key, "bssid") == TRUE)
			extract_addr(&value, &result);
		else if (g_str_equal(key, "ssid") == TRUE)
			extract_ssid(&value, &result);
		else if (g_str_equal(key, "wpaie") == TRUE)
			extract_wpaie(&value, &result);
		else if (g_str_equal(key, "rsnie") == TRUE)
			extract_rsnie(&value, &result);
		else if (g_str_equal(key, "wpsie") == TRUE)
			extract_wpsie(&value, &result);
		else if (g_str_equal(key, "capabilities") == TRUE)
			extract_capabilites(&value, &result);
		else if (g_str_equal(key, "frequency") == TRUE)
			dbus_message_iter_get_basic(&value, &result.frequency);
		else if (g_str_equal(key, "quality") == TRUE)
			dbus_message_iter_get_basic(&value, &result.quality);
		else if (g_str_equal(key, "noise") == TRUE)
			dbus_message_iter_get_basic(&value, &result.noise);
		else if (g_str_equal(key, "level") == TRUE)
			dbus_message_iter_get_basic(&value, &result.level);
		else if (g_str_equal(key, "maxrate") == TRUE)
			dbus_message_iter_get_basic(&value, &result.maxrate);

		dbus_message_iter_next(&dict);
	}

	if (result.path == NULL)
		goto done;

	if (result.path[0] == '\0')
		goto done;

	if (result.frequency > 0 && result.frequency < 14)
		result.frequency = 2407 + (5 * result.frequency);
	else if (result.frequency == 14)
		result.frequency = 2484;
//.........这里部分代码省略.........

static void request_input_passphrase_reply(DBusMessage *reply, void *user_data)
{
	struct request_input_reply *passphrase_reply = user_data;
	bool values_received = false;
	bool wps = false;
	const char *error = NULL;
	char *identity = NULL;
	char *passphrase = NULL;
	char *wpspin = NULL;
	char *key;
	char *name = NULL;
	int name_len = 0;
	DBusMessageIter iter, dict;

	if (!reply)
		goto out;

	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
		error = dbus_message_get_error_name(reply);
		goto done;
	}

	if (!check_reply_has_dict(reply))
		goto done;

	values_received = true;

	dbus_message_iter_init(reply, &iter);
	dbus_message_iter_recurse(&iter, &dict);
	while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
		DBusMessageIter entry, value;

		dbus_message_iter_recurse(&dict, &entry);
		if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
			break;

		dbus_message_iter_get_basic(&entry, &key);

		if (g_str_equal(key, "Identity")) {
			dbus_message_iter_next(&entry);
			if (dbus_message_iter_get_arg_type(&entry)
							!= DBUS_TYPE_VARIANT)
				break;
			dbus_message_iter_recurse(&entry, &value);
			dbus_message_iter_get_basic(&value, &identity);

		} else if (g_str_equal(key, "Passphrase")) {
			dbus_message_iter_next(&entry);
			if (dbus_message_iter_get_arg_type(&entry)
							!= DBUS_TYPE_VARIANT)
				break;
			dbus_message_iter_recurse(&entry, &value);
			dbus_message_iter_get_basic(&value, &passphrase);

		} else if (g_str_equal(key, "WPS")) {
			wps = true;

			dbus_message_iter_next(&entry);
			if (dbus_message_iter_get_arg_type(&entry)
							!= DBUS_TYPE_VARIANT)
				break;
			dbus_message_iter_recurse(&entry, &value);
			dbus_message_iter_get_basic(&value, &wpspin);
			break;
		} else if (g_str_equal(key, "Name")) {
			dbus_message_iter_next(&entry);
			if (dbus_message_iter_get_arg_type(&entry)
							!= DBUS_TYPE_VARIANT)
				break;
			dbus_message_iter_recurse(&entry, &value);
			dbus_message_iter_get_basic(&value, &name);
			name_len = strlen(name);
		} else if (g_str_equal(key, "SSID")) {
			dbus_message_iter_next(&entry);
			if (dbus_message_iter_get_arg_type(&entry)
							!= DBUS_TYPE_VARIANT)
				break;
			dbus_message_iter_recurse(&entry, &value);
			if (dbus_message_iter_get_arg_type(&value)
							!= DBUS_TYPE_VARIANT)
				break;
			if (dbus_message_iter_get_element_type(&value)
							!= DBUS_TYPE_VARIANT)
				break;
			dbus_message_iter_get_fixed_array(&value, &name,
							&name_len);
		}
		dbus_message_iter_next(&dict);
	}

done:
	passphrase_reply->callback(passphrase_reply->service, values_received,
				name, name_len,
				identity, passphrase,
				wps, wpspin, error,
				passphrase_reply->user_data);

out:
	g_free(passphrase_reply);
}

static DBusHandlerResult info(DBusConnection *c, DBusMessage * msg, void *data)
{
    int              driver    = -1;
    int              connected = -1;
    int             *valueptr  = &driver;
    int              value     = -1;
    DBusMessageIter  msgit;
    DBusMessageIter  devit;
    char            *string;
    char            *end;
    char            *device;
    gboolean         is_info;

    (void) c;
    (void) data;

    /* This is an example of what we should get:

       string "connected"
       string "1"
       array [
          string "fmtx"
       ]

    */

    is_info = dbus_message_is_signal(msg, "com.nokia.policy", "info");
    if (!is_info)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    OHM_DEBUG(DBG_INFO, "received an info message");

    dbus_message_iter_init(msg, &msgit);

    for (;;) {
        if (dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_STRING)
            goto done;

        dbus_message_iter_get_basic(&msgit, (void *)&string);

        if (!strcmp(string, "media"))
            goto not_our_signal;

        if (!strcmp(string, "driver")) {
            valueptr = &driver;

            if (!dbus_message_iter_next(&msgit))
                goto done;
        }
        else if (!strcmp(string, "connected")) {
            valueptr = &connected;

            if (!dbus_message_iter_next(&msgit))
                goto done;
        }
        else {
            value = strtol(string, &end, 10);

            if (*end == '\0' && (value == 0 || value == 1)) {
                *valueptr = value;
                break;
            }

            goto done;
        }
    }

    if (!dbus_message_iter_next(&msgit) ||
        dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_ARRAY)
        goto done;

    dbus_message_iter_recurse(&msgit, &devit);

    do {
        if (dbus_message_iter_get_arg_type(&devit) != DBUS_TYPE_STRING)
            continue;

        dbus_message_iter_get_basic(&devit, (void *)&device);

        OHM_DEBUG(DBG_INFO, "device: '%s', driver: '%d', connected: '%d'",
                  device ? device : "NULL", driver, connected);
        if (!is_spurious_event(device, driver, connected))
            dres_accessory_request(device, driver, connected);

    } while (dbus_message_iter_next(&devit));

    dres_all();

 done:
 not_our_signal:
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

int
ac_manage_exec_extend_command(DBusConnection *connection, 
                                            unsigned int command_type, 
                                            char *command, 
                                            struct command_return_s **command_return) {

    if(NULL == connection || NULL == command || NULL == command_return)
        return AC_MANAGE_INPUT_TYPE_ERROR;

    char *comm = command;  
  
    *command_return = NULL;    
    struct command_return_s *end_return = NULL;
    
	DBusMessage *query, *reply;
	DBusError err;
	DBusMessageIter	 iter;

	int ret = AC_MANAGE_DBUS_ERROR;
    int moreReturn = 0;
    char *returnStr = NULL;

	query = dbus_message_new_method_call(AC_MANAGE_DBUS_DBUSNAME, 
										AC_MANAGE_DBUS_OBJPATH,
										AC_MANAGE_DBUS_INTERFACE,
										AC_MANAGE_DBUS_EXTEND_COMMAND_EXEC);

    dbus_error_init(&err);

    dbus_message_append_args(query,
                            DBUS_TYPE_UINT32, &command_type,
                            DBUS_TYPE_STRING, &comm,
                            DBUS_TYPE_INVALID);

    reply = dbus_connection_send_with_reply_and_block(connection, query, -1, &err);

    dbus_message_unref(query);

    if(NULL == reply) {
        if(dbus_error_is_set(&err)) {
            dbus_error_free(&err);
        }
        return AC_MANAGE_DBUS_ERROR;
    }
    
	dbus_message_iter_init(reply, &iter);
	dbus_message_iter_get_basic(&iter, &ret);
	
    dbus_message_iter_next(&iter);  
	dbus_message_iter_get_basic(&iter, &moreReturn);

    while(AC_MANAGE_SUCCESS == ret && moreReturn) {
    
        dbus_message_iter_next(&iter);  
        dbus_message_iter_get_basic(&iter, &returnStr);

        dbus_message_iter_next(&iter);  
        dbus_message_iter_get_basic(&iter, &moreReturn);

        struct command_return_s *temp_return = (struct command_return_s *)malloc(sizeof(struct command_return_s));
        if(NULL == temp_return) {
            dbus_message_unref(reply);
            syslog(LOG_WARNING, "ac_manage_exec_extend_command: malloc temp_return fail!\n");
            return AC_MANAGE_MALLOC_ERROR;
        }
        memset(temp_return, 0, sizeof(struct command_return_s));
        
        strncpy(temp_return->returnString, returnStr, sizeof(temp_return->returnString) - 1);

        if(NULL == *command_return) {
            *command_return = temp_return;
        }
        else {
            end_return->next = temp_return;
        }
        
        end_return = temp_return;
    }
    
    dbus_message_unref(reply);
    
    return ret;
}

static void Crash(DBusMessage* signal)
{
    int r;
    DBusMessageIter in_iter;
    dbus_message_iter_init(signal, &in_iter);

    /* 1st param: package */
    const char* package_name = NULL;
    r = load_charp(&in_iter, &package_name);

    /* 2nd param: dir */
//dir parameter is not used for now, use is planned in the future
    if (r != ABRT_DBUS_MORE_FIELDS)
    {
        error_msg("dbus signal %s: parameter type mismatch", __func__);
        return;
    }
    const char* dir = NULL;
    r = load_charp(&in_iter, &dir);

    /* Optional 3rd param: uid */
    const char* uid_str = NULL;
    if (r == ABRT_DBUS_MORE_FIELDS)
    {
        r = load_charp(&in_iter, &uid_str);
    }
    if (r != ABRT_DBUS_LAST_FIELD)
    {
        error_msg("dbus signal %s: parameter type mismatch", __func__);
        return;
    }

    if (uid_str != NULL)
    {
        char *end;
        errno = 0;
        unsigned long uid_num = strtoul(uid_str, &end, 10);
        if (errno || *end != '\0' || uid_num != getuid())
        {
            return;
        }
    }

    const char* message = _("A crash in the %s package has been detected");
    if (package_name[0] == '\0')
        message = _("A crash has been detected");
    init_applet();
    //applet->AddEvent(uid, package_name);
    set_icon_tooltip(applet, message, package_name);
    show_icon(applet);

    /* If this crash seems to be repeating, do not annoy user with popup dialog.
     * (The icon in the tray is not suppressed)
     */
    static time_t last_time = 0;
    static char* last_package_name = NULL;
    static char* last_dir = NULL;
    time_t cur_time = time(NULL);
    if (last_package_name && strcmp(last_package_name, package_name) == 0
            && last_dir && strcmp(last_dir, dir) == 0
            && (unsigned)(cur_time - last_time) < 2 * 60 * 60
       ) {
        log_msg("repeated crash in %s, not showing the notification", package_name);
        return;
    }
    last_time = cur_time;
    free(last_package_name);
    last_package_name = xstrdup(package_name);
    free(last_dir);
    last_dir = xstrdup(dir);

    show_crash_notification(applet, dir, message, package_name);
}

static DBusHandlerResult
request_navit_set_attr(DBusConnection *connection, DBusMessage *message)
{
    struct navit *navit;
	DBusMessageIter iter, iterattr;
    struct attr attr;
    char *attr_type;

	navit = object_get_from_message(message, "navit");
	if (! navit)
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    dbus_message_iter_init(message, &iter);
    dbus_message_iter_get_basic(&iter, &attr_type);
    attr.type = attr_from_name(attr_type); 
    dbg(0, "attr value: 0x%x string: %s\n", attr.type, attr_type);
    
    if (attr.type == attr_none)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    
    dbus_message_iter_next(&iter);
    dbus_message_iter_recurse(&iter, &iterattr);
    dbg(0, "seems valid. signature: %s\n", dbus_message_iter_get_signature(&iterattr));
    
    if (attr.type > attr_type_item_begin && attr.type < attr_type_item_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if (attr.type > attr_type_int_begin && attr.type < attr_type_boolean_begin) {
        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_INT32)
        {
            dbus_message_iter_get_basic(&iterattr, &attr.u.num);
            if (navit_set_attr(navit, &attr))
                return empty_reply(connection, message);
        }
    }
    else if(attr.type > attr_type_boolean_begin && attr.type < attr_type_int_end) {
        if (dbus_message_iter_get_arg_type(&iterattr) == DBUS_TYPE_BOOLEAN)
        {
            dbus_message_iter_get_basic(&iterattr, &attr.u.num);
            if (navit_set_attr(navit, &attr))
                return empty_reply(connection, message);
        }
    }
#if 0
    else if(attr.type > attr_type_string_begin && attr.type < attr_type_string_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_special_begin && attr.type < attr_type_special_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_double_begin && attr.type < attr_type_double_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_coord_geo_begin && attr.type < attr_type_coord_geo_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_color_begin && attr.type < attr_type_color_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_object_begin && attr.type < attr_type_object_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_coord_begin && attr.type < attr_type_coord_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_pcoord_begin && attr.type < attr_type_pcoord_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_callback_begin && attr.type < attr_type_callback_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
#endif
    else {
        dbg(0, "zomg really unhandled111\n");
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    }
    
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

GList *
upstart_job_listall(void)
{
    GList *units = NULL;
    DBusMessageIter args;
    DBusMessageIter unit;
    DBusMessage *msg = NULL;
    DBusMessage *reply = NULL;
    const char *method = "GetAllJobs";
    DBusError error;
    int lpc = 0;

    if (upstart_init() == FALSE) {
        return NULL;
    }

/*
  com.ubuntu.Upstart0_6.GetAllJobs (out <Array of ObjectPath> jobs)
*/

    dbus_error_init(&error);
    msg = dbus_message_new_method_call(BUS_NAME, // target for the method call
                                       BUS_PATH, // object to call on
                                       UPSTART_06_API, // interface to call on
                                       method); // method name
    CRM_ASSERT(msg != NULL);

    reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, DBUS_TIMEOUT_USE_DEFAULT);
    dbus_message_unref(msg);

    if (dbus_error_is_set(&error)) {
        crm_err("Call to %s failed: %s", method, error.message);
        dbus_error_free(&error);
        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;
        const char *job = NULL;
        char *path = NULL;

        if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_OBJECT_PATH, __FUNCTION__, __LINE__)) {
            continue;
        }

        dbus_message_iter_get_basic(&unit, &value);

        if(value.str) {
            int llpc = 0;
            path = value.str;
            job = value.str;
            while (path[llpc] != 0) {
                if (path[llpc] == '/') {
                    job = path + llpc + 1;
                }
                llpc++;
            }
            lpc++;
            crm_trace("%s -> %s", path, job);
            units = g_list_append(units, fix_upstart_name(job));
        }
        dbus_message_iter_next (&unit);
    }

    dbus_message_unref(reply);
    crm_trace("Found %d upstart jobs", lpc);
    return units;
}

/**
 * add connection settings to network manager
 */
int qaul_network_settings_add(DBusConnection* dbus_connection, qaul_dbus_connection_settings* settings, qaul_dbus_device_properties* device)
{
	DBusMessage* msg;
	DBusMessageIter iter;
	DBusMessageIter iter_array[7];
	char uuid[37];
	const char* connection_path_ptr;
	dbus_uint32_t wlan_channel_ui32;

	printf("qaul_network_settings_add\n");

	msg = dbus_message_new_method_call(
							"org.freedesktop.NetworkManager",
							"/org/freedesktop/NetworkManager/Settings",
							"org.freedesktop.NetworkManager.Settings",
							"AddConnection"
							);

	if(msg == NULL)
	{
		printf("qaul_network_settings_add msg error\n");
		return 0;
	}

	const char* connection_str = "connection";
	const char* connection_keys[]   = {"id",      "type", "uuid", "zone"};
	const char* connection_values[] = {"qaul.net", NULL,   NULL,  "public"};

	// connection uuid
	qaul_dbus_create_uuid(uuid);
	connection_values[2] = uuid;
	printf("uuid: %s\n", uuid);

	// configure settings type & structure
	if(device->type == 2)
	{
		connection_values[1] = "802-11-wireless";
	}
	else if(device->type == 1)
	{
		connection_values[1] = "802-3-ethernet";
	}

	dbus_message_iter_init_append(msg, &iter);

	// configure connection settings
	if(!(
		   dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sa{sv}}", &iter_array[0])
		&& dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1])
		&& dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &connection_str)
		&& dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2])
		&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[0], DBUS_TYPE_STRING, &connection_values[0])
		&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[1], DBUS_TYPE_STRING, &connection_values[1])
		&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[2], DBUS_TYPE_STRING, &connection_values[2])
		&& qaul_dbus_append_dict_entry(&iter_array[2], connection_keys[3], DBUS_TYPE_STRING, &connection_values[3])
		&& dbus_message_iter_close_container(&iter_array[1], &iter_array[2])
		&& dbus_message_iter_close_container(&iter_array[0], &iter_array[1])
		))
	{
		printf("qaul_network_settings_add append connection settings error\n");
		return 0;
	}

	// configure wireless device
	if(device->type == 2)
	{
		const char* wlan = connection_values[1];
		const char* wlan_keys[]   = {"ssid", "mode", "band", "channel"};
		const char* wlan_values[] = {NULL,  "adhoc", "bg"};
		wlan_channel_ui32 = settings->wifi_channel +0;

		if(!(
			   dbus_message_iter_open_container(&iter_array[0], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[1])
			&& dbus_message_iter_append_basic(&iter_array[1], DBUS_TYPE_STRING, &wlan)
			&& dbus_message_iter_open_container(&iter_array[1], DBUS_TYPE_ARRAY, "{sv}", &iter_array[2])

			// add hardware MAC address
			&& qaul_dbus_append_device_mac(&iter_array[2], device)

			// SSID dict entry as byte array
			&& dbus_message_iter_open_container(&iter_array[2], DBUS_TYPE_DICT_ENTRY, NULL, &iter_array[3])
			&& dbus_message_iter_append_basic(&iter_array[3], DBUS_TYPE_STRING, &wlan_keys[0])
			&& dbus_message_iter_open_container(&iter_array[3], DBUS_TYPE_VARIANT, "ay", &iter_array[4])
			&& dbus_message_iter_open_container(&iter_array[4], DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE_AS_STRING, &iter_array[5])
			&& qaul_dbus_append_ssid(&iter_array[5], settings->wifi_ssid)
			&& dbus_message_iter_close_container(&iter_array[4], &iter_array[5])
			&& dbus_message_iter_close_container(&iter_array[3], &iter_array[4])
			&& dbus_message_iter_close_container(&iter_array[2], &iter_array[3])

			// end SSID dict entry
			&& qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[1], DBUS_TYPE_STRING, &wlan_values[1])
			&& qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[2], DBUS_TYPE_STRING, &wlan_values[2])
			&& qaul_dbus_append_dict_entry(&iter_array[2], wlan_keys[3], DBUS_TYPE_UINT32, &wlan_channel_ui32)
			&& dbus_message_iter_close_container(&iter_array[1], &iter_array[2])
			&& dbus_message_iter_close_container(&iter_array[0], &iter_array[1])
		))
		{
//.........这里部分代码省略.........

static DBusHandlerResult
request_navit_get_attr(DBusConnection *connection, DBusMessage *message)
{
    struct navit *navit;
    DBusMessageIter iter;
    char * attr_type = NULL;
    struct attr attr;
    navit = object_get_from_message(message, "navit");
    if (! navit)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    dbus_message_iter_init(message, &iter);
    dbus_message_iter_get_basic(&iter, &attr_type);
    attr.type = attr_from_name(attr_type); 
    dbg(0, "attr value: 0x%x string: %s\n", attr.type, attr_type);

    if (attr.type == attr_none)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    
    if (attr.type > attr_type_item_begin && attr.type < attr_type_item_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if (attr.type > attr_type_int_begin && attr.type < attr_type_boolean_begin)
    {
        dbg(0, "int detected\n");
        if(navit_get_attr(navit, attr.type, &attr, NULL)) {
            dbg(0, "%s = %i\n", attr_type, attr.u.num);
            return reply_simple_as_variant(connection, message, attr.u.num, DBUS_TYPE_INT32);
        }
    }

    else if(attr.type > attr_type_boolean_begin && attr.type < attr_type_int_end)
    {
        dbg(0, "bool detected\n");
        if(navit_get_attr(navit, attr.type, &attr, NULL)) {
            dbg(0, "%s = %i\n", attr_type, attr.u.num);
            return reply_simple_as_variant(connection, message, attr.u.num, DBUS_TYPE_BOOLEAN);
        }
    }

    else if(attr.type > attr_type_string_begin && attr.type < attr_type_string_end)
    {
        dbg(0, "string detected\n");
        if(navit_get_attr(navit, attr.type, &attr, NULL)) {
            dbg(0, "%s = %s\n", attr_type, &attr.u.layout);
            return reply_simple_as_variant(connection, message, &attr.u.layout, DBUS_TYPE_STRING);
        }
    }

#if 0
    else if(attr.type > attr_type_special_begin && attr.type < attr_type_special_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_double_begin && attr.type < attr_type_double_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_coord_geo_begin && attr.type < attr_type_coord_geo_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_color_begin && attr.type < attr_type_color_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_object_begin && attr.type < attr_type_object_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_coord_begin && attr.type < attr_type_coord_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_pcoord_begin && attr.type < attr_type_pcoord_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

    else if(attr.type > attr_type_callback_begin && attr.type < attr_type_callback_end)
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
#endif
    else {
        dbg(0, "zomg really unhandled111\n");
        return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
    }

    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}

/**
 * find the first wifi device
 *
 * @retval 1 wifi device found, properties set
 * @retval 0 no wifi device found, properties not set
 */
int qaul_network_find_wifi(DBusConnection* dbus_connection, qaul_dbus_device_properties* device)
{
	DBusMessage* msg;
	DBusMessageIter iter, iter_array;
	int current_type;
	const char* device_path_ptr;

	printf("qaul_network_find_wifi\n");

	msg = networkmanager_dbus_method_call("GetDevices");
	if(msg == NULL)
		return 0;

	dbus_message_iter_init_append(msg, &iter);
	if(!networkmanager_dbus_send(&msg, dbus_connection))
	{
		printf("qaul_network_find_wifi networkmanager_dbus_send error\n");
		return 0;
	}
	if(!dbus_message_iter_init(msg, &iter)
		|| dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
	{
		printf("qaul_network_find_wifi dbus_message_iter_init | DBUS_TYPE_ARRAY error\n");
		dbus_message_unref(msg);
		return 0;
	}

	// loop recursively over the array
	dbus_message_iter_recurse (&iter, &iter_array);
	while((current_type = dbus_message_iter_get_arg_type(&iter_array)) != DBUS_TYPE_INVALID)
	{
		if(current_type == DBUS_TYPE_OBJECT_PATH)
		{
			dbus_message_iter_get_basic(&iter_array, &device_path_ptr);
			strncpy(device->dbus_device_path, device_path_ptr, sizeof(device->dbus_device_path));

			// get interface name, type
			// dbus low level: dbus_message_new_method_call interface:"org.freedesktop.DBus.Properties" method:"Get" property:"(String)Interface, (UInt32)DeviceType"
			if(networkmanager_device_properties(dbus_connection, device))
			{
				if(device->type == 2 && device->state > 20)
				{
					printf("qaul_network_find_wifi wifi found: %s\n", device->interface);
					dbus_message_unref(msg);
					return 1;
				}
			}
			else
				printf("qaul_network_find_wifi networkmanager_device_get_property failed for %s\n", device->dbus_device_path);
		}
		else
			printf("qaul_network_find_wifi Unknown current type [%i]\n", current_type);

		dbus_message_iter_next(&iter_array);
	}
	dbus_message_unref(msg);

	printf("qaul_network_find_wifi no wifi device found\n");

	return 0;
}

/**
 * Write a Json configuration to @a json_txt of available network devices.
 * Only Wifi and Ethernet devices are represented as the other device cannot be
 * configured at the moment. @a json_txt needs to be a pointer ot a char buffer
 * of the size MAX_JSON_LEN +1.
 *
 * @retval 1 success
 * @retval 2 error
 *
 * https://developer.gnome.org/NetworkManager/unstable/spec.html
 * GetDevices() → ao
 *
 * Dbus messages:
 * http://dbus.freedesktop.org/doc/api/html/group__DBusMessage.html
 * DBUS_EXPORT int dbus_message_iter_get_arg_type(DBusMessageIter * iter)
 */
int qaul_network_devices_json(DBusConnection* dbus_connection, char* json_txt)
{
	DBusMessage* msg;
	DBusMessageIter iter, iter_array;
	int current_type, json_pos, i;
	const char* device_path_ptr;
	qaul_dbus_device_properties device;

	printf("qaul_network_devices_json\n");

	i = 0;
	msg = networkmanager_dbus_method_call("GetDevices");
	if(msg == NULL)
		return 0;

	dbus_message_iter_init_append(msg, &iter);
	if(!networkmanager_dbus_send(&msg, dbus_connection))
	{
		printf("qaul_network_devices_json networkmanager_dbus_send error\n");
		return 0;
	}
	if(!dbus_message_iter_init(msg, &iter)
		|| dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
	{
		printf("qaul_network_devices_json dbus_message_iter_init | DBUS_TYPE_ARRAY error\n");
		dbus_message_unref(msg);
		return 0;
	}

	// loop recursively over the array
	json_pos = 0;
	strncpy(json_txt +json_pos, "", MAX_JSON_LEN -json_pos);
	dbus_message_iter_recurse (&iter, &iter_array);
	while((current_type = dbus_message_iter_get_arg_type(&iter_array)) != DBUS_TYPE_INVALID)
	{
		if(current_type == DBUS_TYPE_OBJECT_PATH)
		{
			dbus_message_iter_get_basic(&iter_array, &device_path_ptr);
			strncpy(device.dbus_device_path, device_path_ptr, sizeof(device.dbus_device_path));

			// get interface name and interface type
			// dbus low level: dbus_message_new_method_call interface:"org.freedesktop.DBus.Properties" method:"Get" property:"(String)Interface, (UInt32)DeviceType"
			if(networkmanager_device_properties(dbus_connection, &device))
			{
				// only wifi and ethernet connections can be handled at the moment
				if(device.type == 2 || device.type == 1)
				{
					if(i > 0)
					{
						json_pos = strlen(json_txt);
						strncpy(json_txt +json_pos, ",", MAX_JSON_LEN -json_pos);
					}
					i++;

					// write to json
					json_pos = strlen(json_txt);
					strncpy(json_txt +json_pos, "{\"name\":\"", MAX_JSON_LEN -json_pos);
					json_pos = strlen(json_txt);
					strncpy(json_txt +json_pos, device.interface, MAX_JSON_LEN -json_pos);
					json_pos = strlen(json_txt);

					if(device.type == 2)
					{
						strncpy(json_txt +json_pos, "\",\"ui_name\":\"WIFI (", MAX_JSON_LEN -json_pos);
						json_pos = strlen(json_txt);
						strncpy(json_txt +json_pos, device.interface, MAX_JSON_LEN -json_pos);
						json_pos = strlen(json_txt);
						strncpy(json_txt +json_pos, ")\",\"type\":1", MAX_JSON_LEN -json_pos);
					}
					else if(device.type == 1)
					{
						strncpy(json_txt +json_pos, "\",\"ui_name\":\"ETHERNET (", MAX_JSON_LEN -json_pos);
						json_pos = strlen(json_txt);
						strncpy(json_txt +json_pos, device.interface, MAX_JSON_LEN -json_pos);
						json_pos = strlen(json_txt);
						strncpy(json_txt +json_pos, ")\",\"type\":2", MAX_JSON_LEN -json_pos);
					}

					json_pos = strlen(json_txt);
					strncpy(json_txt +json_pos, "}", MAX_JSON_LEN -json_pos);
				}
			}
			else
				printf("qaul_network_devices_json networkmanager_device_get_property failed\n");
//.........这里部分代码省略.........

/**
 * get all properties of @a dbus_device_path as @a value struct via dbus @a connection
 *
 * network manager dbus methods are documented here:
 * https://developer.gnome.org/NetworkManager/unstable/spec.html#org.freedesktop.NetworkManager.Device
 */
static int networkmanager_device_properties(DBusConnection* dbus_connection, qaul_dbus_device_properties* device)
{
	DBusMessage* msg;
    DBusMessageIter iter, iter_array, iter_dict, iter_prop;
	DBusPendingCall* pending;
	int success, set_Type, set_Interface, set_State, current_type;
    char* property_ptr;
    char* key_ptr;
	networkmanager_property device_property;

    const char* dbus_interface = "org.freedesktop.NetworkManager.Device";

    // reset values
    set_Type = 0;
    set_Interface = 0;
    set_State = 0;
    device->type = 0;
    device->state = 0;
    strncpy(device->interface, "", sizeof(device->interface));

	msg = dbus_message_new_method_call(
									  "org.freedesktop.NetworkManager",
									  device->dbus_device_path,
									  "org.freedesktop.DBus.Properties",
									  "GetAll"
									  );

	if(msg == NULL)
	{
		printf("networkmanager_device_properties msg error\n");
		return 0;
	}

    dbus_message_iter_init_append(msg, &iter);
    dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &dbus_interface);

	// send dbus message
	// -1 is the default time out. Other time outs can be configured in milli seconds.
	success = dbus_connection_send_with_reply(dbus_connection, msg, &pending, -1);
	if(!success)
	{
		printf("networkmanager_device_properties dbus send error\n");
		return 0;
	}
	if(pending == NULL)
	{
		printf ("networkmanager_device_properties dbus calling error\n");
		return 0;
	}

	dbus_connection_flush(dbus_connection);
	dbus_message_unref(msg);
	dbus_pending_call_block(pending);
	msg = dbus_pending_call_steal_reply(pending);
	dbus_pending_call_unref(pending);

	if(msg == NULL)
	{
		printf("networkmanager_device_properties msg error 2\n");
		return 0;
	}

	if(!dbus_message_iter_init(msg, &iter))
	{
		printf("networkmanager_device_properties dbus_message_iter_init error\n");
		dbus_message_unref(msg);
		return 0;
	}
	if(dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
	{
		printf("networkmanager_device_properties dbus_message_iter_get_arg_type return is not a DBUS_TYPE_ARRAY %i\n", dbus_message_iter_get_arg_type(&iter));
		if(dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_STRING)
		{
			dbus_message_iter_get_basic(&iter, &property_ptr);
			printf("networkmanager_device_properties error msg: %s\n", property_ptr);
		}
		dbus_message_unref(msg);
		return 0;
	}

	// loop over the array
	dbus_message_iter_recurse(&iter, &iter_array);
	while((current_type = dbus_message_iter_get_arg_type(&iter_array)) != DBUS_TYPE_INVALID)
	{
		// check if it is a dict entry
		if(dbus_message_iter_get_arg_type(&iter_array) == DBUS_TYPE_DICT_ENTRY)
		{
			dbus_message_iter_recurse(&iter_array, &iter_dict);
			// get key
			dbus_message_iter_get_basic(&iter_dict, &key_ptr);
			// get property
			if(dbus_message_iter_next(&iter_dict))
			{
				dbus_message_iter_recurse(&iter_dict, &iter_prop);
//.........这里部分代码省略.........

static void get_connections_reply(DBusPendingCall *call, void *user_data)
{
	DBusMessage *reply;
	DBusError error;
	DBusMessageIter array, dict;
	const char *signature = DBUS_TYPE_ARRAY_AS_STRING
		DBUS_STRUCT_BEGIN_CHAR_AS_STRING
		DBUS_TYPE_OBJECT_PATH_AS_STRING
		DBUS_TYPE_ARRAY_AS_STRING
		DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
		DBUS_TYPE_STRING_AS_STRING
		DBUS_TYPE_VARIANT_AS_STRING
		DBUS_DICT_ENTRY_END_CHAR