mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 17:50:22 +00:00
1506 lines
31 KiB
Bash
1506 lines
31 KiB
Bash
#!/bin/bash
|
|
|
|
################################################################################
|
|
## base routines
|
|
##
|
|
|
|
function list_modules() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Show all modules.
|
|
|
|
PARAMETERS:
|
|
-e|--enabled show enabled modules only
|
|
-d|--disabled show disabled modules only
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get additional parameters
|
|
local option=
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
-e|--enabled) option="-e"
|
|
;;
|
|
-d|--disabled) option="-d"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
_list_modules $option
|
|
}
|
|
|
|
function print_module_info() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Show module description.
|
|
|
|
PARAMETERS:
|
|
\$1 module name
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local module=${1-mintleaf}
|
|
|
|
if [ $(list_modules | grep $module | wc -l) -eq 1 ]; then
|
|
if [ -f $MINTLEAF_HOME/modules/$module/$module.md ]; then
|
|
printf "\n"
|
|
cat $MINTLEAF_HOME/modules/$module/$module.md 2> /dev/null
|
|
printf "\n"
|
|
fi
|
|
else
|
|
echo "Module does not exist"
|
|
fi
|
|
}
|
|
|
|
function list_functions() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Show all available functions for given module.
|
|
|
|
PARAMETERS:
|
|
\$1 module name
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
_list_functions $1
|
|
}
|
|
|
|
function create_module() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Create module along with its essential files.
|
|
|
|
PARAMETERS:
|
|
\$1 module name
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local module=$1
|
|
|
|
mkdir $MINTLEAF_HOME/modules/$module
|
|
|
|
[ ! -f $MINTLEAF_HOME/modules/$module/$module.md ] && cat << EOF >> $MINTLEAF_HOME/modules/$module/$module.md
|
|
$module
|
|
=======
|
|
|
|
TODO
|
|
EOF
|
|
[ ! -f $MINTLEAF_HOME/modules/$module/$module.config ] && cat << EOF >> $MINTLEAF_HOME/modules/$module/$module.config
|
|
EOF
|
|
[ ! -f $MINTLEAF_HOME/modules/$module/$module.install ] && cat << EOF >> $MINTLEAF_HOME/modules/$module/$module.install
|
|
#!/bin/bash
|
|
|
|
function install_module() {
|
|
|
|
echo "TODO"
|
|
}
|
|
EOF
|
|
[ ! -f $MINTLEAF_HOME/modules/$module/$module.module ] && cat << EOF >> $MINTLEAF_HOME/modules/$module/$module.module
|
|
#!/bin/bash
|
|
EOF
|
|
[ ! -f $MINTLEAF_HOME/modules/$module/$module.test ] && cat << EOF >> $MINTLEAF_HOME/modules/$module/$module.test
|
|
#!/bin/bash
|
|
|
|
function test_prerequisites() {
|
|
|
|
echo "TODO"
|
|
}
|
|
|
|
function test_module() {
|
|
|
|
assert_prerequisites
|
|
|
|
echo "TODO"
|
|
}
|
|
EOF
|
|
[ ! -f $MINTLEAF_HOME/modules/$module/$module.groovy ] && cat << EOF >> $MINTLEAF_HOME/modules/$module/$module.groovy
|
|
EOF
|
|
}
|
|
|
|
################################################################################
|
|
## general routines
|
|
##
|
|
|
|
function func_exists() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if function exists.
|
|
|
|
PARAMETERS:
|
|
\$1 function name
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local func=$1
|
|
|
|
declare -f -F $func > /dev/null
|
|
if [ "$?" == "0" ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function usleep() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Sleep in increments of milliseconds.
|
|
|
|
PARAMETERS:
|
|
\$1 milliseconds
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local ms=$1
|
|
local sec=$(echo "scale=2; $ms / 1000" | bc)
|
|
|
|
perl -e "select(undef,undef,undef,$sec)"
|
|
}
|
|
|
|
function h2d() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Convert hexadecimal to decimal number.
|
|
|
|
PARAMETERS:
|
|
\$1 hexadecimal number
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local hex=$1
|
|
|
|
hex=$(upper $hex)
|
|
local dec=$(echo "ibase=16; $hex" | bc)
|
|
echo $dec
|
|
}
|
|
|
|
function d2h() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Convert decimal to hexadecimal number.
|
|
|
|
PARAMETERS:
|
|
\$1 decimal number
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local dec=$1
|
|
|
|
local hex=$(echo "ibase=10; obase=16; $dec" | bc)
|
|
hex=$(lower $hex)
|
|
echo $hex
|
|
}
|
|
|
|
function random() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Return random string (A-Za-z0-9) with the given length.
|
|
|
|
PARAMETERS:
|
|
\$1 length
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local len=$1
|
|
|
|
local str=
|
|
str=</dev/urandom tr -dc A-Za-z0-9 | (head -c $ > /dev/null 2>&1 || head -c $len)
|
|
echo $str
|
|
}
|
|
|
|
function trim() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Remove whitespaces from the beginning and the end of a string.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str="$1"
|
|
|
|
str=$(sed -e 's/^[[:space:]]*//' <<<"$str")
|
|
str=$(sed -e 's/[[:space:]]*$//' <<<"$str")
|
|
echo "$str"
|
|
}
|
|
|
|
function lower() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Convert string to lower case.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str="$1"
|
|
|
|
str=$(echo $str | tr '[:upper:]' '[:lower:]')
|
|
echo "$str"
|
|
}
|
|
|
|
function upper() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Convert string to upper case.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str="$1"
|
|
|
|
str=$(echo $str | tr '[:lower:]' '[:upper:]')
|
|
echo "$str"
|
|
}
|
|
|
|
function str_sanitise() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Sanitise string to meet certain criteria.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 character to be used as a replacement
|
|
--allowed-characters <characters>
|
|
--max-length <length>
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local char=$2
|
|
|
|
# get optional parameters
|
|
local allowed_characters=
|
|
local max_length=255
|
|
if [ "$3" != "" ] && [ "$3" != "--allowed-characters" ]; then
|
|
len=$3
|
|
fi
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--allowed-characters) shift; allowed_characters=$1
|
|
;;
|
|
--max-length) shift; max_length=$1
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# remove unwanted characters
|
|
local sanitised=$(echo $str | sed "s/[^A-Za-z0-9$allowed_characters]/$char/g")
|
|
# remove multiple instances of the replacement character
|
|
sanitised=$(echo $sanitised | sed -r "s/($char)+/$char/g")
|
|
# limit the length
|
|
sanitised=$(echo $sanitised | cut -c1-${max_length})
|
|
# make it lower case
|
|
echo $sanitised | tr '[:upper:]' '[:lower:]'
|
|
}
|
|
|
|
function str_substring() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Return substring by removing its prefix and suffix.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 prefix
|
|
\$3 suffix
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 3 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local pre=$2
|
|
local suf=$3
|
|
|
|
local str="${str#${str%${pre}*}${pre}}"
|
|
echo "${str%${suf}*}"
|
|
}
|
|
|
|
function str_contains() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if string contains another string.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 search string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local search=$2
|
|
|
|
local count=$(echo "$str" | grep "$search" | wc -l)
|
|
if [ $count -gt 0 ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function str_begins() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if string begins with another string.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 search string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local search=$2
|
|
|
|
local count=$(echo "$str" | grep "^$search" | wc -l)
|
|
if [ $count -eq 1 ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function str_ends() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if string ends with another string.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 search string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local search=$2
|
|
|
|
local count=$(echo "$str" | grep "$search$" | wc -l)
|
|
if [ $count -eq 1 ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function str_split_part() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Split string and return part given by the third argument.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 separator
|
|
\$3 part (index starts from 1)
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 3 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local separator=$2
|
|
local part=$3
|
|
|
|
echo $(echo $str | awk '{ split($str,a,v1); print a[v2]; }' v1=$separator v2=$part)
|
|
}
|
|
|
|
function str_compare_ver() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Compare two version strings.
|
|
|
|
PARAMETERS:
|
|
\$1 version
|
|
\$2 version
|
|
|
|
RETURN: -1, 0 or 1 as the first argument is less than, equal to or greater than the second.
|
|
HEREDOC
|
|
)
|
|
|
|
if [[ $1 == $2 ]]; then
|
|
echo 0
|
|
return
|
|
fi
|
|
|
|
local ver1a=$(echo $1 | grep -oEi '[0-9\.]*' | head -1)
|
|
local ver1b=$(str_substring $1 $ver1a "")
|
|
local ver2a=$(echo $2 | grep -oEi '[0-9\.]*' | head -1)
|
|
local ver2b=$(str_substring $2 $ver2a "")
|
|
|
|
local IFS=.
|
|
local i ver1=($ver1a) ver2=($ver2a)
|
|
|
|
# test the 1st part
|
|
for ((i=${#ver1[@]}; i<${#ver2[@]}; i++)); do
|
|
ver1[i]=0
|
|
done
|
|
for ((i=0; i<${#ver1[@]}; i++)); do
|
|
if [[ -z ${ver2[i]} ]]; then
|
|
ver2[i]=0
|
|
fi
|
|
if ((10#${ver1[i]} > 10#${ver2[i]})); then
|
|
echo 1
|
|
return
|
|
fi
|
|
if ((10#${ver1[i]} < 10#${ver2[i]})); then
|
|
echo -1
|
|
return
|
|
fi
|
|
done
|
|
|
|
# test the 2nd part
|
|
if [ "$ver1b" \< "$ver2b" ]; then
|
|
echo -1
|
|
return
|
|
elif [ "$ver1b" \> "$ver2b" ]; then
|
|
echo 1
|
|
return
|
|
fi
|
|
|
|
echo 0
|
|
}
|
|
|
|
################################################################################
|
|
## file routines
|
|
##
|
|
|
|
function file_escape_name() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Escape file name using the same way bash does it.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
|
|
echo $(printf '%q' "$str" | sed s/=/\\\\=/g)
|
|
}
|
|
|
|
function file_contains() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if file contains given string.
|
|
|
|
PARAMETERS:
|
|
\$1 string to search for (regular expression matching multiple lines)
|
|
\$2 file name
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local file=$2
|
|
|
|
local count=$(cat $file | pcregrep -M "$str" | wc -l)
|
|
if [ $count -gt 0 ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function file_replace_str() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Replace string in given file.
|
|
|
|
PARAMETERS:
|
|
\$1 string to search for
|
|
\$2 new string
|
|
\$3 file name
|
|
-m|--multiline
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 3 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str1=$1
|
|
local str2=$2
|
|
local file=$3
|
|
|
|
# get optional parameters
|
|
local multiline="n"
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
-m|--multiline) shift; multiline="y"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
local tmp_file=~/file_replace_str.$$
|
|
if [ $multiline == "y" ]; then
|
|
cat $file | perl -0777 -pe "s/$str1/$str2/igs" > $tmp_file
|
|
else
|
|
sed "s/$str1/$str2/g" $file > $tmp_file
|
|
fi
|
|
mv $tmp_file $file
|
|
}
|
|
|
|
function file_remove_str() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Remove string from given file.
|
|
|
|
PARAMETERS:
|
|
\$1 string to remove
|
|
\$2 file name
|
|
-m|--multiline
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local file=$2
|
|
|
|
# get optional parameters
|
|
local multiline="n"
|
|
if [ "$3" == "-m" ] || [ "$3" == "--multiline" ]; then
|
|
multiline="y"
|
|
fi
|
|
|
|
local tmp_file=~/file_remove_str.$$
|
|
if [ $multiline == "y" ]; then
|
|
cat $file | perl -0777 -pe "s/$str//igs" > $tmp_file
|
|
else
|
|
str='1h;1!H;${;g;s/'
|
|
sed -n "$str$1//g;p;}" $file > $tmp_file
|
|
fi
|
|
mv $tmp_file $file
|
|
}
|
|
|
|
function file_download() {
|
|
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Download file from given URL address.
|
|
|
|
PARAMETERS:
|
|
--url <url> URL address of file to download (required).
|
|
--file <name> Name of output file.
|
|
--cache-dir <dir> Cache directory; file name in that directory
|
|
must match the file name given as the parameter.
|
|
--donwload-directory <directory> Destination directory where file
|
|
should be placed after download.
|
|
--size <size> Check file size after download.
|
|
--hash <hash> Check file hash after download.
|
|
--hash-algorithm <algorithm> Hash algorithm used to check file.
|
|
--do-not-cache Do not cache file locally.
|
|
--force Force to download from given URL address not
|
|
using cached file or an alternative location.
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 4 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# variables
|
|
local url=
|
|
local file=
|
|
local cache_dir=$mintleaf_tmp_dir
|
|
local download_dir=./
|
|
local expected_size=0
|
|
local expected_hash=
|
|
local hash_algorithm="md5"
|
|
local do_not_cache=$result_neg
|
|
local force=$result_neg
|
|
local current_dir=$(pwd)
|
|
|
|
# get parameters
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--url) shift; url=$1
|
|
;;
|
|
--file) shift; file=$1
|
|
;;
|
|
--cache-dir) shift; cache_dir=$1
|
|
;;
|
|
--download-directory) shift; download_dir=$1
|
|
;;
|
|
--size) shift; expected_size=$1
|
|
;;
|
|
--hash) shift; expected_hash=$1
|
|
;;
|
|
--hash-algorithm) shift; hash_algorithm=$1
|
|
;;
|
|
--do-not-cache) do_not_cache=$result_pos
|
|
;;
|
|
--force) force=$result_pos
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# file may have already been downloaded
|
|
if [ $force == $result_neg ] && [ -s $cache_dir/$file ] && [ ! -s $download_dir/$file ]; then
|
|
|
|
cp -f $cache_dir/$file $download_dir
|
|
|
|
else
|
|
|
|
# download from local network
|
|
# TODO
|
|
|
|
# download from custom location
|
|
# TODO
|
|
|
|
# download from given url address
|
|
if ([ -n $url ] && ([ ! -s $cache_dir/$file ] || [ $force == $result_pos ])); then
|
|
# try to download
|
|
wget --tries=1 --connect-timeout=10 $url -O $file
|
|
# cache file
|
|
if [ -s $file ]; then
|
|
mv -f $file $cache_dir
|
|
fi
|
|
fi
|
|
|
|
# copy file to the download directory
|
|
if [ -s $cache_dir/$file ] && [ $cache_dir != $download_dir ]; then
|
|
cp -f $cache_dir/$file $download_dir
|
|
fi
|
|
|
|
# do not cache
|
|
if [ $do_not_cache == $result_pos ]; then
|
|
rm -f $cache_dir/$file
|
|
fi
|
|
|
|
fi
|
|
|
|
# check file size
|
|
if [ $expected_size -ne 0 ] && [ -s $download_dir/$file ]; then
|
|
local size=$(ls -l $download_dir/$file | awk '{ print $5 }')
|
|
if [ $expected_size -gt $size ]; then
|
|
rm -f $download_dir/$file
|
|
fi
|
|
fi
|
|
|
|
# return value
|
|
if [ -s $download_dir/$file ]; then
|
|
# check file hash
|
|
if [ -n "$expected_hash" ]; then
|
|
file_valid_hash $download_dir/$file $expected_hash $hash_algorithm
|
|
else
|
|
echo $result_pos
|
|
fi
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
|
|
cd $current_dir
|
|
}
|
|
|
|
function file_valid_hash() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Validate hash sum of given file.
|
|
|
|
PARAMETERS:
|
|
\$1 file name
|
|
\$2 hash sum
|
|
\$3 algorithm (optional) md5,sha1,sha256,sha384,sha512 (default md5)
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local file=$1
|
|
local hash=$2
|
|
local algorithm=$3
|
|
|
|
[ -z "$algorithm" ] && algorithm="md5"
|
|
local current_hash=$(${algorithm}sum $file | awk '{ print $1 }')
|
|
|
|
if [ "$(lower $hash)" == "$(lower $current_hash)" ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function dir_find_str() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Search directory for files that contain given string.
|
|
|
|
PARAMETERS:
|
|
\$1 string to search for
|
|
\$2 directory (optional)
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local dir=$2
|
|
|
|
if [ "$dir" == "" ]; then
|
|
find . -iname "*" | xargs grep -iR "$str" | \
|
|
sort | uniq
|
|
else
|
|
find $dir -iname "*" | xargs grep -iR "$str" | \
|
|
sort | uniq
|
|
fi
|
|
}
|
|
|
|
function dir_replace_str() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Replace string in files in the given directory.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 new string
|
|
\$3 directory (optional)
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str1=$1
|
|
local str2=$2
|
|
local dir=$3
|
|
[ "$dir" == "" ] && dir=.
|
|
|
|
for file in $(find $dir -type f -name "*"); do
|
|
file_replace_str "$str1" "$str2" $file
|
|
done
|
|
}
|
|
|
|
function dir_remove_str() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Remove string in files in the given directory.
|
|
|
|
PARAMETERS:
|
|
\$1 string
|
|
\$2 directory (optional)
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local str=$1
|
|
local dir=$2
|
|
[ "$dir" == "" ] && dir=.
|
|
|
|
for file in $(find $dir -type f -name "*"); do
|
|
file_remove_str $str $file
|
|
done
|
|
}
|
|
|
|
################################################################################
|
|
## chroot routines
|
|
##
|
|
|
|
function chroot_dependency_list() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: List dependencies of an executable file.
|
|
|
|
PARAMETERS:
|
|
\$1 executable file
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local bin=$1
|
|
|
|
(
|
|
local output=$(ldd $bin)
|
|
for line in $output; do
|
|
echo $line
|
|
done
|
|
) 2> /dev/null | grep "^/" | sort | uniq
|
|
}
|
|
|
|
function chroot_dependency_list_all() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: List dependencies of an executable file recursively.
|
|
|
|
PARAMETERS:
|
|
\$1 executable file
|
|
--cur-depth <level> current depth of recursion (1 by default)
|
|
--max-depth <level> maximum depth of recursion (3 by default)
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local bin=$1
|
|
|
|
# get optional parameters
|
|
local cur_depth=1
|
|
local max_depth=3
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--cur-depth) shift; cur_depth=$1
|
|
;;
|
|
--max-depth) shift; max_depth=$1
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
(
|
|
local output=$(chroot_dependency_list $bin)
|
|
for file in $output; do
|
|
echo "$file"
|
|
if [ $cur_depth -lt $max_depth ]; then
|
|
chroot_dependency_list_all $file --cur-depth $(expr $cur_depth + 1) --max-depth $max_depth
|
|
fi
|
|
done
|
|
) 2> /dev/null | grep "^/" | sort | uniq
|
|
}
|
|
|
|
function chroot_dependency_copy() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Copy dependencies of an executable file recursively to chroot directory.
|
|
|
|
PARAMETERS:
|
|
\$1 executable file
|
|
\$2 chroot directory
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local bin=$1
|
|
local dir=$2
|
|
|
|
local output=$(chroot_dependency_list_all $bin)
|
|
for file in $output; do
|
|
echo "$file"
|
|
mkdir -p $dir/$(dirname $file)
|
|
cp $file $dir/$(dirname $file)
|
|
done
|
|
}
|
|
|
|
function chroot_mount_dir() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Mount directory in chroot environment.
|
|
|
|
PARAMETERS:
|
|
\$1 directory to mount
|
|
\$2 directory within chroot directory environment
|
|
--read-only
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local dir=$1
|
|
local chdir=$2
|
|
local read_only="n"
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--read-only) read_only="y"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
if [ -d $dir ]; then
|
|
if [ "$(mount -l | grep $chdir | wc -l)" -gt 0 ]; then
|
|
umount $chdir
|
|
fi
|
|
mkdir -p $chdir
|
|
mount --bind $dir $chdir
|
|
if [ $read_only == "y" ]; then
|
|
mount -o remount,ro $chdir 2> /dev/null
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function chroot_create_env() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Create chroot environment.
|
|
|
|
PARAMETERS:
|
|
\$1 chroot directory
|
|
--user <user> user name to mount their home directory
|
|
--home-read-only whether user home directory should be mounted as read-only
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local dir=$1
|
|
|
|
# get additional parameters
|
|
local user=
|
|
local home_read_only=
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--user) shift; user=$1
|
|
;;
|
|
--home-read-only) home_read_only="--read-only"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
[ ! -d $dir ] && mkdir $dir
|
|
mkdir -p $dir/{bin,dev/pts,etc,home,lib,lib64,proc,root,sbin,tmp,usr/bin,usr/include,usr/lib,usr/lib64,usr/sbin}
|
|
|
|
chmod 1777 $dir/tmp
|
|
|
|
# /bin
|
|
chroot_mount_dir /bin $dir/bin --read-only
|
|
# /dev/pts
|
|
chroot_mount_dir /dev/pts $dir/dev/pts
|
|
# /etc
|
|
chroot_mount_dir /etc $dir/etc --read-only
|
|
# /lib
|
|
chroot_mount_dir /lib $dir/lib --read-only
|
|
# /lib64
|
|
chroot_mount_dir /lib64 $dir/lib64 --read-only
|
|
# /proc
|
|
chroot_mount_dir /proc $dir/proc
|
|
# /sbin
|
|
chroot_mount_dir /sbin $dir/sbin --read-only
|
|
# /usr/bin
|
|
chroot_mount_dir /usr/bin $dir/usr/bin --read-only
|
|
# /usr/include
|
|
chroot_mount_dir /usr/include $dir/usr/include --read-only
|
|
# /usr/lib
|
|
chroot_mount_dir /usr/lib $dir/usr/lib --read-only
|
|
# /usr/lib64
|
|
chroot_mount_dir /usr/lib64 $dir/usr/lib64 --read-only
|
|
# /usr/sbin
|
|
chroot_mount_dir /usr/sbin $dir/usr/sbin --read-only
|
|
|
|
rm -f $dir/dev/null
|
|
mknod -m 666 $dir/dev/null c 1 3
|
|
rm -f $dir/dev/zero
|
|
mknod -m 666 $dir/dev/zero c 1 5
|
|
rm -f $dir/dev/random
|
|
mknod -m 444 $dir/dev/random c 1 8
|
|
rm -f $dir/dev/urandom
|
|
mknod -m 444 $dir/dev/urandom c 1 9
|
|
|
|
# user home directory
|
|
if [ -n "$user" ]; then
|
|
local home_dir=/home/$user
|
|
if [ "$user" == "root" ]; then
|
|
home_dir=/root
|
|
fi
|
|
if [ -d $home_dir ]; then
|
|
chroot_mount_dir $home_dir ${dir}${home_dir} $home_read_only
|
|
fi
|
|
fi
|
|
}
|
|
|
|
function chroot_remove_env() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Remove chroot environment.
|
|
|
|
PARAMETERS:
|
|
\$1 chroot directory
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local dir=$1
|
|
|
|
rm -f $dir/dev/null
|
|
rm -f $dir/dev/zero
|
|
rm -f $dir/dev/random
|
|
rm -f $dir/dev/urandom
|
|
|
|
for path in $(mount -l | grep $dir | awk '{ print $3 }'); do
|
|
umount $path
|
|
done
|
|
|
|
rm -rf $dir/tmp/*
|
|
}
|
|
|
|
function is_chroot() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Indicates if current environment is a chroot environment.
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
if [ $(stat -c %i /) != 2 ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
################################################################################
|
|
## user routines
|
|
##
|
|
|
|
function user_exists() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if user exists.
|
|
|
|
PARAMETERS:
|
|
\$1 user
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local user=$1
|
|
|
|
if [ $(grep "^$1:" /etc/passwd | wc -l) == "1" ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function group_exists() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Check if group exists.
|
|
|
|
PARAMETERS:
|
|
\$1 group
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local group=$1
|
|
|
|
if [ $(grep "^$group:" /etc/group | wc -l) == "1" ]; then
|
|
echo $result_pos
|
|
else
|
|
echo $result_neg
|
|
fi
|
|
}
|
|
|
|
function user_create() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Create a new system user.
|
|
|
|
PARAMETERS:
|
|
\$1 user
|
|
\$2 group
|
|
--uid <user id>
|
|
--gid <group id>
|
|
--groups <list of groups>
|
|
--home <home directory>
|
|
--shell <shell>
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 2 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local user=$1
|
|
local group=$2
|
|
|
|
# get optional parameters
|
|
local uid="-K UID_MIN=${uid_min} -K UID_MAX=${uid_max}"
|
|
local gid="-K GID_MIN=${gid_min} -K GID_MAX=${gid_max}"
|
|
local groups=
|
|
local home="-d /dev/null"
|
|
local shell="-s /usr/sbin/nologin"
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--uid) shift; uid="-u ${1}"
|
|
;;
|
|
--gid) shift; gid="-g ${1}"
|
|
;;
|
|
--groups) shift; groups="-G ${1}"
|
|
;;
|
|
--home) shift; home="-d ${1}"
|
|
;;
|
|
--shell) shift; shell="-s ${1}"
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
groupadd $group $gid
|
|
useradd $user $uid -g $group $groups $home $shell
|
|
}
|
|
|
|
function user_delete() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Delete an existing system user.
|
|
|
|
PARAMETERS:
|
|
\$1 user
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -ne 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local user=$1
|
|
|
|
userdel -f $user > /dev/null 2>&1
|
|
}
|
|
|
|
################################################################################
|
|
## security routines
|
|
##
|
|
|
|
function security_gen_cert() {
|
|
|
|
# define help
|
|
local help=$(cat <<HEREDOC
|
|
|
|
DESCRIPTION: Generates X.509 certificate.
|
|
|
|
PARAMETERS:
|
|
\$1 certificate name
|
|
--size <size> size of certificate (default is 2048)
|
|
--days <days> for how many days certificate remains valid (default is 3650)
|
|
--dir <dirctory> output dirctory
|
|
HEREDOC
|
|
)
|
|
|
|
# check parameters
|
|
if [ "$1" == "--help" ] || [ $# -lt 1 ]; then
|
|
echo -e "${help}\n"
|
|
return
|
|
fi
|
|
|
|
# get parameters
|
|
local name=$1
|
|
local size=2048
|
|
local days=3650
|
|
local dir=.
|
|
while [ "$1" != "" ]; do
|
|
case $1 in
|
|
--size) shift; size=$1
|
|
;;
|
|
--days) shift; days=$1
|
|
;;
|
|
--dir) shift; dir=$1
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
$cmd_openssl req \
|
|
-new -x509 -nodes -sha1 -newkey rsa:$size -days $days -subj "/O=unknown/OU=unknown/CN=$name" \
|
|
-keyout $dir/$name.key \
|
|
-out $dir/$name.crt
|
|
cat $dir/$name.crt $dir/$name.key > $dir/$name.pem
|
|
chmod 400 $dir/$name.{crt,key,pem}
|
|
}
|