Parámetros de estilo dd a un script bash

Me gustaría pasar los parámetros a un script bash, dd-style. Básicamente quiero

./script a=1 b=43

tener el mismo efecto que

a=1 b=43 ./script

Pensé que podría lograr esto con:

for arg in "$@"; do
   eval "$arg";
done

¿Cuál es una buena manera de garantizar que evalsea ​​seguro, es decir, que "$arg"coincida con una asignación de variables estática (sin ejecución de código)?

¿O hay una mejor manera de hacer esto? (Me gustaría mantener esto simple).

Puede hacer esto en bash sin eval (y sin escape artificial):

for arg in "$@"; do
  if [[ $arg =~ ^[[:alpha:]_][[:alnum:]_]*= ]]; then
    declare +i +a +A "$arg"
  fi
done

Editar: Basado en un comentario de Stéphane Chazelas, agregué banderas a la declaración para evitar que la variable asignada ya se declare como una matriz o variable entera, lo que evitará una serie de casos en los que declarese evaluará la parte del valor del key=valargumento. (Esto +aprovocará un error si la variable a establecer ya se declara como una variable de matriz, por ejemplo). Todas estas vulnerabilidades se relacionan con el uso de esta sintaxis para reasignar variables existentes (matriz o entero), que normalmente serían bien conocidas. variables de shell

De hecho, esta es solo una instancia de una clase de ataques de inyección que afectarán igualmente las evalsoluciones basadas en: sería realmente mucho mejor permitir solo nombres de argumentos conocidos que establecer ciegamente cualquier variable que esté presente en la línea de comandos. (Considere lo que sucede si se establece la línea de comando PATH, por ejemplo. O se restablece PS1para incluir alguna evaluación que ocurrirá en la siguiente pantalla de aviso).

En lugar de usar variables bash, preferiría usar una matriz asociativa de argumentos con nombre, que es más fácil de configurar y mucho más seguro. Alternativamente, podría establecer variables bash reales, pero solo si sus nombres están en una matriz asociativa de argumentos legítimos.

Como ejemplo del último enfoque:

# Could use this array for default values, too.
declare -A options=([bs]= [if]= [of]=)
for arg in "$@"; do
  # Make sure that it is an assignment.
  # -v is not an option for many bash versions
  if [[ $arg =~ ^[[:alpha:]_][[:alnum:]_]*= &&
        ${options[${arg%%=*}]+ok} == ok ]]; then
    declare "$arg"
    # or, to put it into the options array
    # options[${arg%%=*}]=${arg#*=}
  fi
done

Una POSIX (se establece en $<prefix>varlugar de $varevitar problemas con variables especiales como IFS/ PATH...):

prefix=my_prefix_
for var do
  case $var in
    (*=*)
       case ${var%%=*} in
         "" | *[!abcdefghijiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_]*) ;;
         (*) eval "$prefix${var%%=*}="'${var#*=}'
       esac
  esac
done

Llamado como myscript x=1 PATH=/tmp/evil %=3 blah '=foo' 1=2, asignaría:

my_prefix_x <= 1
my_prefix_PATH <= /tmp/evil
my_prefix_1 <= 2

La solución de lcd047 se refactorizó con un DD_OPT_prefijo codificado :

while [[ $1 =~ ^[[:alpha:]_][[:alnum:]_]*= ]]; do
  eval "DD_OPT_${1%%=*}"='${1#*=}'; shift;
done

Frostschutz merece el crédito por la mayor parte de la refactorización.

Puse esto en un archivo fuente con una variable global:

DD_OPTS_PARSE=$(cat <<'EOF'
  while [[ $1 =~ ^[[:alpha:]_][[:alnum:]_]*= ]]; do
    eval "DD_OPT_${1%%=*}"='${1#*=}'; shift;
  done
EOF
)

eval "$DD_OPTS_PARSE" hace toda la magia

Una versión para funciones sería:

DD_OPTS_PARSE_LOCAL="${PARSE_AND_REMOVE_DD_OPTS/DD_OPT_/local DD_OPT_}"

En uso:

eval "$DD_OPTS_PARSE_LOCAL"

Hice un repositorio de esto, completo con pruebas y un archivo README.md. Luego usé esto en un contenedor CLI de API de Github que estaba escribiendo, y utilicé el mismo contenedor para configurar un clon de github de dicho repositorio (el arranque es divertido).

Paso seguro de parámetros para scripts de bash en una sola línea. Disfrutar. :)

El shell Bourne clásico es compatible, y los shell Bash y Korn siguen siendo compatibles, una -kopción. Cuando está en vigor, cualquier ddopción de comando ' similar' en cualquier lugar de la línea de comando se convierte automáticamente en variables de entorno que se pasan al comando:

$ set -k
$ echo a=1 b=2 c=3
$ 

Es un poco más difícil convencer de que son variables de entorno; ejecutar esto funciona para mí:

$ set -k
$ env | grep '^[a-z]='   # No environment a, b, c
$ bash -c 'echo "Args: $*" >&2; env' a=1 b=2 c=3 | grep '^[a-z]='
Args: 
a=1
b=2
c=3
$ set +k
$ bash -c 'echo "Args: $*" >&2; env' a=1 b=2 c=3 | grep '^[a-z]='
Args: b=2 c=3
$

El primero env | grepno muestra variables de entorno con una sola letra minúscula. El primero bashmuestra que no se pasan argumentos al script ejecutado mediante -c, y el entorno contiene las tres variables de una letra. La set +kcancela -ky muestra que el mismo comando ahora tiene argumentos pasados. (Se a=1trató como $0para el guión; también puede probarlo con el eco adecuado).

Esto logra lo que la pregunta pregunta: que escribir ./script.sh a=1 b=2debería ser lo mismo que escribir a=1 b=2 ./script.sh.

Tenga en cuenta que tiene problemas si intenta trucos como este dentro de un script:

if [ -z "$already_invoked_with_minus_k" ]
then set -k; exec "$0" "$@" already_invoked_with_minus_k=1
fi

El "$@"es tratado literalmente; no se vuelve a analizar para encontrar variables de estilo de asignación (en ambos bashy ksh). Lo intenté:

#!/bin/bash

echo "BEFORE"
echo "Arguments:"
al "$@"
echo "Environment:"
env | grep -E '^([a-z]|already_invoked_with_minus_k)='
if [ -z "$already_invoked_with_minus_k" ]
then set -k; exec "$0" "$@" already_invoked_with_minus_k=1
fi

echo "AFTER"
echo "Arguments:"
al "$@"
echo "Environment:"
env | grep -E '^([a-z]|already_invoked_with_minus_k)='

unset already_invoked_with_minus_k

y solo la already_invoked_with_minus_kvariable de entorno se establece en el execscript 'd.

Mi intento:

#! /usr/bin/env bash
name='^[a-zA-Z][a-zA-Z0-9_]*$'
count=0
for arg in "$@"; do
    case "$arg" in
        *=*)
            key=${arg%%=*}
            val=${arg#*=}

            [[ "$key" =~ $name ]] && { let count++; eval "$key"=\$val; } || break

            # show time
            if [[ "$key" =~ $name ]]; then
                eval "out=\${$key}"
                printf '|%s| <-- |%s|\n' "$key" "$out"
            fi
            ;;
        *)
            break
            ;;
    esac
done
shift $count

# show time again   
printf 'arg: |%s|\n' "$@"

Funciona con basura (casi) arbitraria en el RHS:

$ ./assign.sh Foo_Bar33='1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0' '1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0=33'
|Foo_Bar33| <-- |1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0|
arg: |1 2;3`4"5~6!7@8#9$0 1%2^3&4*5(6)7-8=9+0=33|

$ ./assign.sh a=1 b=2 c d=4
|a| <-- |1|
|b| <-- |2|
arg: |c|
arg: |d=4|

Hace algún tiempo me decidí aliaspor este tipo de trabajo. Aquí hay alguna otra respuesta mía:

Sin embargo, a veces puede ser posible separar la evaluación y la ejecución de tales declaraciones. Por ejemplo, aliasse puede usar para evaluar previamente un comando. En el siguiente ejemplo, la definición de la variable se guarda en un alias que solo puede declararse con éxito si la $varvariable que está evaluando no contiene bytes que no coincidan con los caracteres alfanuméricos ASCII o _.

LC_OLD=$LC_ALL LC_ALL=C
for var do    val=${var#*=} var=${var%%=*}
    alias  "${var##*[!_A-Z0-9a-z]*}=_$var=\$val" &&
    eval   "${var##[0-9]*}" && unalias "$var"
done;       LC_ALL=$LC_OLD

evalse usa aquí para manejar la invocación de lo nuevo aliasdesde un contexto de nombre de variable entre comillas, no para la asignación exactamente. Y evalsolo se llama si la aliasdefinición anterior es exitosa, y aunque sé que muchas implementaciones diferentes aceptarán muchos tipos diferentes de valores para nombres de alias, aún no he encontrado un shell que acepte uno completamente vacío .

_$varSin embargo, la definición dentro del alias es para , y esto es para garantizar que no se sobrescriban valores de entorno significativos. No conozco ningún valor de entorno notable que comience con un _ y, por lo general, es una apuesta segura para la declaración semiprivada.

De todos modos, si la definición de alias es exitosa, declarará un alias con el nombre del $varvalor. Y evalsolo llamará a eso aliassi tampoco comienza con un número; de lo contrario, evalsolo obtiene un argumento nulo. Entonces, si se cumplen ambas condiciones, se evalllama a la aliasdefinición de variable y se guarda en elalias , después de lo cual el nuevo alias se elimina rápidamente de la tabla hash.

También útil aliasen este contexto es que puede imprimir su trabajo. aliasimprimirá una declaración de ejecución segura de cotización doblemente citada cuando se le solicite .

sh -c "IFS=\'
    alias q=\"\$*\" q" -- \
    some args which alias \
    will print back at us

SALIDA

q='some'"'"'args'"'"'which'"'"'alias'"'"'will'"'"'print'"'"'back'"'"'at'"'"'us'