PHP : l'extension cURL

Les sources de cette extension étant distribuées avec celles de PHP nous devons simplement ajouter l'option --with-curl lors du script configure :

./configure --prefix=/usr/local/php ... --with-curl
make
make install

Cette méthode présente l'avantage de ne pas requérir une recompilation complète de PHP et d'être indépendante (jusqu'à un certain point) du coeur de PHP. Voici comment procéder à la compilation :

cd /répertoire/des/sources/de/l/extension
phpize
./configure
make
make install

Vous devez ensuite modifier le fichier php.ini afin de disposer des fonctions cURL en chargeant l'extension à l'aide de la ligne suivante :

extension=curl.so

Assurez-vous que les chemins indiqués par la directive extension_dir sont corrects puisque PHP sera alors incapable de charger les extensions demandées auquel cas vous obtiendriez des messages d'erreur et aucune des fonctions qu'elles sont censées fournir.

Le but du jeu consiste à envoyer une requête de type HEAD vers la page indiquée et d'en obtenir le code HTTP correspondant. Bien sûr s'il n'y a aucun serveur HTTP à l'adresse et port indiqués, la fonction curl_exec échouera (à commencer lors de la résolution du nom).

Un code HTTP 200 (OK) sera attendu en réponse de notre requête pour un document existant. Cependant, afin d'être un peu moins laxiste dans cette interprétation, les redirections HTTP seront suivies (de codes 301 - Moved Permanently - et 302 - Temporary Redirect).

Outre la gestion des redirections qu'il faut suivre (CURLOPT_FOLLOWLOCATION à vrai et éventuellement leur nombre maximum : CURLOPT_MAXREDIRS), nous utiliserons donc les options de timeout (CURLOPT_TIMEOUT et CURLOPT_CONNECTTIMEOUT) pour assurer que le script nous rende, quoi qu'il arrive, rapidement la main (serveur inexistant ou temporairement indisponible, lenteur) ainsi que CURLOPT_NOBODY car le contenu de la page ne nous intéresse pas ici. Nous obtiendrons uniquement ce code d'erreur en combinant la fonction curl_getinfo à sa constante CURLINFO_HTTP_CODE que nous comparerons ensuite à 200 :

function http_check_url($url, $timeout = 10, $maxredirs = 10)
{
    $ret = FALSE;

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_NOBODY, TRUE);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);
    curl_setopt($ch, CURLOPT_MAXREDIRS, $maxredirs);
    if (strpos($url, 'https://') === 0) {
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE); // On ne vérifie que l'existence de la page
    }
    if (curl_exec($ch)) {
        $ret = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    }
    curl_close($ch);

    return ($ret == 200);
}

// Exemple d'utilisation :
define('OK', '<span style="color: green">OK</span>');
define('KO', '<span style="color: red">KO</span>');
$urls = array(
    'http://www.non-existant.fr',
    'http://www.developpez.com/',
    'http://php.developpez.com/faq/'
);
foreach ($urls as $u) {
    echo $u . ' : ' . (check_url($u) ? OK : KO) . '<br/>';
}

Nous sommes parfois amenés à vouloir récupérer le contenu d'une page distante sous la forme d'une chaîne de caractères à des fins toutes aussi diverses comme par exemple pour en extraire certaines informations, constituer un cache, etc. Cette pratique est monnaie courante avec le protocole HTTP mais puisque nous utilisons cURL est aussi valable pour d'autres, citons par exemple FTP.

L'option cURL la plus importante ici est CURLOPT_RETURNTRANSFER. En effet, si celle-ci est omise ou n'est pas fixée à une valeur vraie, le contenu du fichier distant sera directement renvoyé au navigateur de votre visiteur or nous souhaitons le traiter. Nous réutiliserons des options que nous avons déjà vues auparavant, notamment celles liées à la durée maximale d'exécution de la requête par cURL. Voyons comment implémenter une telle fonction :

function http_fetch_url($url, $timeout = 10, $userpwd = '', $maxredirs = 10)
{
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);
    curl_setopt($ch, CURLOPT_MAXREDIRS, $maxredirs);
    if ($userpwd) {
        curl_setopt($ch, CURLOPT_USERPWD, $userpwd);
    }
    $data = curl_exec($ch);
    curl_close($ch);

    return $data;
}

// Exemple d'utilisation :
if (($content = http_fetch_url('http://www.monsite.fr/zone_privee/sqldump.php', 10, 'utilisateur:mot_de_passe')) === FALSE) {
    die("Une erreur est survenue");
} else {
    echo htmlentities($content);
}

Les paramètres d'identification (login et mot de passe) peuvent directement figurer dans l'URL comme ils peuvent être spécifiés à part via l'option CURLOPT_USERPWD, introduite ci-dessus à titre informatif.

Pour utiliser la méthode POST, nous permettant ainsi d'envoyer des données conséquentes et de simuler la soumission d'un formulaire, l'une des méthodes consiste à regrouper l'ensemble de ces données sous la forme d'une chaîne encodée qui sera ensuite fournie à la session cURL via l'option CURLOPT_POSTFIELDS. Parfaitement, les informations à transmettre doivent être encodées conformément à la définition du protocole HTTP pour garantir la syntaxe de la requête, rappelons que les données doivent se présenter sous la forme suivante : param1=valeur1&param2=valeur2&...&paramN=valeurN et qu'un certain nombre de caractères spéciaux vis-à-vis du protocole HTTP doivent être encodés. En PHP 5, la fonction http_build_query permet de gérer directement tous ces aspects, en revanche, pour PHP 4 il nous faudra la réécrire (voir ci-dessous).

Voyons un exemple sans réel intérêt, dont le rôle est de retransmettre les données POST reçues par un script à destination d'une autre page :

// Pour assurer la compatibilité avec les versions PHP 4
if (!function_exists('http_build_query')) {
    function http_build_query($formdata, $numeric_prefix = NULL, $arg_separator = '', $parent_key = '') {
        $ret = array();
        if (is_array($formdata)) {
            if (empty($arg_separator)) {
                $arg_separator = ini_get('arg_separator.output');
            }
            foreach ($formdata as $k => $v) {
                if (is_int($k) && $numeric_prefix != NULL) {
                    $k = $numeric_prefix . $k;
                }
                if ($parent_key != '') {
                    $k = sprintf('%s[%s]', $parent_key, $k);
                }
                if (is_array($v)) {
                    array_push($ret, http_build_query($v, NULL, $arg_separator, $k));
                } elseif (is_object($v)) {
                    array_push($ret, http_build_query(get_object_vars($v), NULL, $arg_separator, $k));
                } else {
                    array_push($ret, urlencode($k) . '=' . urlencode($v));
                }
            }
        }
        return implode($arg_separator, $ret);
    }
}

// Faire suivre les données POST à une autre page
$ch = curl_init('http://www.monsite.fr/formulaire.html');
curl_setopt($ch, CURLOPT_POST, TRUE);
curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($_POST));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
$ret = curl_exec($ch);
if (!$ret) {
    echo curl_error($ch);
} else {
    echo $ret;
}
curl_close($ch);

L'autre méthode simplifiant quelque peu les choses est de donner à cette option non pas une chaîne de caractères mais un tableau associant le nom du paramètre à sa valeur. L'intérêt est double :

Voyons un exemple visant à simuler la validation d'un formulaire comportant un champ de type textarea (nommé description) et un de type file (photo) :

<form action="envoi_photo.php" method="post" enctype="multipart/form-data">
    Description : <textarea name="description"></textarea>
    Fichier : <input type="file" name="photo"/>
    <input type="submit" value="Envoyer"/>
</form>

// Données à envoyer
$post = array(
    // La zone de texte "description"
    'description' => "Photo n°1 de mon week-end en Bretagne.\r\nPique-nique dans la forêt de Broceliande.",
    // Le fichier à uploader sous "photo"
    'photo'       => '@' . realpath('P1010001.JPG')
);

// On effectue la requête avec cURL
$ch = curl_init('http://www.monsite.fr/envoi_photo.php');
curl_setopt($ch, CURLOPT_NOBODY, TRUE);
curl_setopt($ch, CURLOPT_POST, TRUE);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
$ret = curl_exec($ch);
if (!$ret) {
    echo curl_error($ch);
} else {
    echo 'Envoi OK !';
}
curl_close($ch);

Certaines pages requièrent parfois une authentification avant de donner accès à un contenu plus vaste. Il est alors nécessaire d'établir une première connexion pour créer une session côté serveur afin de mémoriser cette identification et de pouvoir lire par la suite l'ensemble des données du site. Pour cela nous devons faire parvenir son identifiant au serveur pour ne plus avoir à repasser par la case authentification (sur un temps limité) et consulter directement les pages qui nous intéressent par la suite.

Un serveur employant PHP (versions 4 et supérieures) propose deux méthodes indépendantes et complémentaires pour faire transiter l'identifiant de session à savoir : l'utilisation d'un cookie de session ou la réécriture des liens internes et formulaires de sorte à le transmettre à la prochaine requête.

Pour correspondre à un maximum de configuration nous utiliserons les options proposées par cURL pour recourir aux cookies et nous parserons le corps de la page à la recherche d'un tel identifiant. La première étape consiste donc à s'authentifier pour initialiser une session "valide" et de tenter de capturer cet identifiant de session, suivant la configuration du serveur distant, pour pouvoir ensuite le réexploiter lors de notre deuxième requête.

Lors de la seconde, nous renverrons cet identifiant, si nous l'avons trouvé, en méthode GET (la méthode POST le permet aussi), ce qui devrait nous donner directement accès au document que nous souhaitons consulter.

Voici une méthode de procéder propre à un serveur PHP :

define('LOGIN', 'julp');
define('PASSWORD', 'mdp');
define('AUTHENTIFICATION', 'http://localhost/curl/session/login.php');
define('PAGE_PRIVEE', 'http://localhost/curl/session/admin.php');

$sid = '';

/**
 * Première connexion : authentification
 **/
$ch = curl_init(AUTHENTIFICATION);
curl_setopt($ch, CURLOPT_POST, TRUE);
curl_setopt($ch, CURLOPT_POSTFIELDS,
    array(
        'login' => LOGIN,
        'mdp' => PASSWORD
    )
);
curl_setopt($ch, CURLOPT_COOKIEJAR, realpath('cookie.txt'));
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);
curl_setopt($ch, CURLOPT_COOKIESESSION, TRUE);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
$ret = curl_exec($ch);
if ($ret === FALSE) {
    die(curl_error());
}
curl_close($ch);
if (preg_match('/(PHPSESSID=[0-9a-z,-]{32,40})/i', $ret, $m)) {
    $sid = '?' . $m[1];
} else if (preg_match('#<input\s+type="hidden"\s+name="([^\r\n\t <>\'"\\\]+)"\s+value="([0-9a-z,-]{32,40})"\s*/?>#i', $ret, $m)) {
    $sid = '?' . $m[1] . '=' . $m[2];
}

/**
 * Deuxième partie : réutilisation de la session sur une page tierce
 **/
$ch = curl_init(PAGE_PRIVEE . $sid);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
curl_setopt($ch, CURLOPT_COOKIEFILE, realpath('cookie.txt'));
$ret = curl_exec($ch);
if ($ret === FALSE) {
    die(curl_error());
}
curl_close($ch);
echo $ret;

Pour rappel : cURL n'interprète aucun contenu renvoyé (HTML ou Javascript notamment) ainsi il peut être mis à mal par des redirections à effectuer côté client (balise meta, window.location.href, etc). Ce problème ne se pose pas lorsqu'elles sont effectuées au niveau même du protocole HTTP grâce à l'en-tête "Location:" (sous réserve d'indiquer à cURL de les suivre).

Voici une classe PHP 5 qui vous permet d'interroger facilement et rapidement des serveurs HTTP :

class HTTPQuery
{
    /**
     * Tableau : les données POST qui seront envoyées (nom du champ => valeur)
     **/
    protected $_post;

    /**
     * Tableau des options cURL définies par l'utilisateur (option => valeur)
     **/
    protected $_options;

    /**
     * La ressource cURL
     **/
    protected $_ch;

    /**
     * Constructeur
     * @param url URL à laquelle la requête sera envoyée
     * @throws Exception si l'extension cURL n'est pas active
     **/
    public function __construct($url)
    {
        if (!extension_loaded('curl')) {
            throw new Exception("L'extension curl n'est pas disponible");
        }
        $this->_ch = curl_init($url);
        $this->_options = array();
    }

    /**
     * Obtenir la valeur des options cURL avec la syntaxe $ojet->CURLOPT_X définie par l'utilisateur
     * @param nom le nom de l'option cURL
     * @return NULL si l'option n'a pas été définie sinon sa valeur
     **/
    public function __get($nom)
    {
        $resultat = NULL;
        if (defined($nom)) {
            $valeur = constant($nom);
            if (isset($this->_options[$valeur])) {
                $resultat = $this->_options[$valeur];
            }
        }
        return $resultat;
    }

    /**
     * Fixer les valeurs des options cURL avec la syntaxe $objet->CURLOPT_X = Y
     * @param nom    le nom de l'option cURL (constantes CURLOPT_*)
     * @param valeur la nouvelle valeur de l'option (écrase la précédente)
     * @throws Exception si l'option "nom" n'est pas valide (inexistante ou ne commençant pas par CURLOPT_) ou est
     *                   protégée de façon à ce que vous passiez par les méthodes déléguées à la fonctionnalité ciblée
     **/
    public function __set($nom, $valeur)
    {
        if (defined($nom) && preg_match('/^CURLOPT_(?!POSTFIELDS)/', $nom)) {
            $this->_options[constant($nom)] = $valeur;
        } else {
            throw new Exception("Option '$nom' invalide ou protégée");
        }
    }

    /**
     * Prendre connaissance de la définition d'une option cURL par l'utilisateur
     * @param nom le nom de l'option cURL
     * @return un booléen indiquant si cette option a été définie
     **/
    public function __isset($nom)
    {
        return (defined($nom) && isset($this->_options[constant($nom)]));
    }

    /**
     * Détruire la définition d'une option cURL
     * @param nom le nom de l'option cURL à détruire
     **/
    public function __unset($nom)
    {
        if (defined($nom) && isset($this->_options[constant($nom)])) {
            unset($this->_options[constant($nom)]);
        }
    }

    /**
     * Description de l'objet
     * @return une chaîne de caractères décrivant l'objet
     **/
    public function __toString()
    {
        return sprintf("%s (%s)", __CLASS__, curl_getinfo($this->_ch, CURLINFO_EFFECTIVE_URL));
    }

    /**
     * Fixer la durée maximale d'exécution de la requête
     * @param timeout cette durée exprimée en secondes
     **/
    public function setTimeout($timeout)
    {
        $timeout = intval($timeout);
        if ($timeout > 0) {
            $this->CURLOPT_TIMEOUT = $timeout;
            $this->CURLOPT_CONNECTTIMEOUT = $timeout;
        }
    }

    /**
     * Ajouter des données textuelles aux données POST à envoyer
     * @param nom_champ le nom du champ (permet d'exploiter les données côté serveur - $_POST)
     * @param valeur    les données correspondantes à envoyer
     * @return un booléen indiquant que les données ont été prises en compte
     **/
    public function addPostData($nom_champ, $valeur)
    {
        if (!isset($this->_post[$nom_champ]) && !is_array($valeur)) {
            $this->_post[$nom_champ] = $valeur;
            return TRUE;
        } else {
            return FALSE;
        }
    }

    /**
     * Ajouter un fichier aux données POST à envoyer (upload de fichiers)
     * @param nom_champ le nom du champ (permet d'exploiter le fichier à sa réception - $_FILES)
     * @param fichier   le fichier à envoyer
     * @throws Exception si le fichier indiqué est inexistant ou n'est pas un fichier régulier
     **/
    public function addPostFile($nom_champ, $fichier)
    {
        if (is_file($fichier)) {
            $this->_post[$nom_champ] = '@' . realpath($fichier);
        } else {
            throw new Exception("Le fichier '$fichier' n'existe pas ou n'est pas un fichier régulier");
        }
    }

    /**
     * Exécuter la requête
     * @param fichier_sortie, renseigné le contenu de la page distante est écrit dans le fichier indiqué
     * @return le contenu de la page distante ou alors TRUE si le paramètre fichier_sortie a été utilisé
     * @throws Exception en cas d'erreur liée à cURL ou à l'écriture du fichier
     **/
    public function doRequest($fichier_sortie = FALSE)
    {
        if ($this->_options) {
            if (function_exists('curl_setopt_array')) {
                curl_setopt_array($this->_ch, $this->_options);
            } else {
                foreach ($this->_options as $option => $valeur) {
                    curl_setopt($this->_ch, $option, $valeur);
                }
            }
        }
        if ($fichier_sortie) {
            @ $fp = fopen($fichier_sortie, 'w');
            if (!$fp) {
                throw new Exception("Impossible d'ouvrir en écriture le fichier '$fichier_sortie'");
            }
            curl_setopt($this->_ch, CURLOPT_FILE, $fp);
        } else {
            curl_setopt($this->_ch, CURLOPT_RETURNTRANSFER, TRUE);
        }
        if ($this->_post) {
            curl_setopt($this->_ch, CURLOPT_POST, TRUE);
            curl_setopt($this->_ch, CURLOPT_POSTFIELDS, $this->_post);
        }
        $ret = curl_exec($this->_ch);
        if ($fichier_sortie) {
            fclose($fp);
        }
        if ($ret === FALSE) {
            throw new Exception("Une erreur est survenue : '" . curl_error($this->_ch) . "'");
        }
        return $ret;
    }

    /**
     * Destructeur
     **/
    public function __destruct()
    {
        unset($this->_options);
        unset($this->_post);
        curl_close($this->_ch);
    }
}

Un exemple complet visant à afficher la sortie résultant de la soumission d'un formulaire distant d'upload de photos comprenant d'autres champs plus classiques, le tout avec une authentification HTTP et utilisant le protocole HTTPS pour la sécurité :

require_once('/var/www/offline/librairies/HTTPQuery.php');

try {
    $http = new HTTPQuery('https://julp:mdp@mon_serveur/admin/ajouter_photo.php');
    /* Quelques fichiers à uploader */
    $http->addPostFile('images[0]', '../images1.jpg');  // Récupérée sur le serveur distant via $_FILES['images']['name'][0]
    $http->addPostFile('images[1]', '../images2.jpg');  // Récupérée sur le serveur distant via $_FILES['images']['name'][1]
    /* Les données correspondant aux différents champs du formulaire */
    $http->addPostData('visibilite[0]', 'visiteurs');   // $_POST['visibilite'][0] : simulation d'une checkbox
    $http->addPostData('visibilite[1]', 'enregistrés'); // $_POST['visibilite'][1] : simulation d'une checkbox
    $http->addPostData('description', "Les photos de ce week-end.\r\nC'est fou ce qu'il faisait beau."); // $_POST['description'] : simulation d'une textarea
    $http->addPostData('submit', 'x');                  // $_POST['submit'] : le bouton submit
    /* Vérification du certificat présenté par le serveur */
    $http->CURLOPT_CAINFO = 'ca-root.crt';              // Obtenu sur http://www.freebsd.org/cgi/cvsweb.cgi/ports/security/ca-roots/files/
    $http->CURLOPT_SSL_VERIFYPEER = TRUE;
    /* On effectue enfin la requête */
    echo $http->doRequest();
} catch (Exception $e) {
    die($e->getMessage());
}

Il est possible d'obtenir la liste des fichiers présents dans un répertoire distant en utilisant le protocole FTP et l'option CURLOPT_FTPLISTONLY. Le résultat est une liste des noms des fichiers (et aucune autre information comme leur poids) séparés par des nouvelles lignes. Par conséquent voici une méthode pour exploiter et réutiliser ce résultat :

function curl_ftp_list($url, $timeout = 10)
{
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($ch, CURLOPT_FTPLISTONLY, TRUE);
    $ret = curl_exec($ch);
    curl_close($ch);
    if ($ret === FALSE) {
        return FALSE;
    } else {
        return preg_split('/[\r\n]+/', $ret, -1, PREG_SPLIT_NO_EMPTY);
    }
}

// Exemple d'utilisation :
$fichiers = curl_ftp_list('ftp://login:mot_de_passe@serveur/');
natsort($fichiers);
if ($fichiers === FALSE) {
    die("La connexion n'a pu être établie");
} else {
    echo '<ul>';
    foreach ($fichiers as $f) {
        if ($f != '.' and $f != '..') {
            echo '<li>' . $f . '</li>';
        }
    }
    echo '</ul>';
}

On peut cependant aller plus loin en envoyant la commande FTP LIST (via l'option CURLOPT_CUSTOMREQUEST) qui nous permettra de récupérer en plus des noms des fichiers, leurs permissions, propriétaire, taille, etc. Toutefois, ces informations étant renvoyées sous forme de texte monolithique il va nous falloir utiliser une expression régulière afin de séparer ces différentes informations :

function curl_ftp_list_bis($url, $timeout = 10)
{
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "LIST");
    $ret = curl_exec($ch);
    echo curl_error($ch);
    curl_close($ch);
    if ($ret === FALSE) {
        return FALSE;
    } else {
        $fichiers = array();
        $nbFichiers = 0;
        if (preg_match_all('/([-dl])([rwxst-]{9})[ ]+([0-9]+)[ ]+([^ ]+)[ ]+(.+)[ ]+([0-9]+)[ ]+([a-zA-Z]+[ ]+[0-9]+)[ ]+([0-9:]+)[ ]+(.*)/', $ret, $m, PREG_SET_ORDER)) {
            foreach ($m as $f) {
                $fichiers[$nbFichiers] = array();
                $fichiers[$nbFichiers]['dir']         = $f[1] == 'd';  // Répertoire ?
                $fichiers[$nbFichiers]['filename']    = $f[9];         // Nom
                $fichiers[$nbFichiers]['size']        = $f[6];         // Taille
                $fichiers[$nbFichiers]['owner']       = $f[4];         // Propriétaire
                $fichiers[$nbFichiers]['group']       = $f[5];         // Groupe
                $fichiers[$nbFichiers]['permissions'] = $f[2];         // Permissions
                $fichiers[$nbFichiers]['mtime']       = "$f[7] $f[8]"; // Date de dernière modification
                $nbFichiers++;
            }
        }
        return $fichiers;
    }
}

Le fichier à envoyer doit tout d'abord être ouvert en écriture avec la fonction fopen (mode r). Ce descripteur de fichier ainsi obtenu sera transmis à cURL par l'option CURLOPT_INFILE. Nous devons également indiquer la partie du fichier concernée via CURLOPT_INFILESIZE mais notre but étant de faire parvenir ce fichier dans son intégralité nous lui fournirons donc la taille réelle de celui-ci grâce à la fonction filesize. Enfin, nous signalons à cURL qu'il s'agit d'un upload et qu'il doit s'y préparer en positionnant l'option CURLOPT_UPLOAD à vrai :

function curl_ftp_put($url, $nom_local, $mode_ascii = FALSE, $chmod = FALSE)
{
    $ret = FALSE;

    if (is_file($nom_local)) {
        $fp = fopen($nom_local, 'r');
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_INFILE, $fp);
        curl_setopt($ch, CURLOPT_INFILESIZE, filesize($nom_local));
        curl_setopt($ch, CURLOPT_UPLOAD, TRUE);
        if ($mode_ascii) {
            curl_setopt($ch, CURLOPT_TRANSFERTEXT, TRUE);
        }
        if ($chmod) {
            $path = parse_url($url, PHP_URL_PATH);
            curl_setopt($ch, CURLOPT_POSTQUOTE, array("SITE CHMOD $chmod $path"));
        }
        $ret = curl_exec($ch);
        curl_close($ch);
        fclose($fp);
    }

    return $ret;
}

// Exemple d'utilisation :
if (!curl_ftp_put('ftp://login:mot_de_passe@serveur/mon_fichier.txt', 'mon_fichier.txt', TRUE, '0400')) {
    die("Le fichier n'a pu être uploadé sur le serveur");
}

J'ai introduit dans l'exemple ci-dessus deux options que vous serez peut être amenés à réutiliser. Tout d'abord, CURLOPT_TRANSFERTEXT qui indique que le mode de transfert à utiliser n'est pas le mode binaire (par défaut) mais le mode ascii. Le protocole FTP propose en effet deux modes qui dépendent de la nature des données à envoyer et qui lorsque le mode adéquat n'est pas employé donne souvent lieu à des corruptions de fichiers. La deuxième, CURLOPT_POSTQUOTE, permet d'exécuter après la requête une liste (sous forme de tableau) de commandes qui ici peut être employée pour fixer les permissions du fichier à l'issue de sa réception.

Sur le même principe que l'envoi, il faut en premier lieu ouvrir le fichier local qui va accueillir les données reçues en écriture. Chose que nous ferons avec la fonction fopen (mode w) et nous procurerons ensuite le descripteur de fichier ainsi obtenu à cURL par l'intermédiaire de l'option CURLOPT_FILE :

function ftp_curl_get($url, $sortie, $timeout = 10)
{
    if ($fp = fopen($sortie, 'w')) {
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_FILE, $fp);
        curl_setopt($ch, CURLOPT_TIMEOUT, $timeout);
        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
        $ret = curl_exec($ch);
        curl_close($ch);
        fclose($fp);
        return $ret;
    }
    return FALSE;
}

// Exemple d'utilisation :
if (!ftp_curl_get('ftp://utilisateur:mot_de_passe@serveur/fichier_distant', 'nom_local')) {
    die("Le fichier indiqué n'a pu être récupéré");
}