Changeset 740 for vendor/current/nsswitch

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/nsswitch

Files:

• config.m4 (deleted)
• config.mk (deleted)
• libwbclient/config.mk (deleted)
• libwbclient/libwbclient.h (modified) (1 diff)
• libwbclient/tests/wbclient.c (modified) (13 diffs)
• libwbclient/wb_reqtrans.c (deleted)
• libwbclient/wbc_async.c (deleted)
• libwbclient/wbc_async.h (deleted)
• libwbclient/wbc_guid.c (modified) (1 diff)
• libwbclient/wbc_idmap.c (modified) (9 diffs)
• libwbclient/wbc_pam.c (modified) (46 diffs)
• libwbclient/wbc_pwd.c (modified) (19 diffs)
• libwbclient/wbc_sid.c (modified) (34 diffs)
• libwbclient/wbc_util.c (modified) (33 diffs)
• libwbclient/wbclient.c (modified) (5 diffs)
• libwbclient/wbclient.h (modified) (14 diffs)
• libwbclient/wbclient_internal.h (modified) (1 diff)
• libwbclient/wscript_build (added)
• nsstest.c (modified) (24 diffs)
• nsstest.m4 (deleted)
• pam_winbind.c (modified) (11 diffs)
• pam_winbind.h (modified) (4 diffs)
• tests/test_wbinfo.sh (modified) (3 diffs)
• wb_common.c (modified) (13 diffs)
• wb_reqtrans.c (added)
• wb_reqtrans.h (added)
• wbinfo.c (modified) (80 diffs)
• winbind_client.h (modified) (3 diffs)
• winbind_nss_hpux.h (modified) (1 diff)
• winbind_nss_linux.c (modified) (1 diff)
• winbind_nss_solaris.h (modified) (1 diff)
• winbind_struct_protocol.h (modified) (5 diffs)
• wins.c (modified) (12 diffs)
• wscript_build (added)
• wscript_configure (added)

vendor/current/nsswitch/libwbclient/libwbclient.h

@@ -32 +32 @@
 #include "nsswitch/winbind_struct_protocol.h"
 
-#include <talloc.h>
-
 /* Public headers */
 
 #include "wbclient.h"
-#include "wbc_async.h"
 
 /* Private headers */

vendor/current/nsswitch/libwbclient/tests/wbclient.c

@@ -2 +2 @@
    Unix SMB/CIFS implementation.
    SMB torture tester
-   Copyright (C) Guenther Deschner 2009
+   Copyright (C) Guenther Deschner 2009-2010
 
    This program is free software; you can redistribute it and/or modify
@@ -18 +18 @@
 */
 
-#include "includes.h"
+#include "lib/replace/replace.h"
+#include "libcli/util/ntstatus.h"
+#include "libcli/util/werror.h"
+#include "lib/util/data_blob.h"
+#include "lib/util/time.h"
 #include "nsswitch/libwbclient/wbclient.h"
 #include "torture/smbtorture.h"
 #include "torture/winbind/proto.h"
+#include "lib/util/util_net.h"
+#include "lib/util/charset/charset.h"
+#include "libcli/auth/libcli_auth.h"
+#include "source4/param/param.h"
+#include "lib/util/util.h"
+#include "lib/crypto/arcfour.h"
 
 #define WBC_ERROR_EQUAL(x,y) (x == y)
@@ -40 +50 @@
         torture_assert_wbc_ok(tctx, wbcPing(),
                 "wbcPing failed");
+
+        return true;
+}
+
+static bool test_wbc_pingdc(struct torture_context *tctx)
+{
+        torture_assert_wbc_equal(tctx, wbcPingDc("random_string", NULL), WBC_ERR_NOT_IMPLEMENTED,
+                "wbcPingDc failed");
+        torture_assert_wbc_ok(tctx, wbcPingDc(NULL, NULL),
+                "wbcPingDc failed");
 
         return true;
@@ -109 +129 @@
         torture_assert_str_equal(tctx, sid_string, sid_string2,
                 "sid strings differ");
+        wbcFreeMemory(sid_string2);
 
         return true;
@@ -125 +146 @@
         torture_assert_str_equal(tctx, guid_string, guid_string2,
                 "guid strings differ");
+        wbcFreeMemory(guid_string2);
 
         return true;
@@ -131 +153 @@
 static bool test_wbc_domain_info(struct torture_context *tctx)
 {
-        const char *domain_name = NULL;
         struct wbcDomainInfo *info;
         struct wbcInterfaceDetails *details;
@@ -137 +158 @@
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
                 "wbcInterfaceDetails failed");
-
-        domain_name = talloc_strdup(tctx, details->netbios_domain);
+        torture_assert_wbc_ok(
+                tctx, wbcDomainInfo(details->netbios_domain, &info),
+                "wbcDomainInfo failed");
         wbcFreeMemory(details);
 
-        torture_assert_wbc_ok(tctx, wbcDomainInfo(domain_name, &info),
-                "wbcDomainInfo failed");
         torture_assert(tctx, info,
                 "wbcDomainInfo returned NULL pointer");
+        wbcFreeMemory(info);
 
         return true;
@@ -186 +207 @@
                 torture_assert(tctx, name,
                         "wbcLookupSid returned no name");
+                wbcFreeMemory(domain);
+                wbcFreeMemory(name);
                 torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
                         "wbcLookupUserSids failed");
+                torture_assert_wbc_ok(
+                        tctx, wbcGetDisplayName(&sid, &domain, &name,
+                                                &name_type),
+                        "wbcGetDisplayName failed");
+                wbcFreeMemory(domain);
+                wbcFreeMemory(name);
+                wbcFreeMemory(sids);
         }
+        wbcFreeMemory(users);
 
         return true;
@@ -226 +257 @@
                         "wbcLookupSid returned no name");
         }
+        wbcFreeMemory(groups);
 
         return true;
@@ -265 +297 @@
                 */
         }
+        wbcFreeMemory(domains);
 
         return true;
@@ -283 +316 @@
         torture_assert_wbc_ok(tctx, wbcLookupDomainController(domain_name, 0, &dc_info),
                 "wbcLookupDomainController failed");
+        wbcFreeMemory(dc_info);
 
         return true;
@@ -301 +335 @@
         torture_assert_wbc_ok(tctx, wbcLookupDomainControllerEx(domain_name, NULL, NULL, 0, &dc_info),
                 "wbcLookupDomainControllerEx failed");
-
-        return true;
-}
-
+        wbcFreeMemory(dc_info);
+
+        return true;
+}
+
+static bool test_wbc_resolve_winsbyname(struct torture_context *tctx)
+{
+        const char *name;
+        char *ip;
+        wbcErr ret;
+
+        name = torture_setting_string(tctx, "host", NULL);
+
+        ret = wbcResolveWinsByName(name, &ip);
+
+        if (is_ipaddress(name)) {
+                torture_assert_wbc_equal(tctx, ret, WBC_ERR_DOMAIN_NOT_FOUND, "wbcResolveWinsByName failed");
+        } else {
+                torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByName failed");
+        }
+
+        return true;
+}
+
+static bool test_wbc_resolve_winsbyip(struct torture_context *tctx)
+{
+        const char *ip;
+        char *name;
+        wbcErr ret;
+
+        ip = torture_setting_string(tctx, "host", NULL);
+
+        ret = wbcResolveWinsByIP(ip, &name);
+
+        torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByIP failed");
+
+        wbcFreeMemory(name);
+
+        return true;
+}
+
+static bool test_wbc_lookup_rids(struct torture_context *tctx)
+{
+        struct wbcDomainSid builtin;
+        uint32_t rids[2] = { 544, 545 };
+        const char *domain_name, **names;
+        enum wbcSidType *types;
+        wbcErr ret;
+
+        wbcStringToSid("S-1-5-32", &builtin);
+
+        ret = wbcLookupRids(&builtin, 2, rids, &domain_name, &names,
+                            &types);
+        torture_assert_wbc_ok(tctx, ret, "wbcLookupRids failed");
+
+        torture_assert_str_equal(
+                tctx, names[0], "Administrators",
+                "S-1-5-32-544 not mapped to 'Administrators'");
+        torture_assert_str_equal(
+                tctx, names[1], "Users", "S-1-5-32-545 not mapped to 'Users'");
+
+        wbcFreeMemory((char *)domain_name);
+        wbcFreeMemory(names);
+        wbcFreeMemory(types);
+
+        return true;
+}
+
+static bool test_wbc_get_sidaliases(struct torture_context *tctx)
+{
+        struct wbcDomainSid builtin;
+        struct wbcDomainInfo *info;
+        struct wbcInterfaceDetails *details;
+        struct wbcDomainSid sids[2];
+        uint32_t *rids;
+        uint32_t num_rids;
+        wbcErr ret;
+
+        torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+                "wbcInterfaceDetails failed");
+        torture_assert_wbc_ok(
+                tctx, wbcDomainInfo(details->netbios_domain, &info),
+                "wbcDomainInfo failed");
+        wbcFreeMemory(details);
+
+        sids[0] = info->sid;
+        sids[0].sub_auths[sids[0].num_auths++] = 500;
+        sids[1] = info->sid;
+        sids[1].sub_auths[sids[1].num_auths++] = 512;
+        wbcFreeMemory(info);
+
+        torture_assert_wbc_ok(
+                tctx, wbcStringToSid("S-1-5-32", &builtin),
+                "wbcStringToSid failed");
+
+        ret = wbcGetSidAliases(&builtin, sids, 2, &rids, &num_rids);
+        torture_assert_wbc_ok(tctx, ret, "wbcGetSidAliases failed");
+
+        wbcFreeMemory(rids);
+
+        return true;
+}
+
+static bool test_wbc_authenticate_user_int(struct torture_context *tctx,
+                                           const char *correct_password)
+{
+        struct wbcAuthUserParams params;
+        struct wbcAuthUserInfo *info = NULL;
+        struct wbcAuthErrorInfo *error = NULL;
+        wbcErr ret;
+
+        ret = wbcAuthenticateUser(getenv("USERNAME"), correct_password);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcAuthenticateUser failed");
+
+        ZERO_STRUCT(params);
+        params.account_name             = getenv("USERNAME");
+        params.level                    = WBC_AUTH_USER_LEVEL_PLAIN;
+        params.password.plaintext       = correct_password;
+
+        ret = wbcAuthenticateUserEx(&params, &info, &error);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcAuthenticateUserEx failed");
+        wbcFreeMemory(info);
+        info = NULL;
+
+        wbcFreeMemory(error);
+        error = NULL;
+
+        params.password.plaintext       = "wrong";
+        ret = wbcAuthenticateUserEx(&params, &info, &error);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
+                                 "wbcAuthenticateUserEx succeeded where it "
+                                 "should have failed");
+        wbcFreeMemory(info);
+        info = NULL;
+
+        wbcFreeMemory(error);
+        error = NULL;
+
+        return true;
+}
+
+static bool test_wbc_authenticate_user(struct torture_context *tctx)
+{
+        return test_wbc_authenticate_user_int(tctx, getenv("PASSWORD"));
+}
+
+static bool test_wbc_change_password(struct torture_context *tctx)
+{
+        wbcErr ret;
+        const char *oldpass = getenv("PASSWORD");
+        const char *newpass = "Koo8irei";
+
+        struct samr_CryptPassword new_nt_password;
+        struct samr_CryptPassword new_lm_password;
+        struct samr_Password old_nt_hash_enc;
+        struct samr_Password old_lanman_hash_enc;
+
+        uint8_t old_nt_hash[16];
+        uint8_t old_lanman_hash[16];
+        uint8_t new_nt_hash[16];
+        uint8_t new_lanman_hash[16];
+
+        struct wbcChangePasswordParams params;
+
+        if (oldpass == NULL) {
+                torture_skip(tctx,
+                        "skipping wbcChangeUserPassword test as old password cannot be retrieved\n");
+        }
+
+        ZERO_STRUCT(params);
+
+        E_md4hash(oldpass, old_nt_hash);
+        E_md4hash(newpass, new_nt_hash);
+
+        if (lpcfg_client_lanman_auth(tctx->lp_ctx) &&
+            E_deshash(newpass, new_lanman_hash) &&
+            E_deshash(oldpass, old_lanman_hash)) {
+
+                /* E_deshash returns false for 'long' passwords (> 14
+                   DOS chars).  This allows us to match Win2k, which
+                   does not store a LM hash for these passwords (which
+                   would reduce the effective password length to 14) */
+
+                encode_pw_buffer(new_lm_password.data, newpass, STR_UNICODE);
+                arcfour_crypt(new_lm_password.data, old_nt_hash, 516);
+                E_old_pw_hash(new_nt_hash, old_lanman_hash,
+                              old_lanman_hash_enc.hash);
+
+                params.old_password.response.old_lm_hash_enc_length =
+                        sizeof(old_lanman_hash_enc.hash);
+                params.old_password.response.old_lm_hash_enc_data =
+                        old_lanman_hash_enc.hash;
+                params.new_password.response.lm_length =
+                        sizeof(new_lm_password.data);
+                params.new_password.response.lm_data =
+                        new_lm_password.data;
+        } else {
+                ZERO_STRUCT(new_lm_password);
+                ZERO_STRUCT(old_lanman_hash_enc);
+        }
+
+        encode_pw_buffer(new_nt_password.data, newpass, STR_UNICODE);
+
+        arcfour_crypt(new_nt_password.data, old_nt_hash, 516);
+        E_old_pw_hash(new_nt_hash, old_nt_hash, old_nt_hash_enc.hash);
+
+        params.old_password.response.old_nt_hash_enc_length =
+                sizeof(old_nt_hash_enc.hash);
+        params.old_password.response.old_nt_hash_enc_data =
+                old_nt_hash_enc.hash;
+        params.new_password.response.nt_length = sizeof(new_nt_password.data);
+        params.new_password.response.nt_data = new_nt_password.data;
+
+        params.level = WBC_CHANGE_PASSWORD_LEVEL_RESPONSE;
+        params.account_name = getenv("USERNAME");
+        params.domain_name = "SAMBA-TEST";
+
+        ret = wbcChangeUserPasswordEx(&params, NULL, NULL, NULL);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcChangeUserPassword failed");
+
+        if (!test_wbc_authenticate_user_int(tctx, "Koo8irei")) {
+                return false;
+        }
+
+        ret = wbcChangeUserPassword(getenv("USERNAME"), "Koo8irei",
+                                    getenv("PASSWORD"));
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcChangeUserPassword failed");
+
+        return test_wbc_authenticate_user_int(tctx, getenv("PASSWORD"));
+}
+
+static bool test_wbc_logon_user(struct torture_context *tctx)
+{
+        struct wbcLogonUserParams params;
+        struct wbcLogonUserInfo *info = NULL;
+        struct wbcAuthErrorInfo *error = NULL;
+        struct wbcUserPasswordPolicyInfo *policy = NULL;
+        struct wbcInterfaceDetails *iface;
+        struct wbcDomainSid sid;
+        enum wbcSidType sidtype;
+        char *sidstr;
+        wbcErr ret;
+
+        ZERO_STRUCT(params);
+
+        ret = wbcLogonUser(&params, &info, &error, &policy);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_INVALID_PARAM,
+                                 "wbcLogonUser succeeded where it should "
+                                 "have failed");
+
+        params.username = getenv("USERNAME");
+        params.password = getenv("PASSWORD");
+
+        ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
+                              "foo", 0, discard_const_p(uint8_t, "bar"), 4);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcAddNamedBlob failed");
+
+        ret = wbcLogonUser(&params, &info, &error, &policy);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcLogonUser failed");
+        wbcFreeMemory(info); info = NULL;
+        wbcFreeMemory(error); error = NULL;
+        wbcFreeMemory(policy); policy = NULL;
+
+        params.password = "wrong";
+
+        ret = wbcLogonUser(&params, &info, &error, &policy);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
+                                 "wbcLogonUser should have failed with "
+                                 "WBC_ERR_AUTH_ERROR");
+        wbcFreeMemory(info); info = NULL;
+        wbcFreeMemory(error); error = NULL;
+        wbcFreeMemory(policy); policy = NULL;
+
+        ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
+                              "membership_of", 0,
+                              discard_const_p(uint8_t, "S-1-2-3-4"),
+                              strlen("S-1-2-3-4")+1);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcAddNamedBlob failed");
+        params.password = getenv("PASSWORD");
+        ret = wbcLogonUser(&params, &info, &error, &policy);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
+                                 "wbcLogonUser should have failed with "
+                                 "WBC_ERR_AUTH_ERROR");
+        wbcFreeMemory(info); info = NULL;
+        wbcFreeMemory(error); error = NULL;
+        wbcFreeMemory(policy); policy = NULL;
+        wbcFreeMemory(params.blobs);
+        params.blobs = NULL; params.num_blobs = 0;
+
+        ret = wbcInterfaceDetails(&iface);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcInterfaceDetails failed");
+
+        ret = wbcLookupName(iface->netbios_domain, getenv("USERNAME"), &sid,
+                            &sidtype);
+        wbcFreeMemory(iface);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcLookupName failed");
+
+        ret = wbcSidToString(&sid, &sidstr);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcSidToString failed");
+
+        ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
+                              "membership_of", 0,
+                              (uint8_t *)sidstr, strlen(sidstr)+1);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcAddNamedBlob failed");
+        wbcFreeMemory(sidstr);
+        params.password = getenv("PASSWORD");
+        ret = wbcLogonUser(&params, &info, &error, &policy);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcLogonUser failed");
+        wbcFreeMemory(info); info = NULL;
+        wbcFreeMemory(error); error = NULL;
+        wbcFreeMemory(policy); policy = NULL;
+        wbcFreeMemory(params.blobs);
+        params.blobs = NULL; params.num_blobs = 0;
+
+        return true;
+}
+
+static bool test_wbc_getgroups(struct torture_context *tctx)
+{
+        wbcErr ret;
+        uint32_t num_groups;
+        gid_t *groups;
+
+        ret = wbcGetGroups(getenv("USERNAME"), &num_groups, &groups);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcGetGroups failed");
+        wbcFreeMemory(groups);
+        return true;
+}
 
 struct torture_suite *torture_wbclient(void)
 {
-        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "WBCLIENT");
+        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "wbclient");
 
         torture_suite_add_simple_test(suite, "wbcPing", test_wbc_ping);
+        torture_suite_add_simple_test(suite, "wbcPingDc", test_wbc_pingdc);
         torture_suite_add_simple_test(suite, "wbcLibraryDetails", test_wbc_library_details);
         torture_suite_add_simple_test(suite, "wbcInterfaceDetails", test_wbc_interface_details);
@@ -322 +694 @@
         torture_suite_add_simple_test(suite, "wbcLookupDomainController", test_wbc_lookupdc);
         torture_suite_add_simple_test(suite, "wbcLookupDomainControllerEx", test_wbc_lookupdcex);
+        torture_suite_add_simple_test(suite, "wbcResolveWinsByName", test_wbc_resolve_winsbyname);
+        torture_suite_add_simple_test(suite, "wbcResolveWinsByIP", test_wbc_resolve_winsbyip);
+        torture_suite_add_simple_test(suite, "wbcLookupRids",
+                                      test_wbc_lookup_rids);
+        torture_suite_add_simple_test(suite, "wbcGetSidAliases",
+                                      test_wbc_get_sidaliases);
+        torture_suite_add_simple_test(suite, "wbcAuthenticateUser",
+                                      test_wbc_authenticate_user);
+        torture_suite_add_simple_test(suite, "wbcLogonUser",
+                                      test_wbc_logon_user);
+        torture_suite_add_simple_test(suite, "wbcChangeUserPassword",
+                                      test_wbc_change_password);
+        torture_suite_add_simple_test(suite, "wbcGetGroups",
+                                      test_wbc_getgroups);
 
         return suite;

vendor/current/nsswitch/libwbclient/wbc_guid.c

@@ -30 +30 @@
                        char **guid_string)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        char *result;
 
-        if (!guid) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
+        result = (char *)wbcAllocateMemory(37, 1, NULL);
+        if (result == NULL) {
+                return WBC_ERR_NO_MEMORY;
         }
+        snprintf(result, 37,
+                 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                 guid->time_low, guid->time_mid,
+                 guid->time_hi_and_version,
+                 guid->clock_seq[0],
+                 guid->clock_seq[1],
+                 guid->node[0], guid->node[1],
+                 guid->node[2], guid->node[3],
+                 guid->node[4], guid->node[5]);
+        *guid_string = result;
 
-        *guid_string = talloc_asprintf(NULL,
-                                       "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-                                       guid->time_low, guid->time_mid,
-                                       guid->time_hi_and_version,
-                                       guid->clock_seq[0],
-                                       guid->clock_seq[1],
-                                       guid->node[0], guid->node[1],
-                                       guid->node[2], guid->node[3],
-                                       guid->node[4], guid->node[5]);
-        BAIL_ON_PTR_ERROR((*guid_string), wbc_status);
-
-        wbc_status = WBC_ERR_SUCCESS;
-
-done:
-        return wbc_status;
+        return WBC_ERR_SUCCESS;
 }
 

vendor/current/nsswitch/libwbclient/wbc_idmap.c

@@ -5 +5 @@
 
    Copyright (C) Gerald (Jerry) Carter 2007
-
 
    This library is free software; you can redistribute it and/or
@@ -25 +24 @@
 #include "replace.h"
 #include "libwbclient.h"
+#include "../winbind_client.h"
 
 /* Convert a Windows SID to a Unix uid, allocating an uid if needed */
@@ -31 +31 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 
@@ -44 +43 @@
         ZERO_STRUCT(response);
 
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
 
         /* Make request */
@@ -126 +121 @@
         struct winbindd_response response;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
 
         if (!sid || !pgid) {
@@ -138 +132 @@
         ZERO_STRUCT(response);
 
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
 
         /* Make request */
@@ -159 +149 @@
 }
 
+
 /* Convert a Windows SID to a Unix gid if there already is a mapping */
 
@@ -166 +157 @@
         return WBC_ERR_NOT_IMPLEMENTED;
 }
+
 
 /* Convert a Unix gid to a Windows SID, allocating a SID if needed */
@@ -271 +263 @@
 #define _ID_TYPE_GID 2
 
-/* Set an user id mapping */
+/* Set an user id mapping - not implemented any more */
 wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
-
-        if (!sid) {
-                return WBC_ERR_INVALID_PARAM;
-        }
-
-        /* Initialise request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* Make request */
-
-        request.data.dual_idmapset.id = uid;
-        request.data.dual_idmapset.type = _ID_TYPE_UID;
-
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.dual_idmapset.sid, sid_string,
-                sizeof(request.data.dual_idmapset.sid)-1);
-        wbcFreeMemory(sid_string);
-
-        wbc_status = wbcRequestResponsePriv(WINBINDD_SET_MAPPING,
-                                            &request, &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
-}
-
-/* Set a group id mapping */
+        return WBC_ERR_NOT_IMPLEMENTED;
+}
+
+/* Set a group id mapping - not implemented any more */
 wbcErr wbcSetGidMapping(gid_t gid, const struct wbcDomainSid *sid)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
-
-        if (!sid) {
-                return WBC_ERR_INVALID_PARAM;
-        }
-
-        /* Initialise request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* Make request */
-
-        request.data.dual_idmapset.id = gid;
-        request.data.dual_idmapset.type = _ID_TYPE_GID;
-
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.dual_idmapset.sid, sid_string,
-                sizeof(request.data.dual_idmapset.sid)-1);
-        wbcFreeMemory(sid_string);
-
-        wbc_status = wbcRequestResponsePriv(WINBINDD_SET_MAPPING,
-                                            &request, &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
-}
-
-/* Remove a user id mapping */
+        return WBC_ERR_NOT_IMPLEMENTED;
+}
+
+/* Remove a user id mapping - not implemented any more */
 wbcErr wbcRemoveUidMapping(uid_t uid, const struct wbcDomainSid *sid)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
-
-        if (!sid) {
-                return WBC_ERR_INVALID_PARAM;
-        }
-
-        /* Initialise request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* Make request */
-
-        request.data.dual_idmapset.id = uid;
-        request.data.dual_idmapset.type = _ID_TYPE_UID;
-
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.dual_idmapset.sid, sid_string,
-                sizeof(request.data.dual_idmapset.sid)-1);
-        wbcFreeMemory(sid_string);
-
-        wbc_status = wbcRequestResponsePriv(WINBINDD_REMOVE_MAPPING,
-                                            &request, &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
-}
-
-/* Remove a group id mapping */
+        return WBC_ERR_NOT_IMPLEMENTED;
+}
+
+/* Remove a group id mapping - not implemented any more */
 wbcErr wbcRemoveGidMapping(gid_t gid, const struct wbcDomainSid *sid)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
-
-        if (!sid) {
-                return WBC_ERR_INVALID_PARAM;
-        }
-
-        /* Initialise request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* Make request */
-
-        request.data.dual_idmapset.id = gid;
-        request.data.dual_idmapset.type = _ID_TYPE_GID;
-
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.dual_idmapset.sid, sid_string,
-                sizeof(request.data.dual_idmapset.sid)-1);
-        wbcFreeMemory(sid_string);
-
-        wbc_status = wbcRequestResponsePriv(WINBINDD_REMOVE_MAPPING,
-                                            &request, &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
-}
-
-/* Set the highwater mark for allocated uids. */
+        return WBC_ERR_NOT_IMPLEMENTED;
+}
+
+/* Set the highwater mark for allocated uids - not implemented any more */
 wbcErr wbcSetUidHwm(uid_t uid_hwm)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        /* Initialise request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* Make request */
-
-        request.data.dual_idmapset.id = uid_hwm;
-        request.data.dual_idmapset.type = _ID_TYPE_UID;
-
-        wbc_status = wbcRequestResponsePriv(WINBINDD_SET_HWM,
-                                            &request, &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
-}
-
-/* Set the highwater mark for allocated gids. */
+        return WBC_ERR_NOT_IMPLEMENTED;
+}
+
+/* Set the highwater mark for allocated gids - not implemented any more */
 wbcErr wbcSetGidHwm(gid_t gid_hwm)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        /* Initialise request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* Make request */
-
-        request.data.dual_idmapset.id = gid_hwm;
-        request.data.dual_idmapset.type = _ID_TYPE_GID;
-
-        wbc_status = wbcRequestResponsePriv(WINBINDD_SET_HWM,
-                                            &request, &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
-}
+        return WBC_ERR_NOT_IMPLEMENTED;
+}
+
+/* Convert a list of SIDs */
+wbcErr wbcSidsToUnixIds(const struct wbcDomainSid *sids, uint32_t num_sids,
+                        struct wbcUnixId *ids)
+{
+        struct winbindd_request request;
+        struct winbindd_response response;
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        int buflen, extra_len;
+        uint32_t i;
+        char *sidlist, *p, *extra_data;
+
+        buflen = num_sids * (WBC_SID_STRING_BUFLEN + 1) + 1;
+
+        sidlist = (char *)malloc(buflen);
+        if (sidlist == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
+        p = sidlist;
+
+        for (i=0; i<num_sids; i++) {
+                int remaining;
+                int len;
+
+                remaining = buflen - (p - sidlist);
+
+                len = wbcSidToStringBuf(&sids[i], p, remaining);
+                if (len > remaining) {
+                        free(sidlist);
+                        return WBC_ERR_UNKNOWN_FAILURE;
+                }
+
+                p += len;
+                *p++ = '\n';
+        }
+        *p++ = '\0';
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        request.extra_data.data = sidlist;
+        request.extra_len = p - sidlist;
+
+        wbc_status = wbcRequestResponse(WINBINDD_SIDS_TO_XIDS,
+                                        &request, &response);
+        free(sidlist);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                return wbc_status;
+        }
+
+        extra_len = response.length - sizeof(struct winbindd_response);
+        extra_data = (char *)response.extra_data.data;
+
+        if ((extra_len <= 0) || (extra_data[extra_len-1] != '\0')) {
+                goto wbc_err_invalid;
+        }
+
+        p = extra_data;
+
+        for (i=0; i<num_sids; i++) {
+                struct wbcUnixId *id = &ids[i];
+                char *q;
+
+                switch (p[0]) {
+                case 'U':
+                        id->type = WBC_ID_TYPE_UID;
+                        id->id.uid = strtoul(p+1, &q, 10);
+                        break;
+                case 'G':
+                        id->type = WBC_ID_TYPE_GID;
+                        id->id.gid = strtoul(p+1, &q, 10);
+                        break;
+                default:
+                        id->type = WBC_ID_TYPE_NOT_SPECIFIED;
+                        q = p;
+                        break;
+                };
+                if (q[0] != '\n') {
+                        goto wbc_err_invalid;
+                }
+                p = q+1;
+        }
+        wbc_status = WBC_ERR_SUCCESS;
+        goto done;
+
+wbc_err_invalid:
+        wbc_status = WBC_ERR_INVALID_RESPONSE;
+done:
+        winbindd_free_response(&response);
+        return wbc_status;
+}

vendor/current/nsswitch/libwbclient/wbc_pam.c

@@ -26 +26 @@
 #include "replace.h"
 #include "libwbclient.h"
+#include "../winbind_client.h"
 
 /* Authenticate a username/password pair */
@@ -47 +48 @@
 }
 
-static wbcErr wbc_create_auth_info(TALLOC_CTX *mem_ctx,
-                                   const struct winbindd_response *resp,
+static bool sid_attr_compose(struct wbcSidWithAttr *s,
+                             const struct wbcDomainSid *d,
+                             uint32_t rid, uint32_t attr)
+{
+        if (d->num_auths >= WBC_MAXSUBAUTHS) {
+                return false;
+        }
+        s->sid = *d;
+        s->sid.sub_auths[s->sid.num_auths++] = rid;
+        s->attributes = attr;
+        return true;
+}
+
+static void wbcAuthUserInfoDestructor(void *ptr)
+{
+        struct wbcAuthUserInfo *i = (struct wbcAuthUserInfo *)ptr;
+        free(i->account_name);
+        free(i->user_principal);
+        free(i->full_name);
+        free(i->domain_name);
+        free(i->dns_domain_name);
+        free(i->logon_server);
+        free(i->logon_script);
+        free(i->profile_path);
+        free(i->home_directory);
+        free(i->home_drive);
+        free(i->sids);
+}
+
+static wbcErr wbc_create_auth_info(const struct winbindd_response *resp,
                                    struct wbcAuthUserInfo **_i)
 {
@@ -58 +87 @@
         uint32_t j;
 
-        i = talloc(mem_ctx, struct wbcAuthUserInfo);
+        i = (struct wbcAuthUserInfo *)wbcAllocateMemory(
+                1, sizeof(struct wbcAuthUserInfo),
+                wbcAuthUserInfoDestructor);
         BAIL_ON_PTR_ERROR(i, wbc_status);
 
         i->user_flags   = resp->data.auth.info3.user_flgs;
 
-        i->account_name = talloc_strdup(i, resp->data.auth.info3.user_name);
+        i->account_name = strdup(resp->data.auth.info3.user_name);
         BAIL_ON_PTR_ERROR(i->account_name, wbc_status);
         i->user_principal= NULL;
-        i->full_name    = talloc_strdup(i, resp->data.auth.info3.full_name);
+        i->full_name    = strdup(resp->data.auth.info3.full_name);
         BAIL_ON_PTR_ERROR(i->full_name, wbc_status);
-        i->domain_name  = talloc_strdup(i, resp->data.auth.info3.logon_dom);
+        i->domain_name  = strdup(resp->data.auth.info3.logon_dom);
         BAIL_ON_PTR_ERROR(i->domain_name, wbc_status);
         i->dns_domain_name= NULL;
@@ -90 +121 @@
         i->pass_must_change_time= resp->data.auth.info3.pass_must_change_time;
 
-        i->logon_server = talloc_strdup(i, resp->data.auth.info3.logon_srv);
+        i->logon_server = strdup(resp->data.auth.info3.logon_srv);
         BAIL_ON_PTR_ERROR(i->logon_server, wbc_status);
-        i->logon_script = talloc_strdup(i, resp->data.auth.info3.logon_script);
+        i->logon_script = strdup(resp->data.auth.info3.logon_script);
         BAIL_ON_PTR_ERROR(i->logon_script, wbc_status);
-        i->profile_path = talloc_strdup(i, resp->data.auth.info3.profile_path);
+        i->profile_path = strdup(resp->data.auth.info3.profile_path);
         BAIL_ON_PTR_ERROR(i->profile_path, wbc_status);
-        i->home_directory= talloc_strdup(i, resp->data.auth.info3.home_dir);
+        i->home_directory= strdup(resp->data.auth.info3.home_dir);
         BAIL_ON_PTR_ERROR(i->home_directory, wbc_status);
-        i->home_drive   = talloc_strdup(i, resp->data.auth.info3.dir_drive);
+        i->home_drive   = strdup(resp->data.auth.info3.dir_drive);
         BAIL_ON_PTR_ERROR(i->home_drive, wbc_status);
 
@@ -105 +136 @@
         i->num_sids     += resp->data.auth.info3.num_other_sids;
 
-        i->sids = talloc_array(i, struct wbcSidWithAttr, i->num_sids);
+        i->sids = (struct wbcSidWithAttr *)calloc(
+                sizeof(struct wbcSidWithAttr), i->num_sids);
         BAIL_ON_PTR_ERROR(i->sids, wbc_status);
 
@@ -112 +144 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-#define _SID_COMPOSE(s, d, r, a) { \
-        (s).sid = d; \
-        if ((s).sid.num_auths < WBC_MAXSUBAUTHS) { \
-                (s).sid.sub_auths[(s).sid.num_auths++] = r; \
-        } else { \
-                wbc_status = WBC_ERR_INVALID_SID; \
-                BAIL_ON_WBC_ERROR(wbc_status); \
-        } \
-        (s).attributes = a; \
-} while (0)
-
         sn = 0;
-        _SID_COMPOSE(i->sids[sn], domain_sid,
-                     resp->data.auth.info3.user_rid,
-                     0);
+        if (!sid_attr_compose(&i->sids[sn], &domain_sid,
+                              resp->data.auth.info3.user_rid, 0)) {
+                wbc_status = WBC_ERR_INVALID_SID;
+                goto done;
+        }
         sn++;
-        _SID_COMPOSE(i->sids[sn], domain_sid,
-                     resp->data.auth.info3.group_rid,
-                     0);
+        if (!sid_attr_compose(&i->sids[sn], &domain_sid,
+                              resp->data.auth.info3.group_rid, 0)) {
+                wbc_status = WBC_ERR_INVALID_SID;
+                goto done;
+        }
         sn++;
 
@@ -158 +183 @@
                 }
 
-                _SID_COMPOSE(i->sids[sn], domain_sid,
-                             rid, attrs);
+                if (!sid_attr_compose(&i->sids[sn], &domain_sid,
+                                      rid, attrs)) {
+                        wbc_status = WBC_ERR_INVALID_SID;
+                        goto done;
+                }
                 sn++;
         }
@@ -203 +231 @@
         i = NULL;
 done:
-        talloc_free(i);
-        return wbc_status;
-}
-
-static wbcErr wbc_create_error_info(TALLOC_CTX *mem_ctx,
-                                  const struct winbindd_response *resp,
-                                  struct wbcAuthErrorInfo **_e)
+        wbcFreeMemory(i);
+        return wbc_status;
+}
+
+static void wbcAuthErrorInfoDestructor(void *ptr)
+{
+        struct wbcAuthErrorInfo *e = (struct wbcAuthErrorInfo *)ptr;
+        free(e->nt_string);
+        free(e->display_string);
+}
+
+static wbcErr wbc_create_error_info(const struct winbindd_response *resp,
+                                    struct wbcAuthErrorInfo **_e)
 {
         wbcErr wbc_status = WBC_ERR_SUCCESS;
         struct wbcAuthErrorInfo *e;
 
-        e = talloc(mem_ctx, struct wbcAuthErrorInfo);
+        e = (struct wbcAuthErrorInfo *)wbcAllocateMemory(
+                1, sizeof(struct wbcAuthErrorInfo),
+                wbcAuthErrorInfoDestructor);
         BAIL_ON_PTR_ERROR(e, wbc_status);
 
         e->nt_status = resp->data.auth.nt_status;
         e->pam_error = resp->data.auth.pam_error;
-        e->nt_string = talloc_strdup(e, resp->data.auth.nt_status_string);
+        e->nt_string = strdup(resp->data.auth.nt_status_string);
         BAIL_ON_PTR_ERROR(e->nt_string, wbc_status);
 
-        e->display_string = talloc_strdup(e, resp->data.auth.error_string);
+        e->display_string = strdup(resp->data.auth.error_string);
         BAIL_ON_PTR_ERROR(e->display_string, wbc_status);
 
@@ -229 +265 @@
 
 done:
-        talloc_free(e);
-        return wbc_status;
-}
-
-static wbcErr wbc_create_password_policy_info(TALLOC_CTX *mem_ctx,
-                                              const struct winbindd_response *resp,
+        wbcFreeMemory(e);
+        return wbc_status;
+}
+
+static wbcErr wbc_create_password_policy_info(const struct winbindd_response *resp,
                                               struct wbcUserPasswordPolicyInfo **_i)
 {
@@ -240 +275 @@
         struct wbcUserPasswordPolicyInfo *i;
 
-        i = talloc(mem_ctx, struct wbcUserPasswordPolicyInfo);
+        i = (struct wbcUserPasswordPolicyInfo *)wbcAllocateMemory(
+                1, sizeof(struct wbcUserPasswordPolicyInfo), NULL);
         BAIL_ON_PTR_ERROR(i, wbc_status);
 
@@ -253 +289 @@
 
 done:
-        talloc_free(i);
-        return wbc_status;
-}
-
-static wbcErr wbc_create_logon_info(TALLOC_CTX *mem_ctx,
-                                    struct winbindd_response *resp,
+        wbcFreeMemory(i);
+        return wbc_status;
+}
+
+static void wbcLogonUserInfoDestructor(void *ptr)
+{
+        struct wbcLogonUserInfo *i = (struct wbcLogonUserInfo *)ptr;
+        wbcFreeMemory(i->info);
+        wbcFreeMemory(i->blobs);
+}
+
+static wbcErr wbc_create_logon_info(struct winbindd_response *resp,
                                     struct wbcLogonUserInfo **_i)
 {
@@ -264 +306 @@
         struct wbcLogonUserInfo *i;
 
-        i = talloc_zero(mem_ctx, struct wbcLogonUserInfo);
+        i = (struct wbcLogonUserInfo *)wbcAllocateMemory(
+                1, sizeof(struct wbcLogonUserInfo),
+                wbcLogonUserInfoDestructor);
         BAIL_ON_PTR_ERROR(i, wbc_status);
 
-        wbc_status = wbc_create_auth_info(i, resp, &i->info);
+        wbc_status = wbc_create_auth_info(resp, &i->info);
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        if (resp->data.auth.krb5ccname &&
-            strlen(resp->data.auth.krb5ccname)) {
+        if (resp->data.auth.krb5ccname[0] != '\0') {
                 wbc_status = wbcAddNamedBlob(&i->num_blobs,
                                              &i->blobs,
@@ -281 +324 @@
         }
 
-        if (resp->data.auth.unix_username &&
-            strlen(resp->data.auth.unix_username)) {
+        if (resp->data.auth.unix_username[0] != '\0') {
                 wbc_status = wbcAddNamedBlob(&i->num_blobs,
                                              &i->blobs,
@@ -295 +337 @@
         i = NULL;
 done:
-        if (!WBC_ERROR_IS_OK(wbc_status) && i) {
-                wbcFreeMemory(i->blobs);
-        }
-
-        talloc_free(i);
-        return wbc_status;
-}
+        wbcFreeMemory(i);
+        return wbc_status;
+}
+
 
 /* Authenticate with more detailed information */
@@ -437 +476 @@
                         request.flags |= WBFLAG_BIG_NTLMV2_BLOB;
                         request.extra_len = params->password.response.nt_length;
-                        request.extra_data.data = talloc_zero_array(NULL, char, request.extra_len);
+                        request.extra_data.data = (char *)malloc(
+                                request.extra_len);
                         if (request.extra_data.data == NULL) {
                                 wbc_status = WBC_ERR_NO_MEMORY;
@@ -471 +511 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -483 +522 @@
 
         if (info) {
-                wbc_status = wbc_create_auth_info(NULL,
-                                                  &response,
-                                                  info);
+                wbc_status = wbc_create_auth_info(&response, info);
                 BAIL_ON_WBC_ERROR(wbc_status);
         }
 
 done:
-        if (response.extra_data.data)
-                free(response.extra_data.data);
-
-        talloc_free(request.extra_data.data);
+        winbindd_free_response(&response);
+
+        free(request.extra_data.data);
 
         return wbc_status;
@@ -520 +556 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -557 +592 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -601 +635 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -688 +721 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -758 +790 @@
         if (!params->account_name) {
                 wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                goto done;
         }
 
@@ -782 +814 @@
                 if (!params->account_name) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -806 +838 @@
                 if (!params->account_name || !params->domain_name) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -812 +844 @@
                     !params->old_password.response.old_lm_hash_enc_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -818 +850 @@
                     params->old_password.response.old_lm_hash_enc_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -824 +856 @@
                     !params->old_password.response.old_nt_hash_enc_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -830 +862 @@
                     params->old_password.response.old_nt_hash_enc_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -836 +868 @@
                     !params->new_password.response.lm_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -842 +874 @@
                     params->new_password.response.lm_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -848 +880 @@
                     !params->new_password.response.nt_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -854 +886 @@
                     params->new_password.response.nt_data) {
                         wbc_status = WBC_ERR_INVALID_PARAM;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -900 +932 @@
         default:
                 wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                goto done;
                 break;
         }
@@ -917 +949 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -926 +957 @@
 
         if (policy) {
-                wbc_status = wbc_create_password_policy_info(NULL,
-                                                             &response,
+                wbc_status = wbc_create_password_policy_info(&response,
                                                              policy);
                 BAIL_ON_WBC_ERROR(wbc_status);
@@ -975 +1005 @@
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        int cmd = 0;
         struct winbindd_request request;
         struct winbindd_response response;
@@ -1014 +1043 @@
         /* Initialize request */
 
-        cmd = WINBINDD_PAM_AUTH;
         request.flags = WBFLAG_PAM_INFO3_TEXT |
                         WBFLAG_PAM_USER_SESSION_KEY |
@@ -1076 +1104 @@
         }
 
-        wbc_status = wbcRequestResponse(cmd,
+        wbc_status = wbcRequestResponse(WINBINDD_PAM_AUTH,
                                         &request,
                                         &response);
@@ -1082 +1110 @@
         if (response.data.auth.nt_status != 0) {
                 if (error) {
-                        wbc_status = wbc_create_error_info(NULL,
-                                                           &response,
+                        wbc_status = wbc_create_error_info(&response,
                                                            error);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -1094 +1121 @@
 
         if (info) {
-                wbc_status = wbc_create_logon_info(NULL,
-                                                   &response,
+                wbc_status = wbc_create_logon_info(&response,
                                                    info);
                 BAIL_ON_WBC_ERROR(wbc_status);
@@ -1101 +1127 @@
 
         if (policy) {
-                wbc_status = wbc_create_password_policy_info(NULL,
-                                                             &response,
+                wbc_status = wbc_create_password_policy_info(&response,
                                                              policy);
                 BAIL_ON_WBC_ERROR(wbc_status);
@@ -1108 +1133 @@
 
 done:
-        if (response.extra_data.data)
-                free(response.extra_data.data);
-
-        return wbc_status;
+        winbindd_free_response(&response);
+
+        return wbc_status;
+}
+
+static void wbcCredentialCacheInfoDestructor(void *ptr)
+{
+        struct wbcCredentialCacheInfo *i =
+                (struct wbcCredentialCacheInfo *)ptr;
+        wbcFreeMemory(i->blobs);
 }
 
@@ -1187 +1218 @@
 
         if (request.extra_len != 0) {
-                request.extra_data.data = talloc_array(
-                        NULL, char, request.extra_len);
+                request.extra_data.data = (char *)malloc(request.extra_len);
                 if (request.extra_data.data == NULL) {
                         status = WBC_ERR_NO_MEMORY;
@@ -1211 +1241 @@
         }
 
-        result = talloc(NULL, struct wbcCredentialCacheInfo);
+        result = (struct wbcCredentialCacheInfo *)wbcAllocateMemory(
+                1, sizeof(struct wbcCredentialCacheInfo),
+                wbcCredentialCacheInfoDestructor);
         if (result == NULL) {
                 status = WBC_ERR_NO_MEMORY;
@@ -1217 +1249 @@
         }
         result->num_blobs = 0;
-        result->blobs = talloc(result, struct wbcNamedBlob);
-        if (result->blobs == NULL) {
-                status = WBC_ERR_NO_MEMORY;
-                goto fail;
-        }
+        result->blobs = NULL;
         status = wbcAddNamedBlob(&result->num_blobs, &result->blobs,
                                  "auth_blob", 0,
@@ -1237 +1265 @@
         }
 
-        if (response.extra_data.data)
-                free(response.extra_data.data);
         *info = result;
-        return WBC_ERR_SUCCESS;
-
+        result = NULL;
+        status = WBC_ERR_SUCCESS;
 fail:
-        TALLOC_FREE(request.extra_data.data);
-        if (response.extra_data.data)
-                free(response.extra_data.data);
-        talloc_free(result);
+        free(request.extra_data.data);
+        winbindd_free_response(&response);
+        wbcFreeMemory(result);
         return status;
 }

vendor/current/nsswitch/libwbclient/wbc_pwd.c

@@ -25 +25 @@
 #include "replace.h"
 #include "libwbclient.h"
+#include "../winbind_client.h"
 
 /** @brief The maximum number of pwent structs to get from winbindd
@@ -40 +41 @@
  **/
 
+static void wbcPasswdDestructor(void *ptr)
+{
+        struct passwd *pw = (struct passwd *)ptr;
+        free(pw->pw_name);
+        free(pw->pw_passwd);
+        free(pw->pw_gecos);
+        free(pw->pw_shell);
+        free(pw->pw_dir);
+}
+
 static struct passwd *copy_passwd_entry(struct winbindd_pw *p)
 {
-        struct passwd *pwd = NULL;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        pwd = talloc(NULL, struct passwd);
-        BAIL_ON_PTR_ERROR(pwd, wbc_status);
-
-        pwd->pw_name = talloc_strdup(pwd,p->pw_name);
-        BAIL_ON_PTR_ERROR(pwd->pw_name, wbc_status);
-
-        pwd->pw_passwd = talloc_strdup(pwd, p->pw_passwd);
-        BAIL_ON_PTR_ERROR(pwd->pw_passwd, wbc_status);
-
-        pwd->pw_gecos = talloc_strdup(pwd, p->pw_gecos);
-        BAIL_ON_PTR_ERROR(pwd->pw_gecos, wbc_status);
-
-        pwd->pw_shell = talloc_strdup(pwd, p->pw_shell);
-        BAIL_ON_PTR_ERROR(pwd->pw_shell, wbc_status);
-
-        pwd->pw_dir = talloc_strdup(pwd, p->pw_dir);
-        BAIL_ON_PTR_ERROR(pwd->pw_dir, wbc_status);
-
-        pwd->pw_uid = p->pw_uid;
-        pwd->pw_gid = p->pw_gid;
-
-done:
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                talloc_free(pwd);
-                pwd = NULL;
-        }
-
-        return pwd;
+        struct passwd *pw = NULL;
+
+        pw = (struct passwd *)wbcAllocateMemory(1, sizeof(struct passwd),
+                                                wbcPasswdDestructor);
+        if (pw == NULL) {
+                return NULL;
+        }
+        pw->pw_name = strdup(p->pw_name);
+        if (pw->pw_name == NULL) {
+                goto fail;
+        }
+        pw->pw_passwd = strdup(p->pw_passwd);
+        if (pw->pw_passwd == NULL) {
+                goto fail;
+        }
+        pw->pw_gecos = strdup(p->pw_gecos);
+        if (pw->pw_gecos == NULL) {
+                goto fail;
+        }
+        pw->pw_shell = strdup(p->pw_shell);
+        if (pw->pw_shell == NULL) {
+                goto fail;
+        }
+        pw->pw_dir = strdup(p->pw_dir);
+        if (pw->pw_dir == NULL) {
+                goto fail;
+        }
+        pw->pw_uid = p->pw_uid;
+        pw->pw_gid = p->pw_gid;
+        return pw;
+
+fail:
+        wbcFreeMemory(pw);
+        return NULL;
 }
 
@@ -78 +92 @@
  *
  **/
+
+static void wbcGroupDestructor(void *ptr)
+{
+        struct group *gr = (struct group *)ptr;
+        int i;
+
+        free(gr->gr_name);
+        free(gr->gr_passwd);
+
+        /* if the array was partly created this can be NULL */
+        if (gr->gr_mem == NULL) {
+                return;
+        }
+
+        for (i=0; gr->gr_mem[i] != NULL; i++) {
+                free(gr->gr_mem[i]);
+        }
+        free(gr->gr_mem);
+}
 
 static struct group *copy_group_entry(struct winbindd_gr *g,
                                       char *mem_buf)
 {
-        struct group *grp = NULL;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        struct group *gr = NULL;
         int i;
         char *mem_p, *mem_q;
 
-        grp = talloc(NULL, struct group);
-        BAIL_ON_PTR_ERROR(grp, wbc_status);
-
-        grp->gr_name = talloc_strdup(grp, g->gr_name);
-        BAIL_ON_PTR_ERROR(grp->gr_name, wbc_status);
-
-        grp->gr_passwd = talloc_strdup(grp, g->gr_passwd);
-        BAIL_ON_PTR_ERROR(grp->gr_passwd, wbc_status);
-
-        grp->gr_gid = g->gr_gid;
-
-        grp->gr_mem = talloc_array(grp, char*, g->num_gr_mem+1);
+        gr = (struct group *)wbcAllocateMemory(
+                1, sizeof(struct group), wbcGroupDestructor);
+        if (gr == NULL) {
+                return NULL;
+        }
+
+        gr->gr_name = strdup(g->gr_name);
+        if (gr->gr_name == NULL) {
+                goto fail;
+        }
+        gr->gr_passwd = strdup(g->gr_passwd);
+        if (gr->gr_passwd == NULL) {
+                goto fail;
+        }
+        gr->gr_gid = g->gr_gid;
+
+        gr->gr_mem = (char **)calloc(g->num_gr_mem+1, sizeof(char *));
+        if (gr->gr_mem == NULL) {
+                goto fail;
+        }
 
         mem_p = mem_q = mem_buf;
         for (i=0; i<g->num_gr_mem && mem_p; i++) {
-                if ((mem_q = strchr(mem_p, ',')) != NULL) {
+                mem_q = strchr(mem_p, ',');
+                if (mem_q != NULL) {
                         *mem_q = '\0';
                 }
 
-                grp->gr_mem[i] = talloc_strdup(grp, mem_p);
-                BAIL_ON_PTR_ERROR(grp->gr_mem[i], wbc_status);
+                gr->gr_mem[i] = strdup(mem_p);
+                if (gr->gr_mem[i] == NULL) {
+                        goto fail;
+                }
 
                 if (mem_q == NULL) {
@@ -115 +158 @@
                 mem_p = mem_q + 1;
         }
-        grp->gr_mem[i] = NULL;
-
-        wbc_status = WBC_ERR_SUCCESS;
-
-done:
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                talloc_free(grp);
-                grp = NULL;
-        }
-
-        return grp;
+        gr->gr_mem[i] = NULL;
+
+        return gr;
+
+fail:
+        wbcFreeMemory(gr);
+        return NULL;
 }
 
@@ -198 +237 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char * sid_string = NULL;
 
         if (!pwd) {
@@ -205 +243 @@
         }
 
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
         /* Initialize request */
 
@@ -213 +248 @@
         ZERO_STRUCT(response);
 
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid));
+        wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
 
         wbc_status = wbcRequestResponse(WINBINDD_GETPWSID,
@@ -224 +259 @@
 
  done:
-        if (sid_string) {
-                wbcFreeMemory(sid_string);
-        }
-
         return wbc_status;
 }
@@ -262 +293 @@
 
  done:
-        if (response.extra_data.data)
-                free(response.extra_data.data);
+        winbindd_free_response(&response);
 
         return wbc_status;
@@ -297 +327 @@
 
  done:
-        if (response.extra_data.data)
-                free(response.extra_data.data);
+        winbindd_free_response(&response);
 
         return wbc_status;
@@ -325 +354 @@
         if (pw_cache_size > 0) {
                 pw_cache_idx = pw_cache_size = 0;
-                if (pw_response.extra_data.data) {
-                        free(pw_response.extra_data.data);
-                }
+                winbindd_free_response(&pw_response);
         }
 
@@ -347 +374 @@
         if (pw_cache_size > 0) {
                 pw_cache_idx = pw_cache_size = 0;
-                if (pw_response.extra_data.data) {
-                        free(pw_response.extra_data.data);
-                }
+                winbindd_free_response(&pw_response);
         }
 
@@ -376 +401 @@
         pw_cache_idx = 0;
 
-        if (pw_response.extra_data.data) {
-                free(pw_response.extra_data.data);
-                ZERO_STRUCT(pw_response);
-        }
+        winbindd_free_response(&pw_response);
 
         ZERO_STRUCT(request);
@@ -427 +449 @@
         if (gr_cache_size > 0) {
                 gr_cache_idx = gr_cache_size = 0;
-                if (gr_response.extra_data.data) {
-                        free(gr_response.extra_data.data);
-                }
+                winbindd_free_response(&gr_response);
         }
 
@@ -449 +469 @@
         if (gr_cache_size > 0) {
                 gr_cache_idx = gr_cache_size = 0;
-                if (gr_response.extra_data.data) {
-                        free(gr_response.extra_data.data);
-                }
+                winbindd_free_response(&gr_response);
         }
 
@@ -479 +497 @@
         gr_cache_idx = 0;
 
-        if (gr_response.extra_data.data) {
-                free(gr_response.extra_data.data);
-                ZERO_STRUCT(gr_response);
-        }
+        winbindd_free_response(&gr_response);
 
         ZERO_STRUCT(request);
@@ -528 +543 @@
         gr_cache_idx = 0;
 
-        if (gr_response.extra_data.data) {
-                free(gr_response.extra_data.data);
-                ZERO_STRUCT(gr_response);
-        }
+        winbindd_free_response(&gr_response);
+        ZERO_STRUCT(gr_response);
 
         ZERO_STRUCT(request);
@@ -587 +600 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        groups = talloc_array(NULL, gid_t, response.data.num_entries);
+        groups = (gid_t *)wbcAllocateMemory(
+                response.data.num_entries, sizeof(gid_t), NULL);
         BAIL_ON_PTR_ERROR(groups, wbc_status);
 
@@ -601 +615 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (groups) {
-                talloc_free(groups);
-        }
-
-        return wbc_status;
-}
+        winbindd_free_response(&response);
+        wbcFreeMemory(groups);
+        return wbc_status;
+}

vendor/current/nsswitch/libwbclient/wbc_sid.c

@@ -5 +5 @@
 
    Copyright (C) Gerald (Jerry) Carter 2007
+   Copyright (C) Volker Lendecke 2010
 
 
@@ -25 +26 @@
 #include "replace.h"
 #include "libwbclient.h"
-
-
-/* Convert a binary SID to a character string */
-wbcErr wbcSidToString(const struct wbcDomainSid *sid,
-                      char **sid_string)
-{
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+#include "../winbind_client.h"
+
+/* Convert a sid to a string into a buffer. Return the string
+ * length. If buflen is too small, return the string length that would
+ * result if it was long enough. */
+int wbcSidToStringBuf(const struct wbcDomainSid *sid, char *buf, int buflen)
+{
         uint32_t id_auth;
-        int i;
-        char *tmp = NULL;
+        int i, ofs;
 
         if (!sid) {
-                wbc_status = WBC_ERR_INVALID_SID;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
+                strlcpy(buf, "(NULL SID)", buflen);
+                return 10;      /* strlen("(NULL SID)") */
+        }
+
+        /*
+         * BIG NOTE: this function only does SIDS where the identauth is not
+         * >= ^32 in a range of 2^48.
+         */
 
         id_auth = sid->id_auth[5] +
@@ -46 +51 @@
                 (sid->id_auth[2] << 24);
 
-        tmp = talloc_asprintf(NULL, "S-%d-%d", sid->sid_rev_num, id_auth);
-        BAIL_ON_PTR_ERROR(tmp, wbc_status);
-
-        for (i=0; i<sid->num_auths; i++) {
-                char *tmp2;
-                tmp2 = talloc_asprintf_append(tmp, "-%u", sid->sub_auths[i]);
-                BAIL_ON_PTR_ERROR(tmp2, wbc_status);
-
-                tmp = tmp2;
-        }
-
-        *sid_string = tmp;
-        tmp = NULL;
-
-        wbc_status = WBC_ERR_SUCCESS;
-
-done:
-        talloc_free(tmp);
-
-        return wbc_status;
+        ofs = snprintf(buf, buflen, "S-%u-%lu",
+                       (unsigned int)sid->sid_rev_num, (unsigned long)id_auth);
+
+        for (i = 0; i < sid->num_auths; i++) {
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "-%lu",
+                                (unsigned long)sid->sub_auths[i]);
+        }
+        return ofs;
+}
+
+/* Convert a binary SID to a character string */
+wbcErr wbcSidToString(const struct wbcDomainSid *sid,
+                      char **sid_string)
+{
+        char buf[WBC_SID_STRING_BUFLEN];
+        char *result;
+        int len;
+
+        if (!sid) {
+                return WBC_ERR_INVALID_SID;
+        }
+
+        len = wbcSidToStringBuf(sid, buf, sizeof(buf));
+
+        if (len+1 > sizeof(buf)) {
+                return WBC_ERR_INVALID_SID;
+        }
+
+        result = (char *)wbcAllocateMemory(len+1, 1, NULL);
+        if (result == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+        memcpy(result, buf, len+1);
+
+        *sid_string = result;
+        return WBC_ERR_SUCCESS;
 }
 
@@ -132 +153 @@
                 sid->sub_auths[sid->num_auths++] = x;
 
-                if ((*q!='-') || (*q=='\0'))
+                if (*q != '-') {
                         break;
+                }
                 p = q + 1;
         }
@@ -150 +172 @@
 
 }
+
 
 /* Convert a domain and name to SID */
@@ -194 +217 @@
 }
 
+
 /* Convert a SID to a domain and name */
 wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
@@ -203 +227 @@
         struct winbindd_response response;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
-        char *domain = NULL;
-        char *name = NULL;
-        enum wbcSidType name_type = WBC_SID_NAME_USE_NONE;
+        char *domain, *name;
 
         if (!sid) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                return WBC_ERR_INVALID_PARAM;
         }
 
@@ -218 +238 @@
         ZERO_STRUCT(response);
 
-        /* dst is already null terminated from the memset above */
-
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
 
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSID,
-                                           &request,
-                                           &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
+        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSID, &request,
+                                        &response);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                return wbc_status;
+        }
 
         /* Copy out result */
 
-        domain = talloc_strdup(NULL, response.data.name.dom_name);
-        BAIL_ON_PTR_ERROR(domain, wbc_status);
-
-        name = talloc_strdup(NULL, response.data.name.name);
-        BAIL_ON_PTR_ERROR(name, wbc_status);
-
-        name_type = (enum wbcSidType)response.data.name.type;
-
+        wbc_status = WBC_ERR_NO_MEMORY;
+        domain = NULL;
+        name = NULL;
+
+        domain = wbcStrDup(response.data.name.dom_name);
+        if (domain == NULL) {
+                goto done;
+        }
+        name = wbcStrDup(response.data.name.name);
+        if (name == NULL) {
+                goto done;
+        }
+        if (pdomain != NULL) {
+                *pdomain = domain;
+                domain = NULL;
+        }
+        if (pname != NULL) {
+                *pname = name;
+                name = NULL;
+        }
+        if (pname_type != NULL) {
+                *pname_type = (enum wbcSidType)response.data.name.type;
+        }
         wbc_status = WBC_ERR_SUCCESS;
-
- done:
-        if (WBC_ERROR_IS_OK(wbc_status)) {
-                if (pdomain != NULL) {
-                        *pdomain = domain;
-                } else {
-                        TALLOC_FREE(domain);
-                }
-                if (pname != NULL) {
-                        *pname = name;
-                } else {
-                        TALLOC_FREE(name);
-                }
-                if (pname_type != NULL) {
-                        *pname_type = name_type;
-                }
-        }
-        else {
-#if 0
-                /*
-                 * Found by Coverity: In this particular routine we can't end
-                 * up here with a non-NULL name. Further up there are just two
-                 * exit paths that lead here, neither of which leave an
-                 * allocated name. If you add more paths up there, re-activate
-                 * this.
-                 */
-                if (name != NULL) {
-                        talloc_free(name);
-                }
-#endif
-                if (domain != NULL) {
-                        talloc_free(domain);
-                }
-        }
-
+done:
+        wbcFreeMemory(name);
+        wbcFreeMemory(domain);
+        return wbc_status;
+}
+
+static void wbcDomainInfosDestructor(void *ptr)
+{
+        struct wbcDomainInfo *i = (struct wbcDomainInfo *)ptr;
+
+        while (i->short_name != NULL) {
+                wbcFreeMemory(i->short_name);
+                wbcFreeMemory(i->dns_name);
+                i += 1;
+        }
+}
+
+static void wbcTranslatedNamesDestructor(void *ptr)
+{
+        struct wbcTranslatedName *n = (struct wbcTranslatedName *)ptr;
+
+        while (n->name != NULL) {
+                free(n->name);
+                n += 1;
+        }
+}
+
+wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
+                     struct wbcDomainInfo **pdomains, int *pnum_domains,
+                     struct wbcTranslatedName **pnames)
+{
+        struct winbindd_request request;
+        struct winbindd_response response;
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        int buflen, i, extra_len, num_domains, num_names;
+        char *sidlist, *p, *q, *extra_data;
+        struct wbcDomainInfo *domains = NULL;
+        struct wbcTranslatedName *names = NULL;
+
+        buflen = num_sids * (WBC_SID_STRING_BUFLEN + 1) + 1;
+
+        sidlist = (char *)malloc(buflen);
+        if (sidlist == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
+        p = sidlist;
+
+        for (i=0; i<num_sids; i++) {
+                int remaining;
+                int len;
+
+                remaining = buflen - (p - sidlist);
+
+                len = wbcSidToStringBuf(&sids[i], p, remaining);
+                if (len > remaining) {
+                        free(sidlist);
+                        return WBC_ERR_UNKNOWN_FAILURE;
+                }
+
+                p += len;
+                *p++ = '\n';
+        }
+        *p++ = '\0';
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        request.extra_data.data = sidlist;
+        request.extra_len = p - sidlist;
+
+        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSIDS,
+                                        &request, &response);
+        free(sidlist);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                return wbc_status;
+        }
+
+        extra_len = response.length - sizeof(struct winbindd_response);
+        extra_data = (char *)response.extra_data.data;
+
+        if ((extra_len <= 0) || (extra_data[extra_len-1] != '\0')) {
+                goto wbc_err_invalid;
+        }
+
+        p = extra_data;
+
+        num_domains = strtoul(p, &q, 10);
+        if (*q != '\n') {
+                goto wbc_err_invalid;
+        }
+        p = q+1;
+
+        domains = (struct wbcDomainInfo *)wbcAllocateMemory(
+                num_domains+1, sizeof(struct wbcDomainInfo),
+                wbcDomainInfosDestructor);
+        if (domains == NULL) {
+                wbc_status = WBC_ERR_NO_MEMORY;
+                goto fail;
+        }
+
+        for (i=0; i<num_domains; i++) {
+
+                q = strchr(p, ' ');
+                if (q == NULL) {
+                        goto wbc_err_invalid;
+                }
+                *q = '\0';
+                wbc_status = wbcStringToSid(p, &domains[i].sid);
+                if (!WBC_ERROR_IS_OK(wbc_status)) {
+                        goto fail;
+                }
+                p = q+1;
+
+                q = strchr(p, '\n');
+                if (q == NULL) {
+                        goto wbc_err_invalid;
+                }
+                *q = '\0';
+                domains[i].short_name = wbcStrDup(p);
+                if (domains[i].short_name == NULL) {
+                        wbc_status = WBC_ERR_NO_MEMORY;
+                        goto fail;
+                }
+                p = q+1;
+        }
+
+        num_names = strtoul(p, &q, 10);
+        if (*q != '\n') {
+                goto wbc_err_invalid;
+        }
+        p = q+1;
+
+        if (num_names != num_sids) {
+                goto wbc_err_invalid;
+        }
+
+        names = (struct wbcTranslatedName *)wbcAllocateMemory(
+                num_names+1, sizeof(struct wbcTranslatedName),
+                wbcTranslatedNamesDestructor);
+        if (names == NULL) {
+                wbc_status = WBC_ERR_NO_MEMORY;
+                goto fail;
+        }
+
+        for (i=0; i<num_names; i++) {
+
+                names[i].domain_index = strtoul(p, &q, 10);
+                if (*q != ' ') {
+                        goto wbc_err_invalid;
+                }
+                p = q+1;
+
+                names[i].type = strtoul(p, &q, 10);
+                if (*q != ' ') {
+                        goto wbc_err_invalid;
+                }
+                p = q+1;
+
+                q = strchr(p, '\n');
+                if (q == NULL) {
+                        goto wbc_err_invalid;
+                }
+                *q = '\0';
+                names[i].name = wbcStrDup(p);
+                if (names[i].name == NULL) {
+                        wbc_status = WBC_ERR_NO_MEMORY;
+                        goto fail;
+                }
+                p = q+1;
+        }
+        if (*p != '\0') {
+                goto wbc_err_invalid;
+        }
+
+        *pdomains = domains;
+        *pnames = names;
+        winbindd_free_response(&response);
+        return WBC_ERR_SUCCESS;
+
+wbc_err_invalid:
+        wbc_status = WBC_ERR_INVALID_RESPONSE;
+fail:
+        winbindd_free_response(&response);
+        wbcFreeMemory(domains);
+        wbcFreeMemory(names);
         return wbc_status;
 }
@@ -296 +477 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
         char *domain_name = NULL;
         const char **names = NULL;
@@ -312 +492 @@
         }
 
-        wbc_status = wbcSidToString(dom_sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(dom_sid, request.data.sid, sizeof(request.data.sid));
 
         /* Even if all the Rids were of maximum 32bit values,
@@ -325 +501 @@
         ridbuf_size = (sizeof(char)*11) * num_rids + 1;
 
-        ridlist = talloc_zero_array(NULL, char, ridbuf_size);
+        ridlist = (char *)malloc(ridbuf_size);
         BAIL_ON_PTR_ERROR(ridlist, wbc_status);
 
         len = 0;
-        for (i=0; i<num_rids && (len-1)>0; i++) {
-                char ridstr[12];
-
-                len = strlen(ridlist);
-                p = ridlist + len;
-
-                snprintf( ridstr, sizeof(ridstr)-1, "%u\n", rids[i]);
-                strncat(p, ridstr, ridbuf_size-len-1);
-        }
+        for (i=0; i<num_rids; i++) {
+                len += snprintf(ridlist + len, ridbuf_size - len, "%u\n",
+                                rids[i]);
+        }
+        ridlist[len] = '\0';
+        len += 1;
 
         request.extra_data.data = ridlist;
-        request.extra_len = strlen(ridlist)+1;
+        request.extra_len = len;
 
         wbc_status = wbcRequestResponse(WINBINDD_LOOKUPRIDS,
                                         &request,
                                         &response);
-        talloc_free(ridlist);
+        free(ridlist);
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        domain_name = talloc_strdup(NULL, response.data.domain_name);
+        domain_name = wbcStrDup(response.data.domain_name);
         BAIL_ON_PTR_ERROR(domain_name, wbc_status);
 
-        names = talloc_array(NULL, const char*, num_rids);
+        names = wbcAllocateStringArray(num_rids);
         BAIL_ON_PTR_ERROR(names, wbc_status);
 
-        types = talloc_array(NULL, enum wbcSidType, num_rids);
+        types = (enum wbcSidType *)wbcAllocateMemory(
+                num_rids, sizeof(enum wbcSidType), NULL);
         BAIL_ON_PTR_ERROR(types, wbc_status);
 
@@ -364 +538 @@
                 if (*p == '\0') {
                         wbc_status = WBC_ERR_INVALID_RESPONSE;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -371 +545 @@
                 if (*q != ' ') {
                         wbc_status = WBC_ERR_INVALID_RESPONSE;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -378 +552 @@
                 if ((q = strchr(p, '\n')) == NULL) {
                         wbc_status = WBC_ERR_INVALID_RESPONSE;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
                 *q = '\0';
 
-                names[i] = talloc_strdup(names, p);
+                names[i] = strdup(p);
                 BAIL_ON_PTR_ERROR(names[i], wbc_status);
 
@@ -391 +565 @@
         if (*p != '\0') {
                 wbc_status = WBC_ERR_INVALID_RESPONSE;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                goto done;
         }
 
@@ -397 +571 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
+        winbindd_free_response(&response);
 
         if (WBC_ERROR_IS_OK(wbc_status)) {
@@ -407 +579 @@
         }
         else {
-                if (domain_name)
-                        talloc_free(domain_name);
-                if (names)
-                        talloc_free(names);
-                if (types)
-                        talloc_free(types);
+                wbcFreeMemory(domain_name);
+                wbcFreeMemory(names);
+                wbcFreeMemory(types);
         }
 
@@ -428 +597 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
         struct wbcDomainSid *sids = NULL;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -443 +611 @@
         }
 
-        wbc_status = wbcSidToString(user_sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(user_sid, request.data.sid, sizeof(request.data.sid));
 
         if (domain_groups_only) {
@@ -466 +630 @@
         }
 
-        sids = talloc_array(NULL, struct wbcDomainSid,
-                            response.data.num_entries);
+        sids = (struct wbcDomainSid *)wbcAllocateMemory(
+                response.data.num_entries, sizeof(struct wbcDomainSid),
+                NULL);
         BAIL_ON_PTR_ERROR(sids, wbc_status);
 
@@ -487 +652 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
+        winbindd_free_response(&response);
         if (sids) {
-                talloc_free(sids);
+                wbcFreeMemory(sids);
         }
 
@@ -519 +682 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
-        ssize_t sid_len;
         ssize_t extra_data_len = 0;
         char * extra_data = NULL;
@@ -535 +696 @@
         if (!dom_sid) {
                 wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        wbc_status = wbcSidToString(dom_sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
-        sid_string = NULL;
-
-        /* Lets assume each sid is around 54 characters
-         * S-1-5-AAAAAAAAAAA-BBBBBBBBBBB-CCCCCCCCCCC-DDDDDDDDDDD\n */
-        buflen = 54 * num_sids;
-        extra_data = talloc_array(NULL, char, buflen);
+                goto done;
+        }
+
+        wbcSidToStringBuf(dom_sid, request.data.sid, sizeof(request.data.sid));
+
+        /* Lets assume each sid is around 57 characters
+         * S-1-5-21-AAAAAAAAAAA-BBBBBBBBBBB-CCCCCCCCCCC-DDDDDDDDDDD\n */
+        buflen = 57 * num_sids;
+        extra_data = (char *)malloc(buflen);
         if (!extra_data) {
                 wbc_status = WBC_ERR_NO_MEMORY;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                goto done;
         }
 
         /* Build the sid list */
         for (i=0; i<num_sids; i++) {
-                if (sid_string) {
-                        wbcFreeMemory(sid_string);
-                        sid_string = NULL;
-                }
-                wbc_status = wbcSidToString(&sids[i], &sid_string);
-                BAIL_ON_WBC_ERROR(wbc_status);
-
-                sid_len = strlen(sid_string);
+                char sid_str[WBC_SID_STRING_BUFLEN];
+                size_t sid_len;
+
+                sid_len = wbcSidToStringBuf(&sids[i], sid_str, sizeof(sid_str));
 
                 if (buflen < extra_data_len + sid_len + 2) {
                         buflen *= 2;
-                        extra_data = talloc_realloc(NULL, extra_data,
-                            char, buflen);
+                        extra_data = (char *)realloc(extra_data, buflen);
                         if (!extra_data) {
                                 wbc_status = WBC_ERR_NO_MEMORY;
@@ -575 +726 @@
                 }
 
-                strncpy(&extra_data[extra_data_len], sid_string,
+                strncpy(&extra_data[extra_data_len], sid_str,
                         buflen - extra_data_len);
                 extra_data_len += sid_len;
@@ -581 +732 @@
                 extra_data[extra_data_len] = '\0';
         }
+        extra_data_len += 1;
 
         request.extra_data.data = extra_data;
@@ -593 +745 @@
             !response.extra_data.data) {
                 wbc_status = WBC_ERR_INVALID_RESPONSE;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        rids = talloc_array(NULL, uint32_t,
-                            response.data.num_entries);
+                goto done;
+        }
+
+        rids = (uint32_t *)wbcAllocateMemory(response.data.num_entries,
+                                             sizeof(uint32_t), NULL);
         BAIL_ON_PTR_ERROR(sids, wbc_status);
 
@@ -619 +771 @@
 
  done:
-        if (sid_string) {
-                wbcFreeMemory(sid_string);
-        }
-        if (extra_data) {
-                talloc_free(extra_data);
-        }
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (rids) {
-                talloc_free(rids);
-        }
-
+        free(extra_data);
+        winbindd_free_response(&response);
+        wbcFreeMemory(rids);
         return wbc_status;
 }
@@ -663 +805 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
+        users = wbcAllocateStringArray(response.data.num_entries);
+        if (users == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
         /* Look through extra data */
 
         next = (const char *)response.extra_data.data;
         while (next) {
-                const char **tmp;
-                const char *current = next;
-                char *k = strchr(next, ',');
+                const char *current;
+                char *k;
+
+                if (num_users >= response.data.num_entries) {
+                        wbc_status = WBC_ERR_INVALID_RESPONSE;
+                        goto done;
+                }
+
+                current = next;
+                k = strchr(next, ',');
+
                 if (k) {
                         k[0] = '\0';
@@ -677 +832 @@
                 }
 
-                tmp = talloc_realloc(NULL, users,
-                                     const char *,
-                                     num_users+1);
-                BAIL_ON_PTR_ERROR(tmp, wbc_status);
-                users = tmp;
-
-                users[num_users] = talloc_strdup(users, current);
+                users[num_users] = strdup(current);
                 BAIL_ON_PTR_ERROR(users[num_users], wbc_status);
-
-                num_users++;
-        }
-
-        *_num_users = num_users;
+                num_users += 1;
+        }
+        if (num_users != response.data.num_entries) {
+                wbc_status = WBC_ERR_INVALID_RESPONSE;
+                goto done;
+        }
+
+        *_num_users = response.data.num_entries;
         *_users = users;
         users = NULL;
@@ -695 +847 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (users) {
-                talloc_free(users);
-        }
+        winbindd_free_response(&response);
+        wbcFreeMemory(users);
         return wbc_status;
 }
@@ -731 +879 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
+        groups = wbcAllocateStringArray(response.data.num_entries);
+        if (groups == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
         /* Look through extra data */
 
         next = (const char *)response.extra_data.data;
         while (next) {
-                const char **tmp;
-                const char *current = next;
-                char *k = strchr(next, ',');
+                const char *current;
+                char *k;
+
+                if (num_groups >= response.data.num_entries) {
+                        wbc_status = WBC_ERR_INVALID_RESPONSE;
+                        goto done;
+                }
+
+                current = next;
+                k = strchr(next, ',');
+
                 if (k) {
                         k[0] = '\0';
@@ -745 +906 @@
                 }
 
-                tmp = talloc_realloc(NULL, groups,
-                                     const char *,
-                                     num_groups+1);
-                BAIL_ON_PTR_ERROR(tmp, wbc_status);
-                groups = tmp;
-
-                groups[num_groups] = talloc_strdup(groups, current);
+                groups[num_groups] = strdup(current);
                 BAIL_ON_PTR_ERROR(groups[num_groups], wbc_status);
-
-                num_groups++;
-        }
-
-        *_num_groups = num_groups;
+                num_groups += 1;
+        }
+        if (num_groups != response.data.num_entries) {
+                wbc_status = WBC_ERR_INVALID_RESPONSE;
+                goto done;
+        }
+
+        *_num_groups = response.data.num_entries;
         *_groups = groups;
         groups = NULL;
@@ -763 +921 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (groups) {
-                talloc_free(groups);
-        }
+        winbindd_free_response(&response);
+        wbcFreeMemory(groups);
         return wbc_status;
 }
@@ -797 +951 @@
                 wbcFreeMemory(name);
 
-                name = talloc_strdup(NULL, pwd->pw_gecos);
+                name = wbcStrDup(pwd->pw_gecos);
+                wbcFreeMemory(pwd);
                 BAIL_ON_PTR_ERROR(name, wbc_status);
         }

vendor/current/nsswitch/libwbclient/wbc_util.c

@@ -2 +2 @@
    Unix SMB/CIFS implementation.
 
-   Winbind client API
+   Winbind client asynchronous API, utility functions
 
    Copyright (C) Gerald (Jerry) Carter 2007-2008
@@ -25 +25 @@
 #include "replace.h"
 #include "libwbclient.h"
-
-
+#include "../winbind_client.h"
 
 /** @brief Ping winbindd to see if the daemon is running
@@ -32 +31 @@
  * @return #wbcErr
  **/
-
 wbcErr wbcPing(void)
 {
@@ -45 +43 @@
         return wbcRequestResponse(WINBINDD_PING, &request, &response);
 }
+
+static void wbcInterfaceDetailsDestructor(void *ptr)
+{
+        struct wbcInterfaceDetails *i = (struct wbcInterfaceDetails *)ptr;
+        free(i->winbind_version);
+        free(i->netbios_name);
+        free(i->netbios_domain);
+        free(i->dns_domain);
+}
+
+/**
+ * @brief Query useful information about the winbind service
+ *
+ * @param *_details     pointer to hold the struct wbcInterfaceDetails
+ *
+ * @return #wbcErr
+ */
 
 wbcErr wbcInterfaceDetails(struct wbcInterfaceDetails **_details)
@@ -59 +74 @@
         ZERO_STRUCT(response);
 
-        info = talloc(NULL, struct wbcInterfaceDetails);
+        info = (struct wbcInterfaceDetails *)wbcAllocateMemory(
+                1, sizeof(struct wbcInterfaceDetails),
+                wbcInterfaceDetailsDestructor);
         BAIL_ON_PTR_ERROR(info, wbc_status);
 
@@ -71 +88 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        info->winbind_version = talloc_strdup(info,
-                                              response.data.info.samba_version);
+        info->winbind_version = strdup(response.data.info.samba_version);
         BAIL_ON_PTR_ERROR(info->winbind_version, wbc_status);
         info->winbind_separator = response.data.info.winbind_separator;
@@ -80 +96 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        info->netbios_name = talloc_strdup(info,
-                                           response.data.netbios_name);
+        info->netbios_name = strdup(response.data.netbios_name);
         BAIL_ON_PTR_ERROR(info->netbios_name, wbc_status);
 
@@ -88 +103 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        info->netbios_domain = talloc_strdup(info,
-                                        response.data.domain_name);
+        info->netbios_domain = strdup(response.data.domain_name);
         BAIL_ON_PTR_ERROR(info->netbios_domain, wbc_status);
 
@@ -102 +116 @@
 
         if (domain) {
-                info->dns_domain = talloc_strdup(info,
-                                                 domain->dns_name);
+                info->dns_domain = strdup(domain->dns_name);
                 wbcFreeMemory(domain);
                 BAIL_ON_PTR_ERROR(info->dns_domain, wbc_status);
@@ -116 +129 @@
 
 done:
-        talloc_free(info);
-        return wbc_status;
-}
-
-
-/* Lookup the current status of a trusted domain */
+        wbcFreeMemory(info);
+        return wbc_status;
+}
+
+static void wbcDomainInfoDestructor(void *ptr)
+{
+        struct wbcDomainInfo *i = (struct wbcDomainInfo *)ptr;
+        free(i->short_name);
+        free(i->dns_name);
+}
+
+/** @brief Lookup the current status of a trusted domain, sync wrapper
+ *
+ * @param domain      Domain to query
+ * @param *dinfo       Pointer to returned struct wbcDomainInfo
+ *
+ * @return #wbcErr
+ */
+
 wbcErr wbcDomainInfo(const char *domain, struct wbcDomainInfo **dinfo)
 {
@@ -147 +173 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        info = talloc(NULL, struct wbcDomainInfo);
+        info = (struct wbcDomainInfo *)wbcAllocateMemory(
+                1, sizeof(struct wbcDomainInfo), wbcDomainInfoDestructor);
         BAIL_ON_PTR_ERROR(info, wbc_status);
 
-        info->short_name = talloc_strdup(info,
-                                         response.data.domain_info.name);
+        info->short_name = strdup(response.data.domain_info.name);
         BAIL_ON_PTR_ERROR(info->short_name, wbc_status);
 
-        info->dns_name = talloc_strdup(info,
-                                       response.data.domain_info.alt_name);
+        info->dns_name = strdup(response.data.domain_info.alt_name);
         BAIL_ON_PTR_ERROR(info->dns_name, wbc_status);
 
@@ -170 +195 @@
 
         *dinfo = info;
+        info = NULL;
 
         wbc_status = WBC_ERR_SUCCESS;
 
  done:
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                talloc_free(info);
-        }
-
-        return wbc_status;
-}
-
+        wbcFreeMemory(info);
+        return wbc_status;
+}
+
+/* Get the list of current DCs */
+wbcErr wbcDcInfo(const char *domain, size_t *num_dcs,
+                 const char ***dc_names, const char ***dc_ips)
+{
+        struct winbindd_request request;
+        struct winbindd_response response;
+        const char **names = NULL;
+        const char **ips = NULL;
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        size_t extra_len;
+        int i;
+        char *p;
+
+        /* Initialise request */
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        if (domain != NULL) {
+                strncpy(request.domain_name, domain,
+                        sizeof(request.domain_name) - 1);
+        }
+
+        wbc_status = wbcRequestResponse(WINBINDD_DC_INFO,
+                                        &request, &response);
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        names = wbcAllocateStringArray(response.data.num_entries);
+        BAIL_ON_PTR_ERROR(names, wbc_status);
+
+        ips = wbcAllocateStringArray(response.data.num_entries);
+        BAIL_ON_PTR_ERROR(ips, wbc_status);
+
+        wbc_status = WBC_ERR_INVALID_RESPONSE;
+
+        p = (char *)response.extra_data.data;
+
+        if (response.length < (sizeof(struct winbindd_response)+1)) {
+                goto done;
+        }
+
+        extra_len = response.length - sizeof(struct winbindd_response);
+
+        if (p[extra_len-1] != '\0') {
+                goto done;
+        }
+
+        for (i=0; i<response.data.num_entries; i++) {
+                char *q;
+
+                q = strchr(p, '\n');
+                if (q == NULL) {
+                        goto done;
+                }
+                names[i] = strndup(p, q-p);
+                BAIL_ON_PTR_ERROR(names[i], wbc_status);
+                p = q+1;
+
+                q = strchr(p, '\n');
+                if (q == NULL) {
+                        goto done;
+                }
+                ips[i] = strndup(p, q-p);
+                BAIL_ON_PTR_ERROR(ips[i], wbc_status);
+                p = q+1;
+        }
+        if (p[0] != '\0') {
+                goto done;
+        }
+
+        wbc_status = WBC_ERR_SUCCESS;
+done:
+        if (response.extra_data.data)
+                free(response.extra_data.data);
+
+        if (WBC_ERROR_IS_OK(wbc_status)) {
+                *num_dcs = response.data.num_entries;
+                *dc_names = names;
+                names = NULL;
+                *dc_ips = ips;
+                ips = NULL;
+        }
+        wbcFreeMemory(names);
+        wbcFreeMemory(ips);
+        return wbc_status;
+}
 
 /* Resolve a NetbiosName via WINS */
@@ -205 +314 @@
         /* Display response */
 
-        ipaddr = talloc_strdup(NULL, response.data.winsresp);
+        ipaddr = wbcStrDup(response.data.winsresp);
         BAIL_ON_PTR_ERROR(ipaddr, wbc_status);
 
@@ -238 +347 @@
         /* Display response */
 
-        name_str = talloc_strdup(NULL, response.data.winsresp);
+        name_str = wbcStrDup(response.data.winsresp);
         BAIL_ON_PTR_ERROR(name_str, wbc_status);
 
@@ -251 +360 @@
  */
 
-static wbcErr process_domain_info_string(TALLOC_CTX *ctx,
-                                         struct wbcDomainInfo *info,
+static wbcErr process_domain_info_string(struct wbcDomainInfo *info,
                                          char *info_string)
 {
@@ -258 +366 @@
         char *r = NULL;
         char *s = NULL;
-
-        if (!info || !info_string) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        ZERO_STRUCTP(info);
 
         r = info_string;
@@ -276 +377 @@
         s++;
 
-        info->short_name = talloc_strdup(ctx, r);
+        info->short_name = strdup(r);
         BAIL_ON_PTR_ERROR(info->short_name, wbc_status);
 
@@ -289 +390 @@
         s++;
 
-        info->dns_name = talloc_strdup(ctx, r);
+        info->dns_name = strdup(r);
         BAIL_ON_PTR_ERROR(info->dns_name, wbc_status);
 
@@ -382 +483 @@
 }
 
+static void wbcDomainInfoListDestructor(void *ptr)
+{
+        struct wbcDomainInfo *i = (struct wbcDomainInfo *)ptr;
+
+        while (i->short_name != NULL) {
+                free(i->short_name);
+                free(i->dns_name);
+                i += 1;
+        }
+}
+
 /* Enumerate the domain trusts known by Winbind */
 wbcErr wbcListTrusts(struct wbcDomainInfo **domains, size_t *num_domains)
@@ -388 +500 @@
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
         char *p = NULL;
-        char *q = NULL;
         char *extra_data = NULL;
-        int count = 0;
         struct wbcDomainInfo *d_list = NULL;
         int i = 0;
@@ -418 +528 @@
         }
 
-        /* Count number of domains */
-
-        count = 0;
-        while (p) {
-                count++;
-
-                if ((q = strchr(p, '\n')) != NULL)
-                        q++;
-                p = q;
-        }
-
-        d_list = talloc_array(NULL, struct wbcDomainInfo, count);
+        d_list = (struct wbcDomainInfo *)wbcAllocateMemory(
+                response.data.num_entries + 1,sizeof(struct wbcDomainInfo),
+                wbcDomainInfoListDestructor);
         BAIL_ON_PTR_ERROR(d_list, wbc_status);
 
@@ -439 +540 @@
         /* Outer loop processes the list of domain information */
 
-        for (i=0; i<count && p; i++) {
+        for (i=0; i<response.data.num_entries && p; i++) {
                 char *next = strchr(p, '\n');
 
@@ -447 +548 @@
                 }
 
-                wbc_status = process_domain_info_string(d_list, &d_list[i], p);
+                wbc_status = process_domain_info_string(&d_list[i], p);
                 BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -454 +555 @@
 
         *domains = d_list;
+        d_list = NULL;
         *num_domains = i;
 
  done:
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                if (d_list)
-                        talloc_free(d_list);
-                if (extra_data)
-                        free(extra_data);
-        }
-
-        return wbc_status;
+        winbindd_free_response(&response);
+        wbcFreeMemory(d_list);
+        free(extra_data);
+        return wbc_status;
+}
+
+static void wbcDomainControllerInfoDestructor(void *ptr)
+{
+        struct wbcDomainControllerInfo *i =
+                (struct wbcDomainControllerInfo *)ptr;
+        free(i->dc_name);
 }
 
@@ -492 +597 @@
         request.flags = flags;
 
-        dc = talloc(NULL, struct wbcDomainControllerInfo);
+        dc = (struct wbcDomainControllerInfo *)wbcAllocateMemory(
+                 1, sizeof(struct wbcDomainControllerInfo),
+                wbcDomainControllerInfoDestructor);
         BAIL_ON_PTR_ERROR(dc, wbc_status);
 
@@ -502 +609 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        dc->dc_name = talloc_strdup(dc, response.data.dsgetdcname.dc_unc);
+        dc->dc_name = strdup(response.data.dsgetdcname.dc_unc);
         BAIL_ON_PTR_ERROR(dc->dc_name, wbc_status);
 
         *dc_info = dc;
+        dc = NULL;
 
 done:
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                talloc_free(dc);
-        }
-
-        return wbc_status;
-}
-
-static wbcErr wbc_create_domain_controller_info_ex(TALLOC_CTX *mem_ctx,
-                                                   const struct winbindd_response *resp,
+        wbcFreeMemory(dc);
+        return wbc_status;
+}
+
+static void wbcDomainControllerInfoExDestructor(void *ptr)
+{
+        struct wbcDomainControllerInfoEx *i =
+                (struct wbcDomainControllerInfoEx *)ptr;
+        free((char *)(i->dc_unc));
+        free((char *)(i->dc_address));
+        free((char *)(i->domain_guid));
+        free((char *)(i->domain_name));
+        free((char *)(i->forest_name));
+        free((char *)(i->dc_site_name));
+        free((char *)(i->client_site_name));
+}
+
+static wbcErr wbc_create_domain_controller_info_ex(const struct winbindd_response *resp,
                                                    struct wbcDomainControllerInfoEx **_i)
 {
@@ -523 +640 @@
         struct wbcGuid guid;
 
-        i = talloc(mem_ctx, struct wbcDomainControllerInfoEx);
+        i = (struct wbcDomainControllerInfoEx *)wbcAllocateMemory(
+                1, sizeof(struct wbcDomainControllerInfoEx),
+                wbcDomainControllerInfoExDestructor);
         BAIL_ON_PTR_ERROR(i, wbc_status);
 
-        i->dc_unc = talloc_strdup(i, resp->data.dsgetdcname.dc_unc);
+        i->dc_unc = strdup(resp->data.dsgetdcname.dc_unc);
         BAIL_ON_PTR_ERROR(i->dc_unc, wbc_status);
 
-        i->dc_address = talloc_strdup(i, resp->data.dsgetdcname.dc_address);
+        i->dc_address = strdup(resp->data.dsgetdcname.dc_address);
         BAIL_ON_PTR_ERROR(i->dc_address, wbc_status);
 
@@ -536 +655 @@
         wbc_status = wbcStringToGuid(resp->data.dsgetdcname.domain_guid, &guid);
         if (WBC_ERROR_IS_OK(wbc_status)) {
-                i->domain_guid = talloc(i, struct wbcGuid);
+                i->domain_guid = (struct wbcGuid *)malloc(
+                        sizeof(struct wbcGuid));
                 BAIL_ON_PTR_ERROR(i->domain_guid, wbc_status);
 
                 *i->domain_guid = guid;
-        } else {
-                i->domain_guid = NULL;
-        }
-
-        i->domain_name = talloc_strdup(i, resp->data.dsgetdcname.domain_name);
+        }
+
+        i->domain_name = strdup(resp->data.dsgetdcname.domain_name);
         BAIL_ON_PTR_ERROR(i->domain_name, wbc_status);
 
         if (resp->data.dsgetdcname.forest_name[0] != '\0') {
-                i->forest_name = talloc_strdup(i,
-                        resp->data.dsgetdcname.forest_name);
+                i->forest_name = strdup(resp->data.dsgetdcname.forest_name);
                 BAIL_ON_PTR_ERROR(i->forest_name, wbc_status);
-        } else {
-                i->forest_name = NULL;
         }
 
@@ -558 +673 @@
 
         if (resp->data.dsgetdcname.dc_site_name[0] != '\0') {
-                i->dc_site_name = talloc_strdup(i,
-                        resp->data.dsgetdcname.dc_site_name);
+                i->dc_site_name = strdup(resp->data.dsgetdcname.dc_site_name);
                 BAIL_ON_PTR_ERROR(i->dc_site_name, wbc_status);
-        } else {
-                i->dc_site_name = NULL;
         }
 
         if (resp->data.dsgetdcname.client_site_name[0] != '\0') {
-                i->client_site_name = talloc_strdup(i,
+                i->client_site_name = strdup(
                         resp->data.dsgetdcname.client_site_name);
                 BAIL_ON_PTR_ERROR(i->client_site_name, wbc_status);
-        } else {
-                i->client_site_name = NULL;
         }
 
@@ -577 +687 @@
 
 done:
-        talloc_free(i);
+        if (i != NULL) {
+                wbcFreeMemory(i);
+        }
         return wbc_status;
 }
@@ -632 +744 @@
 
         if (dc_info) {
-                wbc_status = wbc_create_domain_controller_info_ex(NULL,
-                                                                  &response,
+                wbc_status = wbc_create_domain_controller_info_ex(&response,
                                                                   dc_info);
                 BAIL_ON_WBC_ERROR(wbc_status);
@@ -643 +754 @@
 }
 
+static void wbcNamedBlobDestructor(void *ptr)
+{
+        struct wbcNamedBlob *b = (struct wbcNamedBlob *)ptr;
+
+        while (b->name != NULL) {
+                free((char *)(b->name));
+                free(b->blob.data);
+                b += 1;
+        }
+}
+
 /* Initialize a named blob and add to list of blobs */
 wbcErr wbcAddNamedBlob(size_t *num_blobs,
-                       struct wbcNamedBlob **blobs,
+                       struct wbcNamedBlob **pblobs,
                        const char *name,
                        uint32_t flags,
@@ -652 +774 @@
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        struct wbcNamedBlob blob;
-
-        *blobs = talloc_realloc(NULL, *blobs, struct wbcNamedBlob,
-                                *(num_blobs)+1);
-        BAIL_ON_PTR_ERROR(*blobs, wbc_status);
-
-        blob.name               = talloc_strdup(*blobs, name);
-        BAIL_ON_PTR_ERROR(blob.name, wbc_status);
-        blob.flags              = flags;
-        blob.blob.length        = length;
-        blob.blob.data          = (uint8_t *)talloc_memdup(*blobs, data, length);
-        BAIL_ON_PTR_ERROR(blob.blob.data, wbc_status);
-
-        (*(blobs))[*num_blobs] = blob;
-        *(num_blobs) += 1;
+        struct wbcNamedBlob *blobs, *blob;
+
+        if (name == NULL) {
+                return WBC_ERR_INVALID_PARAM;
+        }
+
+        /*
+         * Overallocate the b->name==NULL terminator for
+         * wbcNamedBlobDestructor
+         */
+        blobs = (struct wbcNamedBlob *)wbcAllocateMemory(
+                *num_blobs + 2, sizeof(struct wbcNamedBlob),
+                wbcNamedBlobDestructor);
+
+        if (blobs == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
+        if (*pblobs != NULL) {
+                struct wbcNamedBlob *old = *pblobs;
+                memcpy(blobs, old, sizeof(struct wbcNamedBlob) * (*num_blobs));
+                if (*num_blobs != 0) {
+                        /* end indicator for wbcNamedBlobDestructor */
+                        old[0].name = NULL;
+                }
+                wbcFreeMemory(old);
+        }
+        *pblobs = blobs;
+
+        blob = &blobs[*num_blobs];
+
+        blob->name = strdup(name);
+        BAIL_ON_PTR_ERROR(blob->name, wbc_status);
+        blob->flags = flags;
+
+        blob->blob.length = length;
+        blob->blob.data = (uint8_t *)malloc(length);
+        BAIL_ON_PTR_ERROR(blob->blob.data, wbc_status);
+        memcpy(blob->blob.data, data, length);
+
+        *num_blobs += 1;
+        *pblobs = blobs;
+        blobs = NULL;
 
         wbc_status = WBC_ERR_SUCCESS;
 done:
-        if (!WBC_ERROR_IS_OK(wbc_status) && blobs) {
-                wbcFreeMemory(*blobs);
-        }
-        return wbc_status;
-}
+        wbcFreeMemory(blobs);
+        return wbc_status;
+}

vendor/current/nsswitch/libwbclient/wbclient.c

@@ -24 +24 @@
 
 #include "replace.h"
-#include "talloc.h"
-#include "tevent.h"
 #include "libwbclient.h"
 
@@ -37 +35 @@
                                           struct winbindd_response *response);
 
-/** @brief Wrapper around Winbind's send/receive API call
- *
- * @param cmd       Winbind command operation to perform
- * @param request   Send structure
- * @param response  Receive structure
- *
- * @return #wbcErr
- **/
-
-/**********************************************************************
+/*
  result == NSS_STATUS_UNAVAIL: winbind not around
  result == NSS_STATUS_NOTFOUND: winbind around, but domain missing
@@ -57 +46 @@
 
  --Volker
-**********************************************************************/
+*/
 
 static wbcErr wbcRequestResponseInt(
@@ -92 +81 @@
 }
 
+/**
+ * @brief Wrapper around Winbind's send/receive API call
+ *
+ * @param cmd       Winbind command operation to perform
+ * @param request   Send structure
+ * @param response  Receive structure
+ *
+ * @return #wbcErr
+ */
 wbcErr wbcRequestResponse(int cmd,
                           struct winbindd_request *request,
@@ -150 +148 @@
 }
 
+#define WBC_MAGIC (0x7a2b0e1e)
+#define WBC_MAGIC_FREE (0x875634fe)
+
+struct wbcMemPrefix {
+        uint32_t magic;
+        void (*destructor)(void *ptr);
+};
+
+static size_t wbcPrefixLen(void)
+{
+        size_t result = sizeof(struct wbcMemPrefix);
+        return (result + 15) & ~15;
+}
+
+static struct wbcMemPrefix *wbcMemToPrefix(void *ptr)
+{
+        return (struct wbcMemPrefix *)(((char *)ptr) - wbcPrefixLen());
+}
+
+void *wbcAllocateMemory(size_t nelem, size_t elsize,
+                        void (*destructor)(void *ptr))
+{
+        struct wbcMemPrefix *result;
+
+        if (nelem >= (2<<24)/elsize) {
+                /* basic protection against integer wrap */
+                return NULL;
+        }
+
+        result = (struct wbcMemPrefix *)calloc(
+                1, nelem*elsize + wbcPrefixLen());
+        if (result == NULL) {
+                return NULL;
+        }
+        result->magic = WBC_MAGIC;
+        result->destructor = destructor;
+        return ((char *)result) + wbcPrefixLen();
+}
+
 /* Free library allocated memory */
 void wbcFreeMemory(void *p)
 {
-        if (p)
-                talloc_free(p);
-
+        struct wbcMemPrefix *wbcMem;
+
+        if (p == NULL) {
+                return;
+        }
+        wbcMem = wbcMemToPrefix(p);
+        if (wbcMem->magic != WBC_MAGIC) {
+                return;
+        }
+
+        /* paranoid check to ensure we don't double free */
+        wbcMem->magic = WBC_MAGIC_FREE;
+
+        if (wbcMem->destructor != NULL) {
+                wbcMem->destructor(p);
+        }
+        free(wbcMem);
         return;
 }
 
+char *wbcStrDup(const char *str)
+{
+        char *result;
+        size_t len;
+
+        len = strlen(str);
+        result = (char *)wbcAllocateMemory(len+1, sizeof(char), NULL);
+        if (result == NULL) {
+                return NULL;
+        }
+        memcpy(result, str, len+1);
+        return result;
+}
+
+static void wbcStringArrayDestructor(void *ptr)
+{
+        char **p = (char **)ptr;
+        while (*p != NULL) {
+                free(*p);
+                p += 1;
+        }
+}
+
+const char **wbcAllocateStringArray(int num_strings)
+{
+        return (const char **)wbcAllocateMemory(
+                num_strings + 1, sizeof(const char *),
+                wbcStringArrayDestructor);
+}
+
 wbcErr wbcLibraryDetails(struct wbcLibraryDetails **_details)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
         struct wbcLibraryDetails *info;
 
-        info = talloc(NULL, struct wbcLibraryDetails);
-        BAIL_ON_PTR_ERROR(info, wbc_status);
+        info = (struct wbcLibraryDetails *)wbcAllocateMemory(
+                1, sizeof(struct wbcLibraryDetails), NULL);
+
+        if (info == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
 
         info->major_version = WBCLIENT_MAJOR_VERSION;
         info->minor_version = WBCLIENT_MINOR_VERSION;
-        info->vendor_version = talloc_strdup(info,
-                                             WBCLIENT_VENDOR_VERSION);
-        BAIL_ON_PTR_ERROR(info->vendor_version, wbc_status);
+        info->vendor_version = WBCLIENT_VENDOR_VERSION;
 
         *_details = info;
-        info = NULL;
-
-        wbc_status = WBC_ERR_SUCCESS;
-
-done:
-        talloc_free(info);
-        return wbc_status;
-}
+        return WBC_ERR_SUCCESS;
+}

vendor/current/nsswitch/libwbclient/wbclient.h

@@ -66 +66 @@
  *  0.4: Added wbcSidTypeString()
  *  0.5: Added wbcChangeTrustCredentials()
+ *  0.6: Made struct wbcInterfaceDetails char* members non-const
+ *  0.7: Added wbcSidToStringBuf()
+ *  0.8: Added wbcSidsToUnixIds() and wbcLookupSids()
  **/
 #define WBCLIENT_MAJOR_VERSION 0
-#define WBCLIENT_MINOR_VERSION 5
+#define WBCLIENT_MINOR_VERSION 8
 #define WBCLIENT_VENDOR_VERSION "Samba libwbclient"
 struct wbcLibraryDetails {
@@ -82 +85 @@
 struct wbcInterfaceDetails {
         uint32_t interface_version;
-        const char *winbind_version;
+        char *winbind_version;
         char winbind_separator;
-        const char *netbios_name;
-        const char *netbios_domain;
-        const char *dns_domain;
+        char *netbios_name;
+        char *netbios_domain;
+        char *dns_domain;
 };
 
@@ -191 +194 @@
 #define WBC_DOMINFO_TRUSTTYPE_IN_FOREST  0x00000002
 #define WBC_DOMINFO_TRUSTTYPE_EXTERNAL   0x00000003
-
 
 /**
@@ -430 +432 @@
 
 enum wbcPasswordChangeRejectReason {
-        WBC_PWD_CHANGE_REJECT_OTHER=0,
-        WBC_PWD_CHANGE_REJECT_TOO_SHORT=1,
-        WBC_PWD_CHANGE_REJECT_IN_HISTORY=2,
-        WBC_PWD_CHANGE_REJECT_COMPLEXITY=5
-};
+        WBC_PWD_CHANGE_NO_ERROR=0,
+        WBC_PWD_CHANGE_PASSWORD_TOO_SHORT=1,
+        WBC_PWD_CHANGE_PWD_IN_HISTORY=2,
+        WBC_PWD_CHANGE_USERNAME_IN_PASSWORD=3,
+        WBC_PWD_CHANGE_FULLNAME_IN_PASSWORD=4,
+        WBC_PWD_CHANGE_NOT_COMPLEX=5,
+        WBC_PWD_CHANGE_MACHINE_NOT_DEFAULT=6,
+        WBC_PWD_CHANGE_FAILED_BY_FILTER=7,
+        WBC_PWD_CHANGE_PASSWORD_TOO_LONG=8
+};
+
+/* Note: this defines exist for compatibility reasons with existing code */
+#define WBC_PWD_CHANGE_REJECT_OTHER      WBC_PWD_CHANGE_NO_ERROR
+#define WBC_PWD_CHANGE_REJECT_TOO_SHORT  WBC_PWD_CHANGE_PASSWORD_TOO_SHORT
+#define WBC_PWD_CHANGE_REJECT_IN_HISTORY WBC_PWD_CHANGE_PWD_IN_HISTORY
+#define WBC_PWD_CHANGE_REJECT_COMPLEXITY WBC_PWD_CHANGE_NOT_COMPLEX
 
 /**
@@ -519 +532 @@
 const char* wbcSidTypeString(enum wbcSidType type);
 
+#define WBC_SID_STRING_BUFLEN (15*11+25)
+
+/*
+ * @brief Print a sid into a buffer
+ *
+ * @param sid           Binary Security Identifier
+ * @param buf           Target buffer
+ * @param buflen        Target buffer length
+ *
+ * @return Resulting string length.
+ */
+int wbcSidToStringBuf(const struct wbcDomainSid *sid, char *buf, int buflen);
+
 /**
  * @brief Convert a binary SID to a character string
@@ -611 +637 @@
                     char **name,
                     enum wbcSidType *name_type);
+
+struct wbcTranslatedName {
+        enum wbcSidType type;
+        char *name;
+        int domain_index;
+};
+
+wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
+                     struct wbcDomainInfo **domains, int *num_domains,
+                     struct wbcTranslatedName **names);
 
 /**
@@ -758 +794 @@
                         struct wbcDomainSid *sid);
 
+enum wbcIdType {
+        WBC_ID_TYPE_NOT_SPECIFIED,
+        WBC_ID_TYPE_UID,
+        WBC_ID_TYPE_GID
+};
+
+union wbcUnixIdContainer {
+        uid_t uid;
+        gid_t gid;
+};
+
+struct wbcUnixId {
+        enum wbcIdType type;
+        union wbcUnixIdContainer id;
+};
+
+/**
+ * @brief Convert a list of sids to unix ids
+ *
+ * @param sids        Pointer to an array of SIDs to convert
+ * @param num_sids    Number of SIDs
+ * @param ids         Preallocated output array for translated IDs
+ *
+ * @return #wbcErr
+ *
+ **/
+wbcErr wbcSidsToUnixIds(const struct wbcDomainSid *sids, uint32_t num_sids,
+                        struct wbcUnixId *ids);
+
 /**
  * @brief Obtain a new uid from Winbind
@@ -783 +848 @@
  *
  * @return #wbcErr
+ *
+ * @deprecated      This method is not impemented any more and should
+ *                  be removed in the next major version change.
  **/
 wbcErr wbcSetUidMapping(uid_t uid, const struct wbcDomainSid *sid);
@@ -793 +861 @@
  *
  * @return #wbcErr
+ *
+ * @deprecated      This method is not impemented any more and should
+ *                  be removed in the next major version change.
  **/
 wbcErr wbcSetGidMapping(gid_t gid, const struct wbcDomainSid *sid);
@@ -803 +874 @@
  *
  * @return #wbcErr
+ *
+ * @deprecated      This method is not impemented any more and should
+ *                  be removed in the next major version change.
  **/
 wbcErr wbcRemoveUidMapping(uid_t uid, const struct wbcDomainSid *sid);
@@ -813 +887 @@
  *
  * @return #wbcErr
+ *
+ * @deprecated      This method is not impemented any more and should
+ *                  be removed in the next major version change.
  **/
 wbcErr wbcRemoveGidMapping(gid_t gid, const struct wbcDomainSid *sid);
@@ -822 +899 @@
  *
  * @return #wbcErr
+ *
+ * @deprecated      This method is not impemented any more and should
+ *                  be removed in the next major version change.
  **/
 wbcErr wbcSetUidHwm(uid_t uid_hwm);
@@ -831 +911 @@
  *
  * @return #wbcErr
+ *
+ * @deprecated      This method is not impemented any more and should
+ *                  be removed in the next major version change.
  **/
 wbcErr wbcSetGidHwm(gid_t gid_hwm);
@@ -971 +1054 @@
  * @brief Lookup the current status of a trusted domain
  *
- * @param domain      Domain to query
- * @param *info       Pointer to returned domain_info struct
+ * @param domain        The domain to query
+ *
+ * @param dinfo          A pointer to store the returned domain_info struct.
  *
  * @return #wbcErr
  **/
 wbcErr wbcDomainInfo(const char *domain,
-                     struct wbcDomainInfo **info);
+                     struct wbcDomainInfo **dinfo);
+
+/**
+ * @brief Lookup the currently contacted DCs
+ *
+ * @param domain        The domain to query
+ *
+ * @param num_dcs       Number of DCs currently known
+ * @param dc_names      Names of the currently known DCs
+ * @param dc_ips        IP addresses of the currently known DCs
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcDcInfo(const char *domain, size_t *num_dcs,
+                 const char ***dc_names, const char ***dc_ips);
 
 /**

vendor/current/nsswitch/libwbclient/wbclient_internal.h

@@ -33 +33 @@
                               struct winbindd_response *response);
 
+void *wbcAllocateMemory(size_t nelem, size_t elsize,
+                        void (*destructor)(void *ptr));
+
+char *wbcStrDup(const char *str);
+const char **wbcAllocateStringArray(int num_strings);
+
 #endif      /* _WBCLIENT_INTERNAL_H */

vendor/current/nsswitch/nsstest.c

@@ -3 +3 @@
    nss tester for winbindd
    Copyright (C) Andrew Tridgell 2001
+   Copyright (C) Tim Potter 2003
 
    This program is free software; you can redistribute it and/or modify
@@ -18 +19 @@
 */
 
-#include "includes.h"
-
+#include "replace.h"
 #include "nsswitch/nsstest.h"
 
@@ -30 +30 @@
 static void *find_fn(const char *name)
 {
-        char s[1024];
+        char *s;
         static void *h;
         void *res;
 
-        snprintf(s,sizeof(s), "_nss_%s_%s", nss_name, name);
+        if (asprintf(&s, "_nss_%s_%s", nss_name, name) < 0) {
+                exit(1);
+        }
 
         if (!h) {
@@ -46 +48 @@
         if (!res) {
                 printf("Can't find function %s\n", s);
-                return NULL;
-        }
+                total_errors++;
+                free(s);
+                return NULL;
+        }
+        free(s);
         return res;
 }
@@ -62 +67 @@
 {
         NSS_STATUS (*_nss_getpwent_r)(struct passwd *, char *,
-                                      size_t , int *) = find_fn("getpwent_r");
+                                      size_t , int *) =
+                (NSS_STATUS (*)(struct passwd *, char *,
+                                size_t, int *))find_fn("getpwent_r");
         static struct passwd pwd;
         static char buf[1000];
         NSS_STATUS status;
 
+        if (!_nss_getpwent_r)
+                return NULL;
+
         status = _nss_getpwent_r(&pwd, buf, sizeof(buf), &nss_errno);
         if (status == NSS_STATUS_NOTFOUND) {
@@ -81 +91 @@
 {
         NSS_STATUS (*_nss_getpwnam_r)(const char *, struct passwd *, char *,
-                                      size_t , int *) = find_fn("getpwnam_r");
+                                      size_t , int *) =
+                (NSS_STATUS (*)(const char *, struct passwd *, char *,
+                                size_t, int *))find_fn("getpwnam_r");
         static struct passwd pwd;
         static char buf[1000];
         NSS_STATUS status;
 
+        if (!_nss_getpwnam_r)
+                return NULL;
+
         status = _nss_getpwnam_r(name, &pwd, buf, sizeof(buf), &nss_errno);
         if (status == NSS_STATUS_NOTFOUND) {
@@ -100 +115 @@
 {
         NSS_STATUS (*_nss_getpwuid_r)(uid_t , struct passwd *, char *,
-                                      size_t , int *) = find_fn("getpwuid_r");
+                                      size_t , int *) =
+                (NSS_STATUS (*)(uid_t, struct passwd *, char *,
+                                size_t, int *))find_fn("getpwuid_r");
         static struct passwd pwd;
         static char buf[1000];
         NSS_STATUS status;
 
+        if (!_nss_getpwuid_r)
+                return NULL;
+
         status = _nss_getpwuid_r(uid, &pwd, buf, sizeof(buf), &nss_errno);
         if (status == NSS_STATUS_NOTFOUND) {
@@ -118 +138 @@
 static void nss_setpwent(void)
 {
-        NSS_STATUS (*_nss_setpwent)(void) = find_fn("setpwent");
-        NSS_STATUS status;
+        NSS_STATUS (*_nss_setpwent)(void) =
+                (NSS_STATUS(*)(void))find_fn("setpwent");
+        NSS_STATUS status;
+
+        if (!_nss_setpwent)
+                return;
+
         status = _nss_setpwent();
         if (status != NSS_STATUS_SUCCESS) {
@@ -128 +153 @@
 static void nss_endpwent(void)
 {
-        NSS_STATUS (*_nss_endpwent)(void) = find_fn("endpwent");
-        NSS_STATUS status;
+        NSS_STATUS (*_nss_endpwent)(void) =
+                (NSS_STATUS (*)(void))find_fn("endpwent");
+        NSS_STATUS status;
+
+        if (!_nss_endpwent)
+                return;
+
         status = _nss_endpwent();
         if (status != NSS_STATUS_SUCCESS) {
@@ -140 +170 @@
 {
         NSS_STATUS (*_nss_getgrent_r)(struct group *, char *,
-                                      size_t , int *) = find_fn("getgrent_r");
+                                      size_t , int *) =
+                (NSS_STATUS (*)(struct group *, char *,
+                                size_t, int *))find_fn("getgrent_r");
         static struct group grp;
         static char *buf;
@@ -146 +178 @@
         NSS_STATUS status;
 
-        if (!buf) buf = malloc_array_p(char, buflen);
+        if (!_nss_getgrent_r)
+                return NULL;
+
+        if (!buf)
+                buf = (char *)malloc(buflen);
 
 again:
@@ -152 +188 @@
         if (status == NSS_STATUS_TRYAGAIN) {
                 buflen *= 2;
-                buf = realloc_p(buf, char, buflen);
+                buf = (char *)realloc(buf, buflen);
+                if (!buf) {
+                        return NULL;
+                }
                 goto again;
         }
         if (status == NSS_STATUS_NOTFOUND) {
+                free(buf);
                 return NULL;
         }
         if (status != NSS_STATUS_SUCCESS) {
                 report_nss_error("getgrent", status);
+                free(buf);
                 return NULL;
         }
@@ -168 +209 @@
 {
         NSS_STATUS (*_nss_getgrnam_r)(const char *, struct group *, char *,
-                                      size_t , int *) = find_fn("getgrnam_r");
+                                      size_t , int *) =
+                (NSS_STATUS (*)(const char *, struct group *, char *,
+                                size_t, int *))find_fn("getgrnam_r");
         static struct group grp;
         static char *buf;
@@ -174 +217 @@
         NSS_STATUS status;
 
-        if (!buf) buf = malloc_array_p(char, buflen);
+        if (!_nss_getgrnam_r)
+                return NULL;
+
+        if (!buf)
+                buf = (char *)malloc(buflen);
 again:
         status = _nss_getgrnam_r(name, &grp, buf, buflen, &nss_errno);
         if (status == NSS_STATUS_TRYAGAIN) {
                 buflen *= 2;
-                buf = realloc_p(buf, char, buflen);
+                buf = (char *)realloc(buf, buflen);
+                if (!buf) {
+                        return NULL;
+                }
                 goto again;
         }
         if (status == NSS_STATUS_NOTFOUND) {
+                free(buf);
                 return NULL;
         }
         if (status != NSS_STATUS_SUCCESS) {
                 report_nss_error("getgrnam", status);
+                free(buf);
                 return NULL;
         }
@@ -195 +247 @@
 {
         NSS_STATUS (*_nss_getgrgid_r)(gid_t , struct group *, char *,
-                                      size_t , int *) = find_fn("getgrgid_r");
+                                      size_t , int *) =
+                (NSS_STATUS (*)(gid_t, struct group *, char *,
+                                size_t, int *))find_fn("getgrgid_r");
         static struct group grp;
         static char *buf;
@@ -201 +255 @@
         NSS_STATUS status;
 
-        if (!buf) buf = malloc_array_p(char, buflen);
+        if (!_nss_getgrgid_r)
+                return NULL;
+
+        if (!buf)
+                buf = (char *)malloc(buflen);
+
 again:
         status = _nss_getgrgid_r(gid, &grp, buf, buflen, &nss_errno);
         if (status == NSS_STATUS_TRYAGAIN) {
                 buflen *= 2;
-                buf = realloc_p(buf, char, buflen);
+                buf = (char *)realloc(buf, buflen);
+                if (!buf) {
+                        return NULL;
+                }
                 goto again;
         }
         if (status == NSS_STATUS_NOTFOUND) {
+                free(buf);
                 return NULL;
         }
         if (status != NSS_STATUS_SUCCESS) {
                 report_nss_error("getgrgid", status);
+                free(buf);
                 return NULL;
         }
@@ -221 +285 @@
 static void nss_setgrent(void)
 {
-        NSS_STATUS (*_nss_setgrent)(void) = find_fn("setgrent");
-        NSS_STATUS status;
+        NSS_STATUS (*_nss_setgrent)(void) =
+                (NSS_STATUS (*)(void))find_fn("setgrent");
+        NSS_STATUS status;
+
+        if (!_nss_setgrent)
+                return;
+
         status = _nss_setgrent();
         if (status != NSS_STATUS_SUCCESS) {
@@ -231 +300 @@
 static void nss_endgrent(void)
 {
-        NSS_STATUS (*_nss_endgrent)(void) = find_fn("endgrent");
-        NSS_STATUS status;
+        NSS_STATUS (*_nss_endgrent)(void) =
+                (NSS_STATUS (*)(void))find_fn("endgrent");
+        NSS_STATUS status;
+
+        if (!_nss_endgrent)
+                return;
+
         status = _nss_endgrent();
         if (status != NSS_STATUS_SUCCESS) {
@@ -243 +317 @@
         NSS_STATUS (*_nss_initgroups)(char *, gid_t , long int *,
                                       long int *, gid_t **, long int , int *) =
-                find_fn("initgroups_dyn");
-        NSS_STATUS status;
-
-        if (!_nss_initgroups) return NSS_STATUS_UNAVAIL;
+                (NSS_STATUS (*)(char *, gid_t, long int *,
+                                long int *, gid_t **,
+                                long int, int *))find_fn("initgroups_dyn");
+        NSS_STATUS status;
+
+        if (!_nss_initgroups)
+                return NSS_STATUS_UNAVAIL;
 
         status = _nss_initgroups(user, group, start, size, groups, 0, &nss_errno);
@@ -257 +334 @@
 static void print_passwd(struct passwd *pwd)
 {
-        printf("%s:%s:%d:%d:%s:%s:%s\n",
+        printf("%s:%s:%lu:%lu:%s:%s:%s\n",
                pwd->pw_name,
                pwd->pw_passwd,
-               pwd->pw_uid,
-               pwd->pw_gid,
+               (unsigned long)pwd->pw_uid,
+               (unsigned long)pwd->pw_gid,
                pwd->pw_gecos,
                pwd->pw_dir,
@@ -270 +347 @@
 {
         int i;
-        printf("%s:%s:%d: ",
+        printf("%s:%s:%lu:",
                grp->gr_name,
                grp->gr_passwd,
-               grp->gr_gid);
+               (unsigned long)grp->gr_gid);
 
         if (!grp->gr_mem[0]) {
@@ -281 +358 @@
 
         for (i=0; grp->gr_mem[i+1]; i++) {
-                printf("%s, ", grp->gr_mem[i]);
+                printf("%s,", grp->gr_mem[i]);
         }
         printf("%s\n", grp->gr_mem[i]);
@@ -294 +371 @@
         NSS_STATUS status;
 
-        groups = (gid_t *)malloc_array_p(gid_t, size);
+        groups = (gid_t *)malloc(size);
         groups[0] = gid;
 
@@ -304 +381 @@
 
         for (i=0; i<start-1; i++) {
-                printf("%d, ", groups[i]);
-        }
-        printf("%d\n", groups[i]);
+                printf("%lu, ", (unsigned long)groups[i]);
+        }
+        printf("%lu\n", (unsigned long)groups[i]);
 }
 

vendor/current/nsswitch/pam_winbind.c

@@ -157 +157 @@
 {
         if (!initialized) {
-                bindtextdomain(MODULE_NAME, dyn_LOCALEDIR);
+                bindtextdomain(MODULE_NAME, LOCALEDIR);
                 initialized = 1;
         }
@@ -1078 +1078 @@
                                        int sid_list_buffer_size)
 {
-        const char* sid_string = NULL;
-        char *sid_str = NULL;
+        char sid_string[WBC_SID_STRING_BUFLEN];
 
         /* lookup name? */
         if (IS_SID_STRING(name)) {
-                sid_string = name;
+                strlcpy(sid_string, name, sizeof(sid_string));
         } else {
                 wbcErr wbc_status;
@@ -1099 +1098 @@
                 }
 
-                wbc_status = wbcSidToString(&sid, &sid_str);
-                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                        return false;
-                }
-
-                sid_string = sid_str;
+                wbcSidToStringBuf(&sid, sid_string, sizeof(sid_string));
         }
 
         if (!safe_append_string(sid_list_buffer, sid_string,
                                 sid_list_buffer_size)) {
-                wbcFreeMemory(sid_str);
                 return false;
         }
-
-        wbcFreeMemory(sid_str);
         return true;
 }
@@ -1145 +1136 @@
 
         search_location = name_list;
-        while ((comma = strstr(search_location, ",")) != NULL) {
+        while ((comma = strchr(search_location, ',')) != NULL) {
                 current_name = strndup(search_location,
                                        comma - search_location);
@@ -1200 +1191 @@
                  */
                 len = strlen(sid_list_buffer);
-                if (len) {
-                        if (sid_list_buffer[len - 1] == ',') {
-                                sid_list_buffer[len - 1] = '\0';
-                        }
+                if ((len != 0) && (sid_list_buffer[len - 1] == ',')) {
+                        sid_list_buffer[len - 1] = '\0';
                 }
         }
@@ -1435 +1424 @@
                                        const struct wbcAuthErrorInfo *e,
                                        const char *nt_status_string,
-                                       int *pam_error)
+                                       int *pam_err)
 {
         const char *ntstatus = NULL;
         const char *error_string = NULL;
 
-        if (!e || !pam_error) {
+        if (!e || !pam_err) {
                 return false;
         }
@@ -1454 +1443 @@
                 if (error_string) {
                         _make_remark(ctx, PAM_ERROR_MSG, error_string);
-                        *pam_error = e->pam_error;
+                        *pam_err = e->pam_error;
                         return true;
                 }
 
                 if (e->display_string) {
-                        _make_remark(ctx, PAM_ERROR_MSG, e->display_string);
-                        *pam_error = e->pam_error;
+                        _make_remark(ctx, PAM_ERROR_MSG, _(e->display_string));
+                        *pam_err = e->pam_error;
                         return true;
                 }
 
                 _make_remark(ctx, PAM_ERROR_MSG, nt_status_string);
-                *pam_error = e->pam_error;
+                *pam_err = e->pam_error;
 
                 return true;
@@ -1902 +1891 @@
 
  done:
-        if (logon.blobs) {
-                wbcFreeMemory(logon.blobs);
-        }
+        wbcFreeMemory(logon.blobs);
         if (info && info->blobs && !p_info) {
                 wbcFreeMemory(info->blobs);
@@ -2001 +1988 @@
                         case -1:
                                 break;
-                        case WBC_PWD_CHANGE_REJECT_OTHER:
+                        case WBC_PWD_CHANGE_NO_ERROR:
                                 if ((min_pwd_age > 0) &&
                                     (pwd_last_set + min_pwd_age > time(NULL))) {
@@ -2008 +1995 @@
                                 }
                                 break;
-                        case WBC_PWD_CHANGE_REJECT_TOO_SHORT:
+                        case WBC_PWD_CHANGE_PASSWORD_TOO_SHORT:
                                 PAM_WB_REMARK_DIRECT(ctx,
                                         "NT_STATUS_PWD_TOO_SHORT");
                                 break;
-                        case WBC_PWD_CHANGE_REJECT_IN_HISTORY:
+                        case WBC_PWD_CHANGE_PWD_IN_HISTORY:
                                 PAM_WB_REMARK_DIRECT(ctx,
                                         "NT_STATUS_PWD_HISTORY_CONFLICT");
                                 break;
-                        case WBC_PWD_CHANGE_REJECT_COMPLEXITY:
+                        case WBC_PWD_CHANGE_NOT_COMPLEX:
                                 _make_remark(ctx, PAM_ERROR_MSG,
                                              _("Password does not meet "
@@ -2425 +2412 @@
         struct wbcDomainSid sid;
         enum wbcSidType type;
-        char *domain;
+        char *domain = NULL;
         char *name;
         char *p;

vendor/current/nsswitch/pam_winbind.h

@@ +1 @@
+/*
+ * Copyright (c) Andrew Tridgell  <tridge@samba.org>   2000
+ * Copyright (c) Tim Potter       <tpot@samba.org>     2000
+ * Copyright (c) Andrew Bartlettt <abartlet@samba.org> 2002
+ * Copyright (c) Guenther Deschner <gd@samba.org>      2005-2008
+ * Copyright (c) Jan Rêkorajski 1999.
+ * Copyright (c) Andrew G. Morgan 1996-8.
+ * Copyright (c) Alex O. Yuriev, 1996.
+ * Copyright (c) Cristian Gafton 1996.
+ * Copyright (C) Elliot Lee <sopwith@redhat.com> 1996, Red Hat Software.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, and the entire permission notice in its entirety,
+ *    including the disclaimer of warranties.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * ALTERNATIVELY, this product may be distributed under the terms of
+ * the GNU Public License, in which case the provisions of the GPL are
+ * required INSTEAD OF the above restrictions.  (This clause is
+ * necessary due to a potential bad interaction between the GPL and
+ * the restrictions contained in a BSD-style copyright.)
+ *
+ * THIS SOFTWARE IS PROVIDED `AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
 /* pam_winbind header file
    (Solaris needs some macros from Linux for common PAM code)
@@ -4 +47 @@
    Shirish Kalele 2000
 */
+
+#ifndef _NSSWITCH_PAM_WINBIND_H_
+#define _NSSWITCH_PAM_WINBIND_H_
 
 #include "../lib/replace/replace.h"
@@ -10 +56 @@
 #include <talloc.h>
 #include "libwbclient/wbclient.h"
-#include "localedir.h"
 
 #define MODULE_NAME "pam_winbind"
@@ -177 +222 @@
 #define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
 #define TALLOC_P(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
+
+#endif /* _NSSWITCH_PAM_WINBIND_H_ */

vendor/current/nsswitch/tests/test_wbinfo.sh

@@ -16 +16 @@
 failed=0
 samba4bindir="$BUILDDIR/bin"
-wbinfo="$samba4bindir/wbinfo$EXEEXT"
+wbinfo="$VALGRIND $samba4bindir/wbinfo$EXEEXT"
 
 . `dirname $0`/../../testprogs/blackbox/subunit.sh
@@ -164 +164 @@
         echo "Own domain reported as $own_domain instead of $DOMAIN"
         echo "failure: wbinfo --own-domain against $TARGET check output"
+        failed=`expr $failed + 1`
 fi
 
@@ -174 +175 @@
 testit "wbinfo -i against $TARGET" $wbinfo -i "$DOMAIN/$USERNAME" || failed=`expr $failed + 1`
 
-testit "wbinfo --uid-info against $TARGET" $wbinfo --uid-info $admin_uid
-
-# this does not work
-knownfail "wbinfo --group-info against $TARGET" $wbinfo --group-info "S-1-22-2-0"
-knownfail "wbinfo --gid-info against $TARGET" $wbinfo --gid-info 30001
-knownfail "wbinfo -r against $TARGET" $wbinfo -r "$DOMAIN/$USERNAME"
+testit "wbinfo --uid-info against $TARGET" $wbinfo --uid-info $admin_uid || failed=`expr $failed + 1`
+
+echo "test: wbinfo --group-info against $TARGET"
+rawgid=`$wbinfo --group-info "Domain admins" | sed 's/.*:\([0-9][0-9]*\):/\1/'`
+if test x$? = x0; then
+        echo "success: wbinfo --group-info against $TARGET"
+else
+        echo "failure: wbinfo --group-info against $TARGET"
+        failed=`expr $failed + 1`
+fi
+
+gid=`echo $rawgid | sed 's/.*:\([0-9][0-9]*\):/\1/'`
+testit "wbinfo --gid-info against $TARGET" $wbinfo --gid-info $gid || failed=`expr $failed + 1`
+
+testit "wbinfo -r against $TARGET" $wbinfo -r "$DOMAIN/$USERNAME" || failed=`expr $failed + 1`
 
 testit "wbinfo --user-domgroups against $TARGET" $wbinfo --user-domgroups $admin_sid || failed=`expr $failed + 1`

vendor/current/nsswitch/wb_common.c

@@ -23 +23 @@
 */
 
+#include "replace.h"
+#include "system/select.h"
 #include "winbind_client.h"
 
@@ -42 +44 @@
 /* Initialise a request structure */
 
-void winbindd_init_request(struct winbindd_request *request, int request_type)
+static void winbindd_init_request(struct winbindd_request *request,
+                                  int request_type)
 {
         request->length = sizeof(struct winbindd_request);
@@ -65 +68 @@
 __attribute__((destructor))
 #endif
-void winbind_close_sock(void)
+static void winbind_close_sock(void)
 {
         if (winbindd_fd != -1) {
@@ -233 +236 @@
         for (wait_time = 0; connect(fd, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1;
                         wait_time += slept) {
-                struct timeval tv;
-                fd_set w_fds;
+                struct pollfd pfd;
                 int ret;
                 int connect_errno = 0;
@@ -244 +246 @@
                 switch (errno) {
                         case EINPROGRESS:
-                                FD_ZERO(&w_fds);
-                                if (fd < 0 || fd >= FD_SETSIZE) {
-                                        errno = EBADF;
-                                        goto error_out;
-                                }
-                                FD_SET(fd, &w_fds);
-                                tv.tv_sec = CONNECT_TIMEOUT - wait_time;
-                                tv.tv_usec = 0;
-
-                                ret = select(fd + 1, NULL, &w_fds, NULL, &tv);
+                                pfd.fd = fd;
+                                pfd.events = POLLOUT;
+
+                                ret = poll(&pfd, 1, (CONNECT_TIMEOUT - wait_time) * 1000);
 
                                 if (ret > 0) {
@@ -371 +367 @@
 /* Write data to winbindd socket */
 
-int winbind_write_sock(void *buffer, int count, int recursing, int need_priv)
+static int winbind_write_sock(void *buffer, int count, int recursing,
+                              int need_priv)
 {
         int result, nwritten;
@@ -389 +386 @@
 
         while(nwritten < count) {
-                struct timeval tv;
-                fd_set r_fds;
+                struct pollfd pfd;
+                int ret;
 
                 /* Catch pipe close on other end by checking if a read()
-                   call would not block by calling select(). */
-
-                FD_ZERO(&r_fds);
-                if (winbindd_fd < 0 || winbindd_fd >= FD_SETSIZE) {
-                        errno = EBADF;
+                   call would not block by calling poll(). */
+
+                pfd.fd = winbindd_fd;
+                pfd.events = POLLIN|POLLHUP;
+
+                ret = poll(&pfd, 1, 0);
+                if (ret == -1) {
+                        winbind_close_sock();
+                        return -1;                   /* poll error */
+                }
+
+                /* Write should be OK if fd not available for reading */
+
+                if ((ret == 1) && (pfd.revents & (POLLIN|POLLHUP|POLLERR))) {
+
+                        /* Pipe has closed on remote end */
+
+                        winbind_close_sock();
+                        goto restart;
+                }
+
+                /* Do the write */
+
+                result = write(winbindd_fd,
+                               (char *)buffer + nwritten,
+                               count - nwritten);
+
+                if ((result == -1) || (result == 0)) {
+
+                        /* Write failed */
+
                         winbind_close_sock();
                         return -1;
                 }
-                FD_SET(winbindd_fd, &r_fds);
-                ZERO_STRUCT(tv);
-
-                if (select(winbindd_fd + 1, &r_fds, NULL, NULL, &tv) == -1) {
-                        winbind_close_sock();
-                        return -1;                   /* Select error */
-                }
-
-                /* Write should be OK if fd not available for reading */
-
-                if (!FD_ISSET(winbindd_fd, &r_fds)) {
-
-                        /* Do the write */
-
-                        result = write(winbindd_fd,
-                                       (char *)buffer + nwritten,
-                                       count - nwritten);
-
-                        if ((result == -1) || (result == 0)) {
-
-                                /* Write failed */
-
-                                winbind_close_sock();
-                                return -1;
-                        }
-
-                        nwritten += result;
-
-                } else {
-
-                        /* Pipe has closed on remote end */
-
-                        winbind_close_sock();
-                        goto restart;
-                }
+
+                nwritten += result;
         }
 
@@ -443 +433 @@
 /* Read data from winbindd socket */
 
-int winbind_read_sock(void *buffer, int count)
+static int winbind_read_sock(void *buffer, int count)
 {
         int nread = 0;
-        int total_time = 0, selret;
+        int total_time = 0;
 
         if (winbindd_fd == -1) {
@@ -454 +444 @@
         /* Read data from socket */
         while(nread < count) {
-                struct timeval tv;
-                fd_set r_fds;
+                struct pollfd pfd;
+                int ret;
 
                 /* Catch pipe close on other end by checking if a read()
-                   call would not block by calling select(). */
-
-                FD_ZERO(&r_fds);
-                if (winbindd_fd < 0 || winbindd_fd >= FD_SETSIZE) {
-                        errno = EBADF;
+                   call would not block by calling poll(). */
+
+                pfd.fd = winbindd_fd;
+                pfd.events = POLLIN|POLLHUP;
+
+                /* Wait for 5 seconds for a reply. May need to parameterise this... */
+
+                ret = poll(&pfd, 1, 5000);
+                if (ret == -1) {
                         winbind_close_sock();
-                        return -1;
-                }
-                FD_SET(winbindd_fd, &r_fds);
-                ZERO_STRUCT(tv);
-                /* Wait for 5 seconds for a reply. May need to parameterise this... */
-                tv.tv_sec = 5;
-
-                if ((selret = select(winbindd_fd + 1, &r_fds, NULL, NULL, &tv)) == -1) {
-                        winbind_close_sock();
-                        return -1;                   /* Select error */
-                }
-
-                if (selret == 0) {
+                        return -1;                   /* poll error */
+                }
+
+                if (ret == 0) {
                         /* Not ready for read yet... */
                         if (total_time >= 30) {
@@ -487 +472 @@
                 }
 
-                if (FD_ISSET(winbindd_fd, &r_fds)) {
+                if ((ret == 1) && (pfd.revents & (POLLIN|POLLHUP|POLLERR))) {
 
                         /* Do the Read */
@@ -514 +499 @@
 /* Read reply */
 
-int winbindd_read_reply(struct winbindd_response *response)
+static int winbindd_read_reply(struct winbindd_response *response)
 {
         int result1, result2 = 0;
@@ -527 +512 @@
                                     sizeof(struct winbindd_response));
         if (result1 == -1) {
+                return -1;
+        }
+
+        if (response->length < sizeof(struct winbindd_response)) {
                 return -1;
         }
@@ -683 +672 @@
         return status;
 }
-
-/*************************************************************************
- ************************************************************************/
-
-const char *nss_err_str(NSS_STATUS ret)
-{
-        switch (ret) {
-                case NSS_STATUS_TRYAGAIN:
-                        return "NSS_STATUS_TRYAGAIN";
-                case NSS_STATUS_SUCCESS:
-                        return "NSS_STATUS_SUCCESS";
-                case NSS_STATUS_NOTFOUND:
-                        return "NSS_STATUS_NOTFOUND";
-                case NSS_STATUS_UNAVAIL:
-                        return "NSS_STATUS_UNAVAIL";
-#ifdef NSS_STATUS_RETURN
-                case NSS_STATUS_RETURN:
-                        return "NSS_STATUS_RETURN";
-#endif
-                default:
-                        return "UNKNOWN RETURN CODE!!!!!!!";
-        }
-}

vendor/current/nsswitch/wbinfo.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "popt_common.h"
 #include "winbind_client.h"
 #include "libwbclient/wbclient.h"
 #include "lib/popt/popt.h"
 #include "../libcli/auth/libcli_auth.h"
-#if !(_SAMBA_VERSION_) < 4
+#if (_SAMBA_BUILD_) >= 4
 #include "lib/cmdline/popt_common.h"
 #endif
@@ -48 +49 @@
         if (!WBC_ERROR_IS_OK(wbc_status)) {
                 d_fprintf(stderr, "could not obtain winbind interface "
-                                  "details!\n");
+                                  "details: %s\n", wbcErrorString(wbc_status));
         }
 
@@ -173 +174 @@
         wbc_status = wbcGetpwnam(user, &pwd);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetpwnam: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -185 +188 @@
                  pwd->pw_shell);
 
+        wbcFreeMemory(pwd);
+
         return true;
 }
@@ -196 +201 @@
         wbc_status = wbcGetpwuid(uid, &pwd);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetpwuid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -208 +215 @@
                  pwd->pw_shell);
 
+        wbcFreeMemory(pwd);
+
         return true;
 }
@@ -220 +229 @@
         wbc_status = wbcGetpwsid(&sid, &pwd);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetpwsid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -245 +256 @@
         wbc_status = wbcGetgrnam(group, &grp);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetgrnam: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -274 +287 @@
         wbc_status = wbcGetgrgid(gid, &grp);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetgrgid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -307 +322 @@
         wbc_status = wbcGetGroups(user, &num_groups, &groups);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetGroups: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -332 +349 @@
         wbc_status = wbcStringToSid(user_sid_str, &user_sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -337 +356 @@
         wbc_status = wbcLookupUserSids(&user_sid, false, &num_sids, &sids);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
 
         for (i = 0; i < num_sids; i++) {
-                char *str = NULL;
-                wbc_status = wbcSidToString(&sids[i], &str);
-                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                        wbcFreeMemory(sids);
-                        return false;
-                }
+                char str[WBC_SID_STRING_BUFLEN];
+                wbcSidToStringBuf(&sids[i], str, sizeof(str));
                 d_printf("%s\n", str);
-                wbcFreeMemory(str);
         }
 
@@ -367 +383 @@
         wbc_status = wbcStringToSid(user_sid_str, &user_sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -372 +390 @@
         wbc_status = wbcLookupUserSids(&user_sid, true, &num_sids, &sids);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
 
         for (i = 0; i < num_sids; i++) {
-                char *str = NULL;
-                wbc_status = wbcSidToString(&sids[i], &str);
-                if (!WBC_ERROR_IS_OK(wbc_status)) {
-                        wbcFreeMemory(sids);
-                        return false;
-                }
+                char str[WBC_SID_STRING_BUFLEN];
+                wbcSidToStringBuf(&sids[i], str, sizeof(str));
                 d_printf("%s\n", str);
-                wbcFreeMemory(str);
         }
 
@@ -400 +415 @@
         uint32_t *alias_rids = NULL;
         uint32_t num_alias_rids;
-        char *domain_sid_str = NULL;
+        char domain_sid_str[WBC_SID_STRING_BUFLEN];
 
         /* Send request */
@@ -412 +427 @@
         wbc_status = wbcDomainInfo(domain, &dinfo);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
-                d_printf("wbcDomainInfo(%s) failed: %s\n", domain,
-                         wbcErrorString(wbc_status));
+                d_fprintf(stderr, "wbcDomainInfo(%s) failed: %s\n", domain,
+                          wbcErrorString(wbc_status));
                 goto done;
         }
@@ -427 +442 @@
         }
 
-        wbc_status = wbcSidToString(&dinfo->sid, &domain_sid_str);
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                goto done;
-        }
+        wbcSidToStringBuf(&dinfo->sid, domain_sid_str, sizeof(domain_sid_str));
 
         for (i = 0; i < num_alias_rids; i++) {
@@ -439 +451 @@
 
 done:
-        if (domain_sid_str) {
-                wbcFreeMemory(domain_sid_str);
-        }
-        if (dinfo) {
-                wbcFreeMemory(dinfo);
-        }
+        wbcFreeMemory(dinfo);
         return (WBC_ERR_SUCCESS == wbc_status);
 }
@@ -458 +465 @@
         wbc_status = wbcResolveWinsByName(name, &ip);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcResolveWinsByName: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -479 +488 @@
         wbc_status = wbcResolveWinsByIP(ip, &name);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcResolveWinsByIP: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -503 +514 @@
         wbc_status = wbcListTrusts(&domain_list, &num_domains);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -559 +572 @@
         }
 
+        wbcFreeMemory(domain_list);
+
         return true;
 }
@@ -589 +604 @@
         wbc_status = wbcListTrusts(&domain_list, &num_domains);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -609 +626 @@
         }
 
+        wbcFreeMemory(domain_list);
+
         return true;
 }
@@ -619 +638 @@
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
         struct wbcDomainInfo *dinfo = NULL;
-        char *sid_str = NULL;
+        char sid_str[WBC_SID_STRING_BUFLEN];
 
         if ((domain == NULL) || (strequal(domain, ".")) || (domain[0] == '\0')){
@@ -629 +648 @@
         wbc_status = wbcDomainInfo(domain, &dinfo);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
-
-        wbc_status = wbcSidToString(&dinfo->sid, &sid_str);
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                wbcFreeMemory(dinfo);
-                return false;
-        }
+                d_fprintf(stderr, "failed to call wbcDomainInfo: %s\n",
+                          wbcErrorString(wbc_status));
+                return false;
+        }
+
+        wbcSidToStringBuf(&dinfo->sid, sid_str, sizeof(sid_str));
 
         /* Display response */
@@ -655 +672 @@
                  "Yes" : "No");
 
-        wbcFreeMemory(sid_str);
         wbcFreeMemory(dinfo);
 
@@ -743 +759 @@
         }
         if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
+                d_fprintf(stderr, "failed to call wbcCheckTrustCredentials: "
+                          "%s\n", wbcErrorString(wbc_status));
+                return false;
+        }
+
+        return true;
+}
+
+/* Find the currently connected DCs */
+
+static bool wbinfo_dc_info(const char *domain_name)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        size_t i, num_dcs;
+        const char **dc_names, **dc_ips;
+
+        wbc_status = wbcDcInfo(domain_name, &num_dcs,
+                               &dc_names, &dc_ips);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                printf("Could not find dc info %s\n",
+                       domain_name ? domain_name : "our domain");
+                return false;
+        }
+
+        for (i=0; i<num_dcs; i++) {
+                printf("%s (%s)\n", dc_names[i], dc_ips[i]);
+        }
+        wbcFreeMemory(dc_names);
+        wbcFreeMemory(dc_ips);
 
         return true;
@@ -775 +818 @@
         }
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcChangeTrustCredentials: "
+                          "%s\n", wbcErrorString(wbc_status));
                 return false;
         }
@@ -799 +844 @@
         }
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcPingDc: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -811 +858 @@
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
         struct wbcDomainSid sid;
-        char *sid_str = NULL;
+        char sid_str[WBC_SID_STRING_BUFLEN];
 
         /* Send request */
@@ -817 +864 @@
         wbc_status = wbcUidToSid(uid, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
-
-        wbc_status = wbcSidToString(&sid, &sid_str);
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
+                d_fprintf(stderr, "failed to call wbcUidToSid: %s\n",
+                          wbcErrorString(wbc_status));
+                return false;
+        }
+
+        wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
 
         /* Display response */
@@ -829 +875 @@
         d_printf("%s\n", sid_str);
 
-        wbcFreeMemory(sid_str);
-
         return true;
 }
@@ -840 +884 @@
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
         struct wbcDomainSid sid;
-        char *sid_str = NULL;
+        char sid_str[WBC_SID_STRING_BUFLEN];
 
         /* Send request */
@@ -846 +890 @@
         wbc_status = wbcGidToSid(gid, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
-
-        wbc_status = wbcSidToString(&sid, &sid_str);
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
+                d_fprintf(stderr, "failed to call wbcGidToSid: %s\n",
+                          wbcErrorString(wbc_status));
+                return false;
+        }
+
+        wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
 
         /* Display response */
 
         d_printf("%s\n", sid_str);
-
-        wbcFreeMemory(sid_str);
 
         return true;
@@ -875 +916 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -880 +923 @@
         wbc_status = wbcSidToUid(&sid, &uid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcSidToUid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -900 +945 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -905 +952 @@
         wbc_status = wbcSidToGid(&sid, &gid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcSidToGid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -915 +964 @@
 }
 
+static bool wbinfo_sids_to_unix_ids(const char *arg)
+{
+        char sidstr[WBC_SID_STRING_BUFLEN];
+        struct wbcDomainSid *sids;
+        struct wbcUnixId *unix_ids;
+        int i, num_sids;
+        const char *p;
+        wbcErr wbc_status;
+
+
+        num_sids = 0;
+        sids = NULL;
+        p = arg;
+
+        while (next_token(&p, sidstr, LIST_SEP, sizeof(sidstr))) {
+                sids = talloc_realloc(talloc_tos(), sids, struct wbcDomainSid,
+                                      num_sids+1);
+                if (sids == NULL) {
+                        d_fprintf(stderr, "talloc failed\n");
+                        return false;
+                }
+                wbc_status = wbcStringToSid(sidstr, &sids[num_sids]);
+                if (!WBC_ERROR_IS_OK(wbc_status)) {
+                        d_fprintf(stderr, "wbcSidToString(%s) failed: %s\n",
+                                  sidstr, wbcErrorString(wbc_status));
+                        TALLOC_FREE(sids);
+                        return false;
+                }
+                num_sids += 1;
+        }
+
+        unix_ids = talloc_array(talloc_tos(), struct wbcUnixId, num_sids);
+        if (unix_ids == NULL) {
+                TALLOC_FREE(sids);
+                return false;
+        }
+
+        wbc_status = wbcSidsToUnixIds(sids, num_sids, unix_ids);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "wbcSidsToUnixIds failed: %s\n",
+                          wbcErrorString(wbc_status));
+                TALLOC_FREE(sids);
+                return false;
+        }
+
+        for (i=0; i<num_sids; i++) {
+
+                wbcSidToStringBuf(&sids[i], sidstr, sizeof(sidstr));
+
+                switch(unix_ids[i].type) {
+                case WBC_ID_TYPE_UID:
+                        d_printf("%s -> uid %d\n", sidstr, unix_ids[i].id.uid);
+                        break;
+                case WBC_ID_TYPE_GID:
+                        d_printf("%s -> gid %d\n", sidstr, unix_ids[i].id.gid);
+                        break;
+                default:
+                        d_printf("%s -> unmapped\n", sidstr);
+                        break;
+                }
+        }
+
+        TALLOC_FREE(sids);
+        TALLOC_FREE(unix_ids);
+
+        return true;
+}
+
 static bool wbinfo_allocate_uid(void)
 {
@@ -924 +1041 @@
         wbc_status = wbcAllocateUid(&uid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcAllocateUid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -943 +1062 @@
         wbc_status = wbcAllocateGid(&gid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcAllocateGid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -962 +1083 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -967 +1090 @@
         wbc_status = wbcSetUidMapping(uid, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcSetUidMapping: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -987 +1112 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -992 +1119 @@
         wbc_status = wbcSetGidMapping(gid, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcSetGidMapping: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1012 +1141 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1017 +1148 @@
         wbc_status = wbcRemoveUidMapping(uid, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcRemoveUidMapping: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1037 +1170 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1042 +1177 @@
         wbc_status = wbcRemoveGidMapping(gid, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcRemoveGidMapping: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1067 +1204 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1072 +1211 @@
         wbc_status = wbcLookupSid(&sid, &domain, &name, &type);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcLookupSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1097 +1238 @@
         wbc_status = wbcStringToSid(sid_str, &sid);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1102 +1245 @@
         wbc_status = wbcGetDisplayName(&sid, &domain, &name, &type);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcGetDisplayName: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1185 +1330 @@
         ret = true;
 done:
-        if (dinfo) {
-                wbcFreeMemory(dinfo);
-        }
-        if (domain_name) {
-                wbcFreeMemory(domain_name);
-        }
-        if (names) {
-                wbcFreeMemory(names);
-        }
-        if (types) {
-                wbcFreeMemory(types);
-        }
+        wbcFreeMemory(dinfo);
+        wbcFreeMemory(domain_name);
+        wbcFreeMemory(names);
+        wbcFreeMemory(types);
         TALLOC_FREE(mem_ctx);
         return ret;
 }
 
+static bool wbinfo_lookup_sids(const char *arg)
+{
+        char sidstr[WBC_SID_STRING_BUFLEN];
+        struct wbcDomainSid *sids;
+        struct wbcDomainInfo *domains;
+        struct wbcTranslatedName *names;
+        int num_domains;
+        int i, num_sids;
+        const char *p;
+        wbcErr wbc_status;
+
+
+        num_sids = 0;
+        sids = NULL;
+        p = arg;
+
+        while (next_token(&p, sidstr, LIST_SEP, sizeof(sidstr))) {
+                sids = talloc_realloc(talloc_tos(), sids, struct wbcDomainSid,
+                                      num_sids+1);
+                if (sids == NULL) {
+                        d_fprintf(stderr, "talloc failed\n");
+                        return false;
+                }
+                wbc_status = wbcStringToSid(sidstr, &sids[num_sids]);
+                if (!WBC_ERROR_IS_OK(wbc_status)) {
+                        d_fprintf(stderr, "wbcSidToString(%s) failed: %s\n",
+                                  sidstr, wbcErrorString(wbc_status));
+                        TALLOC_FREE(sids);
+                        return false;
+                }
+                num_sids += 1;
+        }
+
+        wbc_status = wbcLookupSids(sids, num_sids, &domains, &num_domains,
+                                   &names);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "wbcLookupSids failed: %s\n",
+                          wbcErrorString(wbc_status));
+                TALLOC_FREE(sids);
+                return false;
+        }
+
+        for (i=0; i<num_sids; i++) {
+                wbcSidToStringBuf(&sids[i], sidstr, sizeof(sidstr));
+
+                d_printf("%s -> %s\\%s %d\n", sidstr,
+                         domains[names[i].domain_index].short_name,
+                         names[i].name, names[i].type);
+        }
+        return true;
+}
+
 /* Convert string to sid */
 
@@ -1207 +1396 @@
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
         struct wbcDomainSid sid;
-        char *sid_str;
+        char sid_str[WBC_SID_STRING_BUFLEN];
         enum wbcSidType type;
         fstring domain_name;
@@ -1220 +1409 @@
                                    &sid, &type);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
-
-        wbc_status = wbcSidToString(&sid, &sid_str);
-        if (!WBC_ERROR_IS_OK(wbc_status)) {
-                return false;
-        }
+                d_fprintf(stderr, "failed to call wbcLookupName: %s\n",
+                          wbcErrorString(wbc_status));
+                return false;
+        }
+
+        wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
 
         /* Display response */
 
         d_printf("%s %s (%d)\n", sid_str, wbcSidTypeString(type), type);
-
-        wbcFreeMemory(sid_str);
 
         return true;
@@ -1312 +1498 @@
                                      sizeof(flags));
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
+                          wbcErrorString(wbc_status));
                 goto done;
         }
@@ -1322 +1510 @@
                                      sizeof(uid));
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
+                          wbcErrorString(wbc_status));
                 goto done;
         }
@@ -1332 +1522 @@
                                      strlen(cctype)+1);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
+                          wbcErrorString(wbc_status));
                 goto done;
         }
@@ -1344 +1536 @@
         if (error) {
                 d_fprintf(stderr,
-                         "error code was %s (0x%x)\nerror messsage was: %s\n",
+                         "error code was %s (0x%x)\nerror message was: %s\n",
                          error->nt_string,
                          error->nt_status,
@@ -1415 +1607 @@
         if (response.data.auth.nt_status)
                 d_fprintf(stderr,
-                         "error code was %s (0x%x)\nerror messsage was: %s\n",
+                         "error code was %s (0x%x)\nerror message was: %s\n",
                          response.data.auth.nt_status_string,
                          response.data.auth.nt_status,
@@ -1516 +1708 @@
         if (wbc_status == WBC_ERR_AUTH_ERROR) {
                 d_fprintf(stderr,
-                         "error code was %s (0x%x)\nerror messsage was: %s\n",
+                         "error code was %s (0x%x)\nerror message was: %s\n",
                          err->nt_string,
                          err->nt_status,
@@ -1529 +1721 @@
 
         return WBC_ERROR_IS_OK(wbc_status);
+}
+
+/* Authenticate a user with a plaintext password */
+
+static bool wbinfo_pam_logon(char *username)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        struct wbcLogonUserParams params;
+        struct wbcAuthErrorInfo *error;
+        char *s = NULL;
+        char *p = NULL;
+        TALLOC_CTX *frame = talloc_tos();
+        uint32_t flags;
+        uint32_t uid;
+
+        ZERO_STRUCT(params);
+
+        if ((s = talloc_strdup(frame, username)) == NULL) {
+                return false;
+        }
+
+        if ((p = strchr(s, '%')) != NULL) {
+                *p = 0;
+                p++;
+                params.password = talloc_strdup(frame, p);
+        } else {
+                params.password = wbinfo_prompt_pass(frame, NULL, username);
+        }
+        params.username = s;
+
+        flags = WBFLAG_PAM_CACHED_LOGIN;
+
+        wbc_status = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
+                                     "flags", 0,
+                                     (uint8_t *)&flags, sizeof(flags));
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_printf("wbcAddNamedBlob failed: %s\n",
+                         wbcErrorString(wbc_status));
+                return false;
+        }
+
+        uid = getuid();
+
+        wbc_status = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
+                                     "user_uid", 0,
+                                     (uint8_t *)&uid, sizeof(uid));
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_printf("wbcAddNamedBlob failed: %s\n",
+                         wbcErrorString(wbc_status));
+                return false;
+        }
+
+        wbc_status = wbcLogonUser(&params, NULL, &error, NULL);
+
+        wbcFreeMemory(params.blobs);
+
+        d_printf("plaintext password authentication %s\n",
+                 WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
+
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr,
+                          "error code was %s (0x%x)\nerror message was: %s\n",
+                          error->nt_string,
+                          (int)error->nt_status,
+                          error->display_string);
+                wbcFreeMemory(error);
+                return false;
+        }
+        return true;
 }
 
@@ -1607 +1868 @@
         if (response.data.auth.nt_status)
                 d_fprintf(stderr,
-                         "error code was %s (0x%x)\nerror messsage was: %s\n",
+                         "error code was %s (0x%x)\nerror message was: %s\n",
                          response.data.auth.nt_status_string,
                          response.data.auth.nt_status,
@@ -1684 +1945 @@
         wbc_status = wbcListGroups(domain, &num_groups, &groups);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
+                d_fprintf(stderr, "failed to call wbcListGroups: %s\n",
+                          wbcErrorString(wbc_status));
                 return false;
         }
@@ -1754 +2017 @@
         OPT_GETDCNAME,
         OPT_DSGETDCNAME,
+        OPT_DC_INFO,
         OPT_USERDOMGROUPS,
         OPT_SIDALIASES,
         OPT_USERSIDS,
+        OPT_LOOKUP_SIDS,
         OPT_ALLOCATE_UID,
         OPT_ALLOCATE_GID,
@@ -1763 +2028 @@
         OPT_REMOVE_UID_MAPPING,
         OPT_REMOVE_GID_MAPPING,
+        OPT_SIDS_TO_XIDS,
         OPT_SEPARATOR,
         OPT_LIST_ALL_DOMAINS,
@@ -1773 +2039 @@
         OPT_ONLINESTATUS,
         OPT_CHANGE_USER_PASSWORD,
-        OPT_PING_DC,
         OPT_CCACHE_SAVE,
         OPT_SID_TO_FULLNAME,
         OPT_NTLMV2,
+        OPT_PAM_LOGON,
+        OPT_LOGOFF,
+        OPT_LOGOFF_USER,
+        OPT_LOGOFF_UID,
         OPT_LANMAN
 };
@@ -1794 +2063 @@
         bool use_ntlmv2 = false;
         bool use_lanman = false;
+        char *logoff_user = getenv("USER");
+        int logoff_uid = geteuid();
 
         struct poptOption long_options[] = {
@@ -1810 +2081 @@
                   OPT_SID_TO_FULLNAME, "Converts sid to fullname", "SID" },
                 { "lookup-rids", 'R', POPT_ARG_STRING, &string_arg, 'R', "Converts RIDs to names", "RIDs" },
+                { "lookup-sids", 0, POPT_ARG_STRING, &string_arg,
+                  OPT_LOOKUP_SIDS, "Converts SIDs to types and names",
+                  "Sid-List"},
                 { "uid-to-sid", 'U', POPT_ARG_INT, &int_arg, 'U', "Converts uid to sid" , "UID" },
                 { "gid-to-sid", 'G', POPT_ARG_INT, &int_arg, 'G', "Converts gid to sid", "GID" },
@@ -1822 +2096 @@
                 { "remove-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_UID_MAPPING, "Remove uid to sid mapping in idmap", "UID,SID" },
                 { "remove-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_GID_MAPPING, "Remove gid to sid mapping in idmap", "GID,SID" },
+                { "sids-to-unix-ids", 0, POPT_ARG_STRING, &string_arg,
+                  OPT_SIDS_TO_XIDS, "Translate SIDs to Unix IDs", "Sid-List" },
                 { "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
                 { "change-secret", 'c', POPT_ARG_NONE, 0, 'c', "Change shared secret" },
-                { "ping-dc", 0, POPT_ARG_NONE, 0, OPT_PING_DC,
+                { "ping-dc", 'P', POPT_ARG_NONE, 0, 'P',
                   "Check the NETLOGON connection" },
                 { "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
                 { "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
                 { "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
-                { "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Show sequence numbers of all domains" },
+                { "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Deprecated command, see --online-status" },
                 { "online-status", 0, POPT_ARG_NONE, 0, OPT_ONLINESTATUS, "Show whether domains are marked as online or offline"},
                 { "domain-info", 'D', POPT_ARG_STRING, &string_arg, 'D', "Show most of the info we have about the domain" },
@@ -1843 +2119 @@
                 { "user-sids", 0, POPT_ARG_STRING, &string_arg, OPT_USERSIDS, "Get user group sids for user SID", "SID" },
                 { "authenticate", 'a', POPT_ARG_STRING, &string_arg, 'a', "authenticate user", "user%password" },
+                { "pam-logon", 0, POPT_ARG_STRING, &string_arg, OPT_PAM_LOGON,
+                  "do a pam logon equivalent", "user%password" },
+                { "logoff", 0, POPT_ARG_NONE, NULL, OPT_LOGOFF,
+                  "log off user", "uid" },
+                { "logoff-user", 0, POPT_ARG_STRING, &logoff_user,
+                  OPT_LOGOFF_USER, "username to log off" },
+                { "logoff-uid", 0, POPT_ARG_INT, &logoff_uid,
+                  OPT_LOGOFF_UID, "uid to log off" },
                 { "set-auth-user", 0, POPT_ARG_STRING, &string_arg, OPT_SET_AUTH_USER, "Store user and password used by winbindd (root only)", "user%password" },
                 { "ccache-save", 0, POPT_ARG_STRING, &string_arg,
@@ -1850 +2134 @@
                   "Get a DC name for a foreign domain", "domainname" },
                 { "dsgetdcname", 0, POPT_ARG_STRING, &string_arg, OPT_DSGETDCNAME, "Find a DC for a domain", "domainname" },
+                { "dc-info", 0, POPT_ARG_STRING, &string_arg, OPT_DC_INFO,
+                  "Find the currently known DCs", "domainname" },
                 { "get-auth-user", 0, POPT_ARG_NONE, NULL, OPT_GET_AUTH_USER, "Retrieve user and password used by winbindd (root only)", NULL },
                 { "ping", 'p', POPT_ARG_NONE, 0, 'p', "Ping winbindd to see if it is alive" },
@@ -1944 +2230 @@
                         }
                         break;
+                case OPT_LOOKUP_SIDS:
+                        if (!wbinfo_lookup_sids(string_arg)) {
+                                d_fprintf(stderr, "Could not lookup SIDs %s\n",
+                                          string_arg);
+                                goto done;
+                        }
+                        break;
                 case 'n':
                         if (!wbinfo_lookupname(string_arg)) {
@@ -2053 +2346 @@
                         }
                         break;
+                case OPT_SIDS_TO_XIDS:
+                        if (!wbinfo_sids_to_unix_ids(string_arg)) {
+                                d_fprintf(stderr, "wbinfo_sids_to_unix_ids "
+                                          "failed\n");
+                                goto done;
+                        }
+                        break;
                 case 't':
                         if (!wbinfo_check_secret(opt_domain_name)) {
@@ -2065 +2365 @@
                         }
                         break;
-                case OPT_PING_DC:
+                case 'P':
                         if (!wbinfo_ping_dc()) {
                                 d_fprintf(stderr, "Could not ping our DC\n");
@@ -2192 +2492 @@
                                 break;
                         }
+                case OPT_PAM_LOGON:
+                        if (!wbinfo_pam_logon(string_arg)) {
+                                d_fprintf(stderr, "pam_logon failed for %s\n",
+                                          string_arg);
+                                goto done;
+                        }
+                        break;
+                case OPT_LOGOFF:
+                {
+                        wbcErr wbc_status;
+
+                        wbc_status = wbcLogoffUser(logoff_user, logoff_uid,
+                                                   "");
+                        d_printf("Logoff %s (%d): %s\n", logoff_user,
+                                 logoff_uid, wbcErrorString(wbc_status));
+                        break;
+                }
                 case 'K': {
                                 uint32_t flags = WBFLAG_PAM_KRB5 |
@@ -2246 +2563 @@
                         }
                         break;
+                case OPT_DC_INFO:
+                        if (!wbinfo_dc_info(string_arg)) {
+                                goto done;
+                        }
+                        break;
                 case OPT_SEPARATOR: {
                         const char sep = winbind_separator();
@@ -2275 +2597 @@
                 /* generic configuration options */
                 case OPT_DOMAIN_NAME:
-                        break;
                 case OPT_VERBOSE:
-                        break;
                 case OPT_NTLMV2:
-                        break;
                 case OPT_LANMAN:
+                case OPT_LOGOFF_USER:
+                case OPT_LOGOFF_UID:
                         break;
                 default:

vendor/current/nsswitch/winbind_client.h

@@ +1 @@
+/*
+   Unix SMB/CIFS implementation.
+
+   winbind client common code
+
+   Copyright (C) Tim Potter 2000
+   Copyright (C) Andrew Tridgell 2000
+   Copyright (C) Andrew Bartlett 2002
+
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 3 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _NSSWITCH_WINBIND_CLIENT_H_
+#define _NSSWITCH_WINBIND_CLIENT_H_
+
 #include "winbind_nss_config.h"
 #include "winbind_struct_protocol.h"
 
-void winbindd_init_request(struct winbindd_request *req,int rq_type);
 void winbindd_free_response(struct winbindd_response *response);
 NSS_STATUS winbindd_send_request(int req_type, int need_priv,
@@ -13 +39 @@
                                           struct winbindd_request *request,
                                           struct winbindd_response *response);
-int winbindd_read_reply(struct winbindd_response *response);
-
 #define winbind_env_set() \
         (strcmp(getenv(WINBINDD_DONT_ENV)?getenv(WINBINDD_DONT_ENV):"0","1") == 0)
@@ -24 +48 @@
         (setenv(WINBINDD_DONT_ENV, "0", 1) == 0)
 
-int winbind_write_sock(void *buffer, int count, int recursing, int need_priv);
-int winbind_read_sock(void *buffer, int count);
-void winbind_close_sock(void);
-
-const char *nss_err_str(NSS_STATUS ret);
+#endif /* _NSSWITCH_WINBIND_CLIENT_H_ */

vendor/current/nsswitch/winbind_nss_hpux.h

@@ -131 +131 @@
         void *returnval;
         int erange;
-        int h_errno;
+        /*
+        *  h_errno is defined as function call macro for multithreaded applications
+        *  in HP-UX. *this* h_errno is not used in the HP-UX codepath of our nss
+        *  modules, so let's simply rename it:
+        */
+        int h_errno_unused;
         nss_status_t status;
 } nss_XbyY_args_t;

vendor/current/nsswitch/winbind_nss_linux.c

@@ -72 +72 @@
                                  size_t buflen, int *errnop);
 
+/*************************************************************************
+ ************************************************************************/
+
+#ifdef DEBUG_NSS
+static const char *nss_err_str(NSS_STATUS ret)
+{
+        switch (ret) {
+                case NSS_STATUS_TRYAGAIN:
+                        return "NSS_STATUS_TRYAGAIN";
+                case NSS_STATUS_SUCCESS:
+                        return "NSS_STATUS_SUCCESS";
+                case NSS_STATUS_NOTFOUND:
+                        return "NSS_STATUS_NOTFOUND";
+                case NSS_STATUS_UNAVAIL:
+                        return "NSS_STATUS_UNAVAIL";
+#ifdef NSS_STATUS_RETURN
+                case NSS_STATUS_RETURN:
+                        return "NSS_STATUS_RETURN";
+#endif
+                default:
+                        return "UNKNOWN RETURN CODE!!!!!!!";
+        }
+}
+#endif
+
 /* Prototypes from wb_common.c */
 

vendor/current/nsswitch/winbind_nss_solaris.h

@@ -23 +23 @@
 #define _WINBIND_NSS_SOLARIS_H
 
-/* Solaris has a broken nss_common header file containing C++ reserved names. */
-#ifndef __cplusplus
-#undef class
-#undef private
-#undef public
-#undef protected
-#undef template
-#undef this
-#undef new
-#undef delete
-#undef friend
-#endif
-
 #include <nss_common.h>
-
-#ifndef __cplusplus
-#define class #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define private #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define public #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define protected #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define template #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define this #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define new #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define delete #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#define friend #error DONT_USE_CPLUSPLUS_RESERVED_NAMES
-#endif
-
 #include <nss_dbdefs.h>
 #include <nsswitch.h>

vendor/current/nsswitch/winbind_struct_protocol.h

@@ -51 +51 @@
  * 23: added session_key to ccache_ntlm_auth response
  *     added WINBINDD_CCACHE_SAVE
+ * 24: Fill in num_entries WINBINDD_LIST_USERS and WINBINDD_LIST_GROUPS
+ * 25: removed WINBINDD_SET_HWM
+ *     removed WINBINDD_SET_MAPPING
+ *     removed WINBINDD_REMOVE_MAPPING
+ * 26: added WINBINDD_DC_INFO
+ * 27: added WINBINDD_LOOKUPSIDS
  */
-#define WINBIND_INTERFACE_VERSION 23
+#define WINBIND_INTERFACE_VERSION 27
 
 /* Have to deal with time_t being 4 or 8 bytes due to structure alignment.
    On a 64bit Linux box, we have to support a constant structure size
-   between /lib/libnss_winbind.so.2 and /li64/libnss_winbind.so.2.
+   between /lib/libnss_winbind.so.2 and /lib64/libnss_winbind.so.2.
    The easiest way to do this is to always use 8byte values for time_t. */
 
@@ -104 +110 @@
         WINBINDD_LOOKUPNAME,
         WINBINDD_LOOKUPRIDS,
+        WINBINDD_LOOKUPSIDS,
 
         /* Lookup functions */
@@ -115 +122 @@
         WINBINDD_ALLOCATE_UID,
         WINBINDD_ALLOCATE_GID,
-        WINBINDD_SET_MAPPING,
-        WINBINDD_REMOVE_MAPPING,
-        WINBINDD_SET_HWM,
 
         /* Miscellaneous other stuff */
@@ -132 +136 @@
         WINBINDD_GETDCNAME,     /* Issue a GetDCName Request */
         WINBINDD_DSGETDCNAME,   /* Issue a DsGetDCName Request */
+        WINBINDD_DC_INFO,       /* Which DC are we connected to? */
 
         WINBINDD_SHOW_SEQUENCE, /* display sequence numbers of domains */
@@ -167 +172 @@
         WINBINDD_DUAL_UID2SID,
         WINBINDD_DUAL_GID2SID,
-        WINBINDD_DUAL_SET_MAPPING,
-        WINBINDD_DUAL_REMOVE_MAPPING,
-        WINBINDD_DUAL_SET_HWM,
 
         /* Wrapper around possibly blocking unix nss calls */

vendor/current/nsswitch/wins.c

@@ -20 +20 @@
 
 #include "includes.h"
+#include "nsswitch/winbind_nss.h"
+
 #ifdef HAVE_NS_API_H
 
@@ -38 +40 @@
 
 static int initialised;
-
-extern bool AllowDebugChange;
 
 NSS_STATUS _nss_wins_gethostbyname_r(const char *hostname, struct hostent *he,
@@ -46 +46 @@
                            char *buffer, size_t buflen, int *h_errnop);
 
-/* Use our own create socket code so we don't recurse.... */
-
-static int wins_lookup_open_socket_in(void)
-{
-        struct sockaddr_in sock;
-        int val=1;
-        int res;
-
-        memset((char *)&sock,'\0',sizeof(sock));
-
-#ifdef HAVE_SOCK_SIN_LEN
-        sock.sin_len = sizeof(sock);
-#endif
-        sock.sin_port = 0;
-        sock.sin_family = AF_INET;
-        sock.sin_addr.s_addr = interpret_addr("0.0.0.0");
-        res = socket(AF_INET, SOCK_DGRAM, 0);
-        if (res == -1)
-                return -1;
-
-        if (setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) != 0) {
-                close(res);
-                return -1;
-        }
-#ifdef SO_REUSEPORT
-        if (setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) != 0) {
-                close(res);
-                return -1;
-        }
-#endif /* SO_REUSEPORT */
-
-        /* now we've got a socket - we need to bind it */
-
-        if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0) {
-                close(res);
-                return(-1);
-        }
-
-        set_socket_options(res,"SO_BROADCAST");
-
-        return res;
-}
-
-
 static void nss_wins_init(void)
 {
         initialised = 1;
-        DEBUGLEVEL = 0;
-        AllowDebugChange = False;
+        load_case_tables_library();
+        lp_set_cmdline("log level", "0");
 
         TimeInit();
         setup_logging("nss_wins",False);
-        load_case_tables();
         lp_load(get_dyn_CONFIGFILE(),True,False,False,True);
         load_interfaces();
@@ -105 +60 @@
 static struct in_addr *lookup_byname_backend(const char *name, int *count)
 {
-        int fd = -1;
         struct ip_service *address = NULL;
         struct in_addr *ret = NULL;
-        int j, flags = 0;
+        int j;
 
         if (!initialised) {
@@ -127 +81 @@
                         return NULL;
                 }
-                *ret = ((struct sockaddr_in *)&address[0].ss)->sin_addr;
+                *ret = ((struct sockaddr_in *)(void *)&address[0].ss)
+                        ->sin_addr;
                 free( address );
                 return ret;
-        }
-
-        fd = wins_lookup_open_socket_in();
-        if (fd == -1) {
-                return NULL;
         }
 
@@ -142 +92 @@
                 struct sockaddr_storage ss;
                 struct sockaddr_storage *pss;
+                NTSTATUS status;
+
                 if (!bcast) {
                         continue;
                 }
                 in_addr_to_sockaddr_storage(&ss, *bcast);
-                pss = name_query(fd,name,0x00,True,True,&ss,count, &flags, NULL);
-                if (pss) {
+                status = name_query(name, 0x00, True, True, &ss,
+                                    NULL, &pss, count, NULL);
+                if (NT_STATUS_IS_OK(status) && (*count > 0)) {
                         if ((ret = SMB_MALLOC_P(struct in_addr)) == NULL) {
                                 return NULL;
                         }
                         *ret = ((struct sockaddr_in *)pss)->sin_addr;
+                        TALLOC_FREE(pss);
                         break;
                 }
         }
 
-        close(fd);
         return ret;
 }
@@ -162 +115 @@
 #ifdef HAVE_NS_API_H
 
-static NODE_STATUS_STRUCT *lookup_byaddr_backend(char *addr, int *count)
-{
-        int fd;
+static struct node_status *lookup_byaddr_backend(char *addr, int *count)
+{
         struct sockaddr_storage ss;
         struct nmb_name nname;
-        NODE_STATUS_STRUCT *status;
+        struct node_status *result;
+        NTSTATUS status;
 
         if (!initialised) {
                 nss_wins_init();
         }
-
-        fd = wins_lookup_open_socket_in();
-        if (fd == -1)
-                return NULL;
 
         make_nmb_name(&nname, "*", 0);
@@ -181 +130 @@
                 return NULL;
         }
-        status = node_status_query(fd, &nname, &ss, count, NULL);
-
-        close(fd);
-        return status;
+        status = node_status_query(NULL, &nname, &ss, &result, count, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                return NULL;
+        }
+
+        return result;
 }
 
@@ -202 +153 @@
         char *addr;
         struct in_addr *ip_list;
-        NODE_STATUS_STRUCT *status;
+        struct node_status *status;
         int i, count, len, size;
         char response[1024];
@@ -234 +185 @@
                     size = strlen(key) + 1;
                     if (size > len) {
-                        free(status);
+                        talloc_free(status);
                         return NSD_ERROR;
                     }
@@ -246 +197 @@
                                 size = sizeof(status[i].name) + 1;
                                 if (size > len) {
-                                    free(status);
+                                    talloc_free(status);
                                     return NSD_ERROR;
                                 }
@@ -256 +207 @@
                     }
                     response[strlen(response)-1] = '\n';
-                    free(status);
+                    talloc_free(status);
                 }
         } else if (StrCaseCmp(map,"hosts.byname") == 0) {