#include "config.h"
+#include <pthread.h>
+
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <unistd.h>
#include <ctype.h>
+#include <netinet/in.h>
+
#include <search.h>
#include <assert.h>
#define NWRAP_INET_ADDRSTRLEN INET_ADDRSTRLEN
#endif
+#define NWRAP_LOCK(m) do { \
+ pthread_mutex_lock(&( m ## _mutex)); \
+} while(0)
+
+#define NWRAP_UNLOCK(m) do { \
+ pthread_mutex_unlock(&( m ## _mutex)); \
+} while(0)
+
+
+static bool nwrap_initialized = false;
+static pthread_mutex_t nwrap_initialized_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* The mutex or accessing the id */
+static pthread_mutex_t nwrap_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t nwrap_gr_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t nwrap_he_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t nwrap_pw_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t nwrap_sp_global_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/* Add new global locks here please */
+/* Also don't forget to add locks to
+ * nwrap_init() function.
+ */
+# define NWRAP_LOCK_ALL do { \
+ NWRAP_LOCK(nwrap_initialized); \
+ NWRAP_LOCK(nwrap_global); \
+ NWRAP_LOCK(nwrap_gr_global); \
+ NWRAP_LOCK(nwrap_he_global); \
+ NWRAP_LOCK(nwrap_pw_global); \
+ NWRAP_LOCK(nwrap_sp_global); \
+} while (0);
+
+# define NWRAP_UNLOCK_ALL do {\
+ NWRAP_UNLOCK(nwrap_sp_global); \
+ NWRAP_UNLOCK(nwrap_pw_global); \
+ NWRAP_UNLOCK(nwrap_he_global); \
+ NWRAP_UNLOCK(nwrap_gr_global); \
+ NWRAP_UNLOCK(nwrap_global); \
+ NWRAP_UNLOCK(nwrap_initialized); \
+} while (0);
+
+static void nwrap_thread_prepare(void)
+{
+ NWRAP_LOCK_ALL;
+}
+
+static void nwrap_thread_parent(void)
+{
+ NWRAP_UNLOCK_ALL;
+}
+
+static void nwrap_thread_child(void)
+{
+ NWRAP_UNLOCK_ALL;
+}
+
enum nwrap_dbglvl_e {
NWRAP_LOG_ERROR = 0,
NWRAP_LOG_WARN,
item != NULL; \
(item) = (vect).items[++iter])
+#define nwrap_vector_is_initialized(vector) ((vector)->items != NULL)
+
static inline bool nwrap_vector_init(struct nwrap_vector *const vector)
{
if (vector == NULL) {
return true;
}
-static bool nwrap_vector_add_item(struct nwrap_vector *cont, void *const item)
+static bool nwrap_vector_add_item(struct nwrap_vector *vector, void *const item)
{
- assert (cont != NULL);
+ assert (vector != NULL);
- if (cont->items == NULL) {
- nwrap_vector_init(cont);
+ if (vector->items == NULL) {
+ nwrap_vector_init(vector);
}
- if (cont->count == cont->capacity) {
+ if (vector->count == vector->capacity) {
/* Items array _MUST_ be NULL terminated because it's passed
* as result to caller which expect NULL terminated array from libc.
*/
- void **items = realloc(cont->items, sizeof(void *) * ((cont->capacity * 2) + 1));
+ void **items = realloc(vector->items, sizeof(void *) * ((vector->capacity * 2) + 1));
if (items == NULL) {
return false;
}
- cont->items = items;
+ vector->items = items;
/* Don't count ending NULL to capacity */
- cont->capacity *= 2;
+ vector->capacity *= 2;
}
- cont->items[cont->count] = item;
+ vector->items[vector->count] = item;
- cont->count += 1;
- cont->items[cont->count] = NULL;
+ vector->count += 1;
+ vector->items[vector->count] = NULL;
return true;
}
struct nwrap_vector nwrap_addrdata;
ssize_t aliases_count;
+};
- struct nwrap_entdata *ed_next;
- struct nwrap_entdata *ed_tail;
+struct nwrap_entlist {
+ struct nwrap_entlist *next;
+ struct nwrap_entdata *ed;
};
struct nwrap_he {
struct nwrap_cache *cache;
- struct nwrap_entdata *list;
- struct nwrap_vector entdata;
+ struct nwrap_vector entries;
+ struct nwrap_vector lists;
int num;
int idx;
static void nwrap_lines_unload(struct nwrap_cache *const nwrap)
{
size_t p;
- for (p = 0; p < nwrap->lines.count; p++) {
+ void *item;
+ nwrap_vector_foreach(item, nwrap->lines, p) {
/* Maybe some vectors were merged ... */
- SAFE_FREE(nwrap->lines.items[p]);
+ SAFE_FREE(item);
}
SAFE_FREE(nwrap->lines.items);
- nwrap->lines.count = 0;
+ ZERO_STRUCTP(&nwrap->lines);
}
/*
static void nwrap_init(void)
{
- static bool initialized;
const char *env;
char *endptr;
size_t max_hostents_tmp;
- if (initialized) return;
- initialized = true;
+ NWRAP_LOCK(nwrap_initialized);
+ if (nwrap_initialized) {
+ NWRAP_UNLOCK(nwrap_initialized);
+ return;
+ }
+
+ /*
+ * Still holding nwrap_initialized lock here.
+ * We don't use NWRAP_(UN)LOCK_ALL macros here because we
+ * want to avoid overhead when other threads do their job.
+ */
+ NWRAP_LOCK(nwrap_global);
+ NWRAP_LOCK(nwrap_gr_global);
+ NWRAP_LOCK(nwrap_he_global);
+ NWRAP_LOCK(nwrap_pw_global);
+ NWRAP_LOCK(nwrap_sp_global);
+
+ nwrap_initialized = true;
+
+ /* Initialize pthread_atfork handlers */
+ pthread_atfork(&nwrap_thread_prepare, &nwrap_thread_parent,
+ &nwrap_thread_child);
env = getenv("NSS_WRAPPER_MAX_HOSTENTS");
if (env != NULL) {
"Error parsing NSS_WRAPPER_MAX_HOSTENTS "
"value or value is too small. "
"Using default value: %lu.",
- max_hostents);
+ (unsigned long)max_hostents);
} else {
max_hostents = max_hostents_tmp;
}
}
/* Initialize hash table */
NWRAP_LOG(NWRAP_LOG_DEBUG,
- "Initializing hash table of size %lu items.", max_hostents);
+ "Initializing hash table of size %lu items.",
+ (unsigned long)max_hostents);
if (hcreate(max_hostents) == 0) {
NWRAP_LOG(NWRAP_LOG_ERROR,
"Failed to initialize hash table");
- return;
+ goto done;
}
nwrap_main_global = &__nwrap_main_global;
nwrap_he_global.cache->private_data = &nwrap_he_global;
nwrap_he_global.cache->parse_line = nwrap_he_parse_line;
nwrap_he_global.cache->unload = nwrap_he_unload;
+
+done:
+ /* We hold all locks here so we can use NWRAP_UNLOCK_ALL. */
+ NWRAP_UNLOCK_ALL;
}
bool nss_wrapper_enabled(void)
do {
n = getline(&line, &len, nwrap->fp);
if (n < 0) {
+ SAFE_FREE(line);
if (feof(nwrap->fp)) {
break;
}
nwrap_lines_unload(nwrap);
}
-static void nwrap_files_cache_reload(struct nwrap_cache *nwrap)
+static bool nwrap_files_cache_reload(struct nwrap_cache *nwrap)
{
struct stat st;
int ret;
"Unable to open '%s' readonly %d:%s",
nwrap->path, nwrap->fd,
strerror(errno));
- return;
+ return false;
}
nwrap->fd = fileno(nwrap->fp);
fclose(nwrap->fp);
nwrap->fp = NULL;
nwrap->fd = -1;
- return;
+ return false;
}
if (retried == false && st.st_nlink == 0) {
NWRAP_LOG(NWRAP_LOG_TRACE,
"st_mtime[%u] hasn't changed, skip reload",
(unsigned)st.st_mtime);
- return;
+ return true;
}
NWRAP_LOG(NWRAP_LOG_TRACE,
if (!ok) {
NWRAP_LOG(NWRAP_LOG_ERROR, "Failed to reload %s", nwrap->path);
nwrap_files_cache_unload(nwrap);
+ return false;
}
NWRAP_LOG(NWRAP_LOG_TRACE, "Reloaded %s", nwrap->path);
+ return true;
}
/*
return 0;
}
-static bool nwrap_add_ai(char *const ip_addr, struct nwrap_entdata *const ed)
+static struct nwrap_entlist *nwrap_entlist_init(struct nwrap_entdata *ed)
{
- ENTRY e = {
- .key = ip_addr,
- .data = (void *)ed,
- };
- ENTRY *p;
+ struct nwrap_entlist *el;
- p = hsearch(e, ENTER);
- if (p == NULL) {
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Hash table is full");
- return false;
+ if (ed == NULL) {
+ NWRAP_LOG(NWRAP_LOG_ERROR,
+ "entry is NULL, can't create list item");
+ return NULL;
}
- return true;
-}
+ el = (struct nwrap_entlist *)malloc(sizeof(struct nwrap_entlist));
+ if (el == NULL) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "malloc failed");
+ return NULL;
+ }
+ el->next = NULL;
+ el->ed = ed;
-static bool nwrap_add_hname_add_new(char *const h_name,
- struct nwrap_entdata *const ed)
+ return el;
+}
+
+static bool nwrap_ed_inventarize_add_new(char *const h_name,
+ struct nwrap_entdata *const ed)
{
- /* No element found.. inventarize new item */
ENTRY e;
ENTRY *p;
+ struct nwrap_entlist *el;
+ bool ok;
+
+ if (h_name == NULL) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "h_name NULL - can't add");
+ return false;
+ }
+
+ el = nwrap_entlist_init(ed);
+ if (el == NULL) {
+ return false;
+ }
e.key = h_name;
- e.data = (void *)ed;
- ed->ed_tail = NULL;
- ed->ed_next = NULL;
+ e.data = (void *)el;
p = hsearch(e, ENTER);
if (p == NULL) {
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Hash table is full!");
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Hash table is full!");
+ return false;
+ }
+
+ ok = nwrap_vector_add_item(&(nwrap_he_global.lists), (void *)el);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR,
+ "Failed to add list entry to vector.");
return false;
}
return true;
}
-static void nwrap_add_hname_add_to_existing(struct nwrap_entdata *const ed,
- struct nwrap_entdata *const ed_dst)
+static bool nwrap_ed_inventarize_add_to_existing(struct nwrap_entdata *const ed,
+ struct nwrap_entlist *const el)
{
- if (ed_dst->ed_tail != NULL) {
- ed_dst->ed_tail->ed_next = ed;
- if (ed_dst->ed_tail != ed) {
- ed_dst->ed_tail = ed;
- ed->ed_next = NULL;
+ struct nwrap_entlist *cursor;
+ struct nwrap_entlist *el_new;
+
+ if (el == NULL) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "list is NULL, can not add");
+ return false;
+ }
+
+
+ for (cursor = el; cursor->next != NULL; cursor = cursor->next)
+ {
+ if (cursor->ed == ed) {
+ return false;
}
- } else {
- ed_dst->ed_tail = ed;
}
+
+ if (cursor->ed == ed) {
+ return false;
+ }
+
+ el_new = nwrap_entlist_init(ed);
+ if (el_new == NULL) {
+ return false;
+ }
+
+ cursor->next = el_new;
+ return true;
}
-static bool nwrap_add_hname_alias(const char *const h_name_a,
- struct nwrap_entdata *const ed)
+static bool nwrap_ed_inventarize(char *const name,
+ struct nwrap_entdata *const ed)
{
- /* One of argument 'h_hame_a' are "optional" */
- char *const h_name = (char *const) ((h_name_a == NULL) ? ed->ht.h_name : h_name_a);
ENTRY e;
ENTRY *p;
+ bool ok;
- /* Maybe it's little bit late ... */
- assert(ed != NULL);
- assert(h_name != NULL);
-
- e.key = h_name;
+ e.key = name;
e.data = NULL;
+
NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
+
p = hsearch(e, FIND);
if (p == NULL) {
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name);
- /* Just add alias and don't mess with metadata */
- nwrap_add_hname_add_new(h_name, ed);
+ NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", name);
+ ok = nwrap_ed_inventarize_add_new(name, ed);
} else {
- /* Element found. Add them to end of list */
- struct nwrap_entdata *ed_dst = (struct nwrap_entdata *)p->data;
+ struct nwrap_entlist *el = (struct nwrap_entlist *)p->data;
- assert(p->data != NULL);
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name);
- nwrap_add_hname_add_to_existing(ed, ed_dst);
+ NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", name);
+ ok = nwrap_ed_inventarize_add_to_existing(ed, el);
}
- return true;
+ return ok;
}
-static bool nwrap_add_hname(const char *const h_name_a,
- struct nwrap_entdata *const ed)
+static bool nwrap_add_hname(struct nwrap_entdata *const ed)
{
- /* One of argument 'h_hame_a' are "optional" */
- char *const h_name = (char *const) ((h_name_a == NULL) ? ed->ht.h_name : h_name_a);
- ENTRY e;
- ENTRY *p;
- char *h_name_alias;
+ char *const h_name = (char *const)(ed->ht.h_name);
unsigned i;
+ bool ok;
- /* Maybe it's little bit late ... */
- assert(ed != NULL);
- assert(h_name != NULL);
-
- e.key = h_name;
- e.data = NULL;
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching name: %s", e.key);
- p = hsearch(e, FIND);
- if (p == NULL) {
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found. Adding...", h_name);
- /* Just add alias and don't mess with metadata */
- nwrap_add_hname_add_new(h_name, ed);
-
- if (ed->ed_tail == NULL) {
- ed->ed_tail = ed;
- }
- } else {
- /* Element found. Add them to end of list */
- struct nwrap_entdata *ed_dst = (struct nwrap_entdata *)p->data;
-
- assert(p->data != NULL);
- NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s found. Add record to list.", h_name);
- nwrap_add_hname_add_to_existing(ed, ed_dst);
+ ok = nwrap_ed_inventarize(h_name, ed);
+ if (!ok) {
+ return false;
}
- /* Return true when list of aliases is empty */
if (ed->ht.h_aliases == NULL) {
return true;
}
/* Itemize aliases */
for (i = 0; ed->ht.h_aliases[i] != NULL; ++i) {
+ char *h_name_alias;
+
h_name_alias = ed->ht.h_aliases[i];
- assert(h_name_alias != NULL);
NWRAP_LOG(NWRAP_LOG_DEBUG, "Add alias: %s", h_name_alias);
- if (!nwrap_add_hname_alias(h_name_alias, ed)) {
- NWRAP_LOG(NWRAP_LOG_DEBUG,
+ if (!nwrap_ed_inventarize(h_name_alias, ed)) {
+ NWRAP_LOG(NWRAP_LOG_ERROR,
"Unable to add alias: %s", h_name_alias);
+ return false;
}
}
char *n;
char *ip;
+ bool ok;
struct nwrap_entdata *ed = (struct nwrap_entdata *)
malloc(sizeof(struct nwrap_entdata));
}
ip = i;
- nwrap_vector_add_item(&(ed->nwrap_addrdata),
- (void *const)ed->addr.host_addr);
+ ok = nwrap_vector_add_item(&(ed->nwrap_addrdata),
+ (void *const)ed->addr.host_addr);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Unable to add addrdata to vector");
+ free(ed);
+ return false;
+ }
ed->ht.h_addr_list = nwrap_vector_head(&ed->nwrap_addrdata);
p++;
aliases_count += 1;
}
- nwrap_vector_add_item(&(nwrap_he->entdata), (void *const)ed);
+ ok = nwrap_vector_add_item(&(nwrap_he->entries), (void *const)ed);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Unable to add entry to vector");
+ free(ed);
+ return false;
+ }
ed->aliases_count = aliases_count;
/* Inventarize item */
- nwrap_add_hname(NULL, ed);
- nwrap_add_ai(ip, ed);
+ ok = nwrap_add_hname(ed);
+ if (!ok) {
+ return false;
+ }
+
+ ok = nwrap_ed_inventarize(ip, ed);
+ if (!ok) {
+ return false;
+ }
nwrap_he->num++;
return true;
struct nwrap_he *nwrap_he =
(struct nwrap_he *)nwrap->private_data;
struct nwrap_entdata *ed;
+ struct nwrap_entlist *el;
size_t i;
- nwrap_vector_foreach (ed, nwrap_he->entdata, i)
+ nwrap_vector_foreach (ed, nwrap_he->entries, i)
{
+ SAFE_FREE(ed->nwrap_addrdata.items);
SAFE_FREE(ed->ht.h_aliases);
SAFE_FREE(ed);
}
- SAFE_FREE(nwrap_he->entdata.items);
- nwrap_he->entdata.count = nwrap_he->entdata.capacity = 0;
+ SAFE_FREE(nwrap_he->entries.items);
+ nwrap_he->entries.count = nwrap_he->entries.capacity = 0;
+
+ nwrap_vector_foreach(el, nwrap_he->lists, i)
+ {
+ while (el != NULL) {
+ struct nwrap_entlist *el_next;
+
+ el_next = el->next;
+ SAFE_FREE(el);
+ el = el_next;
+ }
+ }
+ SAFE_FREE(nwrap_he->lists.items);
+ nwrap_he->lists.count = nwrap_he->lists.capacity = 0;
nwrap_he->num = 0;
nwrap_he->idx = 0;
const char *name)
{
int i;
+ bool ok;
(void) b; /* unused */
NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
- nwrap_files_cache_reload(nwrap_pw_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
+ return NULL;
+ }
for (i=0; i<nwrap_pw_global.num; i++) {
if (strcmp(nwrap_pw_global.list[i].pw_name, name) == 0) {
uid_t uid)
{
int i;
+ bool ok;
(void) b; /* unused */
- nwrap_files_cache_reload(nwrap_pw_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
+ return NULL;
+ }
for (i=0; i<nwrap_pw_global.num; i++) {
if (nwrap_pw_global.list[i].pw_uid == uid) {
(void) b; /* unused */
if (nwrap_pw_global.idx == 0) {
- nwrap_files_cache_reload(nwrap_pw_global.cache);
+ bool ok;
+ ok = nwrap_files_cache_reload(nwrap_pw_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading passwd file");
+ return NULL;
+ }
}
if (nwrap_pw_global.idx >= nwrap_pw_global.num) {
struct spwd *sp;
if (nwrap_sp_global.idx == 0) {
- nwrap_files_cache_reload(nwrap_sp_global.cache);
+ bool ok;
+
+ ok = nwrap_files_cache_reload(nwrap_sp_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading shadow file");
+ return NULL;
+ }
}
if (nwrap_sp_global.idx >= nwrap_sp_global.num) {
static struct spwd *nwrap_files_getspnam(const char *name)
{
int i;
+ bool ok;
NWRAP_LOG(NWRAP_LOG_DEBUG, "Lookup user %s in files", name);
- nwrap_files_cache_reload(nwrap_sp_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_sp_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading shadow file");
+ return NULL;
+ }
for (i=0; i<nwrap_sp_global.num; i++) {
if (strcmp(nwrap_sp_global.list[i].sp_namp, name) == 0) {
const char *name)
{
int i;
+ bool ok;
(void) b; /* unused */
- nwrap_files_cache_reload(nwrap_gr_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
+ return NULL;
+ }
for (i=0; i<nwrap_gr_global.num; i++) {
if (strcmp(nwrap_gr_global.list[i].gr_name, name) == 0) {
gid_t gid)
{
int i;
+ bool ok;
(void) b; /* unused */
- nwrap_files_cache_reload(nwrap_gr_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
+ return NULL;
+ }
for (i=0; i<nwrap_gr_global.num; i++) {
if (nwrap_gr_global.list[i].gr_gid == gid) {
(void) b; /* unused */
if (nwrap_gr_global.idx == 0) {
- nwrap_files_cache_reload(nwrap_gr_global.cache);
+ bool ok;
+
+ ok = nwrap_files_cache_reload(nwrap_gr_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading group file");
+ return NULL;
+ }
}
if (nwrap_gr_global.idx >= nwrap_gr_global.num) {
struct hostent *result,
struct nwrap_vector *addr_list)
{
- struct nwrap_entdata *ed_head;
- struct nwrap_entdata *ed_cur;
+ struct nwrap_entlist *el;
struct hostent *he;
char *h_name_lower;
ENTRY e;
char canon_name[DNS_NAME_MAX] = { 0 };
size_t name_len;
bool he_found = false;
+ bool ok;
- nwrap_files_cache_reload(nwrap_he_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_he_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
+ goto no_ent;
+ }
name_len = strlen(name);
if (name_len < sizeof(canon_name) && name[name_len - 1] == '.') {
SAFE_FREE(h_name_lower);
/* Always cleanup vector and results */
- if (!nwrap_vector_init(addr_list)) {
- NWRAP_LOG(NWRAP_LOG_DEBUG,
- "Unable to initialize memory for addr_list vector");
- goto no_ent;
+ if (!nwrap_vector_is_initialized(addr_list)) {
+ if (!nwrap_vector_init(addr_list)) {
+ NWRAP_LOG(NWRAP_LOG_DEBUG,
+ "Unable to initialize memory for addr_list vector");
+ goto no_ent;
+ }
+ } else {
+ /* When vector is initialized data are valid no more.
+ * Quick way how to free vector is: */
+ addr_list->count = 0;
}
/* Iterate through results */
- ed_head = (struct nwrap_entdata *)e_p->data;
- for (ed_cur = ed_head; ed_cur != NULL; ed_cur = ed_cur->ed_next) {
- he = &(ed_cur->ht);
+ for (el = (struct nwrap_entlist *)e_p->data; el != NULL; el = el->next)
+ {
+ he = &(el->ed->ht);
/* Filter by address familiy if provided */
if (af != AF_UNSPEC && he->h_addrtype != af) {
he->h_name);
he_found = true;
}
- nwrap_vector_merge(addr_list, &ed_cur->nwrap_addrdata);
+ nwrap_vector_merge(addr_list, &el->ed->nwrap_addrdata);
result->h_addr_list = nwrap_vector_head(addr_list);
}
return -1;
}
- memset(buf, '\0', buflen);
+ if (buflen < (addr_list->count * sizeof(void *))) {
+ SAFE_FREE(addr_list->items);
+ SAFE_FREE(addr_list);
+ return ERANGE;
+ }
+
+ /* Copy all to user provided buffer and change
+ * pointers in returned structure.
+ * +1 is for ending NULL pointer. */
+ memcpy(buf, addr_list->items, (addr_list->count + 1) * sizeof(void *));
+
+ free(addr_list->items);
+ free(addr_list);
+
+ ret->h_addr_list = (char **)buf;
*result = ret;
return 0;
}
}
#endif
-static struct addrinfo *nwrap_files_getaddrinfo(const char *name,
- unsigned short port,
- const struct addrinfo *hints,
- struct addrinfo **ai_tail)
+static int nwrap_files_getaddrinfo(const char *name,
+ unsigned short port,
+ const struct addrinfo *hints,
+ struct addrinfo **ai)
{
- struct nwrap_entdata *ed_head;
- struct nwrap_entdata *ed_cur;
+ struct nwrap_entlist *el;
struct hostent *he;
- struct addrinfo *ai = NULL;
struct addrinfo *ai_head = NULL;
- struct addrinfo *ai_prev = NULL;
+ struct addrinfo *ai_cur = NULL;
char *h_name_lower;
size_t name_len;
char canon_name[DNS_NAME_MAX] = { 0 };
bool skip_canonname = false;
- ENTRY e;
- ENTRY *e_p;
+ ENTRY e = {
+ .key = NULL,
+ };
+ ENTRY *e_p = NULL;
+ int rc;
+ bool ok;
- nwrap_files_cache_reload(nwrap_he_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_he_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
+ return EAI_SYSTEM;
+ }
name_len = strlen(name);
if (name_len < DNS_NAME_MAX && name[name_len - 1] == '.') {
if (!str_tolower_copy(&h_name_lower, name)) {
NWRAP_LOG(NWRAP_LOG_DEBUG,
"Out of memory while converting to lower case");
- return NULL;
+ return EAI_MEMORY;
}
NWRAP_LOG(NWRAP_LOG_DEBUG, "Searching for name: %s", h_name_lower);
NWRAP_LOG(NWRAP_LOG_DEBUG, "Name %s not found.", h_name_lower);
SAFE_FREE(h_name_lower);
errno = ENOENT;
- return NULL;
+ return EAI_NONAME;
}
NWRAP_LOG(NWRAP_LOG_DEBUG, "Name: %s found.", h_name_lower);
SAFE_FREE(h_name_lower);
- ed_head = (struct nwrap_entdata *)e_p->data;
-
- for (ed_cur = ed_head; ed_cur != NULL; ed_cur = ed_cur->ed_next) {
- int rc;
+ rc = EAI_NONAME;
+ for (el = (struct nwrap_entlist *)e_p->data; el != NULL; el = el->next)
+ {
+ int rc2;
+ struct addrinfo *ai_new = NULL;
- he = &(ed_cur->ht);
+ he = &(el->ed->ht);
if (hints->ai_family != AF_UNSPEC &&
- he->h_addrtype != hints->ai_family) {
+ he->h_addrtype != hints->ai_family)
+ {
+ NWRAP_LOG(NWRAP_LOG_DEBUG,
+ "Entry found but with wrong AF - "
+ "remembering EAI_ADDRINFO.");
+ rc = EAI_ADDRFAMILY;
continue;
}
/* Function allocates memory and returns it in ai. */
- rc = nwrap_convert_he_ai(he,
+ rc2 = nwrap_convert_he_ai(he,
port,
hints,
- &ai,
+ &ai_new,
skip_canonname);
- if (rc != 0) {
- /* FIXME: Investigate if this is nice to do... */
- NWRAP_LOG(NWRAP_LOG_ERROR,
- "Error in converting he to ai! Skipping.");
- continue;
+ if (rc2 != 0) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error converting he to ai");
+ if (ai_head != NULL) {
+ freeaddrinfo(ai_head);
+ }
+ return rc2;
}
skip_canonname = true;
if (ai_head == NULL) {
- ai_head = ai;
+ ai_head = ai_new;
}
- if (ai_prev != NULL) {
- ai_prev->ai_next = ai;
+ if (ai_cur != NULL) {
+ ai_cur->ai_next = ai_new;
}
- ai_prev = ai;
+ ai_cur = ai_new;
}
- *ai_tail = ai;
- return ai_head;
+ if (ai_head != NULL) {
+ rc = 0;
+ }
+
+ *ai = ai_head;
+
+ return rc;
}
static struct hostent *nwrap_files_gethostbyaddr(const void *addr,
struct nwrap_entdata *ed;
const char *a;
size_t i;
+ bool ok;
(void) len; /* unused */
- nwrap_files_cache_reload(nwrap_he_global.cache);
+ ok = nwrap_files_cache_reload(nwrap_he_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "error loading hosts file");
+ return NULL;
+ }
a = inet_ntop(type, addr, ip, sizeof(ip));
if (a == NULL) {
return NULL;
}
- nwrap_vector_foreach(ed, nwrap_he_global.entdata, i)
+ nwrap_vector_foreach(ed, nwrap_he_global.entries, i)
{
he = &(ed->ht);
if (he->h_addrtype != type) {
struct hostent *he;
if (nwrap_he_global.idx == 0) {
- nwrap_files_cache_reload(nwrap_he_global.cache);
+ bool ok;
+
+ ok = nwrap_files_cache_reload(nwrap_he_global.cache);
+ if (!ok) {
+ NWRAP_LOG(NWRAP_LOG_ERROR, "Error loading hosts file");
+ return NULL;
+ }
}
if (nwrap_he_global.idx >= nwrap_he_global.num) {
return NULL;
}
- he = &((struct nwrap_entdata *)nwrap_he_global.entdata.items[nwrap_he_global.idx++])->ht;
+ he = &((struct nwrap_entdata *)nwrap_he_global.entries.items[nwrap_he_global.idx++])->ht;
NWRAP_LOG(NWRAP_LOG_DEBUG, "return hosts[%s]", he->h_name);
return EAI_MEMORY;
}
- ai->ai_flags = 0;
+ ai->ai_flags = hints->ai_flags;
ai->ai_family = he->h_addrtype;
ai->ai_socktype = hints->ai_socktype;
ai->ai_protocol = hints->ai_protocol;
ai->ai_canonname = NULL;
+ if (ai->ai_socktype == 0) {
+ ai->ai_socktype = SOCK_DGRAM;
+ }
+ if (ai->ai_protocol == 0) {
+ if (ai->ai_socktype == SOCK_DGRAM) {
+ ai->ai_protocol = IPPROTO_UDP;
+ } else if (ai->ai_socktype == SOCK_STREAM) {
+ ai->ai_protocol = IPPROTO_TCP;
+ }
+ }
+
ai->ai_addrlen = socklen;
ai->ai_addr = (void *)(ai + 1);
struct addrinfo **res)
{
struct addrinfo *ai = NULL;
- struct addrinfo *p = NULL;
- struct addrinfo *ai_tail;
unsigned short port = 0;
struct {
int family;
} addr = {
.family = AF_UNSPEC,
};
- int eai = EAI_SYSTEM;
- int ret;
int rc;
if (node == NULL && service == NULL) {
return EAI_BADFLAGS;
}
- ret = libc_getaddrinfo(node, service, hints, &p);
- if (ret == 0) {
- *res = p;
- }
/* If no node has been specified, let glibc deal with it */
if (node == NULL) {
+ int ret;
+ struct addrinfo *p = NULL;
+
+ ret = libc_getaddrinfo(node, service, hints, &p);
+
+ if (ret == 0) {
+ *res = p;
+ }
return ret;
}
if (service != NULL && service[0] != '\0') {
- if (isdigit((int)service[0])) {
- port = (unsigned short)atoi(service);
- } else {
- const char *proto = NULL;
- struct servent *s;
+ const char *proto = NULL;
+ struct servent *s;
+ char *end_ptr;
+ long sl;
- if (hints->ai_protocol != 0) {
- struct protoent *pent;
+ errno = 0;
+ sl = strtol(service, &end_ptr, 10);
- pent = getprotobynumber(hints->ai_protocol);
- if (pent != NULL) {
- proto = pent->p_name;
- }
- }
+ if (*end_ptr == '\0') {
+ port = sl;
+ goto valid_port;
+ } else if (hints->ai_flags & AI_NUMERICSERV) {
+ return EAI_NONAME;
+ }
- s = getservbyname(service, proto);
- if (s != NULL) {
- port = ntohs(s->s_port);
- } else {
- if (p != NULL) {
- freeaddrinfo(p);
- }
- return EAI_SERVICE;
+ if (hints->ai_protocol != 0) {
+ struct protoent *pent;
+
+ pent = getprotobynumber(hints->ai_protocol);
+ if (pent != NULL) {
+ proto = pent->p_name;
}
}
- }
- rc = 0;
- if (hints->ai_family == AF_UNSPEC || hints->ai_family == AF_INET) {
- rc = inet_pton(AF_INET, node, &addr.in.v4);
+ s = getservbyname(service, proto);
+ if (s == NULL) {
+ return EAI_NONAME;
+ }
+ port = ntohs(s->s_port);
}
+
+valid_port:
+
+ rc = inet_pton(AF_INET, node, &addr.in.v4);
if (rc == 1) {
addr.family = AF_INET;
+ }
#ifdef HAVE_IPV6
- } else {
+ if (addr.family == AF_UNSPEC) {
rc = inet_pton(AF_INET6, node, &addr.in.v6);
if (rc == 1) {
addr.family = AF_INET6;
}
-#endif
}
-
- rc = -1;
- if (addr.family == AF_INET) {
- ai = nwrap_files_getaddrinfo(node, port, hints, &ai_tail);
- if (ai != NULL) {
- rc = 1;
- }
-#ifdef HAVE_IPV6
- } else if (addr.family == AF_INET6) {
- ai = nwrap_files_getaddrinfo(node, port, hints, &ai_tail);
- if (ai != NULL) {
- rc = 1;
- }
#endif
- } else {
- ai = nwrap_files_getaddrinfo(node, port, hints, &ai_tail);
- if (ai != NULL) {
- rc = 1;
+
+ if (addr.family == AF_UNSPEC) {
+ if (hints->ai_flags & AI_NUMERICHOST) {
+ return EAI_NONAME;
}
+ } else if ((hints->ai_family != AF_UNSPEC) &&
+ (hints->ai_family != addr.family))
+ {
+ return EAI_ADDRFAMILY;
}
- if (rc < 0) {
- return ret == 0 ? 0 : eai;
- }
+ rc = nwrap_files_getaddrinfo(node, port, hints, &ai);
+ if (rc != 0) {
+ int ret;
+ struct addrinfo *p = NULL;
- if (ret == 0) {
- freeaddrinfo(p);
- }
+ ret = libc_getaddrinfo(node, service, hints, &p);
- if (ai->ai_flags == 0) {
- ai->ai_flags = hints->ai_flags;
- }
- if (ai->ai_socktype == 0) {
- ai->ai_socktype = SOCK_DGRAM;
- }
- if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_DGRAM) {
- ai->ai_protocol = 17; /* UDP */
- } else if (ai->ai_protocol == 0 && ai->ai_socktype == SOCK_STREAM) {
- ai->ai_protocol = 6; /* TCP */
+ if (ret == 0) {
+ /*
+ * nwrap_files_getaddrinfo failed, but libc was
+ * successful -- use the result from libc.
+ */
+ *res = p;
+ return 0;
+ }
+
+ return rc;
}
+ /*
+ * If the socktype was not specified, duplicate
+ * each ai returned, so that we have variants for
+ * both UDP and TCP.
+ */
if (hints->ai_socktype == 0) {
- /* Add second ai */
- struct addrinfo *ai_head = ai;
- struct addrinfo *ai_tmp;
- struct addrinfo *ai_new_tail = ai_tail;
-
- /* Add at least one more struct */
- do {
- /* CHECKS! */
- ai_tmp = malloc(sizeof(struct addrinfo));
- memcpy(ai_tmp, ai_head, sizeof(struct addrinfo));
- ai_tmp->ai_next = NULL;
+ struct addrinfo *ai_cur;
- /* We need a deep copy or freeaddrinfo() will blow up */
- if (ai_head->ai_canonname != NULL) {
- ai_tmp->ai_canonname =
- strdup(ai_head->ai_canonname);
+ /* freeaddrinfo() frees ai_canonname and ai so allocate them */
+ for (ai_cur = ai; ai_cur != NULL; ai_cur = ai_cur->ai_next) {
+ struct addrinfo *ai_new;
+
+ /* duplicate the current entry */
+
+ ai_new = malloc(sizeof(struct addrinfo));
+ if (ai_new == NULL) {
+ freeaddrinfo(ai);
+ return EAI_MEMORY;
}
- ai_tmp->ai_addr = malloc(sizeof(struct sockaddr));
- memcpy(ai_tmp->ai_addr, ai_head, sizeof(struct sockaddr));
- if (ai_head->ai_flags == 0) {
- ai_tmp->ai_flags = hints->ai_flags;
+ memcpy(ai_new, ai_cur, sizeof(struct addrinfo));
+ ai_new->ai_next = NULL;
+
+ /* We need a deep copy or freeaddrinfo() will blow up */
+ if (ai_cur->ai_canonname != NULL) {
+ ai_new->ai_canonname =
+ strdup(ai_cur->ai_canonname);
}
- if (ai_head->ai_socktype == SOCK_DGRAM) {
- ai_tmp->ai_socktype = SOCK_STREAM;
- } else if (ai_head->ai_socktype == SOCK_STREAM) {
- ai_tmp->ai_socktype = SOCK_DGRAM;
+
+ if (ai_cur->ai_socktype == SOCK_DGRAM) {
+ ai_new->ai_socktype = SOCK_STREAM;
+ } else if (ai_cur->ai_socktype == SOCK_STREAM) {
+ ai_new->ai_socktype = SOCK_DGRAM;
}
- if (ai_head->ai_socktype == SOCK_DGRAM) {
- ai_tmp->ai_protocol = 17; /* UDP */
- } else if (ai_head->ai_socktype == SOCK_STREAM) {
- ai_tmp->ai_protocol = 6; /* TCP */
+ if (ai_cur->ai_protocol == IPPROTO_TCP) {
+ ai_new->ai_protocol = IPPROTO_UDP;
+ } else if (ai_cur->ai_protocol == IPPROTO_UDP) {
+ ai_new->ai_protocol = IPPROTO_TCP;
}
- ai_new_tail->ai_next = ai_tmp;
- ai_new_tail = ai_tmp;
- if (ai_head == ai_tail) {
- break;
- }
- ai_head = ai_head->ai_next;
- } while (1);
+ /* now insert the new entry */
+
+ ai_new->ai_next = ai_cur->ai_next;
+ ai_cur->ai_next = ai_new;
+
+ /* and move on (don't duplicate the new entry) */
+
+ ai_cur = ai_new;
+ }
}
*res = ai;
{
int i;
+ NWRAP_LOCK_ALL;
if (nwrap_main_global != NULL) {
struct nwrap_main *m = nwrap_main_global;
}
hdestroy();
+ NWRAP_UNLOCK_ALL;
}