← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

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