295 lines
7.3 KiB
C
295 lines
7.3 KiB
C
/* Netgroup file parser in nss_files modules.
|
|
Copyright (C) 1996-2014 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, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#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"
|
|
|
|
#define DATAFILE "/etc/netgroup"
|
|
|
|
libnss_files_hidden_proto (_nss_files_endnetgrent)
|
|
|
|
#define EXPAND(needed) \
|
|
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)
|
|
|
|
|
|
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, "rce");
|
|
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 (curlen > 1 && 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;
|
|
}
|
|
|
|
|
|
enum nss_status
|
|
_nss_files_endnetgrent (struct __netgrent *result)
|
|
{
|
|
/* 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;
|
|
}
|
|
libnss_files_hidden_def (_nss_files_endnetgrent)
|
|
|
|
static char *
|
|
strip_whitespace (char *str)
|
|
{
|
|
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;
|
|
}
|
|
|
|
enum nss_status
|
|
_nss_netgroup_parseline (char **cursor, struct __netgrent *result,
|
|
char *buffer, size_t buflen, int *errnop)
|
|
{
|
|
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;
|
|
}
|
|
libnss_files_hidden_def (_nss_netgroup_parseline)
|
|
|
|
|
|
enum nss_status
|
|
_nss_files_getnetgrent_r (struct __netgrent *result, char *buffer,
|
|
size_t buflen, int *errnop)
|
|
{
|
|
enum nss_status status;
|
|
|
|
status = _nss_netgroup_parseline (&result->cursor, result, buffer, buflen,
|
|
errnop);
|
|
|
|
return status;
|
|
}
|