/*
 * Copyright (C) 1994-2018 Altair Engineering, Inc.
 * For more information, contact Altair at www.altair.com.
 *
 * This file is part of the PBS Professional ("PBS Pro") software.
 *
 * Open Source License Information:
 *
 * PBS Pro is free software. You can redistribute it and/or modify it under the
 * terms of the GNU Affero General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option) any
 * later version.
 *
 * PBS Pro is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.
 * See the GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Commercial License Information:
 *
 * For a copy of the commercial license terms and conditions,
 * go to: (http://www.pbspro.com/UserArea/agreement.html)
 * or contact the Altair Legal Department.
 *
 * Altair’s dual-license business model allows companies, individuals, and
 * organizations to create proprietary derivative works of PBS Pro and
 * distribute them - whether embedded or bundled with other software -
 * under a commercial license agreement.
 *
 * Use of Altair’s trademarks, including but not limited to "PBS™",
 * "PBS Professional®", and "PBS Pro™" and Altair’s logos is subject to Altair's
 * trademark licensing policies.
 *
 */
/**
 * @file
 *		pbs_probe.c
 *
 * @brief
 * 		Much of this program derives from the PBS utility chk_tree
 * 		and the manner in which thing were done in that program.
 *
 * Functions included are:
 * 	main()
 * 	am_i_authorized()
 * 	infrastruct_params()
 * 	print_infrastruct()
 * 	title_string()
 * 	print_problems()
 * 	msg_table_set_defaults()
 * 	get_primary_values()
 * 	pbsdotconf()
 * 	get_realpath_values()
 * 	is_parent_rpathnull()
 * 	inspect_dir_entries()
 * 	which_suffixset()
 * 	is_suffix_ok()
 * 	which_knwn_mpugs()
 * 	chk_entries()
 * 	pbs_dirtype()
 * 	non_db_resident()
 * 	is_a_numericname()
 * 	check_paths()
 * 	check_owner_modes()
 * 	mbits_and_owner()
 * 	perm_owner_msg()
 * 	perm_string()
 * 	owner_string()
 * 	process_ret_code()
 * 	conf4primary()
 * 	env4primary()
 * 	fix()
 * 	fix_perm_owner()
 *
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#include <fcntl.h>
#include <pwd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <dirent.h>
#include <grp.h>
#include "cmds.h"
#include "pbs_version.h"
#include "pbs_ifl.h"



#ifndef	S_ISLNK
#define	S_ISLNK(m)	(((m) & S_IFMT) == S_IFLNK)
#endif

#define	DEMARC	'/'
#define DFLT_MSGTBL_SZ (1024)

/* ---- required and disallowed dir/file modes ----*/

#define DFLT_REQ_DIR_MODES (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IWOTH)
#define DFLT_DIS_DIR_MODES (S_IWGRP | S_IWOTH)

#define rwxrxrx		(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#define frwxrxrx	(S_IFREG | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#define drwxrxrx	(S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#define tdrwxrwxrwx	(S_ISVTX | S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO)
#define tgworwx		(S_ISVTX | S_IWGRP | S_IRWXO)

#define drwxgo		(S_IFDIR | S_IRWXU)
#define drwxrxo		(S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP)
#define tgrwxorwx	(S_ISVTX | S_IRWXG | S_IRWXO)
#define tgwow		(S_ISVTX | S_IWGRP | S_IWOTH)

#define drwxrxx		(S_IFDIR | S_IRWXU | S_IRGRP | S_IXGRP | S_IXOTH)
#define tgworw		(S_ISVTX | S_IWGRP | S_IROTH | S_IWOTH)
#define dtgwow		(S_IFDIR | S_ISVTX | S_IWGRP | S_IWOTH)

#define frwxrxrx	(S_IFREG | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#define sgswow		(S_ISUID | S_ISGID | S_IWGRP | S_IWOTH)

#define fsrwxrxrx	(S_IFREG | S_ISUID | S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)
#define gswow		(S_ISGID | S_IWGRP | S_IWOTH)

#define frwxgo		(S_IFREG | S_IRWXU)
#define sgsrwxorwx	(S_ISUID | S_ISGID | S_IRWXG | S_IRWXO)

#define frwrr		(S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
#define xsgswxowx	(S_IXUSR | S_ISUID | S_ISGID | S_IWGRP | S_IXGRP | S_IWOTH | S_IXOTH)

#define frwgo		(S_IFREG | S_IRUSR | S_IWUSR)
#define xsgsrwxorwx	(S_IXUSR | S_ISUID | S_ISGID | S_IRWXG | S_IRWXO)

#define frgror		(S_IFREG | S_IRUSR | S_IRGRP | S_IROTH)
#define sgswxowx	(S_ISUID | S_ISGID | S_IWGRP | S_IXGRP | S_IWOTH | S_IXOTH)

#define	drwxrr		(S_IFDIR | S_IRWXU | S_IRGRP | S_IROTH)
#define tgwxowx		(S_ISVTX | S_IWGRP | S_IXGRP | S_IWOTH | S_IXOTH)


/* ---- Codes to identify the source of various data items ----*/

#define	SRC_NONE	0	/* no source/can't determine */
#define	SRC_DFLT	1	/* source is default value */
#define	SRC_ENV		2	/* source is environment variable */
#define	SRC_CONF	3	/* source is PBS config file */


/* -----------  error values -------------*/

#define	PBS_CONF_NO_EXIST	1
#define	PBS_CONF_CAN_NOT_OPEN	2

#define LSTAT_PATH_ERR	-1
#define PATH_ERR	 1


typedef struct  statdata {
	int populated;		/* member "sb" populated */
	struct stat	sb;	/* stat  "buffer" */
} STATDATA;

typedef struct  utsdata {
	int	populated;	/* member "ub" populated */
	struct  utsname ub;	/* uname "buffer" */
} UTSDATA;

typedef struct vld_ug {
	/*
	 * each directory/file in the PBS infrastructure should
	 * one of these "valid users, valid groups" structures
	 * associated with it
	 */
	int	*uids;		/* -1 terminated array UID values */
	int	*gids;		/* -1 terminated array GID values */

	char	**unames; 	/* null terminated table user names */
	char	**gnames; 	/* null terminated table group names */
} VLD_UG;


typedef struct modes_path_user_group {
	/*
	 * each directory/file in the PBS infrastructure should have
	 * one of these "modes, path, user, group, type" structures
	 * associated with it
	 */
	int	fc;		/* fix code: 0=no, 1=perm/own, 2=create */

	int	notReq;		/* bit1 (0x1): 0=always required, 1=never required
				   bit2 (0x2): 1=not required for command-only install
				   bit3 (0x4): 1=not required for execution-only install
				   Note: used in conjunction with "notbits"
				 */

	int	chkfull;	/* 1=check each path component */

	int	req_modes;	/* required permissions (modes) */
	int	dis_modes;	/* disallowed permissions (modes) */
	VLD_UG	*vld_ug;	/* tables of valid users and groups */
	char	*path;		/* location of file/directory */
	char	*realpath;	/* canonicalized absolute location */
} MPUG;

typedef struct modeadjustments {
	/*
	 * an instance of this structure will contain modification
	 * data that should be used in conjunction with the mode data
	 * found in a corresponding MPUG data struccture.
	 */
	int	req;	/* required modes   */
	int	dis;	/* disallowed modes */
} ADJ;


typedef struct primary {

	MPUG	*pbs_mpug;	/* MPUGs: PBS primary dirs/files */

	/*
	 * record values and sources for "path" and "started"
	 */

	struct {
		unsigned	server:1, mom:1, sched:1;
	} started;

	struct {
		unsigned	server:2, mom:2, sched:2;
	} src_started;

	struct {
		unsigned	conf:2, home:2, exec:2;
	} src_path;

} PRIMARY;

/*
 * Numeric codes - use in title generation (see function, title_string)
 */
enum code_title { TC_top, TC_sys, TC_ro, TC_fx, TC_pri, TC_ho, TC_ex,
	TC_cnt, TC_tvrb, TC_datpri, TC_datho, TC_datex, TC_noerr,
	TC_use };
/*
 * Numeric codes - for use in function process_ret_code()
 */
enum func_names { GET_PRIMARY_VALUES, END_FUNC_NAMES };

/*
 * Message Header data - use, output of pbs_probe's "Primary" variables
 */
enum	mhp { MHP_cnf, MHP_home, MHP_exec, MHP_svr, MHP_mom, MHP_sched };
static char mhp[][20] = {
	"PBS_CONF_FILE",
	"PBS_HOME",
	"PBS_EXEC",
	"PBS_START_SERVER",
	"PBS_START_MOM",
	"PBS_START_SCHED"
};

/* ---- default values for uid/gid, user names, group names ----*/

static	int	pbsdata[] = {-1, -1};		  /* PBS datastore */
static	int	pbsu[] = {0, -1};		  /* PBS UID, default */
static	int	du[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1}; /* non-PBS UIDs, default */

static	char	*pbs_dataname[] =  {"pbsdata", NULL}; /* PBS data name, default */
static	char	*pbs_unames[] =  {"root", NULL}; /* PBS user name, default */
static	char	*pbs_gnames[] =  {NULL}; /* PBS group name, default*/

static	int	dg[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1}; /* non-PBS GIDs, default */


/* ---------- default VLD_UG structures, PBS and non-PBS -----------*/

static	VLD_UG	dflt_pbs_data = { pbsdata, dg, &pbs_dataname[0], &pbs_gnames[0] };
static	VLD_UG	dflt_pbs_ug = { pbsu, dg, &pbs_unames[0], &pbs_gnames[0] };
static	VLD_UG	dflt_ext_ug = { du, dg, &pbs_unames[0], &pbs_gnames[0] };

/* ============  PBS path names ============ */

static  char default_pbsconf[] = "/etc/pbs.conf";

/* ------------ PBS HOME: relative paths -----------*/


static char svrhome[][80] = {
	/* 00 */ "server_logs",
	/* 01 */ "spool",
	/* 02 */ "server_priv",
	/* 03 */ "server_priv/resourcedef",
	/* 04 */ "server_priv/server.lock",
	/* 05 */ "server_priv/tracking",
	/* 06 */ "server_priv/accounting",
	/* 07 */ "server_priv/jobs",
	/* 08 */ "server_priv/users",
	/* 09 */ "server_priv/hooks",
	/* 10 */ "server_priv/hooks/tmp",
	/* 11 */ "server_priv/prov_tracking",
	/* 12 */ "server_priv/db_password",
	/* 13 */ "server_priv/db_svrhost",
	/* 14 */ "server_priv/db_svrhost.new",
	/* 15 */ "server_priv/svrlive",
	/* 16 */ "datastore"
};

static char momhome[][80] = {
	/* 0 */ "aux",
	/* 1 */ "checkpoint",
	/* 2 */ "mom_logs",
	/* 3 */ "mom_priv",
	/* 4 */ "mom_priv/mom.lock",
	/* 5 */ "mom_priv/config",
	/* 6 */ "mom_priv/jobs",
	/* 7 */ "spool",
	/* 8 */ "undelivered",
	/* 9 */ "mom_priv/config.d",
	/* 10 */ "mom_priv/hooks",
	/* 11 */ "mom_priv/hooks/tmp"
};

static char schedhome[][80] = {
	/* 0 */ "sched_logs",
	/* 1 */ "sched_priv",
	/* 2 */ "sched_priv/dedicated_time",
	/* 3 */ "sched_priv/holidays",
	/* 4 */ "sched_priv/sched_config",
	/* 5 */ "sched_priv/resource_group",
	/* 6 */ "sched_priv/sched.lock",
	/* 7 */ "sched_priv/sched_out"
};

static char exec[][80] = {
	/* 0 */ "bin",
	/* 1 */ "etc",
	/* 2 */ "include",
	/* 3 */ "lib",
	/* 4 */ "man",
	/* 5 */ "sbin",
	/* 6 */ "tcltk",
	/* 7 */ "python",
	/* 8 */ "pgsql"
};



/* ------------ PBS EXEC: relative paths ----------*/

static char exbin[][80] = {
	/* 00 */ "bin/nqs2pbs",
	/* 01 */ "bin/pbs_topologyinfo",
	/* 02 */ "bin/pbs_hostn",
	/* 03 */ "bin/pbs_rdel",
	/* 04 */ "bin/pbs_rstat",
	/* 05 */ "bin/pbs_rsub",
	/* 06 */ "bin/pbs_tclsh",
	/* 07 */ "bin/pbs_wish",
	/* 08 */ "bin/pbsdsh",
	/* 09 */ "bin/pbsnodes",
	/* 10 */ "bin/printjob",
	/* 11 */ "bin/qalter",
	/* 12 */ "bin/qdel",
	/* 13 */ "bin/qdisable",
	/* 14 */ "bin/qenable",
	/* 15 */ "bin/qhold",
	/* 16 */ "bin/qmgr",
	/* 17 */ "bin/qmove",
	/* 18 */ "bin/qmsg",
	/* 19 */ "bin/qorder",
	/* 20 */ "bin/qrerun",
	/* 21 */ "bin/qrls",
	/* 22 */ "bin/qrun",
	/* 23 */ "bin/qselect",
	/* 24 */ "bin/qsig",
	/* 25 */ "bin/qstart",
	/* 26 */ "bin/qstat",
	/* 27 */ "bin/qstop",
	/* 28 */ "bin/qsub",
	/* 29 */ "bin/qterm",
	/* 30 */ "bin/tracejob",
	/* 31 */ "bin/pbs_password",
	/* 32 */ "bin/pbs_migrate_users",
	/* 33 */ "XXX",				/* slot available for use */
	/* 34 */ "bin/pbs_lamboot",
	/* 35 */ "bin/pbs_mpilam",
	/* 36 */ "bin/pbs_mpirun",
	/* 37 */ "bin/pbs_mpihp",
	/* 38 */ "bin/pbs_attach",
	/* 39 */ "bin/pbs_remsh",
	/* 40 */ "bin/pbs_tmrsh",
	/* 41 */ "bin/mpiexec",
	/* 42 */ "bin/pbsrun",
	/* 43 */ "bin/pbsrun_wrap",
	/* 44 */ "bin/pbsrun_unwrap",
	/* 45 */ "bin/pbs_python",
	/* 46 */ "bin/pbs_ds_password",
	/* 47 */ "bin/pbs_dataservice"
};

static char exsbin[][80] = {
	/* 00 */ "sbin/pbs-report",
	/* 01 */ "sbin/pbs_demux",
	/* 02 */ "sbin/pbs_idled",
	/* 03 */ "sbin/pbs_iff",
	/* 04 */ "sbin/pbs_mom",
	/* 05 */ "sbin/pbs_mom.cpuset",
	/* 06 */ "sbin/pbs_mom.standard",
	/* 07 */ "sbin/pbs_rcp",
	/* 08 */ "sbin/pbs_sched",
	/* 09 */ "sbin/pbs_server",
	/* 10 */ "sbin/pbsfs",
	/* 11 */ "sbin/pbs_probe",
	/* 12 */ "sbin/pbs_upgrade_job"
};

static char exetc[][80] = {
	/* 00 */ "etc/modulefile",
	/* 01 */ "etc/pbs_dedicated",
	/* 02 */ "etc/pbs_habitat",
	/* 03 */ "etc/pbs_holidays",
	/* 04 */ "etc/pbs_init.d",
	/* 05 */ "etc/pbs_postinstall",
	/* 06 */ "etc/pbs_resource_group",
	/* 07 */ "etc/pbs_sched_config",
	/* 08 */ "etc/install_db",
	/* 09 */ "etc/pbs_db_schema.sql",
	/* 10 */ "etc/pbs_topologyinfo"
};

static char exinc[][80] = {
	/* 00 */ "include/pbs_error.h",
	/* 01 */ "include/pbs_ifl.h",
	/* 02 */ "include/rm.h",
	/* 03 */ "include/tm.h",
	/* 04 */ "include/tm_.h"
};

static char exlib[][80] = {
	/* 00 */ "lib/libattr.a",
	/* 01 */ "lib/libcmds.a",	/* this library no longer exists */
	/* 02 */ "lib/liblog.a",
	/* 03 */ "lib/libnet.a",
	/* 04 */ "lib/libpbs.a",
	/* 05 */ "lib/libsite.a",
	/* 06 */ "lib/pbs_sched.a",
	/* 07 */ "lib/pm",
	/* 08 */ "lib/pm/PBS.pm",
	/* 09 */ "lib/MPI",
	/* 10 */ "lib/MPI/sgiMPI.awk",
	/* 11 */ "lib/MPI/pbsrun.ch_gm.init.in",
	/* 12 */ "lib/MPI/pbsrun.ch_mx.init.in",
	/* 13 */ "lib/MPI/pbsrun.gm_mpd.init.in",
	/* 14 */ "lib/MPI/pbsrun.mx_mpd.init.in",
	/* 15 */ "lib/MPI/pbsrun.mpich2.init.in",
	/* 16 */ "lib/MPI/pbsrun.intelmpi.init.in",
	/* 17 */ "lib/MPI/pbsrun.bgl.init.in",
	/* 18 */ "lib/python",
	/* 19 */ "lib/python/altair",
	/* 20 */ "lib/python/altair/pbs",
	/* 21 */ "lib/python/altair/pbs/__init__.pyc",
	/* 22 */ "lib/python/altair/pbs/__init__.py",
	/* 23 */ "lib/python/altair/pbs/v1",
	/* 24 */ "lib/python/altair/pbs/v1/__init__.pyc",
	/* 25 */ "lib/python/altair/pbs/v1/__init__.py",
	/* 26 */ "lib/python/altair/pbs/v1/_export_types.py",
	/* 27 */ "lib/python/altair/pbs/v1/__init__.pyo",
	/* 28 */ "lib/python/altair/pbs/v1/_attr_types.py",
	/* 29 */ "lib/python/altair/pbs/v1/_attr_types.pyc",
	/* 30 */ "lib/python/altair/pbs/v1/_attr_types.pyo",
	/* 31 */ "lib/python/altair/pbs/v1/_base_types.py",
	/* 32 */ "lib/python/altair/pbs/v1/_base_types.pyc",
	/* 33 */ "lib/python/altair/pbs/v1/_base_types.pyo",
	/* 34 */ "lib/python/altair/pbs/v1/_exc_types.py",
	/* 35 */ "lib/python/altair/pbs/v1/_exc_types.pyc",
	/* 36 */ "lib/python/altair/pbs/v1/_exc_types.pyo",
	/* 37 */ "lib/python/altair/pbs/v1/_export_types.pyo",
	/* 38 */ "lib/python/altair/pbs/v1/_export_types.pyc",
	/* 39 */ "lib/python/altair/pbs/v1/_svr_types.pyo",
	/* 40 */ "lib/python/altair/pbs/v1/_svr_types.py",
	/* 41 */ "lib/python/altair/pbs/v1/_svr_types.pyc",
	/* 42 */ "lib/python/altair/pbs/__init__.pyo"
};

#if 0
static char exec_man1[] = "man/man1";
static char exec_man3[] = "man/man3";
static char exec_man7[] = "man/man7";
static char exec_man8[] = "man/man8";
#endif

static char exman1[][80] = {
	/* 00 */ "man/man1",
	/* 01 */ "man/man1/nqs2pbs.1B",
	/* 02 */ "man/man1/pbs_python.1B",
	/* 03 */ "man/man1/pbs_rdel.1B",
	/* 04 */ "man/man1/pbs_rstat.1B",
	/* 05 */ "man/man1/pbs_rsub.1B",
	/* 06 */ "man/man1/pbsdsh.1B",
	/* 07 */ "man/man1/qalter.1B",
	/* 08 */ "man/man1/qdel.1B",
	/* 09 */ "man/man1/qhold.1B",
	/* 10 */ "man/man1/qmove.1B",
	/* 11 */ "man/man1/qmsg.1B",
	/* 12 */ "man/man1/qorder.1B",
	/* 13 */ "man/man1/qrerun.1B",
	/* 14 */ "man/man1/qrls.1B",
	/* 15 */ "man/man1/qselect.1B",
	/* 16 */ "man/man1/qsig.1B",
	/* 17 */ "man/man1/qstat.1B",
	/* 18 */ "man/man1/qsub.1B"
};

static char exman3[][80] = {
	/* 00 */ "man/man3",
	/* 01 */ "man/man3/pbs_alterjob.3B",
	/* 02 */ "man/man3/pbs_connect.3B",
	/* 03 */ "man/man3/pbs_default.3B",
	/* 04 */ "man/man3/pbs_deljob.3B",
	/* 05 */ "man/man3/pbs_disconnect.3B",
	/* 06 */ "man/man3/pbs_geterrmsg.3B",
	/* 07 */ "man/man3/pbs_holdjob.3B",
	/* 08 */ "man/man3/pbs_manager.3B",
	/* 09 */ "man/man3/pbs_movejob.3B",
	/* 10 */ "man/man3/pbs_msgjob.3B",
	/* 11 */ "man/man3/pbs_orderjob.3B",
	/* 12 */ "man/man3/pbs_rerunjob.3B",
	/* 13 */ "man/man3/pbs_statsched.3B",
	/* 14 */ "man/man3/pbs_rescreserve.3B",
	/* 15 */ "man/man3/pbs_rlsjob.3B",
	/* 16 */ "man/man3/pbs_runjob.3B",
	/* 17 */ "man/man3/pbs_selectjob.3B",
	/* 18 */ "man/man3/pbs_sigjob.3B",
	/* 19 */ "man/man3/pbs_stagein.3B",
	/* 20 */ "man/man3/pbs_statjob.3B",
	/* 21 */ "man/man3/pbs_statnode.3B",
	/* 22 */ "man/man3/pbs_statque.3B",
	/* 23 */ "man/man3/pbs_statserver.3B",
	/* 24 */ "man/man3/pbs_submit.3B",
	/* 25 */ "man/man3/pbs_terminate.3B",
	/* 26 */ "man/man3/rpp.3",
	/* 27 */ "man/man3/tm.3",
	/* 28 */ "man/man3/pbs_tclapi.3B",
	/* 29 */ "man/man3/pbs_delresv.3B",
	/* 30 */ "man/man3/pbs_locjob.3B",
	/* 31 */ "man/man3/pbs_selstat.3B",
	/* 32 */ "man/man3/pbs_statresv.3B",
	/* 33 */ "man/man3/pbs_statfree.3B"
};

static char exman7[][80] = {
	/* 00 */ "man/man7",
	/* 01 */ "man/man7/pbs_job_attributes.7B",
	/* 02 */ "man/man7/pbs_node_attributes.7B",
	/* 03 */ "man/man7/pbs_queue_attributes.7B",
	/* 04 */ "man/man7/pbs_resources.7B",
	/* 05 */ "man/man7/pbs_resv_attributes.7B",
	/* 06 */ "man/man7/pbs_server_attributes.7B",
	/* 07 */ "man/man7/pbs_sched_attributes.7B",
	/* 08 */ "man/man7/pbs_professional.7B"
};

static char exman8[][80] = {
	/* 00 */ "man/man8",
	/* 01 */ "man/man8/pbs_idled.8B",
	/* 02 */ "man/man8/pbs_mom.8B",
	/* 03 */ "man/man8/pbs_sched.8B",
	/* 04 */ "man/man8/pbs_server.8B",
	/* 05 */ "man/man8/pbsfs.8B",
	/* 06 */ "man/man8/pbsnodes.8B",
	/* 07 */ "man/man8/qdisable.8B",
	/* 08 */ "man/man8/qenable.8B",
	/* 09 */ "man/man8/qmgr.8B",
	/* 10 */ "man/man8/qrun.8B",
	/* 11 */ "man/man8/qstart.8B",
	/* 12 */ "man/man8/qstop.8B",
	/* 13 */ "man/man8/qterm.8B",
	/* 14 */ "man/man8/pbs_lamboot.8B",
	/* 15 */ "man/man8/pbs_mpilam.8B",
	/* 16 */ "man/man8/pbs_password.8B",
	/* 17 */ "man/man8/pbs_migrate_users.8B",
	/* 18 */ "man/man8/pbs_mpirun.8B",
	/* 19 */ "man/man8/XXX",		/* slot available for use */
	/* 20 */ "man/man8/pbs_attach.8B",
	/* 21 */ "man/man8/pbs_mkdirs.8B",
	/* 22 */ "man/man8/pbs_hostn.8B",
	/* 23 */ "man/man8/pbs_probe.8B",
	/* 24 */ "man/man8/pbs-report.8B",
	/* 25 */ "man/man8/pbs_tclsh.8B",
	/* 26 */ "man/man8/pbs_tmrsh.8B",
	/* 27 */ "man/man8/pbs_wish.8B",
	/* 28 */ "man/man8/printjob.8B",
	/* 29 */ "man/man8/pbs.8B",
	/* 30 */ "man/man8/pbs_interactive.8B"
};

static char extcltk[][80] = {
	/* 0 */ "tcltk/bin",
	/* 1 */ "tcltk/include",
	/* 2 */ "tcltk/lib",
	/* 3 */ "tcltk/license.terms"
};

static char expython[][80] = {
	/* 0 */ "python/bin",
	/* 1 */ "python/include",
	/* 2 */ "python/lib",
	/* 3 */ "python/man",
	/* 4 */ "python/python.changes.txt",
	/* 5 */ "python/bin/python"
};

static char expgsql[][80] = {
	/* 0 */ "pgsql/bin",
	/* 1 */ "pgsql/include",
	/* 2 */ "pgsql/lib",
	/* 3 */ "pgsql/share"
};


/* ----------- messages for stdout ------------- */

#if 0
static	char err_report_all[] = "pbsprobe found the following errors in the PBS infrastructure:";
static	char err_report_one[] = "pbsprobe found the following errors in the PBS infrastructure on ";
static	char err_report_noerr_all[] = "no errors were detected in the PBS infrastructure:";
static	char err_report_noerr_one[] = "no errors were detected in the PBS infrastructure on ";
static	char report_describe_all[] = "pbsprobe checked the following PBS infrastructure:";
static	char report_describe_one[] = "pbsprobe checked the following PBS infrastructure on ";

/* Header and print control strings for Primary Infrastructure Information */

static	char report_hdr_pri_info[] = "Derivation of Primary Infrastructure Information:";
static  char report_pri_conf[] = "PBS's config file path - used %s.";
static  char report_pri_home[] = "PBS's home path - used %s.";
static  char report_pri_exec[] = "PBS's exec path - used %s.";
static  char report_pri_svr_star[] = "Value of PBS_SERVER_STARTED - used %s.";
static  char report_pri_mom_star[] = "Value of PBS_MOM_STARTED - used %s.";
static  char report_pri_sched_star[] = "Value of PBS_SCHED_STARTED - used %s.";

/* Headers and print control strings for categories of problems found */

static  char report_hdr_missing[] = "Missing Files and Directories:";
static  char report_hdr_bad_om[] = "Files or Directories with Incorrect Ownership or Modes:";
static  char report_hdr_unkwn[] = "Unknown Files Detected in PBS Directories:";
static  char report_owner_modes[] = "%s %s has (uid, gid, modes)=(%s, %s, %s); needs to be (%s, %s, %s).";
static  char report_missing[] = "%s %s is missing.";
static  char report_unknwn[] = "%s has %s files with no, or an unrecognized, suffix.";
#endif


/* ----------- messages for stderr ------------- */

/* -------- global static PBS variables -------- */

ADJ dflt_modeadjustments = { S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH, S_IFREG };

enum fixcodes	{ FIX_none, FIX_po };
enum pbsdirtype { PBS_niltype, PBS_logsdir, PBS_acctdir,
	PBS_spooldir, PBS_jobsdir,
	PBS_usersdir,
	PBS_hooksdir, PBS_hookswdir };


enum pbs_mpugs { PBS_conf, PBS_home, PBS_exec, PBS_last };
char	*origin_names[] = {"PBS CONF FILE", "PBS HOME", "PBS EXEC"};

/*
 * The following definitions simplify setting bit field codes
 */

#define C000	{0, 0, 0}		/* no fix,    Req'd, !ckfull */
#define C010	{0, 1, 0}		/* no fix,    noReq, !ckfull */
#define C100	{1, 0, 0}		/* fix perms, Req'd, !ckfull */
#define C110	{1, 1, 0}		/* fix perms, noReq, !ckfull */
#define C111	{1, 1, 1}		/* fix perms, noReq,  ckfull */
#define C200	{2, 0, 0}		/* fix exist, Req'd, !ckfull */
#define C201	{2, 0, 1}		/* fix exist, Req'd,  ckfull */

/*
 * MPUG arrays and mask to use with MPUG's "notReq" member
 */

/*
 * variable records which bits in an MPUG's "notReq" member need be considered
 *	notbits starts as 0x1
 *	For execution only (Mom) set to 0x5
 *	For commands only	 set to 0x3
 *
 *	"notReq" is set to
 *	0 - required for all
 *	1 - not required ever
 *	2 - not required for commands only install
 *	4 - not required for execuition only (Mom) install
 *
 * The two are "and"ed together.  If the result is 0 the file should be there,
 * if the result is non-zero, the file need not be present.
 */
static int	notbits = 0x1;


static MPUG	pbs_mpugs[] = {
	/*
	 * infrastructure data associated with PBS origins
	 * dir, chkfull, required and disallowed modes, pointer
	 * to "valid users, valid groups", path, realpath
	 */
	{1, 0, 0, frwrr,  xsgswxowx, &dflt_ext_ug, NULL, NULL},
	{1, 0, 1, drwxrxrx,   tgwow, &dflt_ext_ug, NULL, NULL},
	{1, 0, 1, drwxrxrx,   tgwow, &dflt_ext_ug, NULL, NULL} };

enum exec_mpugs { EXEC_exec, EXEC_bin, EXEC_sbin,  EXEC_etc, EXEC_include,
	EXEC_lib, EXEC_man, EXEC_man1, EXEC_man3, EXEC_man7,
	EXEC_man8, EXEC_tcltk, EXEC_python, EXEC_pgsql, EXEC_last };

char *exec_mpug_set[EXEC_last] = {"exec", "bin", "sbin", "etc", "include",
	"lib", "man", "man1", "man3", "man7",
	"man8", "tcltk", "python", "pgsql"};

int  exec_sizes[EXEC_last];

static MPUG	 exec_mpugs[] = {
	/*
	 * infrastructure data associated with PBS execution -
	 * bin, sbin, etc, include, lib, man, tcltk, python, pgsql
	 */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[0], NULL}, /* bin */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[1], NULL}, /* etc */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[2], NULL}, /* include */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[3], NULL}, /* lib */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[4], NULL}, /* man */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[5], NULL}, /* sbin */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[6], NULL}, /* tcltk */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[7], NULL}, /* python */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[8], NULL}  /* pgsql */
};



static MPUG	bin_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/bin
	 */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[0],    NULL},
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 0], NULL }, /* nqs2pbs */
	{1, 6, 0,   frwxgo,   sgsrwxorwx, &dflt_pbs_ug, exbin[ 1], NULL }, /* pbs_topologyinfo */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 2], NULL }, /* pbs_hostn */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 3], NULL }, /* pbs_rdel */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 4], NULL }, /* pbs_rstat */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 5], NULL }, /* pbs_rsub */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 6], NULL }, /* pbs_tclsh */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 7], NULL }, /* pbs_wish */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 8], NULL }, /* pbsdsh */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[ 9], NULL }, /* pbsnodes */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[10], NULL }, /* printjob */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[11], NULL }, /* qalter */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[12], NULL }, /* qdel */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[13], NULL }, /* qdisable */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[14], NULL }, /* qenable */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[15], NULL }, /* qhold */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[16], NULL }, /* qmgr */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[17], NULL }, /* qmove */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[18], NULL }, /* qmsg */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[19], NULL }, /* qorder */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[20], NULL }, /* qrerun */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[21], NULL }, /* qrls */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[22], NULL }, /* qrun */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[23], NULL }, /* qselect */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[24], NULL }, /* qsig */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[25], NULL }, /* qstart */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[26], NULL }, /* qstat */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[27], NULL }, /* qstop */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[28], NULL }, /* qsub */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[29], NULL }, /* qterm */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[30], NULL }, /* tracejob */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[31], NULL }, /* pbs_password */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[32], NULL }, /* pbs_migrate_users */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[33], NULL }, /* slot available for use */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[34], NULL }, /* pbs_lamboot */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[35], NULL }, /* pbs_mpilam */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[36], NULL }, /* pbs_mpirun */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[37], NULL }, /* pbs_mpihp */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[38], NULL }, /* pbs_attach */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[39], NULL }, /* pbs_remsh */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[40], NULL }, /* pbs_tmrsh */
	{1, 2, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[41], NULL }, /* mpiexec */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[42], NULL }, /* pbsrun */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[43], NULL }, /* pbsrun_wrap */
	{1, 1, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[44], NULL }, /* pbsrun_unwrap */
	{1, 2, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exbin[45], NULL },  /* pbs_python */
	{1, 6, 0,   frwxgo,     tgrwxorwx, &dflt_pbs_ug, exbin[46], NULL },  /* pbs_ds_password */
	{1, 6, 0,   frwxgo,     tgrwxorwx, &dflt_pbs_ug, exbin[47], NULL }  /* pbs_dataservice */
};

static MPUG	sbin_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/sbin
	 */
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, exec[5], NULL},
	{1, 2, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exsbin[ 0], NULL }, /* pbs-report */
	{1, 2, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exsbin[ 1], NULL }, /* pbs_demux */
	{1, 2, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exsbin[ 2], NULL }, /* pbs_idled */
	{1, 0, 0,  fsrwxrxrx,      gswow, &dflt_pbs_ug, exsbin[ 3], NULL }, /* pbs_iff */
	{1, 2, 0,     frwxgo, sgsrwxorwx, &dflt_pbs_ug, exsbin[ 4], NULL }, /* pbs_mom */
	{1, 1, 0,     frwxgo, sgsrwxorwx, &dflt_pbs_ug, exsbin[ 5], NULL }, /* pbs_mom.cpuset, notReq reset to 2 if SGI Linux */
	{1, 1, 0,     frwxgo, sgsrwxorwx, &dflt_pbs_ug, exsbin[ 6], NULL }, /* pbs_mom.standard, notReq reset to 2 if SGI Linux */
	{1, 2, 0,  fsrwxrxrx,      gswow, &dflt_pbs_ug, exsbin[ 7], NULL }, /* pbs_rcp */
	{1, 6, 0,     frwxgo, sgsrwxorwx, &dflt_pbs_ug, exsbin[ 8], NULL }, /* pbs_sched */
	{1, 6, 0,     frwxgo, sgsrwxorwx, &dflt_pbs_ug, exsbin[ 9], NULL }, /* pbs_server */
	{1, 6, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exsbin[10], NULL }, /* pbsfs */
	{1, 0, 0,   frwxrxrx,     sgswow, &dflt_pbs_ug, exsbin[11], NULL }, /* pbs_probe */
	{1, 2, 0,     frwxgo, sgsrwxorwx, &dflt_pbs_ug, exsbin[12], NULL } /* pbs_upgrade_job */
};


static MPUG	etc_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/etc
	 */
	{1, 0, 0, drwxrxrx,      tgwow, &dflt_pbs_ug,  exec[ 1], NULL },
	{1, 0, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exetc[ 0], NULL }, /* modulefile */
	{1, 6, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exetc[ 1], NULL }, /* pbs_dedicated */
	{1, 2, 0,   frwxgo, sgsrwxorwx, &dflt_pbs_ug, exetc[ 2], NULL }, /* pbs_habitat */
	{1, 6, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exetc[ 3], NULL }, /* pbs_holidays */
	{1, 2, 0,   frwxgo, sgsrwxorwx, &dflt_pbs_ug, exetc[ 4], NULL }, /* pbs_init.d */
	{1, 0, 0,   frwxgo, sgsrwxorwx, &dflt_pbs_ug, exetc[ 5], NULL }, /* pbs_postinstall */
	{1, 6, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exetc[ 6], NULL }, /* pbs_resource_group */
	{1, 6, 0,   frgror,   sgswxowx, &dflt_pbs_ug, exetc[ 7], NULL }, /* pbs_sched_config */
	{1, 6, 0,   frwxgo,  tgrwxorwx, &dflt_pbs_ug, exetc[ 8], NULL }, /* install_db */
	{1, 6, 0,    frwrr,   sgswxowx, &dflt_pbs_ug, exetc[ 9], NULL }, /* pbs_db_schema.sql */
	{1, 6, 0,   frwxgo, sgsrwxorwx, &dflt_pbs_ug, exetc[10], NULL }  /* pbs_topologyinfo */
};


static MPUG	include_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/include
	 */
	{1, 2, 0,   drwxrxrx,    tgwow, &dflt_pbs_ug, exec[2], NULL},
	{1, 2, 0,     frgror,   sgswxowx, &dflt_pbs_ug, exinc[0], NULL }, /* pbs_error.h */
	{1, 2, 0,     frgror,   sgswxowx, &dflt_pbs_ug, exinc[1], NULL }, /* pbs_ifl.h */
	{1, 2, 0,     frgror,   sgswxowx, &dflt_pbs_ug, exinc[2], NULL }, /* rm.h */
	{1, 2, 0,     frgror,   sgswxowx, &dflt_pbs_ug, exinc[3], NULL }, /* tm.h */
	{1, 2, 0,     frgror,   sgswxowx, &dflt_pbs_ug, exinc[4], NULL } }; /* tm_.h */


static MPUG	lib_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/lib
	 */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[3],    NULL},
	{1, 2, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 0], NULL }, /* libattr.a */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 1], NULL }, /* libcmds.a */
	{1, 2, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 2], NULL }, /* liblog.a */

	{1, 2, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 3], NULL }, /* libnet.a */
	{1, 2, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 4], NULL }, /* libpbs.a */
	{1, 2, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 5], NULL }, /* libsite.a */
	{1, 2, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 6], NULL }, /* pbs_sched.a */
	{1, 2, 0,   drwxrxrx,    tgwow, &dflt_pbs_ug, exlib[ 7], NULL }, /* pm */
	{1, 0, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[ 8], NULL }, /* PBS.pm */
	{1, 2, 0,   drwxrxrx,    tgwow, &dflt_pbs_ug, exlib[ 9], NULL}, /* MPI */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[10], NULL}, /* sgiMPI.awk */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[11], NULL}, /* pbsrun.ch_gm.init.in */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[12], NULL}, /* pbsrun.ch_mx.init.in */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[13], NULL}, /* pbsrun.gm_mpd.init.in */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[14], NULL}, /* pbsrun.mx_mpd.init.in */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[15], NULL}, /* pbsrun.mpich2.init.in */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[16], NULL},  /* pbsrun.intelmpi.init.in */
	{1, 1, 0,    frwrr,  xsgswxowx, &dflt_pbs_ug, exlib[17], NULL},  /* pbsrun.bgl.init.in */
	{1, 6, 0,    drwxrxrx,   tgwow, &dflt_pbs_ug, exlib[18], NULL},  /* lib/python */
	{1, 2, 0,    drwxrxrx,   tgwow, &dflt_pbs_ug, exlib[19], NULL},  /* lib/python/altair */
	{1, 2, 0,    drwxrxrx,   tgwow, &dflt_pbs_ug, exlib[20], NULL},  /* lib/python/altair/pbs */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[21], NULL},  /* lib/python/altair/pbs/__init__.pyc */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[22], NULL},  /* lib/python/altair/pbs/__init__.py */
	{1, 2, 0,    drwxrxrx,   tgwow, &dflt_pbs_ug, exlib[23], NULL},  /* lib/python/altair/pbs/v1 */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[24], NULL},  /* lib/python/altair/pbs/v1/__init__.pyc */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[25], NULL},  /* lib/python/altair/pbs/v1/__init__.py */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[26], NULL},  /* lib/python/altair/pbs/v1/_export_types.py */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[27], NULL},  /* lib/python/altair/pbs/v1/__init__.pyo */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[28], NULL},  /* lib/python/altair/pbs/v1/_attr_types.py */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[29], NULL},  /* lib/python/altair/pbs/v1/_attr_types.pyc */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[30], NULL},  /* lib/python/altair/pbs/v1/_attr_types.pyo */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[31], NULL},  /* lib/python/altair/pbs/v1/_base_types.py */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[32], NULL},  /* lib/python/altair/pbs/v1/_base_types.pyc */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[33], NULL},  /* lib/python/altair/pbs/v1/_base_types.pyo */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[34], NULL},  /* lib/python/altair/pbs/v1/_exc_types.py */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[35], NULL},  /* lib/python/altair/pbs/v1/_exc_types.pyc */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[36], NULL},  /* lib/python/altair/pbs/v1/_exc_types.pyo */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[37], NULL},  /* lib/python/altair/pbs/v1/_export_types.pyo */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[38], NULL},  /* lib/python/altair/pbs/v1/_export_types.pyc */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[39], NULL},  /* lib/python/altair/pbs/v1/_svr_types.pyo */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[40], NULL},  /* lib/python/altair/pbs/v1/_svr_types.py */
	{1, 2, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[41], NULL},  /* lib/python/altair/pbs/v1/_svr_types.pyc */
	{1, 0, 0,    frgror,  sgswxowx, &dflt_pbs_ug, exlib[42], NULL},  /* lib/python/altair/pbs/__init__.pyo */
};

static MPUG	man_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/man
	 */
	{1, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, exec[4],    NULL},

	/*
	 * infrastructure data associated with PBS_EXEC/man/man1
	 */
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, exman1[ 0], NULL }, /* man1 */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 1], NULL }, /* nqs2pbs.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 2], NULL }, /* pbs_python.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 3], NULL }, /* pbs_rdel.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 4], NULL }, /* pbs_rstat.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 5], NULL }, /* pbs_rsub.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 6], NULL }, /* pbsdsh.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 7], NULL }, /* qalter.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 8], NULL }, /* qdel.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[ 9], NULL }, /* qhold.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[10], NULL }, /* qmove.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[11], NULL }, /* qmsg.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[12], NULL }, /* qorder.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[13], NULL }, /* qrerun.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[14], NULL }, /* qrls.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[15], NULL }, /* qselect.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[16], NULL }, /* qsig.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[17], NULL }, /* qstat.1B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman1[18], NULL }, /* qsub.1B */

	/*
	 * infrastructure data associated with PBS_EXEC/man/man3
	 */
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, exman3[ 0], NULL }, /* man3 */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 1], NULL }, /* pbs_alterjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 2], NULL }, /* pbs_connect.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 3], NULL }, /* pbs_default.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 4], NULL }, /* pbs_deljob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 5], NULL }, /* pbs_disconnect.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 6], NULL }, /* pbs_geterrmsg.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 7], NULL }, /* pbs_holdjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 8], NULL }, /* pbs_manager.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[ 9], NULL }, /* pbs_movejob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[10], NULL }, /* pbs_msgjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[11], NULL }, /* pbs_orderjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[12], NULL }, /* pbs_rerunjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[13], NULL }, /* pbs_statsched.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[14], NULL }, /* pbs_rescreserve.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[15], NULL }, /* pbs_rlsjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[16], NULL }, /* pbs_runjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[17], NULL }, /* pbs_selectjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[18], NULL }, /* pbs_sigjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[19], NULL }, /* pbs_stagein.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[20], NULL }, /* pbs_statjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[21], NULL }, /* pbs_statnode.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[22], NULL }, /* pbs_statque.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[23], NULL }, /* pbs_statserver.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[24], NULL }, /* pbs_submit.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[25], NULL }, /* pbs_terminate.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[26], NULL }, /* rpp.3 */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[27], NULL }, /* tm.3 */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[28], NULL }, /* pbs_tclapi.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[29], NULL }, /* pbs_delresv.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[30], NULL }, /* pbs_locjob.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[31], NULL }, /* pbs_selstat.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[32], NULL }, /* pbs_statresv.3B */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, exman3[33], NULL }, /* pbs_statfree.3B */

	/*
	 * infrastructure data associated with PBS_EXEC/man/man7
	 */
	{1, 0, 0, drwxrxrx,  tgwow, &dflt_pbs_ug, exman7[ 0], NULL }, /* man7 */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 1], NULL }, /* pbs_job_attributes.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 2], NULL }, /* pbs_node_attributes.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 3], NULL }, /* pbs_queue_attributes.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 4], NULL }, /* pbs_resources.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 5], NULL }, /* pbs_resv_attributes.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 6], NULL }, /* pbs_server_attributes.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 7], NULL }, /* pbs_sched_attributes.7B */
	{1, 0, 0, frwrr, xsgswxowx, &dflt_pbs_ug, exman7[ 8], NULL }, /* pbs_professional.7B */

	/*
	 * infrastructure data associated with PBS_EXEC/man/man8
	 */
	{1, 0, 0,  drwxrxrx,      tgwow, &dflt_pbs_ug, exman8[ 0], NULL }, /* man8 */
	{1, 2, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 1], NULL }, /* pbs_idled.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 2], NULL }, /* pbs_mom.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 3], NULL }, /* pbs_sched.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 4], NULL }, /* pbs_server.8B */
	{1, 2, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 5], NULL }, /* pbsfs.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 6], NULL }, /* pbsnodes.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 7], NULL }, /* qdisable.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 8], NULL }, /* qenable.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[ 9], NULL }, /* qmgr.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[10], NULL }, /* qrun.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[11], NULL }, /* qstart.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[12], NULL }, /* qstop.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[13], NULL }, /* qterm.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[14], NULL }, /* pbs_lamboot.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[15], NULL }, /* pbs_mpilam.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[16], NULL }, /* pbs_password.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[17], NULL }, /* pbs_migrate_users.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[18], NULL }, /* pbs_mpirun.8B */
	{1, 1, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[19], NULL }, /* slot available for use */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[20], NULL }, /* pbs_attach.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[21], NULL }, /* pbs_mkdirs.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[22], NULL }, /* pbs_hostn.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[23], NULL }, /* pbs_probe.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[24], NULL }, /* pbs-report.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[25], NULL }, /* pbs_tclsh.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[26], NULL }, /* pbs_tmrsh.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[27], NULL }, /* pbs_wish.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[28], NULL }, /* printjob.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[29], NULL }, /* pbs.8B */
	{1, 0, 0,     frwrr,  xsgswxowx, &dflt_pbs_ug, exman8[30], NULL } }; /* pbs_interactive.8B */

static MPUG	tcltk_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/tcltk
	 */
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, exec[6],  NULL},
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, extcltk[0], NULL }, /* tcltk/bin */
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, extcltk[1], NULL }, /* tcltk/include */
	{1, 0, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, extcltk[2], NULL }, /* tcltk/lib */
	{1, 0, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, extcltk[3], NULL } }; /* tcltk/license.terms */

static MPUG	python_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/python
	 */
	{1, 2, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, exec[7],  NULL},
	{1, 2, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expython[0], NULL }, /* python/bin */
	{1, 2, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expython[1], NULL }, /* python/include */
	{1, 2, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expython[2], NULL }, /* python/lib */
	{1, 2, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expython[3], NULL }, /* python/man */
	{1, 2, 0,      frwrr,  xsgswxowx, &dflt_pbs_ug, expython[4], NULL }, /* python/python.changes.txt */
	{1, 2, 0,      frwxrxrx,  sgswow, &dflt_pbs_ug, expython[5], NULL } }; /* python/bin/python */

static MPUG	pgsql_mpugs[] = {
	/*
	 * infrastructure data associated with PBS_EXEC/pgsql
	 */
	{1, 6, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, exec[8],  NULL},
	{1, 6, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expgsql[0], NULL }, /* pgsql/bin */
	{1, 6, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expgsql[1], NULL }, /* pgsql/include */
	{1, 6, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expgsql[2], NULL }, /* pgsql/lib */
	{1, 6, 0,   drwxrxrx,      tgwow, &dflt_pbs_ug, expgsql[3], NULL } }; /* pgsql/share */


enum pbshome_mpugs { PH_server, PH_mom, PH_sched, PH_last };

int  home_sizes[PH_last];
char *home_mpug_set[PH_last] = {"pbs_server", "pbs_mom", "pbs_sched"};

enum svr_mpugs { SVR_logs,  SVR_spool, SVR_priv,  SVR_acct,
	SVR_jobs,
	SVR_users, SVR_hooks, SVR_hookswdir, SVR_last };

static MPUG	 svr_mpugs[] = {
	/*
	 * infrastructure data associated with server daemon
	 * home dir, chkfull, required and disallowed modes,
	 * pointer to "valid users, valid groups", path, realpath
	 */
	{2, 0, 0, drwxrxrx,  tgwow,  &dflt_pbs_ug, svrhome[ 0], NULL}, /* logs */
	{2, 0, 0, tdrwxrwxrwx,   0,  &dflt_pbs_ug, svrhome[ 1], NULL}, /* spool */
	{2, 0, 0, drwxrxo, tgworwx,  &dflt_pbs_ug, svrhome[ 2], NULL}, /* priv */
	{1, 1, 0, frwrr, xsgswxowx,  &dflt_pbs_ug, svrhome[ 3], NULL}, /* resourcedef */
	{0, 1, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[ 4], NULL}, /* server.lock */
	{2, 0, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[ 5], NULL}, /* tracking */
	{2, 0, 0, drwxrxrx,  tgwow,  &dflt_pbs_ug, svrhome[ 6], NULL}, /* accounting */
	{2, 0, 0, drwxrxo, tgworwx,  &dflt_pbs_ug, svrhome[ 7], NULL}, /* jobs */
	{2, 0, 0, drwxrxo, tgworwx,  &dflt_pbs_ug, svrhome[ 8], NULL}, /* users */
	{2, 0, 0, drwxrxo, tgworwx,  &dflt_pbs_ug, svrhome[ 9], NULL}, /* hooks */
	{2, 0, 0, drwxrxo, tgworwx,  &dflt_pbs_ug, svrhome[10], NULL}, /* hooks' workdir */
	{1, 0, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[11], NULL}, /* prov_tracking */
	{1, 6, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[12], NULL}, /* db_password */
	{1, 1, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[13], NULL}, /* db_svrhost */
	{1, 1, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[14], NULL}, /* db_svrhost.new */
	{1, 6, 0, frwgo, sgsrwxorwx, &dflt_pbs_ug, svrhome[15], NULL}, /* svrlive */
	{1, 6, 0, drwxgo, tgworwx, &dflt_pbs_data, svrhome[16], NULL}  /* datastore (must be last) */
};


enum mom_mpugs { MOM_aux, MOM_checkpoint, MOM_logs, MOM_priv,
	MOM_jobs, MOM_spool, MOM_undelivered, MOM_last };

static MPUG	mom_mpugs[] = {
	/*
	 * infrastructure data associated with mom daemon
	 * dir, chkfull, required and disallowed modes, pointer
	 * to "valid users, valid groups", path, realpath
	 */
	{2, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, momhome[0], NULL}, /* aux */
	{2, 0, 0, drwxgo,  tgrwxorwx, &dflt_pbs_ug, momhome[1], NULL}, /* checkpoint */
	{2, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, momhome[2], NULL}, /* mom_logs */
	{2, 0, 0, drwxrxx,    tgworw, &dflt_pbs_ug, momhome[3], NULL}, /* mom_priv */
	{0, 1, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, momhome[4], NULL}, /* mom.lock */
	{2, 0, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, momhome[5], NULL}, /* config */
	{2, 0, 0, drwxrxx,    tgworw, &dflt_pbs_ug, momhome[6], NULL}, /* jobs */
	{2, 0, 0, tdrwxrwxrwx,     0, &dflt_pbs_ug, momhome[7], NULL}, /* spool */
	{2, 0, 0, tdrwxrwxrwx,     0, &dflt_pbs_ug, momhome[8], NULL}, /* undelivered */
	{0, 1, 0, drwxgo,     tgworw, &dflt_pbs_ug, momhome[9], NULL}, /* config.d */
	{0, 1, 0, drwxgo,     tgworw, &dflt_pbs_ug, momhome[10], NULL}, /* mom_priv/hooks */
	{0, 1, 0, drwxgo,     tgworw, &dflt_pbs_ug, momhome[11], NULL}};/* mom_priv/hooks/tmp */



enum sched_mpugs { SCHED_logs, SCHED_priv, SCHED_last };

static MPUG	sched_mpugs[] = {
	/*
	 * infrastructure data associated with sched daemon
	 * dir, chkfull, required and disallowed modes, pointer
	 * to "valid users, valid groups", path, realpath
	 */
	{2, 0, 0, drwxrxrx,    tgwow, &dflt_pbs_ug, schedhome[0], NULL}, /* sched_logs */
	{2, 0, 0, drwxrxo,   tgworwx, &dflt_pbs_ug, schedhome[1], NULL}, /* sched_priv */
	{2, 0, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, schedhome[2], NULL}, /* dedicated_time */
	{2, 0, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, schedhome[3], NULL}, /* holidays */
	{2, 0, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, schedhome[4], NULL}, /* sched_config */
	{2, 0, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, schedhome[5], NULL}, /* resource_group */
	{0, 1, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, schedhome[6], NULL}, /* sched.lock */
	{2, 1, 0, frwrr,   xsgswxowx, &dflt_pbs_ug, schedhome[7], NULL} }; /* sched_out */




enum  msg_sources { SRC_pri, SRC_home, SRC_exec, SRC_last, SRC_none };
enum  msg_categories { MSG_md, MSG_mf, MSG_po, MSG_unr, MSG_real, MSG_pri, MSG_oth, MSG_last, MSG_none };
/*
 * MSG_md   - missing directories
 * MSG_mf   - missing files
 * MSG_po   - permission/owner errors
 * MSG_unr  - unrecognized directory entry
 * MSG_pri  - primary data
 * MSG_real - real path problem
 * MSG_oth  - other problems
 * MSG_last - last enumeration value
 */

/*
 * The structure below is used in mechanizing storage of messages in
 * memory for subsequent output.  Things are done this in order that
 * there be more flexibility/control over how information flowing on
 * stdout is organized.
 *
 * For each "source" of output messages, there will be an instance of
 * PROBEMSGS data structure - i.e.,
 * there will be an instance for messages relating to the PRIMARY data,
 * one relating to messages associated with PBS HOME data, and one
 * relating to messages associated with PBS EXEC data.
 */

typedef struct	probemsgs {
	/*
	 * each pointer in mtbls will point to an array of
	 * pointers to messages.  The message pointers in each
	 * array are pointing to output messages from pbsprobe that
	 * belong to the same "category" of message - e.g. messages
	 * about a file being "missing". (see enum msg_categories)
	 *
	 * Structure member "idx" is an array of index values, one for
	 * each array of message pointers - e.g. idx[MSG_mf] holds the
	 * index of the last "missing file" message placed in the array.
	 */
	char **mtbls[MSG_last];
	int  idx[MSG_last];
}  PROBEMSGS;


typedef struct	infrastruct {

	int	mode;		/* pbsprobe "mode" */
	char*	phost;		/* host running pbsprobe */

	/* PRIMARY related MPUGS and their sources */

	PRIMARY	pri;

	/* pointers to PBS HOME related MPUG arrays */

	MPUG	*home[PH_last];

	/* pointers to PBS EXEC related MPUG arrays */

	MPUG	*exec[EXEC_last];

	PROBEMSGS *msgs[SRC_last];

	struct utsdata	utsd;
	struct statdata statd;
} INFRA;

static void	am_i_authorized(void);
static void	infrastruct_params(struct infrastruct *, int);
static void	adjust_for_os(struct infrastruct *pinf);
static void	print_infrastruct(struct infrastruct *);
static void	title_string(enum code_title, int, INFRA *);
static void	print_problems(INFRA *);
static void	msg_table_set_defaults(INFRA *, int, int);
static int	put_msg_in_table(INFRA *, int, int, char*);
static int	get_primary_values(struct infrastruct *);
static int	get_realpath_values(struct infrastruct *);
static int	is_parent_rpathnull(char *, MPUG **, int, int *);
#if 0
static int	is_suffix_ok(char *, char *);
static int	inspect_dir_entries(struct infrastruct *);
static const	char *which_suffixset(MPUG *);
static MPUG	**which_knwn_mpugs(MPUG *, MPUG *[], int *, int asz);
static MPUG	**which_Knwn_mpugs(MPUG *, MPUG *, int);
static void	chk_entries(MPUG *, MPUG **);
static void	pbs_dirtype(int *, MPUG *);
static int	non_db_resident(MPUG*, char*, int, char *entryname);
static int	is_a_numericname(char *);
#endif
static int	check_paths(struct infrastruct *);
static int	check_owner_modes(char *, MPUG *, int);
static int	mbits_and_owner(struct stat *, MPUG *, int);
static char	*perm_string(mode_t);

static const char *perm_owner_msg(struct stat *, MPUG *, ADJ *, int);
static const char *owner_string(struct stat *, MPUG *, int);

static int	process_ret_code(enum func_names, int, struct infrastruct *);
static int	conf4primary(FILE *, struct infrastruct *);
static int	env4primary(struct infrastruct *);
static void     fix(int, int, int, MPUG *, ADJ *, struct stat *, int);
static void     fix_perm_owner(MPUG *, struct stat *, ADJ *);

/* Variables visible to all functions in this file */

static int   flag_verbose;
static	int  mode = 0;
static	int  max_level = FIX_po;
int	nonlocaldata = 0;
/**
 * @Brief
 *      This is main function of pbs_probe process.
 *
 * @return	int
 * @retval	0	: On Success
 * @retval	!=0	: failure
 *
 */
int
main(int argc, char *argv[])
{
	int rc;
	int i=0;
	int err=0;
	struct infrastruct infra;

	extern int optind;

	/*the real deal or output pbs_version and exit?*/
	execution_mode(argc, argv);

	/* If not authorized, don't proceed any further */
	am_i_authorized();

	/*
	 * Check that this invocation of pbsprobe is properly formed
	 * compute the "run mode"
	 */

	while (err == 0 && (i = getopt(argc, argv, "fcv")) != EOF) {

		switch (i) {

				/*other two "recognized" modes*/

			case 'v':
				flag_verbose = 1;
				break;

			case 'f':
				if (mode)
					/*
				 *program allows only one mode at a time, so if
				 *already has a value that is bad
				 */
					err = 1;
				else
					mode = i;
				break;

				/*
				 * Currently, only options are: "none", f, v
				 * Also, for any non-recognized option getopt outputs
				 * an error message to stderr.
				 */

			case 'c':
			default: err = 1;
		}
	}


	if (err == 0 && mode != 'c' && argv[optind] == NULL) {

		/*
		 * Determine name of this host, pbs.conf pathname,
		 * and values for certain primary parameters
		 */

		infrastruct_params(&infra, mode);
		msg_table_set_defaults(&infra, SRC_pri, MSG_oth);

		/*
		 * generate for each infrastructure file/directory
		 * the canonicalized, absolute pathname
		 */

		if ((rc = get_realpath_values(&infra)))
			exit(rc);

		/*
		 * check modes/ownership on those database paths which
		 * successfully mapped to a realpath
		 */

		check_paths(&infra);

		/*
		 * For existing infrastucture directories, inspect their
		 * entries for validity:
		 *   - valid name  (name in database, other general criteria)
		 *   - valid modes (modes from database or suitable default)
		 *
		 * example:
		 * checking content of server's "jobs" directory by checking
		 * entry's suffix and mode
		 */

#if 0
		inspect_dir_entries(&infra);
#endif
		print_problems(&infra);

	} else {

		/*
		 * err == 0 || (for the time being) mode == 'c'
		 * output typical kind of usage message
		 */
		title_string(TC_use, mode, &infra);
		exit(1);
	}

	if (flag_verbose)
		print_infrastruct(&infra);
	exit(0);
}
/**
 * @brief
 * 		Check whether user is authorized to use pbsprobe.
 *
 * @par MT-safe:	No
 */
static void
am_i_authorized(void)
{
	static char allow[] = "root";
	uid_t getuid(void);
	struct passwd *ppwd = getpwuid(getuid()) ;

	if (ppwd && strcmp(ppwd->pw_name, allow) == 0)
		return;

	/*problem encountered*/

	if (ppwd)
		fprintf(stderr, "User %s not authorized to use pbsprobe\n", ppwd->pw_name);
	else
		fprintf(stderr, "Problem checking user authorization for utility\n");
	exit(1);
}
/**
 * @brief
 * 		configure values for various infrastructure parameters.
 *
 * @param[out]	pinf	-	 structpointer to infrastruct
 * @param[out]	mode	-	 pbsprobe "mode"
 */
static void
infrastruct_params(struct infrastruct *pinf, int mode)
{

	int	i, rc;			/* return code */
	char	hname[PBS_MAXHOSTNAME+1];

	memset((void *)pinf, 0, (size_t)sizeof(struct infrastruct));

	for (i=0; i<SRC_last; ++i) {
		pinf->msgs[i] = (PROBEMSGS *)malloc(sizeof(PROBEMSGS));
		if (pinf->msgs[i] == NULL) {
			fprintf(stderr, "pbs_probe: Out of Memory\n");
			exit(1);
		}
		memset((void *)pinf->msgs[i], 0, sizeof(PROBEMSGS));
	}

	pinf->mode = mode;
	pinf->pri.pbs_mpug = &pbs_mpugs[0];

	if (gethostname(hname, (sizeof(hname) - 1)))
		strcpy(hname, "localhost");
	pinf->phost = strdup(hname);

	if (uname(&pinf->utsd.ub) >= 0) {
		pinf->utsd.populated = 1;
		adjust_for_os(pinf);
	}

	/*
	 * output a title and accompanying system information
	 */

	title_string(TC_sys, mode, pinf);

	/*
	 * determine values for the primary variables:
	 * paths - pbs_home, ps_exec,
	 * pbs_start_server, pbs_start_mom, pbs_start_sched
	 */

	if ((rc = get_primary_values(pinf)))
		if (process_ret_code(GET_PRIMARY_VALUES, rc, pinf)) {
			print_problems(pinf);
			exit(1);
		}

	if (nonlocaldata)	/* don't check datastore if it is nonlocal */
		home_sizes[PH_server] -= 1;

	/*
	 * PBS HOME:  load pointers to the various arrays of MPUG data
	 * relevant to value of PBS HOME stored in *pinf's pri element
	 */

	if (pinf->pri.started.server)
		pinf->home[PH_server] = &svr_mpugs[0];

	if (pinf->pri.started.mom)
		pinf->home[PH_mom] =    &mom_mpugs[0];

	if (pinf->pri.started.sched)
		pinf->home[PH_sched] =  &sched_mpugs[0];

	/*
	 * Record install type in the "notbits" variable
	 */

	if (pinf->pri.started.server == 0 &&
		pinf->pri.started.sched == 0  &&  pinf->pri.started.mom) {

		/* did "execution-only" install */

		notbits |= 0x4;
	}
	else if (!pinf->pri.started.server && !pinf->pri.started.sched &&
		!pinf->pri.started.mom) {
		/* did "cmds-only" install */
		notbits |= 0x2;
	}

	home_sizes[PH_server] = sizeof(svr_mpugs)/sizeof(MPUG);
	home_sizes[PH_mom] =  sizeof(mom_mpugs)/sizeof(MPUG);
	home_sizes[PH_sched] = sizeof(sched_mpugs)/sizeof(MPUG);

	/*
	 * PBS EXEC:  load pointers to the various arrays of MPUG data
	 * relevant to value of PBS EXEC stored in *pinf's pri element
	 */

	pinf->exec[EXEC_exec] =  &exec_mpugs[0]; /* make irix compiler happy */
	pinf->exec[EXEC_exec] =  NULL;
	pinf->exec[EXEC_bin] =   &bin_mpugs[0];
	pinf->exec[EXEC_sbin] =  &sbin_mpugs[0];
	pinf->exec[EXEC_etc] =   &etc_mpugs[0];
	pinf->exec[EXEC_lib] =   &lib_mpugs[0];
	pinf->exec[EXEC_man] =   &man_mpugs[0];
	pinf->exec[EXEC_man1] =  NULL;
	pinf->exec[EXEC_man3] =  NULL;
	pinf->exec[EXEC_man7] =  NULL;
	pinf->exec[EXEC_man8] =  NULL;

	pinf->exec[EXEC_tcltk] =   &tcltk_mpugs[0];
	pinf->exec[EXEC_python] =   &python_mpugs[0];
	pinf->exec[EXEC_include] = &include_mpugs[0];
	pinf->exec[EXEC_pgsql] =   &pgsql_mpugs[0];

	exec_sizes[EXEC_exec] = sizeof(exec_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_bin] =  sizeof(bin_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_sbin] = sizeof(sbin_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_etc] =  sizeof(etc_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_lib] =  sizeof(lib_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_man] =  sizeof(man_mpugs)/sizeof(MPUG);

	exec_sizes[EXEC_man1] = 0;
	exec_sizes[EXEC_man3] = 0;
	exec_sizes[EXEC_man7] = 0;
	exec_sizes[EXEC_man8] = 0;

	exec_sizes[EXEC_tcltk] =   sizeof(tcltk_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_python] =   sizeof(python_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_include] = sizeof(include_mpugs)/sizeof(MPUG);
	exec_sizes[EXEC_pgsql] =   sizeof(pgsql_mpugs)/sizeof(MPUG);
}
/**
 * @brief
 * 		adjust the infrastruct parameter values based on the os.
 *
 * @param[out]	pinf	-	 pointer to infrastruct
 */
static void
adjust_for_os(struct infrastruct *pinf)
{
	/* offset to use with specific MPUG array */

	int	ofs_bin = 1;  /* use with bin_mpugs[] */
	int	ofs_lib = 1;  /* use with lib_mpugs[] */
	int	ofs_sbin = 1; /* use with sbin_mpugs[] */

	if (strstr(pinf->utsd.ub.sysname, "Linux") != NULL) {

		/* Linux: pbs_lamboot, pbs_mpilam, pbs_mpirun, mpiexec, pbsrun, pbsrun_wrap, pbsrun_unwrap  */

		bin_mpugs[ofs_bin + 36].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 37].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 38].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 43].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 44].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 45].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 46].notReq &= ~(0x1);

		/* Linux + /etc/sgi-release => SGI Altix		*/
		/* Linux + /etc/sgi-compute-node_release => SGI ICE	*/
		if ((access("/etc/sgi-release", R_OK) == 0) ||
			(access("/etc/sgi-compute-node-release", R_OK) == 0)) {
			lib_mpugs[ofs_lib + 23].notReq = 0;    /* sgiMPI.awk       */
			sbin_mpugs[ofs_sbin + 5].notReq = 0x2; /* pbs_mom.cpuset   */
			sbin_mpugs[ofs_sbin + 6].notReq = 0x2; /* pbs_mom.standard */
		}

		/* Linux: pbsrun.<keyword>.init.in files must exist */
		lib_mpugs[ofs_lib + 24].notReq &= ~(0x1);
		lib_mpugs[ofs_lib + 25].notReq &= ~(0x1);
		lib_mpugs[ofs_lib + 26].notReq &= ~(0x1);
		lib_mpugs[ofs_lib + 27].notReq &= ~(0x1);
		lib_mpugs[ofs_lib + 28].notReq &= ~(0x1);
		lib_mpugs[ofs_lib + 29].notReq &= ~(0x1);
		bin_mpugs[ofs_bin + 30].notReq &= ~(0x1);
	}
}

/**
 * @brief
 * 		print the values of infrstruct.
 *
 * @param[in]	pinf	-	 pointer to infrastruct
 */
static void
print_infrastruct(struct infrastruct *pinf)
{
	int	i, j;
	int	tflag;
	MPUG	*pmpug;

	tflag = 0;
	for (i=0; i<PBS_last; ++i) {

		if (!tflag) {
			++tflag;
			title_string(TC_tvrb, mode, pinf);
		}

		if (pinf->pri.pbs_mpug[i].path) {

			if (tflag == 1) {
				++tflag;
				title_string(TC_datpri, mode, pinf);
			}
			fprintf(stdout, "%s: %s\n", mhp[i], pinf->pri.pbs_mpug[i].path);
		}
	}
	if (tflag) {
		fprintf(stdout, "%s: %d\n", mhp[MHP_svr], pinf->pri.started.server);
		fprintf(stdout, "%s: %d\n", mhp[MHP_mom], pinf->pri.started.mom);
		fprintf(stdout, "%s: %d\n", mhp[MHP_sched], pinf->pri.started.sched);
	}

	tflag = 0;
	for (i=0; i<PH_last; ++i) {

		if ((pmpug = pinf->home[i]) == NULL || (pmpug->notReq & notbits))
			continue;

		if (!tflag++)
			title_string(TC_datho, mode, pinf);

		fprintf(stdout, "\nHierarchy %s:\n", home_mpug_set[i]);

		for (j=0; j<home_sizes[i]; ++j, ++pmpug) {

			if (pmpug->path == NULL || (pmpug->notReq & notbits))
				continue;

			fprintf(stdout, "%-40s(%s, %s)\n", pmpug->path, perm_string((mode_t)pmpug->req_modes), owner_string(NULL, pmpug, 0));
		}
	}

	tflag = 0;
	for (i=0; i<EXEC_last; ++i) {

		if ((pmpug = pinf->exec[i]) == NULL || (pmpug->notReq & notbits))
			continue;

		if (!tflag++)
			title_string(TC_datex, mode, pinf);

		fprintf(stdout, "\nHierarchy %s:\n\n", exec_mpug_set[i]);

		for (j=0; j<exec_sizes[i]; ++j, ++pmpug) {

			if (pmpug->path == NULL || (pmpug->notReq & notbits))
				continue;

			fprintf(stdout, "%-40s(%s, %s)\n", pmpug->path, perm_string((mode_t)pmpug->req_modes), owner_string(NULL, pmpug, 0));
		}
	}
}
/**
 * @brief
 * 		print the title string based on the code_title value.
 *
 * @param[in]	tc	-	code_title value.
 * @param[in]	mode	-	mode (not used here)
 * @param[in]	pinf	-	pointer to infrastruct
 */
static void
title_string(enum code_title tc, int mode, INFRA *pinf)
{
	switch (tc) {
		case TC_sys:
			fprintf(stdout, "\n\n====== System Information =======\n\n");
			fprintf(stdout,
				"\nsysname=%s\nnodename=%s\nrelease=%s\nversion=%s\nmachine=%s\n",
				pinf->utsd.ub.sysname, pinf->utsd.ub.nodename,
				pinf->utsd.ub.release, pinf->utsd.ub.version,
				pinf->utsd.ub.machine);
			break;

		case TC_top:
			fprintf(stdout,
				"\n\n====== PBS Infrastructure Report =======\n\n");
			break;

		case TC_pri:
			fprintf(stdout,
				"\n\n====== Problems in pbs_probe's Primary Data =======\n\n");
			break;

		case TC_ho:
			fprintf(stdout,
				"\n\n====== Problems in PBS HOME Hierarchy =======\n\n");
			break;

		case TC_ex:
			fprintf(stdout,
				"\n\n====== Problems in PBS EXEC Hierarchy =======\n\n");
			break;

		case TC_ro:
		case TC_fx:
		case TC_cnt:
			/* Not explicitely handled, but keeps compiler quiet. */
			break;

			/*
			 * verbose related strings
			 */

		case TC_tvrb:
			fprintf(stdout,
				"\n\n=== Primary variables and specific hierarchies checked by pbs_probe ===\n\n");
			break;

		case TC_datpri:
			fprintf(stdout, "\nPbs_probe's Primary variables:\n\n");
			break;

		case TC_datho:
			fprintf(stdout, "\n\n=== PBS HOME Infrastructure ===\n");
			break;

		case TC_datex:
			fprintf(stdout, "\n\n=== PBS EXEC Infrastructure ===\n");
			break;

		case TC_noerr:
			fprintf(stdout,
				"\n\n=== No PBS Infrastructure Problems Detected ===\n");
			break;

		case TC_use:
			fprintf(stderr, "Usage: pbs_probe [ -fv ]\n");
			fprintf(stderr, "       pbs_probe --version\n");
			fprintf(stderr,
				"\tno option - run in 'report' mode\n");
			fprintf(stderr,
				"\t-f        - run in 'fix' mode\n");
			fprintf(stderr,
				"\t-v        - show hierarchy examined\n");
			fprintf(stderr,
				"\t--version - show PBS Pro version and exit\n");
			break;
	}
}
/**
 * @brief
 * 		print the title string based on the code_title value.
 *
 * @param[in]	tc	-	code_title value.
 * @param[in]	mode	-	mode (not used here)
 * @param[in]	pinf	-	pointer to infrastruct
 */
static void
print_problems(INFRA *pinf)
{
	int i, j, k;
	int idx;
	int tflag, output_err = 0;
	char **pa;

	for (i=0; i<SRC_last; ++i) {
		tflag = 0;
		for (j=0; j < MSG_last; ++j) {

			if (pinf->msgs[i]->mtbls[j] == NULL)
				continue;

			if (!tflag++)
				switch (i) {
					case SRC_pri:
						title_string(TC_pri, mode, pinf);
						break;

					case SRC_home:
						title_string(TC_ho, mode, pinf);
						break;

					case SRC_exec:
						title_string(TC_ex, mode, pinf);
						break;

					default:
						break;
				}
			idx = pinf->msgs[i]->idx[j];
			pa = pinf->msgs[i]->mtbls[j];
			for (k=0; k < idx; ++k) {
				output_err = 1;
				fprintf(stdout, "%s\n", pa[k]);
			}
		}
	}
	if (output_err == 0)
		title_string(TC_noerr, mode, pinf);
}

/**
 * @brief
 * 		Calling put_msg_in_table with a NULL message pointer is the
 * 		mechanism used to cause the loading of new values into the
 *	 	function's three internal static variables: dflt_pinf, dflt_src,
 * 		dflt_cat - i.e. causing new default values to be established.
 *
 * @param[in]	pinf	-	pointer to infrastruct
 * @param[in]	src	-	default source.
 * @param[in]	category	-default category.
 */
static void
msg_table_set_defaults(INFRA *pinf, int src, int category)
{

	put_msg_in_table(pinf, src, category, NULL);
}
/**
 * @brief
 * 		put values in message table.
 *
 * @param[in]	pinf	-	pointer to infrastruct
 * @param[in]	src	-	source. can be SRC_pri, SRC_home,
 * 						SRC_exec, SRC_last, SRC_none
 * @param[in]	category	-	message category.
 * @param[in]	msg	-	message which needs to be put into table.
 *
 * @return	int
 * @retval	0	: things are fine.
 * @retval	1	: something smells bad!
 *
 * @par MT-safe: No
 */
static int
put_msg_in_table(INFRA *pinf, int src, int category, char* msg)
{
	static INFRA			*dflt_pinf = NULL;
	static enum  msg_sources	dflt_src = SRC_none;
	static enum  msg_categories	dflt_cat = MSG_none;
	static char  *msg_headers[MSG_last] = { NULL};

	char   **ptbl;
	char   **mtb;
	int    idx;

	/*
	 * One shot: Create pointers to table headings
	 */

	if (msg_headers[0] == NULL) {
		msg_headers[MSG_md]   = "Missing Directory Problems:";
		msg_headers[MSG_mf]   = "Missing File Problems:";
		msg_headers[MSG_po]   = "Permission/Ownership Problems:";
		msg_headers[MSG_unr]  = "Directory Entry Problems:";
		msg_headers[MSG_pri]  = "Primary Data Problems:";
		msg_headers[MSG_oth]  = "Other Problems:";
		msg_headers[MSG_real] = "Real Path Problems:";
	}

	if (msg == NULL) {

		/* Load new default values */

		if (pinf)
			dflt_pinf = pinf;

		if (src != SRC_none) {
			if (src != SRC_pri && src != SRC_home && src != SRC_exec) {

				fprintf(stderr, "put_msg_in_table: Bad value for argument \"src\"\n");
				exit(1);
			}
			dflt_src = (enum  msg_sources)src;
		}

		if (category != MSG_none) {

			if (category != MSG_mf   &&  category  != MSG_md  &&
				category != MSG_po   &&  category  != MSG_unr &&
				category != MSG_real &&  category  != MSG_pri &&
				category != MSG_oth) {

				fprintf(stderr, "put_msg_in_table: Bad value for argument \"category\"\n");
				exit(1);
			}
			dflt_cat = (enum  msg_categories)category;
		}

		return (0);
	} /* end of msg == NULL */

	if (pinf == NULL) {
		if (dflt_pinf == NULL) {
			fprintf(stderr, "put_msg_in_table: No default set for pinf\n");
			exit(1);
		}
		pinf = dflt_pinf;
	}

	if (src == SRC_none) {
		if (dflt_src == SRC_none) {
			fprintf(stderr, "put_msg_in_table: No default value for \"argument\" src\n");
			exit(1);
		}
		src = dflt_src;
	}

	if (src != SRC_pri && src != SRC_home && src != SRC_exec) {

		fprintf(stderr, "put_msg_in_table: Bad value for message source\n");
		fprintf(stderr, "message %s:  not saved to table\n\n", msg);
		return (1);
	}

	if (category == MSG_none) {
		if (dflt_cat == MSG_none) {
			fprintf(stderr, "put_msg_in_table: No default value for \"argument\" category\n");
			exit(1);
		}
		category = dflt_cat;
	}

	if (category != MSG_mf  && category != MSG_md  && category != MSG_po &&
		category != MSG_unr && category != MSG_pri && category != MSG_oth &&
		category != MSG_real) {

		fprintf(stderr, "put_msg_in_table: Bad value for message category\n");
		fprintf(stderr, "message %s:  not saved to table\n\n", msg);
		return (1);
	}

	if (pinf->msgs[src] != NULL) {
		if (pinf->msgs[src]->mtbls[category] == NULL) {

			/*
			 * No table exists, malloc memory for one and store
			 * in the first location a pointer to a header message
			 */

			mtb = (char **)malloc(DFLT_MSGTBL_SZ * sizeof(char *));
			if (mtb == NULL) {
				fprintf(stderr, "pbs_probe: Out of Memory\n");
				return (1);
			}
			pinf->msgs[src]->mtbls[category] = mtb;
			idx = pinf->msgs[src]->idx[category];

			pinf->msgs[src]->mtbls[category][idx] = msg_headers[category];
			++pinf->msgs[src]->idx[category];
		}
	} else {

		fprintf(stderr, "put_msg_in_table: No initialization of pinf->msgs\n");
		exit(1);
	}

	idx = pinf->msgs[src]->idx[category];
	if (idx >= DFLT_MSGTBL_SZ) {
		fprintf(stderr, "put_msg_in_table: Table full\n");
		fprintf(stderr, "message %s:  not saved to table\n\n", msg);
		return (1);
	}

	/* add pointer to the message into the table and bump table index */

	ptbl = pinf->msgs[src]->mtbls[category];
	ptbl [ idx ] = strdup(msg);
	++pinf->msgs[src]->idx[category];
	return (0);
}
/**
 * @brief
 * 		get primary vaues from configuration file Then,
 * 		over ride conf derived settings with any values
 * 		set in the process's environment.
 *
 * @param[in]	pinf	-	pointer to infrastruct
 *
 * @return	int
 * @retval	0	: things are fine.
 * @retval	!=0	: something smells bad!
 */
static int
get_primary_values(struct infrastruct *pinf)
{
	FILE	*fp;
	int	rc;
	char	*gvalue;		/* used with getenv() */


	origin_names[PBS_conf] = "PBS CONF FILE";
	origin_names[PBS_home] = "PBS HOME";
	origin_names[PBS_exec] = "PBS EXEC";

	/*
	 * determine path for PBS infrastructure configuration file
	 */

	pinf->pri.pbs_mpug = &pbs_mpugs[0];

	gvalue = getenv("PBS_CONF_FILE");
	if (gvalue == NULL || *gvalue == '\0') {
		pinf->pri.pbs_mpug[PBS_conf].path = default_pbsconf;
		pinf->pri.src_path.conf = SRC_DFLT;
	} else {
		pinf->pri.pbs_mpug[PBS_conf].path = strdup(gvalue);
		pinf->pri.src_path.conf = SRC_ENV;
	}

	if ((fp = fopen(pinf->pri.pbs_mpug[PBS_conf].path, "r")) == NULL) {
		if (stat(pinf->pri.pbs_mpug[PBS_conf].path, &pinf->statd.sb)) {
			if (errno == ENOENT)
				if (mode != 'f')
					return (PBS_CONF_NO_EXIST);
			else {
#if 0
				/*
				 * In "fix" mode and pbs.conf doesn't exist
				 * try to find and run pbs_postinstall to create it
				 */
				path = pinf->pri.pbs_mpug[PBS_conf].path;
				return (pbsdotconf(path));
				return (PBS_CONF_NO_EXIST);
#endif
				return (PBS_CONF_CAN_NOT_OPEN);
			}
			else
				return (PBS_CONF_CAN_NOT_OPEN);
		}
	}

	/*
	 * first source for the primary variables is the config file
	 * Then, over ride conf derived settings with any values set
	 * in the process's environment
	 */

	if ((rc = conf4primary(fp, pinf))) {
	}

	if ((rc = env4primary(pinf))) {
	}
	return (rc);
}
/**
 * @brief
 * 		Read the PBS_CONF_FILE path and store in a buffer.
 *
 * @param[in]	path	-	PBS_CONF_FILE path
 *
 * @return	int
 * @retval	PBS_CONF_NO_EXIST	: No PBS_CONF_FILE.
 */
#if 0
static int
pbsdotconf(char * path)
{

	char	*gvalue_save = NULL;

	if (path == NULL)
		return (PBS_CONF_NO_EXIST);

	pbuf = malloc(strlen("PBS_CONF_FILE=") + strlen(path) + 1);
	if (pbuf == NULL)
		return (PBS_CONF_NO_EXIST);

	if ((gvalue = getenv("PBS_CONF_FILE")) != NULL)
		if ((len = strlen(gvalue)))
			gvalue_save = strdup(gvalue);

	strcpy(pbuf, "PBS_CONF_FILE=");
	strcat(pbuf, path);
	if ((rc = putenv(pbuf))) {
		free(pbuf);
		if (gvalue_save)
			free(gvalue_save);
		return (PBS_CONF_NO_EXIST);
	}
}
#endif
/**
 * @brief
 * 		First try and resolve to a real path the MPUG path
 * 		data belonging to *pinf's "pri" member.
 * @par
 * 		If the PBS HOME pathname was resolvable to a realpath in
 * 		the file system - i.e. have good PBS HOME primary value,
 * 		compute MPUG data for PBS_HOME hierarchy.
 *
 * @param[in]	pinf	-	PBS_CONF_FILE path
 *
 * @return	int
 * @retval	0	: good to go.
 */
static	int
get_realpath_values(struct infrastruct *pinf)
{
	char *real = NULL;
	char path[MAXPATHLEN + 1];
	char *endhead;
	char demarc[]="/";
	int  i, j;
	MPUG *pmpug;
	int  good_prime[PBS_last];
	char *msgbuf;

	/*
	 * First try and resolve to a real path the MPUG path
	 * data belonging to *pinf's "pri" member
	 */
	for (i = 0; i < PBS_last; ++i) {
		good_prime[i] = 0;
		if (pinf->pri.pbs_mpug[i].path) {
			if ((real = realpath(pinf->pri.pbs_mpug[i].path, NULL)) != NULL) {
				pinf->pri.pbs_mpug[i].realpath = strdup(real);
				good_prime[i] = 1;
				free(real);
			} else if (pinf->pri.pbs_mpug[i].notReq == 0) {
				/*
				 * system not able to convert path string to valid
				 * file system path
				 */
				pbs_asprintf(&msgbuf,
					"Unable to convert the primary, %s, string to a real path\n%s\n",
					origin_names[i], strerror(errno));
				put_msg_in_table(pinf, SRC_pri, MSG_pri, msgbuf);
				free(msgbuf);
				pbs_asprintf(&msgbuf, "%s: %s\n",
					origin_names[i], pinf->pri.pbs_mpug[i].path);
				put_msg_in_table(pinf, SRC_pri, MSG_pri, msgbuf);
				free(msgbuf);
				/* good_prime[i] = 0; */
			}
		} else {
			if (pinf->pri.pbs_mpug[i].notReq == 0) {
				pbs_asprintf(&msgbuf, "Missing primary path %s", 
					origin_names[i]);
				put_msg_in_table(pinf, SRC_pri, MSG_pri, msgbuf);
				free(msgbuf);
			}
		}
	}
	for (i = 0; i < PBS_last; ++i) {
		if (good_prime[i] == 0 && pinf->pri.pbs_mpug[i].notReq == 0) {
			print_problems(pinf);
			exit(0);
		}
	}

	/*
	 * If the PBS HOME pathname was resolvable to a realpath in
	 * the file system - i.e. have good PBS HOME primary value,
	 * compute MPUG data for PBS_HOME hierarchy.
	 */

	if (good_prime[PBS_home]) {
		/* only need to check database directory if it is local */
		if (nonlocaldata == 0) {
			int fd;
			struct stat st;
			char buf[MAXPATHLEN+1];
			struct passwd	*pw;

			/*
			 * create path for db_user
			 * This is done outside of the table driven files
			 * because it is optional and no message should
			 * be generated if it does not exist.
			 */
			strcpy(path, pinf->pri.pbs_mpug[PBS_home].path);
			strcat(path, "/server_priv/db_user");

			if ((fd = open(path, O_RDONLY)) != -1) {
				if (fstat(fd, &st) != -1) {
					if ((st.st_mode & 0777) != 0600) {
						pbs_asprintf(&msgbuf,
							"%s, permission must be 0600\n",
							path);
						put_msg_in_table(NULL,
							SRC_home, MSG_real, msgbuf);
						free(msgbuf);
					}
					if (st.st_uid != 0) {
						pbs_asprintf(&msgbuf,
							"%s, owner must be root\n",
							path);
						put_msg_in_table(NULL,
							SRC_home, MSG_real, msgbuf);
						free(msgbuf);
					}
					if (st.st_size < sizeof(buf) &&
						read(fd, buf, st.st_size) ==
						st.st_size) {
						buf[st.st_size] = 0;
						pw = getpwnam(buf);
						if (pw != NULL)
							pbs_dataname[0] = strdup(buf);
						else {
							pbs_asprintf(&msgbuf,
								"db_user %s does not exist\n",
								buf);
							put_msg_in_table(NULL,
								SRC_home, MSG_real, msgbuf);
							free(msgbuf);
						}
					}
				}
				close(fd);
			}
			pw = getpwnam(pbs_dataname[0]);
			if (pw != NULL)
				pbsdata[0] = pw->pw_uid;
		}

		strcpy(path, pinf->pri.pbs_mpug[PBS_home].path);
		strcat(path, demarc);
		endhead = &path[strlen(path)];

		for (i = 0; i < PH_last; ++i) {
			if ((pmpug = pinf->home[i]) == NULL)
				continue;

			for (j = 0; j < home_sizes[i]; ++j) {
				if (pmpug[j].path) {

					/* proceed only if parent realpath is not NULL */

					if (is_parent_rpathnull(pmpug[j].path, pinf->home, PH_last, home_sizes))
						continue;

					strcpy(endhead, pmpug[j].path);

					if ((real = realpath(path, NULL)) != NULL) {
						pmpug[j].realpath = strdup(real);
						free(real);
					} else if ((pmpug[j].notReq & notbits) == 0) {

						if (errno == ENOENT)
							pbs_asprintf(&msgbuf, "%s, %s\n",
								path, strerror(errno));
						else
							pbs_asprintf(&msgbuf,
								"%s,  errno = %d\n",
								path, errno);

						put_msg_in_table(NULL, SRC_home, MSG_real, msgbuf);
						free(msgbuf);
					}
				}
			}
		}
	}


	/*
	 * If the PBS EXEC string was  resolvable to a realpath in
	 * the file system - i.e. have good PBS HOME primary value,
	 * compute MPUG data for PBS EXEC hierarchy
	 */

	if (good_prime[PBS_exec]) {
		strcpy(path, pinf->pri.pbs_mpug[PBS_exec].path);
		strcat(path, demarc);
		endhead = &path[strlen(path)];

		for (i = 0; i < EXEC_last; ++i) {

			if ((pmpug = pinf->exec[i]) == NULL)
				continue;

			for (j = 0; j < exec_sizes[i]; ++j) {
				if (pmpug[j].path) {

					/* proceed only if parent realpath is not NULL */

					if ((is_parent_rpathnull(pmpug[j].path, pinf->exec, EXEC_last, exec_sizes)))
						continue;

					strcpy(endhead, pmpug[j].path);

					if ((real = realpath(path, NULL)) != NULL) {
						pmpug[j].realpath = strdup(real);
						free(real);
					} else if ((pmpug[j].notReq & notbits) == 0) {

						if (errno == ENOENT)
							pbs_asprintf(&msgbuf, "%s, %s\n",
								path, strerror(errno));
						else
							pbs_asprintf(&msgbuf,
								"%s,  errno = %d\n",
								path, errno);
						put_msg_in_table(NULL, SRC_exec, MSG_real, msgbuf);
						free(msgbuf);
					}
				}
			}
		}
	}

	return (0);
}

/**
 * @brief
 * 		Does path have a parent directory?
 * @par
 * 		replace demarc value
 *
 * @param[in]	path	-	location of file/directory
 * @param[in]	mpa	-	pointer to MPUG structure which stores file/directory properties.
 * @param[in]	nelts	-	number of elements in mpa
 * @param[in]	nmems	-	array storing number of members for each MPUG.
 *
 * @return	int
 * @retval	0	: good to go.
 * @retval	1	: parent unresolved.
 */
static int
is_parent_rpathnull(char *path, MPUG **mpa, int nelts, int * nmems)
{
	char *dp;
	MPUG *mpug;
	int  i, j;
	int  rc = 0, done = 0;

	/*
	 * Does path have a parent directory?
	 */

	if (path == NULL)
		return (0);
	else if (!((dp = strrchr(path, DEMARC)) && (dp != path)))
		return (0);

	*dp = '\0';	/* temporarily overwrite demarc */

	for (i=0; i<nelts; ++i) {

		if ((mpug = mpa[i]) == NULL)
			continue;

		for (j=0; j<nmems[i]; ++j, ++mpug)

			if (strcmp(path, mpug->path) == 0) {

				/* is parent unresolved */
				if (mpug->realpath == NULL) {
					rc = 1;
				}
				done = 1;
				break;
			}

		if (done)
			break;
	}

	/* replace demarc value */

	*dp = DEMARC;
	return rc;
}
/**
 * @brief
 * 		inspect the directory entries in infrastruct
 *
 * @param[in]	pinf	-	pointer to infrastruct
 *
 * @return	int
 * @retval	0	: good to go.
 */
#if 0
static	int
inspect_dir_entries(struct infrastruct *pinf)
{
	int	i, j;
	MPUG	*pmpug;
	MPUG	**knwn_set;
	int	tsz;


	for (i=0; i<PH_last; ++i) {

		if ((pmpug = pinf->home[i]) == NULL)
			continue;
		tsz = home_sizes[i];

		for (j=0; j<home_sizes[i]; ++j) {

			if (pmpug[j].path && pmpug[j].realpath) {

				/*
				 * If pmpug[j] relates to a directory, find all database
				 * MPUG's for entries that belong to that directory.
				 *
				 * A pointer to an array of MPUG pointers is returned.
				 * These are MPUGS gleened from pbsprobe's database and
				 * is thought of as the, "known set of MPUGS".
				 */

				knwn_set = which_Knwn_mpugs(&pmpug[j], pmpug, tsz);
				msg_table_set_defaults(pinf, SRC_home, MSG_none);

				/*
				 * If *pmpug[j] happens to the MPUG data for a directory,
				 * check each entry of that directory either against
				 * MPUG data from the "known set" or against some other
				 * criteria to ascertain its "correctness"
				 */

				chk_entries(&pmpug[j], knwn_set);
			}
		}
	}

	for (i=0; i<EXEC_last; ++i) {

		if ((pmpug = pinf->exec[i]) == NULL)
			continue;
		tsz = exec_sizes[i];

		for (j=0; j<exec_sizes[i]; ++j) {

			if ((pmpug[j].path)) {

				/*
				 * Refer to block comments in previous code block
				 * for explanation of what this code block does
				 */

				knwn_set = which_Knwn_mpugs(&pmpug[j], pmpug, tsz);
				msg_table_set_defaults(pinf, SRC_exec, MSG_none);
				chk_entries(&pmpug[j], knwn_set);
			}
		}
	}

	return 0;
}
#endif	/* 0 */
/**
 * @brief
 * 		defines the suffix set and returns the set corresponding to the path of directory.
 *
 * @param[in]	pmpug	-	pointer to MPUG struct
 *
 * @return	char *
 * @retval	NULL	: No match found.
 * @retval	the suffix set	: corresponding to the directory.
 */
#if 0
static const char *
which_suffixset(MPUG *pmpug)
{

	static char vld_job[] = ".JB,.SC,.CR,.XP,.OU,.ER,.CK,.TK,.CS,.BD";
	static char vld_hooks[] = ".HK,.PY";
	static char vld_resv[] = ".RB,.RBD";
	static char vld_tcltk[] = ".h,8.3,8.3.a,.sh";
	static char vld_python[] = ".py,.pyc,.pyo,.so";


	if (pmpug->path == NULL)
		return NULL;
	else if (strcmp("server_priv/jobs", pmpug->path) == 0)
		return (vld_job);
	else if (strcmp("server_priv/users", pmpug->path) == 0)
		return (vld_job);
	else if (strcmp("server_priv/hooks", pmpug->path) == 0)
		return (vld_hooks);
	else if (strcmp("mom_priv/jobs", pmpug->path) == 0)
		return (vld_job);
	else if (strcmp("undelivered", pmpug->path) == 0)
		return (vld_job);
	else if (strcmp("spool", pmpug->path) == 0)
		return (vld_job);
	else if (strcmp("tcltk/bin", pmpug->path) == 0)
		return (vld_tcltk);
	else if (strcmp("tcltk/include", pmpug->path) == 0)
		return (vld_tcltk);
	else if (strcmp("tcltk/lib", pmpug->path) == 0)
		return (vld_tcltk);
	else if (strcmp("lib/python", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/altair", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/altair/pbs", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/altair/pbs/v1", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/logging", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/shared", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/xml", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/xml/dom", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/xml/etree", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/xml/parsers", pmpug->path) == 0)
		return (vld_python);
	else if (strcmp("lib/python/python2.5/xml/sax", pmpug->path) == 0)
		return (vld_python);
	else
		return NULL;
}
#endif /* 0 */

#if 0
static	int
is_suffix_ok(char *entryname, char *psuf)
{
	char	tbuf[100];
	char	*tok;
	int	len;
	int	elen = strlen(entryname);

	if (psuf == NULL)
		return 1;

	strcpy(tbuf, psuf);

	tok = strtok(tbuf, ",");
	for (; tok; tok = strtok(NULL,  ",")) {

		len = strlen(tok);
		if (elen <= len)
			continue;
		else if (strcmp(&entryname[elen - len], tok))
			continue;
		else {
			/* matched */
			return (1);
		}
	}
	return 0;
}
#endif	/* 0 */


#if 0
static 	MPUG  **
which_knwn_mpugs(MPUG *pmpug, MPUG *sets[], int *ssizes, int asz)
{
	/* Assumption being made that argument setsz < 100 */

	static	MPUG *knwn_mpugs[100];
	MPUG	     *pm;
	char	     *dp;
	char	     tmp_path[MAXPATHLEN];
	int i, j, idx=0;

	knwn_mpugs[0] = NULL;

	if ((pmpug == NULL) ||  !(pmpug->req_modes & S_IFDIR))
		return knwn_mpugs;

	for (i=0, pm=sets[0]; i<asz; ++i, pm = sets[i]) {
		for (j=0; j<ssizes[i]; ++j, ++pm) {

			/*
			 * copy to temporary avoids a problem when pmpug->path
			 * and pm->path never point to the same memory location
			 */

			strcpy(tmp_path, pm->path);

			if ((dp = strrchr(tmp_path, (int)'/')) == NULL)
				continue;

			*dp = '\0';
			if (strcmp(pmpug->path, tmp_path) == 0)
				knwn_mpugs[idx++] = pm;
			*dp = DEMARC;
		}
	}

	/*
	 * MPUG pointer array _must_ end with a NULL pointer
	 */

	knwn_mpugs[idx] = NULL;
	return	(knwn_mpugs);
}
#endif	/* 0 */

#if 0
static 	MPUG  **
which_Knwn_mpugs(MPUG *pmpug, MPUG *base, int tsize)
{
	/* Assumption being made that argument setsz < 100 */

	static	MPUG *knwn_mpugs[100];
	MPUG	     *pm;
	char	     *dp;
	char	     tmp_path[MAXPATHLEN];
	int	     j, idx=0;

	knwn_mpugs[0] = NULL;

	if ((pmpug == NULL) ||  !(pmpug->req_modes & S_IFDIR))
		return knwn_mpugs;

	for (j=0, pm=base; j<tsize; ++j, ++pm) {

		/*
		 * copy to temporary avoids a problem when pmpug->path
		 * and pm->path never point to the same memory location
		 */

		strcpy(tmp_path, pm->path);

		if ((dp = strrchr(tmp_path, (int)'/')) == NULL)
			continue;

		*dp = '\0';
		if (strcmp(pmpug->path, tmp_path) == 0)
			knwn_mpugs[idx++] = pm;

		*dp = DEMARC;
	}

	/*
	 * MPUG pointer array _must_ end with a NULL pointer
	 */

	knwn_mpugs[idx] = NULL;
	return	(knwn_mpugs);
}
#endif	/* 0 */

#if 0
/**
 * @brief
 * If pmpug happens to the MPUG data for a directory,
 * check each entry of that directory either against
 * MPUG data from the "known set" or against some other
 * criteria to ascertain its "correctness"
 *
 * @param[in] pmpug - pointer to struct modes_path_user_group
 * @param[in] knwn_set - known set of MPUGS
 */
static void
chk_entries(MPUG *pmpug, MPUG **knwn_set)
{
	DIR		*dir;
	struct dirent	*pdirent;
	char		*dirpath = pmpug->realpath;
	int		i;
	int		dirtype;
	char		*name;
	char		*psuf;
	char		msg[1024];

	if ((dirpath == NULL) || !(pmpug->req_modes & S_IFDIR))
		return;

	if ((dir = opendir(dirpath)) == NULL) {

		snprintf(msg, sizeof(msg), "Can't open directory %s for inspection\n", dirpath);
		put_msg_in_table(NULL, SRC_none, MSG_oth, msg);
		return;
	}

	/*
	 * Certain directories will have a list of associated suffixes.
	 * Get the location of any such list.
	 */

	psuf = (char *)which_suffixset(pmpug);

	/*
	 * Determine PBS directory type
	 */

	pbs_dirtype(&dirtype, pmpug);

	while (errno = 0, (pdirent = readdir(dir)) != NULL) {

		/*
		 * Ignore non-relevant directory entries
		 */

		if (strcmp(".", pdirent->d_name) == 0)
			continue;
		else if (strcmp("..", pdirent->d_name) == 0)
			continue;

		/*
		 * Begin by checking if the name of this entry matches any one
		 * of the names stored in the "known names (MPUGS)" subset
		 * supplied as input to this function
		 */

		for (i=0; knwn_set[i]; ++i) {
			if ((name = strrchr(knwn_set[i]->path, DEMARC))) {
				++name;
				if (strcmp(name, pdirent->d_name) == 0)
					break;
			}
		}

		if (knwn_set[i] != NULL) {

			/* matched a known entry, call readdir again */
			continue;
		}

		/*
		 * See if there is any, "name is outside the database,"
		 * kind of processing that would apply, and do it
		 */

		if (non_db_resident(pmpug, psuf, dirtype, pdirent->d_name))
			continue;

		/*
		 * entry is not a known name in pbsprobe's database and none
		 * of the other mechanisms for evaluating, in so way, the
		 * fitness of this entry were found to apply.
		 */

		snprintf(msg, sizeof(msg), "%s, unrecognized entry appears in %s\n", pdirent->d_name, pmpug->path);
		put_msg_in_table(NULL, SRC_none, MSG_unr, msg);
	}
	if (errno != 0 && errno != ENOENT) {

		snprintf(msg, sizeof(msg), "Can't read directory %s for inspection\n", dirpath);
		put_msg_in_table(NULL, SRC_none, MSG_oth, msg);
		(void)closedir(dir);
		return;
	}
	(void)closedir(dir);
}
#endif	/* 0 */

#if 0
static	void
pbs_dirtype(int *dirtype, MPUG *pmpug)
{
	if (strstr(pmpug->path, "logs"))
		*dirtype = PBS_logsdir;
	else if (strstr(pmpug->path, "accounting"))
		*dirtype = PBS_acctdir;
	else if (strstr(pmpug->path, "spool"))
		*dirtype = PBS_spooldir;
	else if (strstr(pmpug->path, "jobs"))
		*dirtype = PBS_jobsdir;
	else if (strstr(pmpug->path, "users"))
		*dirtype = PBS_usersdir;
	else if (strstr(pmpug->path, "hooks"))
		*dirtype = PBS_hooksdir;
	else if (strstr(pmpug->path, "hooks/tmp"))
		*dirtype = PBS_hookswdir;
	else
		*dirtype = PBS_niltype;
}
#endif	/* 0 */

#if 0
static	int
non_db_resident(MPUG *pmpug, char* psuf, int dirtype, char *entryname)
{
	char	msg[1024];

	switch (dirtype) {
		case PBS_acctdir:
		case PBS_logsdir:
			if (is_a_numericname(entryname) == 0) {

				snprintf(msg, sizeof(msg), "%s, unrecognized entry appears in %s\n", entryname, pmpug->path);
				put_msg_in_table(NULL, SRC_none, MSG_unr, msg);
			}
	}

	if (psuf && is_suffix_ok(entryname, psuf)) {
		return (1);
	}

	/* needs further examination to decide */

	return (0);
}
#endif	/* 0 */

#if 0
static	int
is_a_numericname(char *entryname)
{

	char	*endptr;

	(void)strtol(entryname, &endptr, 0);
	if (*endptr == '\0')
		return (1);
	else
		return (0);
}
#endif	/* 0 */
/**
 * @brief
 * 		check owner mode on pbs directories.
 *
 * @param[in]	pinf	-	pointer to infrasruct
 *
 * @return	int
 * @retval	0	: success
 */
static	int
check_paths(struct infrastruct *pinf)
{
	int	i, j;
	MPUG	*pmpug;
	char	*realpath;

#ifndef	_SX
	for (i=0; i<PBS_last; ++i) {

		msg_table_set_defaults(pinf, SRC_pri, MSG_po);

		if ((realpath = pinf->pri.pbs_mpug[i].realpath))
			check_owner_modes(realpath, &pinf->pri.pbs_mpug[i], 0);
	}
#endif

	for (i=0; i<PH_last; ++i) {

		msg_table_set_defaults(pinf, SRC_home, MSG_po);

		if ((pmpug = pinf->home[i]) == NULL)
			continue;

		for (j=0; j<home_sizes[i]; ++j) {
			if ((realpath = pmpug[j].realpath))
				check_owner_modes(realpath, pmpug + j, 0);
		}
	}

	for (i=0; i<EXEC_last; ++i) {

		msg_table_set_defaults(pinf, SRC_exec, MSG_po);

		if ((pmpug = pinf->exec[i]) == NULL)
			continue;

		for (j=0; j<exec_sizes[i]; ++j) {
			if ((realpath = pmpug[j].realpath) &&
				!(pmpug[j].notReq & notbits)) {

				check_owner_modes(realpath, pmpug + j, 0);
			}
		}
	}

	return 0;
}
/**
 * @brief
 * 		if full path check is required, see if the path contains
 * 		a sub-path and if it does, call check_owner_modes on that
 * 		sub-path
 * @par
 * 		if lstat on the path is successful, check perms and owners
 * 		against values stored in MPUG structure
 *
 * @param[in]	path	-	path which needs to be checked.
 * @param[in]	p_mpug	-	pointer to MPUG structure
 * @param[in]	sys	-	indicates ownerID < 10, group id < 10
 *
 * @return	int
 * @retval	0	: success
 * @retval	!=0	: something got wrong!
 *
 * @par MT-safe: No
 */
static	int
check_owner_modes(char *path, MPUG *p_mpug, int sys)
{
	int	    rc = 0;		/* encountered no mode problem */
	char	    *dp;
	char	    msg[256];
	const char  *perm_msg;

	struct stat sbuf;
	static int  cnt_recursive = 0;


	/*
	 * if full path check is required, see if the path contains
	 * a sub-path and if it does, call check_owner_modes on that
	 * sub-path
	 */

	if (p_mpug->chkfull &&
		(dp = strrchr(path, DEMARC)) && (dp != path)) {

		/* temporarily overwrite demarc */

		*dp = '\0';

		++cnt_recursive;
		rc = check_owner_modes(path, p_mpug, 0);

		/* replace demarc value and stat this component of real path */

		*dp = DEMARC;
	}

	/*
	 * if lstat on the path is successful, check perms and owners
	 * against values stored in MPUG structure
	 */

	if (rc == LSTAT_PATH_ERR) {
		if (cnt_recursive > 0)
			--cnt_recursive;
		return (rc);
	}

	/*
	 * Clarification for reader may be in order:
	 *
	 * For a fullpath check, getting to this point in the
	 * code means the prior subpath was ok, else would be
	 * taking the above return.
	 *
	 * For a non-fullpath check, we are immediately here
	 */

	if (! lstat(path, &sbuf)) {

		/* successful on the lstat */

		rc = mbits_and_owner(&sbuf, p_mpug, sys);
		if (rc) {
			snprintf(msg, sizeof(msg), "\n%s", path);
			put_msg_in_table(NULL, SRC_none, MSG_po, msg);
			perm_msg = perm_owner_msg(&sbuf, p_mpug, NULL, sys);
			strcpy(msg, perm_msg);
			put_msg_in_table(NULL, SRC_none, MSG_po, msg);
		}
		/*
		 * if running in "fix" mode, do fixing up to and including
		 * the maximum authorized level (max_level).
		 */
		fix(mode, rc, max_level, p_mpug, NULL, &sbuf, FIX_po);

	} else {

		/* lstat complained about something */

		if (errno != ENOENT || ! p_mpug->notReq) {
			/* this PBS file is required */

			snprintf(msg, sizeof(msg), "lstat error: %s, \"%s\"\n", path, strerror(errno));
			put_msg_in_table(NULL, SRC_none, MSG_real, msg);
			rc = LSTAT_PATH_ERR;
		}
	}

	if (cnt_recursive > 0)
		--cnt_recursive;

	return (rc);
}

/**
 * @brief
 * 		Test mode bits and ownerships
 *
 * @param[in]	ps	-	 stat  "buffer"
 * @param[in]	p_mpug	-	pointer to MPUG structure
 * @param[in]	sys	-	indicates ownerID < 10, group id < 10
 *
 * @return	int
 * @retval	0	: success
 * @retval	PATH_ERR	: something got wrong!
 */

static	int
mbits_and_owner(struct stat *ps, MPUG *p_mpug, int sys)
{
	int	    i;
	mode_t	    modes;

	/*
	 * first adjust bits from the MPUG by turning off mode bits that should
	 * be disallowed at this level in the hierarchy and turn on those bits
	 * that are required, before testing the modes produced by lstat call
	 */

	if (sys == 0) {

		modes = (mode_t)p_mpug->req_modes;
		if ((ps->st_mode & modes) != modes)
			return (PATH_ERR);

		modes = (mode_t)p_mpug->dis_modes;
		if (ps->st_mode & modes)
			return (PATH_ERR);
	}

	/*
	 * if the MPUG has associated "user and group"
	 * data, test if this file's user and group is consitent
	 * with what is in the database
	 */

	if (p_mpug->vld_ug) {
		for (i=0; p_mpug->vld_ug->uids[i] != -1; ++i) {
			if (p_mpug->vld_ug->uids[i] == ps->st_uid)
				break;
		}
		if (p_mpug->vld_ug->uids[i] == -1)
			return (PATH_ERR);
	}

	if (p_mpug->vld_ug) {

		for (i=0; p_mpug->vld_ug->gids[i]; ++i) {
			if (p_mpug->vld_ug->gids[i] == ps->st_gid)
				break;
		}
		if (p_mpug->vld_ug->gids[i] == -1)
			return (PATH_ERR);
	}

	return (0);
}
/**
 * @brief
 * 		prepare a permission owner message in the following format
 * 		perm_is, owner_is, perm_need, owner_need
 *
 * @param[in]	ps	-	 stat  "buffer"
 * @param[in]	p_mpug	-	pointer to MPUG structure
 * @param[in]	p_adj	-	pointer to ADJ structure
 * @param[in]	sys	-	indicates ownerID < 10, group id < 10
 *
 * @return	permission owner message
 *
 * @par MT-safe: No
 */
static const	char *
perm_owner_msg(struct stat *ps, MPUG *p_mpug,
	ADJ  *p_adj, int sys)
{
	mode_t	    modes;
	char	    *perm_is;
	char	    *perm_need;
	char	    *owner_is;
	char	    *owner_need;
	static char buf[1024];

	/*
	 * first adjust bits from the MPUG by turning off mode bits that should
	 * be disallowed at this level in the hierarchy and turn on those bits
	 * that are required, before testing the modes produced by lstat call
	 */

	owner_is = strdup(owner_string(ps, NULL, sys));
	owner_need = strdup(owner_string(NULL, p_mpug, sys));

	if (sys) {

		snprintf(buf, sizeof(buf), "(%s) needs to be (%s)", owner_is, owner_need);
		free(owner_is);
		free(owner_need);
		return (buf);
	}

	/* continue with this part if part of PBS hierarchy proper */

	modes = (mode_t)p_mpug->req_modes;
	if (p_adj)
		modes = (modes & ~p_adj->dis) | p_adj->req;

	perm_is = strdup(perm_string(ps->st_mode));
	perm_need = strdup(perm_string(modes));

	snprintf(buf, sizeof(buf), "(%s , %s) needs to be (%s , %s)",
		perm_is, owner_is, perm_need, owner_need);

	free(perm_is);
	free(perm_need);
	free(owner_is);
	free(owner_need);
	return (buf);
}

/**
 * @brief
 * 		perm_string - create permission string from mode.
 *
 * @param[in]	modes	-	required permissions (modes)
 *
 * @return	permission string
 *
 * @par MT-safe: No
 */
static	char *
perm_string(mode_t modes)
{
	static char buf[12];

	strcpy(buf, "----------");

	if (S_IFDIR & modes)
		buf[0] = 'd';

	if (S_IRUSR & modes)
		buf[1] = 'r';
	if (S_IWUSR & modes)
		buf[2] = 'w';

	if (S_IXUSR & modes)
		buf[3] = 'x';

	if (S_ISUID & modes)
		buf[3] = 's';

	if (S_IRGRP & modes)
		buf[4] = 'r';
	if (S_IWGRP & modes)
		buf[5] = 'w';
	if (S_IXGRP & modes)
		buf[6] = 'x';

	if (S_ISGID & modes)
		buf[6] = 's';

	if (S_IROTH & modes)
		buf[7] = 'r';
	if (S_IWOTH & modes)
		buf[8] = 'w';
	if (S_IXOTH & modes)
		buf[9] = 'x';

	if (S_ISVTX & modes)
		buf[9] = 't';

	return buf;
}
/**
 * @brief
 * 		formulate a string contains owner user info and group info.
 *
 * @param[in]	ps	-	data returned by the stat() function
 * @param[in]	p_mpug	-	modes_path_user_group structure
 * @param[in]	sys	-	indicates ownerID < 10, group id < 10
 *
 * @return	string contains owner user info and group info.
 *
 * @par MT-safe: No
 */
static	const char *
owner_string(struct stat *ps, MPUG *p_mpug, int sys)
{
	struct passwd	*ppw;
	struct group	*pgrp;

	static char buf[1024];

	buf[0] = '\0';
	if (ps) {
		ppw = getpwuid(ps->st_uid);
		pgrp = getgrgid(ps->st_gid);

		if (ppw != NULL && pgrp != NULL &&
			ppw->pw_name != NULL && pgrp->gr_name != NULL)

			snprintf(buf, sizeof(buf), "%s , %s", ppw->pw_name, pgrp->gr_name);
		else
			snprintf(buf, sizeof(buf), "%d , %d", ps->st_uid, ps->st_gid);

	} else if (p_mpug) {
		if (p_mpug->vld_ug) {
			if (sys)
				snprintf(buf, sizeof(buf), "ownerID < 10, group id < 10");
			else
				snprintf(buf, sizeof(buf), "%s, group id < 10", p_mpug->vld_ug->unames[0]);
		} else
			snprintf(buf, sizeof(buf), " ");
	}
	return buf;
}

/**
 * @brief
 * 		process return code and arrive at a return code that will determine the fate of pbs_probe
 *
 * @param[in]	from	-	Numeric codes, options - GET_PRIMARY_VALUES, END_FUNC_NAMES.
 * @param[in]	rc	-	return code to be processed.
 * @param[in]	pinf	-	pointer to infrastruct
 *
 * @return	int
 * @retval	0	: primary data is fine, continue with pbs_probe.
 * @retval	1	:  primary data is bogus, pbs_probe must exit
 */
static int
process_ret_code(enum func_names from, int rc, struct infrastruct *pinf)
{
	int  ret = 0;
	char msg[1024];

	if (from == GET_PRIMARY_VALUES) {

		if (rc != 0) {
			if (pinf->pri.pbs_mpug[PBS_conf].path) {

				if (rc == PBS_CONF_NO_EXIST)
					snprintf(msg, sizeof(msg), "File %s does not exist\n",
						pinf->pri.pbs_mpug[PBS_conf].path);
				else if (rc == PBS_CONF_CAN_NOT_OPEN)
					snprintf(msg, sizeof(msg), "Could not open PBS configuration file %s\n",
						pinf->pri.pbs_mpug[PBS_conf].path);
				else
					snprintf(msg, sizeof(msg),
						"Internal pbs_probe problem, unknown return code\n");

				put_msg_in_table(pinf, SRC_pri, MSG_pri, msg);
			}
			ret = 1;	/* primary data is bogus, pbs_probe must exit */
		}
	}

	return (ret);
}

/**
 * @brief
 * 		read the configuration file and obtain primary data for infrastruct structureS
 *
 * @param[in]	fp	-	file pointer to config file
 * @param[out]	pointer to infrastuct structure
 */
static	int
conf4primary(FILE *fp, struct infrastruct *pinf)
{
	char buf[1024];
	char *conf_name;              /* the name of the conf parameter */
	char *conf_value;             /* the value from the conf file or env*/
	unsigned int uvalue;          /* used with sscanf() */

	/* should not be calling with a NULL value for fp */

	assert(fp != NULL);

	while (fgets(buf, 1024, fp) != NULL) {
		if (buf[0] != '#') {
			/* replace '\n' with '\0' */
			buf[strlen(buf)-1] = '\0';
			conf_name = strtok(buf, "=");
			conf_value = strtok(NULL, "     ");

			/* ignore the unexpected (inserted blank line?) */

			if ((conf_name == NULL) || (conf_value == NULL))
				continue;

			if (!strcmp(conf_name, "PBS_START_SERVER")) {
				if (sscanf(conf_value, "%u", &uvalue) == 1)
					pinf->pri.started.server = ((uvalue > 0) ? 1 : 0);
				pinf->pri.src_started.server = SRC_CONF;
			}
			else if (!strcmp(conf_name, "PBS_START_MOM")) {
				if (sscanf(conf_value, "%u", &uvalue) == 1)
					pinf->pri.started.mom = ((uvalue > 0) ? 1 : 0);
				pinf->pri.src_started.mom = SRC_CONF;
			}
			else if (!strcmp(conf_name, "PBS_START_SCHED")) {
				if (sscanf(conf_value, "%u", &uvalue) == 1)
					pinf->pri.started.sched = ((uvalue > 0) ? 1 : 0);
				pinf->pri.src_started.sched = SRC_CONF;
			}
			else if (!strcmp(conf_name, "PBS_HOME")) {
				if (pinf->pri.pbs_mpug[PBS_home].path)
					free(pinf->pri.pbs_mpug[PBS_home].path);
				pinf->pri.pbs_mpug[PBS_home].path = strdup(conf_value);
				pinf->pri.src_path.home = SRC_CONF;
			}
			else if (!strcmp(conf_name, "PBS_CONF_DATA_SERVICE_HOST")) {
				nonlocaldata = 1;
			}
			else if (!strcmp(conf_name, "PBS_EXEC")) {
				if (pinf->pri.pbs_mpug[PBS_exec].path)
					free(pinf->pri.pbs_mpug[PBS_exec].path);
				pinf->pri.pbs_mpug[PBS_exec].path = strdup(conf_value);
				pinf->pri.src_path.exec = SRC_CONF;
			}

		} else {
			/* ignore comment lines (# in column 1) */
			continue;
		}
	}
	return (0);
}
/**
 * @brief
 * 		read the environment values and store in infrastruct.
 *
 * @param[out]	pinf	-	pointer to environment structure.
 *
 * @return	int
 * @retval	0	: success
 */
static	int
env4primary(struct infrastruct *pinf)
{
	char *gvalue;                 /* used with getenv() */
	unsigned int uvalue;          /* used with sscanf() */

	if ((gvalue = getenv("PBS_START_SERVER"))) {
		if (sscanf(gvalue, "%u", &uvalue) == 1) {
			pinf->pri.started.server = ((uvalue > 0) ? 1 : 0);
			pinf->pri.src_started.server = SRC_ENV;
		}
	}
	if ((gvalue = getenv("PBS_START_MOM"))) {
		if (sscanf(gvalue, "%u", &uvalue) == 1) {
			pinf->pri.started.mom = ((uvalue > 0) ? 1 : 0);
			pinf->pri.src_started.mom = SRC_ENV;
		}
	}
	if ((gvalue = getenv("PBS_START_SCHED"))) {
		if (sscanf(gvalue, "%u", &uvalue) == 1) {
			pinf->pri.started.sched = ((uvalue > 0) ? 1 : 0);
			pinf->pri.src_started.sched = SRC_ENV;
		}
	}
	if ((gvalue = getenv("PBS_HOME"))) {

		if (pinf->pri.pbs_mpug[PBS_home].path)
			free(pinf->pri.pbs_mpug[PBS_home].path);

		pinf->pri.pbs_mpug[PBS_home].path = strdup(gvalue);
		pinf->pri.src_path.home = SRC_ENV;
	}
	if ((gvalue = getenv("PBS_EXEC"))) {

		if (pinf->pri.pbs_mpug[PBS_exec].path)
			free(pinf->pri.pbs_mpug[PBS_exec].path);

		pinf->pri.pbs_mpug[PBS_exec].path = strdup(gvalue);
		pinf->pri.src_path.exec = SRC_ENV;
	}
	if ((gvalue = getenv("PBS_CONF_DATA_SERVICE_HOST")) != NULL) {
		nonlocaldata = 1;
	}
	return (0);
}

/**
 * @brief
 * 		fix - check is a fix is necessary and, if it is, attempt to do
 * 		the fix, being careful not to attempt a fix whose code is higher
 * 		than the maximum allowed (max_level.)
 * @par
 * 		If a fix is attempted, add an appropriate message(s) to the end of
 * 		the relevant message category.
 *
 * @param[in]	probemode	-	probe mode
 * @param[in]	need	-	required or not ?
 * @param[in]	max_level	-	maximum allowed
 * @param[in]	pmpug	-	pointer to modes_path_user_group structure
 * @param[in]	padj	-	pointer to a structure which holds data for modeadjustments.
 * @param[in]	ps	-	data returned by the stat() function
 * @param[in]	fc	-	fix codes.
 *
 * @return	none
 */
static void
fix(int probemode, int need, int max_level, MPUG *pmpug, ADJ *padj, struct stat *ps, int fc)
{
	if ((need == 0) || (probemode != (int)'f') || (fc > max_level))
		return;

	switch (fc) {
		case FIX_po:
			if (padj == NULL)
				fix_perm_owner(pmpug, ps, padj);
			break;
	}
}

/**
 * @brief
 * 		fix_perm_owner - attempt a fix of permission or ownership problems on
 * 		the input file and add a message(s) to whatever default message category
 * 		is currently set.
 *
 * @param[in]	p_mpug	-	pointer to modes_path_user_group structure
 * @param[in]	ps	-	data returned by the stat() function
 * @param[in]	p_adj	-	pointer to a structure which holds data for modeadjustments.
 *
 * @return	none
 */
static void
fix_perm_owner(MPUG *p_mpug, struct stat *ps, ADJ *p_adj)
{
	char		msg[512];
	mode_t		modes;
	mode_t		dis_modes;
	unsigned	fixes = 0;
	int		i, rc;

	if (ps == NULL)
		return;

	modes = (mode_t)p_mpug->req_modes;
	if (p_adj)
		modes = (modes & ~p_adj->dis) | p_adj->req;

	if (p_adj)
		dis_modes = (~modes & (mode_t)p_mpug->dis_modes) | p_adj->dis;
	else
		dis_modes = (mode_t)p_mpug->dis_modes;

	if (dis_modes & modes) {
		snprintf(msg, sizeof(msg), "%s: database problem, 'allowed/disallowed' modes overlap", p_mpug->path);
		put_msg_in_table(NULL, SRC_none, MSG_po, msg);
		return;
	}

	if (ps->st_mode != modes) {
		if ((rc = chmod(p_mpug->realpath, modes))) {
			snprintf(msg, sizeof(msg), "%s: permission correction failed, %s", p_mpug->path, strerror(errno));
			put_msg_in_table(NULL, SRC_none, MSG_po, msg);
		} else {
			fixes |= 0x1;	/* permission */
		}
	}

	/*
	 * Fix any ownership problems (user/group) if they exist
	 */

	if (p_mpug->vld_ug) {
		for (i=0; p_mpug->vld_ug->uids[i] != -1; ++i) {
			if (p_mpug->vld_ug->uids[i] == ps->st_uid)
				break;
		}
		if (p_mpug->vld_ug->uids[i] == -1) {
			rc = chown(p_mpug->realpath, p_mpug->vld_ug->uids[0], -1);
			if (rc) {
				snprintf(msg, sizeof(msg), "%s: ownership correction failed, %s", p_mpug->path, strerror(errno));
				put_msg_in_table(NULL, SRC_none, MSG_po, msg);
			} else {
				fixes |= 0x2;
			}
		}
	}

	if (p_mpug->vld_ug) {
		for (i=0; p_mpug->vld_ug->gids[i]; ++i) {
			if (p_mpug->vld_ug->gids[i] == ps->st_gid)
				break;
		}
		if (p_mpug->vld_ug->gids[i] == -1) {
			/*
			 * Remark: we are using the gid value "0" because
			 * on most of the systems checked the group value was
			 * this value.  On a few it was "1".
			 */
			rc = chown(p_mpug->realpath, -1, p_mpug->vld_ug->gids[0]);
			if (rc) {
				snprintf(msg, sizeof(msg), "%s: group correction failed, %s", p_mpug->path, strerror(errno));
				put_msg_in_table(NULL, SRC_none, MSG_po, msg);
			} else {
				fixes |= 0x4;
			}
		}
	}

	switch (fixes) {
		case 1:
			snprintf(msg, sizeof(msg), "%s: corrected permissions", p_mpug->path);
			put_msg_in_table(NULL, SRC_none, MSG_po, msg);
			break;

		case 2:
		case 4:
		case 6:
			snprintf(msg, sizeof(msg), "%s: corrected ownership(s)", p_mpug->path);
			put_msg_in_table(NULL, SRC_none, MSG_po, msg);
			break;

		case 3:
		case 5:
		case 7:
			snprintf(msg, sizeof(msg), "%s: corrected permissions and ownership(s)", p_mpug->path);
			put_msg_in_table(NULL, SRC_none, MSG_po, msg);
			break;
	}
}

