/*
 * Copyright (c) 1992-1998 Michael A. Cooper.
 * This software may be freely used and distributed provided it is not
 * sold for profit or used in part or in whole for commercial gain
 * without prior written agreement, and the author is credited
 * appropriately.
 */

#ifndef lint
static char *RCSid = "$Revision: 1.1.1.3 $";
#endif

/*
 * Display System Information
 */

#include <stdio.h>
#include <sys/types.h>

#include "defs.h"

/*
 * Local declarations
 */
int				Danger = FALSE;
int 				DoPrintUnknown = FALSE;
int 				DoPrintVersion = FALSE;
int 				DoPrintLicense = FALSE;
int 				MsgLevel = L_GENERAL;
char			       *FormatStr = NULL;
FormatType_t			FormatType = FT_PRETTY;
char			       *MsgClassStr = NULL;
int				MsgClassFlags = SIM_DEFAULT;
int 				UseProm = 0;
int				DebugFlag = 0;
int 				OffSetAmt = 4;
int				UseConfig = 1;
char 			       *ShowStr = NULL;
char			       *ClassNames = NULL;
char			       *TypeNames = NULL;
char 			       *MsgLevelStr = NULL;
char 			       *ListStr = NULL;
char 			       *UnSupported = NULL;
char 			       *ConfFile = NULL;
char			       *ConfDir = CONFIG_DIR;
char			       *MCLprogramName = "sysinfo";
char			      **Environ = NULL;
extern char		       *RepSep;
int 				DoNothing = TRUE;

#if	defined(OPTION_COMPAT)
int 				Terse = FALSE;
#endif	/* OPTION_COMPAT */

/*
 * Command line options table.
 */
OptionDescRec Opts[] = {
    {"-cffile",	SepArg,		OptStr, (OptPtr_t) &ConfFile,		NULL,
	 "file","Sysinfo config file"},
    {"-cfdir",	SepArg,		OptStr, (OptPtr_t) &ConfDir,		NULL,
	 "directory","Sysinfo config directory"},
    {"-class",	SepArg,		OptStr, (OptPtr_t) &ClassNames,		NULL,
	 "<see \"-list class\">",	"Class name"},
    {"-danger",NoArg,		OptBool,(OptPtr_t) &Danger,		"1",
	 NULL,	"Disable runtime platform checks" },
    {"-license",NoArg,		OptBool,(OptPtr_t) &DoPrintLicense,	"1",
	 NULL,	"Print license information" },
    {"-list",	SepArg,		OptStr, (OptPtr_t) &ListStr,		"-",
	 "<what>",	"List information about <what>"},
    {"-format",	SepArg,		OptStr, (OptPtr_t) &FormatStr,		NULL,
	 "<see \"-list format\">",	"Format Type"},
    {"-msgclass",SepArg,	OptStr, (OptPtr_t) &MsgClassStr,	NULL,
	 "<see \"-list msgclass\">", 	"Message Classes to output"},
    {"-msglevel",SepArg,	OptStr, (OptPtr_t) &MsgLevelStr,	NULL,
	 "<see \"-list msglevel\">",	"Message Levels to output"},
    {"-offset",	SepArg,		OptInt, (OptPtr_t) &OffSetAmt,		NULL,
	 "<amount>",	"Number of spaces to offset device info"},
    {"-repsep",	SepArg,		OptStr, (OptPtr_t) &RepSep,		NULL,
	 "<string>","Report field seperator"},
    {"-show",	SepArg,		OptStr, (OptPtr_t) &ShowStr,		NULL,
	 "<see \"-list show\">",	"Show names"},
    {"-type",	SepArg,		OptStr, (OptPtr_t) &TypeNames,		NULL,
	 "<see \"-list type\">",	"Type name"},
    {"+unknown",NoArg,		OptBool,(OptPtr_t) &DoPrintUnknown,	"1",
	 NULL,	"Print unknown devices"},
    {"-unknown",NoArg,		OptBool,(OptPtr_t) &DoPrintUnknown,	"0",
	 NULL,	"Don't print unknown devices"},
    {"+useconfig",NoArg,	OptBool,(OptPtr_t) &UseConfig,		"1",
	 NULL,	"Use config (-cffile,-cfdir) files"},
    {"-useconfig",NoArg,	OptBool,(OptPtr_t) &UseConfig,		"0",
	 NULL,	"Don't use config (-cffile,-cfdir) files"},
    {"+useprom",NoArg,		OptBool,(OptPtr_t) &UseProm,		"1",
	 NULL,	"Use PROM values"},
    {"-useprom",NoArg,		OptBool,(OptPtr_t) &UseProm,		"0",
	 NULL,	"Don't use PROM values"},
    {"-version",NoArg,		OptBool,(OptPtr_t) &DoPrintVersion,	"1",
	 NULL,	"Print version of this program" },
    /*
     * These options are obsolete, but are present for backwards compatibility
     * Some of the options still do things and some don't (see DoNothing).
     */
    {"-debug",ArgHidden|SepArg,	OptInt,	(OptPtr_t) &DebugFlag,		"1",
     	NULL,  "Enable debugging" },
    {"-level",ArgHidden|SepArg,	OptStr, (OptPtr_t) &MsgLevelStr,	NULL,
	 "<see \"-list msglevel\">",	"Message Levels to output"},
    {"+all", ArgHidden|NoArg,	OptBool,(OptPtr_t) &DoNothing,		"1",
	 NULL,	"Print all information"},
    {"-all", ArgHidden|NoArg,	OptBool,(OptPtr_t) &DoNothing,		"0",
	 NULL,	"Don't print all information"},
#if	defined(OPTION_COMPAT)
    /*
     * Old options from version 2.x
     * that can be enabled for backwards compatibility
     */
    {"+terse", 	NoArg,OptBool,(OptPtr_t) &Terse,"1",NULL,"Print info in terse format"},
    {"-terse", 	NoArg,OptBool,(OptPtr_t) &Terse,"0",NULL,"Don't print info in terse format"},
#endif	/* OPTION_COMPAT */
};

/*
 * Values and names of levels
 */
ListInfo_t MsgLevelNames[] = {
    { L_TERSE,		"terse",	"Values only (for parsing)" },
    { L_BRIEF,		"brief",	"Brief, but human readable" },
    { L_GENERAL,	"general",	"General info" },
    { L_DESC,		"descriptions",	"Show description info" },
    { L_CONFIG,		"config",	"Show configuration info" },
    { L_ALL,		"all",		"All information available" },
    { 0 },
};

/*
 * MsgClass options
 */
ListInfo_t MsgClassNames[] = {
    { SIM_INFO,		"info",		"Normal information" },
    { SIM_WARN,		"warn",		"Warnings" },
    { SIM_GERR,		"gerror",	"General errors" },
    { SIM_CERR,		"cerror",	"Critical errors" },
    { SIM_UNKN,		"unknown",	"Messages about unknown values" },
    { SIM_DBG,		"debug",	"Debugging information" },
    { SIM_ALL,		"all",		"All message classes" },
    { 0 },
};

/*
 * Format options
 */
ListInfo_t FormatNames[] = {
    { FT_PRETTY,	"pretty",	"Format output for humans" },
    { FT_REPORT,	"report",	"Format output for programs" },
    { 0 },
};

/*
 * List options
 */
static void			ListMsgLevel();
static void			ListFormat();
static void			ListMsgClass();
static void			ListShow();

ListInfo_t ListInfo[] = {
    { 0, "class",	"Values for `-class' option",	ClassList },
    { 0, "format",	"Values for `-format' option",	ListFormat },
    { 0, "msgclass",	"Values for `-msgclass' option",ListMsgClass },
    { 0, "msglevel",	"Values for `-msglevel' option",ListMsgLevel },
    { 0, "show",	"Values for `-show' option",	ClassCallList },
    { 0, "type",	"Values for `-type' option",	TypeList },
    { 0 },
};

/*
 * List possible values for List
 */
static void ListInfoDesc(OptStr, List)
    char		       *OptStr;
    ListInfo_t		       *List;
{
    register ListInfo_t	       *ListPtr;

    if (OptStr)
	SImsg(SIM_INFO, 
	"\nThe following values may be specified with the `%s' option:\n",
	OptStr);

    SImsg(SIM_INFO, "%-20s %s\n", "VALUE", "DESCRIPTION");

    for (ListPtr = List; ListPtr->Name; ++ListPtr)
	SImsg(SIM_INFO, "%-20s %s\n", ListPtr->Name,
	       (ListPtr->Desc) ? ListPtr->Desc : "");
}

/*
 * List Format values
 */
static void ListFormat()
{
    ListInfoDesc("-format", FormatNames);
}

/*
 * List MsgClass values
 */
static void ListMsgClass()
{
    ListInfoDesc("-msgclass", MsgClassNames);
}

/*
 * List MsgLevel values
 */
static void ListMsgLevel()
{
    ListInfoDesc("-msglevel", MsgLevelNames);
}

/*
 * List list values
 */
static void ListList()
{
    ListInfoDesc("-list", ListInfo);
}

/*
 * List information about each word found in Str.
 */
static void List(Str)
    char		       *Str;
{
    register ListInfo_t	       *ListPtr;
    char		       *Word;
    int				Found;

    if (EQ(Str, "-")) {
	ListList();
	return;
    }

    for (Word = strtok(Str, ","); Word; Word = strtok((char *)NULL, ",")) {
	for (ListPtr = ListInfo, Found = FALSE; 
	     ListPtr->Name && !Found; ++ListPtr)
	    if (EQ(Word, ListPtr->Name)) {
		Found = TRUE;
		(*ListPtr->List)();
	    }

	if (!Found) {
	    SImsg(SIM_CERR, "The word \"%s\" is invalid.", Word);
	    ListList();
	    return;
	}
    }
}

/*
 * Get argument number "arg" from "str".
 */
static char *GetArg(Str, ArgNum)
    char 		       *Str;
    int 			ArgNum;
{
    register char 	       *p, *start = NULL;
    register int 		c;

    for (c = 1, p = Str; p && *p; ++c) {
	/* set start of word */
	start = p; 

	/* skip over word */
	while (p && *p && *p != ' ' && *p != '\t' && *p != '\n')
	    ++p;

	/* is this what we want? */
	if (c == ArgNum) {
	    if (p) *p = C_NULL;
	    break;
	}

	/* skip white space */
	while (*p == ' ' || *p == '\t')
	    ++p;
    }

    return(start);
}

/*
 * Parse and set the level keyword list
 */
static int ParseMsgLevel(Str)
    char		       *Str;
{
    ListInfo_t		       *ListPtr;
    char		       *Word;
    int				Found;

    /*
     * Check each word in the MsgLevelNames table
     */
    for (Word = strtok(Str, ","); Word; Word = strtok((char *)NULL, ",")) {
	for (ListPtr = MsgLevelNames, Found = FALSE; 
	     ListPtr && ListPtr->Name && !Found; ListPtr++) {
	    if (strncasecmp(Word, ListPtr->Name, strlen(Word)) == 0) {
		MsgLevel |= ListPtr->IntKey;
		Found = TRUE;
	    }
	}
	if (!Found) {
	    SImsg(SIM_CERR, "The word \"%s\" is not a valid message level.",
		  Word);
	    return(-1);
	}
    }

    return(0);
}

/*
 * Parse and set the Message Class Flags
 */
static int ParseMsgClass(Str)
    char		       *Str;
{
    ListInfo_t		       *ListPtr;
    char		       *Word;
    int				Found;
    int				NewFlags = 0;

    /*
     * Check each word in the MsgClassNames table
     */
    for (Word = strtok(Str, ","); Word; Word = strtok((char *)NULL, ",")) {
	for (ListPtr = MsgClassNames, Found = FALSE; 
	     ListPtr && ListPtr->Name && !Found; ListPtr++) {
	    if (EQN(Word, ListPtr->Name, strlen(Word))) {
		NewFlags |= ListPtr->IntKey;
		Found = TRUE;
	    }
	}
	if (!Found) {
	    SImsg(SIM_CERR, "The word \"%s\" is not a valid MsgClass flag.",
		  Word);
	    return(-1);
	}
    }

    if (NewFlags)
	MsgClassFlags = NewFlags;

    return(0);
}

/*
 * Parse and set the format type
 */
static int ParseFormat(Str)
    char		       *Str;
{
    register ListInfo_t	       *ListPtr;
    char		       *Word;
    int				Found;

    /*
     * Check each word in the FormatNames table
     */
    for (Word = strtok(Str, ","); Word; Word = strtok((char *)NULL, ",")) {
	for (ListPtr = FormatNames, Found = FALSE; ListPtr->Name && !Found; 
	     ListPtr++) {
	    if (strncasecmp(Word, ListPtr->Name, strlen(Word)) == 0) {
		FormatType = ListPtr->IntKey;
		Found = TRUE;
	    }
	}
	if (!Found) {
	    SImsg(SIM_CERR, "The word \"%s\" is not a valid format type.", 
		  Word);
	    return(-1);
	}
    }

    return(0);
}

/*
 * Check for license.
 *
 *   	PLEASE DO NOT DISABLE.  DISABLING THIS CODE IS A VIOLATION OF 
 *	THE LICENSE.  AND IT'S NOT VERY NICE EITHER.
 */
static mcl_t *CheckMCL(Product)
     char		       *Product;
{
    static mcl_t		Query;
    static char			FileBuff[MAXPATHLEN];

    (void) snprintf(FileBuff, sizeof(FileBuff), "%s/license%s", 
		    ConfDir, MCL_FILE_EXT);
    (void) memset(&Query, 0, sizeof(Query));
    Query.File = FileBuff;
    Query.Product = Product;

    if (MCLcheck(&Query) < 0) {
	if (Query.Status == MCL_STAT_NOTFOUND)
	    SImsg(SIM_CERR|SIM_NOLBL, "\
You are running a free 60-day DEMO version of %s.  Please obtain a\n\
permanent license or cease using this program within 60 days.  Licenses\n\
may be obtained from http://www.MagniComp.com/sysinfo/#getlicense\n",
		  Product);
	SImsg(SIM_DBG, "Cannot obtain license: %s", 
	      (Query.Msg) ? Query.Msg : "UNKNOWN REASON");
	return((mcl_t *) NULL);
    }

    return(&Query);
}

#if	defined(OPTION_COMPAT)
/*
 * Set option compatibility
 */
static void SetOptionCompat()
{
    /*
     * For backwards compatibility
     */
    if (Terse)
	MsgLevel |= L_TERSE;
}
#endif	/* OPTION_COMPAT */

/*
 * Check to see if we're running with the right Root Access.
 */
static void CheckRunTimeAccess()
{
#if	defined(RA_LEVEL) && RA_LEVEL == RA_ADVISED
    if (geteuid() != 0) {
	SImsg(SIM_WARN, 
"This program should be run as `root' (uid=0) to obtain\n\t\
all supported information.  Please either make setuid to\n\t\
root (chown root sysinfo;chmod u+s sysinfo) or invoke as a\n\t\
uid=0 user such as `root'.");
    }
#endif	/* RA_ADVISED */
#if	defined(RA_LEVEL) && RA_LEVEL == RA_NONE
    /* Do nothing */
    return;
#endif	/* RA_NONE */
}

/*
 * Check to see if we're running on the same platform as we were
 * compiled on.
 */
static void CheckRunTimePlatform()
{
    extern char			BuildCPUType[];
    extern char			BuildCPUArch[];
    extern char			BuildOSname[];
    extern char			BuildOSver[];
    static char			What[512];

    /*
     * Skip this check if the user specified the -danger flag
     */
    if (Danger)
	return;

    /* 
     * Yes, it is possible for the OS name to be different.
     * i.e. "IRIX" vs. "IRIX64" 
     */
    if (!EQ(GetOSName(), BuildOSname))
	(void) snprintf(What, sizeof(What),
		"This program was built on `%s' but is being run on `%s'.",
			BuildOSname, GetOSName());
    else if (!EQ(GetOSVer(), BuildOSver))
	(void) snprintf(What, sizeof(What),
"This program was built on `%s %s' \
but is being run on `%s %s'.",
			BuildOSname, BuildOSver, GetOSName(), GetOSVer());
#if	defined(sunos) && OSMVER == 4
    else if (!EQ(GetKernArch(), BuildCPUArch))
	(void) snprintf(What, sizeof(What),
"This program was built on a `%s' kernel arch machine and is being\
run on a `%s' machine.",
			BuildCPUArch, GetKernArch());
#endif

    if (What[0]) {
	SImsg(SIM_CERR, "%s", What);
	SImsg(SIM_CERR, 
	"%s may not be able to provide consistant information.", 
	      ProgramName);
	SImsg(SIM_CERR,
	"If you wish to override and run anyway, use the `-danger'");
	SImsg(SIM_CERR, "option.  This is generally not advised.");
	exit(1);
    }
}

/*
 * Print version information
 */
void PrintVersion()
{
    extern char			BuildDate[];
    extern char			BuildHost[];
    extern char			BuildUser[];
    extern char			BuildOSname[];
    extern char			BuildOSver[];
    extern char			BuildOStype[];
    extern char			BuildAppArch[];
    extern char			BuildCPUArch[];
    int				MsgFlags = SIM_INFO|SIM_DBG|SIM_NONL;
    char		       *MCLinfo;

    if (!VL_TERSE)
	SImsg(MsgFlags, "SysInfo Version ");
    if (PATCHLEVEL)
	SImsg(MsgFlags, "%s.%d", VERSION_STR, PATCHLEVEL);
    else
	SImsg(MsgFlags, "%s", VERSION_STR);

    if (!VL_TERSE) {
	SImsg(MsgFlags, " (%s)\n", VERSION_STATUS);
	SImsg(MsgFlags, "Binary Build Information:\n");
#define bOFFSET 10
	SImsg(MsgFlags, "\t%*s: %s\n", bOFFSET, "Build Date", BuildDate);
	SImsg(MsgFlags, "\t%*s: %s on %s\n", 
	      bOFFSET, "Built By", BuildUser, BuildHost);
	SImsg(MsgFlags, "\t%*s: %s %s\n", 
	      bOFFSET, "OS", BuildOSname, BuildOSver);
	SImsg(MsgFlags, "\t%*s: %s\n", bOFFSET, "OS Type",  BuildOStype);
	SImsg(MsgFlags, "\t%*s: %s\n", bOFFSET, "App Arch", BuildAppArch);
	SImsg(MsgFlags, "\t%*s: %s\n", bOFFSET, "CPU Arch", BuildCPUArch);
#undef bOFFSET
	SImsg(MsgFlags, GENERAL_MSG);
	SImsg(MsgFlags, COPYRIGHT_MSG);
    }

    SImsg(MsgFlags, "\n");
}

/*
 * The beginning
 */
main(Argc, Argv, Envp)
    int 			Argc;
    char 		      **Argv;
    char 		      **Envp;
{
    char		       *cp;
    mcl_t		       *MClic;

    Environ = Envp;

    /*
     * Parse command line arguments.
     */
    if (ParseOptions(Opts, Num_Opts(Opts), Argc, Argv) < 0)
	exit(1);

    /*
     * Cleanup our program name used for error messages.
     */
    if (cp = strrchr(ProgramName, '/'))
	ProgramName = ++cp;

    /*
     * Set Message Class Flags
     */
    if (MsgClassStr && ParseMsgClass(MsgClassStr))
	exit(1);

    /*
     * For -debug backwards compatibile 
     */
    if (DebugFlag)
	MsgClassFlags |= SIM_DBG|SIM_GERR;

    /*
     * If we're setuid(root) and we're not being run by user "root",
     * don't let unpriv'ed users try anything tricky.
     */
    if (UseConfig && (getuid() != 0 && geteuid() == 0) && 
	(ConfFile || !EQ(ConfDir, CONFIG_DIR))) {
	SImsg(SIM_CERR, 
	"Only \"root\" may specify \"-cfdir\" when %s is \"setuid root\".", 
	      ProgramName);
	exit(1);
    }

    UnSupported = (Debug) ? "**UNSUPPORTED**" : (char *)NULL;

#if	defined(OPTION_COMPAT)
    SetOptionCompat();
#endif

    /*
     * Show version info
     */
    if (DoPrintVersion || Debug) {
	PrintVersion();
	if (!Debug)
	    exit(0);
    }
 
    /*
     * Parse config files
     */
    if (UseConfig) {
	if (CFparse(ConfFile, ConfDir) != 0) {
	    SImsg(SIM_CERR, "Errors occured while parsing config file(s).");
	    exit(1);
	}
    }

    /*
     * Check MCL
     */
    MClic = CheckMCL(MCLprogramName);

    if (DoPrintLicense) {
	if (cp = MCLgetInfo(MClic))
	    SImsg(SIM_INFO|SIM_NONL|SIM_DBG, cp);
	exit(0);
    }

    /*
     * Do any list commands and exit
     */
    if (ListStr) {
	List(ListStr);
	exit(0);
    }

    /*
     * Set verbosity strings
     */
    if (MsgLevelStr && ParseMsgLevel(MsgLevelStr))
	exit(1);

    /*
     * Set format type
     */
    if (FormatStr && ParseFormat(FormatStr))
	exit(1);

    /*
     * Check to see if runtime access is ok.
     */
    CheckRunTimeAccess();

    /*
     * Check to see if we're running on the right platform
     */
    CheckRunTimePlatform();

    /*
     * If a -show was specified but not -class, then
     * default to "General".
     */
    if (ShowStr && !ClassNames)
	ClassNames = "General";

    /*
     * Set class info
     */
    ClassSetInfo(ClassNames);

    /*
     * Set type info
     */
    TypeSetInfo(TypeNames);

    SImsg(SIM_DBG, "Verbosity level = 0x%x\n", MsgLevel);

    exit( ClassCall(ShowStr) );
}