Back to index

glibc  2.9
Defines | Functions
files-netgrp.c File Reference
#include <ctype.h>
#include <errno.h>
#include <netdb.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <string.h>
#include "nsswitch.h"
#include "netgroup.h"

Go to the source code of this file.

Defines

#define DATAFILE   "/etc/netgroup"
#define EXPAND(needed)

Functions

 libnss_files_hidden_proto (_nss_files_endnetgrent)
enum nss_status _nss_files_endnetgrent (struct __netgrent *result)
 libnss_files_hidden_def (_nss_files_endnetgrent)
enum nss_status _nss_netgroup_parseline (char **cursor, struct __netgrent *result, char *buffer, size_t buflen, int *errnop)
 libnss_files_hidden_def (_nss_netgroup_parseline)

Define Documentation

#define DATAFILE   "/etc/netgroup"

Definition at line 31 of file files-netgrp.c.

#define EXPAND (   needed)
Value:
do                                                                   \
    {                                                                \
      size_t old_cursor = result->cursor - result->data;                    \
      void *old_data = result->data;                                        \
                                                                     \
      result->data_size += 512 > 2 * needed ? 512 : 2 * needed;                    \
      result->data = realloc (result->data, result->data_size);                    \
                                                                     \
      if (result->data == NULL)                                             \
       {                                                             \
         free (old_data);                                            \
         status = NSS_STATUS_UNAVAIL;                                       \
         goto the_end;                                                      \
       }                                                             \
                                                                     \
      result->cursor = result->data + old_cursor;                           \
    }                                                                \
  while (0)

Function Documentation

enum nss_status _nss_files_endnetgrent ( struct __netgrent result)

Definition at line 157 of file files-netgrp.c.

{
  /* Free allocated memory for data if some is present.  */
  free (result->data);
  result->data = NULL;
  result->data_size = 0;
  result->cursor = NULL;
  return NSS_STATUS_SUCCESS;
}

Here is the caller graph for this function:

enum nss_status _nss_netgroup_parseline ( char **  cursor,
struct __netgrent result,
char *  buffer,
size_t  buflen,
int errnop 
)

Definition at line 188 of file files-netgrp.c.

{
  enum nss_status status;
  const char *host, *user, *domain;
  char *cp = *cursor;

  /* Some sanity checks.  */
  if (cp == NULL)
    return NSS_STATUS_NOTFOUND;

  /* First skip leading spaces.  */
  while (isspace (*cp))
    ++cp;

  if (*cp != '(')
    {
      /* We have a list of other netgroups.  */
      char *name = cp;

      while (*cp != '\0' && ! isspace (*cp))
       ++cp;

      if (name != cp)
       {
         /* It is another netgroup name.  */
         int last = *cp == '\0';

         result->type = group_val;
         result->val.group = name;
         *cp = '\0';
         if (! last)
           ++cp;
         *cursor = cp;
         result->first = 0;

         return NSS_STATUS_SUCCESS;
       }

      return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
    }

  /* Match host name.  */
  host = ++cp;
  while (*cp != ',')
    if (*cp++ == '\0')
      return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;

  /* Match user name.  */
  user = ++cp;
  while (*cp != ',')
    if (*cp++ == '\0')
      return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;

  /* Match domain name.  */
  domain = ++cp;
  while (*cp != ')')
    if (*cp++ == '\0')
      return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
  ++cp;


  /* When we got here we have found an entry.  Before we can copy it
     to the private buffer we have to make sure it is big enough.  */
  if (cp - host > buflen)
    {
      *errnop = ERANGE;
      status = NSS_STATUS_UNAVAIL;
    }
  else
    {
      memcpy (buffer, host, cp - host);
      result->type = triple_val;

      buffer[(user - host) - 1] = '\0';   /* Replace ',' with '\0'.  */
      result->val.triple.host = strip_whitespace (buffer);

      buffer[(domain - host) - 1] = '\0'; /* Replace ',' with '\0'.  */
      result->val.triple.user = strip_whitespace (buffer + (user - host));

      buffer[(cp - host) - 1] = '\0'; /* Replace ')' with '\0'.  */
      result->val.triple.domain = strip_whitespace (buffer + (domain - host));

      status = NSS_STATUS_SUCCESS;

      /* Remember where we stopped reading.  */
      *cursor = cp;

      result->first = 0;
    }

  return status;
}

Here is the caller graph for this function:

Definition at line 166 of file files-netgrp.c.

{
  char *cp = str;

  /* Skip leading spaces.  */
  while (isspace (*cp))
    cp++;

  str = cp;
  while (*cp != '\0' && ! isspace(*cp))
    cp++;

  /* Null-terminate, stripping off any trailing spaces.  */
  *cp = '\0';

  return *str == '\0' ? NULL : str;
}

Definition at line 281 of file files-netgrp.c.

{
  enum nss_status status;

  status = _nss_netgroup_parseline (&result->cursor, result, buffer, buflen,
                                errnop);

  return status;
}

Here is the call graph for this function:

Definition at line 33 of file files-netgrp.c.

    {                                                                \
      size_t old_cursor = result->cursor - result->data;                    \
      void *old_data = result->data;                                        \
                                                                     \
      result->data_size += 512 > 2 * needed ? 512 : 2 * needed;                    \
      result->data = realloc (result->data, result->data_size);                    \
                                                                     \
      if (result->data == NULL)                                             \
       {                                                             \
         free (old_data);                                            \
         status = NSS_STATUS_UNAVAIL;                                       \
         goto the_end;                                                      \
       }                                                             \
                                                                     \
      result->cursor = result->data + old_cursor;                           \
    }                                                                \
  while (0)


enum nss_status
_nss_files_setnetgrent (const char *group, struct __netgrent *result)
{
  FILE *fp;
  enum nss_status status;

  if (group[0] == '\0')
    return NSS_STATUS_UNAVAIL;

  /* Find the netgroups file and open it.  */
  fp = fopen (DATAFILE, "r");
  if (fp == NULL)
    status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
  else
    {
      /* Read the file line by line and try to find the description
        GROUP.  We must take care for long lines.  */
      char *line = NULL;
      size_t line_len = 0;
      const ssize_t group_len = strlen (group);

      status = NSS_STATUS_NOTFOUND;
      result->cursor = result->data;

      __fsetlocking (fp, FSETLOCKING_BYCALLER);

      while (!feof_unlocked (fp))
       {
         ssize_t curlen = getline (&line, &line_len, fp);
         int found;

         if (curlen < 0)
           {
             status = NSS_STATUS_NOTFOUND;
             break;
           }

         found = (curlen > group_len && strncmp (line, group, group_len) == 0
                 && isspace (line[group_len]));

         /* Read the whole line (including continuation) and store it
            if FOUND in nonzero.  Otherwise we don't need it.  */
         if (found)
           {
             /* Store the data from the first line.  */
             EXPAND (curlen - group_len);
             memcpy (result->cursor, &line[group_len + 1],
                    curlen - group_len);
             result->cursor += (curlen - group_len) - 1;
           }

         while (line[curlen - 1] == '\n' && line[curlen - 2] == '\\')
           {
             /* Yes, we have a continuation line.  */
             if (found)
              /* Remove these characters from the stored line.  */
              result->cursor -= 2;

             /* Get next line.  */
             curlen = getline (&line, &line_len, fp);
             if (curlen <= 0)
              break;

             if (found)
              {
                /* Make sure we have enough room.  */
                EXPAND (1 + curlen + 1);

                /* Add separator in case next line starts immediately.  */
                *result->cursor++ = ' ';

                /* Copy new line.  */
                memcpy (result->cursor, line, curlen + 1);
                result->cursor += curlen;
              }
           }

         if (found)
           {
             /* Now we have read the line.  */
             status = NSS_STATUS_SUCCESS;
             result->cursor = result->data;
             result->first = 1;
             break;
           }
       }

    the_end:
      /* We don't need the file and the line buffer anymore.  */
      free (line);
      fclose (fp);

      if (status != NSS_STATUS_SUCCESS)
       _nss_files_endnetgrent (result);
    }

  return status;
}

Here is the call graph for this function: