system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-07-22 02:35:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
NetworkManager/dispatcher/nm-dispatcher-utils.c
Thomas Haller 2800232bbf dispatcher: add NM_DISPATCHER_ACTION environment variable 
Previously, the action was only passed as the first command line
argument to the dispatcher scripts. Now, also set it via the
"$NM_DISPATCHER_ACTION" environment variable.

The main purpose is to have a particular, nm-dispatcher specific
variable that is always set inside the dispatcher scripts.
For example, imagine you have a script that can be either called by
dispatcher or some other means (manually, or spawned via
/etc/NetworkManager/dispatcher.d/11-dhclient).  Then it might make
sense to differenciate from inside the script whether you are called
by nm-dispatcher. But previously, there was no specific environment
variable that was always set inside the dispatcher event. For example,
with the "hostname" action there are no other environment variables.

Now (with version 1.12), you can check for `test -n "$NM_DISPATCHER_ACTION"`.

(cherry picked from commit ce9619047c)
2018-06-18 14:19:16 +02:00

584 lines
16 KiB
C
Raw Blame History

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* 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 (C) 2008 - 2011 Red Hat, Inc.
*/
#include "nm-default.h"
#include <string.h>
#include "nm-dbus-interface.h"
#include "nm-connection.h"
#include "nm-setting-ip4-config.h"
#include "nm-setting-ip6-config.h"
#include "nm-setting-connection.h"
#include "nm-dispatcher-api.h"
#include "nm-utils.h"
#include "nm-dispatcher-utils.h"
/*****************************************************************************/
static gboolean
_is_valid_key (const char *line, gssize len)
{
gsize i, l;
char ch;
if (!line)
return FALSE;
if (len < 0)
len = strlen (line);
if (len == 0)
return FALSE;
ch = line[0];
if ( !(ch >= 'A' && ch <= 'Z')
&& !NM_IN_SET (ch, '_'))
return FALSE;
l = (gsize) len;
for (i = 1; i < l; i++) {
ch = line[i];
if ( !(ch >= 'A' && ch <= 'Z')
&& !(ch >= '0' && ch <= '9')
&& !NM_IN_SET (ch, '_'))
return FALSE;
}
return TRUE;
}
static gboolean
_is_valid_line (const char *line)
{
const char *d;
if (!line)
return FALSE;
d = strchr (line, '=');
if (!d || d == line)
return FALSE;
return _is_valid_key (line, d - line);
}
static char *
_sanitize_var_name (const char *key)
{
char *sanitized;
nm_assert (key);
if (!key[0])
return NULL;
sanitized = g_ascii_strup (key, -1);
if (!NM_STRCHAR_ALL (sanitized, ch, (ch >= 'A' && ch <= 'Z')
|| (ch >= '0' && ch <= '9')
|| NM_IN_SET (ch, '_'))) {
g_free (sanitized);
return NULL;
}
nm_assert (_is_valid_key (sanitized, -1));
return sanitized;
}
static void
_items_add_str_take (GPtrArray *items, char *line)
{
nm_assert (items);
nm_assert (_is_valid_line (line));
g_ptr_array_add (items, line);
}
static void
_items_add_str (GPtrArray *items, const char *line)
{
_items_add_str_take (items, g_strdup (line));
}
static void
_items_add_key (GPtrArray *items, const char *prefix, const char *key, const char *value)
{
nm_assert (items);
nm_assert (_is_valid_key (key, -1));
nm_assert (value);
_items_add_str_take (items, g_strconcat (prefix ?: "", key, "=", value, NULL));
}
static void
_items_add_key0 (GPtrArray *items, const char *prefix, const char *key, const char *value)
{
nm_assert (items);
nm_assert (_is_valid_key (key, -1));
if (!value) {
/* for convenience, allow NULL values to indicate to skip the line. */
return;
}
_items_add_str_take (items, g_strconcat (prefix ?: "", key, "=", value, NULL));
}
G_GNUC_PRINTF (2, 3)
static void
_items_add_printf (GPtrArray *items, const char *fmt, ...)
{
va_list ap;
char *line;
nm_assert (items);
nm_assert (fmt);
va_start (ap, fmt);
line = g_strdup_vprintf (fmt, ap);
va_end (ap);
_items_add_str_take (items, line);
}
static void
_items_add_strv (GPtrArray *items, const char *prefix, const char *key, const char *const*values)
{
gboolean has;
guint i;
GString *str;
nm_assert (items);
nm_assert (_is_valid_key (key, -1));
if (!values || !values[0]) {
/* Only add an item if the list of @values is not empty */
return;
}
str = g_string_new (NULL);
if (prefix)
g_string_append (str, prefix);
g_string_append (str, key);
g_string_append_c (str, '=');
has = FALSE;
for (i = 0; values[i]; i++) {
if (!values[i][0])
continue;
if (has)
g_string_append_c (str, ' ');
else
has = TRUE;
g_string_append (str, values[i]);
}
_items_add_str_take (items, g_string_free (str, FALSE));
}
/*****************************************************************************/
static void
construct_proxy_items (GPtrArray *items, GVariant *proxy_config, const char *prefix)
{
GVariant *variant;
nm_assert (items);
if (!proxy_config)
return;
variant = g_variant_lookup_value (proxy_config, "pac-url", G_VARIANT_TYPE_STRING);
if (variant) {
_items_add_key (items, prefix, "PROXY_PAC_URL",
g_variant_get_string (variant, NULL));
g_variant_unref (variant);
}
variant = g_variant_lookup_value (proxy_config, "pac-script", G_VARIANT_TYPE_STRING);
if (variant) {
_items_add_key (items, prefix, "PROXY_PAC_SCRIPT",
g_variant_get_string (variant, NULL));
g_variant_unref (variant);
}
}
static void
construct_ip_items (GPtrArray *items, int addr_family, GVariant *ip_config, const char *prefix)
{
GVariant *val;
guint i;
guint nroutes = 0;
char four_or_six;
if (!ip_config)
return;
if (!prefix)
prefix = "";
four_or_six = nm_utils_addr_family_to_char (addr_family);
val = g_variant_lookup_value (ip_config,
"addresses",
addr_family == AF_INET
? G_VARIANT_TYPE ("aau")
: G_VARIANT_TYPE ("a(ayuay)"));
if (val) {
gs_unref_ptrarray GPtrArray *addresses = NULL;
gs_free char *gateway_free = NULL;
const char *gateway;
if (addr_family == AF_INET)
addresses = nm_utils_ip4_addresses_from_variant (val, &gateway_free);
else
addresses = nm_utils_ip6_addresses_from_variant (val, &gateway_free);
gateway = gateway_free ?: "0.0.0.0";
if (addresses && addresses->len) {
for (i = 0; i < addresses->len; i++) {
NMIPAddress *addr = addresses->pdata[i];
_items_add_printf (items,
"%sIP%c_ADDRESS_%d=%s/%d %s",
prefix,
four_or_six,
i,
nm_ip_address_get_address (addr),
nm_ip_address_get_prefix (addr),
gateway);
}
_items_add_printf (items,
"%sIP%c_NUM_ADDRESSES=%u",
prefix,
four_or_six,
addresses->len);
}
_items_add_key (items,
prefix,
addr_family == AF_INET
? "IP4_GATEWAY"
: "IP6_GATEWAY",
gateway);
g_variant_unref (val);
}
val = g_variant_lookup_value (ip_config,
"nameservers",
addr_family == AF_INET
? G_VARIANT_TYPE ("au")
: G_VARIANT_TYPE ("aay"));
if (val) {
gs_strfreev char **v = NULL;
if (addr_family == AF_INET)
v = nm_utils_ip4_dns_from_variant (val);
else
v = nm_utils_ip6_dns_from_variant (val);
_items_add_strv (items,
prefix,
addr_family == AF_INET
? "IP4_NAMESERVERS"
: "IP6_NAMESERVERS",
NM_CAST_STRV_CC (v));
g_variant_unref (val);
}
val = g_variant_lookup_value (ip_config, "domains", G_VARIANT_TYPE_STRING_ARRAY);
if (val) {
gs_free const char **v = NULL;
v = g_variant_get_strv (val, NULL);
_items_add_strv (items, prefix,
addr_family == AF_INET
? "IP4_DOMAINS"
: "IP6_DOMAINS",
v);
g_variant_unref (val);
}
if (addr_family == AF_INET) {
val = g_variant_lookup_value (ip_config, "wins-servers", G_VARIANT_TYPE ("au"));
if (val) {
gs_strfreev char **v = NULL;
v = nm_utils_ip4_dns_from_variant (val);
_items_add_strv (items, prefix, "IP4_WINS_SERVERS", NM_CAST_STRV_CC (v));
g_variant_unref (val);
}
}
val = g_variant_lookup_value (ip_config,
"routes",
addr_family == AF_INET
? G_VARIANT_TYPE ("aau")
: G_VARIANT_TYPE ("a(ayuayu)"));
if (val) {
gs_unref_ptrarray GPtrArray *routes = NULL;
if (addr_family == AF_INET)
routes = nm_utils_ip4_routes_from_variant (val);
else
routes = nm_utils_ip6_routes_from_variant (val);
if ( routes
&& routes->len > 0) {
const char *const DEFAULT_GW = addr_family == AF_INET ? "0.0.0.0" : "::";
nroutes = routes->len;
for (i = 0; i < routes->len; i++) {
NMIPRoute *route = routes->pdata[i];
_items_add_printf (items,
"%sIP%c_ROUTE_%u=%s/%d %s %u",
prefix,
four_or_six,
i,
nm_ip_route_get_dest (route),
nm_ip_route_get_prefix (route),
nm_ip_route_get_next_hop (route) ?: DEFAULT_GW,
(guint) NM_MAX ((gint64) 0, nm_ip_route_get_metric (route)));
}
}
g_variant_unref (val);
}
if (nroutes > 0 || addr_family == AF_INET) {
/* we also set IP4_NUM_ROUTES=0, but don't do so for addresses and IPv6 routes.
* Historic reasons. */
_items_add_printf (items, "%sIP%c_NUM_ROUTES=%u", prefix, four_or_six, nroutes);
}
}
static void
construct_device_dhcp_items (GPtrArray *items, int addr_family, GVariant *dhcp_config)
{
GVariantIter iter;
const char *key;
GVariant *val;
char four_or_six;
if (!dhcp_config)
return;
if (!g_variant_is_of_type (dhcp_config, G_VARIANT_TYPE_VARDICT))
return;
four_or_six = nm_utils_addr_family_to_char (addr_family);
g_variant_iter_init (&iter, dhcp_config);
while (g_variant_iter_next (&iter, "{&sv}", &key, &val)) {
if (g_variant_is_of_type (val, G_VARIANT_TYPE_STRING)) {
gs_free char *ucased = NULL;
ucased = _sanitize_var_name (key);
if (ucased) {
_items_add_printf (items,
"DHCP%c_%s=%s",
four_or_six,
ucased,
g_variant_get_string (val, NULL));
}
}
g_variant_unref (val);
}
}
/*****************************************************************************/
char **
nm_dispatcher_utils_construct_envp (const char *action,
GVariant *connection_dict,
GVariant *connection_props,
GVariant *device_props,
GVariant *device_proxy_props,
GVariant *device_ip4_props,
GVariant *device_ip6_props,
GVariant *device_dhcp4_props,
GVariant *device_dhcp6_props,
const char *connectivity_state,
const char *vpn_ip_iface,
GVariant *vpn_proxy_props,
GVariant *vpn_ip4_props,
GVariant *vpn_ip6_props,
char **out_iface,
const char **out_error_message)
{
const char *iface = NULL;
const char *ip_iface = NULL;
const char *uuid = NULL;
const char *id = NULL;
const char *path = NULL;
const char *filename = NULL;
gboolean external;
NMDeviceState dev_state = NM_DEVICE_STATE_UNKNOWN;
GVariant *variant;
gs_unref_ptrarray GPtrArray *items = NULL;
const char *error_message_backup;
if (!out_error_message)
out_error_message = &error_message_backup;
g_return_val_if_fail (action != NULL, NULL);
g_return_val_if_fail (out_iface != NULL, NULL);
g_return_val_if_fail (*out_iface == NULL, NULL);
items = g_ptr_array_new_with_free_func (g_free);
/* Hostname and connectivity changes don't require a device nor contain a connection */
if (NM_IN_STRSET (action, NMD_ACTION_HOSTNAME,
NMD_ACTION_CONNECTIVITY_CHANGE))
goto done;
/* Connection properties */
if (!g_variant_lookup (connection_props, NMD_CONNECTION_PROPS_PATH, "&o", &path)) {
*out_error_message = "Missing or invalid required value " NMD_CONNECTION_PROPS_PATH "!";
return NULL;
}
_items_add_key (items, NULL, "CONNECTION_DBUS_PATH", path);
if (g_variant_lookup (connection_props, NMD_CONNECTION_PROPS_EXTERNAL, "b", &external) && external)
_items_add_str (items, "CONNECTION_EXTERNAL=1");
if (g_variant_lookup (connection_props, NMD_CONNECTION_PROPS_FILENAME, "&s", &filename))
_items_add_key (items, NULL, "CONNECTION_FILENAME", filename);
/* Canonicalize the VPN interface name; "" is used when passing it through
* D-Bus so make sure that's fixed up here.
*/
if (vpn_ip_iface && !vpn_ip_iface[0])
vpn_ip_iface = NULL;
if (!g_variant_lookup (device_props, NMD_DEVICE_PROPS_INTERFACE, "&s", &iface)) {
*out_error_message = "Missing or invalid required value " NMD_DEVICE_PROPS_INTERFACE "!";
return NULL;
}
if (!*iface)
iface = NULL;
variant = g_variant_lookup_value (device_props, NMD_DEVICE_PROPS_IP_INTERFACE, NULL);
if (variant) {
if (!g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING)) {
*out_error_message = "Invalid value " NMD_DEVICE_PROPS_IP_INTERFACE "!";
return NULL;
}
g_variant_unref (variant);
(void) g_variant_lookup (device_props, NMD_DEVICE_PROPS_IP_INTERFACE, "&s", &ip_iface);
}
if (!g_variant_lookup (device_props, NMD_DEVICE_PROPS_TYPE, "u", NULL)) {
*out_error_message = "Missing or invalid required value " NMD_DEVICE_PROPS_TYPE "!";
return NULL;
}
variant = g_variant_lookup_value (device_props, NMD_DEVICE_PROPS_STATE, G_VARIANT_TYPE_UINT32);
if (!variant) {
*out_error_message = "Missing or invalid required value " NMD_DEVICE_PROPS_STATE "!";
return NULL;
}
dev_state = g_variant_get_uint32 (variant);
g_variant_unref (variant);
if (!g_variant_lookup (device_props, NMD_DEVICE_PROPS_PATH, "o", NULL)) {
*out_error_message = "Missing or invalid required value " NMD_DEVICE_PROPS_PATH "!";
return NULL;
}
{
gs_unref_variant GVariant *con_setting = NULL;
con_setting = g_variant_lookup_value (connection_dict, NM_SETTING_CONNECTION_SETTING_NAME, NM_VARIANT_TYPE_SETTING);
if (!con_setting) {
*out_error_message = "Failed to read connection setting";
return NULL;
}
if (!g_variant_lookup (con_setting, NM_SETTING_CONNECTION_UUID, "&s", &uuid)) {
*out_error_message = "Connection hash did not contain the UUID";
return NULL;
}
if (!g_variant_lookup (con_setting, NM_SETTING_CONNECTION_ID, "&s", &id)) {
*out_error_message = "Connection hash did not contain the ID";
return NULL;
}
_items_add_key0 (items, NULL, "CONNECTION_UUID", uuid);
_items_add_key0 (items, NULL, "CONNECTION_ID", id);
_items_add_key0 (items, NULL, "DEVICE_IFACE", iface);
_items_add_key0 (items, NULL, "DEVICE_IP_IFACE", ip_iface);
}
/* Device it's aren't valid if the device isn't activated */
if ( iface
&& dev_state == NM_DEVICE_STATE_ACTIVATED) {
construct_proxy_items (items, device_proxy_props, NULL);
construct_ip_items (items, AF_INET, device_ip4_props, NULL);
construct_ip_items (items, AF_INET6, device_ip6_props, NULL);
construct_device_dhcp_items (items, AF_INET, device_dhcp4_props);
construct_device_dhcp_items (items, AF_INET6, device_dhcp6_props);
}
if (vpn_ip_iface) {
_items_add_key (items, NULL, "VPN_IP_IFACE", vpn_ip_iface);
construct_proxy_items (items, vpn_proxy_props, "VPN_");
construct_ip_items (items, AF_INET, vpn_ip4_props, "VPN_");
construct_ip_items (items, AF_INET6, vpn_ip6_props, "VPN_");
}
/* Backwards compat: 'iface' is set in this order:
* 1) VPN interface name
* 2) Device IP interface name
* 3) Device interface anme
*/
if (vpn_ip_iface)
*out_iface = g_strdup (vpn_ip_iface);
else if (ip_iface)
*out_iface = g_strdup (ip_iface);
else
*out_iface = g_strdup (iface);
done:
/* The connectivity_state value will only be meaningful for 'connectivity-change' events
* (otherwise it will be "UNKNOWN"), so we only set the environment variable in those cases.
*/
if (!NM_IN_STRSET (connectivity_state, NULL, "UNKNOWN"))
_items_add_key (items, NULL, "CONNECTIVITY_STATE", connectivity_state);
_items_add_key0 (items, NULL, "PATH", g_getenv ("PATH"));
_items_add_key (items, NULL, "NM_DISPATCHER_ACTION", action);
*out_error_message = NULL;
g_ptr_array_add (items, NULL);
return (char **) g_ptr_array_free (g_steal_pointer (&items), FALSE);
}
Reference in a new issue View git blame Copy permalink