PHP
Utiliser cURL en PHP

Syntaxe

• ressource curl_init ([chaîne $ url = NULL])
• bool curl_setopt (resource $ ch, option int $, mixed $ value)
• bool curl_setopt_array (resource $ ch, tableau $ options)
• mixte curl_exec (resource $ ch)
• void curl_close (resource $ ch)

Paramètres

Utilisation de base (requêtes GET)

cURL est un outil de transfert de données avec une syntaxe URL. Il supporte HTTP, FTP, SCP et beaucoup d'autres (curl> = 7.19.4). N'oubliez pas que vous devez installer et activer l'extension cURL pour l'utiliser.

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

Demandes POST

Si vous voulez imiter l'action POST du formulaire HTML, vous pouvez utiliser 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);

Utiliser multi_curl pour créer plusieurs requêtes POST

Parfois, nous devons faire beaucoup de requêtes POST vers un ou plusieurs points de terminaison différents. Pour faire face à ce scénario, nous pouvons utiliser multi_curl .

Tout d'abord, nous créons le nombre de requêtes nécessaires exactement de la même manière que dans l'exemple simple et les mettons dans un tableau.

Nous utilisons le curl_multi_init et y ajoutons chaque handle.

Dans cet exemple, nous utilisons 2 points de terminaison différents:

//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]);
}

Ensuite, nous utilisons curl_multi_exec pour envoyer les requêtes

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

Un retour possible pour cet exemple pourrait être:

La demande de « http://www.example.com » a renvoyé «fruits» en 2 secondes.

La demande de ' http://www.example2.com ' a renvoyé 'seafood' en 5 secondes.

Création et envoi d'une requête avec une méthode personnalisée

Par défaut, PHP Curl prend en charge les requêtes GET et POST . Il est également possible d'envoyer des requêtes personnalisées, telles que DELETE , PUT ou PATCH (ou même des méthodes non standard) à l'aide du paramètre 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);

Utiliser des cookies

cURL peut conserver les cookies reçus dans les réponses pour les utiliser avec les demandes suivantes. Pour la gestion simple des cookies de session en mémoire, ceci est réalisé avec une seule ligne de code:

curl_setopt($ch, CURLOPT_COOKIEFILE, "");

Si vous devez conserver les cookies après la destruction du descripteur cURL, vous pouvez spécifier le fichier dans lequel les stocker dans:

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

Ensuite, lorsque vous souhaitez les utiliser à nouveau, transmettez-les en tant que fichier de cookie:

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

Rappelez-vous, cependant, que ces deux étapes ne sont pas nécessaires, sauf si vous devez transporter des cookies entre différentes poignées cURL. Pour la plupart des cas d'utilisation, il suffit de définir CURLOPT_COOKIEFILE sur la chaîne vide.

La gestion des cookies peut être utilisée, par exemple, pour extraire des ressources d'un site Web nécessitant une connexion. Il s'agit généralement d'une procédure en deux étapes. D'abord, POST à ​​la page de connexion.

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

La deuxième étape (après la vérification des erreurs standard) est généralement une simple requête GET. L'important est de réutiliser le handle cURL existant pour la deuxième requête. Cela garantit que les cookies de la première réponse seront automatiquement inclus dans la deuxième demande.

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

Ceci est uniquement conçu comme un exemple de gestion des cookies. Dans la vraie vie, les choses sont généralement plus compliquées. Vous devez souvent effectuer un GET initial de la page de connexion pour extraire un jeton de connexion qui doit être inclus dans votre POST. D'autres sites peuvent bloquer le client cURL en fonction de sa chaîne User-Agent, ce qui vous oblige à le modifier.

Envoi de données multidimensionnelles et de fichiers multiples avec CurlFile en une seule requête

Disons que nous avons un formulaire comme celui ci-dessous. Nous voulons envoyer les données à notre serveur Web via AJAX et de là à un script exécuté sur un serveur externe.

Nous avons donc des entrées normales, un champ multi-sélection et une zone de dépôt de fichiers où nous pouvons télécharger plusieurs fichiers.

En supposant que la requête AJAX POST a réussi, nous obtenons les données suivantes sur le site PHP:

// print_r($_POST)

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

et les fichiers devraient ressembler à ceci

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

        )

)

Jusqu'ici tout va bien. Maintenant, nous voulons envoyer ces données et fichiers au serveur externe en utilisant cURL avec la classe CurlFile

Comme cURL n'accepte qu'un tableau simple mais pas multidimensionnel, nous devons d'abord aplatir le tableau $ _POST.

Pour ce faire, vous pouvez par exemple utiliser cette fonction qui vous donne les informations suivantes:

// print_r($new_post_array)

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

L'étape suivante consiste à créer des objets CurlFile pour les fichiers téléchargés. Cela se fait par la boucle suivante:

$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 est une fonction d'assistance de la classe CurlFile et crée les objets CurlFile. Nous sauvegardons chaque objet dans le tableau $ files avec les clés nommées "upload [0]" et "upload [1]" pour nos deux fichiers.

Nous devons maintenant combiner le tableau de courrier aplati et le tableau de fichiers et l'enregistrer en tant que données $ comme ceci:

$data = $new_post_array + $files;

La dernière étape consiste à envoyer la demande 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);

Puisque $ data est désormais un tableau simple (plat), cURL envoie automatiquement cette requête POST avec le type de contenu: multipart / form-data

Dans upload.php sur le serveur externe, vous pouvez maintenant obtenir les données et les fichiers avec $ _POST et $ _FILES comme vous le feriez normalement.

Obtenir et définir des en-têtes http personnalisés dans PHP

Envoi de l'en-tête de demande

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

Lecture de l'en-tête personnalisé

print_r(apache_request_headers());

OutPut: -

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

Nous pouvons également envoyer l'en-tête en utilisant la syntaxe ci-dessous: -

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