a

1. #!/usr/bin/ksh93
#!/bin/zsh
#!/bin/bash
################################################################
####
#### This script will run in KornShell93, Zshell, or Bash, all you need to do
#### is put the desired "shebang" line at the top of the script.
####
################################################################
function usagemsg_getfilestruct_zbksh {
CMD_ECHO="${GBL_ECHO:-echo -e }"
[[ "_${SHCODE}" == "_korn" ]] && typeset CMD_ECHO="${GBL_ECHO:-echo -e }"
[[ "_${SHCODE}" == "_bash" ]] && declare CMD_ECHO="${GBL_ECHO:-echo -e }"
${CMD_ECHO} ""
${CMD_ECHO} "${1:+Program: ${1}}${2:+ Version: ${2}}"
${CMD_ECHO} ""
${CMD_ECHO} "This script builds arrays of values representing directory and
file"
${CMD_ECHO} "names, with owner, group, and permissions. It will also generate
the"
${CMD_ECHO} "commands necessary to recreate the directory structure, and to
restore"
${CMD_ECHO} "the owner, group, and permissions to all directories and files
under a"
${CMD_ECHO} "top level directory."
${CMD_ECHO} ""
${CMD_ECHO} "Usage: ${1} [-v|-V] [-a] [-c] [-s] [-d|-f] [-R /Alt_Root] TopDir"
${CMD_ECHO} ""
${CMD_ECHO} " Where '-v' = Verbose mode"
${CMD_ECHO} " '-V' = Very Verbose mode"
${CMD_ECHO} " '-a' = Generate Arrays of values as Output"
${CMD_ECHO} " (Default: array definitions)"
${CMD_ECHO} " '-c' = Generate commands to create directory
structures"
${CMD_ECHO} " (Default: array definitions)"
${CMD_ECHO} " '-s' = Generate commands to create Symbolic Links"
${CMD_ECHO} " (Default: OFF)"
${CMD_ECHO} " '-d' = Only gather directory structure information"
${CMD_ECHO} " (Default: Files and Directories)"
${CMD_ECHO} " '-f' = Only gather file information"
${CMD_ECHO} " (Default: Files and Directories)"
${CMD_ECHO} " '-R /ALT_ROOT' = Add an alternate root directory to
every path"
${CMD_ECHO} " This directory does not need to
actually exist"
${CMD_ECHO} " Useful for chroot'ed dirs or ALT_DISK
filesystems"
${CMD_ECHO} " (Default: NUL)"
${CMD_ECHO} ""
${CMD_ECHO} " TopDir = The full path directory name from which to"
${CMD_ECHO} " extract the directory and file structure"
${CMD_ECHO} ""
${CMD_ECHO} "Author: Dana French (dfrench@mtxia.com)"
${CMD_ECHO} "Copyright 2007-2015, All Rights Reserved"
${CMD_ECHO} ""
${CMD_ECHO} ""AutoContent" enabled"
${CMD_ECHO} ""Multi-Shell" enabled"
${CMD_ECHO} ""
}
################################################################
####
#### Description:
####
#### This script builds arrays of values representing directory and file

2. #### names, with owner, group, and permissions. It will also generate the
#### commands necessary to recreate the directory structure, and to restore
#### the owner, group, and permissions to all directories and files under a
#### top level directory.
####
#### This script can operate in two modes: Array or Command generating.
#### In "Array" mode, KornShell93/Bash code is generated is used
#### to define an array of values containing the directory information
#### and attributes. In "Command" mode, unix style commands are generated
#### to recreate the directory structure and attributes. The default is
#### "Array" mode.
####
#### Assumptions:
####
#### If you are using this script to build arrays of values, it is assumed
#### the number of files in the specified top level directory will be limited
#### on only a few thousand. This is because the values are stored in shell
#### variable arrays which are limited in size, depending upon the platform.
#### You will need to test this on your own system to determine the actual
#### limitations.
####
#### Dependencies:
####
#### This script is dependent upon the following Unix utilities:
#### ksh93, bash, or zsh
#### ls
#### find
#### uname
####
#### Products:
####
#### This script generates KornShell93/Bash Compliant commands that can
#### be used to define an array of values, or this script can generate
#### Unix commands to create the directory structure and its attributes.
####
#### Configured Usage:
####
#### This script can be run from the command line, used as a function, or
#### called from a function library.
####
#### Details:
####
################################################################
function getfilestruct_zbksh
{
if [[ "_${SHCODE}" == "_korn" ]] ||
[[ "_${SHCODE}" == "_zshell" ]]
then
typeset VERSION="3.1-zbksh"
typeset TRUE="${TRUE:-1}"
typeset FALSE="${FALSE:-0}"
typeset CMD_ECHO="${GBL_ECHO:-echo -e }"
typeset VERBOSE="${FALSE}"
typeset VERYVERB="${FALSE}"
typeset GENCMDS="${FALSE}"
typeset GENSLNK="${FALSE}"
typeset GENARYS="${FALSE}"
typeset SHWDIRS="${TRUE}"
typeset SHWFILS="${TRUE}"
typeset DCNT="0"
typeset FCNT="0"
typeset SCNT="0"
typeset ALT_ROOT=""

3. typeset CMD=""
typeset DGROUP
typeset DIRID1
typeset DIRIDX
typeset DIRNAME
typeset DMODE
typeset DOWNER
typeset GPERMS
typeset LNAME
typeset MACHNAME
typeset OPERMS
typeset PERMS
typeset RAWFNAME
typeset RAWGROUP
typeset RAWOWNER
typeset RAWPERMS
typeset SNAME
typeset UPERMS
elif [[ "_${SHCODE}" == "_bash" ]]
then
declare VERSION="3.1-zbksh"
declare TRUE="${TRUE:-1}"
declare FALSE="${FALSE:-0}"
declare CMD_ECHO="${GBL_ECHO:-echo -e }"
declare VERBOSE="${FALSE}"
declare VERYVERB="${FALSE}"
declare GENCMDS="${FALSE}"
declare GENSLNK="${FALSE}"
declare GENARYS="${FALSE}"
declare SHWDIRS="${TRUE}"
declare SHWFILS="${TRUE}"
declare DCNT="0"
declare FCNT="0"
declare SCNT="0"
declare ALT_ROOT=""
declare CMD=""
declare DGROUP
declare DIRID1
declare DIRIDX
declare DIRNAME
declare DMODE
declare DOWNER
declare GPERMS
declare LNAME
declare MACHNAME
declare OPERMS
declare PERMS
declare RAWFNAME
declare RAWGROUP
declare RAWOWNER
declare RAWPERMS
declare SNAME
declare UPERMS
else
VERSION="3.1-zbksh"
TRUE="${TRUE:-1}"
FALSE="${FALSE:-0}"
CMD_ECHO="${GBL_ECHO:-echo -e }"
VERBOSE="${FALSE}"
VERYVERB="${FALSE}"
GENCMDS="${FALSE}"
GENSLNK="${FALSE}"
GENARYS="${FALSE}"
SHWDIRS="${TRUE}"

4. SHWFILS="${TRUE}"
DCNT="0"
FCNT="0"
SCNT="0"
ALT_ROOT=""
CMD=""
fi
################################################################
while getopts ":vVcasdfR:" OPTION
do
case "${OPTION}" in
'a') GENARYS="${TRUE}";;
'c') GENCMDS="${TRUE}";;
's') GENSLNK="${TRUE}";;
'd') SHWFILS="${FALSE}";; # Yes, -d turns off showing files
'f') SHWDIRS="${FALSE}";; # Yes, -f turns off showing dirs
'R') ALT_ROOT="${OPTARG}";;
'v') VERBOSE="${TRUE}";;
'V') VERBOSE="${TRUE}"
VERYVERB="${TRUE}";;
'?') usagemsg_getfilestruct_zbksh "${0}" "${VERSION}" && return 1 ;;
esac
done
shift $(( ${OPTIND} - 1 ))
################################################################
trap "usagemsg_getfilestruct_zbksh ${0} ${VERSION} " EXIT
MACHNAME=$( uname -n )
DIRID1="${1:?ERROR: Top level directory not specified}"
if [[ ! -d "${DIRID1}" ]]
then
${CMD_ECHO} "# ERROR: "${DIRID1}" is not a directory or does not exist"
return 4
fi
if (( GENARYS == FALSE )) &&
(( GENCMDS == FALSE ))
then
GENARYS="${TRUE}"
fi
if (( SHWFILS == FALSE )) &&
(( SHWDIRS == FALSE ))
then
${CMD_ECHO} "# ERROR: Do not specify both -d and -f, you must specify one or
the other, or neither."
return 2
fi
trap "-" EXIT
################################################################
DCNT="0"
FCNT="0"
SCNT="0"
DIRIDX="${DIRID1##*/}"
(( ${#DIRIDX} > 8 )) && DIRIDX="${DIRIDX:0:8}"

5. (( VERBOSE == TRUE )) && ${CMD_ECHO} "${SHEBANG:-#!/usr/bin/ksh93}"
(( VERBOSE == TRUE )) && ${CMD_ECHO}
"################################################################"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Program Name..........: ${0}"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Version...............: ${VERSION}"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Script Execution Mode.: ${SHCODE}"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Copyright Info........: Copyright 2007-
2015 by Dana French, All Rights Reserved"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Local hostname........: ${MACHNAME}"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Top Level Directory...: ${DIRID1}"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "# Variable index name...: ${DIRIDX}"
(( VERBOSE == TRUE )) && (( SHWFILS == TRUE )) && ${CMD_ECHO} "# Show
Files............: TRUE"
(( VERBOSE == TRUE )) && (( SHWFILS == FALSE )) && ${CMD_ECHO} "# Show
Files............: FALSE"
(( VERBOSE == TRUE )) && (( SHWDIRS == TRUE )) && ${CMD_ECHO} "# Show
Directories......: TRUE"
(( VERBOSE == TRUE )) && (( SHWDIRS == FALSE )) && ${CMD_ECHO} "# Show
Directories......: FALSE"
(( VERBOSE == TRUE )) && (( GENCMDS == TRUE )) && ${CMD_ECHO} "# Generate
Commands.....: TRUE"
(( VERBOSE == TRUE )) && (( GENCMDS == FALSE )) && ${CMD_ECHO} "# Generate
Commands.....: FALSE"
(( VERBOSE == TRUE )) && (( GENARYS == TRUE )) && ${CMD_ECHO} "# Generate
Arrays.......: TRUE"
(( VERBOSE == TRUE )) && (( GENARYS == FALSE )) && ${CMD_ECHO} "# Generate
Arrays.......: FALSE"
(( VERBOSE == TRUE )) && (( GENSLNK == TRUE )) && ${CMD_ECHO} "# Generate Sym
Link CMDS: TRUE"
(( VERBOSE == TRUE )) && (( GENSLNK == FALSE )) && ${CMD_ECHO} "# Generate Sym
Link CMDS: FALSE"
${CMD_ECHO} ""
${CMD_ECHO} "ALT_ROOT="${ALT_ROOT}""
################################################################
####
#### The first thing the "getfilestruct" script does is to execute a "find"
#### command to retrieve all the directories under the top level directory
#### specified on the command line when the script was run. The "find"
#### command produces "ls -ld" style output for the purpose of extracting and
#### processing the attributes associated with each directory.
####
################################################################
(( SHWFILS == FALSE )) && (( SHWDIRS == TRUE )) && CMD='find "${DIRID1%/}"
-type d -exec ls -ld {} ;'
(( SHWFILS == TRUE )) && (( SHWDIRS == FALSE )) && CMD='find "${DIRID1%/}" !
-type d -exec ls -ld {} ;'
(( SHWFILS == TRUE )) && (( SHWDIRS == TRUE )) && CMD='find "${DIRID1%/}"
-exec ls -ld {} ;'
(( SHWFILS == FALSE )) && (( SHWDIRS == FALSE )) && return 3
eval ${CMD} | while read -r -- RAWPERMS RAWLINKS RAWOWNER RAWGROUP RAWSIZE
RAWDATE1 RAWDATE2 RAWDATE3 RAWFNAME
do
################################################################
####

6. #### If the file is a symbolic link, generate the command to recreate the
#### symbolic link and continue with the next file.
####
################################################################
if [[ "_${RAWPERMS}" == _l* ]]
then
LNAME="${RAWFNAME##* -> }"
SNAME="${RAWFNAME% -> *}"
[[ "_${LNAME}" != _/* ]] && LNAME="${SNAME%/*}/${LNAME}"
if (( GENARYS == TRUE ))
then
${CMD_ECHO} "n#### symbolic link "${RAWFNAME}""
${CMD_ECHO} "SYM_${DIRIDX}_SNAME[${SCNT}]="${ALT_ROOT}${SNAME}""
${CMD_ECHO} "SYM_${DIRIDX}_FLINK[${SCNT}]="${ALT_ROOT}${LNAME}""
SCNT=$(( ${SCNT} + 1 ))
fi
if (( GENSLNK == TRUE ))
then
${CMD_ECHO} "n#### Generate symbolic link "${RAWFNAME}""
${CMD_ECHO} "ln -s "${LNAME}" "${SNAME}""
else
${CMD_ECHO} "n#### Skipping symbolic link "${RAWFNAME}""
${CMD_ECHO} "# ln -s "${LNAME}" "${SNAME}""
fi
continue
fi
################################################################
####
#### The file owner and group are easily
#### extracted from the "ls -ld" output, however the permissions require
#### some processing.
####
################################################################
# extract the owner for the directory from the ls -l output
DOWNER="${RAWOWNER}"
# extract the group for the directory from the ls -l output
DGROUP="${RAWGROUP}"
# extract the permission settings for the directory from the ls -l output
PERMS="${RAWPERMS:1:9}"
# extract the name of the directory from the ls -l output
DIRNAME="${RAWFNAME}"
[[ "_${DIRNAME}" == *lost+found ]] && continue
################################################################
####
#### The permission settings are contained within the first 10 characters
#### of the "ls -ld" output and are processed in 3 steps. The first character
#### is the file type and is ignored, the next 3 characters are associated
#### with the "user" or file owner permissions. The permissions are
#### checked to see if the tacky bit or SUID bit is set. If so
#### the appropriate permission setting is added to the permission string
#### which will be used when directory permissions are set.
####
################################################################
# extract the user permission settings for the directory from the ls -ld output

7. UPERMS="${PERMS:0:3}"
# remove the dashes "-" from the user permissions
UPERMS="${UPERMS//-/}"
# Convert lowercase "s" to "xs" in the user permissions
UPERMS="${UPERMS//s/xs}"
# Convert uppercase "S" to "s" in the user permissions
UPERMS="${UPERMS//S/s}"
# Convert lowercase "t" to "xt" in the user permissions
UPERMS="${UPERMS//t/xt}"
# Convert uppercase "T" to "t" in the user permissions
UPERMS="${UPERMS//T/t}"
################################################################
####
#### The next set of 3 characters are associated with the "group"
#### category of permissions. The permissions are checked to see
#### if the tacky bit or SUID bit is set. If so the appropriate
#### permission setting is added to the permission string which will
#### be used when the directory permissions are set.
####
################################################################
# extract the group permission settings for the directory from the ls -ld output
GPERMS="${PERMS:3:3}"
# remove the dashes "-" from the group permissions
GPERMS="${GPERMS//-/}"
# Convert lowercase "s" to "xs" in the group permissions
GPERMS="${GPERMS//s/xs}"
# Convert uppercase "S" to "s" in the group permissions
GPERMS="${GPERMS//S/s}"
# Convert lowercase "t" to "xt" in the group permissions
GPERMS="${GPERMS//t/xt}"
# Convert uppercase "T" to "t" in the group permissions
GPERMS="${GPERMS//T/t}"
################################################################
####
#### The last set of 3 characters are associated with the "other"
#### category of permissions. Again, the permissions are checked to see
#### if the tacky bit or SUID bit is set. If so the appropriate permission
#### setting is added to the permission string which will be used when the
#### directory permissions are set.
####
################################################################
# extract the other permission settings for the directory from the ls -ld output
OPERMS="${PERMS:6:3}"
# remove the dashes "-" from the other permissions
OPERMS="${OPERMS//-/}"
# Convert lowercase "s" to "xs" in the other permissions
OPERMS="${OPERMS//s/xs}"
# Convert uppercase "S" to "s" in the other permissions
OPERMS="${OPERMS//S/s}"
# Convert lowercase "t" to "xt" in the other permissions
OPERMS="${OPERMS//t/xt}"
# Convert uppercase "T" to "t" in the other permissions
OPERMS="${OPERMS//T/t}"
################################################################
####
#### With the permission setting strings for each user category now known
#### and extracted from the "ls -ld" output, a mnemonic "exact setting"
#### string is constructed for use with the "chmod" command.
####

8. ################################################################
# Build the mnemonic mode exact permission setting command
DMODE="u=${UPERMS},g=${GPERMS},o=${OPERMS}"
(( VERBOSE == TRUE )) && ${CMD_ECHO} "n#### n#### ${MACHNAME}:${DMODE}:$
{DOWNER}:${DGROUP}:${DIRNAME}"
################################################################
#### Depending upon the options specified when this script was run,
#### either KornShell93/Bash compliant commands or Unix commands will
#### be generated.
####
#### The generated KornShell93/Bash Compliant commands can be used to
#### define a variable array of values which contain the directory name
#### and various attributes associated with each directory.
####
#### The Unix commands generated consist of mkdir, chown, chgrp, and
#### chmod, which can be used to create the directory and change its
#### attributes to match those of the original directory.
####
################################################################
if [[ -d "${DIRNAME}" ]]
then
(( VERBOSE == TRUE )) && ${CMD_ECHO} "n${CMD_ECHO} "# Working on $
{DIRNAME}""
if (( GENARYS == TRUE ))
then
${CMD_ECHO} "DIR_${DIRIDX}_DNAME[${DCNT}]="${ALT_ROOT}$
{DIRNAME}";"
${CMD_ECHO} "DIR_${DIRIDX}_OWNER[${DCNT}]="${DOWNER}";"
${CMD_ECHO} "DIR_${DIRIDX}_GROUP[${DCNT}]="${DGROUP}";"
${CMD_ECHO} "DIR_${DIRIDX}_CHMOD[${DCNT}]="${DMODE}";"
fi
if (( GENCMDS == TRUE ))
then
${CMD_ECHO} "mkdir -p "${ALT_ROOT}${DIRNAME}";"
${CMD_ECHO} "chown ${DOWNER} "${ALT_ROOT}${DIRNAME}";"
${CMD_ECHO} "chgrp ${DGROUP} "${ALT_ROOT}${DIRNAME}";"
${CMD_ECHO} "chmod "${DMODE}" "${ALT_ROOT}${DIRNAME}";"
fi
DCNT=$(( ${DCNT} + 1 ))
else
if (( GENARYS == TRUE ))
then
${CMD_ECHO} "FIL_${DIRIDX}_FNAME[${FCNT}]="${ALT_ROOT}$
{DIRNAME}";"
${CMD_ECHO} "FIL_${DIRIDX}_OWNER[${FCNT}]="${DOWNER}";"
${CMD_ECHO} "FIL_${DIRIDX}_GROUP[${FCNT}]="${DGROUP}";"
${CMD_ECHO} "FIL_${DIRIDX}_CHMOD[${FCNT}]="${DMODE}";"
fi
if (( GENCMDS == TRUE ))
then
${CMD_ECHO} "chown ${DOWNER} "${ALT_ROOT}${DIRNAME}";"
${CMD_ECHO} "chgrp ${DGROUP} "${ALT_ROOT}${DIRNAME}";"
${CMD_ECHO} "chmod "${DMODE}" "${ALT_ROOT}${DIRNAME}";"

9. fi
FCNT=$(( ${FCNT} + 1 ))
fi
done
return 0
}
################################################################
################################################################
################################################################
####
#### Main Body of Script Begins Here
####
################################################################
TRUE="1"
FALSE="0"
####
#### Extract the "shebang" line from the beginning of the script
read SHEBANG < "${0}"
export SHEBANG
####
#### Test the "shebang" line to determine what shell interpreter is specified
SHCODE="unknown"
[[ "_${SHEBANG}" == _*/ksh* ]] && SHCODE="korn"
[[ "_${SHEBANG}" == _*/bash* ]] && SHCODE="bash"
[[ "_${SHEBANG}" == _*/zsh* ]] && SHCODE="zshell"
export SHCODE
####
#### Modify the commands and script according to the shell intpreter
GBL_ECHO="echo -e"
[[ "_${SHCODE}" == "_korn" ]] && GBL_ECHO="print --"
[[ "_${SHCODE}" == "_zshell" ]] && GBL_ECHO="print --" && emulate ksh93
[[ "_${SHCODE}" == "_bash" ]] && shopt -s extglob # Turn on extended
globbing
####
#### Call the script function to begin processing
getfilestruct_zbksh "${@}"
exit ${?}

10. fi
FCNT=$(( ${FCNT} + 1 ))
fi
done
return 0
}
################################################################
################################################################
################################################################
####
#### Main Body of Script Begins Here
####
################################################################
TRUE="1"
FALSE="0"
####
#### Extract the "shebang" line from the beginning of the script
read SHEBANG < "${0}"
export SHEBANG
####
#### Test the "shebang" line to determine what shell interpreter is specified
SHCODE="unknown"
[[ "_${SHEBANG}" == _*/ksh* ]] && SHCODE="korn"
[[ "_${SHEBANG}" == _*/bash* ]] && SHCODE="bash"
[[ "_${SHEBANG}" == _*/zsh* ]] && SHCODE="zshell"
export SHCODE
####
#### Modify the commands and script according to the shell intpreter
GBL_ECHO="echo -e"
[[ "_${SHCODE}" == "_korn" ]] && GBL_ECHO="print --"
[[ "_${SHCODE}" == "_zshell" ]] && GBL_ECHO="print --" && emulate ksh93
[[ "_${SHCODE}" == "_bash" ]] && shopt -s extglob # Turn on extended
globbing
####
#### Call the script function to begin processing
getfilestruct_zbksh "${@}"
exit ${?}