← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to nsswitch/winbind_nss_netbsd.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
nsswitch/winbind_nss_netbsd.c
 
1
/*
 
2
   Unix SMB/CIFS implementation.
 
3
 
 
4
   NetBSD loadable authentication module, providing identification
 
5
   routines against Samba winbind/Windows NT Domain
 
6
 
 
7
   Copyright (C) Luke Mewburn 2004-2005
 
8
 
 
9
   This library is free software; you can redistribute it and/or
 
10
   modify it under the terms of the GNU Lesser General Public
 
11
   License as published by the Free Software Foundation; either
 
12
   version 3 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 Lesser General Public
 
20
   License along with this library; if not, see <http://www.gnu.org/licenses/>.
 
21
*/
 
22
 
 
23
 
 
24
#include "winbind_client.h"
 
25
 
 
26
#include <sys/param.h>
 
27
#include <stdarg.h>
 
28
#include <syslog.h>
 
29
 
 
30
        /* dynamic nsswitch with "new" getpw* nsdispatch API available */
 
31
#if defined(NSS_MODULE_INTERFACE_VERSION) && defined(HAVE_GETPWENT_R)
 
32
 
 
33
/*
 
34
        group functions
 
35
        ---------------
 
36
*/
 
37
 
 
38
static struct group     _winbind_group;
 
39
static char             _winbind_groupbuf[1024];
 
40
 
 
41
/*
 
42
 * We need a proper prototype for this :-)
 
43
 */
 
44
 
 
45
NSS_STATUS _nss_winbind_setpwent(void);
 
46
NSS_STATUS _nss_winbind_endpwent(void);
 
47
NSS_STATUS _nss_winbind_getpwent_r(struct passwd *result, char *buffer,
 
48
                                   size_t buflen, int *errnop);
 
49
NSS_STATUS _nss_winbind_getpwuid_r(uid_t uid, struct passwd *result,
 
50
                                   char *buffer, size_t buflen, int *errnop);
 
51
NSS_STATUS _nss_winbind_getpwnam_r(const char *name, struct passwd *result,
 
52
                                   char *buffer, size_t buflen, int *errnop);
 
53
NSS_STATUS _nss_winbind_setgrent(void);
 
54
NSS_STATUS _nss_winbind_endgrent(void);
 
55
NSS_STATUS _nss_winbind_getgrent_r(struct group *result, char *buffer,
 
56
                                   size_t buflen, int *errnop);
 
57
NSS_STATUS _nss_winbind_getgrlst_r(struct group *result, char *buffer,
 
58
                                   size_t buflen, int *errnop);
 
59
NSS_STATUS _nss_winbind_getgrnam_r(const char *name, struct group *result,
 
60
                                   char *buffer, size_t buflen, int *errnop);
 
61
NSS_STATUS _nss_winbind_getgrgid_r(gid_t gid, struct group *result, char *buffer,
 
62
                                   size_t buflen, int *errnop);
 
63
NSS_STATUS _nss_winbind_initgroups_dyn(char *user, gid_t group, long int *start,
 
64
                                       long int *size, gid_t **groups,
 
65
                                       long int limit, int *errnop);
 
66
NSS_STATUS _nss_winbind_getusersids(const char *user_sid, char **group_sids,
 
67
                                    int *num_groups, char *buffer, size_t buf_size,
 
68
                                    int *errnop);
 
69
NSS_STATUS _nss_winbind_nametosid(const char *name, char **sid, char *buffer,
 
70
                                  size_t buflen, int *errnop);
 
71
NSS_STATUS _nss_winbind_sidtoname(const char *sid, char **name, char *buffer,
 
72
                                  size_t buflen, int *errnop);
 
73
NSS_STATUS _nss_winbind_sidtouid(const char *sid, uid_t *uid, int *errnop);
 
74
NSS_STATUS _nss_winbind_sidtogid(const char *sid, gid_t *gid, int *errnop);
 
75
NSS_STATUS _nss_winbind_uidtosid(uid_t uid, char **sid, char *buffer,
 
76
                                 size_t buflen, int *errnop);
 
77
NSS_STATUS _nss_winbind_gidtosid(gid_t gid, char **sid, char *buffer,
 
78
                                 size_t buflen, int *errnop);
 
79
 
 
80
int
 
81
netbsdwinbind_endgrent(void *nsrv, void *nscb, va_list ap)
 
82
{
 
83
        int     rv;
 
84
 
 
85
        rv = _nss_winbind_endgrent();
 
86
        return rv;
 
87
}
 
88
 
 
89
int
 
90
netbsdwinbind_setgrent(void *nsrv, void *nscb, va_list ap)
 
91
{
 
92
        int     rv;
 
93
 
 
94
        rv = _nss_winbind_setgrent();
 
95
        return rv;
 
96
}
 
97
 
 
98
int
 
99
netbsdwinbind_getgrent(void *nsrv, void *nscb, va_list ap)
 
100
{
 
101
        struct group   **retval = va_arg(ap, struct group **);
 
102
 
 
103
        int     rv, rerrno;
 
104
 
 
105
        *retval = NULL;
 
106
        rv = _nss_winbind_getgrent_r(&_winbind_group,
 
107
            _winbind_groupbuf, sizeof(_winbind_groupbuf), &rerrno);
 
108
        if (rv == NS_SUCCESS)
 
109
                *retval = &_winbind_group;
 
110
        return rv;
 
111
}
 
112
 
 
113
int
 
114
netbsdwinbind_getgrent_r(void *nsrv, void *nscb, va_list ap)
 
115
{
 
116
        int             *retval = va_arg(ap, int *);
 
117
        struct group    *grp    = va_arg(ap, struct group *);
 
118
        char            *buffer = va_arg(ap, char *);
 
119
        size_t           buflen = va_arg(ap, size_t);
 
120
        struct group   **result = va_arg(ap, struct group **);
 
121
 
 
122
        int     rv, rerrno;
 
123
 
 
124
        *result = NULL;
 
125
        rerrno = 0;
 
126
 
 
127
        rv = _nss_winbind_getgrent_r(grp, buffer, buflen, rerrno);
 
128
        if (rv == NS_SUCCESS)
 
129
                *result = grp;
 
130
        else
 
131
                *retval = rerrno;
 
132
        return rv;
 
133
}
 
134
 
 
135
int
 
136
netbsdwinbind_getgrgid(void *nsrv, void *nscb, va_list ap)
 
137
{
 
138
        struct group   **retval = va_arg(ap, struct group **);
 
139
        gid_t            gid    = va_arg(ap, gid_t);
 
140
 
 
141
        int     rv, rerrno;
 
142
 
 
143
        *retval = NULL;
 
144
        rv = _nss_winbind_getgrgid_r(gid, &_winbind_group,
 
145
            _winbind_groupbuf, sizeof(_winbind_groupbuf), &rerrno);
 
146
        if (rv == NS_SUCCESS)
 
147
                *retval = &_winbind_group;
 
148
        return rv;
 
149
}
 
150
 
 
151
int
 
152
netbsdwinbind_getgrgid_r(void *nsrv, void *nscb, va_list ap)
 
153
{
 
154
        int             *retval = va_arg(ap, int *);
 
155
        gid_t            gid    = va_arg(ap, gid_t);
 
156
        struct group    *grp    = va_arg(ap, struct group *);
 
157
        char            *buffer = va_arg(ap, char *);
 
158
        size_t           buflen = va_arg(ap, size_t);
 
159
        struct group   **result = va_arg(ap, struct group **);
 
160
 
 
161
        int     rv, rerrno;
 
162
 
 
163
        *result = NULL;
 
164
        rerrno = 0;
 
165
 
 
166
        rv = _nss_winbind_getgrgid_r(gid, grp, buffer, buflen, &rerrno);
 
167
        if (rv == NS_SUCCESS)
 
168
                *result = grp;
 
169
        else
 
170
                *retval = rerrno;
 
171
        return rv;
 
172
}
 
173
 
 
174
int
 
175
netbsdwinbind_getgrnam(void *nsrv, void *nscb, va_list ap)
 
176
{
 
177
        struct group   **retval = va_arg(ap, struct group **);
 
178
        const char      *name   = va_arg(ap, const char *);
 
179
 
 
180
        int     rv, rerrno;
 
181
 
 
182
        *retval = NULL;
 
183
        rv = _nss_winbind_getgrnam_r(name, &_winbind_group,
 
184
            _winbind_groupbuf, sizeof(_winbind_groupbuf), &rerrno);
 
185
        if (rv == NS_SUCCESS)
 
186
                *retval = &_winbind_group;
 
187
        return rv;
 
188
}
 
189
 
 
190
int
 
191
netbsdwinbind_getgrnam_r(void *nsrv, void *nscb, va_list ap)
 
192
{
 
193
        int             *retval = va_arg(ap, int *);
 
194
        const char      *name   = va_arg(ap, const char *);
 
195
        struct group    *grp    = va_arg(ap, struct group *);
 
196
        char            *buffer = va_arg(ap, char *);
 
197
        size_t           buflen = va_arg(ap, size_t);
 
198
        struct group   **result = va_arg(ap, struct group **);
 
199
 
 
200
        int     rv, rerrno;
 
201
 
 
202
        *result = NULL;
 
203
        rerrno = 0;
 
204
 
 
205
        rv = _nss_winbind_getgrnam_r(name, grp, buffer, buflen, &rerrno);
 
206
        if (rv == NS_SUCCESS)
 
207
                *result = grp;
 
208
        else
 
209
                *retval = rerrno;
 
210
        return rv;
 
211
}
 
212
 
 
213
int
 
214
netbsdwinbind_getgroupmembership(void *nsrv, void *nscb, va_list ap)
 
215
{
 
216
        int             *result = va_arg(ap, int *);
 
217
        const char      *uname  = va_arg(ap, const char *);
 
218
        gid_t            agroup = va_arg(ap, gid_t);
 
219
        gid_t           *groups = va_arg(ap, gid_t *);
 
220
        int              maxgrp = va_arg(ap, int);
 
221
        int             *groupc = va_arg(ap, int *);
 
222
 
 
223
        struct winbindd_request request;
 
224
        struct winbindd_response response;
 
225
        gid_t   *wblistv;
 
226
        int     wblistc, i, isdup, dupc;
 
227
 
 
228
        ZERO_STRUCT(request);
 
229
        ZERO_STRUCT(response);
 
230
        strncpy(request.data.username, uname,
 
231
                                sizeof(request.data.username) - 1);
 
232
        i = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
 
233
        if (i != NSS_STATUS_SUCCESS)
 
234
                return NS_NOTFOUND;
 
235
        wblistv = (gid_t *)response.extra_data.data;
 
236
        wblistc = response.data.num_entries;
 
237
 
 
238
        for (i = 0; i < wblistc; i++) {                 /* add winbind gids */
 
239
                isdup = 0;                              /* skip duplicates */
 
240
                for (dupc = 0; dupc < MIN(maxgrp, *groupc); dupc++) {
 
241
                        if (groups[dupc] == wblistv[i]) {
 
242
                                isdup = 1;
 
243
                                break;
 
244
                        }
 
245
                }
 
246
                if (isdup)
 
247
                        continue;
 
248
                if (*groupc < maxgrp)                   /* add this gid */
 
249
                        groups[*groupc] = wblistv[i];
 
250
                else
 
251
                        *result = -1;
 
252
                (*groupc)++;
 
253
        }
 
254
        SAFE_FREE(wblistv);
 
255
        return NS_NOTFOUND;
 
256
}
 
257
 
 
258
 
 
259
/*
 
260
        passwd functions
 
261
        ----------------
 
262
*/
 
263
 
 
264
static struct passwd    _winbind_passwd;
 
265
static char             _winbind_passwdbuf[1024];
 
266
 
 
267
int
 
268
netbsdwinbind_endpwent(void *nsrv, void *nscb, va_list ap)
 
269
{
 
270
        int     rv;
 
271
 
 
272
        rv = _nss_winbind_endpwent();
 
273
        return rv;
 
274
}
 
275
 
 
276
int
 
277
netbsdwinbind_setpwent(void *nsrv, void *nscb, va_list ap)
 
278
{
 
279
        int     rv;
 
280
 
 
281
        rv = _nss_winbind_setpwent();
 
282
        return rv;
 
283
}
 
284
 
 
285
int
 
286
netbsdwinbind_getpwent(void *nsrv, void *nscb, va_list ap)
 
287
{
 
288
        struct passwd  **retval = va_arg(ap, struct passwd **);
 
289
 
 
290
        int     rv, rerrno;
 
291
 
 
292
        *retval = NULL;
 
293
 
 
294
        rv = _nss_winbind_getpwent_r(&_winbind_passwd,
 
295
            _winbind_passwdbuf, sizeof(_winbind_passwdbuf), &rerrno);
 
296
        if (rv == NS_SUCCESS)
 
297
                *retval = &_winbind_passwd;
 
298
        return rv;
 
299
}
 
300
 
 
301
int
 
302
netbsdwinbind_getpwent_r(void *nsrv, void *nscb, va_list ap)
 
303
{
 
304
        int             *retval = va_arg(ap, int *);
 
305
        struct passwd   *pw     = va_arg(ap, struct passwd *);
 
306
        char            *buffer = va_arg(ap, char *);
 
307
        size_t           buflen = va_arg(ap, size_t);
 
308
        struct passwd  **result = va_arg(ap, struct passwd **);
 
309
 
 
310
        int     rv, rerrno;
 
311
 
 
312
        *result = NULL;
 
313
        rerrno = 0;
 
314
 
 
315
        rv = _nss_winbind_getpwent_r(pw, buffer, buflen, rerrno);
 
316
        if (rv == NS_SUCCESS)
 
317
                *result = pw;
 
318
        else
 
319
                *retval = rerrno;
 
320
        return rv;
 
321
}
 
322
 
 
323
int
 
324
netbsdwinbind_getpwnam(void *nsrv, void *nscb, va_list ap)
 
325
{
 
326
        struct passwd  **retval = va_arg(ap, struct passwd **);
 
327
        const char      *name   = va_arg(ap, const char *);
 
328
 
 
329
        int     rv, rerrno;
 
330
 
 
331
        *retval = NULL;
 
332
        rv = _nss_winbind_getpwnam_r(name, &_winbind_passwd,
 
333
            _winbind_passwdbuf, sizeof(_winbind_passwdbuf), &rerrno);
 
334
        if (rv == NS_SUCCESS)
 
335
                *retval = &_winbind_passwd;
 
336
        return rv;
 
337
}
 
338
 
 
339
int
 
340
netbsdwinbind_getpwnam_r(void *nsrv, void *nscb, va_list ap)
 
341
{
 
342
        int             *retval = va_arg(ap, int *);
 
343
        const char      *name   = va_arg(ap, const char *);
 
344
        struct passwd   *pw     = va_arg(ap, struct passwd *);
 
345
        char            *buffer = va_arg(ap, char *);
 
346
        size_t           buflen = va_arg(ap, size_t);
 
347
        struct passwd  **result = va_arg(ap, struct passwd **);
 
348
 
 
349
        int     rv, rerrno;
 
350
 
 
351
        *result = NULL;
 
352
        rerrno = 0;
 
353
 
 
354
        rv = _nss_winbind_getpwnam_r(name, pw, buffer, buflen, &rerrno);
 
355
        if (rv == NS_SUCCESS)
 
356
                *result = pw;
 
357
        else
 
358
                *retval = rerrno;
 
359
        return rv;
 
360
}
 
361
 
 
362
int
 
363
netbsdwinbind_getpwuid(void *nsrv, void *nscb, va_list ap)
 
364
{
 
365
        struct passwd  **retval = va_arg(ap, struct passwd **);
 
366
        uid_t            uid    = va_arg(ap, uid_t);
 
367
 
 
368
        int     rv, rerrno;
 
369
 
 
370
        *retval = NULL;
 
371
        rv = _nss_winbind_getpwuid_r(uid, &_winbind_passwd,
 
372
            _winbind_passwdbuf, sizeof(_winbind_passwdbuf), &rerrno);
 
373
        if (rv == NS_SUCCESS)
 
374
                *retval = &_winbind_passwd;
 
375
        return rv;
 
376
}
 
377
 
 
378
int
 
379
netbsdwinbind_getpwuid_r(void *nsrv, void *nscb, va_list ap)
 
380
{
 
381
        int             *retval = va_arg(ap, int *);
 
382
        uid_t            uid    = va_arg(ap, uid_t);
 
383
        struct passwd   *pw     = va_arg(ap, struct passwd *);
 
384
        char            *buffer = va_arg(ap, char *);
 
385
        size_t           buflen = va_arg(ap, size_t);
 
386
        struct passwd  **result = va_arg(ap, struct passwd **);
 
387
 
 
388
        int     rv, rerrno;
 
389
 
 
390
        *result = NULL;
 
391
        rerrno = 0;
 
392
 
 
393
        rv = _nss_winbind_getpwuid_r(uid, pw, buffer, buflen, &rerrno);
 
394
        if (rv == NS_SUCCESS)
 
395
                *result = pw;
 
396
        else
 
397
                *retval = rerrno;
 
398
        return rv;
 
399
}
 
400
 
 
401
 
 
402
/*
 
403
        nsswitch module setup
 
404
        ---------------------
 
405
*/
 
406
 
 
407
 
 
408
static ns_mtab winbind_methods[] = {
 
409
 
 
410
{ NSDB_GROUP, "endgrent",       netbsdwinbind_endgrent,         NULL },
 
411
{ NSDB_GROUP, "getgrent",       netbsdwinbind_getgrent,         NULL },
 
412
{ NSDB_GROUP, "getgrent_r",     netbsdwinbind_getgrent_r,       NULL },
 
413
{ NSDB_GROUP, "getgrgid",       netbsdwinbind_getgrgid,         NULL },
 
414
{ NSDB_GROUP, "getgrgid_r",     netbsdwinbind_getgrgid_r,       NULL },
 
415
{ NSDB_GROUP, "getgrnam",       netbsdwinbind_getgrnam,         NULL },
 
416
{ NSDB_GROUP, "getgrnam_r",     netbsdwinbind_getgrnam_r,       NULL },
 
417
{ NSDB_GROUP, "setgrent",       netbsdwinbind_setgrent,         NULL },
 
418
{ NSDB_GROUP, "setgroupent",    netbsdwinbind_setgrent,         NULL },
 
419
{ NSDB_GROUP, "getgroupmembership", netbsdwinbind_getgroupmembership, NULL },
 
420
 
 
421
{ NSDB_PASSWD, "endpwent",      netbsdwinbind_endpwent,         NULL },
 
422
{ NSDB_PASSWD, "getpwent",      netbsdwinbind_getpwent,         NULL },
 
423
{ NSDB_PASSWD, "getpwent_r",    netbsdwinbind_getpwent_r,       NULL },
 
424
{ NSDB_PASSWD, "getpwnam",      netbsdwinbind_getpwnam,         NULL },
 
425
{ NSDB_PASSWD, "getpwnam_r",    netbsdwinbind_getpwnam_r,       NULL },
 
426
{ NSDB_PASSWD, "getpwuid",      netbsdwinbind_getpwuid,         NULL },
 
427
{ NSDB_PASSWD, "getpwuid_r",    netbsdwinbind_getpwuid_r,       NULL },
 
428
{ NSDB_PASSWD, "setpassent",    netbsdwinbind_setpwent,         NULL },
 
429
{ NSDB_PASSWD, "setpwent",      netbsdwinbind_setpwent,         NULL },
 
430
 
 
431
};
 
432
 
 
433
ns_mtab *
 
434
nss_module_register(const char *source, unsigned int *mtabsize,
 
435
    nss_module_unregister_fn *unreg)
 
436
{
 
437
        *mtabsize = sizeof(winbind_methods)/sizeof(winbind_methods[0]);
 
438
        *unreg = NULL;
 
439
        return (winbind_methods);
 
440
}
 
441
 
 
442
#endif /* NSS_MODULE_INTERFACE_VERSION && HAVE_GETPWENT_R */