Come posso vedere le intestazioni delle richieste fatte da curl quando invio una richiesta al server?

Voglio vedere le intestazioni delle richieste fatte da curlquando invio una richiesta al server. Come posso verificarlo?

Penso che curl -vsia il più semplice. Sputerà le intestazioni della richiesta (righe precedute da '>') senza dover scrivere in un file:

$ curl -v -I -H "Testing: Test header so you see this works" http://stackoverflow.com/
* About to connect() to stackoverflow.com port 80 (#0)
*   Trying 69.59.196.211... connected
* Connected to stackoverflow.com (69.59.196.211) port 80 (#0)
> HEAD / HTTP/1.1
> User-Agent: curl/7.16.3 (i686-pc-cygwin) libcurl/7.16.3 OpenSSL/0.9.8h zlib/1.2.3 libssh2/0.15-CVS
> Host: stackoverflow.com
> Accept: */*
> Testing: Test header so you see this works
>
< HTTP/1.0 200 OK
...

La domanda non specificava se curlsi intendesse il comando da riga di comando denominato o l'intera libreria cURL.

Il seguente codice PHP che utilizza la libreria cURL utilizza il primo parametro come metodo HTTP (ad es. "GET", "POST", "OPTIONS") e il secondo parametro come URL.

<?php
$ch = curl_init();
$f = tmpfile(); # will be automatically removed after fclose()
curl_setopt_array($ch, array(
    CURLOPT_CUSTOMREQUEST  => $argv[1],
    CURLOPT_URL            => $argv[2], 
    CURLOPT_RETURNTRANSFER => 1,
    CURLOPT_FOLLOWLOCATION => 0,
    CURLOPT_VERBOSE        => 1,
    CURLOPT_HEADER         => 0,
    CURLOPT_CONNECTTIMEOUT => 5,
    CURLOPT_TIMEOUT        => 30,
    CURLOPT_STDERR         => $f,
));
$response = curl_exec($ch);
fseek($f, 0);
echo fread($f, 32*1024); # output up to 32 KB cURL verbose log
fclose($f);
curl_close($ch);
echo $response;

Esempio di utilizzo:

php curl-test.php OPTIONS https://google.com

Si noti che i risultati sono quasi identici alla seguente riga di comando

curl -v -s -o - -X OPTIONS https://google.com

L'unico modo in cui sono riuscito a vedere le mie intestazioni in uscita (arricciatura con php) era usare le seguenti opzioni:

curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch, CURLINFO_HEADER_OUT, true);

Ottenere le informazioni di debug:

$data = curl_exec($ch);
var_dump($data);
var_dump(curl_getinfo($ch));

L' --trace-asciiopzione di arricciatura mostrerà le intestazioni della richiesta, nonché le intestazioni di risposta e il corpo della risposta.

Ad esempio, il comando

curl --trace-ascii curl.trace http://www.google.com/ 

produce un file curl.traceche inizia come segue:

== Info: About to connect() to www.google.com port 80 (#0)
== Info:   Trying 209.85.229.104... == Info: connected
== Info: Connected to www.google.com (209.85.229.104) port 80 (#0)
=> Send header, 145 bytes (0x91)
0000: GET / HTTP/1.1
0010: User-Agent: curl/7.16.3 (powerpc-apple-darwin9.0) libcurl/7.16.3
0050:  OpenSSL/0.9.7l zlib/1.2.3
006c: Host: www.google.com
0082: Accept: */*
008f: 

Ha anche ottenuto una risposta (una risposta 302, per essere precisi ma irrilevante) che è stata registrata.

Se desideri solo salvare le intestazioni di risposta , utilizza l' --dump-headeropzione:

curl -D file url
curl --dump-header file url

Se hai bisogno di maggiori informazioni sulle opzioni disponibili, usa curl --help | less(produce un paio di centinaia di righe di output ma menziona molte opzioni). Oppure trova la pagina di manuale in cui sono disponibili ulteriori spiegazioni sul significato delle opzioni.

curl --trace-ascii {nomefile} o usa un singolo trattino invece del nome del file per farlo inviare a stdout:

curl --trace-ascii - {URL}

CURLOPT_DEBUGFUNCTION se stai usando libcurl

Questo ti mostra tutto ciò che l' arricciatura invia e riceve, con alcune informazioni extra gettate dentro.

Ho provato le risposte qui e ho scoperto che la più utile e semplice non è ancora elencata come risposta, ma è:

curl -v https://example.com/path

Ciò stampa le intestazioni RICHIESTA nonché le intestazioni RESPONSE oltre ad altri utili come il certificato SSL e se una connessione TCP esistente è stata riutilizzata. il -vflag può essere combinato con altri flag, ovviamente, ad esempio per seguire i reindirizzamenti e richiedere l'autenticazione HTTP:

curl -vL --user my_username https://example.com/path

Spero che sia di aiuto.

Un comando come quello sotto mostrerà tre sezioni: intestazioni di richiesta, intestazioni di risposta e dati (separati da CRLF). Evita le informazioni tecniche e il rumore sintattico aggiunto dall'arricciatura.

curl -vs www.stackoverflow.com 2>&1 | sed '/^* /d; /bytes data]$/d; s/> //; s/< //'

Il comando produrrà il seguente output:

GET / HTTP/1.1
Host: www.stackoverflow.com
User-Agent: curl/7.54.0
Accept: */*

HTTP/1.1 301 Moved Permanently
Content-Type: text/html; charset=UTF-8
Location: https://stackoverflow.com/
Content-Length: 149
Accept-Ranges: bytes
Date: Wed, 16 Jan 2019 20:28:56 GMT
Via: 1.1 varnish
Connection: keep-alive
X-Served-By: cache-bma1622-BMA
X-Cache: MISS
X-Cache-Hits: 0
X-Timer: S1547670537.588756,VS0,VE105
Vary: Fastly-SSL
X-DNS-Prefetch-Control: off
Set-Cookie: prov=e4b211f7-ae13-dad3-9720-167742a5dff8; domain=.stackoverflow.com; expires=Fri, 01-Jan-2055 00:00:00 GMT; path=/; HttpOnly

<head><title>Document Moved</title></head>
<body><h1>Object Moved</h1>This document may be found <a HREF="https://stackoverflow.com/">here</a></body>

Descrizione:

• -vs - aggiungi le intestazioni (-v) ma rimuove la barra di avanzamento (-s)
• 2>&1 - combina stdout e stderr in singolo stdout
• sed - modifica la risposta prodotta dall'arricciatura usando i comandi seguenti
• /^* /d - rimuovi le righe che iniziano con '*' (informazioni tecniche)
• /bytes data]$/d - rimuove le righe che terminano con "dati byte]" (informazioni tecniche)
• s/> // - rimuovi il prefisso '>'
• s/< // - rimuovi il prefisso '<'

So che è un po 'tardi, ma il mio metodo preferito per farlo è netcat, dato che ottieni esattamente ciò che ti è stato curlinviato; questo può differire dalle opzioni --traceo --trace-asciiche non mostreranno correttamente i caratteri non ASCII (mostrano solo punti o devono essere decodificati).

Puoi farlo molto facilmente aprendo due finestre di terminale, nel primo tipo:

nc -l localhost 12345

Questo apre un processo di ascolto sulla porta 12345 del tuo computer locale.

Nella seconda finestra del terminale immettere il comando arricciatura, ad esempio:

curl --form 'foo=bar' localhost:12345

Nella prima finestra del terminale vedrai esattamente ciò che l'arricciatura ha inviato nella richiesta.

Ora ovviamente ncnon invierà nulla in risposta (a meno che non lo digiti in te stesso), quindi dovrai interrompere il comando curl (control-c) e ripetere il processo per ogni test.

Tuttavia, questa è un'opzione utile per il semplice debug della tua richiesta, poiché non stai coinvolgendo un round trip da nessuna parte, o producendo false richieste iterative da qualche parte fino a quando non hai capito bene; una volta che sei soddisfatto del comando, reindirizzalo semplicemente a un URL valido e sei a posto.

Puoi fare lo stesso anche per qualsiasi libreria cURL, modifica semplicemente la tua richiesta per puntare ncall'ascoltatore locale fino a quando non sei soddisfatto.

scaricare le intestazioni in un file e il payload della risposta in un altro file

curl -k -v -u user:pass  "url" --trace-ascii headers.txt >> response.txt

curl -s -v -o / dev / null -H "Testheader: test" http://www.example.com

È inoltre -Ipossibile utilizzare l' opzione se si desidera inviare una richiesta HEAD e non una richiesta GET.

Ecco il mio client http in php per fare domande post con i cookie inclusi:

function http_login_client($url, $params = "", $cookies_send = "" ){

    // Vars
    $cookies = array();
    $headers = getallheaders();

    // Perform a http post request to $ur1 using $params
    $ch = curl_init($url);
    $options = array(   CURLOPT_POST => 1,
                        CURLINFO_HEADER_OUT => true,
                        CURLOPT_POSTFIELDS => $params,
                        CURLOPT_RETURNTRANSFER => 1,
                        CURLOPT_HEADER => 1,
                        CURLOPT_COOKIE => $cookies_send,
                        CURLOPT_USERAGENT => $headers['User-Agent']
                    );

    curl_setopt_array($ch, $options);

    $response = curl_exec($ch);

/// DEBUG info echo $ response; var_dump (curl_getinfo ($ ch)); ///

    // Parse response and read cookies
    preg_match_all('/^Set-Cookie: (.*?)=(.*?);/m', $response, $matches);

    // Build an array with cookies
    foreach( $matches[1] as $index => $cookie )
        $cookies[$cookie] = $matches[2][$index];

    return $cookies;
} // end http_login_client

Puoi vederlo usando -iv

$> curl  -ivH "apikey:ad9ff3d36888957" --form  "file=@/home/mar/workspace/images/8.jpg" --form "language=eng" --form "isOverlayRequired=true" https://api.ocr.space/Parse/Image

Puoi usare WireShark o TCXDump per esaminare qualsiasi traffico di rete (anche http).

Invia una richiesta di esempio a https://http-tools.appspot.com/reflect-http-request/some-unique-id e controlla cosa contiene questa richiesta (intestazione della richiesta, corpo della richiesta, parametri della richiesta) dal corrispondente URL di ricerca https : //http-tools.appspot.com/reflect-http-request-finder/some-unique-id . Puoi usare qualsiasi stringa invece di some-unique-id, controlla https://http-tools.appspot.com per maggiori dettagli.