← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to source/nsswitch/winbind_nss_irix.c

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/nsswitch/winbind_nss_irix.c
1
 
/* 
2
 
   Unix SMB/CIFS implementation.
3
 
 
4
 
   Windows NT Domain nsswitch module
5
 
 
6
 
   Copyright (C) Tim Potter 2000
7
 
   Copyright (C) James Peach 2006
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 "winbind_client.h"
26
 
 
27
 
#ifndef PRINTF_ATTRIBUTE
28
 
#define PRINTF_ATTRIBUTE(m, n)
29
 
#endif
30
 
 
31
 
#ifndef HAVE_ASPRINTF_DECL
32
 
/*PRINTFLIKE2 */
33
 
int asprintf(char **,const char *, ...) PRINTF_ATTRIBUTE(2,3);
34
 
#endif
35
 
 
36
 
#ifdef HAVE_NS_API_H
37
 
#undef VOLATILE
38
 
#undef STATIC
39
 
#undef DYNAMIC
40
 
#include <ns_daemon.h>
41
 
#endif
42
 
 
43
 
/* Maximum number of users to pass back over the unix domain socket
44
 
   per call. This is not a static limit on the total number of users 
45
 
   or groups returned in total. */
46
 
 
47
 
#define MAX_GETPWENT_USERS 250
48
 
#define MAX_GETGRENT_USERS 250
49
 
 
50
 
/* Prototypes from wb_common.c */
51
 
 
52
 
extern int winbindd_fd;
53
 
 
54
 
#ifdef HAVE_NS_API_H
55
 
 
56
 
/* IRIX version */
57
 
 
58
 
static int send_next_request(nsd_file_t *, struct winbindd_request *);
59
 
static int do_list(int state, nsd_file_t *rq);
60
 
 
61
 
static nsd_file_t *current_rq = NULL;
62
 
static int current_winbind_xid = 0;
63
 
static int next_winbind_xid = 0;
64
 
 
65
 
typedef struct winbind_xid {
66
 
        int                     xid;
67
 
        nsd_file_t              *rq;
68
 
        struct winbindd_request *request;
69
 
        struct winbind_xid      *next;
70
 
} winbind_xid_t;
71
 
 
72
 
static winbind_xid_t *winbind_xids = (winbind_xid_t *)0;
73
 
 
74
 
static int
75
 
winbind_xid_new(int xid, nsd_file_t *rq, struct winbindd_request *request)
76
 
{
77
 
        winbind_xid_t *new;
78
 
 
79
 
        nsd_logprintf(NSD_LOG_LOW,
80
 
                "entering winbind_xid_new xid = %d rq = 0x%x, request = 0x%x\n",
81
 
                xid, rq, request);
82
 
        new = (winbind_xid_t *)nsd_calloc(1,sizeof(winbind_xid_t));
83
 
        if (!new) {
84
 
                nsd_logprintf(NSD_LOG_RESOURCE,"winbind_xid_new: failed malloc\n");
85
 
                return NSD_ERROR;
86
 
        }
87
 
 
88
 
        new->xid = xid;
89
 
        new->rq = rq;
90
 
        new->request = request;
91
 
        new->next = winbind_xids;
92
 
        winbind_xids = new;
93
 
 
94
 
        return NSD_CONTINUE;
95
 
}
96
 
 
97
 
/*
98
 
** This routine will look down the xid list and return the request
99
 
** associated with an xid.  We remove the record if it is found.
100
 
*/
101
 
nsd_file_t *
102
 
winbind_xid_lookup(int xid, struct winbindd_request **requestp)
103
 
{
104
 
        winbind_xid_t **last, *dx;
105
 
        nsd_file_t *result=0;
106
 
 
107
 
        for (last = &winbind_xids, dx = winbind_xids; dx && (dx->xid != xid);
108
 
            last = &dx->next, dx = dx->next);
109
 
        if (dx) {
110
 
                *last = dx->next;
111
 
                result = dx->rq;
112
 
                *requestp = dx->request;
113
 
                SAFE_FREE(dx);
114
 
        }
115
 
        nsd_logprintf(NSD_LOG_LOW,
116
 
                "entering winbind_xid_lookup xid = %d rq = 0x%x, request = 0x%x\n",
117
 
                xid, result, dx->request);
118
 
 
119
 
        return result;
120
 
}
121
 
 
122
 
static int
123
 
winbind_startnext_timeout(nsd_file_t **rqp, nsd_times_t *to)
124
 
{
125
 
        nsd_file_t *rq;
126
 
        struct winbindd_request *request;
127
 
 
128
 
        nsd_logprintf(NSD_LOG_MIN, "timeout (winbind startnext)\n");
129
 
        rq = to->t_file;
130
 
        *rqp = rq;
131
 
        nsd_timeout_remove(rq);
132
 
        request = to->t_clientdata;
133
 
        return(send_next_request(rq, request));
134
 
}
135
 
 
136
 
static void
137
 
dequeue_request(void)
138
 
{
139
 
        nsd_file_t *rq;
140
 
        struct winbindd_request *request;
141
 
 
142
 
        /*
143
 
         * Check for queued requests
144
 
         */
145
 
        if (winbind_xids) {
146
 
            nsd_logprintf(NSD_LOG_MIN, "timeout (winbind) unqueue xid %d\n",
147
 
                        current_winbind_xid);
148
 
            rq = winbind_xid_lookup(current_winbind_xid++, &request);
149
 
            /* cause a timeout on the queued request so we can send it */
150
 
            nsd_timeout_new(rq,1,winbind_startnext_timeout,request);
151
 
        }
152
 
}
153
 
 
154
 
static int
155
 
do_request(nsd_file_t *rq, struct winbindd_request *request)
156
 
{
157
 
        if (winbind_xids == NULL) {
158
 
                /*
159
 
                 * No outstanding requests.
160
 
                 * Send off the request to winbindd
161
 
                 */
162
 
                nsd_logprintf(NSD_LOG_MIN, "lookup (winbind) sending request\n");
163
 
                return(send_next_request(rq, request));
164
 
        } else {
165
 
                /*
166
 
                 * Just queue it up for now - previous callout or timout
167
 
                 * will start it up
168
 
                 */
169
 
                nsd_logprintf(NSD_LOG_MIN,
170
 
                        "lookup (winbind): queue request xid = %d\n",
171
 
                        next_winbind_xid);
172
 
                return(winbind_xid_new(next_winbind_xid++, rq, request));
173
 
        }
174
 
}
175
 
 
176
 
static int 
177
 
winbind_callback(nsd_file_t **rqp, int fd)
178
 
{
179
 
        struct winbindd_response response;
180
 
        nsd_file_t *rq;
181
 
        NSS_STATUS status;
182
 
        char * result = NULL;
183
 
        size_t rlen;
184
 
 
185
 
        dequeue_request();
186
 
 
187
 
        nsd_logprintf(NSD_LOG_MIN, "entering callback (winbind)\n");
188
 
 
189
 
        rq = current_rq;
190
 
        *rqp = rq;
191
 
 
192
 
        nsd_timeout_remove(rq);
193
 
        nsd_callback_remove(fd);
194
 
 
195
 
        ZERO_STRUCT(response);
196
 
        status = winbindd_get_response(&response);
197
 
 
198
 
        if (status != NSS_STATUS_SUCCESS) {
199
 
                /* free any extra data area in response structure */
200
 
                free_response(&response);
201
 
                nsd_logprintf(NSD_LOG_MIN, 
202
 
                        "callback (winbind) returning not found, status = %d\n",
203
 
                        status);
204
 
 
205
 
                switch (status) {
206
 
                    case NSS_STATUS_UNAVAIL:
207
 
                        rq->f_status = NS_UNAVAIL;
208
 
                        break;
209
 
                    case NSS_STATUS_TRYAGAIN:
210
 
                        rq->f_status = NS_TRYAGAIN;
211
 
                        break;
212
 
                    case NSS_STATUS_NOTFOUND:
213
 
                        /* FALLTHRU */
214
 
                    default:
215
 
                        rq->f_status = NS_NOTFOUND;
216
 
                }
217
 
 
218
 
                return NSD_NEXT;
219
 
        }
220
 
 
221
 
        switch ((int)rq->f_cmd_data) {
222
 
            case WINBINDD_WINS_BYNAME:
223
 
            case WINBINDD_WINS_BYIP:
224
 
                nsd_logprintf(NSD_LOG_MIN,
225
 
                        "callback (winbind) WINS_BYNAME | WINS_BYIP\n");
226
 
 
227
 
                rlen = asprintf(&result, "%s\n", response.data.winsresp);
228
 
                if (rlen == 0 || result == NULL) {
229
 
                        return NSD_ERROR;
230
 
                }
231
 
                
232
 
                free_response(&response);
233
 
                
234
 
                nsd_logprintf(NSD_LOG_MIN, "    %s\n", result);
235
 
                nsd_set_result(rq, NS_SUCCESS, result, rlen, DYNAMIC);
236
 
                return NSD_OK;
237
 
 
238
 
            case WINBINDD_GETPWUID:
239
 
            case WINBINDD_GETPWNAM:
240
 
            {
241
 
                struct winbindd_pw *pw = &response.data.pw;
242
 
            
243
 
                nsd_logprintf(NSD_LOG_MIN,
244
 
                        "callback (winbind) GETPWUID | GETPWUID\n");
245
 
 
246
 
                rlen = asprintf(&result,"%s:%s:%d:%d:%s:%s:%s\n",
247
 
                                pw->pw_name,
248
 
                                pw->pw_passwd,
249
 
                                pw->pw_uid,
250
 
                                pw->pw_gid,
251
 
                                pw->pw_gecos,
252
 
                                pw->pw_dir,
253
 
                                pw->pw_shell);
254
 
                if (rlen == 0 || result == NULL)
255
 
                    return NSD_ERROR;
256
 
            
257
 
                free_response(&response);
258
 
            
259
 
                nsd_logprintf(NSD_LOG_MIN, "    %s\n", result);
260
 
                nsd_set_result(rq, NS_SUCCESS, result, rlen, DYNAMIC);
261
 
                return NSD_OK;
262
 
            }
263
 
 
264
 
            case WINBINDD_GETGRNAM:
265
 
            case WINBINDD_GETGRGID:
266
 
            {
267
 
                const struct winbindd_gr *gr = &response.data.gr;
268
 
                const char * members;
269
 
            
270
 
                nsd_logprintf(NSD_LOG_MIN,
271
 
                        "callback (winbind) GETGRNAM | GETGRGID\n");
272
 
 
273
 
                if (gr->num_gr_mem && response.extra_data.data) {
274
 
                        members = response.extra_data.data;
275
 
                } else {
276
 
                        members = "";
277
 
                }
278
 
            
279
 
                rlen = asprintf(&result, "%s:%s:%d:%s\n",
280
 
                            gr->gr_name, gr->gr_passwd, gr->gr_gid, members);
281
 
                if (rlen == 0 || result == NULL)
282
 
                    return NSD_ERROR;
283
 
            
284
 
                free_response(&response);
285
 
            
286
 
                nsd_logprintf(NSD_LOG_MIN, "    %s\n", result);
287
 
                nsd_set_result(rq, NS_SUCCESS, result, rlen, DYNAMIC);
288
 
                return NSD_OK;
289
 
            }
290
 
 
291
 
            case WINBINDD_SETGRENT:
292
 
            case WINBINDD_SETPWENT:
293
 
                nsd_logprintf(NSD_LOG_MIN,
294
 
                        "callback (winbind) SETGRENT | SETPWENT\n");
295
 
                free_response(&response);
296
 
                return(do_list(1,rq));
297
 
 
298
 
            case WINBINDD_GETGRENT:
299
 
            case WINBINDD_GETGRLST:
300
 
            {
301
 
                int entries;
302
 
            
303
 
                nsd_logprintf(NSD_LOG_MIN,
304
 
                    "callback (winbind) GETGRENT | GETGRLIST %d responses\n",
305
 
                    response.data.num_entries);
306
 
            
307
 
                if (response.data.num_entries) {
308
 
                    const struct winbindd_gr *gr = &response.data.gr;
309
 
                    const char * members;
310
 
                    fstring grp_name;
311
 
                    int     i;
312
 
            
313
 
                    gr = (struct winbindd_gr *)response.extra_data.data;
314
 
                    if (! gr ) {
315
 
                        nsd_logprintf(NSD_LOG_MIN, "     no extra_data\n");
316
 
                        free_response(&response);
317
 
                        return NSD_ERROR;
318
 
                    }
319
 
            
320
 
                    members = (char *)response.extra_data.data +
321
 
                        (response.data.num_entries * sizeof(struct winbindd_gr));
322
 
            
323
 
                    for (i = 0; i < response.data.num_entries; i++) {
324
 
                        snprintf(grp_name, sizeof(grp_name) - 1, "%s:%s:%d:",
325
 
                                    gr->gr_name, gr->gr_passwd, gr->gr_gid);
326
 
            
327
 
                        nsd_append_element(rq, NS_SUCCESS, result, rlen);
328
 
                        nsd_append_result(rq, NS_SUCCESS,
329
 
                                &members[gr->gr_mem_ofs],
330
 
                                strlen(&members[gr->gr_mem_ofs]));
331
 
            
332
 
                        /* Don't log the whole list, because it might be
333
 
                         * _really_ long and we probably don't want to clobber
334
 
                         * the log with it.
335
 
                         */
336
 
                        nsd_logprintf(NSD_LOG_MIN, "    %s (...)\n", grp_name);
337
 
            
338
 
                        gr++;
339
 
                    }
340
 
                }
341
 
            
342
 
                entries = response.data.num_entries;
343
 
                free_response(&response);
344
 
                if (entries < MAX_GETPWENT_USERS)
345
 
                    return(do_list(2,rq));
346
 
                else
347
 
                    return(do_list(1,rq));
348
 
            }
349
 
 
350
 
            case WINBINDD_GETPWENT:
351
 
            {
352
 
                int entries;
353
 
 
354
 
                nsd_logprintf(NSD_LOG_MIN,
355
 
                        "callback (winbind) GETPWENT  %d responses\n",
356
 
                        response.data.num_entries);
357
 
 
358
 
                if (response.data.num_entries) {
359
 
                    struct winbindd_pw *pw = &response.data.pw;
360
 
                    int i;
361
 
 
362
 
                    pw = (struct winbindd_pw *)response.extra_data.data;
363
 
                    if (! pw ) {
364
 
                        nsd_logprintf(NSD_LOG_MIN, "     no extra_data\n");
365
 
                        free_response(&response);
366
 
                        return NSD_ERROR;
367
 
                    }
368
 
                    for (i = 0; i < response.data.num_entries; i++) {
369
 
                        result = NULL;
370
 
                        rlen = asprintf(&result, "%s:%s:%d:%d:%s:%s:%s",
371
 
                                        pw->pw_name,
372
 
                                        pw->pw_passwd,
373
 
                                        pw->pw_uid,
374
 
                                        pw->pw_gid,
375
 
                                        pw->pw_gecos,
376
 
                                        pw->pw_dir,
377
 
                                        pw->pw_shell);
378
 
 
379
 
                        if (rlen != 0 && result != NULL) {
380
 
                            nsd_logprintf(NSD_LOG_MIN, "    %s\n",result);
381
 
                            nsd_append_element(rq, NS_SUCCESS, result, rlen);
382
 
                            free(result);
383
 
                        }
384
 
 
385
 
                        pw++;
386
 
                    }
387
 
                }
388
 
 
389
 
                entries = response.data.num_entries;
390
 
                free_response(&response);
391
 
                if (entries < MAX_GETPWENT_USERS)
392
 
                    return(do_list(2,rq));
393
 
                else
394
 
                    return(do_list(1,rq));
395
 
            }
396
 
 
397
 
            case WINBINDD_ENDGRENT:
398
 
            case WINBINDD_ENDPWENT:
399
 
                nsd_logprintf(NSD_LOG_MIN, "callback (winbind) ENDGRENT | ENDPWENT\n");
400
 
                nsd_append_element(rq, NS_SUCCESS, "\n", 1);
401
 
                free_response(&response);
402
 
                return NSD_NEXT;
403
 
 
404
 
            default:
405
 
                free_response(&response);
406
 
                nsd_logprintf(NSD_LOG_MIN, "callback (winbind) invalid command %d\n", (int)rq->f_cmd_data);
407
 
                return NSD_NEXT;
408
 
        }
409
 
}
410
 
 
411
 
static int 
412
 
winbind_timeout(nsd_file_t **rqp, nsd_times_t *to)
413
 
{
414
 
        nsd_file_t *rq;
415
 
 
416
 
        dequeue_request();
417
 
 
418
 
        nsd_logprintf(NSD_LOG_MIN, "timeout (winbind)\n");
419
 
 
420
 
        rq = to->t_file;
421
 
        *rqp = rq;
422
 
 
423
 
        /* Remove the callback and timeout */
424
 
        nsd_callback_remove(winbindd_fd);
425
 
        nsd_timeout_remove(rq);
426
 
 
427
 
        rq->f_status = NS_NOTFOUND;
428
 
        return NSD_NEXT;
429
 
}
430
 
 
431
 
static int
432
 
send_next_request(nsd_file_t *rq, struct winbindd_request *request)
433
 
{
434
 
        NSS_STATUS status;
435
 
        long timeout;
436
 
 
437
 
        switch (rq->f_index) {
438
 
                case LOOKUP:
439
 
                        timeout = nsd_attr_fetch_long(rq->f_attrs,
440
 
                                        "lookup_timeout", 10, 10);
441
 
                        break;
442
 
                case LIST:
443
 
                        timeout = nsd_attr_fetch_long(rq->f_attrs,
444
 
                                        "list_timeout", 10, 10);
445
 
                        break;
446
 
                default:
447
 
                        nsd_logprintf(NSD_LOG_OPER,
448
 
                                "send_next_request (winbind) "
449
 
                                "invalid request type %d\n", rq->f_index);
450
 
                        rq->f_status = NS_BADREQ;
451
 
                        return NSD_NEXT;
452
 
        }
453
 
 
454
 
        nsd_logprintf(NSD_LOG_MIN,
455
 
                "send_next_request (winbind) %d, timeout = %d sec\n",
456
 
                        rq->f_cmd_data, timeout);
457
 
        status = winbindd_send_request((int)rq->f_cmd_data,request);
458
 
        SAFE_FREE(request);
459
 
 
460
 
        if (status != NSS_STATUS_SUCCESS) {
461
 
                nsd_logprintf(NSD_LOG_MIN, 
462
 
                        "send_next_request (winbind) error status = %d\n",
463
 
                        status);
464
 
                rq->f_status = status;
465
 
                return NSD_NEXT;
466
 
        }
467
 
 
468
 
        current_rq = rq;
469
 
 
470
 
        /*
471
 
         * Set up callback and timeouts
472
 
         */
473
 
        nsd_logprintf(NSD_LOG_MIN, "send_next_request (winbind) fd = %d\n",
474
 
                winbindd_fd);
475
 
 
476
 
        nsd_callback_new(winbindd_fd, winbind_callback, NSD_READ);
477
 
        nsd_timeout_new(rq, timeout * 1000, winbind_timeout, NULL);
478
 
        return NSD_CONTINUE;
479
 
}
480
 
 
481
 
int init(void)
482
 
{
483
 
        nsd_logprintf(NSD_LOG_MIN, "entering init (winbind)\n");
484
 
        return(NSD_OK);
485
 
}
486
 
 
487
 
int lookup(nsd_file_t *rq)
488
 
{
489
 
        char *map;
490
 
        char *key;
491
 
        struct winbindd_request *request;
492
 
 
493
 
        nsd_logprintf(NSD_LOG_MIN, "entering lookup (winbind)\n");
494
 
        if (! rq)
495
 
                return NSD_ERROR;
496
 
 
497
 
        map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
498
 
        key = nsd_attr_fetch_string(rq->f_attrs, "key", (char*)0);
499
 
        if (! map || ! key) {
500
 
                nsd_logprintf(NSD_LOG_MIN, "lookup (winbind) table or key not defined\n");
501
 
                rq->f_status = NS_BADREQ;
502
 
                return NSD_ERROR;
503
 
        }
504
 
 
505
 
        nsd_logprintf(NSD_LOG_MIN, "lookup (winbind %s)\n",map);
506
 
 
507
 
        request = (struct winbindd_request *)nsd_calloc(1,sizeof(struct winbindd_request));
508
 
        if (! request) {
509
 
                nsd_logprintf(NSD_LOG_RESOURCE,
510
 
                        "lookup (winbind): failed malloc\n");
511
 
                return NSD_ERROR;
512
 
        }
513
 
 
514
 
        if (strcasecmp(map,"passwd.byuid") == 0) {
515
 
            request->data.uid = atoi(key);
516
 
            rq->f_cmd_data = (void *)WINBINDD_GETPWUID;
517
 
        } else if (strcasecmp(map,"passwd.byname") == 0) {
518
 
            strncpy(request->data.username, key, 
519
 
                sizeof(request->data.username) - 1);
520
 
            request->data.username[sizeof(request->data.username) - 1] = '\0';
521
 
            rq->f_cmd_data = (void *)WINBINDD_GETPWNAM; 
522
 
        } else if (strcasecmp(map,"group.byname") == 0) {
523
 
            strncpy(request->data.groupname, key, 
524
 
                sizeof(request->data.groupname) - 1);
525
 
            request->data.groupname[sizeof(request->data.groupname) - 1] = '\0';
526
 
            rq->f_cmd_data = (void *)WINBINDD_GETGRNAM; 
527
 
        } else if (strcasecmp(map,"group.bygid") == 0) {
528
 
            request->data.gid = atoi(key);
529
 
            rq->f_cmd_data = (void *)WINBINDD_GETGRGID;
530
 
        } else if (strcasecmp(map,"hosts.byname") == 0) {
531
 
            strncpy(request->data.winsreq, key, sizeof(request->data.winsreq) - 1);
532
 
            request->data.winsreq[sizeof(request->data.winsreq) - 1] = '\0';
533
 
            rq->f_cmd_data = (void *)WINBINDD_WINS_BYNAME;
534
 
        } else if (strcasecmp(map,"hosts.byaddr") == 0) {
535
 
            strncpy(request->data.winsreq, key, sizeof(request->data.winsreq) - 1);
536
 
            request->data.winsreq[sizeof(request->data.winsreq) - 1] = '\0';
537
 
            rq->f_cmd_data = (void *)WINBINDD_WINS_BYIP;
538
 
        } else {
539
 
                /*
540
 
                 * Don't understand this map - just return not found
541
 
                 */
542
 
                nsd_logprintf(NSD_LOG_MIN, "lookup (winbind) unknown table\n");
543
 
                SAFE_FREE(request);
544
 
                rq->f_status = NS_NOTFOUND;
545
 
                return NSD_NEXT;
546
 
        }
547
 
 
548
 
        return(do_request(rq, request));
549
 
}
550
 
 
551
 
int list(nsd_file_t *rq)
552
 
{
553
 
        char *map;
554
 
 
555
 
        nsd_logprintf(NSD_LOG_MIN, "entering list (winbind)\n");
556
 
        if (! rq)
557
 
                return NSD_ERROR;
558
 
 
559
 
        map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
560
 
        if (! map ) {
561
 
                nsd_logprintf(NSD_LOG_MIN, "list (winbind) table not defined\n");
562
 
                rq->f_status = NS_BADREQ;
563
 
                return NSD_ERROR;
564
 
        }
565
 
 
566
 
        nsd_logprintf(NSD_LOG_MIN, "list (winbind %s)\n",map);
567
 
 
568
 
        return (do_list(0,rq));
569
 
}
570
 
 
571
 
static int
572
 
do_list(int state, nsd_file_t *rq)
573
 
{
574
 
        char *map;
575
 
        struct winbindd_request *request;
576
 
 
577
 
        nsd_logprintf(NSD_LOG_MIN, "entering do_list (winbind) state = %d\n",state);
578
 
 
579
 
        map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
580
 
        request = (struct winbindd_request *)nsd_calloc(1,sizeof(struct winbindd_request));
581
 
        if (! request) {
582
 
                nsd_logprintf(NSD_LOG_RESOURCE,
583
 
                        "do_list (winbind): failed malloc\n");
584
 
                return NSD_ERROR;
585
 
        }
586
 
 
587
 
        if (strcasecmp(map,"passwd.byname") == 0) {
588
 
            switch (state) {
589
 
                case 0:
590
 
                    rq->f_cmd_data = (void *)WINBINDD_SETPWENT;
591
 
                    break;
592
 
                case 1:
593
 
                    request->data.num_entries = MAX_GETPWENT_USERS;
594
 
                    rq->f_cmd_data = (void *)WINBINDD_GETPWENT;
595
 
                    break;
596
 
                case 2:
597
 
                    rq->f_cmd_data = (void *)WINBINDD_ENDPWENT;
598
 
                    break;
599
 
                default:
600
 
                    nsd_logprintf(NSD_LOG_MIN, "do_list (winbind) unknown state\n");
601
 
                    SAFE_FREE(request);
602
 
                    rq->f_status = NS_NOTFOUND;
603
 
                    return NSD_NEXT;
604
 
            }
605
 
        } else if (strcasecmp(map,"group.byname") == 0) {
606
 
            switch (state) {
607
 
                case 0:
608
 
                    rq->f_cmd_data = (void *)WINBINDD_SETGRENT;
609
 
                    break;
610
 
                case 1:
611
 
                    request->data.num_entries = MAX_GETGRENT_USERS;
612
 
                    rq->f_cmd_data = (void *)WINBINDD_GETGRENT;
613
 
                    break;
614
 
                case 2:
615
 
                    rq->f_cmd_data = (void *)WINBINDD_ENDGRENT;
616
 
                    break;
617
 
                default:
618
 
                    nsd_logprintf(NSD_LOG_MIN, "do_list (winbind) unknown state\n");
619
 
                    SAFE_FREE(request);
620
 
                    rq->f_status = NS_NOTFOUND;
621
 
                    return NSD_NEXT;
622
 
            }
623
 
        } else {
624
 
                /*
625
 
                 * Don't understand this map - just return not found
626
 
                 */
627
 
                nsd_logprintf(NSD_LOG_MIN, "do_list (winbind) unknown table\n");
628
 
                SAFE_FREE(request);
629
 
                rq->f_status = NS_NOTFOUND;
630
 
                return NSD_NEXT;
631
 
        }
632
 
 
633
 
        return(do_request(rq, request));
634
 
}
635
 
 
636
 
#endif /* HAVE_NS_API_H */