curl_share_close

[edit] Last updated: Mon, 20 May 2013

curl_setopt

(PHP 4 >= 4.0.2, PHP 5)

curl_setopt — Définit une option de transmission cURL

Description

bool curl_setopt ( resource $ch , int $option , mixed $value )

curl_setopt() définit l'option de transfert cURL option, avec la valeur value pour la requête ch.

Liste de paramètres

ch

Un gestionnaire cURL retourné par la fonction curl_init().

option

L'option CURLOPT_XXX à définir.

value

La valeur à définir pour option.

value doit être un bool pour les valeurs suivantes du paramètre option :

Option	Définissez le paramètre `value` à	Notes
`CURLOPT_AUTOREFERER`	`TRUE` pour spécifier automatiquement le champ Referer: dans les requêtes où une redirection Location: suit.
`CURLOPT_BINARYTRANSFER`	`TRUE` pour retourner les données brutes (données binaires) lorsque `CURLOPT_RETURNTRANSFER` est utilisé.	Depuis PHP 5.1.3, cette option n'a aucun effet : l'affichage brute sera toujours retourné lorsque l'option `CURLOPT_RETURNTRANSFER` est utilisé.
`CURLOPT_COOKIESESSION`	`TRUE` pour marquer ceci comme un nouveau cookie "session". Cela forcera libcurl à ignorer tous les cookies qui sont prêts à être chargés qui sont des "cookies de session" provenant des sessions antérieures. Par défaut, libcurl enregistre et charge toujours tous les cookies, indépendamment s'ils sont des cookies de session ou pas. Les cookies de session sont des cookies sans date d'expiration et existeront que pour cette "session" seulement.
`CURLOPT_CERTINFO`	`TRUE` pour sortir les informations de certification SSL vers STDERR pour les transferts sécurisés.	Disponible depuis PHP 5.3.2. Requière `CURLOPT_VERBOSE` d'être activé.
`CURLOPT_CRLF`	`TRUE` pour convertir les nouvelles lignes Unix en nouvelles lignes CRLF pendant le transfert.
`CURLOPT_DNS_USE_GLOBAL_CACHE`	`TRUE` pour utiliser un cache DNS global. Cette option n'est pas compatible avec les threads et est activée par défaut.
`CURLOPT_FAILONERROR`	`TRUE` pour que PHP traite silencieusement les codes HTTP supérieurs ou égaux à 400. Le comportement par défaut est de retourner la page normalement, en ignorant ce code.
`CURLOPT_FILETIME`	`TRUE` pour tenter de récupérer la date de modification du document distant. Vous pouvez également retrouver cette valeur en utilisant l'option `CURLINFO_FILETIME` avec curl_getinfo().
`CURLOPT_FOLLOWLOCATION`	`TRUE` pour suivre toutes les en-têtes "Location: " que le serveur envoie dans les en-têtes HTTP (notez que cette fonction est récursive et que PHP suivra toutes les en-têtes "Location: " qu'il trouvera à moins que `CURLOPT_MAXREDIRS` ne soit définie).
`CURLOPT_FORBID_REUSE`	`TRUE` pour forcer la connexion à se fermer explicitement lorsque le processus est terminé et ne sera pas mise en cache pour être réutilisée.
`CURLOPT_FRESH_CONNECT`	`TRUE` pour forcer à utiliser une nouvelle connexion au lieu de celle en cache.
`CURLOPT_FTP_USE_EPRT`	`TRUE` pour utiliser EPRT (et LPRT) lors de l'activation des téléchargements FTP. Utilisez `FALSE` pour désactiver EPRT et LPRT et ainsi, n'utiliser que PORT.
`CURLOPT_FTP_USE_EPSV`	`TRUE` pour tenter tout d'abord une commande EPSV pour les transferts FTP avant de revenir à une commande PASV. Définissez cette option à `FALSE` pour désactiver EPSV.
`CURLOPT_FTP_CREATE_MISSING_DIRS`	`TRUE` pour créer les dossiers intermédiaires lorsqu'une opération FTP est demandée sur un chemin qui n'existe pas.
`CURLOPT_FTPAPPEND`	`TRUE` pour que PHP ajoute les informations au fichier distant, plutôt que de l'écraser.
`CURLOPT_FTPASCII`	Un alias de `CURLOPT_TRANSFERTEXT`. Utilisez celui-là à la place.
`CURLOPT_FTPLISTONLY`	`TRUE` pour ne lister que les noms d'un dossier FTP.
`CURLOPT_HEADER`	`TRUE` pour inclure l'en-tête dans la valeur de retour.
`CURLINFO_HEADER_OUT`	`TRUE` pour suivre la chaîne de requête handle.	Disponible depuis PHP 5.1.3. Le préfixe `CURLINFO_` est intentionnel.
`CURLOPT_HTTPGET`	`TRUE` pour réinitialiser la méthode de requête HTTP à GET. Sachant que GET est la valeur par défaut, cela n'est uniquement nécessaire que si la méthode de requête a été changée.
`CURLOPT_HTTPPROXYTUNNEL`	`TRUE` pour effectuer un tunnel à travers un proxy HTTP.
`CURLOPT_MUTE`	`TRUE` pour que PHP soit totalement silencieux concernant toutes les fonctions cURL.	Supprimé en cURL 7.15.5 (Vous pouvez utiliser CURLOPT_RETURNTRANSFER à la place)
`CURLOPT_NETRC`	`TRUE` pour que PHP analyse votre fichier `~./netrc` et utilise votre nom de compte et mot de passe sur le site distant que vous souhaitez contacter.
`CURLOPT_NOBODY`	`TRUE` pour que le corps du transfert ne soit pas inclus dans la valeur de retour. La méthode de demande est définie à HEAD. Le fait de modifier cette option à la valeur `FALSE` ne modifie pas la méthode GET.
`CURLOPT_NOPROGRESS`	`TRUE` pour désactiver la barre de progression des transferts cURL. Note: PHP définit automatiquement cette option à `TRUE`. Ne changez cette valeur que le temps du déboguage.
`CURLOPT_NOSIGNAL`	`TRUE` pour ignorer toutes les fonctions cURL qui cause l'envoi d'un signal au processus PHP. Activée par défaut dans les SAPI multithreadés, les options d'expiration peut toujours être utilisées.	Ajouté dans cURL 7.10.
`CURLOPT_POST`	`TRUE` pour que PHP fasse un HTTP POST. Un POST est un encodage normal application/x-www-from-urlencoded, utilisé couramment par les formulaires HTML.
`CURLOPT_PUT`	`TRUE` pour que le chargement se fasse par HTTP PUT. Le fichier à charger doit être fixé avec les options `CURLOPT_INFILE` et `CURLOPT_INFILESIZE`.
`CURLOPT_RETURNTRANSFER`	`TRUE` retourne directement le transfert sous forme de chaîne de la valeur retournée par curl_exec() au lieu de l'afficher directement.
`CURLOPT_SSL_VERIFYPEER`	`FALSE` pour arrêter CURL de vérifier le certificat. Les certificats alternatifs peuvent être spécifiés avec l'option `CURLOPT_CAINFO` (ajouté dans CURL 7.9.8) ou un répertoire de certificat peut être spécifié avec l'option `CURLOPT_CAPATH`.	`TRUE` par défaut depuis cURL 7.10. Paquet installé par défaut depuis cURL 7.10.
`CURLOPT_TRANSFERTEXT`	`TRUE` pour utiliser le mode ASCII pour les transferts FTP. Pour LDAP, il récupère les données en texte plein au lieu d'HTML. Sur les systèmes Windows, STDOUT ne sera pas définie en mode binaire.
`CURLOPT_UNRESTRICTED_AUTH`	`TRUE` pour garder l'envoi du nom de l'utilisateur ainsi que le mot de passe lorsque l'on suit les chemins (en utilisant `CURLOPT_FOLLOWLOCATION`), même si le nom d'hôte change.
`CURLOPT_UPLOAD`	`TRUE` pour que PHP prépare un chargement.
`CURLOPT_VERBOSE`	`TRUE` pour afficher tous les événements. Écrit la sortie sur STDERR ou dans le fichier spécifié en utilisant `CURLOPT_STDERR`.

value doit être un integer pour les valeurs suivantes du paramètres option :

Option	Définissez le paramètre `value` à	Notes
`CURLOPT_BUFFERSIZE`	La taille du buffer à utiliser pour chaque lecture. Cependant, il n'y a aucune garantie que cette requête soit accomplie.	Ajouté en cURL 7.10.
`CURLOPT_CLOSEPOLICY`	Soit `CURLCLOSEPOLICY_LEAST_RECENTLY_USED`, soit `CURLCLOSEPOLICY_OLDEST`. Il y a trois autres constantes CURLCLOSEPOLICY_ mais CURL ne les supporte pas encore.
`CURLOPT_CONNECTTIMEOUT`	Le nombre de secondes à attendre durant la tentative de connexion. Utilisez 0 pour attendre indéfiniment.
`CURLOPT_CONNECTTIMEOUT_MS`	Le nombre de millisecondes à entendre durant la tentative de connexion. Utilisez 0 pour attendre indéfiniment. Si libcurl est construit pour utiliser le système standard de résolution de noms, cette partie de la connexion utilisera toujours la seconde résolution pour le délai d'attente maximal avec un délai d'attente maximal minimum autorisé d'une seconde.	Ajouté en cURL 7.16.2. Disponible depuis PHP 5.2.3.
`CURLOPT_DNS_CACHE_TIMEOUT`	Le temps en seconde que CURL doit conserver les entrées DNS en mémoire. Cette option est définie à 120 secondes (2 minutes) par défaut.
`CURLOPT_FTPSSLAUTH`	La méthode d'identification FTP, lorsqu'elle est activée : CURLFTPAUTH_SSL (tente SSL en premier), CURLFTPAUTH_TLS (tente TLS en premier) ou CURLFTPAUTH_DEFAULT (laisse cURL décider).	Ajouté en cURL 7.12.2.
`CURLOPT_HTTP_VERSION`	`CURL_HTTP_VERSION_NONE` (défaut, laisse cURL décider la version à utiliser), `CURL_HTTP_VERSION_1_0` (force HTTP/1.0), ou `CURL_HTTP_VERSION_1_1` (force HTTP/1.1).
`CURLOPT_HTTPAUTH`	La méthode d'identification HTTP à utiliser. Ces options sont : `CURLAUTH_BASIC`, `CURLAUTH_DIGEST`, `CURLAUTH_GSSNEGOTIATE`, `CURLAUTH_NTLM`, `CURLAUTH_ANY` et `CURLAUTH_ANYSAFE`. Vous pouvez utiliser le séparateur \| ou un opérateur pour combiner plus d'une méthode. Si vous faites cela, CURL interrogera le serveur pour voir quelles sont les méthodes supportées et prendra la meilleur. `CURLAUTH_ANY` est un alias pour CURLAUTH_BASIC \| CURLAUTH_DIGEST \| CURLAUTH_GSSNEGOTIATE \| CURLAUTH_NTLM. `CURLAUTH_ANYSAFE` est un alias pour CURLAUTH_DIGEST \| CURLAUTH_GSSNEGOTIATE \| CURLAUTH_NTLM.
`CURLOPT_INFILESIZE`	La taille attendue, en octets, du fichier lors du téléchargement d'un fichier depuis un site distant. Notez que l'utilisation de cette option n'arrêtera pas libcurl d'envoyer de plus de données, de la même façon que ce qui est envoyé dépend de l'option `CURLOPT_READFUNCTION`.
`CURLOPT_LOW_SPEED_LIMIT`	La vitesse de transfert minimale en octets par secondes en dessous de laquelle, et pendant `CURLOPT_LOW_SPEED_TIME` secondes, PHP considérera qu'elle est trop lente, et annulera le transfert.
`CURLOPT_LOW_SPEED_TIME`	Le temps en secondes, pendant lequel si le transfert reste en dessous de `CURLOPT_LOW_SPEED_LIMIT`, PHP considérera que la connexion est trop lente, et l'annulera.
`CURLOPT_MAXCONNECTS`	Le nombre maximal de connexions persistantes autorisées. Lorsque la limite est atteinte, l'option `CURLOPT_CLOSEPOLICY` est utilisé pour afficher les connexions fermées.
`CURLOPT_MAXREDIRS`	Le nombre maximal de redirections HTTP à suivre. Utilisez cette option avec l'option `CURLOPT_FOLLOWLOCATION`.
`CURLOPT_PORT`	Le numéro du port de connexion, à la place de la valeur par défaut utilisée par le protocole.
`CURLOPT_PROTOCOLS`	Champ de bits de valeurs *`CURLPROTO_`. S'il est utilisé, ce champ limite les protocoles qui peuvent être utilisés durant un transfert. Cela vous permet de limiter le nombre de protocoles utilisés par la libcurl, tout en la compilant avec un grand nombre d'entre eux. Par défaut, libcurl va accepter tous les protocoles qu'elle supporte. Voyez aussi `CURLOPT_REDIR_PROTOCOLS`*. Les options valides de protocoles sont : `CURLPROTO_HTTP`, `CURLPROTO_HTTPS`, `CURLPROTO_FTP`, `CURLPROTO_FTPS`, `CURLPROTO_SCP`, `CURLPROTO_SFTP`, `CURLPROTO_TELNET`, `CURLPROTO_LDAP`, `CURLPROTO_LDAPS`, `CURLPROTO_DICT`, `CURLPROTO_FILE`, `CURLPROTO_TFTP`, `CURLPROTO_ALL`*	Ajouté en cURL 7.19.4.
`CURLOPT_PROXYAUTH`	La méthode d'identification HTTP à utiliser pour la connexion à un proxy. Utilisez la même méthode que celle décrite dans `CURLOPT_HTTPAUTH`. Pour une identification avec un proxy, seuls `CURLAUTH_BASIC` et `CURLAUTH_NTLM` sont actuellement supportés.	Ajouté en CURL 7.10.7.
`CURLOPT_PROXYPORT`	Le numéro du port du proxy à utiliser pour la connexion. Ce numéro de port peut également être défini dans l'option `CURLOPT_PROXY`.
`CURLOPT_PROXYTYPE`	Soit `CURLPROXY_HTTP` (par défaut), soit `CURLPROXY_SOCKS5`.	Ajouté en cURL 7.10.
`CURLOPT_REDIR_PROTOCOLS`	Champ de bits de constantes *`CURLPROTO_`. S'il est utilisé, ce champ limite les protocoles que libcurl peut utiliser pour un transfert, après une redirection lorsque `CURLOPT_FOLLOWLOCATION` est actif. Cela permet de spécifier une sous-partie des protocoles compilés avec libcurl. Par défaut, libcurl va autoriser tous les protocoles, hormis FILE et SCP. C'est une différence importante avec les versions précédents la 7.19.4, qui suivaient inconditionnellement tous les protocoles supportés. Voyez aussi `CURLOPT_PROTOCOLS`** pour connaître la liste des valeurs des constantes.	Ajoutés en cURL 7.19.4.
`CURLOPT_RESUME_FROM`	L'offset, en octets, à partir duquel vous voulez commencer le transfert.
`CURLOPT_SSL_VERIFYHOST`	1 pour vérifier l'existence d'un nom commun dans le certificat SSL. 2 pour vérifier l'existence d'un nom commun et vérifier qu'il correspond avec le nom d'hôte fourni. En environnement de production, la valeur de cette option doit être conservée à 2 (valeur par défaut).	Support pour la valeur 1 supprimé en cURL 7.28.1
`CURLOPT_SSLVERSION`	La version de SSL (2 ou 3) à utiliser. Par défaut, PHP essayera de le déterminer lui-même, bien que dans certains cas, il vous faudra le faire manuellement.
`CURLOPT_TIMECONDITION`	Comment `CURLOPT_TIMEVALUE` est traité. Utilisez `CURL_TIMECOND_IFMODSINCE` pour retourner la page uniquement si elle a été modifiée depuis le temps spécifié par `CURLOPT_TIMEVALUE`. Si elle n'a pas été modifiée, un en-tête HTTP "304 Not Modified" sera retourné en supposant que `CURLOPT_HEADER` vaut `TRUE`. Utilisez `CURL_TIMECOND_IFUNMODSINCE` pour faire l'inverse. `CURL_TIMECOND_IFMODSINCE` est par défaut.
`CURLOPT_TIMEOUT`	Le temps maximum d'exécution de la fonction cURL.
`CURLOPT_TIMEOUT_MS`	Le nombre maximal de millisecondes autorisé aux fonctions cURL pour l'exécution. Si libcurl est construit pour utiliser le système standard de résolution de noms, cette partie de la connexion utilisera toujours la seconde résolution pour le délai d'attente maximal avec un délai d'attente maximal minimum autorisé d'une seconde.	Ajouté en cURL 7.16.2. Disponible depuis PHP 5.2.3.
`CURLOPT_TIMEVALUE`	Le temps en secondes depuis le 1er janvier 1970. Cette valeur sera utilisée comme spécifié dans l'option `CURLOPT_TIMECONDITION`. Par défaut, `CURL_TIMECOND_IFMODSINCE` sera utilisée.
`CURLOPT_MAX_RECV_SPEED_LARGE`	Si un téléchargement en réception excède cette vitesse (comptée en octets par seconde) sur une moyenne cumulée durant le transfert, le transfert se mettra en pause pour conserver la moyenne inférieure ou égales à la valeur de ce paramètre. Par défaut, la vitesse est illimitée.	Ajouté en cURL 7.15.5. Disponible depuis PHP 5.4.0.
`CURLOPT_MAX_SEND_SPEED_LARGE`	Si un téléchargement en émission excède cette vitesse (comptée en octets par seconde) sur une moyenne cumulée durant le transfert, le transfert se mettra en pause pour conserver la moyenne inférieure ou égales à la valeur de ce paramètre. Par défaut, la vitesse est illimitée.	Ajouté en cURL 7.15.5. Disponible depuis PHP 5.4.0.
`CURLOPT_SSH_AUTH_TYPES`	Un masque constitué d'une ou plusieurs constantes suivantes : `CURLSSH_AUTH_PUBLICKEY`, `CURLSSH_AUTH_PASSWORD`, `CURLSSH_AUTH_HOST`, `CURLSSH_AUTH_KEYBOARD`. Utilisez la constante `CURLSSH_AUTH_ANY` pour laisser libcurl en choisir une pour vous.	Ajouté en cURL 7.16.1.

value doit être une chaîne pour les valeurs suivantes du paramètres option :

Option	Définissez le paramètre `value` à	Notes
`CURLOPT_CAINFO`	Le nom d'un fichier contenant un ou plusieurs certificats pour vérifier la concordance. Cela n'a de sens que si vous l'utilisez en combinaison de l'option `CURLOPT_SSL_VERIFYPEER`.	Nécessite un chemin absolu.
`CURLOPT_CAPATH`	Un dossier qui contient les certificats. Utilisez cette option avec l'option `CURLOPT_SSL_VERIFYPEER`.
`CURLOPT_COOKIE`	Le contenu de l'en-tête "Cookie: ", à transmettre dans l'en-tête HTTP. Notez que les cookies sont séparées par des points-virgule, suivi d'un d'espace (e.g., "fruit=pomme; couleur=rouge")
`CURLOPT_COOKIEFILE`	Le nom du fichier contenant les données de cookie. Le fichier de cookie peut être au format Netscape, ou simplement des en-têtes HTTP écrits dans un fichier. Si le nom est une chaîne de caractère vide, aucun cookie n'est chargé, mais le gestionnaire est toujours actif.
`CURLOPT_COOKIEJAR`	Le nom de fichier pour y sauvegarder tous les cookies internes lorsque la connexion se ferme, par exemple après un appel à curl_close.
`CURLOPT_CUSTOMREQUEST`	Une méthode de requête qui sera utilisée à la place de "GET" ou "HEAD" lors des requêtes HTTP. Cette commande est pratique pour effectuer un "DELETE" ou une autre commande HTTP exotique. Les valeurs valides sont "GET", "POST", "CONNECT" et plus ; i.e. n'entrez pas une requête HTTP ici. Pour le moment, entrez "GET /index.html HTTP/1.0\r\n\r\n" serait incorrect. Note: N'utilisez pas cette commande sans vous assurer que le serveur l'accepte.
`CURLOPT_EGDSOCKET`	Comme `CURLOPT_RANDOM_FILE` excepté que vous passez une chaîne qui contient un nom de fichier vers le socket Entropy Gathering Daemon.
`CURLOPT_ENCODING`	Le contenu des en-têtes "Accept-Encoding: " et active le décodage de la réponse. Les encodages supportés sont "identity", "deflate" et "gzip". Si une chaîne vide "" est utilisé, un en-tête contenant tous les types d'encodage supportés est envoyé.	Ajouté en cURL 7.10.
`CURLOPT_FTPPORT`	La valeur qui sera utilisée pour récupérer l'adresse IP utilisée pour l'instruction FTP "PORT". L'instruction POST indique au serveur distant de se connecter à cette adresse IP. La chaîne peut être une adresse IP, un nom d'hôte, un nom d'interface réseau (sous UNIX), ou juste '-', pour utiliser les IP par défaut du système.
`CURLOPT_INTERFACE`	Le nom de l'interface à utiliser. Cela peut être le nom d'une interface, une adresse IP ou encore le nom de l'hôte.
`CURLOPT_KEYPASSWD`	Le mot de passé nécessaire pour utiliser la clé privée `CURLOPT_SSLKEY` ou la clé privée `CURLOPT_SSH_PRIVATE_KEYFILE`.	Added in cURL 7.16.1.
`CURLOPT_KRB4LEVEL`	Le degré de sécurité KRB4 (Kerberos 4). Chacune des valeurs (dans l'ordre du plus petit au plus grand) suivantes sont valides : "clear", "safe", "confidential", "private".. Si la chaîne passée ne correspond pas à une de ces valeurs, la valeur "private" sera définie. Positionner cette valeur à `NULL` revient à désactiver la sécurité KRB4. Actuellement, la sécurité KRB4 fonctionne uniquement avec les transaction FTP.
`CURLOPT_POSTFIELDS`	Toutes les données à passer lors d'une opération de HTTP POST. Pour envoyer un fichier, préfixez le nom du fichier avec un @ et utilisez le chemin complet. Le type de fichier peut être explicitement spécifié en faisant suivre le nom du fichier par le type au format ';type=mimetype'. Ce paramètre peut être passé sous la forme d'une chaîne encodée URL, comme 'para1=val1&para2=val2&...' ou sous la forme d'un tableau dont le nom du champ est la clé, et les données du champ la valeur. Si le paramètre `value` est un tableau, l'en-tête Content-Type sera définie à multipart/form-data. Depuis PHP 5.2.0, `value` doit être un tableau si les fichiers sont passés à cette option avec le préfixe @.
`CURLOPT_PROXY`	Le nom du proxy HTTP au tunnel qui le demande.
`CURLOPT_PROXYUSERPWD`	Un nom d'utilisateur et un mot de passe formatés sous la forme "[username]:[password]" à utiliser pour la connexion avec le proxy.
`CURLOPT_RANDOM_FILE`	Un nom de fichier à utiliser pour interroger le générateur de nombre aléatoire pour SSL.
`CURLOPT_RANGE`	La plage de valeurs à récupérer sous la forme "X-Y", où les valeurs de X ou Y peuvent être omises. Le transfert HTTP supporte aussi plusieurs intervalles, séparés par des virgules : "X-Y,N-M".
`CURLOPT_REFERER`	Le contenu de l'en-tête "Referer: " à utiliser dans une requête HTTP.
`CURLOPT_SSH_HOST_PUBLIC_KEY_MD5`	Une chaîne contenant 32 digits hexédécimaux. La chaîne doit être la somme MD5 de la clé publique de l'hôte distant, et libcurl rejètera la connexion à l'hôte tant que les sommes MD5 ne corresponderont pas. Cette option n'est valable que pour les transferts SCP et SFTP.	Ajouté en cURL 7.17.1.
`CURLOPT_SSH_PUBLIC_KEYFILE`	Le nom du fichier pour la clé publique. Si non utilisé, libcurl utilisera pas défaut $HOME/.ssh/id_dsa.pub si la variable d'environnement $HOME est définie, et seulement "id_dsa.pub" si HOME n'est pas définie.	Ajouté en cURL 7.16.1.
`CURLOPT_SSH_PRIVATE_KEYFILE`	Le nom du fichier pour la clé privée. Si non utilisé, libcurl utilisera pas défaut $HOME/.ssh/id_dsa si la variable d'environnement $HOME est définie, et seulement "id_dsa" si HOME n'est pas définie. Si le fichier est protégé par un mot de passe, définissez le avec la constante `CURLOPT_KEYPASSWD`.	Ajouté en cURL 7.16.1.
`CURLOPT_SSL_CIPHER_LIST`	Une liste de chiffrements à utiliser avec SSL. Par exemple, RC4-SHA et TLSv1 sont des listes valides de chiffrements.
`CURLOPT_SSLCERT`	Le nom de fichier du certificat, au format PEM.
`CURLOPT_SSLCERTPASSWD`	Le mot de passe nécessaire pour utiliser le certificat `CURLOPT_SSLCERT`.
`CURLOPT_SSLCERTTYPE`	Le format de votre certificat. Les formats supportés sont "PEM" (par défaut), "DER", et "ENG".	Ajouté en cURL 7.9.3.
`CURLOPT_SSLENGINE`	L'identifiant pour le moteur de chiffrement de votre clé privée spécifié dans `CURLOPT_SSLKEY`.
`CURLOPT_SSLENGINE_DEFAULT`	L'identifiant pour le moteur de chiffrement utilisé pour les opérations de chiffrement asymétrique.
`CURLOPT_SSLKEY`	Un nom de fichier contenant votre clé privée SSL.
`CURLOPT_SSLKEYPASSWD`	Le mot de passe secret utilisé par votre clé SSL privée spécifié dans `CURLOPT_SSLKEY`. Note: Du fait que cette option contient un mot de passe sensible, souvenez-vous de conserver le script PHP qui le contient en toute sécurité.
`CURLOPT_SSLKEYTYPE`	Le type de votre clé SSL privée spécifié dans `CURLOPT_SSLKEY`. Les types de clé supportés sont "PEM" (par défaut), "DER", et "ENG".
`CURLOPT_URL`	L'URL à récupérer. Vous pouvez aussi choisir cette valeur lors de l'appel à curl_init().
`CURLOPT_USERAGENT`	Le contenu de l'en-tête "User-Agent: " à utiliser dans une requête HTTP.
`CURLOPT_USERPWD`	Un nom d'utilisateur et un mot de passe formatés sous la forme "[username]:[password]" à utiliser pour la connexion.

value doit être un tableau pour les valeurs suivantes du paramètres option :

Option	Définissez le paramètre `value` à	Notes
`CURLOPT_HTTP200ALIASES`	Un tableau de réponses HTTP 200 qui sera traité comme réponses valides et non comme des erreurs.	Ajouté en CURL 7.10.3.
`CURLOPT_HTTPHEADER`	Un tableau de champs d'en-têtes HTTP à définir, au format `array('Content-type: text/plain', 'Content-length: 100')`
`CURLOPT_POSTQUOTE`	Un tableau de commandes FTP à exécuter sur le serveur après que la requête FTP se soit exécutée.
`CURLOPT_QUOTE`	Un tableau de commandes FTP à exécuter sur le serveur avant la requête FTP.

value doit être une ressource (utilisant fopen(), par exemple) pour les valeurs suivantes du paramètre option :

Option	Définissez le paramètre `value` à
`CURLOPT_FILE`	Le fichier où sera écrit le transfert. Par défaut, STDOUT (la fenêtre du navigateur).
`CURLOPT_INFILE`	Le fichier lu par le transfert lors du chargement.
`CURLOPT_STDERR`	Un chemin alternatif à utiliser pour afficher les erreurs au lieu de STDERR.
`CURLOPT_WRITEHEADER`	Le fichier où sera écrit les parties d'en-tête du transfert.

value doit être le nom d'une fonction ou d'une Closure valide pour les valeurs suivantes du paramètres option :

Option	Définissez le paramètre `value` à
`CURLOPT_HEADERFUNCTION`	Une fonction de rappel acceptant deux paramètres. Le premier est la ressource cURL, le second, une chaîne de caractères avec les données d'en-têtes à écrire. Ces données d'en-têtes doivent être écrites par cette fonction de rappel. Le nombre d'octets écrit sera retourné.
`CURLOPT_PASSWDFUNCTION`	Une fonction de rappel qui prend trois paramètres. Le premier est la ressource CURL, le second, une chaîne contenant un mot de passe de prompt et le troisième, est la longueur maximale du mot de passe. Retourne une chaîne contenant le mot de passe.
`CURLOPT_PROGRESSFUNCTION`	Unea fonction de rappel qui prend trois paramètres. Le premier est la ressource cURL, le second est la ressource de description de fichier, et le troisième, est la longueur. Retourne la chaîne de caractères contenant les données.
`CURLOPT_READFUNCTION`	Une fonction de rappel qui prend trois paramètres. Le premier est une ressource cURL, le second, une ressource de flux fournie à cURL via l'option `CURLOPT_INFILE`, et le troisième, la quantité maximale de données à lire. La fonction de rappel doit retourner une chaîne dont la taille est inférieure ou égale à la quantité de données demandées, habituellement en les lisant depuis la ressource de flux passée. Elle doit retourner une chaîne vide pour signaler la fin EOF.
`CURLOPT_WRITEFUNCTION`	Une fonction de rappel qui prend deux paramètres. Le premier est la ressource CURL et le second, une chaîne contenant les données à écrire. En utilisant cette fonction de rappel, il devient de votre responsabilité d'écrire les données. Doit retourner le nombre exact d'octets écrits ou le transfert échouera avec une erreur.

Valeurs de retour

Cette fonction retourne TRUE en cas de succès ou FALSE si une erreur survient.

Historique

Version	Description
5.2.10	Ajout de `CURLOPT_PROTOCOLS` et `CURLOPT_REDIR_PROTOCOLS`.
5.1.0	Ajout de `CURLOPT_AUTOREFERER`, `CURLOPT_BINARYTRANSFER`, `CURLOPT_FTPSSLAUTH`, `CURLOPT_PROXYAUTH` et `CURLOPT_TIMECONDITION`.
5.0.0	Ajout de `CURLOPT_FTP_USE_EPRT`, `CURLOPT_NOSIGNAL`, `CURLOPT_UNRESTRICTED_AUTH`, `CURLOPT_BUFFERSIZE`, `CURLOPT_HTTPAUTH`, `CURLOPT_PROXYPORT`, `CURLOPT_PROXYTYPE`, `CURLOPT_SSLCERTTYPE` et `CURLOPT_HTTP200ALIASES`.

Exemples

Exemple #1 Initialisation d'une nouvelle session CURL et recherche d'une page Web


<?php
// Création d'une ressource cURL
$ch = curl_init();

// Définition de l'URL et autres options appropriées
curl_setopt($ch, CURLOPT_URL, "http://www.example.com/");
curl_setopt($ch, CURLOPT_HEADER, false);

// Récupération de l'URL et passage au navigateur
curl_exec($ch);

// Fermeture de la ressource cURL et libération des ressources systèmes
curl_close($ch);
?>

Exemple #2 Télécharger un fichier sur un serveur


<?php

/* http://localhost/upload.php:
print_r($_POST);
print_r($_FILES);
*/

$ch = curl_init();

$data = array('name' => 'Foo', 'file' => '@/home/user/test.png');

curl_setopt($ch, CURLOPT_URL, 'http://localhost/upload.php');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

curl_exec($ch);
?>

L'exemple ci-dessus va afficher :

Array
(
    [name] => Foo
)
Array
(
    [file] => Array
        (
            [name] => test.png
            [type] => image/png
            [tmp_name] => /tmp/phpcpjNeQ
            [error] => 0
            [size] => 279
        )

)

Notes

Note:
Le fait de passer un tableau à la constante CURLOPT_POSTFIELDS encodera les données comme multipart/form-data, tandis que le fait de passer une chaîne encodée URL encodera les données comme application/x-www-form-urlencoded.

Voir aussi

curl_setopt_array() - Fixe plusieurs options pour un transfert cURL

curl_share_close

curl_setopt_array

[edit] Last updated: Mon, 20 May 2013

add a note User Contributed Notes curl_setopt - [136 notes]

down

miloshio at gmail dot com ¶

6 months ago


Remember: 



- 'Server-side' cookies exists as information even before they were set on browser agent(HTTP COOKIE HEADER),

- javascript cookies does NOT exists as information before they were set on browser agent,



so, if you're trying to save cookies using CURLOPT_COOKIEJAR to a local file, that cookie must be server - side cookie, otherwise you are wasting time, javascript-produced cookies only exists when client browser's JS interpreter set them.

down

saidk at phirebranding dot com ¶

4 years ago


Passing in PHP's $_SESSION into your cURL call:





<?php


session_start();


$strCookie = 'PHPSESSID=' . $_COOKIE['PHPSESSID'] . '; path=/';


session_write_close();





$curl_handle = curl_init('enter_external_url_here');


curl_setopt( $curl_handle, CURLOPT_COOKIE, $strCookie );


curl_exec($curl_handle);


curl_close($curl_handle);


?>





This worked great for me.  I was calling pages from the same server and needed to keep the $_SESSION variables.  This passes them over.  If you want to test, just print_r($_SESSION);





Enjoy!

down

Tim Severien ¶

1 year ago


I've been stuck when using the CURLOPT_CONNECTTIMEOUT_MS constant. In fact, on my PHP version (5.3.1) it's not a number but rather a string. Same thing for CURLOPT_TIMEOUT_MS.



I got this error: Warning: curl_setopt() expects parameter 2 to be long, string given



If you are experiencing simular problems, you can replace the constant with the actual number or (re)define the constant.



CURLOPT_TIMEOUT_MS should be 155

CURLOPT_CONNECTTIMEOUT_MS should be 156



curl_setopt($ch, CURLOPT_CONNECTTIMEOUT_MS, 2500); // error

curl_setopt($ch, 156, 2500); // problem solved

down

shailesh4all at gmail dot com ¶

2 years ago


Hi,


Anyone who is interested in submitting their information by post to HTTPS site (e.g. payment gateway) where https page needs basic authentication before submitting the information. below code will be helpful. 





<?php


$submit_url = "https://sitename/process.php";





$curl = curl_init();





curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC ) ;


curl_setopt($curl, CURLOPT_USERPWD, "username:password");


curl_setopt($curl, CURLOPT_SSLVERSION,3);


curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);


curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2);


curl_setopt($curl, CURLOPT_HEADER, true);


curl_setopt($curl, CURLOPT_POST, true);


curl_setopt($curl, CURLOPT_POSTFIELDS, $params ); 


curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);


curl_setopt($curl, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)");


curl_setopt($curl, CURLOPT_URL, $submit_url);





$data = split("text/html", curl_exec($curl) );


$temp = split("\r\n", $data[1]) ;





$result = unserialize( $temp[2] ) ;





print_r($result);


curl_close($curl);


?>

down

xektrum at gmail dot com ¶

3 years ago


As of php 5.3 CURLOPT_PROGRESSFUNCTION its supported here's how:



<?php



function callback($download_size, $downloaded, $upload_size, $uploaded)

{

    // do your progress stuff here

}



$ch = curl_init('http://www.example.com');



// This is required to curl give us some progress

// if this is not set to false the progress function never

// gets called

curl_setopt($ch, CURLOPT_NOPROGRESS, false);



// Set up the callback

curl_setopt($ch, CURLOPT_PROGRESSFUNCTION, 'callback');



// Big buffer less progress info/callbacks

// Small buffer more progress info/callbacks

curl_setopt($ch, CURLOPT_BUFFERSIZE, 128);



$data = curl_exec($ch);



?>



Hope this help.

down

regan dot corey at gmail dot com ¶

6 months ago


I spent a couple of days trying to POST a multi-dimensional array of form fields, including a file upload, to a remote server to update a product. Here are the breakthroughs that FINALLY allowed the script to run as desired.



Firstly, the HTML form used input names like these:

<input type="text" name="product[name]" />

<input type="text" name="product[cost]" />

<input type="file" name="product[thumbnail]" />

in conjunction with two other form inputs not part of the product array

<input type="text" name="method" value="put" />

<input type="text" name="mode" />



I used several cURL options, but the only two (other than URL) that mattered were:

curl_setopt($handle, CURLOPT_POST, true);

curl_setopt($handle, CURLOPT_POSTFIELDS, $postfields);

Pretty standard so far.

Note: headers didn't need to be set, cURL automatically sets headers (like content-type: multipart/form-data; content-length...) when you pass an array into CURLOPT_POSTFIELDS.

Note: even though this is supposed to be a PUT command through an HTTP POST form, no special PUT options needed to be passed natively through cURL. Options such as

curl_setopt($handle, CURLOPT_HTTPHEADER, array('X-HTTP-Method-Override: PUT', 'Content-Length: ' . strlen($fields)));

or

curl_setopt($handle, CURLOPT_PUT, true);

or

curl_setopt($handle, CURLOPT_CUSTOMREQUEST, "PUT);

were not needed to make the code work.



The fields I wanted to pass through cURL were arranged into an array something like this:

$postfields = array("method" => $_POST["method"],

                    "mode" => $_POST["mode"],

                    "product" => array("name" => $_POST["product"], 

                                        "cost" => $_POST["product"]["cost"], 

                                        "thumbnail" => "@{$_FILES["thumbnail"]["tmp_name"]};type={$_FILES["thumbnail"]["type"]}")

                    );



-Notice how the @ precedes the temporary filename, this creates a link so PHP will upload/transfer an actual file instead of just the file name, which would happen if the @ isn't included.

-Notice how I forcefully set the mime-type of the file to upload. I was having issues where images filetypes were defaulting to octet-stream instead of image/png or image/jpeg or whatever the type of the selected image.



I then tried passing $postfields straight into curl_setopt($this->handle, CURLOPT_POSTFIELDS, $postfields); but it didn't work.

I tried using http_build_query($postfields); but that didn't work properly either.

In both cases either the file wouldn't be treated as an actual file and the form data wasn't being sent properly. The problem was HTTP's methods of transmitting arrays. While PHP and other languages can figure out how to handle arrays passed via forms, HTTP isn't quite as sofisticated. I had to rewrite the $postfields array like so:

$postfields = array("method" => $_POST["method"],

                    "mode" => $_POST["mode"],

                    "product[name]" => $_POST["product"], 

                    "product[cost]" => $_POST["product"]["cost"], 

                    "product[thumbnail]" => "@{$_FILES["thumbnail"]["tmp_name"]}");

curl_setopt($handle, CURLOPT_POSTFIELDS, $postfields);



This, without the use of http_build_query, solved all of my problems. Now the receiving host outputs both $_POST and $_FILES vars correctly.

down

qeremy [atta] gmail [dotta] com ¶

9 months ago


If you are trying to update something on your server and you need to handle this update operation by PUT;



<?php

curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");

curl_setopt($ch, CURLOPT_PUT, 1);

?>



are "useless" without;



<?php

curl_setopt($ch, CURLOPT_HTTPHEADER, array('X-HTTP-Method-Override: PUT'));

?>



Example;



Updating a book data in database identified by "id 1";



--cURL Part--

<?php

$data = http_build_query($_POST);

// or

$data = http_build_query(array(

   'name'  => 'PHP in Action',

   'price' => 10.9

));



$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, "http://api.localhost/rest/books/1");

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

// curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT"); // no need anymore

// or

// curl_setopt($ch, CURLOPT_PUT, 1); // no need anymore

curl_setopt($ch, CURLOPT_HTTPHEADER, array('X-HTTP-Method-Override: PUT'));

curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$ce = curl_exec($ch);

curl_close($ch);

print_r($ce);

?>



--API class--

<?php

public function putAction() {

    echo "putAction() -> id: ". $this->_getParam('id') ."\n";

    print_r($_POST);

    // do stuff with post data

    ...

?>



--Output--

putAction() -> id: 15

Array

(

    [name] => PHP in Action

    [price] => 10.9

)



---Keywords--

rest, restfull api, restfull put, curl put, curl customrequest put

down

adrian at foeder dot de ¶

10 months ago


if you want to do a GET request with additional body data it will become tricky not to implicitly change the request to a POST, like many notes below correctly state.

So to do the analogy of command line's



curl -XGET 'http://example.org?foo=bar' -d '<baz>some additional data</baz>'



in PHP you'll do, besides your other necessary stuff,



<?php

    curl_setopt($curlHandle, CURLOPT_CUSTOMREQUEST, 'GET');

    curl_setopt($curlHandle, CURLOPT_POSTFIELDS, '<baz>some additional data</baz>');

?>



during my experiments, every other "similar" way, like e.g. CURLOPT_HTTPGET, didn't send the additional data or fell into POST.

down

Joey Hewitt ¶

1 year ago


Note that if you put a certificate chain in a PEM file, the certificates need to be ordered so that each certificate is followed by its issuer (i.e., root last.)



Source: http://publib.boulder.ibm.com/tividd/td/ITIM/SC32-1493-00/en_US/HTML/im451_config09.htm

down

dotpointer at gmail dot com ¶

1 year ago


About CURLOPT_COOKIEJAR and CURLOPT_COOKIEFILE, and which / how to use.





- CURLOPT_COOKIEJAR is used when cURL is reading cookie data from disk.





- CURLOPT_COOKIEFILE is used when cURL is writing the cookie data to disk.





So you need to specify both (and set the same file location on both) when working with sessions for example.

down

Steve Kamerman ¶

1 year ago


If you want cURL to timeout in less than one second, you can use CURLOPT_TIMEOUT_MS, although there is a bug/"feature"  on "Unix-like systems" that causes libcurl to timeout immediately if the value is < 1000 ms with the error "cURL Error (28): Timeout was reached".  The explanation for this behavior is:



"If libcurl is built to use the standard system name resolver, that portion of the transfer will still use full-second resolution for timeouts with a minimum timeout allowed of one second."



What this means to PHP developers is "You can use this function without testing it first, because you can't tell if libcurl is using the standard system name resolver (but you can be pretty sure it is)"



The problem is that on (Li|U)nix, when libcurl uses the standard name resolver, a SIGALRM is raised during name resolution which libcurl thinks is the timeout alarm.



The solution is to disable signals using CURLOPT_NOSIGNAL.  Here's an example script that requests itself causing a 10-second delay so you can test timeouts:



<?php

if (!isset($_GET['foo'])) {

        // Client

        $ch = curl_init('http://localhost/test/test_timeout.php?foo=bar');

        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        curl_setopt($ch, CURLOPT_NOSIGNAL, 1);

        curl_setopt($ch, CURLOPT_TIMEOUT_MS, 200);

        $data = curl_exec($ch);

        $curl_errno = curl_errno($ch);

        $curl_error = curl_error($ch);

        curl_close($ch);



        if ($curl_errno > 0) {

                echo "cURL Error ($curl_errno): $curl_error\n";

        } else {

                echo "Data received: $data\n";

        }

} else {

        // Server

        sleep(10);

        echo "Done.";

}

?>

down

W at RHaworth dot net ¶

2 years ago


I had problems with the Wikimedia software and sending a POST request where the data was more than 1024 bytes long. I traced this to cURL adding: Expect: 100-continue to the headers.



I added curl_setopt($ch,CURLOPT_HTTPHEADER,array("Expect:")); and that suppresses the Expect line.

down

anderseta at gmail dot com ¶

3 years ago


If you wish to find the size of the file you are streaming and use it as your header this is how:





<?php





function write_function($curl_resource, $string)


{


    if(curl_getinfo($curl_resource, CURLINFO_SIZE_DOWNLOAD) <= 2000)


    {


        header('Expires: 0');


        header('Cache-Control: must-revalidate, post-check=0, pre-check=0');


        header('Pragma: public');


        header('Content-Description: File Transfer');


        header("Content-Transfer-Encoding: binary");


        header("Content-Type: ".curl_getinfo($curl_resource, CURLINFO_CONTENT_TYPE)."");


        header("Content-Length: ".curl_getinfo($curl_resource, CURLINFO_CONTENT_LENGTH_DOWNLOAD)."");


    }


    


    print $string;





    return mb_strlen($string, '8bit');


}





?>





1440 is the the default number of bytes curl will call the write function (BUFFERSIZE does not affect this, i actually think you can not change this value), so it means the headers are going to be set only one time.





write_function must return the exact number of bytes of the string, so you can return a value with mb_strlen.

down

eion at bigfoot dot com ¶

6 years ago


If you are trying to use CURLOPT_FOLLOWLOCATION and you get this warning:

Warning: curl_setopt() [function.curl-setopt]: CURLOPT_FOLLOWLOCATION cannot be activated when in safe_mode or an open_basedir is set...



then you will want to read http://www.php.net/ChangeLog-4.php which says "Disabled CURLOPT_FOLLOWLOCATION in curl when open_basedir or safe_mode are enabled." as of PHP 4.4.4/5.1.5.  This is due to the fact that curl is not part of PHP and doesn't know the values of open_basedir or safe_mode, so you could comprimise your webserver operating in safe_mode by redirecting (using header('Location: ...')) to "file://" urls, which curl would have gladly retrieved.



Until the curl extension is changed in PHP or curl (if it ever will) to deal with "Location:" headers, here is a far from perfect remake of the curl_exec function that I am using.



Since there's no curl_getopt function equivalent, you'll have to tweak the function to make it work for your specific use.  As it is here, it returns the body of the response and not the header.  It also doesn't deal with redirection urls with username and passwords in them.



<?php

    function curl_redir_exec($ch)

    {

        static $curl_loops = 0;

        static $curl_max_loops = 20;

        if ($curl_loops++ >= $curl_max_loops)

        {

            $curl_loops = 0;

            return FALSE;

        }

        curl_setopt($ch, CURLOPT_HEADER, true);

        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

        $data = curl_exec($ch);

        list($header, $data) = explode("\n\n", $data, 2);

        $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if ($http_code == 301 || $http_code == 302)

        {

            $matches = array();

            preg_match('/Location:(.*?)\n/', $header, $matches);

            $url = @parse_url(trim(array_pop($matches)));

            if (!$url)

            {

                //couldn't process the url to redirect to

                $curl_loops = 0;

                return $data;

            }

            $last_url = parse_url(curl_getinfo($ch, CURLINFO_EFFECTIVE_URL));

            if (!$url['scheme'])

                $url['scheme'] = $last_url['scheme'];

            if (!$url['host'])

                $url['host'] = $last_url['host'];

            if (!$url['path'])

                $url['path'] = $last_url['path'];

            $new_url = $url['scheme'] . '://' . $url['host'] . $url['path'] . ($url['query']?'?'.$url['query']:'');

            curl_setopt($ch, CURLOPT_URL, $new_url);

            debug('Redirecting to', $new_url);

            return curl_redir_exec($ch);

        } else {

            $curl_loops=0;

            return $data;

        }

    }

?>

down

webmaster () stauceni.com ¶

7 years ago


A little mistake, that took a half-day to fix it:

When specifing CURLOPT_COOKIEFILE or CURLOPT_COOKIEJAR options, don't forget to "chmod 777" that directory where cookie-file must be created.

down

yann dot corno at free dot fr ¶

10 years ago


About the CURLOPT_HTTPHEADER option, it took me some time to figure out how to format the so-called 'Array'. It fact, it is a list of strings. If Curl was already defining a header item, yours will replace it. Here is an example to change the Content Type in a POST:





<?php curl_setopt ($ch, CURLOPT_HTTPHEADER, Array("Content-Type: text/xml")); ?>





Yann

down

fil at rezox dot com ¶

12 years ago


If you want to connect to a secure server for posting info/reading info, you need to make cURL with the openSSL options. Then the sequence is nearly identical to the previous example (except http_S_://, and possibly add the useragent):





<?php


curl_setopt($ch, CURLOPT_URL,"https://example.com");


//some sites only accept your request if your browser looks legit, so send a useragent profile... 


curl_setopt ($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)");


?>

down

rmckay at webaware dot com dot au ¶

6 months ago


Please everyone, stop setting CURLOPT_SSL_VERIFYPEER to false or 0. If your PHP installation doesn't have an up-to-date CA root certificate bundle, download the one at the curl website and save it on your server:



http://curl.haxx.se/docs/caextract.html



Then set a path to it in your php.ini file, e.g. on Windows:



curl.cainfo=c:\php\cacert.pem



Turning off CURLOPT_SSL_VERIFYPEER allows man in the middle (MITM) attacks, which you don't want!

down

zsalab ¶

2 years ago


Handling redirections with curl if safe_mode or open_basedir is enabled. The function working transparent, no problem with header and returntransfer options. You can handle the max redirection with the optional second argument (the function is set the variable to zero if max redirection exceeded).


Second parameter values:


- maxredirect is null or not set: redirect maximum five time, after raise PHP warning


- maxredirect is greather then zero: no raiser error, but parameter variable set to zero


- maxredirect is less or equal zero: no follow redirections





<?php


function curl_exec_follow(/*resource*/ $ch, /*int*/ &$maxredirect = null) {


    $mr = $maxredirect === null ? 5 : intval($maxredirect);


    if (ini_get('open_basedir') == '' && ini_get('safe_mode' == 'Off')) {


        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, $mr > 0);


        curl_setopt($ch, CURLOPT_MAXREDIRS, $mr);


    } else {


        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);


        if ($mr > 0) {


            $newurl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL);





            $rch = curl_copy_handle($ch);


            curl_setopt($rch, CURLOPT_HEADER, true);


            curl_setopt($rch, CURLOPT_NOBODY, true);


            curl_setopt($rch, CURLOPT_FORBID_REUSE, false);


            curl_setopt($rch, CURLOPT_RETURNTRANSFER, true);


            do {


                curl_setopt($rch, CURLOPT_URL, $newurl);


                $header = curl_exec($rch);


                if (curl_errno($rch)) {


                    $code = 0;


                } else {


                    $code = curl_getinfo($rch, CURLINFO_HTTP_CODE);


                    if ($code == 301 || $code == 302) {


                        preg_match('/Location:(.*?)\n/', $header, $matches);


                        $newurl = trim(array_pop($matches));


                    } else {


                        $code = 0;


                    }


                }


            } while ($code && --$mr);


            curl_close($rch);


            if (!$mr) {


                if ($maxredirect === null) {


                    trigger_error('Too many redirects. When following redirects, libcurl hit the maximum amount.', E_USER_WARNING);


                } else {


                    $maxredirect = 0;


                }


                return false;


            }


            curl_setopt($ch, CURLOPT_URL, $newurl);


        }


    }


    return curl_exec($ch);


}


?>

down

S\ ¶

2 years ago


When using CURLOPT_POSTFIELDS with an array as parameter, you have to pay high attention to user input. Unvalidated user input will lead to serious security issues.



<?php



/**

 * test.php:

 */

$ch = curl_init('http://example.com');



curl_setopt($ch, CURLOPT_POST, 1);

curl_setopt($ch, CURLOPT_POSTFIELDS, array(

    'foo' => $_GET['bar']

));



curl_exec($ch);



?>



Requesting "test.php?bar=@/home/user/test.png" will send "test.png" to example.com. 

Make sure you remove the leading "@" from user input.

down

ericbianchetti at gmail dot com ¶

3 years ago


if you need to send a SOAP string that is the CURL you must use :





<?php


$ch = curl_init();


curl_setopt($ch, CURLOPT_URL, XML_POST_URL); 


curl_setopt ($ch, CURLOPT_HTTPHEADER, array('SOAPAction: ""'));    


curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); 


curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);


curl_setopt($ch, CURLOPT_POSTFIELDS, XML_PAYLOAD); 


curl_setopt($ch, CURLOPT_HEADER, 0);





$output = curl_exec($ch); 


?>





Note : Having based my snipet on Chemo demonstration (oscommerce user know who he is), XML_POST_URL and XML_PAYLOAD where defined as constant with define().





The point is : at the opposite of .xml , SOAP must send the header 'SOAPAction: ""' that can be a valid URI, an empty string (that is here) or nothing ('SOAPAction: '). The later case baing not accepted by all server, the second one indicating the target is the URI used to post the SOAP.


http://www.w3.org/TR/2000/NOTE-SOAP-20000508/#_Toc478383528

down

fnjordy at gmail dot com ¶

4 years ago


Note that CURLOPT_RETURNTRANSFER when used with CURLOPT_WRITEFUNCTION has effectively three settings: default, true, and false.



default - callbacks will be called as expected.

true - content will be returned but callback function will not be called.

false - content will be output and callback function will not be called.



Note that CURLOPT_HEADERFUNCTION callbacks are always called.

down

daniel at blacklotus dot no ¶

2 years ago


Sime sites may protect themselves from remote logins by checking which site you came from.



Then you might want to use CURLOPT_REFERER.



<?php



// $url = page to POST data

// $ref_url = tell the server which page you came from (spoofing)

// $login = true will make a clean cookie-file.

// $proxy = proxy data

// $proxystatus = do you use a proxy ? true/false



function 

curl_grab_page($url,$ref_url,$data,$login,$proxy,$proxystatus){

    if($login == 'true') {

        $fp = fopen("cookie.txt", "w");

        fclose($fp);

    }

    $ch = curl_init();

    curl_setopt($ch, CURLOPT_COOKIEJAR, "cookie.txt");

    curl_setopt($ch, CURLOPT_COOKIEFILE, "cookie.txt");

    curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)");

    curl_setopt($ch, CURLOPT_TIMEOUT, 40);

    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);

    if ($proxystatus == 'true') {

        curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, TRUE);

        curl_setopt($ch, CURLOPT_PROXY, $proxy);

    }

    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);

    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);



    curl_setopt($ch, CURLOPT_URL, $url);

    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

    curl_setopt($ch, CURLOPT_REFERER, $ref_url);



    curl_setopt($ch, CURLOPT_HEADER, TRUE);

    curl_setopt($ch, CURLOPT_USERAGENT, $_SERVER['HTTP_USER_AGENT']);

    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, TRUE);

    curl_setopt($ch, CURLOPT_POST, TRUE);

    curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

    ob_start();

    return curl_exec ($ch); // execute the curl command

    ob_end_clean();

    curl_close ($ch);

    unset($ch);

}



echo curl_grab_page("https://www.example.net/login.php", "https://www.example.net/", "username=foo&password=bar", "true",  "null", "false");



?>

down

Sylvain R ¶

3 years ago


When you are using CURLOPT_FILE to download directly into a file you must close the file handler after the curl_close() otherwise the file will be incomplete and you will not be able to use it until the end of the execution of the php process.





<?php





$fh = fopen('/tmp/foo', 'w');


$ch = curl_init('http://example.com/foo');


curl_setopt($ch, CURLOPT_FILE, $fh);


curl_exec($ch);


curl_close($ch);





# at this point your file is not complete and corrupted





fclose($fh);





# now you can use your file;





read_file('/tmp/foo');





?>

down

charles at tastik dot net ¶

5 years ago


FYI,





Anyone trying to connect to .NET with CURL to send a simple XML post, pay attention to the following. This will save you hours! There is a previous note that I saw either on this page, or somewhere else on this site that explains the correct way to specify the header option is to create an array, then reference the array from the CURLOPT. 





ie.  Do something like this:





<?php


// Req. HTTP Header Values 


 $header[] = "Content-type: text/xml";





// Target URL


 $sendTo = "http://www.example.com";





// Post Data


 $post = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<root>\n....etc, etc,";





// Create CURL Connection


 $ch = curl_init();


 curl_setopt($ch, CURLOPT_USERAGENT, 'XtraDoh xAgent');


 curl_setopt($ch, CURLOPT_URL, $sendTo);


 curl_setopt($ch, CURLOPT_TIMEOUT, 900);


 curl_setopt($ch, CURLOPT_CONNECTIONTIMEOUT, 30);


 curl_setopt($ch, CURLOPT_FAILONERROR, false);


 curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);


 curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);


 curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);


 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);


 curl_setopt($ch, CURLOPT_HTTPHEADER, $header);


 curl_setopt($ch, CURLOPT_POST, true);


 curl_setopt($ch, CURLOPT_POSTFIELDS, $post);


?>





Notice the HTTPHEADER, $header above. I have not been able to get .NET to properly read the HTTP header as specified (in this case as text/xml) when using the following:





<?php


curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type'=>'text/xml'));


?>





Although this may work when working with other PHP, IIS, or even PHP, Apache, it does not (at least in my experience) work with .NET, IIS.

down

michael sky ¶

5 years ago


if you are trying to connect to 'https://...' and after that want to work with POST data - that's the way:





<?php


$curl = curl_init();


curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, FALSE);


curl_setopt($curl, CURLOPT_HEADER, 0);


curl_setopt($curl, CURLOPT_POST, true);


curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);


curl_setopt($curl, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)");


curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);


curl_setopt($curl, CURLOPT_COOKIEFILE, "cookiefile");


curl_setopt($curl, CURLOPT_COOKIEJAR, "cookiefile"); # SAME cookiefile


curl_setopt($curl, CURLOPT_URL, "url1"); # this is where you first time connect - GET method authorization in my case, if you have POST - need to edit code a bit


$xxx = curl_exec($curl);





curl_setopt($curl, CURLOPT_URL, "url2"); # this is where you are requesting POST-method form results (working with secure connection using cookies after auth)


curl_setopt($curl, CURLOPT_POSTFIELDS, "var1=value&var2=value&var3=value&"); # form params that'll be used to get form results


$xxx = curl_exec($curl);





curl_close ($curl);


echo $xxx;


?>

down

Manasi ¶

9 days ago


CURLAUTH_ANY is not an alias for CURLAUTH_NTLM. I had to specify CURLAUTH_NTLM for a Windows authenticated URL

down

Madcat ¶

13 days ago


If you have a mixture of strings starting with @ (at character) and files in CURLOPT_POSTFIELDS you have a problem (such as posting a tweet with attached media) because curl tries to interpret anything starting with @ as a file.



<?php



$postfields = array(

    'upload_file' => '@file_to_upload.png',

    'upload_text' => '@text_to_upload'

);



$curl = curl_init();

curl_setopt($curl, CURLOPT_URL, 'http://example.com/upload-test');

curl_setopt($curl, CURLOPT_POSTFIELDS, $postfields);

curl_exec($curl);

curl_close($curl);



?>



To get around this, prepend the text string with the NULL character like so:



<?php

    $postfields = array(

        'upload_file' => '@file_to_upload.png',

        'upload_text' => sprintf("\0%s", '@text_to_upload')

    );

?>



Original source: http://bit.ly/AntMle

down

S.F. ¶

1 month ago


I spent a couple of days trying to upload a file using a curl post.





The problem I ran into was the filename had an '@' in the middle of it.  It turned out that at least on my system if I encoded the file path using the quoted_printable_encode() function the upload works.





I'm posting this in the hopes that it will help someone else, and for my own future reference.





Code:


<?php





$filepath = '/tmp/test@example.txt';


$postdata['file'] = '@' . quoted_printable_encode($filepath);





//... supporting code.





$result = curl_exec($ch);





?>


I'm not exactly sure why this works when escaping the '@' doesn't work but it does for me.





If anyone can offer insight into why this works or a better way to handle the '@' symbol in a filename when using curl to upload I would love to hear it.





Thanks

down

dardyole at hotmail dot com ¶

1 month ago


Another note addressing the issues with servers that have open_basedir and safe mode turned on. Such an issue spawns the following E_WARNING:



Warning: curl_setopt() [function.curl-setopt]: CURLOPT_FOLLOWLOCATION cannot be activated when safe_mode is enabled or an open_basedir is set



After looking through the notes, most of the proposed manual implementations were kind of clunky and in some cases just didn't work at all. Most importantly (in my case), was the behaviour of the 302 Header. Anyway, here's the code I ended up using which has worked well for me in all cases so far, it even addresses the issue that caused FOLLOWLOCATION to be turned off in some cases :)



EDIT: Unfortunately the code itself is deemed "too long" for PHP's note system. I've uploaded it to a few paste sites below so hopefully the links will live for a while at least.



http://pastebin.com/aaJtPy1j

http://pastie.org/7646116



Use it as a replacement for curl_exec. For example:



<?php

$ch = curl_init("http://php.net");

var_dump(curl_exec_follow($ch, 9001));

curl_close($ch);

?>

down

xuyan83121 at gmail dot com ¶

2 months ago


when use curl_multi_exec, the CURLOPT_TIMEOUT need curl version newer than 7.21.2.

this can be found at curl changelog.

down

m at mar dot lt ¶

6 months ago


Be careful when changing CURLOPT_SSL_VERIFYHOST or other options to true (boolean). It may cause insecure behavior [1]



This is because boolean true casts into integer 1, and CURLOPT_SSL_VERIFYHOST = 1 is not secure behavior.



[1] Martin Georgiev and Subodh Iyengar and Suman Jana and Rishita Anubhai and Dan Boneh and Vitaly Shmatikov, The most dangerous code in the world: validating SSL certificates in non-browser software, ACM CCS '12, pp. 38-49, 2012

down

coding query ¶

11 months ago


Sometimes we want to extract the HTML content of the remote website page, this technique is called as HTML scrapper. This article will discuss on how we can extract the HTML content of the remote webpage.


We can achieve HTML scrapper operation in 2 step operation:


Call to Remote Web Page and extract the HTML content.


Match the HTML tags using Regular Expression.


Call to Remote Web Page using PHP:


In PHP there are various ways we can call the remote webpage. But here we will be using CURL to achieve our operation.





<?php


$ch = curl_init();


$timeout = 5; // set to zero for no timeout


curl_setopt ($ch, CURLOPT_URL, $url);


curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);


curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);


$file_contents = curl_exec($ch);


curl_close($ch);





 preg_match_all('/<span>[\\/\\(\\)-:<>\\w\\s]+< \\/span>/',$file_contents,$htmlContent);


?>

down

jeffb at nospam dot videx dot com ¶

1 year ago


When trying to pass a multi-dimensional array to CURLOPT_POSTFIELDS, first run it through http_build_query().  That will get rid of the Array to String conversion notice.

down

ellert at _removeme_ vankoperen dot nl ¶

1 year ago


If you are using curl to do a soap request and consistently get the following error back: 

The server cannot service the request because the media type is unsupported.

You are sending the Content-type of soap 1.2 to a 1.1 server.

Soap 1.1 needs Content-Type: text/xml;

Soap 1.2 should have Content-Type: application/soap+xml;

down

anonymous ¶

1 year ago


This may be not obvious, but if you specify the CURLOPT_POSTFIELDS and don't specify the CURLOPT_POST - it will still send POST, not GET (as you might think - since GET is default).

So the line:



curl_setopt($ch, CURLOPT_POSTFIELDS, $data);



is synonym to:



curl_setopt($ch, CURLOPT_POST, 1);

curl_setopt($ch, CURLOPT_POSTFIELDS, $data);



Even if you set the options like this (in this order):



curl_setopt($ch, CURLOPT_POST, 0);

curl_setopt($ch, CURLOPT_POSTFIELDS, $data);



it will send POST, since CURLOPT_POSTFIELDS is latter.

So if you want GET - make sure you don't have CURLOPT_POSTFIELDS specified somewhere.

down

mw+php dot net at lw-systems dot de ¶

1 year ago


The description of the use of the CURLOPT_POSTFIELDS option should be emphasize, that using POST with HTTP/1.1 with cURL implies the use of a "Expect: 100-continue" header. Some web servers will not understand the handling of chunked transfer of post data.



To disable this behavior one must disable the use of the "Expect:" header with



    curl_setopt($ch, CURLOPT_HTTPHEADER,array("Expect:"));

down

wonderfish+php at gmail dot com ¶

1 year ago


As of at least PHP 5.3.9, if you are continuing to use a cURL session handle after downloading a file and closing the file handle, you will need to change CURLOPT_FILE back to stdout, and cannot count simply on a side effect of CURLOPT_RETURNTRANSFER to do so, even if you are setting it.  For example:





<?php


$ch = curl_init();


$fh = fopen('/path/to/stored/file/example_file.dat', 'w');


curl_setopt($ch, CURLOPT_FILE, $fh);


curl_setopt($ch, CURLOPT_URL, 'http://example.com/example_file.dat');


curl_exec($ch);


fflush($fh);


fclose($fh);





//must reset cURL file handle. Not doing so will cause a warning to be


//thrown and for cURL to default to output regardless


//for our example, we'll set return transfer.


curl_setopt($ch, CURLOPT_FILE, fopen('php://stdout', 'w'));


curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);


curl_setopt($ch, CURLOPT_URL, 'http://example.org/index.html');


$html = curl_exec($ch); //this will now work


?>

down

dotpointer at gmail dot com ¶

1 year ago


I noted something when using CURLOPT_POSTFIELDS in combination with arrays from PHP.





You may supply an array, but there may not be any sub-arrays in this array, as this will give Array-to-string-conversion notice.





Example:





<?php


$ch = curl_init();





# this works


$data = array('name' => 'value');





# this gives "Notice: Array to string conversion..."


$data = array('name' => array('subname' => 'subvalue'));





curl_setopt($ch, CURLOPT_URL, 'http://localhost/test.php');


curl_setopt($ch, CURLOPT_POST, 1);


curl_setopt($ch, CURLOPT_POSTFIELDS, $data);





curl_exec($ch);


?>

down

v dot tverdun at gmail dot com ¶

1 year ago


Make sure to set keys for array if passing to CURLOPT_POSTFIELDS.



<?php

//This can cause errors

$data = array('bar');



//Use this instead

$data = array('foo' => 'bar');



curl_setopt(CURLOPT_POSTFIELDS, $data);

?>

down

Adam Monsen ¶

1 year ago


CURLOPT_POST must be left unset if you want the Content-Type header set to "multipart/form-data" (e.g., when CURLOPT_POSTFIELDS is an array). If you set CURLOPT_POSTFIELDS to an array and have CURLOPT_POST set to TRUE, Content-Length will be -1 and most sane servers will reject the request. If you set CURLOPT_POSTFIELDS to an array and have CURLOPT_POST set to FALSE, cURL will send a GET request.

down

chsa at ten dot ch ¶

1 year ago


Sending a post file upload across a squid proxy, the request was rejected by the proxy. In the error page returned it provided among other possible causes:"Expect:" feature is being asked from a HTTP/one.zero.

Solution: Add the option <?php curl_setopt($cl,CURLOPT_HTTPHEADER,array("Expect:")); ?>. This will remove the expect http header.

down

m dot ghadam at gmail dot com ¶

1 year ago


When you set ($ch, curlopt_post, 1) , after you have posted your data with curl_exec , you need to set ($ch, curlopt_post, 0), Otherwise all your subsequent requests seems as a post with no postdata and some reverse proxy servers send 500 or 403 error for these case ( access denied or forbidden )!

down

PHP at RHaworth dot net ¶

2 years ago


When CURLOPT_FOLLOWLOCATION and CURLOPT_HEADER are both true and redirect/s have happened then the header returned by curl_exec() will contain all the headers in the redirect chain in the order they were encountered.

down

anon@mouse dot com ¶

2 years ago


If your POST data seems to be disappearing (POST data empty, request is being handled by the server as a GET), try rearranging the order of CURLOPT_POSTFIELDS setting with CURLOPT_NOBODY. CURLOPT_POSTFIELDS has to come AFTER CURLOPT_NOBODY setting because if it comes after it wipes out the Content-Type header that tells your URL target that the request is a POST not a GET. 



Not sure if this is expected behavior but it certainly isn't documented (except on Stackoverflow.com, which is supremely unhelpful - BTW, guys over on stack overflow... once you've figured out a PHP problem, posting the solution here would save everyone extra search time).

down

gskluzacek at gmail dot com ¶

2 years ago


FYI... unless you specifically set the user agent, no user agent will be sent in your request as there is no default value like some of the other options.



As others have said, not sending a user agent may cause you to not  get the results that you expected, e.g., 0 byte length content, different content, etc.

down

john dot david dot steele at gmail dot com ¶

2 years ago


A note on the way Curl posts files...



<?php

  curl_setopt($ch, CURLOPT_POSTFIELDS, array('file' => '@/path/to/file.ext');

?>



will post the FULL PATH of the file in the filename field:



Content-Disposition: form-data; name="file"; filename="/path/to/file.ext"



Whereas typical browser behavior only sends the filename:



Content-Disposition: form-data; name="file"; filename="file.ext"



Workaround: 

<?php

  curl_setopt($ch, CURLOPT_POSTFIELDS, array('file' => '@file.ext');

  $cwd = getcwd();

  chdir('/path/to/');

  $receivedData = curl_exec($ch);

  chdir($cwd);

?>

down

scy-phpmanual at scytale dot name ¶

2 years ago


In order to reset CURLOPT_HTTPHEADER, set it to array(). The cURL C API says you should set it to NULL, but that doesn’t work in the PHP wrapper.

down

prohfesor at gmail dot com ¶

2 years ago


This function helps to parse netscape cookie file, generated by cURL into cookie array:





<?php


  function _curl_parse_cookiefile($file) {


    $aCookies = array();


    $aLines = file($file);


    foreach($aLines as $line){


      if('#'==$line{0})


        continue;


      $arr = explode("\t", $line);


      if(isset($arr[5]) && isset($arr[6]))


        $aCookies[$arr[5]] = $arr[6];


    }


    


    return $aCookies; 


  }


?>

down

kavih7 at yahoo dot com ¶

2 years ago


When POSTing with cURL, my POSTs were magically being converted to GETs and I debugged it until finding the issue. I was setting the CURLOPT_MUTE option. Not sure why this conflicts, since the documentation doesn't specify as such. Anyways, if your $_POST is empty, make sure you aren't setting CURLOPT_MUTE.



Cheers!

down

sam at def dot reyssi dot net ¶

2 years ago


Be careful when setting the CURLOPT_POSTFIELDS setting using an array. The array used to set the POST fields must only contain scalar values. Multidimentional arrays or objects lacking a __toString implementation will cause Curl to error.





If there is a need to send non-scalar values using a POST request, consider serializing them before transmission.





<?php


$ch = curl_init('http://host.example.com');





// Data to post


$multiDimensional = array(


   'name' = 'foo',


   'data' = array(1,2,3,4),


   'value' = 'bar'


);





// Will error


curl_setopt($ch, CURLOPT_POSTFIELDS, $multiDimensional);





// Data to post


$postData = array(


  'name' = 'foo',


  'data' = serialize(array(1,2,3,4)),


  'value' = 'bar'


);





// Will not error


curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);


?>

down

joeterranova at gmail dot com ¶

2 years ago


It appears that setting CURLOPT_FILE before setting CURLOPT_RETURNTRANSFER doesn't work, presumably because CURLOPT_FILE depends on CURLOPT_RETURNTRANSFER being set.





So do this:





<?php


curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);


curl_setopt($ch, CURLOPT_FILE, $fp);


?>





not this:





<?php


curl_setopt($ch, CURLOPT_FILE, $fp);


curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);


?>

down

patryk at do dot not dot spam dot com ¶

2 years ago


CURLOPT_HTTPPROXYTUNNEL means curl will use CONNECT method of the HTTP protocol to make a tunnel through a proxy, which is most likely not the one you want to do.

down

JScott jscott401 at gmail dot com ¶

2 years ago


Some additional notes for curlopt_writefunction. I struggled with this at first because it really isn't documented very well.



When you write a callback function and use it with curlopt_writefunction it will be called MULTIPLE times. Your function MUST return the ammount of data written to it each time. It is very picky about this. Here is a snippet from my code that may help you



<?php

curl_setopt($this->curl_handle, CURLOPT_WRITEFUNCTION, array($this, "receiveResponse"));



// later on in the class I wrote my receive Response method



private function receiveResponse($curlHandle,$xmldata)

                {

                        $this->responseString = $xmldata;

                        $this->responseXML .=  $this->responseString;

                        $this->length = strlen($xmldata);

                        $this->size += $this->length;

                        return $this->length;



                }

?>



Now I did this for a class. If you aren't doing OOP then you will obviously need to modify this for your own use.



CURL calls your script MULTIPLE times because the data will not always be sent all at once. Were talking internet here so its broken up into packets. You need to take your data and concatenate it all together until it is all written. I was about to pull my damn hair out because I would get broken chunks of XML back from the server and at random lengths. I finally figured out what was going on. Hope this helps

down

obones_remove_me at free dot fr ¶

3 years ago


For those of you wondering how to specify the content-type for a file uploaded via curl, the syntax is as follows:



<?php



$data = array('file' => '@/home/user/test.png;type=image/png');



?>



Simply adding a semicolon with the type= at the end.

Note that this has been reported not to work in all versions of PHP and I have done the following tests:



5.2.6 (libcurl 7.18.2) : Does not work

5.2.13 (libcurl 7.20.0) : Works just fine



So it might be worth updating your installation of PHP and/or libcurl if you want to be able to use this syntax

down

sjungwirth at google mail dot com ¶

3 years ago


I couldn't find a way to force a curl request to go to a particular IP address, but you can do it with fsockopen:


<?php


    $ip = '123.45.67.89';


    $fp = fsockopen($ip, 80, $errno, $errstr, 5);


    $result = '';


    if (!$fp) {


        echo "$errstr ($errno)<br />\n";


    } else {


        $out = "GET /path/to/the/file.ext HTTP/1.1\r\n";


        $out .= "Host: www.exampl.com\r\n";


        $out .= "Connection: Close\r\n\r\n";


        fwrite($fp, $out);


        while (!feof($fp)) {


            $result .= fgets($fp, 128);


        }


        fclose($fp);


    }


?>


I needed it to test the response from a set of servers behind a load balancer.

down

clint at fewbar dot com ¶

3 years ago


If you have turned on conditional gets on a curl handle, and then for a subsequent request, you don't have a good setting for CURLOPT_TIMEVALUE , you can disable If-Modified-Since checking with:



<?php



$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, $foo);

curl_setopt($ch, CURLOPT_TIMEVALUE, filemtime($foo_path));

curl_setopt($ch, CURLOPT_TIMECONDITION, CURLOPT_TIMECOND_IFMODIFIEDSINCE);

curl_exec($ch);

// Reuse same curl handle

curl_setopt($ch, CURLOPT_URL, $bar);

curl_setopt($ch, CURLOPT_TIMEVALUE, null); // don't know mtime

curl_setopt($ch, CURLOPT_TIMECONDITION, 0); // set it to 0, turns it off

curl_exec($ch);



?>

down

julien veneziano ¶

3 years ago


If you need to send deta in a DELETE request, use:



<?php

$request_body = 'some data';

$ch = curl_init('http://www.example.com');

        curl_setopt($ch, CURLOPT_POSTFIELDS, $request_body);

        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);

        curl_setopt($ch, CURLOPT_HEADER, 0); 

        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");

        $response = curl_exec($ch);

var_dump($response);

?>

down

starosielec at googlemail dot com ¶

3 years ago


You can use also use object methods as callback functions. This is usefull if your curl ressource is part of an object handling transfers.


Instead of curl_setopt($curl, CURLOPT_WRITEFUNCTION, "curl_handler_recv") you can use array($object, "method") as value for callback options.





For example:





<?php


class downloader {


    private $curl;





    function __construct() {


        $this->curl = curl_init();


        curl_setopt($this->curl, CURLOPT_WRITEFUNCTION, array($this, "curl_handler_recv"));


    }





     function curl_handler_recv($res, $data) {


      //...


     }


   //... 


}


?>

down

Ed Cradock ¶

3 years ago


PUT requests are very simple, just make sure to specify a content-length header and set post fields as a string.





Example:





<?php


function doPut($url, $fields)


{


   $fields = (is_array($fields)) ? http_build_query($fields) : $fields;





   if($ch = curl_init($url))


   {


      curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');


      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);


      curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Length: ' . strlen($fields)));


      curl_setopt($ch, CURLOPT_POSTFIELDS, $fields);


      curl_exec($ch);





      $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);





      curl_close($ch);





      return (int) $status;


   }


   else


   {


      return false;


   }


}





if(doPut('http://example.com/api/a/b/c', array('foo' => 'bar')) == 200)


   // do something


else


   // do something else.


?>





You can grab the request data on the other side with:





<?php


if($_SERVER['REQUEST_METHOD'] == 'PUT')


{


   parse_str(file_get_contents('php://input'), $requestData);





   // Array ( [foo] => bar )


   print_r($requestData);





   // Do something with data...


}


?>





DELETE  can be done in exactly the same way.

down

Pawel Antczak ¶

3 years ago


Hello. 

During problems with "CURLOPT_FOLLOWLOCATION cannot be activated when in safe_mode or an open_basedir is set" 

I was looking for solution. 

I've found few methods on this page, but none of them was good enough, so I made one.

<?php

function curl_redirect_exec($ch, &$redirects, $curlopt_header = false) {

    curl_setopt($ch, CURLOPT_HEADER, true);

    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

    $data = curl_exec($ch);

    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    if ($http_code == 301 || $http_code == 302) {

        list($header) = explode("\r\n\r\n", $data, 2);

        $matches = array();

        preg_match('/(Location:|URI:)(.*?)\n/', $header, $matches);

        $url = trim(array_pop($matches));

        $url_parsed = parse_url($url);

        if (isset($url_parsed)) {

            curl_setopt($ch, CURLOPT_URL, $url);

            $redirects++;

            return curl_redirect_exec($ch, $redirects);

        }

    }

    if ($curlopt_header)

        return $data;

    else {

        list(,$body) = explode("\r\n\r\n", $data, 2);

        return $body;

    }

}

?>



Main issue in existing functions was lack of information, how many redirects was done. 

This one will count it. 

First parameter as usual. 

Second should be already initialized integer, it will be incremented by number of done redirects. 

You can set CURLOPT_HEADER if You need it.

down

Chris at PureFormSolutions dot com ¶

3 years ago


I've found that setting CURLOPT_HTTPHEADER more than once will clear out any headers you've set previously with CURLOPT_HTTPHEADER.



Consider the following:

<?php

    # ...



    curl_setopt($cURL,CURLOPT_HTTPHEADER,array (

        "Content-Type: text/xml; charset=utf-8",

        "Expect: 100-continue"

    ));



    # ... do some other stuff ...



    curl_setopt($cURL,CURLOPT_HTTPHEADER,array (

        "Accept: application/json"

    ));



    # ...

?>



Both the Content-Type and Expect I set will not be in the outgoing headers, but Accept will.

down

Stan van de Burgt ¶

3 years ago


If you get a "failed creating formpost data" upon curl_exec() when POSTing a form, check if one of the field values starts with the @ character.



Took me an hour or so to find out as I wanted to post a @reply tweet to twitter which typically start with @screenname.

down

Tyranoweb ¶

3 years ago


There is a function to send POST data in page with five parameters :





$post must be an array


$page is the page where POST datas will be send.


$n must be true to continue if they are php redirection (Location: )


$session must be define true if you want to use cookies 


$referer must be a link to get a wrong referer or only to have a referer.





<?php


function curl_data_post($post, $page, $n, $session, $referer)


    {


        if(!is_array($post))


        {


         return false;


        }


        


        $DATA_POST = curl_init();


        curl_setopt($DATA_POST, CURLOPT_RETURNTRANSFER, true);


        curl_setopt($DATA_POST, CURLOPT_URL, $page);


        curl_setopt($DATA_POST, CURLOPT_POST, true);


        if($n)


        {


         curl_setopt($DATA_POST, CURLOPT_FOLLOWLOCATION, true);


        }


        if($session)


        {


         curl_setopt($DATA_POST, CURLOPT_COOKIEFILE, 'cookiefile.txt');


         curl_setopt($DATA_POST, CURLOPT_COOKIEJAR, 'cookiefile.txt'); 


        }


        


        if($referer)


        {


         curl_setopt($DATA_POST, CURLOPT_REFERER, $referer); 


        }


        


        curl_setopt($DATA_POST, CURLOPT_POSTFIELDS, $post);


        $data = curl_exec($DATA_POST);


        if($data == false)


        {


         echo'Warning : ' . curl_error($DATA_POST);


         curl_close($DATA_POST);


         return false;


        }


        else


        {


         curl_close($DATA_POST);


         return $data;


        }


    }


?>

down

rob ¶

3 years ago


Whats not mentioned in the documentation is that you have to set CURLOPT_COOKIEJAR to a file for the CURL handle to actually use cookies, if it is not set then cookies will not be parsed.

down

mikeseth at gmail dot com ¶

3 years ago


When using CURLOPT_FILE, pass it the file handle that is open for write only (eg fopen('blahblah', 'w+')). If you also open the file for reading (eg fopen('blahblah', 'rw')), curl will fail with error 23.

down

Victor Jerlin ¶

3 years ago


Seems like some options not mentioned on this page, but listed on http://curl.haxx.se/libcurl/c/curl_easy_setopt.html is actually supported.



I was happy to see that I could actually use CURLOPT_FTP_CREATE_MISSING_DIRS even from PHP.

down

Andrew ¶

3 years ago


I noticed that if you want to get current cookie file after curl_exec() - you need to close current curl handle (like it said in manual), but if you want cookies to be dumped to file after any curl_exec (without curl_close) you can:





<?php


#call it normally


$ch = curl_init(); 


curl_setopt($ch, CURLOPT_HEADER, 0); 


curl_setopt($ch, CURLOPT_COOKIEFILE, "cookiefile"); 


curl_setopt($ch, CURLOPT_COOKIEJAR, "cookiefile"); 


curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1); 


curl_setopt($ch, CURLOPT_URL, 'http://www.example.com/'); 


$result1 = curl_exec($ch); 





#and then  make a temp copy


$ch_temp=curl_copy_handle(ch);


curl_close($ch);


$ch=$ch_temp;


?>





Only this way, if you close $ch_temp - cookies wont be dumped.

down

franciscocha at gmail dot com ¶

4 years ago


Example how to connect to FTPES (FTP explicit SSL). This script will connect to any FTPES server and out put the list of directories.





<?php


    $username = 'username';


    $password = 'password';


    $url = 'example.com';


    $ftp_server = "ftp://" . $username . ":" . $password . "@" . $url;


    


    echo "Starting CURL.\n";


    $ch = curl_init();


    echo "Set CURL URL.\n";


    


    //curl FTP


    curl_setopt($ch, CURLOPT_URL, $ftp_server);


    


    //For Debugging


    //curl_setopt($ch, CURLOPT_VERBOSE, TRUE);    


    


    //SSL Settings


    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);


    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);


    curl_setopt($ch, CURLOPT_FTP_SSL, CURLFTPSSL_TRY);


    


    //List FTP files and directories


    curl_setopt($ch, CURLOPT_FTPLISTONLY, TRUE);


    


    //Output to curl_exec


    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);





    echo "Executing CURL.\n";


    $output = curl_exec($ch);


    curl_close($ch);


    echo "Closing CURL.\n";


    echo $output . "\n";





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


   print_r($files);


?>

down

ashooner - - gmail , com ¶

4 years ago


When passing CURLOPT_POSTFIELDS a url-encoded string in order to use Content-Type: application/x-www-form-urlencoded, you can pass a string directly:

<?php

curl_setopt(CURLOPT_POSTFIELDS, 'field1=value&field2=value2');

?>



rather than passing the string in an array, as in fred at themancan dot com's example.

down

Ariz Jacinto ¶

4 years ago


if unserialize() returns FALSE on a serialized PHP object due to an extraneous string (e.g. "1") appended at the end of the object, you need to set the ff cURL option:





<?php


curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);


?>

down

urkle at outoforder dot cc ¶

4 years ago


To send a post as a different content-type (ie.. application/json or text/xml) add this setopt call





<?php


curl_setopt($ch, CURLOPT_HTTPHEADERS,array('Content-Type: application/json'));


?>





[EDIT BY danbrown AT php DOT net: Contains a typofix by 'KdoubleU' on 3-FEB-09.]

down

dorphalsig at gmail dot com ¶

4 years ago


This may not be a surprise for many, but I know I bled my eyes out trying to implement this in php. And when I knew it was this simple, I really felt extremely stupid. So I put this just so google will save somebody some time in the future.





PHP NTLM AUTH





Make sure you have the 'curl' extension loaded


now just do...





<?php


curl_setopt($ch,CURLAUTH_NTLM);


curl_setopt($ch,CURLOPT_USERPWD,"$username:$password");


?>





and just continue to use curl in the ordinary fashion.

down

OPALA ¶

4 years ago


To fetch (or submit data to) multiple pages during one session,use this:





<?php


$ch = curl_init();


curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);


curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);


curl_setopt($ch, CURLOPT_COOKIESESSION, TRUE);


curl_setopt($ch, CURLOPT_HEADER, 0);


curl_setopt($ch, CURLOPT_COOKIEFILE, "cookiefile");


curl_setopt($ch, CURLOPT_COOKIEJAR, "cookiefile");


curl_setopt($ch, CURLOPT_COOKIE, session_name() . '=' . session_id());


curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);





curl_setopt($ch, CURLOPT_URL, 'http://example.com/page1.php');


$result1 = curl_exec($ch);





curl_setopt($ch, CURLOPT_URL, 'http://example.com/page2.php');


$result2 = curl_exec($ch);





curl_close($ch);


?>

down

George ¶

4 years ago


If you set CURLOPT_RESUME_FROM to resume the file, and then reuse the same Curl handle to download another file, you must reset the resume status by calling curl_setopt( $ch, CURLOPT_RESUME_FROM, 0 ). It will not reset, and will apply to all subsequent transfers even if the URL is the same.

down

w dot danford at electronics-software dot com ¶

4 years ago


Just a small detail I too easily overlooked.

<?php

/*  If you set:  */

curl_setopt ($ch, CURLOPT_POST, 1);

/* then you must have the data: */

curl_setopt ($ch, CURLOPT_POSTFIELDS, $PostData);

?>

I found with only the CURLOPT_POST set (from copy, paste editing of course) cookies were not getting sent with CURLOPT_COOKIE.  Just something subtle to watch out for.

down

fred at themancan dot com ¶

4 years ago


To find what encoding a given HTTP POST request uses is easy -- passing an array to CURLOPT_POSTFIELDS results in  multipart/form-data:





<?php


curl_setopt(CURLOPT_POSTFIELDS, array('field1' => 'value'));


?>





Passing a URL-encoded string will result in application/x-www-form-urlencoded:





<?php


curl_setopt(CURLOPT_POSTFIELDS, array('field1=value&field2=value2'));


?>





I ran across this when integrating with both a warehouse system and an email system; neither would accept multipart/form-data, but both happily accepted application/x-www-form-urlencoded.

down

jID ¶

4 years ago


if you use

<?php

curl_setopt($ch, CURLOPT_INTERFACE, "XXX.XXX.XXX.XXX");

?>

to specify IP adress for request, sometimes you need to get list of all your IP's.



ifconfig command will output something like:



rl0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> mtu 1500

    options=8<VLAN_MTU>

    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX

    inet 78.24.XXX.XXX netmask 0xffffffff broadcast 78.24.XXX.XXX

    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX

    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX

    inet 82.146.XXX.XXX netmask 0xffffffff broadcast 82.146.XXX.XXX

    inet 78.24.XXX.XXX netmask 0xffffffff broadcast 78.24.XXX.XXX

    inet 78.24.XXX.XXX netmask 0xffffffff broadcast 78.24.XXX.XXX

    ether XX:XX:XX:XX:XX:XX

    media: Ethernet autoselect (100baseTX <full-duplex>)

    status: active

lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384

tun0: flags=8051<UP,POINTOPOINT,RUNNING,MULTICAST> mtu 1500

    Opened by PID 564

tun1: flags=8051<UP,POINTOPOINT,RUNNING,MULTICAST> mtu 1500

    Opened by PID 565

    Opened by PID 565



My solution for FreeBSD 6 and PHP 5 was:

<?php

  ob_start();

  $ips=array();

  $ifconfig=system("ifconfig");

  echo $ifconfig;

  $ifconfig=ob_get_contents();

  ob_end_clean();

  $ifconfig=explode(chr(10), $ifconfig);

  for ($i=0; $i<count($ifconfig); $i++) {

    $t=explode(" ", $ifconfig[$i]);

    if ($t[0]=="\tinet") {

      array_push($ips, $t[1]);

    }     

  }

  for ($i=0; $i<count($ips); $i++) {

    echo $ips[$i]."\n";

  }

?>



You will get list of IP adresses in $ips array, like:

82.146.XXX.XXX

78.24.XXX.XXX

82.146.XXX.XXX

82.146.XXX.XXX

82.146.XXX.XXX

78.24.XXX.XXX

78.24.XXX.XXX

down

ac at an dot y-co dot de ¶

4 years ago


If you want to connect to a server which requires that you identify yourself with a certificate, use following code. Your certificate and servers certificate are signed by an authority whose certificate is in ca.ctr.



<?php

curl_setopt($ch, CURLOPT_VERBOSE, '1');

curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, '1');

curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, '1');

curl_setopt($ch, CURLOPT_CAINFO,  getcwd().'/cert/ca.crt');

curl_setopt($ch, CURLOPT_SSLCERT, getcwd().'/cert/mycert.pem');

curl_setopt($ch, CURLOPT_SSLCERTPASSWD, 'password');

?>



If your original certificate is in .pfx format, you have to convert it to .pem using following commands

# openssl pkcs12 -in mycert.pfx -out mycert.key

# openssl rsa -in mycert.key -out mycert.pem

# openssl x509 -in mycert.key >> mycert.pem

down

nick at glype dot com ¶

4 years ago


Although CURLOPT_CLOSEPOLICY and the applicable choices are valid constants, setting this option with curl_setopt() always returns false. A quick google search suggests the option is deprecated and/or never worked.

down

Salil Kothadia ¶

4 years ago


In PHP5, for the "CURLOPT_POSTFIELDS" option, we can use:



<?php

$ch = curl_init($URI);

$Post = http_build_query($PostData);

curl_setopt($ch, CURLOPT_POSTFIELDS, $Post);

$Output = curl_exec($ch);

curl_close($ch);

?>

down

sgamon at yahoo dot com ¶

5 years ago


If you are doing a POST, and the content length is 1,025 or greater, then curl exploits a feature of http 1.1: 100 (Continue) Status.



See http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3



* it adds a header, "Expect: 100-continue".  

* it then sends the request head, waits for a 100 response code, then sends the content 



Not all web servers support this though.  Various errors are returned depending on the server.  If this happens to you, suppress the "Expect" header with this command:



<?php

curl_setopt($ch, CURLOPT_HTTPHEADER, array('Expect:'));

?>



See http://www.gnegg.ch/2007/02/the-return-of-except-100-continue/

down

john factorial ¶

5 years ago


Clarification for the CURLOPT_NOBODY option: by excluding the body from your request, you're effectively making a HEAD request. Use the CURLOPT_NOBODY option to return only the headers in the remote response.





Example:





<?php


function check_url($url) {


    $c = curl_init();


    curl_setopt($c, CURLOPT_URL, $url);


    curl_setopt($c, CURLOPT_HEADER, 1); // get the header


    curl_setopt($c, CURLOPT_NOBODY, 1); // and *only* get the header


    curl_setopt($c, CURLOPT_RETURNTRANSFER, 1); // get the response as a string from curl_exec(), rather than echoing it


    curl_setopt($c, CURLOPT_FRESH_CONNECT, 1); // don't use a cached version of the url


    if (!curl_exec($c)) { return false; }





    $httpcode = curl_getinfo($c, CURLINFO_HTTP_CODE);


    return ($httpcode < 400);


}


?>

down

c00lways at gmail dot com ¶

5 years ago


if you would like to send xml request to a server (lets say, making a soap proxy),


you have to set





<?php


curl_setopt($ch, CURLOPT_HTTPHEADER, Array("Content-Type: text/xml"));


?>





makesure you watch for cache issue:


the below code will prevent cache...





<?php


curl_setopt($ch, CURLOPT_FORBID_REUSE, 1);


curl_setopt($ch, CURLOPT_FRESH_CONNECT, 1);


?>





hope it helps ;)

down

mavook at gmail dot com ¶

5 years ago


If you try to upload file to a server, you need do CURLOPT_POST first and then fill CURLOPT_POSTFIELDS.





<?php


curl_setopt($ch, CURLOPT_POST, 1);


curl_setopt($ch, CURLOPT_POSTFIELDS, $postvars);


// ^^ This will post multipart/form-data


?>

down

jade dot skaggs at gmail dot com ¶

5 years ago


After much struggling, I managed to get a SOAP request requiring HTTP authentication to work.  Here's some source that will hopefully be useful to others. 





         <?php





         $credentials = "username:password";


         


         // Read the XML to send to the Web Service


         $request_file = "./SampleRequest.xml";


        $fh = fopen($request_file, 'r');


        $xml_data = fread($fh, filesize($request_file));


        fclose($fh);


                


        $url = "http://www.example.com/services/calculation";


        $page = "/services/calculation";


        $headers = array(


            "POST ".$page." HTTP/1.0",


            "Content-type: text/xml;charset=\"utf-8\"",


            "Accept: text/xml",


            "Cache-Control: no-cache",


            "Pragma: no-cache",


            "SOAPAction: \"run\"",


            "Content-length: ".strlen($xml_data),


            "Authorization: Basic " . base64_encode($credentials)


        );


       


        $ch = curl_init();


        curl_setopt($ch, CURLOPT_URL,$url);


        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);


        curl_setopt($ch, CURLOPT_TIMEOUT, 60);


        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);


        curl_setopt($ch, CURLOPT_USERAGENT, $defined_vars['HTTP_USER_AGENT']);


        


        // Apply the XML to our curl call


        curl_setopt($ch, CURLOPT_POST, 1);


        curl_setopt($ch, CURLOPT_POSTFIELDS, $xml_data); 





        $data = curl_exec($ch); 





        if (curl_errno($ch)) {


            print "Error: " . curl_error($ch);


        } else {


            // Show me the result


            var_dump($data);


            curl_close($ch);


        }





?>

down

andrabr at gmail dot com ¶

5 years ago


This is very clear in hindsight, but it still cost me several hours:





<?php curl_setopt($session, CURLOPT_HTTPPROXYTUNNEL, 1); ?>





means that you will tunnel THROUGH the proxy, as in "your communications will go as if the proxy is NOT THERE".





Why do you care? - Well, if you are trying to use, say, Paros, to debug HTTP between your cURL and the server, with CURLOPT_HTTPPROXYTUNNEL set to TRUE Paros will not see or log your traffic thus defeating the purpose and driving you nuts.





There are other cases, of course, where this option is extremely useful...

down

mcbreen at gmail dot com ¶

5 years ago


If you are getting the following error:





SSL: certificate subject name 'example.com' does not match target host name 'example.net'





Then you can set the following option to get around it:





<?php curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE); ?>

down

vincent at ludden dot nl ¶

5 years ago


Please note that the CURLOPT_INTERFACE setting only accepts IP addresses and hostnames of the local machine. It is not meant to send a URL to a specific IP address.

down

ashw1 - at - no spam - post - dot - cz ¶

5 years ago


In case you wonder how come, that cookies don't work under Windows, I've googled for some answers, and here is the result: Under WIN you need to input absolute path of the cookie file.





This piece of code solves it:





<?php





if ($cookies != '')


    {


    if (substr(PHP_OS, 0, 3) == 'WIN')


        {$cookies = str_replace('\\','/', getcwd().'/'.$cookies);}


    curl_setopt($ch, CURLOPT_COOKIEJAR, $cookies);


    curl_setopt($ch, CURLOPT_COOKIEFILE, $cookies);


    }





?>

down

Jon Freilich ¶

6 years ago


curl will sometimes return an "Empty reply from server" error if you don't send a User-Agent string.  Use the CURLOPT_USERAGENT option.

down

rob at infoglobe dot net ¶

6 years ago


Options not included in the above, but that work (Taken from the libcurl.a C documentation)



CURLOPT_FTP_SSL 



Pass a long using one of the values from below, to make libcurl use your desired level of SSL for the ftp transfer. (Added in 7.11.0) 



CURLFTPSSL_NONE 



Don't attempt to use SSL. 



CURLFTPSSL_TRY 



Try using SSL, proceed as normal otherwise. 



CURLFTPSSL_CONTROL 



Require SSL for the control connection or fail with CURLE_FTP_SSL_FAILED. 



CURLFTPSSL_ALL 



Require SSL for all communication or fail with CURLE_FTP_SSL_FAILED.

down

alfredoaguirre dot v at gmail dot com ¶

6 years ago


Seems that CURLOPT_RETURNTRANSFER Option set to TRUE, returns a "1" when the transaction returns a blank page.



I think is for eliminate the FALSE to can be with a blank page as return

down

paczor ¶

6 years ago


How to get rid of response after POST: just add callback function for returned data (CURLOPT_WRITEFUNCTION) and make this function empty.





<?php


function curlHeaderCallback($ch, $strHeader) {


}


curl_setopt($ch, CURLOPT_WRITEFUNCTION, 'curlHeaderCallback');


?>

down

pyroevi at yahoo dot com ¶

6 years ago


I was working on using php to interface with an authorize.net gateway, and I ran into a problem with certificates using curl to talk the https:// url.





curl_error() told me "SSL certificate problem, verify that the CA cert is OK."





I googled it and found the same "solution" over and over again: bypass verification by adding this line after curl_init():





<?php


curl_setopt($connection, CURLOPT_SSL_VERIFYPEER, false);


?>





This worked great, but I was required to verify, so here's what I did. Add the following lines:





<?php


curl_setopt($connection, CURLOPT_SSL_VERIFYPEER, 1);


curl_setopt($connection, CURLOPT_CAINFO, "path:/ca-bundle.crt");


?>





with "path:/ca-bundle.crt" being the path to that certificate file. You can get this file by downloading the curl package (http://curl.haxx.se/download.html) and looking for it in the lib folder.





Feel free to email me.

down

php at miggy dot org ¶

6 years ago


Note that if you want to use a proxy and use it as a _cache_, you'll have to do:





<?php curl_setopt($ch, CURLOPT_HTTPHEADER, array("Pragma: ")); ?>





else by default Curl puts a "Pragma: no-cache" header in and thus force cache misses for all requests.

down

Philippe dot Jausions at 11abacus dot com ¶

6 years ago


Clarification on the callback methods:



- CURLOPT_HEADERFUNCTION is for handling header lines received *in the response*,

- CURLOPT_WRITEFUNCTION is for handling data received *from the response*,

- CURLOPT_READFUNCTION is for handling data passed along *in the request*.



The callback "string" can be any callable function, that includes the array(&$obj, 'someMethodName') format.



 -Philippe

down

mr at coder dot tv ¶

7 years ago


Sometimes you can't use CURLOPT_COOKIEJAR and CURLOPT_COOKIEFILE becoz of the server php-settings(They say u may grab any files from server using these options). Here is the solution

1)Don't use CURLOPT_FOLLOWLOCATION

2)Use curl_setopt($ch, CURLOPT_HEADER, 1)

3)Grab from the header cookies like this:

preg_match_all('|Set-Cookie: (.*);|U', $content, $results);    

$cookies = implode(';', $results[1]);

4)Set them using curl_setopt($ch, CURLOPT_COOKIE,  $cookies);



Good Luck, Yevgen

down

heyrocker at yahoo dot com ¶

7 years ago


The examples below for HTTP file upload work great, but I wanted to be able to post multiple files through HTTP upload using HTML arrays as specified in example 38.3 at





http://php.net/features.file-upload





In this case, you need to set the arrays AND keys in the $post_data, it will not work with just the array names. The following example shows how this works:





<?php





    $post_data = array();


    


    $post_data['pictures[0]'] = "@cat.jpg";


    $post_data['pictures[1]'] = "@dog.jpg";


    





    $ch = curl_init();


    curl_setopt($ch, CURLOPT_URL, "http://example.com/my_url.php" ); 


    curl_setopt($ch, CURLOPT_POST, 1 );


    curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data);


    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);


    $postResult = curl_exec($ch);





    if (curl_errno($ch)) {


       print curl_error($ch);


    }


    curl_close($ch);


    print "$postResult";


?>

down

petelu $ post dot sk ¶

7 years ago


load https:// or  http://example.com/exam.php  


with  POST  data (name=alex&year=18) and apply COOKIEs





<?php


$sessions = curl_init();


curl_setopt($sessions,CURLOPT_URL,'http://example.com/exam.php');


curl_setopt($sessions, CURLOPT_POST, 1);


curl_setopt($sessions,CURLOPT_POSTFIELDS,'name=alex&year=18');


curl_setopt($sessions,CURLOPT_COOKIEJAR,


dirname(__FILE__).'/cookie.txt');


curl_setopt($sessions,CURLOPT_FOLLOWLOCATION,0);


curl_setopt($sessions, CURLOPT_HEADER , 1);


curl_setopt($sessions, CURLOPT_RETURNTRANSFER,1);


$my_load_page = curl_exec($this->sessions);


?>

down

luca dot manzo at bbsitalia dot com ¶

7 years ago


If you're getting trouble with cookie handling in curl: 





- curl manages tranparently cookies in a single curl session


- the option 


<?php curl_setopt($ch, CURLOPT_COOKIEJAR, "/tmp/cookieFileName"); ?>





makes curl to store the cookies in a file at the and of the curl session





- the option 


<?php curl_setopt($ch, CURLOPT_COOKIEFILE, "/tmp/cookieFileName"); ?>





makes curl to use the given file as source for the cookies to send to the server. 





so to handle correctly cookies between different curl session, the you have to do something like this:





<?php


       $ch = curl_init(); 


       curl_setopt ($ch, CURLOPT_URL, $url); 


       curl_setopt ($ch, CURLOPT_COOKIEJAR, COOKIE_FILE_PATH);


       curl_setopt ($ch, CURLOPT_COOKIEFILE, COOKIE_FILE_PATH);





       curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1); 


       $result = curl_exec ($ch);


       curl_close($ch);


       return $result;


?>





in particular this is NECESSARY if you are using PEAR_SOAP libraries to build a webservice client over https and the remote server need to establish a session cookie. in fact each soap message is sent using a different curl session!!





I hope this can help someone


Luca

down

Dustin Hawkins ¶

7 years ago


To further expand upon use of CURLOPT_CAPATH and CURLOPT_CAINFO...



In my case I wanted to prevent curl from talking to any HTTPS server except my own using a self signed certificate. To do this, you'll need openssl installed and access to the HTTPS Server Certificate (server.crt by default on apache)



You can then use a command simiar to this to translate your apache certificate into one that curl likes.



$ openssl x509 -in server.crt -out outcert.pem -text



Then set CURLOPT_CAINFO equal to the the full path to outcert.pem and turn on CURLOPT_SSL_VERIFYPEER.



If you want to use the CURLOPT_CAPATH option, you should create a directory for all the valid certificates you have created, then use the c_rehash script that is included with openssl to "prepare" the directory.



If you dont use the c_rehash utility, curl will ignore any file in the directory you set.

down

skyogre __at__ yandex __dot__ ru ¶

7 years ago


There is really a problem of transmitting $_POST data with curl in php 4+ at least.

I improved the encoding function by Alejandro Moreno to work properly with mulltidimensional arrays.



<?php

function data_encode($data, $keyprefix = "", $keypostfix = "") {

  assert( is_array($data) );

  $vars=null;

  foreach($data as $key=>$value) {

    if(is_array($value)) $vars .= data_encode($value, $keyprefix.$key.$keypostfix.urlencode("["), urlencode("]"));

    else $vars .= $keyprefix.$key.$keypostfix."=".urlencode($value)."&";

  }

  return $vars;

}



curl_setopt($ch, CURLOPT_POSTFIELDS, substr(data_encode($_POST), 0, -1) );



?>

down

ROXORT at TGNOOB dot FR ¶

7 years ago


<?php


/*


  Here is a script that is usefull to :


  - login to a POST form,


  - store a session cookie,


  - download a file once logged in.


*/





// INIT CURL


$ch = curl_init();





// SET URL FOR THE POST FORM LOGIN


curl_setopt($ch, CURLOPT_URL, 'http://www.example.com/Members/Login.php');





// ENABLE HTTP POST


curl_setopt ($ch, CURLOPT_POST, 1);





// SET POST PARAMETERS : FORM VALUES FOR EACH FIELD


curl_setopt ($ch, CURLOPT_POSTFIELDS, 'fieldname1=fieldvalue1&fieldname2=fieldvalue2');





// IMITATE CLASSIC BROWSER'S BEHAVIOUR : HANDLE COOKIES


curl_setopt ($ch, CURLOPT_COOKIEJAR, 'cookie.txt');





# Setting CURLOPT_RETURNTRANSFER variable to 1 will force cURL


# not to print out the results of its query.


# Instead, it will return the results as a string return value


# from curl_exec() instead of the usual true/false.


curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);





// EXECUTE 1st REQUEST (FORM LOGIN)


$store = curl_exec ($ch);





// SET FILE TO DOWNLOAD


curl_setopt($ch, CURLOPT_URL, 'http://www.example.com/Members/Downloads/AnnualReport.pdf');





// EXECUTE 2nd REQUEST (FILE DOWNLOAD)


$content = curl_exec ($ch);





// CLOSE CURL


curl_close ($ch); 





/*


  At this point you can do do whatever you want


  with the downloaded file stored in $content :


  display it, save it as file, and so on.


*/


?>

down

mcknight at chek dot com ¶

7 years ago


when specifing the file for either CURLOPT_COOKIEFILE or CURLOPT_COOKIEJAR you may need to use the full file path instead of just the relative path.

down

phpnet at andywaite dot com ¶

7 years ago


After setting CURLOPT_FILE, you may want want to revert back to the normal behaviour of displaying the results. This can be achieved using:





<?php


$fp = fopen ("php://output", "w") or die("Unable to open stdout for writing.\n");


curl_setopt($ch, CURLOPT_FILE, $fp);


?>

down

michaeledwards.com ¶

7 years ago


Problems can occur if you mix CURLOPT_URL with a 'Host:' header in CURLOPT_HEADERS on redirects because cURL will combine the host you explicitly stated in the 'Host:' header with the host from the Location: header of the redirect response. 





In short, don't do this:





<?php


$host = "www.example.com";


$url = "http://$host/";





$headers = array("Host: $host");





$ch = curl_init();





curl_setopt($ch, CURLOPT_URL, $url);


curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);





Do this instead:





$host = "www.example.com";


$url = "http://$host/";





$ch = curl_init();





curl_setopt($ch, CURLOPT_URL, $url);


?>

down

samlowry at e-baka dot net ¶

8 years ago


About CURLOPT_ENCODING:


added in curl in 7.10 - Oct 1 2002


In 7.10.5 - May 19 2003 syntax was chnaged:


"setting CURLOPT_ENCODING to "" automaticly enables all supported encodings"

down

ikendra at yken dot nospam dot org ¶

8 years ago


Using cURL, I needed to call a third-party script which was returning binary data as attachment to pass on retrieved data again as attachment.





Problem was that the third-party script occassionally returned HTTP errors and I wanted to avoid passing on zero-length attachment in such case.





Combination of using CURLOPT_FAILONERROR and CURLOPT_HEADERFUNCTION callback helped to process the third-party script HTTP errors neatly:





<?php


function curlHeaderCallback($resURL, $strHeader) {


    if (preg_match('/^HTTP/i', $strHeader)) {


        header($strHeader);


        header('Content-Disposition: attachment; filename="file-name.zip"');


    }


    return strlen($strHeader);


}





$strURL = 'http://www.example.com/script-whichs-dumps-binary-attachment.php';





$resURL = curl_init();


curl_setopt($resURL, CURLOPT_URL, $strURL);


curl_setopt($resURL, CURLOPT_BINARYTRANSFER, 1);


curl_setopt($resURL, CURLOPT_HEADERFUNCTION, 'curlHeaderCallback');


curl_setopt($resURL, CURLOPT_FAILONERROR, 1);





curl_exec ($resURL);





$intReturnCode = curl_getinfo($resURL, CURLINFO_HTTP_CODE);


curl_close ($resURL);





if ($intReturnCode != 200) {


    print 'was error: ' . $intReturnCode;


}


?>

down

ron at ttvavanti dot nl ¶

9 years ago


If you specify a CAINFO, note that the file must be in PEM format! (If not, it won't work).

Using Openssl you can use: 

openssl x509 -in <cert> -inform d -outform PEM -out cert.pem 

To create a pem formatted certificate from a binary certificate (the one you get if you download the ca somewhere).

down

Jakub Horky <jakub dot php at horky dot net> ¶

9 years ago


A bit more documentation (without minimum version numbers):



- CURLOPT_WRITEFUNCTION

- CURLOPT_HEADERFUNCTION

  Pass a function which will be called to write data or headers respectively. The callback function prototype:



long write_callback (resource ch, string data)



The ch argument is CURL session handle. The data argument is data received. Note that its size is variable. When writing data, as much data as possible will be returned in all invokes. When writing headers, exactly one complete header line is returned for better parsing.

The function must return number of bytes actually taken care of. If that amount differs from the amount passed to this function, an error will occur.



- CURLOPT_READFUNCTION

  Pass a function which will be called to read data. The callback function prototype:



string read_callback (resource ch, resource fd, long length)



The ch argument is CURL session handle. The fd argument is file descriptor passed to CURL by CURLOPT_INFILE option. The length argument is maximum length which can be returned.

The function must return string containing the data which were read. If length of the data is more than maximum length, it will be truncated to maximum length. Returning anything else than a string means an EOF.



[Note: there is more callbacks implemented in current cURL library but they aren't unfortunately implemented in php curl interface yet.]

down

tim dot php at ebw dot ca ¶

9 years ago


The page http://curl.haxx.se/libcurl/c/curl_easy_setopt.html at the cURL site has a list of all the CURLOPTS, including many not mentioned here. Also see http://curl.haxx.se/libcurl/php/examples/ for cURL examples in PHP.

down

eric at imap dot ch ¶

9 years ago


I managed to use curl to retrieve information from severs on ports other than 80 or 443 (for https) on some installations but not on all. 


If you get an "CURLE_COULDNT_CONNECT /* 7 */" error, try adding the port : (for example)





<?php curl_setopt($ch, CURLOPT_PORT, $_SERVER['SERVER_PORT']); ?>

down

me ¶

10 years ago


Just a reminder: When setting your CURLOPT_POSTFIELDS remember to replace the spaces in your values with %20

down

dweingart at pobox dot com ¶

10 years ago


If you want to Curl to follow redirects and you would also like Curl to echo back any cookies that are set in the process, use this:





<?php curl_setopt($ch, CURLOPT_COOKIEJAR, '-'); ?>





'-' means stdout





-dw

down

Anonymous ¶

10 years ago


beware that not all cURLlib constants are supported under php :


e.g. CURLOPT_PROGRESSFUNCTION or CURLOPT_WRITEDATA are not supported.





CURLOPT_WRITEFUNCTION, although undocumented is supported. It takes the name of a user_defined function.


the function should take two arguments (the curl handle, and the inputdata) and return the length of the written data


e.g.





<?php


function myPoorProgressFunc($ch,$str){


global $fd;


$len = fwrite($fd,$str);


print("#");


return $len;


}





curl_setopt($ch,CURLOPT_WRITEFUNCTION,"myPoorProgressFunc");


?>





Also be aware that CURLOPT_WRITEFUNCTION  does NOT take the CURLOPT_FILE as a parameter! 


in curl lib it would take CURLOPT_WRITEDATA but this is not supported by php; that's why I use "global $fd;" in my exemple function.





CURLOPT_HEADERFUNCTION works the same, and is guaranteed to receive complete header lines as input! 





Hope this helps





Ivan

down

mrcheezy at hotmail dot com ¶

10 years ago


If you set return transfer to 1 and are sending a post form and find that this crashes php try setting follow location to 1 also. I'm not exactly sure why this crashed, but after i used follow it stopped.





<?php


  curl_setopt ($sess, CURLOPT_FOLLOWLOCATION, '1');


  curl_setopt ($sess, CURLOPT_RETURNTRANSFER, '1');


?>

down

paul at zgtec dot com ¶

10 years ago


To make a POST in multipart/form-data mode 


this worked for me, the " \n" at the end of the variables was very important on my OS X server.





<?php





$file = "file_to_upload.txt";


$submit_url = "http://www.example.com/upload_page.php";





$formvars = array("cc"=>"us \n");


$formvars[variable_1] = "bla bla \n";


$formvars[variable_2] = "bla bla \n";


$formvars[variable_3] = "bla bla \n";


$formvars[variable_4] = "bla bla \n";


$formvars[upfile] = "@$file"; // "@" causes cURL to send as file and not string (I believe) 





    // init curl handle


    $ch = curl_init($submit_url);


    curl_setopt($ch, CURLOPT_COOKIEJAR, "my_cookies.txt");  //initiates cookie file if needed


    curl_setopt($ch, CURLOPT_COOKIEFILE, "my_cookies.txt");  // Uses cookies from previous session if exist


    curl_setopt($ch, CURLOPT_REFERER, "http://www.example.net");  //if server needs to think this post came from elsewhere


    curl_setopt($ch, CURLOPT_VERBOSE, 1);


    curl_setopt($ch, CURLOPT_HEADER, 1);


    curl_setopt($ch, CURLOPT_FOLLOWLOCATION,1); // follow redirects recursively


    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);


    curl_setopt($ch, CURLOPT_POSTFIELDS, $formvars);





    // perform post


    echo $pnp_result_page = curl_exec($ch);


    curl_close ($ch);





?>

down

tychay at alumni dot caltech dot edu ¶

11 years ago


CURLOPT_HTTPHEADER is NOT like the -H command line switch. The command line switch adds or replaces headers (much like the header() line in PHP, but for HTTP clients instead of servers), but the curl extension will eliminate the headers cURL sends by default.



For instance, your Authorization, Host, Referer, Pragma, and Accept headers which are normally written by default or by other CURLOPT_*'s.



Also, it might seem intuitive that this should accept an array hash of header->values, but this is not the case. It accepts an array of strings of the format "Header: Value", much like the -H command-line switch.



Hope this helps,



terry

down

bvwj at swbell dot net ¶

11 years ago


To collect cookies recieved with a request, set CURLOPT_COOKIEJAR "cookieFileName".  Then use CURLOPT_COOKIEFILE "cookieFileName" to recall them in subsequent transactions.

down

Anonymous ¶

11 years ago


To make a POST in multipart/form-data mode





(to upload a file for example) you can use 





<?php curl_setopt($ch,CURLOPT_POSTFIELDS,$post); ?>





where $post is an array :





<?php


$post['key1'] = 'data1';


//  like a text field in a POST


$post['file1'] = '@filename1' 


// upload filename1


?>





For more informations see the 





curl_formparse man page.

down

bvr at xs4all dot nl ¶

12 years ago


If you'd like to include extra headers in your POST request, you can accomplish this by setting the following option:





CURLOPT_HTTPHEADER





This is similar to the CURL -H command line switch.





Thanks to Daniel Stenberg for pointing out this usefull feature!





Note: this option was first supported in PHP version 4.03 .

down

awestholm at imail dot usi dot net ¶

12 years ago


Just because the docs are rather sparse on this, to set multiple values in a cookie, you separate them with a semicolon, as usual. An example, yo set j to j and k to k:





<?php curl_setopt($ch,CURLOPT_COOKIE,"j=j;k=k"); ?>





    -- Alex

down

dan dot polansky at seznam dot cz ¶

12 years ago


I used to download www pages to my script and one of the pages was different in MS explorer and different, when I downloaded it. Namely, information, I was really interested in was missing. That was because the server on the other bank of the river was looking at who is downloading the page. Everything got fixed when I pretended I was MSIE. It is done with curl. Here is a function, that you may use in similar situation





<?php


function download_pretending($url,$user_agent) {


   $ch = curl_init();


   curl_setopt ($ch, CURLOPT_URL, $url);


   curl_setopt ($ch, CURLOPT_USERAGENT, $user_agent);


   curl_setopt ($ch, CURLOPT_HEADER, 0);


   curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);


   $result = curl_exec ($ch); 


   curl_close ($ch);


   return $result;


}


?>

down

-1

juozaspo at gmail dot com ¶

7 months ago


I've created an example that gets the file on url passed to script and outputs it to the browser. 



<?php

//get the file (e.g. image) and output it to the browser

$ch = curl_init(); //open curl handle

curl_setopt($ch, CURLOPT_URL, $_GET['url']); //set an url

curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); //do not output directly, use variable

curl_setopt($ch, CURLOPT_BINARYTRANSFER, 1); //do a binary transfer

curl_setopt($ch, CURLOPT_FAILONERROR, 1); //stop if an error occurred

$file=curl_exec($ch); //store the content in variable

if(!curl_errno($ch))

{

    //send out headers and output

    header ("Content-type: ".curl_getinfo($ch, CURLINFO_CONTENT_TYPE)."");

    header ("Content-Length: ".curl_getinfo($ch, CURLINFO_CONTENT_LENGTH_DOWNLOAD)."");

    echo $file;

} else echo 'Curl error: ' . curl_error($ch);

curl_close($ch); //close curl handle

?>



p.s. Make sure that there're no new lines before and after code or script may not work.

down

-1

support at lostair dot com ¶

2 years ago


Force Curl Request To Go To A Particular IP Address





Yes, there is a method of passing an IP address to curl.  Excellent for services with multiple IP addresses and also to take DNS out of the equation for testing/debugging.





<?php


    function fetch_page($url, $host_ip = NULL)


    {





      $ch = curl_init();





      if (!is_null($host_ip))


      {


        $urldata = parse_url($url);





        //  Ensure we have the query too, if there is any...


        if (!empty($urldata['query']))


          $urldata['path'] .= "?".$urldata['query'];





        //  Specify the host (name) we want to fetch...


        $headers = array("Host: ".$urldata['host']);


        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);





        //  create the connecting url (with the hostname replaced by IP)


        $url = $urldata['scheme']."://".$host_ip.$urldata['path'];


      }





      curl_setopt($ch,  CURLOPT_URL, $url);


      curl_setopt ($ch, CURLOPT_HEADER, 0);


      curl_setopt($ch,  CURLOPT_RETURNTRANSFER, true);





      $result = curl_exec ($ch);


      curl_close ($ch);





      return $result;


    }


?>

down

-1

curlysue ¶

2 years ago


If you've got problems with connecting througth a proxy using php/apache/xampp. So if you get no result string from the exec function, try enabling the following options in apache.



...\xampp\apache\conf

LoadModule proxy_module modules/mod_proxy.so

LoadModule proxy_http_module modules/mod_proxy_http.so



cURL seems to neet this modules.

down

-1

php dot net at NO dot sgerrand dot SPAM dot com ¶

3 years ago


If you change the post array to a string, PHP creates the post data successfully.





As a quick and dirty example of implementing this fix:





<?php





$ch = curl_init;


$url = 'http://www.example.com';





curl_setopt($ch, CURLOPT_URL, $url);


curl_setopt($ch, CURLOPT_POST, true);





foreach ($postData as $var) if (strpos($var, '@') === 0) {


    $postAsString = true;


}





if ($postAsString === true) {


    $str = '';





    foreach ($postData as $key => $val) {


        $str .= '&' . $key . '=' . $val;


    }





    $postData = substr_replace($str, '', 0, 1);


}





curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);





curl_exec($ch);





?>

down

-1

rkirilow at gmail dot com ¶

4 years ago


Some of you may noticed that curl is not transferring cookies between sequent calls to a host. This is because you must activate curl`s "cookie parser". That is achieved using an external file like this:


<?php


curl_setopt(CURLOPT_FILE, '/tmp/cookies_file');


?>


If you don`t need to read any cookies but you still want the "cookie parser" use the same code but with dummy file with no data like '/dev/null', that way curl is storing cookies internaly per curl_handle:


<?php


curl_setopt(CURLOPT_FILE, '/dev/null');


?>





[EDIT BY danbrown AT php DOT net: In a note dated 26-SEP-08, (adamplumb AT gmail DOT com) offered the following addendum:





[It] should really be CURLOPT_COOKIEFILE.  I was bitten by this issue myself with code that previously worked for logging into a website and posting a form.  However, at some point the code just stopped working, and I eventually found that I needed to set this option to /dev/null for it to work.


]

down

-1

Ojas Ojasvi ¶

5 years ago


<?php


/*


* Author: Ojas Ojasvi


* Released: September 25, 2007


* Description: An example of the disguise_curl() function in order to grab contents from a website while remaining fully camouflaged by using a fake user agent and fake headers.


*/





$url = 'http://www.php.net';





// disguises the curl using fake headers and a fake user agent.


function disguise_curl($url)


{


  $curl = curl_init();





  // Setup headers - I used the same headers from Firefox version 2.0.0.6


  // below was split up because php.net said the line was too long. :/


  $header[0] = "Accept: text/xml,application/xml,application/xhtml+xml,";


  $header[0] .= "text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5";


  $header[] = "Cache-Control: max-age=0";


  $header[] = "Connection: keep-alive";


  $header[] = "Keep-Alive: 300";


  $header[] = "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7";


  $header[] = "Accept-Language: en-us,en;q=0.5";


  $header[] = "Pragma: "; // browsers keep this blank.





  curl_setopt($curl, CURLOPT_URL, $url);


  curl_setopt($curl, CURLOPT_USERAGENT, 'Googlebot/2.1 (+http://www.google.com/bot.html)');


  curl_setopt($curl, CURLOPT_HTTPHEADER, $header);


  curl_setopt($curl, CURLOPT_REFERER, 'http://www.google.com');


  curl_setopt($curl, CURLOPT_ENCODING, 'gzip,deflate');


  curl_setopt($curl, CURLOPT_AUTOREFERER, true);


  curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);


  curl_setopt($curl, CURLOPT_TIMEOUT, 10);





  $html = curl_exec($curl); // execute the curl command


  curl_close($curl); // close the connection





  return $html; // and finally, return $html


}





// uses the function and displays the text off the website


$text = disguise_curl($url);


echo $text;


?>





Ojas Ojasvi

down

-1

phpnet at wafflehouse dot de ¶

7 years ago


Resetting CURLOPT_FILE to STDOUT won't work by calling curl_setopt() with the STDOUT constant or a php://output stream handle (at least I get error messages when trying the code from phpnet at andywaite dot com). Instead, one can simply reset it as a side effect of CURLOPT_RETURNTRANSFER. Just say





<?php curl_setopt($this->curl,CURLOPT_RETURNTRANSFER,0); ?>





and following calls to curl_exec() will output to STDOUT again.

down

-1

raul at navenetworks dot com ¶

8 years ago


Hi!



I have found some information I am sure it could help lot of programmers when they want to connect with curl to any https website and they haven't a good or right CA Cert :)



I give you just one example It has resolved me 2 hours of my time looking for a solution.



It is simple, just if you get any error in the curl_exec (use curl_error(...) to see the error to trace it) add the next line and everything is solved:



(note: replace $ch with the right curl variable)



curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);



<?php



$ch = curl_init();

$res= curl_setopt ($ch, CURLOPT_URL,"https://yoururl/cgi");



curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);

curl_setopt ($ch, CURLOPT_HEADER, 0);

curl_setopt($ch, CURLOPT_POST, 1);

curl_setopt($ch, CURLOPT_POSTFIELDS, "Idc=si&");

curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);

$xyz = curl_exec ($ch);



curl_close ($ch);

echo $xyz;

if ($xyz == NULL) { 

           echo "Error:<br>";

           echo curl_errno($ch) . " - " . curl_error($ch) . "<br>";

}

?>



I hope this helps.



Raul Mate Galan

Ceo Navenetworks Corp.



Note: Thanks to Ruben Lopez Gea for his help too.

down

-1

asmith at crawlspace dot com ¶

11 years ago


It's possible to take advantage of multiple URLs on the same host in one curl_exec transaction ... just use multiple instances of CURLOPT_URL.





Example:





<?php


$ch = curl_init();


curl_setopt($ch, CURLOPT_URL, "http://example.com/a.html");


curl_setopt($ch, CURLOPT_URL, "http://example.com/b.html");


curl_setopt($ch, CURLOPT_URL, "http://example.com/c.html");


curl_exec($ch);


curl_close($ch);


?>





... the URLs appear to be hit in the same order they are entered. This takes advantage of cURL's Persistant Connection capability if all the URLs are on the same host!

down

-1

sr2899.at.hotmail.com ¶

12 years ago


CURLOPT_RETURNTRANSFER has the interesting behaviour of tacking a null char onto the end of the string.  This null char is actually on the end of the php string, and can cause some odd results if you're not expecting it to be there.

down

-2

sleepwalker at rahulsjohari dot com ¶

5 years ago


Two things that I noted, one of which has been mentioned earlier, if you are connecting to an SSL site (https) and don't have the appropriate certificate, don't forget to set CURLOPT_SSL_VERIFYPEER as "false"... it's set to "true" by default. Scratched my head over 2 hours to figure this one out as I had a machine with an older version installed and everything worked fine without using this option on that one - but failed on other machines with newer versions.





Second very important thing, I've never had my scripts work (tried on various machines, multiple platforms) with a Relative path to a COOKIEJAR or COOKIEFILE. In my experience I HAVE to specify the absolute path and not the relative path. 





Small script I wrote to connect to a page, gather all cookies into a jar, connect to another page to login, taking the cookiejar with you for authentication:





<?php


$ch = curl_init();


curl_setopt($ch, CURLOPT_COOKIEJAR, "/Library/WebServer/Documents/tmp/cookieFileName");


curl_setopt($ch, CURLOPT_URL,"https://www.example.com/myaccount/start.asp");


curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);


ob_start();      // Prevent output


curl_exec ($ch);


ob_end_clean();  // End preventing output


curl_close ($ch);


unset($ch);





$ch = curl_init();


curl_setopt($ch, CURLOPT_POST, 1);


curl_setopt($ch, CURLOPT_POSTFIELDS, "field1=".$f1."&field2=".$f2."&SomeFlag=True");


curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);


curl_setopt($ch, CURLOPT_COOKIEFILE, "/Library/WebServer/Documents/tmp/cookieFileName");


curl_setopt($ch, CURLOPT_URL,"https://www.example.com/myaccount/Login.asp");


curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);


curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);


$result = curl_exec ($ch);


curl_close ($ch);


?>

down

-3

null at nahdah dot com ¶

6 years ago


I was having problems with Authorize.net and the SSL cert matching even after adding:





<?php


curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);


?>





What I found after a lot of stumbling was I needed to set VERIFYHOST to FALSE.  So if you are still have a problem with Authorize.NET SSL and cURL add this:





<?php


curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);


?>

add a note