fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-05-05 04:08:01 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

dns: merge branch 'th/dns-rc-manager-bgo765387'

Browse source 
https://bugzilla.gnome.org/show_bug.cgi?id=765387
This commit is contained in:
Thomas Haller 2016-04-26 14:02:06 +02:00
commit 87ded99611
4 changed files with 150 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
man/NetworkManager.conf.xml
View file

@ -303,7 +303,8 @@ no-auto-default=*
configuration with DNSSEC support. The /etc/resolv.conf
will be managed by dnssec-trigger daemon.</para>
<para><literal>none</literal>: NetworkManager will not
modify resolv.conf.</para>
modify resolv.conf. This implies <varname>rc-manager</varname>
<literal>unmanaged</literal></para>
</listitem>
</varlistentry>
@ -313,7 +314,7 @@ no-auto-default=*
management mode. The default value depends on how NetworkManager
was built. Regardless of this setting, NetworkManager will
always write resolv.conf to its runtime state directory.</para>
<para><literal>none</literal>: NetworkManager will symlink
<para><literal>symlink</literal>: NetworkManager will symlink
<filename>/etc/resolv.conf</filename> to its private
resolv.conf file in the runtime state directory.</para>
<para><literal>file</literal>: NetworkManager will write
@ -322,6 +323,10 @@ no-auto-default=*
resolvconf to update the DNS configuration.</para>
<para><literal>netconfig</literal>: NetworkManager will run
netconfig to update the DNS configuration.</para>
<para><literal>unmanaged</literal>: don't touch
<filename>resolv.conf</filename>.</para>
<para><literal>none</literal>: deprecated alias for
<literal>symlink</literal>.</para>
</listitem>
</varlistentry>

10
src/devices/nm-device.c
View file

@ -8822,14 +8822,13 @@ update_ip4_config (NMDevice *self, gboolean initial)
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
int ifindex;
gboolean capture_resolv_conf;
NMDnsManagerResolvConfMode resolv_conf_mode;
ifindex = nm_device_get_ip_ifindex (self);
if (!ifindex)
return;
resolv_conf_mode = nm_dns_manager_get_resolv_conf_mode (nm_dns_manager_get ());
capture_resolv_conf = initial && (resolv_conf_mode == NM_DNS_MANAGER_RESOLV_CONF_EXPLICIT);
capture_resolv_conf = initial
&& nm_dns_manager_get_resolv_conf_explicit (nm_dns_manager_get ());
/* IPv4 */
g_clear_object (&priv->ext_ip4_config);
@ -8900,14 +8899,13 @@ update_ip6_config (NMDevice *self, gboolean initial)
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
int ifindex;
gboolean capture_resolv_conf;
NMDnsManagerResolvConfMode resolv_conf_mode;
ifindex = nm_device_get_ip_ifindex (self);
if (!ifindex)
return;
resolv_conf_mode = nm_dns_manager_get_resolv_conf_mode (nm_dns_manager_get ());
capture_resolv_conf = initial && (resolv_conf_mode == NM_DNS_MANAGER_RESOLV_CONF_EXPLICIT);
capture_resolv_conf = initial
&& nm_dns_manager_get_resolv_conf_explicit (nm_dns_manager_get ());
/* IPv6 */
g_clear_object (&priv->ext_ip6_config);

243
src/dns-manager/nm-dns-manager.c
View file

@ -121,11 +121,7 @@ typedef struct _NMDnsManagerPrivate {
guint8 hash[HASH_LEN]; /* SHA1 hash of current DNS config */
guint8 prev_hash[HASH_LEN]; /* Hash when begin_updates() was called */
NMDnsManagerResolvConfMode resolv_conf_mode;
NMDnsManagerResolvConfManager rc_manager;
char *last_mode;
bool last_immutable:1;
bool mode_initialized:1;
NMDnsPlugin *plugin;
NMConfig *config;
@ -164,11 +160,13 @@ typedef struct {
NM_UTILS_LOOKUP_STR_DEFINE_STATIC (_rc_manager_to_string, NMDnsManagerResolvConfManager,
NM_UTILS_LOOKUP_DEFAULT_WARN (NULL),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE, "none"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE, "file"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF, "resolvconf"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG, "netconfig"),
NM_UTILS_LOOKUP_ITEM_IGNORE (_NM_DNS_MANAGER_RESOLV_CONF_MAN_INTERNAL_ONLY),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_UNKNOWN, "unknown"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED, "unmanaged"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_IMMUTABLE, "immutable"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK, "symlink"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE, "file"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF, "resolvconf"),
NM_UTILS_LOOKUP_STR_ITEM (NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG, "netconfig"),
);
static void
@ -585,7 +583,7 @@ update_resolv_conf (NMDnsManager *self,
*
* This is the only situation, where we don't try to update our
* internal resolv.conf file. */
if (rc_manager == _NM_DNS_MANAGER_RESOLV_CONF_MAN_INTERNAL_ONLY) {
if (rc_manager == NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED) {
gs_free char *path = g_file_read_link (_PATH_RESCONF, NULL);
if (g_strcmp0 (path, MY_RESOLV_CONF) == 0) {
@ -673,7 +671,7 @@ update_resolv_conf (NMDnsManager *self,
return write_file_result;
}
if (rc_manager != NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE) {
if (rc_manager != NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK) {
_LOGT ("update-resolv-conf: write internal file %s succeeded", MY_RESOLV_CONF);
return SR_SUCCESS;
}
@ -908,7 +906,8 @@ update_dns (NMDnsManager *self,
priv = NM_DNS_MANAGER_GET_PRIVATE (self);
nm_clear_g_source (&priv->plugin_ratelimit.timer);
if (priv->resolv_conf_mode == NM_DNS_MANAGER_RESOLV_CONF_UNMANAGED) {
if (NM_IN_SET (priv->rc_manager, NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED,
NM_DNS_MANAGER_RESOLV_CONF_MAN_IMMUTABLE)) {
update = FALSE;
_LOGD ("update-dns: not updating resolv.conf");
} else {
@ -1068,7 +1067,7 @@ update_dns (NMDnsManager *self,
if (update) {
switch (priv->rc_manager) {
case NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE:
case NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK:
case NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE:
result = update_resolv_conf (self, searches, nameservers, options, error, priv->rc_manager);
resolv_conf_updated = TRUE;
@ -1087,7 +1086,7 @@ update_dns (NMDnsManager *self,
if (result == SR_NOTFOUND) {
_LOGD ("update-dns: program not available, writing to resolv.conf");
g_clear_error (error);
result = update_resolv_conf (self, searches, nameservers, options, error, NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE);
result = update_resolv_conf (self, searches, nameservers, options, error, NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK);
resolv_conf_updated = TRUE;
}
}
@ -1095,7 +1094,7 @@ update_dns (NMDnsManager *self,
/* Unless we've already done it, update private resolv.conf in NMRUNDIR
ignoring any errors */
if (!resolv_conf_updated)
update_resolv_conf (self, searches, nameservers, options, NULL, _NM_DNS_MANAGER_RESOLV_CONF_MAN_INTERNAL_ONLY);
update_resolv_conf (self, searches, nameservers, options, NULL, NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED);
/* signal that resolv.conf was changed */
if (update && result == SR_SUCCESS)
@ -1359,10 +1358,21 @@ nm_dns_manager_set_hostname (NMDnsManager *self,
}
}
NMDnsManagerResolvConfMode
nm_dns_manager_get_resolv_conf_mode (NMDnsManager *self)
gboolean
nm_dns_manager_get_resolv_conf_explicit (NMDnsManager *self)
{
return NM_DNS_MANAGER_GET_PRIVATE (self)->resolv_conf_mode;
NMDnsManagerPrivate *priv;
g_return_val_if_fail (NM_IS_DNS_MANAGER (self), FALSE);
priv = NM_DNS_MANAGER_GET_PRIVATE (self);
if ( NM_IN_SET (priv->rc_manager, NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED,
NM_DNS_MANAGER_RESOLV_CONF_MAN_IMMUTABLE)
|| priv->plugin)
return FALSE;
return TRUE;
}
void
@ -1417,22 +1427,66 @@ nm_dns_manager_end_updates (NMDnsManager *self, const char *func)
/******************************************************************/
static gboolean
_clear_plugin (NMDnsManager *self)
{
NMDnsManagerPrivate *priv = NM_DNS_MANAGER_GET_PRIVATE (self);
if (priv->plugin) {
g_signal_handlers_disconnect_by_func (priv->plugin, plugin_failed, self);
g_signal_handlers_disconnect_by_func (priv->plugin, plugin_child_quit, self);
g_clear_object (&priv->plugin);
return TRUE;
}
return FALSE;
}
static NMDnsManagerResolvConfManager
_get_resolv_conf_manager_default (void)
{
#if defined(RESOLVCONF_SELECTED)
return NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF;
#elif defined(NETCONFIG_SELECTED)
return NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG;
#else
return NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK;
#endif
}
static NMDnsManagerResolvConfManager
_get_resolv_conf_manager (NMConfig *config)
{
const char *man;
man = nm_config_data_get_rc_manager (nm_config_get_data (config));
if (!man)
return _get_resolv_conf_manager_default ();
if (NM_IN_STRSET (man, "symlink", "none"))
return NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK;
if (nm_streq (man, "file"))
return NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE;
if (nm_streq (man, "resolvconf"))
return NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF;
if (nm_streq (man, "netconfig"))
return NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG;
if (nm_streq (man, "unmanaged"))
return NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED;
return NM_DNS_MANAGER_RESOLV_CONF_MAN_UNKNOWN;
}
static bool
_get_resconf_immutable (int *immutable_cached)
_get_resconf_immutable (void)
{
int fd, flags;
int immutable;
bool immutable = FALSE;
immutable = *immutable_cached;
if (!NM_IN_SET (immutable, FALSE, TRUE)) {
immutable = FALSE;
fd = open (_PATH_RESCONF, O_RDONLY);
if (fd != -1) {
if (ioctl (fd, FS_IOC_GETFLAGS, &flags) != -1)
immutable = NM_FLAGS_HAS (flags, FS_IMMUTABLE_FL);
close (fd);
}
*immutable_cached = immutable;
fd = open (_PATH_RESCONF, O_RDONLY);
if (fd != -1) {
if (ioctl (fd, FS_IOC_GETFLAGS, &flags) != -1)
immutable = NM_FLAGS_HAS (flags, FS_IMMUTABLE_FL);
close (fd);
}
return immutable;
}
@ -1443,96 +1497,58 @@ static void
init_resolv_conf_mode (NMDnsManager *self)
{
NMDnsManagerPrivate *priv = NM_DNS_MANAGER_GET_PRIVATE (self);
const char *mode, *mode_unknown;
int immutable = -1;
NMDnsManagerResolvConfManager rc_manager;
const char *mode;
gboolean plugin_changed = FALSE;
mode = nm_config_data_get_dns_mode (nm_config_get_data (priv->config));
if ( priv->mode_initialized
&& nm_streq0 (mode, priv->last_mode)
&& ( nm_streq0 (mode, "none")
|| priv->last_immutable == _get_resconf_immutable (&immutable))) {
/* we call init_resolv_conf_mode() on every SIGHUP to possibly reload
* when either "mode" or "immutable" changed. However, we don't want to
* re-create the plugin, when the paramters didn't actually change. So
* detect that we would recreate the same plugin and return early. */
return;
if (nm_streq0 (mode, "none"))
rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED;
else if (_get_resconf_immutable ())
rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_IMMUTABLE;
else {
rc_manager = _get_resolv_conf_manager (priv->config);
if (rc_manager == NM_DNS_MANAGER_RESOLV_CONF_MAN_UNKNOWN) {
_LOGW ("init: unknown resolv.conf manager '%s'",
nm_config_data_get_rc_manager (nm_config_get_data (priv->config)));
rc_manager = _get_resolv_conf_manager_default ();
}
}
priv->mode_initialized = TRUE;
g_free (priv->last_mode);
priv->last_mode = g_strdup (mode);
priv->last_immutable = FALSE;
g_clear_object (&priv->plugin);
priv->resolv_conf_mode = NM_DNS_MANAGER_RESOLV_CONF_UNMANAGED;
if (nm_streq0 (mode, "none")) {
_LOGI ("%s%s", "set resolv-conf-mode: ", "none");
return;
}
priv->last_immutable = _get_resconf_immutable (&immutable);
if (NM_IN_STRSET (mode, "dnsmasq", "unbound")) {
if (!immutable)
priv->resolv_conf_mode = NM_DNS_MANAGER_RESOLV_CONF_PROXY;
if (nm_streq (mode, "dnsmasq"))
if (nm_streq0 (mode, "dnsmasq")) {
if (!NM_IS_DNS_DNSMASQ (priv->plugin)) {
_clear_plugin (self);
priv->plugin = nm_dns_dnsmasq_new ();
else
plugin_changed = TRUE;
}
} else if (nm_streq0 (mode, "unbound")) {
if (!NM_IS_DNS_UNBOUND (priv->plugin)) {
_clear_plugin (self);
priv->plugin = nm_dns_unbound_new ();
plugin_changed = TRUE;
}
} else {
if (!NM_IN_STRSET (mode, NULL, "none", "default")) {
_LOGW ("init: unknown dns mode '%s'", mode);
mode = "default";
}
if (_clear_plugin (self))
plugin_changed = TRUE;
}
if (plugin_changed && priv->plugin) {
g_signal_connect (priv->plugin, NM_DNS_PLUGIN_FAILED, G_CALLBACK (plugin_failed), self);
g_signal_connect (priv->plugin, NM_DNS_PLUGIN_CHILD_QUIT, G_CALLBACK (plugin_child_quit), self);
_NMLOG (immutable ? LOGL_WARN : LOGL_INFO,
"%s%s%s%s%s%s",
"set resolv-conf-mode: ",
immutable ? "none" : mode,
", plugin=\"", nm_dns_plugin_get_name (priv->plugin), "\"",
immutable ? ", resolv.conf immutable" : "");
return;
}
if (!immutable)
priv->resolv_conf_mode = NM_DNS_MANAGER_RESOLV_CONF_EXPLICIT;
mode_unknown = mode && !nm_streq (mode, "default") ? mode : NULL;
_NMLOG (mode_unknown ? LOGL_WARN : LOGL_INFO,
"%s%s%s%s%s%s",
"set resolv-conf-mode: ",
immutable ? "none" : "default",
NM_PRINT_FMT_QUOTED (mode_unknown, " -- unknown configuration '", mode_unknown, "'", ""),
immutable ? ", resolv.conf immutable" : "");
}
static void
init_resolv_conf_manager (NMDnsManager *self)
{
NMDnsManagerPrivate *priv = NM_DNS_MANAGER_GET_PRIVATE (self);
const char *man;
man = nm_config_data_get_rc_manager (nm_config_get_data (priv->config));
if (!g_strcmp0 (man, "none"))
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE;
else if (nm_streq0 (man, "file"))
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE;
else if (!g_strcmp0 (man, "resolvconf"))
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF;
else if (!g_strcmp0 (man, "netconfig"))
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG;
else {
#if defined(RESOLVCONF_SELECTED)
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF;
#elif defined(NETCONFIG_SELECTED)
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG;
#else
priv->rc_manager = NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE;
#endif
if (man)
_LOGW ("unknown resolv.conf manager '%s'", man);
if ( plugin_changed
|| priv->rc_manager != rc_manager) {
priv->rc_manager = rc_manager;
_LOGI ("init: dns=%s, rc-manager=%s%s%s%s",
mode, _rc_manager_to_string (rc_manager),
NM_PRINT_FMT_QUOTED (priv->plugin, ", plugin=", nm_dns_plugin_get_name (priv->plugin), "", ""));
}
_LOGI ("using resolv.conf manager '%s'", _rc_manager_to_string (priv->rc_manager));
}
static void
@ -1545,6 +1561,7 @@ config_changed_cb (NMConfig *config,
GError *error = NULL;
if (NM_FLAGS_ANY (changes, NM_CONFIG_CHANGE_DNS_MODE |
NM_CONFIG_CHANGE_RC_MANAGER |
NM_CONFIG_CHANGE_SIGHUP)) {
/* reload the resolv-conf mode also on SIGHUP (when DNS_MODE didn't change).
* The reason is, that the configuration also depends on whether resolv.conf
@ -1553,9 +1570,6 @@ config_changed_cb (NMConfig *config,
init_resolv_conf_mode (self);
}
if (NM_FLAGS_HAS (changes, NM_CONFIG_CHANGE_RC_MANAGER))
init_resolv_conf_manager (self);
if (NM_FLAGS_ANY (changes, NM_CONFIG_CHANGE_SIGHUP |
NM_CONFIG_CHANGE_SIGUSR1 |
NM_CONFIG_CHANGE_DNS_MODE |
@ -1587,7 +1601,6 @@ nm_dns_manager_init (NMDnsManager *self)
G_CALLBACK (config_changed_cb),
self);
init_resolv_conf_mode (self);
init_resolv_conf_manager (self);
}
static void
@ -1599,13 +1612,7 @@ dispose (GObject *object)
_LOGT ("disposing");
if (priv->plugin) {
g_signal_handlers_disconnect_by_func (priv->plugin, plugin_failed, self);
g_signal_handlers_disconnect_by_func (priv->plugin, plugin_child_quit, self);
g_clear_object (&priv->plugin);
}
g_clear_pointer (&priv->last_mode, g_free);
_clear_plugin (self);
/* If we're quitting, leave a valid resolv.conf in place, not one
* pointing to 127.0.0.1 if any plugins were active. Thus update

41
src/dns-manager/nm-dns-manager.h
View file

@ -87,33 +87,18 @@ void nm_dns_manager_set_initial_hostname (NMDnsManager *self,
void nm_dns_manager_set_hostname (NMDnsManager *self,
const char *hostname);
/**
* NMDnsManagerResolvConfMode:
* @NM_DNS_MANAGER_RESOLV_CONF_UNMANAGED: NM is not managing resolv.conf
* @NM_DNS_MANAGER_RESOLV_CONF_EXPLICIT: NM is managing resolv.conf by
* adding and removing "nameserver" lines corresponding to the currently
* active connections
* @NM_DNS_MANAGER_RESOLV_CONF_PROXY: NM is managing resolv.conf by
* pointing it to some other service (eg, dnsmasq) that knows the
* nameservers corresponding to the currently active connections.
*
* NMDnsManager's behavior toward /etc/resolv.conf.
*/
typedef enum {
NM_DNS_MANAGER_RESOLV_CONF_UNMANAGED,
NM_DNS_MANAGER_RESOLV_CONF_EXPLICIT,
NM_DNS_MANAGER_RESOLV_CONF_PROXY
} NMDnsManagerResolvConfMode;
/**
* NMDnsManagerResolvConfManager
* @_NM_DNS_MANAGER_RESOLV_CONF_MAN_INTERNAL_ONLY: dummy-manager
* to not write resolv.conf at all, only the internal file in
* NM's run state directory.
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE: NM writes resolv.conf
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_UNKNOWN: unspecified rc-manager.
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED: do not touch /etc/resolv.conf
* (but still write the internal copy -- unless it is symlinked by
* /etc/resolv.conf)
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_IMMUTABLE: similar to "unmanaged",
* but indicates that resolv.conf cannot be modified.
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK: NM writes resolv.conf
* by symlinking it to the run state directory.
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE: Like NONE, but instead of symlinking
* resolv.conf, write it as a file.
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE: Like SYMLINK, but instead of
* symlinking /etc/resolv.conf, write it as a file.
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF: NM is managing resolv.conf
through resolvconf
* @NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG: NM is managing resolv.conf
@ -122,14 +107,16 @@ typedef enum {
* NMDnsManager's management of resolv.conf
*/
typedef enum {
_NM_DNS_MANAGER_RESOLV_CONF_MAN_INTERNAL_ONLY,
NM_DNS_MANAGER_RESOLV_CONF_MAN_NONE,
NM_DNS_MANAGER_RESOLV_CONF_MAN_UNKNOWN,
NM_DNS_MANAGER_RESOLV_CONF_MAN_UNMANAGED,
NM_DNS_MANAGER_RESOLV_CONF_MAN_IMMUTABLE,
NM_DNS_MANAGER_RESOLV_CONF_MAN_SYMLINK,
NM_DNS_MANAGER_RESOLV_CONF_MAN_FILE,
NM_DNS_MANAGER_RESOLV_CONF_MAN_RESOLVCONF,
NM_DNS_MANAGER_RESOLV_CONF_MAN_NETCONFIG,
} NMDnsManagerResolvConfManager;
NMDnsManagerResolvConfMode nm_dns_manager_get_resolv_conf_mode (NMDnsManager *self);
gboolean nm_dns_manager_get_resolv_conf_explicit (NMDnsManager *self);
G_END_DECLS