?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libwbclient: Make wbcLookupRids not use talloc
[Samba/ekacnet.git] / nsswitch / libwbclient / wbc_sid.c
bloba2ed5e1d3f3a1455562e0feec7ea5bf3771ce6be
1 /*
2 Unix SMB/CIFS implementation.
3
4 Winbind client API
5
6 Copyright (C) Gerald (Jerry) Carter 2007
7 Copyright (C) Volker Lendecke 2010
8
9
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
14
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Library General Public License for more details.
19
20 You should have received a copy of the GNU Lesser General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 /* Required Headers */
25
26 #include "replace.h"
27 #include "libwbclient.h"
28 #include "../winbind_client.h"
29
30 /* Convert a binary SID to a character string */
31 wbcErr wbcSidToString(const struct wbcDomainSid *sid,
32 char **sid_string)
33 {
34 uint32_t id_auth;
35 int i, ofs, maxlen;
36 char *result;
37
38 if (!sid) {
39 return WBC_ERR_INVALID_SID;
40 }
41
42 maxlen = sid->num_auths * 11 + 25;
43
44 result = (char *)wbcAllocateMemory(maxlen, 1, NULL);
45 if (result == NULL) {
46 return WBC_ERR_NO_MEMORY;
47 }
48
49 /*
50 * BIG NOTE: this function only does SIDS where the identauth is not
51 * >= ^32 in a range of 2^48.
52 */
53
54 id_auth = sid->id_auth[5] +
55 (sid->id_auth[4] << 8) +
56 (sid->id_auth[3] << 16) +
57 (sid->id_auth[2] << 24);
58
59 ofs = snprintf(result, maxlen, "S-%u-%lu",
60 (unsigned int)sid->sid_rev_num, (unsigned long)id_auth);
61
62 for (i = 0; i < sid->num_auths; i++) {
63 ofs += snprintf(result + ofs, maxlen - ofs, "-%lu",
64 (unsigned long)sid->sub_auths[i]);
65 }
66
67 *sid_string = result;
68 return WBC_ERR_SUCCESS;
69 }
70
71 /* Convert a character string to a binary SID */
72 wbcErr wbcStringToSid(const char *str,
73 struct wbcDomainSid *sid)
74 {
75 const char *p;
76 char *q;
77 uint32_t x;
78 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
79
80 if (!sid) {
81 wbc_status = WBC_ERR_INVALID_PARAM;
82 BAIL_ON_WBC_ERROR(wbc_status);
83 }
84
85 /* Sanity check for either "S-" or "s-" */
86
87 if (!str
88 || (str[0]!='S' && str[0]!='s')
89 || (str[1]!='-'))
90 {
91 wbc_status = WBC_ERR_INVALID_PARAM;
92 BAIL_ON_WBC_ERROR(wbc_status);
93 }
94
95 /* Get the SID revision number */
96
97 p = str+2;
98 x = (uint32_t)strtol(p, &q, 10);
99 if (x==0 || !q || *q!='-') {
100 wbc_status = WBC_ERR_INVALID_SID;
101 BAIL_ON_WBC_ERROR(wbc_status);
102 }
103 sid->sid_rev_num = (uint8_t)x;
104
105 /* Next the Identifier Authority. This is stored in big-endian
106 in a 6 byte array. */
107
108 p = q+1;
109 x = (uint32_t)strtol(p, &q, 10);
110 if (!q || *q!='-') {
111 wbc_status = WBC_ERR_INVALID_SID;
112 BAIL_ON_WBC_ERROR(wbc_status);
113 }
114 sid->id_auth[5] = (x & 0x000000ff);
115 sid->id_auth[4] = (x & 0x0000ff00) >> 8;
116 sid->id_auth[3] = (x & 0x00ff0000) >> 16;
117 sid->id_auth[2] = (x & 0xff000000) >> 24;
118 sid->id_auth[1] = 0;
119 sid->id_auth[0] = 0;
120
121 /* now read the the subauthorities */
122
123 p = q +1;
124 sid->num_auths = 0;
125 while (sid->num_auths < WBC_MAXSUBAUTHS) {
126 x=(uint32_t)strtoul(p, &q, 10);
127 if (p == q)
128 break;
129 if (q == NULL) {
130 wbc_status = WBC_ERR_INVALID_SID;
131 BAIL_ON_WBC_ERROR(wbc_status);
132 }
133 sid->sub_auths[sid->num_auths++] = x;
134
135 if ((*q!='-') || (*q=='\0'))
136 break;
137 p = q + 1;
138 }
139
140 /* IF we ended early, then the SID could not be converted */
141
142 if (q && *q!='\0') {
143 wbc_status = WBC_ERR_INVALID_SID;
144 BAIL_ON_WBC_ERROR(wbc_status);
145 }
146
147 wbc_status = WBC_ERR_SUCCESS;
148
149 done:
150 return wbc_status;
151
152 }
153
154
155 /* Convert a domain and name to SID */
156 wbcErr wbcLookupName(const char *domain,
157 const char *name,
158 struct wbcDomainSid *sid,
159 enum wbcSidType *name_type)
160 {
161 struct winbindd_request request;
162 struct winbindd_response response;
163 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
164
165 if (!sid || !name_type) {
166 wbc_status = WBC_ERR_INVALID_PARAM;
167 BAIL_ON_WBC_ERROR(wbc_status);
168 }
169
170 /* Initialize request */
171
172 ZERO_STRUCT(request);
173 ZERO_STRUCT(response);
174
175 /* dst is already null terminated from the memset above */
176
177 strncpy(request.data.name.dom_name, domain,
178 sizeof(request.data.name.dom_name)-1);
179 strncpy(request.data.name.name, name,
180 sizeof(request.data.name.name)-1);
181
182 wbc_status = wbcRequestResponse(WINBINDD_LOOKUPNAME,
183 &request,
184 &response);
185 BAIL_ON_WBC_ERROR(wbc_status);
186
187 wbc_status = wbcStringToSid(response.data.sid.sid, sid);
188 BAIL_ON_WBC_ERROR(wbc_status);
189
190 *name_type = (enum wbcSidType)response.data.sid.type;
191
192 wbc_status = WBC_ERR_SUCCESS;
193
194 done:
195 return wbc_status;
196 }
197
198
199 /* Convert a SID to a domain and name */
200 wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
201 char **pdomain,
202 char **pname,
203 enum wbcSidType *pname_type)
204 {
205 struct winbindd_request request;
206 struct winbindd_response response;
207 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
208 char *sid_string = NULL;
209 char *domain, *name;
210
211 if (!sid) {
212 return WBC_ERR_INVALID_PARAM;
213 }
214
215 /* Initialize request */
216
217 ZERO_STRUCT(request);
218 ZERO_STRUCT(response);
219
220 /* dst is already null terminated from the memset above */
221
222 wbc_status = wbcSidToString(sid, &sid_string);
223 if (!WBC_ERROR_IS_OK(wbc_status)) {
224 return wbc_status;
225 }
226
227 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
228 wbcFreeMemory(sid_string);
229
230 /* Make request */
231
232 wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSID, &request,
233 &response);
234 if (!WBC_ERROR_IS_OK(wbc_status)) {
235 return wbc_status;
236 }
237
238 /* Copy out result */
239
240 wbc_status = WBC_ERR_NO_MEMORY;
241 domain = NULL;
242 name = NULL;
243
244 domain = wbcStrDup(response.data.name.dom_name);
245 if (domain == NULL) {
246 goto done;
247 }
248 name = wbcStrDup(response.data.name.name);
249 if (name == NULL) {
250 goto done;
251 }
252 if (pdomain != NULL) {
253 *pdomain = domain;
254 domain = NULL;
255 }
256 if (pname != NULL) {
257 *pname = name;
258 name = NULL;
259 }
260 if (pname_type != NULL) {
261 *pname_type = (enum wbcSidType)response.data.name.type;
262 }
263 wbc_status = WBC_ERR_SUCCESS;
264 done:
265 wbcFreeMemory(name);
266 wbcFreeMemory(domain);
267 return wbc_status;
268 }
269
270 /* Translate a collection of RIDs within a domain to names */
271
272 wbcErr wbcLookupRids(struct wbcDomainSid *dom_sid,
273 int num_rids,
274 uint32_t *rids,
275 const char **pp_domain_name,
276 const char ***pnames,
277 enum wbcSidType **ptypes)
278 {
279 size_t i, len, ridbuf_size;
280 char *ridlist;
281 char *p;
282 struct winbindd_request request;
283 struct winbindd_response response;
284 char *sid_string = NULL;
285 char *domain_name = NULL;
286 const char **names = NULL;
287 enum wbcSidType *types = NULL;
288 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
289
290 /* Initialise request */
291
292 ZERO_STRUCT(request);
293 ZERO_STRUCT(response);
294
295 if (!dom_sid || (num_rids == 0)) {
296 wbc_status = WBC_ERR_INVALID_PARAM;
297 BAIL_ON_WBC_ERROR(wbc_status);
298 }
299
300 wbc_status = wbcSidToString(dom_sid, &sid_string);
301 BAIL_ON_WBC_ERROR(wbc_status);
302
303 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
304 wbcFreeMemory(sid_string);
305
306 /* Even if all the Rids were of maximum 32bit values,
307 we would only have 11 bytes per rid in the final array
308 ("4294967296" + \n). Add one more byte for the
309 terminating '\0' */
310
311 ridbuf_size = (sizeof(char)*11) * num_rids + 1;
312
313 ridlist = (char *)malloc(ridbuf_size);
314 BAIL_ON_PTR_ERROR(ridlist, wbc_status);
315
316 len = 0;
317 for (i=0; i<num_rids; i++) {
318 len += snprintf(ridlist + len, ridbuf_size - len, "%u\n",
319 rids[i]);
320 }
321 ridlist[len] = '\0';
322 len += 1;
323
324 request.extra_data.data = ridlist;
325 request.extra_len = len;
326
327 wbc_status = wbcRequestResponse(WINBINDD_LOOKUPRIDS,
328 &request,
329 &response);
330 free(ridlist);
331 BAIL_ON_WBC_ERROR(wbc_status);
332
333 domain_name = wbcStrDup(response.data.domain_name);
334 BAIL_ON_PTR_ERROR(domain_name, wbc_status);
335
336 names = wbcAllocateStringArray(num_rids);
337 BAIL_ON_PTR_ERROR(names, wbc_status);
338
339 types = (enum wbcSidType *)wbcAllocateMemory(
340 num_rids, sizeof(enum wbcSidType), NULL);
341 BAIL_ON_PTR_ERROR(types, wbc_status);
342
343 p = (char *)response.extra_data.data;
344
345 for (i=0; i<num_rids; i++) {
346 char *q;
347
348 if (*p == '\0') {
349 wbc_status = WBC_ERR_INVALID_RESPONSE;
350 BAIL_ON_WBC_ERROR(wbc_status);
351 }
352
353 types[i] = (enum wbcSidType)strtoul(p, &q, 10);
354
355 if (*q != ' ') {
356 wbc_status = WBC_ERR_INVALID_RESPONSE;
357 BAIL_ON_WBC_ERROR(wbc_status);
358 }
359
360 p = q+1;
361
362 if ((q = strchr(p, '\n')) == NULL) {
363 wbc_status = WBC_ERR_INVALID_RESPONSE;
364 BAIL_ON_WBC_ERROR(wbc_status);
365 }
366
367 *q = '\0';
368
369 names[i] = strdup(p);
370 BAIL_ON_PTR_ERROR(names[i], wbc_status);
371
372 p = q+1;
373 }
374
375 if (*p != '\0') {
376 wbc_status = WBC_ERR_INVALID_RESPONSE;
377 BAIL_ON_WBC_ERROR(wbc_status);
378 }
379
380 wbc_status = WBC_ERR_SUCCESS;
381
382 done:
383 winbindd_free_response(&response);
384
385 if (WBC_ERROR_IS_OK(wbc_status)) {
386 *pp_domain_name = domain_name;
387 *pnames = names;
388 *ptypes = types;
389 }
390 else {
391 wbcFreeMemory(domain_name);
392 wbcFreeMemory(names);
393 wbcFreeMemory(types);
394 }
395
396 return wbc_status;
397 }
398
399 /* Get the groups a user belongs to */
400 wbcErr wbcLookupUserSids(const struct wbcDomainSid *user_sid,
401 bool domain_groups_only,
402 uint32_t *num_sids,
403 struct wbcDomainSid **_sids)
404 {
405 uint32_t i;
406 const char *s;
407 struct winbindd_request request;
408 struct winbindd_response response;
409 char *sid_string = NULL;
410 struct wbcDomainSid *sids = NULL;
411 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
412 int cmd;
413
414 /* Initialise request */
415
416 ZERO_STRUCT(request);
417 ZERO_STRUCT(response);
418
419 if (!user_sid) {
420 wbc_status = WBC_ERR_INVALID_PARAM;
421 BAIL_ON_WBC_ERROR(wbc_status);
422 }
423
424 wbc_status = wbcSidToString(user_sid, &sid_string);
425 BAIL_ON_WBC_ERROR(wbc_status);
426
427 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
428 wbcFreeMemory(sid_string);
429
430 if (domain_groups_only) {
431 cmd = WINBINDD_GETUSERDOMGROUPS;
432 } else {
433 cmd = WINBINDD_GETUSERSIDS;
434 }
435
436 wbc_status = wbcRequestResponse(cmd,
437 &request,
438 &response);
439 BAIL_ON_WBC_ERROR(wbc_status);
440
441 if (response.data.num_entries &&
442 !response.extra_data.data) {
443 wbc_status = WBC_ERR_INVALID_RESPONSE;
444 BAIL_ON_WBC_ERROR(wbc_status);
445 }
446
447 sids = talloc_array(NULL, struct wbcDomainSid,
448 response.data.num_entries);
449 BAIL_ON_PTR_ERROR(sids, wbc_status);
450
451 s = (const char *)response.extra_data.data;
452 for (i = 0; i < response.data.num_entries; i++) {
453 char *n = strchr(s, '\n');
454 if (n) {
455 *n = '\0';
456 }
457 wbc_status = wbcStringToSid(s, &sids[i]);
458 BAIL_ON_WBC_ERROR(wbc_status);
459 s += strlen(s) + 1;
460 }
461
462 *num_sids = response.data.num_entries;
463 *_sids = sids;
464 sids = NULL;
465 wbc_status = WBC_ERR_SUCCESS;
466
467 done:
468 winbindd_free_response(&response);
469 if (sids) {
470 talloc_free(sids);
471 }
472
473 return wbc_status;
474 }
475
476 static inline
477 wbcErr _sid_to_rid(struct wbcDomainSid *sid, uint32_t *rid)
478 {
479 if (sid->num_auths < 1) {
480 return WBC_ERR_INVALID_RESPONSE;
481 }
482 *rid = sid->sub_auths[sid->num_auths - 1];
483
484 return WBC_ERR_SUCCESS;
485 }
486
487 /* Get alias membership for sids */
488 wbcErr wbcGetSidAliases(const struct wbcDomainSid *dom_sid,
489 struct wbcDomainSid *sids,
490 uint32_t num_sids,
491 uint32_t **alias_rids,
492 uint32_t *num_alias_rids)
493 {
494 uint32_t i;
495 const char *s;
496 struct winbindd_request request;
497 struct winbindd_response response;
498 char *sid_string = NULL;
499 ssize_t sid_len;
500 ssize_t extra_data_len = 0;
501 char * extra_data = NULL;
502 ssize_t buflen = 0;
503 struct wbcDomainSid sid;
504 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
505 uint32_t * rids = NULL;
506
507 /* Initialise request */
508
509 ZERO_STRUCT(request);
510 ZERO_STRUCT(response);
511
512 if (!dom_sid) {
513 wbc_status = WBC_ERR_INVALID_PARAM;
514 BAIL_ON_WBC_ERROR(wbc_status);
515 }
516
517 wbc_status = wbcSidToString(dom_sid, &sid_string);
518 BAIL_ON_WBC_ERROR(wbc_status);
519
520 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
521 wbcFreeMemory(sid_string);
522 sid_string = NULL;
523
524 /* Lets assume each sid is around 54 characters
525 * S-1-5-AAAAAAAAAAA-BBBBBBBBBBB-CCCCCCCCCCC-DDDDDDDDDDD\n */
526 buflen = 54 * num_sids;
527 extra_data = talloc_array(NULL, char, buflen);
528 if (!extra_data) {
529 wbc_status = WBC_ERR_NO_MEMORY;
530 BAIL_ON_WBC_ERROR(wbc_status);
531 }
532
533 /* Build the sid list */
534 for (i=0; i<num_sids; i++) {
535 wbcFreeMemory(sid_string);
536 sid_string = NULL;
537 wbc_status = wbcSidToString(&sids[i], &sid_string);
538 BAIL_ON_WBC_ERROR(wbc_status);
539
540 sid_len = strlen(sid_string);
541
542 if (buflen < extra_data_len + sid_len + 2) {
543 buflen *= 2;
544 extra_data = talloc_realloc(NULL, extra_data,
545 char, buflen);
546 if (!extra_data) {
547 wbc_status = WBC_ERR_NO_MEMORY;
548 BAIL_ON_WBC_ERROR(wbc_status);
549 }
550 }
551
552 strncpy(&extra_data[extra_data_len], sid_string,
553 buflen - extra_data_len);
554 extra_data_len += sid_len;
555 extra_data[extra_data_len++] = '\n';
556 extra_data[extra_data_len] = '\0';
557 }
558 extra_data_len += 1;
559
560 request.extra_data.data = extra_data;
561 request.extra_len = extra_data_len;
562
563 wbc_status = wbcRequestResponse(WINBINDD_GETSIDALIASES,
564 &request,
565 &response);
566 BAIL_ON_WBC_ERROR(wbc_status);
567
568 if (response.data.num_entries &&
569 !response.extra_data.data) {
570 wbc_status = WBC_ERR_INVALID_RESPONSE;
571 BAIL_ON_WBC_ERROR(wbc_status);
572 }
573
574 rids = talloc_array(NULL, uint32_t,
575 response.data.num_entries);
576 BAIL_ON_PTR_ERROR(sids, wbc_status);
577
578 s = (const char *)response.extra_data.data;
579 for (i = 0; i < response.data.num_entries; i++) {
580 char *n = strchr(s, '\n');
581 if (n) {
582 *n = '\0';
583 }
584 wbc_status = wbcStringToSid(s, &sid);
585 BAIL_ON_WBC_ERROR(wbc_status);
586 wbc_status = _sid_to_rid(&sid, &rids[i]);
587 BAIL_ON_WBC_ERROR(wbc_status);
588 s += strlen(s) + 1;
589 }
590
591 *num_alias_rids = response.data.num_entries;
592 *alias_rids = rids;
593 rids = NULL;
594 wbc_status = WBC_ERR_SUCCESS;
595
596 done:
597 wbcFreeMemory(sid_string);
598 talloc_free(extra_data);
599 winbindd_free_response(&response);
600 talloc_free(rids);
601 return wbc_status;
602 }
603
604
605 /* Lists Users */
606 wbcErr wbcListUsers(const char *domain_name,
607 uint32_t *_num_users,
608 const char ***_users)
609 {
610 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
611 struct winbindd_request request;
612 struct winbindd_response response;
613 uint32_t num_users = 0;
614 const char **users = NULL;
615 const char *next;
616
617 /* Initialise request */
618
619 ZERO_STRUCT(request);
620 ZERO_STRUCT(response);
621
622 if (domain_name) {
623 strncpy(request.domain_name, domain_name,
624 sizeof(request.domain_name)-1);
625 }
626
627 wbc_status = wbcRequestResponse(WINBINDD_LIST_USERS,
628 &request,
629 &response);
630 BAIL_ON_WBC_ERROR(wbc_status);
631
632 /* Look through extra data */
633
634 next = (const char *)response.extra_data.data;
635 while (next) {
636 const char **tmp;
637 const char *current = next;
638 char *k = strchr(next, ',');
639 if (k) {
640 k[0] = '\0';
641 next = k+1;
642 } else {
643 next = NULL;
644 }
645
646 tmp = talloc_realloc(NULL, users,
647 const char *,
648 num_users+1);
649 BAIL_ON_PTR_ERROR(tmp, wbc_status);
650 users = tmp;
651
652 users[num_users] = talloc_strdup(users, current);
653 BAIL_ON_PTR_ERROR(users[num_users], wbc_status);
654
655 num_users++;
656 }
657
658 *_num_users = num_users;
659 *_users = users;
660 users = NULL;
661 wbc_status = WBC_ERR_SUCCESS;
662
663 done:
664 winbindd_free_response(&response);
665 if (users) {
666 talloc_free(users);
667 }
668 return wbc_status;
669 }
670
671 /* Lists Groups */
672 wbcErr wbcListGroups(const char *domain_name,
673 uint32_t *_num_groups,
674 const char ***_groups)
675 {
676 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
677 struct winbindd_request request;
678 struct winbindd_response response;
679 uint32_t num_groups = 0;
680 const char **groups = NULL;
681 const char *next;
682
683 /* Initialise request */
684
685 ZERO_STRUCT(request);
686 ZERO_STRUCT(response);
687
688 if (domain_name) {
689 strncpy(request.domain_name, domain_name,
690 sizeof(request.domain_name)-1);
691 }
692
693 wbc_status = wbcRequestResponse(WINBINDD_LIST_GROUPS,
694 &request,
695 &response);
696 BAIL_ON_WBC_ERROR(wbc_status);
697
698 /* Look through extra data */
699
700 next = (const char *)response.extra_data.data;
701 while (next) {
702 const char **tmp;
703 const char *current = next;
704 char *k = strchr(next, ',');
705 if (k) {
706 k[0] = '\0';
707 next = k+1;
708 } else {
709 next = NULL;
710 }
711
712 tmp = talloc_realloc(NULL, groups,
713 const char *,
714 num_groups+1);
715 BAIL_ON_PTR_ERROR(tmp, wbc_status);
716 groups = tmp;
717
718 groups[num_groups] = talloc_strdup(groups, current);
719 BAIL_ON_PTR_ERROR(groups[num_groups], wbc_status);
720
721 num_groups++;
722 }
723
724 *_num_groups = num_groups;
725 *_groups = groups;
726 groups = NULL;
727 wbc_status = WBC_ERR_SUCCESS;
728
729 done:
730 winbindd_free_response(&response);
731 if (groups) {
732 talloc_free(groups);
733 }
734 return wbc_status;
735 }
736
737 wbcErr wbcGetDisplayName(const struct wbcDomainSid *sid,
738 char **pdomain,
739 char **pfullname,
740 enum wbcSidType *pname_type)
741 {
742 wbcErr wbc_status;
743 char *domain = NULL;
744 char *name = NULL;
745 enum wbcSidType name_type;
746
747 wbc_status = wbcLookupSid(sid, &domain, &name, &name_type);
748 BAIL_ON_WBC_ERROR(wbc_status);
749
750 if (name_type == WBC_SID_NAME_USER) {
751 uid_t uid;
752 struct passwd *pwd;
753
754 wbc_status = wbcSidToUid(sid, &uid);
755 BAIL_ON_WBC_ERROR(wbc_status);
756
757 wbc_status = wbcGetpwuid(uid, &pwd);
758 BAIL_ON_WBC_ERROR(wbc_status);
759
760 wbcFreeMemory(name);
761
762 name = talloc_strdup(NULL, pwd->pw_gecos);
763 BAIL_ON_PTR_ERROR(name, wbc_status);
764 wbcFreeMemory(pwd);
765 }
766
767 wbc_status = WBC_ERR_SUCCESS;
768
769 done:
770 if (WBC_ERROR_IS_OK(wbc_status)) {
771 *pdomain = domain;
772 *pfullname = name;
773 *pname_type = name_type;
774 } else {
775 wbcFreeMemory(domain);
776 wbcFreeMemory(name);
777 }
778
779 return wbc_status;
780 }
781
782 const char* wbcSidTypeString(enum wbcSidType type)
783 {
784 switch (type) {
785 case WBC_SID_NAME_USE_NONE: return "SID_NONE";
786 case WBC_SID_NAME_USER: return "SID_USER";
787 case WBC_SID_NAME_DOM_GRP: return "SID_DOM_GROUP";
788 case WBC_SID_NAME_DOMAIN: return "SID_DOMAIN";
789 case WBC_SID_NAME_ALIAS: return "SID_ALIAS";
790 case WBC_SID_NAME_WKN_GRP: return "SID_WKN_GROUP";
791 case WBC_SID_NAME_DELETED: return "SID_DELETED";
792 case WBC_SID_NAME_INVALID: return "SID_INVALID";
793 case WBC_SID_NAME_UNKNOWN: return "SID_UNKNOWN";
794 case WBC_SID_NAME_COMPUTER: return "SID_COMPUTER";
795 default: return "Unknown type";
796 }
797 }