Winbind status program.
Copyright (C) Tim Potter 2000-2003
- Copyright (C) Andrew Bartlett 2002
+ Copyright (C) Andrew Bartlett 2002-2007
+ Copyright (C) Volker Lendecke 2009
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
#include "includes.h"
+#include "popt_common.h"
#include "winbind_client.h"
#include "libwbclient/wbclient.h"
#include "lib/popt/popt.h"
#include "../libcli/auth/libcli_auth.h"
-#if !(_SAMBA_VERSION_) < 4
+#if (_SAMBA_BUILD_) >= 4
#include "lib/cmdline/popt_common.h"
#endif
-
+#ifdef DBGC_CLASS
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_WINBIND
+#endif
static struct wbcInterfaceDetails *init_interface_details(void)
{
wbc_status = wbcInterfaceDetails(&details);
if (!WBC_ERROR_IS_OK(wbc_status)) {
d_fprintf(stderr, "could not obtain winbind interface "
- "details!\n");
+ "details: %s\n", wbcErrorString(wbc_status));
}
return details;
return true;
}
-/* Parse string of "uid,sid" or "gid,sid" into separate int and string values.
- * Return true if input was valid, false otherwise. */
-static bool parse_mapping_arg(char *arg, int *id, char **sid)
-{
- char *tmp, *endptr;
-
- if (!arg || !*arg)
- return false;
-
- tmp = strtok(arg, ",");
- *sid = strtok(NULL, ",");
-
- if (!tmp || !*tmp || !*sid || !**sid)
- return false;
-
- /* Because atoi() can return 0 on invalid input, which would be a valid
- * UID/GID we must use strtoul() and do error checking */
- *id = strtoul(tmp, &endptr, 10);
-
- if (endptr[0] != '\0')
- return false;
-
- return true;
-}
-
/* pull pwent info for a given user */
static bool wbinfo_get_userinfo(char *user)
wbc_status = wbcGetpwnam(user, &pwd);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetpwnam: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcGetpwuid(uid, &pwd);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetpwuid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcStringToSid(sid_str, &sid);
wbc_status = wbcGetpwsid(&sid, &pwd);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetpwsid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcGetgrnam(group, &grp);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetgrnam: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcGetgrgid(gid, &grp);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetgrgid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcGetGroups(user, &num_groups, &groups);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetGroups: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcStringToSid(user_sid_str, &user_sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcLookupUserSids(&user_sid, false, &num_sids, &sids);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
char *str = NULL;
wbc_status = wbcSidToString(&sids[i], &str);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: "
+ "%s\n", wbcErrorString(wbc_status));
wbcFreeMemory(sids);
return false;
}
wbc_status = wbcStringToSid(user_sid_str, &user_sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcLookupUserSids(&user_sid, true, &num_sids, &sids);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
char *str = NULL;
wbc_status = wbcSidToString(&sids[i], &str);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: "
+ "%s\n", wbcErrorString(wbc_status));
wbcFreeMemory(sids);
return false;
}
wbc_status = wbcDomainInfo(domain, &dinfo);
if (!WBC_ERROR_IS_OK(wbc_status)) {
- d_printf("wbcDomainInfo(%s) failed: %s\n", domain,
- wbcErrorString(wbc_status));
+ d_fprintf(stderr, "wbcDomainInfo(%s) failed: %s\n", domain,
+ wbcErrorString(wbc_status));
goto done;
}
wbc_status = wbcStringToSid(user_sid_str, &user_sid);
wbc_status = wbcResolveWinsByName(name, &ip);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcResolveWinsByName: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcResolveWinsByIP(ip, &name);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcResolveWinsByIP: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcListTrusts(&domain_list, &num_domains);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcListTrusts(&domain_list, &num_domains);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcDomainInfo(domain, &dinfo);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcDomainInfo: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcSidToString(&dinfo->sid, &sid_str);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: %s\n",
+ wbcErrorString(wbc_status));
wbcFreeMemory(dinfo);
return false;
}
/* Find a DC */
static bool wbinfo_dsgetdcname(const char *domain_name, uint32_t flags)
{
- struct winbindd_request request;
- struct winbindd_response response;
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct wbcDomainControllerInfoEx *dc_info;
+ char *str = NULL;
- ZERO_STRUCT(request);
- ZERO_STRUCT(response);
+ wbc_status = wbcLookupDomainControllerEx(domain_name, NULL, NULL,
+ flags | DS_DIRECTORY_SERVICE_REQUIRED,
+ &dc_info);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ printf("Could not find dc for %s\n", domain_name);
+ return false;
+ }
- fstrcpy(request.data.dsgetdcname.domain_name, domain_name);
- request.data.dsgetdcname.flags = flags;
+ wbcGuidToString(dc_info->domain_guid, &str);
- request.flags |= DS_DIRECTORY_SERVICE_REQUIRED;
+ d_printf("%s\n", dc_info->dc_unc);
+ d_printf("%s\n", dc_info->dc_address);
+ d_printf("%d\n", dc_info->dc_address_type);
+ d_printf("%s\n", str);
+ d_printf("%s\n", dc_info->domain_name);
+ d_printf("%s\n", dc_info->forest_name);
+ d_printf("0x%08x\n", dc_info->dc_flags);
+ d_printf("%s\n", dc_info->dc_site_name);
+ d_printf("%s\n", dc_info->client_site_name);
- /* Send request */
+ return true;
+}
- if (winbindd_request_response(WINBINDD_DSGETDCNAME, &request,
- &response) != NSS_STATUS_SUCCESS) {
- d_fprintf(stderr, "Could not find dc for %s\n", domain_name);
+/* Check trust account password */
+
+static bool wbinfo_check_secret(const char *domain)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct wbcAuthErrorInfo *error = NULL;
+ const char *domain_name;
+
+ if (domain) {
+ domain_name = domain;
+ } else {
+ domain_name = get_winbind_domain();
+ }
+
+ wbc_status = wbcCheckTrustCredentials(domain_name, &error);
+
+ d_printf("checking the trust secret for domain %s via RPC calls %s\n",
+ domain_name,
+ WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
+
+ if (wbc_status == WBC_ERR_AUTH_ERROR) {
+ d_fprintf(stderr, "error code was %s (0x%x)\n",
+ error->nt_string, error->nt_status);
+ wbcFreeMemory(error);
+ }
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcCheckTrustCredentials: "
+ "%s\n", wbcErrorString(wbc_status));
return false;
}
- /* Display response */
+ return true;
+}
+
+/* Find the currently connected DCs */
- d_printf("%s\n", response.data.dsgetdcname.dc_unc);
- d_printf("%s\n", response.data.dsgetdcname.dc_address);
- d_printf("%d\n", response.data.dsgetdcname.dc_address_type);
- d_printf("%s\n", response.data.dsgetdcname.domain_guid);
- d_printf("%s\n", response.data.dsgetdcname.domain_name);
- d_printf("%s\n", response.data.dsgetdcname.forest_name);
- d_printf("0x%08x\n", response.data.dsgetdcname.dc_flags);
- d_printf("%s\n", response.data.dsgetdcname.dc_site_name);
- d_printf("%s\n", response.data.dsgetdcname.client_site_name);
+static bool wbinfo_dc_info(const char *domain_name)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ size_t i, num_dcs;
+ const char **dc_names, **dc_ips;
+
+ wbc_status = wbcDcInfo(domain_name, &num_dcs,
+ &dc_names, &dc_ips);
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ printf("Could not find dc info %s\n",
+ domain_name ? domain_name : "our domain");
+ return false;
+ }
+
+ for (i=0; i<num_dcs; i++) {
+ printf("%s (%s)\n", dc_names[i], dc_ips[i]);
+ }
+ wbcFreeMemory(dc_names);
+ wbcFreeMemory(dc_ips);
return true;
}
-/* Check trust account password */
+/* Change trust account password */
+
+static bool wbinfo_change_secret(const char *domain)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct wbcAuthErrorInfo *error = NULL;
+ const char *domain_name;
+
+ if (domain) {
+ domain_name = domain;
+ } else {
+ domain_name = get_winbind_domain();
+ }
+
+ wbc_status = wbcChangeTrustCredentials(domain_name, &error);
+
+ d_printf("changing the trust secret for domain %s via RPC calls %s\n",
+ domain_name,
+ WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
-static bool wbinfo_check_secret(void)
+ if (wbc_status == WBC_ERR_AUTH_ERROR) {
+ d_fprintf(stderr, "error code was %s (0x%x)\n",
+ error->nt_string, error->nt_status);
+ wbcFreeMemory(error);
+ }
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcChangeTrustCredentials: "
+ "%s\n", wbcErrorString(wbc_status));
+ return false;
+ }
+
+ return true;
+}
+
+/* Check DC connection */
+
+static bool wbinfo_ping_dc(void)
{
wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
struct wbcAuthErrorInfo *error = NULL;
- wbc_status = wbcCheckTrustCredentials(NULL, &error);
+ wbc_status = wbcPingDc(NULL, &error);
- d_printf("checking the trust secret via RPC calls %s\n",
+ d_printf("checking the NETLOGON dc connection %s\n",
WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
if (wbc_status == WBC_ERR_AUTH_ERROR) {
wbcFreeMemory(error);
}
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcPingDc: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcUidToSid(uid, &sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcUidToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcSidToString(&sid, &sid_str);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcGidToSid(gid, &sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGidToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcSidToString(&sid, &sid_str);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcStringToSid(sid_str, &sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcSidToUid(&sid, &uid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToUid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcStringToSid(sid_str, &sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcSidToGid(&sid, &gid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToGid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcAllocateUid(&uid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcAllocateUid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcAllocateGid(&gid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcAllocateGid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
return true;
}
-static bool wbinfo_set_uid_mapping(uid_t uid, const char *sid_str)
-{
- wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
- struct wbcDomainSid sid;
-
- /* Send request */
-
- wbc_status = wbcStringToSid(sid_str, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- wbc_status = wbcSetUidMapping(uid, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- /* Display response */
-
- d_printf("uid %u now mapped to sid %s\n",
- (unsigned int)uid, sid_str);
-
- return true;
-}
-
-static bool wbinfo_set_gid_mapping(gid_t gid, const char *sid_str)
-{
- wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
- struct wbcDomainSid sid;
-
- /* Send request */
-
- wbc_status = wbcStringToSid(sid_str, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- wbc_status = wbcSetGidMapping(gid, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- /* Display response */
-
- d_printf("gid %u now mapped to sid %s\n",
- (unsigned int)gid, sid_str);
-
- return true;
-}
-
-static bool wbinfo_remove_uid_mapping(uid_t uid, const char *sid_str)
-{
- wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
- struct wbcDomainSid sid;
-
- /* Send request */
-
- wbc_status = wbcStringToSid(sid_str, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- wbc_status = wbcRemoveUidMapping(uid, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- /* Display response */
-
- d_printf("Removed uid %u to sid %s mapping\n",
- (unsigned int)uid, sid_str);
-
- return true;
-}
-
-static bool wbinfo_remove_gid_mapping(gid_t gid, const char *sid_str)
-{
- wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
- struct wbcDomainSid sid;
-
- /* Send request */
-
- wbc_status = wbcStringToSid(sid_str, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- wbc_status = wbcRemoveGidMapping(gid, &sid);
- if (!WBC_ERROR_IS_OK(wbc_status)) {
- return false;
- }
-
- /* Display response */
-
- d_printf("Removed gid %u to sid %s mapping\n",
- (unsigned int)gid, sid_str);
-
- return true;
-}
-
/* Convert sid to string */
static bool wbinfo_lookupsid(const char *sid_str)
wbc_status = wbcStringToSid(sid_str, &sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcLookupSid(&sid, &domain, &name, &type);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcLookupSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcStringToSid(sid_str, &sid);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcGetDisplayName(&sid, &domain, &name, &type);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcGetDisplayName: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
for (i=0; i<num_rids; i++) {
d_printf("%8d: %s (%s)\n", rids[i], names[i],
- sid_type_lookup(types[i]));
+ wbcSidTypeString(types[i]));
}
ret = true;
wbc_status = wbcLookupName(domain_name, account_name,
&sid, &type);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcLookupName: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
wbc_status = wbcSidToString(&sid, &sid_str);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcSidToString: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
/* Display response */
- d_printf("%s %s (%d)\n", sid_str, sid_type_lookup(type), type);
+ d_printf("%s %s (%d)\n", sid_str, wbcSidTypeString(type), type);
wbcFreeMemory(sid_str);
char *p = NULL;
char *password = NULL;
char *name = NULL;
+ char *local_cctype = NULL;
uid_t uid;
struct wbcLogonUserParams params;
struct wbcLogonUserInfo *info;
password = wbinfo_prompt_pass(frame, NULL, username);
}
+ local_cctype = talloc_strdup(frame, cctype);
+
name = s;
uid = geteuid();
(uint8_t *)&flags,
sizeof(flags));
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
+ wbcErrorString(wbc_status));
goto done;
}
(uint8_t *)&uid,
sizeof(uid));
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
+ wbcErrorString(wbc_status));
goto done;
}
¶ms.blobs,
"krb5_cc_type",
0,
- (uint8_t *)cctype,
+ (uint8_t *)local_cctype,
strlen(cctype)+1);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
+ wbcErrorString(wbc_status));
goto done;
}
if (error) {
d_fprintf(stderr,
- "error code was %s (0x%x)\nerror messsage was: %s\n",
+ "error code was %s (0x%x)\nerror message was: %s\n",
error->nt_string,
error->nt_status,
error->display_string);
}
done:
- TALLOC_FREE(frame);
wbcFreeMemory(params.blobs);
return WBC_ERROR_IS_OK(wbc_status);
#if 0
if (response.data.auth.nt_status)
d_fprintf(stderr,
- "error code was %s (0x%x)\nerror messsage was: %s\n",
+ "error code was %s (0x%x)\nerror message was: %s\n",
response.data.auth.nt_status_string,
response.data.auth.nt_status,
response.data.auth.error_string);
#endif
- TALLOC_FREE(frame);
-
return WBC_ERROR_IS_OK(wbc_status);
}
&lm, &nt, NULL, NULL)) {
data_blob_free(&names_blob);
data_blob_free(&server_chal);
- SAFE_FREE(pass);
+ TALLOC_FREE(pass);
return false;
}
data_blob_free(&names_blob);
if (wbc_status == WBC_ERR_AUTH_ERROR) {
d_fprintf(stderr,
- "error code was %s (0x%x)\nerror messsage was: %s\n",
+ "error code was %s (0x%x)\nerror message was: %s\n",
err->nt_string,
err->nt_status,
err->display_string);
data_blob_free(&nt);
data_blob_free(&lm);
+
+ return WBC_ERROR_IS_OK(wbc_status);
+}
+
+/* Authenticate a user with a plaintext password */
+
+static bool wbinfo_pam_logon(char *username)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ struct wbcLogonUserParams params;
+ struct wbcAuthErrorInfo *error;
+ char *s = NULL;
+ char *p = NULL;
+ TALLOC_CTX *frame = talloc_tos();
+ uint32_t flags;
+ uint32_t uid;
+
+ ZERO_STRUCT(params);
+
+ if ((s = talloc_strdup(frame, username)) == NULL) {
+ return false;
+ }
+
+ if ((p = strchr(s, '%')) != NULL) {
+ *p = 0;
+ p++;
+ params.password = talloc_strdup(frame, p);
+ } else {
+ params.password = wbinfo_prompt_pass(frame, NULL, username);
+ }
+ params.username = s;
+
+ flags = WBFLAG_PAM_CACHED_LOGIN;
+
+ wbc_status = wbcAddNamedBlob(¶ms.num_blobs, ¶ms.blobs,
+ "flags", 0,
+ (uint8_t *)&flags, sizeof(flags));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_printf("wbcAddNamedBlob failed: %s\n",
+ wbcErrorString(wbc_status));
+ return false;
+ }
+
+ uid = getuid();
+
+ wbc_status = wbcAddNamedBlob(¶ms.num_blobs, ¶ms.blobs,
+ "user_uid", 0,
+ (uint8_t *)&uid, sizeof(uid));
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_printf("wbcAddNamedBlob failed: %s\n",
+ wbcErrorString(wbc_status));
+ return false;
+ }
+
+ wbc_status = wbcLogonUser(¶ms, NULL, &error, NULL);
+
+ wbcFreeMemory(params.blobs);
+
+ d_printf("plaintext password authentication %s\n",
+ WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
+
+ if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr,
+ "error code was %s (0x%x)\nerror message was: %s\n",
+ error->nt_string,
+ (int)error->nt_status,
+ error->display_string);
+ wbcFreeMemory(error);
+ return false;
+ }
+ return true;
+}
+
+/* Save creds with winbind */
+
+static bool wbinfo_ccache_save(char *username)
+{
+ wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+ char *s = NULL;
+ char *p = NULL;
+ char *password = NULL;
+ char *name = NULL;
+ TALLOC_CTX *frame = talloc_stackframe();
+
+ s = talloc_strdup(frame, username);
+ if (s == NULL) {
+ return false;
+ }
+
+ p = strchr(s, '%');
+ if (p != NULL) {
+ *p = 0;
+ p++;
+ password = talloc_strdup(frame, p);
+ } else {
+ password = wbinfo_prompt_pass(frame, NULL, username);
+ }
+
+ name = s;
+
+ wbc_status = wbcCredentialSave(name, password);
+
+ d_printf("saving creds %s\n",
+ WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
+
TALLOC_FREE(frame);
return WBC_ERROR_IS_OK(wbc_status);
}
+#ifdef WITH_FAKE_KASERVER
/* Authenticate a user with a plaintext password and set a token */
static bool wbinfo_klog(char *username)
if (response.data.auth.nt_status)
d_fprintf(stderr,
- "error code was %s (0x%x)\nerror messsage was: %s\n",
+ "error code was %s (0x%x)\nerror message was: %s\n",
response.data.auth.nt_status_string,
response.data.auth.nt_status,
response.data.auth.error_string);
d_printf("Successfully created AFS token\n");
return true;
}
+#else
+static bool wbinfo_klog(char *username)
+{
+ d_fprintf(stderr, "No AFS support compiled in.\n");
+ return false;
+}
+#endif
/* Print domain users */
wbc_status = wbcListGroups(domain, &num_groups, &groups);
if (!WBC_ERROR_IS_OK(wbc_status)) {
+ d_fprintf(stderr, "failed to call wbcListGroups: %s\n",
+ wbcErrorString(wbc_status));
return false;
}
d_printf("Password change for user %s %s\n", username,
WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
- TALLOC_FREE(frame);
-
return WBC_ERROR_IS_OK(wbc_status);
}
OPT_SEQUENCE,
OPT_GETDCNAME,
OPT_DSGETDCNAME,
+ OPT_DC_INFO,
OPT_USERDOMGROUPS,
OPT_SIDALIASES,
OPT_USERSIDS,
OPT_ALLOCATE_UID,
OPT_ALLOCATE_GID,
- OPT_SET_UID_MAPPING,
- OPT_SET_GID_MAPPING,
- OPT_REMOVE_UID_MAPPING,
- OPT_REMOVE_GID_MAPPING,
OPT_SEPARATOR,
OPT_LIST_ALL_DOMAINS,
OPT_LIST_OWN_DOMAIN,
OPT_VERBOSE,
OPT_ONLINESTATUS,
OPT_CHANGE_USER_PASSWORD,
+ OPT_CCACHE_SAVE,
OPT_SID_TO_FULLNAME,
OPT_NTLMV2,
+ OPT_PAM_LOGON,
+ OPT_LOGOFF,
+ OPT_LOGOFF_USER,
+ OPT_LOGOFF_UID,
OPT_LANMAN
};
TALLOC_CTX *frame = talloc_stackframe();
poptContext pc;
static char *string_arg;
- char *string_subarg = NULL;
static char *opt_domain_name;
static int int_arg;
- int int_subarg = -1;
int result = 1;
bool verbose = false;
bool use_ntlmv2 = false;
bool use_lanman = false;
+ char *logoff_user = getenv("USER");
+ int logoff_uid = geteuid();
struct poptOption long_options[] = {
POPT_AUTOHELP
"Get a new UID out of idmap" },
{ "allocate-gid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_GID,
"Get a new GID out of idmap" },
- { "set-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_SET_UID_MAPPING, "Create or modify uid to sid mapping in idmap", "UID,SID" },
- { "set-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_SET_GID_MAPPING, "Create or modify gid to sid mapping in idmap", "GID,SID" },
- { "remove-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_UID_MAPPING, "Remove uid to sid mapping in idmap", "UID,SID" },
- { "remove-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_GID_MAPPING, "Remove gid to sid mapping in idmap", "GID,SID" },
{ "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
+ { "change-secret", 'c', POPT_ARG_NONE, 0, 'c', "Change shared secret" },
+ { "ping-dc", 'P', POPT_ARG_NONE, 0, 'P',
+ "Check the NETLOGON connection" },
{ "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
{ "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
{ "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
- { "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Show sequence numbers of all domains" },
+ { "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Deprecated command, see --online-status" },
{ "online-status", 0, POPT_ARG_NONE, 0, OPT_ONLINESTATUS, "Show whether domains are marked as online or offline"},
{ "domain-info", 'D', POPT_ARG_STRING, &string_arg, 'D', "Show most of the info we have about the domain" },
{ "user-info", 'i', POPT_ARG_STRING, &string_arg, 'i', "Get user info", "USER" },
{ "sid-aliases", 0, POPT_ARG_STRING, &string_arg, OPT_SIDALIASES, "Get sid aliases", "SID" },
{ "user-sids", 0, POPT_ARG_STRING, &string_arg, OPT_USERSIDS, "Get user group sids for user SID", "SID" },
{ "authenticate", 'a', POPT_ARG_STRING, &string_arg, 'a', "authenticate user", "user%password" },
+ { "pam-logon", 0, POPT_ARG_STRING, &string_arg, OPT_PAM_LOGON,
+ "do a pam logon equivalent", "user%password" },
+ { "logoff", 0, POPT_ARG_NONE, NULL, OPT_LOGOFF,
+ "log off user", "uid" },
+ { "logoff-user", 0, POPT_ARG_STRING, &logoff_user,
+ OPT_LOGOFF_USER, "username to log off" },
+ { "logoff-uid", 0, POPT_ARG_INT, &logoff_uid,
+ OPT_LOGOFF_UID, "uid to log off" },
{ "set-auth-user", 0, POPT_ARG_STRING, &string_arg, OPT_SET_AUTH_USER, "Store user and password used by winbindd (root only)", "user%password" },
+ { "ccache-save", 0, POPT_ARG_STRING, &string_arg,
+ OPT_CCACHE_SAVE, "Store user and password for ccache "
+ "operation", "user%password" },
{ "getdcname", 0, POPT_ARG_STRING, &string_arg, OPT_GETDCNAME,
"Get a DC name for a foreign domain", "domainname" },
{ "dsgetdcname", 0, POPT_ARG_STRING, &string_arg, OPT_DSGETDCNAME, "Find a DC for a domain", "domainname" },
+ { "dc-info", 0, POPT_ARG_STRING, &string_arg, OPT_DC_INFO,
+ "Find the currently known DCs", "domainname" },
{ "get-auth-user", 0, POPT_ARG_NONE, NULL, OPT_GET_AUTH_USER, "Retrieve user and password used by winbindd (root only)", NULL },
{ "ping", 'p', POPT_ARG_NONE, 0, 'p', "Ping winbindd to see if it is alive" },
{ "domain", 0, POPT_ARG_STRING, &opt_domain_name, OPT_DOMAIN_NAME, "Define to the domain to restrict operation", "domain" },
goto done;
}
break;
- case OPT_SET_UID_MAPPING:
- if (!parse_mapping_arg(string_arg, &int_subarg,
- &string_subarg) ||
- !wbinfo_set_uid_mapping(int_subarg, string_subarg))
- {
- d_fprintf(stderr, "Could not create or modify "
- "uid to sid mapping\n");
- goto done;
- }
- break;
- case OPT_SET_GID_MAPPING:
- if (!parse_mapping_arg(string_arg, &int_subarg,
- &string_subarg) ||
- !wbinfo_set_gid_mapping(int_subarg, string_subarg))
- {
- d_fprintf(stderr, "Could not create or modify "
- "gid to sid mapping\n");
- goto done;
- }
- break;
- case OPT_REMOVE_UID_MAPPING:
- if (!parse_mapping_arg(string_arg, &int_subarg,
- &string_subarg) ||
- !wbinfo_remove_uid_mapping(int_subarg,
- string_subarg))
- {
- d_fprintf(stderr, "Could not remove uid to sid "
- "mapping\n");
+ case 't':
+ if (!wbinfo_check_secret(opt_domain_name)) {
+ d_fprintf(stderr, "Could not check secret\n");
goto done;
}
break;
- case OPT_REMOVE_GID_MAPPING:
- if (!parse_mapping_arg(string_arg, &int_subarg,
- &string_subarg) ||
- !wbinfo_remove_gid_mapping(int_subarg,
- string_subarg))
- {
- d_fprintf(stderr, "Could not remove gid to sid "
- "mapping\n");
+ case 'c':
+ if (!wbinfo_change_secret(opt_domain_name)) {
+ d_fprintf(stderr, "Could not change secret\n");
goto done;
}
break;
- case 't':
- if (!wbinfo_check_secret()) {
- d_fprintf(stderr, "Could not check secret\n");
+ case 'P':
+ if (!wbinfo_ping_dc()) {
+ d_fprintf(stderr, "Could not ping our DC\n");
goto done;
}
break;
goto done;
break;
}
+ case OPT_PAM_LOGON:
+ if (!wbinfo_pam_logon(string_arg)) {
+ d_fprintf(stderr, "pam_logon failed for %s\n",
+ string_arg);
+ goto done;
+ }
+ break;
+ case OPT_LOGOFF:
+ {
+ wbcErr wbc_status;
+
+ wbc_status = wbcLogoffUser(logoff_user, logoff_uid,
+ "");
+ d_printf("Logoff %s (%d): %s\n", logoff_user,
+ logoff_uid, wbcErrorString(wbc_status));
+ break;
+ }
case 'K': {
uint32_t flags = WBFLAG_PAM_KRB5 |
WBFLAG_PAM_CACHED_LOGIN |
wbinfo_get_auth_user();
goto done;
break;
+ case OPT_CCACHE_SAVE:
+ if (!wbinfo_ccache_save(string_arg)) {
+ goto done;
+ }
+ break;
case OPT_GETDCNAME:
if (!wbinfo_getdcname(string_arg)) {
goto done;
goto done;
}
break;
+ case OPT_DC_INFO:
+ if (!wbinfo_dc_info(string_arg)) {
+ goto done;
+ }
+ break;
case OPT_SEPARATOR: {
const char sep = winbind_separator();
if ( !sep ) {
/* generic configuration options */
case OPT_DOMAIN_NAME:
- break;
case OPT_VERBOSE:
- break;
case OPT_NTLMV2:
- break;
case OPT_LANMAN:
+ case OPT_LOGOFF_USER:
+ case OPT_LOGOFF_UID:
break;
default:
d_fprintf(stderr, "Invalid option\n");
git.samba.org / samba.git / blobdiff