1/* Netgroup file parser in nss_files modules.
2 Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#include <ctype.h>
21#include <errno.h>
22#include <netdb.h>
23#include <stdio.h>
24#include <stdio_ext.h>
25#include <stdlib.h>
26#include <string.h>
27#include "nsswitch.h"
28#include "netgroup.h"
29#include <nss_files.h>
30
31#define DATAFILE "/etc/netgroup"
32
33libc_hidden_proto (_nss_files_endnetgrent)
34
35#define EXPAND(needed) \
36 do \
37 { \
38 size_t old_cursor = result->cursor - result->data; \
39 void *old_data = result->data; \
40 \
41 result->data_size += 512 > 2 * needed ? 512 : 2 * needed; \
42 result->data = realloc (result->data, result->data_size); \
43 \
44 if (result->data == NULL) \
45 { \
46 free (old_data); \
47 status = NSS_STATUS_UNAVAIL; \
48 goto the_end; \
49 } \
50 \
51 result->cursor = result->data + old_cursor; \
52 } \
53 while (0)
54
55
56enum nss_status
57_nss_files_setnetgrent (const char *group, struct __netgrent *result)
58{
59 FILE *fp;
60 enum nss_status status;
61
62 if (group[0] == '\0')
63 return NSS_STATUS_UNAVAIL;
64
65 /* Find the netgroups file and open it. */
66 fp = __nss_files_fopen (DATAFILE);
67 if (fp == NULL)
68 status = errno == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
69 else
70 {
71 /* Read the file line by line and try to find the description
72 GROUP. We must take care for long lines. */
73 char *line = NULL;
74 size_t line_len = 0;
75 const ssize_t group_len = strlen (group);
76
77 status = NSS_STATUS_NOTFOUND;
78 result->cursor = result->data;
79
80 while (!__feof_unlocked (fp))
81 {
82 ssize_t curlen = __getline (&line, &line_len, fp);
83 int found;
84
85 if (curlen < 0)
86 {
87 status = NSS_STATUS_NOTFOUND;
88 break;
89 }
90
91 found = (curlen > group_len && strncmp (line, group, group_len) == 0
92 && isspace (line[group_len]));
93
94 /* Read the whole line (including continuation) and store it
95 if FOUND in nonzero. Otherwise we don't need it. */
96 if (found)
97 {
98 /* Store the data from the first line. */
99 EXPAND (curlen - group_len);
100 memcpy (result->cursor, &line[group_len + 1],
101 curlen - group_len);
102 result->cursor += (curlen - group_len) - 1;
103 }
104
105 while (curlen > 1 && line[curlen - 1] == '\n'
106 && line[curlen - 2] == '\\')
107 {
108 /* Yes, we have a continuation line. */
109 if (found)
110 /* Remove these characters from the stored line. */
111 result->cursor -= 2;
112
113 /* Get next line. */
114 curlen = __getline (&line, &line_len, fp);
115 if (curlen <= 0)
116 break;
117
118 if (found)
119 {
120 /* Make sure we have enough room. */
121 EXPAND (1 + curlen + 1);
122
123 /* Add separator in case next line starts immediately. */
124 *result->cursor++ = ' ';
125
126 /* Copy new line. */
127 memcpy (result->cursor, line, curlen + 1);
128 result->cursor += curlen;
129 }
130 }
131
132 if (found)
133 {
134 /* Now we have read the line. */
135 status = NSS_STATUS_SUCCESS;
136 result->cursor = result->data;
137 result->first = 1;
138 break;
139 }
140 }
141
142 the_end:
143 /* We don't need the file and the line buffer anymore. */
144 free (line);
145 fclose (fp);
146
147 if (status != NSS_STATUS_SUCCESS)
148 _nss_files_endnetgrent (result);
149 }
150
151 return status;
152}
153libc_hidden_def (_nss_files_setnetgrent)
154
155enum nss_status
156_nss_files_endnetgrent (struct __netgrent *result)
157{
158 /* Free allocated memory for data if some is present. */
159 free (result->data);
160 result->data = NULL;
161 result->data_size = 0;
162 result->cursor = NULL;
163 return NSS_STATUS_SUCCESS;
164}
165libc_hidden_def (_nss_files_endnetgrent)
166
167static char *
168strip_whitespace (char *str)
169{
170 char *cp = str;
171
172 /* Skip leading spaces. */
173 while (isspace (*cp))
174 cp++;
175
176 str = cp;
177 while (*cp != '\0' && ! isspace(*cp))
178 cp++;
179
180 /* Null-terminate, stripping off any trailing spaces. */
181 *cp = '\0';
182
183 return *str == '\0' ? NULL : str;
184}
185
186enum nss_status
187_nss_netgroup_parseline (char **cursor, struct __netgrent *result,
188 char *buffer, size_t buflen, int *errnop)
189{
190 enum nss_status status;
191 const char *host, *user, *domain;
192 char *cp = *cursor;
193
194 /* Some sanity checks. */
195 if (cp == NULL)
196 return NSS_STATUS_NOTFOUND;
197
198 /* First skip leading spaces. */
199 while (isspace (*cp))
200 ++cp;
201
202 if (*cp != '(')
203 {
204 /* We have a list of other netgroups. */
205 char *name = cp;
206
207 while (*cp != '\0' && ! isspace (*cp))
208 ++cp;
209
210 if (name != cp)
211 {
212 /* It is another netgroup name. */
213 int last = *cp == '\0';
214
215 result->type = group_val;
216 result->val.group = name;
217 *cp = '\0';
218 if (! last)
219 ++cp;
220 *cursor = cp;
221 result->first = 0;
222
223 return NSS_STATUS_SUCCESS;
224 }
225
226 return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
227 }
228
229 /* Match host name. */
230 host = ++cp;
231 while (*cp != ',')
232 if (*cp++ == '\0')
233 return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
234
235 /* Match user name. */
236 user = ++cp;
237 while (*cp != ',')
238 if (*cp++ == '\0')
239 return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
240
241 /* Match domain name. */
242 domain = ++cp;
243 while (*cp != ')')
244 if (*cp++ == '\0')
245 return result->first ? NSS_STATUS_NOTFOUND : NSS_STATUS_RETURN;
246 ++cp;
247
248
249 /* When we got here we have found an entry. Before we can copy it
250 to the private buffer we have to make sure it is big enough. */
251 if (cp - host > buflen)
252 {
253 *errnop = ERANGE;
254 status = NSS_STATUS_TRYAGAIN;
255 }
256 else
257 {
258 memcpy (buffer, host, cp - host);
259 result->type = triple_val;
260
261 buffer[(user - host) - 1] = '\0'; /* Replace ',' with '\0'. */
262 result->val.triple.host = strip_whitespace (buffer);
263
264 buffer[(domain - host) - 1] = '\0'; /* Replace ',' with '\0'. */
265 result->val.triple.user = strip_whitespace (buffer + (user - host));
266
267 buffer[(cp - host) - 1] = '\0'; /* Replace ')' with '\0'. */
268 result->val.triple.domain = strip_whitespace (buffer + (domain - host));
269
270 status = NSS_STATUS_SUCCESS;
271
272 /* Remember where we stopped reading. */
273 *cursor = cp;
274
275 result->first = 0;
276 }
277
278 return status;
279}
280libc_hidden_def (_nss_netgroup_parseline)
281
282
283enum nss_status
284_nss_files_getnetgrent_r (struct __netgrent *result, char *buffer,
285 size_t buflen, int *errnop)
286{
287 enum nss_status status;
288
289 status = _nss_netgroup_parseline (&result->cursor, result, buffer, buflen,
290 errnop);
291
292 return status;
293}
294libc_hidden_def (_nss_files_getnetgrent_r)
295