¿Obtener curl para generar el código de estado HTTP?

Estoy usando curlla línea de comando en Linux para emitir solicitudes HTTP. Los cuerpos de respuesta se imprimen en estándar, lo cual está bien, pero no puedo ver desde la página del manual cómo obtener curl para imprimir el código de estado HTTP de la respuesta (404, 403, etc.). es posible?

Esto debería funcionar para usted si el servidor web puede responder a las solicitudes HEAD (esto no realizará a GET):

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

Como complemento, para que cURL siga los redireccionamientos (estados 3xx) agregue -L.

Una forma más específica de imprimir solo el código de estado HTTP es algo similar a:

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

Es mucho más fácil trabajar con scripts, ya que no requiere ningún análisis :-)

El parámetro -Ipodría agregarse para mejorar el rendimiento de la carga de respuesta. Este parámetro solo solicita estado / encabezados de respuesta, sin descargar el cuerpo de respuesta.

Nota: %{http_code} regresa en la primera línea de carga HTTP

es decir:

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

Si desea ver el encabezado y el resultado, puede usar la opción detallada:

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

El estado aparecerá en el encabezado. P.ej

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

Puede imprimir el código de estado, además de todos los encabezados, haciendo lo siguiente:

curl -i http://example.org

Lo bueno de esto -ies que también funciona -X POST.

Si desea capturar el código de estado HTTP en una variable, pero aún así redirigir el contenido a STDOUT, debe crear dos STDOUT. Puede hacerlo con la sustitución de proceso> () y la sustitución de comando $ () .

Primero, cree un descriptor de archivo 3para su proceso actual 'STDOUT with exec 3>&1.

Luego, use la -oopción de curl para redirigir el contenido de la respuesta a una respuesta temporal usando la sustitución de comandos, y luego dentro de esa sustitución de comandos, redirija la salida de nuevo al descriptor de archivo STDOUT del proceso actual 3con -o >(cat >&3).

Poniendo todo junto bash 3.2.57(1)-release(estándar 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')

Tenga en cuenta que esto no funciona /bin/shcomo SamK señaló en los comentarios a continuación .

Redefinir la salida del rizo:

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

Se puede usar con cualquier tipo de solicitud.

Código de estado SOLO

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

Todo el crédito a este GIST

Esta es una curl --faillimitación dolorosa . De man curl:

-f, --fail (HTTP) Falla silenciosa (sin salida) en errores del servidor

Pero no hay forma de obtener el código de retorno distinto de cero Y el cuerpo de respuesta en stdout.

Basado en la respuesta de pvandenberk y este otro truco muy útil aprendido en SO , aquí hay una solución:

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 función se comporta exactamente como curl, pero devolverá 127 (un código de retorno no utilizado por curl) en el caso de un código HTTP en el rango [400, 600 [.

Esto enviará una solicitud a url, obtendrá solo la primera línea de la respuesta, la dividirá en bloques y seleccionará la segunda.

Contiene el código de respuesta.

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

Para una solicitud POST, funcionó lo siguiente:

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 el siguiente comando cURL y canalícelo a grep así:

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

Esto es lo que hace cada bandera:

• -I: Mostrar solo encabezados de respuesta
• -s: Silencioso - No mostrar barra de progreso
• -L: Seguir Location:encabezados

Aquí hay un enlace a los códigos de estado HTTP .

Ejecutar desde la línea de comando. Este rizo se ejecuta en modo silencioso, sigue cualquier redireccionamiento, obtiene los encabezados HTTP. grep imprimirá el código de estado HTTP a la salida estándar.

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

Esto devolverá la siguiente información:

1. datos de respuesta, si la API devuelve algún dato como error
2. código de estado

Aquí hay un comando curl que está usando GETy que devuelve el código HTTP.

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

Recuerde que está utilizando el siguiente enfoque HEAD, que es más rápido pero puede que no funcione bien con algunos servidores HTTP menos compatibles con la web.

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

Un ejemplo de cómo usar los códigos de respuesta. Lo uso para volver a descargar las bases de datos Geolite solo si han cambiado ( -z) y también siguiendo los redireccionamientos ( -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

El OP quiere saber el código de estado. A menudo, al descargar un archivo, también desea tener una idea de su tamaño, así que primero uso curl para mostrar el código de estado y el tamaño del archivo y luego apago el archivo detallado y directo al lugar y el nombre que quiero:

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

Entonces espero a que termine el rizo

wait ${!}

antes de ejecutar el siguiente comando. Lo anterior cuando se usa en un script de muchos comandos como el anterior da una buena respuesta como:

http: 200 42824

http: 200 34728

http: 200 35452

Tenga en cuenta que -o in curl debe ser seguido por la ruta completa del archivo + nombre del archivo. Esto le permite guardar archivos en una estructura de nombre sensible cuando los d / l con curl. También tenga en cuenta que -s y -S usados ​​juntos silencian la salida pero muestran errores. Tenga en cuenta también que -R intenta establecer la marca de tiempo del archivo en la del archivo web.

Mi respuesta se basa en lo que @pvandenberk sugirió originalmente, pero además en realidad guarda el archivo en algún lugar, en lugar de simplemente dirigirlo a / dev / null.

Divida el contenido de salida stdouty el código de estado HTTP para stderr:

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

Si solo se desea el código de estado HTTP para stderr, --silentpuede usarse:

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

La secuencia deseada se puede seleccionar redirigiendo una no deseada a /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>
...

Tenga en cuenta que para que la segunda redirección se comporte como lo deseamos, necesitamos ejecutar el comando curl en subshell.