To understand the setuid bit, let’s first see what happens when I try to cat a file that belongs to root:

su -
# I am now root; fear me
touch no-one-can-touch-me
chmod 600 no-one-can-touch-me
exit
cat no-one-can-touch-me
# cat: Permission denied 

Next, I’ll create a shell script that cats the file:

#!/bin/bash
 
cat no-one-can-touch-me

And make the script setuid root:

su -
chown root:root script.sh
chmod +xs script.sh

If I now execute the script, I still get the permission denied. What I need to make this work is a wrapper program. For that, I refer to Wiebe’s post about the same subject. (Yeah, I know: why bother publishing this if Wiebe already did an excellent job explaining? Well, I just hate to throw away an otherwise fine draft.)

echo /just/a/path/ | sed -e 's#/$##'
# Output: /just/a/path
 
# And, if there isn't an appending slash, nothing happens:
 
echo /just/another/path | sed -e 's#/$##'
# Output: /just/another/path 

It works quite simple. Sed executes expression (-e) on its standard input. The expression is a substitution using regular expressions. The #-sign is the delimiter. The part (#/) between the first two hash signs is the matching expression and the (empty) part between the second and the third hash sign is the replacement expression. This expression (“s#/$##”) basically says: replace all occurrences of “/” at the end of the line (the dollar sign is the end-of-line anchor) with nothing.

To use this in a script is easy-peasy. Suppose $1 is a system path that may or may not include an appending slash:

#!/bin/bash
 
sanitized_path=`echo "$1" | sed -e 's#/$##'`
 
echo $sanitized_path

This script outputs its first parameter with the appending slash removed.

#!/bin/bash
#
# Author: Wiebe Cazemier (wiebe@halfgaar.net)
#
# Template bash script, for when you need something overengineerd :)
 
# Hack prevention
PATH="/sbin:/usr/sbin:/bin:/usr/bin"
 
# Error codes
wrong_params=5
interrupted=99
default_error=1
 
# Function to echo in color. Don't supply color for normal color.
echo_color()
{
  message="$1"
  color="$2"
 
  red_begin="\033[01;31m"
  green_begin="\033[01;32m"
  yellow_begin="\033[01;33m"
  color_end="\033[00m"
 
  # Set color to normal when there is no color
  [ ! "$color" ] && color_begin="$color_end"
 
  if [ "$color" == "red" ]; then
    color_begin="$red_begin"
  fi
 
  if [ "$color" == "green" ]; then
    color_begin="$green_begin"
  fi
 
  if [ "$color" == "yellow" ]; then
    color_begin="$yellow_begin"
  fi
 
  echo -e "${color_begin}${message}${color_end}"
}
 
end()
{
  message="$1"
  exit_status="$2"
 
  if [ -z "$exit_status" ]; then
    exit_status="0"
  fi
 
  if [ ! "$exit_status" -eq "0" ]; then
    echo_color "$message" "red"
  else
    echo_color "$message" "green"
  fi
 
  if [ "$exit_status" -eq "$wrong_params" ]; then
    dohelp
  fi
 
  exit $exit_status
}
 
# Define function to call when SIGTERM is received
trap "end 'Interrupted' $interrupted" 1 2 3 15
 
dohelp()
{
  echo ""
  echo "Example script"
  echo ""
  echo "help = todo"
 
  # Exit because you don't want the script to do anything after displaying help
  exit 
}
 
 
while [ -n "$*" ]; do
  flag=$1
  value=$2
 
  case "$flag" in
    "--option1")
      option1=$value
      shift
    ;;
    "--help")
      dohelp
    ;;
    "--")
      break
    ;;
    *)
      end "unknown option $flag. Type --help" "$wrong_params"
    ;;
  esac
 
  shift
done
 
if [ -z "$option1" ]; then
  end "option1 not given" $wrong_params
fi

dohelp()
{
  echo "Example script"
  echo ""
 
  # Exit because you don't want the script to do anything after displaying help
  exit
}
 
 
while [ -n "$*" ]; do
  flag=$1
  value=$2
 
  case "$flag" in
    "--one")
      one=$value
      shift
    ;;
    "--two")
      two=$value
      shift
    ;;
    "--pretend")
      pretend=true
    ;;
    "--help")
      dohelp
    ;;
    "--")
      break
    ;;
    *)
      echo -e "unknown option $flag\n"
      dohelp
    ;;
  esac
 
  shift
done

cannot open `+6' for reading: No such file or directory 

This line caused it:

sum1=`tail +6 $0 | cksum | sed -e 's/ /Z/' -e 's/   /Z/' | cut -dZ -f1`

To fix it, I set this environment variable:

export _POSIX2_VERSION=199209

Apparently, this makes programs behave differently. Research is required to find out exactly what it does…

#!/bin/bash
 
usage() {
    cat <<"EOF"
$0 [--dry-run] <svn_dir> <replacement_dir>
 
This script replaces the contents of <svn_dir> with the contents of <replacement_dir>,
where <replacement_dir> is not an svn directory.
 
Copyleft 2010, Rowan Rodrik van der Molen <rowan@bigsmoke.us>
EOF
}
 
fatal_error() {
    message=$1
 
    echo -e "\e[1;31m$message\e[0m"
    exit 1
}
 
usage_error() {
    error="Wrong usage."
 
    if [ -n "$1" ]; then
        error=$1
    fi
 
    echo -e "\e[1;31m$error\e[0m"
    exit 1
}
 
run_command() {
    echo -e "\e[1;34m$1\e[0m"
 
    [ $dry_run == 1 ] || eval $1
}
 
dry_run=0
if [ $1 == '--dry-run' ]; then
  dry_run=1
  shift
fi
 
 
[ $# == 2 ] || usage_error "Wrong number of arguments."
 
svn_dir=`echo "$1"|sed -e 's#/$##'`
replacement_dir=`echo "$2"|sed -e 's#/$##'`
begin_path=$PWD
 
#if [ "${svn_dir:0:1}" != "/" ]; then svn_dir="$PWD/$svn_dir"; fi
#if [ "${replacement_dir:0:1}" != "/" ]; then replacement_dir="$PWD/$replacement_dir"; fi
 
[ -d "$svn_dir" ] || usage_error "$svn_dir is not a directory."
[ -d "$replacement_dir" ] || usage_error "$replacement_dir is not a directory."
 
 
# Create all subdirectories in $svn_dir that do not yet exist
cd $replacement_dir
find . -mindepth 1 -type d -print | sed -e 's#^./##' | while read d; do
    cd $begin_path/$svn_dir
    # Doesn't the destination directory already exist?
    if [ ! -d "$d" ]; then
        run_command "svn mkdir '$d'"
    fi
done
 
# Copy all files from $replacement_dir to $svn_dir
cd $begin_path/$replacement_dir
find . -type f -print | sed -e 's#^./##' | while read f; do
    cd $begin_path
    run_command "cp '$replacement_dir/$f' '$svn_dir/$f'" # FIXME: Quoting problem
done
 
# Remove all files that do no longer exist in $replacement dir
cd $begin_path/$svn_dir
find . -type f -print | grep -v '.svn' | while read f; do
    if [ ! -f "$begin_path/$replacement_dir/$f" ]; then
        run_command "svn rm '$f'"
    fi
done
 
# Remove all subdirs that do no longer exist in $replacement dir
cd $begin_path/$svn_dir
find . -mindepth 1 -type d -print | grep -v '.svn' | while read d; do
    if [ ! -d "$begin_path/$replacement_dir/$d" ]; then
        run_command "svn rm '$d'"
    fi
done
 
exit 0

Using the script is simple:

svn-replace-dir simple-tags new-simple-tags|less -R

It replaces all the contents of the first directory (simple-tags in the example) with those of the second directory and it deletes everything that is no longer present in the second dir. In the process, it does all the necessary calls to svn mkdir, svn rm and (in the next version) svn add.

diff tells me that the script has done its work correctly:

diff -x .svn -ruN simple-tags new-simple-tags
# Emptiness is bliss :-) 

This is another one of these occasions when Git would have made life so much easier. Luckily, at least there’s GitHub to host this script as a Gist. Check there if you want to fetch the newest version of this script.

/etc/bash.bashrc_halfgaar (naming scheme depends on distro):

function prompt_command {
  local XTERM_TITLE="\e]2;\u@\H:\w\a"
 
  local BGJOBS_COLOR="\[\e[1;30m\]"
  local BGJOBS=""
  if [ "$(jobs | head -c1)" ]; then BGJOBS=" $BGJOBS_COLOR(bg:\j)"; fi
 
  local DOLLAR_COLOR="\[\e[1;32m\]"
  if [[ ${EUID} == 0 ]] ; then DOLLAR_COLOR="\[\e[1;31m\]"; fi
  local DOLLAR="$DOLLAR_COLOR\\\$"
 
  local USER_COLOR="\[\e[1;32m\]"
  if [[ ${EUID} == 0 ]]; then USER_COLOR="\[\e[41;1;32m\]"; fi
 
  PS1="$XTERM_TITLE$USER_COLOR\u\[\e[1;32m\]@\H:\[\e[m\] \[\e[1;34m\]\w\[\e[m\]\n\
$DOLLAR$BGJOBS \[\e[m\]"
}
export PROMPT_COMMAND=prompt_command
 
export EDITOR=vim
 
alias ls='ls --color=auto'
alias ll='ls -l'
alias lh='ls -lh'
alias grep='grep --color=auto'

Don’t forget to source the file in ~/.bashrc

~/.screenrc:

caption always "%{= kB}%-Lw%{=s kB}%50>%n%f* %t %{-}%+Lw%<"
vbell off
startup_message off
term linux

#! /bin/bash
#
# Script to send an SMS email notifcation to Mollie's HTTP gateways
# Based on the SMS2Email script which can also be found on nagiosexchange.org
# Reworked by Dennis Storm - Brainstorm ICT
# Again reworked by Wiebe Cazemier (wiebe@halfgaar.net), to include proper failure checks
#
#################################################################################
 
config_file="/etc/send-sms.conf"
log_file="/var/log/send-sms.log"
 
if [ -L "$log_file" ]; then
  echo "cannot continue, $log_file is a symlink."
  exit 2
fi
 
touch "$log_file" > /dev/null 2>&1
 
sender="SMSScript"
 
if [ -f "$config_file" ]; then
  source $config_file
fi
 
curl_location=`which curl 2> /dev/null`
 
if [ -z "$curl_location" ]; then
  echo "Curl command not found. Install that." >&2
  exit 1
fi
 
logfail()
{
  message="$1"
  message="Failure: [`date`]: $message" 
 
  echo $message
 
  if [ -w "$log_file" ]; then
    echo "$message" >> "$log_file"
  fi
 
  exit 1
}
 
# Show usage if necessary
if [ $# -eq 0 ]; then
    echo "Usage: $0 -s [sender] -n [numbers] -m [message] -u [username] -p [password]";
    echo "";
    echo "[numbers]  = SMS numbers (if multiple, enclose in quotes) to send message to.";
    echo "[message]  = Text of message you want to send";
    echo "[username] = Username assocated with Mollie  account";
    echo "[sender]   = Sender"
    echo "[password] = MD5 HTTP API Password assocated with Mollie account";
    echo ""
    echo "-d         = Dry run, pretend success."
    echo ""
    echo "The numbers, sender, username and password options are optional and";
    echo "override the account credentials defined in $config_file.";
    echo ""
    echo "A log file $log_file will be kept if it is writable to the user."
    echo "";
    exit 1;
fi
 
# Get command line arguments
while [ "$1" != "" ] ; do
    case $1
    in
  -n)
      # Get the SMS numbers that we should send message to
      numbers="$2";
      shift 2;
      ;;
  -m)
      # Get the message we should send
      message="$2";
      shift 2;
      ;;
  -s)
      # Get the sender to show in the SMS
      sender="$2";
      shift 2;
      ;;
  -u)
      # Get the username
      username="$2";
      shift 2;
      ;;
  -p)
      # Get the password
      password="$2";
      shift 2;
      ;;
  -d)
      dry_run="dry_run";
      shift 1;
      ;;
  *)
      echo "Unknown option: $1"
      exit 1;
      ;;
    esac
done
 
if [ -z "$username" ]; then
  logfail "No username specified or found in $config_file."
fi
 
if [ -z "$password" ]; then
  logfail "No password specified or found in $config_file."
fi
 
if [ -z "$numbers" ]; then
  logfail "No numbers specified or found in $config_file."
fi
 
message_length=`echo -n "$message"|wc -c`
sender_length=`echo -n "$sender"|wc -c`
 
if [ "$message_length" -gt "160" ]; then
  logfail "SMS message is longer than 160 chars ($message_length). That is not allowed." >&2
fi
 
if [ "$sender_length" -gt "11" ]; then
  logfail "Sender is longer than 11 chars ($sender_length). That is not allowed." >&2
fi
 
# We haven't sent the message yet
message_sent_ok=0;
 
# The API supports sending to a comma seperated list, but that doesn't seem
# to work well. Therefore, I space seperate them and just call the API for
# each number.
for number in $numbers; do 
  if [ ! "$dry_run" ]; then
    RESPONSE=`curl -s -d username="$username" -d md5_password="$password" -d originator="$sender" -d recipients="$number" -d message="$message" http://www.mollie.nl/xml/sms/`
  else
    RESPONSE="<success>true</success>"
  fi
 
  # Curl was able to post okay...
  if [ "$?" -eq "0" ]; then
    success_line_true=`echo "$RESPONSE"|grep -i "<success>true</success>"`
 
    if [ -z "$success_line_true" ]; then
      logfail "$message to $number. Response was: $RESPONSE"
    fi
  else
    logfail "curl return an error while trying to contact mollie to send an SMS." >&2
  fi
 
  if [ -w "$log_file" ]; then
    echo "Success: [`date`]: $dry_run Sent '$message' to $number" >> $log_file
  fi
done
 
echo "Success sending sms(es)."

It has the following config file in /etc/notify_sms.conf:

# Default values. Can be overriden with command line arguments
username="halfgaar"
password="" # MD5sum of HTTP API password.
sender="Melk"
numbers="+316xxxxxxxx" # You can set multiple numbers by space seperating them. 

Let’s say you have a file with a space: “bla bla.txt”. If I were to ls that file, I would do:

ls 'bla bla.txt'

This works. However, when I want to do this from a variable (in a script) and do:

command="ls 'bla bla.txt'"
$command

The result is:

ls: cannot access 'bla: No such file or directory
ls: cannot access bla.txt': No such file or directory

You can solve this by using eval:

command="ls 'bla bla.txt'"
eval $command

This gives:

bla bla.txt

Some time ago, I suggested this as answer on somebodies question at userfriendly, to which somebody else said that using eval actually makes things worse:

That’s actually worse. . . as the quoting gets re-parsed (remember, ‘eval’ means “take arguments as shell input”), which means that single quotes in the name break it, horribly, and names with spaces get even _worse_.

Another example: let’s say you have two files:

-rw-r----- 1 halfgaar halfgaar 0 2009-10-18 16:51 bla's bla"s.txt
-rw-r----- 1 halfgaar halfgaar 0 2009-10-18 16:52 normal.txt

I’m gonna run this command on it: find . -mindepth 1 -exec ls ‘{}’ \;. When executed without eval, it says this:

find: missing argument to `-exec' 

With eval, it says:

./normal.txt
./bla's bla"s.txt

Eval seems to be what I need, so what is wrong with using it? Also, shouldn’t that double quote be a problem? If someone can give a situation where that poses problems, I’m all ears.

cat upgrade-wordpress.sh 
#!/bin/bash
 
svn_repo_url=file:///var/svn/blog.omega-research.org/vendor/wordpress/
last_version=$1
new_version=$2
 
tmp_dir=`mktemp -d`
cd $tmp_dir
 
for version in $*; do
    echo "Downloading and extracting WordPress version $version..."
 
    if [ -z `svn ls $svn_repo_url|grep $version` ]; then
        branch=`echo $version |sed -e 's/\.[0-9]\+$//'`
        archive_file="wordpress-$version.tar.gz"
        md5_file="wordpress-$version.md5"
 
        wget "http://wordpress.org/$md5_file"
        wget "http://wordpress.org/$archive_file"
 
        if [ `md5sum $archive_file |cut -f 1 -d ' '` != `cat $md5_file` ]; then
            echo "MD5 sum did not match!" >&2
            exit 1
        fi
 
        tar --extract --ungzip --transform "s/^wordpress/$version/" --file $archive_file
        svn_load_dirs.pl $svn_repo_url -t $version current $version
    fi
done
 
cd -
svn merge "$svn_repo_url$last_version" "$svn_repo_url$new_version" .

I’m actually planning to make both scripts a little bit more generic (in the sense that svn_repo_url becomes an external param) and to track future changes to them using GitHub’s Gist. (How ironic is that, tracking an script for Subversion using Git?)