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);