O PHP cURL pode recuperar cabeçalhos de resposta E corpo em uma única solicitação?

Existe alguma maneira de obter cabeçalhos e corpo para uma solicitação cURL usando PHP? Eu achei que esta opção:

curl_setopt($ch, CURLOPT_HEADER, true);

vai retornar o corpo mais os cabeçalhos , mas preciso analisá-lo para obter o corpo. Existe alguma maneira de obter os dois de uma maneira mais utilizável (e segura)?

Observe que, para "solicitação única", evito emitir uma solicitação HEAD antes do GET / POST.

Uma solução para isso foi publicada nos comentários da documentação do PHP: http://www.php.net/manual/en/function.curl-exec.php#80442

Exemplo de código:

$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);

Aviso: Conforme observado nos comentários abaixo, isso pode não ser confiável quando usado com servidores proxy ou ao lidar com certos tipos de redirecionamentos. A resposta de @ Geoffrey pode lidar com isso de maneira mais confiável.

Muitas das outras soluções oferecidas nesse segmento não estão fazendo isso corretamente.

• A divisão \r\n\r\nnão é confiável quando CURLOPT_FOLLOWLOCATIONestá ativada ou quando o servidor responde com um código 100.
• Nem todos os servidores são compatíveis com os padrões e transmitem apenas um \npara novas linhas.
• A detecção do tamanho dos cabeçalhos CURLINFO_HEADER_SIZEtambém nem sempre é confiável, especialmente quando proxies são usados ​​ou em alguns dos mesmos cenários de redirecionamento.

O método mais correto está usando CURLOPT_HEADERFUNCTION.

Aqui está um método muito limpo de executar isso usando fechamentos PHP. Ele também converte todos os cabeçalhos em minúsculas para manipulação consistente entre servidores e versões HTTP.

Esta versão manterá cabeçalhos duplicados

Está em conformidade com RFC822 e RFC2616, por favor não sugerir edições para fazer uso das mb_funções de string, pois está incorreto!

$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);

O Curl possui uma opção integrada para isso, chamada CURLOPT_HEADERFUNCTION. O valor dessa opção deve ser o nome de uma função de retorno de chamada. A ondulação passará o cabeçalho (e apenas o cabeçalho!) Para essa função de retorno de chamada, linha por linha (para que a função seja chamada para cada linha de cabeçalho, começando na parte superior da seção do cabeçalho). Sua função de retorno de chamada pode fazer qualquer coisa com ela (e deve retornar o número de bytes da linha especificada). Aqui está um código de trabalho testado:

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); 

O acima funciona com tudo, protocolos e proxies diferentes também, e você não precisa se preocupar com o tamanho do cabeçalho ou definir muitas opções de ondulação diferentes.

PS: Para manipular as linhas de cabeçalho com um método de objeto, faça o seguinte:

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

é isso que você está procurando?

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

Basta definir opções:

• CURLOPT_HEADER, 0

• CURLOPT_RETURNTRANSFER, 1

e use curl_getinfo com CURLINFO_HTTP_CODE (ou nenhum parâmetro de opção e você terá um array associativo com todas as informações que desejar)

Mais em: http://php.net/manual/fr/function.curl-getinfo.php

Se você deseja especificamente Content-Type, há uma opção especial de cURL para recuperá-lo:

$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);

Funciona com HTTP/1.1 100 Continueantes de outros cabeçalhos.

Se você precisar trabalhar com servidores com bugs, que enviam apenas LF em vez de CRLF como quebras de linha, você pode usar preg_splito seguinte:

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);

Meu jeito é

$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 necessário, aplique um loop for e remova o limite de explosão.

Aqui está minha contribuição para o debate ... Isso retorna uma única matriz com os dados separados e os cabeçalhos listados. Isso funciona com base no fato de que CURL retornará dados de um pedaço de cabeçalho [linha em branco]

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;
    }
}

O problema com muitas respostas aqui é que "\r\n\r\n"elas podem aparecer legitimamente no corpo do html; portanto, você não pode ter certeza de que está dividindo os cabeçalhos corretamente.

Parece que a única maneira de armazenar cabeçalhos separadamente com uma chamada curl_execé usar um retorno de chamada, conforme sugerido acima em https://stackoverflow.com/a/25118032/3326494

E, para (de maneira confiável) obter apenas o corpo da solicitação, você precisará passar o valor do Content-Lengthcabeçalho para substr()um valor inicial negativo.

Caso você não possa / não use CURLOPT_HEADERFUNCTIONou outras soluções;

$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));
}

Retorne os cabeçalhos de resposta com um parâmetro de referência:

<?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 você realmente não precisa usar curl;

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

Quais saídas

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>...

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