#!/bin/bash
# Author: Josh Bailey
# Email: jbsnake <at> <no spam> usalug.org
# A function/subroutine library
# A lot of these functions and subroutines I use
# in all my scripts, some I have only used once.
# This is a lot of hard work right here, so please
# don't get tempted by saying you did it yourself :)
# If you use something here (which you ofcourse are free to do)
# Please atleast give a link to www.usalug.org or www.bashscripts.org
# You don't have to mention me, just mention where you found such awesome code ;)
function notAForwardSlash
{
if [[ ${1} != '/' ]]
then
return 0
else
return 1
fi
}
function notADot
{
if [[ ${1} != '.' ]]
then
return 0
else
return 1
fi
}
function getFileName
{
# call this function like
# filename_variable=`getFileName /some/path/with/a/file.name`
local STRING=$1
local LENGTH=${#STRING}
local n=0
local FileName=""
for ((n=0;n <= $LENGTH; n++))
do
local CHAR=${STRING:$n:1}
if notAForwardSlash $CHAR
then
FileName=$FileName$CHAR
else
FileName=""
fi
done
echo "FileName"
}
function getExtension
{
# call this like
# extension_variable=`getExtension /path/to/some/file.txt`
# extension_variable would be "txt" for that example
# you can also just pass it a filename
# extension_variable=`getExtension somefile.lst`
# extention_variable would be "lst" for that example
# but if you pass it a filename or path without a .
# it will return exactly what you pass it
# extension_variable=`getExtension /path/to/my/script`
# extension_variable would be "/path/to/my/script"
local STRING="${1}"
local LENGTH="${#STRING}"
local n=0
local Extension=""
for ((n=0; n <= $LENGTH; n++))
do
local CHAR=${STRING:$n:1}
if notADot $CHAR
then
Extension=$Extension$CHAR
else
Extension=""
fi
done
echo "$Extension"
}
function getPath
{
# call this like
# chop_path=`getPath /path/to/something.file`
# chop_path would be populated with "/path/to/"
# function to get only the path from a path/filename combo
# first get the filename from $1 which is a path/filename combo
local just_filename=`getFileName "$1"`
# set the variable containing the path
local newPath=${1:0:(${#1}-${#just_filename})}
echo "$newPath"
}
function inStr
{
# call this function like
# instr_variable=`inStr "=" "1=2"`
# since the position of = is 1 (i.e. 0 1 2 )
# instr_variable would equal 1
local searchFor="$1";
local lenOf=${#searchFor};
local searchIn="$2";
for (( i=0; i < ${#searchIn}; i++ ))
do
if [[ "${searchIn:$i:$lenOf}" = "$searchFor" ]]
then
echo "$i"
return 0
fi
done
echo "$i"
return 1
}
function math
{
# call this function like
# math_variable=`math 1 + 2`
# the variable math_variable would be: 3
local newNumber=`bc -l 2> /dev/null<< EOF
scale = 2
${1} ${2} ${3}
EOF
`
echo "$newNumber"
}
##################### sub routines ###########################
function isRoot
{
# call this like
# if [[ isRoot ]]
# then
# yes the user is root
# else
# no the user isn't root
#fi
if [[ `id -u` = 0 ]]
then
return 0
else
return 1
fi
}
function has_read_write_access
{
# call this like
# if [[ has_read_write_access /path/to/directory/to/check ]]
# then
# yes they do
# else
# no they don't
# fi
ls ${1} > /dev/null
if [[ $? -eq 1 ]]
then
return 1
else
touch ${1}/bob.yea\ do0d 2> /dev/null
if [[ $? -eq 1 ]]
then
rm ${1}/bob.yea\ do0d 2> /dev/null
return 1
else
rm ${1}/bob.yea\do0d 2> /dev/null
return 0
fi
fi
}
function trimspaces
{
# call this like
# new_string=`trimspaces "some random text" " "`
# new_string variable would be "somerandomtext"
# new_string=`trimspaces "some_random_text" "_"`
# new_string variable would be "somerandomtest"
# new_string=`trimspaces "some random_text"
# new_string variable would be "somerandom_text" (default, if nothing is passed, to remove are spaces)
local NewString=""
local STRING="$1"
local rmChar="$2"
local CHAR=""
local NewString=""
if [[ $rmChar = "" ]]
then
rmChar=' '
fi
for ((i=0; i<${#STRING}; i++))
do
CHAR=${STRING:$i:1}
if [[ $CHAR != $rmChar ]]
then
NewString=$NewString$CHAR
fi
done
echo "${NewString}"
}
function fileExist
{
# call this like
# if [[ fileExist "/path/to/some/file.name" ]]
# then
# yes it does
# else
# no it doesn't
# fi
if [[ -a "$1" ]]
then
return 0
else
return 1
fi
}
function isNumeric
{
# call this like
# if [[ isNumeric <something> ]]
# then
# yes it is
# else
# no it's not
# fi
local Numeric='y'
local len=`echo ${#1}`
local val=""
local retval=""
for ((i=0; i<$len; i++))
do
val=`echo ${1:$i:1}`
echo $val | grep ^[0-9] > /dev/null
retval=$?
if [[ $retval -eq 1 ]]
then
if [[ $i -eq 0 && $val = '-' ]]
then
num="negative"
else
Numeric='n'
break
fi
fi
done
if [[ $Numeric = 'y' ]]
then
return 0
else
return 1
fi
}
function isAlpha
{
# call this like
# if [[ isAlpha <something> ]]
# then
# yes it is
# else
# no it's not
# fi
local Alpha='y'
local len=`echo ${#1}`
local val=""
local retval=""
for ((i=0; i<$len; i++))
do
val=`echo ${1:$i:1}`
val=`echo $val | tr [:upper:] [:lower:]`
echo $val | grep ^[a-z] > /dev/null
retval=$?
if [[ $retval -eq 1 ]]
then
Alpha='n'
break
fi
done
if [[ $Alpha = 'y' ]]
then
return 0
else
return 1
fi
}
function isAlphaNum
{
# call this like
# if [[ isAlphNum <something> ]]
# then
# yes it is
# else
# no it's not
# fi
local AlphaNum='y'
local len=`echo ${#1}`
local val=""
local retval=""
for ((i=0; i<$len; i++))
do
val=`echo ${1:$i:1}`
val=`echo $val | tr [:upper:] [:lower:]`
echo $val | grep ^[a-z] > /dev/null
retval=$?
if [[ $retval -eq 1 ]]
then
echo $val | grep ^[0-9] > /dev/null
retval=$?
if [[ $retval -eq 1 ]]
then
AlphaNum='n'
break
fi
fi
done
if [[ $AlphaNum = 'y' ]]
then
return 0
else
return 1
fi
}
function initialCaps()
{
# call this like
# new_string=`initialCaps "john doe"`
# new_string variable would be "John Doe"
local Cap=""
local Info=""
local Word=""
local string="${1}"
local cut=""
while [ ${#1} != 0 ]
do
Cap=`echo ${string:0:1} | tr [:lower:] [:upper:]`
Info=`echo -n $Cap; echo ${string:1:${#string}} | tr [:upper:] [:lower:]`
Info=${Info}" "
Word=${Word}${Info}
shift 1
done
cut=${#Word}-1
Word="${Word:0:${cut}}"
echo "${Word}"
}
######## Music file format stuff #################################
function get_ogg_info
{
# call this like
# ogg_info_string=`get_ogg_info "/path/to/file.ogg"`
# ofcourse the string would have to be parsed
# it is pipe | delimited
# in order artist, title, album, genre, date, and track number
# inStr function needed; vorbiscomment (comes with oggenc)
local turn=""
local index=0
local item=""
local cartist=""
local ctitle=""
local calbum=""
local cgenre=""
local cdate=""
local ctracknumber=""
vorbiscomment -l "$1" > info.lst
for turn in artist title album genre date tracknumber
do
tmp_comment=`grep -i "$turn" info.lst`
item=`inStr "=" "$tmp_comment"`
comment=${tmp_comment:${item}+1}
((index++))
case $index in
1) cartist="$comment";
;;
2) ctitle="$comment";
;;
3) calbum="$comment";
;;
4) cgenre="$comment";
;;
5) cdate="$comment";
;;
6) ctracknumber="$comment";
;;
esac
done
info="${cartist}|${ctitle}|${calbum}|${cgenre}|${cdate}|${ctracknumber}"
echo "${info}"
rm -f info.lst
}
function encode_flac2mp3
{
# call this like
# encode_flac2mp3 /path/to/source/file.flac /path/to/destination
# needs: getFileName function; flac encoder/decoder; lame
local old_file="${1}"
local new_dir="${2}"
local short_filename=`getFileName "${old_file}"`
local new_file="${short_filename:0:${#short_filename}-5}.mp3"
flac -d -o - "${old_file}" | lame -b 320 -h - > "${new_dir}/${new_file}"
}
function encode_flac2ogg
{
# call this like
# encode_flac2ogg /path/to/source/file.flac /path/to/destination
# needs: getFileName function; flac encoder/decoder; oggenc
local old_file="${1}"
local new_dir="${2}"
local short_filename=`getFileName "${old_file}"`
local new_file="${short_filename:0:${#short_filename}-5}.ogg"
###### get artist and album before release #########
# flac -d -o - "${old_file}" | oggenc -a "$artist" -l "$album" -t "${title}" - -o "${new_dir}/${new_file}"
####################################################
local title="${short_filename:0:${#short_filename}-4}"
flac -d -o - "${old_file}" | oggenc -t "${title}" - -o "${new_dir}/${new_file}"
}
function encode_ogg2mp3
{
# call this like
# encode_ogg2mp3 /path/to/source/file.flac /path/to/destination
# needs: getFileName function; oggdec; lame
local old_file="${1}"
local new_dir="${2}"
local short_filename=`getFileName "${old_file}"`
local new_file="${short_filename:0:${#short_filename}-4}.mp3"
local info_string=`get_ogg_info "$old_file"`
local cartist=`cut -d| -f1 ${info_string}`
local ctitle=`cut -d| -f2 ${info_string}`
local calbum=`cut -d| -f3 ${info_string}`
local cgenre=`cut -d| -f4 ${info_string}`
local cdate=`cut -d| -f5 ${info_string}`
local ctracknumber=`cut -d| -f6 ${info_string}`
oggdec "${old_file}" -o - | lame -b 320 --tt "$ctitle" --ta "$cartist" --tl "$calbum" --ty $cdate --tn $ctracknumber --tg "$cgenre" -h - > "${new_dir}/${new_file}"
sleep .5
}
####################################################################################
############################ gpg stuff #############################################
function list_private_keys
{
# call this like
# list_private_keys
# it just clears the screen then
# pipes the private items on your keyring to less
clear;
echo ":: Listing private keys";
gpg --list-secret-keys | less;
echo ":: Done";
}
function list_public_keys
{
# call this like
# list_public_keys
# it just clears the screen then
# pipes the public imported keys on
# your keyring to less
clear;
echo ":: Listing public keys";
gpg --list-keys | less;
echo ":: Done";
}
function decrypt_any_file
{
# call this like
# decrypt_any_file /path/to/some/encrypted/file.asc
# it clears the screen then prompts you for your passphrase
# then decrypts the encrypted file into another file
local filename="$1";
local person=`whoami`;
clear;
if [[ ${filename:${#filename}-11:11} -eq "-encrypted" ]]
then
local newfilename="${filename:0:${#filename}-${#person}-12}";
gpg -d --output "$newfilename" "$filename";
echo ":: Decrypted $filename";
echo ":: Saved as $newfilename";
else
gpg -d --output "$filename.decrypted" "$filename";
echo ":: Decrypted $filename";
echo ":: Saved as $filename.decrypted";
fi
}
function encrypt_any_file
{
# call this like
# encrypt_any_file /path/to/file/to/encrypt.asc "who it's encrypted for"
# it clears the screen then encrypts the file you specified
# saving the encrypted file to have the persons name and "-encrypted" at the end
local filename="$1";
local person="$2";
clear;
gpg -sea --output "$filename"."$person"-encrypted --recipient "$person";
echo ":: File $filename encrypted";
echo ":: Encrypted file saved as $filename.$person-encrypted";
}
function export_public_key
{
# call this like
# export_public_key "Key Identifier"
# generates a key pair and saves the public key as "Key Identifier.pub"
local ID="$1";
gpg -ao $ID.pub --export $ID;
echo ":: Public Key for $ID has been generated"
echo ":: File is saved as $ID.pub"
}
function import_public_directory
{
# call this like
# import_public_directory /path/to/directory/full/of/public/keys
# changes directory to the public key directory and imports every file there
# then goes back to the directory you started in
local DIR=$1;
cd "$DIR";
for filename in *
do
gpg --import "$filename";
done;
cd ~-;
}
function create_encrypted_ascii_file
{
# call this like
# create_encrypted_ascii_file /path/to/location/for/future/message.asc "Who to encrypt for"
# opens a vi session (note you can make the editor whatever you want by changing the variable)
# once you close the editor, the file you just edited is encrypted
# then it's echo'd to the console for easy copy and pasting
local editor="vi"
local file="${1}";
local person="${2}";
${editor} "${file}";
gpg -sea --output "${file}.${person}-encrypted" --recipient "${person}" "${file}";
clear;
echo ":: Encrypted file created";
echo ":: File saved as ${file}.${person}-encrypted";
echo ":: Contents of file shown below";
echo -e "\n\n";
cat "${file}.${person}-encrypted"
}
function import_public_key
{
# call this like
# import_public_key
# it prompts you for the key-file you wish to import
read -p "Please type the path of the public key you wish to import: " file
if [[ -e "$file" ]]
then
gpg --import "$file"
else
echo "${file}: doesn't exist, or you typed the wrong path!"
exit
fi
}
function create_user_list
{
# call this like
# create_user_list
# makes a list of users on the system
# it grabs the contents of /etc/passwd
# then removes the entry for root
# and saves the list as users.list
cat /etc/passwd | cut -d: -f1 > pre.list;
cat pre.list | grep -v "root" > users.list;
rm pre.list;
}
#####################################################################################3
function app_up
{
# call this like
# app_up /path/to/file/append.from /path/to/file/append.to
# puts data from a file at the top of another file instead of the bottom
if [[ ! -e ${2} ]]
then
touch ${2}
fi
${1} > temp
cat ${2} >> temp
rm -f ${2}
mv temp ${2}
}
function createROMISO
{
# call this like
# createROMISO /dev/cdrom /path/to/new/rom.iso
# the command that makes an ISO from a cd/dvd
# $1 should be the device path (/dev/cdrom)
# $2 should be the iso path and filename
dd if=$1 of=$2 bs=32k
}
function createDIRISO
{
# call this like
# createDIRISO /path/to/new/rom.iso /path/to/directory/you/want/to/backup
# the command that makes an ISO from a directory
# $1 should be the iso path and filename
# $2 should be the directory to backup
mkisofs -o $1 $2
}
function msg
{
# call this like
# msg "Title of Message Box"
# or
# msg "Title of Message Box" $height $width
# function for making a messagebox
# if it has less than two arguments
if [[ $# < 2 ]]
then
# use auto-size for the messagebox
dialog --msgbox "$1" 0 0
else
# use specified height and width
dialog --msgbox "$1" $2 $3
fi
clear
}
