Changeset 988 for vendor/current/nsswitch/libwbclient

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/nsswitch/libwbclient

Files:

• ABI (added)
• ABI/wbclient-0.10.sigs (added)
• ABI/wbclient-0.11.sigs (added)
• ABI/wbclient-0.12.sigs (added)
• ABI/wbclient-0.9.sigs (added)
• tests/wbclient.c (modified) (41 diffs)
• wbc_err_internal.h (modified) (2 diffs)
• wbc_idmap.c (modified) (21 diffs)
• wbc_pam.c (modified) (30 diffs)
• wbc_pwd.c (modified) (28 diffs)
• wbc_sid.c (modified) (27 diffs)
• wbc_util.c (modified) (27 diffs)
• wbclient.c (modified) (7 diffs)
• wbclient.h (modified) (82 diffs)
• wbclient.pc.in (added)
• wbclient_internal.h (modified) (2 diffs)
• wscript (added)
• wscript_build (deleted)

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

@@ -23 +23 @@
 #include "lib/util/data_blob.h"
 #include "lib/util/time.h"
+#include "libcli/resolve/resolve.h"
 #include "nsswitch/libwbclient/wbclient.h"
 #include "torture/smbtorture.h"
@@ -29 +30 @@
 #include "lib/util/charset/charset.h"
 #include "libcli/auth/libcli_auth.h"
-#include "source4/param/param.h"
-#include "lib/util/util.h"
+#include "lib/param/param.h"
+#include "lib/util/samba_util.h"
 #include "lib/crypto/arcfour.h"
+#include "auth/credentials/credentials.h"
+#include "lib/cmdline/popt_common.h"
 
 #define WBC_ERROR_EQUAL(x,y) (x == y)
 
-#define torture_assert_wbc_equal(torture_ctx, got, expected, cmt) \
+#define torture_assert_wbc_equal(torture_ctx, got, expected, cmt, cmt_arg)      \
         do { wbcErr __got = got, __expected = expected; \
         if (!WBC_ERROR_EQUAL(__got, __expected)) { \
-                torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", wbcErrorString(__got), wbcErrorString(__expected), cmt); \
+                torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: " cmt, wbcErrorString(__got), wbcErrorString(__expected), cmt_arg); \
                 return false; \
         } \
         } while (0)
 
-#define torture_assert_wbc_ok(torture_ctx,expr,cmt) \
-                torture_assert_wbc_equal(torture_ctx,expr,WBC_ERR_SUCCESS,cmt)
+#define torture_assert_wbc_ok(torture_ctx,expr,cmt,cmt_arg)                     \
+        torture_assert_wbc_equal(torture_ctx,expr,WBC_ERR_SUCCESS,cmt,cmt_arg)
 
 static bool test_wbc_ping(struct torture_context *tctx)
 {
         torture_assert_wbc_ok(tctx, wbcPing(),
-                "wbcPing failed");
+                "%s", "wbcPing failed");
 
         return true;
@@ -56 +59 @@
 static bool test_wbc_pingdc(struct torture_context *tctx)
 {
-        torture_assert_wbc_equal(tctx, wbcPingDc("random_string", NULL), WBC_ERR_NOT_IMPLEMENTED,
-                "wbcPingDc failed");
+        struct wbcInterfaceDetails *details;
+
+        torture_assert_wbc_equal(tctx, wbcPingDc("random_string", NULL), WBC_ERR_DOMAIN_NOT_FOUND,
+                                 "%s", "wbcPingDc failed");
         torture_assert_wbc_ok(tctx, wbcPingDc(NULL, NULL),
-                "wbcPingDc failed");
+                "%s", "wbcPingDc failed");
+
+        torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+                "%s", "wbcInterfaceDetails failed");
+        torture_assert(tctx, details,
+                       "wbcInterfaceDetails returned NULL pointer");
+        torture_assert(tctx, details->netbios_domain,
+                       "wbcInterfaceDetails returned NULL netbios_domain");
+
+        torture_assert_wbc_ok(tctx, wbcPingDc(details->netbios_domain, NULL),
+                "wbcPingDc(%s) failed", details->netbios_domain);
+
+        torture_assert_wbc_ok(tctx, wbcPingDc("BUILTIN", NULL),
+                "%s", "wbcPingDc(BUILTIN) failed");
+
+        wbcFreeMemory(details);
+        return true;
+}
+
+static bool test_wbc_pingdc2(struct torture_context *tctx)
+{
+        struct wbcInterfaceDetails *details;
+        char *name = NULL;
+
+        torture_assert_wbc_equal(tctx, wbcPingDc2("random_string", NULL, &name),
+                                 WBC_ERR_DOMAIN_NOT_FOUND, "%s",
+                                 "wbcPingDc2 failed");
+        torture_assert_wbc_ok(tctx, wbcPingDc2(NULL, NULL, &name), "%s",
+                              "wbcPingDc2 failed");
+
+        wbcFreeMemory(name);
+
+        torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
+                "%s", "wbcInterfaceDetails failed");
+        torture_assert(tctx, details,
+                       "wbcInterfaceDetails returned NULL pointer");
+        torture_assert(tctx, details->netbios_domain,
+                       "wbcInterfaceDetails returned NULL netbios_domain");
+
+        torture_assert_wbc_ok(tctx, wbcPingDc2(details->netbios_domain, NULL, &name),
+                "wbcPingDc2(%s) failed", details->netbios_domain);
+        wbcFreeMemory(name);
+
+        torture_assert_wbc_ok(tctx, wbcPingDc2("BUILTIN", NULL, &name),
+                "%s", "wbcPingDc2(BUILTIN) failed");
+        wbcFreeMemory(name);
+
+        wbcFreeMemory(details);
 
         return true;
@@ -69 +121 @@
 
         torture_assert_wbc_ok(tctx, wbcLibraryDetails(&details),
-                "wbcLibraryDetails failed");
+                "%s", "wbcLibraryDetails failed");
         torture_assert(tctx, details,
                 "wbcLibraryDetails returned NULL pointer");
@@ -83 +135 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                "%s", "wbcInterfaceDetails failed");
         torture_assert(tctx, details,
-                "wbcInterfaceDetails returned NULL pointer");
+                       "wbcInterfaceDetails returned NULL pointer");
 
         wbcFreeMemory(details);
@@ -113 +165 @@
                                  "SID_UNKNOWN", "SID_UNKNOWN failed");
         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_COMPUTER),
-                                 "SID_COMPUTER", "SID_COMPUTER failed");
+                                 "SID_COMPUTER",  "SID_COMPUTER failed");
         return true;
 }
@@ -124 +176 @@
 
         torture_assert_wbc_ok(tctx, wbcStringToSid(sid_string, &sid),
-                "wbcStringToSid failed");
+                              "wbcStringToSid of %s failed", sid_string);
         torture_assert_wbc_ok(tctx, wbcSidToString(&sid, &sid_string2),
-                "wbcSidToString failed");
+                              "wbcSidToString of %s failed", sid_string);
         torture_assert_str_equal(tctx, sid_string, sid_string2,
                 "sid strings differ");
@@ -141 +193 @@
 
         torture_assert_wbc_ok(tctx, wbcStringToGuid(guid_string, &guid),
-                "wbcStringToGuid failed");
+                              "wbcStringToGuid of %s failed", guid_string);
         torture_assert_wbc_ok(tctx, wbcGuidToString(&guid, &guid_string2),
-                "wbcGuidToString failed");
+                              "wbcGuidToString of %s failed", guid_string);
         torture_assert_str_equal(tctx, guid_string, guid_string2,
-                "guid strings differ");
+                                 "guid strings differ");
         wbcFreeMemory(guid_string2);
 
@@ -157 +209 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                "%s", "wbcInterfaceDetails failed");
         torture_assert_wbc_ok(
                 tctx, wbcDomainInfo(details->netbios_domain, &info),
-                "wbcDomainInfo failed");
+                "%s", "wbcDomainInfo failed");
         wbcFreeMemory(details);
 
@@ -179 +231 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                "%s", "wbcInterfaceDetails failed");
 
         domain_name = talloc_strdup(tctx, details->netbios_domain);
@@ -185 +237 @@
 
         torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
-                "wbcListUsers failed");
+                "%s", "wbcListUsers failed");
         torture_assert(tctx, !(num_users > 0 && !users),
                 "wbcListUsers returned invalid results");
@@ -195 +247 @@
                 char *domain;
                 char *name;
+                char *sid_string;
                 uint32_t num_sids;
 
                 torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, users[i], &sid, &name_type),
-                        "wbcLookupName failed");
+                                      "wbcLookupName of %s failed", users[i]);
                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
-                        "wbcLookupName expected WBC_SID_NAME_USER");
+                                         "wbcLookupName expected WBC_SID_NAME_USER");
+                wbcSidToString(&sid, &sid_string);
                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
-                        "wbcLookupSid failed");
+                                      "wbcLookupSid of %s failed", sid_string);
                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
-                        "wbcLookupSid expected WBC_SID_NAME_USER");
+                                         "wbcLookupSid of expected WBC_SID_NAME_USER");
                 torture_assert(tctx, name,
                         "wbcLookupSid returned no name");
@@ -210 +264 @@
                 wbcFreeMemory(name);
                 torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
-                        "wbcLookupUserSids failed");
+                        "wbcLookupUserSids of %s failed", sid_string);
                 torture_assert_wbc_ok(
                         tctx, wbcGetDisplayName(&sid, &domain, &name,
                                                 &name_type),
-                        "wbcGetDisplayName failed");
+                        "wbcGetDisplayName of %s failed", sid_string);
                 wbcFreeMemory(domain);
                 wbcFreeMemory(name);
                 wbcFreeMemory(sids);
+                wbcFreeMemory(sid_string);
         }
         wbcFreeMemory(users);
@@ -233 +288 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                              "%s", "wbcInterfaceDetails failed");
 
         domain_name = talloc_strdup(tctx, details->netbios_domain);
@@ -239 +294 @@
 
         torture_assert_wbc_ok(tctx, wbcListGroups(domain_name, &num_groups, &groups),
-                "wbcListGroups failed");
+                              "wbcListGroups in %s failed", domain_name);
         torture_assert(tctx, !(num_groups > 0 && !groups),
-                "wbcListGroups returned invalid results");
+                       "wbcListGroups returned invalid results");
 
         for (i=0; i < MIN(num_groups,100); i++) {
@@ -249 +304 @@
                 char *domain;
                 char *name;
+                char *sid_string;
 
                 torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, groups[i], &sid, &name_type),
-                        "wbcLookupName failed");
+                                      "wbcLookupName for %s failed", domain_name);
+                wbcSidToString(&sid, &sid_string);
                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
-                        "wbcLookupSid failed");
+                                      "wbcLookupSid of %s failed", sid_string);
+                wbcFreeMemory(sid_string);
                 torture_assert(tctx, name,
                         "wbcLookupSid returned no name");
@@ -269 +327 @@
 
         torture_assert_wbc_ok(tctx, wbcListTrusts(&domains, &num_domains),
-                "wbcListTrusts failed");
+                              "%s", "wbcListTrusts failed");
         torture_assert(tctx, !(num_domains > 0 && !domains),
                 "wbcListTrusts returned invalid results");
@@ -283 +341 @@
                 */
                 torture_assert_wbc_ok(tctx, wbcCheckTrustCredentials(domains[i].short_name, &error),
-                        "wbcCheckTrustCredentials failed");
+                                      "%s", "wbcCheckTrustCredentials failed");
                 /*
                 torture_assert_wbc_ok(tctx, wbcLookupName(domains[i].short_name, NULL, &sid, &name_type),
@@ -309 +367 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                "%s", "wbcInterfaceDetails failed");
 
         domain_name = talloc_strdup(tctx, details->netbios_domain);
@@ -315 +373 @@
 
         torture_assert_wbc_ok(tctx, wbcLookupDomainController(domain_name, 0, &dc_info),
-                "wbcLookupDomainController failed");
+                              "wbcLookupDomainController for %s failed", domain_name);
         wbcFreeMemory(dc_info);
 
@@ -328 +386 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                "%s", "wbcInterfaceDetails failed");
 
         domain_name = talloc_strdup(tctx, details->netbios_domain);
@@ -334 +392 @@
 
         torture_assert_wbc_ok(tctx, wbcLookupDomainControllerEx(domain_name, NULL, NULL, 0, &dc_info),
-                "wbcLookupDomainControllerEx failed");
+                "wbcLookupDomainControllerEx for %s failed", domain_name);
         wbcFreeMemory(dc_info);
 
@@ -348 +406 @@
         name = torture_setting_string(tctx, "host", NULL);
 
+        torture_comment(tctx, "test-WinsByName: host='%s'\n", name);
+
         ret = wbcResolveWinsByName(name, &ip);
 
         if (is_ipaddress(name)) {
-                torture_assert_wbc_equal(tctx, ret, WBC_ERR_DOMAIN_NOT_FOUND, "wbcResolveWinsByName failed");
+                torture_assert_wbc_equal(tctx, ret, WBC_ERR_DOMAIN_NOT_FOUND, "wbcResolveWinsByName of %s failed", name);
         } else {
-                torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByName failed");
+                torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByName for %s failed", name);
         }
 
@@ -362 +422 @@
 {
         const char *ip;
+        const char *host;
+        struct nbt_name nbt_name;
         char *name;
         wbcErr ret;
-
-        ip = torture_setting_string(tctx, "host", NULL);
+        NTSTATUS status;
+
+        host = torture_setting_string(tctx, "host", NULL);
+
+        torture_comment(tctx, "test-WinsByIp: host='%s'\n", host);
+
+        make_nbt_name_server(&nbt_name, host);
+
+        status = resolve_name_ex(lpcfg_resolve_context(tctx->lp_ctx),
+                                 0, 0, &nbt_name, tctx, &ip, tctx->ev);
+        torture_assert_ntstatus_ok(tctx, status,
+                        talloc_asprintf(tctx,"Failed to resolve %s: %s",
+                                        nbt_name.name, nt_errstr(status)));
+
+        torture_comment(tctx, "test-WinsByIp: ip='%s'\n", ip);
 
         ret = wbcResolveWinsByIP(ip, &name);
 
-        torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByIP failed");
+        torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByIP for %s failed", ip);
 
         wbcFreeMemory(name);
@@ -388 +463 @@
         ret = wbcLookupRids(&builtin, 2, rids, &domain_name, &names,
                             &types);
-        torture_assert_wbc_ok(tctx, ret, "wbcLookupRids failed");
+        torture_assert_wbc_ok(tctx, ret, "%s", "wbcLookupRids for 544 and 545 failed");
 
         torture_assert_str_equal(
@@ -396 +471 @@
                 tctx, names[1], "Users", "S-1-5-32-545 not mapped to 'Users'");
 
-        wbcFreeMemory((char *)domain_name);
+        wbcFreeMemory(discard_const_p(char ,domain_name));
         wbcFreeMemory(names);
         wbcFreeMemory(types);
@@ -414 +489 @@
 
         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
-                "wbcInterfaceDetails failed");
+                              "%s", "wbcInterfaceDetails failed");
         torture_assert_wbc_ok(
                 tctx, wbcDomainInfo(details->netbios_domain, &info),
-                "wbcDomainInfo failed");
+                "wbcDomainInfo of %s failed", details->netbios_domain);
         wbcFreeMemory(details);
 
@@ -428 +503 @@
         torture_assert_wbc_ok(
                 tctx, wbcStringToSid("S-1-5-32", &builtin),
-                "wbcStringToSid failed");
+                "wbcStringToSid of %s failed", "S-1-5-32");
 
         ret = wbcGetSidAliases(&builtin, sids, 2, &rids, &num_rids);
-        torture_assert_wbc_ok(tctx, ret, "wbcGetSidAliases failed");
+        torture_assert_wbc_ok(tctx, ret, "%s", "wbcGetSidAliases failed");
 
         wbcFreeMemory(rids);
@@ -446 +521 @@
         wbcErr ret;
 
-        ret = wbcAuthenticateUser(getenv("USERNAME"), correct_password);
-        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcAuthenticateUser failed");
+        ret = wbcAuthenticateUser(cli_credentials_get_username(cmdline_credentials), correct_password);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcAuthenticateUser of %s failed",
+                                 cli_credentials_get_username(cmdline_credentials));
 
         ZERO_STRUCT(params);
-        params.account_name             = getenv("USERNAME");
+        params.account_name             = cli_credentials_get_username(cmdline_credentials);
         params.level                    = WBC_AUTH_USER_LEVEL_PLAIN;
         params.password.plaintext       = correct_password;
@@ -457 +533 @@
         ret = wbcAuthenticateUserEx(&params, &info, &error);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcAuthenticateUserEx failed");
+                                 "wbcAuthenticateUserEx of %s failed", params.account_name);
         wbcFreeMemory(info);
         info = NULL;
@@ -467 +543 @@
         ret = wbcAuthenticateUserEx(&params, &info, &error);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
-                                 "wbcAuthenticateUserEx succeeded where it "
-                                 "should have failed");
+                                 "wbcAuthenticateUserEx for %s succeeded where it "
+                                 "should have failed", params.account_name);
         wbcFreeMemory(info);
         info = NULL;
@@ -480 +556 @@
 static bool test_wbc_authenticate_user(struct torture_context *tctx)
 {
-        return test_wbc_authenticate_user_int(tctx, getenv("PASSWORD"));
+        return test_wbc_authenticate_user_int(tctx, cli_credentials_get_password(cmdline_credentials));
 }
 
@@ -486 +562 @@
 {
         wbcErr ret;
-        const char *oldpass = getenv("PASSWORD");
-        const char *newpass = "Koo8irei";
+        const char *oldpass = cli_credentials_get_password(cmdline_credentials);
+        const char *newpass = "Koo8irei%$";
 
         struct samr_CryptPassword new_nt_password;
@@ -551 +627 @@
 
         params.level = WBC_CHANGE_PASSWORD_LEVEL_RESPONSE;
-        params.account_name = getenv("USERNAME");
-        params.domain_name = "SAMBA-TEST";
+        params.account_name = cli_credentials_get_username(cmdline_credentials);
+        params.domain_name = cli_credentials_get_domain(cmdline_credentials);
 
         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")) {
+                                 "wbcChangeUserPassword for %s failed", params.account_name);
+
+        if (!test_wbc_authenticate_user_int(tctx, newpass)) {
                 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"));
+        ret = wbcChangeUserPassword(cli_credentials_get_username(cmdline_credentials), newpass,
+                                    cli_credentials_get_password(cmdline_credentials));
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcChangeUserPassword for %s failed", params.account_name);
+
+        return test_wbc_authenticate_user_int(tctx, cli_credentials_get_password(cmdline_credentials));
 }
 
@@ -586 +662 @@
         ret = wbcLogonUser(&params, &info, &error, &policy);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_INVALID_PARAM,
-                                 "wbcLogonUser succeeded where it should "
+                                 "%s", "wbcLogonUser succeeded for NULL where it should "
                                  "have failed");
 
-        params.username = getenv("USERNAME");
-        params.password = getenv("PASSWORD");
+        params.username = cli_credentials_get_username(cmdline_credentials);
+        params.password = cli_credentials_get_password(cmdline_credentials);
 
         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");
+                                 "%s", "wbcAddNamedBlob failed");
 
         ret = wbcLogonUser(&params, &info, &error, &policy);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcLogonUser failed");
+                                 "wbcLogonUser for %s failed", params.username);
         wbcFreeMemory(info); info = NULL;
         wbcFreeMemory(error); error = NULL;
@@ -608 +684 @@
         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");
+                                 "wbcLogonUser for %s should have failed with "
+                                 "WBC_ERR_AUTH_ERROR", params.username);
         wbcFreeMemory(info); info = NULL;
         wbcFreeMemory(error); error = NULL;
@@ -619 +695 @@
                               strlen("S-1-2-3-4")+1);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcAddNamedBlob failed");
-        params.password = getenv("PASSWORD");
+                                 "%s", "wbcAddNamedBlob failed");
+        params.password = cli_credentials_get_password(cmdline_credentials);
         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");
+                                 "wbcLogonUser for %s should have failed with "
+                                 "WBC_ERR_AUTH_ERROR", params.username);
         wbcFreeMemory(info); info = NULL;
         wbcFreeMemory(error); error = NULL;
@@ -633 +709 @@
         ret = wbcInterfaceDetails(&iface);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcInterfaceDetails failed");
-
-        ret = wbcLookupName(iface->netbios_domain, getenv("USERNAME"), &sid,
+                                 "%s", "wbcInterfaceDetails failed");
+
+        ret = wbcLookupName(iface->netbios_domain, cli_credentials_get_username(cmdline_credentials), &sid,
                             &sidtype);
         wbcFreeMemory(iface);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcLookupName failed");
+                                 "wbcLookupName for %s failed", cli_credentials_get_username(cmdline_credentials));
 
         ret = wbcSidToString(&sid, &sidstr);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcSidToString failed");
+                                 "%s", "wbcSidToString failed");
 
         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
@@ -649 +725 @@
                               (uint8_t *)sidstr, strlen(sidstr)+1);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcAddNamedBlob failed");
+                                 "%s", "wbcAddNamedBlob failed");
         wbcFreeMemory(sidstr);
-        params.password = getenv("PASSWORD");
+        params.password = cli_credentials_get_password(cmdline_credentials);
         ret = wbcLogonUser(&params, &info, &error, &policy);
         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcLogonUser failed");
+                                 "wbcLogonUser for %s failed", params.username);
         wbcFreeMemory(info); info = NULL;
         wbcFreeMemory(error); error = NULL;
@@ -670 +746 @@
         gid_t *groups;
 
-        ret = wbcGetGroups(getenv("USERNAME"), &num_groups, &groups);
-        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
-                                 "wbcGetGroups failed");
+        ret = wbcGetGroups(cli_credentials_get_username(cmdline_credentials), &num_groups, &groups);
+        torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
+                                 "wbcGetGroups for %s failed", cli_credentials_get_username(cmdline_credentials));
         wbcFreeMemory(groups);
         return true;
@@ -683 +759 @@
         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, "wbcPingDc2", test_wbc_pingdc2);
         torture_suite_add_simple_test(suite, "wbcLibraryDetails", test_wbc_library_details);
         torture_suite_add_simple_test(suite, "wbcInterfaceDetails", test_wbc_interface_details);

vendor/current/nsswitch/libwbclient/wbc_err_internal.h

@@ -30 +30 @@
                         goto done;              \
                 }                               \
-        } while(0);
+        } while(0)
 
 #define BAIL_ON_PTR_ERROR(x, status)                    \
@@ -40 +40 @@
                         status = WBC_ERR_SUCCESS;       \
                 }                                       \
-        } while (0);
+        } while (0)
 
 

vendor/current/nsswitch/libwbclient/wbc_idmap.c

@@ -27 +27 @@
 
 /* Convert a Windows SID to a Unix uid, allocating an uid if needed */
-wbcErr wbcSidToUid(const struct wbcDomainSid *sid, uid_t *puid)
+wbcErr wbcCtxSidToUid(struct wbcContext *ctx, const struct wbcDomainSid *sid,
+                      uid_t *puid)
 {
         struct winbindd_request request;
@@ -47 +48 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_SID_TO_UID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_SID_TO_UID,
                                         &request,
                                         &response);
@@ -58 +59 @@
  done:
         return wbc_status;
+}
+
+wbcErr wbcSidToUid(const struct wbcDomainSid *sid, uid_t *puid)
+{
+        return wbcCtxSidToUid(NULL, sid, puid);
 }
 
@@ -68 +74 @@
 
 /* Convert a Unix uid to a Windows SID, allocating a SID if needed */
-wbcErr wbcUidToSid(uid_t uid, struct wbcDomainSid *sid)
+wbcErr wbcCtxUidToSid(struct wbcContext *ctx, uid_t uid,
+                      struct wbcDomainSid *sid)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -88 +95 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_UID_TO_SID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_UID_TO_SID,
                                         &request,
                                         &response);
@@ -98 +105 @@
 done:
         return wbc_status;
+}
+
+wbcErr wbcUidToSid(uid_t uid, struct wbcDomainSid *sid)
+{
+        return wbcCtxUidToSid(NULL, uid, sid);
 }
 
@@ -116 +128 @@
  **/
 
-wbcErr wbcSidToGid(const struct wbcDomainSid *sid, gid_t *pgid)
+wbcErr wbcCtxSidToGid(struct wbcContext *ctx, const struct wbcDomainSid *sid,
+                      gid_t *pgid)
 {
         struct winbindd_request request;
@@ -136 +149 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_SID_TO_GID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_SID_TO_GID,
                                         &request,
                                         &response);
@@ -149 +162 @@
 }
 
+wbcErr wbcSidToGid(const struct wbcDomainSid *sid, gid_t *pgid)
+{
+        return wbcCtxSidToGid(NULL, sid, pgid);
+}
 
 /* Convert a Windows SID to a Unix gid if there already is a mapping */
@@ -160 +177 @@
 
 /* Convert a Unix gid to a Windows SID, allocating a SID if needed */
-wbcErr wbcGidToSid(gid_t gid, struct wbcDomainSid *sid)
+wbcErr wbcCtxGidToSid(struct wbcContext *ctx, gid_t gid,
+                      struct wbcDomainSid *sid)
 {
         struct winbindd_request request;
@@ -180 +198 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_GID_TO_SID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GID_TO_SID,
                                         &request,
                                         &response);
@@ -190 +208 @@
 done:
         return wbc_status;
+}
+
+wbcErr wbcGidToSid(gid_t gid, struct wbcDomainSid *sid)
+{
+        return wbcCtxGidToSid(NULL, gid, sid);
 }
 
@@ -200 +223 @@
 
 /* Obtain a new uid from Winbind */
-wbcErr wbcAllocateUid(uid_t *puid)
+wbcErr wbcCtxAllocateUid(struct wbcContext *ctx, uid_t *puid)
 {
         struct winbindd_request request;
@@ -216 +239 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponsePriv(WINBINDD_ALLOCATE_UID,
+        wbc_status = wbcRequestResponsePriv(ctx, WINBINDD_ALLOCATE_UID,
                                             &request, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
@@ -229 +252 @@
 }
 
+wbcErr wbcAllocateUid(uid_t *puid)
+{
+        return wbcCtxAllocateUid(NULL, puid);
+}
+
 /* Obtain a new gid from Winbind */
-wbcErr wbcAllocateGid(gid_t *pgid)
+wbcErr wbcCtxAllocateGid(struct wbcContext *ctx, gid_t *pgid)
 {
         struct winbindd_request request;
@@ -246 +274 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponsePriv(WINBINDD_ALLOCATE_GID,
+        wbc_status = wbcRequestResponsePriv(ctx, WINBINDD_ALLOCATE_GID,
                                             &request, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
@@ -257 +285 @@
  done:
         return wbc_status;
+}
+
+wbcErr wbcAllocateGid(gid_t *pgid)
+{
+        return wbcCtxAllocateGid(NULL, pgid);
 }
 
@@ -300 +333 @@
 
 /* Convert a list of SIDs */
-wbcErr wbcSidsToUnixIds(const struct wbcDomainSid *sids, uint32_t num_sids,
-                        struct wbcUnixId *ids)
+wbcErr wbcCtxSidsToUnixIds(struct wbcContext *ctx,
+                           const struct wbcDomainSid *sids,
+                           uint32_t num_sids, struct wbcUnixId *ids)
 {
         struct winbindd_request request;
@@ -342 +376 @@
         request.extra_len = p - sidlist;
 
-        wbc_status = wbcRequestResponse(WINBINDD_SIDS_TO_XIDS,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_SIDS_TO_XIDS,
                                         &request, &response);
         free(sidlist);
@@ -371 +405 @@
                         id->id.gid = strtoul(p+1, &q, 10);
                         break;
+                case 'B':
+                        id->type = WBC_ID_TYPE_BOTH;
+                        id->id.uid = strtoul(p+1, &q, 10);
+                        break;
                 default:
                         id->type = WBC_ID_TYPE_NOT_SPECIFIED;
-                        q = p;
+                        q = strchr(p, '\n');
                         break;
                 };
-                if (q[0] != '\n') {
+                if (q == NULL || q[0] != '\n') {
                         goto wbc_err_invalid;
                 }
@@ -390 +428 @@
         return wbc_status;
 }
+
+wbcErr wbcSidsToUnixIds(const struct wbcDomainSid *sids, uint32_t num_sids,
+                        struct wbcUnixId *ids)
+{
+        return wbcCtxSidsToUnixIds(NULL, sids, num_sids, ids);
+}

vendor/current/nsswitch/libwbclient/wbc_pam.c

@@ -29 +29 @@
 
 /* Authenticate a username/password pair */
-wbcErr wbcAuthenticateUser(const char *username,
-                           const char *password)
+wbcErr wbcCtxAuthenticateUser(struct wbcContext *ctx,
+                              const char *username, const char *password)
 {
         wbcErr wbc_status = WBC_ERR_SUCCESS;
@@ -41 +41 @@
         params.password.plaintext       = password;
 
-        wbc_status = wbcAuthenticateUserEx(&params, NULL, NULL);
+        wbc_status = wbcCtxAuthenticateUserEx(ctx, &params, NULL, NULL);
         BAIL_ON_WBC_ERROR(wbc_status);
 
 done:
         return wbc_status;
+}
+
+wbcErr wbcAuthenticateUser(const char *username, const char *password)
+{
+        return wbcCtxAuthenticateUser(NULL, username, password);
 }
 
@@ -343 +348 @@
 
 /* Authenticate with more detailed information */
-wbcErr wbcAuthenticateUserEx(const struct wbcAuthUserParams *params,
-                             struct wbcAuthUserInfo **info,
-                             struct wbcAuthErrorInfo **error)
+wbcErr wbcCtxAuthenticateUserEx(struct wbcContext *ctx,
+                                const struct wbcAuthUserParams *params,
+                                struct wbcAuthUserInfo **info,
+                                struct wbcAuthErrorInfo **error)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -364 +370 @@
         }
 
-        if (!params->account_name) {
+        if (params->level != WBC_AUTH_USER_LEVEL_PAC && !params->account_name) {
                 wbc_status = WBC_ERR_INVALID_PARAM;
                 BAIL_ON_WBC_ERROR(wbc_status);
@@ -389 +395 @@
                         ZERO_STRUCT(sep_response);
 
-                        wbc_status = wbcRequestResponse(WINBINDD_INFO,
+                        wbc_status = wbcRequestResponse(ctx, WINBINDD_INFO,
                                                         NULL, &sep_response);
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -491 +497 @@
                 }
                 break;
+
+        case WBC_AUTH_USER_LEVEL_PAC:
+                cmd = WINBINDD_PAM_AUTH_CRAP;
+                request.flags = WBFLAG_PAM_AUTH_PAC | WBFLAG_PAM_INFO3_TEXT;
+                request.extra_data.data = malloc(params->password.pac.length);
+                if (request.extra_data.data == NULL) {
+                        wbc_status = WBC_ERR_NO_MEMORY;
+                        BAIL_ON_WBC_ERROR(wbc_status);
+                }
+                memcpy(request.extra_data.data, params->password.pac.data,
+                       params->password.pac.length);
+                request.extra_len = params->password.pac.length;
+                break;
+
         default:
                 break;
@@ -505 +525 @@
 
         if (cmd == WINBINDD_PAM_AUTH_CRAP) {
-                wbc_status = wbcRequestResponsePriv(cmd, &request, &response);
+                wbc_status = wbcRequestResponsePriv(ctx, cmd,
+                                                    &request, &response);
         } else {
-                wbc_status = wbcRequestResponse(cmd, &request, &response);
+                wbc_status = wbcRequestResponse(ctx, cmd,
+                                                &request, &response);
         }
         if (response.data.auth.nt_status != 0) {
@@ -534 +556 @@
 }
 
+wbcErr wbcAuthenticateUserEx(const struct wbcAuthUserParams *params,
+                             struct wbcAuthUserInfo **info,
+                             struct wbcAuthErrorInfo **error)
+{
+        return wbcCtxAuthenticateUserEx(NULL, params, info, error);
+}
+
 /* Trigger a verification of the trust credentials of a specific domain */
-wbcErr wbcCheckTrustCredentials(const char *domain,
-                                struct wbcAuthErrorInfo **error)
+wbcErr wbcCtxCheckTrustCredentials(struct wbcContext *ctx, const char *domain,
+                                   struct wbcAuthErrorInfo **error)
 {
         struct winbindd_request request;
@@ -552 +581 @@
         /* Send request */
 
-        wbc_status = wbcRequestResponsePriv(WINBINDD_CHECK_MACHACC,
+        wbc_status = wbcRequestResponsePriv(ctx, WINBINDD_CHECK_MACHACC,
                                             &request, &response);
         if (response.data.auth.nt_status != 0) {
@@ -570 +599 @@
 }
 
+wbcErr wbcCheckTrustCredentials(const char *domain,
+                                struct wbcAuthErrorInfo **error)
+{
+        return wbcCtxCheckTrustCredentials(NULL, domain, error);
+}
+
 /* Trigger a change of the trust credentials for a specific domain */
-wbcErr wbcChangeTrustCredentials(const char *domain,
-                                 struct wbcAuthErrorInfo **error)
+wbcErr wbcCtxChangeTrustCredentials(struct wbcContext *ctx, const char *domain,
+                                    struct wbcAuthErrorInfo **error)
 {
         struct winbindd_request request;
@@ -588 +623 @@
         /* Send request */
 
-        wbc_status = wbcRequestResponsePriv(WINBINDD_CHANGE_MACHACC,
-                                        &request, &response);
+        wbc_status = wbcRequestResponsePriv(ctx, WINBINDD_CHANGE_MACHACC,
+                                            &request, &response);
         if (response.data.auth.nt_status != 0) {
                 if (error) {
@@ -606 +641 @@
 }
 
+wbcErr wbcChangeTrustCredentials(const char *domain,
+                                 struct wbcAuthErrorInfo **error)
+{
+        return wbcCtxChangeTrustCredentials(NULL, domain, error);
+}
+
 /*
  * Trigger a no-op NETLOGON call. Lightweight version of
  * wbcCheckTrustCredentials
  */
+wbcErr wbcCtxPingDc(struct wbcContext *ctx, const char *domain,
+                    struct wbcAuthErrorInfo **error)
+{
+        return wbcCtxPingDc2(ctx, domain, error, NULL);
+}
+
 wbcErr wbcPingDc(const char *domain, struct wbcAuthErrorInfo **error)
+{
+        return wbcPingDc2(domain, error, NULL);
+}
+
+/*
+ * Trigger a no-op NETLOGON call. Lightweight version of
+ * wbcCheckTrustCredentials, optionally return attempted DC
+ */
+wbcErr wbcCtxPingDc2(struct wbcContext *ctx, const char *domain,
+                     struct wbcAuthErrorInfo **error, char **dcname)
 {
         struct winbindd_request request;
@@ -616 +673 @@
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 
-        if (domain) {
-                /*
-                 * the current protocol doesn't support
-                 * specifying a domain
-                 */
-                wbc_status = WBC_ERR_NOT_IMPLEMENTED;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
         ZERO_STRUCT(request);
         ZERO_STRUCT(response);
 
+        if (domain) {
+                strncpy(request.domain_name, domain,
+                        sizeof(request.domain_name)-1);
+        }
+
         /* Send request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_PING_DC,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_PING_DC,
                                         &request,
                                         &response);
+
+        if (dcname && response.extra_data.data) {
+                size_t len;
+
+                len = response.length - sizeof(struct winbindd_response);
+                *dcname = wbcAllocateMemory(1, len, NULL);
+                BAIL_ON_PTR_ERROR(*dcname, wbc_status);
+
+                strlcpy(*dcname, response.extra_data.data, len);
+        }
+
         if (response.data.auth.nt_status != 0) {
                 if (error) {
@@ -649 +713 @@
 }
 
+wbcErr wbcPingDc2(const char *domain, struct wbcAuthErrorInfo **error,
+                  char **dcname)
+{
+        return wbcCtxPingDc2(NULL, domain, error, dcname);
+}
+
 /* Trigger an extended logoff notification to Winbind for a specific user */
-wbcErr wbcLogoffUserEx(const struct wbcLogoffUserParams *params,
-                       struct wbcAuthErrorInfo **error)
+wbcErr wbcCtxLogoffUserEx(struct wbcContext *ctx,
+                          const struct wbcLogoffUserParams *params,
+                          struct wbcAuthErrorInfo **error)
 {
         struct winbindd_request request;
@@ -714 +785 @@
         /* Send request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_PAM_LOGOFF,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_PAM_LOGOFF,
                                         &request,
                                         &response);
@@ -735 +806 @@
 }
 
+wbcErr wbcLogoffUserEx(const struct wbcLogoffUserParams *params,
+                       struct wbcAuthErrorInfo **error)
+{
+        return wbcCtxLogoffUserEx(NULL, params, error);
+}
+
 /* Trigger a logoff notification to Winbind for a specific user */
+wbcErr wbcCtxLogoffUser(struct wbcContext *ctx,
+                        const char *username, uid_t uid,
+                        const char *ccfilename)
+{
+        struct winbindd_request request;
+        struct winbindd_response response;
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+        /* validate input */
+
+        if (!username) {
+                wbc_status = WBC_ERR_INVALID_PARAM;
+                BAIL_ON_WBC_ERROR(wbc_status);
+        }
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        strncpy(request.data.logoff.user, username,
+                sizeof(request.data.logoff.user)-1);
+        request.data.logoff.uid = uid;
+
+        if (ccfilename) {
+                strncpy(request.data.logoff.krb5ccname, ccfilename,
+                        sizeof(request.data.logoff.krb5ccname)-1);
+        }
+
+        /* Send request */
+
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_PAM_LOGOFF,
+                                        &request,
+                                        &response);
+
+        /* Take the response above and return it to the caller */
+
+ done:
+        return wbc_status;
+}
+
 wbcErr wbcLogoffUser(const char *username,
                      uid_t uid,
                      const char *ccfilename)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        /* validate input */
-
-        if (!username) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        strncpy(request.data.logoff.user, username,
-                sizeof(request.data.logoff.user)-1);
-        request.data.logoff.uid = uid;
-
-        if (ccfilename) {
-                strncpy(request.data.logoff.krb5ccname, ccfilename,
-                        sizeof(request.data.logoff.krb5ccname)-1);
-        }
-
-        /* Send request */
-
-        wbc_status = wbcRequestResponse(WINBINDD_PAM_LOGOFF,
-                                        &request,
-                                        &response);
-
-        /* Take the response above and return it to the caller */
-
- done:
-        return wbc_status;
+        return wbcCtxLogoffUser(NULL, username, uid, ccfilename);
 }
 
 /* Change a password for a user with more detailed information upon failure */
-wbcErr wbcChangeUserPasswordEx(const struct wbcChangePasswordParams *params,
-                               struct wbcAuthErrorInfo **error,
-                               enum wbcPasswordChangeRejectReason *reject_reason,
-                               struct wbcUserPasswordPolicyInfo **policy)
+wbcErr wbcCtxChangeUserPasswordEx(struct wbcContext *ctx,
+                        const struct wbcChangePasswordParams *params,
+                        struct wbcAuthErrorInfo **error,
+                        enum wbcPasswordChangeRejectReason *reject_reason,
+                        struct wbcUserPasswordPolicyInfo **policy)
 {
         struct winbindd_request request;
@@ -938 +1023 @@
         /* Send request */
 
-        wbc_status = wbcRequestResponse(cmd,
+        wbc_status = wbcRequestResponse(ctx, cmd,
                                         &request,
                                         &response);
@@ -973 +1058 @@
 }
 
+wbcErr wbcChangeUserPasswordEx(const struct wbcChangePasswordParams *params,
+                              struct wbcAuthErrorInfo **error,
+                              enum wbcPasswordChangeRejectReason *reject_reason,
+                              struct wbcUserPasswordPolicyInfo **policy)
+{
+        return wbcCtxChangeUserPasswordEx(NULL, params, error,
+                                          reject_reason, policy);
+}
+
 /* Change a password for a user */
-wbcErr wbcChangeUserPassword(const char *username,
-                             const char *old_password,
-                             const char *new_password)
+wbcErr wbcCtxChangeUserPassword(struct wbcContext *ctx,
+                                const char *username,
+                                const char *old_password,
+                                const char *new_password)
 {
         wbcErr wbc_status = WBC_ERR_SUCCESS;
@@ -988 +1083 @@
         params.new_password.plaintext   = new_password;
 
-        wbc_status = wbcChangeUserPasswordEx(&params,
-                                             NULL,
-                                             NULL,
-                                             NULL);
+        wbc_status = wbcCtxChangeUserPasswordEx(ctx, &params,
+                                                NULL,
+                                                NULL,
+                                                NULL);
         BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -998 +1093 @@
 }
 
+wbcErr wbcChangeUserPassword(const char *username,
+                             const char *old_password,
+                             const char *new_password)
+{
+        return wbcCtxChangeUserPassword(NULL, username,
+                                        old_password, new_password);
+}
+
 /* Logon a User */
-wbcErr wbcLogonUser(const struct wbcLogonUserParams *params,
-                    struct wbcLogonUserInfo **info,
-                    struct wbcAuthErrorInfo **error,
-                    struct wbcUserPasswordPolicyInfo **policy)
+wbcErr wbcCtxLogonUser(struct wbcContext *ctx,
+                       const struct wbcLogonUserParams *params,
+                       struct wbcLogonUserInfo **info,
+                       struct wbcAuthErrorInfo **error,
+                       struct wbcUserPasswordPolicyInfo **policy)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -1104 +1208 @@
         }
 
-        wbc_status = wbcRequestResponse(WINBINDD_PAM_AUTH,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_PAM_AUTH,
                                         &request,
                                         &response);
@@ -1138 +1242 @@
 }
 
+wbcErr wbcLogonUser(const struct wbcLogonUserParams *params,
+                    struct wbcLogonUserInfo **info,
+                    struct wbcAuthErrorInfo **error,
+                    struct wbcUserPasswordPolicyInfo **policy)
+{
+        return wbcCtxLogonUser(NULL, params, info, error, policy);
+}
+
 static void wbcCredentialCacheInfoDestructor(void *ptr)
 {
@@ -1146 +1258 @@
 
 /* Authenticate a user with cached credentials */
-wbcErr wbcCredentialCache(struct wbcCredentialCacheParams *params,
-                          struct wbcCredentialCacheInfo **info,
-                          struct wbcAuthErrorInfo **error)
+wbcErr wbcCtxCredentialCache(struct wbcContext *ctx,
+                             struct wbcCredentialCacheParams *params,
+                             struct wbcCredentialCacheInfo **info,
+                             struct wbcAuthErrorInfo **error)
 {
         wbcErr status = WBC_ERR_UNKNOWN_FAILURE;
@@ -1161 +1274 @@
         ZERO_STRUCT(response);
 
-        if (info != NULL) {
-                *info = NULL;
-        }
+        *info = NULL;
+
         if (error != NULL) {
                 *error = NULL;
@@ -1174 +1286 @@
         }
 
+        for (i=0; i<params->num_blobs; i++) {
+                /*
+                 * Older callers may used to provide the NEGOTIATE request
+                 * as "initial_blob", but it was completely ignored by winbindd.
+                 *
+                 * So we keep ignoring it.
+                 *
+                 * A new callers that is capable to support "new_spnego",
+                 * will provide the NEGOTIATE request as "negotiate_blob"
+                 * instead.
+                 */
+                if (strcasecmp(params->blobs[i].name, "negotiate_blob") == 0) {
+                        if (initial_blob != NULL) {
+                                status = WBC_ERR_INVALID_PARAM;
+                                goto fail;
+                        }
+                        initial_blob = &params->blobs[i];
+                        continue;
+                }
+                if (strcasecmp(params->blobs[i].name, "challenge_blob") == 0) {
+                        if (challenge_blob != NULL) {
+                                status = WBC_ERR_INVALID_PARAM;
+                                goto fail;
+                        }
+                        challenge_blob = &params->blobs[i];
+                        continue;
+                }
+        }
+
         if (params->domain_name != NULL) {
-                status = wbcRequestResponse(WINBINDD_INFO, NULL, &response);
+                status = wbcRequestResponse(ctx, WINBINDD_INFO,
+                                            NULL, &response);
                 if (!WBC_ERROR_IS_OK(status)) {
                         goto fail;
@@ -1191 +1333 @@
         request.data.ccache_ntlm_auth.uid = getuid();
 
-        for (i=0; i<params->num_blobs; i++) {
-                if (strcasecmp(params->blobs[i].name, "initial_blob") == 0) {
-                        initial_blob = &params->blobs[i];
-                        break;
-                }
-                if (strcasecmp(params->blobs[i].name, "challenge_blob") == 0) {
-                        challenge_blob = &params->blobs[i];
-                        break;
-                }
-        }
-
         request.data.ccache_ntlm_auth.initial_blob_len = 0;
         request.data.ccache_ntlm_auth.challenge_blob_len = 0;
@@ -1235 +1366 @@
         }
 
-        status = wbcRequestResponse(WINBINDD_CCACHE_NTLMAUTH, &request,
-                                    &response);
+        status = wbcRequestResponse(ctx, WINBINDD_CCACHE_NTLMAUTH,
+                                    &request, &response);
         if (!WBC_ERROR_IS_OK(status)) {
                 goto fail;
@@ -1264 +1395 @@
                 goto fail;
         }
+        if (response.data.ccache_ntlm_auth.new_spnego) {
+                status = wbcAddNamedBlob(
+                        &result->num_blobs, &result->blobs, "new_spnego", 0,
+                        &response.data.ccache_ntlm_auth.new_spnego,
+                        sizeof(response.data.ccache_ntlm_auth.new_spnego));
+                if (!WBC_ERROR_IS_OK(status)) {
+                        goto fail;
+                }
+        }
 
         *info = result;
@@ -1275 +1415 @@
 }
 
+wbcErr wbcCredentialCache(struct wbcCredentialCacheParams *params,
+                          struct wbcCredentialCacheInfo **info,
+                          struct wbcAuthErrorInfo **error)
+{
+        return wbcCtxCredentialCache(NULL, params, info, error);
+}
+
 /* Authenticate a user with cached credentials */
-wbcErr wbcCredentialSave(const char *user, const char *password)
+wbcErr wbcCtxCredentialSave(struct wbcContext *ctx,
+                            const char *user, const char *password)
 {
         struct winbindd_request request;
@@ -1290 +1438 @@
         request.data.ccache_save.uid = getuid();
 
-        return wbcRequestResponse(WINBINDD_CCACHE_SAVE, &request, &response);
-}
+        return wbcRequestResponse(ctx, WINBINDD_CCACHE_SAVE, &request, &response);
+}
+
+wbcErr wbcCredentialSave(const char *user, const char *password)
+{
+        return wbcCtxCredentialSave(NULL, user, password);
+}

vendor/current/nsswitch/libwbclient/wbc_pwd.c

@@ -5 +5 @@
 
    Copyright (C) Gerald (Jerry) Carter 2007
+   Copyright (C) Matthew Newton 2015
 
 
@@ -168 +169 @@
 
 /* Fill in a struct passwd* for a domain user based on username */
-wbcErr wbcGetpwnam(const char *name, struct passwd **pwd)
+wbcErr wbcCtxGetpwnam(struct wbcContext *ctx,
+                      const char *name, struct passwd **pwd)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -188 +190 @@
         strncpy(request.data.username, name, sizeof(request.data.username)-1);
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETPWNAM,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETPWNAM,
                                         &request,
                                         &response);
@@ -200 +202 @@
 }
 
+wbcErr wbcGetpwnam(const char *name, struct passwd **pwd)
+{
+        return wbcCtxGetpwnam(NULL, name, pwd);
+}
+
 /* Fill in a struct passwd* for a domain user based on uid */
-wbcErr wbcGetpwuid(uid_t uid, struct passwd **pwd)
+wbcErr wbcCtxGetpwuid(struct wbcContext *ctx, uid_t uid, struct passwd **pwd)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -219 +226 @@
         request.data.uid = uid;
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETPWUID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETPWUID,
                                         &request,
                                         &response);
@@ -231 +238 @@
 }
 
+wbcErr wbcGetpwuid(uid_t uid, struct passwd **pwd)
+{
+        return wbcCtxGetpwuid(NULL, uid, pwd);
+}
+
 /* Fill in a struct passwd* for a domain user based on sid */
-wbcErr wbcGetpwsid(struct wbcDomainSid *sid, struct passwd **pwd)
+wbcErr wbcCtxGetpwsid(struct wbcContext *ctx,
+                      struct wbcDomainSid *sid, struct passwd **pwd)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -250 +263 @@
         wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETPWSID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETPWSID,
                                         &request,
                                         &response);
@@ -262 +275 @@
 }
 
+wbcErr wbcGetpwsid(struct wbcDomainSid *sid, struct passwd **pwd)
+{
+        return wbcCtxGetpwsid(NULL, sid, pwd);
+}
+
 /* Fill in a struct passwd* for a domain user based on username */
-wbcErr wbcGetgrnam(const char *name, struct group **grp)
+wbcErr wbcCtxGetgrnam(struct wbcContext *ctx,
+                      const char *name, struct group **grp)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -283 +302 @@
         strncpy(request.data.groupname, name, sizeof(request.data.groupname)-1);
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETGRNAM,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETGRNAM,
                                         &request,
                                         &response);
@@ -298 +317 @@
 }
 
+wbcErr wbcGetgrnam(const char *name, struct group **grp)
+{
+        return wbcCtxGetgrnam(NULL, name, grp);
+}
+
 /* Fill in a struct passwd* for a domain user based on uid */
-wbcErr wbcGetgrgid(gid_t gid, struct group **grp)
+wbcErr wbcCtxGetgrgid(struct wbcContext *ctx, gid_t gid, struct group **grp)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -317 +341 @@
         request.data.gid = gid;
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETGRGID,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETGRGID,
                                         &request,
                                         &response);
@@ -332 +356 @@
 }
 
-/** @brief Number of cached passwd structs
- *
- */
-static uint32_t pw_cache_size;
-
-/** @brief Position of the pwent context
- *
- */
-static uint32_t pw_cache_idx;
+wbcErr wbcGetgrgid(gid_t gid, struct group **grp)
+{
+        return wbcCtxGetgrgid(NULL, gid, grp);
+}
 
 /** @brief Winbindd response containing the passwd structs
@@ -348 +367 @@
 
 /* Reset the passwd iterator */
+wbcErr wbcCtxSetpwent(struct wbcContext *ctx)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
+        if (ctx->pw_cache_size > 0) {
+                ctx->pw_cache_idx = ctx->pw_cache_size = 0;
+                winbindd_free_response(&pw_response);
+        }
+
+        ZERO_STRUCT(pw_response);
+
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_SETPWENT,
+                                        NULL, NULL);
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+ done:
+        return wbc_status;
+}
+
 wbcErr wbcSetpwent(void)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        if (pw_cache_size > 0) {
-                pw_cache_idx = pw_cache_size = 0;
+        return wbcCtxSetpwent(NULL);
+}
+
+/* Close the passwd iterator */
+wbcErr wbcCtxEndpwent(struct wbcContext *ctx)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
+        if (ctx->pw_cache_size > 0) {
+                ctx->pw_cache_idx = ctx->pw_cache_size = 0;
                 winbindd_free_response(&pw_response);
         }
 
-        ZERO_STRUCT(pw_response);
-
-        wbc_status = wbcRequestResponse(WINBINDD_SETPWENT,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_ENDPWENT,
                                         NULL, NULL);
         BAIL_ON_WBC_ERROR(wbc_status);
@@ -367 +417 @@
 }
 
-/* Close the passwd iterator */
 wbcErr wbcEndpwent(void)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        if (pw_cache_size > 0) {
-                pw_cache_idx = pw_cache_size = 0;
-                winbindd_free_response(&pw_response);
-        }
-
-        wbc_status = wbcRequestResponse(WINBINDD_ENDPWENT,
-                                        NULL, NULL);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
+        return wbcCtxEndpwent(NULL);
 }
 
 /* Return the next struct passwd* entry from the pwent iterator */
+wbcErr wbcCtxGetpwent(struct wbcContext *ctx, struct passwd **pwd)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        struct winbindd_request request;
+        struct winbindd_pw *wb_pw;
+
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
+        /* If there's a cached result, return that. */
+        if (ctx->pw_cache_idx < ctx->pw_cache_size) {
+                goto return_result;
+        }
+
+        /* Otherwise, query winbindd for some entries. */
+
+        ctx->pw_cache_idx = 0;
+
+        winbindd_free_response(&pw_response);
+
+        ZERO_STRUCT(request);
+        request.data.num_entries = MAX_GETPWENT_USERS;
+
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETPWENT, &request,
+                                        &pw_response);
+
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        ctx->pw_cache_size = pw_response.data.num_entries;
+
+return_result:
+
+        wb_pw = (struct winbindd_pw *) pw_response.extra_data.data;
+
+        *pwd = copy_passwd_entry(&wb_pw[ctx->pw_cache_idx]);
+
+        BAIL_ON_PTR_ERROR(*pwd, wbc_status);
+
+        ctx->pw_cache_idx++;
+
+done:
+        return wbc_status;
+}
+
 wbcErr wbcGetpwent(struct passwd **pwd)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        struct winbindd_request request;
-        struct winbindd_pw *wb_pw;
-
-        /* If there's a cached result, return that. */
-        if (pw_cache_idx < pw_cache_size) {
-                goto return_result;
-        }
-
-        /* Otherwise, query winbindd for some entries. */
-
-        pw_cache_idx = 0;
-
-        winbindd_free_response(&pw_response);
-
-        ZERO_STRUCT(request);
-        request.data.num_entries = MAX_GETPWENT_USERS;
-
-        wbc_status = wbcRequestResponse(WINBINDD_GETPWENT, &request,
-                                        &pw_response);
-
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        pw_cache_size = pw_response.data.num_entries;
-
-return_result:
-
-        wb_pw = (struct winbindd_pw *) pw_response.extra_data.data;
-
-        *pwd = copy_passwd_entry(&wb_pw[pw_cache_idx]);
-
-        BAIL_ON_PTR_ERROR(*pwd, wbc_status);
-
-        pw_cache_idx++;
-
-done:
-        return wbc_status;
-}
-
-/** @brief Number of cached group structs
- *
- */
-static uint32_t gr_cache_size;
-
-/** @brief Position of the grent context
- *
- */
-static uint32_t gr_cache_idx;
+        return wbcCtxGetpwent(NULL, pwd);
+}
 
 /** @brief Winbindd response containing the group structs
@@ -443 +479 @@
 
 /* Reset the group iterator */
+wbcErr wbcCtxSetgrent(struct wbcContext *ctx)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
+        if (ctx->gr_cache_size > 0) {
+                ctx->gr_cache_idx = ctx->gr_cache_size = 0;
+                winbindd_free_response(&gr_response);
+        }
+
+        ZERO_STRUCT(gr_response);
+
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_SETGRENT,
+                                        NULL, NULL);
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+ done:
+        return wbc_status;
+}
+
 wbcErr wbcSetgrent(void)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        if (gr_cache_size > 0) {
-                gr_cache_idx = gr_cache_size = 0;
+        return wbcCtxSetgrent(NULL);
+}
+
+/* Close the group iterator */
+wbcErr wbcCtxEndgrent(struct wbcContext *ctx)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
+        if (ctx->gr_cache_size > 0) {
+                ctx->gr_cache_idx = ctx->gr_cache_size = 0;
                 winbindd_free_response(&gr_response);
         }
 
-        ZERO_STRUCT(gr_response);
-
-        wbc_status = wbcRequestResponse(WINBINDD_SETGRENT,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_ENDGRENT,
                                         NULL, NULL);
         BAIL_ON_WBC_ERROR(wbc_status);
@@ -462 +529 @@
 }
 
-/* Close the group iterator */
 wbcErr wbcEndgrent(void)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        if (gr_cache_size > 0) {
-                gr_cache_idx = gr_cache_size = 0;
-                winbindd_free_response(&gr_response);
-        }
-
-        wbc_status = wbcRequestResponse(WINBINDD_ENDGRENT,
-                                        NULL, NULL);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
- done:
-        return wbc_status;
+        return wbcCtxEndgrent(NULL);
 }
 
 /* Return the next struct group* entry from the pwent iterator */
-wbcErr wbcGetgrent(struct group **grp)
+wbcErr wbcCtxGetgrent(struct wbcContext *ctx, struct group **grp)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -488 +542 @@
         uint32_t mem_ofs;
 
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
         /* If there's a cached result, return that. */
-        if (gr_cache_idx < gr_cache_size) {
+        if (ctx->gr_cache_idx < ctx->gr_cache_size) {
                 goto return_result;
         }
@@ -495 +553 @@
         /* Otherwise, query winbindd for some entries. */
 
-        gr_cache_idx = 0;
+        ctx->gr_cache_idx = 0;
 
         winbindd_free_response(&gr_response);
@@ -502 +560 @@
         request.data.num_entries = MAX_GETGRENT_GROUPS;
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETGRENT, &request,
-                                        &gr_response);
-
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        gr_cache_size = gr_response.data.num_entries;
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETGRENT,
+                                        &request, &gr_response);
+
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        ctx->gr_cache_size = gr_response.data.num_entries;
 
 return_result:
@@ -513 +571 @@
         wb_gr = (struct winbindd_gr *) gr_response.extra_data.data;
 
-        mem_ofs = wb_gr[gr_cache_idx].gr_mem_ofs +
-                  gr_cache_size * sizeof(struct winbindd_gr);
-
-        *grp = copy_group_entry(&wb_gr[gr_cache_idx],
+        mem_ofs = wb_gr[ctx->gr_cache_idx].gr_mem_ofs +
+                  ctx->gr_cache_size * sizeof(struct winbindd_gr);
+
+        *grp = copy_group_entry(&wb_gr[ctx->gr_cache_idx],
                                 ((char *)gr_response.extra_data.data)+mem_ofs);
 
         BAIL_ON_PTR_ERROR(*grp, wbc_status);
 
-        gr_cache_idx++;
+        ctx->gr_cache_idx++;
 
 done:
@@ -527 +585 @@
 }
 
+wbcErr wbcGetgrent(struct group **grp)
+{
+        return wbcCtxGetgrent(NULL, grp);
+}
+
 /* Return the next struct group* entry from the pwent iterator */
-wbcErr wbcGetgrlist(struct group **grp)
+wbcErr wbcCtxGetgrlist(struct wbcContext *ctx, struct group **grp)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -534 +597 @@
         struct winbindd_gr *wb_gr;
 
+        if (!ctx) {
+                ctx = wbcGetGlobalCtx();
+        }
+
         /* If there's a cached result, return that. */
-        if (gr_cache_idx < gr_cache_size) {
+        if (ctx->gr_cache_idx < ctx->gr_cache_size) {
                 goto return_result;
         }
@@ -541 +608 @@
         /* Otherwise, query winbindd for some entries. */
 
-        gr_cache_idx = 0;
+        ctx->gr_cache_idx = 0;
 
         winbindd_free_response(&gr_response);
@@ -549 +616 @@
         request.data.num_entries = MAX_GETGRENT_GROUPS;
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETGRLST, &request,
-                                        &gr_response);
-
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        gr_cache_size = gr_response.data.num_entries;
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETGRLST,
+                                        &request, &gr_response);
+
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        ctx->gr_cache_size = gr_response.data.num_entries;
 
 return_result:
@@ -560 +627 @@
         wb_gr = (struct winbindd_gr *) gr_response.extra_data.data;
 
-        *grp = copy_group_entry(&wb_gr[gr_cache_idx], NULL);
+        *grp = copy_group_entry(&wb_gr[ctx->gr_cache_idx], NULL);
 
         BAIL_ON_PTR_ERROR(*grp, wbc_status);
 
-        gr_cache_idx++;
+        ctx->gr_cache_idx++;
 
 done:
@@ -570 +637 @@
 }
 
+wbcErr wbcGetgrlist(struct group **grp)
+{
+        return wbcCtxGetgrlist(NULL, grp);
+}
+
 /* Return the unix group array belonging to the given user */
-wbcErr wbcGetGroups(const char *account,
-                    uint32_t *num_groups,
-                    gid_t **_groups)
+wbcErr wbcCtxGetGroups(struct wbcContext *ctx, const char *account,
+                       uint32_t *num_groups, gid_t **_groups)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -595 +666 @@
         strncpy(request.data.username, account, sizeof(request.data.username)-1);
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETGROUPS,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETGROUPS,
                                         &request,
                                         &response);
@@ -619 +690 @@
         return wbc_status;
 }
+
+wbcErr wbcGetGroups(const char *account, uint32_t *num_groups, gid_t **_groups)
+{
+        return wbcCtxGetGroups(NULL, account, num_groups, _groups);
+}

vendor/current/nsswitch/libwbclient/wbc_sid.c

@@ -33 +33 @@
 int wbcSidToStringBuf(const struct wbcDomainSid *sid, char *buf, int buflen)
 {
-        uint32_t id_auth;
+        uint64_t id_auth;
         int i, ofs;
 
@@ -41 +41 @@
         }
 
-        /*
-         * 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] +
-                (sid->id_auth[4] << 8) +
-                (sid->id_auth[3] << 16) +
-                (sid->id_auth[2] << 24);
-
-        ofs = snprintf(buf, buflen, "S-%u-%lu",
-                       (unsigned int)sid->sid_rev_num, (unsigned long)id_auth);
+        id_auth = (uint64_t)sid->id_auth[5] +
+                ((uint64_t)sid->id_auth[4] << 8) +
+                ((uint64_t)sid->id_auth[3] << 16) +
+                ((uint64_t)sid->id_auth[2] << 24) +
+                ((uint64_t)sid->id_auth[1] << 32) +
+                ((uint64_t)sid->id_auth[0] << 40);
+
+        ofs = snprintf(buf, buflen, "S-%hhu-", (unsigned char)sid->sid_rev_num);
+        if (id_auth >= UINT32_MAX) {
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "0x%llx",
+                                (unsigned long long)id_auth);
+        } else {
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "%llu",
+                                (unsigned long 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]);
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "-%u",
+                                (unsigned int)sid->sub_auths[i]);
         }
         return ofs;
@@ -89 +92 @@
 }
 
+#define AUTHORITY_MASK  (~(0xffffffffffffULL))
+
 /* Convert a character string to a binary SID */
 wbcErr wbcStringToSid(const char *str,
@@ -95 +100 @@
         const char *p;
         char *q;
-        uint32_t x;
+        uint64_t x;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
 
@@ -116 +121 @@
 
         p = str+2;
-        x = (uint32_t)strtol(p, &q, 10);
-        if (x==0 || !q || *q!='-') {
+        x = (uint64_t)strtoul(p, &q, 10);
+        if (x==0 || x > UINT8_MAX || !q || *q!='-') {
                 wbc_status = WBC_ERR_INVALID_SID;
                 BAIL_ON_WBC_ERROR(wbc_status);
@@ -123 +128 @@
         sid->sid_rev_num = (uint8_t)x;
 
-        /* Next the Identifier Authority.  This is stored in big-endian
-           in a 6 byte array. */
-
+        /*
+         * Next the Identifier Authority.  This is stored big-endian in a
+         * 6 byte array. If the authority value is >= UINT_MAX, then it should
+         * be expressed as a hex value, according to MS-DTYP.
+         */
         p = q+1;
-        x = (uint32_t)strtol(p, &q, 10);
-        if (!q || *q!='-') {
+        x = strtoull(p, &q, 0);
+        if (!q || *q!='-' || (x & AUTHORITY_MASK)) {
                 wbc_status = WBC_ERR_INVALID_SID;
                 BAIL_ON_WBC_ERROR(wbc_status);
         }
-        sid->id_auth[5] = (x & 0x000000ff);
-        sid->id_auth[4] = (x & 0x0000ff00) >> 8;
-        sid->id_auth[3] = (x & 0x00ff0000) >> 16;
-        sid->id_auth[2] = (x & 0xff000000) >> 24;
-        sid->id_auth[1] = 0;
-        sid->id_auth[0] = 0;
+        sid->id_auth[5] = (x & 0x0000000000ffULL);
+        sid->id_auth[4] = (x & 0x00000000ff00ULL) >> 8;
+        sid->id_auth[3] = (x & 0x000000ff0000ULL) >> 16;
+        sid->id_auth[2] = (x & 0x0000ff000000ULL) >> 24;
+        sid->id_auth[1] = (x & 0x00ff00000000ULL) >> 32;
+        sid->id_auth[0] = (x & 0xff0000000000ULL) >> 40;
 
         /* now read the the subauthorities */
-
         p = q +1;
         sid->num_auths = 0;
         while (sid->num_auths < WBC_MAXSUBAUTHS) {
-                x=(uint32_t)strtoul(p, &q, 10);
+                x = strtoull(p, &q, 10);
                 if (p == q)
                         break;
-                if (q == NULL) {
+                if (x > UINT32_MAX) {
                         wbc_status = WBC_ERR_INVALID_SID;
                         BAIL_ON_WBC_ERROR(wbc_status);
@@ -175 +181 @@
 
 /* Convert a domain and name to SID */
+wbcErr wbcCtxLookupName(struct wbcContext *ctx,
+                        const char *domain,
+                        const char *name,
+                        struct wbcDomainSid *sid,
+                        enum wbcSidType *name_type)
+{
+        struct winbindd_request request;
+        struct winbindd_response response;
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+
+        if (!sid || !name_type) {
+                wbc_status = WBC_ERR_INVALID_PARAM;
+                BAIL_ON_WBC_ERROR(wbc_status);
+        }
+
+        /* Initialize request */
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        /* dst is already null terminated from the memset above */
+
+        strncpy(request.data.name.dom_name, domain,
+                sizeof(request.data.name.dom_name)-1);
+        strncpy(request.data.name.name, name,
+                sizeof(request.data.name.name)-1);
+
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LOOKUPNAME,
+                                        &request,
+                                        &response);
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        wbc_status = wbcStringToSid(response.data.sid.sid, sid);
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        *name_type = (enum wbcSidType)response.data.sid.type;
+
+        wbc_status = WBC_ERR_SUCCESS;
+
+ done:
+        return wbc_status;
+}
+
 wbcErr wbcLookupName(const char *domain,
                      const char *name,
@@ -180 +229 @@
                      enum wbcSidType *name_type)
 {
-        struct winbindd_request request;
-        struct winbindd_response response;
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-
-        if (!sid || !name_type) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        /* Initialize request */
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        /* dst is already null terminated from the memset above */
-
-        strncpy(request.data.name.dom_name, domain,
-                sizeof(request.data.name.dom_name)-1);
-        strncpy(request.data.name.name, name,
-                sizeof(request.data.name.name)-1);
-
-        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPNAME,
-                                        &request,
-                                        &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        wbc_status = wbcStringToSid(response.data.sid.sid, sid);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        *name_type = (enum wbcSidType)response.data.sid.type;
-
-        wbc_status = WBC_ERR_SUCCESS;
-
- done:
-        return wbc_status;
+        return wbcCtxLookupName(NULL, domain, name, sid, name_type);
 }
 
 
 /* Convert a SID to a domain and name */
-wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
-                    char **pdomain,
-                    char **pname,
-                    enum wbcSidType *pname_type)
+wbcErr wbcCtxLookupSid(struct wbcContext *ctx,
+                       const struct wbcDomainSid *sid,
+                       char **pdomain,
+                       char **pname,
+                       enum wbcSidType *pname_type)
 {
         struct winbindd_request request;
@@ -242 +258 @@
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSID, &request,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LOOKUPSID,
+                                        &request,
                                         &response);
         if (!WBC_ERROR_IS_OK(wbc_status)) {
@@ -280 +297 @@
 }
 
+wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
+                    char **pdomain,
+                    char **pname,
+                    enum wbcSidType *pname_type)
+{
+        return wbcCtxLookupSid(NULL, sid, pdomain, pname, pname_type);
+}
+
 static void wbcDomainInfosDestructor(void *ptr)
 {
@@ -296 +321 @@
 
         while (n->name != NULL) {
-                free(n->name);
+                wbcFreeMemory(n->name);
                 n += 1;
         }
 }
 
-wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
-                     struct wbcDomainInfo **pdomains, int *pnum_domains,
-                     struct wbcTranslatedName **pnames)
+wbcErr wbcCtxLookupSids(struct wbcContext *ctx,
+                        const struct wbcDomainSid *sids, int num_sids,
+                        struct wbcDomainInfo **pdomains, int *pnum_domains,
+                        struct wbcTranslatedName **pnames)
 {
         struct winbindd_request request;
@@ -345 +371 @@
         request.extra_len = p - sidlist;
 
-        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSIDS,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LOOKUPSIDS,
                                         &request, &response);
         free(sidlist);
@@ -470 +496 @@
 }
 
+wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
+                     struct wbcDomainInfo **pdomains, int *pnum_domains,
+                     struct wbcTranslatedName **pnames)
+{
+        return wbcCtxLookupSids(NULL, sids, num_sids, pdomains,
+                                pnum_domains, pnames);
+}
+
 /* Translate a collection of RIDs within a domain to names */
 
-wbcErr wbcLookupRids(struct wbcDomainSid *dom_sid,
+wbcErr wbcCtxLookupRids(struct wbcContext *ctx, struct wbcDomainSid *dom_sid,
                      int num_rids,
                      uint32_t *rids,
@@ -522 +556 @@
         request.extra_len = len;
 
-        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPRIDS,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LOOKUPRIDS,
                                         &request,
                                         &response);
@@ -594 +628 @@
 }
 
+wbcErr wbcLookupRids(struct wbcDomainSid *dom_sid,
+                     int num_rids,
+                     uint32_t *rids,
+                     const char **pp_domain_name,
+                     const char ***pnames,
+                     enum wbcSidType **ptypes)
+{
+        return wbcCtxLookupRids(NULL, dom_sid, num_rids, rids,
+                                pp_domain_name, pnames, ptypes);
+}
+
 /* Get the groups a user belongs to */
-wbcErr wbcLookupUserSids(const struct wbcDomainSid *user_sid,
-                         bool domain_groups_only,
-                         uint32_t *num_sids,
-                         struct wbcDomainSid **_sids)
+wbcErr wbcCtxLookupUserSids(struct wbcContext *ctx,
+                            const struct wbcDomainSid *user_sid,
+                            bool domain_groups_only,
+                            uint32_t *num_sids,
+                            struct wbcDomainSid **_sids)
 {
         uint32_t i;
@@ -626 +672 @@
         }
 
-        wbc_status = wbcRequestResponse(cmd,
+        wbc_status = wbcRequestResponse(ctx, cmd,
                                         &request,
                                         &response);
@@ -667 +713 @@
 }
 
+wbcErr wbcLookupUserSids(const struct wbcDomainSid *user_sid,
+                         bool domain_groups_only,
+                         uint32_t *num_sids,
+                         struct wbcDomainSid **_sids)
+{
+        return wbcCtxLookupUserSids(NULL, user_sid, domain_groups_only,
+                                    num_sids, _sids);
+}
+
 static inline
 wbcErr _sid_to_rid(struct wbcDomainSid *sid, uint32_t *rid)
@@ -679 +734 @@
 
 /* Get alias membership for sids */
-wbcErr wbcGetSidAliases(const struct wbcDomainSid *dom_sid,
-                        struct wbcDomainSid *sids,
-                        uint32_t num_sids,
-                        uint32_t **alias_rids,
-                        uint32_t *num_alias_rids)
+wbcErr wbcCtxGetSidAliases(struct wbcContext *ctx,
+                           const struct wbcDomainSid *dom_sid,
+                           struct wbcDomainSid *sids,
+                           uint32_t num_sids,
+                           uint32_t **alias_rids,
+                           uint32_t *num_alias_rids)
 {
         uint32_t i;
@@ -744 +800 @@
         request.extra_len = extra_data_len;
 
-        wbc_status = wbcRequestResponse(WINBINDD_GETSIDALIASES,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_GETSIDALIASES,
                                         &request,
                                         &response);
@@ -784 +840 @@
 }
 
+wbcErr wbcGetSidAliases(const struct wbcDomainSid *dom_sid,
+                        struct wbcDomainSid *sids,
+                        uint32_t num_sids,
+                        uint32_t **alias_rids,
+                        uint32_t *num_alias_rids)
+{
+        return wbcCtxGetSidAliases(NULL, dom_sid, sids, num_sids,
+                                   alias_rids, num_alias_rids);
+}
+
 
 /* Lists Users */
-wbcErr wbcListUsers(const char *domain_name,
-                    uint32_t *_num_users,
-                    const char ***_users)
+wbcErr wbcCtxListUsers(struct wbcContext *ctx,
+                       const char *domain_name,
+                       uint32_t *_num_users,
+                       const char ***_users)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -807 +874 @@
         }
 
-        wbc_status = wbcRequestResponse(WINBINDD_LIST_USERS,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LIST_USERS,
                                         &request,
                                         &response);
@@ -859 +926 @@
 }
 
+wbcErr wbcListUsers(const char *domain_name,
+                    uint32_t *_num_users,
+                    const char ***_users)
+{
+        return wbcCtxListUsers(NULL, domain_name, _num_users, _users);
+}
+
 /* Lists Groups */
-wbcErr wbcListGroups(const char *domain_name,
-                     uint32_t *_num_groups,
-                     const char ***_groups)
+wbcErr wbcCtxListGroups(struct wbcContext *ctx,
+                        const char *domain_name,
+                        uint32_t *_num_groups,
+                        const char ***_groups)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -881 +956 @@
         }
 
-        wbc_status = wbcRequestResponse(WINBINDD_LIST_GROUPS,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LIST_GROUPS,
                                         &request,
                                         &response);
@@ -933 +1008 @@
 }
 
-wbcErr wbcGetDisplayName(const struct wbcDomainSid *sid,
-                         char **pdomain,
-                         char **pfullname,
-                         enum wbcSidType *pname_type)
+wbcErr wbcListGroups(const char *domain_name,
+                     uint32_t *_num_groups,
+                     const char ***_groups)
+{
+        return wbcCtxListGroups(NULL, domain_name, _num_groups, _groups);
+}
+
+wbcErr wbcCtxGetDisplayName(struct wbcContext *ctx,
+                            const struct wbcDomainSid *sid,
+                            char **pdomain,
+                            char **pfullname,
+                            enum wbcSidType *pname_type)
 {
         wbcErr wbc_status;
@@ -943 +1026 @@
         enum wbcSidType name_type;
 
-        wbc_status = wbcLookupSid(sid, &domain, &name, &name_type);
+        wbc_status = wbcCtxLookupSid(ctx, sid, &domain, &name, &name_type);
         BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -950 +1033 @@
                 struct passwd *pwd;
 
-                wbc_status = wbcSidToUid(sid, &uid);
-                BAIL_ON_WBC_ERROR(wbc_status);
-
-                wbc_status = wbcGetpwuid(uid, &pwd);
+                wbc_status = wbcCtxSidToUid(ctx, sid, &uid);
+                BAIL_ON_WBC_ERROR(wbc_status);
+
+                wbc_status = wbcCtxGetpwuid(ctx, uid, &pwd);
                 BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -976 +1059 @@
 
         return wbc_status;
+}
+
+wbcErr wbcGetDisplayName(const struct wbcDomainSid *sid,
+                         char **pdomain,
+                         char **pfullname,
+                         enum wbcSidType *pname_type)
+{
+        return wbcCtxGetDisplayName(NULL, sid, pdomain, pfullname, pname_type);
 }
 

vendor/current/nsswitch/libwbclient/wbc_util.c

@@ -29 +29 @@
 /** @brief Ping winbindd to see if the daemon is running
  *
+ * @param *ctx       wbclient Context
+ *
  * @return #wbcErr
  **/
-wbcErr wbcPing(void)
+wbcErr wbcCtxPing(struct wbcContext *ctx)
 {
         struct winbindd_request request;
@@ -41 +43 @@
         ZERO_STRUCT(response);
 
-        return wbcRequestResponse(WINBINDD_PING, &request, &response);
+        return wbcRequestResponse(ctx, WINBINDD_PING, &request, &response);
+}
+
+wbcErr wbcPing(void)
+{
+        return wbcCtxPing(NULL);
 }
 
@@ -61 +68 @@
  */
 
-wbcErr wbcInterfaceDetails(struct wbcInterfaceDetails **_details)
+wbcErr wbcCtxInterfaceDetails(struct wbcContext *ctx,
+                              struct wbcInterfaceDetails **_details)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -80 +88 @@
 
         /* first the interface version */
-        wbc_status = wbcRequestResponse(WINBINDD_INTERFACE_VERSION, NULL, &response);
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_INTERFACE_VERSION,
+                                        NULL, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
         info->interface_version = response.data.interface_version;
 
         /* then the samba version and the winbind separator */
-        wbc_status = wbcRequestResponse(WINBINDD_INFO, NULL, &response);
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_INFO, NULL, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -93 +102 @@
 
         /* then the local netbios name */
-        wbc_status = wbcRequestResponse(WINBINDD_NETBIOS_NAME, NULL, &response);
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_NETBIOS_NAME,
+                                        NULL, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -100 +110 @@
 
         /* then the local workgroup name */
-        wbc_status = wbcRequestResponse(WINBINDD_DOMAIN_NAME, NULL, &response);
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_DOMAIN_NAME,
+                                        NULL, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
 
@@ -106 +117 @@
         BAIL_ON_PTR_ERROR(info->netbios_domain, wbc_status);
 
-        wbc_status = wbcDomainInfo(info->netbios_domain, &domain);
+        wbc_status = wbcCtxDomainInfo(ctx, info->netbios_domain, &domain);
         if (wbc_status == WBC_ERR_DOMAIN_NOT_FOUND) {
                 /* maybe it's a standalone server */
@@ -131 +142 @@
         wbcFreeMemory(info);
         return wbc_status;
+}
+
+wbcErr wbcInterfaceDetails(struct wbcInterfaceDetails **_details)
+{
+        return wbcCtxInterfaceDetails(NULL, _details);
 }
 
@@ -148 +164 @@
  */
 
-wbcErr wbcDomainInfo(const char *domain, struct wbcDomainInfo **dinfo)
+wbcErr wbcCtxDomainInfo(struct wbcContext *ctx,
+                        const char *domain,
+                        struct wbcDomainInfo **dinfo)
 {
         struct winbindd_request request;
@@ -168 +186 @@
                 sizeof(request.domain_name)-1);
 
-        wbc_status = wbcRequestResponse(WINBINDD_DOMAIN_INFO,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_DOMAIN_INFO,
                                         &request,
                                         &response);
@@ -204 +222 @@
 }
 
+wbcErr wbcDomainInfo(const char *domain, struct wbcDomainInfo **dinfo)
+{
+        return wbcCtxDomainInfo(NULL, domain, dinfo);
+}
+
 /* Get the list of current DCs */
-wbcErr wbcDcInfo(const char *domain, size_t *num_dcs,
-                 const char ***dc_names, const char ***dc_ips)
+wbcErr wbcCtxDcInfo(struct wbcContext *ctx,
+                    const char *domain, size_t *num_dcs,
+                    const char ***dc_names, const char ***dc_ips)
 {
         struct winbindd_request request;
@@ -227 +251 @@
         }
 
-        wbc_status = wbcRequestResponse(WINBINDD_DC_INFO,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_DC_INFO,
                                         &request, &response);
         BAIL_ON_WBC_ERROR(wbc_status);
@@ -291 +315 @@
 }
 
+wbcErr wbcDcInfo(const char *domain, size_t *num_dcs,
+                 const char ***dc_names, const char ***dc_ips)
+{
+        return wbcCtxDcInfo(NULL, domain, num_dcs, dc_names, dc_ips);
+}
+
 /* Resolve a NetbiosName via WINS */
-wbcErr wbcResolveWinsByName(const char *name, char **ip)
+wbcErr wbcCtxResolveWinsByName(struct wbcContext *ctx,
+                               const char *name, char **ip)
 {
         struct winbindd_request request;
@@ -307 +338 @@
                 sizeof(request.data.winsreq)-1);
 
-        wbc_status = wbcRequestResponse(WINBINDD_WINS_BYNAME,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_WINS_BYNAME,
                                         &request,
                                         &response);
@@ -324 +355 @@
 }
 
+wbcErr wbcResolveWinsByName(const char *name, char **ip)
+{
+        return wbcCtxResolveWinsByName(NULL, name, ip);
+}
+
 /* Resolve an IP address via WINS into a NetbiosName */
-wbcErr wbcResolveWinsByIP(const char *ip, char **name)
+wbcErr wbcCtxResolveWinsByIP(struct wbcContext *ctx,
+                             const char *ip, char **name)
 {
         struct winbindd_request request;
@@ -340 +377 @@
                 sizeof(request.data.winsreq)-1);
 
-        wbc_status = wbcRequestResponse(WINBINDD_WINS_BYIP,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_WINS_BYIP,
                                         &request,
                                         &response);
@@ -355 +392 @@
  done:
         return wbc_status;
+}
+
+wbcErr wbcResolveWinsByIP(const char *ip, char **name)
+{
+        return wbcCtxResolveWinsByIP(NULL, ip, name);
 }
 
@@ -467 +509 @@
 
         /* Online/Offline status */
-
         r = s;
-        if (r == NULL) {
-                wbc_status = WBC_ERR_INVALID_RESPONSE;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
         if ( strcmp(r, "Offline") == 0) {
                 info->domain_flags |= WBC_DOMINFO_DOMAIN_OFFLINE;
@@ -495 +532 @@
 
 /* Enumerate the domain trusts known by Winbind */
-wbcErr wbcListTrusts(struct wbcDomainInfo **domains, size_t *num_domains)
+wbcErr wbcCtxListTrusts(struct wbcContext *ctx,
+                        struct wbcDomainInfo **domains, size_t *num_domains)
 {
         struct winbindd_response response;
@@ -511 +549 @@
         /* Send request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_LIST_TRUSTDOM,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_LIST_TRUSTDOM,
                                         NULL,
                                         &response);
@@ -565 +603 @@
 }
 
+wbcErr wbcListTrusts(struct wbcDomainInfo **domains, size_t *num_domains)
+{
+        return wbcCtxListTrusts(NULL, domains, num_domains);
+}
+
 static void wbcDomainControllerInfoDestructor(void *ptr)
 {
@@ -573 +616 @@
 
 /* Enumerate the domain trusts known by Winbind */
-wbcErr wbcLookupDomainController(const char *domain,
-                                 uint32_t flags,
-                                struct wbcDomainControllerInfo **dc_info)
+wbcErr wbcCtxLookupDomainController(struct wbcContext *ctx,
+                                    const char *domain, uint32_t flags,
+                                    struct wbcDomainControllerInfo **dc_info)
 {
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -604 +647 @@
         /* Send request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_DSGETDCNAME,
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_DSGETDCNAME,
                                         &request,
                                         &response);
@@ -620 +663 @@
 }
 
+wbcErr wbcLookupDomainController(const char *domain, uint32_t flags,
+                                 struct wbcDomainControllerInfo **dc_info)
+{
+        return wbcCtxLookupDomainController(NULL, domain, flags, dc_info);
+}
+
 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));
+        free(discard_const_p(char, i->dc_unc));
+        free(discard_const_p(char, i->dc_address));
+        free(discard_const_p(char, i->domain_guid));
+        free(discard_const_p(char, i->domain_name));
+        free(discard_const_p(char, i->forest_name));
+        free(discard_const_p(char, i->dc_site_name));
+        free(discard_const_p(char, i->client_site_name));
 }
 
@@ -694 +743 @@
 
 /* Get extended domain controller information */
+wbcErr wbcCtxLookupDomainControllerEx(struct wbcContext *ctx,
+                                      const char *domain,
+                                      struct wbcGuid *guid,
+                                      const char *site,
+                                      uint32_t flags,
+                                      struct wbcDomainControllerInfoEx **dc_info)
+{
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        struct winbindd_request request;
+        struct winbindd_response response;
+
+        /* validate input params */
+
+        if (!domain || !dc_info) {
+                wbc_status = WBC_ERR_INVALID_PARAM;
+                BAIL_ON_WBC_ERROR(wbc_status);
+        }
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        request.data.dsgetdcname.flags = flags;
+
+        strncpy(request.data.dsgetdcname.domain_name, domain,
+                sizeof(request.data.dsgetdcname.domain_name)-1);
+
+        if (site) {
+                strncpy(request.data.dsgetdcname.site_name, site,
+                        sizeof(request.data.dsgetdcname.site_name)-1);
+        }
+
+        if (guid) {
+                char *str = NULL;
+
+                wbc_status = wbcGuidToString(guid, &str);
+                BAIL_ON_WBC_ERROR(wbc_status);
+
+                strncpy(request.data.dsgetdcname.domain_guid, str,
+                        sizeof(request.data.dsgetdcname.domain_guid)-1);
+
+                wbcFreeMemory(str);
+        }
+
+        /* Send request */
+
+        wbc_status = wbcRequestResponse(ctx, WINBINDD_DSGETDCNAME,
+                                        &request,
+                                        &response);
+        BAIL_ON_WBC_ERROR(wbc_status);
+
+        if (dc_info) {
+                wbc_status = wbc_create_domain_controller_info_ex(&response,
+                                                                  dc_info);
+                BAIL_ON_WBC_ERROR(wbc_status);
+        }
+
+        wbc_status = WBC_ERR_SUCCESS;
+done:
+        return wbc_status;
+}
+
 wbcErr wbcLookupDomainControllerEx(const char *domain,
                                    struct wbcGuid *guid,
@@ -700 +810 @@
                                    struct wbcDomainControllerInfoEx **dc_info)
 {
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        struct winbindd_request request;
-        struct winbindd_response response;
-
-        /* validate input params */
-
-        if (!domain || !dc_info) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        ZERO_STRUCT(request);
-        ZERO_STRUCT(response);
-
-        request.data.dsgetdcname.flags = flags;
-
-        strncpy(request.data.dsgetdcname.domain_name, domain,
-                sizeof(request.data.dsgetdcname.domain_name)-1);
-
-        if (site) {
-                strncpy(request.data.dsgetdcname.site_name, site,
-                        sizeof(request.data.dsgetdcname.site_name)-1);
-        }
-
-        if (guid) {
-                char *str = NULL;
-
-                wbc_status = wbcGuidToString(guid, &str);
-                BAIL_ON_WBC_ERROR(wbc_status);
-
-                strncpy(request.data.dsgetdcname.domain_guid, str,
-                        sizeof(request.data.dsgetdcname.domain_guid)-1);
-
-                wbcFreeMemory(str);
-        }
-
-        /* Send request */
-
-        wbc_status = wbcRequestResponse(WINBINDD_DSGETDCNAME,
-                                        &request,
-                                        &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        if (dc_info) {
-                wbc_status = wbc_create_domain_controller_info_ex(&response,
-                                                                  dc_info);
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        wbc_status = WBC_ERR_SUCCESS;
-done:
-        return wbc_status;
+        return wbcCtxLookupDomainControllerEx(NULL, domain, guid, site,
+                                              flags, dc_info);
 }
 
@@ -759 +819 @@
 
         while (b->name != NULL) {
-                free((char *)(b->name));
+                free(discard_const_p(char, b->name));
                 free(b->blob.data);
                 b += 1;

vendor/current/nsswitch/libwbclient/wbclient.c

@@ -5 +5 @@
 
    Copyright (C) Gerald (Jerry) Carter 2007
+   Copyright (C) Matthew Newton 2015
 
 
@@ -28 +29 @@
 /* From wb_common.c */
 
-NSS_STATUS winbindd_request_response(int req_type,
+struct winbindd_context;
+
+NSS_STATUS winbindd_request_response(struct winbindd_context *wbctx,
+                                     int req_type,
                                      struct winbindd_request *request,
                                      struct winbindd_response *response);
-NSS_STATUS winbindd_priv_request_response(int req_type,
+NSS_STATUS winbindd_priv_request_response(struct winbindd_context *wbctx,
+                                          int req_type,
                                           struct winbindd_request *request,
                                           struct winbindd_response *response);
+struct winbindd_context *winbindd_ctx_create(void);
+void winbindd_ctx_free(struct winbindd_context *ctx);
+
+/* Global context used for non-Ctx functions */
+
+static struct wbcContext wbcGlobalCtx = {
+        .winbindd_ctx = NULL,
+        .pw_cache_size = 0,
+        .pw_cache_idx = 0,
+        .gr_cache_size = 0,
+        .gr_cache_idx = 0
+};
 
 /*
@@ -49 +66 @@
 
 static wbcErr wbcRequestResponseInt(
+        struct winbindd_context *wbctx,
         int cmd,
         struct winbindd_request *request,
         struct winbindd_response *response,
-        NSS_STATUS (*fn)(int req_type,
+        NSS_STATUS (*fn)(struct winbindd_context *wbctx, int req_type,
                          struct winbindd_request *request,
                          struct winbindd_response *response))
@@ -61 +79 @@
         /* for some calls the request and/or response can be NULL */
 
-        nss_status = fn(cmd, request, response);
+        nss_status = fn(wbctx, cmd, request, response);
 
         switch (nss_status) {
@@ -84 +102 @@
  * @brief Wrapper around Winbind's send/receive API call
  *
+ * @param ctx       Context
  * @param cmd       Winbind command operation to perform
  * @param request   Send structure
@@ -90 +109 @@
  * @return #wbcErr
  */
-wbcErr wbcRequestResponse(int cmd,
+wbcErr wbcRequestResponse(struct wbcContext *ctx, int cmd,
                           struct winbindd_request *request,
                           struct winbindd_response *response)
 {
-        return wbcRequestResponseInt(cmd, request, response,
+        struct winbindd_context *wbctx = NULL;
+
+        if (ctx) {
+                wbctx = ctx->winbindd_ctx;
+        }
+
+        return wbcRequestResponseInt(wbctx, cmd, request, response,
                                      winbindd_request_response);
 }
 
-wbcErr wbcRequestResponsePriv(int cmd,
+wbcErr wbcRequestResponsePriv(struct wbcContext *ctx, int cmd,
                               struct winbindd_request *request,
                               struct winbindd_response *response)
 {
-        return wbcRequestResponseInt(cmd, request, response,
+        struct winbindd_context *wbctx = NULL;
+
+        if (ctx) {
+                wbctx = ctx->winbindd_ctx;
+        }
+
+        return wbcRequestResponseInt(wbctx, cmd, request, response,
                                      winbindd_priv_request_response);
 }
@@ -258 +289 @@
         return WBC_ERR_SUCCESS;
 }
+
+/* Context handling functions */
+
+static void wbcContextDestructor(void *ptr)
+{
+        struct wbcContext *ctx = (struct wbcContext *)ptr;
+
+        winbindd_ctx_free(ctx->winbindd_ctx);
+}
+
+struct wbcContext *wbcCtxCreate(void)
+{
+        struct wbcContext *ctx;
+        struct winbindd_context *wbctx;
+
+        ctx = (struct wbcContext *)wbcAllocateMemory(
+                1, sizeof(struct wbcContext), wbcContextDestructor);
+
+        if (!ctx) {
+                return NULL;
+        }
+
+        wbctx = winbindd_ctx_create();
+
+        if (!wbctx) {
+                wbcFreeMemory(ctx);
+                return NULL;
+        }
+
+        ctx->winbindd_ctx = wbctx;
+
+        return ctx;
+}
+
+void wbcCtxFree(struct wbcContext *ctx)
+{
+        wbcFreeMemory(ctx);
+}
+
+struct wbcContext *wbcGetGlobalCtx(void)
+{
+        return &wbcGlobalCtx;
+}

vendor/current/nsswitch/libwbclient/wbclient.h

@@ -6 +6 @@
    Copyright (C) Gerald (Jerry) Carter 2007
    Copyright (C) Volker Lendecke 2009
+   Copyright (C) Matthew Newton 2015
 
    This library is free software; you can redistribute it and/or
@@ -69 +70 @@
  *  0.7: Added wbcSidToStringBuf()
  *  0.8: Added wbcSidsToUnixIds() and wbcLookupSids()
+ *  0.9: Added support for WBC_ID_TYPE_BOTH
+ *  0.10: Added wbcPingDc2()
+ *  0.11: Extended wbcAuthenticateUserEx to provide PAC parsing
+ *  0.12: Added wbcCtxCreate and friends
  **/
 #define WBCLIENT_MAJOR_VERSION 0
-#define WBCLIENT_MINOR_VERSION 8
+#define WBCLIENT_MINOR_VERSION 12
 #define WBCLIENT_VENDOR_VERSION "Samba libwbclient"
 struct wbcLibraryDetails {
@@ -91 +96 @@
         char *dns_domain;
 };
+
+/**
+ *  @brief Library context data
+ *
+ **/
+
+struct wbcContext;
 
 /*
@@ -196 +208 @@
 
 /**
+ * @brief Generic Blob
+ **/
+
+struct wbcBlob {
+        uint8_t *data;
+        size_t length;
+};
+
+/**
+ * @brief Named Blob
+ **/
+
+struct wbcNamedBlob {
+        const char *name;
+        uint32_t flags;
+        struct wbcBlob blob;
+};
+
+/**
  * @brief Auth User Parameters
  **/
@@ -211 +242 @@
                 WBC_AUTH_USER_LEVEL_PLAIN = 1,
                 WBC_AUTH_USER_LEVEL_HASH = 2,
-                WBC_AUTH_USER_LEVEL_RESPONSE = 3
+                WBC_AUTH_USER_LEVEL_RESPONSE = 3,
+                WBC_AUTH_USER_LEVEL_PAC = 4
         } level;
         union {
@@ -226 +258 @@
                         uint8_t *lm_data;
                 } response;
+                struct wbcBlob pac;
         } password;
-};
-
-/**
- * @brief Generic Blob
- **/
-
-struct wbcBlob {
-        uint8_t *data;
-        size_t length;
-};
-
-/**
- * @brief Named Blob
- **/
-
-struct wbcNamedBlob {
-        const char *name;
-        uint32_t flags;
-        struct wbcBlob blob;
 };
 
@@ -519 +533 @@
 
 
+/**********************************************************
+ * Context Management
+ **********************************************************/
+
+/**
+ * @brief Create a new wbcContext context
+ *
+ * @return wbcContext
+ **/
+struct wbcContext *wbcCtxCreate(void);
+
+/**
+ * @brief Free a library context
+ *
+ * @param ctx           wbcContext to free
+ *
+ * @return void
+ **/
+void wbcCtxFree(struct wbcContext *ctx);
+
+
+
 /*
  * Utility functions for dealing with SIDs
@@ -596 +632 @@
  * @brief Ping winbindd to see if the daemon is running
  *
+ * @param *ctx        wbclient Context
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxPing(struct wbcContext *ctx);
+
+/**
+ * @brief Ping winbindd to see if the daemon is running
+ *
  * @return #wbcErr
  **/
@@ -602 +647 @@
 wbcErr wbcLibraryDetails(struct wbcLibraryDetails **details);
 
+wbcErr wbcCtxInterfaceDetails(struct wbcContext *ctx,
+                              struct wbcInterfaceDetails **details);
 wbcErr wbcInterfaceDetails(struct wbcInterfaceDetails **details);
 
@@ -611 +658 @@
  * @brief Convert a domain and name to SID
  *
+ * @param *ctx        wbclient Context
  * @param dom_name    Domain name (possibly "")
  * @param name        User or group name
@@ -618 +666 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxLookupName(struct wbcContext *ctx,
+                        const char *dom_name,
+                        const char *name,
+                        struct wbcDomainSid *sid,
+                        enum wbcSidType *name_type);
+
+/**
+ * @brief Convert a domain and name to SID
+ *
+ * @param dom_name    Domain name (possibly "")
+ * @param name        User or group name
+ * @param *sid        Pointer to the resolved domain SID
+ * @param *name_type  Pointer to the SID type
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcLookupName(const char *dom_name,
                      const char *name,
@@ -626 +690 @@
  * @brief Convert a SID to a domain and name
  *
- * @param *sid        Pointer to the domain SID to be resolved
+ * @param *ctx       wbclient Context
+ * @param *sid       Pointer to the domain SID to be resolved
+ * @param domain     Resolved Domain name (possibly "")
+ * @param name       Resolved User or group name
+ * @param *name_type Pointer to the resolved SID type
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxLookupSid(struct wbcContext *ctx,
+                       const struct wbcDomainSid *sid,
+                       char **domain,
+                       char **name,
+                       enum wbcSidType *name_type);
+
+/**
+ * @brief Convert a SID to a domain and name
+ *
+ * @param *sid       Pointer to the domain SID to be resolved
  * @param domain     Resolved Domain name (possibly "")
  * @param name       Resolved User or group name
@@ -644 +725 @@
 };
 
+wbcErr wbcCtxLookupSids(struct wbcContext *ctx,
+                        const struct wbcDomainSid *sids, int num_sids,
+                        struct wbcDomainInfo **domains, int *num_domains,
+                        struct wbcTranslatedName **names);
+
 wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
                      struct wbcDomainInfo **domains, int *num_domains,
                      struct wbcTranslatedName **names);
+
+/**
+ * @brief Translate a collection of RIDs within a domain to names
+ */
+wbcErr wbcCtxLookupRids(struct wbcContext *ctx,
+                        struct wbcDomainSid *dom_sid,
+                        int num_rids,
+                        uint32_t *rids,
+                        const char **domain_name,
+                        const char ***names,
+                        enum wbcSidType **types);
 
 /**
@@ -661 +758 @@
  * @brief Get the groups a user belongs to
  **/
+wbcErr wbcCtxLookupUserSids(struct wbcContext *ctx,
+                            const struct wbcDomainSid *user_sid,
+                            bool domain_groups_only,
+                            uint32_t *num_sids,
+                            struct wbcDomainSid **sids);
+
+/*
+ * @brief Get the groups a user belongs to
+ **/
 wbcErr wbcLookupUserSids(const struct wbcDomainSid *user_sid,
                          bool domain_groups_only,
                          uint32_t *num_sids,
                          struct wbcDomainSid **sids);
+
+/*
+ * @brief Get alias membership for sids
+ **/
+wbcErr wbcCtxGetSidAliases(struct wbcContext *ctx,
+                           const struct wbcDomainSid *dom_sid,
+                           struct wbcDomainSid *sids,
+                           uint32_t num_sids,
+                           uint32_t **alias_rids,
+                           uint32_t *num_alias_rids);
 
 /*
@@ -678 +794 @@
  * @brief Lists Users
  **/
+wbcErr wbcCtxListUsers(struct wbcContext *ctx,
+                       const char *domain_name,
+                       uint32_t *num_users,
+                       const char ***users);
+
+/**
+ * @brief Lists Users
+ **/
 wbcErr wbcListUsers(const char *domain_name,
                     uint32_t *num_users,
@@ -685 +809 @@
  * @brief Lists Groups
  **/
+wbcErr wbcCtxListGroups(struct wbcContext *ctx,
+                        const char *domain_name,
+                        uint32_t *num_groups,
+                        const char ***groups);
+
+/**
+ * @brief Lists Groups
+ **/
 wbcErr wbcListGroups(const char *domain_name,
                      uint32_t *num_groups,
                      const char ***groups);
+
+wbcErr wbcCtxGetDisplayName(struct wbcContext *ctx,
+                            const struct wbcDomainSid *sid,
+                            char **pdomain,
+                            char **pfullname,
+                            enum wbcSidType *pname_type);
 
 wbcErr wbcGetDisplayName(const struct wbcDomainSid *sid,
@@ -701 +839 @@
  * @brief Convert a Windows SID to a Unix uid, allocating an uid if needed
  *
+ * @param *ctx        wbclient Context
  * @param *sid        Pointer to the domain SID to be resolved
  * @param *puid       Pointer to the resolved uid_t value
@@ -707 +846 @@
  *
  **/
+wbcErr wbcCtxSidToUid(struct wbcContext *ctx,
+                      const struct wbcDomainSid *sid,
+                      uid_t *puid);
+
+/**
+ * @brief Convert a Windows SID to a Unix uid, allocating an uid if needed
+ *
+ * @param *sid        Pointer to the domain SID to be resolved
+ * @param *puid       Pointer to the resolved uid_t value
+ *
+ * @return #wbcErr
+ *
+ **/
 wbcErr wbcSidToUid(const struct wbcDomainSid *sid,
                    uid_t *puid);
@@ -725 +877 @@
  * @brief Convert a Unix uid to a Windows SID, allocating a SID if needed
  *
+ * @param *ctx        wbclient Context
  * @param uid         Unix uid to be resolved
  * @param *sid        Pointer to the resolved domain SID
@@ -731 +884 @@
  *
  **/
+wbcErr wbcCtxUidToSid(struct wbcContext *ctx, uid_t uid,
+                      struct wbcDomainSid *sid);
+
+/**
+ * @brief Convert a Unix uid to a Windows SID, allocating a SID if needed
+ *
+ * @param uid         Unix uid to be resolved
+ * @param *sid        Pointer to the resolved domain SID
+ *
+ * @return #wbcErr
+ *
+ **/
 wbcErr wbcUidToSid(uid_t uid,
                    struct wbcDomainSid *sid);
@@ -749 +914 @@
  * @brief Convert a Windows SID to a Unix gid, allocating a gid if needed
  *
+ * @param *ctx        wbclient Context
  * @param *sid        Pointer to the domain SID to be resolved
  * @param *pgid       Pointer to the resolved gid_t value
@@ -755 +921 @@
  *
  **/
+wbcErr wbcCtxSidToGid(struct wbcContext *ctx,
+                      const struct wbcDomainSid *sid,
+                      gid_t *pgid);
+
+/**
+ * @brief Convert a Windows SID to a Unix gid, allocating a gid if needed
+ *
+ * @param *sid        Pointer to the domain SID to be resolved
+ * @param *pgid       Pointer to the resolved gid_t value
+ *
+ * @return #wbcErr
+ *
+ **/
 wbcErr wbcSidToGid(const struct wbcDomainSid *sid,
                    gid_t *pgid);
@@ -769 +948 @@
 wbcErr wbcQuerySidToGid(const struct wbcDomainSid *sid,
                         gid_t *pgid);
+
+/**
+ * @brief Convert a Unix gid to a Windows SID, allocating a SID if needed
+ *
+ * @param *ctx        wbclient Context
+ * @param gid         Unix gid to be resolved
+ * @param *sid        Pointer to the resolved domain SID
+ *
+ * @return #wbcErr
+ *
+ **/
+wbcErr wbcCtxGidToSid(struct wbcContext *ctx, gid_t gid,
+                   struct wbcDomainSid *sid);
 
 /**
@@ -797 +989 @@
         WBC_ID_TYPE_NOT_SPECIFIED,
         WBC_ID_TYPE_UID,
-        WBC_ID_TYPE_GID
+        WBC_ID_TYPE_GID,
+        WBC_ID_TYPE_BOTH
 };
 
@@ -813 +1006 @@
  * @brief Convert a list of sids to unix ids
  *
+ * @param *ctx        wbclient Context
  * @param sids        Pointer to an array of SIDs to convert
  * @param num_sids    Number of SIDs
@@ -820 +1014 @@
  *
  **/
+wbcErr wbcCtxSidsToUnixIds(struct wbcContext *ctx,
+                           const struct wbcDomainSid *sids, uint32_t num_sids,
+                           struct wbcUnixId *ids);
+
+/**
+ * @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);
@@ -826 +1034 @@
  * @brief Obtain a new uid from Winbind
  *
- * @param *puid      *pointer to the allocated uid
+ * @param *ctx        wbclient Context
+ * @param *puid       Pointer to the allocated uid
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxAllocateUid(struct wbcContext *ctx, uid_t *puid);
+
+/**
+ * @brief Obtain a new uid from Winbind
+ *
+ * @param *puid       Pointer to the allocated uid
  *
  * @return #wbcErr
@@ -835 +1053 @@
  * @brief Obtain a new gid from Winbind
  *
- * @param *pgid      Pointer to the allocated gid
+ * @param *ctx        wbclient Context
+ * @param *pgid       Pointer to the allocated gid
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxAllocateGid(struct wbcContext *ctx, gid_t *pgid);
+
+/**
+ * @brief Obtain a new gid from Winbind
+ *
+ * @param *pgid       Pointer to the allocated gid
  *
  * @return #wbcErr
@@ -845 +1073 @@
  *
  * @param uid       Uid of the desired mapping.
- * @param *sid      Pointer to the sid of the diresired mapping.
+ * @param *sid      Pointer to the sid of the desired mapping.
  *
  * @return #wbcErr
@@ -858 +1086 @@
  *
  * @param gid       Gid of the desired mapping.
- * @param *sid      Pointer to the sid of the diresired mapping.
+ * @param *sid      Pointer to the sid of the desired mapping.
  *
  * @return #wbcErr
@@ -925 +1153 @@
  *   on username
  *
+ * @param *ctx      wbclient Context
  * @param *name     Username to lookup
  * @param **pwd     Pointer to resulting struct passwd* from the query.
@@ -930 +1159 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxGetpwnam(struct wbcContext *ctx,
+                      const char *name, struct passwd **pwd);
+
+/**
+ * @brief Fill in a struct passwd* for a domain user based
+ *   on username
+ *
+ * @param *name     Username to lookup
+ * @param **pwd     Pointer to resulting struct passwd* from the query.
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcGetpwnam(const char *name, struct passwd **pwd);
 
@@ -936 +1177 @@
  *   on uid
  *
+ * @param *ctx      wbclient Context
  * @param uid       Uid to lookup
  * @param **pwd     Pointer to resulting struct passwd* from the query.
@@ -941 +1183 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxGetpwuid(struct wbcContext *ctx,
+                      uid_t uid, struct passwd **pwd);
+
+/**
+ * @brief Fill in a struct passwd* for a domain user based
+ *   on uid
+ *
+ * @param uid       Uid to lookup
+ * @param **pwd     Pointer to resulting struct passwd* from the query.
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcGetpwuid(uid_t uid, struct passwd **pwd);
 
@@ -947 +1201 @@
  *   on sid
  *
+ * @param *ctx         wbclient Context
  * @param sid       Sid to lookup
  * @param **pwd     Pointer to resulting struct passwd* from the query.
@@ -952 +1207 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxGetpwsid(struct wbcContext *ctx,
+                      struct wbcDomainSid * sid, struct passwd **pwd);
+
+/**
+ * @brief Fill in a struct passwd* for a domain user based
+ *   on sid
+ *
+ * @param sid       Sid to lookup
+ * @param **pwd     Pointer to resulting struct passwd* from the query.
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcGetpwsid(struct wbcDomainSid * sid, struct passwd **pwd);
 
@@ -958 +1225 @@
  *   on username
  *
+ * @param *ctx      wbclient Context
  * @param *name     Username to lookup
  * @param **grp     Pointer to resulting struct group* from the query.
@@ -963 +1231 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxGetgrnam(struct wbcContext *ctx,
+                      const char *name, struct group **grp);
+
+/**
+ * @brief Fill in a struct passwd* for a domain user based
+ *   on username
+ *
+ * @param *name     Username to lookup
+ * @param **grp     Pointer to resulting struct group* from the query.
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcGetgrnam(const char *name, struct group **grp);
 
@@ -969 +1249 @@
  *   on uid
  *
+ * @param *ctx      wbclient Context
  * @param gid       Uid to lookup
  * @param **grp     Pointer to resulting struct group* from the query.
@@ -974 +1255 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxGetgrgid(struct wbcContext *ctx,
+                      gid_t gid, struct group **grp);
+
+/**
+ * @brief Fill in a struct passwd* for a domain user based
+ *   on uid
+ *
+ * @param gid       Uid to lookup
+ * @param **grp     Pointer to resulting struct group* from the query.
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcGetgrgid(gid_t gid, struct group **grp);
 
@@ -979 +1272 @@
  * @brief Reset the passwd iterator
  *
+ * @param *ctx      wbclient Context
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxSetpwent(struct wbcContext *ctx);
+
+/**
+ * @brief Reset the passwd iterator
+ *
  * @return #wbcErr
  **/
@@ -986 +1288 @@
  * @brief Close the passwd iterator
  *
+ * @param *ctx      wbclient Context
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxEndpwent(struct wbcContext *ctx);
+
+/**
+ * @brief Close the passwd iterator
+ *
  * @return #wbcErr
  **/
@@ -993 +1304 @@
  * @brief Return the next struct passwd* entry from the pwent iterator
  *
- * @param **pwd       Pointer to resulting struct passwd* from the query.
+ * @param *ctx      wbclient Context
+ * @param **pwd     Pointer to resulting struct passwd* from the query.
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxGetpwent(struct wbcContext *ctx, struct passwd **pwd);
+
+/**
+ * @brief Return the next struct passwd* entry from the pwent iterator
+ *
+ * @param **pwd     Pointer to resulting struct passwd* from the query.
  *
  * @return #wbcErr
@@ -1002 +1323 @@
  * @brief Reset the group iterator
  *
+ * @param *ctx      wbclient Context
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxSetgrent(struct wbcContext *ctx);
+
+/**
+ * @brief Reset the group iterator
+ *
  * @return #wbcErr
  **/
@@ -1009 +1339 @@
  * @brief Close the group iterator
  *
+ * @param *ctx      wbclient Context
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxEndgrent(struct wbcContext *ctx);
+
+/**
+ * @brief Close the group iterator
+ *
  * @return #wbcErr
  **/
@@ -1016 +1355 @@
  * @brief Return the next struct group* entry from the pwent iterator
  *
- * @param **grp       Pointer to resulting struct group* from the query.
+ * @param *ctx      wbclient Context
+ * @param **grp     Pointer to resulting struct group* from the query.
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxGetgrent(struct wbcContext *ctx, struct group **grp);
+
+/**
+ * @brief Return the next struct group* entry from the pwent iterator
+ *
+ * @param **grp     Pointer to resulting struct group* from the query.
  *
  * @return #wbcErr
@@ -1027 +1376 @@
  * This is similar to #wbcGetgrent, just that the member list is empty
  *
- * @param **grp       Pointer to resulting struct group* from the query.
+ * @param *ctx      wbclient Context
+ * @param **grp     Pointer to resulting struct group* from the query.
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxGetgrlist(struct wbcContext *ctx, struct group **grp);
+
+/**
+ * @brief Return the next struct group* entry from the pwent iterator
+ *
+ * This is similar to #wbcGetgrent, just that the member list is empty
+ *
+ * @param **grp     Pointer to resulting struct group* from the query.
  *
  * @return #wbcErr
@@ -1036 +1397 @@
  * @brief Return the unix group array belonging to the given user
  *
+ * @param *ctx           wbclient Context
  * @param *account       The given user name
  * @param *num_groups    Number of elements returned in the groups array
@@ -1042 +1404 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxGetGroups(struct wbcContext *ctx,
+                       const char *account,
+                       uint32_t *num_groups,
+                       gid_t **_groups);
+
+/**
+ * @brief Return the unix group array belonging to the given user
+ *
+ * @param *account       The given user name
+ * @param *num_groups    Number of elements returned in the groups array
+ * @param **_groups      Pointer to resulting gid_t array.
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcGetGroups(const char *account,
                     uint32_t *num_groups,
@@ -1054 +1430 @@
  * @brief Lookup the current status of a trusted domain
  *
- * @param domain        The domain to query
+ * @param *ctx           wbclient Context
+ * @param domain         The domain to query
+ *
+ * @param dinfo          A pointer to store the returned domain_info struct.
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxDomainInfo(struct wbcContext *ctx,
+                        const char *domain,
+                        struct wbcDomainInfo **dinfo);
+
+/**
+ * @brief Lookup the current status of a trusted domain
+ *
+ * @param domain         The domain to query
  *
  * @param dinfo          A pointer to store the returned domain_info struct.
@@ -1066 +1456 @@
  * @brief Lookup the currently contacted DCs
  *
+ * @param *ctx          wbclient Context
  * @param domain        The domain to query
  *
@@ -1074 +1465 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxDcInfo(struct wbcContext *ctx,
+                    const char *domain, size_t *num_dcs,
+                    const char ***dc_names, const char ***dc_ips);
+
+/**
+ * @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);
+
+/**
+ * @brief Enumerate the domain trusts known by Winbind
+ *
+ * @param *ctx          wbclient Context
+ * @param **domains     Pointer to the allocated domain list array
+ * @param *num_domains  Pointer to number of domains returned
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxListTrusts(struct wbcContext *ctx,
+                        struct wbcDomainInfo **domains,
+                        size_t *num_domains);
 
 /**
@@ -1113 +1532 @@
  * @brief Enumerate the domain trusts known by Winbind
  *
+ * @param *ctx          wbclient Context
  * @param domain        Name of the domain to query for a DC
  * @param flags         Bit flags used to control the domain location query
@@ -1119 +1539 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxLookupDomainController(struct wbcContext *ctx,
+                                    const char *domain,
+                                    uint32_t flags,
+                                    struct wbcDomainControllerInfo **dc_info);
+
+/**
+ * @brief Enumerate the domain trusts known by Winbind
+ *
+ * @param domain        Name of the domain to query for a DC
+ * @param flags         Bit flags used to control the domain location query
+ * @param *dc_info      Pointer to the returned domain controller information
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcLookupDomainController(const char *domain,
                                  uint32_t flags,
@@ -1126 +1560 @@
  * @brief Get extended domain controller information
  *
+ * @param *ctx          wbclient Context
  * @param domain        Name of the domain to query for a DC
  * @param guid          Guid of the domain to query for a DC
@@ -1134 +1569 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxLookupDomainControllerEx(struct wbcContext *ctx,
+                                      const char *domain,
+                                      struct wbcGuid *guid,
+                                      const char *site,
+                                      uint32_t flags,
+                                      struct wbcDomainControllerInfoEx **dc_info);
+
+/**
+ * @brief Get extended domain controller information
+ *
+ * @param domain        Name of the domain to query for a DC
+ * @param guid          Guid of the domain to query for a DC
+ * @param site          Site of the domain to query for a DC
+ * @param flags         Bit flags used to control the domain location query
+ * @param *dc_info      Pointer to the returned extended domain controller information
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcLookupDomainControllerEx(const char *domain,
                                    struct wbcGuid *guid,
@@ -1147 +1600 @@
  * @brief Authenticate a username/password pair
  *
+ * @param *ctx         wbclient Context
  * @param username     Name of user to authenticate
  * @param password     Clear text password os user
@@ -1152 +1606 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxAuthenticateUser(struct wbcContext *ctx,
+                              const char *username,
+                              const char *password);
+
+/**
+ * @brief Authenticate a username/password pair
+ *
+ * @param username     Name of user to authenticate
+ * @param password     Clear text password os user
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcAuthenticateUser(const char *username,
                            const char *password);
@@ -1158 +1624 @@
  * @brief Authenticate with more detailed information
  *
+ * @param *ctx         wbclient Context
  * @param params       Input parameters, WBC_AUTH_USER_LEVEL_HASH
  *                     is not supported yet
@@ -1165 +1632 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxAuthenticateUserEx(struct wbcContext *ctx,
+                                const struct wbcAuthUserParams *params,
+                                struct wbcAuthUserInfo **info,
+                                struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Authenticate with more detailed information
+ *
+ * @param params       Input parameters, WBC_AUTH_USER_LEVEL_HASH
+ *                     is not supported yet
+ * @param info         Output details on WBC_ERR_SUCCESS
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcAuthenticateUserEx(const struct wbcAuthUserParams *params,
                              struct wbcAuthUserInfo **info,
@@ -1172 +1654 @@
  * @brief Logon a User
  *
+ * @param[in]  *ctx        wbclient Context
  * @param[in]  params      Pointer to a wbcLogonUserParams structure
  * @param[out] info        Pointer to a pointer to a wbcLogonUserInfo structure
@@ -1179 +1662 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxLogonUser(struct wbcContext *ctx,
+                       const struct wbcLogonUserParams *params,
+                       struct wbcLogonUserInfo **info,
+                       struct wbcAuthErrorInfo **error,
+                       struct wbcUserPasswordPolicyInfo **policy);
+
+/**
+ * @brief Logon a User
+ *
+ * @param[in]  params      Pointer to a wbcLogonUserParams structure
+ * @param[out] info        Pointer to a pointer to a wbcLogonUserInfo structure
+ * @param[out] error       Pointer to a pointer to a wbcAuthErrorInfo structure
+ * @param[out] policy      Pointer to a pointer to a wbcUserPasswordPolicyInfo structure
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcLogonUser(const struct wbcLogonUserParams *params,
                     struct wbcLogonUserInfo **info,
@@ -1187 +1686 @@
  * @brief Trigger a logoff notification to Winbind for a specific user
  *
+ * @param *ctx        wbclient Context
  * @param username    Name of user to remove from Winbind's list of
  *                    logged on users.
@@ -1195 +1695 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxLogoffUser(struct wbcContext *ctx,
+                        const char *username, uid_t uid,
+                        const char *ccfilename);
+
+/**
+ * @brief Trigger a logoff notification to Winbind for a specific user
+ *
+ * @param username    Name of user to remove from Winbind's list of
+ *                    logged on users.
+ * @param uid         Uid assigned to the username
+ * @param ccfilename  Absolute path to the Krb5 credentials cache to
+ *                    be removed
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcLogoffUser(const char *username,
                      uid_t uid,
@@ -1202 +1717 @@
  * @brief Trigger an extended logoff notification to Winbind for a specific user
  *
+ * @param *ctx        wbclient Context
  * @param params      A wbcLogoffUserParams structure
  * @param error       User output details on error
@@ -1207 +1723 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxLogoffUserEx(struct wbcContext *ctx,
+                          const struct wbcLogoffUserParams *params,
+                          struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Trigger an extended logoff notification to Winbind for a specific user
+ *
+ * @param params      A wbcLogoffUserParams structure
+ * @param error       User output details on error
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcLogoffUserEx(const struct wbcLogoffUserParams *params,
                        struct wbcAuthErrorInfo **error);
@@ -1213 +1741 @@
  * @brief Change a password for a user
  *
+ * @param *ctx          wbclient Context
  * @param username      Name of user to authenticate
  * @param old_password  Old clear text password of user
@@ -1219 +1748 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxChangeUserPassword(struct wbcContext *ctx,
+                                const char *username,
+                                const char *old_password,
+                                const char *new_password);
+
+/**
+ * @brief Change a password for a user
+ *
+ * @param username      Name of user to authenticate
+ * @param old_password  Old clear text password of user
+ * @param new_password  New clear text password of user
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcChangeUserPassword(const char *username,
                              const char *old_password,
@@ -1227 +1770 @@
  *   failure
  *
+ * @param *ctx                  wbclient Context
  * @param params                Input parameters
  * @param error                 User output details on WBC_ERR_PWD_CHANGE_FAILED
@@ -1234 +1778 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxChangeUserPasswordEx(struct wbcContext *ctx,
+                                  const struct wbcChangePasswordParams *params,
+                                  struct wbcAuthErrorInfo **error,
+                                  enum wbcPasswordChangeRejectReason *reject_reason,
+                                  struct wbcUserPasswordPolicyInfo **policy);
+
+/**
+ * @brief Change a password for a user with more detailed information upon
+ *   failure
+ *
+ * @param params                Input parameters
+ * @param error                 User output details on WBC_ERR_PWD_CHANGE_FAILED
+ * @param reject_reason         New password reject reason on WBC_ERR_PWD_CHANGE_FAILED
+ * @param policy                Password policy output details on WBC_ERR_PWD_CHANGE_FAILED
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcChangeUserPasswordEx(const struct wbcChangePasswordParams *params,
                                struct wbcAuthErrorInfo **error,
@@ -1242 +1803 @@
  * @brief Authenticate a user with cached credentials
  *
+ * @param *ctx       wbclient Context
  * @param *params    Pointer to a wbcCredentialCacheParams structure
  * @param **info     Pointer to a pointer to a wbcCredentialCacheInfo structure
@@ -1248 +1810 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxCredentialCache(struct wbcContext *ctx,
+                             struct wbcCredentialCacheParams *params,
+                             struct wbcCredentialCacheInfo **info,
+                             struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Authenticate a user with cached credentials
+ *
+ * @param *params    Pointer to a wbcCredentialCacheParams structure
+ * @param **info     Pointer to a pointer to a wbcCredentialCacheInfo structure
+ * @param **error    Pointer to a pointer to a wbcAuthErrorInfo structure
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcCredentialCache(struct wbcCredentialCacheParams *params,
                           struct wbcCredentialCacheInfo **info,
@@ -1255 +1831 @@
  * @brief Save a password with winbind for doing wbcCredentialCache() later
  *
+ * @param *ctx       wbclient Context
+ * @param *user      Username
+ * @param *password  Password
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxCredentialSave(struct wbcContext *ctx,
+                            const char *user, const char *password);
+
+/**
+ * @brief Save a password with winbind for doing wbcCredentialCache() later
+ *
  * @param *user      Username
  * @param *password  Password
@@ -1269 +1857 @@
  * @brief Resolve a NetbiosName via WINS
  *
+ * @param *ctx         wbclient Context
  * @param name         Name to resolve
  * @param *ip          Pointer to the ip address string
@@ -1274 +1863 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxResolveWinsByName(struct wbcContext *ctx,
+                               const char *name, char **ip);
+
+/**
+ * @brief Resolve a NetbiosName via WINS
+ *
+ * @param name         Name to resolve
+ * @param *ip          Pointer to the ip address string
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcResolveWinsByName(const char *name, char **ip);
 
@@ -1279 +1879 @@
  * @brief Resolve an IP address via WINS into a NetbiosName
  *
- * @param ip          The ip address string
- * @param *name       Pointer to the name
+ * @param *ctx         wbclient Context
+ * @param ip           The ip address string
+ * @param *name        Pointer to the name
+ *
+ * @return #wbcErr
+ *
+ **/
+wbcErr wbcCtxResolveWinsByIP(struct wbcContext *ctx,
+                             const char *ip, char **name);
+
+/**
+ * @brief Resolve an IP address via WINS into a NetbiosName
+ *
+ * @param ip           The ip address string
+ * @param *name        Pointer to the name
  *
  * @return #wbcErr
@@ -1294 +1907 @@
  * @brief Trigger a verification of the trust credentials of a specific domain
  *
+ * @param *ctx         wbclient Context
  * @param *domain      The name of the domain.
  * @param error        Output details on WBC_ERR_AUTH_ERROR
@@ -1299 +1913 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxCheckTrustCredentials(struct wbcContext *ctx, const char *domain,
+                                   struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Trigger a verification of the trust credentials of a specific domain
+ *
+ * @param *domain      The name of the domain.
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcCheckTrustCredentials(const char *domain,
                                 struct wbcAuthErrorInfo **error);
@@ -1305 +1930 @@
  * @brief Trigger a change of the trust credentials for a specific domain
  *
+ * @param *ctx         wbclient Context
  * @param *domain      The name of the domain.
  * @param error        Output details on WBC_ERR_AUTH_ERROR
@@ -1310 +1936 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxChangeTrustCredentials(struct wbcContext *ctx, const char *domain,
+                                    struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Trigger a change of the trust credentials for a specific domain
+ *
+ * @param *domain      The name of the domain.
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcChangeTrustCredentials(const char *domain,
                                  struct wbcAuthErrorInfo **error);
@@ -1317 +1954 @@
  *        version of wbcCheckTrustCredentials
  *
+ * @param *ctx         wbclient Context
  * @param *domain      The name of the domain, only NULL for the default domain is
  *                     supported yet. Other values than NULL will result in
@@ -1324 +1962 @@
  * @return #wbcErr
  **/
+wbcErr wbcCtxPingDc(struct wbcContext *ctx, const char *domain,
+                    struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Trigger a no-op call through the NETLOGON pipe. Low-cost
+ *        version of wbcCheckTrustCredentials
+ *
+ * @param *domain      The name of the domain, only NULL for the default domain is
+ *                     supported yet. Other values than NULL will result in
+ *                     WBC_ERR_NOT_IMPLEMENTED.
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ *
+ * @return #wbcErr
+ **/
 wbcErr wbcPingDc(const char *domain, struct wbcAuthErrorInfo **error);
+
+/**
+ * @brief Trigger a no-op call through the NETLOGON pipe. Low-cost
+ *        version of wbcCheckTrustCredentials
+ *
+ * @param *ctx         wbclient Context
+ * @param *domain      The name of the domain, only NULL for the default domain is
+ *                     supported yet. Other values than NULL will result in
+ *                     WBC_ERR_NOT_IMPLEMENTED.
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ * @param dcname       DC that was attempted to ping
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcCtxPingDc2(struct wbcContext *ctx, const char *domain,
+                     struct wbcAuthErrorInfo **error,
+                     char **dcname);
+
+/**
+ * @brief Trigger a no-op call through the NETLOGON pipe. Low-cost
+ *        version of wbcCheckTrustCredentials
+ *
+ * @param *domain      The name of the domain, only NULL for the default domain is
+ *                     supported yet. Other values than NULL will result in
+ *                     WBC_ERR_NOT_IMPLEMENTED.
+ * @param error        Output details on WBC_ERR_AUTH_ERROR
+ * @param dcname       DC that was attempted to ping
+ *
+ * @return #wbcErr
+ **/
+wbcErr wbcPingDc2(const char *domain, struct wbcAuthErrorInfo **error,
+                  char **dcname);
 
 /**********************************************************

vendor/current/nsswitch/libwbclient/wbclient_internal.h

@@ -23 +23 @@
 #define _WBCLIENT_INTERNAL_H
 
+struct wbcContext {
+        struct winbindd_context *winbindd_ctx;
+        uint32_t pw_cache_size; /* Number of cached passwd structs */
+        uint32_t pw_cache_idx;  /* Position of the pwent context */
+        uint32_t gr_cache_size; /* Number of cached group structs */
+        uint32_t gr_cache_idx;  /* Position of the grent context */
+};
+
 /* Private functions */
 
-wbcErr wbcRequestResponse(int cmd,
+wbcErr wbcRequestResponse(struct wbcContext *ctx, int cmd,
                           struct winbindd_request *request,
                           struct winbindd_response *response);
 
-wbcErr wbcRequestResponsePriv(int cmd,
+wbcErr wbcRequestResponsePriv(struct wbcContext *ctx, int cmd,
                               struct winbindd_request *request,
                               struct winbindd_response *response);
@@ -38 +46 @@
 char *wbcStrDup(const char *str);
 const char **wbcAllocateStringArray(int num_strings);
+struct wbcContext *wbcGetGlobalCtx(void);
 
 #endif      /* _WBCLIENT_INTERNAL_H */