xref: /onnv-gate/usr/src/cmd/scadm/sparc/mpxu/common/user.c (revision 1708:ea74d8598a3a)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * user.c: support for the scadm useradd, userdel, usershow, userpassword,
 * userperm options (administration of service processor users)
 */

#include <libintl.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <termios.h>
#include <time.h>  /* required by librsc.h */

#include "librsc.h"
#include "adm.h"


static void ADM_Get_Password(char  *password);
static void ADM_Destroy_Password(char  *password);
static void max_username();
static void malformed_username();
static void wrong_response();
static void no_user();
static void no_info();
static void userperm_usage();
static void show_header();
static void cleanup();


/* Globals so that exit routine can clean up echo */
static int		echoOff = 0;
static struct termios	oldOpts;

typedef union {
	char	DataBuffer[DP_MAX_MSGLEN];
	void	*DataBuffer_p;
} data_buffer_t;


void
ADM_Process_useradd(int argc, char *argv[])
{
	static data_buffer_t	dataBuffer;
	rscp_msg_t		Message;
	struct timespec		Timeout;
	dp_user_adm_t		*admMessage;
	dp_user_adm_r_t		*admResponse;
	char			*userName;


	if (argc != 3) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("USAGE: scadm useradd <username>"));
		exit(-1);
	}

	ADM_Start();

	if (strlen(argv[2]) > DP_USER_NAME_SIZE) {
		max_username();
		exit(-1);
	}

	admMessage = (dp_user_adm_t *)&dataBuffer;
	userName   = (char *)(&((char *)admMessage)[sizeof (dp_user_adm_t)]);
	admMessage->command = DP_USER_CMD_ADD;
	(void) strcpy(userName, argv[2]);

	Message.type = DP_USER_ADM;
	Message.len  = sizeof (dp_user_adm_t) + strlen(userName) + 1;
	Message.data = admMessage;
	ADM_Send(&Message);

	Timeout.tv_nsec = 0;
	Timeout.tv_sec  = ADM_SEPROM_TIMEOUT;
	ADM_Recv(&Message, &Timeout, DP_USER_ADM_R, sizeof (dp_user_adm_r_t));

	admResponse = (dp_user_adm_r_t *)Message.data;
	if (admResponse->command != DP_USER_CMD_ADD) {
		wrong_response();
		exit(-1);
	}

	if (admResponse->status == DP_ERR_USER_FULL) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: all user slots are full"));
		exit(-1);
	} else if (admResponse->status == DP_ERR_USER_THERE) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: user already exists"));
		exit(-1);
	} else if (admResponse->status == DP_ERR_USER_WARNING) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: username did not start with letter\n"
		    "        or did not contain lower case letter\n"));
		exit(-1);
	} else if (admResponse->status == DP_ERR_USER_BAD) {
		malformed_username();
		exit(-1);
	} else if (admResponse->status != 0) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: couldn't add user"));
		exit(-1);
	}

	ADM_Free(&Message);
}


void
ADM_Process_userdel(int argc, char *argv[])
{
	static data_buffer_t	dataBuffer;
	rscp_msg_t		Message;
	struct timespec		Timeout;
	dp_user_adm_t		*admMessage;
	dp_user_adm_r_t		*admResponse;
	char			*userName;


	if (argc != 3) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("USAGE: scadm userdel <username>"));
		exit(-1);
	}

	ADM_Start();

	if (strlen(argv[2]) > DP_USER_NAME_SIZE) {
		max_username();
		exit(-1);
	}

	admMessage = (dp_user_adm_t *)&dataBuffer;
	userName   = (char *)(&((char *)admMessage)[sizeof (dp_user_adm_t)]);
	admMessage->command = DP_USER_CMD_DEL;
	(void) strcpy(userName, argv[2]);

	Message.type = DP_USER_ADM;
	Message.len  = sizeof (dp_user_adm_t) + strlen(userName) + 1;
	Message.data = admMessage;
	ADM_Send(&Message);

	Timeout.tv_nsec = 0;
	Timeout.tv_sec  = ADM_SEPROM_TIMEOUT;
	ADM_Recv(&Message, &Timeout, DP_USER_ADM_R, sizeof (dp_user_adm_r_t));

	admResponse = (dp_user_adm_r_t *)Message.data;
	if (admResponse->command != DP_USER_CMD_DEL) {
		wrong_response();
		exit(-1);
	}

	if (admResponse->status == DP_ERR_USER_NONE) {
		no_user();
		exit(-1);
	} else if (admResponse->status == DP_ERR_USER_BAD) {
		malformed_username();
		exit(-1);
	} else if (admResponse->status != 0) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: couldn't delete user"));
		exit(-1);
	}

	ADM_Free(&Message);
}


void
ADM_Process_usershow(int argc, char *argv[])
{
	static data_buffer_t	dataBuffer;
	rscp_msg_t		Message;
	struct timespec		Timeout;
	dp_user_adm_t		*admMessage;
	dp_user_adm_r_t		*admResponse;
	char			*userName;
	char			*permissions;
	char			*passwd;
	int			index;



	if ((argc != 2) && (argc != 3)) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("USAGE: scadm usershow [username]"));
		exit(-1);
	}

	ADM_Start();

	if (argc == 3) {
		admMessage = (dp_user_adm_t *)&dataBuffer;
		admMessage->command = DP_USER_CMD_SHOW;
		Message.type = DP_USER_ADM;
		Message.data = admMessage;

		if (strlen(argv[2]) > DP_USER_NAME_SIZE) {
			max_username();
			exit(-1);
		}
		userName = (char *)(&((char *)admMessage)[
		    sizeof (dp_user_adm_t)]);
		(void) strcpy(userName, argv[2]);
		admMessage->parm = DP_USER_SHOW_USERNAME;
		Message.len = sizeof (dp_user_adm_t) + strlen(userName) + 1;
		ADM_Send(&Message);

		Timeout.tv_nsec = 0;
		Timeout.tv_sec  = ADM_SEPROM_TIMEOUT;
		ADM_Recv(&Message, &Timeout,
		    DP_USER_ADM_R, sizeof (dp_user_adm_r_t));

		admResponse = (dp_user_adm_r_t *)Message.data;
		if (admResponse->command != DP_USER_CMD_SHOW) {
			wrong_response();
			exit(-1);
		}

		if (admResponse->status == DP_ERR_USER_NONE) {
			no_user();
			exit(-1);
		} else if (admResponse->status == DP_ERR_USER_BAD) {
			malformed_username();
			exit(-1);
		} else if (admResponse->status != 0) {
			no_info();
			exit(-1);
		}

		userName = &(((char *)admResponse)[
		    sizeof (dp_user_adm_r_t)]);
		permissions = &userName[strlen(userName)+1];
		passwd = &permissions[strlen(permissions)+1];
		show_header();
		(void) printf(" %-16s    %-15s    ", userName, permissions);
		if (strncmp(passwd, "Assigned", 12) == 0) {
			(void) printf("%s\n\n", gettext("Assigned"));
		} else if (strncmp(passwd, "None", 12) == 0) {
			(void) printf("%s\n\n", gettext("None"));
		} else {
			(void) printf("%-12s\n\n", passwd);
		}
		ADM_Free(&Message);
	} else {
		show_header();
		for (index = 1; index <= DP_USER_MAX; index++) {
			admMessage = (dp_user_adm_t *)&dataBuffer;
			admMessage->command = DP_USER_CMD_SHOW;
			admMessage->parm    = index;

			Message.type = DP_USER_ADM;
			Message.data = admMessage;
			Message.len  = sizeof (dp_user_adm_t);
			ADM_Send(&Message);

			Timeout.tv_nsec = 0;
			Timeout.tv_sec  = ADM_SEPROM_TIMEOUT;
			ADM_Recv(&Message, &Timeout,
			    DP_USER_ADM_R, sizeof (dp_user_adm_r_t));

			admResponse = (dp_user_adm_r_t *)Message.data;
			if (admResponse->command != DP_USER_CMD_SHOW) {
				wrong_response();
				exit(-1);
			}

			if (admResponse->status == DP_ERR_USER_NONE) {
				ADM_Free(&Message);
				continue;
			} else if (admResponse->status == DP_ERR_USER_BAD) {
				malformed_username();
				exit(-1);
			} else if (admResponse->status != 0) {
				no_info();
				exit(-1);
			}

			userName = &(((char *)admResponse)[
			    sizeof (dp_user_adm_r_t)]);
			permissions = &userName[strlen(userName)+1];
			passwd = &permissions[strlen(permissions)+1];
			(void) printf(" %-16s    %-15s    ",
			    userName, permissions);
			if (strncmp(passwd, "Assigned", 12) == 0) {
				(void) printf("%s\n", gettext("Assigned"));
			} else if (strncmp(passwd, "None", 12) == 0) {
				(void) printf("%s\n", gettext("None"));
			} else {
				(void) printf("%-12s\n", passwd);
			}

			ADM_Free(&Message);
		}
		(void) printf("\n");
	}
}


void
ADM_Process_userpassword(int argc, char *argv[])
{
	static data_buffer_t	dataBuffer;
	rscp_msg_t		Message;
	struct timespec		Timeout;
	dp_user_adm_t		*admMessage;
	dp_user_adm_r_t		*admResponse;
	char			*userName;
	char			*password;
	int			passTry;


	/* Try to set password up to 3 times on Malformed password */
	passTry = 3;

	if (argc != 3) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("USAGE: scadm userpassword <username>"));
		exit(-1);
	}

	ADM_Start();

	if (strlen(argv[2]) > DP_USER_NAME_SIZE) {
		max_username();
		exit(-1);
	}

	admMessage = (dp_user_adm_t *)&dataBuffer;
	admMessage->command = DP_USER_CMD_PASSWORD;
	userName = (&((char *)admMessage)[sizeof (dp_user_adm_t)]);
	(void) strcpy(userName, argv[2]);
	password = (&((char *)admMessage)[sizeof (dp_user_adm_t) +
	    strlen(userName) + 1]);

	for (;;) {
		ADM_Get_Password(password);

		Message.type = DP_USER_ADM;
		Message.len  = sizeof (dp_user_adm_t) + strlen(userName) +
		    strlen(password) + 2;
		Message.data = admMessage;
		ADM_Send(&Message);

		ADM_Destroy_Password(password);
		Timeout.tv_nsec = 0;
		Timeout.tv_sec  = ADM_SEPROM_TIMEOUT;
		ADM_Recv(&Message, &Timeout,
		    DP_USER_ADM_R, sizeof (dp_user_adm_r_t));

		admResponse = (dp_user_adm_r_t *)Message.data;
		if (admResponse->command != DP_USER_CMD_PASSWORD) {
			wrong_response();
			exit(-1);
		}

		if (admResponse->status == DP_ERR_USER_NONE) {
			no_user();
			exit(-1);
		} else if (admResponse->status == DP_ERR_USER_BAD) {
			malformed_username();
			exit(-1);
		} else if (admResponse->status == DP_ERR_USER_PASSWD) {
			(void) fprintf(stderr, "\n%s\n\n",
			    gettext("scadm: malformed password\n"
			    "        A valid password is between 6 and 8 "
			    "characters,\n"
			    "        has at least two alphabetic characters, "
			    "and at\n"
			    "        least one numeric or special character. "
			    "The\n"
			    "        password must differ from the user's "
			    "login name\n"
			    "        and any reverse or circular shift of that "
			    "login\n"
			    "        name.\n"));
			passTry--;
			if (passTry > 0) {
				ADM_Free(&Message);
				continue;
			} else
				exit(-1);
		} else if (admResponse->status != 0) {
			(void) fprintf(stderr, "\n%s\n\n",
			    gettext("scadm: couldn't change password"));
			exit(-1);
		}

		/* password was changed successfully, get out of while */
		break;
	}

	ADM_Free(&Message);
}


void
ADM_Process_userperm(int argc, char *argv[])
{
	static data_buffer_t	dataBuffer;
	rscp_msg_t		Message;
	struct timespec		Timeout;
	dp_user_adm_t		*admMessage;
	dp_user_adm_r_t		*admResponse;
	char			*userName;
	int			permissions;
	int			index;


	if ((argc != 3) && (argc != 4)) {
		userperm_usage();
		exit(-1);
	}

	if (argc == 3) {
		permissions = 0;
	} else {
		if ((strlen(argv[3]) > 4) || (strlen(argv[3]) < 1)) {
			userperm_usage();
			exit(-1);
		}

		permissions = 0;
		for (index = 0; index < strlen(argv[3]); index++) {
			if ((argv[3][index] != 'c') &&
			    (argv[3][index] != 'C') &&
			    (argv[3][index] != 'u') &&
			    (argv[3][index] != 'U') &&
			    (argv[3][index] != 'a') &&
			    (argv[3][index] != 'A') &&
			    (argv[3][index] != 'r') &&
			    (argv[3][index] != 'R')) {
				userperm_usage();
				exit(-1);
			}

			if ((argv[3][index] == 'c') ||
			    (argv[3][index] == 'C')) {
				/* See if this field was entered twice */
				if ((permissions & DP_USER_PERM_C) != 0) {
					userperm_usage();
					exit(-1);
				}
				permissions = permissions | DP_USER_PERM_C;
			}

			if ((argv[3][index] == 'u') ||
			    (argv[3][index] == 'U')) {
				/* See if this field was enetered twice */
				if ((permissions & DP_USER_PERM_U) != 0) {
					userperm_usage();
					exit(-1);
				}
				permissions = permissions | DP_USER_PERM_U;
			}

			if ((argv[3][index] == 'a') ||
			    (argv[3][index] == 'A')) {
				/* See if this field was enetered twice */
				if ((permissions & DP_USER_PERM_A) != 0) {
					userperm_usage();
					exit(-1);
				}
				permissions = permissions | DP_USER_PERM_A;
			}

			if ((argv[3][index] == 'r') ||
			    (argv[3][index] == 'R')) {
				/* See if this field was enetered twice */
				if ((permissions & DP_USER_PERM_R) != 0) {
					userperm_usage();
					exit(-1);
				}
				permissions = permissions | DP_USER_PERM_R;
			}
		}
	}

	ADM_Start();

	if (strlen(argv[2]) > DP_USER_NAME_SIZE) {
		max_username();
		exit(-1);
	}

	admMessage = (dp_user_adm_t *)&dataBuffer;
	admMessage->command = DP_USER_CMD_PERM;
	admMessage->parm    = permissions;
	userName   = (char *)(&((char *)admMessage)[sizeof (dp_user_adm_t)]);
	(void) strcpy(userName, argv[2]);

	Message.type = DP_USER_ADM;
	Message.len  = sizeof (dp_user_adm_t) + strlen(userName) + 1;
	Message.data = admMessage;
	ADM_Send(&Message);

	Timeout.tv_nsec = 0;
	Timeout.tv_sec  = ADM_SEPROM_TIMEOUT;
	ADM_Recv(&Message, &Timeout, DP_USER_ADM_R, sizeof (dp_user_adm_r_t));

	admResponse = (dp_user_adm_r_t *)Message.data;
	if (admResponse->command != DP_USER_CMD_PERM) {
		wrong_response();
		exit(-1);
	}

	if (admResponse->status == DP_ERR_USER_NONE) {
		no_user();
		exit(-1);
	} else if (admResponse->status == DP_ERR_USER_BAD) {
		malformed_username();
		exit(-1);
	} else if (admResponse->status != 0) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: couldn't change permissions"));
		exit(-1);
	}

	ADM_Free(&Message);
}


static void
ADM_Get_Password(char *password)
{
	static char		pass1[64];
	static char		pass2[64];
	static struct termios	newOpts;
	int			passTry;
	int			validPass;


	validPass = 0;
	passTry   = 3;

	if (signal(SIGINT, cleanup) == SIG_ERR) {
		(void) fprintf(stderr, "\n%s\n\n",
		    gettext("scadm: cleanup() registration failed"));
		exit(-1);
	}

	echoOff = 1;
	(void) tcgetattr(0, &oldOpts);
	newOpts = oldOpts;
	newOpts.c_lflag &= ~ECHO;
	(void) tcsetattr(0, TCSANOW, &newOpts);

	while ((passTry > 0) && (validPass == 0)) {
		passTry = passTry - 1;
		(void) printf("%s", gettext("Password: "));
		(void) scanf("%s", pass1);
		(void) printf("\n");
		(void) fflush(stdin);
		(void) printf("%s", gettext("Re-enter Password: "));
		(void) scanf("%s", pass2);
		(void) printf("\n");

		/* Truncate at 8 characters  */
		pass1[8] = pass2[8] = '\0';

		if ((strcmp(pass1, pass2) != 0) && (passTry > 0)) {
			ADM_Destroy_Password(pass1);
			ADM_Destroy_Password(pass2);
			(void) fprintf(stderr, "%s\n\n",
			    gettext("Passwords didn't match, try again"));
		} else if ((strcmp(pass1, pass2) != 0) && (passTry <= 0)) {
			ADM_Destroy_Password(pass1);
			ADM_Destroy_Password(pass2);
			(void) fprintf(stderr, "\n%s\n\n",
			    gettext("scadm: ERROR, passwords didn't match"));
			(void) tcsetattr(0, TCSANOW, &oldOpts);
			exit(-1);
		} else {
			validPass = 1;
		}
	}

	(void) tcsetattr(0, TCSANOW, &oldOpts);
	echoOff = 0;
	(void) strcpy(password, pass1);
	ADM_Destroy_Password(pass1);
	ADM_Destroy_Password(pass2);
}


static void
cleanup()
{
	if (echoOff)
		(void) tcsetattr(0, TCSANOW, &oldOpts);

	exit(-1);
}


static void
ADM_Destroy_Password(char *password)
{
	int index;

	for (index = 0; index < strlen(password); index++)
		password[index] = 0x1;
}


static void
max_username()
{
	(void) fprintf(stderr,
	    gettext("\nscadm: maximum username length is %d\n\n"),
	    DP_USER_NAME_SIZE);
}


static void
malformed_username()
{
	(void) fprintf(stderr,
	    "\n%s\n\n", gettext("scadm: malformed username"));
}


static void
wrong_response()
{
	(void) fprintf(stderr, "\n%s\n\n",
	    gettext("scadm: SC returned wrong response"));
}


static void
no_user()
{
	(void) fprintf(stderr,
	    "\n%s\n\n", gettext("scadm: username does not exist"));
}


static void
no_info()
{
	(void) fprintf(stderr, "\n%s\n\n",
	    gettext("scadm: couldn't get information on user"));
}


static void
userperm_usage()
{
	(void) fprintf(stderr, "\n%s\n\n",
	    gettext("USAGE: scadm userperm <username> [cuar]"));
}


static void
show_header()
{
	int i;
	int usernLen = strlen(gettext("username"));
	int permLen = strlen(gettext("permissions"));
	int pwdLen = strlen(gettext("password"));

	(void) printf("\n");
	(void) putchar(' ');
	(void) printf("%s", gettext("username"));
	for (i = 0; i < (20 - usernLen); i++)
		(void) putchar(' ');

	(void) printf("%s", gettext("permissions"));
	for (i = 0; i < (19 - permLen); i++)
		(void) putchar(' ');

	(void) printf("%s\n", gettext("password"));

	(void) putchar(' ');
	for (i = 0; i < usernLen; i++)
		(void) putchar('-');
	for (; i < 20; i++)
		(void) putchar(' ');

	for (i = 0; i < permLen; i++)
		(void) putchar('-');
	for (; i < 19; i++)
		(void) putchar(' ');

	for (i = 0; i < pwdLen; i++)
		(void) putchar('-');
	(void) printf("\n");
}