brought the winbindd code into head
[kai/samba.git] / source / nsswitch / winbind_nss.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 2.0
4
5    Windows NT Domain nsswitch module
6
7    Copyright (C) Tim Potter 2000
8    
9    This library is free software; you can redistribute it and/or
10    modify it under the terms of the GNU Library General Public
11    License as published by the Free Software Foundation; either
12    version 2 of the License, or (at your option) any later version.
13    
14    This library is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17    Library General Public License for more details.
18    
19    You should have received a copy of the GNU Library General Public
20    License along with this library; if not, write to the
21    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22    Boston, MA  02111-1307, USA.   
23 */
24
25 #include "ntdom_config.h"
26 #include "winbindd_ntdom.h"
27
28 /* prototypes from common.c */
29 void init_request(struct winbindd_request *req,int rq_type);
30 int write_sock(void *buffer, int count);
31 int read_reply(struct winbindd_response *response);
32
33
34 /* Allocate some space from the nss static buffer.  The buffer and buflen
35    are the pointers passed in by the C library to the _nss_ntdom_*
36    functions. */
37
38 static char *get_static(char **buffer, int *buflen, int len)
39 {
40     char *result;
41
42     /* Error check.  We return false if things aren't set up right, or
43        there isn't enough buffer space left. */
44
45     if ((buffer == NULL) || (buflen == NULL) || (*buflen < len)) {
46         return NULL;
47     }
48
49     /* Return an index into the static buffer */
50
51     result = *buffer;
52     *buffer += len;
53     *buflen -= len;
54
55     return result;
56 }
57
58 /* I've copied the strtok() replacement function next_token() from
59    lib/util_str.c as I really don't want to have to link in any other
60    objects if I can possibly avoid it. */
61
62 #ifdef strchr /* Aargh! This points at multibyte_strchr(). )-: */
63 #undef strchr
64 #endif
65
66 static char *last_ptr = NULL;
67
68 BOOL next_token(char **ptr, char *buff, char *sep, size_t bufsize)
69 {
70     char *s;
71     BOOL quoted;
72     size_t len=1;
73     
74     if (!ptr) ptr = &last_ptr;
75     if (!ptr) return(False);
76     
77     s = *ptr;
78     
79     /* default to simple separators */
80     if (!sep) sep = " \t\n\r";
81     
82     /* find the first non sep char */
83     while(*s && strchr(sep,*s)) s++;
84     
85     /* nothing left? */
86     if (! *s) return(False);
87     
88     /* copy over the token */
89     for (quoted = False; 
90          len < bufsize && *s && (quoted || !strchr(sep,*s)); 
91          s++) {
92
93         if (*s == '\"') {
94             quoted = !quoted;
95         } else {
96             len++;
97             *buff++ = *s;
98         }
99     }
100     
101     *ptr = (*s) ? s+1 : s;  
102     *buff = 0;
103     last_ptr = *ptr;
104   
105     return(True);
106 }
107
108
109 /* handle simple types of requests */
110 static enum nss_status generic_request(int req_type, 
111                                        struct winbindd_request *request,
112                                        struct winbindd_response *response)
113 {
114         struct winbindd_request lrequest;
115         struct winbindd_response lresponse;
116
117         if (!response) response = &lresponse;
118         if (!request) request = &lrequest;
119         
120         /* Fill in request and send down pipe */
121         init_request(request, req_type);
122         
123         if (write_sock(request, sizeof(*request)) == -1) {
124                 return NSS_STATUS_UNAVAIL;
125         }
126         
127         /* Wait for reply */
128         if (read_reply(response) == -1) {
129                 return NSS_STATUS_UNAVAIL;
130         }
131
132         /* Copy reply data from socket */
133         if (response->result != WINBINDD_OK) {
134                 return NSS_STATUS_NOTFOUND;
135         }
136         
137         return NSS_STATUS_SUCCESS;
138 }
139
140 /* Fill a pwent structure from a winbindd_response structure.  We use
141    the static data passed to us by libc to put strings and stuff in.
142    Return errno = ERANGE and NSS_STATUS_TRYAGAIN if we run out of
143    memory. */
144
145 static enum nss_status fill_pwent(struct passwd *result,
146                                   struct winbindd_response *response,
147                                   char **buffer, int *buflen, int *errnop)
148 {
149     struct winbindd_pw *pw = &response->data.pw;
150
151     /* User name */
152
153     if ((result->pw_name = 
154          get_static(buffer, buflen, strlen(pw->pw_name) + 1)) == NULL) {
155
156         /* Out of memory */
157
158         *errnop = ERANGE;
159         return NSS_STATUS_TRYAGAIN;
160     }
161
162     strcpy(result->pw_name, pw->pw_name);
163
164     /* Password */
165
166     if ((result->pw_passwd = 
167          get_static(buffer, buflen, strlen(pw->pw_passwd) + 1)) == NULL) {
168
169         /* Out of memory */
170
171         *errnop = ERANGE;
172         return NSS_STATUS_TRYAGAIN;
173     }
174
175     strcpy(result->pw_passwd, pw->pw_passwd);
176         
177     /* [ug]id */
178
179     result->pw_uid = pw->pw_uid;
180     result->pw_gid = pw->pw_gid;
181
182     /* GECOS */
183
184     if ((result->pw_gecos = 
185          get_static(buffer, buflen, strlen(pw->pw_gecos) + 1)) == NULL) {
186
187         /* Out of memory */
188
189         *errnop = ERANGE;
190         return NSS_STATUS_TRYAGAIN;
191     }
192
193     strcpy(result->pw_gecos, pw->pw_gecos);
194
195     /* Home directory */
196
197     if ((result->pw_dir = 
198          get_static(buffer, buflen, strlen(pw->pw_dir) + 1)) == NULL) {
199
200         /* Out of memory */
201
202         *errnop = ERANGE;
203         return NSS_STATUS_TRYAGAIN;
204     }
205
206     strcpy(result->pw_dir, pw->pw_dir);
207
208     /* Logon shell */
209
210     if ((result->pw_shell = 
211          get_static(buffer, buflen, strlen(pw->pw_shell) + 1)) == NULL) {
212
213         /* Out of memory */
214
215         *errnop = ERANGE;
216         return NSS_STATUS_TRYAGAIN;
217     }
218
219     strcpy(result->pw_shell, pw->pw_shell);
220
221     return NSS_STATUS_SUCCESS;
222 }
223
224 /* Fill a grent structure from a winbindd_response structure.  We use
225    the static data passed to us by libc to put strings and stuff in.
226    Return errno = ERANGE and NSS_STATUS_TRYAGAIN if we run out of
227    memory. */
228
229 static int fill_grent(struct group *result, 
230                       struct winbindd_response *response,
231                       char **buffer, int *buflen, int *errnop)
232 {
233     struct winbindd_gr *gr = &response->data.gr;
234     fstring name;
235     int i;
236
237     /* Group name */
238
239     if ((result->gr_name =
240          get_static(buffer, buflen, strlen(gr->gr_name) + 1)) == NULL) {
241
242         /* Out of memory */
243
244         *errnop = ERANGE;
245         return NSS_STATUS_TRYAGAIN;
246     }
247
248     strcpy(result->gr_name, gr->gr_name);
249
250     /* Password */
251
252     if ((result->gr_passwd =
253          get_static(buffer, buflen, strlen(gr->gr_passwd) + 1)) == NULL) {
254
255         /* Out of memory */
256
257         *errnop = ERANGE;
258         return NSS_STATUS_TRYAGAIN;
259     }
260
261     strcpy(result->gr_passwd, gr->gr_passwd);
262
263     /* gid */
264
265     result->gr_gid = gr->gr_gid;
266
267     /* Group membership */
268
269     if ((gr->num_gr_mem < 0) || !response->extra_data) {
270         gr->num_gr_mem = 0;
271     }
272
273     if ((result->gr_mem = 
274          (char **)get_static(buffer, buflen, (gr->num_gr_mem + 1) * 
275                              sizeof(char *))) == NULL) {
276
277         /* Out of memory */
278
279         *errnop = ERANGE;
280         return NSS_STATUS_TRYAGAIN;
281     }
282
283     if (gr->num_gr_mem == 0) {
284
285         /* Group is empty */
286
287         *(result->gr_mem) = NULL;
288         return NSS_STATUS_SUCCESS;
289     }
290
291     /* Start looking at extra data */
292
293     i = 0;
294
295     while(next_token(&response->extra_data, name, ",", sizeof(fstring))) {
296         
297         /* Allocate space for member */
298         
299         if (((result->gr_mem)[i] = 
300              get_static(buffer, buflen, strlen(name) + 1)) == NULL) {
301             
302             /* Out of memory */
303             
304             *errnop = ERANGE;
305             return NSS_STATUS_TRYAGAIN;
306         }        
307         
308         strcpy((result->gr_mem)[i], name);
309         i++;
310     }
311
312     /* Terminate list */
313
314     (result->gr_mem)[i] = NULL;
315     
316     return NSS_STATUS_SUCCESS;
317 }
318
319 /*
320  * NSS user functions
321  */
322
323 /* Rewind "file pointer" to start of ntdom password database */
324
325 enum nss_status
326 _nss_ntdom_setpwent(void)
327 {
328         return generic_request(WINBINDD_SETPWENT, NULL, NULL);
329 }
330
331 /* Close ntdom password database "file pointer" */
332
333 enum nss_status
334 _nss_ntdom_endpwent(void)
335 {
336         return generic_request(WINBINDD_ENDPWENT, NULL, NULL);
337 }
338
339 /* Fetch the next password entry from ntdom password database */
340
341 enum nss_status
342 _nss_ntdom_getpwent_r(struct passwd *result, char *buffer, 
343                       size_t buflen, int *errnop)
344 {
345         enum nss_status ret;
346         struct winbindd_response response;
347
348         ret = generic_request(WINBINDD_GETPWENT, NULL, &response);
349         if (ret != NSS_STATUS_SUCCESS) return ret;
350
351         return fill_pwent(result, &response, &buffer, &buflen, errnop);
352 }
353
354 /* Return passwd struct from uid */
355
356 enum nss_status
357 _nss_ntdom_getpwuid_r(uid_t uid, struct passwd *result, char *buffer,
358                       size_t buflen, int *errnop)
359 {
360         enum nss_status ret;
361         struct winbindd_response response;
362         struct winbindd_request request;
363
364         request.data.uid = uid;
365
366         ret = generic_request(WINBINDD_GETPWNAM_FROM_UID, &request, &response);
367         if (ret != NSS_STATUS_SUCCESS) return ret;
368
369         return fill_pwent(result, &response, &buffer, &buflen, errnop);
370 }
371
372 /* Return passwd struct from username */
373
374 enum nss_status
375 _nss_ntdom_getpwnam_r(const char *name, struct passwd *result, char *buffer,
376                       size_t buflen, int *errnop)
377 {
378         enum nss_status ret;
379         struct winbindd_response response;
380         struct winbindd_request request;
381
382         strncpy(request.data.username, name, sizeof(request.data.username) - 1);
383         request.data.username[sizeof(request.data.username) - 1] = '\0';
384
385         ret = generic_request(WINBINDD_GETPWNAM_FROM_USER, &request, &response);
386         if (ret != NSS_STATUS_SUCCESS) return ret;
387
388         return fill_pwent(result, &response, &buffer, &buflen, errnop);
389 }
390
391 /*
392  * NSS group functions
393  */
394
395 /* Rewind "file pointer" to start of ntdom group database */
396
397 enum nss_status
398 _nss_ntdom_setgrent(void)
399 {
400         return generic_request(WINBINDD_SETGRENT, NULL, NULL);
401 }
402
403 /* Close "file pointer" for ntdom group database */
404
405 enum nss_status
406 _nss_ntdom_endgrent(void)
407 {
408         return generic_request(WINBINDD_ENDGRENT, NULL, NULL);
409 }
410
411
412
413 /* Get next entry from ntdom group database */
414
415 enum nss_status
416 _nss_ntdom_getgrent_r(struct group *result,
417                       char *buffer, size_t buflen, int *errnop)
418 {
419         enum nss_status ret;
420         struct winbindd_response response;
421
422         ret = generic_request(WINBINDD_GETGRENT, NULL, &response);
423         if (ret != NSS_STATUS_SUCCESS) return ret;
424
425         return fill_grent(result, &response, &buffer, &buflen, errnop);
426 }
427
428 /* Return group struct from group name */
429
430 enum nss_status
431 _nss_ntdom_getgrnam_r(const char *name,
432                       struct group *result, char *buffer,
433                       size_t buflen, int *errnop)
434 {
435         enum nss_status ret;
436         struct winbindd_response response;
437         struct winbindd_request request;
438
439         strncpy(request.data.groupname, name, sizeof(request.data.groupname));
440         request.data.groupname[sizeof(request.data.groupname) - 1] = '\0';
441
442         ret = generic_request(WINBINDD_GETGRNAM_FROM_GROUP, &request, &response);
443         if (ret != NSS_STATUS_SUCCESS) return ret;
444
445         return fill_grent(result, &response, &buffer, &buflen, errnop);
446 }
447
448 /* Return group struct from gid */
449
450 enum nss_status
451 _nss_ntdom_getgrgid_r(gid_t gid,
452                       struct group *result, char *buffer,
453                       size_t buflen, int *errnop)
454 {
455         enum nss_status ret;
456         struct winbindd_response response;
457         struct winbindd_request request;
458
459         request.data.gid = gid;
460
461         ret = generic_request(WINBINDD_GETGRNAM_FROM_GID, &request, &response);
462         if (ret != NSS_STATUS_SUCCESS) return ret;
463
464         return fill_grent(result, &response, &buffer, &buflen, errnop);
465 }