1/* Copyright (c) 1997-2016 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <errno.h>
20#include <string.h>
21#include <rpcsvc/nis.h>
22
23nis_name
24nis_leaf_of (const_nis_name name)
25{
26 static char result[NIS_MAXNAMELEN + 1];
27
28 return nis_leaf_of_r (name, result, NIS_MAXNAMELEN);
29}
30
31nis_name
32nis_leaf_of_r (const_nis_name name, char *buffer, size_t buflen)
33{
34 size_t i = 0;
35
36 buffer[0] = '\0';
37
38 while (name[i] != '.' && name[i] != '\0')
39 i++;
40
41 if (__glibc_unlikely (i >= buflen))
42 {
43 __set_errno (ERANGE);
44 return NULL;
45 }
46
47 *((char *) __mempcpy (buffer, name, i)) = '\0';
48
49 return buffer;
50}
51libnsl_hidden_def (nis_leaf_of_r)
52
53nis_name
54nis_name_of (const_nis_name name)
55{
56 static char result[NIS_MAXNAMELEN + 1];
57
58 return nis_name_of_r (name, result, NIS_MAXNAMELEN);
59}
60
61nis_name
62nis_name_of_r (const_nis_name name, char *buffer, size_t buflen)
63{
64 char *local_domain;
65 int diff;
66
67 local_domain = nis_local_directory ();
68
69 diff = strlen (name) - strlen (local_domain);
70 if (diff <= 0)
71 return NULL;
72
73 if (strcmp (&name[diff], local_domain) != 0)
74 return NULL;
75
76 if ((size_t) diff >= buflen)
77 {
78 __set_errno (ERANGE);
79 return NULL;
80 }
81
82 *((char *) __mempcpy (buffer, name, diff - 1)) = '\0';
83
84 if (diff - 1 == 0)
85 return NULL;
86
87 return buffer;
88}
89libnsl_hidden_def (nis_name_of_r)
90
91static int __always_inline
92count_dots (const_nis_name str)
93{
94 int count = 0;
95
96 for (size_t i = 0; str[i] != '\0'; ++i)
97 if (str[i] == '.')
98 ++count;
99
100 return count;
101}
102
103/* If we run out of memory, we don't give already allocated memory
104 free. The overhead for bringing getnames back in a safe state to
105 free it is to big. */
106nis_name *
107nis_getnames (const_nis_name name)
108{
109 const char *local_domain = nis_local_directory ();
110 size_t local_domain_len = strlen (local_domain);
111 size_t name_len = strlen (name);
112 char *path;
113 int pos = 0;
114 char *saveptr = NULL;
115 int have_point;
116 const char *cp;
117 const char *cp2;
118
119 int count = 2;
120 nis_name *getnames = malloc ((count + 1) * sizeof (char *));
121 if (__glibc_unlikely (getnames == NULL))
122 return NULL;
123
124 /* Do we have a fully qualified NIS+ name ? If yes, give it back */
125 if (name[name_len - 1] == '.')
126 {
127 if ((getnames[0] = strdup (name)) == NULL)
128 {
129 free_null:
130 while (pos-- > 0)
131 free (getnames[pos]);
132 free (getnames);
133 return NULL;
134 }
135
136 getnames[1] = NULL;
137
138 return getnames;
139 }
140
141 /* If the passed NAME is shared a suffix (the latter of course with
142 a final dot) with each other we pass back NAME with a final
143 dot. */
144 if (local_domain_len > 2)
145 {
146 have_point = 0;
147 cp = &local_domain[local_domain_len - 2];
148 cp2 = &name[name_len - 1];
149
150 while (*cp == *cp2)
151 {
152 if (*cp == '.')
153 have_point = 1;
154 --cp;
155 --cp2;
156 if (cp < local_domain)
157 {
158 have_point = cp2 < name || *cp2 == '.';
159 break;
160 }
161 if (cp2 < name)
162 {
163 have_point = *cp == '.';
164 break;
165 }
166 }
167
168 if (have_point)
169 {
170 getnames[0] = malloc (name_len + 2);
171 if (getnames[0] == NULL)
172 goto free_null;
173
174 strcpy (stpcpy (getnames[0], name), ".");
175 ++pos;
176 }
177 }
178
179 /* Get the search path, where we have to search "name" */
180 path = getenv ("NIS_PATH");
181 if (path == NULL)
182 path = strdupa ("$");
183 else
184 path = strdupa (path);
185
186 have_point = strchr (name, '.') != NULL;
187
188 cp = __strtok_r (path, ":", &saveptr);
189 while (cp)
190 {
191 if (strcmp (cp, "$") == 0)
192 {
193 const char *cptr = local_domain;
194 char *tmp;
195
196 while (*cptr != '\0' && count_dots (cptr) >= 2)
197 {
198 if (pos >= count)
199 {
200 count += 5;
201 nis_name *newp = realloc (getnames,
202 (count + 1) * sizeof (char *));
203 if (__glibc_unlikely (newp == NULL))
204 goto free_null;
205 getnames = newp;
206 }
207 tmp = malloc (strlen (cptr) + local_domain_len + name_len + 2);
208 if (__glibc_unlikely (tmp == NULL))
209 goto free_null;
210
211 getnames[pos] = tmp;
212 tmp = stpcpy (tmp, name);
213 *tmp++ = '.';
214 if (cptr[1] != '\0')
215 stpcpy (tmp, cptr);
216 else
217 ++cptr;
218
219 ++pos;
220
221 while (*cptr != '.' && *cptr != '\0')
222 ++cptr;
223 if (cptr[0] != '\0' && cptr[1] != '\0')
224 /* If we have only ".", don't remove the "." */
225 ++cptr;
226 }
227 }
228 else
229 {
230 char *tmp;
231 size_t cplen = strlen (cp);
232
233 if (cp[cplen - 1] == '$')
234 {
235 char *p;
236
237 tmp = malloc (cplen + local_domain_len + name_len + 2);
238 if (__glibc_unlikely (tmp == NULL))
239 goto free_null;
240
241 p = __stpcpy (tmp, name);
242 *p++ = '.';
243 p = __mempcpy (p, cp, cplen);
244 --p;
245 if (p[-1] != '.')
246 *p++ = '.';
247 __stpcpy (p, local_domain);
248 }
249 else
250 {
251 char *p;
252
253 tmp = malloc (cplen + name_len + 3);
254 if (__glibc_unlikely (tmp == NULL))
255 goto free_null;
256
257 p = __mempcpy (tmp, name, name_len);
258 *p++ = '.';
259 p = __mempcpy (p, cp, cplen);
260 if (p[-1] != '.')
261 *p++ = '.';
262 *p = '\0';
263 }
264
265 if (pos >= count)
266 {
267 count += 5;
268 nis_name *newp = realloc (getnames,
269 (count + 1) * sizeof (char *));
270 if (__glibc_unlikely (newp == NULL))
271 goto free_null;
272 getnames = newp;
273 }
274 getnames[pos] = tmp;
275 ++pos;
276 }
277 cp = __strtok_r (NULL, ":", &saveptr);
278 }
279
280 if (pos == 0
281 && __asprintf (&getnames[pos++], "%s%s%s%s",
282 name, name[name_len - 1] == '.' ? "" : ".",
283 local_domain,
284 local_domain[local_domain_len - 1] == '.' ? "" : ".") < 0)
285 goto free_null;
286
287 getnames[pos] = NULL;
288
289 return getnames;
290}
291libnsl_hidden_def (nis_getnames)
292
293void
294nis_freenames (nis_name *names)
295{
296 int i = 0;
297
298 while (names[i] != NULL)
299 {
300 free (names[i]);
301 ++i;
302 }
303
304 free (names);
305}
306libnsl_hidden_def (nis_freenames)
307
308name_pos
309nis_dir_cmp (const_nis_name n1, const_nis_name n2)
310{
311 int len1, len2;
312
313 len1 = strlen (n1);
314 len2 = strlen (n2);
315
316 if (len1 == len2)
317 {
318 if (strcmp (n1, n2) == 0)
319 return SAME_NAME;
320 else
321 return NOT_SEQUENTIAL;
322 }
323
324 if (len1 < len2)
325 {
326 if (n2[len2 - len1 - 1] != '.')
327 return NOT_SEQUENTIAL;
328 else if (strcmp (&n2[len2 - len1], n1) == 0)
329 return HIGHER_NAME;
330 else
331 return NOT_SEQUENTIAL;
332 }
333 else
334 {
335 if (n1[len1 - len2 - 1] != '.')
336 return NOT_SEQUENTIAL;
337 else if (strcmp (&n1[len1 - len2], n2) == 0)
338 return LOWER_NAME;
339 else
340 return NOT_SEQUENTIAL;
341
342 }
343}
344libnsl_hidden_def (nis_dir_cmp)
345
346void
347nis_destroy_object (nis_object *obj)
348{
349 nis_free_object (obj);
350}
351libnsl_hidden_def (nis_destroy_object)
352