int freeAllStrings(int type)
{
string_item *sitem,*slast;
slast = NULL;
sitem = used_list.first;
while (used_list.num && (sitem != NULL)) {
if (sitem->type <= type) {
sitem->string[0] = '\0';
if (sitem == used_list.first) {
used_list.first = sitem->next;
used_list.num--;
sitem->next = NULL;
add_string_item(&free_list,sitem);
sitem = used_list.first;
} else {
used_list.num--;
slast->next = sitem->next;
add_string_item(&free_list,sitem);
sitem = slast->next;
}
} else {
slast = sitem;
sitem = sitem->next;
}
}
return TRUE;
}
char* newString(int length, int type)
{
int num, x;
string_item *sitem;
if (free_list.num == 0) {
if ((length == HUGE_STRING_LEN) || (length == MAX_STRING_LEN))
num = 5;
else
num = 1;
allocate_strings(&free_list, length, num);
}
sitem = free_list.first;
for(x = 0; x < free_list.num ; x++) {
if (sitem->length == length) {
remove_string_item(&free_list,sitem);
add_string_item(&used_list,sitem);
sitem->type = type;
return sitem->string;
}
sitem = sitem->next;
}
/* Don't have a string of the correct size, make one.
* Since allocate_strings adds strings to beginning of list, just return
* first string in used_list.
* In the future, might want to just return one which is larger.
*/
allocate_strings(&used_list, length, 1);
used_list.first->type = type;
return used_list.first->string;
}
static void
merge_one_ip4_config (NMResolvConfData *rc, NMIP4Config *src)
{
guint32 num, i;
num = nm_ip4_config_get_num_nameservers (src);
for (i = 0; i < num; i++) {
struct in_addr addr;
char buf[INET_ADDRSTRLEN];
addr.s_addr = nm_ip4_config_get_nameserver (src, i);
if (inet_ntop (AF_INET, &addr, buf, INET_ADDRSTRLEN) > 0)
add_string_item (rc->nameservers, buf);
}
num = nm_ip4_config_get_num_domains (src);
for (i = 0; i < num; i++) {
const char *domain;
domain = nm_ip4_config_get_domain (src, i);
if (!rc->domain)
rc->domain = domain;
add_string_item (rc->searches, domain);
}
num = nm_ip4_config_get_num_searches (src);
for (i = 0; i < num; i++)
add_string_item (rc->searches, nm_ip4_config_get_search (src, i));
/* NIS stuff */
num = nm_ip4_config_get_num_nis_servers (src);
for (i = 0; i < num; i++) {
struct in_addr addr;
char buf[INET_ADDRSTRLEN];
addr.s_addr = nm_ip4_config_get_nis_server (src, i);
if (inet_ntop (AF_INET, &addr, buf, INET_ADDRSTRLEN) > 0)
add_string_item (rc->nis_servers, buf);
}
if (nm_ip4_config_get_nis_domain (src)) {
/* FIXME: handle multiple domains */
if (!rc->nis_domain)
rc->nis_domain = nm_ip4_config_get_nis_domain (src);
}
}
static void
merge_one_ip6_config (NMResolvConfData *rc, NMIP6Config *src, const char *iface)
{
guint32 num, i;
num = nm_ip6_config_get_num_nameservers (src);
for (i = 0; i < num; i++) {
const struct in6_addr *addr;
char buf[INET6_ADDRSTRLEN];
addr = nm_ip6_config_get_nameserver (src, i);
/* inet_ntop is probably supposed to do this for us, but it doesn't */
if (IN6_IS_ADDR_V4MAPPED (addr)) {
if (inet_ntop (AF_INET, &(addr->s6_addr32[3]), buf, INET_ADDRSTRLEN) > 0)
add_string_item (rc->nameservers, buf);
} else {
if (inet_ntop (AF_INET6, addr, buf, INET6_ADDRSTRLEN) > 0) {
if (IN6_IS_ADDR_LINKLOCAL (addr) && strchr (buf, '%') == NULL) {
char *tmp;
tmp = g_strdup_printf ("%s%%%s", buf, iface);
add_string_item (rc->nameservers, tmp);
g_free (tmp);
} else
add_string_item (rc->nameservers, buf);
}
}
}
num = nm_ip6_config_get_num_domains (src);
for (i = 0; i < num; i++) {
const char *domain;
domain = nm_ip6_config_get_domain (src, i);
if (!rc->domain)
rc->domain = domain;
add_string_item (rc->searches, domain);
}
num = nm_ip6_config_get_num_searches (src);
for (i = 0; i < num; i++)
add_string_item (rc->searches, nm_ip6_config_get_search (src, i));
}
int freeString(char *string)
{
int x;
string_item *sitem;
if (string == NULL) return FALSE;
sitem = used_list.first;
for(x = 0; x < used_list.num ; x++) {
if (sitem->string == string) {
string[0] = '\0';
remove_string_item(&used_list,sitem);
add_string_item(&free_list,sitem);
return TRUE;
}
sitem = sitem->next;
}
log_error("Attempt to Free String not in Use",gConfiguration->error_log);
return FALSE;
}
int pack_message_v3(struct pam_items *pi, size_t *size, uint8_t **buffer)
{
int len;
uint8_t *buf;
size_t rp;
len = sizeof(uint32_t) +
2*sizeof(uint32_t) + pi->pam_user_size +
sizeof(uint32_t);
len += *pi->pam_service != '\0' ?
2*sizeof(uint32_t) + pi->pam_service_size : 0;
len += *pi->pam_tty != '\0' ?
2*sizeof(uint32_t) + pi->pam_tty_size : 0;
len += *pi->pam_ruser != '\0' ?
2*sizeof(uint32_t) + pi->pam_ruser_size : 0;
len += *pi->pam_rhost != '\0' ?
2*sizeof(uint32_t) + pi->pam_rhost_size : 0;
len += pi->pam_authtok != NULL ?
3*sizeof(uint32_t) + pi->pam_authtok_size : 0;
len += pi->pam_newauthtok != NULL ?
3*sizeof(uint32_t) + pi->pam_newauthtok_size : 0;
len += 3*sizeof(uint32_t); /* cli_pid */
len += *pi->requested_domains != '\0' ?
2*sizeof(uint32_t) + pi->requested_domains_size : 0;
buf = malloc(len);
if (buf == NULL) {
D(("malloc failed."));
return PAM_BUF_ERR;
}
rp = 0;
SAFEALIGN_SETMEM_UINT32(buf, SSS_START_OF_PAM_REQUEST, &rp);
rp += add_string_item(SSS_PAM_ITEM_USER, pi->pam_user, pi->pam_user_size,
&buf[rp]);
rp += add_string_item(SSS_PAM_ITEM_SERVICE, pi->pam_service,
pi->pam_service_size, &buf[rp]);
rp += add_string_item(SSS_PAM_ITEM_TTY, pi->pam_tty, pi->pam_tty_size,
&buf[rp]);
rp += add_string_item(SSS_PAM_ITEM_RUSER, pi->pam_ruser, pi->pam_ruser_size,
&buf[rp]);
rp += add_string_item(SSS_PAM_ITEM_RHOST, pi->pam_rhost, pi->pam_rhost_size,
&buf[rp]);
rp += add_string_item(SSS_PAM_ITEM_REQUESTED_DOMAINS, pi->requested_domains, pi->requested_domains_size,
&buf[rp]);
rp += add_uint32_t_item(SSS_PAM_ITEM_CLI_PID, (uint32_t) pi->cli_pid,
&buf[rp]);
rp += add_authtok_item(SSS_PAM_ITEM_AUTHTOK, pi->pam_authtok_type,
pi->pam_authtok, pi->pam_authtok_size, &buf[rp]);
rp += add_authtok_item(SSS_PAM_ITEM_NEWAUTHTOK, pi->pam_newauthtok_type,
pi->pam_newauthtok, pi->pam_newauthtok_size,
&buf[rp]);
SAFEALIGN_SETMEM_UINT32(buf + rp, SSS_END_OF_PAM_REQUEST, &rp);
if (rp != len) {
D(("error during packet creation."));
free(buf);
return PAM_BUF_ERR;
}
*size = len;
*buffer = buf;
return 0;
}
static gboolean
update_dns (NMDnsManager *self,
const char *iface,
gboolean no_caching,
GError **error)
{
NMDnsManagerPrivate *priv;
NMResolvConfData rc;
GSList *iter, *vpn_configs = NULL, *dev_configs = NULL, *other_configs = NULL;
const char *domain = NULL;
const char *nis_domain = NULL;
char **searches = NULL;
char **nameservers = NULL;
char **nis_servers = NULL;
int num, i, len;
gboolean success = FALSE, caching = FALSE;
g_return_val_if_fail (error != NULL, FALSE);
g_return_val_if_fail (*error == NULL, FALSE);
priv = NM_DNS_MANAGER_GET_PRIVATE (self);
if (iface && (iface != priv->last_iface)) {
g_free (priv->last_iface);
priv->last_iface = g_strdup (iface);
}
/* Update hash with config we're applying */
compute_hash (self, priv->hash);
rc.nameservers = g_ptr_array_new ();
rc.domain = NULL;
rc.searches = g_ptr_array_new ();
rc.nis_domain = NULL;
rc.nis_servers = g_ptr_array_new ();
if (priv->ip4_vpn_config)
merge_one_ip4_config (&rc, priv->ip4_vpn_config);
if (priv->ip4_device_config)
merge_one_ip4_config (&rc, priv->ip4_device_config);
if (priv->ip6_vpn_config)
merge_one_ip6_config (&rc, priv->ip6_vpn_config, iface);
if (priv->ip6_device_config)
merge_one_ip6_config (&rc, priv->ip6_device_config, iface);
for (iter = priv->configs; iter; iter = g_slist_next (iter)) {
if ( (iter->data == priv->ip4_vpn_config)
|| (iter->data == priv->ip4_device_config)
|| (iter->data == priv->ip6_vpn_config)
|| (iter->data == priv->ip6_device_config))
continue;
if (NM_IS_IP4_CONFIG (iter->data)) {
NMIP4Config *config = NM_IP4_CONFIG (iter->data);
merge_one_ip4_config (&rc, config);
} else if (NM_IS_IP6_CONFIG (iter->data)) {
NMIP6Config *config = NM_IP6_CONFIG (iter->data);
merge_one_ip6_config (&rc, config, iface);
} else
g_assert_not_reached ();
}
/* Add the current domain name (from the hostname) to the searches list;
* see rh #600407. The bug report is that when the hostname is set to
* something like 'dcbw.foobar.com' (ie an FQDN) that pinging 'dcbw' doesn't
* work because the resolver doesn't have anything to append to 'dcbw' when
* looking it up.
*/
if (priv->hostname) {
const char *hostsearch = strchr (priv->hostname, '.');
/* +1 to get rid of the dot */
if (hostsearch && strlen (hostsearch + 1))
add_string_item (rc.searches, hostsearch + 1);
}
domain = rc.domain;
/* Per 'man resolv.conf', the search list is limited to 6 domains
* totalling 256 characters.
*/
num = MIN (rc.searches->len, 6);
for (i = 0, len = 0; i < num; i++) {
len += strlen (rc.searches->pdata[i]) + 1; /* +1 for spaces */
if (len > 256)
break;
}
g_ptr_array_set_size (rc.searches, i);
if (rc.searches->len) {
g_ptr_array_add (rc.searches, NULL);
searches = (char **) g_ptr_array_free (rc.searches, FALSE);
} else
g_ptr_array_free (rc.searches, TRUE);
if (rc.nameservers->len) {
g_ptr_array_add (rc.nameservers, NULL);
nameservers = (char **) g_ptr_array_free (rc.nameservers, FALSE);
} else
g_ptr_array_free (rc.nameservers, TRUE);
if (rc.nis_servers->len) {
g_ptr_array_add (rc.nis_servers, NULL);
nis_servers = (char **) g_ptr_array_free (rc.nis_servers, FALSE);
} else
g_ptr_array_free (rc.nis_servers, TRUE);
nis_domain = rc.nis_domain;
/* Build up config lists for plugins; we use the raw configs here, not the
* merged information that we write to resolv.conf so that the plugins can
* still use the domain information in each config to provide split DNS if
* they want to.
*/
if (priv->ip4_vpn_config)
vpn_configs = g_slist_append (vpn_configs, priv->ip4_vpn_config);
if (priv->ip6_vpn_config)
vpn_configs = g_slist_append (vpn_configs, priv->ip6_vpn_config);
if (priv->ip4_device_config)
dev_configs = g_slist_append (dev_configs, priv->ip4_device_config);
if (priv->ip6_device_config)
dev_configs = g_slist_append (dev_configs, priv->ip6_device_config);
for (iter = priv->configs; iter; iter = g_slist_next (iter)) {
if ( (iter->data != priv->ip4_vpn_config)
&& (iter->data != priv->ip4_device_config)
&& (iter->data != priv->ip6_vpn_config)
&& (iter->data != priv->ip6_device_config))
other_configs = g_slist_append (other_configs, iter->data);
}
/* Let any plugins do their thing first */
for (iter = priv->plugins; iter; iter = g_slist_next (iter)) {
NMDnsPlugin *plugin = NM_DNS_PLUGIN (iter->data);
const char *plugin_name = nm_dns_plugin_get_name (plugin);
if (nm_dns_plugin_is_caching (plugin)) {
if (no_caching) {
nm_log_dbg (LOGD_DNS, "DNS: plugin %s ignored (caching disabled)",
plugin_name);
continue;
}
caching = TRUE;
}
nm_log_dbg (LOGD_DNS, "DNS: updating plugin %s", plugin_name);
if (!nm_dns_plugin_update (plugin,
vpn_configs,
dev_configs,
other_configs,
priv->hostname,
iface)) {
nm_log_warn (LOGD_DNS, "DNS: plugin %s update failed", plugin_name);
/* If the plugin failed to update, we shouldn't write out a local
* caching DNS configuration to resolv.conf.
*/
caching = FALSE;
}
}
g_slist_free (vpn_configs);
g_slist_free (dev_configs);
g_slist_free (other_configs);
/* If caching was successful, we only send 127.0.0.1 to /etc/resolv.conf
* to ensure that the glibc resolver doesn't try to round-robin nameservers,
* but only uses the local caching nameserver.
*/
if (caching) {
if (nameservers)
g_strfreev (nameservers);
nameservers = g_new0 (char*, 2);
nameservers[0] = g_strdup ("127.0.0.1");
}
#ifdef RESOLVCONF_PATH
success = dispatch_resolvconf (domain, searches, nameservers, iface, error);
#endif
#ifdef TARGET_SUSE
if (success == FALSE) {
success = dispatch_netconfig (domain, searches, nameservers,
nis_domain, nis_servers,
iface, error);
}
#endif
if (success == FALSE)
success = update_resolv_conf (domain, searches, nameservers, iface, error);
if (success)
nm_backend_update_dns ();
if (searches)
g_strfreev (searches);
if (nameservers)
g_strfreev (nameservers);
if (nis_servers)
g_strfreev (nis_servers);
return success;
}
