bash - net - install cygwin 64 bits

¿Cómo comprobar si se está ejecutando en Cygwin, Mac o Linux?

Question

Tengo un script de shell que se usa tanto en Windows / Cygwin como en Mac y Linux. Necesita variables ligeramente diferentes para cada versión.

¿Cómo puede un script shell / bash detectar si se está ejecutando en Cygwin, en una Mac o en Linux?

Answer 1

Aquí está el script de bash que utilicé para detectar tres tipos de sistemas operativos diferentes (GNU / Linux, Mac OS X, Windows NT)

Presta atención

• En su script de bash, use #!/usr/bin/env bash lugar de #!/bin/sh para evitar el problema causado por /bin/sh vinculado a una shell predeterminada diferente en diferentes plataformas, o habrá un error como operador inesperado , eso es lo que pasó en mi computadora (Ubuntu 64 bits 12.04).
• Mac OS X 10.6.8 (Snow Leopard) no tiene el programa expr menos que lo instales, así que solo uso uname .

Diseño

1. Use uname para obtener la información del sistema (parámetro -s ).
2. Utilice expr y substr para tratar con la cadena.
3. Utilice if elif fi para hacer el trabajo correspondiente.
4. Puede agregar más soporte de sistema si lo desea, simplemente siga la especificación de uname -s .

Implementación

#!/usr/bin/env bash

if [ "$(uname)" == "Darwin" ]; then
    # Do something under Mac OS X platform        
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]; then
    # Do something under GNU/Linux platform
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW32_NT" ]; then
    # Do something under 32 bits Windows NT platform
elif [ "$(expr substr $(uname -s) 1 10)" == "MINGW64_NT" ]; then
    # Do something under 64 bits Windows NT platform
fi

Pruebas

• Linux (Ubuntu 12.04 LTS, Kernel 3.2.0) probado OK.
• OS X (10.6.8 Snow Leopard) probado OK.
• Windows (Windows 7 64 bit) probado OK.

Que aprendí

1. Compruebe las cotizaciones de apertura y cierre.
2. Compruebe si hay paréntesis y llaves faltantes {}

Referencias

• [1] en.wikipedia.org/wiki/Uname
• [2] error de sintaxis del script de shell: final inesperado del archivo
• [3] Detecta el sistema operativo desde un script Bash
• [4] Introducción a la programación de BASH CÓMO

Answer 2

Bash establece la variable de shell OSTYPE. De man bash :

Se establece automáticamente en una cadena que describe el sistema operativo en el que se está ejecutando bash.

Esto tiene una pequeña ventaja sobre uname ya que no requiere iniciar un nuevo proceso, por lo que será más rápido de ejecutar.

Sin embargo, no puedo encontrar una lista autorizada de valores esperados. Para mí, en Ubuntu 14.04 está configurado como ''linux-gnu''. He raspado la web por otros valores. Por lo tanto:

case "$OSTYPE" in
  linux*)   echo "Linux / WSL" ;;
  darwin*)  echo "Mac OS" ;; 
  win*)     echo "Windows" ;;
  msys*)    echo "MSYS / MinGW / Git Bash" ;;
  cygwin*)  echo "Cygwin" ;;
  bsd*)     echo "BSD" ;;
  solaris*) echo "Solaris" ;;
  *)        echo "unknown: $OSTYPE" ;;
esac

Los asteriscos son importantes en algunos casos, por ejemplo, OSX agrega un número de versión del sistema operativo después del ''darwin''. El valor de ''ganar'' es en realidad ''win32'', me han dicho: ¿quizás hay un ''win64''?

Quizás podríamos trabajar juntos para completar una tabla de valores verificados aquí:

• Linux Ubuntu (incl. WSL ): linux-gnu
• Cygwin de 64 bits: cygwin
• Msys / MINGW (Git Bash para Windows): msys

(Agregue su valor si difiere de las entradas existentes)

Answer 3

Ok, aquí está mi camino.

osis()
{
    local n=0
    if [[ "$1" = "-n" ]]; then n=1;shift; fi

    # echo $OS|grep $1 -i >/dev/null
    uname -s |grep -i "$1" >/dev/null

    return $(( $n ^ $? ))
}

p.ej

osis Darwin &&
{
    log_debug Detect mac osx
}
osis Linux &&
{
    log_debug Detect linux
}
osis -n Cygwin &&
{
    log_debug Not Cygwin
}

Yo uso esto en mis dotfiles

Answer 4

Para $COMSPEC en la respuesta de Albert, me gusta usar $COMSPEC para detectar Windows:

#!/bin/bash

if [ "$(uname)" == "Darwin" ]
then
 echo Do something under Mac OS X platform
elif [ "$(expr substr $(uname -s) 1 5)" == "Linux" ]
then
  echo Do something under Linux platform
elif [ -n "$COMSPEC" -a -x "$COMSPEC" ]
then 
  echo $0: this script does not support Windows /:/(
fi

Esto evita el análisis de variantes de nombres de Windows para $OS , y el análisis de variantes de uname como MINGW, Cygwin, etc.

Fondo: %COMSPEC% es una variable de entorno de Windows que especifica la ruta completa al procesador de comandos (también conocido como shell de Windows). El valor de esta variable suele ser %SystemRoot%/system32/cmd.exe , que generalmente se evalúa como C:/Windows/system32/cmd.exe .

Answer 5

Supongo que la respuesta uname es inmejorable, principalmente en términos de limpieza.

Si bien toma un tiempo ridículo para ejecutarlo, descubrí que probar la presencia de archivos específicos también me proporciona resultados buenos y rápidos, ya que no invoco un ejecutable

Asi que,

[ -f /usr/bin/cygwin1.dll ] && echo Yep, Cygwin running

solo usa un chequeo rápido de presencia del archivo Bash. Como estoy en Windows en este momento, no puedo decirte ningún archivo específico para Linux y Mac OS X desde mi cabeza, pero estoy bastante seguro de que existen. :-)

Answer 6

Usar solo esto desde la línea de comandos funciona muy bien, gracias a Justin:

#!/bin/bash

################################################## #########
# Bash script to find which OS
################################################## #########

OS=`uname`
echo "$OS"

source

Answer 7

Utilice uname -s ( --kernel-name ) porque uname -o ( --operating-system operativo) no es compatible con algunos sistemas operativos como Mac OS , Solaris . También puede usar solo uname sin argumento, ya que el argumento predeterminado es -s ( --kernel-name ).

El fragmento de código siguiente no requiere bash (es decir, no requiere #!/bin/bash )

#!/bin/sh

case "$(uname -s)" in

   Darwin)
     echo ''Mac OS X''
     ;;

   Linux)
     echo ''Linux''
     ;;

   CYGWIN*|MINGW32*|MSYS*)
     echo ''MS Windows''
     ;;

   # Add here more strings to compare
   # See correspondence table at the bottom of this answer

   *)
     echo ''other OS'' 
     ;;
esac

El siguiente Makefile está inspirado en el proyecto Git ( config.mak.uname ) .

ifdef MSVC     # Avoid the MingW/Cygwin sections
    uname_S := Windows
else                          # If uname not available => ''not'' 
    uname_S := $(shell sh -c ''uname -s 2>/dev/null || echo not'')
endif

# Avoid nesting "if .. else if .. else .. endif endif"
# because maintenance of matching if/else/endif is a pain

ifeq ($(uname_S),Windows)
    CC := cl 
endif
ifeq ($(uname_S),OSF1)
    CFLAGS += -D_OSF_SOURCE
endif
ifeq ($(uname_S),Linux)
    CFLAGS += -DNDEBUG
endif
ifeq ($(uname_S),GNU/kFreeBSD)
    CFLAGS += -D_BSD_ALLOC
endif
ifeq ($(uname_S),UnixWare)
    CFLAGS += -Wextra
endif
...

Vea también esta respuesta completa sobre uname -s y Makefile .

La tabla de correspondencia en la parte inferior de esta respuesta es del artículo de Wikipedia sobre uname . Contribuya para mantenerlo actualizado (edite la respuesta o publique un comentario). También puede actualizar el artículo de Wikipedia y publicar un comentario para notarme sobre su contribución ;-)

Operating System uname -s
Mac OS X Darwin
Cygwin 32-bit (Win-XP) CYGWIN_NT-5.1
Cygwin 32-bit (Win-7 32-bit) CYGWIN_NT-6.1
Cygwin 32-bit (Win-7 64-bit) CYGWIN_NT-6.1-WOW64
Cygwin 64-bit (Win-7 64-bit) CYGWIN_NT-6.1
MinGW (Windows 7 32-bit) MINGW32_NT-6.1
MinGW (Windows 10 64-bit) MINGW64_NT-10.0
Interix (Services for UNIX) Interix MSYS MSYS_NT-6.1 Windows Subsystem for Linux Linux
Android Linux
coreutils Linux
CentOS Linux
Fedora Linux
Gentoo Linux
Red Hat Linux Linux
Linux Mint Linux
openSUSE Linux
Ubuntu Linux
Unity Linux Linux
Manjaro Linux Linux
OpenWRT r40420 Linux
Debian (Linux) Linux
Debian (GNU Hurd) GNU
Debian (kFreeBSD) GNU/kFreeBSD
FreeBSD FreeBSD
NetBSD NetBSD
DragonFlyBSD DragonFly
Haiku Haiku
NonStop NONSTOP_KERNEL
QNX QNX
ReliantUNIX ReliantUNIX-Y
SINIX SINIX-Y
Tru64 OSF1
Ultrix ULTRIX
IRIX 32 bits IRIX
IRIX 64 bits IRIX64
Minix
Solaris SunOS
UWIN (64-bit Windows 7) UWIN-W7
SYS$UNIX:SH on OpenVMS IS/WB
z/OS USS OS/390
Cray sn5176
(SCO) OpenServer SCO_SV
(SCO) System V SCO_SV
(SCO) UnixWare UnixWare
IBM AIX AIX
IBM i with QSH OS400
HP-UX HP-UX

Answer 8

en.wikipedia.org/wiki/Uname

Toda la información que necesitarás. Google es tu amigo.

Use uname -s para consultar el nombre del sistema.

• Mac: Darwin
• Cygwin: CYGWIN_...
• Linux: varios, LINUX para la mayoría

Answer 9

Por lo general, uname con sus diversas opciones le dirá en qué entorno está ejecutando:

pax> uname -a
CYGWIN_NT-5.1 IBM-L3F3936 1.5.25(0.156/4/2) 2008-06-12 19:34 i686 Cygwin

pax> uname -s
CYGWIN_NT-5.1

Y, según el schot muy útil (en los comentarios), uname -s le da a Darwin para OSX y Linux para Linux, mientras que mi Cygwin le da a CYGWIN_NT-5.1 . Pero es posible que tengas que experimentar con todo tipo de versiones diferentes.

Por lo tanto, el código de bash para hacer tal verificación estaría en la línea de:

unameOut="$(uname -s)"
case "${unameOut}" in
    Linux*)     machine=Linux;;
    Darwin*)    machine=Mac;;
    CYGWIN*)    machine=Cygwin;;
    MINGW*)     machine=MinGw;;
    *)          machine="UNKNOWN:${unameOut}"
esac
echo ${machine}

Tenga en cuenta que supongo que en realidad está ejecutando CygWin (el shell bash ), por lo que las rutas ya deberían estar correctamente configuradas. Como señala un comentarista, puede ejecutar el programa bash , pasando el script, desde el mismo cmd y esto puede hacer que las rutas no se configuren según sea necesario.

Si está haciendo eso, es su responsabilidad asegurarse de que se llame a los ejecutables correctos (es decir, los de CygWin), posiblemente modificando la ruta de antemano o especificando completamente las ubicaciones ejecutables (por ejemplo, /c/cygwin/bin/uname ).

Answer 10

# This script fragment emits Cygwin rulez under bash/cygwin
if [[ $(uname -s) == CYGWIN* ]];then
    echo Cygwin rulez
else 
    echo Unix is king
fi

Si los 6 primeros caracteres del comando uname -s son "CYGWIN", se asume un sistema cygwin