Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

wbinfo.c

Visit:

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago
Samba Server: update vendor to version 4.4.3
File size: 64.8 KB

Rev	Line
[860]	1	/*
	2	Unix SMB/CIFS implementation.
	3
	4	Winbind status program.
	5
	6	Copyright (C) Tim Potter 2000-2003
	7	Copyright (C) Andrew Bartlett 2002-2007
	8	Copyright (C) Volker Lendecke 2009
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 3 of the License, or
	13	(at your option) any later version.
	14
	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with this program. If not, see <http://www.gnu.org/licenses/>.
	22	*/
	23
	24	#include "includes.h"
	25	#include "winbind_client.h"
	26	#include "libwbclient/wbclient.h"
	27	#include "../libcli/auth/libcli_auth.h"
	28	#include "lib/cmdline/popt_common.h"
[988]	29	#include "lib/afs/afs_settoken.h"
[860]	30
	31	#ifdef DBGC_CLASS
	32	#undef DBGC_CLASS
	33	#define DBGC_CLASS DBGC_WINBIND
	34	#endif
	35
	36	static struct wbcInterfaceDetails *init_interface_details(void)
	37	{
	38	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	39	static struct wbcInterfaceDetails *details;
	40
	41	if (details) {
	42	return details;
	43	}
	44
	45	wbc_status = wbcInterfaceDetails(&details);
	46	if (!WBC_ERROR_IS_OK(wbc_status)) {
	47	d_fprintf(stderr, "could not obtain winbind interface "
	48	"details: %s\n", wbcErrorString(wbc_status));
	49	}
	50
	51	return details;
	52	}
	53
	54	static char winbind_separator(void)
	55	{
	56	struct wbcInterfaceDetails *details;
	57	static bool got_sep;
	58	static char sep;
	59
	60	if (got_sep)
	61	return sep;
	62
	63	details = init_interface_details();
	64
	65	if (!details) {
	66	d_fprintf(stderr, "could not obtain winbind separator!\n");
	67	return 0;
	68	}
	69
	70	sep = details->winbind_separator;
	71	got_sep = true;
	72
	73	if (!sep) {
	74	d_fprintf(stderr, "winbind separator was NULL!\n");
	75	return 0;
	76	}
	77
	78	return sep;
	79	}
	80
	81	static const char *get_winbind_domain(void)
	82	{
	83	static struct wbcInterfaceDetails *details;
	84
	85	details = init_interface_details();
	86
	87	if (!details) {
	88	d_fprintf(stderr, "could not obtain winbind domain name!\n");
	89	return 0;
	90	}
	91
	92	return details->netbios_domain;
	93	}
	94
	95	static const char *get_winbind_netbios_name(void)
	96	{
	97	static struct wbcInterfaceDetails *details;
	98
	99	details = init_interface_details();
	100
	101	if (!details) {
	102	d_fprintf(stderr, "could not obtain winbind netbios name!\n");
	103	return 0;
	104	}
	105
	106	return details->netbios_name;
	107	}
	108
	109	/* Copy of parse_domain_user from winbindd_util.c. Parse a string of the
	110	form DOMAIN/user into a domain and a user */
	111
	112	static bool parse_wbinfo_domain_user(const char *domuser, fstring domain,
	113	fstring user)
	114	{
	115
	116	char *p = strchr(domuser,winbind_separator());
	117
	118	if (!p) {
	119	/* Maybe it was a UPN? */
[988]	120	p = strchr(domuser, '@');
	121	if (p != NULL) {
[860]	122	fstrcpy(domain, "");
	123	fstrcpy(user, domuser);
	124	return true;
	125	}
	126
	127	fstrcpy(user, domuser);
	128	fstrcpy(domain, get_winbind_domain());
	129	return true;
	130	}
	131
	132	fstrcpy(user, p+1);
	133	fstrcpy(domain, domuser);
	134	domain[PTR_DIFF(p, domuser)] = 0;
	135
	136	return true;
	137	}
	138
	139	/* Parse string of "uid,sid" or "gid,sid" into separate int and string values.
	140	* Return true if input was valid, false otherwise. */
	141	static bool parse_mapping_arg(char arg, int id, char **sid)
	142	{
	143	char tmp, endptr;
	144
	145	if (!arg \|\| !*arg)
	146	return false;
	147
	148	tmp = strtok(arg, ",");
	149	*sid = strtok(NULL, ",");
	150
	151	if (!tmp \|\| !tmp \|\| !sid \|\| !**sid)
	152	return false;
	153
	154	/* Because atoi() can return 0 on invalid input, which would be a valid
	155	* UID/GID we must use strtoul() and do error checking */
	156	*id = strtoul(tmp, &endptr, 10);
	157
	158	if (endptr[0] != '\0')
	159	return false;
	160
	161	return true;
	162	}
	163
	164	/* pull pwent info for a given user */
	165
	166	static bool wbinfo_get_userinfo(char *user)
	167	{
	168	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	169	struct passwd *pwd = NULL;
	170
	171	wbc_status = wbcGetpwnam(user, &pwd);
	172	if (!WBC_ERROR_IS_OK(wbc_status)) {
	173	d_fprintf(stderr, "failed to call wbcGetpwnam: %s\n",
	174	wbcErrorString(wbc_status));
	175	return false;
	176	}
	177
	178	d_printf("%s:%s:%u:%u:%s:%s:%s\n",
	179	pwd->pw_name,
	180	pwd->pw_passwd,
	181	(unsigned int)pwd->pw_uid,
	182	(unsigned int)pwd->pw_gid,
	183	pwd->pw_gecos,
	184	pwd->pw_dir,
	185	pwd->pw_shell);
	186
	187	wbcFreeMemory(pwd);
	188
	189	return true;
	190	}
	191
	192	/* pull pwent info for a given uid */
	193	static bool wbinfo_get_uidinfo(int uid)
	194	{
	195	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	196	struct passwd *pwd = NULL;
	197
	198	wbc_status = wbcGetpwuid(uid, &pwd);
	199	if (!WBC_ERROR_IS_OK(wbc_status)) {
	200	d_fprintf(stderr, "failed to call wbcGetpwuid: %s\n",
	201	wbcErrorString(wbc_status));
	202	return false;
	203	}
	204
	205	d_printf("%s:%s:%u:%u:%s:%s:%s\n",
	206	pwd->pw_name,
	207	pwd->pw_passwd,
	208	(unsigned int)pwd->pw_uid,
	209	(unsigned int)pwd->pw_gid,
	210	pwd->pw_gecos,
	211	pwd->pw_dir,
	212	pwd->pw_shell);
	213
	214	wbcFreeMemory(pwd);
	215
	216	return true;
	217	}
	218
	219	static bool wbinfo_get_user_sidinfo(const char *sid_str)
	220	{
	221	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	222	struct passwd *pwd = NULL;
	223	struct wbcDomainSid sid;
	224
	225	wbc_status = wbcStringToSid(sid_str, &sid);
	226	wbc_status = wbcGetpwsid(&sid, &pwd);
	227	if (!WBC_ERROR_IS_OK(wbc_status)) {
	228	d_fprintf(stderr, "failed to call wbcGetpwsid: %s\n",
	229	wbcErrorString(wbc_status));
	230	return false;
	231	}
	232
	233	d_printf("%s:%s:%u:%u:%s:%s:%s\n",
	234	pwd->pw_name,
	235	pwd->pw_passwd,
	236	(unsigned int)pwd->pw_uid,
	237	(unsigned int)pwd->pw_gid,
	238	pwd->pw_gecos,
	239	pwd->pw_dir,
	240	pwd->pw_shell);
	241
[988]	242	wbcFreeMemory(pwd);
	243
[860]	244	return true;
	245	}
	246
	247
	248	/* pull grent for a given group */
	249	static bool wbinfo_get_groupinfo(const char *group)
	250	{
	251	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	252	struct group *grp;
	253	char **mem;
	254
	255	wbc_status = wbcGetgrnam(group, &grp);
	256	if (!WBC_ERROR_IS_OK(wbc_status)) {
	257	d_fprintf(stderr, "failed to call wbcGetgrnam: %s\n",
	258	wbcErrorString(wbc_status));
	259	return false;
	260	}
	261
	262	d_printf("%s:%s:%u:",
	263	grp->gr_name,
	264	grp->gr_passwd,
	265	(unsigned int)grp->gr_gid);
	266
	267	mem = grp->gr_mem;
	268	while (*mem != NULL) {
	269	d_printf("%s%s", mem, (mem+1) != NULL ? "," : "");
	270	mem += 1;
	271	}
	272	d_printf("\n");
	273
	274	wbcFreeMemory(grp);
	275
	276	return true;
	277	}
	278
	279	/* pull grent for a given gid */
	280	static bool wbinfo_get_gidinfo(int gid)
	281	{
	282	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	283	struct group *grp;
	284	char **mem;
	285
	286	wbc_status = wbcGetgrgid(gid, &grp);
	287	if (!WBC_ERROR_IS_OK(wbc_status)) {
	288	d_fprintf(stderr, "failed to call wbcGetgrgid: %s\n",
	289	wbcErrorString(wbc_status));
	290	return false;
	291	}
	292
	293	d_printf("%s:%s:%u:",
	294	grp->gr_name,
	295	grp->gr_passwd,
	296	(unsigned int)grp->gr_gid);
	297
	298	mem = grp->gr_mem;
	299	while (*mem != NULL) {
	300	d_printf("%s%s", mem, (mem+1) != NULL ? "," : "");
	301	mem += 1;
	302	}
	303	d_printf("\n");
	304
	305	wbcFreeMemory(grp);
	306
	307	return true;
	308	}
	309
	310	/* List groups a user is a member of */
	311
	312	static bool wbinfo_get_usergroups(const char *user)
	313	{
	314	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	315	uint32_t num_groups;
	316	uint32_t i;
	317	gid_t *groups = NULL;
	318
	319	/* Send request */
	320
	321	wbc_status = wbcGetGroups(user, &num_groups, &groups);
	322	if (!WBC_ERROR_IS_OK(wbc_status)) {
	323	d_fprintf(stderr, "failed to call wbcGetGroups: %s\n",
	324	wbcErrorString(wbc_status));
	325	return false;
	326	}
	327
	328	for (i = 0; i < num_groups; i++) {
	329	d_printf("%d\n", (int)groups[i]);
	330	}
	331
	332	wbcFreeMemory(groups);
	333
	334	return true;
	335	}
	336
	337
	338	/* List group SIDs a user SID is a member of */
	339	static bool wbinfo_get_usersids(const char *user_sid_str)
	340	{
	341	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	342	uint32_t num_sids;
	343	uint32_t i;
	344	struct wbcDomainSid user_sid, *sids = NULL;
	345
	346	/* Send request */
	347
	348	wbc_status = wbcStringToSid(user_sid_str, &user_sid);
	349	if (!WBC_ERROR_IS_OK(wbc_status)) {
	350	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	351	wbcErrorString(wbc_status));
	352	return false;
	353	}
	354
	355	wbc_status = wbcLookupUserSids(&user_sid, false, &num_sids, &sids);
	356	if (!WBC_ERROR_IS_OK(wbc_status)) {
	357	d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
	358	wbcErrorString(wbc_status));
	359	return false;
	360	}
	361
	362	for (i = 0; i < num_sids; i++) {
	363	char str[WBC_SID_STRING_BUFLEN];
	364	wbcSidToStringBuf(&sids[i], str, sizeof(str));
	365	d_printf("%s\n", str);
	366	}
	367
	368	wbcFreeMemory(sids);
	369
	370	return true;
	371	}
	372
	373	static bool wbinfo_get_userdomgroups(const char *user_sid_str)
	374	{
	375	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	376	uint32_t num_sids;
	377	uint32_t i;
	378	struct wbcDomainSid user_sid, *sids = NULL;
	379
	380	/* Send request */
	381
	382	wbc_status = wbcStringToSid(user_sid_str, &user_sid);
	383	if (!WBC_ERROR_IS_OK(wbc_status)) {
	384	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	385	wbcErrorString(wbc_status));
	386	return false;
	387	}
	388
	389	wbc_status = wbcLookupUserSids(&user_sid, true, &num_sids, &sids);
	390	if (!WBC_ERROR_IS_OK(wbc_status)) {
	391	d_fprintf(stderr, "failed to call wbcLookupUserSids: %s\n",
	392	wbcErrorString(wbc_status));
	393	return false;
	394	}
	395
	396	for (i = 0; i < num_sids; i++) {
	397	char str[WBC_SID_STRING_BUFLEN];
	398	wbcSidToStringBuf(&sids[i], str, sizeof(str));
	399	d_printf("%s\n", str);
	400	}
	401
	402	wbcFreeMemory(sids);
	403
	404	return true;
	405	}
	406
	407	static bool wbinfo_get_sidaliases(const char *domain,
	408	const char *user_sid_str)
	409	{
	410	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	411	struct wbcDomainInfo *dinfo = NULL;
	412	uint32_t i;
	413	struct wbcDomainSid user_sid;
	414	uint32_t *alias_rids = NULL;
	415	uint32_t num_alias_rids;
	416	char domain_sid_str[WBC_SID_STRING_BUFLEN];
	417
	418	/* Send request */
	419	if ((domain == NULL) \|\| (strequal(domain, ".")) \|\|
	420	(domain[0] == '\0')) {
	421	domain = get_winbind_domain();
	422	}
	423
	424	/* Send request */
	425
	426	wbc_status = wbcDomainInfo(domain, &dinfo);
	427	if (!WBC_ERROR_IS_OK(wbc_status)) {
	428	d_fprintf(stderr, "wbcDomainInfo(%s) failed: %s\n", domain,
	429	wbcErrorString(wbc_status));
	430	goto done;
	431	}
	432	wbc_status = wbcStringToSid(user_sid_str, &user_sid);
	433	if (!WBC_ERROR_IS_OK(wbc_status)) {
	434	goto done;
	435	}
	436
	437	wbc_status = wbcGetSidAliases(&dinfo->sid, &user_sid, 1,
	438	&alias_rids, &num_alias_rids);
	439	if (!WBC_ERROR_IS_OK(wbc_status)) {
	440	goto done;
	441	}
	442
	443	wbcSidToStringBuf(&dinfo->sid, domain_sid_str, sizeof(domain_sid_str));
	444
	445	for (i = 0; i < num_alias_rids; i++) {
	446	d_printf("%s-%d\n", domain_sid_str, alias_rids[i]);
	447	}
	448
	449	wbcFreeMemory(alias_rids);
	450
	451	done:
	452	wbcFreeMemory(dinfo);
	453	return (WBC_ERR_SUCCESS == wbc_status);
	454	}
	455
	456
	457	/* Convert NetBIOS name to IP */
	458
	459	static bool wbinfo_wins_byname(const char *name)
	460	{
	461	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	462	char *ip = NULL;
	463
	464	wbc_status = wbcResolveWinsByName(name, &ip);
	465	if (!WBC_ERROR_IS_OK(wbc_status)) {
	466	d_fprintf(stderr, "failed to call wbcResolveWinsByName: %s\n",
	467	wbcErrorString(wbc_status));
	468	return false;
	469	}
	470
	471	/* Display response */
	472
	473	d_printf("%s\n", ip);
	474
	475	wbcFreeMemory(ip);
	476
	477	return true;
	478	}
	479
	480	/* Convert IP to NetBIOS name */
	481
	482	static bool wbinfo_wins_byip(const char *ip)
	483	{
	484	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	485	char *name = NULL;
	486
	487	wbc_status = wbcResolveWinsByIP(ip, &name);
	488	if (!WBC_ERROR_IS_OK(wbc_status)) {
	489	d_fprintf(stderr, "failed to call wbcResolveWinsByIP: %s\n",
	490	wbcErrorString(wbc_status));
	491	return false;
	492	}
	493
	494	/* Display response */
	495
	496	d_printf("%s\n", name);
	497
	498	wbcFreeMemory(name);
	499
	500	return true;
	501	}
	502
	503	/* List all/trusted domains */
	504
	505	static bool wbinfo_list_domains(bool list_all_domains, bool verbose)
	506	{
	507	struct wbcDomainInfo *domain_list = NULL;
	508	size_t num_domains;
	509	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	510	bool print_all = !list_all_domains && verbose;
	511	int i;
	512
	513	wbc_status = wbcListTrusts(&domain_list, &num_domains);
	514	if (!WBC_ERROR_IS_OK(wbc_status)) {
	515	d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
	516	wbcErrorString(wbc_status));
	517	return false;
	518	}
	519
	520	if (print_all) {
[988]	521	d_printf("%-16s%-65s%-12s%-12s%-5s%-5s\n",
[860]	522	"Domain Name", "DNS Domain", "Trust Type",
	523	"Transitive", "In", "Out");
	524	}
	525
	526	for (i=0; i<num_domains; i++) {
	527	if (print_all) {
	528	d_printf("%-16s", domain_list[i].short_name);
	529	} else {
	530	d_printf("%s", domain_list[i].short_name);
	531	d_printf("\n");
	532	continue;
	533	}
	534
[988]	535	d_printf("%-65s", domain_list[i].dns_name);
[860]	536
	537	switch(domain_list[i].trust_type) {
	538	case WBC_DOMINFO_TRUSTTYPE_NONE:
	539	d_printf("None ");
	540	break;
	541	case WBC_DOMINFO_TRUSTTYPE_FOREST:
	542	d_printf("Forest ");
	543	break;
	544	case WBC_DOMINFO_TRUSTTYPE_EXTERNAL:
	545	d_printf("External ");
	546	break;
	547	case WBC_DOMINFO_TRUSTTYPE_IN_FOREST:
	548	d_printf("In-Forest ");
	549	break;
	550	}
	551
	552	if (domain_list[i].trust_flags & WBC_DOMINFO_TRUST_TRANSITIVE) {
	553	d_printf("Yes ");
	554	} else {
	555	d_printf("No ");
	556	}
	557
	558	if (domain_list[i].trust_flags & WBC_DOMINFO_TRUST_INCOMING) {
	559	d_printf("Yes ");
	560	} else {
	561	d_printf("No ");
	562	}
	563
	564	if (domain_list[i].trust_flags & WBC_DOMINFO_TRUST_OUTGOING) {
	565	d_printf("Yes ");
	566	} else {
	567	d_printf("No ");
	568	}
	569
	570	d_printf("\n");
	571	}
	572
	573	wbcFreeMemory(domain_list);
	574
	575	return true;
	576	}
	577
	578	/* List own domain */
	579
	580	static bool wbinfo_list_own_domain(void)
	581	{
	582	d_printf("%s\n", get_winbind_domain());
	583
	584	return true;
	585	}
	586
	587	/* show sequence numbers */
	588	static bool wbinfo_show_sequence(const char *domain)
	589	{
	590	d_printf("This command has been deprecated. Please use the "
	591	"--online-status option instead.\n");
	592	return false;
	593	}
	594
	595	/* show sequence numbers */
	596	static bool wbinfo_show_onlinestatus(const char *domain)
	597	{
	598	struct wbcDomainInfo *domain_list = NULL;
	599	size_t num_domains;
	600	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	601	int i;
	602
	603	wbc_status = wbcListTrusts(&domain_list, &num_domains);
	604	if (!WBC_ERROR_IS_OK(wbc_status)) {
	605	d_fprintf(stderr, "failed to call wbcListTrusts: %s\n",
	606	wbcErrorString(wbc_status));
	607	return false;
	608	}
	609
	610	for (i=0; i<num_domains; i++) {
	611	bool is_offline;
	612
	613	if (domain) {
	614	if (!strequal(domain_list[i].short_name, domain)) {
	615	continue;
	616	}
	617	}
	618
	619	is_offline = (domain_list[i].domain_flags &
	620	WBC_DOMINFO_DOMAIN_OFFLINE);
	621
	622	d_printf("%s : %s\n",
	623	domain_list[i].short_name,
	624	is_offline ? "offline" : "online" );
	625	}
	626
	627	wbcFreeMemory(domain_list);
	628
	629	return true;
	630	}
	631
	632
	633	/* Show domain info */
	634
	635	static bool wbinfo_domain_info(const char *domain)
	636	{
	637	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	638	struct wbcDomainInfo *dinfo = NULL;
	639	char sid_str[WBC_SID_STRING_BUFLEN];
	640
	641	if ((domain == NULL) \|\| (strequal(domain, ".")) \|\| (domain[0] == '\0')){
	642	domain = get_winbind_domain();
	643	}
	644
	645	/* Send request */
	646
	647	wbc_status = wbcDomainInfo(domain, &dinfo);
	648	if (!WBC_ERROR_IS_OK(wbc_status)) {
	649	d_fprintf(stderr, "failed to call wbcDomainInfo: %s\n",
	650	wbcErrorString(wbc_status));
	651	return false;
	652	}
	653
	654	wbcSidToStringBuf(&dinfo->sid, sid_str, sizeof(sid_str));
	655
	656	/* Display response */
	657
	658	d_printf("Name : %s\n", dinfo->short_name);
	659	d_printf("Alt_Name : %s\n", dinfo->dns_name);
	660
	661	d_printf("SID : %s\n", sid_str);
	662
	663	d_printf("Active Directory : %s\n",
	664	(dinfo->domain_flags & WBC_DOMINFO_DOMAIN_AD) ? "Yes" : "No");
	665	d_printf("Native : %s\n",
	666	(dinfo->domain_flags & WBC_DOMINFO_DOMAIN_NATIVE) ?
	667	"Yes" : "No");
	668
	669	d_printf("Primary : %s\n",
	670	(dinfo->domain_flags & WBC_DOMINFO_DOMAIN_PRIMARY) ?
	671	"Yes" : "No");
	672
	673	wbcFreeMemory(dinfo);
	674
	675	return true;
	676	}
	677
	678	/* Get a foreign DC's name */
	679	static bool wbinfo_getdcname(const char *domain_name)
	680	{
	681	struct winbindd_request request;
	682	struct winbindd_response response;
	683
	684	ZERO_STRUCT(request);
	685	ZERO_STRUCT(response);
	686
	687	fstrcpy(request.domain_name, domain_name);
	688
	689	/* Send request */
	690
[988]	691	if (winbindd_request_response(NULL, WINBINDD_GETDCNAME, &request,
[860]	692	&response) != NSS_STATUS_SUCCESS) {
	693	d_fprintf(stderr, "Could not get dc name for %s\n",domain_name);
	694	return false;
	695	}
	696
	697	/* Display response */
	698
	699	d_printf("%s\n", response.data.dc_name);
	700
	701	return true;
	702	}
	703
	704	/* Find a DC */
	705	static bool wbinfo_dsgetdcname(const char *domain_name, uint32_t flags)
	706	{
	707	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	708	struct wbcDomainControllerInfoEx *dc_info;
	709	char *str = NULL;
	710
	711	wbc_status = wbcLookupDomainControllerEx(domain_name, NULL, NULL,
	712	flags \| DS_DIRECTORY_SERVICE_REQUIRED,
	713	&dc_info);
	714	if (!WBC_ERROR_IS_OK(wbc_status)) {
	715	printf("Could not find dc for %s\n", domain_name);
	716	return false;
	717	}
	718
	719	wbcGuidToString(dc_info->domain_guid, &str);
	720
	721	d_printf("%s\n", dc_info->dc_unc);
	722	d_printf("%s\n", dc_info->dc_address);
	723	d_printf("%d\n", dc_info->dc_address_type);
	724	d_printf("%s\n", str);
	725	d_printf("%s\n", dc_info->domain_name);
	726	d_printf("%s\n", dc_info->forest_name);
	727	d_printf("0x%08x\n", dc_info->dc_flags);
	728	d_printf("%s\n", dc_info->dc_site_name);
	729	d_printf("%s\n", dc_info->client_site_name);
	730
	731	return true;
	732	}
	733
	734	/* Check trust account password */
	735
	736	static bool wbinfo_check_secret(const char *domain)
	737	{
	738	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	739	struct wbcAuthErrorInfo *error = NULL;
	740	const char *domain_name;
	741
	742	if (domain) {
	743	domain_name = domain;
	744	} else {
	745	domain_name = get_winbind_domain();
	746	}
	747
	748	wbc_status = wbcCheckTrustCredentials(domain_name, &error);
	749
	750	d_printf("checking the trust secret for domain %s via RPC calls %s\n",
	751	domain_name,
	752	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	753
	754	if (wbc_status == WBC_ERR_AUTH_ERROR) {
[988]	755	d_fprintf(stderr, "wbcCheckTrustCredentials(%s): error code was %s (0x%x)\n",
	756	domain_name, error->nt_string, error->nt_status);
[860]	757	wbcFreeMemory(error);
	758	}
	759	if (!WBC_ERROR_IS_OK(wbc_status)) {
	760	d_fprintf(stderr, "failed to call wbcCheckTrustCredentials: "
	761	"%s\n", wbcErrorString(wbc_status));
	762	return false;
	763	}
	764
	765	return true;
	766	}
	767
	768	/* Find the currently connected DCs */
	769
	770	static bool wbinfo_dc_info(const char *domain_name)
	771	{
	772	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	773	size_t i, num_dcs;
	774	const char dc_names, dc_ips;
	775
	776	wbc_status = wbcDcInfo(domain_name, &num_dcs,
	777	&dc_names, &dc_ips);
	778	if (!WBC_ERROR_IS_OK(wbc_status)) {
	779	printf("Could not find dc info %s\n",
	780	domain_name ? domain_name : "our domain");
	781	return false;
	782	}
	783
	784	for (i=0; i<num_dcs; i++) {
	785	printf("%s (%s)\n", dc_names[i], dc_ips[i]);
	786	}
	787	wbcFreeMemory(dc_names);
	788	wbcFreeMemory(dc_ips);
	789
	790	return true;
	791	}
	792
	793	/* Change trust account password */
	794
	795	static bool wbinfo_change_secret(const char *domain)
	796	{
	797	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	798	struct wbcAuthErrorInfo *error = NULL;
	799	const char *domain_name;
	800
	801	if (domain) {
	802	domain_name = domain;
	803	} else {
	804	domain_name = get_winbind_domain();
	805	}
	806
	807	wbc_status = wbcChangeTrustCredentials(domain_name, &error);
	808
	809	d_printf("changing the trust secret for domain %s via RPC calls %s\n",
	810	domain_name,
	811	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	812
	813	if (wbc_status == WBC_ERR_AUTH_ERROR) {
[988]	814	d_fprintf(stderr, "wbcChangeTrustCredentials(%s): error code was %s (0x%x)\n",
	815	domain_name, error->nt_string, error->nt_status);
[860]	816	wbcFreeMemory(error);
	817	}
	818	if (!WBC_ERROR_IS_OK(wbc_status)) {
	819	d_fprintf(stderr, "failed to call wbcChangeTrustCredentials: "
	820	"%s\n", wbcErrorString(wbc_status));
	821	return false;
	822	}
	823
	824	return true;
	825	}
	826
	827	/* Check DC connection */
	828
[988]	829	static bool wbinfo_ping_dc(const char *domain)
[860]	830	{
	831	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	832	struct wbcAuthErrorInfo *error = NULL;
[988]	833	char *dcname = NULL;
[860]	834
[988]	835	const char *domain_name;
[860]	836
[988]	837	if (domain) {
	838	domain_name = domain;
	839	} else {
	840	domain_name = get_winbind_domain();
	841	}
	842
	843	wbc_status = wbcPingDc2(domain_name, &error, &dcname);
	844
	845	d_printf("checking the NETLOGON for domain[%s] dc connection to \"%s\" %s\n",
	846	domain_name ? domain_name : "",
	847	dcname ? dcname : "",
[860]	848	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	849
[988]	850	wbcFreeMemory(dcname);
[860]	851	if (wbc_status == WBC_ERR_AUTH_ERROR) {
[988]	852	d_fprintf(stderr, "wbcPingDc2(%s): error code was %s (0x%x)\n",
	853	domain_name, error->nt_string, error->nt_status);
[860]	854	wbcFreeMemory(error);
[988]	855	return false;
[860]	856	}
	857	if (!WBC_ERROR_IS_OK(wbc_status)) {
	858	d_fprintf(stderr, "failed to call wbcPingDc: %s\n",
	859	wbcErrorString(wbc_status));
	860	return false;
	861	}
	862
	863	return true;
	864	}
	865
	866	/* Convert uid to sid */
	867
	868	static bool wbinfo_uid_to_sid(uid_t uid)
	869	{
	870	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	871	struct wbcDomainSid sid;
	872	char sid_str[WBC_SID_STRING_BUFLEN];
	873
	874	/* Send request */
	875
	876	wbc_status = wbcUidToSid(uid, &sid);
	877	if (!WBC_ERROR_IS_OK(wbc_status)) {
	878	d_fprintf(stderr, "failed to call wbcUidToSid: %s\n",
	879	wbcErrorString(wbc_status));
	880	return false;
	881	}
	882
	883	wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
	884
	885	/* Display response */
	886
	887	d_printf("%s\n", sid_str);
	888
	889	return true;
	890	}
	891
	892	/* Convert gid to sid */
	893
	894	static bool wbinfo_gid_to_sid(gid_t gid)
	895	{
	896	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	897	struct wbcDomainSid sid;
	898	char sid_str[WBC_SID_STRING_BUFLEN];
	899
	900	/* Send request */
	901
	902	wbc_status = wbcGidToSid(gid, &sid);
	903	if (!WBC_ERROR_IS_OK(wbc_status)) {
	904	d_fprintf(stderr, "failed to call wbcGidToSid: %s\n",
	905	wbcErrorString(wbc_status));
	906	return false;
	907	}
	908
	909	wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
	910
	911	/* Display response */
	912
	913	d_printf("%s\n", sid_str);
	914
	915	return true;
	916	}
	917
	918	/* Convert sid to uid */
	919
	920	static bool wbinfo_sid_to_uid(const char *sid_str)
	921	{
	922	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	923	struct wbcDomainSid sid;
	924	uid_t uid;
	925
	926	/* Send request */
	927
	928	wbc_status = wbcStringToSid(sid_str, &sid);
	929	if (!WBC_ERROR_IS_OK(wbc_status)) {
	930	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	931	wbcErrorString(wbc_status));
	932	return false;
	933	}
	934
	935	wbc_status = wbcSidToUid(&sid, &uid);
	936	if (!WBC_ERROR_IS_OK(wbc_status)) {
	937	d_fprintf(stderr, "failed to call wbcSidToUid: %s\n",
	938	wbcErrorString(wbc_status));
	939	return false;
	940	}
	941
	942	/* Display response */
	943
	944	d_printf("%d\n", (int)uid);
	945
	946	return true;
	947	}
	948
	949	static bool wbinfo_sid_to_gid(const char *sid_str)
	950	{
	951	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	952	struct wbcDomainSid sid;
	953	gid_t gid;
	954
	955	/* Send request */
	956
	957	wbc_status = wbcStringToSid(sid_str, &sid);
	958	if (!WBC_ERROR_IS_OK(wbc_status)) {
	959	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	960	wbcErrorString(wbc_status));
	961	return false;
	962	}
	963
	964	wbc_status = wbcSidToGid(&sid, &gid);
	965	if (!WBC_ERROR_IS_OK(wbc_status)) {
	966	d_fprintf(stderr, "failed to call wbcSidToGid: %s\n",
	967	wbcErrorString(wbc_status));
	968	return false;
	969	}
	970
	971	/* Display response */
	972
	973	d_printf("%d\n", (int)gid);
	974
	975	return true;
	976	}
	977
	978	static bool wbinfo_sids_to_unix_ids(const char *arg)
	979	{
	980	char sidstr[WBC_SID_STRING_BUFLEN];
	981	struct wbcDomainSid *sids;
	982	struct wbcUnixId *unix_ids;
	983	int i, num_sids;
	984	const char *p;
	985	wbcErr wbc_status;
	986
	987
	988	num_sids = 0;
	989	sids = NULL;
	990	p = arg;
	991
	992	while (next_token(&p, sidstr, LIST_SEP, sizeof(sidstr))) {
	993	sids = talloc_realloc(talloc_tos(), sids, struct wbcDomainSid,
	994	num_sids+1);
	995	if (sids == NULL) {
	996	d_fprintf(stderr, "talloc failed\n");
	997	return false;
	998	}
	999	wbc_status = wbcStringToSid(sidstr, &sids[num_sids]);
	1000	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1001	d_fprintf(stderr, "wbcSidToString(%s) failed: %s\n",
	1002	sidstr, wbcErrorString(wbc_status));
	1003	TALLOC_FREE(sids);
	1004	return false;
	1005	}
	1006	num_sids += 1;
	1007	}
	1008
	1009	unix_ids = talloc_array(talloc_tos(), struct wbcUnixId, num_sids);
	1010	if (unix_ids == NULL) {
	1011	TALLOC_FREE(sids);
	1012	return false;
	1013	}
	1014
	1015	wbc_status = wbcSidsToUnixIds(sids, num_sids, unix_ids);
	1016	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1017	d_fprintf(stderr, "wbcSidsToUnixIds failed: %s\n",
	1018	wbcErrorString(wbc_status));
	1019	TALLOC_FREE(sids);
	1020	return false;
	1021	}
	1022
	1023	for (i=0; i<num_sids; i++) {
	1024
	1025	wbcSidToStringBuf(&sids[i], sidstr, sizeof(sidstr));
	1026
	1027	switch(unix_ids[i].type) {
	1028	case WBC_ID_TYPE_UID:
	1029	d_printf("%s -> uid %d\n", sidstr, unix_ids[i].id.uid);
	1030	break;
	1031	case WBC_ID_TYPE_GID:
	1032	d_printf("%s -> gid %d\n", sidstr, unix_ids[i].id.gid);
	1033	break;
[988]	1034	case WBC_ID_TYPE_BOTH:
	1035	d_printf("%s -> uid/gid %d\n", sidstr, unix_ids[i].id.uid);
	1036	break;
[860]	1037	default:
	1038	d_printf("%s -> unmapped\n", sidstr);
	1039	break;
	1040	}
	1041	}
	1042
	1043	TALLOC_FREE(sids);
	1044	TALLOC_FREE(unix_ids);
	1045
	1046	return true;
	1047	}
	1048
	1049	static bool wbinfo_allocate_uid(void)
	1050	{
	1051	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1052	uid_t uid;
	1053
	1054	/* Send request */
	1055
	1056	wbc_status = wbcAllocateUid(&uid);
	1057	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1058	d_fprintf(stderr, "failed to call wbcAllocateUid: %s\n",
	1059	wbcErrorString(wbc_status));
	1060	return false;
	1061	}
	1062
	1063	/* Display response */
	1064
	1065	d_printf("New uid: %u\n", (unsigned int)uid);
	1066
	1067	return true;
	1068	}
	1069
	1070	static bool wbinfo_allocate_gid(void)
	1071	{
	1072	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1073	gid_t gid;
	1074
	1075	/* Send request */
	1076
	1077	wbc_status = wbcAllocateGid(&gid);
	1078	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1079	d_fprintf(stderr, "failed to call wbcAllocateGid: %s\n",
	1080	wbcErrorString(wbc_status));
	1081	return false;
	1082	}
	1083
	1084	/* Display response */
	1085
	1086	d_printf("New gid: %u\n", (unsigned int)gid);
	1087
	1088	return true;
	1089	}
	1090
	1091	static bool wbinfo_set_uid_mapping(uid_t uid, const char *sid_str)
	1092	{
	1093	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1094	struct wbcDomainSid sid;
	1095
	1096	/* Send request */
	1097
	1098	wbc_status = wbcStringToSid(sid_str, &sid);
	1099	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1100	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	1101	wbcErrorString(wbc_status));
	1102	return false;
	1103	}
	1104
	1105	wbc_status = wbcSetUidMapping(uid, &sid);
	1106	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1107	d_fprintf(stderr, "failed to call wbcSetUidMapping: %s\n",
	1108	wbcErrorString(wbc_status));
	1109	return false;
	1110	}
	1111
	1112	/* Display response */
	1113
	1114	d_printf("uid %u now mapped to sid %s\n",
	1115	(unsigned int)uid, sid_str);
	1116
	1117	return true;
	1118	}
	1119
	1120	static bool wbinfo_set_gid_mapping(gid_t gid, const char *sid_str)
	1121	{
	1122	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1123	struct wbcDomainSid sid;
	1124
	1125	/* Send request */
	1126
	1127	wbc_status = wbcStringToSid(sid_str, &sid);
	1128	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1129	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	1130	wbcErrorString(wbc_status));
	1131	return false;
	1132	}
	1133
	1134	wbc_status = wbcSetGidMapping(gid, &sid);
	1135	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1136	d_fprintf(stderr, "failed to call wbcSetGidMapping: %s\n",
	1137	wbcErrorString(wbc_status));
	1138	return false;
	1139	}
	1140
	1141	/* Display response */
	1142
	1143	d_printf("gid %u now mapped to sid %s\n",
	1144	(unsigned int)gid, sid_str);
	1145
	1146	return true;
	1147	}
	1148
	1149	static bool wbinfo_remove_uid_mapping(uid_t uid, const char *sid_str)
	1150	{
	1151	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1152	struct wbcDomainSid sid;
	1153
	1154	/* Send request */
	1155
	1156	wbc_status = wbcStringToSid(sid_str, &sid);
	1157	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1158	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	1159	wbcErrorString(wbc_status));
	1160	return false;
	1161	}
	1162
	1163	wbc_status = wbcRemoveUidMapping(uid, &sid);
	1164	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1165	d_fprintf(stderr, "failed to call wbcRemoveUidMapping: %s\n",
	1166	wbcErrorString(wbc_status));
	1167	return false;
	1168	}
	1169
	1170	/* Display response */
	1171
	1172	d_printf("Removed uid %u to sid %s mapping\n",
	1173	(unsigned int)uid, sid_str);
	1174
	1175	return true;
	1176	}
	1177
	1178	static bool wbinfo_remove_gid_mapping(gid_t gid, const char *sid_str)
	1179	{
	1180	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1181	struct wbcDomainSid sid;
	1182
	1183	/* Send request */
	1184
	1185	wbc_status = wbcStringToSid(sid_str, &sid);
	1186	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1187	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	1188	wbcErrorString(wbc_status));
	1189	return false;
	1190	}
	1191
	1192	wbc_status = wbcRemoveGidMapping(gid, &sid);
	1193	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1194	d_fprintf(stderr, "failed to call wbcRemoveGidMapping: %s\n",
	1195	wbcErrorString(wbc_status));
	1196	return false;
	1197	}
	1198
	1199	/* Display response */
	1200
	1201	d_printf("Removed gid %u to sid %s mapping\n",
	1202	(unsigned int)gid, sid_str);
	1203
	1204	return true;
	1205	}
	1206
	1207	/* Convert sid to string */
	1208
	1209	static bool wbinfo_lookupsid(const char *sid_str)
	1210	{
	1211	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1212	struct wbcDomainSid sid;
	1213	char *domain;
	1214	char *name;
	1215	enum wbcSidType type;
	1216
	1217	/* Send off request */
	1218
	1219	wbc_status = wbcStringToSid(sid_str, &sid);
	1220	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1221	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	1222	wbcErrorString(wbc_status));
	1223	return false;
	1224	}
	1225
	1226	wbc_status = wbcLookupSid(&sid, &domain, &name, &type);
	1227	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1228	d_fprintf(stderr, "failed to call wbcLookupSid: %s\n",
	1229	wbcErrorString(wbc_status));
	1230	return false;
	1231	}
	1232
	1233	/* Display response */
	1234
[988]	1235	if (type == WBC_SID_NAME_DOMAIN) {
	1236	d_printf("%s %d\n", domain, type);
	1237	} else {
	1238	d_printf("%s%c%s %d\n",
	1239	domain, winbind_separator(), name, type);
	1240	}
[860]	1241
[988]	1242	wbcFreeMemory(domain);
	1243	wbcFreeMemory(name);
	1244
[860]	1245	return true;
	1246	}
	1247
	1248	/* Convert sid to fullname */
	1249
	1250	static bool wbinfo_lookupsid_fullname(const char *sid_str)
	1251	{
	1252	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1253	struct wbcDomainSid sid;
	1254	char *domain;
	1255	char *name;
	1256	enum wbcSidType type;
	1257
	1258	/* Send off request */
	1259
	1260	wbc_status = wbcStringToSid(sid_str, &sid);
	1261	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1262	d_fprintf(stderr, "failed to call wbcStringToSid: %s\n",
	1263	wbcErrorString(wbc_status));
	1264	return false;
	1265	}
	1266
	1267	wbc_status = wbcGetDisplayName(&sid, &domain, &name, &type);
	1268	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1269	d_fprintf(stderr, "failed to call wbcGetDisplayName: %s\n",
	1270	wbcErrorString(wbc_status));
	1271	return false;
	1272	}
	1273
	1274	/* Display response */
	1275
	1276	d_printf("%s%c%s %d\n",
	1277	domain, winbind_separator(), name, type);
	1278
[988]	1279	wbcFreeMemory(domain);
	1280	wbcFreeMemory(name);
	1281
[860]	1282	return true;
	1283	}
	1284
	1285	/* Lookup a list of RIDs */
	1286
	1287	static bool wbinfo_lookuprids(const char domain, const char arg)
	1288	{
	1289	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1290	struct wbcDomainInfo *dinfo = NULL;
	1291	char *domain_name = NULL;
	1292	const char **names = NULL;
	1293	enum wbcSidType *types = NULL;
	1294	size_t i;
	1295	int num_rids;
	1296	uint32_t *rids = NULL;
	1297	const char *p;
	1298	char *ridstr;
	1299	TALLOC_CTX *mem_ctx = NULL;
	1300	bool ret = false;
	1301
	1302	if ((domain == NULL) \|\| (strequal(domain, ".")) \|\| (domain[0] == '\0')){
	1303	domain = get_winbind_domain();
	1304	}
	1305
	1306	/* Send request */
	1307
	1308	wbc_status = wbcDomainInfo(domain, &dinfo);
	1309	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1310	d_printf("wbcDomainInfo(%s) failed: %s\n", domain,
	1311	wbcErrorString(wbc_status));
	1312	goto done;
	1313	}
	1314
	1315	mem_ctx = talloc_new(NULL);
	1316	if (mem_ctx == NULL) {
	1317	d_printf("talloc_new failed\n");
	1318	goto done;
	1319	}
	1320
	1321	num_rids = 0;
	1322	rids = NULL;
	1323	p = arg;
	1324
	1325	while (next_token_talloc(mem_ctx, &p, &ridstr, " ,\n")) {
	1326	uint32_t rid = strtoul(ridstr, NULL, 10);
	1327	rids = talloc_realloc(mem_ctx, rids, uint32_t, num_rids + 1);
	1328	if (rids == NULL) {
	1329	d_printf("talloc_realloc failed\n");
	1330	}
	1331	rids[num_rids] = rid;
	1332	num_rids += 1;
	1333	}
	1334
	1335	if (rids == NULL) {
	1336	d_printf("no rids\n");
	1337	goto done;
	1338	}
	1339
	1340	wbc_status = wbcLookupRids(&dinfo->sid, num_rids, rids,
[988]	1341	&p, &names, &types);
[860]	1342	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1343	d_printf("winbind_lookup_rids failed: %s\n",
	1344	wbcErrorString(wbc_status));
	1345	goto done;
	1346	}
	1347
[988]	1348	domain_name = discard_const_p(char, p);
[860]	1349	d_printf("Domain: %s\n", domain_name);
	1350
	1351	for (i=0; i<num_rids; i++) {
	1352	d_printf("%8d: %s (%s)\n", rids[i], names[i],
	1353	wbcSidTypeString(types[i]));
	1354	}
	1355
	1356	ret = true;
	1357	done:
	1358	wbcFreeMemory(dinfo);
	1359	wbcFreeMemory(domain_name);
	1360	wbcFreeMemory(names);
	1361	wbcFreeMemory(types);
	1362	TALLOC_FREE(mem_ctx);
	1363	return ret;
	1364	}
	1365
	1366	static bool wbinfo_lookup_sids(const char *arg)
	1367	{
	1368	char sidstr[WBC_SID_STRING_BUFLEN];
	1369	struct wbcDomainSid *sids;
	1370	struct wbcDomainInfo *domains;
	1371	struct wbcTranslatedName *names;
	1372	int num_domains;
	1373	int i, num_sids;
	1374	const char *p;
	1375	wbcErr wbc_status;
	1376
	1377
	1378	num_sids = 0;
	1379	sids = NULL;
	1380	p = arg;
	1381
	1382	while (next_token(&p, sidstr, LIST_SEP, sizeof(sidstr))) {
	1383	sids = talloc_realloc(talloc_tos(), sids, struct wbcDomainSid,
	1384	num_sids+1);
	1385	if (sids == NULL) {
	1386	d_fprintf(stderr, "talloc failed\n");
	1387	return false;
	1388	}
	1389	wbc_status = wbcStringToSid(sidstr, &sids[num_sids]);
	1390	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1391	d_fprintf(stderr, "wbcSidToString(%s) failed: %s\n",
	1392	sidstr, wbcErrorString(wbc_status));
	1393	TALLOC_FREE(sids);
	1394	return false;
	1395	}
	1396	num_sids += 1;
	1397	}
	1398
	1399	wbc_status = wbcLookupSids(sids, num_sids, &domains, &num_domains,
	1400	&names);
	1401	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1402	d_fprintf(stderr, "wbcLookupSids failed: %s\n",
	1403	wbcErrorString(wbc_status));
	1404	TALLOC_FREE(sids);
	1405	return false;
	1406	}
	1407
	1408	for (i=0; i<num_sids; i++) {
	1409	const char *domain = NULL;
	1410
	1411	wbcSidToStringBuf(&sids[i], sidstr, sizeof(sidstr));
	1412
	1413	if (names[i].domain_index >= num_domains) {
	1414	domain = "<none>";
	1415	} else if (names[i].domain_index < 0) {
	1416	domain = "<none>";
	1417	} else {
	1418	domain = domains[names[i].domain_index].short_name;
	1419	}
	1420
	1421	if (names[i].type == WBC_SID_NAME_DOMAIN) {
	1422	d_printf("%s -> %s %d\n", sidstr,
[988]	1423	domain,
	1424	names[i].type);
[860]	1425	} else {
	1426	d_printf("%s -> %s%c%s %d\n", sidstr,
[988]	1427	domain,
	1428	winbind_separator(),
	1429	names[i].name, names[i].type);
[860]	1430	}
	1431	}
[988]	1432	wbcFreeMemory(names);
	1433	wbcFreeMemory(domains);
[860]	1434	return true;
	1435	}
	1436
	1437	/* Convert string to sid */
	1438
	1439	static bool wbinfo_lookupname(const char *full_name)
	1440	{
	1441	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1442	struct wbcDomainSid sid;
	1443	char sid_str[WBC_SID_STRING_BUFLEN];
	1444	enum wbcSidType type;
	1445	fstring domain_name;
	1446	fstring account_name;
	1447
	1448	/* Send off request */
	1449
	1450	parse_wbinfo_domain_user(full_name, domain_name,
	1451	account_name);
	1452
	1453	wbc_status = wbcLookupName(domain_name, account_name,
	1454	&sid, &type);
	1455	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1456	d_fprintf(stderr, "failed to call wbcLookupName: %s\n",
	1457	wbcErrorString(wbc_status));
	1458	return false;
	1459	}
	1460
	1461	wbcSidToStringBuf(&sid, sid_str, sizeof(sid_str));
	1462
	1463	/* Display response */
	1464
	1465	d_printf("%s %s (%d)\n", sid_str, wbcSidTypeString(type), type);
	1466
	1467	return true;
	1468	}
	1469
	1470	static char wbinfo_prompt_pass(TALLOC_CTX mem_ctx,
	1471	const char *prefix,
	1472	const char *username)
	1473	{
	1474	char *prompt;
[988]	1475	char buf[1024] = {0};
	1476	int rc;
[860]	1477
	1478	prompt = talloc_asprintf(mem_ctx, "Enter %s's ", username);
	1479	if (!prompt) {
	1480	return NULL;
	1481	}
	1482	if (prefix) {
	1483	prompt = talloc_asprintf_append(prompt, "%s ", prefix);
	1484	if (!prompt) {
	1485	return NULL;
	1486	}
	1487	}
	1488	prompt = talloc_asprintf_append(prompt, "password: ");
	1489	if (!prompt) {
	1490	return NULL;
	1491	}
	1492
[988]	1493	rc = samba_getpass(prompt, buf, sizeof(buf), false, false);
[860]	1494	TALLOC_FREE(prompt);
[988]	1495	if (rc < 0) {
	1496	return NULL;
	1497	}
[860]	1498
[988]	1499	return talloc_strdup(mem_ctx, buf);
[860]	1500	}
	1501
	1502	/* Authenticate a user with a plaintext password */
	1503
	1504	static bool wbinfo_auth_krb5(char username, const char cctype, uint32_t flags)
	1505	{
	1506	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1507	char *s = NULL;
	1508	char *p = NULL;
	1509	char *password = NULL;
	1510	char *name = NULL;
	1511	char *local_cctype = NULL;
	1512	uid_t uid;
	1513	struct wbcLogonUserParams params;
	1514	struct wbcLogonUserInfo *info;
	1515	struct wbcAuthErrorInfo *error;
	1516	struct wbcUserPasswordPolicyInfo *policy;
	1517	TALLOC_CTX *frame = talloc_tos();
	1518
	1519	if ((s = talloc_strdup(frame, username)) == NULL) {
	1520	return false;
	1521	}
	1522
	1523	if ((p = strchr(s, '%')) != NULL) {
	1524	*p = 0;
	1525	p++;
	1526	password = talloc_strdup(frame, p);
	1527	} else {
	1528	password = wbinfo_prompt_pass(frame, NULL, username);
	1529	}
	1530
	1531	local_cctype = talloc_strdup(frame, cctype);
	1532
	1533	name = s;
	1534
	1535	uid = geteuid();
	1536
	1537	params.username = name;
	1538	params.password = password;
	1539	params.num_blobs = 0;
	1540	params.blobs = NULL;
	1541
	1542	wbc_status = wbcAddNamedBlob(&params.num_blobs,
	1543	&params.blobs,
	1544	"flags",
	1545	0,
	1546	(uint8_t *)&flags,
	1547	sizeof(flags));
	1548	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1549	d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
	1550	wbcErrorString(wbc_status));
	1551	goto done;
	1552	}
	1553
	1554	wbc_status = wbcAddNamedBlob(&params.num_blobs,
	1555	&params.blobs,
	1556	"user_uid",
	1557	0,
	1558	(uint8_t *)&uid,
	1559	sizeof(uid));
	1560	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1561	d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
	1562	wbcErrorString(wbc_status));
	1563	goto done;
	1564	}
	1565
	1566	wbc_status = wbcAddNamedBlob(&params.num_blobs,
	1567	&params.blobs,
	1568	"krb5_cc_type",
	1569	0,
	1570	(uint8_t *)local_cctype,
	1571	strlen(cctype)+1);
	1572	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1573	d_fprintf(stderr, "failed to call wbcAddNamedBlob: %s\n",
	1574	wbcErrorString(wbc_status));
	1575	goto done;
	1576	}
	1577
	1578	wbc_status = wbcLogonUser(&params, &info, &error, &policy);
	1579
	1580	d_printf("plaintext kerberos password authentication for [%s] %s "
	1581	"(requesting cctype: %s)\n",
	1582	username, WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed",
	1583	cctype);
	1584
	1585	if (error) {
	1586	d_fprintf(stderr,
[988]	1587	"wbcLogonUser(%s): error code was %s (0x%x)\n"
	1588	"error message was: %s\n",
	1589	params.username, error->nt_string,
[860]	1590	error->nt_status,
	1591	error->display_string);
	1592	}
	1593
	1594	if (WBC_ERROR_IS_OK(wbc_status)) {
	1595	if (flags & WBFLAG_PAM_INFO3_TEXT) {
	1596	if (info && info->info && info->info->user_flags &
	1597	NETLOGON_CACHED_ACCOUNT) {
	1598	d_printf("user_flgs: "
	1599	"NETLOGON_CACHED_ACCOUNT\n");
	1600	}
	1601	}
	1602
	1603	if (info) {
	1604	int i;
	1605	for (i=0; i < info->num_blobs; i++) {
	1606	if (strequal(info->blobs[i].name,
	1607	"krb5ccname")) {
	1608	d_printf("credentials were put "
	1609	"in: %s\n",
	1610	(const char *)
	1611	info->blobs[i].blob.data);
	1612	break;
	1613	}
	1614	}
	1615	} else {
	1616	d_printf("no credentials cached\n");
	1617	}
	1618	}
	1619	done:
	1620
	1621	wbcFreeMemory(params.blobs);
	1622
	1623	return WBC_ERROR_IS_OK(wbc_status);
	1624	}
	1625
	1626	/* Authenticate a user with a plaintext password */
	1627
	1628	static bool wbinfo_auth(char *username)
	1629	{
	1630	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1631	char *s = NULL;
	1632	char *p = NULL;
	1633	char *password = NULL;
	1634	char *name = NULL;
	1635	TALLOC_CTX *frame = talloc_tos();
	1636
	1637	if ((s = talloc_strdup(frame, username)) == NULL) {
	1638	return false;
	1639	}
	1640
	1641	if ((p = strchr(s, '%')) != NULL) {
	1642	*p = 0;
	1643	p++;
	1644	password = talloc_strdup(frame, p);
	1645	} else {
	1646	password = wbinfo_prompt_pass(frame, NULL, username);
	1647	}
	1648
	1649	name = s;
	1650
	1651	wbc_status = wbcAuthenticateUser(name, password);
	1652
	1653	d_printf("plaintext password authentication %s\n",
	1654	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	1655
	1656	#if 0
	1657	if (response.data.auth.nt_status)
	1658	d_fprintf(stderr,
	1659	"error code was %s (0x%x)\nerror message was: %s\n",
	1660	response.data.auth.nt_status_string,
	1661	response.data.auth.nt_status,
	1662	response.data.auth.error_string);
	1663	#endif
	1664
	1665	return WBC_ERROR_IS_OK(wbc_status);
	1666	}
	1667
	1668	/* Authenticate a user with a challenge/response */
	1669
	1670	static bool wbinfo_auth_crap(char *username, bool use_ntlmv2, bool use_lanman)
	1671	{
	1672	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1673	struct wbcAuthUserParams params;
	1674	struct wbcAuthUserInfo *info = NULL;
	1675	struct wbcAuthErrorInfo *err = NULL;
	1676	DATA_BLOB lm = data_blob_null;
	1677	DATA_BLOB nt = data_blob_null;
	1678	fstring name_user;
	1679	fstring name_domain;
	1680	char *pass;
	1681	char *p;
	1682	TALLOC_CTX *frame = talloc_tos();
	1683
	1684	p = strchr(username, '%');
	1685
	1686	if (p) {
	1687	*p = 0;
	1688	pass = talloc_strdup(frame, p + 1);
	1689	} else {
	1690	pass = wbinfo_prompt_pass(frame, NULL, username);
	1691	}
	1692
	1693	parse_wbinfo_domain_user(username, name_domain, name_user);
	1694
	1695	params.account_name = name_user;
	1696	params.domain_name = name_domain;
	1697	params.workstation_name = NULL;
	1698
	1699	params.flags = 0;
	1700	params.parameter_control= WBC_MSV1_0_ALLOW_WORKSTATION_TRUST_ACCOUNT \|
	1701	WBC_MSV1_0_ALLOW_SERVER_TRUST_ACCOUNT;
	1702
	1703	params.level = WBC_AUTH_USER_LEVEL_RESPONSE;
	1704
	1705	generate_random_buffer(params.password.response.challenge, 8);
	1706
	1707	if (use_ntlmv2) {
	1708	DATA_BLOB server_chal;
	1709	DATA_BLOB names_blob;
	1710
	1711	server_chal = data_blob(params.password.response.challenge, 8);
	1712
	1713	/* Pretend this is a login to 'us', for blob purposes */
	1714	names_blob = NTLMv2_generate_names_blob(NULL,
	1715	get_winbind_netbios_name(),
	1716	get_winbind_domain());
	1717
	1718	if (!SMBNTLMv2encrypt(NULL, name_user, name_domain, pass,
	1719	&server_chal,
	1720	&names_blob,
	1721	&lm, &nt, NULL, NULL)) {
	1722	data_blob_free(&names_blob);
	1723	data_blob_free(&server_chal);
	1724	TALLOC_FREE(pass);
	1725	return false;
	1726	}
	1727	data_blob_free(&names_blob);
	1728	data_blob_free(&server_chal);
	1729
	1730	} else {
	1731	if (use_lanman) {
	1732	bool ok;
	1733	lm = data_blob(NULL, 24);
	1734	ok = SMBencrypt(pass,
	1735	params.password.response.challenge,
	1736	lm.data);
	1737	if (!ok) {
	1738	data_blob_free(&lm);
	1739	}
	1740	}
	1741	nt = data_blob(NULL, 24);
	1742	SMBNTencrypt(pass, params.password.response.challenge,
	1743	nt.data);
	1744	}
	1745
	1746	params.password.response.nt_length = nt.length;
	1747	params.password.response.nt_data = nt.data;
	1748	params.password.response.lm_length = lm.length;
	1749	params.password.response.lm_data = lm.data;
	1750
	1751	wbc_status = wbcAuthenticateUserEx(&params, &info, &err);
	1752
	1753	/* Display response */
	1754
	1755	d_printf("challenge/response password authentication %s\n",
	1756	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	1757
	1758	if (wbc_status == WBC_ERR_AUTH_ERROR) {
	1759	d_fprintf(stderr,
[988]	1760	"wbcAuthenticateUserEx(%s%c%s): error code was %s (0x%x)\n"
	1761	"error message was: %s\n",
	1762	name_domain,
	1763	winbind_separator(),
	1764	name_user,
[860]	1765	err->nt_string,
	1766	err->nt_status,
	1767	err->display_string);
	1768	wbcFreeMemory(err);
	1769	} else if (WBC_ERROR_IS_OK(wbc_status)) {
	1770	wbcFreeMemory(info);
	1771	}
	1772
	1773	data_blob_free(&nt);
	1774	data_blob_free(&lm);
	1775
	1776	return WBC_ERROR_IS_OK(wbc_status);
	1777	}
	1778
	1779	/* Authenticate a user with a plaintext password */
	1780
[988]	1781	static bool wbinfo_pam_logon(char *username, bool verbose)
[860]	1782	{
	1783	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1784	struct wbcLogonUserParams params;
[988]	1785	struct wbcLogonUserInfo *info = NULL;
[860]	1786	struct wbcAuthErrorInfo *error = NULL;
	1787	char *s = NULL;
	1788	char *p = NULL;
	1789	TALLOC_CTX *frame = talloc_tos();
	1790	uint32_t flags;
	1791	uint32_t uid;
	1792
	1793	ZERO_STRUCT(params);
	1794
	1795	if ((s = talloc_strdup(frame, username)) == NULL) {
	1796	return false;
	1797	}
	1798
	1799	if ((p = strchr(s, '%')) != NULL) {
	1800	*p = 0;
	1801	p++;
	1802	params.password = talloc_strdup(frame, p);
	1803	} else {
	1804	params.password = wbinfo_prompt_pass(frame, NULL, username);
	1805	}
	1806	params.username = s;
	1807
	1808	flags = WBFLAG_PAM_CACHED_LOGIN;
	1809
	1810	wbc_status = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
	1811	"flags", 0,
	1812	(uint8_t *)&flags, sizeof(flags));
	1813	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1814	d_printf("wbcAddNamedBlob failed: %s\n",
	1815	wbcErrorString(wbc_status));
	1816	return false;
	1817	}
	1818
	1819	uid = getuid();
	1820
	1821	wbc_status = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
	1822	"user_uid", 0,
	1823	(uint8_t *)&uid, sizeof(uid));
	1824	if (!WBC_ERROR_IS_OK(wbc_status)) {
	1825	d_printf("wbcAddNamedBlob failed: %s\n",
	1826	wbcErrorString(wbc_status));
	1827	return false;
	1828	}
	1829
[988]	1830	wbc_status = wbcLogonUser(&params, &info, &error, NULL);
[860]	1831
[988]	1832	if (verbose && (info != NULL)) {
	1833	struct wbcAuthUserInfo *i = info->info;
	1834	uint32_t j;
	1835
	1836	if (i->account_name != NULL) {
	1837	d_printf("account_name: %s\n", i->account_name);
	1838	}
	1839	if (i->user_principal != NULL) {
	1840	d_printf("user_principal: %s\n", i->user_principal);
	1841	}
	1842	if (i->full_name != NULL) {
	1843	d_printf("full_name: %s\n", i->full_name);
	1844	}
	1845	if (i->domain_name != NULL) {
	1846	d_printf("domain_name: %s\n", i->domain_name);
	1847	}
	1848	if (i->dns_domain_name != NULL) {
	1849	d_printf("dns_domain_name: %s\n", i->dns_domain_name);
	1850	}
	1851	if (i->logon_server != NULL) {
	1852	d_printf("logon_server: %s\n", i->logon_server);
	1853	}
	1854	if (i->logon_script != NULL) {
	1855	d_printf("logon_script: %s\n", i->logon_script);
	1856	}
	1857	if (i->profile_path != NULL) {
	1858	d_printf("profile_path: %s\n", i->profile_path);
	1859	}
	1860	if (i->home_directory != NULL) {
	1861	d_printf("home_directory: %s\n", i->home_directory);
	1862	}
	1863	if (i->home_drive != NULL) {
	1864	d_printf("home_drive: %s\n", i->home_drive);
	1865	}
	1866
	1867	d_printf("sids:");
	1868
	1869	for (j=0; j<i->num_sids; j++) {
	1870	char buf[WBC_SID_STRING_BUFLEN];
	1871	wbcSidToStringBuf(&i->sids[j].sid, buf, sizeof(buf));
	1872	d_printf(" %s", buf);
	1873	}
	1874	d_printf("\n");
	1875
	1876	wbcFreeMemory(info);
	1877	info = NULL;
	1878	}
	1879
[860]	1880	wbcFreeMemory(params.blobs);
	1881
	1882	d_printf("plaintext password authentication %s\n",
	1883	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	1884
	1885	if (!WBC_ERROR_IS_OK(wbc_status) && (error != NULL)) {
	1886	d_fprintf(stderr,
[988]	1887	"wbcLogonUser(%s): error code was %s (0x%x)\n"
	1888	"error message was: %s\n",
	1889	params.username,
[860]	1890	error->nt_string,
	1891	(int)error->nt_status,
	1892	error->display_string);
	1893	wbcFreeMemory(error);
	1894	}
	1895	return WBC_ERROR_IS_OK(wbc_status);
	1896	}
	1897
	1898	/* Save creds with winbind */
	1899
	1900	static bool wbinfo_ccache_save(char *username)
	1901	{
	1902	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	1903	char *s = NULL;
	1904	char *p = NULL;
	1905	char *password = NULL;
	1906	char *name = NULL;
	1907	TALLOC_CTX *frame = talloc_stackframe();
	1908
	1909	s = talloc_strdup(frame, username);
	1910	if (s == NULL) {
	1911	return false;
	1912	}
	1913
	1914	p = strchr(s, '%');
	1915	if (p != NULL) {
	1916	*p = 0;
	1917	p++;
	1918	password = talloc_strdup(frame, p);
	1919	} else {
	1920	password = wbinfo_prompt_pass(frame, NULL, username);
	1921	}
	1922
	1923	name = s;
	1924
	1925	wbc_status = wbcCredentialSave(name, password);
	1926
	1927	d_printf("saving creds %s\n",
	1928	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	1929
	1930	TALLOC_FREE(frame);
	1931
	1932	return WBC_ERROR_IS_OK(wbc_status);
	1933	}
	1934
	1935	#ifdef WITH_FAKE_KASERVER
	1936	/* Authenticate a user with a plaintext password and set a token */
	1937
	1938	static bool wbinfo_klog(char *username)
	1939	{
	1940	struct winbindd_request request;
	1941	struct winbindd_response response;
	1942	NSS_STATUS result;
	1943	char *p;
	1944
	1945	/* Send off request */
	1946
	1947	ZERO_STRUCT(request);
	1948	ZERO_STRUCT(response);
	1949
	1950	p = strchr(username, '%');
	1951
	1952	if (p) {
	1953	*p = 0;
	1954	fstrcpy(request.data.auth.user, username);
	1955	fstrcpy(request.data.auth.pass, p + 1);
	1956	*p = '%';
	1957	} else {
	1958	fstrcpy(request.data.auth.user, username);
[988]	1959	(void) samba_getpass("Password: ",
	1960	request.data.auth.pass,
	1961	sizeof(request.data.auth.pass),
	1962	false, false);
[860]	1963	}
	1964
	1965	request.flags \|= WBFLAG_PAM_AFS_TOKEN;
	1966
[988]	1967	result = winbindd_request_response(NULL, WINBINDD_PAM_AUTH, &request,
[860]	1968	&response);
	1969
	1970	/* Display response */
	1971
	1972	d_printf("plaintext password authentication %s\n",
	1973	(result == NSS_STATUS_SUCCESS) ? "succeeded" : "failed");
	1974
	1975	if (response.data.auth.nt_status)
	1976	d_fprintf(stderr,
	1977	"error code was %s (0x%x)\nerror message was: %s\n",
	1978	response.data.auth.nt_status_string,
	1979	response.data.auth.nt_status,
	1980	response.data.auth.error_string);
	1981
	1982	if (result != NSS_STATUS_SUCCESS)
	1983	return false;
	1984
	1985	if (response.extra_data.data == NULL) {
	1986	d_fprintf(stderr, "Did not get token data\n");
	1987	return false;
	1988	}
	1989
	1990	if (!afs_settoken_str((char *)response.extra_data.data)) {
	1991	d_fprintf(stderr, "Could not set token\n");
	1992	return false;
	1993	}
	1994
	1995	d_printf("Successfully created AFS token\n");
	1996	return true;
	1997	}
	1998	#else
	1999	static bool wbinfo_klog(char *username)
	2000	{
	2001	d_fprintf(stderr, "No AFS support compiled in.\n");
	2002	return false;
	2003	}
	2004	#endif
	2005
	2006	/* Print domain users */
	2007
	2008	static bool print_domain_users(const char *domain)
	2009	{
	2010	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	2011	uint32_t i;
	2012	uint32_t num_users = 0;
	2013	const char **users = NULL;
	2014
	2015	/* Send request to winbind daemon */
	2016
[988]	2017	if (domain == NULL) {
[860]	2018	domain = get_winbind_domain();
[988]	2019	} else {
	2020	/* '.' is the special sign for our own domain */
	2021	if ((domain[0] == '\0') \|\| strcmp(domain, ".") == 0) {
	2022	domain = get_winbind_domain();
	2023	/* '' is the special sign for all domains /
	2024	} else if (strcmp(domain, "*") == 0) {
	2025	domain = NULL;
	2026	}
[860]	2027	}
	2028
	2029	wbc_status = wbcListUsers(domain, &num_users, &users);
	2030	if (!WBC_ERROR_IS_OK(wbc_status)) {
	2031	return false;
	2032	}
	2033
	2034	for (i=0; i < num_users; i++) {
	2035	d_printf("%s\n", users[i]);
	2036	}
	2037
	2038	wbcFreeMemory(users);
	2039
	2040	return true;
	2041	}
	2042
	2043	/* Print domain groups */
	2044
	2045	static bool print_domain_groups(const char *domain)
	2046	{
	2047	wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
	2048	uint32_t i;
	2049	uint32_t num_groups = 0;
	2050	const char **groups = NULL;
	2051
	2052	/* Send request to winbind daemon */
	2053
[988]	2054	if (domain == NULL) {
[860]	2055	domain = get_winbind_domain();
[988]	2056	} else {
	2057	/* '.' is the special sign for our own domain */
	2058	if ((domain[0] == '\0') \|\| strcmp(domain, ".") == 0) {
	2059	domain = get_winbind_domain();
	2060	/* '' is the special sign for all domains /
	2061	} else if (strcmp(domain, "*") == 0) {
	2062	domain = NULL;
	2063	}
[860]	2064	}
	2065
	2066	wbc_status = wbcListGroups(domain, &num_groups, &groups);
	2067	if (!WBC_ERROR_IS_OK(wbc_status)) {
	2068	d_fprintf(stderr, "failed to call wbcListGroups: %s\n",
	2069	wbcErrorString(wbc_status));
	2070	return false;
	2071	}
	2072
	2073	for (i=0; i < num_groups; i++) {
	2074	d_printf("%s\n", groups[i]);
	2075	}
	2076
	2077	wbcFreeMemory(groups);
	2078
	2079	return true;
	2080	}
	2081
	2082	/* Set the authorised user for winbindd access in secrets.tdb */
	2083
	2084	static bool wbinfo_set_auth_user(char *username)
	2085	{
	2086	d_fprintf(stderr, "This functionality was moved to the 'net' utility.\n"
	2087	"See 'net help setauthuser' for details.\n");
	2088	return false;
	2089	}
	2090
	2091	static void wbinfo_get_auth_user(void)
	2092	{
	2093	d_fprintf(stderr, "This functionality was moved to the 'net' utility.\n"
	2094	"See 'net help getauthuser' for details.\n");
	2095	}
	2096
	2097	static bool wbinfo_ping(void)
	2098	{
	2099	wbcErr wbc_status;
	2100
	2101	wbc_status = wbcPing();
	2102
	2103	/* Display response */
	2104
	2105	d_printf("Ping to winbindd %s\n",
	2106	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	2107
	2108	return WBC_ERROR_IS_OK(wbc_status);
	2109	}
	2110
	2111	static bool wbinfo_change_user_password(const char *username)
	2112	{
	2113	wbcErr wbc_status;
	2114	char *old_password = NULL;
	2115	char *new_password = NULL;
	2116	TALLOC_CTX *frame = talloc_tos();
	2117
	2118	old_password = wbinfo_prompt_pass(frame, "old", username);
	2119	new_password = wbinfo_prompt_pass(frame, "new", username);
	2120
	2121	wbc_status = wbcChangeUserPassword(username, old_password,new_password);
	2122
	2123	/* Display response */
	2124
	2125	d_printf("Password change for user %s %s\n", username,
	2126	WBC_ERROR_IS_OK(wbc_status) ? "succeeded" : "failed");
	2127
	2128	return WBC_ERROR_IS_OK(wbc_status);
	2129	}
	2130
	2131	/* Main program */
	2132
	2133	enum {
	2134	OPT_SET_AUTH_USER = 1000,
	2135	OPT_GET_AUTH_USER,
	2136	OPT_DOMAIN_NAME,
	2137	OPT_SEQUENCE,
	2138	OPT_GETDCNAME,
	2139	OPT_DSGETDCNAME,
	2140	OPT_DC_INFO,
	2141	OPT_USERDOMGROUPS,
	2142	OPT_SIDALIASES,
	2143	OPT_USERSIDS,
	2144	OPT_LOOKUP_SIDS,
	2145	OPT_ALLOCATE_UID,
	2146	OPT_ALLOCATE_GID,
	2147	OPT_SET_UID_MAPPING,
	2148	OPT_SET_GID_MAPPING,
	2149	OPT_REMOVE_UID_MAPPING,
	2150	OPT_REMOVE_GID_MAPPING,
	2151	OPT_SIDS_TO_XIDS,
	2152	OPT_SEPARATOR,
	2153	OPT_LIST_ALL_DOMAINS,
	2154	OPT_LIST_OWN_DOMAIN,
	2155	OPT_UID_INFO,
	2156	OPT_USER_SIDINFO,
	2157	OPT_GROUP_INFO,
	2158	OPT_GID_INFO,
	2159	OPT_VERBOSE,
	2160	OPT_ONLINESTATUS,
	2161	OPT_CHANGE_USER_PASSWORD,
	2162	OPT_CCACHE_SAVE,
	2163	OPT_SID_TO_FULLNAME,
	2164	OPT_NTLMV2,
	2165	OPT_PAM_LOGON,
	2166	OPT_LOGOFF,
	2167	OPT_LOGOFF_USER,
	2168	OPT_LOGOFF_UID,
[988]	2169	OPT_LANMAN,
	2170	OPT_KRB5CCNAME
[860]	2171	};
	2172
[988]	2173	int main(int argc, const char argv, char envp)
[860]	2174	{
	2175	int opt;
	2176	TALLOC_CTX *frame = talloc_stackframe();
	2177	poptContext pc;
	2178	static char *string_arg;
	2179	char *string_subarg = NULL;
	2180	static char *opt_domain_name;
	2181	static int int_arg;
	2182	int int_subarg = -1;
	2183	int result = 1;
	2184	bool verbose = false;
	2185	bool use_ntlmv2 = false;
	2186	bool use_lanman = false;
	2187	char *logoff_user = getenv("USER");
	2188	int logoff_uid = geteuid();
[988]	2189	const char *opt_krb5ccname = "FILE";
[860]	2190
	2191	struct poptOption long_options[] = {
	2192	POPT_AUTOHELP
	2193
	2194	/* longName, shortName, argInfo, argPtr, value, descrip,
	2195	argDesc */
	2196
	2197	{ "domain-users", 'u', POPT_ARG_NONE, 0, 'u', "Lists all domain users", "domain"},
	2198	{ "domain-groups", 'g', POPT_ARG_NONE, 0, 'g', "Lists all domain groups", "domain" },
	2199	{ "WINS-by-name", 'N', POPT_ARG_STRING, &string_arg, 'N', "Converts NetBIOS name to IP", "NETBIOS-NAME" },
	2200	{ "WINS-by-ip", 'I', POPT_ARG_STRING, &string_arg, 'I', "Converts IP address to NetBIOS name", "IP" },
	2201	{ "name-to-sid", 'n', POPT_ARG_STRING, &string_arg, 'n', "Converts name to sid", "NAME" },
	2202	{ "sid-to-name", 's', POPT_ARG_STRING, &string_arg, 's', "Converts sid to name", "SID" },
	2203	{ "sid-to-fullname", 0, POPT_ARG_STRING, &string_arg,
	2204	OPT_SID_TO_FULLNAME, "Converts sid to fullname", "SID" },
	2205	{ "lookup-rids", 'R', POPT_ARG_STRING, &string_arg, 'R', "Converts RIDs to names", "RIDs" },
	2206	{ "lookup-sids", 0, POPT_ARG_STRING, &string_arg,
	2207	OPT_LOOKUP_SIDS, "Converts SIDs to types and names",
	2208	"Sid-List"},
	2209	{ "uid-to-sid", 'U', POPT_ARG_INT, &int_arg, 'U', "Converts uid to sid" , "UID" },
	2210	{ "gid-to-sid", 'G', POPT_ARG_INT, &int_arg, 'G', "Converts gid to sid", "GID" },
	2211	{ "sid-to-uid", 'S', POPT_ARG_STRING, &string_arg, 'S', "Converts sid to uid", "SID" },
	2212	{ "sid-to-gid", 'Y', POPT_ARG_STRING, &string_arg, 'Y', "Converts sid to gid", "SID" },
	2213	{ "allocate-uid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_UID,
	2214	"Get a new UID out of idmap" },
	2215	{ "allocate-gid", 0, POPT_ARG_NONE, 0, OPT_ALLOCATE_GID,
	2216	"Get a new GID out of idmap" },
	2217	{ "set-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_SET_UID_MAPPING, "Create or modify uid to sid mapping in idmap", "UID,SID" },
	2218	{ "set-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_SET_GID_MAPPING, "Create or modify gid to sid mapping in idmap", "GID,SID" },
	2219	{ "remove-uid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_UID_MAPPING, "Remove uid to sid mapping in idmap", "UID,SID" },
	2220	{ "remove-gid-mapping", 0, POPT_ARG_STRING, &string_arg, OPT_REMOVE_GID_MAPPING, "Remove gid to sid mapping in idmap", "GID,SID" },
	2221	{ "sids-to-unix-ids", 0, POPT_ARG_STRING, &string_arg,
	2222	OPT_SIDS_TO_XIDS, "Translate SIDs to Unix IDs", "Sid-List" },
	2223	{ "check-secret", 't', POPT_ARG_NONE, 0, 't', "Check shared secret" },
	2224	{ "change-secret", 'c', POPT_ARG_NONE, 0, 'c', "Change shared secret" },
	2225	{ "ping-dc", 'P', POPT_ARG_NONE, 0, 'P',
	2226	"Check the NETLOGON connection" },
	2227	{ "trusted-domains", 'm', POPT_ARG_NONE, 0, 'm', "List trusted domains" },
	2228	{ "all-domains", 0, POPT_ARG_NONE, 0, OPT_LIST_ALL_DOMAINS, "List all domains (trusted and own domain)" },
	2229	{ "own-domain", 0, POPT_ARG_NONE, 0, OPT_LIST_OWN_DOMAIN, "List own domain" },
	2230	{ "sequence", 0, POPT_ARG_NONE, 0, OPT_SEQUENCE, "Deprecated command, see --online-status" },
	2231	{ "online-status", 0, POPT_ARG_NONE, 0, OPT_ONLINESTATUS, "Show whether domains are marked as online or offline"},
	2232	{ "domain-info", 'D', POPT_ARG_STRING, &string_arg, 'D', "Show most of the info we have about the domain" },
	2233	{ "user-info", 'i', POPT_ARG_STRING, &string_arg, 'i', "Get user info", "USER" },
	2234	{ "uid-info", 0, POPT_ARG_INT, &int_arg, OPT_UID_INFO, "Get user info from uid", "UID" },
	2235	{ "group-info", 0, POPT_ARG_STRING, &string_arg, OPT_GROUP_INFO, "Get group info", "GROUP" },
	2236	{ "user-sidinfo", 0, POPT_ARG_STRING, &string_arg, OPT_USER_SIDINFO, "Get user info from sid", "SID" },
	2237	{ "gid-info", 0, POPT_ARG_INT, &int_arg, OPT_GID_INFO, "Get group info from gid", "GID" },
	2238	{ "user-groups", 'r', POPT_ARG_STRING, &string_arg, 'r', "Get user groups", "USER" },
	2239	{ "user-domgroups", 0, POPT_ARG_STRING, &string_arg,
	2240	OPT_USERDOMGROUPS, "Get user domain groups", "SID" },
	2241	{ "sid-aliases", 0, POPT_ARG_STRING, &string_arg, OPT_SIDALIASES, "Get sid aliases", "SID" },
	2242	{ "user-sids", 0, POPT_ARG_STRING, &string_arg, OPT_USERSIDS, "Get user group sids for user SID", "SID" },
	2243	{ "authenticate", 'a', POPT_ARG_STRING, &string_arg, 'a', "authenticate user", "user%password" },
	2244	{ "pam-logon", 0, POPT_ARG_STRING, &string_arg, OPT_PAM_LOGON,
	2245	"do a pam logon equivalent", "user%password" },
	2246	{ "logoff", 0, POPT_ARG_NONE, NULL, OPT_LOGOFF,
	2247	"log off user", "uid" },
	2248	{ "logoff-user", 0, POPT_ARG_STRING, &logoff_user,
	2249	OPT_LOGOFF_USER, "username to log off" },
	2250	{ "logoff-uid", 0, POPT_ARG_INT, &logoff_uid,
	2251	OPT_LOGOFF_UID, "uid to log off" },
	2252	{ "set-auth-user", 0, POPT_ARG_STRING, &string_arg, OPT_SET_AUTH_USER, "Store user and password used by winbindd (root only)", "user%password" },
	2253	{ "ccache-save", 0, POPT_ARG_STRING, &string_arg,
	2254	OPT_CCACHE_SAVE, "Store user and password for ccache "
	2255	"operation", "user%password" },
	2256	{ "getdcname", 0, POPT_ARG_STRING, &string_arg, OPT_GETDCNAME,
	2257	"Get a DC name for a foreign domain", "domainname" },
	2258	{ "dsgetdcname", 0, POPT_ARG_STRING, &string_arg, OPT_DSGETDCNAME, "Find a DC for a domain", "domainname" },
	2259	{ "dc-info", 0, POPT_ARG_STRING, &string_arg, OPT_DC_INFO,
	2260	"Find the currently known DCs", "domainname" },
	2261	{ "get-auth-user", 0, POPT_ARG_NONE, NULL, OPT_GET_AUTH_USER, "Retrieve user and password used by winbindd (root only)", NULL },
	2262	{ "ping", 'p', POPT_ARG_NONE, 0, 'p', "Ping winbindd to see if it is alive" },
	2263	{ "domain", 0, POPT_ARG_STRING, &opt_domain_name, OPT_DOMAIN_NAME, "Define to the domain to restrict operation", "domain" },
	2264	#ifdef WITH_FAKE_KASERVER
	2265	{ "klog", 'k', POPT_ARG_STRING, &string_arg, 'k', "set an AFS token from winbind", "user%password" },
	2266	#endif
	2267	#ifdef HAVE_KRB5
	2268	{ "krb5auth", 'K', POPT_ARG_STRING, &string_arg, 'K', "authenticate user using Kerberos", "user%password" },
	2269	/* destroys wbinfo --help output */
	2270	/* "user%password,DOM\\user%password,user@EXAMPLE.COM,EXAMPLE.COM\\user%password" }, */
[988]	2271	{ "krb5ccname", 0, POPT_ARG_STRING, &opt_krb5ccname, OPT_KRB5CCNAME, "authenticate user using Kerberos and specific credential cache type", "krb5ccname" },
[860]	2272	#endif
	2273	{ "separator", 0, POPT_ARG_NONE, 0, OPT_SEPARATOR, "Get the active winbind separator", NULL },
	2274	{ "verbose", 0, POPT_ARG_NONE, 0, OPT_VERBOSE, "Print additional information per command", NULL },
	2275	{ "change-user-password", 0, POPT_ARG_STRING, &string_arg, OPT_CHANGE_USER_PASSWORD, "Change the password for a user", NULL },
	2276	{ "ntlmv2", 0, POPT_ARG_NONE, 0, OPT_NTLMV2, "Use NTLMv2 cryptography for user authentication", NULL},
	2277	{ "lanman", 0, POPT_ARG_NONE, 0, OPT_LANMAN, "Use lanman cryptography for user authentication", NULL},
	2278	POPT_COMMON_VERSION
	2279	POPT_TABLEEND
	2280	};
	2281
	2282	/* Samba client initialisation */
[988]	2283	smb_init_locale();
[860]	2284
	2285
	2286	/* Parse options */
	2287
[988]	2288	pc = poptGetContext("wbinfo", argc, argv,
[860]	2289	long_options, 0);
	2290
	2291	/* Parse command line options */
	2292
	2293	if (argc == 1) {
	2294	poptPrintHelp(pc, stderr, 0);
	2295	return 1;
	2296	}
	2297
	2298	while((opt = poptGetNextOpt(pc)) != -1) {
	2299	/* get the generic configuration parameters like --domain */
	2300	switch (opt) {
	2301	case OPT_VERBOSE:
	2302	verbose = true;
	2303	break;
	2304	case OPT_NTLMV2:
	2305	use_ntlmv2 = true;
	2306	break;
	2307	case OPT_LANMAN:
	2308	use_lanman = true;
	2309	break;
	2310	}
	2311	}
	2312
	2313	poptFreeContext(pc);
	2314
	2315	pc = poptGetContext(NULL, argc, (const char **)argv, long_options,
	2316	POPT_CONTEXT_KEEP_FIRST);
	2317
	2318	while((opt = poptGetNextOpt(pc)) != -1) {
	2319	switch (opt) {
	2320	case 'u':
	2321	if (!print_domain_users(opt_domain_name)) {
	2322	d_fprintf(stderr,
	2323	"Error looking up domain users\n");
	2324	goto done;
	2325	}
	2326	break;
	2327	case 'g':
	2328	if (!print_domain_groups(opt_domain_name)) {
	2329	d_fprintf(stderr,
	2330	"Error looking up domain groups\n");
	2331	goto done;
	2332	}
	2333	break;
	2334	case 's':
	2335	if (!wbinfo_lookupsid(string_arg)) {
	2336	d_fprintf(stderr,
	2337	"Could not lookup sid %s\n",
	2338	string_arg);
	2339	goto done;
	2340	}
	2341	break;
	2342	case OPT_SID_TO_FULLNAME:
	2343	if (!wbinfo_lookupsid_fullname(string_arg)) {
	2344	d_fprintf(stderr, "Could not lookup sid %s\n",
	2345	string_arg);
	2346	goto done;
	2347	}
	2348	break;
	2349	case 'R':
	2350	if (!wbinfo_lookuprids(opt_domain_name, string_arg)) {
	2351	d_fprintf(stderr, "Could not lookup RIDs %s\n",
	2352	string_arg);
	2353	goto done;
	2354	}
	2355	break;
	2356	case OPT_LOOKUP_SIDS:
	2357	if (!wbinfo_lookup_sids(string_arg)) {
	2358	d_fprintf(stderr, "Could not lookup SIDs %s\n",
	2359	string_arg);
	2360	goto done;
	2361	}
	2362	break;
	2363	case 'n':
	2364	if (!wbinfo_lookupname(string_arg)) {
	2365	d_fprintf(stderr, "Could not lookup name %s\n",
	2366	string_arg);
	2367	goto done;
	2368	}
	2369	break;
	2370	case 'N':
	2371	if (!wbinfo_wins_byname(string_arg)) {
	2372	d_fprintf(stderr,
	2373	"Could not lookup WINS by name %s\n",
	2374	string_arg);
	2375	goto done;
	2376	}
	2377	break;
	2378	case 'I':
	2379	if (!wbinfo_wins_byip(string_arg)) {
	2380	d_fprintf(stderr,
	2381	"Could not lookup WINS by IP %s\n",
	2382	string_arg);
	2383	goto done;
	2384	}
	2385	break;
	2386	case 'U':
	2387	if (!wbinfo_uid_to_sid(int_arg)) {
	2388	d_fprintf(stderr,
	2389	"Could not convert uid %d to sid\n",
	2390	int_arg);
	2391	goto done;
	2392	}
	2393	break;
	2394	case 'G':
	2395	if (!wbinfo_gid_to_sid(int_arg)) {
	2396	d_fprintf(stderr,
	2397	"Could not convert gid %d to sid\n",
	2398	int_arg);
	2399	goto done;
	2400	}
	2401	break;
	2402	case 'S':
	2403	if (!wbinfo_sid_to_uid(string_arg)) {
	2404	d_fprintf(stderr,
	2405	"Could not convert sid %s to uid\n",
	2406	string_arg);
	2407	goto done;
	2408	}
	2409	break;
	2410	case 'Y':
	2411	if (!wbinfo_sid_to_gid(string_arg)) {
	2412	d_fprintf(stderr,
	2413	"Could not convert sid %s to gid\n",
	2414	string_arg);
	2415	goto done;
	2416	}
	2417	break;
	2418	case OPT_ALLOCATE_UID:
	2419	if (!wbinfo_allocate_uid()) {
	2420	d_fprintf(stderr, "Could not allocate a uid\n");
	2421	goto done;
	2422	}
	2423	break;
	2424	case OPT_ALLOCATE_GID:
	2425	if (!wbinfo_allocate_gid()) {
	2426	d_fprintf(stderr, "Could not allocate a gid\n");
	2427	goto done;
	2428	}
	2429	break;
	2430	case OPT_SET_UID_MAPPING:
	2431	if (!parse_mapping_arg(string_arg, &int_subarg,
	2432	&string_subarg) \|\|
	2433	!wbinfo_set_uid_mapping(int_subarg, string_subarg))
	2434	{
	2435	d_fprintf(stderr, "Could not create or modify "
	2436	"uid to sid mapping\n");
	2437	goto done;
	2438	}
	2439	break;
	2440	case OPT_SET_GID_MAPPING:
	2441	if (!parse_mapping_arg(string_arg, &int_subarg,
	2442	&string_subarg) \|\|
	2443	!wbinfo_set_gid_mapping(int_subarg, string_subarg))
	2444	{
	2445	d_fprintf(stderr, "Could not create or modify "
	2446	"gid to sid mapping\n");
	2447	goto done;
	2448	}
	2449	break;
	2450	case OPT_REMOVE_UID_MAPPING:
	2451	if (!parse_mapping_arg(string_arg, &int_subarg,
	2452	&string_subarg) \|\|
	2453	!wbinfo_remove_uid_mapping(int_subarg,
	2454	string_subarg))
	2455	{
	2456	d_fprintf(stderr, "Could not remove uid to sid "
	2457	"mapping\n");
	2458	goto done;
	2459	}
	2460	break;
	2461	case OPT_REMOVE_GID_MAPPING:
	2462	if (!parse_mapping_arg(string_arg, &int_subarg,
	2463	&string_subarg) \|\|
	2464	!wbinfo_remove_gid_mapping(int_subarg,
	2465	string_subarg))
	2466	{
	2467	d_fprintf(stderr, "Could not remove gid to sid "
	2468	"mapping\n");
	2469	goto done;
	2470	}
	2471	break;
	2472	case OPT_SIDS_TO_XIDS:
	2473	if (!wbinfo_sids_to_unix_ids(string_arg)) {
	2474	d_fprintf(stderr, "wbinfo_sids_to_unix_ids "
	2475	"failed\n");
	2476	goto done;
	2477	}
	2478	break;
	2479	case 't':
	2480	if (!wbinfo_check_secret(opt_domain_name)) {
	2481	d_fprintf(stderr, "Could not check secret\n");
	2482	goto done;
	2483	}
	2484	break;
	2485	case 'c':
	2486	if (!wbinfo_change_secret(opt_domain_name)) {
	2487	d_fprintf(stderr, "Could not change secret\n");
	2488	goto done;
	2489	}
	2490	break;
	2491	case 'P':
[988]	2492	if (!wbinfo_ping_dc(opt_domain_name)) {
[860]	2493	goto done;
	2494	}
	2495	break;
	2496	case 'm':
	2497	if (!wbinfo_list_domains(false, verbose)) {
	2498	d_fprintf(stderr,
	2499	"Could not list trusted domains\n");
	2500	goto done;
	2501	}
	2502	break;
	2503	case OPT_SEQUENCE:
	2504	if (!wbinfo_show_sequence(opt_domain_name)) {
	2505	d_fprintf(stderr,
	2506	"Could not show sequence numbers\n");
	2507	goto done;
	2508	}
	2509	break;
	2510	case OPT_ONLINESTATUS:
	2511	if (!wbinfo_show_onlinestatus(opt_domain_name)) {
	2512	d_fprintf(stderr,
	2513	"Could not show online-status\n");
	2514	goto done;
	2515	}
	2516	break;
	2517	case 'D':
	2518	if (!wbinfo_domain_info(string_arg)) {
	2519	d_fprintf(stderr,
	2520	"Could not get domain info\n");
	2521	goto done;
	2522	}
	2523	break;
	2524	case 'i':
	2525	if (!wbinfo_get_userinfo(string_arg)) {
	2526	d_fprintf(stderr,
	2527	"Could not get info for user %s\n",
	2528	string_arg);
	2529	goto done;
	2530	}
	2531	break;
	2532	case OPT_USER_SIDINFO:
	2533	if ( !wbinfo_get_user_sidinfo(string_arg)) {
	2534	d_fprintf(stderr,
	2535	"Could not get info for user "
	2536	"sid %s\n", string_arg);
	2537	goto done;
	2538	}
	2539	break;
	2540	case OPT_UID_INFO:
	2541	if ( !wbinfo_get_uidinfo(int_arg)) {
	2542	d_fprintf(stderr, "Could not get info for uid "
	2543	"%d\n", int_arg);
	2544	goto done;
	2545	}
	2546	break;
	2547	case OPT_GROUP_INFO:
	2548	if ( !wbinfo_get_groupinfo(string_arg)) {
	2549	d_fprintf(stderr, "Could not get info for "
	2550	"group %s\n", string_arg);
	2551	goto done;
	2552	}
	2553	break;
	2554	case OPT_GID_INFO:
	2555	if ( !wbinfo_get_gidinfo(int_arg)) {
	2556	d_fprintf(stderr, "Could not get info for gid "
	2557	"%d\n", int_arg);
	2558	goto done;
	2559	}
	2560	break;
	2561	case 'r':
	2562	if (!wbinfo_get_usergroups(string_arg)) {
	2563	d_fprintf(stderr,
	2564	"Could not get groups for user %s\n",
	2565	string_arg);
	2566	goto done;
	2567	}
	2568	break;
	2569	case OPT_USERSIDS:
	2570	if (!wbinfo_get_usersids(string_arg)) {
	2571	d_fprintf(stderr, "Could not get group SIDs "
	2572	"for user SID %s\n",
	2573	string_arg);
	2574	goto done;
	2575	}
	2576	break;
	2577	case OPT_USERDOMGROUPS:
	2578	if (!wbinfo_get_userdomgroups(string_arg)) {
	2579	d_fprintf(stderr, "Could not get user's domain "
	2580	"groups for user SID %s\n",
	2581	string_arg);
	2582	goto done;
	2583	}
	2584	break;
	2585	case OPT_SIDALIASES:
	2586	if (!wbinfo_get_sidaliases(opt_domain_name,
	2587	string_arg)) {
	2588	d_fprintf(stderr, "Could not get sid aliases "
	2589	"for user SID %s\n", string_arg);
	2590	goto done;
	2591	}
	2592	break;
	2593	case 'a': {
	2594	bool got_error = false;
	2595
	2596	if (!wbinfo_auth(string_arg)) {
	2597	d_fprintf(stderr,
	2598	"Could not authenticate user "
	2599	"%s with plaintext "
	2600	"password\n", string_arg);
	2601	got_error = true;
	2602	}
	2603
	2604	if (!wbinfo_auth_crap(string_arg, use_ntlmv2,
	2605	use_lanman)) {
	2606	d_fprintf(stderr,
	2607	"Could not authenticate user "
	2608	"%s with challenge/response\n",
	2609	string_arg);
	2610	got_error = true;
	2611	}
	2612
	2613	if (got_error)
	2614	goto done;
	2615	break;
	2616	}
	2617	case OPT_PAM_LOGON:
[988]	2618	if (!wbinfo_pam_logon(string_arg, verbose)) {
[860]	2619	d_fprintf(stderr, "pam_logon failed for %s\n",
	2620	string_arg);
	2621	goto done;
	2622	}
	2623	break;
	2624	case OPT_LOGOFF:
	2625	{
	2626	wbcErr wbc_status;
	2627
	2628	wbc_status = wbcLogoffUser(logoff_user, logoff_uid,
	2629	"");
	2630	d_printf("Logoff %s (%d): %s\n", logoff_user,
	2631	logoff_uid, wbcErrorString(wbc_status));
	2632	break;
	2633	}
	2634	case 'K': {
	2635	uint32_t flags = WBFLAG_PAM_KRB5 \|
	2636	WBFLAG_PAM_CACHED_LOGIN \|
	2637	WBFLAG_PAM_FALLBACK_AFTER_KRB5 \|
	2638	WBFLAG_PAM_INFO3_TEXT \|
	2639	WBFLAG_PAM_CONTACT_TRUSTDOM;
	2640
[988]	2641	if (!wbinfo_auth_krb5(string_arg, opt_krb5ccname,
[860]	2642	flags)) {
	2643	d_fprintf(stderr,
	2644	"Could not authenticate user "
	2645	"[%s] with Kerberos "
	2646	"(ccache: %s)\n", string_arg,
[988]	2647	opt_krb5ccname);
[860]	2648	goto done;
	2649	}
	2650	break;
	2651	}
	2652	case 'k':
	2653	if (!wbinfo_klog(string_arg)) {
	2654	d_fprintf(stderr, "Could not klog user\n");
	2655	goto done;
	2656	}
	2657	break;
	2658	case 'p':
	2659	if (!wbinfo_ping()) {
	2660	d_fprintf(stderr, "could not ping winbindd!\n");
	2661	goto done;
	2662	}
	2663	break;
	2664	case OPT_SET_AUTH_USER:
	2665	if (!wbinfo_set_auth_user(string_arg)) {
	2666	goto done;
	2667	}
	2668	break;
	2669	case OPT_GET_AUTH_USER:
	2670	wbinfo_get_auth_user();
	2671	goto done;
	2672	break;
	2673	case OPT_CCACHE_SAVE:
	2674	if (!wbinfo_ccache_save(string_arg)) {
	2675	goto done;
	2676	}
	2677	break;
	2678	case OPT_GETDCNAME:
	2679	if (!wbinfo_getdcname(string_arg)) {
	2680	goto done;
	2681	}
	2682	break;
	2683	case OPT_DSGETDCNAME:
	2684	if (!wbinfo_dsgetdcname(string_arg, 0)) {
	2685	goto done;
	2686	}
	2687	break;
	2688	case OPT_DC_INFO:
	2689	if (!wbinfo_dc_info(string_arg)) {
	2690	goto done;
	2691	}
	2692	break;
	2693	case OPT_SEPARATOR: {
	2694	const char sep = winbind_separator();
	2695	if ( !sep ) {
	2696	goto done;
	2697	}
	2698	d_printf("%c\n", sep);
	2699	break;
	2700	}
	2701	case OPT_LIST_ALL_DOMAINS:
	2702	if (!wbinfo_list_domains(true, verbose)) {
	2703	goto done;
	2704	}
	2705	break;
	2706	case OPT_LIST_OWN_DOMAIN:
	2707	if (!wbinfo_list_own_domain()) {
	2708	goto done;
	2709	}
	2710	break;
	2711	case OPT_CHANGE_USER_PASSWORD:
	2712	if (!wbinfo_change_user_password(string_arg)) {
	2713	d_fprintf(stderr,
	2714	"Could not change user password "
	2715	"for user %s\n", string_arg);
	2716	goto done;
	2717	}
	2718	break;
	2719
	2720	/* generic configuration options */
	2721	case OPT_DOMAIN_NAME:
	2722	case OPT_VERBOSE:
	2723	case OPT_NTLMV2:
	2724	case OPT_LANMAN:
	2725	case OPT_LOGOFF_USER:
	2726	case OPT_LOGOFF_UID:
[988]	2727	case OPT_KRB5CCNAME:
[860]	2728	break;
	2729	default:
	2730	d_fprintf(stderr, "Invalid option\n");
	2731	poptPrintHelp(pc, stderr, 0);
	2732	goto done;
	2733	}
	2734	}
	2735
	2736	result = 0;
	2737
	2738	/* Exit code */
	2739
	2740	done:
	2741	talloc_free(frame);
	2742
	2743	poptFreeContext(pc);
	2744	return result;
	2745	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: vendor/current/nsswitch/wbinfo.c

Download in other formats: