Back to index

glibc  2.9
Defines | Functions
db-XXX.c File Reference
#include <dlfcn.h>
#include <fcntl.h>
#include <bits/libc-lock.h>
#include "nsswitch.h"
#include "nss_db.h"
#include <paths.h>

Go to the source code of this file.

Defines

#define ENTNAME_r   CONCAT(ENTNAME,_r)
#define DBFILE   _PATH_VARDB DATABASE ".db"
#define H_ERRNO_PROTO
#define H_ERRNO_ARG
#define H_ERRNO_SET(val)   ((void) 0)
#define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)
#define KEYPRINTF(pattern, args...)   snprintf (key.data, size, pattern ,##args)

Functions

 __libc_lock_define_initialized (static, lock)
enum nss_status CONCAT (_nss_db_end, ENTNAME)
static enum nss_status lookup (DBT *key, struct STRUCTURE *result, void *buffer, size_t buflen, int *errnop H_ERRNO_PROTO EXTRA_ARGS_DECL)
enum nss_status CONCAT (_nss_db_get, ENTNAME_r)

Define Documentation

#define DB_LOOKUP (   name,
  keysize,
  keypattern,
  break_if_match,
  proto... 
)
Value:
enum nss_status                                                             \
_nss_db_get##name##_r (proto,                                               \
                     struct STRUCTURE *result,                       \
                     char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\
{                                                                    \
  DBT key;                                                           \
  enum nss_status status;                                            \
  const size_t size = (keysize) + 1;                                        \
  key.data = __alloca (size);                                               \
  key.size = KEYPRINTF keypattern;                                   \
  key.flags = 0;                                                     \
  __libc_lock_lock (lock);                                           \
  status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG         \
                 EXTRA_ARGS_VALUE);                                         \
  __libc_lock_unlock (lock);                                                \
  return status;                                                     \
}

Definition at line 203 of file db-XXX.c.

#define DBFILE   _PATH_VARDB DATABASE ".db"

Definition at line 38 of file db-XXX.c.

#define ENTNAME_r   CONCAT(ENTNAME,_r)

Definition at line 35 of file db-XXX.c.

#define H_ERRNO_ARG

Definition at line 46 of file db-XXX.c.

#define H_ERRNO_PROTO

Definition at line 45 of file db-XXX.c.

#define H_ERRNO_SET (   val)    ((void) 0)

Definition at line 47 of file db-XXX.c.

#define KEYPRINTF (   pattern,
  args... 
)    snprintf (key.data, size, pattern ,##args)

Definition at line 222 of file db-XXX.c.


Function Documentation

__libc_lock_define_initialized ( static  ,
lock   
)

Definition at line 51 of file db-XXX.c.

{
  enum nss_status status;

  __libc_lock_lock (lock);

  status = internal_setent (DBFILE, &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:

enum nss_status CONCAT ( _nss_db_end  ,
ENTNAME   
)

Definition at line 84 of file db-XXX.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 CONCAT ( _nss_db_get  ,
ENTNAME_r   
)

Definition at line 229 of file db-XXX.c.

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

  __libc_lock_lock (lock);

  /* Loop until we find a valid entry or hit EOF.  See above for the
     special meaning of the status value.  */
  do
    {
      key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
      key.flags = 0;
      status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG
                     EXTRA_ARGS_VALUE);
      if (status == NSS_STATUS_TRYAGAIN
#ifdef NEED_H_ERRNO
         && *herrnop == NETDB_INTERNAL
#endif
         && *errnop == ERANGE)
       /* Give the user a chance to get the same entry with a larger
          buffer.  */
       --entidx;
    }
  while (status == NSS_STATUS_RETURN);

  __libc_lock_unlock (lock);

  return status;
}

Here is the call graph for this function:

static enum nss_status lookup ( DBT key,
struct STRUCTURE result,
void *  buffer,
size_t  buflen,
int *errnop H_ERRNO_PROTO  EXTRA_ARGS_DECL 
) [static]

Definition at line 100 of file db-XXX.c.

{
  char *p;
  enum nss_status status;
  int err;
  DBT value;

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

  /* Succeed iff it matches a value that parses correctly.  */
  value.flags = 0;
  err = DL_CALL_FCT (db->get, (db->db, NULL, key, &value, 0));
  if (err != 0)
    {
      if (err == db_notfound)
       {
         H_ERRNO_SET (HOST_NOT_FOUND);
         status = NSS_STATUS_NOTFOUND;
       }
      else
       {
         *errnop = err;
         H_ERRNO_SET (NETDB_INTERNAL);
         status = NSS_STATUS_UNAVAIL;
       }
    }
  else if (buflen < value.size)
    {
      /* No room to copy the data to.  */
      *errnop = ERANGE;
      H_ERRNO_SET (NETDB_INTERNAL);
      status = NSS_STATUS_TRYAGAIN;
    }
  else
    {
      /* Copy the result to a safe place.  */
      p = (char *) memcpy (buffer, value.data, value.size);

      /* Skip leading blanks.  */
      while (isspace (*p))
       ++p;

      err = parse_line (p, result, buffer, buflen, errnop EXTRA_ARGS);

      if (err == 0)
       {
         /* If the key begins with '0' we are trying to get the next
            entry.  We want to ignore unparsable lines in this case.  */
         if (((char *) key->data)[0] == '0')
           {
             /* Super magical return value.  We need to tell our caller
               that it should continue looping.  This value cannot
               happen in other cases.  */
             status = NSS_STATUS_RETURN;
           }
         else
           {
             H_ERRNO_SET (HOST_NOT_FOUND);
             status = NSS_STATUS_NOTFOUND;
           }
       }
      else if (err < 0)
       {
         H_ERRNO_SET (NETDB_INTERNAL);
         status = NSS_STATUS_TRYAGAIN;
       }
      else
       status = NSS_STATUS_SUCCESS;
    }

  if (! keep_db)
    internal_endent (&db);

  return status;
}

Here is the call graph for this function:

Here is the caller graph for this function: