nsswitch: Move source3 files to top level dir.
[garming/samba-autobuild/.git] / nsswitch / winbind_nss_solaris.c
1 /*
2   Solaris NSS wrapper for winbind
3   - Shirish Kalele 2000
4
5   Based on Luke Howard's ldap_nss module for Solaris
6   */
7
8 /*
9   Copyright (C) 1997-2003 Luke Howard.
10   This file is part of the nss_ldap library.
11
12   The nss_ldap library is free software; you can redistribute it and/or
13   modify it under the terms of the GNU Lesser General Public License as
14   published by the Free Software Foundation; either version 3 of the
15   License, or (at your option) any later version.
16
17   The nss_ldap library is distributed in the hope that it will be useful,
18   but WITHOUT ANY WARRANTY; without even the implied warranty of
19   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20   Library General Public License for more details.
21
22   You should have received a copy of the GNU Lesser General Public
23   License along with the nss_ldap library; see the file COPYING.LIB.  If not,
24   see <http://www.gnu.org/licenses/>.
25 */
26
27 #undef DEVELOPER
28
29 #include "winbind_client.h"
30 #include <stdlib.h>
31 #include <sys/types.h>
32 #include <sys/param.h>
33 #include <string.h>
34 #include <pwd.h>
35 #include "includes.h"
36 #include <syslog.h>
37 #if !defined(HPUX)
38 #include <sys/syslog.h>
39 #endif /*hpux*/
40
41 #if defined(HAVE_NSS_COMMON_H) || defined(HPUX)
42
43 #undef NSS_DEBUG
44
45 #ifdef NSS_DEBUG
46 #define NSS_DEBUG(str) syslog(LOG_DEBUG, "nss_winbind: %s", str);
47 #else
48 #define NSS_DEBUG(str) ;
49 #endif
50
51 #define NSS_ARGS(args) ((nss_XbyY_args_t *)args)
52
53 #ifdef HPUX
54
55 /*
56  * HP-UX 11 has no definiton of the nss_groupsbymem structure.   This
57  * definition is taken from the nss_ldap project at:
58  *  http://www.padl.com/OSS/nss_ldap.html
59  */
60
61 struct nss_groupsbymem {
62        const char *username;
63        gid_t *gid_array;
64        int maxgids;
65        int force_slow_way;
66        int (*str2ent)(const char *instr, int instr_len, void *ent,
67                       char *buffer, int buflen);
68        nss_status_t (*process_cstr)(const char *instr, int instr_len,
69                                     struct nss_groupsbymem *);
70        int numgids;
71 };
72
73 #endif /* HPUX */
74
75 #define make_pwent_str(dest, src)                                       \
76 {                                                                       \
77   if((dest = get_static(buffer, buflen, strlen(src)+1)) == NULL)        \
78     {                                                                   \
79       *errnop = ERANGE;                                                 \
80       NSS_DEBUG("ERANGE error");                                        \
81       return NSS_STATUS_TRYAGAIN;                                       \
82     }                                                                   \
83   strcpy(dest, src);                                                    \
84 }
85
86 static NSS_STATUS _nss_winbind_setpwent_solwrap (nss_backend_t* be, void* args)
87 {
88         NSS_DEBUG("_nss_winbind_setpwent_solwrap");
89         return _nss_winbind_setpwent();
90 }
91
92 static NSS_STATUS
93 _nss_winbind_endpwent_solwrap (nss_backend_t * be, void *args)
94 {
95         NSS_DEBUG("_nss_winbind_endpwent_solwrap");
96         return _nss_winbind_endpwent();
97 }
98
99 static NSS_STATUS
100 _nss_winbind_getpwent_solwrap (nss_backend_t* be, void *args)
101 {
102         NSS_STATUS ret;
103         char* buffer = NSS_ARGS(args)->buf.buffer;
104         int buflen = NSS_ARGS(args)->buf.buflen;
105         struct passwd* result = (struct passwd*) NSS_ARGS(args)->buf.result;
106         int* errnop = &NSS_ARGS(args)->erange;
107         char logmsg[80];
108
109         ret = _nss_winbind_getpwent_r(result, buffer,
110                                       buflen, errnop);
111
112         if(ret == NSS_STATUS_SUCCESS)
113                 {
114                         snprintf(logmsg, 79, "_nss_winbind_getpwent_solwrap: Returning user: %s\n",
115                                  result->pw_name);
116                         NSS_DEBUG(logmsg);
117                         NSS_ARGS(args)->returnval = (void*) result;
118                 } else {
119                         snprintf(logmsg, 79, "_nss_winbind_getpwent_solwrap: Returning error: %d.\n",ret);
120                         NSS_DEBUG(logmsg);
121                 }
122
123         return ret;
124 }
125
126 static NSS_STATUS
127 _nss_winbind_getpwnam_solwrap (nss_backend_t* be, void* args)
128 {
129         NSS_STATUS ret;
130         struct passwd* result = (struct passwd*) NSS_ARGS(args)->buf.result;
131
132         NSS_DEBUG("_nss_winbind_getpwnam_solwrap");
133
134         ret = _nss_winbind_getpwnam_r (NSS_ARGS(args)->key.name,
135                                                 result,
136                                                 NSS_ARGS(args)->buf.buffer,
137                                                 NSS_ARGS(args)->buf.buflen,
138                                                 &NSS_ARGS(args)->erange);
139         if(ret == NSS_STATUS_SUCCESS)
140                 NSS_ARGS(args)->returnval = (void*) result;
141
142         return ret;
143 }
144
145 static NSS_STATUS
146 _nss_winbind_getpwuid_solwrap(nss_backend_t* be, void* args)
147 {
148         NSS_STATUS ret;
149         struct passwd* result = (struct passwd*) NSS_ARGS(args)->buf.result;
150
151         NSS_DEBUG("_nss_winbind_getpwuid_solwrap");
152         ret = _nss_winbind_getpwuid_r (NSS_ARGS(args)->key.uid,
153                                        result,
154                                        NSS_ARGS(args)->buf.buffer,
155                                        NSS_ARGS(args)->buf.buflen,
156                                        &NSS_ARGS(args)->erange);
157         if(ret == NSS_STATUS_SUCCESS)
158                 NSS_ARGS(args)->returnval = (void*) result;
159
160         return ret;
161 }
162
163 static NSS_STATUS _nss_winbind_passwd_destr (nss_backend_t * be, void *args)
164 {
165         SAFE_FREE(be);
166         NSS_DEBUG("_nss_winbind_passwd_destr");
167         return NSS_STATUS_SUCCESS;
168 }
169
170 static nss_backend_op_t passwd_ops[] =
171 {
172         _nss_winbind_passwd_destr,
173         _nss_winbind_endpwent_solwrap,          /* NSS_DBOP_ENDENT */
174         _nss_winbind_setpwent_solwrap,          /* NSS_DBOP_SETENT */
175         _nss_winbind_getpwent_solwrap,          /* NSS_DBOP_GETENT */
176         _nss_winbind_getpwnam_solwrap,          /* NSS_DBOP_PASSWD_BYNAME */
177         _nss_winbind_getpwuid_solwrap           /* NSS_DBOP_PASSWD_BYUID */
178 };
179
180 nss_backend_t*
181 _nss_winbind_passwd_constr (const char* db_name,
182                             const char* src_name,
183                             const char* cfg_args)
184 {
185         nss_backend_t *be;
186
187         if(!(be = SMB_MALLOC_P(nss_backend_t)) )
188                 return NULL;
189
190         be->ops = passwd_ops;
191         be->n_ops = sizeof(passwd_ops) / sizeof(nss_backend_op_t);
192
193         NSS_DEBUG("Initialized nss_winbind passwd backend");
194         return be;
195 }
196
197 /*****************************************************************
198  GROUP database backend
199  *****************************************************************/
200
201 static NSS_STATUS _nss_winbind_setgrent_solwrap (nss_backend_t* be, void* args)
202 {
203         NSS_DEBUG("_nss_winbind_setgrent_solwrap");
204         return _nss_winbind_setgrent();
205 }
206
207 static NSS_STATUS
208 _nss_winbind_endgrent_solwrap (nss_backend_t * be, void *args)
209 {
210         NSS_DEBUG("_nss_winbind_endgrent_solwrap");
211         return _nss_winbind_endgrent();
212 }
213
214 static NSS_STATUS
215 _nss_winbind_getgrent_solwrap(nss_backend_t* be, void* args)
216 {
217         NSS_STATUS ret;
218         char* buffer = NSS_ARGS(args)->buf.buffer;
219         int buflen = NSS_ARGS(args)->buf.buflen;
220         struct group* result = (struct group*) NSS_ARGS(args)->buf.result;
221         int* errnop = &NSS_ARGS(args)->erange;
222         char logmsg[80];
223
224         ret = _nss_winbind_getgrent_r(result, buffer,
225                                       buflen, errnop);
226
227         if(ret == NSS_STATUS_SUCCESS)
228                 {
229                         snprintf(logmsg, 79, "_nss_winbind_getgrent_solwrap: Returning group: %s\n", result->gr_name);
230                         NSS_DEBUG(logmsg);
231                         NSS_ARGS(args)->returnval = (void*) result;
232                 } else {
233                         snprintf(logmsg, 79, "_nss_winbind_getgrent_solwrap: Returning error: %d.\n", ret);
234                         NSS_DEBUG(logmsg);
235                 }
236
237         return ret;
238
239 }
240
241 static NSS_STATUS
242 _nss_winbind_getgrnam_solwrap(nss_backend_t* be, void* args)
243 {
244         NSS_STATUS ret;
245         struct group* result = (struct group*) NSS_ARGS(args)->buf.result;
246
247         NSS_DEBUG("_nss_winbind_getgrnam_solwrap");
248         ret = _nss_winbind_getgrnam_r(NSS_ARGS(args)->key.name,
249                                       result,
250                                       NSS_ARGS(args)->buf.buffer,
251                                       NSS_ARGS(args)->buf.buflen,
252                                       &NSS_ARGS(args)->erange);
253
254         if(ret == NSS_STATUS_SUCCESS)
255                 NSS_ARGS(args)->returnval = (void*) result;
256
257         return ret;
258 }
259
260 static NSS_STATUS
261 _nss_winbind_getgrgid_solwrap(nss_backend_t* be, void* args)
262 {
263         NSS_STATUS ret;
264         struct group* result = (struct group*) NSS_ARGS(args)->buf.result;
265
266         NSS_DEBUG("_nss_winbind_getgrgid_solwrap");
267         ret = _nss_winbind_getgrgid_r (NSS_ARGS(args)->key.gid,
268                                        result,
269                                        NSS_ARGS(args)->buf.buffer,
270                                        NSS_ARGS(args)->buf.buflen,
271                                        &NSS_ARGS(args)->erange);
272
273         if(ret == NSS_STATUS_SUCCESS)
274                 NSS_ARGS(args)->returnval = (void*) result;
275
276         return ret;
277 }
278
279 static NSS_STATUS
280 _nss_winbind_getgroupsbymember_solwrap(nss_backend_t* be, void* args)
281 {
282         int errnop;
283         struct nss_groupsbymem *gmem = (struct nss_groupsbymem *)args;
284
285         NSS_DEBUG("_nss_winbind_getgroupsbymember");
286
287         _nss_winbind_initgroups_dyn(gmem->username,
288                 gmem->gid_array[0], /* Primary Group */
289                 &gmem->numgids,
290                 &gmem->maxgids,
291                 &gmem->gid_array,
292                 gmem->maxgids,
293                 &errnop);
294
295         /*
296          * If the maximum number of gids have been found, return
297          * SUCCESS so the switch engine will stop searching. Otherwise
298          * return NOTFOUND so nsswitch will continue to get groups
299          * from the remaining database backends specified in the
300          * nsswitch.conf file.
301          */
302         return (gmem->numgids == gmem->maxgids ? NSS_STATUS_SUCCESS : NSS_STATUS_NOTFOUND);
303 }
304
305 static NSS_STATUS
306 _nss_winbind_group_destr (nss_backend_t* be, void* args)
307 {
308         SAFE_FREE(be);
309         NSS_DEBUG("_nss_winbind_group_destr");
310         return NSS_STATUS_SUCCESS;
311 }
312
313 static nss_backend_op_t group_ops[] =
314 {
315         _nss_winbind_group_destr,
316         _nss_winbind_endgrent_solwrap,
317         _nss_winbind_setgrent_solwrap,
318         _nss_winbind_getgrent_solwrap,
319         _nss_winbind_getgrnam_solwrap,
320         _nss_winbind_getgrgid_solwrap,
321         _nss_winbind_getgroupsbymember_solwrap
322 };
323
324 nss_backend_t*
325 _nss_winbind_group_constr (const char* db_name,
326                            const char* src_name,
327                            const char* cfg_args)
328 {
329         nss_backend_t* be;
330
331         if(!(be = SMB_MALLOC_P(nss_backend_t)) )
332                 return NULL;
333
334         be->ops = group_ops;
335         be->n_ops = sizeof(group_ops) / sizeof(nss_backend_op_t);
336
337         NSS_DEBUG("Initialized nss_winbind group backend");
338         return be;
339 }
340
341 /*****************************************************************
342  hosts and ipnodes backend
343  *****************************************************************/
344 #if defined(SUNOS5)     /* not compatible with HP-UX */
345
346 /* this parser is shared between get*byname and get*byaddr, as key type
347    in request is stored in different locations, I had to provide the
348    address family as an argument, caller must free the winbind response. */
349
350 static NSS_STATUS
351 parse_response(int af, nss_XbyY_args_t* argp, struct winbindd_response *response)
352 {
353         struct hostent *he = (struct hostent *)argp->buf.result;
354         char *buffer = argp->buf.buffer;
355         int buflen =  argp->buf.buflen;
356         NSS_STATUS ret;
357
358         char *p, *data;
359         int addrcount = 0;
360         int len = 0;
361         struct in_addr *addrp;
362 #if defined(AF_INET6)
363         struct in6_addr *addrp6;
364 #endif
365         int i;
366
367         /* response is tab separated list of ip addresses with hostname
368            and newline at the end. so at first we will strip newline
369            then construct list of addresses for hostent.
370         */
371         p = strchr(response->data.winsresp, '\n');
372         if(p) *p = '\0';
373         else {/* it must be broken */
374                 argp->h_errno = NO_DATA;
375                 return NSS_STATUS_UNAVAIL;
376         }
377
378         for(; p != response->data.winsresp; p--) {
379                 if(*p == '\t') addrcount++;
380         }
381
382         if(addrcount == 0) {/* it must be broken */
383                 argp->h_errno = NO_DATA;
384                 return NSS_STATUS_UNAVAIL;
385         }
386
387         /* allocate space for addresses and h_addr_list */
388         he->h_addrtype = af;
389         if( he->h_addrtype == AF_INET) {
390                 he->h_length =  sizeof(struct in_addr);
391                 addrp = (struct in_addr *)ROUND_DOWN(buffer + buflen,
392                                                 sizeof(struct in_addr));
393                 addrp -= addrcount;
394                 he->h_addr_list = (char **)ROUND_DOWN(addrp, sizeof (char*));
395                 he->h_addr_list -= addrcount+1;
396         }
397 #if defined(AF_INET6)
398         else {
399                 he->h_length = sizeof(struct in6_addr);
400                 addrp6 = (struct in6_addr *)ROUND_DOWN(buffer + buflen,
401                                                 sizeof(struct in6_addr));
402                 addrp6 -= addrcount;
403                 he->h_addr_list = (char **)ROUND_DOWN(addrp6, sizeof (char*));
404                 he->h_addr_list -= addrcount+1;
405         }
406 #endif
407
408         /* buffer too small?! */
409         if((char *)he->h_addr_list < buffer ) {
410                 argp->erange = 1;
411                 return NSS_STR_PARSE_ERANGE;
412         }
413
414         data = response->data.winsresp;
415         for( i = 0; i < addrcount; i++) {
416                 p = strchr(data, '\t');
417                 if(p == NULL) break; /* just in case... */
418
419                 *p = '\0'; /* terminate the string */
420                 if(he->h_addrtype == AF_INET) {
421                   he->h_addr_list[i] = (char *)&addrp[i];
422                   if ((addrp[i].s_addr = inet_addr(data)) == -1) {
423                     argp->erange = 1;
424                     return NSS_STR_PARSE_ERANGE;
425                   }
426                 }
427 #if defined(AF_INET6)
428                 else {
429                   he->h_addr_list[i] = (char *)&addrp6[i];
430                   if (strchr(data, ':') != 0) {
431                         if (inet_pton(AF_INET6, data, &addrp6[i]) != 1) {
432                           argp->erange = 1;
433                           return NSS_STR_PARSE_ERANGE;
434                         }
435                   } else {
436                         struct in_addr in4;
437                         if ((in4.s_addr = inet_addr(data)) == -1) {
438                           argp->erange = 1;
439                           return NSS_STR_PARSE_ERANGE;
440                         }
441                         IN6_INADDR_TO_V4MAPPED(&in4, &addrp6[i]);
442                   }
443                 }
444 #endif
445                 data = p+1;
446         }
447
448         he->h_addr_list[i] = (char *)NULL;
449
450         len = strlen(data);
451         if(len > he->h_addr_list - (char**)argp->buf.buffer) {
452                 argp->erange = 1;
453                 return NSS_STR_PARSE_ERANGE;
454         }
455
456         /* this is a bit overkill to use _nss_netdb_aliases here since
457            there seems to be no aliases but it will create all data for us */
458         he->h_aliases = _nss_netdb_aliases(data, len, buffer,
459                                 ((char*) he->h_addr_list) - buffer);
460         if(he->h_aliases == NULL) {
461             argp->erange = 1;
462             ret = NSS_STR_PARSE_ERANGE;
463         } else {
464             he->h_name = he->h_aliases[0];
465             he->h_aliases++;
466             ret = NSS_STR_PARSE_SUCCESS;
467         }
468
469         argp->returnval = (void*)he;
470         return ret;
471 }
472
473 static NSS_STATUS
474 _nss_winbind_ipnodes_getbyname(nss_backend_t* be, void *args)
475 {
476         nss_XbyY_args_t *argp = (nss_XbyY_args_t*) args;
477         struct winbindd_response response;
478         struct winbindd_request request;
479         NSS_STATUS ret;
480         int af;
481
482         ZERO_STRUCT(response);
483         ZERO_STRUCT(request);
484
485         /* I assume there that AI_ADDRCONFIG cases are handled in nss
486            frontend code, at least it seems done so in solaris...
487
488            we will give NO_DATA for pure IPv6; IPv4 will be returned for
489            AF_INET or for AF_INET6 and AI_ALL|AI_V4MAPPED we have to map
490            IPv4 to IPv6.
491          */
492 #if defined(AF_INET6)
493 #ifdef HAVE_NSS_XBYY_KEY_IPNODE
494         af = argp->key.ipnode.af_family;
495         if(af == AF_INET6 && argp->key.ipnode.flags == 0) {
496                 argp->h_errno = NO_DATA;
497                 return NSS_STATUS_UNAVAIL;
498         }
499 #else
500         /* I'm not that sure if this is correct, but... */
501         af = AF_INET6;
502 #endif
503 #endif
504
505         strncpy(request.data.winsreq, argp->key.name, sizeof(request.data.winsreq) - 1);
506         request.data.winsreq[sizeof(request.data.winsreq) - 1] = '\0';
507
508         if( (ret = winbindd_request_response(WINBINDD_WINS_BYNAME, &request, &response))
509                 == NSS_STATUS_SUCCESS ) {
510           ret = parse_response(af, argp, &response);
511         }
512
513         winbindd_free_response(&response);
514         return ret;
515 }
516
517 static NSS_STATUS
518 _nss_winbind_hosts_getbyname(nss_backend_t* be, void *args)
519 {
520         nss_XbyY_args_t *argp = (nss_XbyY_args_t*) args;
521         struct winbindd_response response;
522         struct winbindd_request request;
523         NSS_STATUS ret;
524
525         ZERO_STRUCT(response);
526         ZERO_STRUCT(request);
527
528         strncpy(request.data.winsreq, argp->key.name, sizeof(request.data.winsreq) - 1);
529         request.data.winsreq[sizeof(request.data.winsreq) - 1] = '\0';
530
531         if( (ret = winbindd_request_response(WINBINDD_WINS_BYNAME, &request, &response))
532                 == NSS_STATUS_SUCCESS ) {
533           ret = parse_response(AF_INET, argp, &response);
534         }
535
536         winbindd_free_response(&response);
537         return ret;
538 }
539
540 static NSS_STATUS
541 _nss_winbind_hosts_getbyaddr(nss_backend_t* be, void *args)
542 {
543         NSS_STATUS ret;
544         struct winbindd_response response;
545         struct winbindd_request request;
546         nss_XbyY_args_t *argp = (nss_XbyY_args_t *)args;
547         const char *p;
548
549         ZERO_STRUCT(response);
550         ZERO_STRUCT(request);
551
552 #if defined(AF_INET6)
553         /* winbindd currently does not resolve IPv6 */
554         if(argp->key.hostaddr.type == AF_INET6) {
555                 argp->h_errno = NO_DATA;
556                 return NSS_STATUS_UNAVAIL;
557         }
558
559         p = inet_ntop(argp->key.hostaddr.type, argp->key.hostaddr.addr,
560                         request.data.winsreq, sizeof request.data.winsreq);
561 #else
562         snprintf(request.data.winsreq, sizeof request.data.winsreq,
563                 "%u.%u.%u.%u",
564                 ((unsigned char *)argp->key.hostaddr.addr)[0],
565                 ((unsigned char *)argp->key.hostaddr.addr)[1],
566                 ((unsigned char *)argp->key.hostaddr.addr)[2],
567                 ((unsigned char *)argp->key.hostaddr.addr)[3]);
568 #endif
569
570         ret = winbindd_request_response(WINBINDD_WINS_BYIP, &request, &response);
571
572         if( ret == NSS_STATUS_SUCCESS) {
573           parse_response(argp->key.hostaddr.type, argp, &response);
574         }
575         winbindd_free_response(&response);
576         return ret;
577 }
578
579 /* winbind does not provide setent, getent, endent for wins */
580 static NSS_STATUS
581 _nss_winbind_common_endent(nss_backend_t* be, void *args)
582 {
583         return (NSS_STATUS_UNAVAIL);
584 }
585
586 static NSS_STATUS
587 _nss_winbind_common_setent(nss_backend_t* be, void *args)
588 {
589         return (NSS_STATUS_UNAVAIL);
590 }
591
592 static NSS_STATUS
593 _nss_winbind_common_getent(nss_backend_t* be, void *args)
594 {
595         return (NSS_STATUS_UNAVAIL);
596 }
597
598 static nss_backend_t*
599 _nss_winbind_common_constr (nss_backend_op_t ops[], int n_ops)
600 {
601         nss_backend_t* be;
602
603         if(!(be = SMB_MALLOC_P(nss_backend_t)) )
604         return NULL;
605
606         be->ops = ops;
607         be->n_ops = n_ops;
608
609         return be;
610 }
611
612 static NSS_STATUS
613 _nss_winbind_common_destr (nss_backend_t* be, void* args)
614 {
615         SAFE_FREE(be);
616         return NSS_STATUS_SUCCESS;
617 }
618
619 static nss_backend_op_t ipnodes_ops[] = {
620         _nss_winbind_common_destr,
621         _nss_winbind_common_endent,
622         _nss_winbind_common_setent,
623         _nss_winbind_common_getent,
624         _nss_winbind_ipnodes_getbyname,
625         _nss_winbind_hosts_getbyaddr,
626 };
627
628 nss_backend_t *
629 _nss_winbind_ipnodes_constr(dummy1, dummy2, dummy3)
630         const char      *dummy1, *dummy2, *dummy3;
631 {
632         return (_nss_winbind_common_constr(ipnodes_ops,
633                 sizeof (ipnodes_ops) / sizeof (ipnodes_ops[0])));
634 }
635
636 static nss_backend_op_t host_ops[] = {
637         _nss_winbind_common_destr,
638         _nss_winbind_common_endent,
639         _nss_winbind_common_setent,
640         _nss_winbind_common_getent,
641         _nss_winbind_hosts_getbyname,
642         _nss_winbind_hosts_getbyaddr,
643 };
644
645 nss_backend_t *
646 _nss_winbind_hosts_constr(dummy1, dummy2, dummy3)
647         const char      *dummy1, *dummy2, *dummy3;
648 {
649         return (_nss_winbind_common_constr(host_ops,
650                 sizeof (host_ops) / sizeof (host_ops[0])));
651 }
652
653 #endif  /* defined(SUNOS5) */
654 #endif  /* defined(HAVE_NSS_COMMON_H) || defined(HPUX) */