summaryrefslogtreecommitdiffstats
path: root/newlib/libc/sys/linux/net/nsswitch.c
diff options
context:
space:
mode:
Diffstat (limited to 'newlib/libc/sys/linux/net/nsswitch.c')
-rw-r--r--newlib/libc/sys/linux/net/nsswitch.c772
1 files changed, 772 insertions, 0 deletions
diff --git a/newlib/libc/sys/linux/net/nsswitch.c b/newlib/libc/sys/linux/net/nsswitch.c
new file mode 100644
index 000000000..6c5d1f8e9
--- /dev/null
+++ b/newlib/libc/sys/linux/net/nsswitch.c
@@ -0,0 +1,772 @@
+/* Copyright (C) 1996, 1997, 1998, 1999, 2001, 2002, 2003, 2004
+ Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <ctype.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <netdb.h>
+#include <bits/libc-lock.h>
+#include <search.h>
+#include <stdio.h>
+#include <stdio_ext.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <aliases.h>
+#include <grp.h>
+#include <netinet/ether.h>
+#include <pwd.h>
+#include <shadow.h>
+
+#include "local.h"
+
+#if !defined DO_STATIC_NSS || defined SHARED
+# include <gnu/lib-names.h>
+#endif
+
+#include "nsswitch.h"
+#include "nscd/nscd_proto.h"
+
+/* Prototypes for the local functions. */
+static name_database *nss_parse_file (const char *fname) internal_function;
+static name_database_entry *nss_getline (char *line) internal_function;
+static service_user *nss_parse_service_list (const char *line)
+ internal_function;
+static service_library *nss_new_service (name_database *database,
+ const char *name) internal_function;
+
+
+/* Declare external database variables. */
+#define DEFINE_DATABASE(name) \
+ extern service_user *__nss_##name##_database attribute_hidden; \
+ weak_extern (__nss_##name##_database)
+#include "databases.def"
+#undef DEFINE_DATABASE
+
+/* Structure to map database name to variable. */
+static struct
+{
+ const char *name;
+ service_user **dbp;
+} databases[] =
+{
+#define DEFINE_DATABASE(name) \
+ { #name, &__nss_##name##_database },
+#include "databases.def"
+#undef DEFINE_DATABASE
+};
+
+
+__libc_lock_define_initialized (static, lock)
+
+#if !defined DO_STATIC_NSS || defined SHARED
+/* String with revision number of the shared object files. */
+static const char *const __nss_shlib_revision = LIBNSS_FILES_SO + 15;
+#endif
+
+/* The root of the whole data base. */
+static name_database *service_table;
+
+
+/* -1 == database not found
+ 0 == database entry pointer stored */
+int
+__nss_database_lookup (const char *database, const char *alternate_name,
+ const char *defconfig, service_user **ni)
+{
+ /* Prevent multiple threads to change the service table. */
+ __libc_lock_lock (lock);
+
+ /* Reconsider database variable in case some other thread called
+ `__nss_configure_lookup' while we waited for the lock. */
+ if (*ni != NULL)
+ {
+ __libc_lock_unlock (lock);
+ return 0;
+ }
+
+ /* Are we initialized yet? */
+ if (service_table == NULL)
+ /* Read config file. */
+ service_table = nss_parse_file (_PATH_NSSWITCH_CONF);
+
+ /* Test whether configuration data is available. */
+ if (service_table != NULL)
+ {
+ /* Return first `service_user' entry for DATABASE. */
+ name_database_entry *entry;
+
+ /* XXX Could use some faster mechanism here. But each database is
+ only requested once and so this might not be critical. */
+ for (entry = service_table->entry; entry != NULL; entry = entry->next)
+ if (strcmp (database, entry->name) == 0)
+ *ni = entry->service;
+
+ if (*ni == NULL && alternate_name != NULL)
+ /* We haven't found an entry so far. Try to find it with the
+ alternative name. */
+ for (entry = service_table->entry; entry != NULL; entry = entry->next)
+ if (strcmp (alternate_name, entry->name) == 0)
+ *ni = entry->service;
+ }
+
+ /* No configuration data is available, either because nsswitch.conf
+ doesn't exist or because it doesn't has a line for this database.
+
+ DEFCONFIG specifies the default service list for this database,
+ or null to use the most common default. */
+ if (*ni == NULL)
+ *ni = nss_parse_service_list (defconfig
+ ?: "nis [NOTFOUND=return] files");
+
+ __libc_lock_unlock (lock);
+
+ return 0;
+}
+libc_hidden_def (__nss_database_lookup)
+
+
+/* -1 == not found
+ 0 == function found
+ 1 == finished */
+int
+__nss_lookup (service_user **ni, const char *fct_name, void **fctp)
+{
+ *fctp = __nss_lookup_function (*ni, fct_name);
+
+ while (*fctp == NULL
+ && nss_next_action (*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_CONTINUE
+ && (*ni)->next != NULL)
+ {
+ *ni = (*ni)->next;
+
+ *fctp = __nss_lookup_function (*ni, fct_name);
+ }
+
+ return *fctp != NULL ? 0 : (*ni)->next == NULL ? 1 : -1;
+}
+
+
+/* -1 == not found
+ 0 == adjusted for next function
+ 1 == finished */
+int
+__nss_next (service_user **ni, const char *fct_name, void **fctp, int status,
+ int all_values)
+{
+ if (all_values)
+ {
+ if (nss_next_action (*ni, NSS_STATUS_TRYAGAIN) == NSS_ACTION_RETURN
+ && nss_next_action (*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_RETURN
+ && nss_next_action (*ni, NSS_STATUS_NOTFOUND) == NSS_ACTION_RETURN
+ && nss_next_action (*ni, NSS_STATUS_SUCCESS) == NSS_ACTION_RETURN)
+ return 1;
+ }
+ else
+ {
+ /* This is really only for debugging. */
+ if (NSS_STATUS_TRYAGAIN > status || status > NSS_STATUS_RETURN)
+ {
+ fprintf (stderr, "illegal status in __nss_next");
+ abort();
+ }
+
+ if (nss_next_action (*ni, status) == NSS_ACTION_RETURN)
+ return 1;
+ }
+
+ if ((*ni)->next == NULL)
+ return -1;
+
+ do
+ {
+ *ni = (*ni)->next;
+
+ *fctp = __nss_lookup_function (*ni, fct_name);
+ }
+ while (*fctp == NULL
+ && nss_next_action (*ni, NSS_STATUS_UNAVAIL) == NSS_ACTION_CONTINUE
+ && (*ni)->next != NULL);
+
+ return *fctp != NULL ? 0 : -1;
+}
+libc_hidden_def (__nss_next)
+
+
+int
+__nss_configure_lookup (const char *dbname, const char *service_line)
+{
+ service_user *new_db;
+ size_t cnt;
+
+ for (cnt = 0; cnt < sizeof databases; ++cnt)
+ {
+ int cmp = strcmp (dbname, databases[cnt].name);
+ if (cmp == 0)
+ break;
+ if (cmp < 0)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+ }
+
+ if (cnt == sizeof databases)
+ {
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ /* Test whether it is really used. */
+ if (databases[cnt].dbp == NULL)
+ /* Nothing to do, but we could do. */
+ return 0;
+
+ /* Try to generate new data. */
+ new_db = nss_parse_service_list (service_line);
+ if (new_db == NULL)
+ {
+ /* Illegal service specification. */
+ __set_errno (EINVAL);
+ return -1;
+ }
+
+ /* Prevent multiple threads to change the service table. */
+ __libc_lock_lock (lock);
+
+ /* Install new rules. */
+ *databases[cnt].dbp = new_db;
+
+ __libc_lock_unlock (lock);
+
+ return 0;
+}
+
+
+/* Comparison function for searching NI->known tree. */
+static int
+known_compare (const void *p1, const void *p2)
+{
+ return p1 == p2 ? 0 : strcmp (*(const char *const *) p1,
+ *(const char *const *) p2);
+}
+
+
+void *
+__nss_lookup_function (service_user *ni, const char *fct_name)
+{
+ void **found, *result;
+
+ /* We now modify global data. Protect it. */
+ __libc_lock_lock (lock);
+
+ /* Search the tree of functions previously requested. Data in the
+ tree are `known_function' structures, whose first member is a
+ `const char *', the lookup key. The search returns a pointer to
+ the tree node structure; the first member of the is a pointer to
+ our structure (i.e. what will be a `known_function'); since the
+ first member of that is the lookup key string, &FCT_NAME is close
+ enough to a pointer to our structure to use as a lookup key that
+ will be passed to `known_compare' (above). */
+
+ found = tsearch (&fct_name, (void **) &ni->known, &known_compare);
+ if (*found != &fct_name)
+ /* The search found an existing structure in the tree. */
+ result = ((known_function *) *found)->fct_ptr;
+ else
+ {
+ /* This name was not known before. Now we have a node in the tree
+ (in the proper sorted position for FCT_NAME) that points to
+ &FCT_NAME instead of any real `known_function' structure.
+ Allocate a new structure and fill it in. */
+
+ known_function *known = malloc (sizeof *known);
+ if (! known)
+ {
+ remove_from_tree:
+ /* Oops. We can't instantiate this node properly.
+ Remove it from the tree. */
+ tdelete (&fct_name, (void **) &ni->known, &known_compare);
+ result = NULL;
+ }
+ else
+ {
+ /* Point the tree node at this new structure. */
+ *found = known;
+ known->fct_name = fct_name;
+
+ if (ni->library == NULL)
+ {
+ /* This service has not yet been used. Fetch the service
+ library for it, creating a new one if need be. If there
+ is no service table from the file, this static variable
+ holds the head of the service_library list made from the
+ default configuration. */
+ static name_database default_table;
+ ni->library = nss_new_service (service_table ?: &default_table,
+ ni->name);
+ if (ni->library == NULL)
+ {
+ /* This only happens when out of memory. */
+ free (known);
+ goto remove_from_tree;
+ }
+ }
+
+#if !defined DO_STATIC_NSS || defined SHARED
+ if (ni->library->lib_handle == NULL)
+ {
+ /* Load the shared library. */
+ size_t shlen = (7 + strlen (ni->library->name) + 3
+ + strlen (__nss_shlib_revision) + 1);
+ int saved_errno = errno;
+ char shlib_name[shlen];
+
+ /* Construct shared object name. */
+ stpcpy (stpcpy (stpcpy (stpcpy (shlib_name,
+ "libnss_"),
+ ni->library->name),
+ ".so"),
+ __nss_shlib_revision);
+
+ ni->library->lib_handle = __libc_dlopen (shlib_name);
+ if (ni->library->lib_handle == NULL)
+ {
+ /* Failed to load the library. */
+ ni->library->lib_handle = (void *) -1l;
+ __set_errno (saved_errno);
+ }
+ }
+
+ if (ni->library->lib_handle == (void *) -1l)
+ /* Library not found => function not found. */
+ result = NULL;
+ else
+ {
+ /* Get the desired function. */
+ size_t namlen = (5 + strlen (ni->library->name) + 1
+ + strlen (fct_name) + 1);
+ char name[namlen];
+
+ /* Construct the function name. */
+ stpcpy (stpcpy (stpcpy (stpcpy (name, "_nss_"),
+ ni->library->name),
+ "_"),
+ fct_name);
+
+ /* Look up the symbol. */
+ result = __libc_dlsym (ni->library->lib_handle, name);
+ }
+#else
+ /* We can't get function address dynamically in static linking. */
+ {
+# define DEFINE_ENT(h,nm) \
+ { #h"_get"#nm"ent_r", _nss_##h##_get##nm##ent_r }, \
+ { #h"_end"#nm"ent", _nss_##h##_end##nm##ent }, \
+ { #h"_set"#nm"ent", _nss_##h##_set##nm##ent },
+# define DEFINE_GET(h,nm) \
+ { #h"_get"#nm"_r", _nss_##h##_get##nm##_r },
+# define DEFINE_GETBY(h,nm,ky) \
+ { #h"_get"#nm"by"#ky"_r", _nss_##h##_get##nm##by##ky##_r },
+ static struct fct_tbl { const char *fname; void *fp; } *tp, tbl[] =
+ {
+# include "function.def"
+ { NULL, NULL }
+ };
+ size_t namlen = (5 + strlen (ni->library->name) + 1
+ + strlen (fct_name) + 1);
+ char name[namlen];
+
+ /* Construct the function name. */
+ stpcpy (stpcpy (stpcpy (name, ni->library->name),
+ "_"),
+ fct_name);
+
+ result = NULL;
+ for (tp = &tbl[0]; tp->fname; tp++)
+ if (strcmp (tp->fname, name) == 0)
+ {
+ result = tp->fp;
+ break;
+ }
+ }
+#endif
+
+ /* Remember function pointer for later calls. Even if null, we
+ record it so a second try needn't search the library again. */
+ known->fct_ptr = result;
+ }
+ }
+
+ /* Remove the lock. */
+ __libc_lock_unlock (lock);
+
+ return result;
+}
+libc_hidden_def (__nss_lookup_function)
+
+
+static name_database *
+internal_function
+nss_parse_file (const char *fname)
+{
+ FILE *fp;
+ name_database *result;
+ name_database_entry *last;
+ char *line;
+ size_t len;
+
+ /* Open the configuration file. */
+ fp = fopen (fname, "rc");
+ if (fp == NULL)
+ return NULL;
+
+ /* No threads use this stream. */
+ __fsetlocking (fp, FSETLOCKING_BYCALLER);
+
+ result = (name_database *) malloc (sizeof (name_database));
+ if (result == NULL)
+ return NULL;
+
+ result->entry = NULL;
+ result->library = NULL;
+ last = NULL;
+ line = NULL;
+ len = 0;
+ do
+ {
+ name_database_entry *this;
+ ssize_t n;
+ char *tmp;
+
+ n = __getline (&line, &len, fp);
+ if (n < 0)
+ break;
+ if (line[n - 1] == '\n')
+ line[n - 1] = '\0';
+
+ /* Because the file format does not know any form of quoting we
+ can search forward for the next '#' character and if found
+ make it terminating the line. */
+ tmp = strchr (line, '#');
+ if (tmp == NULL)
+ tmp = line + strlen (line);
+ *tmp = '\0';
+
+ /* If the line is blank it is ignored. */
+ if (line[0] == '\0')
+ continue;
+
+ /* Each line completely specifies the actions for a database. */
+ this = nss_getline (line);
+ if (this != NULL)
+ {
+ if (last != NULL)
+ last->next = this;
+ else
+ result->entry = this;
+
+ last = this;
+ }
+ }
+ while (!feof (fp));
+
+ /* Free the buffer. */
+ free (line);
+ /* Close configuration file. */
+ fclose (fp);
+
+ return result;
+}
+
+
+/* Read the source names:
+ `( <source> ( "[" "!"? (<status> "=" <action> )+ "]" )? )*'
+ */
+static service_user *
+internal_function
+nss_parse_service_list (const char *line)
+{
+ service_user *result = NULL, **nextp = &result;
+
+ while (1)
+ {
+ service_user *new_service;
+ const char *name;
+
+ while (isspace (line[0]))
+ ++line;
+ if (line[0] == '\0')
+ /* No source specified. */
+ return result;
+
+ /* Read <source> identifier. */
+ name = line;
+ while (line[0] != '\0' && !isspace (line[0]) && line[0] != '[')
+ ++line;
+ if (name == line)
+ return result;
+
+
+ new_service = (service_user *) malloc (sizeof (service_user)
+ + (line - name + 1));
+ if (new_service == NULL)
+ return result;
+
+ *((char *) mempcpy (new_service->name, name, line - name)) = '\0';
+
+ /* Set default actions. */
+ new_service->actions[2 + NSS_STATUS_TRYAGAIN] = NSS_ACTION_CONTINUE;
+ new_service->actions[2 + NSS_STATUS_UNAVAIL] = NSS_ACTION_CONTINUE;
+ new_service->actions[2 + NSS_STATUS_NOTFOUND] = NSS_ACTION_CONTINUE;
+ new_service->actions[2 + NSS_STATUS_SUCCESS] = NSS_ACTION_RETURN;
+ new_service->actions[2 + NSS_STATUS_RETURN] = NSS_ACTION_RETURN;
+ new_service->library = NULL;
+ new_service->known = NULL;
+ new_service->next = NULL;
+
+ while (isspace (line[0]))
+ ++line;
+
+ if (line[0] == '[')
+ {
+ /* Read criterions. */
+ do
+ ++line;
+ while (line[0] != '\0' && isspace (line[0]));
+
+ do
+ {
+ int not;
+ enum nss_status status;
+ lookup_actions action;
+
+ /* Grok ! before name to mean all statii but that one. */
+ not = line[0] == '!';
+ if (not)
+ ++line;
+
+ /* Read status name. */
+ name = line;
+ while (line[0] != '\0' && !isspace (line[0]) && line[0] != '='
+ && line[0] != ']')
+ ++line;
+
+ /* Compare with known statii. */
+ if (line - name == 7)
+ {
+ if (strncasecmp (name, "SUCCESS", 7) == 0)
+ status = NSS_STATUS_SUCCESS;
+ else if (strncasecmp (name, "UNAVAIL", 7) == 0)
+ status = NSS_STATUS_UNAVAIL;
+ else
+ return result;
+ }
+ else if (line - name == 8)
+ {
+ if (strncasecmp (name, "NOTFOUND", 8) == 0)
+ status = NSS_STATUS_NOTFOUND;
+ else if (strncasecmp (name, "TRYAGAIN", 8) == 0)
+ status = NSS_STATUS_TRYAGAIN;
+ else
+ return result;
+ }
+ else
+ return result;
+
+ while (isspace (line[0]))
+ ++line;
+ if (line[0] != '=')
+ return result;
+ do
+ ++line;
+ while (isspace (line[0]));
+
+ name = line;
+ while (line[0] != '\0' && !isspace (line[0]) && line[0] != '='
+ && line[0] != ']')
+ ++line;
+
+ if (line - name == 6 && strncasecmp (name, "RETURN", 6) == 0)
+ action = NSS_ACTION_RETURN;
+ else if (line - name == 8
+ && strncasecmp (name, "CONTINUE", 8) == 0)
+ action = NSS_ACTION_CONTINUE;
+ else
+ return result;
+
+ if (not)
+ {
+ /* Save the current action setting for this status,
+ set them all to the given action, and reset this one. */
+ const lookup_actions save = new_service->actions[2 + status];
+ new_service->actions[2 + NSS_STATUS_TRYAGAIN] = action;
+ new_service->actions[2 + NSS_STATUS_UNAVAIL] = action;
+ new_service->actions[2 + NSS_STATUS_NOTFOUND] = action;
+ new_service->actions[2 + NSS_STATUS_SUCCESS] = action;
+ new_service->actions[2 + status] = save;
+ }
+ else
+ new_service->actions[2 + status] = action;
+
+ /* Skip white spaces. */
+ while (isspace (line[0]))
+ ++line;
+ }
+ while (line[0] != ']');
+
+ /* Skip the ']'. */
+ ++line;
+ }
+
+ *nextp = new_service;
+ nextp = &new_service->next;
+ }
+}
+
+static name_database_entry *
+internal_function
+nss_getline (char *line)
+{
+ const char *name;
+ name_database_entry *result;
+ size_t len;
+
+ /* Ignore leading white spaces. ATTENTION: this is different from
+ what is implemented in Solaris. The Solaris man page says a line
+ beginning with a white space character is ignored. We regard
+ this as just another misfeature in Solaris. */
+ while (isspace (line[0]))
+ ++line;
+
+ /* Recognize `<database> ":"'. */
+ name = line;
+ while (line[0] != '\0' && !isspace (line[0]) && line[0] != ':')
+ ++line;
+ if (line[0] == '\0' || name == line)
+ /* Syntax error. */
+ return NULL;
+ *line++ = '\0';
+
+ len = strlen (name) + 1;
+
+ result = (name_database_entry *) malloc (sizeof (name_database_entry) + len);
+ if (result == NULL)
+ return NULL;
+
+ /* Save the database name. */
+ memcpy (result->name, name, len);
+
+ /* Parse the list of services. */
+ result->service = nss_parse_service_list (line);
+
+ result->next = NULL;
+ return result;
+}
+
+
+static service_library *
+internal_function
+nss_new_service (name_database *database, const char *name)
+{
+ service_library **currentp = &database->library;
+
+ while (*currentp != NULL)
+ {
+ if (strcmp ((*currentp)->name, name) == 0)
+ return *currentp;
+ currentp = &(*currentp)->next;
+ }
+
+ /* We have to add the new service. */
+ *currentp = (service_library *) malloc (sizeof (service_library));
+ if (*currentp == NULL)
+ return NULL;
+
+ (*currentp)->name = name;
+ (*currentp)->lib_handle = NULL;
+ (*currentp)->next = NULL;
+
+ return *currentp;
+}
+
+
+#ifdef USE_NSCD
+/* Called by nscd and nscd alone. */
+void
+__nss_disable_nscd (void)
+{
+ /* Disable all uses of NSCD. */
+ __nss_not_use_nscd_passwd = -1;
+ __nss_not_use_nscd_group = -1;
+ __nss_not_use_nscd_hosts = -1;
+}
+#endif
+
+
+/* Free all resources if necessary. */
+libc_freeres_fn (free_mem)
+{
+ name_database *top = service_table;
+ name_database_entry *entry;
+ service_library *library;
+
+ if (top == NULL)
+ /* Maybe we have not read the nsswitch.conf file. */
+ return;
+
+ /* Don't disturb ongoing other threads (if there are any). */
+ service_table = NULL;
+
+ entry = top->entry;
+ while (entry != NULL)
+ {
+ name_database_entry *olde = entry;
+ service_user *service = entry->service;
+
+ while (service != NULL)
+ {
+ service_user *olds = service;
+
+ if (service->known != NULL)
+ tdestroy (service->known, free);
+
+ service = service->next;
+ free (olds);
+ }
+
+ entry = entry->next;
+ free (olde);
+ }
+
+ library = top->library;
+ while (library != NULL)
+ {
+ service_library *oldl = library;
+
+ if (library->lib_handle && library->lib_handle != (void *) -1l)
+ __libc_dlclose (library->lib_handle);
+
+ library = library->next;
+ free (oldl);
+ }
+
+ free (top);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-24 23:33:29 +0000