Category Archives: UNIX & Linux Code Snippets

Nagios Plugin - check_mem

check_mem is a simple Nagios plugin to check memory utilisation on Linux servers. I have written both a bash and a Ruby version of this script.

bash version:

#!/bin/bash
AWK="/usr/bin/awk"
BASENAME="/bin/basename"
ECHO="/bin/echo"
EGREP="/bin/egrep"
FREE="/usr/bin/free"
GREP="/bin/grep"
THISPROG=$( ${BASENAME} $0 )
VERBOSE=0
E_OK=0
E_WARNING=1
E_CRITICAL=2
E_UNKNOWN=3
function print_error {
   ${ECHO} "Error: $@" >&2
}
function printv {
   (( VERBOSE )) && {
      ${ECHO} "--> $@"
   }
}
function print_usage {
   {
      ${ECHO} "Usage: ${THISPROG} [-hv] -w <warning_mb> -c <critical_mb>"
      ${ECHO} "       -c   Critical memory (MB)"
      ${ECHO} "       -w   Warning memory (MB)"
      ${ECHO} "       -h   Display this usage message"
      ${ECHO} "       -v   Verbose mode"
   } >&2
}
function check_arguments {
  ERROR_COUNT=0
  if [ -z "${WARNING}" ]; then
    print_error "-w option mandatory"
    (( ERROR_COUNT = ERROR_COUNT + 1 ))
  else
    ${ECHO} "${WARNING}" | ${EGREP} -qs '^[0-9]+$'
    if [ "$?" -ne "0" ]; then
      print_error "-w must be an integer"
      (( ERROR_COUNT = ERROR_COUNT + 1 ))
    fi
  fi
  if [ -z "${CRITICAL}" ]; then
    print_error "-c option mandatory"
    (( ERROR_COUNT = ERROR_COUNT + 1 ))
  else
    ${ECHO} "${CRITICAL}" | ${EGREP} -qs '^[0-9]+$'
    if [ "$?" -ne "0" ]; then
      print_error "-c must be an integer"
      (( ERROR_COUNT = ERROR_COUNT + 1 ))
    fi
  fi
  if [ "${ERROR_COUNT}" -gt "0" ]; then
    exit ${E_UNKNOWN}
  else
    if [ "${WARNING}" -le "${CRITICAL}" ]; then
      print_error "-w must be > -c"
      exit ${E_UNKNOWN}
    fi
  fi
}
function check_memory {
  FREE_MEMORY=$( ${FREE} -m | ${GREP} 'buffers/cache' | ${AWK} '{print $4}' )
  if [ "${FREE_MEMORY}" -lt "${CRITICAL}" ]; then
    ${ECHO} "CRITICAL: Free memory ${FREE_MEMORY}MB"
    exit ${E_CRITICAL}
  elif [ "${FREE_MEMORY}" -lt "${WARNING}" ]; then
    ${ECHO} "WARNING: Free memory ${FREE_MEMORY}MB"
    exit ${E_WARNING}
  else
    ${ECHO} "OK: Free memory ${FREE_MEMORY}MB"
    exit ${E_OK}
  fi
}
#
# main()
#
while getopts ":c:hvw:" OPTION; do
  case ${OPTION} in
     "c")  CRITICAL="${OPTARG}"    ;;
     "h")  print_usage && exit 0   ;;
     "v")  VERBOSE=1               ;;
     "w")  WARNING="${OPTARG}"     ;;
     *  )  print_usage && exit 1   ;;
  esac
done
shift $(( ${OPTIND} - 1 ))
if [ "$#" -ne "0" ]; then
   print_usage && exit 1
fi
check_arguments
check_memory
exit 0

100

101

102

103

104

105

106

107

#!/bin/bash

AWK="/usr/bin/awk"

BASENAME="/bin/basename"

ECHO="/bin/echo"

EGREP="/bin/egrep"

FREE="/usr/bin/free"

GREP="/bin/grep"

THISPROG=$( ${BASENAME} $0 )

VERBOSE=0

E_OK=0

E_WARNING=1

E_CRITICAL=2

E_UNKNOWN=3

function print_error {

${ECHO} "Error: $@" >&2

}

function printv {

(( VERBOSE )) && {

${ECHO} "--> $@"

}

function print_usage {

{

${ECHO} "Usage: ${THISPROG} [-hv] -w <warning_mb> -c <critical_mb>"

${ECHO} " -c Critical memory (MB)"

${ECHO} " -w Warning memory (MB)"

${ECHO} " -h Display this usage message"

${ECHO} " -v Verbose mode"

} >&2

}

function check_arguments {

ERROR_COUNT=0

if [ -z "${WARNING}" ]; then

print_error "-w option mandatory"

(( ERROR_COUNT = ERROR_COUNT + 1 ))

else

${ECHO} "${WARNING}" | ${EGREP} -qs '^[0-9]+$'

if [ "$?" -ne "0" ]; then

print_error "-w must be an integer"

(( ERROR_COUNT = ERROR_COUNT + 1 ))

if [ -z "${CRITICAL}" ]; then

print_error "-c option mandatory"

(( ERROR_COUNT = ERROR_COUNT + 1 ))

else

${ECHO} "${CRITICAL}" | ${EGREP} -qs '^[0-9]+$'

if [ "$?" -ne "0" ]; then

print_error "-c must be an integer"

(( ERROR_COUNT = ERROR_COUNT + 1 ))

if [ "${ERROR_COUNT}" -gt "0" ]; then

exit ${E_UNKNOWN}

else

if [ "${WARNING}" -le "${CRITICAL}" ]; then

print_error "-w must be > -c"

exit ${E_UNKNOWN}

}

function check_memory {

FREE_MEMORY=$( ${FREE} -m | ${GREP} 'buffers/cache' | ${AWK} '{print $4}' )

if [ "${FREE_MEMORY}" -lt "${CRITICAL}" ]; then

${ECHO} "CRITICAL: Free memory ${FREE_MEMORY}MB"

exit ${E_CRITICAL}

elif [ "${FREE_MEMORY}" -lt "${WARNING}" ]; then

${ECHO} "WARNING: Free memory ${FREE_MEMORY}MB"

exit ${E_WARNING}

else

${ECHO} "OK: Free memory ${FREE_MEMORY}MB"

exit ${E_OK}

}

# main()

while getopts ":c:hvw:" OPTION; do

case ${OPTION} in

"c") CRITICAL="${OPTARG}" ;;

"h") print_usage && exit 0 ;;

"v") VERBOSE=1 ;;

"w") WARNING="${OPTARG}" ;;

* ) print_usage && exit 1 ;;

esac

done

shift $(( ${OPTIND} - 1 ))

if [ "$#" -ne "0" ]; then

print_usage && exit 1

check_arguments

check_memory

exit 0

Ruby version:

#!/usr/bin/ruby
require 'optparse'
this_script = "check_mem"
FREE="/usr/bin/free -m"
E_OK = 0
E_WARNING = 1
E_CRITICAL = 2
E_UNKNOWN = 3
options = {}
options[:verbose] = false
o = OptionParser.new do |opts|
  opts.banner = "Usage: #{this_script} -w <warn> -c <crit>"
  opts.on("-w", "--warning WARNING", "Warning threshold") { |warning| options[:warning] = warning }
  opts.on("-c", "--critical CRITICAL", "Critical threshold") { |critical| options[:critical] = critical }
  opts.on("-h", "Print help" ) { puts opts; exit(0) }
  opts.on("-v", "--verbose", "Be verbose") do
              options[:verbose] = true
            end
end
begin o.parse! ARGV
rescue OptionParser::InvalidOption => e
  puts e
  puts o
  exit(E_UNKNOWN)
end
def print_error(msg)
  $stderr.puts "#{msg}"
end
def check_arguments(options)
  error_count = 0
  if options[:warning] == nil
    print_error "-w option mandatory"
    error_count += 1
  end
  if options[:critical] == nil
    print_error "-c option mandatory"
    error_count += 1
  end
  if options[:warning].to_i == 0
    print_error "-w must be an integer > 0"
    error_count += 1
  end
  if options[:critical].to_i == 0
    print_error "-c must be an integer > 0"
    error_count += 1
  end
  if options[:warning].to_i <= options[:critical].to_i
    print_error "-w must be > -c"
    error_count += 1
  end
  if error_count > 0
    exit(E_UNKNOWN)
  end
end
def check_memory(options)
  memory_output = %x[ #{FREE} ]
  free_memory = memory_output.grep(/buffers\/cache/).to_s.split[3]
  if free_memory.to_i < options[:critical].to_i
    puts "CRITICAL: Free memory #{free_memory}MB"
    exit(E_CRITICAL)
  elsif free_memory.to_i < options[:warning].to_i
    puts "WARNING: Free memory #{free_memory}MB"
    exit(E_WARNING)
  else
    puts "OK: Free memory #{free_memory}MB"
    exit(E_OK)
  end
end
check_arguments(options)
check_memory(options)

#!/usr/bin/ruby

require 'optparse'

this_script = "check_mem"

FREE="/usr/bin/free -m"

E_OK = 0

E_WARNING = 1

E_CRITICAL = 2

E_UNKNOWN = 3

options = {}

options[:verbose] = false

o = OptionParser.new do |opts|

opts.banner = "Usage: #{this_script} -w <warn> -c <crit>"

opts.on("-w", "--warning WARNING", "Warning threshold") { |warning| options[:warning] = warning }

opts.on("-c", "--critical CRITICAL", "Critical threshold") { |critical| options[:critical] = critical }

opts.on("-h", "Print help" ) { puts opts; exit(0) }

opts.on("-v", "--verbose", "Be verbose") do

options[:verbose] = true

end

begin o.parse! ARGV

rescue OptionParser::InvalidOption => e

puts e

puts o

exit(E_UNKNOWN)

end

def print_error(msg)

$stderr.puts "#{msg}"

end

def check_arguments(options)

error_count = 0

if options[:warning] == nil

print_error "-w option mandatory"

error_count += 1

end

if options[:critical] == nil

print_error "-c option mandatory"

error_count += 1

end

if options[:warning].to_i == 0

print_error "-w must be an integer > 0"

error_count += 1

end

if options[:critical].to_i == 0

print_error "-c must be an integer > 0"

error_count += 1

end

if options[:warning].to_i <= options[:critical].to_i

print_error "-w must be > -c"

error_count += 1

end

if error_count > 0

exit(E_UNKNOWN)

end

def check_memory(options)

memory_output = %x[ #{FREE} ]

free_memory = memory_output.grep(/buffers\/cache/).to_s.split[3]

if free_memory.to_i < options[:critical].to_i

puts "CRITICAL: Free memory #{free_memory}MB"

exit(E_CRITICAL)

elsif free_memory.to_i < options[:warning].to_i

puts "WARNING: Free memory #{free_memory}MB"

exit(E_WARNING)

else

puts "OK: Free memory #{free_memory}MB"

exit(E_OK)

end

check_arguments(options)

check_memory(options)

How to Fix Perl Make Errors Under Solaris

When you build Perl modules under Solaris, they are optimised for Sun Studio, which of course, we all use :/ So if you build with gcc, the build will likely fail. To avoid this Perl make error, you can use the following magical one-liner to fix this brain damage, and your modules will build correctly.

# pwd
/usr/local/src/cpan/Some-PerlMod-0.123
# find . -name "Makefile" | while read MAKEFILE; do
> sed 's/^CC = cc$/CC = gcc/' ${MAKEFILE} > ${MAKEFILE}.tmp
> sed 's/^LD = cc$/LD = gcc/' ${MAKEFILE}.tmp > ${MAKEFILE}
> sed 's/^CCCDLFLAGS = -KPIC$/CCCDLFLAGS = -fPIC/' ${MAKEFILE} > ${MAKEFILE}.tmp
> sed 's/OPTIMIZE = -xO3 -xspace -xildoff$/OPTIMIZE =/' ${MAKEFILE}.tmp > ${MAKEFILE}
> sed 's/ -xarch=v8//' ${MAKEFILE} > ${MAKEFILE}.tmp && mv ${MAKEFILE}.tmp ${MAKEFILE}
> done

# pwd

/usr/local/src/cpan/Some-PerlMod-0.123

# find . -name "Makefile" | while read MAKEFILE; do

> sed 's/^CC = cc$/CC = gcc/' ${MAKEFILE} > ${MAKEFILE}.tmp

> sed 's/^LD = cc$/LD = gcc/' ${MAKEFILE}.tmp > ${MAKEFILE}

> sed 's/^CCCDLFLAGS = -KPIC$/CCCDLFLAGS = -fPIC/' ${MAKEFILE} > ${MAKEFILE}.tmp

> sed 's/OPTIMIZE = -xO3 -xspace -xildoff$/OPTIMIZE =/' ${MAKEFILE}.tmp > ${MAKEFILE}

> sed 's/ -xarch=v8//' ${MAKEFILE} > ${MAKEFILE}.tmp && mv ${MAKEFILE}.tmp ${MAKEFILE}

> done

GNU and UNIX Commands: Using a while Loop to Populate Configuration File

I recently had a need to generate a lot of Nagios host definitions. The hosts all had a similar naming convention:

foo-nnnnprjenv

Here, nnnn was a zero-padded number from 0 to 9999. In this particular environment, there were 41 hosts. A simple multiline echo command inside a while loop fed by seq produces the appropriate host stanzas we can add to our Nagios configuration. We also look up the servers IP addresses via the host command and insert those too:

$ seq -w 1 41 | while read num; do
   echo "define host {
        use             generic-host
        host_name       foo-00${num}prjenv
        alias           foo-00${num}prjenv
        address         $( host foo-00${num}prjenv | awk '{print $NF}' )
        register        1
}
"
done

$ seq -w 1 41 | while read num; do

echo "define host {

use generic-host

host_name foo-00${num}prjenv

alias foo-00${num}prjenv

address $( host foo-00${num}prjenv | awk '{print $NF}' )

}

done

The -w option to seq causes it to output a leading-zero padded number. Redirect the output of this loop to a file, and you’ll have your Nagios host configuration. This is another reasons why having a naming convention for a large number of servers is important - it will aid you in automation and administration down the track.

How to Check md5sum on Solaris 10

If you don’t have the md5sum utility installed, just use the digest tool supplied with Solaris 10

$ digest -a md5 -v /bin/ls
md5 (/bin/ls) = b57e173220af4b919f1d4bef9db11482

1 2	$ digest -a md5 -v /bin/ls md5 (/bin/ls) = b57e173220af4b919f1d4bef9db11482

How to Remove Bounces From the Mail Queue

When using Postfix, the following simple one liner will do the trick to remove bounces:

# mailq | grep MAILER-DAEMON | awk '{print $1}' | sed 's/\*//' | postsuper -d -

1	# mailq \| grep MAILER-DAEMON \| awk '{print $1}' \| sed 's/\*//' \| postsuper -d -

How to Selectively Remove Files

I wanted to remove a large number of files from a directory. However, I did not want to descend into subdirectories, nor did I want to remove any .pdf or .chm files. Some of the files had non-standard characters (such as quotes and spaces) in them.

The solution? A simple one liner using find and xargs:

$ find . \( ! -name "*.pdf" -a ! -name "*.chm" \) -maxdepth 1 -type f -print0 | xargs -0 rm

1	$ find . $ ! -name ".pdf" -a ! -name ".chm" $ -maxdepth 1 -type f -print0 \| xargs -0 rm

How to Update a File on All Zones at the Same Time

I recently modified /etc/resolv.conf on all of my global zones after building new nameservers. I wanted a quick way to copy this updated configuration to all child zones. A simple one-liner does the trick on each global zone (assuming all your zones are in the /var/zones zonepath):

# zoneadm list | grep -v global | while read zone; do cp -p /etc/resolv.conf /var/zones/${zone}/root/etc; done

1	# zoneadm list \| grep -v global \| while read zone; do cp -p /etc/resolv.conf /var/zones/${zone}/root/etc; done

How to Use wget for Recursive get Without Traversing the Parent Directory

When grabbing files with wget, it is useful to sometimes not traverse parent directories. For example, say I want to download everything under http://www.example.com/my/home recursively, but not traverse upwards into parent directories. You can add the –no-parent option for this.

$ wget -r --no-parent http://www.example.com/my/home

1	$ wget -r --no-parent http://www.example.com/my/home

How to Generate a Hashed Password

Another OpenSSL related tip.

If you’ve ever wanted to generate a hashed password suitable for inclusion in the /etc/shadow file (for example, during post-install procedures such as sysidcfg), you can use the openssl passwd command:

$ openssl passwd
Password:
Verifying - Password:
HaShEdPaSsCoMeSoUt

$ openssl passwd

Password:

Verifying - Password:

HaShEdPaSsCoMeSoUt

Security: Replacing a Digital Certificate within a Java Keystore

Some notes I prepared whilst renewing a certificate stored in a Java keystore:

# make backup
cp -p /path/to/keystore.jks /path/to/keystore.jks.`date +%Y%m%d`
# check current keystore contents
keytool -list -v -keystore /path/to/keystore.jks -storepass <pass>
# create a CSR from the cert in the keystore
keytool -certreq -v -file myrequest.csr -keystore /path/to/keystore.jks -alias <alias> -storepass <pass>
# check contents of csr
openssl req -noout -text -in myrequest.csr
# send it and get it signed....
# once received....
# verify the certificate you're about to import
openssl x509 -noout -text -in /path/to/newcert.pem
# ok, import it
keytool -import -file /path/to/newcert.pem -alias <alias> \
  -trustcacerts -keystore /path/to/keystore.jks -storepass <pass>
# check it was all good
keytool -list -v -keystore /path/to/keystore.jks -storepass <pass>
# may need to restart any Java apps using that keystore

# make backup

cp -p /path/to/keystore.jks /path/to/keystore.jks.`date +%Y%m%d`

# check current keystore contents

keytool -list -v -keystore /path/to/keystore.jks -storepass <pass>

# create a CSR from the cert in the keystore

keytool -certreq -v -file myrequest.csr -keystore /path/to/keystore.jks -alias <alias> -storepass <pass>

# check contents of csr

openssl req -noout -text -in myrequest.csr

# send it and get it signed....

# once received....

# verify the certificate you're about to import

openssl x509 -noout -text -in /path/to/newcert.pem

# ok, import it

keytool -import -file /path/to/newcert.pem -alias <alias> \

-trustcacerts -keystore /path/to/keystore.jks -storepass <pass>

# check it was all good

keytool -list -v -keystore /path/to/keystore.jks -storepass <pass>

# may need to restart any Java apps using that keystore

Toki Winter

Advanced UNIX for the experienced system administrator

Category Archives: UNIX & Linux Code Snippets

Nagios Plugin - check_mem

How to Fix Perl Make Errors Under Solaris

GNU and UNIX Commands: Using a while Loop to Populate Configuration File

How to Check md5sum on Solaris 10

How to Remove Bounces From the Mail Queue

How to Selectively Remove Files

How to Update a File on All Zones at the Same Time

How to Use wget for Recursive get Without Traversing the Parent Directory

How to Generate a Hashed Password

Security: Replacing a Digital Certificate within a Java Keystore