curl_setopt

(PHP 4 >= 4.0.2, PHP 5, PHP 7, PHP 8)

curl_setopt — Configura una opción para una transferencia cURL

Descripción

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

Establece una opción en la sesión del recurso cURL.

Parámetros

ch

El recurso cURL devuelto por curl_init().

option

La opción CURLOPT_XXX a configurar.

value

Valor a configurar en la option.

value debe ser un bool para los siguientes valores del parámetro option:

Opción	Establecer `value` a	Notas
`CURLOPT_AUTOREFERER`	`true` para automáticamente establecer el valor del campo `Referer:` en peticiones que siguen una redireción `Location:`.
`CURLOPT_BINARYTRANSFER`	`true` para devolver el resultado sin tratar `CURLOPT_RETURNTRANSFER` está activado.	Desde PHP 5.1.3, esta opción no tiene efecto: el resultado sin tratar será siempre retornado cuando `CURLOPT_RETURNTRANSFER` sea usado.
`CURLOPT_COOKIESESSION`	`true` para usarse como una nueva cookie de "sesión". Forzará libcurl a ignorar todas las cookies, se trata de cargar estas "cookies de sesión" de la sesión anterior. Por defecto, libcurl siempre guarda y carga todas las cookies, independientemente si hay cookies de sesión o no. Las cookies de sesión son cookies sin fecha de caducidad y estan pensadas para mantenerse activas y solo existir para esta "sesión".
`CURLOPT_CERTINFO`	`true` para mostrar información sobre certificación SSL al `STDERR` en transferencias seguras.	Añadido en cURL 7.19.1 Disponible desde PHP 5.3.2. Requiere `CURLOPT_VERBOSE` activado para que tenga efecto.
`CURLOPT_CONNECT_ONLY`	`true` le dice a la biblioteca que realice todas las autenticaciones de proxy requeridas y la configuración de la conexión, pero no la transferencia de datos. Esta opción se implementa para HTTP, SMTP y POP3.	Aladida en 7.15.2. Disponbible desde PHP 5.5.0.
`CURLOPT_CRLF`	`true` para convertir nuevas líneas Unix a nuevas líneas CRLF en transferencias.
`CURLOPT_DNS_USE_GLOBAL_CACHE`	`true` para usar caché DNS global. Esta opción no es thread-safe y está activada por defecto.
`CURLOPT_FAILONERROR`	`true` para fallar con verbosidad si el código HTTP devuelto es mayor o igual que 400. El comportamiento por defecto es devolver la página normalmente, ignornado el código.
`CURLOPT_SSL_FALSESTART`	`true` para habilitar el inicio falso de TLS.	Añadida en cURL 7.42.0. Disponible desde PHP 7.0.7.
`CURLOPT_FILETIME`	`true` para intentar obtener la fecha de modificación del documento. Este valor puede obtenerse usando la opción `CURLINFO_FILETIME` con curl_getinfo().
`CURLOPT_FOLLOWLOCATION`	`true` para seguir cualquier encabezado `"Location: "` que el servidor envíe como parte del encabezado HTTP (observe la recursividad, PHP seguirá tantos header `"Location: "` como se envíen, a no ser que la opción `CURLOPT_MAXREDIRS` esté establecida).
`CURLOPT_FORBID_REUSE`	`true` para forzar a cerrar explicitamente la conexión cuando se finalice el proceso y no guardarla para su reuso.
`CURLOPT_FRESH_CONNECT`	`true` para forzar el uso de una nueva conexión en lugar de usar una en caché.
`CURLOPT_FTP_USE_EPRT`	`true` para usar EPRT (y LPRT) cuando se hacen descargas FTP activas. Use `false` para desactivar EPRT y LPRT y usar PORT solamente.
`CURLOPT_FTP_USE_EPSV`	`true` para probar primero el comando EPSV para transferencias FTP antes de volver a PASV. Establezca la opción a `false` para desactivar EPSV.
`CURLOPT_FTP_CREATE_MISSING_DIRS`	`true` para crear directorios faltantes cuando una operación se encuentra con una ruta que actualmente no existe.
`CURLOPT_FTPAPPEND`	`true` para añadir al fichero remoto en lugar de sobreescribirlo.
`CURLOPT_TCP_NODELAY`	`true` para deshabilitar el algoritmo de TCP de Nagle, el cual intenta minimizar el número de paquetes pequeños en la red.	Disponible desde PHP 5.2.1 para versiones compiladas con libcurl 7.11.2 o superior.
`CURLOPT_FTPASCII`	Un alias de `CURLOPT_TRANSFERTEXT`. Para usar en su lugar.
`CURLOPT_FTPLISTONLY`	`true` para solo listar los nombres de un directorio FTP directorio.
`CURLOPT_HEADER`	`true` para incluir el header en el output.
`CURLINFO_HEADER_OUT`	`true` para seguir la cadena de la petición del recurso.	Disponible desde PHP 5.1.3. El prefijo `CURLINFO_` es intencionado.
`CURLOPT_HTTPGET`	`true` para resetear la petición HTTP a GET. Puesto que GET es el método por defecto, solo es necesario si el método fue cambiado.
`CURLOPT_HTTPPROXYTUNNEL`	`true` para usar un tunel a través de un proxy HTTP.
`CURLOPT_MUTE`	`true` para completar silenciosamente en lo que se refiere a las funciones cURL.	Eliminado en cURL 7.15.5 (Se puede usar CURLOPT_RETURNTRANSFER en su lugar)
`CURLOPT_NETRC`	`true` para escanear el fichero `~/.netrc` y buscar un usuario y contraseña para establecer una conexión con el sitio remoto.
`CURLOPT_NOBODY`	`true` para excluir el body del output. El método de petición es establecido a HEAD. Si se cambia a `false` no cambia el método a GET.
`CURLOPT_NOPROGRESS`	`true` para desactivar medidor de progreso para transferencias cURL. Nota: PHP automáticamente establece esta opción a `true`, solo debería cambiarse para razones de testing.
`CURLOPT_NOSIGNAL`	`true` para ignorar cualquier función cURL que cause una señal a ser enviada al proceso PHP. Esta opción está activada por defecto en multi-hilo SAPI, entonces las opciones de timeout pueden ser usadas.	Añadido en cURL 7.10.
`CURLOPT_PATH_AS_IS`	`true` para no manejar secuencias de puntos.	Añadida en cURL 7.42.0. Disponible desde PHP 7.0.7.
`CURLOPT_PIPEWAIT`	`true` para esperar por 'pipelining'/multiplexación.	Añadida en cURL 7.43.0. Disponible desde PHP 7.0.7.
`CURLOPT_POST`	`true` para hacer un HTTP POST normal. Este POST del tipo `application/x-www-form-urlencoded`, el más común en formularios HTML.
`CURLOPT_PUT`	`true` para hacer un HTTP PUT de un fichero. El fichero a subir debe establecerse en `CURLOPT_INFILE` y `CURLOPT_INFILESIZE`.
`CURLOPT_RETURNTRANSFER`	`true` para devolver el resultado de la transferencia como string del valor de curl_exec() en lugar de mostrarlo directamente.
`CURLOPT_SAFE_UPLOAD`	`true` para deshabilitar el soporta para el prefijo `@` para cargar ficheros en `CURLOPT_POSTFIELDS`, lo que significa que los valores que empiecen por `@` pueden ser pasados de forma segura como campos. Se podría usar CURLFile en su lugar para las cargas.	Añadido en PHP 5.5.0 con `false` como valor predeterminado. PHP 5.6.0 cabia este valor predeterminado a `true`. PHP 7 elimina esta opción; la interfaz de CURLFile debe emplearse para subir ficheros.
`CURLOPT_SASL_IR`	`true` para habilitar el envío de la respuesta inicial en el primer paquete.	Añadida en cURL 7.31.10. Disponible desde PHP 7.0.7.
`CURLOPT_SSL_ENABLE_ALPN`	`false` para inhabilitar ALPN en la negociación de SSL (si libcurl del «backend» de SSL está construido para admitirla), lo cual se puede usar para negiaciar http2.	Añadida en cURL 7.36.0. Disponible desde PHP 7.0.7.
`CURLOPT_SSL_ENABLE_NPN`	`false` para inhabilitar NPN en la negociación de SSL (si libcurl del «backend» de SSL está construido para admitirla), lo cual se puede usar para negiaciar http2.	Añadida en cURL 7.36.0. Disponible desde PHP 7.0.7.
`CURLOPT_SSL_VERIFYPEER`	`false` para que cURL no verifique el peer del certificado. Para usar diferentes certificados para la verificación se pueden especificar con la opción `CURLOPT_CAINFO` o se puede especificar el directorio donde se encuentra el certificado con la opción `CURLOPT_CAPATH`.	`true` por omisión desde cURL 7.10. Paquete instalado por defecto en la versión CURL 7.10.
`CURLOPT_SSL_VERIFYSTATUS`	`true` para verificar el estado del certificado.	Añadida en cURL 7.41.0. Disponible desde PHP 7.0.7.
`CURLOPT_TCP_FASTOPEN`	`true` Para habilitar la Apertura Rápida de TCP (TCP Fast Open).	Añadida en cURL 7.49.0. Disponible desde PHP 7.0.7.
`CURLOPT_TFTP_NO_OPTIONS`	`true` para no enviar peticiones de opciones de TFTP.	Añadida en cURL 7.48.0. Disponible desde PHP 7.0.7.
`CURLOPT_TRANSFERTEXT`	`true` para usar modo ASCII para transferencias FTP. En LDAP, obtiene los datos en texto plano en lugar de HTML. En sistemas Windows, no estabecerá `STDOUT` en modo binario.
`CURLOPT_UNRESTRICTED_AUTH`	`true` para prevenir el envio de usuario y contraseña cuando se siguen locations (usando `CURLOPT_FOLLOWLOCATION`), incluso cuando el hostname es diferente.
`CURLOPT_UPLOAD`	`true` preparar cURL para subir un fichero.
`CURLOPT_VERBOSE`	`true` para mostrar información verbose. Escribe la salida en `STDERR`, o el fichero especificado usando `CURLOPT_STDERR`.

value debe ser un integer para los siguientes valores del parámetro option:

Opción	Establecer `value` a	Notas
`CURLOPT_BUFFERSIZE`	Tamaño del búfer a usar por cada lectura. De todas formas, no hay ninguna garantía de que la petición usará todo el búfer.	Añadido en cURL 7.10.
`CURLOPT_CLOSEPOLICY`	Uno de los valores de *`CURLCLOSEPOLICY_`. Nota**: Esta opción está obsoleta, ya que nunca se ha implementado en cURL, por lo que nunca ha tenido ningún efecto.	Eliminada en PHP 5.6.0.
`CURLOPT_CONNECTTIMEOUT`	Número de segundos a esperar cuando se está intentado conectar. Use 0 para esperar indefinidamente.
`CURLOPT_CONNECTTIMEOUT_MS`	Número de milisegundos a esperar cuando se está intentado conectar. Use 0 para esperar indefinidamente. Si se ha compilado libcurl para utilizar el sistema estándar de resolución de nombres, esta porción de conexión utilizará una resolución completa de un segundo en tiempos de expiración, con un mínimo permitido de un segundo.	Añadido en cURL 7.16.2. Disponible desde PHP 5.2.3.
`CURLOPT_DNS_CACHE_TIMEOUT`	Número de segundos a mantener las entradas DNS en memoria. Esta opción está establecida a 120 (2 minutos) por defecto.
`CURLOPT_EXPECT_100_TIMEOUT_MS`	El tiempo de espera para respuestas «Expect: 100-continue», en milisegundos. El valor predeterminado es 1000 milisegundos.	Añadida en cURL 7.36.0. Disponible desde PHP 7.0.7.
`CURLOPT_FTPSSLAUTH`	Método de autenticación FTP (cuando está activado): `CURLFTPAUTH_SSL` (prueba SSL primero), `CURLFTPAUTH_TLS` (prueba TLS primero), o `CURLFTPAUTH_DEFAULT` (hacer que cURL decida).	Añadido en cURL 7.12.2.
`CURLOPT_HEADEROPT`	Cómo tratar con cabeceras. una de las siguientes constantes: `CURLHEADER_UNIFIED`: las cabeceras especificadas en `CURLOPT_HTTPHEADER` se usarán en peticiones tanto a servidores como a proxies. Con esta opción habilitada, `CURLOPT_PROXYHEADER` no tendrá efecto. `CURLHEADER_SEPARATE`: hace que las cabeceras `CURLOPT_HTTPHEADER` solamente sean enviadas a un servidor y no a un proxy. Las cabeceras de proxies deben establecerse con `CURLOPT_PROXYHEADER` para poder usarlas. Observe que si se envía una petición no CONNECT a un proxy, libcurl enviará tanto las cabeceras de servidor como del proxy. Al realizar CONNECT, libcurl enviará cabeceras `CURLOPT_PROXYHEADER` solamente al proxy y luego cabeceeras `CURLOPT_HTTPHEADER` solamente al servidor. Lo predeterminado es `CURLHEADER_SEPARATE` a partir de cURL 7.42.1, y `CURLHEADER_UNIFIED` anteriormente.	Añadida en cURL 7.37.0. Disponible desde PHP 7.0.7.
`CURLOPT_HTTP_VERSION`	`CURL_HTTP_VERSION_NONE` (por defecto, hacer que CURL decida que versión a usar), `CURL_HTTP_VERSION_1_0` (fuerza HTTP/1.0), or `CURL_HTTP_VERSION_1_1` (fuerza HTTP/1.1).
`CURLOPT_HTTPAUTH`	Los métodos de autenticación HTTP. Las opciones son: `CURLAUTH_BASIC`, `CURLAUTH_DIGEST`, `CURLAUTH_GSSNEGOTIATE`, `CURLAUTH_NTLM`, `CURLAUTH_ANY`, y `CURLAUTH_ANYSAFE`. El separador `\|` o operador puede ser usado para combinar más de un método. Si se utiliza, cURL comprobará en el servidor remoto que métodos soporta y utilizará el más adecuado. `CURLAUTH_ANY` es un alias para `CURLAUTH_BASIC \| CURLAUTH_DIGEST \| CURLAUTH_GSSNEGOTIATE \| CURLAUTH_NTLM`. `CURLAUTH_ANYSAFE` es un alias para `CURLAUTH_DIGEST \| CURLAUTH_GSSNEGOTIATE \| CURLAUTH_NTLM`.
`CURLOPT_INFILESIZE`	El tamaño esperado en bytes, del fichero cuando se está subiendo un fichero al sitio remoto. Téngase en cuenta que el uso de esta opción no detendrá libcurl a la hora de enviar más datos, exactamente lo que se envía depende de `CURLOPT_READFUNCTION`.
`CURLOPT_LOW_SPEED_LIMIT`	La velocidad de transferencia, en bytes por segundo, que la transferencia debería estar por debajo durante `CURLOPT_LOW_SPEED_TIME` segundos para PHP a considerar que la transferencia es demasiado lenta y debe abortarse.
`CURLOPT_LOW_SPEED_TIME`	Número en segundos en que la velocidad de transferencia debería estar debajo de `CURLOPT_LOW_SPEED_LIMIT` antes que PHP considere que la transferencia es demasiado lenta y debe abortarse.
`CURLOPT_MAXCONNECTS`	Número máximo de conexiones persistentes que están permitidas. Cuando se llega al límite, se utiliza `CURLOPT_CLOSEPOLICY` para determinar que conexión debe cerrarse.
`CURLOPT_MAXREDIRS`	Número máximo de redirecciones HTTP a seguir. Use esta opción con `CURLOPT_FOLLOWLOCATION`.
`CURLOPT_PORT`	Puerto alternativo a conectarse.
`CURLOPT_POSTREDIR`	Una máscara de bit de 1 (301 Movido permanentemente), 2 (302 Encontrado) y 4 (303 Ver otro) si el método POST de HTTP debería ser mantenido cuando `CURLOPT_FOLLOWLOCATION` está establecido y ocurre un tipo específico o una redirección.	Añadido en cURL 7.19.1. Disponible des PHP 5.3.2.
`CURLOPT_PROTOCOLS`	Máscara de los valores *`CURLPROTO_`. Si se utiliza, esta máscara limitará que protocolos utilizará libcurl en transferencias. Permite que libcurl utilice cualquiera de los protocolos pero limita que grupo de protocolos a usar en específicas transferencias. Por defecto libcurl acepta todos los protocolos. Vea también: `CURLOPT_REDIR_PROTOCOLS`**. Las opciones para válidos procolos son: `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`	Añadido en cURL 7.19.4.
`CURLOPT_PROXYAUTH`	Método de autenticación HTTP para usar conexiones vía proxy. Usa el mismo tipo de máscaras descritas en `CURLOPT_HTTPAUTH`. Para autenticación proxy, solamente `CURLAUTH_BASIC` y `CURLAUTH_NTLM` están actualmente soportadas.	Añadido en cURL 7.10.7.
`CURLOPT_PROXYPORT`	Número del puerto para usar en la conexión proxy. Este puerto también puede configurase en `CURLOPT_PROXY`.
`CURLOPT_PROXYTYPE`	Puede ser `CURLPROXY_HTTP` (por defecto), `CURLPROXY_SOCKS4`, `CURLPROXY_SOCKS5`, `CURLPROXY_SOCKS4A` o `CURLPROXY_SOCKS5_HOSTNAME`.	Añadido en cURL 7.10.
`CURLOPT_REDIR_PROTOCOLS`	Máscara de valores *`CURLPROTO_`. Si se usa, esta máscara limitará que protocolos usará libcurl en una transferencia que sigue una redireción cuando `CURLOPT_FOLLOWLOCATION` está activado. Esto permite limitar a específicas transferencias que grupo de protocolos utilizar en redireciones. Por defecto libcurl aceptará todos los protocolos excepto FILE y SCP. Esto es nuevo si se compara con versiones anteriores a 7.19.4 donde se seguían incodicionalmente todos los protocolos soportados. Vea también `CURLOPT_PROTOCOLS`** para los valores de las constantes.	Añadido en cURL 7.19.4.
`CURLOPT_RESUME_FROM`	El punto, en bytes desde donde continuar una transferencia.
`CURLOPT_SSL_OPTIONS`	Establecer las opciones de funcionamento de SSL, las cuales son una máscara de bits de las siguientes constantes: `CURLSSLOPT_ALLOW_BEAST`: no intentar usar ningún método alternativo para defectos de seguridad en los protocolos SSL3 y TLS1.0. `CURLSSLOPT_NO_REVOKE`: inhabilitar la comprobación de revocación de certificados para aquellos «backends» de SSL donde tal funcionamiento está presente.	Añadida en cURL 7.25.0. Disponible desde PHP 7.0.7.
`CURLOPT_SSL_VERIFYHOST`	`1` para comprobar que existe un nombre común en el peer del certificado SSL. `2` para comprobar que existe un nombre común y también para verificar que el hostname coinicide con el proporcionado. `0` para no comprobar nombres. En entornos de producción el valor de esta opción debe mantenerse a `2` (valor predeterminado).	Soporte para el valor `1` eliminado en cURL 7.28.1
`CURLOPT_SSLVERSION`	Una de las constantes `CURL_SSLVERSION_DEFAULT` (0), `CURL_SSLVERSION_TLSv1` (1), `CURL_SSLVERSION_SSLv2` (2), `CURL_SSLVERSION_SSLv3` (3), `CURL_SSLVERSION_TLSv1_0` (4), `CURL_SSLVERSION_TLSv1_1` (5) o `CURL_SSLVERSION_TLSv1_2` (6). Nota: Lo mejor es no establecerlo y dejar el valor predeterminado. Establecerlo a 2 o 3 es muy peligroso dadas las vulnerabilidades conocidas en SSLv2 y SSLv3.
`CURLOPT_STREAM_WEIGHT`	Establecer el peso del flujo numérico (un número entre 1 y 256).	Añadida en cURL 7.46.0. Disponible desde PHP 7.0.7.
`CURLOPT_TIMECONDITION`	Como se trata `CURLOPT_TIMEVALUE`. Utilice `CURL_TIMECOND_IFMODSINCE` para devolver la página solamente si fue modificada desde el tiempo especificado en `CURLOPT_TIMEVALUE`. Si no fué modificada, se devolverá `"304 Not Modified"` en el header asumiendo que `CURLOPT_HEADER` es `true`. Utilice `CURL_TIMECOND_IFUNMODSINCE` para el efecto contrario. `CURL_TIMECOND_IFMODSINCE` está activado por defecto.
`CURLOPT_TIMEOUT`	Número máximo de segundos permitido para ejectuar funciones cURL.
`CURLOPT_TIMEOUT_MS`	Número máximo en milisegundos permitido para ejecutar funciones cURL. Si se ha compilado libcurl para utilizar el sistema estándar de resolución de nombres, esta porción de conexión utilizará una resolución completa de un segundo en tiempos de expiración, con un mínimo permitido de un segundo.	Añadido en cURL 7.16.2. Disponible desde PHP 5.2.3.
`CURLOPT_TIMEVALUE`	Tiempo en segundos desde el 1 de enero de 1970. El tiempo será usado por `CURLOPT_TIMECONDITION`. Por defecto, se utiliza `CURL_TIMECOND_IFMODSINCE`.
`CURLOPT_MAX_RECV_SPEED_LARGE`	Si una descarga supera esta velocidad (en bytes por segundo) en su tasa media de transferencia, ésta se detendrá temporalmente para mantener la media igual o inferior al valor del parámetro. Por omisión, la velocidad es ilimitada.	Añadido en cURL 7.15.5. Disponible desde PHP 5.4.0.
`CURLOPT_MAX_SEND_SPEED_LARGE`	Si una subida supera esta velocidad (en bytes por segundo) en su tasa media de transferencia, ésta se detendrá temporalmente para mantener la media igual o inferior al valor del parámetro. Por omisión, la velocidad es ilimitada.	Añadido en cURL 7.15.5. Disponible desde PHP 5.4.0.
`CURLOPT_SSH_AUTH_TYPES`	Una máscara de bits que consta de una o más de `CURLSSH_AUTH_PUBLICKEY`, `CURLSSH_AUTH_PASSWORD`, `CURLSSH_AUTH_HOST`, `CURLSSH_AUTH_KEYBOARD`. Establece a `CURLSSH_AUTH_ANY` para que libcurl elija uno.	Añadido en cURL 7.16.1.
`CURLOPT_IPRESOLVE`	Permite a una aplicación seleccionar el tipo de dirección IP a usar cuando se resuelven nombres de host. Esto es interesante solamente al usar nombres de host que resuelven direcciones usando más de una versión de IP. Los valores posibles son `CURL_IPRESOLVE_WHATEVER`, `CURL_IPRESOLVE_V4`, `CURL_IPRESOLVE_V6`; el predeterminado es `CURL_IPRESOLVE_WHATEVER`.	Añadida en cURL 7.10.8.
`CURLOPT_FTP_FILEMETHOD`	Indicar a curl qué método empelar para alcanzar un fichero en un servidor FTP(S). Los valores posibles son `CURLFTPMETHOD_MULTICWD`, `CURLFTPMETHOD_NOCWD` y `CURLFTPMETHOD_SINGLECWD`.	Añadida en cURL 7.15.1. Disponible desde PHP 5.3.0.

El value debe ser una string para los siguientes valores del parámetro option:

Opción	Configurar `value` a	Notas
`CURLOPT_CAINFO`	Nombre del fichero que contiene uno o más certificados para verificar el peer. Solo tiene sentido cuando se utiliza en combinación de `CURLOPT_SSL_VERIFYPEER`.	Podría requerir una ruta absoluta.
`CURLOPT_CAPATH`	Directorio que contiene múltiple certificados CA. Utilice esta opción junto con `CURLOPT_SSL_VERIFYPEER`.
`CURLOPT_COOKIE`	Contenido de `"Cookie: "` del header para ser usado en la petición HTTP. Observe que múltiples cookies van separadas con punto y coma seguidas por un espacio (ej., "`fruit=apple; colour=red`")
`CURLOPT_COOKIEFILE`	Nombre del fichero que contiene datos de las cookies. El fichero de cookies puede estar en formato Netscape, o simplemente tipo HTTP plano dentro de un fichero. Si el nombre es una cadena vacía, no se cargarán cookies, aunque el manejo de cookies aún está habilitado.
`CURLOPT_COOKIEJAR`	Nombre del fichero donde guardar cookies internas cuando se cierra se cierra, por e.j. después de llamar a curl_close.
`CURLOPT_CUSTOMREQUEST`	Método de petición personalizado a usar en lugar de `"GET"` o `"HEAD"` cuando se realiza una petición HTTP. Es útil para hacer `"DELETE"` o otros tipos de peticiones HTTP menos comunes. `"GET"`, `"POST"`, `"CONNECT"` y otros, son valores válidos. Ej. No introduzca toda la petición HTTP aquí, seria incorrecto introducir: `"GET /index.html HTTP/1.0\r\n\r\n"`. Nota: No cambie este valor sin antes asegurarse que el servidor soporta el método de petición personalizado.
`CURLOPT_DEFAULT_PROTOCOL`	El protocolo predeterminado a usar si al URL le falta un nombre de esquema.	Añadida en cURL 7.45.0. Disponible desde PHP 7.0.7.
`CURLOPT_DNS_INTERFACE`	Establecer el nombre de la interfaz de red a la que el resolvente de DNS debe vincularse. Debe ser un nombre de interfaz (no una dirección).	Añadida en cURL 7.33.0. Disponible desde PHP 7.0.7.
`CURLOPT_DNS_LOCAL_IP4`	Establecer la dirección IPv4 local a la que debe vincularse el resolvente. El argumento debe contener una dirección IPv4 numérica dada como cadena.	Añadida en cURL 7.33.0. Disponible desde PHP 7.0.7.
`CURLOPT_DNS_LOCAL_IP6`	Establecer la dirección IPv6 local a la que debe vincularse el resolvente. El argumento debe contener una dirección IPv6 numérica dada como cadena.	Añadida en cURL 7.33.0. Disponible desde PHP 7.0.7.
`CURLOPT_EGDSOCKET`	Es como `CURLOPT_RANDOM_FILE`, con excepción que en lugar de un fichero se utiliza un Entropy Gathering Daemon socket.
`CURLOPT_ENCODING`	Contenido del valor `"Accept-Encoding: "` en el header. Esto permite decodificar la respuesta. Los formatos de codificación disponibles son `"identity"`, `"deflate"`, y `"gzip"`. Si el valor se envía vacío, `""`, se enviarán todos los tipos de condificación soportados.	Añadido en cURL 7.10.
`CURLOPT_FTPPORT`	El valor que será usando para obtener la dirección IP a usar para la instrucción FTP "PORT". La instrucción "PORT" dice al servidor remoto a qué dirección IP se debe conectar. La cadena puede ser una dirección IP, el nombre de un servidor o un interfaz de red (bajo Unix), o simplemente '-' para usar la dirección IP por defecto del sistema.
`CURLOPT_INTERFACE`	Nombre del interfaz de salida a usar. Puede ser el nombre del interfaz, una dirección IP o el nombre de un servidor.
`CURLOPT_KEYPASSWD`	El password requerido para usar la clave privada `CURLOPT_SSLKEY` o `CURLOPT_SSH_PRIVATE_KEYFILE`.	Añadido en cURL 7.16.1.
`CURLOPT_KRB4LEVEL`	Nivel de seguridad KRB4 (Kerberos 4). Cualquiera de los siguientes valores (en orden de menos a más potentes) son válidos: `"clear"`, `"safe"`, `"confidential"`, `"private".`. Si la cadena no coincide con alguno de estos valores, será usado `"private"`. Configure esta opción a `null` para desactivar seguridad KRB4. Actualmente la seguridad KRB4 solo funciona con transaciones FTP.
`CURLOPT_LOGIN_OPTIONS`	Se puede usar para establecer las opciones de inicio de sesión específicas del protocolo, tales como el mecanismoe de autenticación preferido mediante "AUTH=NTLM" o "AUTH=", debiéndose ser usada junto con la opción `CURLOPT_USERNAME`*.	Añadida en cURL 7.34.0. Disponible desde PHP 7.0.7.
`CURLOPT_PINNEDPUBLICKEY`	Establecer la clave pública fijada. La cadena puede ser el nombre de fichero de la clave pública fijada. El formato de fichero esperado es "PEM" o "DER". La cadena también puede ser cualquier númbero de «hashes» sha256 codificados en base64 precedidos de "sha256//" y separados por ";".	Añadida en cURL 7.39.0. Disponible desde PHP 7.0.7.
`CURLOPT_POSTFIELDS`	Todos los datos para enviar vía HTTP "POST". para enviar un fichero, prefija el nombre del fichero con `@` y utiliza la ruta completa. Se puede especificar explícitamente el tipo de fichero añadiendo el tipo al nombre del fichero, en el formato '`;type=mimetype`'. Se puede enviar una cadena urlencoded como '`para1=val1&para2=val2&...`' o también como un array con el nombre del campo como key y los datos como value. Si `value` es un array, el encabezado `Content-Type` será definido como `multipart/form-data`. A partir de PHP 5.2.0, `value` debe ser un array si los archivos son pasados a esta opción con el prefijo `@`. A partir de PHP 5.5.0, el prefijo `@` está obsoleto, por lo que los ficheros se pueden enviar usando CURLFile. El prefijo `@` puede ser deshabilitado por seguridad de proporcionar valores que comienzan con `@` estableciendo la opción `CURLOPT_SAFE_UPLOAD` a `true`.
`CURLOPT_PRIVATE`	Cualquier dato que debería estar asociado con este manejador de cURL. Estos datos puede ser recuperados posteriormente con la opción `CURLINFO_PRIVATE` de curl_getinfo(). cURL no hace nada con estos datos. Al emplear un multimanejador de cURL, estos datos privados son típicamente una clave única para identificar un manejador estándar de cURL.	Añadida en cURL 7.10.3.
`CURLOPT_PROXY`	El proxy HTTP para enviar peticiones a través de tunel.
`CURLOPT_PROXY_SERVICE_NAME`	El nombre del servicio de autenticación del proxy.	Añadida en cURL 7.34.0. Disponible desde PHP 7.0.7.
`CURLOPT_PROXYUSERPWD`	Usuario y contraseña con el siguiente formato `"[username]:[password]"` para usarse en la conexión al proxy.
`CURLOPT_RANDOM_FILE`	Nombre del fichero a ser usado para generar números aleatorios para el SSL.
`CURLOPT_RANGE`	Rango(s) de datos para obtener en el formato `"X-Y"` donde X y Y son opcionales. Transferencias HTTP también soportan varios intérvalos, separados por comas en el formato `"X-Y,N-M"`.
`CURLOPT_REFERER`	Contenido del Header `"Referer: "` para ser usado en la petición HTTP.
`CURLOPT_SERVICE_NAME`	El nombre del servicio de autenticación.	Añadida en cURL 7.43.0. Disponible desde PHP 7.0.7.
`CURLOPT_SSH_HOST_PUBLIC_KEY_MD5`	Un string que contiene 32 dígitos hexadecimales. El string debe ser el MD5 checksum de la clave pública del host remoto, y libcurl rechazará la conexión a el host a menos que el md5sums coincida. Esta opción es sólo para las transferencias SCP y SFTP.	Añadido en cURL 7.17.1.
`CURLOPT_SSH_PUBLIC_KEYFILE`	El nombre de el fichero de la clave pública. Si no se utiliza, libcurl por omisión usa $HOME/.ssh/id_dsa.pub si la variable de entorno HOME es establecida, y "id_dsa.pub" en el directorio actual si HOME no está establecida.	Añadido en cURL 7.16.1.
`CURLOPT_SSH_PRIVATE_KEYFILE`	El nombre de el fichero de la clave privada. Si no se utiliza, libcurl por omisión usa $HOME/.ssh/id_dsa si la variable de entorno HOME es establecida, y "id_dsa" en el directorio actual si HOME no está establecida. Si el fichero está protegido con contraseña, establecer la contraseña con la constante `CURLOPT_KEYPASSWD`.	Añadido en cURL 7.16.1.
`CURLOPT_SSL_CIPHER_LIST`	Lista de ciphers a ser usados por SSL. Por ejemplo, `RC4-SHA` y `TLSv1` es una lista válida de ciphers.
`CURLOPT_SSLCERT`	Nombre del fichero que contiene un certificado con formato PEM.
`CURLOPT_SSLCERTPASSWD`	Contraseña requerida para usar el certificado `CURLOPT_SSLCERT`.
`CURLOPT_SSLCERTTYPE`	Formato del certificado. Los formatos soportados son `"PEM"` (por defecto), `"DER"`, y `"ENG"`.	Añadido en cURL 7.9.3.
`CURLOPT_SSLENGINE`	El identificador para el crypto engine de la clave privada SSL especificada en `CURLOPT_SSLKEY`.
`CURLOPT_SSLENGINE_DEFAULT`	Identificador para el crypto engine usado para operaciones crypto asimétricas.
`CURLOPT_SSLKEY`	Nombre del fichero que contiene la clave privada SSL.
`CURLOPT_SSLKEYPASSWD`	Contraseña secreta requerida para usar la clave privada SSL especificada en `CURLOPT_SSLKEY`. Nota: Como esta opción contiene una contraseña, recuerde mantener el PHP script en un sitio seguro.
`CURLOPT_SSLKEYTYPE`	Tipo de llave privada SSL especificada en `CURLOPT_SSLKEY`. Los tipos de claves soportadas son `"PEM"` (default), `"DER"`, y `"ENG"`.
`CURLOPT_UNIX_SOCKET_PATH`	Habilita el uso de sockets de dominio Unix como extremos de conexión y establece la ruta al string dado.	Añadida en cURL 7.40.0. Disponible desde PHP 7.0.7.
`CURLOPT_URL`	Dirección URL a capturar. Este valor también puede ser configurado cuando se inicia una sesión con curl_init().
`CURLOPT_USERAGENT`	Contenido del header `"User-Agent: "` a ser usado en la petición HTTP.
`CURLOPT_USERNAME`	El nombre de usuario a emplear en la autenticación.	Añadida en cURL 7.19.0. Disponible desde PHP 5.5.0.
`CURLOPT_USERPWD`	Nombre de usuario y contraseña siguiendo el formato `"[username]:[password]"` para ser usado en la conexión.
`CURLOPT_XOAUTH2_BEARER`	Especifica el «token» de acceso de OAuth 2.0.	Añadida en cURL 7.33.0. Disponible desde PHP 7.0.7.

El value debe ser un array para los siguientes valores del parámetro option:

Opción	Configurar `value` a	Notas
`CURLOPT_CONNECT_TO`	Se conecta a un puerto y host específicos en lugar del puerto y host del URL. Acepta un array de cadenas con el formato `HOST:PORT:CONNECT-TO-HOST:CONNECT-TO-PORT`.	Añadida en cURL 7.49.0. Disponible desde PHP 7.0.7.
`CURLOPT_HTTP200ALIASES`	Array de respuestas HTTP 200 que serán tratadas como respuestas válidas y no como errores.	Añadido en cURL 7.10.3.
`CURLOPT_HTTPHEADER`	Un array de campos a configurar para el header HTTP, en el formato: `array('Content-type: text/plain', 'Content-length: 100')`
`CURLOPT_POSTQUOTE`	Un array de comandos FTP a ejecutar en el servidor después de que se realice la petición FTP.
`CURLOPT_PROXYHEADER`	Un array de cabeceras HTTP personalizadas a pasar a los proxies.	Añadida en cURL 7.37.0. Disponible desde PHP 7.0.7.
`CURLOPT_QUOTE`	Un array de comandos FTP a ejecutar en el servidor antes de que se realice la petición FTP.

El value debe ser un recurso de flujo (usando fopen(), por ejemplo) para los siguientes valores del parámetro option:

Opción	Configurar `value` a
`CURLOPT_FILE`	El fichero en el que el proceso de transferencia guardará el resultado. Por defecto es `STDOUT` (la ventana del navegador).
`CURLOPT_INFILE`	El fichero que el proceso de transferencia debe leer a la hora de subir un fichero.
`CURLOPT_STDERR`	Localización alternativa para mostrar los errores en lugar de `STDERR`.
`CURLOPT_WRITEHEADER`	El fichero donde guardar la parte del header durante la transferencia.

value debería ser el nombre de una función válida o un objeto Closure para los siguientes valores del parámetro option:

Opción	Configurar `value` a
`CURLOPT_HEADERFUNCTION`	Una llamada de retorno que acepta dos parámetros. El primero es el recurso cURL, el segundo es un string con los datos de la cabecera a escribir. Los datos de la cabecera deben ser escritos por esta llamada de retorno. Devuelve el número de bytes escritos.
`CURLOPT_PASSWDFUNCTION`	Una llamada de retorno que acepta tres parámetros. El primero es el recurso cURL, el segundo es un string que contiene la contraseña, y el tercero es la longitud máxima para la contraseña. Devuelve un string que contiene la contraseña.
`CURLOPT_PROGRESSFUNCTION`	Una llamada de retorno que acepta cinco parámetros. El primero es el recurso cURL, el segundo es el número total de bytes que se espera descargar en esta transferencia, el tercero es el número de bytes descargados hasta ahora, el cuarto es el número total de bytes que se espera subir en esta transferencia, y el quinto es el número de bytes subidos hasta ahora. Nota: La llamada de retorno solamente se invoca cuando la opción `CURLOPT_NOPROGRESS` está establecida a `false`. Devuelve un valor distinto de cero para abortar la transferencia. En este caso, la transferencia establecerá un error `CURLE_ABORTED_BY_CALLBACK`.
`CURLOPT_READFUNCTION`	Una llamada de retorno que acepta tres parámetros. El primero es el recurso cURL, el segundo es un recurso de flujo de datos proporcionado a través de la opción `CURLOPT_INFILE`, y el tercero es la máxima cantidad de datos a leer. La llamada de retorno debe devolver un string con la misma longitud o menor que la cantidad de datos pedidos, normalmente leyéndolos del recurso de flujo de datos pasado. Debe devolver una cadena vacía para marcar el `EOF`.
`CURLOPT_WRITEFUNCTION`	Una llamada de retorno que acepta dos parámetros. El primero es el recurso cURL, el segundo es un string con los datos a escribir. Los datos deben ser guardados por esta llamada de retorno. Debe devolver el número exacto de bytes escritos o la transferencia será abortada con un error.

Otros valores:

Opción	Establecer `value` a
`CURLOPT_SHARE`	Un resultado de curl_share_init(). Hace que el gestor de cURL use los datos del gestor compartido.

Valores devueltos

Devuelve true en caso de éxito o false en caso de error.

Historial de cambios

Versión	Descripción
7.0.7	Se introdujeron `CURL_HTTP_VERSION_2`, `CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE`, `CURL_HTTP_VERSION_2TLS`, `CURL_REDIR_POST_301`, `CURL_REDIR_POST_302`, `CURL_REDIR_POST_303`, `CURL_REDIR_POST_ALL`, `CURL_VERSION_KERBEROS5`, `CURL_VERSION_PSL`, `CURL_VERSION_UNIX_SOCKETS`, `CURLAUTH_NEGOTIATE`, `CURLAUTH_NTLM_WB`, `CURLFTP_CREATE_DIR`, `CURLFTP_CREATE_DIR_NONE`, `CURLFTP_CREATE_DIR_RETRY`, `CURLHEADER_SEPARATE`, `CURLHEADER_UNIFIED`, `CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE`, `CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE`, `CURLMOPT_MAX_HOST_CONNECTIONS`, `CURLMOPT_MAX_PIPELINE_LENGTH`, `CURLMOPT_MAX_TOTAL_CONNECTIONS`, `CURLOPT_CONNECT_TO`, `CURLOPT_DEFAULT_PROTOCOL`, `CURLOPT_DNS_INTERFACE`, `CURLOPT_DNS_LOCAL_IP4`, `CURLOPT_DNS_LOCAL_IP6`, `CURLOPT_EXPECT_100_TIMEOUT_MS`, `CURLOPT_HEADEROPT`, `CURLOPT_LOGIN_OPTIONS`, `CURLOPT_PATH_AS_IS`, `CURLOPT_PINNEDPUBLICKEY`, `CURLOPT_PIPEWAIT`, `CURLOPT_PROXY_SERVICE_NAME`, `CURLOPT_PROXYHEADER`, `CURLOPT_SASL_IR`, `CURLOPT_SERVICE_NAME`, `CURLOPT_SSL_ENABLE_ALPN`, `CURLOPT_SSL_ENABLE_NPN`, `CURLOPT_SSL_FALSESTART`, `CURLOPT_SSL_VERIFYSTATUS`, `CURLOPT_STREAM_WEIGHT`, `CURLOPT_TCP_FASTOPEN`, `CURLOPT_TFTP_NO_OPTIONS`, `CURLOPT_UNIX_SOCKET_PATH`, `CURLOPT_XOAUTH2_BEARER`, `CURLPROTO_SMB`, `CURLPROTO_SMBS`, `CURLPROXY_HTTP_1_0`, `CURLSSH_AUTH_AGENT` y `CURLSSLOPT_NO_REVOKE`.
7.0.0	Se ha eliminado el soporte para inhabilitar la opción `CURLOPT_SAFE_UPLOAD`. Todas las subidas de ficheros de curl deben emplear CURLFile.
5.6.0	`CURLOPT_SAFE_UPLOAD` ahore es `true` de forma predeterminada.
5.6.0	Se eliminó `CURLOPT_CLOSEPOLICY` y sus valores asociados.
5.5.0	Se añadió el recurso cURL como el primer parámetro de la llamada de retorno `CURLOPT_PROGRESSFUNCTION`.
5.5.0	Se introdujo `CURLOPT_SHARE`.
5.3.0	Se introdujo `CURLOPT_PROGRESSFUNCTION`.
5.2.10	Se introdujo `CURLOPT_PROTOCOLS`, y `CURLOPT_REDIR_PROTOCOLS`.
5.2.4	Se introdujo `CURLOPT_PRIVATE`.
5.1.0	Se introdujo `CURLOPT_AUTOREFERER`, `CURLOPT_BINARYTRANSFER`, `CURLOPT_FTPSSLAUTH`, `CURLOPT_PROXYAUTH`, y `CURLOPT_TIMECONDITION`.
5.0.0	Se introdujo `CURLOPT_FTP_USE_EPRT`, `CURLOPT_NOSIGNAL`, `CURLOPT_UNRESTRICTED_AUTH`, `CURLOPT_BUFFERSIZE`, `CURLOPT_HTTPAUTH`, `CURLOPT_PROXYPORT`, `CURLOPT_PROXYTYPE`, `CURLOPT_SSLCERTTYPE`, y `CURLOPT_HTTP200ALIASES`.

Ejemplos

Ejemplo #1 Inicializar una nueva sesión de cURL y obtener una página web

<?php
// Crear un nuevo recurso cURL
$ch = curl_init();

// Configurar URL y otras opciones apropiadas
curl_setopt($ch, CURLOPT_URL, "http://www.example.com/");
curl_setopt($ch, CURLOPT_HEADER, false);

// Capturar la URL y pasarla al navegador
curl_exec($ch);

// Cerrar el recurso cURL y liberar recursos del sistema
curl_close($ch);
?>

Ejemplo #2 Subir un fichero (obsoleto a partir de PHP 5.5.0)

<?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_SAFE_UPLOAD, false); // requerido a partir de PHP 5.6.0
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

curl_exec($ch);
?>

El resultado del ejemplo sería:

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

)

Notas

Nota:
Si pasamos un array a CURLOPT_POSTFIELDS codificará los datos como multipart/form-data, pero si pasamos una cadena URL-encoded codificará los datos como application/x-www-form-urlencoded.

Ver también

curl_setopt_array() - Configura múltiples opciones para una transferencia cURL

Improve This Page

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 64 notes

down

223

rmckay at webaware dot com dot au ¶

11 years 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

joey ¶

8 years ago

It is important that anyone working with cURL and PHP keep in mind that not all of the CURLOPT and CURLINFO constants are documented. I always recommend reading the cURL documentation directly as it sometimes contains better information. The cURL API in tends to be fubar as well so do not expect things to be where you would normally logically look for them.

curl is especially difficult to work with when it comes to cookies. So I will talk about what I found with PHP 5.6 and curl 7.26.

If you want to manage cookies in memory without using files including reading, writing and clearing custom cookies then continue reading.

To start with, the way to enable in memory only cookies associated with a cURL handle you should use:

    curl_setopt($curl, CURLOPT_COOKIEFILE, "");

cURL likes to use magic strings in options as special commands. Rather than having an option to enable the cookie engine in memory it uses a magic string to do that. Although vaguely the documentation here mentions this however most people like me wouldn't even read that because a COOKIEFILE is the complete opposite of what we want.

To get the cookies for a curl handle you can use:

    curl_getinfo($curl, CURLINFO_COOKIELIST);

This will give an array containing a string for each cookie. It is tab delimited and unfortunately you will have to parse it yourself if you want to do anything beyond copying the cookies.

To clear the in memory cookies for a cURL handle you can use:

    curl_setopt($curl, CURLOPT_COOKIELIST, "ALL");

This is a magic string. There are others in the cURL documentation. If a magic string isn't used, this field should take a cookie in the same string format as in getinfo for the cookielist constant. This can be used to delete individual cookies although it's not the most elegant API for doing so.

For copying cookies I recommend using curl_share_init.

You can also copy cookies from one handle to another like so:

    foreach(curl_getinfo($curl_a, CURLINFO_COOKIELIST) as $cookie_line)
        curl_setopt($curl, CURLOPT_COOKIELIST, $cookie_line);

An inelegant way to delete a cookie would be to skip the one you don't want. 

I only recommend using COOKIELIST with magic strings because the cookie format is not secure or stable. You can inject tabs into at least path and name so it becomes impossible to parse reliably. If you must parse this then to keep it secure I recommend prohibiting more than 6 tabs in the content which probably isn't a big loss to most people.

A the absolute minimum for validation I would suggest:

    /^([^\t]+\t){5}[^\t]+$/D

Here is the format:

    #define SEP  "\t"  /* Tab separates the fields */
 
    char *my_cookie =
      "example.com"    /* Hostname */
      SEP "FALSE"      /* Include subdomains */
      SEP "/"          /* Path */
      SEP "FALSE"      /* Secure */
      SEP "0"          /* Expiry in epoch time format. 0 == Session */
      SEP "foo"        /* Name */
      SEP "bar";       /* Value */

down

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

17 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

Steve Kamerman ¶

13 years 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

qwertz182 ¶

3 years ago

As the "example #2 Uploading file" says it is deprecated as of PHP 5.5.0 but doesn't tell you how it's done right,
here is a really easy example using the CURLFile class:

<?php
$request = [
    'firstName' => 'John',
    'lastName' => 'Doe',
    'file' => new CURLFile('example.txt', 'text/plain') // or use curl_file_create()
];

$curlOptions = [
    CURLOPT_URL => 'http://example.com/upload.php',
    CURLOPT_POST => true,
    CURLOPT_HEADER => false,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POSTFIELDS => $request,
];

$ch = curl_init();
curl_setopt_array($ch, $curlOptions);

$response = curl_exec($ch);
?>

This is just like posting a html form with an input[type=file] field.
The result on windows could look like this:

<?php
// $_POST
Array
(
    [firstName] => John
    [lastName] => Doe
)

// $_FILES
Array
(
    [file] => Array
        (
            [name] => example.txt
            [type] => text/plain
            [tmp_name] => C:\wamp64\tmp\php3016.tmp
            [error] => 0
            [size] => 14
        )

)
?>

Since the request is an array (and not a string), curl will automatically encode the data as "multipart/form-data".
Please be aware that if you pass an invalid file path to CURLFile, setting the CURLOPT_POSTFIELDS option will fail.
So if you are using curl_setopt_array for setting the options at once, according to the manual, "If an option could not be successfully set, FALSE is immediately returned, ignoring any future options in the options array.".
So you should make sure that the file exists or set CURLOPT_POSTFIELDS with curl_setopt() and check if it returns false and act accordingly.

down

Philippe dot Jausions at 11abacus dot com ¶

18 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

JScott jscott401 at gmail dot com ¶

14 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

cmatiasvillanueva at gmail dot com ¶

6 years ago

What is not mentioned in the documentation is that if you want to set  a local-port or local-port-range to establish a connection is possible by adding   CURLOPT_LOCALPORT and CURLOPT_LOCALPORTRANGE options.   

Ex:
$conn=curl_init ('example.com');
curl_setopt($conn, CURLOPT_LOCALPORT, 35000);
curl_setopt($conn, CURLOPT_LOCALPORTRANGE, 200);

CURLOPT_LOCALPORT: This sets the local port number of the socket used for the connection.

CURLOPT_LOCALPORTRANGE:  The range argument is the number of attempts libcurl will make to find a working local port number. It starts with the given CURLOPT_LOCALPORT and adds one to the number for each retry. Setting this option to 1 or below will make libcurl do only one try for the exact port number.

Interface can be also configured using CURLOPT_INTERFACE:

Ex:

curl_setopt($conn,  CURLOPT_INTERFACE, "eth1");

down

sgamon at yahoo dot com ¶

16 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

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

12 years 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

Ed Cradock ¶

14 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

Victor Jerlin ¶

15 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

dweingart at pobox dot com ¶

21 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

yann dot corno at free dot fr ¶

21 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

luca dot manzo at bbsitalia dot com ¶

18 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

Chris at PureFormSolutions dot com ¶

14 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

joelhy ¶

8 years ago

Please notice that CURLINFO_HEADER_OUT and CURLOPT_VERBOSE option does not work together:
"When CURLINFO_HEADER_OUT is set to TRUE than CURLOPT_VERBOSE does not work."(from https://bugs.php.net/bug.php?id=65348). 
This took me an hour or two to figure it out.

down

badman ¶

10 years ago

Many hosters use PHP safe_mode or/and open_basedir, so you can't use CURLOPT_FOLLOWLOCATION. If you try, you see message like this:
CURLOPT_FOLLOWLOCATION cannot be activated when safe_mode is enabled or an open_basedir is set in [you script name & path] on line XXX

First, I try to use zsalab function (http://us2.php.net/manual/en/function.curl-setopt.php#102121) from this page, but for some reason it did not work properly. So, I wrote my own.

It can be use instead of curl_exec. If server HTTP response codes is 30x, function will forward the request as long as the response is not different from 30x (for example, 200 Ok). Also you can use POST.

function curlExec(/* Array */$curlOptions='', /* Array */$curlHeaders='', /* Array */$postFields='')
{
  $newUrl = '';
  $maxRedirection = 10;
  do
  {
    if ($maxRedirection<1) die('Error: reached the limit of redirections');

    $ch = curl_init();
    if (!empty($curlOptions)) curl_setopt_array($ch, $curlOptions);
    if (!empty($curlHeaders)) curl_setopt($ch, CURLOPT_HTTPHEADER, $curlHeaders);
    if (!empty($postFields))
    {
      curl_setopt($ch, CURLOPT_POST, 1);
      curl_setopt($ch, CURLOPT_POSTFIELDS, $postFields);
    }
    
    if (!empty($newUrl)) curl_setopt($ch, CURLOPT_URL, $newUrl); // redirect needed
    
    $curlResult = curl_exec($ch);
    $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    if ($code == 301 || $code == 302 || $code == 303 || $code == 307)
    {
      preg_match('/Location:(.*?)\n/', $curlResult, $matches);
      $newUrl = trim(array_pop($matches));
      curl_close($ch);

      $maxRedirection--;
      continue;
    }
    else // no more redirection
    {
      $code = 0;
      curl_close($ch);
    }
  }
  while($code);
  return $curlResult;
}

down

jade dot skaggs at gmail dot com ¶

16 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

jancister at gmail dot com ¶

9 years ago

Please note that if you want to handle progress using CURLOPT_PROGRESSFUNCTION option, you need to take into consideration what version of PHP are you using. Since version 5.5.0, compatibility-breaking change was introduced in number/order of the arguments passed to the callback function, and cURL resource is now passed as first argument.

Prior to version 5.5.0:
<?php
// ...
curl_setopt($resource, CURLOPT_PROGRESSFUNCTION, 'progressCallback');
curl_setopt($resource, CURLOPT_NOPROGRESS, false);
// ...
function progressCallback($download_size = 0, $downloaded = 0, $upload_size = 0, $uploaded = 0)
{
    // Handle progress
}
?>

From version 5.5.0:
<?php
// ...
curl_setopt($resource, CURLOPT_PROGRESSFUNCTION, 'progressCallback');
curl_setopt($resource, CURLOPT_NOPROGRESS, false);
// ...
function progressCallback($resource, $download_size = 0, $downloaded = 0, $upload_size = 0, $uploaded = 0)
{
    // Handle progress
}
?>

However, if your code needs to be compatible with PHP version both before and after 5.5.0, consider adding a version check:
<?php
// ...
curl_setopt($resource, CURLOPT_PROGRESSFUNCTION, 'progressCallback');
curl_setopt($resource, CURLOPT_NOPROGRESS, false);
// ...
function progressCallback($resource, $download_size = 0, $downloaded = 0, $upload_size = 0, $uploaded = 0)
{
   /**
    * $resource parameter was added in version 5.5.0 breaking backwards compatibility;
    * if we are using PHP version lower than 5.5.0, we need to shift the arguments
    * @see http://php.net/manual/en/function.curl-setopt.php#refsect1-function.curl-setopt-changelog
    */
    if (version_compare(PHP_VERSION, '5.5.0') < 0) {
        $uploaded = $upload_size;
        $upload_size = $downloaded;
        $downloaded = $download_size;
        $download_size = $resource;
    }

    // Handle progress
}
?>

down

joeterranova at gmail dot com ¶

14 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

skyogre __at__ yandex __dot__ ru ¶

18 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

fnjordy at gmail dot com ¶

15 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

juozaspo at gmail dot com ¶

11 years 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

Joey Hewitt ¶

12 years 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

anderseta at gmail dot com ¶

14 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

PHP at RHaworth dot net ¶

13 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

Dustin Hawkins ¶

18 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

saidk at phirebranding dot com ¶

15 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

Martin K. ¶

10 years ago

If you only want to enable cookie handling and you don't need to save the cookies for a separate session, just set CURLOPT_COOKIEFILE to an empty string.  I was given the advice to use php://memory but that did not seem to have the same effect.

Although this is stated in the documentation I thought it was worth reiterating since it cause me so much trouble.

down

Ojas Ojasvi ¶

16 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

Aaron Wells ¶

9 years ago

If you use cURL to fetch user-supplied URLs (for instance, in a web-based RSS aggregator), be aware of the risk of server-side request forgery (SSRF). This is an attack where the user takes advantage of the fact that cURL requests are sent from the web server itself, to reach network locations they wouldn't be able to reach from outside the network.

For instance, they could enter a "http://localhost" URL, and access things on the web server via "localhost". Or, "ftp://localhost". cURL supports a lot of protocols!

If you are using CURLOPT_FOLLOWLOCATION, the malicious URL could be in a redirect from the original request. cURL also will follow redirect headers to other protocols! (303 See Other; Location: ftp://localhost).

So if you're using cURL with user-supplied URLs, at the very least use CURLOPT_PROTOCOLS (which also sets CURLOPT_REDIR_PROTOCOLS), and either disable CURLOPT_FOLLOWLOCATION or use the "SafeCurl" library to safely follow redirects.

down

mr at coder dot tv ¶

18 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

eric dot van dot eldik at peercode dot nl ¶

5 years ago

When you get this error using a PUT request: "SSL read: error:00000000:lib(0):func(0):reason(0), errno 104")

It could be caused by:
<?php
curl_setopt($ch, CURLOPT_PUT, TRUE);
?>

Instead try:
<?php
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
?>

down

S\ ¶

13 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

clint at fewbar dot com ¶

14 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

ohcc at 163 dot com ¶

6 years ago

This is howto upload an existing file to an FTP server with cURL in PHP.

You should remember that CURLOPT_URL should contain the file's basename to save on the FTP server. For example, if you upload hello.txt to ftp://www.wuxiancheng.cn/text/, CURLOPT_URL should be ftp://www.wuxiancheng.cn/text/hello.txt rather than ftp://www.wuxiancheng.cn/text/, otherwise you will get an error message like "Uploading to a URL without a file name! " when you call curl_error();

<?php
    $ch = curl_init();
    $filepath = 'D:\Web\www\wuxiancheng.cn\hello.txt';
    $basename = pathInfo($filepath, PATHINFO_BASENAME);
    $filesize = fileSize($filepath);
    curl_setopt_array(
        $ch,
        array(
            CURLOPT_URL => 'ftp://www.wuxiancheng.cn/text/' . $basename,
            CURLOPT_USERPWD => 'USERNAME:PASSWORD',
            CURLOPT_PROTOCOLS => CURLPROTO_FTP,
            CURLOPT_UPLOAD => true,
            CURLOPT_INFILE => $filepath,
            CURLOPT_INFILESIZE => $filesize,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HEADER => false,
        )
    );
    curl_exec($ch);
    $message = curl_errno($ch) === CURLE_OK ? 'success' : 'failure';
    echo $message;
?>

down

Pawel Antczak ¶

14 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

regan dot corey at gmail dot com ¶

11 years 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

zsalab ¶

13 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

Adam Monsen ¶

12 years 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

c00lways at gmail dot com ¶

16 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

fred at themancan dot com ¶

16 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

scy-phpmanual at scytale dot name ¶

13 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

rob ¶

15 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

markandrewslade at gmail dot com ¶

7 years ago

Contrary to the documentation, CURLOPT_STDERR should be set to a handle to the file you want to write to, not the file's location.

down

ron at ttvavanti dot nl ¶

20 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

eion at bigfoot dot com ¶

17 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

shiplu at programmer dot net ¶

11 years ago

CURLOPT_POST should be set before CURLOPT_POSTFIELDS. Otherwise you might encounter 411 Length required error.

Following code generates "411 Length Required" on nginx/1.1.15
<?php
curl_setopt ($ch, CURLOPT_POSTFIELDS, $postfields); 
curl_setopt ($ch, CURLOPT_POST, 1);
?>

But this one works.

<?php
curl_setopt ($ch, CURLOPT_POST, 1);
curl_setopt ($ch, CURLOPT_POSTFIELDS, $postfields); 
?>

down

michaeledwards.com ¶

19 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

php at miggy dot org ¶

18 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

joel at mojamail dot com ¶

6 years ago

In the long documentation, it's easy to miss the fact that CURLOPT_POSTFIELDS will set the Content-Type to "multipart/form-data" (instead of the usual "application/x-www-form-urlencoded") IFF you supply an array (instead of a query string)!

Some servers will return weird errors (like "SSL read: error:00000000:lib(0):func(0):reason(0), errno 104") for the wrong Content-Type, and you may waste many hours of time trying to figure out why!

down

qeremy [atta] gmail [dotta] com ¶

12 years 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

gskluzacek at gmail dot com ¶

13 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

Andrew ¶

15 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

anonymous ¶

12 years 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

ac at an dot y-co dot de ¶

16 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, '2');

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

Madcat ¶

11 years 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

Salil Kothadia ¶

16 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

Sylvain R ¶

15 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

julien veneziano ¶

14 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

adrian at foeder dot de ¶

12 years 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

Niki Romagnoli ¶

1 year ago

Set order when using CURLOPT_POST and CURLOPT_POSTFIELDS *matters*.
Setting CURL_POST to true will ERASE any previous CURLOPT_POSTFIELDS using an array. Result is request be a POST with empty body.

CURLOPT_POSTFIELDS will set CURLOPT_POST to true for you, no need for repeat.
If you really need to set both, then either:
  - set CURLOPT_POST *before* CURLOPT_POSTFIELDS
  - or don't use array and convert CURLOPT_POSTFIELDS to URL-encoded string, it will not be affected this way (ie. <?php curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($yourArray)); ?> )

down

alexchexes at gmail dot com ¶

1 year ago

If you want cURL to successfully write cookies to a file specified with CURLOPT_COOKIEJAR, ensure that cURL has the necessary permissions to modify the file if it already exists.

I spent nearly a day trying to understand why cURL wasn't saving cookies to an existing file, even though I could easily modify the exact same file using file_put_contents(). Moreover, cURL itself could create the same file and save cookies, but only if it didn't previously exist.

Ultimately, the issue was related to file ownership. I was working within WSL2, inside a symlinked Windows directory. The [automount]"metadata" in wsl.conf was not set, causing every file created from PHP to have the default owner, which differed from the user running PHP.

Once I configured wsl.conf and then changed the ownership of the entire directory to match the user running PHP, cookies were successfully written to any file without any issues.

＋add a note