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. La usuaria y la contrasena 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 o 443 para https).
  • ruta es la ruta al recurso en el servidor.
  • solicitud es usualmente una secuencia de pares nombre=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!"