#!/bin/bash

# generate filename without directory:
FILENAME=$(basename $0)
CAT=$(which cat)

print_help()
{
##########################################################################
$CAT <<EOF

  $FILENAME - little GnuPG helper

  author:      Karl Voit, shellscript@Karl-Voit.at

  date:        2003-04-28

  version:     v0.2

  copyright:   GPL

  usage:       $FILENAME (sign|accept|import) <emailaddress> <key-id>

  description: This script helps to manage the process of handling 
               the network of GnuPG-signatures.

               The switches mean:

               sign: a key is fetched, signed and sent so the owner.

               accept: after verification of the emailaddress, the
                       key is re-imported to the local keyring.

               import: someone sent me my signed key, import/add it to
                       my local keyring.

               Please email me suggestions for improvements and errors!
               I am still learning how to write good shell-scripts and
               use my GnuPG *g*

EOF
##########################################################################
}

## 2do:
##      * 
##      * 



########################################################
########################################################
########################################################
##                                                    ##
##                  PERSONALISATION                   ##
##                                                    ##
########################################################
########################################################
########################################################


# filenames to use for ...




# change to "done", if you changed all options above to _your_ needs!

CONFIGURED_="notdone"


########################################################




# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #

# --- normally you DON'T have to change anything below this line! --- #

# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #
# !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! #




########################################################
########################################################
########################################################
##                                                    ##
##               hardcoded configuration              ##
##                                                    ##
########################################################
########################################################
########################################################


## generates a timestamp like "2002_Jan_31_-_09h43m03s"
TIMESTAMP1=`/bin/date +%Y_%b_%d_-_%Hh%Mm%Ss`

## generates a syslog-like timestamp like "Mar 16 09:19:50"
## lisa qmail:
TIMESTAMP2=`/bin/date +"%b %d %H:%M:%S"`

# change to "on" if you want to read the debug-messages (can be much) to trace
# down problems:
export DEBUG="off"

# if "on" then various steps that are require for beginners are skipped.
# if "off" then everything is asked.
export ADVANCED="off"

# same as ADVANCED but with less questions and a fixed way of navigation:
# fetches key, gosub --edit-key, mail via mutt, DON'T delete from local 
# keyring but deletes temporary key-file from current directory:
export VERYLAZY="off"

########################################################
########################################################
########################################################
##                                                    ##
##                   F U N C T I O N S                ##
##                                                    ##
########################################################
########################################################
########################################################

## ---------------------------------------------------------

myexit()
{
    doreport debug "function myexit($1) called"

    [ "$1" -lt 1 ] && echo "$FILENAME done."
    [ "$1" -gt 0 ] && echo "$FILENAME aborted with errorcode $1."

#optionally    [ "$1" -gt 0 ] && do_sound_error

    exit $1
}


## ---------------------------------------------------------


## check, if some files needed are not found
testiffound()
{
    doreport debug "function testiffound($1) called"

  if [ -z "$2" ]; then
    doreport debug "The tool \"$1\" is missing because \"$2\" is empty."
    doreport notify "The tool \"$1\" could not be located (missing?)"
    export SOMETHINGMISSING="yes"
  fi
}



## ---------------------------------------------------------

report()
{
## reports the parameter to the stdout

  echo
  echo "==============================================================="
  echo "                                                 $FILENAME"
  echo "$1"
  echo
  echo "==============================================================="
  echo

}



## ---------------------------------------------------------

debugthis()
{
## debugs the script
        #echo $FILENAME: DEBUG: $1
        echo "do nothing" >/dev/null
}



## ---------------------------------------------------------

logthis()
{
## logs some text with a timestamp added
## usage: logthis "mytext"

    ## generates a timestamp like "2002_Jan_31_-_09h43m03s"
    TIMESTAMPLONG=`/bin/date +%Y_%b_%d_-_%Hh%Mm%Ss`

    ## generates a syslog-like timestamp like "Mar 16 09:19:50"
    TIMESTAMPSHORT=`/bin/date +"%b %d %H:%M:%S"`

    ## add computername and scriptname like "lisa qmail: "
    LOGTIMESTAMP=$TIMESTAMPSHORT" lisa $FILENAME:"


    # probably won't annoy logfiles with this crap?
    #        echo $LOGTIMESTAMP "$1" >> $mylogfile
    #        echo $LOGTIMESTAMP "$1" 
        echo "do nothing" >/dev/null
}



## ---------------------------------------------------------

mailthis()
{
        # usage: $1=To $2=Subject $3=Body

        echo -e "$3" | mail -s "$2" $1
}



## ---------------------------------------------------------


doreport_internal_writestring()
{
## !! for use withing function "doreport" only !!
## prints out all strings on stdout

## 2do: error-msg written with { echo 1>&2 "text" } (stderr)

        echo
        echo "===$1============================================"
        echo "                                                 $FILENAME"


## FIXXME:
## 2DO: loop instead of this quick-hack!!!

        if [ ! -z "$2" ]; then
	    echo "$2"
        fi
        if [ ! -z "$3" ]; then
	    echo "$3"
        fi
        if [ ! -z "$4" ]; then
	    echo "$4"
        fi
        if [ ! -z "$5" ]; then
	    echo "$5"
        fi
        if [ ! -z "$6" ]; then
	    echo "$6"
        fi
        if [ ! -z "$7" ]; then
	    echo "$7"
        fi
        if [ ! -z "$8" ]; then
	    echo "$8"
        fi

        echo
        echo "===============================================================";
        echo

}



## ---------------------------------------------------------


doreport()
{
## reports the parameter to the stdout

## usage: (shortnote|notify|error|debug) string1 [string2] [string3] [...] [string7]

## NEEDS: doreport_internal_writestring


    case "$1" in

    "shortnote") 
	echo "$FILENAME: $2 $3 $4 $5 $6 $7";;

    "notify") 
	doreport_internal_writestring " notification ==" "$2" "$3" "$4" "$5" "$6" "$7";;

    "error") 
        doreport_internal_writestring " ERROR =========" "$2" "$3" "$4" "$5" "$6" "$7";;

    "debug") 
        ## debugs the script
        if [[ "$DEBUG" = "on" ]]; then echo "$TIMESTAMP $FILENAME: DEBUG: $2 $3 $4 $5 $6 $7"; fi;
        echo "do nothing" >/dev/null;;

    "log") 
        ## logs some text with a timestamp added
        ## usage: $2 == "mytext"
      
        ## generates a timestamp like "2002_Jan_31_-_09h43m03s"
        TEMP_TIMESTAMPLONG=`/bin/date +%Y_%b_%d_-_%Hh%Mm%Ss`;
        ## generates a syslog-like timestamp like "Mar 16 09:19:50"
        TEMP_TIMESTAMPSHORT=`/bin/date +"%b %d %H:%M:%S"`;
        ## add computername and scriptname like "lisa qmail: "
        TEMP_LOGTIMESTAMP=$TEMP_TIMESTAMPSHORT" lisa $FILENAME:";

        # probably won't annoy logfiles with this crap?
        #        echo $LOGTIMESTAMP "$2" >> $mylogfile;
        #        echo $LOGTIMESTAMP "$2" ;;
        echo "do nothing" >/dev/null;;

    "mail") 
        # usage: $2=To $3=Subject $4=Body
        echo -e "$4" | mail -s "$3" $2;;

    *)
        doreport_internal_writestring " INTERNAL ERROR " "An error occured, while calling function \"doreport\":" "The parameter that was given ($1) has no target/handle." "Aborting.";
        myexit 1;;

    esac
}




## ---------------------------------------------------------

ask()
{
## asks something (parameter 1) the user

  echo
  echo "=== question =================================================="
  echo "                                                 $FILENAME"
  echo "$1"
  echo
  echo "==============================================================="
  echo

## example: ##  ask "Do you want this?"
## example: ##  read ANSWER
## example: ##  echo  
## example: ##  case "$ANSWER" in
## example: ##  
## example: ##  y)
## example: ##    CDCPY_docover ;;
## example: ##  *)
## example: ##    echo "  OK, maybe you're right." ;
## example: ##    echo "  We don't need these fancy stuff anyway ..." ;
## example: ##    echo ;;
## example: ##
## example: ##  esac

}


## ---------------------------------------------------------

## checks, if the directory given exists and tries to create it, if necessary
## returns: 0 = "exists"/"created" or 1 = "error"
makesure_directory_exists()
{
    doreport debug "function makesure_directory_exists($1) called"

    if [ ! -d "$1" ]; then

      doreport debug "Directory \"$1\" not found! So I try to make it now..."
      mkdir "$1"

      if [ $? -eq 0 ]        # Test exit status
       then
           doreport debug "Directory $1 successfully created!"
	   return 0
       else 
           doreport error "Could NOT create directory $1!" "Most likely: no write-permission OR non existing parent-directory."
	   return 1
       fi

    else
	doreport debug "Directory already found"
	return 0
    fi

## EXAMPLE:
##        makesure_directory_exists "$(dirname $FILENAME)"
##	## check, if given dir is really a directory:
##	if [ -d "$DIRNAME" ]; then
##	  doreport debug "Directory $DIRNAME is checked as a valid directory"
##        else  
##          print_help
##          doreport "error" "Directory $DIRNAME is not an existing directory! (see error-output above for possible reason!)" "aborting."
##          exit 1
##	fi


## unsure, because returns also exits current region!
## if [[ $(makesure_directory_exists "$(dirname $A_file)") ]]; then
##     doreport error "The directory for the tempfile could not be found or generated!"
##     myexit 1
## else
##     doreport debug "Directory exists."
## fi


}


## ---------------------------------------------------------

## checks if file exists; if it does not exist, it will be created
makeSureTheFileExists()
{
    doreport debug "function makeSureTheFileExists($1) called"

    ## wether "touch" exists, is to be checked in preconditions!
    [ -e "$1" ] || `which touch` "$1"
}


## ---------------------------------------------------------

handle_sign()
{

if [ "x$ADVANCED" = "xoff" ]; then

###################################################################
### Step 1
###################################################################
doreport "notify" "Step 1/14:" "Check the authentity of the key-fingerprint"
$CAT <<EOT
Please check now, if the key you want to sign is related to
the person.
This can be done in several ways:
*) check the fingerprint of the key with the fingerprint which
   the person has published
*) download the whole key from the homepage of the other person
*) ...

Either way, you have to check the person too: let's have a look
at the person's ID-card.

(press ENTER when finished with each point)
EOT

read
fi

if [ "x$ADVANCED" = "xoff" ]; then
###################################################################
### Step 2
###################################################################
doreport "notify" "Step 2/14:" "Make sure, you *really* checked the identity."
$CAT <<EOT
The quality of the "web of trust" is inherently related to the
fact, that noone signs other keys without having checked the
person or the connection between the emailaddress and the person.

You would not sign any official document blindly and GnuPG-signed
EMails can be seen as "official documents" from you.

So please do NOT blindly sign other keys without a REAL check!
Thank you!

EOT
read
fi

###################################################################
### Step 3
###################################################################
doreport "notify" "Step 3/14:" "Getting the public key"
$CAT <<EOT
There are several ways to get the public key of someone into
your local keyring:

1) get it from a keyserver
EOT
echo "   executing \"gpg --recv-keys $KEYID\""
$CAT <<EOT

2) import the public key which is already on your harddisk
EOT

echo "   executing \"gpg --import $KEYID.gpg.asc\" (from current directory)"
$CAT <<EOT

3) execute nothing, I'll probably skip it or do it by hand

EOT
ask "What do you want?"

if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=1
fi

echo  
case "$ANSWER" in

1)
   $GPG --recv-keys $KEYID;
   doreport "notify" "finished external execution";;
2)
   $GPG --import $KEYID.gpg.asc;
   doreport "notify" "finished external execution";;
*)
  echo "  (you skipped that step)" ;
  echo ;;

esac

if [ "x$ADVANCED" = "xoff" ]; then
###################################################################
### Step 4
###################################################################
doreport "notify" "Step 4/14:" "What EMailaddress do I have to use?"
$CAT <<EOT
Be sure, that you use only the confirmed emailaddress of 
the other person even when there are several UIDs (user IDs)
with different emailaddresses in the public key.

Note that anybody can send you EMails from let's say
              Bill.Gates@microsoft.com
No problem for someone, who want's to do something like this.

EOT
read DUMMY
fi

###################################################################
### Step 5-9
###################################################################
doreport "notify" "Step 5-9/14:" "Now, for the GnuPG-part..."
$CAT <<EOT
You will have to use GnuPG (gpg) to sign the public key.

1) start it now
EOT
echo "    executing \"gpg --edit-key $KEYID\""
$CAT <<EOT

2) execute nothing, I'll probably skip it or do it by hand

EOT
ask "What do you want?"
if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=1
fi

doreport "notify" "What is to be done in GnuPG?"
$CAT <<EOT
Step 5/14: Command> fpr
EOT
if [ "x$ADVANCED" = "xoff" ]; then
$CAT <<EOT
   Just to make sure, you have to check the fingerprint of
   the key you're about to sign.

EOT
fi
$CAT <<EOT
Step 6/14: Command> uid <uid-number>
EOT
if [ "x$ADVANCED" = "xoff" ]; then
echo "   Select the UID of $EMAILADDRESS"
fi
$CAT <<EOT
Step 7/14: Command> sign
EOT
if [ "x$ADVANCED" = "xoff" ]; then
$CAT <<EOT
   Sign the public key of the other person with the correct
   identity of yours.

EOT
fi
$CAT <<EOT
Step 8/14: Command> trust
EOT
if [ "x$ADVANCED" = "xoff" ]; then
$CAT <<EOT
   Define your local/private trust in the other key.

EOT
fi
$CAT <<EOT
Step 9/14: Command> save
EOT
if [ "x$ADVANCED" = "xoff" ]; then
$CAT <<EOT
   Save your modifications to your local keyring.
   (This also quits gpg)

EOT
fi

echo  
case "$ANSWER" in

1)
   $GPG --edit-key $KEYID;
   doreport "notify" "finished external execution";;
*)
  echo "  For the case, you want to do it manually, I pause here..." ;
  read DUMMY;
  echo ;;

esac

if [ "x$ADVANCED" = "xoff" ]; then
###################################################################
### Step 9b
###################################################################
doreport "notify" "And now export to the keyserver?"
$CAT <<EOT
NO!
You did not check, if the user id (UID) matches to the
emailaddress, the person pretended to own.

EOT
read DUMMY
fi

###################################################################
### Step 10
###################################################################
doreport "notify" "Step 10/14:" "Export the key into an ascii-file"
$CAT <<EOT
Step 10/14
Now, you export the signed public key into a human readable
textfile on your local harddisk.

EOT
echo "1) executing \"gpg --armor --export $KEYID > \"$KEYID.gpg.asc\"\""
$CAT <<EOT

2) execute nothing, I'll probably skip it or do it by hand.

EOT
ask "What do you want?"

if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=1
fi

echo  
case "$ANSWER" in

1)
   $GPG  --armor --export $KEYID > "$KEYID.gpg.asc";
   doreport "notify" "finished external execution";;
*)
  echo "  (you skipped that step)" ;
  echo ;;

esac

###################################################################
### Step 11
###################################################################
doreport "notify" "Step 11/14:" "Send the signed key to the owner of $EMAILADDRESS"
$CAT <<EOT
At this point, you can send the signed key to the owner of the
emailaddress.

NOTE: You have to send this email signed and encrypted!

EOT
echo "1) executing \"mutt -s \"Your signed key (mail generated by lgh)\" -a \"$KEYID.gpg.asc\" $EMAILADDRESS\""
$CAT <<EOT

2) execute nothing, I'll probably skip it or do it by hand.

EOT
ask "What do you want?"

if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=1
fi

echo  
case "$ANSWER" in

1)
   $MUTT -s "Your signed key (mail generated by lgh)" -a "$KEYID.gpg.asc" $EMAILADDRESS;
   doreport "notify" "finished external execution";;
*)
  echo "  (you skipped that step)" ;
  echo ;;

esac


###################################################################
### Step 12
###################################################################
doreport "notify" "Step 12/14:" "Delete the key from local keyring"
$CAT <<EOT
Until now, you don't have the guarantee, that the key belongs
to the guy, who owns the emailaddress. Therefore, you'll delete
this key from the local keyring, until you get your signed and
encrypted key from that emailaddress.

NOTE: This step may be skipped, if you already got this email.

EOT
echo "1) executing \"gpg --delete-key $EMAILADDRESS\""
$CAT <<EOT

2) execute nothing, I'll probably skip it or do it by hand.

EOT
ask "What do you want?"

if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=2
fi

echo  
case "$ANSWER" in

1)
   $GPG --delete-key $EMAILADDRESS;
   doreport "notify" "finished external execution";;
*)
  echo "  (you skipped that step)" ;
  echo ;;

esac




###################################################################
### Step 13
###################################################################
doreport "notify" "Step 13/14:" "Finished. What's next?"
$CAT <<EOT
You're done so far.

EOT
echo "When a returnmail arrives _exactly from $EMAILADDRESS_, you can"
echo "re-import the stored key from \"$KEYID.gpg.asc\" into your local"
$CAT <<EOT
keyring by executing command below.

Since then, you cannot be irritated by a "false" verification of a bad
person which claimed, that this emailaddress belongs to that bad person.

EOT
echo "1) executing \"gpg --import \"$KEYID.gpg.asc\"\""
$CAT <<EOT

2) execute nothing, I'll probably skip it or do it by hand.

EOT
ask "What do you want?"

if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=2
fi

echo  
case "$ANSWER" in

1)
   $GPG --import "$KEYID.gpg.asc";
   doreport "notify" "finished external execution";;
*)
  echo "  (you skipped that step)" ;
  echo ;;

esac


###################################################################
### Step 14
###################################################################
doreport "notify" "Step 14/14:" "Delete saved key?"

echo "1) executing \"rm \"$KEYID.gpg.asc\"\""
$CAT <<EOT

2) execute nothing, I'll probably skip it or do it by hand.

EOT
ask "What do you want?"

if [ "x$VERYLAZY" = "xoff" ]; then
  read ANSWER
else
  ANSWER=1
fi

echo  
case "$ANSWER" in

1)
   $RM "$KEYID.gpg.asc";
   doreport "notify" "finished external execution";;
*)
  echo "  (you skipped that step)" ;
  echo ;;

esac

}


## ---------------------------------------------------------

handle_accept()
{
doreport "notify" "Sorry!" "This functionality is not yet implemented."

}


## ---------------------------------------------------------

handle_import()
{
doreport "notify" "Sorry!" "This functionality is not yet implemented."


}



## ---------------------------------------------------------

precondition_asserts()
{
## * test for things that are needed
## * check, if caller = root-user
## * check, if everything was configured by the user
## * check, if a parameter is given:

      export SOMETHINGMISSING="no"


      CAT=$(which cat)
      testiffound cat $CAT
      
      GPG=$(which gpg)
      testiffound gpg $GPG
      
      MUTT=$(which mutt)
      testiffound mutt $MUTT
      
      RM=`which rm`
      testiffound rm $RM
      
#      AWK=`which awk`
#      testiffound awk $AWK
#      
#      SED=`which sed`
#      testiffound sed $SED
#      
#      FIND=`which find`
#      testiffound find $FIND
#      
#      DATE=`which date`
#      testiffound date $DATE
#      
#      CHOWN=`which chown`
#      testiffound chown $CHOWN


    ## check, if any tool was NOT found
    doreport debug "CHECK: any tool missing?"
    if [ "$SOMETHINGMISSING" = "yes" ]; then
      print_help
      doreport error "One or more tool(s), that are needed are missing! (See output above!)" "Please make sure, that you those tools are installed properly and try again." "aborting."
      myexit 2
    fi



      ## check, if everything was configured by the user
      if [ ! "$CONFIGURED_" = "done" ]; then
        print_help
	doreport "error" "Please make sure, that you checked/modified all options" "to meet your requirements!" "(see section "PERSONALISATION" in file $0)"
        myexit 3
      fi
      

      ## can be: (sign|accept|import)      
      ## check, if a parameter is given:
      if [ -z "$1" ]; then
        print_help
        doreport "error" "no parameter 1 for SWITCH found!" "aborting."
        exit 1
      else
        doreport debug "parameter 1 (SWITCH) was found."
        case "$1" in
            "help"|"--help"|"?"|"/?")
        	doreport debug "Parameter for help|--help|?|/? is OK";;
	    "s"|"sign"|"SIGN"|"Sign")
        	doreport debug "Parameter for s|sign|SIGN|Sign is OK";;
	    "a"|"accept"|"ACCEPT"|"Accept")
        	doreport debug "Parameter for a|accept|accept|Accept is OK";;
	    "i"|"import"|"IMPORT"|"Import")
        	doreport debug "Parameter for i|import|IMPORT|Import is OK";;
	    *)
		print_help;
	        doreport "error" "parameter 1 for SWITCH found but not valid!" "aborting.";
		exit 1;;
        esac
        SWITCH="$1"
      fi

      
      ## check, if a parameter is given:
      if [ -z "$2" ]; then
        print_help
        doreport "error" "no parameter 2 for EMAILADDRESS found!" "aborting."
        exit 1
      else
        doreport debug "parameter 2 (EMAILADDRESS) was found."
        EMAILADDRESS="$2"
      fi


      ## check, if a parameter is given:
      if [ -z "$3" ]; then
        print_help
        doreport "error" "no parameter 3 for KEYID found!" "aborting."
        exit 1
      else
        doreport debug "parameter 3 (KEYID) was found."
        KEYID="$3"
      fi


      ## check, if a parameter is given:
      if [ ! -z "$3" ]; then
        doreport debug "parameter 3 was found but is not nessecary."
      fi


##      ## check, if a parameter is given:
##      if [ -z "$2" ]; then
##        print_help
##        doreport "error" "no parameter 2 for ??? found!" "aborting."
##        exit 1
##      else
##        doreport debug "parameter 2 was found."
##        SOME_PARAMETER="$2"
##      fi


##	## check, if parameter 1 is a directory:
##	if [ -d "$1" ]; then
##	  doreport debug "Parameter 1 is checked as a directory."
##        else  
##          print_help
##          doreport "error" "parameter 1 is not an existing directory!" "aborting."
##          exit 1
##	fi

      

    doreport debug "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< all checks OK!"
    export PRECONDITIONS_CHECKED="yes"


}



## ---------------------------------------------------------

postcondition_asserts()
{

## * deletes temporary files
## * ...

##  if [ -z "???filename" ]; then
##    ???
##  fi

echo "donothing" >/dev/null

}



########################################################
########################################################
########################################################
##                                                    ##
##                S C R I P T                         ##
##                                                    ##
########################################################
########################################################
########################################################


## test for important stuff:
precondition_asserts "$1" "$2" "$3" "$4" "$4" "$5" "$6" "$7" "$8" "$9"



doreport "debug" SWITCH=$SWITCH
doreport "debug" EMAILADDRESS=$EMAILADDRESS
doreport "debug" KEYID=$KEYID


## parse parameter SWITCH
case "$SWITCH" in

    "help"|"--help"|"?"|"/?")
	doreport debug "Parameter help|--help|?|/? detected"
	print_help;
	myexit 0;;

    "s"|"sign"|"SIGN"|"Sign")
   	handle_sign;;

    "a"|"accept"|"ACCEPT"|"Accept")
   	handle_accept;;

    "i"|"import"|"IMPORT"|"Import")
   	handle_import;;

esac

doreport "debug" "returned from handle-subprocedures"
doreport "shortnote" "Thank you for using $FILENAME! Have a nice day."


########################################################


## test for important stuff:
postcondition_asserts

myexit 0


########################################################
##                      E N D                         ##
########################################################