Affichage des articles dont le libellé est ksh. Afficher tous les articles
Affichage des articles dont le libellé est ksh. Afficher tous les articles

lundi 26 octobre 2015

Scripting : set variables depending how the where launched (terminal mode, cron/auto mode, ...)

You all know the deal : when you launch a command it (obviously) comes with all your environment variables. But when you want to cron it, none of them is present. We hence want to set some variables, but only in some cases. The "tty" command will help us do so.


You can use the tty tool to check if a script is called from the standard output :


if ! tty -s
then
    exec >/dev/null 2>&1
else
    MAIL_DEST="email@server.ext"
fi



  • The command tty returns :

User Commands                                              tty(1)

NAME
     tty - return user's terminal name

SYNOPSIS
     tty [-l] [-s]

DESCRIPTION
     The tty utility writes to the standard output  the  name  of
     the  terminal  that is open as standard input. The name that
     is used is equivalent to the string that would  be  returned
     by the ttyname(3C) function.

OPTIONS
     The following options are supported:

     -l       Prints the synchronous line  number  to  which  the
              user's terminal is connected, if it is on an active
              synchronous line.

     -s       Inhibits printing of the terminal path name, allow-
              ing one to test just the exit status.

EXIT STATUS
     The following exit values are returned:

     0        Standard input is a terminal.

     1        Standard input is not a terminal.

     >1       An error occurred.

 

vendredi 24 avril 2015

get return value ($?) of a tee'd command in ksh

How to get the return value of "command1" if passed to a " | command2" , for example "| tee OUTFILE" :
 
 
    command1 | tee OUTFILE


 With recent shells, you can use the array storing this : bash is ${PIPESTATUS[x]} , zsh is $pipestatus[x] to get this value :
 
      command1 | tee OUTFILE
      echo ${PIPESTATUS[0]}

With older shells, this feature is not available, but you still can use posix features and play around with the file descriptors :
 
    exec 4>&1; RETVAL=$({ { command1 ; echo $? >&3 ; } | { tee $OUTFILE >&4; } } 3>&1); exec 4>&-

 
Explainations 
  1. Create a file descriptor fd4 and map it to STDOUT
  2. Fill the RETVAL value with the fork.
    1. fd4 is transmitted, but STDOUT and STDERR are recreated for the forked process so fd4 still exist and is available.
    2. create the fd3 and redirect it to STDOUT
    3. map 'tee' STDOUT to the previously created fd4 so that it gets printed to the terminal; 
    4. tee then forks the piped 'command1' which output value $? is sent to fd3 with 'echo $? >&3', and hence outputed in the RETVAL variable; 
  3. Eventually, close the fd4


References :

vendredi 8 août 2014

KSH eval / variable subtitution / variable test

from :http://b62.tripod.com/doc/docksh.htm

OTHER FUNCTIONALITIES


cmd1 || cmd2    exec cmd2 if cmd1 fail
cmd1 && cmd2    exec cmd2 if cmd1 is OK

V1=${V2:=V3}    Set V1 with the value of V2 if this is set else set the
                variable V1 with value of V3 (V3 could be a number).
                sh replacement:  if [ $V2 ] ; then
                                                V1=$V2
                                 else
                                                V1=$V3
                Example: DisplaySize=${LINES:24} ; Command=${Command:"cat"}


${V1:?word}     if V1 set  & V1!=null   ret $V1 else print word and exit
                  : ${V1:?"variable V1 not set on null"}
${V1:=word}     if V1 !set | V1==null   set V1=$word
${V1:-word}     if V1 set  & V1!=null   ret $V1 else ret word
${V1:+word}     if V1 set  & V1!=null   ret word else ret nothing
${V1##patt}
${V1#patt}      if patt are found at the begin of V1 return V1 whitout the patt
                else return V1
                V1="lspwd" ; ${V1#"ls"}  # exec pwd
${V1%%patt}
${V1%patt}      if patt are found at the end of V1 return V1 whitout the patt
                else return V1
                V1="lspwd" ; ${V1%"pwd"}  # exec ls 
 
 
from : http://www.well.ox.ac.uk/~johnb/comp/unix/ksh.html 
Variable Manipulations

Removing something from a variable

Variables that contain a path can very easily be stripped of it: ${name##*/} gives you just the filename.
Or if one wants the path: ${name%/*}. % takes it away from the left and # from the right.
%% and ## take the longest possibility while % and # just take the shortest one.

Replacing a variable if it does not yet exits

If we wanted $foo or if not set 4 then: ${foo:-4} but it still remains unset. To change that we use:
${foo:=4}

Exiting and stating something if variable is not set

This is very important if our program relays on a certain vaiable: ${foo:?"foo not set!"}

Just check for the variable

${foo:+1} gives one if $foo is set, otherwise nothing.
 

KSH : $- and Flags

Under Solaris and using the Korn Shell KSH, the $- allows access to the flags setted.
Example of how it changes when setting the debug mode '-x' :

# echo $-
ismC
# set -x
# echo $-
+ echo isxmC
isxmC
# set +x

man ksh informs us that (cf. http://www.lehman.cuny.edu/cgi-bin/man-cgi?ksh+1 for example)

  "   -  "         Correspond to the "Flags supplied to the shell on invocation  or  by the set command." and that "The current set of flags can be found in $- ":



  Parameters Set by Shell
     -          Flags supplied to the shell on invocation  or  by
                the set command.

   
     set [ _abCefhkmnopstuvx ] [ _o option ]... [ _A name ] [ arg
     ... ]

         The flags for this command have meaning as follows:

         -A          Array assignment. Unsets the  variable  name
                     and  assigns  values  sequentially  from the
                     list arg. If +A is used, the  variable  name
                     is not unset first.

         -a          All subsequent variables  that  are  defined
                     are automatically exported.

         -b          Causes the shell to notify  the  user  asyn-
                     chronously  of  background  job completions.
                     The following message is written to standard
                     error:

                       "[%d]%c %s%s\n", , , , \
                           

                     where the fields are as follows:

                            The character  +  identifies
                                     the  job  that would be used
                                     as a default for the  fg  or
                                     bg  utilities.  This job can
                                     also be specified using  the
                                     job_id %+ or %%. The charac-
                                     ter  -  identifies  the  job
                                     that    would   become   the
                                     default   if   the   current
                                     default  job  were  to exit;
                                     this job can also be  speci-
                                     fied  using  the  job_id %-.
                                     For other jobs,  this  field
                                     is  a  space  character.  At
                                     most one job can be  identi-
                                     fied  with + and at most one
                                     job can be  identified  with
                                     -. If there is any suspended
                                     job, then the current job is
                                     a  suspended  job.  If there
                                     are at least  two  suspended
                                     jobs,  then the previous job
                                     is also a suspended job.

                         A number that can be used to
                                     identify  the  process group
                                     to the  wait,  fg,  bg,  and
                                     kill  utilities. Using these
                                     utilities, the  job  can  be
                                     identified  by prefixing the
                                     job number with %.

                             Unspecified.

                           Unspecified.

                     When the shell notifies the user a  job  has
                     been completed, it can remove the job's pro-
                     cess ID from the list of those known in  the
                     current  shell  execution environment. Asyn-
                     chronous  notification  is  not  enabled  by
                     default.

         -C          Prevents existing files from being overwrit-
                     ten  by  the shell's > redirection operator.
                     The >| redirection operator  overrides  this
                     noclobber option for an individual file.

         -e          If a command has  a  non-zero  exit  status,
                     executes  the  ERR  trap,  if set, and exit.
                     This mode is  disabled  while  reading  pro-
                     files.
         -f          Disables file name generation.

         -h          Each command becomes a  tracked  alias  when
                     first encountered.

         -k          All variable assignment arguments are placed
                     in  the  environment for a command, not just
                     those that precede the command name.

         -m          Background jobs runs in a  separate  process
                     group and a line prints upon completion. The
                     exit status of background jobs  is  reported
                     in a completion message. On systems with job
                     control, this flag is  turned  on  automati-
                     cally for interactive shells.

         -n          Reads commands and  check  them  for  syntax
                     errors, but do not execute them. Ignored for
                     interactive shells.

         -o          Writes the current option settings to  stan-
                     dard output in a format that is suitable for
                     reinput  to  the  shell  as  commands   that
                     achieve the same option settings.

         -o          The following argument can  be  one  of  the
                     following option names:

                     allexport     Same as -a.

                     errexit       Same as -e.

                     bgnice        All background jobs are run at
                                   a  lower priority. This is the
                                   default mode.

                     emacs         Puts you  in  an  emacs  style
                                   in-line   editor  for  command
                                   entry.

                     gmacs         Puts you in a gmacs style  in-
                                   line editor for command entry.                     
                     ignoreeof     The shell does not exit onEOF.
                                   The command exit must be used.

                     keyword       Same as -k.

                     markdirs      All directory names  resulting
                                   from file name generation have
                                   a trailing / appended.

                     monitor       Same as -m.

                     noclobber     Prevents  redirection  >  from
                                   truncating   existing   files.
                                   Require >| to truncate a  file
                                   when  turned on. Equivalent to
                                   -C.

                     noexec        Same as -n.

                     noglob        Same as -f.

                     nolog         Do not save  function  defini-
                                   tions in history file.

                     notify        Equivalent to -b.

                     nounset       Same as -u.

                     privileged    Same as -p.

                     verbose       Same as -v.

                     trackall      Same as -h.

                     vi            Puts you in insert mode  of  a
                                   vi  style in-line editor until
                                   you hit escape character  033.
                                   This puts you in control mode.
                                   A return sends the line.
                     viraw         Each character is processed as
                                   it is typed in vi mode.

                     xtrace        Same as -x.

                     If no option name is supplied,  the  current
                     option settings are printed.

         -p          Disables processing  of  the  $HOME/.profile
                     file  and  uses  the  file /etc/suid_profile
                     instead of the ENV file.  This  mode  is  on
                     whenever  the  effective uid is not equal to
                     the real uid, or when the effective  gid  is
                     not  equal to the real gid. Turning this off
                     causes the effective uid and gid to  be  set
                     to the real uid and gid.

         -s          Sorts the positional parameters lexicograph-
                     ically.

         -t          Exits after reading and executing  one  com-
                     mand.

         -u          Treats unset parameters  as  an  error  when
                     substituting.

         -v          Prints shell input lines as they are read.

         -x          Prints commands and their arguments as  they
                     are executed.

         -           Turns off -x and -v flags and stops  examin-
                     ing arguments for flags.

         --          Does not change any of the flags. Useful  in
                     setting  $1  to a value beginning with -. If
                     no arguments follow this flag then the posi-
                     tional parameters are unset.

                     Using + rather than - causes these flags  to
                     be  turned off. These flags can also be used
                     upon invocation of the  shell.  The  current
                     set  of  flags can be found in $-. Unless -A
                     is specified, the  remaining  arguments  are
                     positional  parameters  and are assigned, in
                     order, to $1 $2 ....  If  no  arguments  are
                     given, the names and values of all variables
                     are printed on the standard output.                                  

mercredi 23 juillet 2014

Test dir var (eval shell)



 Test if the given variable contains a valid directory. If not, exit. (This uses the eval function of the shell)
testdirvar () {
    tmp=$1
    if [ -d "${!tmp}" ] ; then
        echo "${tmp}=${!tmp} (variable ${tmp}: directory exists)"
    else
        echo "!!! ${tmp}=${!tmp} is not a directory (variable ${tmp}) !!!"
        exit
    fi
}