Obtenir que curl émette un code d'état HTTP ?

Une façon plus spécifique d'imprimer juste le code d'état HTTP est quelque chose du genre :

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

Beaucoup plus facile à utiliser dans les scripts, car il ne nécessite aucune analyse :-)

Le paramètre -I pourrait être ajouté pour améliorer les performances de la charge de réponse. Ce paramètre demande simplement le statut/en-têtes de la réponse, sans corps de réponse de téléchargement.

Note: %{http_code} retourne sur la première ligne de la charge utile HTTP

c'est-à-dire :

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

Cela devrait fonctionner pour vous si le serveur web est capable de répondre aux requêtes HEAD (cela n'exécutera pas un GET) :

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

En complément, pour permettre à cURL de suivre les redirections (3xx statuts) ajoutez -L.

Si vous voulez voir l'en-tête ainsi que le résultat, vous pouvez utiliser l'option verbeuse :

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

Le statut apparaîtra dans l'en-tête. Par exemple :

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

Vous pouvez imprimer le code de statut, en plus de tous les en-têtes, en faisant ce qui suit :

curl -i http://example.org

L'avantage de -i est qu'il fonctionne également avec -X POST.

Si vous voulez capturer le code d'état HTTP dans une variable, mais rediriger quand même le contenu vers STDOUT, vous devez créer deux STDOUT. Vous pouvez le faire avec substitution de processus >() et substitution de commande $() .

Tout d'abord, créez un descripteur de fichier 3 pour votre processus actuel’ STDOUT avec exec 3>&1. Ensuite, utilisez l'option -o de curl pour rediriger le contenu de la réponse vers un fifo temporaire en utilisant la substitution de commande, et ensuite, dans le cadre de cette substitution de commande, redirigez la sortie vers le descripteur de fichier 3 de votre processus actuel STDOUT avec -o >(cat >&3).

Mettre tout cela ensemble dans bash 3.2.57(1)-release (standard pour 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')

Notez que cela ne fonctionne pas dans /bin/sh comme [ SamK l'a noté dans les commentaires ci-dessous ]&3.

Redéfinir la sortie de la boucle :

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

Peut être utilisé avec tout type de demande.

Code de statut ONLY

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

Tous les crédits sont attribués à ce GIST

Il s'agit d'une douloureuse limitation curl --fail. De man curl :

-f, –fail (HTTP) Fail silencieusement (pas de sortie du tout) sur les erreurs du serveur

Mais il n'y a aucun moyen d'obtenir à la fois le code de retour non nul ET le corps de réponse dans stdout. Basé sur la réponse de pvandenberk et cet autre truc très utile appris sur SO , voici un contournement :

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
}

Cette fonction se comporte exactement comme curl, mais retournera 127 (un code de retour non utilisé par curl) en cas de code HTTP dans la plage [400, 600[.

Cela enverra une demande à l'url, n'obtiendra que la première ligne de la réponse, la divisera en blocs et sélectionnera la seconde.

Il contient le code de réponse

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

Pour une demande POST, les éléments suivants ont fonctionné :

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

Utilisez la commande cURL suivante et mettez la en pipe pour grep comme ceci :

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

Voici ce que fait chaque drapeau :

• -I : Afficher uniquement les en-têtes de réponse
• -s : Silencieux - Ne montre pas la barre de progression
• -L : Suivre les en-têtes Location: Voici un lien vers codes d'état HTTP .

Exécuter à partir de la ligne de commande. Cette boucle s'exécute en mode silencieux, suit toutes les redirections, récupère les en-têtes HTTP. grep imprimera le code d'état HTTP sur la sortie standard.

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

Cela renvoie les informations suivantes :

1. données de réponse, si des données sont renvoyées par l'API comme une erreur
2. code de statut

Voici une commande curl qui utilise GET et qui renvoie le code HTTP.

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

N'oubliez pas que l'approche ci-dessous utilise HEAD, qui est plus rapide mais qui peut ne pas fonctionner correctement avec certains serveurs HTTP moins compatibles avec le web.

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

Un exemple d'utilisation des codes de réponse. Je l'utilise pour retélécharger les bases de données Géolite uniquement si elles ont changé (-z) et aussi en suivant les redirections (-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

L'OP veut connaître le code de statut. J'utilise donc d'abord curl pour afficher le code d'état et la taille du fichier, puis j'éteins le verbe et je dirige le fichier vers l'endroit et le nom que je veux :

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

Puis j'attends la fin de curl

wait ${!}

avant d'exécuter la commande suivante. Ce qui précède, lorsqu'il est utilisé dans un script de plusieurs commandes comme ci-dessus, donne une réponse agréable comme :

http : 200 42824

http : 200 34728

http : 200 35452

Veuillez noter que -o dans curl doit être suivi par le chemin complet du fichier + le nom du fichier. Cela vous permet donc d'enregistrer les fichiers dans une structure de nom raisonnable lorsque vous les d/l avec curl. Notez également que -s et -S utilisés ensemble réduisent la sortie au silence mais présentent des erreurs. Notez également que -R essaie de régler l'horodatage du fichier sur celui du fichier web.

Ma réponse est basée sur ce que @pvandenberk a suggéré à l'origine, mais en plus il sauvegarde effectivement le fichier quelque part, au lieu de simplement le diriger vers /dev/null.

Séparer le contenu de sortie vers stdout et le code d'état HTTP vers stderr :

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

Si seul le code d'état HTTP est souhaité pour stderr, --silent peut être utilisé :

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

Le flux souhaité peut alors être sélectionné en redirigeant un flux indésirable vers /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>
...

Notez que pour que la seconde redirection se comporte comme souhaité, nous devons exécuter la commande curl dans le sous-réseau.