Beispiel #1
0
void notify(DBusMessage * dmsg)
{
        DBusMessage *reply;
        DBusMessageIter args;
        DBusMessageIter hints;
        DBusMessageIter hint;
        char *hint_name;

        int i;
        int id;
        const char *appname = NULL;
        const char *summary = NULL;
        const char *body = NULL;
        const char *icon = NULL;
        const char *fgcolor = NULL;
        const char *bgcolor = NULL;
        int urgency = 1;
        int progress = -1;
        notification *n = malloc(sizeof(notification));
        dbus_uint32_t replaces_id = 0;
        dbus_int32_t expires = -1;

        dbus_serial++;
        dbus_message_iter_init(dmsg, &args);

        _extract_basic(DBUS_TYPE_STRING, &args, &appname);

        dbus_message_iter_next(&args);
        _extract_basic(DBUS_TYPE_UINT32, &args, &replaces_id);

        dbus_message_iter_next(&args);
        _extract_basic(DBUS_TYPE_STRING, &args, &icon);

        dbus_message_iter_next(&args);
        _extract_basic(DBUS_TYPE_STRING, &args, &summary);

        dbus_message_iter_next(&args);
        _extract_basic(DBUS_TYPE_STRING, &args, &body);

        dbus_message_iter_next(&args);
        dbus_message_iter_next(&args);

        dbus_message_iter_recurse(&args, &hints);
        dbus_message_iter_next(&args);

        _extract_basic(DBUS_TYPE_INT32, &args, &expires);

        while (dbus_message_iter_get_arg_type(&hints) != DBUS_TYPE_INVALID) {
                dbus_message_iter_recurse(&hints, &hint);
                while (dbus_message_iter_get_arg_type(&hint) !=
                       DBUS_TYPE_INVALID) {
                        if (dbus_message_iter_get_arg_type(&hint) !=
                            DBUS_TYPE_STRING) {
                                dbus_message_iter_next(&hint);
                                continue;
                        }
                        dbus_message_iter_get_basic(&hint, &hint_name);
                        _extract_hint(DBUS_TYPE_BYTE, "urgency", hint_name,
                                      &hint, &urgency);
                        _extract_hint(DBUS_TYPE_STRING, "fgcolor", hint_name,
                                      &hint, &fgcolor);
                        _extract_hint(DBUS_TYPE_STRING, "bgcolor", hint_name,
                                      &hint, &bgcolor);
                        _extract_hint(DBUS_TYPE_INT32, "value", hint_name,
                                      &hint, &progress);
                        if (!progress)
                                _extract_hint(DBUS_TYPE_UINT32, "value",
                                              hint_name, &hint, &progress);
                        dbus_message_iter_next(&hint);
                }
                dbus_message_iter_next(&hints);
        }

        if (expires > 0) {
                /* do some rounding */
                expires = (expires + 500) / 1000;
                if (expires < 1) {
                        expires = 1;
                }
        }
        n->appname = appname != NULL ? strdup(appname) : "";
        n->summary = summary != NULL ? strdup(summary) : "";
        n->body = body != NULL ? strdup(body) : "";
        n->icon = icon != NULL ? strdup(icon) : "";
        n->timeout = expires;
        n->progress = (progress < 0 || progress > 100) ? 0 : progress + 1;
        n->urgency = urgency;
        n->dbus_client = strdup(dbus_message_get_sender(dmsg));
        for (i = 0; i < ColLast; i++) {
                n->color_strings[i] = NULL;
        }
        n->color_strings[ColFG] = fgcolor == NULL ? NULL : strdup(fgcolor);
        n->color_strings[ColBG] = bgcolor == NULL ? NULL : strdup(bgcolor);

        id = init_notification(n, replaces_id);
        if (id > 0)
                map_win();

        reply = dbus_message_new_method_return(dmsg);

        dbus_message_iter_init_append(reply, &args);
        dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &id);
        dbus_connection_send(dbus_conn, reply, &dbus_serial);

        dbus_message_unref(reply);
}
Beispiel #2
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");
		}
		else
			printf("qaul_network_devices_json Unknown current type [%i]\n", current_type);

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

	return 1;
}
Beispiel #3
0
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;
}
Beispiel #4
0
static DBusMessage *change_session(DBusConnection *conn,
					DBusMessage *msg, void *user_data)
{
	struct connman_session *session = user_data;
	struct session_info *info = session->info;
	DBusMessageIter iter, value;
	const char *name;
	const char *val;
	GSList *allowed_bearers;
	int err;

	DBG("session %p", session);
	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);

	switch (dbus_message_iter_get_arg_type(&value)) {
	case DBUS_TYPE_ARRAY:
		if (g_str_equal(name, "AllowedBearers") == TRUE) {
			err = parse_bearers(&value, &allowed_bearers);
			if (err < 0)
				return __connman_error_failed(msg, err);

			g_slist_free(info->config.allowed_bearers);
			session->user_allowed_bearers = allowed_bearers;

			err = apply_policy_on_bearers(
					session->policy_config->allowed_bearers,
					session->user_allowed_bearers,
					&info->config.allowed_bearers);

			if (err < 0)
				return __connman_error_failed(msg, err);
		} else {
			goto err;
		}
		break;
	case DBUS_TYPE_STRING:
		if (g_str_equal(name, "ConnectionType") == TRUE) {
			dbus_message_iter_get_basic(&value, &val);
			info->config.type = apply_policy_on_type(
				session->policy_config->type,
				connman_session_parse_connection_type(val));
		} else {
			goto err;
		}
		break;
	default:
		goto err;
	}

	session_changed(session, CONNMAN_SESSION_TRIGGER_SETTING);

	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);

err:
	return __connman_error_invalid_arguments(msg);
}
Beispiel #5
0
/**
 * 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;
}
Beispiel #6
0
static void handle_message (DBusMessage *msg, struct cb_data *data)
{
    char *cb_decision_name;
    int found = 0, i = 0;

    struct transaction_data *trans_data = NULL;

    /* parse the message to ep_decision array */

    dbus_uint32_t    txid;
    char            *actname;

    DBusMessageIter  msgit;
    DBusMessageIter  arrit;
    DBusMessageIter  entit;
    DBusMessageIter  actit;
    DBusMessageIter  structit;
    DBusMessageIter  structfieldit;
    DBusMessageIter  variantit;

    int              success = TRUE;

    /* printf("libep: parsing the message\n"); */

    /**
     * This is really complicated and nasty. Idea is that the message is
     * supposed to look something like this:
     *
     * uint32 0
     * array [
     *    dict entry(
     *       string "com.nokia.policy.audio_route"
     *       array [
     *          array [
     *             struct {
     *                string "type"
     *                variant                      string "source"
     *             }
     *             struct {
     *                string "device"
     *                variant                      string "headset"
     *             }
     *          ]
     *          array [
     *             struct {
     *                string "type"
     *                variant                      string "sink"
     *             }
     *             struct {
     *                string "device"
     *                variant                      string "headset"
     *             }
     *          ]
     *       ]
     *    )
     * ]
     *
     */

    dbus_message_iter_init(msg, &msgit);

    if (dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_UINT32)
        return;

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

    if (txid != 0) {
        trans_data = calloc(1, sizeof(struct transaction_data));
        if (!trans_data)
            goto send_signal;
        trans_data->txid = txid;
        if (!ep_list_append(&transaction_list, trans_data)) {
            success = FALSE;
            goto send_signal;
        }
    }

    /* printf("libep: txid: %u\n", txid); */

    if (!dbus_message_iter_next(&msgit) ||
        dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_ARRAY) {
        success = FALSE;
        goto send_signal;
    }

    dbus_message_iter_recurse(&msgit, &arrit);

    do {
        if (dbus_message_iter_get_arg_type(&arrit) != DBUS_TYPE_DICT_ENTRY) {
            success = FALSE;
            continue;
        }

        dbus_message_iter_recurse(&arrit, &entit);

        do {
            struct ep_decision **decisions = NULL;
            struct ep_list_head_s decision_list;
            
            memset(&decision_list, 0, sizeof(struct ep_list_head_s));
    
            if (dbus_message_iter_get_arg_type(&entit) != DBUS_TYPE_STRING) {
                success = FALSE;
                continue;
            }
            
            dbus_message_iter_get_basic(&entit, (void *)&actname);
    
            /* printf("libep: decision set name '%s'\n", actname); */
            
            if (!dbus_message_iter_next(&entit) ||
                dbus_message_iter_get_arg_type(&entit) != DBUS_TYPE_ARRAY) {
                success = FALSE;
                continue;
            }
            
            dbus_message_iter_recurse(&entit, &actit);
            
            /* gather the decisions to the decision set */
            do {
                struct ep_decision *decision = calloc(1, sizeof(struct ep_decision));

                struct ep_list_head_s pair_list;
                memset(&pair_list, 0, sizeof(struct ep_list_head_s));

                if (dbus_message_iter_get_arg_type(&actit) != DBUS_TYPE_ARRAY) {
                    success = FALSE;
                    free(decision);
                    continue;
                }
                dbus_message_iter_recurse(&actit, &structit);

                /* gather the key-value pairs to the decision */
                do {
                    struct ep_key_value_pair *pair =
                        calloc(1, sizeof(struct ep_key_value_pair));
                    void *tmp = NULL;
                    char *key = NULL;

                    if (dbus_message_iter_get_arg_type(&structit) != DBUS_TYPE_STRUCT) {
                        success = FALSE;
                        free(pair);
                        continue;
                    }
                    dbus_message_iter_recurse(&structit, &structfieldit);

                    /* there are two fields inside the struct: one
                     * string and one variant */

                    if (dbus_message_iter_get_arg_type(&structfieldit) != DBUS_TYPE_STRING) {
                        success = FALSE;
                        free(pair);
                        continue;
                    }

                    dbus_message_iter_get_basic(&structfieldit, (void *)&key);
                    pair->key = strdup(key);
                    /* printf("libep:   key: '%s'\n", pair->key); */

                    if (!dbus_message_iter_next(&structfieldit)) {
                        success = FALSE;
                        free(pair);
                        continue;
                    }

                    if (dbus_message_iter_get_arg_type(&structfieldit) != DBUS_TYPE_VARIANT) {
                        success = FALSE;
                        free(pair);
                        continue;
                    }
                    dbus_message_iter_recurse(&structfieldit, &variantit);
                    dbus_message_iter_get_basic(&variantit, (void *)&tmp);
                    
                    switch (dbus_message_iter_get_arg_type(&variantit)) {
                        case DBUS_TYPE_INT32:
                            pair->value = malloc(sizeof(int));
                            memcpy(pair->value, &tmp, sizeof(int));
                            pair->type = EP_VALUE_INT;
                            /* printf("libep:   value (int)    '%i'\n",
                                    *(int *) pair->value); */
                            break;
                        case DBUS_TYPE_DOUBLE:
                            pair->value = malloc(sizeof(double));
                            memcpy(pair->value, &tmp, sizeof(double));
                            pair->type = EP_VALUE_FLOAT;
                            /* printf("libep:   value (float)  '%f'\n",
                                    *(float *) pair->value); */
                            break;
                        case DBUS_TYPE_STRING:
                            pair->value = strdup(tmp);
                            pair->type = EP_VALUE_STRING;
                            /* printf("libep:   value (string) '%s'\n",
                                    (char *) pair->value); */
                            break;
                        default:
                            /* printf("libep:   value is unknown D-Bus type '%i'\n", 
                                    dbus_message_iter_get_arg_type(&variantit)); */
                            break;
                    }
                    
                    ep_list_append(&pair_list, pair);

                } while (dbus_message_iter_next(&structit));

                decision->pairs =
                    (struct ep_key_value_pair **) ep_list_convert_to_array(&pair_list);
                ep_list_free_all(&pair_list);
                
                ep_list_append(&decision_list, decision);
            
            } while (dbus_message_iter_next(&entit));

            decisions = (struct ep_decision **) ep_list_convert_to_array(&decision_list);
            ep_list_free_all(&decision_list);

            /* count the callbacks if a transaction is needed */
            if (trans_data) {
                if (data->decision_names[0]) {
                    i = 0;
                    cb_decision_name = data->decision_names[i];
                    while (cb_decision_name) {
                        if (strcmp(cb_decision_name, actname) == 0) {
                            trans_data->refcount++;
#if 0
                            printf("libep: increased transaction data '%p' refcount to %u for name '%s'\n",
                                    trans_data, trans_data->refcount, cb_decision_name);
#endif
                        }
                        cb_decision_name = data->decision_names[++i];
                    }
                }
                else {
                    /* subscribe to all decisions */
                    trans_data->refcount++;
                }
            }

            if (data->decision_names[0]) {
                i = 0;
                cb_decision_name = data->decision_names[i];

                /* send the decisions */
                while (cb_decision_name) {
                    if (strcmp(cb_decision_name, actname) == 0) {
                        data->cb(actname, decisions, ep_ready, txid, data->user_data);
                        found = TRUE;
                    }
                    cb_decision_name = data->decision_names[++i];
                }
            }
            else {
                /* call the callback for all decisions */
                data->cb(actname, decisions, ep_ready, txid, data->user_data);
                found = TRUE;
            }
            
            free_decisions(decisions);

        } while (dbus_message_iter_next(&entit));

    } while (dbus_message_iter_next(&arrit));
    
    if (txid == 0) {
        /* no ack is needed, go to send_signal for cleanup */
        goto send_signal;
    }

    if (found) {

        /* It's possible that the callbacks have had errors, and the
         * NACK is already sent. In this case the transaction is already
         * removed from the list and freed. See if this is the case. */
        trans_data = ep_get_transaction(txid);
        if (!trans_data) {
            return;
        }

        /* the ACK signal is now ready to be sent */
        trans_data->ready = TRUE;
        send_if_done(trans_data);

#if 0
        printf("libep: signal handling success, waiting for callbacks\n");
#endif
        return; /* success */
    }

send_signal:

    /* no-one is interested or everything failed, just send the signal
     * and be done with it */

    /* TODO: free all memory */

    if (trans_data) {
        ep_list_remove(&transaction_list, trans_data);
        free(trans_data);
        trans_data = NULL;
    }

    /* printf("libep: not waiting for handlers to return, parsing %s a success\n",
            success ? "was" : "was not"); */

    send_signal(txid, success);
}
Beispiel #7
0
static void request_input_reply(DBusMessage *reply, void *user_data)
{
	struct request_input_reply *l2tp_reply = user_data;
	const char *error = NULL;
	char *username = NULL, *password = NULL;
	char *key;
	DBusMessageIter iter, dict;

	DBG("provider %p", l2tp_reply->provider);

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

	if (vpn_agent_check_reply_has_dict(reply) == FALSE)
		goto done;

	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;
		const char *str;

		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, "Username")) {
			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_STRING)
				break;
			dbus_message_iter_get_basic(&value, &str);
			username = g_strdup(str);
		}

		if (g_str_equal(key, "Password")) {
			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_STRING)
				break;
			dbus_message_iter_get_basic(&value, &str);
			password = g_strdup(str);
		}

		dbus_message_iter_next(&dict);
	}

done:
	l2tp_reply->callback(l2tp_reply->provider, username, password, error,
				l2tp_reply->user_data);

	g_free(username);
	g_free(password);

	g_free(l2tp_reply);
}
Beispiel #8
0
static DBusMessage *cf_set_property(DBusConnection *conn, DBusMessage *msg,
					void *data)
{
	struct ofono_call_forwarding *cf = data;
	struct ofono_modem *modem = __ofono_atom_get_modem(cf->atom);
	DBusMessageIter iter;
	DBusMessageIter var;
	const char *property;
	int cls;
	int type;

	if (ofono_modem_get_online(modem) == FALSE)
		return __ofono_error_not_available(msg);

	if (__ofono_call_forwarding_is_busy(cf) ||
			__ofono_ussd_is_busy(cf->ussd))
		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 (cf_condition_timeout_property(property, &cls)) {
		dbus_uint16_t timeout;
		GSList *l;
		struct ofono_call_forwarding_condition *c;

		type = CALL_FORWARDING_TYPE_NO_REPLY;

		if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_UINT16)
			return __ofono_error_invalid_args(msg);

		dbus_message_iter_get_basic(&var, &timeout);

		if (timeout < 1 || timeout > 30)
			return __ofono_error_invalid_format(msg);

		l = g_slist_find_custom(cf->cf_conditions[type],
				GINT_TO_POINTER(cls),
				cf_condition_find_with_cls);

		if (l == NULL)
			return __ofono_error_failed(msg);

		c = l->data;

		return set_property_request(cf, msg, type, cls,
						&c->phone_number, timeout);
	} else if (cf_condition_enabled_property(cf, property, &type, &cls)) {
		struct ofono_phone_number ph;
		const char *number;
		int timeout;

		ph.number[0] = '\0';
		ph.type = 129;

		if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
			return __ofono_error_invalid_args(msg);

		dbus_message_iter_get_basic(&var, &number);

		if (strlen(number) > 0 && !valid_phone_number_format(number))
			return __ofono_error_invalid_format(msg);

		if (number[0] != '\0')
			string_to_phone_number(number, &ph);

		timeout = cf_find_timeout(cf->cf_conditions[type], cls);

		return set_property_request(cf, msg, type, cls, &ph,
						timeout);
	}

	return __ofono_error_invalid_args(msg);
}
inline QVariant qIterGet(DBusMessageIter *it)
{
    DBusMessageIter sub;
    dbus_message_iter_recurse(it, &sub);
    return QDBusTypeHelper<QVariant>::toVariant(qFetchParameter(&sub));
}    
static int oc_notify(DBusMessage *msg, struct vpn_provider *provider)
{
	DBusMessageIter iter, dict;
	const char *reason, *key, *value;
	char *domain = NULL;
	char *addressv4 = NULL, *addressv6 = NULL;
	char *netmask = NULL, *gateway = NULL;
	unsigned char prefix_len = 0;
	struct connman_ipaddress *ipaddress;

	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, "connect"))
		return VPN_STATE_DISCONNECT;

	domain = g_strdup(vpn_provider_get_string(provider, "VPN.Domain"));

	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);

		if (strcmp(key, "CISCO_CSTP_OPTIONS"))
			DBG("%s = %s", key, value);

		if (!strcmp(key, "VPNGATEWAY"))
			gateway = g_strdup(value);

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

		if (!strcmp(key, "INTERNAL_IP6_ADDRESS")) {
			addressv6 = g_strdup(value);
			prefix_len = 128;
		}

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

		if (!strcmp(key, "INTERNAL_IP6_NETMASK")) {
			char *sep;

			/* The netmask contains the address and the prefix */
			sep = strchr(value, '/');
			if (sep != NULL) {
				unsigned char ip_len = sep - value;

				addressv6 = g_strndup(value, ip_len);
				prefix_len = (unsigned char)
						strtol(sep + 1, NULL, 10);
			}
		}

		if (!strcmp(key, "INTERNAL_IP4_DNS") ||
				!strcmp(key, "INTERNAL_IP6_DNS"))
			vpn_provider_set_nameservers(provider, value);

		if (!strcmp(key, "CISCO_PROXY_PAC"))
			vpn_provider_set_pac(provider, value);

		if (domain == NULL && !strcmp(key, "CISCO_DEF_DOMAIN")) {
			g_free(domain);
			domain = g_strdup(value);
		}

		if (g_str_has_prefix(key, "CISCO_SPLIT_INC") == TRUE ||
			g_str_has_prefix(key, "CISCO_IPV6_SPLIT_INC") == TRUE)
			vpn_provider_append_route(provider, key, value);

		dbus_message_iter_next(&dict);
	}

	DBG("%p %p", addressv4, addressv6);

	if (addressv4 != NULL)
		ipaddress = connman_ipaddress_alloc(AF_INET);
	else if (addressv6 != NULL)
		ipaddress = connman_ipaddress_alloc(AF_INET6);
	else
		ipaddress = NULL;

	if (ipaddress == NULL) {
		g_free(addressv4);
		g_free(addressv6);
		g_free(netmask);
		g_free(gateway);
		g_free(domain);

		return VPN_STATE_FAILURE;
	}

	if (addressv4 != NULL)
		connman_ipaddress_set_ipv4(ipaddress, addressv4,
						netmask, gateway);
	else
		connman_ipaddress_set_ipv6(ipaddress, addressv6,
						prefix_len, gateway);
	vpn_provider_set_ipaddress(provider, ipaddress);
	vpn_provider_set_domain(provider, domain);

	g_free(addressv4);
	g_free(addressv6);
	g_free(netmask);
	g_free(gateway);
	g_free(domain);
	connman_ipaddress_free(ipaddress);

	return VPN_STATE_CONNECT;
}
Beispiel #11
0
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 void request_input_cookie_reply(DBusMessage *reply, void *user_data)
{
	struct oc_private_data *data = user_data;
	char *cookie = NULL, *servercert = NULL, *vpnhost = NULL;
	char *key;
	DBusMessageIter iter, dict;

	DBG("provider %p", data->provider);

	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
		goto err;
	}

	if (vpn_agent_check_reply_has_dict(reply) == FALSE)
		goto err;

	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, "OpenConnect.Cookie")) {
			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_STRING)
				break;
			dbus_message_iter_get_basic(&value, &cookie);
			vpn_provider_set_string_hide_value(data->provider,
					key, cookie);

		} else if (g_str_equal(key, "OpenConnect.ServerCert")) {
			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_STRING)
				break;
			dbus_message_iter_get_basic(&value, &servercert);
			vpn_provider_set_string(data->provider, key,
					servercert);

		} else if (g_str_equal(key, "OpenConnect.VPNHost")) {
			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_STRING)
				break;
			dbus_message_iter_get_basic(&value, &vpnhost);
			vpn_provider_set_string(data->provider, key, vpnhost);
		}

		dbus_message_iter_next(&dict);
	}

	if (cookie == NULL || servercert == NULL || vpnhost == NULL)
		goto err;

	run_connect(data->provider, data->task, data->if_name, data->cb,
		data->user_data);

	free_private_data(data);

	return;

err:
	vpn_provider_indicate_error(data->provider,
			VPN_PROVIDER_ERROR_AUTH_FAILED);

	free_private_data(data);
}
Beispiel #13
0
static vlc_keystore_entry*
kwallet_read_password_list( vlc_keystore* p_keystore, char* psz_entry_name,
                            unsigned int* pi_count )
{
    vlc_keystore_sys* p_sys = p_keystore->p_sys;
    DBusMessage* msg = NULL;
    DBusMessage* repmsg = NULL;
    DBusMessageIter args;
    DBusMessageIter sub_iter;
    DBusMessageIter dict_iter;
    DBusMessageIter var_iter;
    vlc_keystore_entry* p_entries = NULL;
    size_t i_size;
    uint8_t* p_secret_decoded;
    char* p_reply;
    char* p_secret;
    int i = 0;

    /* init */
    *pi_count = 0;
    if ( !( msg = vlc_dbus_new_method( p_keystore, "readPasswordList" ) ) )
    {
        msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_new_method failed" );
        goto error;
    }

    /* argument init */
    dbus_message_iter_init_append( msg, &args );
    if ( !dbus_message_iter_append_basic( &args, DBUS_TYPE_INT32, &p_sys->i_handle ) ||
         !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_folder ) ||
         !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_entry_name ) ||
         !dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &p_sys->psz_app_id ) )
        goto error;

    /* sending message */
    if ( !( repmsg = vlc_dbus_send_message( p_keystore, msg ) ) )
    {
        msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_send_message failed" );
        goto error;
    }

    /* handling reply */
    if ( !dbus_message_iter_init( repmsg, &args ) )
    {
        msg_Err( p_keystore, "kwallet_read_password_list : Message has no arguments" );
        goto error;
    }
    else if ( dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY )
    {
        msg_Err( p_keystore, "kwallet_read_password_list : Wrong reply type" );
        goto error;
    }
    else
    {
        /* calculating p_entries's size */
        dbus_message_iter_recurse( &args, &sub_iter );
        do
        {
            if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY )
                continue;
            dbus_message_iter_recurse( &sub_iter, &dict_iter );
            if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING )
                continue;
            dbus_message_iter_next(&dict_iter);
            if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT )
                continue;
            ++( *pi_count );
       } while ( dbus_message_iter_next( &sub_iter ) );

        if ( *pi_count == 0 )
            goto error;
        if ( !( p_entries = calloc( *pi_count, sizeof( vlc_keystore_entry ) ) ) )
            goto error;

        dbus_message_iter_init( repmsg, &args );
        /* recurse into the reply array */
        dbus_message_iter_recurse( &args, &sub_iter );
        do
        {
            if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY )
            {
                msg_Err( p_keystore, "Wrong type not DBUS_TYPE_DICT_ENTRY" );
                continue;
            }
            /* recurse into the dict-entry in the array */
            dbus_message_iter_recurse( &sub_iter, &dict_iter );
            if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING )
            {
                msg_Err( p_keystore, "First type of Dict-Entry is not a string" );
                continue;
            }
            dbus_message_iter_get_basic( &dict_iter, &p_reply );
            dbus_message_iter_next(&dict_iter);
            if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT )
            {
                msg_Err( p_keystore, "Second type of Dict-Entry is not a variant" );
                continue;
            }
            /* recurse into the variant in the dict-entry */
            dbus_message_iter_recurse( &dict_iter, &var_iter );
            dbus_message_iter_get_basic( &var_iter, &p_secret );

            i_size = vlc_b64_decode_binary( &p_secret_decoded, p_secret);
            if ( key2values( p_reply, &p_entries[i] ) )
                goto error;
            if ( ( vlc_keystore_entry_set_secret( &p_entries[i],
                                                  p_secret_decoded,
                                                  i_size ) ) )
                goto error;

            free(p_secret_decoded);
            i += 1;
        } while ( dbus_message_iter_next( &sub_iter ) );
    }

    dbus_message_unref( msg );
    dbus_message_unref( repmsg );

    return p_entries;

error:
    *pi_count = 0;
    vlc_keystore_release_entries( p_entries, i );
    if ( msg )
        dbus_message_unref( msg );
    if ( repmsg )
        dbus_message_unref( repmsg );
    return NULL;
}
Beispiel #14
0
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.locale1",
                        "/org/freedesktop/locale1",
                        "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;
        }

        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);
        strv_free(info.locale);
        return 0;
}
Beispiel #15
0
/*id的范围是1至ACIPLIST_NUM-1*/
int show_ac_ip_list_one_cmd(int instance_id,char *id, DCLI_AC_IP_LIST_API_GROUP **IPLIST)/*返回0表示失败,返回1表示成功,返回-1表示unknown id format*/
																							   /*返回-2表示AC IP LIST id should be 1 to ACIPLIST_NUM-1*/
									                                             			   /*返回-3表示id does not exist,返回-4表示error*/
{	
	if(NULL == id)
	{
		*IPLIST = NULL;
		return 0;
	}
	
	int ret;
	unsigned char ID = 0;
#if 0	
	int i = 0;
	unsigned int num = 0;
	struct wid_ac_ip **iplist;
	
	char en[] = "enable";
	char dis[] = "disable";
	
	DBusMessage *query, *reply;	
	DBusMessageIter	 iter;
	DBusMessageIter	 iter_array;
	DBusError err;
#endif	
	int retu;
	
	ret = parse_char_ID((char*)id, &ID);
	if(ret != WID_DBUS_SUCCESS){
		return -1;
	}	
	if(ID >= ACIPLIST_NUM || ID == 0){
		return -2;
	}

	int index;
#if 0	
	char BUSNAME[PATH_LEN];
	char OBJPATH[PATH_LEN];
	char INTERFACE[PATH_LEN];
#endif

	/*if(vty->node == CONFIG_NODE){
		index = 0;
	}else if(vty->node == HANSI_NODE){
		index = vty->index;
	}*/
	index = instance_id;
#if 0	
	ReInitDbusPath(index,WID_DBUS_BUSNAME,BUSNAME);
	ReInitDbusPath(index,WID_DBUS_ACIPLIST_OBJPATH,OBJPATH);
	ReInitDbusPath(index,WID_DBUS_ACIPLIST_INTERFACE,INTERFACE);
	query = dbus_message_new_method_call(BUSNAME,OBJPATH,INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST_ONE);

/*	query = dbus_message_new_method_call(WID_DBUS_BUSNAME,WID_DBUS_ACIPLIST_OBJPATH,\
						WID_DBUS_ACIPLIST_INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST_ONE);*/
	dbus_error_init(&err);

	dbus_message_append_args(query,
							 DBUS_TYPE_BYTE,&ID,
							 DBUS_TYPE_INVALID);

	reply = dbus_connection_send_with_reply_and_block (dcli_dbus_connection,query,-1, &err);
	
	dbus_message_unref(query);
	
	if (NULL == reply) {
		vty_out(vty,"<error> failed get reply.\n");
		if (dbus_error_is_set(&err)) {
			vty_out(vty,"%s raised: %s",err.name,err.message);
			dbus_error_free(&err);
		}
		return CMD_SUCCESS;
	}

	
	dbus_message_iter_init(reply,&iter);
	dbus_message_iter_get_basic(&iter,&ret);
	
	if(ret == 0 )
	{	
		AC_IP_LIST = (wid_ac_ip_group *)malloc(sizeof(wid_ac_ip_group));
		dbus_message_iter_next(&iter);	
		dbus_message_iter_get_basic(&iter,&AC_IP_LIST->GroupID);
		
		dbus_message_iter_next(&iter);	
		dbus_message_iter_get_basic(&iter,&AC_IP_LIST->ifname);
		
		dbus_message_iter_next(&iter);	
		dbus_message_iter_get_basic(&iter,&num);
		
		iplist = malloc(num* sizeof(struct wid_ac_ip *));
		memset(iplist, 0, num*sizeof(struct wid_ac_ip*));
		dbus_message_iter_next(&iter);	
		dbus_message_iter_recurse(&iter,&iter_array);
		
		for (i = 0; i < num; i++) {
			DBusMessageIter iter_struct;
			
			iplist[i] = (struct wid_ac_ip *)malloc(sizeof(struct wid_ac_ip));
			
			dbus_message_iter_recurse(&iter_array,&iter_struct);
		
			dbus_message_iter_get_basic(&iter_struct,&(iplist[i]->ip));

			dbus_message_iter_next(&iter_struct);	
			dbus_message_iter_get_basic(&iter_struct,&(iplist[i]->priority));
		
			dbus_message_iter_next(&iter_array);
		}
	}
		
	dbus_message_unref(reply);
#endif

	void*(*dcli_init_func)(
						int ,
						unsigned char ,
						unsigned int ,
						unsigned int* ,
						unsigned char *,
						DBusConnection *,
						char *
						);

	*IPLIST = NULL;
	if(NULL != ccgi_dl_handle)
	{
		dcli_init_func = dlsym(ccgi_dl_handle,"dcli_ac_ip_list_show_api_group");
		if(NULL != dcli_init_func)
		{
			*IPLIST =(*dcli_init_func)
				  (
					  index,
					  ID,
					  0,
					  &ret,
					  0,
					  ccgi_dbus_connection,
					  WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST_ONE
				  );
		}
		else
		{
			return 0;
		}
	}
	else
	{
		return 0;
	}	
	
	if(ret == -1)
	{
		retu = 0;
	}
	if((ret == 0)&&(*IPLIST))
	{
		retu = 1;
	}
	else if(ret == WID_EBR_NOT_EXIST)
	{
		retu = -3;
	}
	else 
	{	
		retu = -4;
	}
	
	return retu;
}
static QVariant qFetchParameter(DBusMessageIter *it)
{
    switch (dbus_message_iter_get_arg_type(it)) {
    case DBUS_TYPE_BYTE:
        return qVariantFromValue(qIterGet<unsigned char>(it));
    case DBUS_TYPE_INT16:
	return qVariantFromValue(qIterGet<dbus_int16_t>(it));
    case DBUS_TYPE_UINT16:
	return qVariantFromValue(qIterGet<dbus_uint16_t>(it));
    case DBUS_TYPE_INT32:
        return qIterGet<dbus_int32_t>(it);
    case DBUS_TYPE_UINT32:
        return qIterGet<dbus_uint32_t>(it);
    case DBUS_TYPE_DOUBLE:
        return qIterGet<double>(it);
    case DBUS_TYPE_BOOLEAN:
        return bool(qIterGet<dbus_bool_t>(it));
    case DBUS_TYPE_INT64:
        return static_cast<qlonglong>(qIterGet<dbus_int64_t>(it));
    case DBUS_TYPE_UINT64:
        return static_cast<qulonglong>(qIterGet<dbus_uint64_t>(it));
    case DBUS_TYPE_STRING:
    case DBUS_TYPE_OBJECT_PATH:
    case DBUS_TYPE_SIGNATURE:
        return QString::fromUtf8(qIterGet<char *>(it));
    case DBUS_TYPE_VARIANT:
        return qIterGet<QVariant>(it);
    case DBUS_TYPE_ARRAY: {
        int arrayType = dbus_message_iter_get_element_type(it);
        switch (arrayType)
        {
        case DBUS_TYPE_BYTE: {
            // QByteArray
            DBusMessageIter sub;
	    dbus_message_iter_recurse(it, &sub);
	    int len = dbus_message_iter_get_array_len(&sub);
	    char* data;
	    dbus_message_iter_get_fixed_array(&sub,&data,&len);
	    return QByteArray(data,len);
        }
        case DBUS_TYPE_INT16:
            return qFetchList<dbus_int16_t, short>(it);
        case DBUS_TYPE_UINT16:
            return qFetchList<dbus_uint16_t, ushort>(it);
        case DBUS_TYPE_INT32:
            return qFetchList<dbus_int32_t, int>(it);
        case DBUS_TYPE_UINT32:
            return qFetchList<dbus_uint32_t, uint>(it);
        case DBUS_TYPE_BOOLEAN:
            return qFetchList<dbus_bool_t, bool>(it);
        case DBUS_TYPE_DOUBLE:
            return qFetchList<double, double>(it);
        case DBUS_TYPE_INT64:
            return qFetchList<dbus_int64_t, qlonglong>(it);
        case DBUS_TYPE_UINT64:
            return qFetchList<dbus_uint64_t, qulonglong>(it);
        case DBUS_TYPE_STRING:
        case DBUS_TYPE_OBJECT_PATH:
        case DBUS_TYPE_SIGNATURE:
            return qFetchStringList(it);
        case DBUS_TYPE_VARIANT:
            return qFetchList<QVariant, QVariant>(it);
        case DBUS_TYPE_DICT_ENTRY: {
            // ### support other types of maps?
            QMap<QString, QVariant> map;
            DBusMessageIter sub;
            
            dbus_message_iter_recurse(it, &sub);
            if (dbus_message_iter_get_array_len(&sub) == 0)
                // empty map
                return map;
            
            do {
                DBusMessageIter itemIter;
                dbus_message_iter_recurse(&sub, &itemIter);
                Q_ASSERT(dbus_message_iter_has_next(&itemIter));
                QString key = qFetchParameter(&itemIter).toString();
                dbus_message_iter_next(&itemIter);
                map.insertMulti(key, qFetchParameter(&itemIter));
            } while (dbus_message_iter_next(&sub));
            return map;
        }
        }
    }
    // fall through
    // common handling for structs and lists of lists (for now)
    case DBUS_TYPE_STRUCT: {
        QList<QVariant> list;
        DBusMessageIter sub;
        dbus_message_iter_recurse(it, &sub);
        if (dbus_message_iter_get_array_len(&sub) == 0)
            return list;
        do {
            list.append(qFetchParameter(&sub));
        } while (dbus_message_iter_next(&sub));
        return list;
    }

    default:
        qWarning("Don't know how to handle type %d '%c'", dbus_message_iter_get_arg_type(it), dbus_message_iter_get_arg_type(it));
        return QVariant();
        break;
    }
}
Beispiel #17
0
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);

		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);

	} 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);
}
Beispiel #18
0
static int ov_notify(DBusMessage *msg, struct connman_provider *provider)
{
	DBusMessageIter iter, dict;
	const char *reason, *key, *value;
	char *nameservers = NULL;
	char *address = NULL, *gateway = NULL, *peer = NULL;
	struct connman_ipaddress *ipaddress;

	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, "up"))
		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, "trusted_ip")) {
			connman_provider_set_string(provider, "Gateway", value);
			gateway = g_strdup(value);
		}

		if (!strcmp(key, "ifconfig_local")) {
			connman_provider_set_string(provider, "Address", value);
			address = g_strdup(value);
		}

		if (!strcmp(key, "ifconfig_remote")) {
			connman_provider_set_string(provider, "Peer", value);
			peer = g_strdup(value);
		}

		if (g_str_has_prefix(key, "route_") == TRUE)
			connman_provider_append_route(provider, key, value);

		ov_append_dns_entries(key, value, &nameservers);

		dbus_message_iter_next(&dict);
	}

	ipaddress = connman_ipaddress_alloc(AF_INET);
	if (ipaddress == NULL) {
		g_free(nameservers);
		g_free(address);
		g_free(gateway);
		g_free(peer);

		return VPN_STATE_FAILURE;
	}

	connman_ipaddress_set_ipv4(ipaddress, address, NULL, gateway);
	connman_ipaddress_set_peer(ipaddress, peer);
	connman_provider_set_ipaddress(provider, ipaddress);

	connman_provider_set_nameservers(provider, nameservers);

	g_free(nameservers);
	g_free(address);
	g_free(gateway);
	g_free(peer);
	connman_ipaddress_free(ipaddress);

	return VPN_STATE_CONNECT;
}
Beispiel #19
0
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")) {
			vpn_provider_set_string(provider, "Address", value);
			addressv4 = g_strdup(value);
		}

		if (!strcmp(key, "INTERNAL_IP4_NETMASK")) {
			vpn_provider_set_string(provider, "Netmask", value);
			netmask = g_strdup(value);
		}

		if (!strcmp(key, "INTERNAL_IP4_DNS")) {
			vpn_provider_set_string(provider, "DNS", value);
			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 != NULL)
		ipaddress = connman_ipaddress_alloc(AF_INET);

	g_free(ifname);

	if (ipaddress == NULL) {
		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 != NULL) {
		vpn_provider_set_string(provider, "Gateway", value);
		gateway = g_strdup(value);
	}

	if (addressv4 != NULL)
		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;
}
Beispiel #20
0
GList *
systemd_unit_listall(void)
{
    int nfiles = 0;
    GList *units = NULL;
    DBusMessageIter args;
    DBusMessageIter unit;
    DBusMessageIter elem;
    DBusMessage *reply = NULL;

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

/*
        "  <method name=\"ListUnitFiles\">\n"                               \
        "   <arg name=\"files\" type=\"a(ss)\" direction=\"out\"/>\n" \
        "  </method>\n"                                                 \
*/

    reply = systemd_call_simple_method("ListUnitFiles");
    if (reply == NULL) {
        return NULL;
    }
    if (!dbus_message_iter_init(reply, &args)) {
        crm_err("Could not list systemd unit files: systemd reply has no arguments");
        dbus_message_unref(reply);
        return NULL;
    }
    if (!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY,
                              __FUNCTION__, __LINE__)) {
        crm_err("Could not list systemd unit files: systemd reply has invalid arguments");
        dbus_message_unref(reply);
        return NULL;
    }

    dbus_message_iter_recurse(&args, &unit);
    for (; dbus_message_iter_get_arg_type(&unit) != DBUS_TYPE_INVALID;
        dbus_message_iter_next(&unit)) {

        DBusBasicValue value;
        const char *match = NULL;
        char *unit_name = NULL;
        char *basename = NULL;

        if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_STRUCT, __FUNCTION__, __LINE__)) {
            crm_debug("ListUnitFiles reply has unexpected type");
            continue;
        }

        dbus_message_iter_recurse(&unit, &elem);
        if(!pcmk_dbus_type_check(reply, &elem, DBUS_TYPE_STRING, __FUNCTION__, __LINE__)) {
            crm_debug("ListUnitFiles reply does not contain a string");
            continue;
        }

        dbus_message_iter_get_basic(&elem, &value);
        if (value.str == NULL) {
            crm_debug("ListUnitFiles reply did not provide a string");
            continue;
        }
        crm_trace("DBus ListUnitFiles listed: %s", value.str);

        match = systemd_unit_extension(value.str);
        if (match == NULL) {
            // Unit files always have an extension, so skip if not present
            crm_debug("ListUnitFiles entry '%s' does not have an extension",
                      value.str);
            continue;
        }

        // ListUnitFiles returns full path names
        basename = strrchr(value.str, '/');
        if (basename) {
            basename = basename + 1;
        } else {
            basename = value.str;
        }

        /* Unit files will include types (such as .target) that we can't manage,
         * so filter the replies here.
         */
        if (!strcmp(match, ".service")) {
            // Service is the "default" unit type, so strip it
            unit_name = strndup(basename, match - basename);

        } else if (!strcmp(match, ".mount")
                   || !strcmp(match, ".socket")) {
            unit_name = strdup(basename);
        }
        if (unit_name == NULL) {
            crm_trace("ListUnitFiles entry '%s' is not manageable",
                      value.str);
            continue;
        }

        nfiles++;
        units = g_list_prepend(units, unit_name);
    }

    dbus_message_unref(reply);

    crm_trace("Found %d manageable systemd unit files", nfiles);
    units = g_list_sort(units, crm_alpha_sort);
    return units;
}
DBusHandlerResult avahi_service_resolver_event (AvahiClient *client, AvahiResolverEvent event, DBusMessage *message) {
    AvahiServiceResolver *r = NULL;
    DBusError error;
    const char *path;
    AvahiStringList *strlst = NULL;

    assert(client);
    assert(message);
    
    dbus_error_init (&error);

    if (!(path = dbus_message_get_path(message)))
        goto fail;

    for (r = client->service_resolvers; r; r = r->service_resolvers_next)
        if (strcmp (r->path, path) == 0)
            break;

    if (!r)
        goto fail;

    switch (event) {
        case AVAHI_RESOLVER_FOUND: {
            int j;
            int32_t interface, protocol, aprotocol;
            uint32_t flags;
            char *name, *type, *domain, *host, *address;
            uint16_t port;
            DBusMessageIter iter, sub;
            AvahiAddress a;
            
            if (!dbus_message_get_args(
                    message, &error,
                    DBUS_TYPE_INT32, &interface,
                    DBUS_TYPE_INT32, &protocol,
                    DBUS_TYPE_STRING, &name,
                    DBUS_TYPE_STRING, &type,
                    DBUS_TYPE_STRING, &domain,
                    DBUS_TYPE_STRING, &host,
                    DBUS_TYPE_INT32, &aprotocol,
                    DBUS_TYPE_STRING, &address,
                    DBUS_TYPE_UINT16, &port,
                    DBUS_TYPE_INVALID) ||
                dbus_error_is_set (&error)) {
            
                fprintf(stderr, "Failed to parse resolver event.\n");
                goto fail;
            }
        
            dbus_message_iter_init(message, &iter);
        
            for (j = 0; j < 9; j++)
                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_ARRAY) {
                fprintf(stderr, "Error parsing service resolving message\n");
                goto fail;
            }
        
            strlst = NULL;
            dbus_message_iter_recurse(&iter, &sub);
        
            for (;;) {
                DBusMessageIter sub2;
                int at;
                const uint8_t *k;
                int n;
            
                if ((at = dbus_message_iter_get_arg_type(&sub)) == DBUS_TYPE_INVALID)
                    break;
            
                assert(at == DBUS_TYPE_ARRAY);
            
                if (dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_BYTE) {
                    fprintf(stderr, "Error parsing service resolving message\n");
                    goto fail;
                }
            
                dbus_message_iter_recurse(&sub, &sub2);

                k = NULL; n = 0;
                dbus_message_iter_get_fixed_array(&sub2, &k, &n);
                if (k && n > 0)
                    strlst = avahi_string_list_add_arbitrary(strlst, k, n);
            
                dbus_message_iter_next(&sub);
            }

            dbus_message_iter_next(&iter);

            if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) {
                fprintf(stderr, "Failed to parse resolver event.\n");
                goto fail;
            }

            dbus_message_iter_get_basic(&iter, &flags);
                                    
            assert(address);

            if (address[0] == 0)
                address = NULL;
	    else
            	avahi_address_parse(address, (AvahiProtocol) aprotocol, &a);
    
            r->callback(r, (AvahiIfIndex) interface, (AvahiProtocol) protocol, AVAHI_RESOLVER_FOUND, name, type, domain, host, address ? &a : NULL, port, strlst, (AvahiLookupResultFlags) flags, r->userdata);
        
            avahi_string_list_free(strlst);
            break;
        }
            
        case AVAHI_RESOLVER_FAILURE: {
            char *etxt;
            
            if (!dbus_message_get_args(
                    message, &error,
                    DBUS_TYPE_STRING, &etxt,
                    DBUS_TYPE_INVALID) ||
                dbus_error_is_set (&error)) {
                fprintf(stderr, "Failed to parse resolver event.\n");
                goto fail;
            }
            
            avahi_client_set_errno(r->client, avahi_error_dbus_to_number(etxt));
            r->callback(r, r->interface, r->protocol, event, r->name, r->type, r->domain, NULL, NULL, 0, NULL, 0, r->userdata);
            break;
        }
    }

    return DBUS_HANDLER_RESULT_HANDLED;

    
fail:
    dbus_error_free (&error);
    avahi_string_list_free(strlst);
    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
int bridge_request_json_params_parse(bridge_request_t *self, DBusMessageIter *it,
				     struct json_object **result, const char **key)
{
	int ret;
	const char *unused;
	int type = dbus_message_iter_get_arg_type(it);

	*key = 0;
	*result = 0;
	switch (type) {
		case DBUS_TYPE_STRING:
		case DBUS_TYPE_SIGNATURE:
		case DBUS_TYPE_OBJECT_PATH: {
			char *value;
			dbus_message_iter_get_basic(it, &value);
			*result = json_object_new_string(value);
			break;
		}
		case DBUS_TYPE_UINT16:
		case DBUS_TYPE_UINT32:
		case DBUS_TYPE_UINT64: {
			uint64_t value = 0;
			dbus_message_iter_get_basic(it, &value);
			*result = json_object_new_int64(value);
			break;
		}
		case DBUS_TYPE_INT16:
		case DBUS_TYPE_INT32:
		case DBUS_TYPE_INT64:
		case DBUS_TYPE_BYTE: {
			int64_t value = 0;
			dbus_message_iter_get_basic(it, &value);
			*result = json_object_new_int64(value);
			break;
		}
		case DBUS_TYPE_DOUBLE: {
			double value;
			dbus_message_iter_get_basic(it, &value);
			*result = json_object_new_double(value);
			break;
		}
		case DBUS_TYPE_BOOLEAN: {
			int value;
			dbus_message_iter_get_basic(it, &value);
			*result = json_object_new_boolean(value);
			break;
		}
		case DBUS_TYPE_ARRAY:
		case DBUS_TYPE_STRUCT:
		case DBUS_TYPE_VARIANT: {
			DBusMessageIter args;
			dbus_message_iter_recurse(it, &args);
			ret = bridge_request_json_params(self,
				&args, result, ((type == DBUS_TYPE_ARRAY) || (type == DBUS_TYPE_STRUCT)));
			if (ret != 0)
				return ret;
			break;
		}
		case DBUS_TYPE_DICT_ENTRY: {
			DBusMessageIter args;
			dbus_message_iter_recurse(it, &args);
			if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING) {
				bridge_request_error(self,
					"dictionary with non-string keys not supported.");
				return EINVAL;
			}
			dbus_message_iter_get_basic(&args, key);
			if (!dbus_message_iter_has_next(&args))
				break;
			dbus_message_iter_next(&args);
			ret = bridge_request_json_params_parse(self, &args, result, &unused);
			if (ret != 0)
				return ret;
			break;
		}
		default:
			break;
	}
	if (!*result) {
		bridge_request_error(self,
			"Unexpected error while parsing D-Bus arguments.");
		FCGX_FPrintF(self->request.err, "arg: %i\n", dbus_message_iter_get_arg_type(it));
		return EINVAL;
	}
	return 0;
}
Beispiel #23
0
int __connman_session_create(DBusMessage *msg)
{
	const char *owner, *notify_path;
	char *session_path = NULL;
	DBusMessageIter iter, array;
	struct connman_session *session = NULL;
	struct user_config *user_config = NULL;
	connman_bool_t user_allowed_bearers = FALSE;
	connman_bool_t user_connection_type = FALSE;
	int err;

	owner = dbus_message_get_sender(msg);

	DBG("owner %s", owner);

	if (ecall_session != NULL && ecall_session->ecall == TRUE) {
		/*
		 * If there is an emergency call already going on,
		 * ignore session creation attempt
		 */
		err = -EBUSY;
		goto err;
	}

	user_config = g_try_new0(struct user_config, 1);
	if (user_config == NULL) {
		err = -ENOMEM;
		goto err;
	}

	user_config->pending = dbus_message_ref(msg);

	dbus_message_iter_init(msg, &iter);
	dbus_message_iter_recurse(&iter, &array);

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

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

		dbus_message_iter_next(&entry);
		dbus_message_iter_recurse(&entry, &value);

		switch (dbus_message_iter_get_arg_type(&value)) {
		case DBUS_TYPE_ARRAY:
			if (g_str_equal(key, "AllowedBearers") == TRUE) {
				err = parse_bearers(&value,
						&user_config->allowed_bearers);
				if (err < 0)
					goto err;

				user_allowed_bearers = TRUE;
			} else {
				err = -EINVAL;
				goto err;
			}
			break;
		case DBUS_TYPE_STRING:
			if (g_str_equal(key, "ConnectionType") == TRUE) {
				dbus_message_iter_get_basic(&value, &val);
				user_config->type =
					connman_session_parse_connection_type(val);

				user_connection_type = TRUE;
			} else {
				err = -EINVAL;
				goto err;
			}
		}
		dbus_message_iter_next(&array);
	}

	/*
	 * If the user hasn't provided a configuration, we set
	 * the default configuration.
	 *
	 * For AllowedBearers this is '*', ...
	 */
	if (user_allowed_bearers == FALSE) {
		user_config->allowed_bearers =
			g_slist_append(NULL,
				GINT_TO_POINTER(CONNMAN_SERVICE_TYPE_UNKNOWN));
		if (user_config->allowed_bearers == NULL) {
			err = -ENOMEM;
			goto err;
		}
	}

	/* ... and for ConnectionType it is 'any'. */
	if (user_connection_type == FALSE)
		user_config->type = CONNMAN_SESSION_TYPE_ANY;

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

	if (notify_path == NULL) {
		err = -EINVAL;
		goto err;
	}

	session_path = g_strdup_printf("/sessions%s", notify_path);
	if (session_path == NULL) {
		err = -ENOMEM;
		goto err;
	}

	session = g_hash_table_lookup(session_hash, session_path);
	if (session != NULL) {
		g_free(session_path);
		session = NULL;
		err = -EEXIST;
		goto err;
	}

	session = g_try_new0(struct connman_session, 1);
	if (session == NULL) {
		g_free(session_path);
		err = -ENOMEM;
		goto err;
	}

	session->session_path = session_path;

	session->info = g_try_new0(struct session_info, 1);
	if (session->info == NULL) {
		err = -ENOMEM;
		goto err;
	}

	session->info_last = g_try_new0(struct session_info, 1);
	if (session->info_last == NULL) {
		err = -ENOMEM;
		goto err;
	}

	session->owner = g_strdup(owner);
	session->notify_path = g_strdup(notify_path);
	session->notify_watch =
		g_dbus_add_disconnect_watch(connection, session->owner,
					owner_disconnect, session, NULL);

	err = assign_policy_plugin(session);
	if (err < 0)
		goto err;

	err = create_policy_config(session, session_create_cb, user_config);
	if (err < 0 && err != -EINPROGRESS)
		return err;

	return -EINPROGRESS;

err:
	connman_error("Failed to create session");

	free_session(session);

	cleanup_user_config(user_config);
	return err;
}
Beispiel #24
0
static void request_input_passphrase_reply(DBusPendingCall *call, void *user_data)
{
	struct request_input_reply *passphrase_reply = user_data;
	connman_bool_t wps = FALSE;
	char *identity = NULL;
	char *passphrase = NULL;
	char *wpspin = NULL;
	char *key;
	DBusMessageIter iter, dict;
	DBusMessage *reply = dbus_pending_call_steal_reply(call);

	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
		goto done;

	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;
		}
		dbus_message_iter_next(&dict);
	}

	if (wps == TRUE) {
		struct connman_network *network;

		network = __connman_service_get_network(
						passphrase_reply->service);
		if (network == NULL)
			goto done;

		connman_network_set_bool(network, "WiFi.UseWPS", wps);

		if (wpspin != NULL && strlen(wpspin) > 0)
			connman_network_set_string(network,
						"WiFi.PinWPS", wpspin);
		else
			connman_network_set_string(network,
						"WiFi.PinWPS", NULL);
	}

done:
	passphrase_reply->callback(passphrase_reply->service, identity,
				passphrase, passphrase_reply->user_data);
	connman_service_unref(passphrase_reply->service);
	dbus_message_unref(reply);
	g_free(passphrase_reply);
}
Beispiel #25
0
/**
 * 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);
				if (strcmp(key_ptr, "Interface") == 0)
				{
					if(dbus_message_iter_get_arg_type(&iter_prop) == DBUS_TYPE_STRING)
					{
						dbus_message_iter_get_basic(&iter_prop, &property_ptr);
						strncpy(device->interface, property_ptr, sizeof(device->interface));
						printf("networkmanager_device_get_property interface %s\n", property_ptr);
						set_Interface = 1;
					}
					else
						printf("networkmanager_device_properties Interface not DBUS_TYPE_STRING %i\n", dbus_message_iter_get_arg_type(&iter_prop));
				}
				else if(strcmp(key_ptr, "DeviceType") == 0)
				{
					if(dbus_message_iter_get_arg_type(&iter_prop) == DBUS_TYPE_UINT32)
					{
						dbus_message_iter_get_basic(&iter_prop, &device->type);
						printf("networkmanager_device_get_property DeviceType %i\n", device->type);
						set_Type = 1;
					}
					else
						printf("networkmanager_device_properties DeviceType not DBUS_TYPE_UINT32 %i\n", dbus_message_iter_get_arg_type(&iter_prop));
				}
				else if(strcmp(key_ptr, "State") == 0)
				{
					if(dbus_message_iter_get_arg_type(&iter_prop) == DBUS_TYPE_UINT32)
					{
						dbus_message_iter_get_basic(&iter_prop, &device->state);
						printf("networkmanager_device_get_property State %i\n", device->state);
						set_State = 1;
					}
					else
						printf("networkmanager_device_properties state not DBUS_TYPE_UINT32 %i\n", dbus_message_iter_get_arg_type(&iter_prop));
				}
			}
		}
		dbus_message_iter_next(&iter_array);
	}
	dbus_message_unref(msg);

	// store dbus path
	printf("networkmanager_device_properties device_property.dbus_path\n");
	device_property.dbus_path = device->dbus_device_path;

	printf("networkmanager_device_properties device_property.dbus_interface\n");
	if(device->type == 2)
		device_property.dbus_interface = "org.freedesktop.NetworkManager.Device.Wireless";
	else if(device->type == 1)
		device_property.dbus_interface = "org.freedesktop.NetworkManager.Device.Wired";
	else device_property.dbus_interface = "";

	// retrieve Hardware address property only for known device types
	if(device->type == 1 || device->type == 2)
	{
		printf("networkmanager_device_properties device->mac\n");
		device_property.dbus_property_name = "PermHwAddress";
		device_property.value_string = device->mac;
		device_property.value_string_len = sizeof(device->mac);
	}

	if(strlen(device_property.dbus_interface)>0)
	{
		if(!networkmanager_get_property(dbus_connection, &device_property))
			printf("qaul_network_device_get_by_interface get %s property error\n", device_property.dbus_property_name);
	}
	else
		printf("qaul_network_device_get_by_interface no supported type for Hardware MAC address\n");

	if(!set_Type)
		printf("networkmanager_device_properties Device type not set.\n");
	if(!set_Interface)
		printf("networkmanager_device_properties Interface name not set\n");
	if(!set_State)
		printf("networkmanager_device_properties Device state not set\n");

	return 1;
}
Beispiel #26
0
GList *
systemd_unit_listall(void)
{
    int lpc = 0;
    GList *units = NULL;
    DBusMessageIter args;
    DBusMessageIter unit;
    DBusMessageIter elem;
    DBusMessage *reply = NULL;

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

/*
        "  <method name=\"ListUnits\">\n"                               \
        "   <arg name=\"units\" type=\"a(ssssssouso)\" direction=\"out\"/>\n" \
        "  </method>\n"                                                 \
*/

    reply = systemd_call_simple_method("ListUnits");
    if (reply == NULL) {
        return NULL;
    }
    if (!dbus_message_iter_init(reply, &args)) {
        crm_err("Could not list systemd units: systemd reply has no arguments");
        dbus_message_unref(reply);
        return NULL;
    }
    if (!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY,
                              __FUNCTION__, __LINE__)) {
        crm_err("Could not list systemd units: systemd reply has invalid arguments");
        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("DBus ListUnits listed: %s", value.str);
        if(value.str) {
            const char *match = systemd_unit_extension(value.str);

            if (match) {
                char *unit_name;

                if (!strcmp(match, ".service")) {
                    /* service is the "default" unit type, so strip it */
                    unit_name = strndup(value.str, match - value.str);
                } else {
                    unit_name = strdup(value.str);
                }
                lpc++;
                units = g_list_append(units, unit_name);
            }
        }
        dbus_message_iter_next (&unit);
    }

    dbus_message_unref(reply);

    crm_trace("Found %d systemd services", lpc);
    return units;
}
Beispiel #27
0
/**
 * 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;
}
Beispiel #28
0
/*返回1时,调用Free_show_ac_ip_list()释放空间*/
int show_ac_ip_list_cmd(int instance_id,DCLI_AC_IP_LIST_API_GROUP **IPLIST)/*返回0表示失败,返回1表示成功*/
{	
	int ret;
#if 0
	int i = 0;
	int num = 0;
	wid_ac_ip_group *ACIPLIST[ACIPLIST_NUM];
	DBusMessage *query, *reply;	
	DBusMessageIter	 iter;
	DBusMessageIter	 iter_array;
	DBusError err;
	char en[] = "enable";
	char dis[] = "disable";	
#endif

	int retu;
	
	
	int index;
#if 0
	char BUSNAME[PATH_LEN];
	char OBJPATH[PATH_LEN];
	char INTERFACE[PATH_LEN];
#endif

	/*if(vty->node == CONFIG_NODE){
		index = 0;
	}else if(vty->node == HANSI_NODE){
		index = vty->index;
	}*/
	index = instance_id;
#if 0	
	ReInitDbusPath(index,WID_DBUS_BUSNAME,BUSNAME);
	ReInitDbusPath(index,WID_DBUS_ACIPLIST_OBJPATH,OBJPATH);
	ReInitDbusPath(index,WID_DBUS_ACIPLIST_INTERFACE,INTERFACE);
	query = dbus_message_new_method_call(BUSNAME,OBJPATH,INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST);

/*	query = dbus_message_new_method_call(WID_DBUS_BUSNAME,WID_DBUS_ACIPLIST_OBJPATH,\
						WID_DBUS_ACIPLIST_INTERFACE,WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST);*/
	dbus_error_init(&err);

	reply = dbus_connection_send_with_reply_and_block (dcli_dbus_connection,query,-1, &err);
	
	dbus_message_unref(query);
	
	if (NULL == reply) {
		vty_out(vty,"<error> failed get reply.\n");
		if (dbus_error_is_set(&err)) {
			vty_out(vty,"%s raised: %s",err.name,err.message);
			dbus_error_free(&err);
		}
		return CMD_SUCCESS;
	}

	
	dbus_message_iter_init(reply,&iter);
	dbus_message_iter_get_basic(&iter,&ret);
	
	if(ret == 0 )
	{	
		
		dbus_message_iter_next(&iter);	
		dbus_message_iter_get_basic(&iter,&num);
	
		dbus_message_iter_next(&iter);	
		dbus_message_iter_recurse(&iter,&iter_array);
		
		for (i = 0; i < num; i++) {
			DBusMessageIter iter_struct;
			
			ACIPLIST[i] = (wid_ac_ip_group *)malloc(sizeof(wid_ac_ip_group));
			
			dbus_message_iter_recurse(&iter_array,&iter_struct);
		
			dbus_message_iter_get_basic(&iter_struct,&(ACIPLIST[i]->GroupID));
		
			dbus_message_iter_next(&iter_struct);
			
			dbus_message_iter_get_basic(&iter_struct,&(ACIPLIST[i]->ifname));

			dbus_message_iter_next(&iter_array);
		}
	}
	
	dbus_message_unref(reply);
#endif

	void*(*dcli_init_func)(
						int ,
						unsigned char ,
						unsigned int ,
						unsigned int* ,
						unsigned char *,
						DBusConnection *,
						char *
						);

	*IPLIST = NULL;
	if(NULL != ccgi_dl_handle)
	{
		dcli_init_func = dlsym(ccgi_dl_handle,"dcli_ac_ip_list_show_api_group");
		if(NULL != dcli_init_func)
		{
			*IPLIST =(*dcli_init_func)
				  (
					  index,
					  0,
					  0,
					  &ret,
					  0,
					  ccgi_dbus_connection,
					  WID_DBUS_ACIPLIST_METHOD_SHOW_AC_IP_LIST
				  );
		}
		else
		{
			return 0;
		}
	}
	else
	{
		return 0;
	}	

	if(ret == -1)
	{
		retu = 0;
	}
	if((ret == 0)&&(*IPLIST))
	{
		retu = 1;
	}

	return retu;
}
Beispiel #29
0
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;
}
Beispiel #30
0
bool dp_unpack_pam_response(DBusMessage *msg, struct pam_data *pd, DBusError *dbus_error)
{
    DBusMessageIter iter;
    DBusMessageIter array_iter;
    DBusMessageIter struct_iter;
    DBusMessageIter sub_iter;
    int type;
    int len;
    const uint8_t *data;

    if (!dbus_message_iter_init(msg, &iter)) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response has no arguments.\n");
        return false;
    }

    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
        return false;
    }
    dbus_message_iter_get_basic(&iter, &(pd->pam_status));

    if (!dbus_message_iter_next(&iter)) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response has too few arguments.\n");
        return false;
    }

    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_UINT32) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
        return false;
    }
    dbus_message_iter_get_basic(&iter, &(pd->account_locked));

    if (!dbus_message_iter_next(&iter)) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response has too few arguments.\n");
        return false;
    }

    /* After this point will be an array of pam data */
    if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
        DEBUG(SSSDBG_CRIT_FAILURE,
              "Type was %c\n", (char)dbus_message_iter_get_arg_type(&iter));
        return false;
    }

    if (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
        DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
        return false;
    }

    dbus_message_iter_recurse(&iter, &array_iter);
    while (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_INVALID) {
        /* Read in a pam data struct */
        if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) {
            DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
            return false;
        }

        dbus_message_iter_recurse(&array_iter,  &struct_iter);

        /* PAM data struct contains a type and a byte-array of data */

        /* Get the pam data type */
        if (dbus_message_iter_get_arg_type(&struct_iter) != DBUS_TYPE_UINT32) {
            DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
            return false;
        }
        dbus_message_iter_get_basic(&struct_iter, &type);

        if (!dbus_message_iter_next(&struct_iter)) {
            DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
            return false;
        }

        /* Get the byte array */
        if (dbus_message_iter_get_arg_type(&struct_iter) != DBUS_TYPE_ARRAY ||
            dbus_message_iter_get_element_type(&struct_iter) != DBUS_TYPE_BYTE) {
            DEBUG(SSSDBG_CRIT_FAILURE, "pam response format error.\n");
            return false;
        }

        dbus_message_iter_recurse(&struct_iter, &sub_iter);
        dbus_message_iter_get_fixed_array(&sub_iter, &data, &len);

        if (pam_add_response(pd, type, len, data) != EOK) {
            DEBUG(SSSDBG_CRIT_FAILURE, "pam_add_response failed.\n");
            return false;
        }
        dbus_message_iter_next(&array_iter);
    }

    return true;
}