source: vendor/current/source3/lib/winbind_util.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 10.5 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Winbind Utility functions
4
5 Copyright (C) Gerald (Jerry) Carter 2007
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22#include "../libcli/security/security.h"
23#include "../lib/util/util_pw.h"
24#include "nsswitch/libwbclient/wbclient.h"
25
26#if defined(WITH_WINBIND)
27
28#include "lib/winbind_util.h"
29
30struct passwd * winbind_getpwnam(const char * name)
31{
32 wbcErr result;
33 struct passwd * tmp_pwd = NULL;
34 struct passwd * pwd = NULL;
35
36 result = wbcGetpwnam(name, &tmp_pwd);
37 if (result != WBC_ERR_SUCCESS)
38 return pwd;
39
40 pwd = tcopy_passwd(talloc_tos(), tmp_pwd);
41
42 wbcFreeMemory(tmp_pwd);
43
44 return pwd;
45}
46
47struct passwd * winbind_getpwsid(const struct dom_sid *sid)
48{
49 wbcErr result;
50 struct passwd * tmp_pwd = NULL;
51 struct passwd * pwd = NULL;
52 struct wbcDomainSid dom_sid;
53
54 memcpy(&dom_sid, sid, sizeof(dom_sid));
55
56 result = wbcGetpwsid(&dom_sid, &tmp_pwd);
57 if (result != WBC_ERR_SUCCESS)
58 return pwd;
59
60 pwd = tcopy_passwd(talloc_tos(), tmp_pwd);
61
62 wbcFreeMemory(tmp_pwd);
63
64 return pwd;
65}
66
67/* Call winbindd to convert a name to a sid */
68
69bool winbind_lookup_name(const char *dom_name, const char *name, struct dom_sid *sid,
70 enum lsa_SidType *name_type)
71{
72 struct wbcDomainSid dom_sid;
73 wbcErr result;
74 enum wbcSidType type;
75
76 result = wbcLookupName(dom_name, name, &dom_sid, &type);
77 if (result != WBC_ERR_SUCCESS)
78 return false;
79
80 memcpy(sid, &dom_sid, sizeof(struct dom_sid));
81 *name_type = (enum lsa_SidType)type;
82
83 return true;
84}
85
86/* Call winbindd to convert sid to name */
87
88bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
89 const char **domain, const char **name,
90 enum lsa_SidType *name_type)
91{
92 struct wbcDomainSid dom_sid;
93 wbcErr result;
94 enum wbcSidType type;
95 char *domain_name = NULL;
96 char *account_name = NULL;
97
98 memcpy(&dom_sid, sid, sizeof(dom_sid));
99
100 result = wbcLookupSid(&dom_sid, &domain_name, &account_name, &type);
101 if (result != WBC_ERR_SUCCESS)
102 return false;
103
104 /* Copy out result */
105
106 if (domain) {
107 *domain = talloc_strdup(mem_ctx, domain_name);
108 }
109 if (name) {
110 *name = talloc_strdup(mem_ctx, account_name);
111 }
112 *name_type = (enum lsa_SidType)type;
113
114 DEBUG(10, ("winbind_lookup_sid: SUCCESS: SID %s -> %s %s\n",
115 sid_string_dbg(sid), domain_name, account_name));
116
117 wbcFreeMemory(domain_name);
118 wbcFreeMemory(account_name);
119
120 if ((domain && !*domain) || (name && !*name)) {
121 DEBUG(0,("winbind_lookup_sid: talloc() failed!\n"));
122 return false;
123 }
124
125
126 return true;
127}
128
129/* Ping winbindd to see it is alive */
130
131bool winbind_ping(void)
132{
133 wbcErr result = wbcPing();
134
135 return (result == WBC_ERR_SUCCESS);
136}
137
138/* Call winbindd to convert SID to uid */
139
140bool winbind_sid_to_uid(uid_t *puid, const struct dom_sid *sid)
141{
142 struct wbcDomainSid dom_sid;
143 wbcErr result;
144
145 memcpy(&dom_sid, sid, sizeof(dom_sid));
146
147 result = wbcSidToUid(&dom_sid, puid);
148
149 return (result == WBC_ERR_SUCCESS);
150}
151
152/* Call winbindd to convert uid to sid */
153
154bool winbind_uid_to_sid(struct dom_sid *sid, uid_t uid)
155{
156 struct wbcDomainSid dom_sid;
157 wbcErr result;
158
159 result = wbcUidToSid(uid, &dom_sid);
160 if (result == WBC_ERR_SUCCESS) {
161 memcpy(sid, &dom_sid, sizeof(struct dom_sid));
162 } else {
163 sid_copy(sid, &global_sid_NULL);
164 }
165
166 return (result == WBC_ERR_SUCCESS);
167}
168
169/* Call winbindd to convert SID to gid */
170
171bool winbind_sid_to_gid(gid_t *pgid, const struct dom_sid *sid)
172{
173 struct wbcDomainSid dom_sid;
174 wbcErr result;
175
176 memcpy(&dom_sid, sid, sizeof(dom_sid));
177
178 result = wbcSidToGid(&dom_sid, pgid);
179
180 return (result == WBC_ERR_SUCCESS);
181}
182
183/* Call winbindd to convert gid to sid */
184
185bool winbind_gid_to_sid(struct dom_sid *sid, gid_t gid)
186{
187 struct wbcDomainSid dom_sid;
188 wbcErr result;
189
190 result = wbcGidToSid(gid, &dom_sid);
191 if (result == WBC_ERR_SUCCESS) {
192 memcpy(sid, &dom_sid, sizeof(struct dom_sid));
193 } else {
194 sid_copy(sid, &global_sid_NULL);
195 }
196
197 return (result == WBC_ERR_SUCCESS);
198}
199
200/* Check for a trusted domain */
201
202wbcErr wb_is_trusted_domain(const char *domain)
203{
204 wbcErr result;
205 struct wbcDomainInfo *info = NULL;
206
207 result = wbcDomainInfo(domain, &info);
208
209 if (WBC_ERROR_IS_OK(result)) {
210 wbcFreeMemory(info);
211 }
212
213 return result;
214}
215
216/* Lookup a set of rids in a given domain */
217
218bool winbind_lookup_rids(TALLOC_CTX *mem_ctx,
219 const struct dom_sid *domain_sid,
220 int num_rids, uint32_t *rids,
221 const char **domain_name,
222 const char ***names, enum lsa_SidType **types)
223{
224 const char *dom_name = NULL;
225 const char **namelist = NULL;
226 enum wbcSidType *name_types = NULL;
227 struct wbcDomainSid dom_sid;
228 wbcErr ret;
229 int i;
230
231 memcpy(&dom_sid, domain_sid, sizeof(struct wbcDomainSid));
232
233 ret = wbcLookupRids(&dom_sid, num_rids, rids,
234 &dom_name, &namelist, &name_types);
235 if (ret != WBC_ERR_SUCCESS) {
236 return false;
237 }
238
239 *domain_name = talloc_strdup(mem_ctx, dom_name);
240 *names = talloc_array(mem_ctx, const char*, num_rids);
241 *types = talloc_array(mem_ctx, enum lsa_SidType, num_rids);
242
243 for(i=0; i<num_rids; i++) {
244 (*names)[i] = talloc_strdup(*names, namelist[i]);
245 (*types)[i] = (enum lsa_SidType)name_types[i];
246 }
247
248 wbcFreeMemory(discard_const_p(char, dom_name));
249 wbcFreeMemory(namelist);
250 wbcFreeMemory(name_types);
251
252 return true;
253}
254
255/* Ask Winbind to allocate a new uid for us */
256
257bool winbind_allocate_uid(uid_t *uid)
258{
259 wbcErr ret;
260
261 ret = wbcAllocateUid(uid);
262
263 return (ret == WBC_ERR_SUCCESS);
264}
265
266/* Ask Winbind to allocate a new gid for us */
267
268bool winbind_allocate_gid(gid_t *gid)
269{
270 wbcErr ret;
271
272 ret = wbcAllocateGid(gid);
273
274 return (ret == WBC_ERR_SUCCESS);
275}
276
277bool winbind_get_groups(TALLOC_CTX * mem_ctx, const char *account, uint32_t *num_groups, gid_t **_groups)
278{
279 wbcErr ret;
280 uint32_t ngroups;
281 gid_t *group_list = NULL;
282
283 ret = wbcGetGroups(account, &ngroups, &group_list);
284 if (ret != WBC_ERR_SUCCESS)
285 return false;
286
287 *_groups = talloc_array(mem_ctx, gid_t, ngroups);
288 if (*_groups == NULL) {
289 wbcFreeMemory(group_list);
290 return false;
291 }
292
293 memcpy(*_groups, group_list, ngroups* sizeof(gid_t));
294 *num_groups = ngroups;
295
296 wbcFreeMemory(group_list);
297 return true;
298}
299
300bool winbind_get_sid_aliases(TALLOC_CTX *mem_ctx,
301 const struct dom_sid *dom_sid,
302 const struct dom_sid *members,
303 size_t num_members,
304 uint32_t **pp_alias_rids,
305 size_t *p_num_alias_rids)
306{
307 wbcErr ret;
308 struct wbcDomainSid domain_sid;
309 struct wbcDomainSid *sid_list = NULL;
310 size_t i;
311 uint32_t * rids;
312 uint32_t num_rids;
313
314 memcpy(&domain_sid, dom_sid, sizeof(*dom_sid));
315
316 sid_list = talloc_array(mem_ctx, struct wbcDomainSid, num_members);
317
318 for (i=0; i < num_members; i++) {
319 memcpy(&sid_list[i], &members[i], sizeof(sid_list[i]));
320 }
321
322 ret = wbcGetSidAliases(&domain_sid,
323 sid_list,
324 num_members,
325 &rids,
326 &num_rids);
327 if (ret != WBC_ERR_SUCCESS) {
328 return false;
329 }
330
331 *pp_alias_rids = talloc_array(mem_ctx, uint32_t, num_rids);
332 if (*pp_alias_rids == NULL) {
333 wbcFreeMemory(rids);
334 return false;
335 }
336
337 memcpy(*pp_alias_rids, rids, sizeof(uint32_t) * num_rids);
338
339 *p_num_alias_rids = num_rids;
340 wbcFreeMemory(rids);
341
342 return true;
343}
344
345bool winbind_lookup_usersids(TALLOC_CTX *mem_ctx,
346 const struct dom_sid *user_sid,
347 uint32_t *p_num_sids,
348 struct dom_sid **p_sids)
349{
350 wbcErr ret;
351 struct wbcDomainSid dom_sid;
352 struct wbcDomainSid *sid_list = NULL;
353 uint32_t num_sids;
354
355 memcpy(&dom_sid, user_sid, sizeof(dom_sid));
356
357 ret = wbcLookupUserSids(&dom_sid,
358 false,
359 &num_sids,
360 &sid_list);
361 if (ret != WBC_ERR_SUCCESS) {
362 return false;
363 }
364
365 *p_sids = talloc_array(mem_ctx, struct dom_sid, num_sids);
366 if (*p_sids == NULL) {
367 wbcFreeMemory(sid_list);
368 return false;
369 }
370
371 memcpy(*p_sids, sid_list, sizeof(dom_sid) * num_sids);
372
373 *p_num_sids = num_sids;
374 wbcFreeMemory(sid_list);
375
376 return true;
377}
378
379#else /* WITH_WINBIND */
380
381struct passwd * winbind_getpwnam(const char * name)
382{
383 return NULL;
384}
385
386struct passwd * winbind_getpwsid(const struct dom_sid *sid)
387{
388 return NULL;
389}
390
391bool winbind_lookup_name(const char *dom_name, const char *name, struct dom_sid *sid,
392 enum lsa_SidType *name_type)
393{
394 return false;
395}
396
397/* Call winbindd to convert sid to name */
398
399bool winbind_lookup_sid(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
400 const char **domain, const char **name,
401 enum lsa_SidType *name_type)
402{
403 return false;
404}
405
406/* Ping winbindd to see it is alive */
407
408bool winbind_ping(void)
409{
410 return false;
411}
412
413/* Call winbindd to convert SID to uid */
414
415bool winbind_sid_to_uid(uid_t *puid, const struct dom_sid *sid)
416{
417 return false;
418}
419
420/* Call winbindd to convert uid to sid */
421
422bool winbind_uid_to_sid(struct dom_sid *sid, uid_t uid)
423{
424 return false;
425}
426
427/* Call winbindd to convert SID to gid */
428
429bool winbind_sid_to_gid(gid_t *pgid, const struct dom_sid *sid)
430{
431 return false;
432}
433
434/* Call winbindd to convert gid to sid */
435
436bool winbind_gid_to_sid(struct dom_sid *sid, gid_t gid)
437{
438 return false;
439}
440
441/* Check for a trusted domain */
442
443wbcErr wb_is_trusted_domain(const char *domain)
444{
445 return WBC_ERR_UNKNOWN_FAILURE;
446}
447
448/* Lookup a set of rids in a given domain */
449
450bool winbind_lookup_rids(TALLOC_CTX *mem_ctx,
451 const struct dom_sid *domain_sid,
452 int num_rids, uint32_t *rids,
453 const char **domain_name,
454 const char ***names, enum lsa_SidType **types)
455{
456 return false;
457}
458
459/* Ask Winbind to allocate a new uid for us */
460
461bool winbind_allocate_uid(uid_t *uid)
462{
463 return false;
464}
465
466/* Ask Winbind to allocate a new gid for us */
467
468bool winbind_allocate_gid(gid_t *gid)
469{
470 return false;
471}
472
473bool winbind_get_groups(TALLOC_CTX *mem_ctx, const char *account, uint32_t *num_groups, gid_t **_groups)
474{
475 return false;
476}
477
478bool winbind_get_sid_aliases(TALLOC_CTX *mem_ctx,
479 const struct dom_sid *dom_sid,
480 const struct dom_sid *members,
481 size_t num_members,
482 uint32_t **pp_alias_rids,
483 size_t *p_num_alias_rids)
484{
485 return false;
486}
487
488bool winbind_lookup_usersids(TALLOC_CTX *mem_ctx,
489 const struct dom_sid *user_sid,
490 uint32_t *p_num_sids,
491 struct dom_sid **p_sids)
492{
493 return false;
494}
495
496#endif /* WITH_WINBIND */
Note: See TracBrowser for help on using the repository browser.