505 lines
14 KiB
Bash
505 lines
14 KiB
Bash
#!/usr/bin/env ksh
|
|
#******************************************************************************
|
|
# @(#) include_data.sh
|
|
#******************************************************************************
|
|
# @(#) Copyright (C) 2017 by KUDOS BVBA (info@kudos.be). All rights reserved.
|
|
#
|
|
# This program is a free software; you can redistribute it and/or modify
|
|
# it under the same terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program 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 General Public License for more details
|
|
#******************************************************************************
|
|
#
|
|
# DOCUMENTATION (MAIN)
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) MAIN: include_data
|
|
# DOES: helper functions for data (manipulation)
|
|
#
|
|
# -----------------------------------------------------------------------------
|
|
# DO NOT CHANGE THIS FILE UNLESS YOU KNOW WHAT YOU ARE DOING!
|
|
#******************************************************************************
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_get_lvalue_from_config()
|
|
# DOES: get an lvalue from the configuration file
|
|
# EXPECTS: parameter to look for [string]
|
|
# OUTPUTS: parameter value [string]
|
|
# RETURNS: 0=found; 1=not found
|
|
# REQUIRES: n/a
|
|
function data_get_lvalue_from_config
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _PARAMETER="${1}"
|
|
typeset _LVALUE=""
|
|
typeset _RC=0
|
|
|
|
_LVALUE=$(grep -i "^${_PARAMETER}=" ${_CONFIG_FILE} | cut -f2 -d'=')
|
|
|
|
if [[ -n "${_LVALUE}" ]]
|
|
then
|
|
print $(data_dequote "${_LVALUE}")
|
|
else
|
|
_RC=1
|
|
fi
|
|
|
|
return ${_RC}
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_chop()
|
|
# DOES: cut last character of input
|
|
# EXPECTS: string
|
|
# OUTPUTS: string with last character omitted
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_chop
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1%?}"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_contains_string()
|
|
# DOES: checks if a string (haystack) contains a substring (needle).
|
|
# EXPECTS: $1=haystack [string]; $2=needle [string]
|
|
# OUTPUTS: n/a
|
|
# RETURNS: 0=not found; 1=found
|
|
# REQUIRES: n/a
|
|
function data_contains_string
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
typeset _HAYSTACK="$1"
|
|
typeset _NEEDLE="$2"
|
|
typeset _RC=0
|
|
|
|
[[ "${_HAYSTACK#*${_NEEDLE}}" = "${_HAYSTACK}" ]] || _RC=1
|
|
|
|
return ${_RC}
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_decomma()
|
|
# DOES: remove comma's
|
|
# EXPECTS: [string] with comma's
|
|
# OUTPUTS: [string] without comma's
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_decomma
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr -d ',' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_decomma_last()
|
|
# DOES: remove last comma
|
|
# EXPECTS: [string] with a last comma
|
|
# OUTPUTS: [string] without last comma
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_decomma_last
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1%*,}"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_decomma_first()
|
|
# DOES: remove last comma
|
|
# EXPECTS: [string] with a last comma
|
|
# OUTPUTS: [string] without last comma
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_decomma_first
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1#,*}"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_dequote()
|
|
# DOES: remove quotes
|
|
# EXPECTS: quoted [string]
|
|
# OUTPUTS: de-quoted (both double and single, but not escaped) [string]
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_dequote
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr -d '\"' 2>/dev/null | tr -d "'" 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_comma2space()
|
|
# DOES: replace commas with a space
|
|
# EXPECTS: [string] with commas
|
|
# OUTPUTS: [string] with spaces
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_comma2space
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr ',' ' ' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_comma2newline()
|
|
# DOES: replace commas with a space
|
|
# EXPECTS: [string] with commas
|
|
# OUTPUTS: [string] with newlines
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_comma2newline
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr ',' '\n' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_newline2comma()
|
|
# DOES: replace newlines with a comma
|
|
# EXPECTS: [string] with newlines
|
|
# OUTPUTS: [string] with commas
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_newline2comma
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr '\n' ',' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_newline2hash()
|
|
# DOES: replace newlines with a hash
|
|
# EXPECTS: [string] with newlines (UNIX)
|
|
# OUTPUTS: [string] with hashes (UNIX)
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_newline2hash
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr '\r' '#' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_space2comma()
|
|
# DOES: replace spaces with a comma
|
|
# EXPECTS: [string] with spaces
|
|
# OUTPUTS: [string] with commas
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_space2comma
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr -s ' ' 2>/dev/null | tr ' ' ',' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_space2hash()
|
|
# DOES: replace spaces with a hash
|
|
# EXPECTS: [string] with spaces
|
|
# OUTPUTS: [string] with hashes
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_space2hash
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr -s ' ' 2>/dev/null | tr ' ' '#' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_strip_newline()
|
|
# DOES: remove newlines
|
|
# EXPECTS: [string] with newlines
|
|
# OUTPUTS: [string] without newlines
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_strip_newline
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr -d '\n' 2>/dev/null | tr -d '\r' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_lc()
|
|
# DOES: switch to lower case
|
|
# EXPECTS: [string]
|
|
# OUTPUTS: lower case [string]
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_lc
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr '[:upper:]' '[:lower:]' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_uc()
|
|
# DOES: switch to upper case
|
|
# EXPECTS: [string]
|
|
# OUTPUTS: upper case [string]
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
function data_uc
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
|
|
print "${1}" | tr '[:lower:]' '[:upper:]' 2>/dev/null
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_encode_url
|
|
# DOES: encode URL data
|
|
# EXPECTS: text to be encoded [string]
|
|
# OUTPUTS: encoded text [string]
|
|
# RETURNS: 0
|
|
# REQUIRES:
|
|
# REFERENCE: added from http://www.shelldorado.com/scripts/cmds/urlencode
|
|
function data_encode_url
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _EncodeEOL=0
|
|
|
|
LANG=C awk '
|
|
BEGIN {
|
|
# We assume an awk implementation that is just plain dumb.
|
|
# We will convert an character to its ASCII value with the
|
|
# table ord[], and produce two-digit hexadecimal output
|
|
# without the printf("%02X") feature.
|
|
|
|
EOL = "%0A" # "end of line" string (encoded)
|
|
split ("1 2 3 4 5 6 7 8 9 A B C D E F", hextab, " ")
|
|
hextab [0] = 0
|
|
for ( i=1; i<=255; ++i ) ord [ sprintf ("%c", i) "" ] = i + 0
|
|
if ("'"$_EncodeEOL"'" == "yes") _EncodeEOL = 1; else _EncodeEOL = 0
|
|
}
|
|
{
|
|
encoded = ""
|
|
for ( i=1; i<=length ($0); ++i ) {
|
|
c = substr ($0, i, 1)
|
|
if ( c ~ /[a-zA-Z0-9.-]/ ) {
|
|
encoded = encoded c # safe character
|
|
} else if ( c == " " ) {
|
|
encoded = encoded "+" # special handling
|
|
} else {
|
|
# unsafe character, encode it as a two-digit hex-number
|
|
lo = ord [c] % 16
|
|
hi = int (ord [c] / 16);
|
|
encoded = encoded "%" hextab [hi] hextab [lo]
|
|
}
|
|
}
|
|
if ( _EncodeEOL ) {
|
|
printf ("%s", encoded EOL)
|
|
} else {
|
|
print encoded
|
|
}
|
|
}
|
|
END {
|
|
#if ( _EncodeEOL ) print ""
|
|
}
|
|
' "$@"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_dot2ip()
|
|
# DOES: converts a dotted-decimal IPv4 address representation to the 32 bit number.
|
|
# EXPECTS: dotted-decimal IPv4 address [string]
|
|
# OUTPUTS: 32 bit number [string]
|
|
# REQUIRES: n/a
|
|
# REFERENCE: https://raw.githubusercontent.com/dualbus/tutorial_nmap/master/iprange
|
|
function data_dot2ip
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _DOT="$1"
|
|
typeset _IP=0
|
|
typeset _OLD_IFS="${IFS}"
|
|
|
|
IFS="."
|
|
set -A _COMPS ${_DOT}
|
|
IFS="${OLD_IFS}"
|
|
|
|
_IP=$((_IP | ((_COMPS[0] & 255) << 24) ))
|
|
_IP=$((_IP | ((_COMPS[1] & 255) << 16) ))
|
|
_IP=$((_IP | ((_COMPS[2] & 255) << 8) ))
|
|
_IP=$((_IP | ((_COMPS[3] & 255) << 0) ))
|
|
|
|
print "${_IP}"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_ip2dot()
|
|
# DOES: converts a 32 bit unsigned integer to dotted-decimal notation.
|
|
# EXPECTS: 32 bit unsigned integer [string]
|
|
# OUTPUTS: dotted-decimal [string]
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
# REFERENCE: https://raw.githubusercontent.com/dualbus/tutorial_nmap/master/iprange
|
|
function data_ip2dot
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _IP="$1"
|
|
typeset _W=""
|
|
typeset _X=""
|
|
typeset _Y=""
|
|
typeset _Z=""
|
|
|
|
_W=$(( (_IP >> 24) & 255 ))
|
|
_X=$(( (_IP >> 16) & 255 ))
|
|
_Y=$(( (_IP >> 8) & 255 ))
|
|
_Z=$(( (_IP >> 0) & 255 ))
|
|
|
|
print "${_W}.${_X}.${_Y}.${_Z}"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_bits2mask()
|
|
# DOES: converts bits notation (prefix) to a dotted-decimal representation
|
|
# EXPECTS: netmask in prefix [string]
|
|
# OUTPUTS: netmask in dotted decimal notation [string]
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
# REFERENCE: https://raw.githubusercontent.com/dualbus/tutorial_nmap/master/iprange
|
|
function data_bits2mask
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _BITS=$1
|
|
typeset _MAX=4294967296
|
|
typeset _OFFSET=0
|
|
|
|
case "${_BITS}" in
|
|
0) _OFFSET=${_MAX} ;;
|
|
1) _OFFSET=2147483648 ;;
|
|
2) _OFFSET=1073741824 ;;
|
|
3) _OFFSET=536870912 ;;
|
|
4) _OFFSET=268435456 ;;
|
|
5) _OFFSET=134217728 ;;
|
|
6) _OFFSET=67108864 ;;
|
|
7) _OFFSET=33554432 ;;
|
|
8) _OFFSET=16777216 ;;
|
|
9) _OFFSET=8388608 ;;
|
|
10) _OFFSET=4194304 ;;
|
|
11) _OFFSET=2097152 ;;
|
|
12) _OFFSET=1048576 ;;
|
|
13) _OFFSET=524288 ;;
|
|
14) _OFFSET=262144 ;;
|
|
15) _OFFSET=131072 ;;
|
|
16) _OFFSET=65536 ;;
|
|
17) _OFFSET=32768 ;;
|
|
18) _OFFSET=16384 ;;
|
|
19) _OFFSET=8192 ;;
|
|
20) _OFFSET=4096 ;;
|
|
21) _OFFSET=2048 ;;
|
|
22) _OFFSET=1024 ;;
|
|
23) _OFFSET=512 ;;
|
|
24) _OFFSET=256 ;;
|
|
25) _OFFSET=128 ;;
|
|
26) _OFFSET=64 ;;
|
|
27) _OFFSET=32 ;;
|
|
28) _OFFSET=16 ;;
|
|
29) _OFFSET=8 ;;
|
|
30) _OFFSET=4 ;;
|
|
31) _OFFSET=2 ;;
|
|
32) _OFFSET=1 ;;
|
|
esac
|
|
|
|
data_ip2dot "$(( (_MAX - 1) & ~(_OFFSET - 1) ))"
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_mask2bits()
|
|
# DOES: converts decimal netmask to bits notation (prefix)
|
|
# EXPECTS: netmask in dotted decimal notation [string]
|
|
# OUTPUTS: netmask in prefix [string]
|
|
# RETURNS: 0
|
|
# REQUIRES: n/a
|
|
# REFERENCE: https://raw.githubusercontent.com/dualbus/tutorial_nmap/master/iprange
|
|
function data_mask2bits
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _MASK="$1"
|
|
typeset -i _I=32
|
|
|
|
while (( _I > 0 ))
|
|
do
|
|
[[ "${_MASK}" = $(data_bits2mask "${_I}") ]] && print "${_I}"
|
|
_I=$(( _I - 1 ))
|
|
done
|
|
|
|
return 0
|
|
}
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# @(#) FUNCTION: data_is_IPv4()
|
|
# DOES: checks if an IP address is in IPv4 dotted notation
|
|
# EXPECTS: IPv4 address in decimal notation [string]
|
|
# RETURNS: 0=not IPv4; <>0=IPv4
|
|
# REQUIRES: n/a
|
|
function data_is_ipv4
|
|
{
|
|
(( ARG_DEBUG != 0 && ARG_DEBUG_LEVEL > 0 )) && set "${DEBUG_OPTS}"
|
|
typeset _IP="$1"
|
|
typeset _RC=0
|
|
|
|
_RC=$(print "${_IP}" | grep -c -E -e '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' 2>/dev/null)
|
|
|
|
return ${_RC}
|
|
}
|
|
|
|
#******************************************************************************
|
|
# END of script
|
|
#******************************************************************************
|