/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * rmf_main.c :
 *	The file containing main() for rmformat. The command line
 *	options are parsed in this file.
 */


#include <priv.h>
#include "rmformat.h"

int32_t b_flag = 0;
int32_t c_flag = 0;
int32_t D_flag = 0;
int32_t e_flag = 0;
int32_t F_flag = 0;
int32_t H_flag = 0;
int32_t l_flag = 0;
int32_t p_flag = 0;
int32_t R_flag = 0;
int32_t s_flag = 0;
int32_t U_flag = 0;
int32_t V_flag = 0;
int32_t W_flag = 0;
int32_t w_flag = 0;

static char *myname;
char *slice_file = NULL;
char *label;
uint32_t repair_blk_no;
int32_t quick_format = 0;
int32_t long_format = 0;
int32_t force_format = 0;
int32_t rw_protect_enable = 0;
int32_t rw_protect_disable = 0;
int32_t wp_enable_passwd = 0;
int32_t wp_disable_passwd = 0;
int32_t wp_enable = 0;
int32_t wp_disable = 0;
int32_t verify_write = 0;
char *dev_name = NULL;

static void usage(char *);
void check_invalid_combinations();
void check_invalid_combinations_again(int32_t);
extern int64_t my_atoll(char *ptr);
extern void my_perror(char *err_string);
void process_options();


main(int32_t argc, char **argv)
{
	char i;
	char *tmp_ptr;

	/*
	 * This program requires file_dac_read, file_dac_write,
	 * proc_fork, and proc_exec privileges
	 *
	 * child processes require the sys_mount privilege
	 */
	(void) priv_set(PRIV_SET, PRIV_LIMIT, PRIV_FILE_DAC_READ,
	    PRIV_FILE_DAC_WRITE, PRIV_PROC_FORK, PRIV_PROC_EXEC,
	    PRIV_SYS_MOUNT, (char *)NULL);

	/* Turn privileges off until needed */
	(void) priv_set(PRIV_OFF, PRIV_EFFECTIVE, PRIV_FILE_DAC_READ,
	    PRIV_FILE_DAC_WRITE, PRIV_PROC_FORK, PRIV_PROC_EXEC,
	    PRIV_SYS_MOUNT, (char *)NULL);

	/* Become who we really are */
	if (seteuid(getuid()) < 0) {
		PERROR("Can't set effective user id");
		exit(1);
	}
	if (setegid(getgid()) < 0) {
		PERROR("Can't set effective group id");
		exit(1);
	}

	(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN	"SYS_TEST"
#endif

	(void) textdomain(TEXT_DOMAIN);

	myname = argv[0];
	DPRINTF1("myname %s\n", myname);

	while ((i = getopt(argc, argv, "b:c:DeF:HlpR:s:tUV:W:w:"))
							!= -1) {
		DPRINTF1("arg %c\n", i);
		switch (i) {
		case 'b' :
			b_flag++;
			label = strdup(optarg);
			if (strlen(label) > 8) {
				(void) fprintf(stderr, gettext("Label is \
restricted to 8 characters.\n"));
				exit(1);
			}

			break;

		case 'c' :
			c_flag++;
			tmp_ptr = strdup(optarg);
			errno = 0;
			repair_blk_no = (uint32_t)my_atoll(tmp_ptr);
			if (repair_blk_no == (uint32_t)(-1)) {
				free(tmp_ptr);
				usage("invalid block number");
			}

			DPRINTF1(" block no. %x\n", repair_blk_no);
			free(tmp_ptr);
			break;

		case 'D' :
			D_flag++;
			break;

		case 'e' :
			e_flag++;
			break;

		case 'F' :
			F_flag++;
			tmp_ptr = strdup(optarg);
			if (strcmp(tmp_ptr, "quick") == 0) {
				DPRINTF("q");
				quick_format = 1;
			} else if (strcmp(tmp_ptr, "long") == 0) {
				DPRINTF("l");
				long_format = 1;
			} else if (strcmp(tmp_ptr, "force") == 0) {
				DPRINTF("f");
				force_format = 1;
			} else {
				free(tmp_ptr);
				usage("invalid argument for option -F");
			}
			free(tmp_ptr);
			break;

		case 'H' :
			H_flag++;
			break;

		case 'l' :
			l_flag++;
			break;

		case 'p' :
			p_flag++;
			break;

		case 'R' :
			R_flag++;
			tmp_ptr = strdup(optarg);
			if (strcmp(tmp_ptr, "enable") == 0) {
				rw_protect_enable++;
			} else if (strcmp(tmp_ptr, "disable") == 0) {
				rw_protect_disable++;
			} else {
				usage("Invalid argument for -R option");
			}
			free(tmp_ptr);
			break;

		case 's' :
			s_flag++;

			slice_file = strdup(optarg);
			break;

		case 'U' :
			U_flag++;
			break;

		case 'V' :
			V_flag++;
			tmp_ptr = strdup(optarg);
			if (strcmp(tmp_ptr, "read") == 0) {
				verify_write = 0;
			} else if (strcmp(tmp_ptr, "write") == 0) {
				verify_write = 1;
			} else {
				usage("Invalid argument for -V option");
			}
			free(tmp_ptr);
			break;

		case 'W' :
			W_flag++;
			tmp_ptr = strdup(optarg);
			if (strcmp(tmp_ptr, "enable") == 0) {
				wp_enable_passwd++;
			} else if (strcmp(tmp_ptr, "disable") == 0) {
				wp_disable_passwd++;
			} else {
				usage("Invalid argument for -W option");
			}
			free(tmp_ptr);
			break;

		case 'w' :
			w_flag++;
			tmp_ptr = strdup(optarg);
			if (strcmp(tmp_ptr, "enable") == 0) {
				wp_enable++;
			} else if (strcmp(tmp_ptr, "disable") == 0) {
				wp_disable++;
			} else {
				usage("Invalid arguments for -w option");
			}
			free(tmp_ptr);
			break;

		default:
			usage("");
			break;
		}
	}
	if (optind < argc -1) {
		usage("more than one device name argument");
		/* NOTREACHED */
	}

	if (optind == argc -1) {
		dev_name = argv[optind];
	} else if (optind == 1) {
		/* list devices by default */
		l_flag++;
	} else if ((optind == argc) && !l_flag) {
		(void) fprintf(stderr,
		    gettext("No device specified.\n"));
		exit(1);
#if 0
		(void) printf("Using floppy device\n");
		dev_name = "/dev/rdiskette";
#endif /* 0 */
	}

	process_options();
	return (0);
}

static void
usage(char *str)
{

	if (strlen(str)) {
		(void) fprintf(stderr, "%s : ", myname);
		(void) fprintf(stderr, gettext(str));
		(void) fprintf(stderr, "\n");
	}

	(void) fprintf(stderr, "Usage:\n");
	(void) fprintf(stderr, gettext("\t%s \
[ -DeHpU ] [ -b label ] [ -c blockno ] [ -F quick|long|force ] \
[ -R enable|disable ] [ -s filename ] [ -V read|write ] \
[ -w enable|disable ] [ -W enable|disable ] devname \n"), myname);
	(void) fprintf(stderr, gettext("\t%s -l [ devname ]\n"),
	    myname);
	exit(1);
}

void
check_invalid_combinations()
{

	/* Inherited from FLOPPY */

	if (D_flag && H_flag) {
		usage("Options -D and -H incompatible");
	}

	if (D_flag && F_flag) {
		usage("Options -D and -F incompatible");
	}

	if (H_flag && F_flag) {
		usage("Options -H and -F incompatible");
	}

	/* rmformat additions */

	if ((w_flag && W_flag) || (w_flag && R_flag) || (W_flag && R_flag)) {
		usage("Options -w, -W and -R incompatible");
	}

	if (c_flag && F_flag) {
		usage("Options -c, -F incompatible");
	}

	/* l_flag is mutually exclusive of these flags */
	if (l_flag && (D_flag + e_flag + H_flag + p_flag + U_flag +
	    b_flag + c_flag + F_flag + R_flag + s_flag + V_flag +
	    w_flag + W_flag)) {
		usage("Options incompatible");
	}
}


void
check_invalid_combinations_again(int32_t medium_type)
{
	if ((medium_type != SM_FLOPPY) &&
			(medium_type != SM_PCMCIA_MEM)) {
		if (D_flag || H_flag) {
			usage("-D, -H  options are compatible with floppy and \
PCMCIA memory cards only.");
		}
	}
}