2 Unix SMB/CIFS implementation.
4 Winbind client asynchronous API, utility functions
6 Copyright (C) Gerald (Jerry) Carter 2007-2008
9 This library is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Lesser General Public
11 License as published by the Free Software Foundation; either
12 version 3 of the License, or (at your option) any later version.
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.
19 You should have received a copy of the GNU Lesser General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 /* Required Headers */
26 #include "libwbclient.h"
27 #include "../winbind_client.h"
29 /** @brief Ping winbindd to see if the daemon is running
35 struct winbindd_request request
;
36 struct winbindd_response response
;
38 /* Initialize request */
41 ZERO_STRUCT(response
);
43 return wbcRequestResponse(WINBINDD_PING
, &request
, &response
);
46 static void wbcInterfaceDetailsDestructor(void *ptr
)
48 struct wbcInterfaceDetails
*i
= (struct wbcInterfaceDetails
*)ptr
;
49 free(i
->winbind_version
);
50 free(i
->netbios_name
);
51 free(i
->netbios_domain
);
56 * @brief Query useful information about the winbind service
58 * @param *_details pointer to hold the struct wbcInterfaceDetails
63 wbcErr
wbcInterfaceDetails(struct wbcInterfaceDetails
**_details
)
65 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
66 struct wbcInterfaceDetails
*info
;
67 struct wbcDomainInfo
*domain
= NULL
;
68 struct winbindd_request request
;
69 struct winbindd_response response
;
71 /* Initialize request */
74 ZERO_STRUCT(response
);
76 info
= (struct wbcInterfaceDetails
*)wbcAllocateMemory(
77 sizeof(struct wbcInterfaceDetails
), 1,
78 wbcInterfaceDetailsDestructor
);
79 BAIL_ON_PTR_ERROR(info
, wbc_status
);
81 /* first the interface version */
82 wbc_status
= wbcRequestResponse(WINBINDD_INTERFACE_VERSION
, NULL
, &response
);
83 BAIL_ON_WBC_ERROR(wbc_status
);
84 info
->interface_version
= response
.data
.interface_version
;
86 /* then the samba version and the winbind separator */
87 wbc_status
= wbcRequestResponse(WINBINDD_INFO
, NULL
, &response
);
88 BAIL_ON_WBC_ERROR(wbc_status
);
90 info
->winbind_version
= strdup(response
.data
.info
.samba_version
);
91 BAIL_ON_PTR_ERROR(info
->winbind_version
, wbc_status
);
92 info
->winbind_separator
= response
.data
.info
.winbind_separator
;
94 /* then the local netbios name */
95 wbc_status
= wbcRequestResponse(WINBINDD_NETBIOS_NAME
, NULL
, &response
);
96 BAIL_ON_WBC_ERROR(wbc_status
);
98 info
->netbios_name
= strdup(response
.data
.netbios_name
);
99 BAIL_ON_PTR_ERROR(info
->netbios_name
, wbc_status
);
101 /* then the local workgroup name */
102 wbc_status
= wbcRequestResponse(WINBINDD_DOMAIN_NAME
, NULL
, &response
);
103 BAIL_ON_WBC_ERROR(wbc_status
);
105 info
->netbios_domain
= strdup(response
.data
.domain_name
);
106 BAIL_ON_PTR_ERROR(info
->netbios_domain
, wbc_status
);
108 wbc_status
= wbcDomainInfo(info
->netbios_domain
, &domain
);
109 if (wbc_status
== WBC_ERR_DOMAIN_NOT_FOUND
) {
110 /* maybe it's a standalone server */
112 wbc_status
= WBC_ERR_SUCCESS
;
114 BAIL_ON_WBC_ERROR(wbc_status
);
118 info
->dns_domain
= strdup(domain
->dns_name
);
119 wbcFreeMemory(domain
);
120 BAIL_ON_PTR_ERROR(info
->dns_domain
, wbc_status
);
122 info
->dns_domain
= NULL
;
128 wbc_status
= WBC_ERR_SUCCESS
;
135 static void wbcDomainInfoDestructor(void *ptr
)
137 struct wbcDomainInfo
*i
= (struct wbcDomainInfo
*)ptr
;
142 /** @brief Lookup the current status of a trusted domain, sync wrapper
144 * @param domain Domain to query
145 * @param *dinfo Pointer to returned struct wbcDomainInfo
150 wbcErr
wbcDomainInfo(const char *domain
, struct wbcDomainInfo
**dinfo
)
152 struct winbindd_request request
;
153 struct winbindd_response response
;
154 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
155 struct wbcDomainInfo
*info
= NULL
;
157 if (!domain
|| !dinfo
) {
158 wbc_status
= WBC_ERR_INVALID_PARAM
;
159 BAIL_ON_WBC_ERROR(wbc_status
);
162 /* Initialize request */
164 ZERO_STRUCT(request
);
165 ZERO_STRUCT(response
);
167 strncpy(request
.domain_name
, domain
,
168 sizeof(request
.domain_name
)-1);
170 wbc_status
= wbcRequestResponse(WINBINDD_DOMAIN_INFO
,
173 BAIL_ON_WBC_ERROR(wbc_status
);
175 info
= (struct wbcDomainInfo
*)wbcAllocateMemory(
176 sizeof(struct wbcDomainInfo
), 1, wbcDomainInfoDestructor
);
177 BAIL_ON_PTR_ERROR(info
, wbc_status
);
179 info
->short_name
= strdup(response
.data
.domain_info
.name
);
180 BAIL_ON_PTR_ERROR(info
->short_name
, wbc_status
);
182 info
->dns_name
= strdup(response
.data
.domain_info
.alt_name
);
183 BAIL_ON_PTR_ERROR(info
->dns_name
, wbc_status
);
185 wbc_status
= wbcStringToSid(response
.data
.domain_info
.sid
,
187 BAIL_ON_WBC_ERROR(wbc_status
);
189 if (response
.data
.domain_info
.native_mode
)
190 info
->domain_flags
|= WBC_DOMINFO_DOMAIN_NATIVE
;
191 if (response
.data
.domain_info
.active_directory
)
192 info
->domain_flags
|= WBC_DOMINFO_DOMAIN_AD
;
193 if (response
.data
.domain_info
.primary
)
194 info
->domain_flags
|= WBC_DOMINFO_DOMAIN_PRIMARY
;
199 wbc_status
= WBC_ERR_SUCCESS
;
207 /* Resolve a NetbiosName via WINS */
208 wbcErr
wbcResolveWinsByName(const char *name
, char **ip
)
210 struct winbindd_request request
;
211 struct winbindd_response response
;
212 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
215 ZERO_STRUCT(request
);
216 ZERO_STRUCT(response
);
220 strncpy(request
.data
.winsreq
, name
,
221 sizeof(request
.data
.winsreq
)-1);
223 wbc_status
= wbcRequestResponse(WINBINDD_WINS_BYNAME
,
226 BAIL_ON_WBC_ERROR(wbc_status
);
228 /* Display response */
230 ipaddr
= wbcStrDup(response
.data
.winsresp
);
231 BAIL_ON_PTR_ERROR(ipaddr
, wbc_status
);
234 wbc_status
= WBC_ERR_SUCCESS
;
240 /* Resolve an IP address via WINS into a NetbiosName */
241 wbcErr
wbcResolveWinsByIP(const char *ip
, char **name
)
243 struct winbindd_request request
;
244 struct winbindd_response response
;
245 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
248 ZERO_STRUCT(request
);
249 ZERO_STRUCT(response
);
253 strncpy(request
.data
.winsreq
, ip
,
254 sizeof(request
.data
.winsreq
)-1);
256 wbc_status
= wbcRequestResponse(WINBINDD_WINS_BYIP
,
259 BAIL_ON_WBC_ERROR(wbc_status
);
261 /* Display response */
263 name_str
= wbcStrDup(response
.data
.winsresp
);
264 BAIL_ON_PTR_ERROR(name_str
, wbc_status
);
267 wbc_status
= WBC_ERR_SUCCESS
;
276 static wbcErr
process_domain_info_string(TALLOC_CTX
*ctx
,
277 struct wbcDomainInfo
*info
,
280 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
284 if (!info
|| !info_string
) {
285 wbc_status
= WBC_ERR_INVALID_PARAM
;
286 BAIL_ON_WBC_ERROR(wbc_status
);
294 if ((s
= strchr(r
, '\\')) == NULL
) {
295 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
296 BAIL_ON_WBC_ERROR(wbc_status
);
301 info
->short_name
= talloc_strdup(ctx
, r
);
302 BAIL_ON_PTR_ERROR(info
->short_name
, wbc_status
);
307 if ((s
= strchr(r
, '\\')) == NULL
) {
308 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
309 BAIL_ON_WBC_ERROR(wbc_status
);
314 info
->dns_name
= talloc_strdup(ctx
, r
);
315 BAIL_ON_PTR_ERROR(info
->dns_name
, wbc_status
);
319 if ((s
= strchr(r
, '\\')) == NULL
) {
320 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
321 BAIL_ON_WBC_ERROR(wbc_status
);
326 wbc_status
= wbcStringToSid(r
, &info
->sid
);
327 BAIL_ON_WBC_ERROR(wbc_status
);
331 if ((s
= strchr(r
, '\\')) == NULL
) {
332 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
333 BAIL_ON_WBC_ERROR(wbc_status
);
338 if (strcmp(r
, "None") == 0) {
339 info
->trust_type
= WBC_DOMINFO_TRUSTTYPE_NONE
;
340 } else if (strcmp(r
, "External") == 0) {
341 info
->trust_type
= WBC_DOMINFO_TRUSTTYPE_EXTERNAL
;
342 } else if (strcmp(r
, "Forest") == 0) {
343 info
->trust_type
= WBC_DOMINFO_TRUSTTYPE_FOREST
;
344 } else if (strcmp(r
, "In Forest") == 0) {
345 info
->trust_type
= WBC_DOMINFO_TRUSTTYPE_IN_FOREST
;
347 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
348 BAIL_ON_WBC_ERROR(wbc_status
);
353 if ((s
= strchr(r
, '\\')) == NULL
) {
354 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
355 BAIL_ON_WBC_ERROR(wbc_status
);
360 if (strcmp(r
, "Yes") == 0) {
361 info
->trust_flags
|= WBC_DOMINFO_TRUST_TRANSITIVE
;
366 if ((s
= strchr(r
, '\\')) == NULL
) {
367 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
368 BAIL_ON_WBC_ERROR(wbc_status
);
373 if (strcmp(r
, "Yes") == 0) {
374 info
->trust_flags
|= WBC_DOMINFO_TRUST_INCOMING
;
379 if ((s
= strchr(r
, '\\')) == NULL
) {
380 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
381 BAIL_ON_WBC_ERROR(wbc_status
);
386 if (strcmp(r
, "Yes") == 0) {
387 info
->trust_flags
|= WBC_DOMINFO_TRUST_OUTGOING
;
390 /* Online/Offline status */
394 wbc_status
= WBC_ERR_INVALID_RESPONSE
;
395 BAIL_ON_WBC_ERROR(wbc_status
);
397 if ( strcmp(r
, "Offline") == 0) {
398 info
->domain_flags
|= WBC_DOMINFO_DOMAIN_OFFLINE
;
401 wbc_status
= WBC_ERR_SUCCESS
;
407 /* Enumerate the domain trusts known by Winbind */
408 wbcErr
wbcListTrusts(struct wbcDomainInfo
**domains
, size_t *num_domains
)
410 struct winbindd_response response
;
411 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
414 char *extra_data
= NULL
;
416 struct wbcDomainInfo
*d_list
= NULL
;
422 ZERO_STRUCT(response
);
426 wbc_status
= wbcRequestResponse(WINBINDD_LIST_TRUSTDOM
,
429 BAIL_ON_WBC_ERROR(wbc_status
);
431 /* Decode the response */
433 p
= (char *)response
.extra_data
.data
;
435 if ((p
== NULL
) || (strlen(p
) == 0)) {
436 /* We should always at least get back our
439 wbc_status
= WBC_ERR_DOMAIN_NOT_FOUND
;
440 BAIL_ON_WBC_ERROR(wbc_status
);
443 /* Count number of domains */
449 if ((q
= strchr(p
, '\n')) != NULL
)
454 d_list
= talloc_array(NULL
, struct wbcDomainInfo
, count
);
455 BAIL_ON_PTR_ERROR(d_list
, wbc_status
);
457 extra_data
= strdup((char*)response
.extra_data
.data
);
458 BAIL_ON_PTR_ERROR(extra_data
, wbc_status
);
462 /* Outer loop processes the list of domain information */
464 for (i
=0; i
<count
&& p
; i
++) {
465 char *next
= strchr(p
, '\n');
472 wbc_status
= process_domain_info_string(d_list
, &d_list
[i
], p
);
473 BAIL_ON_WBC_ERROR(wbc_status
);
483 winbindd_free_response(&response
);
489 static void wbcDomainControllerInfoDestructor(void *ptr
)
491 struct wbcDomainControllerInfo
*i
=
492 (struct wbcDomainControllerInfo
*)ptr
;
496 /* Enumerate the domain trusts known by Winbind */
497 wbcErr
wbcLookupDomainController(const char *domain
,
499 struct wbcDomainControllerInfo
**dc_info
)
501 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
502 struct winbindd_request request
;
503 struct winbindd_response response
;
504 struct wbcDomainControllerInfo
*dc
= NULL
;
506 /* validate input params */
508 if (!domain
|| !dc_info
) {
509 wbc_status
= WBC_ERR_INVALID_PARAM
;
510 BAIL_ON_WBC_ERROR(wbc_status
);
513 ZERO_STRUCT(request
);
514 ZERO_STRUCT(response
);
516 strncpy(request
.data
.dsgetdcname
.domain_name
, domain
,
517 sizeof(request
.data
.dsgetdcname
.domain_name
)-1);
519 request
.flags
= flags
;
521 dc
= (struct wbcDomainControllerInfo
*)wbcAllocateMemory(
522 sizeof(struct wbcDomainControllerInfo
), 1,
523 wbcDomainControllerInfoDestructor
);
524 BAIL_ON_PTR_ERROR(dc
, wbc_status
);
528 wbc_status
= wbcRequestResponse(WINBINDD_DSGETDCNAME
,
531 BAIL_ON_WBC_ERROR(wbc_status
);
533 dc
->dc_name
= strdup(response
.data
.dsgetdcname
.dc_unc
);
534 BAIL_ON_PTR_ERROR(dc
->dc_name
, wbc_status
);
544 static wbcErr
wbc_create_domain_controller_info_ex(TALLOC_CTX
*mem_ctx
,
545 const struct winbindd_response
*resp
,
546 struct wbcDomainControllerInfoEx
**_i
)
548 wbcErr wbc_status
= WBC_ERR_SUCCESS
;
549 struct wbcDomainControllerInfoEx
*i
;
552 i
= talloc(mem_ctx
, struct wbcDomainControllerInfoEx
);
553 BAIL_ON_PTR_ERROR(i
, wbc_status
);
555 i
->dc_unc
= talloc_strdup(i
, resp
->data
.dsgetdcname
.dc_unc
);
556 BAIL_ON_PTR_ERROR(i
->dc_unc
, wbc_status
);
558 i
->dc_address
= talloc_strdup(i
, resp
->data
.dsgetdcname
.dc_address
);
559 BAIL_ON_PTR_ERROR(i
->dc_address
, wbc_status
);
561 i
->dc_address_type
= resp
->data
.dsgetdcname
.dc_address_type
;
563 wbc_status
= wbcStringToGuid(resp
->data
.dsgetdcname
.domain_guid
, &guid
);
564 if (WBC_ERROR_IS_OK(wbc_status
)) {
565 i
->domain_guid
= talloc(i
, struct wbcGuid
);
566 BAIL_ON_PTR_ERROR(i
->domain_guid
, wbc_status
);
568 *i
->domain_guid
= guid
;
570 i
->domain_guid
= NULL
;
573 i
->domain_name
= talloc_strdup(i
, resp
->data
.dsgetdcname
.domain_name
);
574 BAIL_ON_PTR_ERROR(i
->domain_name
, wbc_status
);
576 if (resp
->data
.dsgetdcname
.forest_name
[0] != '\0') {
577 i
->forest_name
= talloc_strdup(i
,
578 resp
->data
.dsgetdcname
.forest_name
);
579 BAIL_ON_PTR_ERROR(i
->forest_name
, wbc_status
);
581 i
->forest_name
= NULL
;
584 i
->dc_flags
= resp
->data
.dsgetdcname
.dc_flags
;
586 if (resp
->data
.dsgetdcname
.dc_site_name
[0] != '\0') {
587 i
->dc_site_name
= talloc_strdup(i
,
588 resp
->data
.dsgetdcname
.dc_site_name
);
589 BAIL_ON_PTR_ERROR(i
->dc_site_name
, wbc_status
);
591 i
->dc_site_name
= NULL
;
594 if (resp
->data
.dsgetdcname
.client_site_name
[0] != '\0') {
595 i
->client_site_name
= talloc_strdup(i
,
596 resp
->data
.dsgetdcname
.client_site_name
);
597 BAIL_ON_PTR_ERROR(i
->client_site_name
, wbc_status
);
599 i
->client_site_name
= NULL
;
610 /* Get extended domain controller information */
611 wbcErr
wbcLookupDomainControllerEx(const char *domain
,
612 struct wbcGuid
*guid
,
615 struct wbcDomainControllerInfoEx
**dc_info
)
617 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
618 struct winbindd_request request
;
619 struct winbindd_response response
;
621 /* validate input params */
623 if (!domain
|| !dc_info
) {
624 wbc_status
= WBC_ERR_INVALID_PARAM
;
625 BAIL_ON_WBC_ERROR(wbc_status
);
628 ZERO_STRUCT(request
);
629 ZERO_STRUCT(response
);
631 request
.data
.dsgetdcname
.flags
= flags
;
633 strncpy(request
.data
.dsgetdcname
.domain_name
, domain
,
634 sizeof(request
.data
.dsgetdcname
.domain_name
)-1);
637 strncpy(request
.data
.dsgetdcname
.site_name
, site
,
638 sizeof(request
.data
.dsgetdcname
.site_name
)-1);
644 wbc_status
= wbcGuidToString(guid
, &str
);
645 BAIL_ON_WBC_ERROR(wbc_status
);
647 strncpy(request
.data
.dsgetdcname
.domain_guid
, str
,
648 sizeof(request
.data
.dsgetdcname
.domain_guid
)-1);
655 wbc_status
= wbcRequestResponse(WINBINDD_DSGETDCNAME
,
658 BAIL_ON_WBC_ERROR(wbc_status
);
661 wbc_status
= wbc_create_domain_controller_info_ex(NULL
,
664 BAIL_ON_WBC_ERROR(wbc_status
);
667 wbc_status
= WBC_ERR_SUCCESS
;
672 static void wbcNamedBlobDestructor(void *ptr
)
674 struct wbcNamedBlob
*b
= (struct wbcNamedBlob
*)ptr
;
676 while (b
->name
!= NULL
) {
677 free((char *)(b
->name
));
683 /* Initialize a named blob and add to list of blobs */
684 wbcErr
wbcAddNamedBlob(size_t *num_blobs
,
685 struct wbcNamedBlob
**pblobs
,
691 wbcErr wbc_status
= WBC_ERR_UNKNOWN_FAILURE
;
692 struct wbcNamedBlob
*blobs
, *blob
;
695 return WBC_ERR_INVALID_PARAM
;
699 * Overallocate the b->name==NULL terminator for
700 * wbcNamedBlobDestructor
702 blobs
= (struct wbcNamedBlob
*)wbcAllocateMemory(
703 sizeof(struct wbcNamedBlob
), *num_blobs
+ 2,
704 wbcNamedBlobDestructor
);
706 if (*pblobs
!= NULL
) {
707 struct wbcNamedBlob
*old
= *pblobs
;
708 memcpy(blobs
, old
, sizeof(struct wbcNamedBlob
) * (*num_blobs
));
709 if (*num_blobs
!= 0) {
710 /* end indicator for wbcNamedBlobDestructor */
717 blob
= &blobs
[*num_blobs
];
719 blob
->name
= strdup(name
);
720 BAIL_ON_PTR_ERROR(blob
->name
, wbc_status
);
723 blob
->blob
.length
= length
;
724 blob
->blob
.data
= (uint8_t *)malloc(length
);
725 BAIL_ON_PTR_ERROR(blob
->blob
.data
, wbc_status
);
726 memcpy(blob
->blob
.data
, data
, length
);
732 wbc_status
= WBC_ERR_SUCCESS
;
734 wbcFreeMemory(blobs
);