¿Cómo puedo obtener la versión de ksh de forma segura?

¿Cómo puedo obtener la versión de ksh de forma segura desde un script ksh?

He visto las siguientes soluciones :

1. ksh --version
2. echo ${.sh.version}
3. echo $KSH_VERSION

Y dadas las circunstancias correctas, cada uno de estos funciona correctamente. Sin embargo, me importa el caso no perfecto.

Específicamente, hay varias máquinas con las que trabajo que tienen versiones anteriores de ksh que, para mis propósitos, carecen de funcionalidad. De todos modos, la razón por la que quiero verificar la versión (programáticamente) es para ver si la versión ksh es una de las versiones menos capaces; y si es así, quiero ejecutar una rama con un código menos sorprendente.

Sin embargo, en las máquinas problemáticas, la ineptitud del shell se extiende hasta verificar la versión ...

• Si lo intento ksh --version, no imprime nada y abre una nueva instancia de ksh!

• Si lo intento echo ${.sh.version}, kshtrata esto como un error de sintaxis con el que no se puede descartar 2> /dev/null.

  $ echo ${.sh.version} 2> /dev/null  
  ksh: ${.sh.version}: bad substitution

• Por supuesto, echo $KSH_VERSIONparece funcionar bien, quiero decir que no se bloqueará, aunque en estas máquinas está en blanco. Además, vi en algún lugar que KSH_VERSIONse establece solo por pdksh.

Preguntas:

• ¿Cómo puedo verificar la versión de forma segura mediante kshprogramación? Para mis propósitos aquí, realmente no me importa cuál es el número de versión real, solo si es una versión desactualizada ksh.
• Es $KSH_VERSIONlo suficientemente bueno? Quiero decir, si está en blanco, ¿es kshnecesariamente una versión desactualizada? ¿Era correcto ese otro foro en el que podría no estar configurado incluso para versiones más recientes ksh?
• ¿No hay forma de verificar esto?

Creo que .sh.versionha existido desde la primera versión de ATT ksh 93. No está disponible en pdksh o mksh. Como se ${.sh.version}trata de un error de sintaxis en shells distintos de ksh93, envuelva la prueba en un subshell y protéjalo detrás eval.

_sh_version=$(eval 'echo "${.sh.version}"' 2>/dev/null) 2>/dev/null
case $_sh_version in
  '') echo "This isn't ATT ksh93";;
  …
esac

KSH_VERSION comenzó en el dominio público ksh clone (pdksh), y se agregó al shell Korn real hace relativamente poco, en 2008 con ksh93t.

En lugar de probar un número de versión, debe probar la función específica que le causa dolor. La mayoría de las características se pueden probar probando alguna construcción en una subshell y ver si desencadena un error.

KSH_VERSIONno se implementó ksh93antes de la versión 93t. Se encuentra en mksh, pdksh, lksh. Entonces, para verificar la versión de ksh, podemos probar estos pasos:

• Comprobación KSH_VERSIONde detectar mksh, pdksh,lksh
• Si el primer paso falla, pruebe una función que sea diferente entre ksh93y ksh88/86( deje que David Korn nos lo muestre ).

Con esto en mente, iré con:

case "$KSH_VERSION" in
  (*MIRBSD*|*PD*|*LEGACY*) printf '%s\n' "$KSH_VERSION" ;;
  (*) [ -z "$ERRNO" ] && printf '%s\n' "${.sh.version}" || echo ksh88/86 ;;
esac

Para las kshversiones "reales" (es decir, basadas en AT&T), utilizo este comando:

strings /bin/ksh | grep Version | tail -2 

Aquí hay varios resultados que obtengo:

Ksh original:

@(#)Version M-11/16/88i

dtksh;

@(#)Version 12/28/93
Version not defined

Ksh93 moderno:

@(#)$Id: Version AJM 93u+ 2012-08-01 $

Para pdksh/ msh kshclones y kshversiones modernas de AT&T también, aquí hay algo que funciona:

$ mksh -c 'echo $KSH_VERSION'
@(#)MIRBSD KSH R50 2015/04/19

Editar:

Pasé por alto que estabas preguntando acerca de hacerlo desde dentro de un script, no sabiendo la ruta al binario ksh probado.

Suponiendo que realmente desea la versión de kshutilizado, y no las características que admite, aquí hay una forma de hacerlo utilizando solo el stringscomando que debería funcionar al menos en Linux y Solaris:

echo $(for i in $(find /proc/$$ ! -type d ! -name "pagemap" | 
  grep -v "/path/" | grep -v "/fd/" ) ; do
  strings $i | egrep "([V]ersion|[K]SH_VERSION).*[0-9]" | sort -u
done 2>/dev/null)

Tenga en cuenta que este método no es confiable ya que /procpodría no estar montado, y ciertamente hay otras debilidades. No se ha probado en otros sistemas operativos Unix.

Mientras escribía un script para ksh, noté que la -aopción del whencecomando incorporado de ksh parece no ser compatible con versiones anteriores de ksh. Y esto parece ser cierto en todos los sistemas que verifiqué, incluidos Solaris, AIX, HP-UX y Linux.

Así que aquí está la solución como una función ksh:

is_modern_ksh() {
  if whence -a whence > /dev/null 2>&1 ; then
    return 0 #success -> true
  fi
  #Else the call to `whence` failed because `-a` is not supported
  return 1 #failure -> false
}

Y aquí está cómo usarlo:

if is_modern_ksh ; then
  echo "You're using a MODERN version of ksh. :)"
else
  echo "You're using an OLD version of ksh. :("
fi

CTRL+ ALT+V

o

ESC, CTRL+V

Por lo general, han demostrado ser muy confiables en lo que respecta a la determinación interactiva de la versión de KSH que está utilizando, sin embargo, crear scripts es más difícil.

Creo que el problema fundamental con el uso de $ {. Sh.version} es que ksh88 simplemente se detiene, con un código de salida distinto de cero.

Por lo tanto, mi solución es poner el código que hace referencia a $ {. Sh.version} en un sub-shell, luego probar para ver si el sub-shell sale de cero y tiene un código en el sub-shell que funcionará en versiones de el ksh donde hacer referencia a $ {. sh.version} funciona. Envolviéndolo en una función que luego es llamada por otra función que invierte el código de retorno, de modo que la última llamada verifica que sea verdadera.

function is_oldksh
{
    (test -n ${.sh.version}) 2>/dev/null
}

function oldkshtest
{

    is_oldksh || return 0 && return 1
}

oldkshtest && echo "old ksh" || echo "new ksh"

He ejecutado esto en AIX y Oracle Enterprise Linux 5 y 6, con ksh88, ksh93 y pdksh.

Pete

Lo siguiente parece funcionar razonablemente bien para todos los shells que he probado, incluido el viejo ksh88e y una gama casi completa de clones Ksh comunes (aunque solo una versión de cada uno), aunque todavía no he probado un shell Bourne original real ( y hacerlo puede requerir adaptar la testexpresión para versiones anteriores ...

Apéndice:

Ahora también he probado con éxito esto con Heirloom Bourne Shell, aunque con un programa externo (y más moderno) test.

is_attksh()
{
    # ksh93
    _sh_version=$(eval 'echo "${.sh.version}"' 2>/dev/null)
    # pdksh only
    _opt_login=$(set -o | grep login)

    test -n "${_sh_version}" -o \( -z "${_opt_login}" -a -n "${_}" -a -n "${ERRNO}" -a -n "${FCEDIT}" -a -n "${PS3}" \)
}
is_attksh && echo "AT&T Ksh${_sh_version:+: }${_sh_version:- (probably ksh88 or ksh86)}" || echo "not real ksh"

is_zsh()
{
    test -n "${ZSH_VERSION}"
}
is_zsh && echo "Zsh: ${ZSH_VERSION}" || echo "not zsh"