Back to index

glibc  2.9
Functions
db-alias.c File Reference
#include <aliases.h>
#include <alloca.h>
#include <ctype.h>
#include <dlfcn.h>
#include <errno.h>
#include <bits/libc-lock.h>
#include <paths.h>
#include <string.h>
#include "nsswitch.h"
#include "nss_db.h"

Go to the source code of this file.

Functions

 __libc_lock_define_initialized (static, lock)
enum nss_status _nss_db_endaliasent (void)
static enum nss_status lookup (DBT *key, struct aliasent *result, char *buffer, size_t buflen, int *errnop)
enum nss_status _nss_db_getaliasent_r (struct aliasent *result, char *buffer, size_t buflen, int *errnop)
enum nss_status _nss_db_getaliasbyname_r (const char *name, struct aliasent *result, char *buffer, size_t buflen, int *errnop)

Function Documentation

__libc_lock_define_initialized ( static  ,
lock   
)

Definition at line 34 of file db-alias.c.

{
  enum nss_status status;

  __libc_lock_lock (lock);

  status = internal_setent (_PATH_VARDB "aliases.db", &db);

  /* Remember STAYOPEN flag.  */
  if (db != NULL)
    keep_db |= stayopen;

  /* Reset the sequential index.  */
  entidx = 0;

  __libc_lock_unlock (lock);

  return status;
}

Here is the call graph for this function:

Definition at line 68 of file db-alias.c.

{
  __libc_lock_lock (lock);

  internal_endent (&db);

  /* Reset STAYOPEN flag.  */
  keep_db = 0;

  __libc_lock_unlock (lock);

  return NSS_STATUS_SUCCESS;
}

Here is the call graph for this function:

enum nss_status _nss_db_getaliasbyname_r ( const char *  name,
struct aliasent result,
char *  buffer,
size_t  buflen,
int errnop 
)

Definition at line 197 of file db-alias.c.

{
  DBT key;
  enum nss_status status;

  key.size = 1 + strlen (name);

  key.data = __alloca (key.size);
  ((char *) key.data)[0] = '.';
  memcpy (&((char *) key.data)[1], name, key.size - 1);
  key.flags = 0;

  __libc_lock_lock (lock);
  status = lookup (&key, result, buffer, buflen, errnop);
  __libc_lock_unlock (lock);

  return status;
}

Here is the call graph for this function:

enum nss_status _nss_db_getaliasent_r ( struct aliasent result,
char *  buffer,
size_t  buflen,
int errnop 
)

Definition at line 175 of file db-alias.c.

{
  /* Return next entry in alias file.  */
  enum nss_status status;
  char buf[20];
  DBT key;

  __libc_lock_lock (lock);
  key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
  key.flags = 0;
  status = lookup (&key, result, buffer, buflen, errnop);
  if (status == NSS_STATUS_TRYAGAIN && *errnop == ERANGE)
    /* Give the user a chance to get the same entry with a larger buffer.  */
    --entidx;
  __libc_lock_unlock (lock);

  return status;
}

Here is the call graph for this function:

static enum nss_status lookup ( DBT key,
struct aliasent result,
char *  buffer,
size_t  buflen,
int errnop 
) [static]

Definition at line 87 of file db-alias.c.

{
  enum nss_status status;
  DBT value;

  /* Open the database.  */
  if (db == NULL)
    {
      status = internal_setent (_PATH_VARDB "aliases.db", &db);
      if (status != NSS_STATUS_SUCCESS)
       {
         *errnop = errno;
         return status;
       }
    }

  value.flags = 0;
  if (DL_CALL_FCT (db->get, (db->db, NULL, key, &value, 0)) == 0)
    {
      const char *src = value.data;
      char *cp;
      size_t cnt;

      result->alias_members_len = 0;

      /* We now have to fill the BUFFER with all the information. */
      if (buflen < key->size + 1)
       {
       no_more_room:
         *errnop = ERANGE;
         return NSS_STATUS_TRYAGAIN;
       }

      buffer = stpncpy (buffer, key->data, key->size) + 1;
      buflen -= key->size + 1;

      while (*src != '\0')
       {
         const char *end, *upto;
         while (isspace (*src))
           ++src;

         end = strchr (src, ',');
         if (end == NULL)
           end = strchr (src, '\0');
         for (upto = end; upto > src && isspace (upto[-1]); --upto);

         if (upto != src)
           {
             if ((upto - src) + __alignof__ (char *) > buflen)
              goto no_more_room;
             buffer = stpncpy (buffer, src, upto - src) + 1;
             buflen -= (upto - src) + __alignof (char *);
             ++result->alias_members_len;
           }
         src = end + (*end != '\0');
       }

      /* Now prepare the return.  Provide string pointers for the
        currently selected aliases.  */

      /* Adjust the pointer so it is aligned for storing pointers.  */
      buffer += __alignof__ (char *) - 1;
      buffer -= ((buffer - (char *) 0) % __alignof__ (char *));
      result->alias_members = (char **) buffer;

      /* Compute addresses of alias entry strings.  */
      cp = result->alias_name;
      for (cnt = 0; cnt < result->alias_members_len; ++cnt)
       {
         cp = strchr (cp, '\0') + 1;
         result->alias_members[cnt] = cp;
       }

      status = (result->alias_members_len == 0
              ? NSS_STATUS_RETURN : NSS_STATUS_SUCCESS);
    }
  else
    status = NSS_STATUS_NOTFOUND;

  if (! keep_db)
    internal_endent (&db);

  return status;
}

Here is the call graph for this function:

Here is the caller graph for this function: