PHP
Usando cURL en PHP

Sintaxis

• resource curl_init ([string $ url = NULL])
• bool curl_setopt (resource $ ch, int $ option, mixed $ value)
• bool curl_setopt_array (resource $ ch, array $ options)
• mezclado curl_exec (recurso $ ch)
• void curl_close (resource $ ch)

Parámetros

Uso básico (solicitudes GET)

cURL es una herramienta para transferir datos con sintaxis de URL. Es compatible con HTTP, FTP, SCP y muchos otros (curl> = 7.19.4). Recuerde, debe instalar y habilitar la extensión cURL para usarla.

// a little script check is the cURL extension loaded or not
if(!extension_loaded("curl")) {
    die("cURL extension not loaded! Quit Now.");
}

// Actual script start

// create a new cURL resource
// $curl is the handle of the resource
$curl = curl_init();

// set the URL and other options
curl_setopt($curl, CURLOPT_URL, "http://www.example.com");

// execute and pass the result to browser
curl_exec($curl);

// close the cURL resource
curl_close($curl);

Solicitudes POST

Si desea imitar la acción POST del formulario HTML, puede utilizar cURL.

// POST data in array
$post = [
    'a' => 'apple',
    'b' => 'banana'
];

// Create a new cURL resource with URL to POST
$ch = curl_init('http://www.example.com');

// We set parameter CURLOPT_RETURNTRANSFER to read output
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// Let's pass POST data
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);

// We execute our request, and get output in a $response variable
$response = curl_exec($ch);

// Close the connection
curl_close($ch);

Usando multi_curl para hacer múltiples solicitudes POST

A veces necesitamos hacer muchas solicitudes POST a uno o muchos puntos finales diferentes. Para lidiar con este escenario, podemos usar multi_curl .

En primer lugar, creamos cuantas solicitudes se necesitan exactamente de la misma forma que en el ejemplo simple y las colocamos en una matriz.

Usamos curl_multi_init y le agregamos cada identificador.

En este ejemplo, estamos usando 2 puntos finales diferentes:

//array of data to POST
$request_contents = array();
//array of URLs
$urls = array();
//array of cURL handles
$chs = array();

//first POST content
$request_contents[] = [
    'a' => 'apple',
    'b' => 'banana'
];
//second POST content
$request_contents[] = [
    'a' => 'fish',
    'b' => 'shrimp'
];
//set the urls
$urls[] = 'http://www.example.com';
$urls[] = 'http://www.example2.com';

//create the array of cURL handles and add to a multi_curl
$mh = curl_multi_init();
foreach ($urls as $key => $url) {
    $chs[$key] = curl_init($url);
    curl_setopt($chs[$key], CURLOPT_RETURNTRANSFER, true);
    curl_setopt($chs[$key], CURLOPT_POST, true);
    curl_setopt($chs[$key], CURLOPT_POSTFIELDS, $request_contents[$key]);

    curl_multi_add_handle($mh, $chs[$key]);
}

Luego, usamos curl_multi_exec para enviar las solicitudes

//running the requests
$running = null;
do {
  curl_multi_exec($mh, $running);
} while ($running);

//getting the responses
foreach(array_keys($chs) as $key){
    $error = curl_error($chs[$key]);
    $last_effective_URL = curl_getinfo($chs[$key], CURLINFO_EFFECTIVE_URL);
    $time = curl_getinfo($chs[$key], CURLINFO_TOTAL_TIME);
    $response = curl_multi_getcontent($chs[$key]);  // get results
    if (!empty($error)) {
      echo "The request $key return a error: $error" . "\n";
    }
    else {
      echo "The request to '$last_effective_URL' returned '$response' in $time seconds." . "\n";
    }

    curl_multi_remove_handle($mh, $chs[$key]);
}

// close current handler
curl_multi_close($mh);

Una posible devolución para este ejemplo podría ser:

La solicitud a ' http://www.example.com ' devolvió 'frutos' en 2 segundos.

La solicitud a ' http://www.example2.com ' devolvió 'mariscos' en 5 segundos.

Creando y enviando una solicitud con un método personalizado.

Por defecto, PHP Curl admite solicitudes GET y POST . También es posible enviar solicitudes personalizadas, como DELETE , PUT o PATCH (o incluso métodos no estándar) utilizando el parámetro CURLOPT_CUSTOMREQUEST .

$method = 'DELETE'; // Create a DELETE request

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
$content = curl_exec($ch);
curl_close($ch);

Uso de cookies

cURL puede mantener las cookies recibidas en las respuestas para su uso con solicitudes posteriores. Para el manejo simple de cookies de sesión en la memoria, esto se logra con una sola línea de código:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

En los casos en los que deba conservar las cookies después de que se destruya el manejador de la CURL, puede especificar el archivo para almacenarlas:

curl_setopt($ch, CURLOPT_COOKIEJAR, "/tmp/cookies.txt");

Luego, cuando desee volver a utilizarlos, páselos como archivo de cookie:

curl_setopt($ch, CURLOPT_COOKIEFILE, "/tmp/cookies.txt");

Sin embargo, recuerde que estos dos pasos no son necesarios a menos que necesite llevar cookies entre diferentes manejadores de cURL. Para la mayoría de los casos de uso, todo lo que necesita es establecer CURLOPT_COOKIEFILE en la cadena vacía.

El manejo de cookies se puede usar, por ejemplo, para recuperar recursos de un sitio web que requiere un inicio de sesión. Esto suele ser un procedimiento de dos pasos. Primero, POST a la página de inicio de sesión.

<?php

# create a cURL handle
$ch  = curl_init();

# set the URL (this could also be passed to curl_init() if desired)
curl_setopt($ch, CURLOPT_URL, "https://www.example.com/login.php");

# set the HTTP method to POST
curl_setopt($ch, CURLOPT_POST, true);

# setting this option to an empty string enables cookie handling
# but does not load cookies from a file
curl_setopt($ch, CURLOPT_COOKIEFILE, "");

# set the values to be sent
curl_setopt($ch, CURLOPT_POSTFIELDS, array(
    "username"=>"joe_bloggs",
    "password"=>"$up3r_$3cr3t",
));

# return the response body
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

# send the request
$result = curl_exec($ch);

El segundo paso (después de que se realiza la comprobación de errores estándar) suele ser una simple solicitud GET. Lo importante es reutilizar el identificador de cURL existente para la segunda solicitud. Esto asegura que las cookies de la primera respuesta se incluirán automáticamente en la segunda solicitud.

# we are not calling curl_init()

# simply change the URL
curl_setopt($ch, CURLOPT_URL, "https://www.example.com/show_me_the_foo.php");

# change the method back to GET
curl_setopt($ch, CURLOPT_HTTPGET, true);

# send the request
$result = curl_exec($ch);

# finished with cURL
curl_close($ch);

# do stuff with $result...

Esto solo pretende ser un ejemplo de manejo de cookies. En la vida real, las cosas suelen ser más complicadas. A menudo, debe realizar un GET inicial de la página de inicio de sesión para obtener un token de inicio de sesión que debe incluirse en su POST. Otros sitios pueden bloquear el cliente cURL en función de su cadena User-Agent, lo que requiere que lo modifique.

Envío de datos multidimensionales y varios archivos con CurlFile en una sola solicitud

Digamos que tenemos una forma como la de abajo. Queremos enviar los datos a nuestro servidor web a través de AJAX y desde allí a un script que se ejecuta en un servidor externo.

Así que tenemos entradas normales, un campo de selección múltiple y una zona de descarga de archivos donde podemos cargar varios archivos.

Asumiendo que la solicitud POST de AJAX fue exitosa, obtenemos los siguientes datos en el sitio PHP:

// print_r($_POST)

Array
(
    [first_name] => John
    [last_name] => Doe
    [activities] => Array
        (
            [0] => soccer
            [1] => hiking
        )
)

y los archivos deberían verse así

// print_r($_FILES)

Array
(
    [upload] => Array
        (
            [name] => Array
                (
                    [0] => my_photo.jpg
                    [1] => my_life.pdf
                )

            [type] => Array
                (
                    [0] => image/jpg
                    [1] => application/pdf
                )

            [tmp_name] => Array
                (
                    [0] => /tmp/phpW5spji
                    [1] => /tmp/phpWgnUeY
                )

            [error] => Array
                (
                    [0] => 0
                    [1] => 0
                )

            [size] => Array
                (
                    [0] => 647548
                    [1] => 643223
                )

        )

)

Hasta ahora tan bueno. Ahora queremos enviar estos datos y archivos al servidor externo usando cURL con la clase CurlFile

Como cURL solo acepta una matriz simple pero no multidimensional, primero tenemos que aplanar la matriz $ _POST.

Para hacer esto, podrías usar esta función, por ejemplo, que te da lo siguiente:

// print_r($new_post_array)

Array
(
    [first_name] => John
    [last_name] => Doe
    [activities[0]] => soccer
    [activities[1]] => hiking
)

El siguiente paso es crear objetos CurlFile para los archivos cargados. Esto se hace mediante el siguiente bucle:

$files = array();

foreach ($_FILES["upload"]["error"] as $key => $error) {
    if ($error == UPLOAD_ERR_OK) {

        $files["upload[$key]"] = curl_file_create(
            $_FILES['upload']['tmp_name'][$key],
            $_FILES['upload']['type'][$key],
            $_FILES['upload']['name'][$key]
        );
    }
}

curl_file_create es una función auxiliar de la clase CurlFile y crea los objetos CurlFile. Guardamos cada objeto en la matriz $ files con claves llamadas "upload [0]" y "upload [1]" para nuestros dos archivos.

Ahora tenemos que combinar la matriz de publicaciones aplanada y la matriz de archivos y guardarla como $ datos como este:

$data = $new_post_array + $files;

El último paso es enviar la solicitud cURL:

$ch = curl_init();

curl_setopt_array($ch, array(
    CURLOPT_POST => 1,
    CURLOPT_URL => "https://api.externalserver.com/upload.php",
    CURLOPT_RETURNTRANSFER => 1,
    CURLINFO_HEADER_OUT => 1,
    CURLOPT_POSTFIELDS => $data
));

$result = curl_exec($ch);

curl_close ($ch);

Ya que $ data ahora es una matriz simple (plana), cURL envía automáticamente esta solicitud POST con Tipo de contenido: multipart / form-data

En upload.php en el servidor externo, ahora puede obtener los datos y archivos publicados con $ _POST y $ _FILES como lo haría normalmente.

Obtén y establece encabezados http personalizados en php

Enviando el encabezado de solicitud

$uri = 'http://localhost/http.php';
$ch = curl_init($uri);
curl_setopt_array($ch, array(
    CURLOPT_HTTPHEADER  => array('X-User: admin', 'X-Authorization: 123456'),
    CURLOPT_RETURNTRANSFER  =>true,
    CURLOPT_VERBOSE     => 1
));
$out = curl_exec($ch);
curl_close($ch);
// echo response output
echo $out;

Leyendo el encabezado personalizado

print_r(apache_request_headers());

Salida: -

Array
(
    [Host] => localhost
    [Accept] => */*
    [X-User] => admin
    [X-Authorization] => 123456
    [Content-Length] => 9
    [Content-Type] => application/x-www-form-urlencoded
)

También podemos enviar el encabezado usando la siguiente sintaxis:

curl --header "X-MyHeader: 123" www.google.com