static GVariant * get_ip4_routes (void) { GVariantBuilder builder; GVariant *value; char *tmp; int i, size = 0; g_variant_builder_init (&builder, G_VARIANT_TYPE ("aau")); for (i = 1; i < 256; i++) { GVariantBuilder array; char buf[BUFLEN]; struct in_addr network; struct in_addr netmask; struct in_addr gateway = { 0, }; guint32 prefix, metric = 0; snprintf (buf, BUFLEN, "route_network_%d", i); tmp = getenv (buf); if (!tmp || strlen (tmp) < 1) break; if (inet_pton (AF_INET, tmp, &network) <= 0) { _LOGW ("Ignoring invalid static route address '%s'", tmp ? tmp : "NULL"); continue; } snprintf (buf, BUFLEN, "route_netmask_%d", i); tmp = getenv (buf); if (!tmp || inet_pton (AF_INET, tmp, &netmask) <= 0) { _LOGW ("Ignoring invalid static route netmask '%s'", tmp ? tmp : "NULL"); continue; } snprintf (buf, BUFLEN, "route_gateway_%d", i); tmp = getenv (buf); /* gateway can be missing */ if (tmp && (inet_pton (AF_INET, tmp, &gateway) <= 0)) { _LOGW ("Ignoring invalid static route gateway '%s'", tmp ? tmp : "NULL"); continue; } snprintf (buf, BUFLEN, "route_metric_%d", i); tmp = getenv (buf); /* metric can be missing */ if (tmp && strlen (tmp)) { long int tmp_metric; errno = 0; tmp_metric = strtol (tmp, NULL, 10); if (errno || tmp_metric < 0 || tmp_metric > G_MAXUINT32) { _LOGW ("Ignoring invalid static route metric '%s'", tmp); continue; } metric = (guint32) tmp_metric; } g_variant_builder_init (&array, G_VARIANT_TYPE ("au")); g_variant_builder_add_value (&array, g_variant_new_uint32 (network.s_addr)); prefix = nm_utils_ip4_netmask_to_prefix (netmask.s_addr); g_variant_builder_add_value (&array, g_variant_new_uint32 (prefix)); g_variant_builder_add_value (&array, g_variant_new_uint32 (gateway.s_addr)); g_variant_builder_add_value (&array, g_variant_new_uint32 (metric)); g_variant_builder_add_value (&builder, g_variant_builder_end (&array)); size++; } value = g_variant_builder_end (&builder); if (size > 0) return value; g_variant_unref (value); return NULL; }
static GVariant * dconf_dbus_to_gv (DBusMessageIter *iter, GError **error) { gint arg_type; arg_type = dbus_message_iter_get_arg_type (iter); switch (dbus_message_iter_get_arg_type (iter)) { case DBUS_TYPE_BOOLEAN: { dbus_bool_t value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_boolean (value); } case DBUS_TYPE_BYTE: { guchar value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_byte (value); } case DBUS_TYPE_INT16: { gint16 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_int16 (value); } case DBUS_TYPE_UINT16: { guint16 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_uint16 (value); } case DBUS_TYPE_INT32: { gint32 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_int32 (value); } case DBUS_TYPE_UINT32: { guint32 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_uint32 (value); } case DBUS_TYPE_INT64: { gint64 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_int64 (value); } case DBUS_TYPE_UINT64: { guint64 value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_uint64 (value); } case DBUS_TYPE_DOUBLE: { gdouble value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_double (value); } case DBUS_TYPE_STRING: { const gchar *value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_string (value); } case DBUS_TYPE_OBJECT_PATH: { const gchar *value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_object_path (value); } case DBUS_TYPE_SIGNATURE: { const gchar *value; dbus_message_iter_get_basic (iter, &value); return g_variant_new_signature (value); } case DBUS_TYPE_VARIANT: { GVariantBuilder *builder; GVariantClass class; DBusMessageIter sub; char *type; GVariant *val; dbus_message_iter_recurse (iter, &sub); class = dbus_message_iter_get_arg_type (iter); type = dbus_message_iter_get_signature (&sub); builder = g_variant_builder_new (G_VARIANT_TYPE_VARIANT); dbus_free (type); while (dbus_message_iter_get_arg_type (&sub)) { val = dconf_dbus_to_gv (&sub, error); if (val == NULL) { g_variant_builder_cancel (builder); goto fail; } g_variant_builder_add_value (builder, val); dbus_message_iter_next (&sub); } return g_variant_builder_end (builder); } case DBUS_TYPE_ARRAY: case DBUS_TYPE_STRUCT: case DBUS_TYPE_DICT_ENTRY: { GVariantBuilder *builder; GVariantClass class; DBusMessageIter sub; char *type; GVariant *val; dbus_message_iter_recurse (iter, &sub); class = dbus_message_iter_get_arg_type (iter); type = dbus_message_iter_get_signature (iter); builder = g_variant_builder_new (G_VARIANT_TYPE (type)); dbus_free (type); while (dbus_message_iter_get_arg_type (&sub)) { val = dconf_dbus_to_gv (&sub, error); if (val == NULL) { g_variant_builder_cancel (builder); goto fail; } g_variant_builder_add_value (builder, val); dbus_message_iter_next (&sub); } return g_variant_builder_end (builder); } default: g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_CONVERSION_FAILED, _("Error serializing D-Bus message to GVariant. Unsupported arg type `%c' (%d)"), arg_type, arg_type); goto fail; } g_assert_not_reached (); fail: return NULL; }
Variant::Variant(uint32_t value) : Variant(g_variant_new_uint32(value)) {}
static GVariant * parse_json (JsonNode *node, const GVariantType *type, GError **error) { const GVariantType *element_type; const gchar *str; if (!g_variant_type_is_definite (type)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Indefinite type '%.*s' is not supported", (int)g_variant_type_get_string_length (type), g_variant_type_peek_string (type)); return NULL; } if (g_variant_type_is_basic (type)) { if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_BOOLEAN, error)) return g_variant_new_boolean (json_node_get_boolean (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_byte (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int16 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint16 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int32 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint32 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_int64 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error)) return g_variant_new_uint64 (json_node_get_int (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, NULL)) return g_variant_new_double (json_node_get_int (node)); else if (check_type (node, JSON_NODE_VALUE, G_TYPE_DOUBLE, error)) return g_variant_new_double (json_node_get_double (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) return g_variant_new_string (json_node_get_string (node)); } else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) { str = json_node_get_string (node); if (g_variant_is_object_path (str)) return g_variant_new_object_path (str); else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Invalid object path '%s'", str); return NULL; } } } else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE)) { if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error)) { str = json_node_get_string (node); if (g_variant_is_signature (str)) return g_variant_new_signature (str); else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Invalid signature '%s'", str); return NULL; } } } else { parse_not_supported (type, error); } } else if (g_variant_type_is_variant (type)) { return parse_json_variant (node, error); } else if (g_variant_type_is_array (type)) { element_type = g_variant_type_element (type); if (g_variant_type_is_dict_entry (element_type)) return parse_json_dictionary (node, element_type, error); else return parse_json_array (node, element_type, error); } else if (g_variant_type_is_tuple (type)) { return parse_json_tuple (node, g_variant_type_first (type), error); } else { parse_not_supported (type, error); } return NULL; }
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { int cg_type = CG_NONE; struct dev_context *devc; const struct scope_config *model; devc = (sdi) ? sdi->priv : NULL; model = (devc) ? devc->model_config : NULL; if (!cg) { switch (key) { case SR_CONF_SCAN_OPTIONS: case SR_CONF_DEVICE_OPTIONS: return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts); case SR_CONF_TIMEBASE: *data = std_gvar_tuple_array(ARRAY_AND_SIZE(dlm_timebases)); return SR_OK; case SR_CONF_TRIGGER_SOURCE: if (!model) return SR_ERR_ARG; *data = g_variant_new_strv(*model->trigger_sources, model->num_trigger_sources); return SR_OK; case SR_CONF_TRIGGER_SLOPE: *data = g_variant_new_strv(ARRAY_AND_SIZE(dlm_trigger_slopes)); return SR_OK; case SR_CONF_NUM_HDIV: *data = g_variant_new_uint32(model->num_xdivs); return SR_OK; default: return SR_ERR_NA; } } if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; switch (key) { case SR_CONF_DEVICE_OPTIONS: if (cg_type == CG_ANALOG) *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_analog)); else if (cg_type == CG_DIGITAL) *data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_digital)); else *data = std_gvar_array_u32(NULL, 0); break; case SR_CONF_COUPLING: if (!cg) return SR_ERR_CHANNEL_GROUP; *data = g_variant_new_strv(*model->coupling_options, model->num_coupling_options); break; case SR_CONF_VDIV: if (!cg) return SR_ERR_CHANNEL_GROUP; *data = std_gvar_tuple_array(ARRAY_AND_SIZE(dlm_vdivs)); break; default: return SR_ERR_NA; } return SR_OK; }
/** * fwupd_remote_to_variant: * @self: A #FwupdRemote * * Creates a GVariant from the remote data. * * Returns: the GVariant, or %NULL for error * * Since: 1.0.0 **/ GVariant * fwupd_remote_to_variant (FwupdRemote *self) { FwupdRemotePrivate *priv = GET_PRIVATE (self); GVariantBuilder builder; g_return_val_if_fail (FWUPD_IS_REMOTE (self), NULL); /* create an array with all the metadata in */ g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); if (priv->id != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_REMOTE_ID, g_variant_new_string (priv->id)); } if (priv->username != NULL) { g_variant_builder_add (&builder, "{sv}", "Username", g_variant_new_string (priv->username)); } if (priv->password != NULL) { g_variant_builder_add (&builder, "{sv}", "Password", g_variant_new_string (priv->password)); } if (priv->title != NULL) { g_variant_builder_add (&builder, "{sv}", "Title", g_variant_new_string (priv->title)); } if (priv->agreement != NULL) { g_variant_builder_add (&builder, "{sv}", "Agreement", g_variant_new_string (priv->agreement)); } if (priv->checksum != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_CHECKSUM, g_variant_new_string (priv->checksum)); } if (priv->metadata_uri != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_URI, g_variant_new_string (priv->metadata_uri)); } if (priv->report_uri != NULL) { g_variant_builder_add (&builder, "{sv}", "ReportUri", g_variant_new_string (priv->report_uri)); } if (priv->firmware_base_uri != NULL) { g_variant_builder_add (&builder, "{sv}", "FirmwareBaseUri", g_variant_new_string (priv->firmware_base_uri)); } if (priv->priority != 0) { g_variant_builder_add (&builder, "{sv}", "Priority", g_variant_new_int32 (priv->priority)); } if (priv->kind != FWUPD_REMOTE_KIND_UNKNOWN) { g_variant_builder_add (&builder, "{sv}", "Type", g_variant_new_uint32 (priv->kind)); } if (priv->keyring_kind != FWUPD_KEYRING_KIND_UNKNOWN) { g_variant_builder_add (&builder, "{sv}", "Keyring", g_variant_new_uint32 (priv->keyring_kind)); } if (priv->mtime != 0) { g_variant_builder_add (&builder, "{sv}", "ModificationTime", g_variant_new_uint64 (priv->mtime)); } if (priv->filename_cache != NULL) { g_variant_builder_add (&builder, "{sv}", "FilenameCache", g_variant_new_string (priv->filename_cache)); } if (priv->filename_source != NULL) { g_variant_builder_add (&builder, "{sv}", "FilenameSource", g_variant_new_string (priv->filename_source)); } g_variant_builder_add (&builder, "{sv}", "Enabled", g_variant_new_boolean (priv->enabled)); g_variant_builder_add (&builder, "{sv}", "ApprovalRequired", g_variant_new_boolean (priv->approval_required)); return g_variant_new ("a{sv}", &builder); }
static gboolean ot_static_delta_builtin_generate (int argc, char **argv, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; GOptionContext *context; glnx_unref_object OstreeRepo *repo = NULL; context = g_option_context_new ("Generate static delta files"); if (!ostree_option_context_parse (context, generate_options, &argc, &argv, OSTREE_BUILTIN_FLAG_NONE, &repo, cancellable, error)) goto out; if (!ostree_ensure_repo_writable (repo, error)) goto out; if (argc >= 3 && opt_to_rev == NULL) opt_to_rev = argv[2]; if (argc < 3 && opt_to_rev == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "TO revision must be specified"); goto out; } else { const char *from_source; g_autofree char *from_resolved = NULL; g_autofree char *to_resolved = NULL; g_autofree char *from_parent_str = NULL; g_autoptr(GVariantBuilder) parambuilder = NULL; g_assert (opt_to_rev); if (opt_empty) { if (opt_from_rev) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Cannot specify both --empty and --from=REV"); goto out; } from_source = NULL; } else if (opt_from_rev == NULL) { from_parent_str = g_strconcat (opt_to_rev, "^", NULL); from_source = from_parent_str; } else { from_source = opt_from_rev; } if (from_source) { if (!ostree_repo_resolve_rev (repo, from_source, FALSE, &from_resolved, error)) goto out; } if (!ostree_repo_resolve_rev (repo, opt_to_rev, FALSE, &to_resolved, error)) goto out; parambuilder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); if (opt_min_fallback_size) g_variant_builder_add (parambuilder, "{sv}", "min-fallback-size", g_variant_new_uint32 (g_ascii_strtoull (opt_min_fallback_size, NULL, 10))); if (opt_max_bsdiff_size) g_variant_builder_add (parambuilder, "{sv}", "max-bsdiff-size", g_variant_new_uint32 (g_ascii_strtoull (opt_max_bsdiff_size, NULL, 10))); if (opt_max_chunk_size) g_variant_builder_add (parambuilder, "{sv}", "max-chunk-size", g_variant_new_uint32 (g_ascii_strtoull (opt_max_chunk_size, NULL, 10))); if (opt_disable_bsdiff) g_variant_builder_add (parambuilder, "{sv}", "bsdiff-enabled", g_variant_new_boolean (FALSE)); g_variant_builder_add (parambuilder, "{sv}", "verbose", g_variant_new_boolean (TRUE)); g_print ("Generating static delta:\n"); g_print (" From: %s\n", from_resolved ? from_resolved : "empty"); g_print (" To: %s\n", to_resolved); if (!ostree_repo_static_delta_generate (repo, OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR, from_resolved, to_resolved, NULL, g_variant_builder_end (parambuilder), cancellable, error)) goto out; } ret = TRUE; out: if (context) g_option_context_free (context); return ret; }
GVariant * nm_lldp_listener_get_neighbors (NMLldpListener *self) { GVariantBuilder array_builder, neigh_builder; GHashTableIter iter; NMLldpListenerPrivate *priv; LLDPNeighbor *neigh; char *dest_str = NULL; priv = NM_LLDP_LISTENER_GET_PRIVATE (self); if (priv->variant) goto out; g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aa{sv}")); g_hash_table_iter_init (&iter, priv->lldp_neighbors); while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &neigh)) { GHashTableIter val_iter; gpointer key, val; g_variant_builder_init (&neigh_builder, G_VARIANT_TYPE ("a{sv}")); g_variant_builder_add (&neigh_builder, "{sv}", NM_LLDP_ATTR_CHASSIS_ID_TYPE, g_variant_new_uint32 (neigh->chassis_id_type)); g_variant_builder_add (&neigh_builder, "{sv}", NM_LLDP_ATTR_CHASSIS_ID, g_variant_new_string (neigh->chassis_id)); g_variant_builder_add (&neigh_builder, "{sv}", NM_LLDP_ATTR_PORT_ID_TYPE, g_variant_new_uint32 (neigh->port_id_type)); g_variant_builder_add (&neigh_builder, "{sv}", NM_LLDP_ATTR_PORT_ID, g_variant_new_string (neigh->port_id)); switch (neigh->dest) { case SD_LLDP_DESTINATION_TYPE_NEAREST_BRIDGE: dest_str = NM_LLDP_DEST_NEAREST_BRIDGE; break; case SD_LLDP_DESTINATION_TYPE_NEAREST_NON_TPMR_BRIDGE: dest_str = NM_LLDP_DEST_NEAREST_NON_TPMR_BRIDGE; break; case SD_LLDP_DESTINATION_TYPE_NEAREST_CUSTOMER_BRIDGE: dest_str = NM_LLDP_DEST_NEAREST_CUSTOMER_BRIDGE; break; } if (dest_str) { g_variant_builder_add (&neigh_builder, "{sv}", NM_LLDP_ATTR_DESTINATION, g_variant_new_string (dest_str)); } g_hash_table_iter_init (&val_iter, neigh->tlvs); while (g_hash_table_iter_next (&val_iter, &key, &val)) { GValue *item = val; if (G_VALUE_HOLDS_STRING (item)) { g_variant_builder_add (&neigh_builder, "{sv}", key, g_variant_new_string (g_value_get_string (item))); } else if (G_VALUE_HOLDS_UINT (item)) { g_variant_builder_add (&neigh_builder, "{sv}", key, g_variant_new_uint32 (g_value_get_uint (item))); } } g_variant_builder_add (&array_builder, "a{sv}", &neigh_builder); } priv->variant = g_variant_ref_sink (g_variant_builder_end (&array_builder)); out: return priv->variant; }
/** * fwupd_result_to_data: * @result: A #FwupdResult * @type_string: The Gvariant type string, e.g. "{sa{sv}}" or "(a{sv})" * * Creates a GVariant from the result data. * * Returns: the GVariant, or %NULL for error * * Since: 0.7.0 **/ GVariant * fwupd_result_to_data (FwupdResult *result, const gchar *type_string) { FwupdResultPrivate *priv = GET_PRIVATE (result); GVariantBuilder builder; g_return_val_if_fail (FWUPD_IS_RESULT (result), NULL); g_return_val_if_fail (type_string != NULL, NULL); /* create an array with all the metadata in */ g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY); if (priv->guid != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_GUID, g_variant_new_string (priv->guid)); } if (priv->device_name != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_NAME, g_variant_new_string (priv->device_name)); } if (priv->device_vendor != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_VENDOR, g_variant_new_string (priv->device_vendor)); } if (priv->device_flags > 0) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_FLAGS, g_variant_new_uint64 (priv->device_flags)); } if (priv->device_created > 0) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_CREATED, g_variant_new_uint64 (priv->device_created)); } if (priv->device_modified > 0) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_MODIFIED, g_variant_new_uint64 (priv->device_modified)); } if (priv->update_id != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_ID, g_variant_new_string (priv->update_id)); } if (priv->device_description != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_DESCRIPTION, g_variant_new_string (priv->device_description)); } if (priv->update_filename != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_FILENAME, g_variant_new_string (priv->update_filename)); } if (priv->device_checksum != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_CHECKSUM, g_variant_new_string (priv->device_checksum)); g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_CHECKSUM_KIND, g_variant_new_uint32 (priv->device_checksum_kind)); } if (priv->update_license != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_LICENSE, g_variant_new_string (priv->update_license)); } if (priv->update_name != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_NAME, g_variant_new_string (priv->update_name)); } if (priv->update_error != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_ERROR, g_variant_new_string (priv->update_error)); } if (priv->update_state != FWUPD_UPDATE_STATE_UNKNOWN) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_STATE, g_variant_new_uint32 (priv->update_state)); } if (priv->device_provider != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_PROVIDER, g_variant_new_string (priv->device_provider)); } if (priv->update_size != 0) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_SIZE, g_variant_new_uint64 (priv->update_size)); } if (priv->update_trust_flags != 0) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_TRUST_FLAGS, g_variant_new_uint64 (priv->update_trust_flags)); } if (priv->update_summary != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_SUMMARY, g_variant_new_string (priv->update_summary)); } if (priv->update_description != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_DESCRIPTION, g_variant_new_string (priv->update_description)); } if (priv->update_checksum != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_CHECKSUM, g_variant_new_string (priv->update_checksum)); g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_CHECKSUM_KIND, g_variant_new_uint32 (priv->update_checksum_kind)); } if (priv->update_uri != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_URI, g_variant_new_string (priv->update_uri)); } if (priv->update_homepage != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_HOMEPAGE, g_variant_new_string (priv->update_homepage)); } if (priv->update_version != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_VERSION, g_variant_new_string (priv->update_version)); } if (priv->update_vendor != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_UPDATE_VENDOR, g_variant_new_string (priv->update_vendor)); } if (priv->device_version != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_VERSION, g_variant_new_string (priv->device_version)); } if (priv->device_version_lowest != NULL) { g_variant_builder_add (&builder, "{sv}", FWUPD_RESULT_KEY_DEVICE_VERSION_LOWEST, g_variant_new_string (priv->device_version_lowest)); } /* supported types */ if (g_strcmp0 (type_string, "{sa{sv}}") == 0) return g_variant_new ("{sa{sv}}", priv->device_id, &builder); if (g_strcmp0 (type_string, "(a{sv})") == 0) return g_variant_new ("(a{sv})", &builder); return NULL; }
static GVariant * gtk_application_impl_dbus_real_get_window_system_id (GtkApplicationImplDBus *dbus, GtkWindow *window) { return g_variant_new_uint32 (0); }
static guint gtk_application_impl_dbus_inhibit (GtkApplicationImpl *impl, GtkWindow *window, GtkApplicationInhibitFlags flags, const gchar *reason) { GtkApplicationImplDBus *dbus = (GtkApplicationImplDBus *) impl; GVariant *res; GError *error = NULL; guint cookie; static gboolean warned = FALSE; if (dbus->sm_proxy) { res = g_dbus_proxy_call_sync (dbus->sm_proxy, "Inhibit", g_variant_new ("(s@usu)", dbus->application_id, window ? gtk_application_impl_dbus_get_window_system_id (dbus, window) : g_variant_new_uint32 (0), reason, flags), G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, &error); if (res) { g_variant_get (res, "(u)", &cookie); g_variant_unref (res); return cookie; } if (error) { if (!warned) { g_warning ("Calling %s.Inhibit failed: %s", g_dbus_proxy_get_interface_name (dbus->sm_proxy), error->message); warned = TRUE; } g_clear_error (&error); } } else if (dbus->inhibit_proxy) { GVariantBuilder options; g_variant_builder_init (&options, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&options, "{sv}", "reason", g_variant_new_string (reason)); res = g_dbus_proxy_call_sync (dbus->inhibit_proxy, "Inhibit", g_variant_new ("(su@a{sv})", "", /* window */ flags, g_variant_builder_end (&options)), G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, &error); if (res) { InhibitHandle *handle; handle = g_new (InhibitHandle, 1); handle->cookie = ++next_cookie; g_variant_get (res, "(o)", &handle->handle); g_variant_unref (res); dbus->inhibit_handles = g_slist_prepend (dbus->inhibit_handles, handle); return handle->cookie; } if (error) { if (!warned) { g_warning ("Calling %s.Inhibit failed: %s", g_dbus_proxy_get_interface_name (dbus->inhibit_proxy), error->message); warned = TRUE; } g_clear_error (&error); } } return 0; }
GVariant * mm_bearer_properties_get_dictionary (MMBearerProperties *self) { GVariantBuilder builder; /* We do allow NULL */ if (!self) return NULL; g_return_val_if_fail (MM_IS_BEARER_PROPERTIES (self), NULL); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); if (self->priv->apn) g_variant_builder_add (&builder, "{sv}", PROPERTY_APN, g_variant_new_string (self->priv->apn)); if (self->priv->allowed_auth != MM_BEARER_ALLOWED_AUTH_UNKNOWN) g_variant_builder_add (&builder, "{sv}", PROPERTY_ALLOWED_AUTH, g_variant_new_uint32 (self->priv->allowed_auth)); if (self->priv->user) g_variant_builder_add (&builder, "{sv}", PROPERTY_USER, g_variant_new_string (self->priv->user)); if (self->priv->password) g_variant_builder_add (&builder, "{sv}", PROPERTY_PASSWORD, g_variant_new_string (self->priv->password)); if (self->priv->ip_type != MM_BEARER_IP_FAMILY_UNKNOWN) g_variant_builder_add (&builder, "{sv}", PROPERTY_IP_TYPE, g_variant_new_uint32 (self->priv->ip_type)); if (self->priv->number) g_variant_builder_add (&builder, "{sv}", PROPERTY_NUMBER, g_variant_new_string (self->priv->number)); if (self->priv->allow_roaming_set) g_variant_builder_add (&builder, "{sv}", PROPERTY_ALLOW_ROAMING, g_variant_new_boolean (self->priv->allow_roaming)); if (self->priv->rm_protocol) g_variant_builder_add (&builder, "{sv}", PROPERTY_RM_PROTOCOL, g_variant_new_uint32 (self->priv->rm_protocol)); return g_variant_ref_sink (g_variant_builder_end (&builder)); }
static gboolean generate_all_deltas (OstreeRepo *repo, GPtrArray **unwanted_deltas, GCancellable *cancellable, GError **error) { g_autoptr(GHashTable) all_refs = NULL; g_autoptr(GHashTable) all_deltas_hash = NULL; g_autoptr(GHashTable) wanted_deltas_hash = NULL; g_autoptr(GPtrArray) all_deltas = NULL; int i; GHashTableIter iter; gpointer key, value; g_autoptr(GVariantBuilder) parambuilder = NULL; g_autoptr(GVariant) params = NULL; int n_spawned_delta_generate = 0; g_autoptr(GMainContextPopDefault) context = NULL; g_autoptr(GPtrArray) ignore_patterns = g_ptr_array_new_with_free_func ((GDestroyNotify)g_pattern_spec_free); g_print ("Generating static deltas\n"); parambuilder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); /* Fall back for 1 meg files */ g_variant_builder_add (parambuilder, "{sv}", "min-fallback-size", g_variant_new_uint32 (1)); params = g_variant_ref_sink (g_variant_builder_end (parambuilder)); if (!ostree_repo_list_static_delta_names (repo, &all_deltas, cancellable, error)) return FALSE; wanted_deltas_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); all_deltas_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); for (i = 0; i < all_deltas->len; i++) g_hash_table_insert (all_deltas_hash, g_strdup (g_ptr_array_index (all_deltas, i)), NULL); if (!ostree_repo_list_refs (repo, NULL, &all_refs, cancellable, error)) return FALSE; context = flatpak_main_context_new_default (); if (opt_static_delta_ignore_refs != NULL) { for (i = 0; opt_static_delta_ignore_refs[i] != NULL; i++) g_ptr_array_add (ignore_patterns, g_pattern_spec_new (opt_static_delta_ignore_refs[i])); } g_hash_table_iter_init (&iter, all_refs); while (g_hash_table_iter_next (&iter, &key, &value)) { const char *ref = key; const char *commit = value; g_autoptr(GVariant) variant = NULL; g_autoptr(GVariant) parent_variant = NULL; g_autofree char *parent_commit = NULL; g_autofree char *grandparent_commit = NULL; gboolean ignore_ref = FALSE; if (g_str_has_prefix (ref, "app/") || g_str_has_prefix (ref, "runtime/")) { g_auto(GStrv) parts = g_strsplit (ref, "/", 4); for (i = 0; i < ignore_patterns->len; i++) { GPatternSpec *pattern = g_ptr_array_index(ignore_patterns, i); if (g_pattern_match_string (pattern, parts[1])) { ignore_ref = TRUE; break; } } } else if (g_str_has_prefix (ref, "appstream/")) { /* Old appstream branch deltas poorly, and most users handle the new format */ ignore_ref = TRUE; } else if (g_str_has_prefix (ref, "appstream2/")) { /* Always delta this */ ignore_ref = FALSE; } else { /* Ignore unknown ref types */ ignore_ref = FALSE; } if (ignore_ref) { g_debug ("Ignoring deltas for ref %s", ref); continue; } if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, commit, &variant, NULL)) { g_warning ("Couldn't load commit %s", commit); continue; } /* From empty */ if (!g_hash_table_contains (all_deltas_hash, commit)) { if (!spawn_delta_generation (context, &n_spawned_delta_generate, repo, params, ref, NULL, commit, error)) return FALSE; } /* Mark this one as wanted */ g_hash_table_insert (wanted_deltas_hash, g_strdup (commit), GINT_TO_POINTER (1)); parent_commit = ostree_commit_get_parent (variant); if (parent_commit != NULL && !ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, parent_commit, &parent_variant, NULL)) { g_warning ("Couldn't load parent commit %s", parent_commit); continue; } /* From parent */ if (parent_variant != NULL) { g_autofree char *from_parent = g_strdup_printf ("%s-%s", parent_commit, commit); if (!g_hash_table_contains (all_deltas_hash, from_parent)) { if (!spawn_delta_generation (context, &n_spawned_delta_generate, repo, params, ref, parent_commit, commit, error)) return FALSE; } /* Mark parent-to-current as wanted */ g_hash_table_insert (wanted_deltas_hash, g_strdup (from_parent), GINT_TO_POINTER (1)); /* We also want to keep around the parent and the grandparent-to-parent deltas * because otherwise these will be deleted immediately which may cause a race if * someone is currently downloading them. * However, there is no need to generate these if they don't exist. */ g_hash_table_insert (wanted_deltas_hash, g_strdup (parent_commit), GINT_TO_POINTER (1)); grandparent_commit = ostree_commit_get_parent (parent_variant); if (grandparent_commit != NULL) g_hash_table_insert (wanted_deltas_hash, g_strdup_printf ("%s-%s", grandparent_commit, parent_commit), GINT_TO_POINTER (1)); } } while (n_spawned_delta_generate > 0) g_main_context_iteration (context, TRUE); *unwanted_deltas = g_ptr_array_new_with_free_func (g_free); for (i = 0; i < all_deltas->len; i++) { const char *delta = g_ptr_array_index (all_deltas, i); if (!g_hash_table_contains (wanted_deltas_hash, delta)) g_ptr_array_add (*unwanted_deltas, g_strdup (delta)); } return TRUE; }
static guint gtk_application_impl_dbus_inhibit (GtkApplicationImpl *impl, GtkWindow *window, GtkApplicationInhibitFlags flags, const gchar *reason) { GtkApplicationImplDBus *dbus = (GtkApplicationImplDBus *) impl; GVariant *res; GError *error = NULL; guint cookie; if (dbus->sm_proxy == NULL) return 0; res = g_dbus_proxy_call_sync (dbus->sm_proxy, "Inhibit", g_variant_new ("(s@usu)", dbus->app_id, window ? gtk_application_impl_dbus_get_window_system_id (dbus, window) : g_variant_new_uint32 (0), reason, flags), G_DBUS_CALL_FLAGS_NONE, G_MAXINT, NULL, &error); if (error) { g_warning ("Calling Inhibit failed: %s", error->message); g_error_free (error); return 0; } g_variant_get (res, "(u)", &cookie); g_variant_unref (res); return cookie; }
static GVariant * trusted_remote_to_gvariant (void) { char *tmp; GVariant *val = NULL; const char *p; gboolean is_name = FALSE; tmp = getenv ("trusted_ip6"); if (tmp) { val = addr6_to_gvariant (tmp); if (val == NULL) { _LOGW ("failed to convert VPN gateway address '%s' (%d)", tmp, errno); return NULL; } return val; } tmp = getenv ("trusted_ip"); if (!tmp) tmp = getenv ("remote_1"); if (!tmp) { _LOGW ("did not receive remote gateway address"); return NULL; } /* Check if it seems to be a hostname */ p = tmp; while (*p) { if (*p != '.' && !isdigit (*p)) { is_name = TRUE; break; } p++; } /* Resolve a hostname if required. Only look for IPv4 addresses */ if (is_name) { struct in_addr addr; struct addrinfo hints; struct addrinfo *result = NULL, *rp; int err; addr.s_addr = 0; memset (&hints, 0, sizeof (hints)); hints.ai_family = AF_INET; hints.ai_flags = AI_ADDRCONFIG; err = getaddrinfo (tmp, NULL, &hints, &result); if (err != 0) { _LOGW ("failed to look up VPN gateway address '%s' (%d)", tmp, err); return NULL; } /* FIXME: so what if the name resolves to multiple IP addresses? We * don't know which one pptp decided to use so we could end up using a * different one here, and the VPN just won't work. */ for (rp = result; rp; rp = rp->ai_next) { if ( (rp->ai_family == AF_INET) && (rp->ai_addrlen == sizeof (struct sockaddr_in))) { struct sockaddr_in *inptr = (struct sockaddr_in *) rp->ai_addr; memcpy (&addr, &(inptr->sin_addr), sizeof (struct in_addr)); break; } } freeaddrinfo (result); if (addr.s_addr != 0) return g_variant_new_uint32 (addr.s_addr); else { _LOGW ("failed to convert or look up VPN gateway address '%s'", tmp); return NULL; } } else { val = addr4_to_gvariant (tmp); if (val == NULL) { _LOGW ("failed to convert VPN gateway address '%s' (%d)", tmp, errno); return NULL; } } return val; }
static GVariant * _override_flags_get (NMSetting *setting, const char *property) { return g_variant_new_uint32 (nm_setting_vlan_get_flags ((NMSettingVlan *) setting)); }
int main (int argc, char *argv[]) { GDBusProxy *proxy; GVariantBuilder builder, ip4builder, ip6builder; GVariant *ip4config, *ip6config; char *tmp; GVariant *val; int i; GError *err = NULL; GPtrArray *dns4_list, *dns6_list; GPtrArray *nbns_list; GPtrArray *dns_domains; struct in_addr temp_addr; int tapdev = -1; char **iter; int shift = 0; gboolean is_restart; gboolean has_ip4_prefix = FALSE; gboolean has_ip4_address = FALSE; gboolean has_ip6_address = FALSE; gchar *bus_name = NM_DBUS_SERVICE_OPENVPN; #if !GLIB_CHECK_VERSION (2, 35, 0) g_type_init (); #endif for (i = 1; i < argc; i++) { if (!strcmp (argv[i], "--")) { i++; break; } if (nm_streq (argv[i], "--debug")) { if (i + 2 >= argc) { g_printerr ("Missing debug arguments (requires <LEVEL> <PREFIX_TOKEN>)\n"); exit (1); } gl.log_level = _nm_utils_ascii_str_to_int64 (argv[++i], 10, 0, LOG_DEBUG, 0); gl.log_prefix_token = argv[++i]; } else if (!strcmp (argv[i], "--tun")) tapdev = 0; else if (!strcmp (argv[i], "--tap")) tapdev = 1; else if (!strcmp (argv[i], "--bus-name")) { if (++i == argc) { g_printerr ("Missing bus name argument\n"); exit (1); } if (!g_dbus_is_name (argv[i])) { g_printerr ("Invalid bus name\n"); exit (1); } bus_name = argv[i]; } else break; } shift = i - 1; if (_LOGD_enabled ()) { GString *args; args = g_string_new (NULL); for (i = 0; i < argc; i++) { if (i > 0) g_string_append_c (args, ' '); if (shift && 1 + shift == i) g_string_append (args, " "); tmp = g_strescape (argv[i], NULL); g_string_append_printf (args, "\"%s\"", tmp); g_free (tmp); } _LOGD ("command line: %s", args->str); g_string_free (args, TRUE); for (iter = environ; iter && *iter; iter++) _LOGD ("environment: %s", *iter); } /* shift the arguments to the right leaving only those provided by openvpn */ argv[shift] = argv[0]; argv += shift; argc -= shift; is_restart = argc >= 7 && !g_strcmp0 (argv[6], "restart"); proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES, NULL, bus_name, NM_VPN_DBUS_PLUGIN_PATH, NM_VPN_DBUS_PLUGIN_INTERFACE, NULL, &err); if (!proxy) { _LOGW ("Could not create a D-Bus proxy: %s", err->message); g_error_free (err); exit (1); } g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); g_variant_builder_init (&ip4builder, G_VARIANT_TYPE_VARDICT); g_variant_builder_init (&ip6builder, G_VARIANT_TYPE_VARDICT); /* External world-visible VPN gateway */ val = trusted_remote_to_gvariant (); if (val) g_variant_builder_add (&builder, "{sv}", NM_VPN_PLUGIN_CONFIG_EXT_GATEWAY, val); else helper_failed (proxy, "VPN Gateway"); /* Internal VPN subnet gateway */ tmp = getenv ("route_vpn_gateway"); val = addr4_to_gvariant (tmp); if (val) g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_INT_GATEWAY, val); else { val = addr6_to_gvariant (tmp); if (val) g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_INT_GATEWAY, val); } /* VPN device */ tmp = getenv ("dev"); val = str_to_gvariant (tmp, FALSE); if (val) g_variant_builder_add (&builder, "{sv}", NM_VPN_PLUGIN_CONFIG_TUNDEV, val); else helper_failed (proxy, "Tunnel Device"); if (tapdev == -1) tapdev = strncmp (tmp, "tap", 3) == 0; /* IPv4 address */ tmp = getenv ("ifconfig_local"); if (!tmp && is_restart) tmp = argv[4]; if (tmp && strlen (tmp)) { val = addr4_to_gvariant (tmp); if (val) { has_ip4_address = TRUE; g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS, val); } else helper_failed (proxy, "IP4 Address"); } /* PTP address; for vpnc PTP address == internal IP4 address */ tmp = getenv ("ifconfig_remote"); if (!tmp && is_restart) tmp = argv[5]; val = addr4_to_gvariant (tmp); if (val) { /* Sigh. Openvpn added 'topology' stuff in 2.1 that changes the meaning * of the ifconfig bits without actually telling you what they are * supposed to mean; basically relying on specific 'ifconfig' behavior. */ if (tmp && !strncmp (tmp, "255.", 4)) { guint32 addr; /* probably a netmask, not a PTP address; topology == subnet */ addr = g_variant_get_uint32 (val); g_variant_unref (val); val = g_variant_new_uint32 (nm_utils_ip4_netmask_to_prefix (addr)); g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val); has_ip4_prefix = TRUE; } else g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PTP, val); } /* Netmask * * Either TAP or TUN modes can have an arbitrary netmask in newer versions * of openvpn, while in older versions only TAP mode would. So accept a * netmask if passed, otherwise default to /32 for TUN devices since they * are usually point-to-point. */ tmp = getenv ("ifconfig_netmask"); if (tmp && inet_pton (AF_INET, tmp, &temp_addr) > 0) { val = g_variant_new_uint32 (nm_utils_ip4_netmask_to_prefix (temp_addr.s_addr)); g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val); } else if (!tapdev) { if (has_ip4_address && !has_ip4_prefix) { val = g_variant_new_uint32 (32); g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PREFIX, val); } } else _LOGW ("No IP4 netmask/prefix (missing or invalid 'ifconfig_netmask')"); val = get_ip4_routes (); if (val) g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_ROUTES, val); else if (is_restart) { g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_PRESERVE_ROUTES, g_variant_new_boolean (TRUE)); } /* IPv6 address */ tmp = getenv ("ifconfig_ipv6_local"); if (tmp && strlen (tmp)) { val = addr6_to_gvariant (tmp); if (val) { g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_ADDRESS, val); has_ip6_address = TRUE; } else helper_failed (proxy, "IP6 Address"); } /* IPv6 remote address */ tmp = getenv ("ifconfig_ipv6_remote"); if (tmp && strlen (tmp)) { val = addr6_to_gvariant (tmp); if (val) g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_PTP, val); else helper_failed (proxy, "IP6 PTP Address"); } /* IPv6 netbits */ tmp = getenv ("ifconfig_ipv6_netbits"); if (tmp && strlen (tmp)) { long int netbits; errno = 0; netbits = strtol (tmp, NULL, 10); if (errno || netbits < 0 || netbits > 128) { _LOGW ("Ignoring invalid prefix '%s'", tmp); } else { val = g_variant_new_uint32 ((guint32) netbits); g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_PREFIX, val); } } val = get_ip6_routes (); if (val) g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_ROUTES, val); else if (is_restart) { g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_PRESERVE_ROUTES, g_variant_new_boolean (TRUE)); } /* DNS and WINS servers */ dns_domains = g_ptr_array_sized_new (3); dns4_list = g_ptr_array_new (); dns6_list = g_ptr_array_new (); nbns_list = g_ptr_array_new (); for (i = 1; i < 256; i++) { char *env_name; env_name = g_strdup_printf ("foreign_option_%d", i); tmp = getenv (env_name); g_free (env_name); if (!tmp || strlen (tmp) < 1) break; if (!g_str_has_prefix (tmp, "dhcp-option ")) continue; tmp += 12; /* strlen ("dhcp-option ") */ if (g_str_has_prefix (tmp, "DNS ")) parse_addr_list (dns4_list, dns6_list, tmp + 4); else if (g_str_has_prefix (tmp, "WINS ")) parse_addr_list (nbns_list, NULL, tmp + 5); else if (g_str_has_prefix (tmp, "DOMAIN ") && is_domain_valid (tmp + 7)) g_ptr_array_add (dns_domains, tmp + 7); } if (dns4_list->len) { val = g_variant_new_array (G_VARIANT_TYPE_UINT32, (GVariant **) dns4_list->pdata, dns4_list->len); g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_DNS, val); } if (has_ip6_address && dns6_list->len) { val = g_variant_new_array (G_VARIANT_TYPE ("ay"), (GVariant **) dns6_list->pdata, dns6_list->len); g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_DNS, val); } if (nbns_list->len) { val = g_variant_new_array (G_VARIANT_TYPE_UINT32, (GVariant **) nbns_list->pdata, nbns_list->len); g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_NBNS, val); } if (dns_domains->len) { val = g_variant_new_strv ((const gchar **) dns_domains->pdata, dns_domains->len); g_variant_builder_add (&ip4builder, "{sv}", NM_VPN_PLUGIN_IP4_CONFIG_DOMAINS, val); /* Domains apply to both IPv4 and IPv6 configurations */ if (has_ip6_address) { val = g_variant_new_strv ((const gchar **) dns_domains->pdata, dns_domains->len); g_variant_builder_add (&ip6builder, "{sv}", NM_VPN_PLUGIN_IP6_CONFIG_DOMAINS, val); } } g_ptr_array_unref (dns4_list); g_ptr_array_unref (dns6_list); g_ptr_array_unref (nbns_list); g_ptr_array_unref (dns_domains); /* Tunnel MTU */ tmp = getenv ("tun_mtu"); if (tmp && strlen (tmp)) { long int mtu; errno = 0; mtu = strtol (tmp, NULL, 10); if (errno || mtu < 0 || mtu > 20000) { _LOGW ("Ignoring invalid tunnel MTU '%s'", tmp); } else { val = g_variant_new_uint32 ((guint32) mtu); g_variant_builder_add (&builder, "{sv}", NM_VPN_PLUGIN_CONFIG_MTU, val); } } ip4config = g_variant_builder_end (&ip4builder); if (g_variant_n_children (ip4config)) { val = g_variant_new_boolean (TRUE); g_variant_builder_add (&builder, "{sv}", NM_VPN_PLUGIN_CONFIG_HAS_IP4, val); } else { g_variant_unref (ip4config); ip4config = NULL; } ip6config = g_variant_builder_end (&ip6builder); if (g_variant_n_children (ip6config)) { val = g_variant_new_boolean (TRUE); g_variant_builder_add (&builder, "{sv}", NM_VPN_PLUGIN_CONFIG_HAS_IP6, val); } else { g_variant_unref (ip6config); ip6config = NULL; } if (!ip4config && !ip6config) helper_failed (proxy, "IPv4 or IPv6 configuration"); /* Send the config info to nm-openvpn-service */ send_config (proxy, g_variant_builder_end (&builder), ip4config, ip6config); g_object_unref (proxy); return 0; }
/** * g_dbus_gvalue_to_gvariant: * @gvalue: A #GValue to convert to a #GVariant * @type: A #GVariantType * * Converts a #GValue to a #GVariant of the type indicated by the @type * parameter. * * The conversion is using the following rules: * * - #G_TYPE_STRING: 's', 'o', 'g' or 'ay' * - #G_TYPE_STRV: 'as', 'ao' or 'aay' * - #G_TYPE_BOOLEAN: 'b' * - #G_TYPE_UCHAR: 'y' * - #G_TYPE_INT: 'i', 'n' * - #G_TYPE_UINT: 'u', 'q' * - #G_TYPE_INT64 'x' * - #G_TYPE_UINT64: 't' * - #G_TYPE_DOUBLE: 'd' * - #G_TYPE_VARIANT: Any #GVariantType * * This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type * is ['i'][G-VARIANT-TYPE-INT32:CAPS]. It will also fail for any #GType * (including e.g. #G_TYPE_OBJECT and #G_TYPE_BOXED derived-types) not * in the table above. * * Note that if @gvalue is of type #G_TYPE_VARIANT and its value is * %NULL, the empty #GVariant instance (never %NULL) for @type is * returned (e.g. 0 for scalar types, the empty string for string types, * '/' for object path types, the empty array for any array type and so on). * * See the g_dbus_gvariant_to_gvalue() function for how to convert a * #GVariant to a #GValue. * * Returns: A #GVariant (never floating) of #GVariantType @type holding * the data from @gvalue or %NULL in case of failure. Free with * g_variant_unref(). * * Since: 2.30 */ GVariant * g_dbus_gvalue_to_gvariant (const GValue *gvalue, const GVariantType *type) { GVariant *ret; const gchar *s; const gchar * const *as; const gchar *empty_strv[1] = {NULL}; g_return_val_if_fail (gvalue != NULL, NULL); g_return_val_if_fail (type != NULL, NULL); ret = NULL; /* @type can easily be e.g. "s" with the GValue holding a GVariant - for example this * can happen when using the org.gtk.GDBus.C.ForceGVariant annotation with the * gdbus-codegen(1) tool. */ if (G_VALUE_TYPE (gvalue) == G_TYPE_VARIANT) { ret = g_value_dup_variant (gvalue); } else { switch (g_variant_type_peek_string (type)[0]) { case G_VARIANT_CLASS_BOOLEAN: ret = g_variant_ref_sink (g_variant_new_boolean (g_value_get_boolean (gvalue))); break; case G_VARIANT_CLASS_BYTE: ret = g_variant_ref_sink (g_variant_new_byte (g_value_get_uchar (gvalue))); break; case G_VARIANT_CLASS_INT16: ret = g_variant_ref_sink (g_variant_new_int16 (g_value_get_int (gvalue))); break; case G_VARIANT_CLASS_UINT16: ret = g_variant_ref_sink (g_variant_new_uint16 (g_value_get_uint (gvalue))); break; case G_VARIANT_CLASS_INT32: ret = g_variant_ref_sink (g_variant_new_int32 (g_value_get_int (gvalue))); break; case G_VARIANT_CLASS_UINT32: ret = g_variant_ref_sink (g_variant_new_uint32 (g_value_get_uint (gvalue))); break; case G_VARIANT_CLASS_INT64: ret = g_variant_ref_sink (g_variant_new_int64 (g_value_get_int64 (gvalue))); break; case G_VARIANT_CLASS_UINT64: ret = g_variant_ref_sink (g_variant_new_uint64 (g_value_get_uint64 (gvalue))); break; case G_VARIANT_CLASS_DOUBLE: ret = g_variant_ref_sink (g_variant_new_double (g_value_get_double (gvalue))); break; case G_VARIANT_CLASS_STRING: s = g_value_get_string (gvalue); if (s == NULL) s = ""; ret = g_variant_ref_sink (g_variant_new_string (s)); break; case G_VARIANT_CLASS_OBJECT_PATH: s = g_value_get_string (gvalue); if (s == NULL) s = "/"; ret = g_variant_ref_sink (g_variant_new_object_path (s)); break; case G_VARIANT_CLASS_SIGNATURE: s = g_value_get_string (gvalue); if (s == NULL) s = ""; ret = g_variant_ref_sink (g_variant_new_signature (s)); break; case G_VARIANT_CLASS_ARRAY: switch (g_variant_type_peek_string (type)[1]) { case G_VARIANT_CLASS_BYTE: s = g_value_get_string (gvalue); if (s == NULL) s = ""; ret = g_variant_ref_sink (g_variant_new_bytestring (s)); break; case G_VARIANT_CLASS_STRING: as = g_value_get_boxed (gvalue); if (as == NULL) as = empty_strv; ret = g_variant_ref_sink (g_variant_new_strv (as, -1)); break; case G_VARIANT_CLASS_OBJECT_PATH: as = g_value_get_boxed (gvalue); if (as == NULL) as = empty_strv; ret = g_variant_ref_sink (g_variant_new_objv (as, -1)); break; case G_VARIANT_CLASS_ARRAY: switch (g_variant_type_peek_string (type)[2]) { case G_VARIANT_CLASS_BYTE: as = g_value_get_boxed (gvalue); if (as == NULL) as = empty_strv; ret = g_variant_ref_sink (g_variant_new_bytestring_array (as, -1)); break; default: ret = g_value_dup_variant (gvalue); break; } break; default: ret = g_value_dup_variant (gvalue); break; } break; case G_VARIANT_CLASS_HANDLE: case G_VARIANT_CLASS_VARIANT: case G_VARIANT_CLASS_MAYBE: case G_VARIANT_CLASS_TUPLE: case G_VARIANT_CLASS_DICT_ENTRY: ret = g_value_dup_variant (gvalue); break; } } /* Could be that the GValue is holding a NULL GVariant - in that case, * we return an "empty" GVariant instead of a NULL GVariant */ if (ret == NULL) { GVariant *untrusted_empty; untrusted_empty = g_variant_new_from_data (type, NULL, 0, FALSE, NULL, NULL); ret = g_variant_ref_sink (g_variant_get_normal_form (untrusted_empty)); g_variant_unref (untrusted_empty); } g_assert (!g_variant_is_floating (ret)); return ret; }
static GVariant * gconf_settings_backend_simple_gconf_value_type_to_gvariant (GConfValue *gconf_value, const GVariantType *expected_type) { /* Note: it's guaranteed that the types are compatible */ GVariant *variant = NULL; if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN)) variant = g_variant_new_boolean (gconf_value_get_bool (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE)) { int value = gconf_value_get_int (gconf_value); if (value < 0 || value > 255) return NULL; variant = g_variant_new_byte (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16)) { int value = gconf_value_get_int (gconf_value); if (value < G_MINSHORT || value > G_MAXSHORT) return NULL; variant = g_variant_new_int16 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16)) { int value = gconf_value_get_int (gconf_value); if (value < 0 || value > G_MAXUSHORT) return NULL; variant = g_variant_new_uint16 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32)) variant = g_variant_new_int32 (gconf_value_get_int (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_uint32 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64)) variant = g_variant_new_int64 ((gint64) gconf_value_get_int (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_uint64 (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE)) { int value = gconf_value_get_int (gconf_value); if (value < 0) return NULL; variant = g_variant_new_handle (value); } else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double (gconf_value_get_float (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING)) variant = g_variant_new_string (gconf_value_get_string (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH)) variant = g_variant_new_object_path (gconf_value_get_string (gconf_value)); else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE)) variant = g_variant_new_signature (gconf_value_get_string (gconf_value)); return variant; }
static GPtrArray * gs_plugin_steam_parse_appinfo_file (const gchar *filename, GError **error) { GPtrArray *apps; GHashTable *app = NULL; const gchar *tmp; guint8 *data = NULL; gsize data_len = 0; guint i = 0; gboolean debug = g_getenv ("GS_PLUGIN_STEAM_DEBUG") != NULL; /* load file */ if (!g_file_get_contents (filename, (gchar **) &data, &data_len, error)) { gs_utils_error_convert_gio (error); return NULL; } /* a GPtrArray of GHashTable */ apps = g_ptr_array_new_with_free_func ((GDestroyNotify) g_hash_table_unref); /* find the first application and avoid header */ gs_plugin_steam_find_next_sync_point (data, data_len, &i); for (i = i + 1; i < data_len; i++) { if (debug) g_debug ("%04x {0x%02x} %s", i, data[i], gs_plugin_steam_token_kind_to_str (data[i])); if (data[i] == GS_PLUGIN_STEAM_TOKEN_START) { /* this is a new application/game */ if (data[i+1] == 0x02) { /* reset */ app = gs_plugin_steam_add_app (apps); i++; continue; } /* new group */ if (g_ascii_isprint (data[i+1])) { tmp = gs_plugin_steam_consume_string (data, data_len, &i); if (debug) g_debug ("[%s] {", tmp); continue; } /* something went wrong */ if (debug) g_debug ("CORRUPTION DETECTED"); gs_plugin_steam_find_next_sync_point (data, data_len, &i); continue; } if (data[i] == GS_PLUGIN_STEAM_TOKEN_END) { if (debug) g_debug ("}"); continue; } if (data[i] == GS_PLUGIN_STEAM_TOKEN_STRING) { const gchar *value; tmp = gs_plugin_steam_consume_string (data, data_len, &i); value = gs_plugin_steam_consume_string (data, data_len, &i); if (debug) g_debug ("\t%s=%s", tmp, value); if (tmp != NULL && value != NULL) { if (g_hash_table_lookup (app, tmp) != NULL) continue; g_hash_table_insert (app, g_strdup (tmp), g_variant_new_string (value)); } continue; } if (data[i] == GS_PLUGIN_STEAM_TOKEN_INTEGER) { guint32 value; tmp = gs_plugin_steam_consume_string (data, data_len, &i); value = gs_plugin_steam_consume_uint32 (data, data_len, &i); if (debug) g_debug ("\t%s=%u", tmp, value); if (tmp != NULL) { if (g_hash_table_lookup (app, tmp) != NULL) continue; g_hash_table_insert (app, g_strdup (tmp), g_variant_new_uint32 (value)); } continue; } } return apps; }
GVariant * mm_simple_connect_properties_get_dictionary (MMSimpleConnectProperties *self) { GVariantBuilder builder; GVariantIter iter; gchar *key; GVariant *value; GVariant *bearer_properties_dictionary; /* We do allow NULL */ if (!self) return NULL; g_return_val_if_fail (MM_IS_SIMPLE_CONNECT_PROPERTIES (self), NULL); g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); if (self->priv->pin) g_variant_builder_add (&builder, "{sv}", PROPERTY_PIN, g_variant_new_string (self->priv->pin)); if (self->priv->operator_id) g_variant_builder_add (&builder, "{sv}", PROPERTY_OPERATOR_ID, g_variant_new_string (self->priv->operator_id)); if (self->priv->bands) g_variant_builder_add (&builder, "{sv}", PROPERTY_BANDS, mm_common_bands_array_to_variant (self->priv->bands, self->priv->n_bands)); if (self->priv->allowed_modes_set) { g_variant_builder_add (&builder, "{sv}", PROPERTY_ALLOWED_MODES, g_variant_new_uint32 (self->priv->allowed_modes)); g_variant_builder_add (&builder, "{sv}", PROPERTY_PREFERRED_MODE, g_variant_new_uint32 (self->priv->preferred_mode)); } /* Merge dictionaries */ bearer_properties_dictionary = mm_bearer_properties_get_dictionary (self->priv->bearer_properties); g_variant_iter_init (&iter, bearer_properties_dictionary); while (g_variant_iter_next (&iter, "{sv}", &key, &value)) { g_variant_builder_add (&builder, "{sv}", key, value); g_variant_unref (value); g_free (key); } g_variant_unref (bearer_properties_dictionary); return g_variant_ref_sink (g_variant_builder_end (&builder)); }
GVariant* js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue, const GVariantType* sig, JSValueRef *exception) { if (g_variant_type_is_array(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); if (g_variant_type_is_dict_entry(child_sig)) { const GVariantType* key_sig = g_variant_type_first(child_sig); const GVariantType* value_sig = g_variant_type_next(key_sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_function_child(ctx, jsvalue, i)) { continue; } g_variant_builder_open(&builder, child_sig); JSValueRef key = JSValueMakeString(ctx, JSPropertyNameArrayGetNameAtIndex(array, i)); JSValueRef value = JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL); g_variant_builder_add_value(&builder, js_to_dbus(ctx, key, key_sig, exception)); g_variant_builder_add_value(&builder, js_to_dbus(ctx, value, value_sig, exception)); g_variant_builder_close(&builder); } return g_variant_builder_end(&builder); } else { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) { continue; } g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), child_sig, exception)); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } } else if (g_variant_type_is_tuple(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* current_sig = g_variant_type_first(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) { continue; } g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), current_sig, exception)); current_sig = g_variant_type_next(current_sig); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } else { switch (g_variant_type_peek_string(sig)[0]) { case 'y': return g_variant_new_byte(JSValueToNumber(ctx, jsvalue, exception)); case 'n': return g_variant_new_int16(JSValueToNumber(ctx, jsvalue, exception)); case 'q': return g_variant_new_uint16(JSValueToNumber(ctx, jsvalue, exception)); case 'i': return g_variant_new_int32(JSValueToNumber(ctx, jsvalue, exception)); case 'u': return g_variant_new_uint32(JSValueToNumber(ctx, jsvalue, exception)); case 'x': return g_variant_new_int64(JSValueToNumber(ctx, jsvalue, exception)); case 't': return g_variant_new_uint64(JSValueToNumber(ctx, jsvalue, exception)); case 'd': return g_variant_new_double(JSValueToNumber(ctx, jsvalue, exception)); case 'h': return g_variant_new_handle(JSValueToNumber(ctx, jsvalue, exception)); case 'b': return g_variant_new_boolean(JSValueToBoolean(ctx, jsvalue)); case 's': { char* v = jsvalue_to_cstr(ctx, jsvalue); GVariant* r = g_variant_new_string(v); g_free(v); return r; } case 'v': { //TODO: /*g_variant_new_variant()*/ g_assert_not_reached(); } } } g_assert_not_reached(); }