Isso deve funcionar para você se o servidor web puder responder a solicitações HEAD (isso não executará GET ):
curl -I http://www.example.org
Como complemento, para deixar o cURL seguir redirecionamentos (3xx statuses), adicione -L.
Estou usando curl na linha de comando no Linux para emitir solicitações HTTP. Os corpos de resposta são impressos no padrão, o que é bom, mas não consigo ver na man page como obter o curl para imprimir o código de status HTTP da resposta (404, 403 etc.). Isso é possível?
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, já que não requer análise: -)
O parâmetro -I pode ser adicionado para melhorar o desempenho da carga de resposta. Esse parâmetro apenas solicita status / cabeçalhos de resposta, sem o corpo da resposta do download. (% {http_code} retorna na primeira linha da carga HTTP)
ou seja:
curl -s -o /dev/null -I -w "%{http_code}" http://www.example.org/
Se você quiser ver o cabeçalho e o resultado, use 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 de -i é que também funciona com -X POST .
Se você deseja capturar o código de status HTTP em uma variável, mas ainda redirecionar o conteúdo para STDOUT, deverá criar dois STDOUTs. Você pode fazer isso com substituir o processo > () e substituição do comando $ () .
Primeiro, crie um descritor de arquivo 3 para seu processo atual 'STDOUT com exec 3>&1 .
Em seguida, use a opção -o do curl para redirecionar o conteúdo da resposta para um fifo temporário usando a substituição de comando e, em seguida, dentro dessa substituição de comando, redirecione a saída de volta ao descritor de arquivo STDOUT do processo atual 3 with -o >(cat >&3) . / p>
Colocando tudo junto 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 em /bin/sh como SamK anotou nos comentários abaixo .
Redefina a saída de curvas:
curl -sw '%{http_code}' http://example.org
Pode ser usado com qualquer tipo de solicitação.
Isto irá enviar um pedido para url, obter apenas a primeira linha da resposta, dividir em blocos e selecionar o segundo.
Ele contém o código de resposta
curl -I http://example.org 2>/dev/null | head -n 1 | cut -d$' ' -f2
Código de status SOMENTE
[0]$ curl -LI http://www.example.org -o /dev/null -w '%{http_code}\n' -s
[0]$ 200
Todo o crédito para este GIST
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]'
Esta é uma limitação dolorosa de curl --fail . De man curl :
-f, --fail (HTTP) Fail silently (no output at all) on server errors
Mas não há como obter o código de retorno diferente de zero E o corpo da resposta no stdout.
Baseado na resposta do pvandenberk e este outro truque muito útil aprendido em 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
}
Esta função se comporta exatamente como curl , mas retornará 127 (um código de retorno não usado por curl ) no caso de um código HTTP no intervalo [400, 600 [.
curl -so -i /dev/null -w "%{http_code}" http://www.any_example.com
Isso retornará as seguintes informações:
Aqui está um comando curl que está usando GET e 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á usando HEAD , que é mais rápido, mas pode não funcionar bem com alguns servidores HTTP menos compatíveis com a Web.
curl -I http://www.example.org
Use o seguinte comando cURL e canalize-o para o grep da seguinte forma:
$ curl -I -s -L http://example.com/v3/get_list | grep "HTTP/1.1"
Veja o que cada bandeira faz:
-I : mostra apenas cabeçalhos de resposta -s : silencioso - não mostra a barra de progresso -L : siga Location: cabeçalhos Este é um link para os códigos de status HTTP .
Execute a partir da linha de comando. Esse curl é executado no modo silencioso, segue todos os redirecionamentos, obtém os cabeçalhos HTTP. grep irá imprimir o código de status HTTP para a saída padrão.
O OP quer saber o código de status. Muitas vezes, ao fazer o download de um arquivo, você também quer ter uma idéia do tamanho, então estou usando curl primeiro para mostrar o código de status e tamanho do arquivo e, em seguida, desligo o arquivo detalhado e direto para o local e nome que eu quero:
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 o acabamento da onda
wait ${!}
antes de executar o próximo comando. O acima, quando usado em um script de muitos comandos como acima, dá uma boa resposta como:
http: 200 42824
http: 200 34728
http: 200 35452
Por favor, note que -o em curl precisa ser seguido pelo caminho completo do arquivo + nome do arquivo. Isso permite que você salve arquivos em uma estrutura de nome sensível ao digitá-los com ondulação. 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 originalmente sugeriu, mas além disso, na verdade, salva o arquivo em algum lugar, em vez de simplesmente direcionar para / dev / null.
Um exemplo de como usar os códigos de resposta. Eu uso isso para baixar novamente os bancos de dados Geolite somente se eles tiverem mudado ( -z ) & também seguindo 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