Shell Programming and Scripting

# test="a 'b c'"
# xargs -n 1 << EOF | while read var; do echo $var ; done
$test
EOF
a
b c

tmail - lean send-only mailer for scripts and minimal embedded systems
tmail [OPTION] [COMMANDs]
    also accepts COMMANDs form STDIN if first line is "%%%%%".
    Use "%%%%%" to signify the end of OPTION section (remainder is mail body).
    Normally the end of the mail body is EOF but "%%%%%" can be used as well.
    This is useful when calling tmail from the terminal.
    Execution order is [OPTIONs] [COMMANDs] [COMMANDs from STDIN].
Any COMMAND without the ":" character "naked email" is assumed to be a email recipient.
    See -b below.
Options without arguments:
-?      Help            Show usage and exit
-b      Blind Mode      Assume naked e-mails are BCC: instead of To:
-l      Loud            show the telnet session.
-x      Debug Mode      echo what would have gone to telnet to stdout
                        (also sets delay=0)
 
Options with arguments:
-d  'date/time'         Date/Time override
                          Replaces calculated Date/Time with string.
                          (same as command date:'date/time')
-h  'host'              Host override
                          Replaces how the computer introduces itself to the SMTP server.
                          (same as command host:'host')
-m  'boundary'          MIME Boundary override
                          Replaces default MIME boundary
                          (same as command boundary:'boundary')
-v  server:port:delay   Server Override
                          Replaces the default SMTP Sever and Port number.
                          Delay is the delay after issuing commands to SMTP server.
                          See 'man sleep' for units.
                          Any field left blank does not override default.
                          ':18:' or '::2" changes only the Port or Delay, respectively.
                          (same as command server:)
 -a path:type:name      Attach File
                          Add an attachment to the email.  If not included name will be
                          the short name of the path and type will be guessed from the
                          file extension, if any.
                          (same as command attach: or a:)
 -f filepath            Use file for body of message instead of stdin.
 -h 'header'            Replaces "%%%%%" header with another string.
 -s 'subject'           Sets the message subject.
 
Commands:
from:email@domain           Set Sender (also f:)
to:email@domain             Add a "To:" recipient (also t:)
cc:email@domain             Add a "CC:" recipient (also c:)
bcc:email@domain            Add a recipient (also b:)
subject:'subject'           Sets the message subject (see -s above) (also s:)
attach:path:type:name       Add an attachment (see -a above) (also a:)
server:server:port:delay    Set Server, Port, and Delay (see -v above)
port:port                   Set Port (does not change server or dealy)
delay:delay                 Set Delay (does not change server or port)
host:host                   Set Host (see -h)
boundary:'boundary'         Set MIME boundary (see -m)
other                       Naked Email.  Any command without a ":" is assumed to be a "naked email".
                              Treated as a "To:" recipient unless blind mode (-b) is set.

#! /bin/bash
##################################################################################
#  tmail: Send an Email with Telnet                                              #
##################################################################################
#
##################################################################################
#  Declarations                                                                  #
##################################################################################
header="%%%%%"
boundary="XOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXO"
warning="This is a multipart message in MIME format."
mailDate="$(date +%a", "%d" "%b" "%Y" "%T" "%z)"
host="$HOSTNAME"
sender="$USER""@""$HOSTNAME"
##################################################################################
#Standard User Editable Defaults
#move this to a .conf file later
subject="no subject"
server="smtp.abcde.com"; port="25"; delay="1"
##################################################################################
declare -A recipients   # We are going to use associative array keys (and not values)
declare -A toList       # to keep track of mailing lists ${!array[@]} as a builtin
declare -A ccList       # way of preventing duplicates without sorting.
# add getopts options to handle "-x" type arguments.
# grab remaining arguments
#commands+=" ""$@"" "
# read in commands from stdin between "$header" lines, if any
read -r line
if [[ "$line" == "$header" ]]; then
    firstLine=""
    while read line && [[ "$line" != "$header" ]]; do commands+=$"$line"$'\n'; done
else
    firstLine="$line"
fi
# Process commands from whatever source
# echo "$commands" #debug
oIFS="$IFS"; IFS=$'\n'; for var in $commands; do # For does not seem to like temporary assignment
    if [[ "$var" == *:* ]]; then
        IFS=":" read -r comm val1 val2 val3 < <(echo "$var")
        case "${comm,,}" in
            "subject"|"s") subject="$val1" ;;
            "from"|"f") sender="$val1" ;;
            "to"|"t") recipients["$val1"]=1; toList["$val1"]=1 ;;
            "cc"|"c") recipients["$val1"]=1; ccList["$val1"]=1 ;;
            "bcc"|"b") recipients["$val1"]=1 ;;
            "attach"|"a") # add this
                ;;
            "server")
                [[ "$val1" ]] && server="$val1"
                [[ "$val2" ]] && port="$val2"
                [[ "$val3" ]] && delay="$val3"
                ;;
            "port") port="$val1" ;;
            "delay") delay="$val1" ;;
            "host") host="$val1" ;;
            "boundary") boundary="$val1" ;;
            "warning") warning="$val1" ;;
            "date") mailDate="$val1" ;;
            *) echo "bad command"; echo "var: ""$var"; echo "1: ""$val1"; echo "2: ""$val2"; echo "3: ""$val3";echo "4: ""$val4"; exit 1 ;;  #add usage and exist here.
        esac
    else recipients["$var"]=1; [[ ! "$blind" ]] && toList["$var"]=1
    fi
done; IFS="$oIFS"
# Telnet Session
{   echo "HELO ""$host"
    sleep "$delay"
    echo "MAIL FROM: ""$sender"
    sleep "$delay"
    oIFS="$IFS"; IFS=$'\n'; for i in "${!recipients[@]}"; do
        echo "RCPT TO: ""$i"
        sleep "$delay"
    done; IFS="$oIFS"
    echo "DATA"
    sleep "$delay"
    echo "From: ""$sender"
    toString="To: "
    oIFS="$IFS"; IFS=$'\n'; for i in "${!toList[@]}"; do
        toString+="$i"", "; done; IFS="$oIFS"
    echo "${toString%", "}"
    ccString="CC: "
    oIFS="$IFS"; IFS=$'\n'; for i in "${!ccList[@]}"; do ccString+="$i"", "; done; IFS="$oIFS"
    echo "${ccString%", "}"
    echo "Date: ""$mailDate"
    echo "Subject: ""$subject"
    echo "Content-Type: multipart/mixed; boundary=\"""$boundary""\""
    echo "MIME-Version: 1.0"
    echo    
    echo "$warning"
    echo
    echo "--"""$boundary""
    echo "Content-Type: text/plain"
    echo
    if [[ "$firstLine" ]]; then echo "$firstLine"; fi
        while read line && [[ "$line" != "$header" ]]; do echo "$line"; done
    echo
    #add a loop for multiple attachments
    if [[ "$attachment" ]]; then # add an attachment if not blank
        echo "--"""$boundary""
        echo "Content-Type: ""$attachmentType""; name=\""$attachmentName"\""
        echo "Content-Transfer-Encoding: base64";
        echo "Content-Disposition: attachment; filename=\""$attachmentName"\""
        echo
        base64 <"$attachment" | head
        echo
    fi
    echo "--"""$boundary"""--"
    echo "."
    sleep "$delay"
    echo "QUIT"; } | telnet "$server" "$port"
    exit 0

%%%%%
subject:This is the mail subject
from:mike
to:bob
cc:frank
bcc:diane
%%%%%
Hello guys.
Here is an email
 
Mike

function f_Parse
{
typeset fIn="$1"                                 # input file
typeset lInStr=0                                 # flag: inside (quoted) string
typeset chProfStr=""
typeset chAct=""                                 # current char
typeset chRest=""
typeset chBuffer=""

chProfStr="$(cat "$fIn")"
while [ -n "$chProfStr" ] ; do
     chRest="${chProfStr#?}"                     # split off first char
     chAct="${chProfStr%${chRest}}"
     chProfStr="$chRest"

     #print - "chAct: $chAct"
     #print - "read : $chBuffer"

     case "$chAct" in
          \")
               if [ $lInStr -eq 0 ] ; then
                    (( lInStr = 1 ))
               else
                    (( lInStr = 0 ))
               fi
               chBuffer="${chBuffer}${chAct}"
               ;;

          " ")
               if [ $lInStr -eq 0 ] ; then
                    print - "$chBuffer"          # write / flush buffer
                    chBuffer=""
               else
                    chBuffer="${chBuffer}${chAct}"
               fi
               ;;

          *)
               chBuffer="${chBuffer}${chAct}"
               ;;

     esac
done

return 0
}

test='one two three four five
"this and" that
done'

while quoted_read p1 p2 rest
do
   printf "%s\n" "p1=$p1" "p2=$p2" "rest=$rest" ""
done <<EOF
$test
EOF

p1=one
p2=two
rest=three four five

p1=this and
p2=that
rest=

p1=done
p2=
rest=

function quoted_read
{
  typeset lInStr=0
  typeset chBuffer
  typeset chAct
  typeset RET=1

  [ $# -eq 0 ] && set -- REPLY

  OIFS=$IFS
  IFS=
  while read -N 1 chAct
  do
     RET=0
     case "$chAct" in
        \") (( lInStr = (lInStr + 1) % 2 ))
            continue
            ;;
        " "|$'\n') if [ $lInStr -eq 0 ]
             then
                 [ "$chAct" == $'\n' ] && break
                 if [ $# -gt 1 ]
                 then
                    # More vars to assign -> not appending to current
                    export $1="$chBuffer"
                    shift
                    chBuffer=""
                    continue
                 fi
             fi
             ;;
     esac
     chBuffer="${chBuffer}${chAct}"
  done

  if [ ${#chBuffer} -gt 0 ]
  then
      export $1="$chBuffer"
      shift
  fi

  # Blank any vars not assigned
  while [ $# -gt 0 ]
  do
      export $1=""
      shift
  done
  IFS=$OIFS
  return $RET
}