Obtendo curl para gerar o código de status HTTP?

Estou usando curlna linha de comando no Linux para emitir solicitações HTTP. Os corpos de resposta são impressos com padrão, o que é bom, mas não consigo ver na página de manual como obter curl para imprimir o código de status HTTP a partir da resposta (404, 403, etc.). Isso é possível?

Isso deve funcionar para você se o servidor da web puder responder às solicitações HEAD (isso não será executado a GET):

curl -I http://www.example.org

Além disso, para permitir que o cURL siga os redirecionamentos (status 3xx), adicione -L.

Uma maneira mais específica de imprimir apenas o código de status HTTP é algo como:

curl -s -o /dev/null -w "%{http_code}" http://www.example.org/

Muito mais fácil de trabalhar em scripts, pois não requer análise :-)

O parâmetro -Ipode ser adicionado para melhorar o desempenho do carregamento de resposta. Este parâmetro apenas solicita status / cabeçalhos de resposta, sem o corpo da resposta do download.

Nota: %{http_code} retorna na primeira linha da carga útil HTTP

ou seja:

curl -s -o /dev/null -I -w "%{http_code}" http://www.example.org/

Se você deseja ver o cabeçalho e o resultado, pode usar a opção detalhada:

curl -v http://www.example.org
curl --verbose http://www.example.org

O status aparecerá no cabeçalho. Por exemplo

< Date: Tue, 04 Nov 2014 19:12:59 GMT
< Content-Type: application/json; charset=utf-8
< Status: 422 Unprocessable Entity

Você pode imprimir o código de status, além de todos os cabeçalhos, fazendo o seguinte:

curl -i http://example.org

O bom -ié que ele também funciona -X POST.

Se você deseja capturar o código de status HTTP em uma variável, mas ainda redirecionar o conteúdo para STDOUT, crie duas STDOUTs. Você pode fazer isso com a substituição do processo> () e a substituição do comando $ () .

Primeiro, crie um descritor de arquivo 3para o seu processo atual 'STDOUT with exec 3>&1.

Em seguida, use a -oopção curl para redirecionar o conteúdo da resposta para um fifo temporário usando substituição de comando e, dentro dessa substituição de comando, redirecione a saída de volta ao seu descritor de arquivo STDOUT do processo atual 3com -o >(cat >&3).

Juntando tudo em bash 3.2.57(1)-release(padrão para macOS):

# creates a new file descriptor 3 that redirects to 1 (STDOUT)
exec 3>&1 
# Run curl in a separate command, capturing output of -w "%{http_code}" into HTTP_STATUS
# and sending the content to this command's STDOUT with -o >(cat >&3)
HTTP_STATUS=$(curl -w "%{http_code}" -o >(cat >&3) 'http://example.com')

Observe que isso não funciona /bin/shcomo o SamK observou nos comentários abaixo .

Redefinir a saída de ondulação:

curl -sw '%{http_code}' http://example.org

Pode ser usado com qualquer tipo de solicitação.

SOMENTE código de status

[0]$ curl -LI http://www.example.org -o /dev/null -w '%{http_code}\n' -s
[0]$ 200

Todo o crédito a este GIST

Essa é uma curl --faillimitação dolorosa . De man curl:

-f, --fail (HTTP) falha silenciosamente (sem saída) nos erros do servidor

Mas não há como obter o código de retorno diferente de zero E o corpo da resposta no stdout.

Com base na resposta de pvandenberk e neste outro truque muito útil aprendido no SO , aqui está uma solução alternativa:

curl_with_error_code () {
    _curl_with_error_code "$@" | sed '$d'
}
_curl_with_error_code () {
    local curl_error_code http_code
    exec 17>&1
    http_code=$(curl --write-out '\n%{http_code}\n' "$@" | tee /dev/fd/17 | tail -n 1)
    curl_error_code=$?
    exec 17>&-
    if [ $curl_error_code -ne 0 ]; then
        return $curl_error_code
    fi
    if [ $http_code -ge 400 ] && [ $http_code -lt 600 ]; then
        echo "HTTP $http_code" >&2
        return 127
    fi
}

Essa função se comporta exatamente como curl, mas retornará 127 (um código de retorno não utilizado por curl) no caso de um código HTTP no intervalo [400, 600 [.

Isso enviará uma solicitação para o URL, obtenha apenas a primeira linha da resposta, divida-a em blocos e selecione a segunda.

Ele contém o código de resposta

curl -I http://example.org 2>/dev/null | head -n 1 | cut -d$' ' -f2

Para uma solicitação POST, o seguinte funcionou:

curl -w 'RESP_CODE:%{response_code}' -s -X POST --data '{"asda":"asd"}' http://example.com --header "Content-Type:application/json"|grep -o  'RESP_CODE:[1-4][0-9][0-9]'

Use o seguinte comando cURL e envie-o para grep da seguinte maneira:

$ curl -I -s -L http://example.com/v3/get_list | grep "HTTP / 1.1"

Aqui está o que cada sinalizador faz:

• -I: Mostrar apenas cabeçalhos de resposta
• -s: Silencioso - não mostrar barra de progresso
• -L: Seguir Location:cabeçalhos

Aqui está um link para os códigos de status HTTP .

Execute a partir da linha de comando. Essa onda é executada no modo silencioso, segue todos os redirecionamentos, obtém os cabeçalhos HTTP. O grep imprimirá o código de status HTTP na saída padrão.

curl -so -i /dev/null -w "%{http_code}"  http://www.any_example.com

Isso retornará as seguintes informações:

1. dados de resposta, se algum dado for retornado pela API, como erro
2. código de status

Aqui está um comando curl que está usando GETe que retorna o código HTTP.

curl -so /dev/null -w '%{response_code}' http://www.example.org

Lembre-se de que a abordagem abaixo está sendo usada HEAD, que é mais rápida, mas pode não funcionar bem com alguns servidores HTTP menos compatíveis com a Web.

 curl -I http://www.example.org

Um exemplo de como usar os códigos de resposta. Eu uso isso para baixar novamente os bancos de dados Geolite apenas se eles foram alterados ( -z) e também após redirecionamentos ( -L):

url=http://example.com/file.gz
file=$(basename $url)

response=$(curl -L -s -o $file -z $file $url -w "%{http_code}")

case "$response" in
        200) do_something ;;
        301) do_something ;;
        304) printf "Received: HTTP $response (file unchanged) ==> $url\n" ;;
        404) printf "Received: HTTP $response (file not found) ==> $url\n" ;;
          *) printf "Received: HTTP $response ==> $url\n" ;;
esac

O OP quer saber o código de status. Freqüentemente, ao baixar um arquivo, você também quer ter uma ideia do seu tamanho, então estou usando o curl primeiro para mostrar o código de status e o tamanho do arquivo e, em seguida, desative o arquivo detalhado e direto para o local e o nome que desejo:

curl -R -s -S -w  "\nhttp: %{http_code} %{size_download}\n" -o /Users/myfiles/the_local_name.html http://archive.onweb.com/the_online_name.html

Então eu espero pelo acabamento do cacho

wait ${!}

antes de executar o próximo comando. O exemplo acima, quando usado em um script de muitos comandos como o acima, fornece uma boa resposta, como:

http: 200 42824

http: 200 34728

http: 200 35452

Observe que -o in curl precisa ser seguido pelo caminho completo do arquivo + nome do arquivo. Dessa forma, você pode salvar arquivos em uma estrutura de nome sensível quando você os desativa com curvatura. Observe também que -s e -S usados ​​juntos silenciam a saída, mas mostram erros. Observe também que -R tenta definir o registro de data e hora do arquivo para o arquivo da web.

Minha resposta é baseada no que o @pvandenberk sugeriu originalmente, mas além disso, ele salva o arquivo em algum lugar, em vez de apenas direcionar para / dev / null.

Divida o conteúdo de saída stdoute o código de status HTTP para stderr:

curl http://www.example.org -o >(cat >&1) -w "%{http_code}\n" 1>&2

Se apenas o código de status HTTP for desejado para stderr, --silentpoderá ser usado:

curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}\n" 1>&2

O fluxo desejado pode ser escolhido redirecionando o indesejado para /dev/null:

$ (curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}" 1>&2) 1>/dev/null
200
$ (curl --silent http://www.example.org -o >(cat >&1) -w "%{http_code}" 1>&2) 2>/dev/null
<!doctype html>
...

Observe que, para o segundo redirecionamento se comportar conforme desejado, precisamos executar o comando curl no subshell.