PHP cURL può recuperare le intestazioni di risposta E il corpo in una singola richiesta?

C'è un modo per ottenere sia le intestazioni che il corpo per una richiesta cURL usando PHP? Ho scoperto che questa opzione:

curl_setopt($ch, CURLOPT_HEADER, true);

restituirà il corpo più le intestazioni , ma poi devo analizzarlo per ottenere il corpo. Esiste un modo per ottenere entrambi in un modo più utilizzabile (e sicuro)?

Si noti che per "singola richiesta" intendo evitare di emettere una richiesta HEAD prima di GET / POST.

Una soluzione a questo è stata pubblicata nei commenti sulla documentazione di PHP: http://www.php.net/manual/en/function.curl-exec.php#80442

Esempio di codice:

$ch = curl_init();
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_VERBOSE, 1);
curl_setopt($ch, CURLOPT_HEADER, 1);
// ...

$response = curl_exec($ch);

// Then, after your curl_exec call:
$header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
$header = substr($response, 0, $header_size);
$body = substr($response, $header_size);

Avviso: come indicato nei commenti seguenti, questo potrebbe non essere affidabile se utilizzato con server proxy o durante la gestione di determinati tipi di reindirizzamenti. La risposta di @ Geoffrey può gestirli in modo più affidabile.

Molte delle altre soluzioni offerte da questo thread non lo stanno facendo correttamente.

• Splitting su \r\n\r\nnon è affidabile quando CURLOPT_FOLLOWLOCATIONè acceso o quando le risponde server con un codice 100.
• Non tutti i server sono conformi agli standard e trasmettono solo \nper le nuove linee.
• Anche il rilevamento delle dimensioni delle intestazioni tramite CURLINFO_HEADER_SIZEnon è sempre affidabile, specialmente quando vengono utilizzati i proxy o in alcuni degli stessi scenari di reindirizzamento.

Il metodo più corretto sta usando CURLOPT_HEADERFUNCTION.

Ecco un metodo molto pulito per eseguire ciò utilizzando le chiusure PHP. Converte anche tutte le intestazioni in lettere minuscole per una gestione coerente tra server e versioni HTTP.

Questa versione manterrà le intestazioni duplicate

Questo è conforme a RFC822 e RFC2616, non suggerire modifiche per utilizzare le mb_funzioni di stringa, non è corretto!

$ch = curl_init();
$headers = [];
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

// this function is called by curl for each header received
curl_setopt($ch, CURLOPT_HEADERFUNCTION,
  function($curl, $header) use (&$headers)
  {
    $len = strlen($header);
    $header = explode(':', $header, 2);
    if (count($header) < 2) // ignore invalid headers
      return $len;

    $headers[strtolower(trim($header[0]))][] = trim($header[1]);

    return $len;
  }
);

$data = curl_exec($ch);
print_r($headers);

Curl ha un'opzione integrata per questo, chiamata CURLOPT_HEADERFUNCTION. Il valore di questa opzione deve essere il nome di una funzione di callback. Curl passerà l'intestazione (e solo l'intestazione!) A questa funzione di richiamata, riga per riga (quindi la funzione verrà chiamata per ogni riga di intestazione, a partire dalla parte superiore della sezione dell'intestazione). La tua funzione di callback può quindi fare qualsiasi cosa con essa (e deve restituire il numero di byte di una determinata riga). Ecco un codice di lavoro testato:

function HandleHeaderLine( $curl, $header_line ) {
    echo "<br>YEAH: ".$header_line; // or do whatever
    return strlen($header_line);
}


$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://www.google.com");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADERFUNCTION, "HandleHeaderLine");
$body = curl_exec($ch); 

Quanto sopra funziona con tutto, protocolli e proxy diversi, e non devi preoccuparti della dimensione dell'intestazione o impostare molte opzioni di arricciatura diverse.

PS: per gestire le righe di intestazione con un metodo oggetto, procedere come segue:

curl_setopt($ch, CURLOPT_HEADERFUNCTION, array(&$object, 'methodName'))

è questo che stai cercando?

curl_setopt($ch, CURLOPT_HTTPHEADER, array('Expect:'));
$response = curl_exec($ch); 
list($header, $body) = explode("\r\n\r\n", $response, 2);

Basta impostare le opzioni:

• CURLOPT_HEADER, 0

• CURLOPT_RETURNTRANSFER, 1

e usa curl_getinfo con CURLINFO_HTTP_CODE (o nessun parametro opt e avrai un array associativo con tutte le informazioni che vuoi)

Maggiori informazioni su: http://php.net/manual/fr/function.curl-getinfo.php

Se si desidera specificamente l' Content-Typeopzione, è disponibile un'opzione speciale cURL per recuperarla:

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$response = curl_exec($ch);
$content_type = curl_getinfo($ch, CURLINFO_CONTENT_TYPE);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_VERBOSE, 1);
curl_setopt($ch, CURLOPT_HEADER, 1);

$parts = explode("\r\n\r\nHTTP/", $response);
$parts = (count($parts) > 1 ? 'HTTP/' : '').array_pop($parts);
list($headers, $body) = explode("\r\n\r\n", $parts, 2);

Funziona con HTTP/1.1 100 Continueprima di altre intestazioni.

Se hai bisogno di lavorare con server buggy che inviano solo LF invece di CRLF come interruzioni di riga, puoi utilizzare preg_splitcome segue:

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_VERBOSE, 1);
curl_setopt($ch, CURLOPT_HEADER, 1);

$parts = preg_split("@\r?\n\r?\nHTTP/@u", $response);
$parts = (count($parts) > 1 ? 'HTTP/' : '').array_pop($parts);
list($headers, $body) = preg_split("@\r?\n\r?\n@u", $parts, 2);

La mia strada è

$response = curl_exec($ch);
$x = explode("\r\n\r\n", $v, 3);
$header=http_parse_headers($x[0]);
if ($header=['Response Code']==100){ //use the other "header"
    $header=http_parse_headers($x[1]);
    $body=$x[2];
}else{
    $body=$x[1];
}

Se necessario, applicare un ciclo for e rimuovere il limite di esplosione.

Ecco il mio contributo al dibattito ... Questo restituisce un singolo array con i dati separati e le intestazioni elencate. Questo funziona sulla base del fatto che CURL restituirà i dati di un pezzo di intestazione [riga vuota]

curl_setopt($ch, CURLOPT_HEADER, 1); // we need this to get headers back
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_VERBOSE, true);

// $output contains the output string
$output = curl_exec($ch);

$lines = explode("\n",$output);

$out = array();
$headers = true;

foreach ($lines as $l){
    $l = trim($l);

    if ($headers && !empty($l)){
        if (strpos($l,'HTTP') !== false){
            $p = explode(' ',$l);
            $out['Headers']['Status'] = trim($p[1]);
        } else {
            $p = explode(':',$l);
            $out['Headers'][$p[0]] = trim($p[1]);
        }
    } elseif (!empty($l)) {
        $out['Data'] = $l;
    }

    if (empty($l)){
        $headers = false;
    }
}

Il problema con molte risposte qui è che "\r\n\r\n"può apparire legittimamente nel corpo dell'html, quindi non puoi essere sicuro di dividere correttamente le intestazioni.

Sembra che l'unico modo per memorizzare le intestazioni separatamente con una chiamata curl_execsia utilizzare una richiamata come suggerito sopra in https://stackoverflow.com/a/25118032/3326494

Quindi, per ottenere (in modo affidabile) solo il corpo della richiesta, è necessario passare il valore Content-Lengthdell'intestazione substr()come valore iniziale negativo.

Nel caso in cui non sia possibile / non utilizzare CURLOPT_HEADERFUNCTIONo altre soluzioni;

$nextCheck = function($body) {
    return ($body && strpos($body, 'HTTP/') === 0);
};

[$headers, $body] = explode("\r\n\r\n", $result, 2);
if ($nextCheck($body)) {
    do {
        [$headers, $body] = explode("\r\n\r\n", $body, 2);
    } while ($nextCheck($body));
}

Restituisci le intestazioni di risposta con un parametro di riferimento:

<?php
$data=array('device_token'=>'5641c5b10751c49c07ceb4',
            'content'=>'测试测试test'
           );
$rtn=curl_to_host('POST', 'http://test.com/send_by_device_token', array(), $data, $resp_headers);
echo $rtn;
var_export($resp_headers);

function curl_to_host($method, $url, $headers, $data, &$resp_headers)
         {$ch=curl_init($url);
          curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $GLOBALS['POST_TO_HOST.LINE_TIMEOUT']?$GLOBALS['POST_TO_HOST.LINE_TIMEOUT']:5);
          curl_setopt($ch, CURLOPT_TIMEOUT, $GLOBALS['POST_TO_HOST.TOTAL_TIMEOUT']?$GLOBALS['POST_TO_HOST.TOTAL_TIMEOUT']:20);
          curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
          curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
          curl_setopt($ch, CURLOPT_HEADER, 1);

          if ($method=='POST')
             {curl_setopt($ch, CURLOPT_POST, true);
              curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data));
             }
          foreach ($headers as $k=>$v)
                  {$headers[$k]=str_replace(' ', '-', ucwords(strtolower(str_replace('_', ' ', $k)))).': '.$v;
                  }
          curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
          $rtn=curl_exec($ch);
          curl_close($ch);

          $rtn=explode("\r\n\r\nHTTP/", $rtn, 2);    //to deal with "HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK...\r\n\r\n..." header
          $rtn=(count($rtn)>1 ? 'HTTP/' : '').array_pop($rtn);
          list($str_resp_headers, $rtn)=explode("\r\n\r\n", $rtn, 2);

          $str_resp_headers=explode("\r\n", $str_resp_headers);
          array_shift($str_resp_headers);    //get rid of "HTTP/1.1 200 OK"
          $resp_headers=array();
          foreach ($str_resp_headers as $k=>$v)
                  {$v=explode(': ', $v, 2);
                   $resp_headers[$v[0]]=$v[1];
                  }

          return $rtn;
         }
?>

Se non hai davvero bisogno di usare l'arricciatura;

$body = file_get_contents('http://example.com');
var_export($http_response_header);
var_export($body);

Quali uscite

array (
  0 => 'HTTP/1.0 200 OK',
  1 => 'Accept-Ranges: bytes',
  2 => 'Cache-Control: max-age=604800',
  3 => 'Content-Type: text/html',
  4 => 'Date: Tue, 24 Feb 2015 20:37:13 GMT',
  5 => 'Etag: "359670651"',
  6 => 'Expires: Tue, 03 Mar 2015 20:37:13 GMT',
  7 => 'Last-Modified: Fri, 09 Aug 2013 23:54:35 GMT',
  8 => 'Server: ECS (cpm/F9D5)',
  9 => 'X-Cache: HIT',
  10 => 'x-ec-custom-error: 1',
  11 => 'Content-Length: 1270',
  12 => 'Connection: close',
)'<!doctype html>
<html>
<head>
    <title>Example Domain</title>...

Vedi http://php.net/manual/en/reserved.variables.httpresponseheader.php