Changeset 745 for trunk/server/nsswitch/libwbclient

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• nsswitch/libwbclient/config.mk (deleted)
• nsswitch/libwbclient/libwbclient.h (modified) (1 diff)
• nsswitch/libwbclient/tests/wbclient.c (modified) (13 diffs)
• nsswitch/libwbclient/wb_reqtrans.c (deleted)
• nsswitch/libwbclient/wbc_async.c (deleted)
• nsswitch/libwbclient/wbc_async.h (deleted)
• nsswitch/libwbclient/wbc_guid.c (modified) (1 diff)
• nsswitch/libwbclient/wbc_idmap.c (modified) (9 diffs)
• nsswitch/libwbclient/wbc_pam.c (modified) (46 diffs)
• nsswitch/libwbclient/wbc_pwd.c (modified) (19 diffs)
• nsswitch/libwbclient/wbc_sid.c (modified) (34 diffs)
• nsswitch/libwbclient/wbc_util.c (modified) (33 diffs)
• nsswitch/libwbclient/wbclient.c (modified) (5 diffs)
• nsswitch/libwbclient/wbclient.h (modified) (14 diffs)
• nsswitch/libwbclient/wbclient_internal.h (modified) (1 diff)
• nsswitch/libwbclient/wscript_build (copied) (copied from vendor/current/nsswitch/libwbclient/wscript_build )

trunk/server/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 */

trunk/server/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;

trunk/server/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;
 }
 

trunk/server/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;
+}

trunk/server/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;
 }

trunk/server/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;
+}

trunk/server/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);
         }

trunk/server/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;
+}

trunk/server/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;
+}

trunk/server/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);
 
 /**

trunk/server/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 */