update from main arcive 961210
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-spwd.c
1 /* Copyright (C) 1996 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1996.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    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    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20 #include <nss.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <string.h>
24 #include <shadow.h>
25 #include <libc-lock.h>
26 #include <rpcsvc/yp.h>
27 #include <rpcsvc/ypclnt.h>
28
29 #include "nss-nis.h"
30
31 /* Protect global state against multiple changers */
32 __libc_lock_define_initialized (static, lock)
33
34 static bool_t new_start = 1;
35 static char *oldkey = NULL;
36 static int oldkeylen = 0;
37
38 enum nss_status
39 _nss_nis_setspent (void)
40 {
41   __libc_lock_lock (lock);
42
43   new_start = 1;
44   if (oldkey != NULL)
45     {
46       free (oldkey);
47       oldkey = NULL;
48       oldkeylen = 0;
49     }
50
51   __libc_lock_unlock (lock);
52
53   return NSS_STATUS_SUCCESS;
54 }
55
56 enum nss_status
57 _nss_nis_endspent (void)
58 {
59   __libc_lock_lock (lock);
60
61   new_start = 1;
62   if (oldkey != NULL)
63     {
64       free (oldkey);
65       oldkey = NULL;
66       oldkeylen = 0;
67     }
68
69   __libc_lock_unlock (lock);
70
71   return NSS_STATUS_SUCCESS;
72 }
73
74 static enum nss_status
75 internal_nis_getspent_r (struct spwd *sp, char *buffer, size_t buflen)
76 {
77   char *domain, *result, *outkey;
78   int len, keylen, parse_res;
79
80   if (yp_get_default_domain (&domain))
81     return NSS_STATUS_UNAVAIL;
82
83   /* Get the next entry until we found a correct one. */
84   do
85     {
86       enum nss_status retval;
87       char *p;
88
89       if (new_start)
90         retval = yperr2nss (yp_first (domain, "shadow.byname",
91                                       &outkey, &keylen, &result, &len));
92       else
93         retval = yperr2nss ( yp_next (domain, "shadow.byname",
94                                       oldkey, oldkeylen,
95                                       &outkey, &keylen, &result, &len));
96
97       if (retval != NSS_STATUS_SUCCESS)
98         {
99           if (retval == NSS_STATUS_TRYAGAIN)
100             __set_errno (EAGAIN);
101           return retval;
102         }
103
104       if (len + 1 > buflen)
105         {
106           free (result);
107           __set_errno (ERANGE);
108           return NSS_STATUS_TRYAGAIN;
109         }
110
111       p = strncpy (buffer, result, len);
112       buffer[len] = '\0';
113       while (isspace (*p))
114         ++p;
115       free (result);
116
117       parse_res = _nss_files_parse_spent (p, sp, buffer, buflen);
118       if (!parse_res && errno == ERANGE)
119         return NSS_STATUS_TRYAGAIN;
120
121       free (oldkey);
122       oldkey = outkey;
123       oldkeylen = keylen;
124       new_start = 0;
125     }
126   while (!parse_res);
127
128   return NSS_STATUS_SUCCESS;
129 }
130
131 enum nss_status
132 _nss_nis_getspent_r (struct spwd *result, char *buffer, size_t buflen)
133 {
134   int status;
135
136   __libc_lock_lock (lock);
137
138   status = internal_nis_getspent_r (result, buffer, buflen);
139
140   __libc_lock_unlock (lock);
141
142   return status;
143 }
144
145 enum nss_status
146 _nss_nis_getspnam_r (const char *name, struct spwd *sp,
147                      char *buffer, size_t buflen)
148 {
149   enum nss_status retval;
150   char *domain, *result, *p;
151   int len, parse_res;
152
153   if (name == NULL)
154     {
155       __set_errno (EINVAL);
156       return NSS_STATUS_UNAVAIL;
157     }
158
159   if (yp_get_default_domain (&domain))
160     return NSS_STATUS_UNAVAIL;
161
162   retval = yperr2nss (yp_match (domain, "shadow.byname", name,
163                                 strlen (name), &result, &len));
164
165   if (retval != NSS_STATUS_SUCCESS)
166     {
167       if (retval == NSS_STATUS_TRYAGAIN)
168         __set_errno (EAGAIN);
169       return retval;
170     }
171
172   if (len + 1 > buflen)
173     {
174       free (result);
175       __set_errno (ERANGE);
176       return NSS_STATUS_TRYAGAIN;
177     }
178
179   p = strncpy (buffer, result, len);
180   buffer[len] = '\0';
181   while (isspace (*p))
182     ++p;
183   free (result);
184
185   parse_res = _nss_files_parse_spent (p, sp, buffer, buflen);
186
187   if (!parse_res)
188     {
189       if (errno == ERANGE)
190         return NSS_STATUS_TRYAGAIN;
191       else
192         return NSS_STATUS_NOTFOUND;
193     }
194   else
195     return NSS_STATUS_SUCCESS;
196 }