Tutorial de Curl
Introduccion
curl significa "Cliente para URL". Se trata de un programa capaz de realizar transferencias de Internet, donde actua como cliente, cargando y descargando datos desde un servidor remoto. Los datos pueden responder a cualquier tipologia: texto, imagenes, audio, video, etcetera.
Curl soporta tanto protocolos no autenticados (como HTTP o FTP), como sus contrapartes autenticados mas modernos (como HTTPS o SFTP).
Historia
curl comenzo originalmente en 1996 como un proyecto llamado httpget, de Rafael Sagula, quien luego transfirio el control del mismo a Daniel Stenberg. Daniel lo renombro a curl en 1998, y en 2000 dividio la funcionalidad de red de datos para colocarla en la biblioteca libcurl. Por lo cual curl en si se trasnformo en un envolvedor para la linea de comandos alrededor de dicha biblioteca.
Curl se encuentra liberado bajo una licencia MIT ligeramente modificada. Opera en 92 sistemas operativos en cuenta con mas de 20 mil millones de instalaciones en todo el mundo.
Sintaxis de Curl
Desde la linea de comandos
operaras el comando curl
, haciendo caso a las reglas de
sintaxis del mismo.
Sintaxis basica de Curl
Para curl, todo lo que comience con -
o --
lo interpretara como una opcion de curl.
Existen opciones de curl que usan sintaxis cortas (con un
guion -
):
curl -V
...y opciones de curl de sintaxis largas (usan doble guion
--
):
curl --version
Todas las opciones de curl estan disponibles en el formato "largo", pero las mas usadas son las que usan la version "corta". El programa cuenta actualmente con unas 250 opciones, pero en este tutorial dejaremos de lado aquellas que se usan en otros protocolos distintos a http/https.
Sintaxis complejas
Las ordenes mas complejas recurren a este tipo de sintaxis.
Opciones Boleanas
Algunas opciones son del tipo booleano. Podremos activarlas con:
curl --silent http://httpbin/uuid
...o desactivarlas con:
curl --no-silent http://httpbin/uuid
Opciones Argumentadas
Algunas opciones de curl aceptan argumentos, que permiten especificarle mas definidamente que es lo que queremos que haga:
curl --output /tmp/uuid.json http://httpbin/uuid
Aquellos argumentos que contienen espacios en blanco deben
entrecomillarse: "..."
. Por ejemplo:
curl -o /dev/null --write-out "type: %{content_type}" http://httpbin/uuid
Transmisiones No autenticadas
Curl puede desactivar la verificacion de servidor con la opcion
--insecure
, pero es mejor no hacer esto por seguridad.
Los datos transferidos sobre un protocolo no autenticado pueden ser intereceptados y utilizados, de manera que siempre es mejor usar los autenticados.
URLs
Todo aquello que pasemos a curl que no comience con -
o
--
, sera considerado una URL.
Curl soporta URLs segun la forma de URIs aceptada en la
protocolizacion RFC 3986, o sea:
esquema://usuaria:contrasena@huesped:puerto/ruta?solicitud#fragmento
.
En esta:
esquema
define un protocolo (como HTTP o FTP). De omitirse, curl intentara adivinarlo. Lausuaria
y lacontrasena
son credenciales de autenticacion (transmitir las credenciales en la URL generalmente no esta recomendado o permitido por motivos de seguridad).huesped
es el nombre de maquina, nombre de dominio o direccion IP del servidor.puerto0
es el numero de puerto de transmision. De omitirse, curl empleara el puerto por defecto asociado con el esquema (por ejemplo,80
para http o443
para https).ruta
es la ruta al recurso en el servidor.solicitud
es usualmente una secuencia de paresnombre=valor
separada por un caracter&
.
Solicitud
Si fuese necesario pasar a curl una gran cantidad de parametros de
URL, la parte que involucra a la solicitud podria resultar
extensamente larga. La opcion --url-query
permite
especificar separadamente estas partes, para que pasarle URL largas nos
resulte mas comodo:
curl http://httpbin/get --url-query "name=Fulana" --url-query "edad=25"
URL Multiples
Curl acepta cualquier cantidad de URLs, pero cada una de las cuales
requerira definirle un destino (ya sea un fichero o stdout). Por
ejemplo, este comando guardara la primer UUID en
/tmp/uuid1.json
y la segunda UUID en
/tmp/uuid2.json
:
curl
-o /tmp/uuid1.json http://httpbin/uuid
-o /tmp/uuid2.json http://httpbin/uuid
&& cat /tmp/uuid1.json
&& cat /tmp/uuid2.json
De aqui en mas, ocasionalmente en este tutorial se mostraran multilineas a modo ilustrativo. En realidad curl espera una linea de comando unica, o a lo sumo lineas divididas con
\
).
La opcion -O
deriva el nombre de fichero desde la
URL:
curl --output-dir /tmp
-O http://httpbin/cualquier/ruta/uno
-O http://httpbin/cualquier/ruta/dos
&& ls /tmp
Para guardar ambas respuestas en un mismo fichero, podremos usar metacaracteres de redireccion:
curl http://httpbin/uuid http://httpbin/uuid > /tmp/uuid.json
&& cat /tmp/uuid.json
Englobado de URL
Curl expande automaticamente aquellas expresiones englobadas en URLs, en multiples URLs especificas.
Por ejemplo, este comando solicita tres rutas distintas
(al
, bt
, gm
), cada una con dos
parametros distintos (num=1
y num=2
),
totalizando seis URLs:
curl --output-dir /tmp -o "salida_#1_#2.txt"
http://httpbin/cualquier/ruta/{al,bt,gm}?num=[1-2]
&& ls /tmp
Si en las URLs indicadas existiesen los caracteres interpretables de
englobado ([]{}
), esto provocaria un tremendo dolor de
cabeza. Sin embargo, podremos desactivar su interpretado de englobado
gracias a la opcion --globoff
. De este modo, Curl tratara
las URLs de manera literal, sin importar que contengan dichos
caracteres.
Transferencias en paralelo
Es posible usar la opcion --parallel
(-Z
)
para ordenar a Curl el procesado de URLs de forma concurrente.
Fichero de Configuracion
En la medida que se incrementa el numero de opciones, el comando Curl
se volvera mas dificil de descifrar. Para hacerlo mas legible, podriamos
preparar un fichero de configuracion delimitando una opcion por linea
(el uso de --
es opcional):
Config file
output-dir /tmp
show-error
silent
Por defecto, Curl lee el fichero de configuracion desde
$HOME/.curlrc
, pero esto puede alterarse indicandolo con la
opcion --config
(-K
):
curl --config /sandbox/.curlrc http://httpbin/uuid
Reseteo de estado
Debemos estar atentos que al configurar las opciones de curl, tal configuracion se aplicara a todas las URLs que procese curl. Por ejemplo, aqui ambos encabezados se envian a ambas URLs:
curl
-H "x-num: uno" http://httpbin/headers?1
-H "x-num: dos" http://httpbin/headers?2
En ocasiones no deseamos hacer esto. Para resetear el estado entre
las llamadas a las URLS, debemos recurrir a la opcion
--next
:
curl
-H "x-num: uno" http://httpbin/encabezados?1
--next
-H "x-num: dos" http://httpbin/encabezados?2
Medidor de Progreso
Curl cuenta con dos medidores de progreso distintos para saber como va la transferencia ordenada.
Indicador de progreso verboso
curl --no-silent http://httpbin/uuid
Indicador de progreso compacto
El otro es indicador compactito:
curl --no-silent --progress-bar http://httpbin/uuid
Desactivar indicacion de progreso
La opcion --silent
desactiva completamente el
medidor:
curl --silent http://httpbin/uuid
Curl Basico
Ahora que entendemos como funciona Curl y la sintaxis de sus opciones, podremos ver sus opciones especificas.
Versionado
--version
(-V
) explica todo sobre la
version instalada de curl. Por ejemplo:
curl -V
...listara linea a linea las versiones de Curl en si y sus dependencias, la fecha de lanzamiento, los protocolos disponibles, y las caracteristicas activadas.
--verbose
(-v
) hace que Curl sea verboso,
lo que puede ser util en depuracion:
curl -v http://httpbin/uuid
Si --verbose
es insuficiente, podriamos intentar con el
inefable --trace
(el -
envia la salida de
trace a stdout):
curl --trace - http://httpbin/uuid
...o bien con --trace-ascii
:
curl --trace-ascii - http://httpbin/uuid
Utiliza --write-out
(-w
) para extraer
informacion especifica sobre la respuestas recibidas. Este soporta mas
de 50 variables. Por ejemplo, aqui extraemos el codigo de status y la
respuesta del Content-type:
curl
-w "\nstatus: %{response_code}\ntype: %{content_type}"
http://httpbin/status/429
...o algunos encabezados de la respuesta:
curl
-w "\ndate: %header{date}\nlength: %header{content-length}"
http://httpbin/status/429
Descargas
La opcion --remote-name
(-O
) le dice a curl
que guarde la salida en un fichero indicado en base a la URL,
(especificamente, por la parte que sigue a la ultima /
de
esta). A menudo se usa en conjunto con la opcion
--output-dir
, lo que le dira a Curl exactamente donde
colocar el fichero a guardar:
curl --output-dir /tmp -O http://httpbin/uuid
&& cat /tmp/uuid
Si tal directorio es inexistente, --output-dir
no lo
creara por ti. Deberas usar --create-dirs
para que esto
suceda:
curl --output-dir /tmp/alguna/ruta --create-dirs
-O http://httpbin/uuid
&& cat /tmp/alguna/ruta/uuid
Puedes usar --max-filesize
(en bytes) para limitar el
tamano maximo de respuesta permitido (aunque esto a menudo no se conoce
por adelantado, lo que podria provocar fallas).
Reintentado
A veces puede suceder que el huesped remoto este indispuesto. Para
hacer caso a estas situaciones, Curl provee la opcion
--retry [numero]
. Si la solicitud falla, Curl lo intentara
nuevamente, pero no mas alla de la cantidad de veces indicada por
numero
:
curl -i --retry 3 http://httpbin/unstable
(esta URL falla el 50% de las veces)
Podras indicar la cantidad maxima de tiempo que Curl invertira en
intentar nuevamente la solicitud, por medio de la opcion
--retry-max-time
(segundos), o bien el retraso entre
reintentos, con --retry-delay
(tambien en segundos):
curl -i --retry 3 http://httpbin/unstable
--retry-max-time 2
--retry-delay 1
Para Curl, "request failed" implica recibir alguno de los codigos de
respuesta HTTP: 408
, 429
, 500
,
502
, 503
o 504
. Si la solicitud
falla con un error de "connection refused", Curl no intentara
nuevamente. Sin embargo, este funcionamiento tipico puede alterarse
con la opcion --retry-connrefused
, o incluso activar los
reintentos para todo tipo de problemas con la opcion
--retry-all-errors
.
Subidas
Curl a menudo se usa para bajar informacion (descargar) del servidor,
pero tambien puede subirla. Para ello use la opcion
--upload-file
(-T
):
echo "hola Tercer Mundo!" > /tmp/hola.txt &&
curl -T /tmp/hola.txt http://httpbin/put
Para las cargas de datos a traves de protocolo HTTP, Curl usa el metodo PUT.
Controles de Transferencia
Para detener las descargas lentas, debe configurar la velocidad de
descarga minima permitida (en bytes por segundo) con
--speed-limit
. Por defecto, Curl revisa la velocidad en
intervalos de 30 segundos, pero este comportamiento tipico puede ser
modificado con la opcion --speed-time
.
Por ejemplo, para permitir no menos de 10 bytes/segundo durante un intervalo de 3 segundos:
curl -v --speed-limit 10 --speed-time 3 http://httpbin/get
Para limitar el uso de ancho de banda, utiliza la opcion
--limit-rate
. Esta acepta cualquier cantidad, desde bytes a
petabytes:
curl --limit-rate 3 http://httpbin/get
curl --limit-rate 3k http://httpbin/get
curl --limit-rate 3m http://httpbin/get
curl --limit-rate 3g http://httpbin/get
curl --limit-rate 3t http://httpbin/get
curl --limit-rate 3p http://httpbin/get
Otra cosa para limitar es el numero de solicitudes concurrentes (ej,
si descargas muchos ficheros). Usa --rate
para tal cosa.
Acepta segundos, minutos, horas o dias:
curl --rate 3/s http://httpbin/anything/[1-9].txt
curl --rate 3/m http://httpbin/anything/[1-9].txt
curl --rate 3/h http://httpbin/anything/[1-9].txt
curl --rate 3/d http://httpbin/anything/[1-9].txt
Resolucion de nombre
Por defecto, curl usa tu servidor DNS para resolver desde nombres de
huesped a direcciones IP. Pero puedes forzarlo a resolver una IP
especifica por medio de la opcion --resolve
:
curl --resolve texto-plano.xyz:80:127.0.0.1
http://httpbingo.org:8080/get
...(este falla porque nadie escucha en 127.0.0.1)
O puedes incluso mapear un par maquina:puerto
a otro par
maquina:puerto
con --connect-to
:
curl --connect-to texto-plano.xyz:443:texto-plano:80
http://texto-plano.xyz:443/
(este funcionara bien)
Opciones a nivel conexion
Tambien existen configuraciones a nivel conexion.
timeouts
Para limitar la cantidad de tiempo que curl se pasa interactuando con
una unica URL, usa --max-time
(en fraccionales de
segundo):
curl --max-time 0.5 http:/httpbin/delay/1
(este falla)
En lugar de limitar el tiempo total, puedes usar
--connect-timeout
para limitar solo el tiempo que toma
establecer la conexion en la red:
curl --connect-timeout 0.5 http:/httpbin/delay/1
(este funciona bien)
Credenciales
Casi nunca querras pasar nombre de usuario y contrasena en el comando
de curl en si. Una forma de evitarlo es usar el fichero
$HOME/netrc
. Especifica los nombres de maquina y
credenciales para accederlos:
machine httpbin
login pedro
password chori
machine ejemplo.com
login pablo
password pan
Pasa la opcion --netrc
para usar el fichero
$HOME/.netrc
, o --netrc-file
para usar uno
especifico:
echo -e "machine httpbin\nlogin pedro\npassword chori" > /tmp/netrc &&
curl --netrc-file /tmp/netrc
http://httpbin/basic-auth/pedro/chori
Estados de Salida
Cuando curl finaliza ("sale"), devuelve un valor numerico a la shell
denominado status de salida. El exito se senala con
0
, y los errores tienen 100 valores distintos.
Por ejemplo, aqui hay un exit status 7 ("failed to connect to host"):
curl http://httpbin:1313/get
Puede acceder al status de salida a traves de la variable de
interprete $?
.
HTTP
Principalmente, Curl se usa para trabajar con HTTP, de modo que hablemos un poco de esto.
HTTP/1.x es un protocolo de texto plano que describe la comunicacion entre el cliente y el servidor. El cliente envia mensajes como este:
POST /fulana/sitio HTTP/1.1
host: texto-plano.xyz
content-type: application/json
user-agent: curl/7.87.0
{
"message": "Hola Tercer Mundo!"
}
- La primer linea es una linea de solicitud. El metodo (POST)
define la operacion que el cliente desea realizar. La ruta
(
/fulana/sitio
) es la URL del recurso solicitado (sin poner protocolo, dominio ni puerto). La version (HTTP/1.1
) indica la version del protocolo HTTP usado. - Las lineas siguientes (hasta la linea en blanco) son encabezados.
Cada envabzado tiene un par clave-valor que le dice al servidor
informacion util sobre la solicitud. En este caso es el nombre de host
del servidor (
texto-plano.xyz
), el tipo de contenido (application/json
) y la auto-identificacion del cliente (user-agent
). - Finalmente, estos son los datos que el cliente envia al servidor.
En respuesta a esto, el cliente recibira un mensaje como este:
HTTP/1.1 200 OK
date: Mon, 28 Aug 2023 07:51:49 GMT
content-type: application/json
{
"message": "Como va!"
}
- La primer linea es la linea de status. La version
(
HTTP/1.1
) indica la version del protocolo HTTP. El codigo de status (200
) informa si la solicitud fue exitosa o no, y porque (existen muchos codigos de status para distintas situaciones). El mensaje de status es una descripcion para el humano del codigo de status (HTTP/2 no la tiene). - Las siguientes lineas (hasta la linea en blanco) son encabezados. Al igual que los encabezados de solicitud, estos dan informacion util sobre la respuesta del cliente.
- Finalmente, va la informacion real que el servidor envia al cliente.
El protocolo HTTP carece de estado, por lo cual cualquier estado debera estar contenido dentro de la solicitud en si (ya sea en el encabezado o en el cuerpo).
HTTP/2
HTTP/2, es el sucesor de HTTP/1.1, y en realidad es un protocolo binario. Sin embargo, curl presenta los mensajes de HTTP/2 en texto plano (al igual que en HTTP/1.1), asi que para propositos de uso de curl, podemos ignorar este hecho.
Metodo HTTP
Curl soporta todos los metodos HTTP (a menudos referidos como verbos).
GET
(el que es por defecto, no necesita opciones):
curl http://httpbin/get
HEAD
(-I
/--head
, solo devuelve
los encabezados):
curl -I http://httpbin/head
POST (-d
/--data
para datos o
-F
/--form
para el formulario HTTP):
curl -d "name=fulana" http://httpbin/post
O cualquier otro metodo con --request
(-X
):
curl -X PATCH -d "name=fulana" http://httpbin/patch
Codigo de Respuesta
Tipicamente, los codigos de status 2xx
(200
, especificamente) son considerados "exitosos",
mientras que los 4xx
son tratados como errores del lado del
cliente, y los 5xx
como errores del lado del servidor. Pero
a curl no les importan los codigos, para el, cualquier respuesta HTTP
obtenida es considerada un exito:
curl http://httpbin/status/503 && echo OK
Para hacer que curl trate los codigos 4xx y 5xx como errores, use
--fail
(-f
):
curl -f http://httpbin/status/503 && echo OK
Para presentar el codigo de respuesta, use --write-out
con la variable response_code
:
curl -w "%{response_code}" http://httpbin/status/200
Encabezados de Respuesta
Para presentar los encabezados de respuesta, use --head
(-i
):
curl -i http://httpbin/status/200
O guardelos en un fichero usando --dump-header
(-D
):
curl -D /tmp/encabezados http://httpbin/status/200
&& cat /tmp/encabezados
Cuerpo de Respuesta
Lo que devuelve por defecto curl es el cuerpo de respuesta, a menudo llamado payload o cabeza de guerra.
curl http://httpbin/get
Puede solicitar al servidor comprimir los datos por medio de
--compressed
, pero aun asi curl los presentara
descomprimidos:
curl --compressed http://httpbin/get
(note como el encabezado de solicitud Accept-Encoding ha cambiado)
Rangos
Para solicitar al servidor una seccion de los datos en lugar del todo
el entero, se usa la opcion --range
(r
). Esto
provocara que curl solicite el rango de bytes especificados.
Por ejemplo, para solicitar 50 bytes de datos a partir del 100° byte:
curl --range 100-150 http://httpbin/range/1024
Tenga presente que el server puede ignorar un pedido delimitado, y devolver la respuesta entera y completa (dependiendo de su propia configuracion de seguridad).
Si esta descargando datos de un servidor, tambien puede usar
--continue-at
(-C
) para continuar la
transmision previa en un offset determinado:
curl --continue-at 1000 http://httpbin/range/1024
Versiones HTTP
Por defecto, curl usa HTTP/1.1 para el esquema de transmision http, y HTTP/2 para https. Se puede cambiar esto con modificadores:
curl --http0.9
curl --http1.0
curl --http1.1
curl --http2
curl --http3
Para saber que version de HTTP soporta el server, use la variable de
respuesta http_version
:
curl -w "%{http_version}" http://httpbin/status/200
Solicitudes Condicionales
Las solicitudes condicionales son utiles cuando queremos evitar descargar datos ya descargados (asumiendo que la transmision no esta detenida). Curl soporta dos condiciones distintas: etiquetado de hora de fichero ("file timestamp") y etiquetado electronico ("etag").
Para condiciones de Timestamp use --time-cond
(-z
).
Descargar datos solo si el recurso remoto es mas nuevo (la condicion se retiene):
curl --time-cond "Aug 30, 2023" http://httpbin/etag/etag
...o mas viejo (la condicion falla):
curl -i --time-cond "-Aug 30, 2023" http://httpbin/etag/etag
Las condiciones Etag son un poco mas completas. Un etag es un valor devuelto por el servidor que identifica univocamente la version actual del recurso solicitado. A menudo es un hash de los datos.
Para revisar un etag, curl debe primero guardarlo con
--etag-save
:
curl --etag-save /tmp/etags http://httpbin/etag/etag
...y usar --etag-compare
en las solicitudes
subsecuentes:
curl --etag-save /tmp/etags -o /dev/null http://httpbin/etag/etag &&
curl -i --etag-compare /tmp/etags http://httpbin/etag/etag
Las condiciones Timestamp confian en el encabezado de respuesta Last-Modified ("modificado por ultima vez"), de modo que si el servidor no lo ofrece, el recurso siempre sera considerado el mas actual. Lo mismo sucede para las condiciones etag y para el encabezado de respuesta Etag.
Envio HTTP
POST
envia datos al servidor. Por defecto, es un
conjunto de pares clave-valor condificados en una sola cadena con un
encabezado Content-Type
application/x-www-form-urlencoded
.
Puede usar --data
(-d
) para especificar los
pares clave-valor individualmente (o para la cadena entera):
curl -d name=fulana -d edad=25 http://httpbin/post
Para enviar datos desde un fichero, usamos @
con la ruta
del fichero. Usamos --header
(-H
) para cambiar
el encabezado Content-Type de acuerdo a los contenidos del
fichero:
echo "Fulana, edad 25" > /tmp/data.txt &&
curl -d @/tmp/datos.txt -H "content-type: text/plain"
http://httpbin/post
--data-raw
envia datos de manera similar a
--data
, pero sin interpretar el caracter
@
.
Para enviar datos JSON, usamos --json
. Automaticamente
cambiara los encabezados Content-Type y Accept de
manera acorde:
curl --json '{"nombre": "fulana"}' http://httpbin/post
Solicitudes JSON
Usamos jo
y jq
para simplificar el trabajo
con JSON.
Para condificar datos de URL-encode (escapar todos los simbolos no
permitidos en las URLs), use el --data-urlencode
:
curl --data-urlencode "Nombre: Fulana Mengana" http://httpbin/post
Envio de formularios multiparte
POST
puede enviar tados como una secuencia de "partes"
con un timpo de contenido multipart/form-data
. Esto se usa
a menudo para formularios HTML que contienen tanto campos de texto y
ficheros.
Cada parte tiene un nombre, encabezados, y datos. Las parte se separan por una "frontera mime" (27 guiones e identificador alfanumerico de 16 caracteres), de esta manera:
--------------------------d74496d66958873e
Content-Disposition: form-data; nombre="persona"
Anonimo
--------------------------d74496d66958873e
Content-Disposition: form-data; nombre="secret"; filename="fichero.txt"
Content-Type: text/plain
contenidos del fichero
--------------------------d74496d66958873e--
Para construir estas solicitudes multipartes con curl, usamos
--form
(F
). Cada una de estas opciones agrega
una parte a la solicitud:
touch /tmp/fulana.png &&
curl -F nombre=Fulana -F edad=25 -F foto=@/tmp/fulana.png
http://httpbin/post
Redirecciones
Una redireccion sucede cuando el servidor, en lugar de devolver el
recurso solicitado, le dice al cliente que el recurso esta localizado en
otro lado (como se indica en el encabezado de Locacion). La redireccion
siempre tiene un codigo de respuesta 3xx
.
Por defecto, Curl no sigue el redireccionamiento, y devuelve una respuesta similar a:
curl -i http://httpbin/redirect/1
Para hacer que Curl sigua redirecciones, use --follow
(-L
):
curl -L http://httpbin/redirect/1
Para protegerse contra redirecciones en bucle sinfin, use el
limitador --max-redirs
, por ejemplo:
curl -L --max-redirs 3 http://httpbin/redirect/10
HTTP PUT
A menudo se usa el metodo PUT
para enviar ficheros al
servidor. Para esto, use --upload-file
(-T
):
echo "Hola Tercer Mundo!" > /tmp/hola.txt &&
curl -T /tmp/hola.txt http://httpbin/put
En ocasiones, se utiliza PUT
para hacer solicitudes a
APIs REST. Para ellas, utilice --request
(-X
)
para establecer el metodo, y --data
(-d
) para
enviar los datos:
curl -X PUT -H "content-type: application/json"
-d '{"nombre": "fulana"}'
http://httpbin/put
Cookies
El protocolo HTTP carece de estado, y las cookies fueron concebidas como un metodo ingenioso para sortear esto, siguiendo este mecanismo general:
- El servidor desea asociar algun estado con la sesion del cliente.
- El servidor devuelve el estado en el encabezado de respueta Set-Cookie.
- El cliente reconoce las cookies y las envia de vuelta con cada solicitud incorporada al encabezado de solicitud de la cookie.
Cada cookie tiene una fecha de vencimiento - ya sea explifita o una de "fin de sesion" (en los clientes de navegacion, esto a menudo sucede cuando se cierra el navegador)
Por defecto, Curl ignora las cookies. Para activarlas, use la opcion
--cookie
(-b
). Para hacer que curl haga
persistir las cookies entre llamadas, use --cookie-jar
(-c
).
Aunque su reputacion ha sido ensuciada por los infames "baneos de cookies", las cookies siguen siendo uno de los mejores ejemplos de nombrado de funcionalidad.
Aqui el servidor establece la sessionid de cookie al valor
123456
y curl la almacena en el jarro de cookies siguado en
/tmp/cookies
:
curl -b "" -c /tmp/cookies
http://httpbin/cookies/set?sessionid=123456
&& cat /tmp/cookies
...Las llamadas subsecuentes con -b /tmp/cookies
enviaran la cookie con la sessionid indicada de vuelta al
servidor.
Curl descarta automaticamente las cookies del jarro de cookies cuando
superan su vencimiento (esto requiere una fecha de vencimiento explicita
configurada por el servidor). Para desccartar las cookies basadas en
sesion, use --junk-session-cookies
(-j
):
curl -j -b /tmp/cookies http://httpbin/get
Servicios alternativos
El encabezado de respuesta HTTP Alt-Svc indica que existe otra localizacion de red (un servicio alternativo) que el cliente podria utilizar para solicitudes futuras.
Para permitir los servicios alternativos, use --alt-svc
.
Esto le dice a curl que almacenee dichos servicios en un fichero
especificado, y los considere para solicitudes futuras.
curl --alt-svc /tmp/servicios_alternativos -o /dev/null
http://httpbin/get
&& cat /tmp/servicios_alternativos
Seguridad Estricta de Transporte HTTP
El encabezado de respuesta HTTP Strict-Transport-Security (tambien conocido como HSTS) informa al cliente que el servidor solo debe ser accedido a traves de HTTPS, y que cualquier intento futuro de accederlo a traves de HTTP debe ser convertido a HTTPS automaticamente.
Para hacer que curl respete esta represion impuesta por el HSTS, use
--hsts
. Esto hara que curl almacene los servidores con HSTS
activado en un fichero especificado, y convierta automaticamente las
solicitudes http a https cuando las acceda.
curl --hsts /tmp/hsts -o /dev/null
http://httpbin/get
&& cat /tmp/hsts
Documentacion
Curl cuenta con una extensa documentacion de referencia. Puedes verla con:
curl --help
Para ver la version completa del manual, puedes probar con:
curl --manual | less
Conclusion
Curl es una de las herramientas predilectas para las transferencias electronicas, e intentar dominarlo en texto-plano.xyz requiere alardearlo con gab:
gab -m "¡Aprendi a usar curl, la “navaja suiza del hacker” en texto-plano.xyz!"