Jak urlencode dane dla polecenia curl?

Próbuję napisać skrypt bash do testowania, który pobiera parametr i wysyła go przez curl do strony internetowej. Muszę zakodować adres URL, aby upewnić się, że znaki specjalne są poprawnie przetwarzane. Jak najlepiej to zrobić?

Oto mój podstawowy skrypt do tej pory:

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

Użyj curl --data-urlencode; z man curl:

Publikuje dane, podobnie jak inne --dataopcje, z tym wyjątkiem, że wykonuje kodowanie adresów URL. Aby być zgodnym z CGI, <data>część powinna zaczynać się od nazwy, po której następuje separator i specyfikacja treści.

Przykładowe użycie:

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

Zobacz stronę manuala aby uzyskać więcej informacji.

Wymaga to curl 7.18.0 lub nowszego (wydanego w styczniu 2008) . Posługiwać się curl -V aby sprawdzić, którą wersję posiadasz.

Możesz również zakodować ciąg zapytania :

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

Oto czysta odpowiedź BASH.

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
}

Możesz użyć go na dwa sposoby:

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

[edytowany]

Oto pasująca funkcja rawurldecode (), która - przy całej skromności - jest niesamowita.

# 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
}

Dzięki pasującemu zestawowi możemy teraz wykonać kilka prostych testów:

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

Output: Matched

A jeśli naprawdę czujesz, że potrzebujesz zewnętrznego narzędzia (cóż, będzie działać znacznie szybciej i może tworzyć pliki binarne itp.) Znalazłem to na moim routerze OpenWRT ...

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

Gdzie url_escape.sed był plikiem zawierającym następujące reguły:

# 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

Użyj URI::Escapemodułu i uri_escapefunkcji Perla w drugiej linii skryptu bash:

...

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

Edycja: Napraw problemy z cytowaniem, jak sugerował Chris Johnsen w komentarzach. Dzięki!

Inną opcją jest użycie jq(jako filtru):

jq -sRr @uri

-R( --raw-input) traktuje wiersze wejściowe jako ciągi zamiast analizować je jako JSON, a -sR( --slurp --raw-input) odczytuje dane wejściowe w jednym ciągu. -r(--raw-output ) wyświetla zawartość ciągów zamiast literałów ciągów JSON.

Jeśli dane wejściowe nie są danymi wyjściowymi innego polecenia, możesz je zapisać w jqzmiennej łańcuchowej:

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

-n( --null-input) nie odczytuje danych wejściowych i --arg name valuezapisuje valuew zmiennej namejako ciąg znaków. W filtrze $name(w pojedynczych cudzysłowach, aby uniknąć rozwinięcia przez powłokę), odwołuje się do zmiennej name.

Opakowany jako funkcja Bash, staje się:

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

Lub ten procent koduje wszystkie bajty:

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

ze względu na kompletność, wiele rozwiązań wykorzystujących sedlub awktłumaczących specjalny zestaw znaków, a zatem jest dość dużych pod względem rozmiaru kodu, a także nie tłumaczy innych znaków specjalnych, które powinny być zakodowane.

bezpiecznym sposobem na urlencode byłoby po prostu zakodowanie każdego bajtu - nawet tych, które byłyby dozwolone.

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

xxd dba o to, aby dane wejściowe były traktowane jako bajty, a nie znaki.

edytować:

xxd jest dostarczany z pakietem vim-common w Debianie, a ja byłem na systemie, w którym nie został zainstalowany i nie chciałem go instalować. Altornatywą jest użyciehexdump z pakietu bsdmainutils w Debianie. Zgodnie z poniższym wykresem prawdopodobieństwo zainstalowania bsdmainutils i vim-common powinno być prawie równe:

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

ale tutaj jest wersja, która używa hexdumpzamiast xxdi pozwala uniknąć trpołączenia:

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

Jeden z wariantów może być brzydki, ale prosty:

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
}

Oto na przykład wersja jednoliniowa (zgodnie z sugestią 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/'

Uważam, że jest bardziej czytelny w Pythonie:

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

potrójny „gwarantuje, że pojedyncze cytaty wartości nie zaszkodzą. urllib znajduje się w standardowej bibliotece. To działa na przykład dla tego zwariowanego (prawdziwego świata) adresu URL:

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

Uważam, że następujący fragment kodu jest przydatny do umieszczenia go w łańcuchu wywołań programu, w których URI :: Escape może nie być zainstalowany:

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

( źródło )

Jeśli chcesz uruchomić GETżądanie i użyć czystego curl, po prostu dodaj --getdo rozwiązania @ Jacob.

Oto przykład:

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

Bezpośredni link do wersji awk: http://www.shelldorado.com/scripts/cmds/urlencode
Używałem go od lat i działa jak urok

:
##########################################################################
# 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 ""
    }
' "$@"

To może być najlepszy:

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

Oto rozwiązanie Bash, które nie wywołuje żadnych programów zewnętrznych:

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')

spowoduje to zakodowanie ciągu wewnątrz $ 1 i wyprowadzenie go w $ url. chociaż nie musisz umieszczać go w var, jeśli chcesz. BTW nie uwzględnił sed dla tabu, sądząc, że zamieni go w spacje

Za pomocą php ze skryptu powłoki:

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

Dla tych z Was, którzy szukają rozwiązania, które nie potrzebuje perla, oto takie, które potrzebuje tylko hexdump i 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
   '`
}

Połączone ze sobą z kilku miejsc w sieci i trochę lokalnych prób i błędów. Działa świetnie!

uni2ascii jest bardzo przydatny:

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

Jeśli nie chcesz polegać na Perlu, możesz także użyć sed. To trochę bałagan, ponieważ każda postać musi być uciekana indywidualnie. Utwórz plik o następującej treści i wywołaj gourlencode.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

Aby go użyć, wykonaj następujące czynności.

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"

Spowoduje to podzielenie łańcucha na część, która wymaga kodowania, a część, która jest w porządku, koduje część, która jej potrzebuje, a następnie ponownie łączy.

Możesz to dla wygody umieścić w skrypcie sh, może wymagać kodowania parametru, umieścić go na swojej ścieżce, a następnie możesz po prostu wywołać:

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

_źródło

Możesz emulować javascript encodeURIComponentw perlu. Oto polecenie:

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

Możesz ustawić to jako alias bash w .bash_profile:

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

Teraz możesz przesyłać do encodeURIComponent:

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

Oto wersja węzła:

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

Pytanie dotyczy robienia tego w bashu i nie ma potrzeby używania Pythona lub Perla, ponieważ w rzeczywistości istnieje jedno polecenie, które robi dokładnie to, co chcesz - „urlencode”.

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

Jest to również znacznie lepsze, ponieważ powyższy perl na przykład nie koduje poprawnie wszystkich znaków. Wypróbuj to, używając długiej kreski, którą otrzymujesz z Worda, a otrzymasz nieprawidłowe kodowanie.

Uwaga: aby udostępnić to polecenie, musisz zainstalować „klientów gridsite-klientów”.

Prosta opcja PHP:

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

Ruby, dla kompletności

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

Inne podejście php:

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

Oto moja wersja dla jesshell busy dla systemu wbudowanego, pierwotnie przyjąłem wariant 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}"
}

Oto funkcja POSIX, aby to zrobić:

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"
}

Przykład:

value=$(encodeURIComponent "$2")

Źródło

Oto konwersja jednowierszowa przy użyciu Lua, podobna do odpowiedzi blueyed, z wyjątkiem wszystkich niezarezerwowanych znaków RFC 3986 niezakodowanych (jak ta odpowiedź ):

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

Ponadto może być konieczne upewnienie się, że znaki nowego wiersza w ciągu są konwertowane z LF na CRLF, w którym to przypadku można wstawić gsub("\r?\n", "\r\n")łańcuch przed kodowaniem procentowym.

Oto wariant, który w niestandardowym stylu application / x-www-form-urlencoded wykonuje normalizację nowej linii, a także koduje spacje jako „+” zamiast „% 20” (które prawdopodobnie można by dodać do Fragment kodu Perla przy użyciu podobnej techniki).

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

Po zainstalowaniu php używam w ten sposób:

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

To jest wersja ksh odpowiedzi orwellophile zawierającej funkcje rawurlencode i rawurldecode (link: Jak urlencode dane dla polecenia curl? ). Nie mam wystarczającej liczby przedstawicieli, aby opublikować komentarz, stąd nowy 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++

Co lepiej parsowałoby adresy URL niż javascript?

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

Poniższe informacje oparte są na odpowiedzi Orwellophila, ale rozwiązują wielobajtowy błąd wymieniony w komentarzach, ustawiając LC_ALL = C (lewę z vte.sh). Napisałem to w formie funkcji odpowiedniej PROMPT_COMMAND, ponieważ właśnie tak go używam.

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}"
}