* hesiod/nss_hesiod/hesiod-proto.c (_nss_hesiod_setprotoent): Fix
[kopensolaris-gnu/glibc.git] / nis / nss_nis / nis-spwd.c
1 /* Copyright (C) 1996, 1997, 1998 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 <bits/libc-lock.h>
26 #include <rpcsvc/yp.h>
27 #include <rpcsvc/ypclnt.h>
28
29 #include "nss-nis.h"
30
31 /* Get the declaration of the parser function.  */
32 #define ENTNAME spent
33 #define STRUCTURE spwd
34 #define EXTERN_PARSER
35 #include <nss/nss_files/files-parse.c>
36
37 /* Protect global state against multiple changers */
38 __libc_lock_define_initialized (static, lock)
39
40 static bool_t new_start = 1;
41 static char *oldkey = NULL;
42 static int oldkeylen = 0;
43
44 enum nss_status
45 _nss_nis_setspent (int stayopen)
46 {
47   __libc_lock_lock (lock);
48
49   new_start = 1;
50   if (oldkey != NULL)
51     {
52       free (oldkey);
53       oldkey = NULL;
54       oldkeylen = 0;
55     }
56
57   __libc_lock_unlock (lock);
58
59   return NSS_STATUS_SUCCESS;
60 }
61
62 enum nss_status
63 _nss_nis_endspent (void)
64 {
65   __libc_lock_lock (lock);
66
67   new_start = 1;
68   if (oldkey != NULL)
69     {
70       free (oldkey);
71       oldkey = NULL;
72       oldkeylen = 0;
73     }
74
75   __libc_lock_unlock (lock);
76
77   return NSS_STATUS_SUCCESS;
78 }
79
80 static enum nss_status
81 internal_nis_getspent_r (struct spwd *sp, char *buffer, size_t buflen,
82                          int *errnop)
83 {
84   struct parser_data *data = (void *) buffer;
85   char *domain, *result, *outkey;
86   int len, keylen, parse_res;
87
88   if (yp_get_default_domain (&domain))
89     return NSS_STATUS_UNAVAIL;
90
91   /* Get the next entry until we found a correct one. */
92   do
93     {
94       enum nss_status retval;
95       char *p;
96
97       if (new_start)
98         retval = yperr2nss (yp_first (domain, "shadow.byname",
99                                       &outkey, &keylen, &result, &len));
100       else
101         retval = yperr2nss ( yp_next (domain, "shadow.byname",
102                                       oldkey, oldkeylen,
103                                       &outkey, &keylen, &result, &len));
104
105       if (retval != NSS_STATUS_SUCCESS)
106         {
107           if (retval == NSS_STATUS_NOTFOUND)
108             *errnop = ENOENT;
109           else if (retval == NSS_STATUS_TRYAGAIN)
110             *errnop = errno;
111           return retval;
112         }
113
114       if ((size_t) (len + 1) > buflen)
115         {
116           free (result);
117           *errnop = ERANGE;
118           return NSS_STATUS_TRYAGAIN;
119         }
120
121       p = strncpy (buffer, result, len);
122       buffer[len] = '\0';
123       while (isspace (*p))
124         ++p;
125       free (result);
126
127       parse_res = _nss_files_parse_spent (p, sp, data, buflen, errnop);
128       if (parse_res == -1)
129         {
130           free (outkey);
131           *errnop = ERANGE;
132           return NSS_STATUS_TRYAGAIN;
133         }
134
135       free (oldkey);
136       oldkey = outkey;
137       oldkeylen = keylen;
138       new_start = 0;
139     }
140   while (!parse_res);
141
142   return NSS_STATUS_SUCCESS;
143 }
144
145 enum nss_status
146 _nss_nis_getspent_r (struct spwd *result, char *buffer, size_t buflen,
147                      int *errnop)
148 {
149   int status;
150
151   __libc_lock_lock (lock);
152
153   status = internal_nis_getspent_r (result, buffer, buflen, errnop);
154
155   __libc_lock_unlock (lock);
156
157   return status;
158 }
159
160 enum nss_status
161 _nss_nis_getspnam_r (const char *name, struct spwd *sp,
162                      char *buffer, size_t buflen, int *errnop)
163 {
164   struct parser_data *data = (void *) buffer;
165   enum nss_status retval;
166   char *domain, *result, *p;
167   int len, parse_res;
168
169   if (name == NULL)
170     {
171       *errnop = EINVAL;
172       return NSS_STATUS_UNAVAIL;
173     }
174
175   if (yp_get_default_domain (&domain))
176     return NSS_STATUS_UNAVAIL;
177
178   retval = yperr2nss (yp_match (domain, "shadow.byname", name,
179                                 strlen (name), &result, &len));
180
181   if (retval != NSS_STATUS_SUCCESS)
182     {
183       if (retval == NSS_STATUS_NOTFOUND)
184         *errnop = ENOENT;
185       else if (retval == NSS_STATUS_TRYAGAIN)
186         *errnop = errno;
187       return retval;
188     }
189
190   if ((size_t) (len + 1) > buflen)
191     {
192       free (result);
193       *errnop = ERANGE;
194       return NSS_STATUS_TRYAGAIN;
195     }
196
197   p = strncpy (buffer, result, len);
198   buffer[len] = '\0';
199   while (isspace (*p))
200     ++p;
201   free (result);
202
203   parse_res = _nss_files_parse_spent (p, sp, data, buflen, errnop);
204   if (parse_res < 1)
205     {
206       if (parse_res == -1)
207         return NSS_STATUS_TRYAGAIN;
208       else
209         {
210           *errnop = ENOENT;
211           return NSS_STATUS_NOTFOUND;
212         }
213     }
214   return NSS_STATUS_SUCCESS;
215 }