/* nmcli - command-line tool to control NetworkManager * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * * Copyright 2010 - 2018 Red Hat, Inc. */ #include "nm-default.h" #include "nm-meta-setting-desc.h" #include #include #include "nm-common-macros.h" #include "nm-utils/nm-enum-utils.h" #include "nm-vpn-helpers.h" #include "nm-client-utils.h" #include "nm-meta-setting-access.h" /*****************************************************************************/ static char *secret_flags_to_string (guint32 flags, NMMetaAccessorGetType get_type); #define ALL_SECRET_FLAGS \ (NM_SETTING_SECRET_FLAG_NONE | \ NM_SETTING_SECRET_FLAG_AGENT_OWNED | \ NM_SETTING_SECRET_FLAG_NOT_SAVED | \ NM_SETTING_SECRET_FLAG_NOT_REQUIRED) /*****************************************************************************/ static GType _gobject_property_get_gtype (GObject *gobject, const char *property_name) { GParamSpec *param_spec; param_spec = g_object_class_find_property (G_OBJECT_GET_CLASS (gobject), property_name); if (param_spec) return param_spec->value_type; g_return_val_if_reached (G_TYPE_INVALID); } static GType _gtype_property_get_gtype (GType gtype, const char *property_name) { /* given @gtype, a type for a GObject, lookup the property @property_name * and return its value_type. */ if (G_TYPE_IS_CLASSED (gtype)) { GParamSpec *param_spec; nm_auto_unref_gtypeclass GTypeClass *gtypeclass = g_type_class_ref (gtype); if (G_IS_OBJECT_CLASS (gtypeclass)) { param_spec = g_object_class_find_property (G_OBJECT_CLASS (gtypeclass), property_name); if (param_spec) return param_spec->value_type; } } g_return_val_if_reached (G_TYPE_INVALID); } /*****************************************************************************/ static NMIPAddress * _parse_ip_address (int family, const char *address, GError **error) { gs_free char *ip_str = NULL; const int MAX_PREFIX = (family == AF_INET) ? 32 : 128; NMIPAddress *addr; char *plen; int prefix; GError *local = NULL; g_return_val_if_fail (address, NULL); g_return_val_if_fail (!error || !*error, NULL); ip_str = g_strstrip (g_strdup (address)); prefix = MAX_PREFIX; plen = strchr (ip_str, '/'); if (plen) { *plen++ = '\0'; if ((prefix = _nm_utils_ascii_str_to_int64 (plen, 10, 1, MAX_PREFIX, -1)) == -1) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("invalid prefix '%s'; <1-%d> allowed"), plen, MAX_PREFIX); return NULL; } } addr = nm_ip_address_new (family, ip_str, prefix, &local); if (!addr) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("invalid IP address: %s"), local->message); g_clear_error (&local); } return addr; } static NMIPRoute * _parse_ip_route (int family, const char *str, GError **error) { const int MAX_PREFIX = (family == AF_INET) ? 32 : 128; const char *next_hop = NULL; const char *canon_dest; int prefix; NMIPRoute *route = NULL; GError *local = NULL; gint64 metric = -1; guint i; gs_free const char **routev = NULL; gs_free char *str_clean = NULL; gs_free char *dest_clone = NULL; const char *dest; const char *plen; gs_unref_hashtable GHashTable *attrs = NULL; GHashTable *tmp_attrs; #define ROUTE_SYNTAX _("The valid syntax is: 'ip[/prefix] [next-hop] [metric] [attribute=val]... [,ip[/prefix] ...]'") nm_assert (NM_IN_SET (family, AF_INET, AF_INET6)); nm_assert (str); nm_assert (!error || !*error); str_clean = g_strstrip (g_strdup (str)); routev = nm_utils_strsplit_set (str_clean, " \t", FALSE); if (!routev) { g_set_error (error, 1, 0, "'%s' is not valid. %s", str, ROUTE_SYNTAX); return NULL; } dest = routev[0]; plen = strchr (dest, '/'); /* prefix delimiter */ if (plen) { dest_clone = g_strdup (dest); plen = &dest_clone[plen - dest]; dest = dest_clone; *((char *) plen) = '\0'; plen++; } prefix = MAX_PREFIX; if (plen) { if ((prefix = _nm_utils_ascii_str_to_int64 (plen, 10, 1, MAX_PREFIX, -1)) == -1) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("invalid prefix '%s'; <1-%d> allowed"), plen, MAX_PREFIX); return NULL; } } for (i = 1; routev[i]; i++) { gint64 tmp64; if (nm_utils_ipaddr_valid (family, routev[i])) { if (metric != -1 || attrs) { g_set_error (error, 1, 0, _("the next hop ('%s') must be first"), routev[i]); return NULL; } next_hop = routev[i]; } else if ((tmp64 = _nm_utils_ascii_str_to_int64 (routev[i], 10, 0, G_MAXUINT32, -1)) != -1) { if (attrs) { g_set_error (error, 1, 0, _("the metric ('%s') must be before attributes"), routev[i]); return NULL; } metric = tmp64; } else if (strchr (routev[i], '=')) { GHashTableIter iter; char *iter_key; GVariant *iter_value; tmp_attrs = nm_utils_parse_variant_attributes (routev[i], ' ', '=', FALSE, nm_ip_route_get_variant_attribute_spec(), error); if (!tmp_attrs) { g_prefix_error (error, "invalid option '%s': ", routev[i]); return NULL; } if (!attrs) { attrs = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref); } g_hash_table_iter_init (&iter, tmp_attrs); while (g_hash_table_iter_next (&iter, (gpointer *) &iter_key, (gpointer *) &iter_value)) { /* need to sink the reference, because nm_utils_parse_variant_attributes() returns * floating refs. */ g_variant_ref_sink (iter_value); if (!nm_ip_route_attribute_validate (iter_key, iter_value, family, NULL, error)) { g_prefix_error (error, "%s: ", iter_key); g_hash_table_unref (tmp_attrs); return NULL; } g_hash_table_insert (attrs, iter_key, iter_value); g_hash_table_iter_steal (&iter); } g_hash_table_unref (tmp_attrs); } else { g_set_error (error, 1, 0, "%s", ROUTE_SYNTAX); return NULL; } } route = nm_ip_route_new (family, dest, prefix, next_hop, metric, &local); if (!route) { g_set_error (error, 1, 0, _("invalid route: %s. %s"), local->message, ROUTE_SYNTAX); g_clear_error (&local); return NULL; } /* We don't accept default routes as NetworkManager handles it * itself. But we have to check this after @route has normalized the * dest string. */ canon_dest = nm_ip_route_get_dest (route); if (!strcmp (canon_dest, "0.0.0.0") || !strcmp (canon_dest, "::")) { g_set_error_literal (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("default route cannot be added (NetworkManager handles it by itself)")); g_clear_pointer (&route, nm_ip_route_unref); return NULL; } if (attrs) { GHashTableIter iter; char *name; GVariant *variant; g_hash_table_iter_init (&iter, attrs); while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer *) &variant)) nm_ip_route_set_attribute (route, name, variant); } return route; } static char * _dump_team_link_watcher (NMTeamLinkWatcher *watcher) { const char *name; NMTeamLinkWatcherArpPingFlags flags; GString *w_dump; if (!watcher) return NULL; w_dump = g_string_new (NULL); name = nm_team_link_watcher_get_name (watcher); g_string_append_printf (w_dump, "name=%s", name); #define DUMP_WATCHER_INT(str, watcher, name, key) \ G_STMT_START { \ int _val = nm_team_link_watcher_get_##key (watcher); \ \ if (_val) \ g_string_append_printf (str, " %s=%d", name, _val); \ } G_STMT_END; if (nm_streq (name, NM_TEAM_LINK_WATCHER_ETHTOOL)) { DUMP_WATCHER_INT (w_dump, watcher, "delay-up", delay_up); DUMP_WATCHER_INT (w_dump, watcher, "delay-down", delay_down); return g_string_free (w_dump, FALSE); } /* NM_TEAM_LINK_WATCHER_NSNA_PING and NM_TEAM_LINK_WATCHER_ARP_PING */ DUMP_WATCHER_INT (w_dump, watcher, "init-wait", init_wait); DUMP_WATCHER_INT (w_dump, watcher, "interval", interval); DUMP_WATCHER_INT (w_dump, watcher, "missed-max", missed_max); g_string_append_printf (w_dump, " target-host=%s", nm_team_link_watcher_get_target_host (watcher)); if (nm_streq (name, NM_TEAM_LINK_WATCHER_NSNA_PING)) return g_string_free (w_dump, FALSE); DUMP_WATCHER_INT (w_dump, watcher, "vlanid", vlanid); #undef DUMP_WATCHER_INT g_string_append_printf (w_dump, " source-host=%s", nm_team_link_watcher_get_source_host (watcher)); flags = nm_team_link_watcher_get_flags (watcher); if (flags & NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_ACTIVE) g_string_append_printf (w_dump, " validate-active=true"); if (flags & NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_INACTIVE) g_string_append_printf (w_dump, " validate-inactive=true"); if (flags & NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_SEND_ALWAYS) g_string_append_printf (w_dump, "send-always=true"); return g_string_free (w_dump, FALSE); } static NMTeamLinkWatcher * _parse_team_link_watcher (const char *str, GError **error) { gs_free const char **watcherv = NULL; gs_free char *str_clean = NULL; guint i; gs_free const char *name = NULL; int val1 = 0, val2 = 0, val3 = 3, val4 = -1; gs_free const char *target_host = NULL; gs_free const char *source_host = NULL; NMTeamLinkWatcherArpPingFlags flags = 0; nm_assert (str); nm_assert (!error || !*error); str_clean = g_strstrip (g_strdup (str)); watcherv = nm_utils_strsplit_set (str_clean, " \t", FALSE); if (!watcherv) { g_set_error (error, 1, 0, "'%s' is not valid", str); return NULL; } for (i = 0; watcherv[i]; i++) { gs_free const char **pair = NULL; pair = nm_utils_strsplit_set (watcherv[i], "=", FALSE); if (!pair) { g_set_error (error, 1, 0, "'%s' is not valid: %s", watcherv[i], "properties should be specified as 'key=value'"); return NULL; } if (!pair[1]) { g_set_error (error, 1, 0, "'%s' is not valid: %s", watcherv[i], "missing key value"); return NULL; } if (pair[2]) { g_set_error (error, 1, 0, "'%s' is not valid: %s", watcherv[i], "properties should be specified as 'key=value'"); return NULL; } if (nm_streq (pair[0], "name")) name = g_strdup (pair[1]); else if ( nm_streq (pair[0], "delay-up") || nm_streq (pair[0], "init-wait")) val1 = _nm_utils_ascii_str_to_int64 (pair[1], 10, 0, G_MAXINT32, -1); else if ( nm_streq (pair[0], "delay-down") || nm_streq (pair[0], "interval")) val2 = _nm_utils_ascii_str_to_int64 (pair[1], 10, 0, G_MAXINT32, -1); else if (nm_streq (pair[0], "missed-max")) val3 = _nm_utils_ascii_str_to_int64 (pair[1], 10, 0, G_MAXINT32, -1); else if (nm_streq (pair[0], "vlanid")) val4 = _nm_utils_ascii_str_to_int64 (pair[1], 10, -1, 4094, -2); else if (nm_streq (pair[0], "target-host")) target_host = g_strdup (pair[1]); else if (nm_streq (pair[0], "source-host")) source_host = g_strdup (pair[1]); else if (nm_streq (pair[0], "validate-active")) { if (nm_streq (pair[1], "true")) flags |= NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_ACTIVE; } else if (nm_streq (pair[0], "validate-inactive")) { if (nm_streq (pair[1], "true")) flags |= NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_VALIDATE_INACTIVE; } else if (nm_streq (pair[0], "send-always")) { if (nm_streq (pair[1], "true")) flags |= NM_TEAM_LINK_WATCHER_ARP_PING_FLAG_SEND_ALWAYS; } else { g_set_error (error, 1, 0, "'%s' is not valid: %s", watcherv[i], "unknown key"); return NULL; } if ((val1 < 0) || (val2 < 0) || (val3 < 0)) { g_set_error (error, 1, 0, "'%s' is not valid: %s", watcherv[i], "value is not a valid number [0, MAXINT]"); return NULL; } if (val4 < -1) { g_set_error (error, 1, 0, "'%s' is not valid: %s", watcherv[i], "value is not a valid number [-1, 4094]"); return NULL; } } if (nm_streq0 (name, NM_TEAM_LINK_WATCHER_ETHTOOL)) return nm_team_link_watcher_new_ethtool (val1, val2, error); else if (nm_streq0 (name, NM_TEAM_LINK_WATCHER_NSNA_PING)) return nm_team_link_watcher_new_nsna_ping (val1, val2, val3, target_host, error); else if (nm_streq0 (name, NM_TEAM_LINK_WATCHER_ARP_PING)) return nm_team_link_watcher_new_arp_ping2 (val1, val2, val3, val4, target_host, source_host, flags, error); if (!name) g_set_error (error, 1, 0, "link watcher name missing"); else g_set_error (error, 1, 0, "unknown link watcher name: '%s'", name); return NULL; } /* Max priority values from libnm-core/nm-setting-vlan.c */ #define MAX_SKB_PRIO G_MAXUINT32 #define MAX_8021P_PRIO 7 /* Max 802.1p priority */ /* * Parse VLAN priority mappings from the following format: 2:1,3:4,7:3 * and verify if the priority numbers are valid * * Return: string array with split maps, or NULL on error * Caller is responsible for freeing the array. */ static char ** _parse_vlan_priority_maps (const char *priority_map, NMVlanPriorityMap map_type, GError **error) { char **mapping = NULL, **iter; unsigned long from, to, from_max, to_max; g_return_val_if_fail (priority_map != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); if (map_type == NM_VLAN_INGRESS_MAP) { from_max = MAX_8021P_PRIO; to_max = MAX_SKB_PRIO; } else { from_max = MAX_SKB_PRIO; to_max = MAX_8021P_PRIO; } mapping = g_strsplit (priority_map, ",", 0); for (iter = mapping; iter && *iter; iter++) { char *left, *right; left = g_strstrip (*iter); right = strchr (left, ':'); if (!right) { g_set_error (error, 1, 0, _("invalid priority map '%s'"), *iter); g_strfreev (mapping); return NULL; } *right++ = '\0'; if (!nmc_string_to_uint (left, TRUE, 0, from_max, &from)) { g_set_error (error, 1, 0, _("priority '%s' is not valid (<0-%ld>)"), left, from_max); g_strfreev (mapping); return NULL; } if (!nmc_string_to_uint (right, TRUE, 0, to_max, &to)) { g_set_error (error, 1, 0, _("priority '%s' is not valid (<0-%ld>)"), right, to_max); g_strfreev (mapping); return NULL; } *(right-1) = ':'; /* Put back ':' */ } return mapping; } /* * nmc_proxy_check_script: * @script: file name with PAC script, or raw PAC Script data * @out_script: raw PAC Script (with removed new-line characters) * @error: location to store error, or %NULL * * Check PAC Script from @script parameter and return the checked/sanitized * config in @out_script. * * Returns: %TRUE if the script is valid, %FALSE if it is invalid */ static gboolean nmc_proxy_check_script (const char *script, char **out_script, GError **error) { enum { _PAC_SCRIPT_TYPE_GUESS, _PAC_SCRIPT_TYPE_FILE, _PAC_SCRIPT_TYPE_JSON, } desired_type = _PAC_SCRIPT_TYPE_GUESS; const char *filename = NULL; size_t c_len = 0; gs_free char *script_clone = NULL; *out_script = NULL; if (!script || !script[0]) return TRUE; if (g_str_has_prefix (script, "file://")) { script += NM_STRLEN ("file://"); desired_type = _PAC_SCRIPT_TYPE_FILE; } else if (g_str_has_prefix (script, "js://")) { script += NM_STRLEN ("js://"); desired_type = _PAC_SCRIPT_TYPE_JSON; } if (NM_IN_SET (desired_type, _PAC_SCRIPT_TYPE_FILE, _PAC_SCRIPT_TYPE_GUESS)) { gs_free char *contents = NULL; if (!g_file_get_contents (script, &contents, &c_len, NULL)) { if (desired_type == _PAC_SCRIPT_TYPE_FILE) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("cannot read pac-script from file '%s'"), script); return FALSE; } } else { if (c_len != strlen (contents)) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("file '%s' contains non-valid utf-8"), script); return FALSE; } filename = script; script = script_clone = g_steal_pointer (&contents); } } if ( !strstr (script, "FindProxyForURL") || !g_utf8_validate (script, -1, NULL)) { if (filename) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("'%s' does not contain a valid PAC Script"), filename); } else { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("Not a valid PAC Script")); } return FALSE; } *out_script = (script == script_clone) ? g_steal_pointer (&script_clone) : g_strdup (script); return TRUE; } /* * nmc_team_check_config: * @config: file name with team config, or raw team JSON config data * @out_config: raw team JSON config data * The value must be freed with g_free(). * @error: location to store error, or %NUL * * Check team config from @config parameter and return the checked * config in @out_config. * * Returns: %TRUE if the config is valid, %FALSE if it is invalid */ static gboolean nmc_team_check_config (const char *config, char **out_config, GError **error) { enum { _TEAM_CONFIG_TYPE_GUESS, _TEAM_CONFIG_TYPE_FILE, _TEAM_CONFIG_TYPE_JSON, } desired_type = _TEAM_CONFIG_TYPE_GUESS; const char *filename = NULL; size_t c_len = 0; gs_free char *config_clone = NULL; *out_config = NULL; if (!config || !config[0]) return TRUE; if (g_str_has_prefix (config, "file://")) { config += NM_STRLEN ("file://"); desired_type = _TEAM_CONFIG_TYPE_FILE; } else if (g_str_has_prefix (config, "json://")) { config += NM_STRLEN ("json://"); desired_type = _TEAM_CONFIG_TYPE_JSON; } if (NM_IN_SET (desired_type, _TEAM_CONFIG_TYPE_FILE, _TEAM_CONFIG_TYPE_GUESS)) { gs_free char *contents = NULL; if (!g_file_get_contents (config, &contents, &c_len, NULL)) { if (desired_type == _TEAM_CONFIG_TYPE_FILE) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("cannot read team config from file '%s'"), config); return FALSE; } } else { if (c_len != strlen (contents)) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("team config file '%s' contains non-valid utf-8"), config); return FALSE; } filename = config; config = config_clone = g_steal_pointer (&contents); } } if (!nm_utils_is_json_object (config, NULL)) { if (filename) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("'%s' does not contain a valid team configuration"), filename); } else { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("team configuration must be a JSON object")); } return FALSE; } *out_config = (config == config_clone) ? g_steal_pointer (&config_clone) : g_strdup (config); return TRUE; } static const char * _get_text_hidden (NMMetaAccessorGetType get_type) { if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) return _(NM_META_TEXT_HIDDEN); return NM_META_TEXT_HIDDEN; } /*****************************************************************************/ G_GNUC_PRINTF (4, 5) static void _env_warn_fcn (const NMMetaEnvironment *environment, gpointer environment_user_data, NMMetaEnvWarnLevel warn_level, const char *fmt_l10n, ...) { va_list ap; if (!environment || !environment->warn_fcn) return; va_start (ap, fmt_l10n); environment->warn_fcn (environment, environment_user_data, warn_level, fmt_l10n, ap); va_end (ap); } /*****************************************************************************/ #define ARGS_DESCRIBE_FCN \ const NMMetaPropertyInfo *property_info, char **out_to_free #define ARGS_GET_FCN \ const NMMetaPropertyInfo *property_info, const NMMetaEnvironment *environment, gpointer environment_user_data, NMSetting *setting, NMMetaAccessorGetType get_type, NMMetaAccessorGetFlags get_flags, NMMetaAccessorGetOutFlags *out_flags, gboolean *out_is_default, gpointer *out_to_free #define ARGS_SET_FCN \ const NMMetaPropertyInfo *property_info, const NMMetaEnvironment *environment, gpointer environment_user_data, NMSetting *setting, const char *value, GError **error #define ARGS_REMOVE_FCN \ const NMMetaPropertyInfo *property_info, const NMMetaEnvironment *environment, gpointer environment_user_data, NMSetting *setting, const char *value, guint32 idx, GError **error #define ARGS_COMPLETE_FCN \ const NMMetaPropertyInfo *property_info, const NMMetaEnvironment *environment, gpointer environment_user_data, const NMMetaOperationContext *operation_context, const char *text, char ***out_to_free #define ARGS_VALUES_FCN \ const NMMetaPropertyInfo *property_info, char ***out_to_free #define ARGS_SETTING_INIT_FCN \ const NMMetaSettingInfoEditor *setting_info, NMSetting *setting, NMMetaAccessorSettingInitType init_type #define RETURN_UNSUPPORTED_GET_TYPE() \ G_STMT_START { \ if (!NM_IN_SET (get_type, \ NM_META_ACCESSOR_GET_TYPE_PARSABLE, \ NM_META_ACCESSOR_GET_TYPE_PRETTY)) { \ nm_assert_not_reached (); \ return NULL; \ } \ } G_STMT_END; #define RETURN_STR_TO_FREE(val) \ G_STMT_START { \ char *_val = (val); \ return ((*(out_to_free)) = _val); \ } G_STMT_END static gboolean property_is_default (NMSetting *setting, const char *prop_name) { nm_auto_unset_gvalue GValue v = G_VALUE_INIT; GParamSpec *pspec; GHashTable *ht; char **strv; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (setting)), prop_name); if (!G_IS_PARAM_SPEC (pspec)) g_return_val_if_reached (FALSE); g_value_init (&v, pspec->value_type); g_object_get_property (G_OBJECT (setting), prop_name, &v); if (pspec->value_type == G_TYPE_STRV) { strv = g_value_get_boxed (&v); return !strv || !strv[0]; } else if (pspec->value_type == G_TYPE_HASH_TABLE) { ht = g_value_get_boxed (&v); return !ht || !g_hash_table_size (ht); } return g_param_value_defaults (pspec, &v); } static gconstpointer _get_fcn_nmc_with_default (ARGS_GET_FCN) { const char *s; char *s_full; GValue val = G_VALUE_INIT; RETURN_UNSUPPORTED_GET_TYPE (); NM_SET_OUT (out_is_default, property_is_default (setting, property_info->property_name)); if (property_info->property_typ_data->subtype.get_with_default.fcn (setting)) { if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) return _("(default)"); return ""; } g_value_init (&val, G_TYPE_STRING); g_object_get_property (G_OBJECT (setting), property_info->property_name, &val); s = g_value_get_string (&val); if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) s_full = s ? g_strdup_printf ("\"%s\"", s) : g_strdup (""); else s_full = g_strdup (s && *s ? s : " "); g_value_unset (&val); RETURN_STR_TO_FREE (s_full); } static gconstpointer _get_fcn_gobject_impl (const NMMetaPropertyInfo *property_info, NMSetting *setting, NMMetaAccessorGetType get_type, gboolean *out_is_default, gpointer *out_to_free) { char *s; const char *s_c; GType gtype_prop; nm_auto_unset_gvalue GValue val = G_VALUE_INIT; RETURN_UNSUPPORTED_GET_TYPE (); NM_SET_OUT (out_is_default, property_is_default (setting, property_info->property_name)); gtype_prop = _gobject_property_get_gtype (G_OBJECT (setting), property_info->property_name); if (gtype_prop == G_TYPE_BOOLEAN) { gboolean b; g_value_init (&val, gtype_prop); g_object_get_property (G_OBJECT (setting), property_info->property_name, &val); b = g_value_get_boolean (&val); if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) s_c = b ? _("yes") : _("no"); else s_c = b ? "yes" : "no"; return s_c; } else { g_value_init (&val, G_TYPE_STRING); g_object_get_property (G_OBJECT (setting), property_info->property_name, &val); s = g_value_dup_string (&val); RETURN_STR_TO_FREE (s); } } static gconstpointer _get_fcn_gobject (ARGS_GET_FCN) { return _get_fcn_gobject_impl (property_info, setting, get_type, out_is_default, out_to_free); } static gconstpointer _get_fcn_gobject_int (ARGS_GET_FCN) { GParamSpec *pspec; nm_auto_unset_gvalue GValue gval = G_VALUE_INIT; gboolean is_uint64 = FALSE; NMMetaSignUnsignInt64 v; guint base = 10; const NMMetaUtilsIntValueInfo *value_infos; char *return_str; RETURN_UNSUPPORTED_GET_TYPE (); pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (setting)), property_info->property_name); if (!G_IS_PARAM_SPEC (pspec)) g_return_val_if_reached (FALSE); g_value_init (&gval, pspec->value_type); g_object_get_property (G_OBJECT (setting), property_info->property_name, &gval); NM_SET_OUT (out_is_default, g_param_value_defaults (pspec, &gval)); switch (pspec->value_type) { case G_TYPE_INT: v.i64 = g_value_get_int (&gval); break; case G_TYPE_UINT: v.u64 = g_value_get_uint (&gval); is_uint64 = TRUE; break; case G_TYPE_INT64: v.i64 = g_value_get_int64 (&gval); break; case G_TYPE_UINT64: v.u64 = g_value_get_uint64 (&gval); is_uint64 = TRUE; break; default: g_return_val_if_reached (NULL); break; } if ( property_info->property_typ_data && property_info->property_typ_data->subtype.gobject_int.base > 0) { base = property_info->property_typ_data->subtype.gobject_int.base; } switch (base) { case 10: if (is_uint64) return_str = g_strdup_printf ("%"G_GUINT64_FORMAT, v.u64); else return_str = g_strdup_printf ("%"G_GINT64_FORMAT, v.i64); break; case 16: if (is_uint64) return_str = g_strdup_printf ("0x%"G_GINT64_MODIFIER"x", v.u64); else return_str = g_strdup_printf ("0x%"G_GINT64_MODIFIER"x", (guint64) v.i64); break; default: return_str = NULL; g_assert_not_reached (); } if ( get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY && property_info->property_typ_data && (value_infos = property_info->property_typ_data->subtype.gobject_int.value_infos)) { for (; value_infos->nick; value_infos++) { if ( ( is_uint64 && value_infos->value.u64 == v.u64) || (!is_uint64 && value_infos->value.i64 == v.i64)) { char *old_str = return_str; return_str = g_strdup_printf ("%s (%s)", old_str, value_infos->nick); g_free (old_str); break; } } } RETURN_STR_TO_FREE (return_str); } static gconstpointer _get_fcn_gobject_mtu (ARGS_GET_FCN) { guint32 mtu; RETURN_UNSUPPORTED_GET_TYPE (); if ( !property_info->property_typ_data || !property_info->property_typ_data->subtype.mtu.get_fcn) return _get_fcn_gobject_impl (property_info, setting, get_type, out_is_default, out_to_free); mtu = property_info->property_typ_data->subtype.mtu.get_fcn (setting); if (mtu == 0) { NM_SET_OUT (out_is_default, TRUE); if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) return _("auto"); return "auto"; } RETURN_STR_TO_FREE (g_strdup_printf ("%u", (unsigned) mtu)); } static gconstpointer _get_fcn_gobject_secret_flags (ARGS_GET_FCN) { guint v; GValue val = G_VALUE_INIT; RETURN_UNSUPPORTED_GET_TYPE (); g_value_init (&val, G_TYPE_UINT); g_object_get_property (G_OBJECT (setting), property_info->property_name, &val); v = g_value_get_uint (&val); g_value_unset (&val); RETURN_STR_TO_FREE (secret_flags_to_string (v, get_type)); } static gconstpointer _get_fcn_gobject_enum (ARGS_GET_FCN) { GType gtype = 0; nm_auto_unref_gtypeclass GTypeClass *gtype_class = NULL; nm_auto_unref_gtypeclass GTypeClass *gtype_prop_class = NULL; const struct _NMUtilsEnumValueInfo *value_infos = NULL; gboolean has_gtype = FALSE; nm_auto_unset_gvalue GValue gval = G_VALUE_INIT; gint64 v; gboolean format_numeric = FALSE; gboolean format_numeric_hex = FALSE; gboolean format_numeric_hex_unknown = FALSE; gboolean format_text = FALSE; gboolean format_text_l10n = FALSE; gs_free char *s = NULL; char s_numeric[64]; GParamSpec *pspec; RETURN_UNSUPPORTED_GET_TYPE (); if (property_info->property_typ_data) { if (property_info->property_typ_data->subtype.gobject_enum.get_gtype) { gtype = property_info->property_typ_data->subtype.gobject_enum.get_gtype (); has_gtype = TRUE; } } if ( property_info->property_typ_data && get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY && NM_FLAGS_ANY (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_NUMERIC | NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_NUMERIC_HEX | NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_TEXT | NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_TEXT_L10N)) { format_numeric_hex = NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_NUMERIC_HEX); format_numeric = format_numeric_hex || NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_NUMERIC); format_text_l10n = NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_TEXT_L10N); format_text = format_text_l10n || NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PRETTY_TEXT); } else if ( property_info->property_typ_data && get_type != NM_META_ACCESSOR_GET_TYPE_PRETTY && NM_FLAGS_ANY (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PARSABLE_NUMERIC | NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PARSABLE_NUMERIC_HEX | NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PARSABLE_TEXT)) { format_numeric_hex = NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PARSABLE_NUMERIC_HEX); format_numeric = format_numeric && NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PARSABLE_NUMERIC); format_text = NM_FLAGS_HAS (property_info->property_typ_data->typ_flags, NM_META_PROPERTY_TYP_FLAG_ENUM_GET_PARSABLE_TEXT); } else if (get_type == NM_META_ACCESSOR_GET_TYPE_PRETTY) { /* by default, output in format "%u (%s)" (with hex for flags and l10n). */ format_numeric = TRUE; format_numeric_hex_unknown = TRUE; format_text = TRUE; format_text_l10n = TRUE; } else { /* by default, output only numeric (with hex for flags). */ format_numeric = TRUE; format_numeric_hex_unknown = TRUE; } nm_assert (format_text || format_numeric); pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), property_info->property_name); g_return_val_if_fail (pspec, NULL); g_value_init (&gval, pspec->value_type); g_object_get_property (G_OBJECT (setting), property_info->property_name, &gval); NM_SET_OUT (out_is_default, g_param_value_defaults (pspec, &gval)); if ( pspec->value_type == G_TYPE_INT || ( G_TYPE_IS_CLASSED (pspec->value_type) && G_IS_ENUM_CLASS ((gtype_prop_class ?: (gtype_prop_class = g_type_class_ref (pspec->value_type)))))) { if (pspec->value_type == G_TYPE_INT) { if (!has_gtype) g_return_val_if_reached (NULL); v = g_value_get_int (&gval); } else v = g_value_get_enum (&gval); } else if ( pspec->value_type == G_TYPE_UINT || ( G_TYPE_IS_CLASSED (pspec->value_type) && G_IS_FLAGS_CLASS ((gtype_prop_class ?: (gtype_prop_class = g_type_class_ref (pspec->value_type)))))) { if (pspec->value_type == G_TYPE_UINT) { if (!has_gtype) g_return_val_if_reached (NULL); v = g_value_get_uint (&gval); } else v = g_value_get_flags (&gval); } else g_return_val_if_reached (NULL); if (!has_gtype) { gtype = pspec->value_type; gtype_class = g_steal_pointer (>ype_prop_class); } nm_assert (({ nm_auto_unref_gtypeclass GTypeClass *t = NULL; ( G_TYPE_IS_CLASSED (gtype) && (t = g_type_class_ref (gtype)) && (G_IS_ENUM_CLASS (t) || G_IS_FLAGS_CLASS (t))); })); if (format_numeric && !format_text) { s = format_numeric_hex || ( format_numeric_hex_unknown && !G_IS_ENUM_CLASS (gtype_class ?: (gtype_class = g_type_class_ref (gtype)))) ? g_strdup_printf ("0x%"G_GINT64_FORMAT, v) : g_strdup_printf ("%"G_GINT64_FORMAT, v); RETURN_STR_TO_FREE (g_steal_pointer (&s)); } /* the gobject_enum.value_infos are currently ignored for the getter. They * only declare additional aliases for the setter. */ if (property_info->property_typ_data) value_infos = property_info->property_typ_data->subtype.gobject_enum.value_infos_get; s = _nm_utils_enum_to_str_full (gtype, (int) v, ", ", value_infos); if (!format_numeric) RETURN_STR_TO_FREE (g_steal_pointer (&s)); if ( format_numeric_hex || ( format_numeric_hex_unknown && !G_IS_ENUM_CLASS (gtype_class ?: (gtype_class = g_type_class_ref (gtype))))) nm_sprintf_buf (s_numeric, "0x%"G_GINT64_FORMAT, v); else nm_sprintf_buf (s_numeric, "%"G_GINT64_FORMAT, v); if (nm_streq0 (s, s_numeric)) RETURN_STR_TO_FREE (g_steal_pointer (&s)); if (format_text_l10n) RETURN_STR_TO_FREE (g_strdup_printf (_("%s (%s)"), s_numeric, s)); else RETURN_STR_TO_FREE (g_strdup_printf ("%s (%s)", s_numeric, s)); } /*****************************************************************************/ static gboolean _set_fcn_gobject_string (ARGS_SET_FCN) { gs_free char *to_free = NULL; if (property_info->property_typ_data) { if (property_info->property_typ_data->subtype.gobject_string.validate_fcn) { value = property_info->property_typ_data->subtype.gobject_string.validate_fcn (value, &to_free, error); if (!value) return FALSE; } else if (property_info->property_typ_data->values_static) { value = nmc_string_is_valid (value, (const char **) property_info->property_typ_data->values_static, error); if (!value) return FALSE; } } g_object_set (setting, property_info->property_name, value, NULL); return TRUE; } static gboolean _set_fcn_gobject_bool (ARGS_SET_FCN) { gboolean val_bool; if (!nmc_string_to_bool (value, &val_bool, error)) return FALSE; g_object_set (setting, property_info->property_name, val_bool, NULL); return TRUE; } static gboolean _set_fcn_gobject_int (ARGS_SET_FCN) { int errsv; const GParamSpec *pspec; nm_auto_unset_gvalue GValue gval = G_VALUE_INIT; gboolean is_uint64; NMMetaSignUnsignInt64 v; gboolean has_minmax = FALSE; NMMetaSignUnsignInt64 min = { 0 }; NMMetaSignUnsignInt64 max = { 0 }; guint base = 10; const NMMetaUtilsIntValueInfo *value_infos; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (setting)), property_info->property_name); if (!G_IS_PARAM_SPEC (pspec)) g_return_val_if_reached (FALSE); is_uint64 = NM_IN_SET (pspec->value_type, G_TYPE_UINT, G_TYPE_UINT64); if (property_info->property_typ_data) { if ( value && (value_infos = property_info->property_typ_data->subtype.gobject_int.value_infos)) { gs_free char *vv_stripped = NULL; const char *vv = nm_str_skip_leading_spaces (value); if (vv[0] && g_ascii_isspace (vv[strlen (vv) - 1])) { vv_stripped = g_strstrip (g_strdup (vv)); vv = vv_stripped; } for (; value_infos->nick; value_infos++) { if (nm_streq (value_infos->nick, vv)) { v = value_infos->value; goto have_value_from_nick; } } } if (property_info->property_typ_data->subtype.gobject_int.base > 0) base = property_info->property_typ_data->subtype.gobject_int.base; if ( ( is_uint64 && ( property_info->property_typ_data->subtype.gobject_int.min.u64 || property_info->property_typ_data->subtype.gobject_int.max.u64)) || ( !is_uint64 && ( property_info->property_typ_data->subtype.gobject_int.min.i64 || property_info->property_typ_data->subtype.gobject_int.max.i64))) { min = property_info->property_typ_data->subtype.gobject_int.min; max = property_info->property_typ_data->subtype.gobject_int.max; has_minmax = TRUE; } } if (!has_minmax) { switch (pspec->value_type) { case G_TYPE_INT: { const GParamSpecInt *p = (GParamSpecInt *) pspec; min.i64 = p->minimum; max.i64 = p->maximum; } break; case G_TYPE_UINT: { const GParamSpecUInt *p = (GParamSpecUInt *) pspec; min.u64 = p->minimum; max.u64 = p->maximum; } break; case G_TYPE_INT64: { const GParamSpecInt64 *p = (GParamSpecInt64 *) pspec; min.i64 = p->minimum; max.i64 = p->maximum; } break; case G_TYPE_UINT64: { const GParamSpecUInt64 *p = (GParamSpecUInt64 *) pspec; min.u64 = p->minimum; max.u64 = p->maximum; } break; default: g_return_val_if_reached (FALSE); } } if (is_uint64) v.u64 = _nm_utils_ascii_str_to_uint64 (value, base, min.u64, max.u64, 0); else v.i64 = _nm_utils_ascii_str_to_int64 (value, base, min.i64, max.i64, 0); if ((errsv = errno) != 0) { if (errsv == ERANGE) { if (is_uint64) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("'%s' is out of range [%"G_GUINT64_FORMAT", %"G_GUINT64_FORMAT"]"), value, min.u64, max.u64); } else { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("'%s' is out of range [%"G_GINT64_FORMAT", %"G_GINT64_FORMAT"]"), value, min.i64, max.i64); } } else { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("'%s' is not a valid number"), value); } return FALSE; } have_value_from_nick: g_value_init (&gval, pspec->value_type); switch (pspec->value_type) { case G_TYPE_INT: g_value_set_int (&gval, v.i64); break; case G_TYPE_UINT: g_value_set_uint (&gval, v.u64); break; case G_TYPE_INT64: g_value_set_int64 (&gval, v.i64); break; case G_TYPE_UINT64: g_value_set_uint64 (&gval, v.u64); break; default: g_return_val_if_reached (FALSE); break; } /* Validate the number according to the property spec */ if (!nm_g_object_set_property (G_OBJECT (setting), property_info->property_name, &gval, error)) g_return_val_if_reached (FALSE); return TRUE; } static gboolean _set_fcn_gobject_mtu (ARGS_SET_FCN) { nm_auto_unset_gvalue GValue gval = G_VALUE_INIT; const GParamSpec *pspec; gint64 v; if (nm_streq0 (value, "auto")) value = "0"; pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (setting)), property_info->property_name); if (!pspec || pspec->value_type != G_TYPE_UINT) g_return_val_if_reached (FALSE); v = _nm_utils_ascii_str_to_int64 (value, 10, 0, G_MAXUINT32, -1); if (v < 0) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("'%s' is out of range [0, %u]"), value, (unsigned) G_MAXUINT32); return FALSE; } g_value_init (&gval, pspec->value_type); g_value_set_uint (&gval, v); if (!nm_g_object_set_property (G_OBJECT (setting), property_info->property_name, &gval, error)) g_return_val_if_reached (FALSE); return TRUE; } /* Ideally we'll be able to get this from a public header. */ #ifndef IEEE802154_ADDR_LEN #define IEEE802154_ADDR_LEN 8 #endif static gboolean _set_fcn_gobject_mac (ARGS_SET_FCN) { NMMetaPropertyTypeMacMode mode; gboolean valid; if (property_info->property_typ_data) mode = property_info->property_typ_data->subtype.mac.mode; else mode = NM_META_PROPERTY_TYPE_MAC_MODE_DEFAULT; if (mode == NM_META_PROPERTY_TYPE_MAC_MODE_INFINIBAND) { valid = nm_utils_hwaddr_valid (value, INFINIBAND_ALEN); } else if (mode == NM_META_PROPERTY_TYPE_MAC_MODE_WPAN) { valid = nm_utils_hwaddr_valid (value, IEEE802154_ADDR_LEN); } else { valid = nm_utils_hwaddr_valid (value, ETH_ALEN) || ( mode == NM_META_PROPERTY_TYPE_MAC_MODE_CLONED && NM_CLONED_MAC_IS_SPECIAL (value)); } if (!valid) { g_set_error (error, 1, 0, _("'%s' is not a valid Ethernet MAC"), value); return FALSE; } g_object_set (setting, property_info->property_name, value, NULL); return TRUE; } static gboolean _set_fcn_gobject_enum (ARGS_SET_FCN) { GType gtype = 0; GType gtype_prop; gboolean has_gtype = FALSE; nm_auto_unset_gvalue GValue gval = G_VALUE_INIT; nm_auto_unref_gtypeclass GTypeClass *gtype_class = NULL; gboolean is_flags; int v; if (property_info->property_typ_data) { if (property_info->property_typ_data->subtype.gobject_enum.get_gtype) { gtype = property_info->property_typ_data->subtype.gobject_enum.get_gtype (); has_gtype = TRUE; } } gtype_prop = _gobject_property_get_gtype (G_OBJECT (setting), property_info->property_name); if ( has_gtype && NM_IN_SET (gtype_prop, G_TYPE_INT, G_TYPE_UINT) && G_TYPE_IS_CLASSED (gtype) && (gtype_class = g_type_class_ref (gtype)) && ( (is_flags = G_IS_FLAGS_CLASS (gtype_class)) || G_IS_ENUM_CLASS (gtype_class))) { /* valid */ } else if ( !has_gtype && G_TYPE_IS_CLASSED (gtype_prop) && (gtype_class = g_type_class_ref (gtype_prop)) && ( (is_flags = G_IS_FLAGS_CLASS (gtype_class)) || G_IS_ENUM_CLASS (gtype_class))) { gtype = gtype_prop; } else g_return_val_if_reached (FALSE); if (!_nm_utils_enum_from_str_full (gtype, value, &v, NULL, property_info->property_typ_data ? property_info->property_typ_data->subtype.gobject_enum.value_infos : NULL)) goto fail; if ( property_info->property_typ_data && property_info->property_typ_data->subtype.gobject_enum.pre_set_notify) { property_info->property_typ_data->subtype.gobject_enum.pre_set_notify (property_info, environment, environment_user_data, setting, v); } g_value_init (&gval, gtype_prop); if (gtype_prop == G_TYPE_INT) g_value_set_int (&gval, v); else if (gtype_prop == G_TYPE_UINT) g_value_set_uint (&gval, v); else if (is_flags) { nm_assert (G_IS_FLAGS_CLASS (gtype_class)); g_value_set_flags (&gval, v); } else { nm_assert (G_IS_ENUM_CLASS (gtype_class)); g_value_set_enum (&gval, v); } if (!nm_g_object_set_property (G_OBJECT (setting), property_info->property_name, &gval, NULL)) goto fail; return TRUE; fail: if (error) { gs_free const char **valid_all = NULL; gs_free const char *valid_str = NULL; gboolean has_minmax = FALSE; int min = G_MININT; int max = G_MAXINT; if (property_info->property_typ_data) { if ( property_info->property_typ_data->subtype.gobject_enum.min || property_info->property_typ_data->subtype.gobject_enum.max) { min = property_info->property_typ_data->subtype.gobject_enum.min; max = property_info->property_typ_data->subtype.gobject_enum.max; has_minmax = TRUE; } } if (!has_minmax && is_flags) { min = 0; max = (int) G_MAXUINT; } valid_all = nm_utils_enum_get_values (gtype, min, max); valid_str = g_strjoinv (",", (char **) valid_all); if (is_flags) { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("invalid option '%s', use a combination of [%s]"), value, valid_str); } else { g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_INVALID_ARGUMENT, _("invalid option '%s', use one of [%s]"), value, valid_str); } } return FALSE; } /*****************************************************************************/ static const char *const* _values_fcn_gobject_enum (ARGS_VALUES_FCN) { GType gtype = 0; gboolean has_gtype = FALSE; gboolean has_minmax = FALSE; int min = G_MININT; int max = G_MAXINT; char **v; if (property_info->property_typ_data) { if ( property_info->property_typ_data->subtype.gobject_enum.min || property_info->property_typ_data->subtype.gobject_enum.max) { min = property_info->property_typ_data->subtype.gobject_enum.min; max = property_info->property_typ_data->subtype.gobject_enum.max; has_minmax = TRUE; } if (property_info->property_typ_data->subtype.gobject_enum.get_gtype) { gtype = property_info->property_typ_data->subtype.gobject_enum.get_gtype (); has_gtype = TRUE; } } if (!has_gtype) { gtype = _gtype_property_get_gtype (property_info->setting_info->general->get_setting_gtype (), property_info->property_name); } if ( !has_minmax && G_TYPE_IS_CLASSED (gtype)) { nm_auto_unref_gtypeclass GTypeClass *class = NULL; class = g_type_class_ref (gtype); if (G_IS_FLAGS_CLASS (class)) { min = 0; max = (int) G_MAXUINT; } } /* the gobject_enum.value_infos are currently ignored for the list of * values. They only declare additional (hidden) aliases for the setter. */ v = nm_utils_strv_make_deep_copied (nm_utils_enum_get_values (gtype, min, max)); return (const char *const*) (*out_to_free = v); } /*****************************************************************************/ static const char *const* _complete_fcn_gobject_bool (ARGS_COMPLETE_FCN) { static const char *const v[] = { "true", "false", "on", "off", "1", "0", "yes", "no", NULL, }; if (!text || !text[0]) return &v[6]; return v; } static const char *const* _complete_fcn_gobject_devices (ARGS_COMPLETE_FCN) { NMDevice *const*devices = NULL; guint i, j; guint len = 0; char **ifnames; if ( environment && environment->get_nm_devices) { devices = environment->get_nm_devices (environment, environment_user_data, &len); } if (len == 0) return NULL; ifnames = g_new (char *, len + 1); for (i = 0, j = 0; i < len; i++) { const char *ifname; nm_assert (NM_IS_DEVICE (devices[i])); ifname = nm_device_get_iface (devices[i]); if (ifname) ifnames[j++] = g_strdup (ifname); } ifnames[j++] = NULL; *out_to_free = ifnames; return (const char *const*) ifnames; } /*****************************************************************************/ static char * wep_key_type_to_string (NMWepKeyType type) { switch (type) { case NM_WEP_KEY_TYPE_KEY: return g_strdup_printf (_("%d (key)"), type); case NM_WEP_KEY_TYPE_PASSPHRASE: return g_strdup_printf (_("%d (passphrase)"), type); case NM_WEP_KEY_TYPE_UNKNOWN: default: return g_strdup_printf (_("%d (unknown)"), type); } } static char * bytes_to_string (GBytes *bytes) { const guint8 *data; gsize len; GString *cert = NULL; int i; if (!bytes) return NULL; data = g_bytes_get_data (bytes, &len); cert = g_string_new (NULL); for (i = 0; i < len; i++) g_string_append_printf (cert, "%02X", data[i]); return g_string_free (cert, FALSE); } static char * vlan_flags_to_string (guint32 flags, NMMetaAccessorGetType get_type) { GString *flag_str; if (get_type != NM_META_ACCESSOR_GET_TYPE_PRETTY) return g_strdup_printf ("%u", flags); if (flags == 0) return g_strdup (_("0 (NONE)")); flag_str = g_string_new (NULL); g_string_printf (flag_str, "%d (", flags); if (flags & NM_VLAN_FLAG_REORDER_HEADERS) g_string_append (flag_str, _("REORDER_HEADERS, ")); if (flags & NM_VLAN_FLAG_GVRP) g_string_append (flag_str, _("GVRP, ")); if (flags & NM_VLAN_FLAG_LOOSE_BINDING) g_string_append (flag_str, _("LOOSE_BINDING, ")); if (flags & NM_VLAN_FLAG_MVRP) g_string_append (flag_str, _("MVRP, ")); if (flag_str->str[flag_str->len-1] == '(') g_string_append (flag_str, _("unknown")); else g_string_truncate (flag_str, flag_str->len-2); /* chop off trailing ', ' */ g_string_append_c (flag_str, ')'); return g_string_free (flag_str, FALSE); } static char * vlan_priorities_to_string (NMSettingVlan *s_vlan, NMVlanPriorityMap map) { GString *priorities; int i; priorities = g_string_new (NULL); for (i = 0; i < nm_setting_vlan_get_num_priorities (s_vlan, map); i++) { guint32 from, to; if (nm_setting_vlan_get_priority (s_vlan, map, i, &from, &to)) g_string_append_printf (priorities, "%d:%d,", from, to); } if (priorities->len) g_string_truncate (priorities, priorities->len-1); /* chop off trailing ',' */ return g_string_free (priorities, FALSE); } static char * secret_flags_to_string (guint32 flags, NMMetaAccessorGetType get_type) { GString *flag_str; if (get_type != NM_META_ACCESSOR_GET_TYPE_PRETTY) return g_strdup_printf ("%u", flags); if (flags == 0) return g_strdup (_("0 (none)")); flag_str = g_string_new (NULL); g_string_printf (flag_str, "%u (", flags); if (flags & NM_SETTING_SECRET_FLAG_AGENT_OWNED) g_string_append (flag_str, _("agent-owned, ")); if (flags & NM_SETTING_SECRET_FLAG_NOT_SAVED) g_string_append (flag_str, _("not saved, ")); if (flags & NM_SETTING_SECRET_FLAG_NOT_REQUIRED) g_string_append (flag_str, _("not required, ")); if (flag_str->str[flag_str->len-1] == '(') g_string_append (flag_str, _("unknown")); else g_string_truncate (flag_str, flag_str->len-2); /* chop off trailing ', ' */ g_string_append_c (flag_str, ')'); return g_string_free (flag_str, FALSE); } static void vpn_data_item (const char *key, const char *value, gpointer user_data) { GString *ret_str = (GString *) user_data; if (ret_str->len != 0) g_string_append (ret_str, ", "); g_string_append_printf (ret_str, "%s = %s", key, value); } #define DEFINE_SETTER_STR_LIST_MULTI(def_func, s_macro, set_func) \ static gboolean \ def_func (NMSetting *setting, \ const char *prop, \ const char *value, \ const char **valid_strv, \ GError **error) \ { \ gs_free const char **strv = NULL; \ gsize i; \ const char *item; \ nm_assert (!error || !*error); \ strv = nm_utils_strsplit_set (value, " \t,", FALSE); \ if (strv) { \ for (i = 0; strv[i]; i++) { \ if (!(item = nmc_string_is_valid (strv[i], valid_strv, error))) { \ return FALSE; \ } \ set_func (s_macro (setting), item); \ } \ } \ return TRUE; \ } #define DEFINE_SETTER_OPTIONS(def_func, s_macro, s_type, add_func, valid_func1, valid_func2) \ static gboolean \ def_func (ARGS_SET_FCN) \ { \ gs_free const char **strv = NULL; \ const char **iter; \ const char **(*valid_func1_p) (s_type *) = valid_func1; \ const char * (*valid_func2_p) (const char *, const char *, GError **) = valid_func2; \ const char *opt_name, *opt_val; \ \ nm_assert (!error || !*error); \ \ strv = nm_utils_strsplit_set (value, ",", FALSE); \ for (iter = strv; iter && *iter; iter++) { \ gs_free char *left_clone = g_strstrip (g_strdup (*iter)); \ char *left = left_clone; \ char *right = strchr (left, '='); \ if (!right) { \ g_set_error (error, 1, 0, _("'%s' is not valid; use