Como urlencode dados para o comando curl?

Estou tentando escrever um script bash para teste que usa um parâmetro e o envia através de curl para o site. Preciso codificar o valor do URL para garantir que os caracteres especiais sejam processados ​​corretamente. Qual é a melhor maneira de fazer isso?

Aqui está o meu script básico até agora:

#!/bin/bash
host=${1:?'bad host'}
value=$2
shift
shift
curl -v -d "param=${value}" http://${host}/somepath $@

Use curl --data-urlencode; de man curl:

Isso publica dados, semelhantes às outras --dataopções, com a exceção de que ela executa codificação de URL. Para ser compatível com CGI, a <data>parte deve começar com um nome seguido por um separador e uma especificação de conteúdo.

Exemplo de uso:

curl \
    --data-urlencode "paramName=value" \
    --data-urlencode "secondParam=value" \
    http://example.com

Veja a página de manual para mais informações.

Isso requer a curvatura 7.18.0 ou mais recente (lançada em janeiro de 2008) . Use curl -Vpara verificar qual versão você possui.

Você também pode codificar a string de consulta :

curl -G \
    --data-urlencode "p1=value 1" \
    --data-urlencode "p2=value 2" \
    http://example.com
    # http://example.com?p1=value%201&p2=value%202

Aqui está a resposta BASH pura.

rawurlencode() {
  local string="${1}"
  local strlen=${#string}
  local encoded=""
  local pos c o

  for (( pos=0 ; pos<strlen ; pos++ )); do
     c=${string:$pos:1}
     case "$c" in
        [-_.~a-zA-Z0-9] ) o="${c}" ;;
        * )               printf -v o '%%%02x' "'$c"
     esac
     encoded+="${o}"
  done
  echo "${encoded}"    # You can either set a return variable (FASTER) 
  REPLY="${encoded}"   #+or echo the result (EASIER)... or both... :p
}

Você pode usá-lo de duas maneiras:

easier:  echo http://url/q?=$( rawurlencode "$args" )
faster:  rawurlencode "$args"; echo http://url/q?${REPLY}

[editado]

Aqui está a função rawurldecode () correspondente, que - com toda a modéstia - é incrível.

# Returns a string in which the sequences with percent (%) signs followed by
# two hex digits have been replaced with literal characters.
rawurldecode() {

  # This is perhaps a risky gambit, but since all escape characters must be
  # encoded, we can replace %NN with \xNN and pass the lot to printf -b, which
  # will decode hex for us

  printf -v REPLY '%b' "${1//%/\\x}" # You can either set a return variable (FASTER)

  echo "${REPLY}"  #+or echo the result (EASIER)... or both... :p
}

Com o conjunto de correspondência, agora podemos executar alguns testes simples:

$ diff rawurlencode.inc.sh \
        <( rawurldecode "$( rawurlencode "$( cat rawurlencode.inc.sh )" )" ) \
        && echo Matched

Output: Matched

E se você realmente acha que precisa de uma ferramenta externa (bem, ela será muito mais rápida e poderá fazer arquivos binários e coisas assim ...) Encontrei isso no meu roteador OpenWRT ...

replace_value=$(echo $replace_value | sed -f /usr/lib/ddns/url_escape.sed)

Onde url_escape.sed era um arquivo que continha estas regras:

# sed url escaping
s:%:%25:g
s: :%20:g
s:<:%3C:g
s:>:%3E:g
s:#:%23:g
s:{:%7B:g
s:}:%7D:g
s:|:%7C:g
s:\\:%5C:g
s:\^:%5E:g
s:~:%7E:g
s:\[:%5B:g
s:\]:%5D:g
s:`:%60:g
s:;:%3B:g
s:/:%2F:g
s:?:%3F:g
s^:^%3A^g
s:@:%40:g
s:=:%3D:g
s:&:%26:g
s:\$:%24:g
s:\!:%21:g
s:\*:%2A:g

Use o URI::Escapemódulo e a uri_escapefunção do Perl na segunda linha do seu script bash:

...

value="$(perl -MURI::Escape -e 'print uri_escape($ARGV[0]);' "$2")"
...

Editar: Corrija os problemas de citação, conforme sugerido por Chris Johnsen nos comentários. Obrigado!

Outra opção é usar jq(como um filtro):

jq -sRr @uri

-R( --raw-input) trata as linhas de entrada como seqüências de caracteres em vez de analisá-las como JSON e -sR( --slurp --raw-input) lê a entrada em uma única sequência. -r(--raw-output ) gera o conteúdo das strings em vez dos literais JSON.

Se a entrada não for a saída de outro comando, você poderá armazená-la em uma jqvariável de cadeia:

jq -nr --arg v "my shell string" '$v|@uri'

-n( --null-input) não lê entrada e --arg name valuearmazena valuena variável namecomo uma sequência. No filtro, $name(entre aspas simples, para evitar a expansão pelo shell), referencia a variávelname .

Embrulhado como uma função Bash, isso se torna:

function uriencode { jq -nr --arg v "$1" '$v|@uri'; }

Ou esse percentual codifica todos os bytes:

xxd -p|tr -d \\n|sed 's/../%&/g'

por uma questão de integridade, muitas soluções usando sedouawk traduzem apenas um conjunto especial de caracteres e, portanto, são muito grandes em tamanho de código e também não traduzem outros caracteres especiais que devem ser codificados.

uma maneira segura de codificar por URL seria codificar apenas cada byte - mesmo aqueles que seriam permitidos.

echo -ne 'some random\nbytes' | xxd -plain | tr -d '\n' | sed 's/\(..\)/%\1/g'

O xxd está cuidando aqui para que a entrada seja tratada como bytes e não como caracteres.

editar:

O xxd vem com o pacote vim-common no Debian e eu estava em um sistema em que não estava instalado e não queria instalá-lo. A alternativa é usarhexdump o pacote bsdmainutils no Debian. De acordo com o gráfico a seguir, bsdmainutils e vim-common devem ter uma probabilidade quase igual de instalação:

http://qa.debian.org/popcon-png.php?packages=vim-common%2Cbsdmainutils&show_installed=1&want_legend=1&want_ticks=1

mas, no entanto, aqui uma versão que usa em hexdumpvez de xxde permite evitar a trchamada:

echo -ne 'some random\nbytes' | hexdump -v -e '/1 "%02x"' | sed 's/\(..\)/%\1/g'

Uma das variantes, pode ser feia, mas simples:

urlencode() {
    local data
    if [[ $# != 1 ]]; then
        echo "Usage: $0 string-to-urlencode"
        return 1
    fi
    data="$(curl -s -o /dev/null -w %{url_effective} --get --data-urlencode "$1" "")"
    if [[ $? != 3 ]]; then
        echo "Unexpected error" 1>&2
        return 2
    fi
    echo "${data##/?}"
    return 0
}

Aqui está a versão one-liner, por exemplo (como sugerido por Bruno ):

date | curl -Gso /dev/null -w %{url_effective} --data-urlencode @- "" | cut -c 3-

# If you experience the trailing %0A, use
date | curl -Gso /dev/null -w %{url_effective} --data-urlencode @- "" | sed -E 's/..(.*).../\1/'

Acho mais legível em python:

encoded_value=$(python -c "import urllib; print urllib.quote('''$value''')")

o triplo 'garante que aspas simples em valor não sejam prejudiciais. O urllib está na biblioteca padrão. Ele funciona, por exemplo, para este URL louco (do mundo real):

"http://www.rai.it/dl/audio/" "1264165523944Ho servito il re d'Inghilterra - Puntata 7

Eu achei o seguinte trecho útil para colá-lo em uma cadeia de chamadas de programa, em que o URI :: Escape pode não estar instalado:

perl -p -e 's/([^A-Za-z0-9])/sprintf("%%%02X", ord($1))/seg'

( fonte )

Se você deseja executar a GETsolicitação e usar o curl puro, adicione --geta solução do @ Jacob.

Aqui está um exemplo:

curl -v --get --data-urlencode "access_token=$(cat .fb_access_token)" https://graph.facebook.com/me/feed

Link direto para a versão do awk: http://www.shelldorado.com/scripts/cmds/urlencode
Eu usei por anos e funciona como um encanto

:
##########################################################################
# Title      :  urlencode - encode URL data
# Author     :  Heiner Steven (heiner.steven@odn.de)
# Date       :  2000-03-15
# Requires   :  awk
# Categories :  File Conversion, WWW, CGI
# SCCS-Id.   :  @(#) urlencode  1.4 06/10/29
##########################################################################
# Description
#   Encode data according to
#       RFC 1738: "Uniform Resource Locators (URL)" and
#       RFC 1866: "Hypertext Markup Language - 2.0" (HTML)
#
#   This encoding is used i.e. for the MIME type
#   "application/x-www-form-urlencoded"
#
# Notes
#    o  The default behaviour is not to encode the line endings. This
#   may not be what was intended, because the result will be
#   multiple lines of output (which cannot be used in an URL or a
#   HTTP "POST" request). If the desired output should be one
#   line, use the "-l" option.
#
#    o  The "-l" option assumes, that the end-of-line is denoted by
#   the character LF (ASCII 10). This is not true for Windows or
#   Mac systems, where the end of a line is denoted by the two
#   characters CR LF (ASCII 13 10).
#   We use this for symmetry; data processed in the following way:
#       cat | urlencode -l | urldecode -l
#   should (and will) result in the original data
#
#    o  Large lines (or binary files) will break many AWK
#       implementations. If you get the message
#       awk: record `...' too long
#        record number xxx
#   consider using GNU AWK (gawk).
#
#    o  urlencode will always terminate it's output with an EOL
#       character
#
# Thanks to Stefan Brozinski for pointing out a bug related to non-standard
# locales.
#
# See also
#   urldecode
##########################################################################

PN=`basename "$0"`          # Program name
VER='1.4'

: ${AWK=awk}

Usage () {
    echo >&2 "$PN - encode URL data, $VER
usage: $PN [-l] [file ...]
    -l:  encode line endings (result will be one line of output)

The default is to encode each input line on its own."
    exit 1
}

Msg () {
    for MsgLine
    do echo "$PN: $MsgLine" >&2
    done
}

Fatal () { Msg "$@"; exit 1; }

set -- `getopt hl "$@" 2>/dev/null` || Usage
[ $# -lt 1 ] && Usage           # "getopt" detected an error

EncodeEOL=no
while [ $# -gt 0 ]
do
    case "$1" in
        -l) EncodeEOL=yes;;
    --) shift; break;;
    -h) Usage;;
    -*) Usage;;
    *)  break;;         # First file name
    esac
    shift
done

LANG=C  export LANG
$AWK '
    BEGIN {
    # We assume an awk implementation that is just plain dumb.
    # We will convert an character to its ASCII value with the
    # table ord[], and produce two-digit hexadecimal output
    # without the printf("%02X") feature.

    EOL = "%0A"     # "end of line" string (encoded)
    split ("1 2 3 4 5 6 7 8 9 A B C D E F", hextab, " ")
    hextab [0] = 0
    for ( i=1; i<=255; ++i ) ord [ sprintf ("%c", i) "" ] = i + 0
    if ("'"$EncodeEOL"'" == "yes") EncodeEOL = 1; else EncodeEOL = 0
    }
    {
    encoded = ""
    for ( i=1; i<=length ($0); ++i ) {
        c = substr ($0, i, 1)
        if ( c ~ /[a-zA-Z0-9.-]/ ) {
        encoded = encoded c     # safe character
        } else if ( c == " " ) {
        encoded = encoded "+"   # special handling
        } else {
        # unsafe character, encode it as a two-digit hex-number
        lo = ord [c] % 16
        hi = int (ord [c] / 16);
        encoded = encoded "%" hextab [hi] hextab [lo]
        }
    }
    if ( EncodeEOL ) {
        printf ("%s", encoded EOL)
    } else {
        print encoded
    }
    }
    END {
        #if ( EncodeEOL ) print ""
    }
' "$@"

Este pode ser o melhor:

after=$(echo -e "$before" | od -An -tx1 | tr ' ' % | xargs printf "%s")

Aqui está uma solução Bash que não chama nenhum programa externo:

uriencode() {
  s="${1//'%'/%25}"
  s="${s//' '/%20}"
  s="${s//'"'/%22}"
  s="${s//'#'/%23}"
  s="${s//'$'/%24}"
  s="${s//'&'/%26}"
  s="${s//'+'/%2B}"
  s="${s//','/%2C}"
  s="${s//'/'/%2F}"
  s="${s//':'/%3A}"
  s="${s//';'/%3B}"
  s="${s//'='/%3D}"
  s="${s//'?'/%3F}"
  s="${s//'@'/%40}"
  s="${s//'['/%5B}"
  s="${s//']'/%5D}"
  printf %s "$s"
}

url=$(echo "$1" | sed -e 's/%/%25/g' -e 's/ /%20/g' -e 's/!/%21/g' -e 's/"/%22/g' -e 's/#/%23/g' -e 's/\$/%24/g' -e 's/\&/%26/g' -e 's/'\''/%27/g' -e 's/(/%28/g' -e 's/)/%29/g' -e 's/\*/%2a/g' -e 's/+/%2b/g' -e 's/,/%2c/g' -e 's/-/%2d/g' -e 's/\./%2e/g' -e 's/\//%2f/g' -e 's/:/%3a/g' -e 's/;/%3b/g' -e 's//%3e/g' -e 's/?/%3f/g' -e 's/@/%40/g' -e 's/\[/%5b/g' -e 's/\\/%5c/g' -e 's/\]/%5d/g' -e 's/\^/%5e/g' -e 's/_/%5f/g' -e 's/`/%60/g' -e 's/{/%7b/g' -e 's/|/%7c/g' -e 's/}/%7d/g' -e 's/~/%7e/g')

isso codificará a string dentro de $ 1 e a produzirá em $ url. embora você não precise colocá-lo em um var, se quiser. BTW não incluiu o sed para tab pensei que iria transformá-lo em espaços

Usando php de um script de shell:

value="http://www.google.com"
encoded=$(php -r "echo rawurlencode('$value');")
# encoded = "http%3A%2F%2Fwww.google.com"
echo $(php -r "echo rawurldecode('$encoded');")
# returns: "http://www.google.com"

1. http://www.php.net/manual/en/function.rawurlencode.php
2. http://www.php.net/manual/en/function.rawurldecode.php

Para aqueles que procuram uma solução que não precisa de perl, aqui está uma que precisa apenas de hexdump e awk:

url_encode() {
 [ $# -lt 1 ] && { return; }

 encodedurl="$1";

 # make sure hexdump exists, if not, just give back the url
 [ ! -x "/usr/bin/hexdump" ] && { return; }

 encodedurl=`
   echo $encodedurl | hexdump -v -e '1/1 "%02x\t"' -e '1/1 "%_c\n"' |
   LANG=C awk '
     $1 == "20"                    { printf("%s",   "+"); next } # space becomes plus
     $1 ~  /0[adAD]/               {                      next } # strip newlines
     $2 ~  /^[a-zA-Z0-9.*()\/-]$/  { printf("%s",   $2);  next } # pass through what we can
                                   { printf("%%%s", $1)        } # take hex value of everything else
   '`
}

Costurados em vários lugares da rede e algumas tentativas e erros locais. Funciona muito bem!

O uni2ascii é muito útil:

$ echo -ne '你好世界' | uni2ascii -aJ
%E4%BD%A0%E5%A5%BD%E4%B8%96%E7%95%8C

Se você não quer depender do Perl, também pode usar o sed. É um pouco confuso, pois cada personagem precisa ser escapado individualmente. Crie um arquivo com o seguinte conteúdo e chame-ourlencode.sed

s/%/%25/g
s/ /%20/g
s/ /%09/g
s/!/%21/g
s/"/%22/g
s/#/%23/g
s/\$/%24/g
s/\&/%26/g
s/'\''/%27/g
s/(/%28/g
s/)/%29/g
s/\*/%2a/g
s/+/%2b/g
s/,/%2c/g
s/-/%2d/g
s/\./%2e/g
s/\//%2f/g
s/:/%3a/g
s/;/%3b/g
s//%3e/g
s/?/%3f/g
s/@/%40/g
s/\[/%5b/g
s/\\/%5c/g
s/\]/%5d/g
s/\^/%5e/g
s/_/%5f/g
s/`/%60/g
s/{/%7b/g
s/|/%7c/g
s/}/%7d/g
s/~/%7e/g
s/      /%09/g

Para usá-lo, faça o seguinte.

STR1=$(echo "https://www.example.com/change&$ ^this to?%checkthe@-functionality" | cut -d\? -f1)
STR2=$(echo "https://www.example.com/change&$ ^this to?%checkthe@-functionality" | cut -d\? -f2)
OUT2=$(echo "$STR2" | sed -f urlencode.sed)
echo "$STR1?$OUT2"

Isso dividirá a sequência em uma parte que precisa de codificação, e a parte que é boa, codifica a parte que precisa dela e, em seguida, é costurada novamente.

Você pode colocar isso em um script sh por conveniência, talvez precise de um parâmetro para codificar, coloque-o no seu caminho e, em seguida, basta chamar:

urlencode https://www.exxample.com?isThisFun=HellNo

_fonte

Você pode emular javascript encodeURIComponentem perl. Aqui está o comando:

perl -pe 's/([^a-zA-Z0-9_.!~*()'\''-])/sprintf("%%%02X", ord($1))/ge'

Você pode definir isso como um alias do bash em .bash_profile:

alias encodeURIComponent='perl -pe '\''s/([^a-zA-Z0-9_.!~*()'\''\'\'''\''-])/sprintf("%%%02X",ord($1))/ge'\'

Agora você pode canalizar para encodeURIComponent:

$ echo -n 'hèllo wôrld!' | encodeURIComponent
h%C3%A8llo%20w%C3%B4rld!

Aqui está a versão do nó:

uriencode() {
  node -p "encodeURIComponent('${1//\'/\\\'}')"
}

A questão é fazer isso no bash e não há necessidade de python ou perl, pois na verdade existe um único comando que faz exatamente o que você deseja - "urlencode".

value=$(urlencode "${2}")

Isso também é muito melhor, pois a resposta perl acima, por exemplo, não codifica todos os caracteres corretamente. Experimente com o longo traço obtido do Word e a codificação incorreta.

Observe que você precisa "gridsite-clients" instalado para fornecer este comando.

Opção PHP simples:

echo 'part-that-needs-encoding' | php -R 'echo urlencode($argn);'

Ruby, para completar

value="$(ruby -r cgi -e 'puts CGI.escape(ARGV[0])' "$2")"

Outra abordagem php:

echo "encode me" | php -r "echo urlencode(file_get_contents('php://stdin'));"

Aqui está a minha versão do busybox ash shell para um sistema incorporado. Adotei originalmente a variante do Orwellophile:

urlencode()
{
    local S="${1}"
    local encoded=""
    local ch
    local o
    for i in $(seq 0 $((${#S} - 1)) )
    do
        ch=${S:$i:1}
        case "${ch}" in
            [-_.~a-zA-Z0-9]) 
                o="${ch}"
                ;;
            *) 
                o=$(printf '%%%02x' "'$ch")                
                ;;
        esac
        encoded="${encoded}${o}"
    done
    echo ${encoded}
}

urldecode() 
{
    # urldecode <string>
    local url_encoded="${1//+/ }"
    printf '%b' "${url_encoded//%/\\x}"
}

Aqui está uma função POSIX para fazer isso:

encodeURIComponent() {
  awk 'BEGIN {while (y++ < 125) z[sprintf("%c", y)] = y
  while (y = substr(ARGV[1], ++j, 1))
  q = y ~ /[[:alnum:]_.!~*\47()-]/ ? q y : q sprintf("%%%02X", z[y])
  print q}' "$1"
}

Exemplo:

value=$(encodeURIComponent "$2")

Fonte

Aqui está uma conversão de uma linha usando Lua, semelhante à resposta do blueyed, exceto com todos os caracteres não reservados da RFC 3986 deixados sem codificação (como esta resposta ):

url=$(echo 'print((arg[1]:gsub("([^%w%-%.%_%~])",function(c)return("%%%02X"):format(c:byte())end)))' | lua - "$1")

Além disso, pode ser necessário garantir que as novas linhas da sua sequência sejam convertidas de LF para CRLF. Nesse caso, você pode inserir um gsub("\r?\n", "\r\n") na cadeia antes da codificação percentual.

Aqui está uma variante que, no estilo não padrão de application / x-www-form-urlencoded , faz essa normalização de nova linha, além de codificar espaços como '+' em vez de '% 20' (que provavelmente poderiam ser adicionados ao arquivo Snippet Perl usando uma técnica semelhante).

url=$(echo 'print((arg[1]:gsub("\r?\n", "\r\n"):gsub("([^%w%-%.%_%~ ]))",function(c)return("%%%02X"):format(c:byte())end):gsub(" ","+"))' | lua - "$1")

Tendo o php instalado, eu uso desta maneira:

URL_ENCODED_DATA=`php -r "echo urlencode('$DATA');"`

Esta é a versão ksh da resposta do orwellophile que contém as funções rawurlencode e rawurldecode (link: Como urlencode dados para o comando curl? ). Não tenho representante suficiente para postar um comentário, daí o novo post ..

#!/bin/ksh93

function rawurlencode
{
    typeset string="${1}"
    typeset strlen=${#string}
    typeset encoded=""

    for (( pos=0 ; pos<strlen ; pos++ )); do
        c=${string:$pos:1}
        case "$c" in
            [-_.~a-zA-Z0-9] ) o="${c}" ;;
            * )               o=$(printf '%%%02x' "'$c")
        esac
        encoded+="${o}"
    done
    print "${encoded}"
}

function rawurldecode
{
    printf $(printf '%b' "${1//%/\\x}")
}

print $(rawurlencode "C++")     # --> C%2b%2b
print $(rawurldecode "C%2b%2b") # --> C++

O que analisaria URLs melhor que o javascript?

node -p "encodeURIComponent('$url')"

O seguinte é baseado na resposta do Orwellophile, mas resolve o bug multibyte mencionado nos comentários, definindo LC_ALL = C (um truque do vte.sh). Eu escrevi na forma de função adequada PROMPT_COMMAND, porque é assim que eu a uso.

print_path_url() {
  local LC_ALL=C
  local string="$PWD"
  local strlen=${#string}
  local encoded=""
  local pos c o

  for (( pos=0 ; pos<strlen ; pos++ )); do
     c=${string:$pos:1}
     case "$c" in
        [-_.~a-zA-Z0-9/] ) o="${c}" ;;
        * )               printf -v o '%%%02x' "'$c"
     esac
     encoded+="${o}"
  done
  printf "\033]7;file://%s%s\007" "${HOSTNAME:-}" "${encoded}"
}