Add libnsl_hidden_def. Minor optimizations.
[kopensolaris-gnu/glibc.git] / nis / nis_subr.c
1 /* Copyright (c) 1997, 1999, 2000, 2004 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, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #include <errno.h>
21 #include <string.h>
22 #include <rpcsvc/nis.h>
23
24 nis_name
25 nis_leaf_of (const_nis_name name)
26 {
27   static char result[NIS_MAXNAMELEN + 1];
28
29   return nis_leaf_of_r (name, result, NIS_MAXNAMELEN);
30 }
31
32 nis_name
33 nis_leaf_of_r (const_nis_name name, char *buffer, size_t buflen)
34 {
35   size_t i = 0;
36
37   buffer[0] = '\0';
38
39   while (name[i] != '.' && name[i] != '\0')
40     i++;
41
42   if (i > buflen - 1)
43     {
44       __set_errno (ERANGE);
45       return NULL;
46     }
47
48   if (i > 0)
49     {
50       if ((size_t)i >= buflen)
51         {
52           __set_errno (ERANGE);
53           return NULL;
54         }
55
56       *((char *) __mempcpy (buffer, name, i)) = '\0';
57     }
58
59   return buffer;
60 }
61 libnsl_hidden_def (nis_leaf_of_r)
62
63 nis_name
64 nis_name_of (const_nis_name name)
65 {
66   static char result[NIS_MAXNAMELEN + 1];
67
68   return nis_name_of_r (name, result, NIS_MAXNAMELEN);
69 }
70
71 nis_name
72 nis_name_of_r (const_nis_name name, char *buffer, size_t buflen)
73 {
74   char *local_domain;
75   int diff;
76
77   local_domain = nis_local_directory ();
78
79   diff = strlen (name) - strlen (local_domain);
80   if (diff <= 0)
81     return NULL;
82
83   if (strcmp (&name[diff], local_domain) != 0)
84     return NULL;
85
86   if ((size_t) diff >= buflen)
87     {
88       __set_errno (ERANGE);
89       return NULL;
90     }
91
92   *((char *) __mempcpy (buffer, name, diff - 1)) = '\0';
93
94   if (diff - 1 == 0)
95     return NULL;
96
97   return buffer;
98 }
99 libnsl_hidden_def (nis_name_of_r)
100
101 static int
102 count_dots (const_nis_name str)
103 {
104   int count = 0;
105   size_t l = strlen (str);
106
107   for (size_t i = 0; i < l; ++i)
108     if (str[i] == '.')
109       ++count;
110
111   return count;
112 }
113
114 /* If we run out of memory, we don't give already allocated memory
115    free. The overhead for bringing getnames back in a safe state to
116    free it is to big. */
117 nis_name *
118 nis_getnames (const_nis_name name)
119 {
120   nis_name *getnames = NULL;
121   char local_domain[NIS_MAXNAMELEN + 1];
122   char *path;
123   char *cp;
124   int count;
125   int pos = 0;
126   int have_point;
127   char *saveptr;
128
129   strncpy (local_domain, nis_local_directory (), NIS_MAXNAMELEN);
130   local_domain[NIS_MAXNAMELEN] = '\0';
131
132   count = 1;
133   getnames = malloc ((count + 1) * sizeof (char *));
134   if (__builtin_expect (getnames == NULL, 0))
135       return NULL;
136
137   /* Do we have a fully qualified NIS+ name ? If yes, give it back */
138   if (name[strlen (name) - 1] == '.')
139     {
140       if ((getnames[0] = strdup (name)) == NULL)
141         {
142         free_null:
143           while (pos-- > 0)
144             free (getnames[pos]);
145           free (getnames);
146           return NULL;
147         }
148
149       getnames[1] = NULL;
150
151       return getnames;
152     }
153
154   /* Get the search path, where we have to search "name" */
155   path = getenv ("NIS_PATH");
156   if (path == NULL)
157     path = strdupa ("$");
158   else
159     path = strdupa (path);
160
161   have_point = (strchr (name, '.') != NULL);
162
163   cp = __strtok_r (path, ":", &saveptr);
164   while (cp)
165     {
166       if (strcmp (cp, "$") == 0)
167         {
168           char *cptr = local_domain;
169           char *tmp;
170
171           while ((have_point && *cptr != '\0') || (count_dots (cptr) >= 2))
172             {
173               if (pos >= count)
174                 {
175                   count += 5;
176                   nis_name *newp = realloc (getnames,
177                                             (count + 1) * sizeof (char *));
178                   if (__builtin_expect (newp == NULL, 0))
179                     goto free_null;
180                   getnames = newp;
181                 }
182               tmp = malloc (strlen (cptr) + strlen (local_domain) +
183                             strlen (name) + 2);
184               if (__builtin_expect (tmp == NULL, 0))
185                 goto free_null;
186
187               getnames[pos] = tmp;
188               tmp = stpcpy (tmp, name);
189               *tmp++ = '.';
190               if (cptr[1] != '\0')
191                 stpcpy (tmp, cptr);
192               else
193                 ++cptr;
194
195               ++pos;
196
197               while (*cptr != '.' && *cptr != '\0')
198                 ++cptr;
199               if (cptr[0] != '\0' && cptr[1] != '\0')
200                 /* If we have only ".", don't remove the "." */
201                 ++cptr;
202             }
203         }
204       else
205         {
206           char *tmp;
207           size_t cplen = strlen (cp);
208
209           if (cp[cplen - 1] == '$')
210             {
211               char *p;
212
213               tmp = malloc (cplen + strlen (local_domain) + strlen (name) + 2);
214               if (__builtin_expect (tmp == NULL, 0))
215                 goto free_null;
216
217               p = __stpcpy (tmp, name);
218               *p++ = '.';
219               p = __mempcpy (p, cp, cplen);
220               --p;
221               if (p[-1] != '.')
222                 *p++ = '.';
223               __stpcpy (p, local_domain);
224             }
225           else
226             {
227               char *p;
228
229               tmp = malloc (cplen + strlen (name) + 2);
230               if (__builtin_expect (tmp == NULL, 0))
231                 goto free_null;
232
233               p = __stpcpy (tmp, name);
234               *p++ = '.';
235               memcpy (p, cp, cplen + 1);
236             }
237
238           if (pos >= count)
239             {
240               count += 5;
241               nis_name *newp = realloc (getnames,
242                                         (count + 1) * sizeof (char *));
243               if (__builtin_expect (newp == NULL, 0))
244                 goto free_null;
245               getnames = newp;
246             }
247           getnames[pos] = tmp;
248           ++pos;
249         }
250       cp = __strtok_r (NULL, ":", &saveptr);
251     }
252
253   getnames[pos] = NULL;
254
255   return getnames;
256 }
257 libnsl_hidden_def (nis_getnames)
258
259 void
260 nis_freenames (nis_name *names)
261 {
262   int i = 0;
263
264   while (names[i] != NULL)
265     {
266       free (names[i]);
267       ++i;
268     }
269
270   free (names);
271 }
272 libnsl_hidden_def  (nis_freenames)
273
274 name_pos
275 nis_dir_cmp (const_nis_name n1, const_nis_name n2)
276 {
277   int len1, len2;
278
279   len1 = strlen (n1);
280   len2 = strlen (n2);
281
282   if (len1 == len2)
283     {
284       if (strcmp (n1, n2) == 0)
285         return SAME_NAME;
286       else
287         return NOT_SEQUENTIAL;
288     }
289
290   if (len1 < len2)
291     {
292       if (n2[len2 - len1 - 1] != '.')
293         return NOT_SEQUENTIAL;
294       else if (strcmp (&n2[len2 - len1], n1) == 0)
295         return HIGHER_NAME;
296       else
297         return NOT_SEQUENTIAL;
298     }
299   else
300     {
301       if (n1[len1 - len2 - 1] != '.')
302         return NOT_SEQUENTIAL;
303       else if (strcmp (&n1[len1 - len2], n2) == 0)
304         return LOWER_NAME;
305       else
306         return NOT_SEQUENTIAL;
307
308     }
309 }
310 libnsl_hidden_def (nis_dir_cmp)
311
312 void
313 nis_destroy_object (nis_object *obj)
314 {
315   nis_free_object (obj);
316 }
317 libnsl_hidden_def (nis_destroy_object)