?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tsocket: fill in sa.sa_len if the system supports it
[Samba/gebeck_regimport.git] / nsswitch / libwbclient / wbc_sid.c
blob73bd4162472c1f3cfbfb1d29122807f8f24201ca
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 goto done;
351 }
352
353 types[i] = (enum wbcSidType)strtoul(p, &q, 10);
354
355 if (*q != ' ') {
356 wbc_status = WBC_ERR_INVALID_RESPONSE;
357 goto done;
358 }
359
360 p = q+1;
361
362 if ((q = strchr(p, '\n')) == NULL) {
363 wbc_status = WBC_ERR_INVALID_RESPONSE;
364 goto done;
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 goto done;
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 = (struct wbcDomainSid *)wbcAllocateMemory(
448 response.data.num_entries, sizeof(struct wbcDomainSid),
449 NULL);
450 BAIL_ON_PTR_ERROR(sids, wbc_status);
451
452 s = (const char *)response.extra_data.data;
453 for (i = 0; i < response.data.num_entries; i++) {
454 char *n = strchr(s, '\n');
455 if (n) {
456 *n = '\0';
457 }
458 wbc_status = wbcStringToSid(s, &sids[i]);
459 BAIL_ON_WBC_ERROR(wbc_status);
460 s += strlen(s) + 1;
461 }
462
463 *num_sids = response.data.num_entries;
464 *_sids = sids;
465 sids = NULL;
466 wbc_status = WBC_ERR_SUCCESS;
467
468 done:
469 winbindd_free_response(&response);
470 if (sids) {
471 wbcFreeMemory(sids);
472 }
473
474 return wbc_status;
475 }
476
477 static inline
478 wbcErr _sid_to_rid(struct wbcDomainSid *sid, uint32_t *rid)
479 {
480 if (sid->num_auths < 1) {
481 return WBC_ERR_INVALID_RESPONSE;
482 }
483 *rid = sid->sub_auths[sid->num_auths - 1];
484
485 return WBC_ERR_SUCCESS;
486 }
487
488 /* Get alias membership for sids */
489 wbcErr wbcGetSidAliases(const struct wbcDomainSid *dom_sid,
490 struct wbcDomainSid *sids,
491 uint32_t num_sids,
492 uint32_t **alias_rids,
493 uint32_t *num_alias_rids)
494 {
495 uint32_t i;
496 const char *s;
497 struct winbindd_request request;
498 struct winbindd_response response;
499 char *sid_string = NULL;
500 ssize_t sid_len;
501 ssize_t extra_data_len = 0;
502 char * extra_data = NULL;
503 ssize_t buflen = 0;
504 struct wbcDomainSid sid;
505 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
506 uint32_t * rids = NULL;
507
508 /* Initialise request */
509
510 ZERO_STRUCT(request);
511 ZERO_STRUCT(response);
512
513 if (!dom_sid) {
514 wbc_status = WBC_ERR_INVALID_PARAM;
515 goto done;
516 }
517
518 wbc_status = wbcSidToString(dom_sid, &sid_string);
519 BAIL_ON_WBC_ERROR(wbc_status);
520
521 strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
522 wbcFreeMemory(sid_string);
523 sid_string = NULL;
524
525 /* Lets assume each sid is around 57 characters
526 * S-1-5-21-AAAAAAAAAAA-BBBBBBBBBBB-CCCCCCCCCCC-DDDDDDDDDDD\n */
527 buflen = 57 * num_sids;
528 extra_data = (char *)malloc(buflen);
529 if (!extra_data) {
530 wbc_status = WBC_ERR_NO_MEMORY;
531 goto done;
532 }
533
534 /* Build the sid list */
535 for (i=0; i<num_sids; i++) {
536 wbc_status = wbcSidToString(&sids[i], &sid_string);
537 BAIL_ON_WBC_ERROR(wbc_status);
538
539 sid_len = strlen(sid_string);
540
541 if (buflen < extra_data_len + sid_len + 2) {
542 buflen *= 2;
543 extra_data = (char *)realloc(extra_data, buflen);
544 if (!extra_data) {
545 wbc_status = WBC_ERR_NO_MEMORY;
546 BAIL_ON_WBC_ERROR(wbc_status);
547 }
548 }
549
550 strncpy(&extra_data[extra_data_len], sid_string,
551 buflen - extra_data_len);
552 extra_data_len += sid_len;
553 extra_data[extra_data_len++] = '\n';
554 extra_data[extra_data_len] = '\0';
555 wbcFreeMemory(sid_string);
556 sid_string = NULL;
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 goto done;
572 }
573
574 rids = (uint32_t *)wbcAllocateMemory(response.data.num_entries,
575 sizeof(uint32_t), NULL);
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 free(extra_data);
599 winbindd_free_response(&response);
600 wbcFreeMemory(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 users = wbcAllocateStringArray(response.data.num_entries);
633 if (users == NULL) {
634 return WBC_ERR_NO_MEMORY;
635 }
636
637 /* Look through extra data */
638
639 next = (const char *)response.extra_data.data;
640 while (next) {
641 const char *current;
642 char *k;
643
644 if (num_users >= response.data.num_entries) {
645 wbc_status = WBC_ERR_INVALID_RESPONSE;
646 goto done;
647 }
648
649 current = next;
650 k = strchr(next, ',');
651
652 if (k) {
653 k[0] = '\0';
654 next = k+1;
655 } else {
656 next = NULL;
657 }
658
659 users[num_users] = strdup(current);
660 BAIL_ON_PTR_ERROR(users[num_users], wbc_status);
661 num_users += 1;
662 }
663 if (num_users != response.data.num_entries) {
664 wbc_status = WBC_ERR_INVALID_RESPONSE;
665 goto done;
666 }
667
668 *_num_users = response.data.num_entries;
669 *_users = users;
670 users = NULL;
671 wbc_status = WBC_ERR_SUCCESS;
672
673 done:
674 winbindd_free_response(&response);
675 wbcFreeMemory(users);
676 return wbc_status;
677 }
678
679 /* Lists Groups */
680 wbcErr wbcListGroups(const char *domain_name,
681 uint32_t *_num_groups,
682 const char ***_groups)
683 {
684 wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
685 struct winbindd_request request;
686 struct winbindd_response response;
687 uint32_t num_groups = 0;
688 const char **groups = NULL;
689 const char *next;
690
691 /* Initialise request */
692
693 ZERO_STRUCT(request);
694 ZERO_STRUCT(response);
695
696 if (domain_name) {
697 strncpy(request.domain_name, domain_name,
698 sizeof(request.domain_name)-1);
699 }
700
701 wbc_status = wbcRequestResponse(WINBINDD_LIST_GROUPS,
702 &request,
703 &response);
704 BAIL_ON_WBC_ERROR(wbc_status);
705
706 groups = wbcAllocateStringArray(response.data.num_entries);
707 if (groups == NULL) {
708 return WBC_ERR_NO_MEMORY;
709 }
710
711 /* Look through extra data */
712
713 next = (const char *)response.extra_data.data;
714 while (next) {
715 const char *current;
716 char *k;
717
718 if (num_groups >= response.data.num_entries) {
719 wbc_status = WBC_ERR_INVALID_RESPONSE;
720 goto done;
721 }
722
723 current = next;
724 k = strchr(next, ',');
725
726 if (k) {
727 k[0] = '\0';
728 next = k+1;
729 } else {
730 next = NULL;
731 }
732
733 groups[num_groups] = strdup(current);
734 BAIL_ON_PTR_ERROR(groups[num_groups], wbc_status);
735 num_groups += 1;
736 }
737 if (num_groups != response.data.num_entries) {
738 wbc_status = WBC_ERR_INVALID_RESPONSE;
739 goto done;
740 }
741
742 *_num_groups = response.data.num_entries;
743 *_groups = groups;
744 groups = NULL;
745 wbc_status = WBC_ERR_SUCCESS;
746
747 done:
748 winbindd_free_response(&response);
749 wbcFreeMemory(groups);
750 return wbc_status;
751 }
752
753 wbcErr wbcGetDisplayName(const struct wbcDomainSid *sid,
754 char **pdomain,
755 char **pfullname,
756 enum wbcSidType *pname_type)
757 {
758 wbcErr wbc_status;
759 char *domain = NULL;
760 char *name = NULL;
761 enum wbcSidType name_type;
762
763 wbc_status = wbcLookupSid(sid, &domain, &name, &name_type);
764 BAIL_ON_WBC_ERROR(wbc_status);
765
766 if (name_type == WBC_SID_NAME_USER) {
767 uid_t uid;
768 struct passwd *pwd;
769
770 wbc_status = wbcSidToUid(sid, &uid);
771 BAIL_ON_WBC_ERROR(wbc_status);
772
773 wbc_status = wbcGetpwuid(uid, &pwd);
774 BAIL_ON_WBC_ERROR(wbc_status);
775
776 wbcFreeMemory(name);
777
778 name = wbcStrDup(pwd->pw_gecos);
779 BAIL_ON_PTR_ERROR(name, wbc_status);
780 wbcFreeMemory(pwd);
781 }
782
783 wbc_status = WBC_ERR_SUCCESS;
784
785 done:
786 if (WBC_ERROR_IS_OK(wbc_status)) {
787 *pdomain = domain;
788 *pfullname = name;
789 *pname_type = name_type;
790 } else {
791 wbcFreeMemory(domain);
792 wbcFreeMemory(name);
793 }
794
795 return wbc_status;
796 }
797
798 const char* wbcSidTypeString(enum wbcSidType type)
799 {
800 switch (type) {
801 case WBC_SID_NAME_USE_NONE: return "SID_NONE";
802 case WBC_SID_NAME_USER: return "SID_USER";
803 case WBC_SID_NAME_DOM_GRP: return "SID_DOM_GROUP";
804 case WBC_SID_NAME_DOMAIN: return "SID_DOMAIN";
805 case WBC_SID_NAME_ALIAS: return "SID_ALIAS";
806 case WBC_SID_NAME_WKN_GRP: return "SID_WKN_GROUP";
807 case WBC_SID_NAME_DELETED: return "SID_DELETED";
808 case WBC_SID_NAME_INVALID: return "SID_INVALID";
809 case WBC_SID_NAME_UNKNOWN: return "SID_UNKNOWN";
810 case WBC_SID_NAME_COMPUTER: return "SID_COMPUTER";
811 default: return "Unknown type";
812 }
813 }
reg import