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; }