Cómo usar el comando ar de Linux para crear bibliotecas estáticas

Utilice el comando ar de Linux para crear bibliotecas de funciones cuando esté desarrollando software. Este tutorial le mostrará cómo crear una biblioteca estática, modificarla y usarla en un programa, con código de muestra.

El comando ar es un verdadero veterano; existe desde 1971. El nombre ar hace referencia al uso original previsto para la herramienta, que fue para crear archivos de almacenamiento. Un archivo de almacenamiento es un archivo único que actúa como contenedor de otros archivos. A veces, para muchos otros archivos. Los archivos se pueden agregar, eliminar o extraer del archivo. Las personas que buscan ese tipo de funcionalidad ya no recurren a AR. Ese papel ha sido asumido por otras utilidades como tar.

Sin embargo, el comando ar todavía se usa para algunos propósitos especializados. ar se utiliza para crear bibliotecas estáticas. Estos se utilizan en el desarrollo de software. Y ar también se utiliza para crear archivos de paquetes como los archivos «.deb» utilizados en la distribución Debian Linux y sus derivados, como Ubuntu.

Vamos a ejecutar los pasos necesarios para crear y modificar una biblioteca estática, y demostraremos cómo usar la biblioteca en un programa. Para hacer eso, necesitamos un requisito para que la biblioteca estática cumpla. El propósito de esta biblioteca es codificar cadenas de texto y decodificar texto codificado.

Tenga en cuenta que este es un truco rápido y sucio para fines de demostración. No utilice este cifrado para nada que sea de valor. Es el mas simple del mundo cifrado de sustitución, donde A se convierte en B, B se convierte en C, y así sucesivamente.

Las funciones cipher_encode () y cipher_decode ()

Vamos a trabajar en un directorio llamado «biblioteca» y luego crearemos un subdirectorio llamado «prueba».

Tenemos dos archivos en este directorio. En un archivo de texto llamado cipher_encode.c tenemos la función cipher_encode ():

void cipher_encode(char *text)
{
 for (int i=0; text[i] != 0x0; i++) {
   text[i]++;
 }

} // end of cipher_encode

La función correspondiente cipher_decode () está en un archivo de texto llamado cipher_decode.c:

void cipher_decode(char *text)
{
 for (int i=0; text[i] != 0x0; i++) {
   text[i]--;
 }

} // end of cipher_decode

Los archivos que contienen instrucciones de programación se denominan archivos de código fuente. Vamos a crear un archivo de biblioteca llamado libcipher.a. Contendrá las versiones compiladas de estos dos archivos de código fuente. También crearemos un archivo de texto corto llamado libcipher.h. Este es un archivo de encabezado que contiene las definiciones de las dos funciones en nuestra nueva biblioteca.

Cualquiera que tenga la biblioteca y el archivo de encabezado podrá utilizar las dos funciones en sus propios programas. No necesitan reinventar la rueda y reescribir las funciones; simplemente hacen uso de las copias de nuestra biblioteca.

Compilar los archivos cipher_encode.cy cipher_decode.c

Para compilar los archivos de código fuente, usaremos gcc, el compilador GNU estándar. La opción -c (compilar, sin enlace) le dice a gcc que compile los archivos y luego se detenga. Produce un archivo intermediario de cada archivo de código fuente llamado archivo objeto. El enlazador gcc generalmente toma todos los archivos de objeto y los vincula para crear un programa ejecutable. Nos saltamos ese paso usando la opción -c. Solo necesitamos los archivos de objeto.

Comprobemos que tenemos los archivos que creemos que tenemos.

ls -l

Los dos archivos de código fuente están presentes en este directorio. Usemos gcc para compilarlos en archivos objeto.

gcc -c cipher_encode.c

gcc -c cipher_decode.c

No debería haber salida de gcc si todo va bien.

Esto genera dos archivos de objeto con el mismo nombre que los archivos de código fuente, pero con extensiones «.o». Estos son los archivos que necesitamos agregar al archivo de la biblioteca.

ls -l

Creación de la biblioteca libcipher.a

Para crear el archivo de biblioteca, que en realidad es un archivo de almacenamiento, usaremos ar.

Estamos usando la opción -c (crear) para crear el archivo de la biblioteca, la opción -r (agregar con reemplazar) para agregar los archivos al archivo de la biblioteca y la opción -s (índice) para crear un índice de los archivos dentro el archivo de la biblioteca.

Vamos a llamar al archivo de biblioteca libcipher.a. Proporcionamos ese nombre en la línea de comandos, junto con los nombres de los archivos de objeto que vamos a agregar a la biblioteca.

ar -crs libcipher.a cipher_encode.o cipher_decode.o

Si enumeramos los archivos en el directorio, veremos que ahora tenemos un archivo libcipher.a.

ls -l

Si usamos la opción -t (tabla) con ar, podemos ver los módulos dentro del archivo de la biblioteca.

ar -t libcipher.a

Creación del archivo de encabezado libcipher.h

El archivo libcipher.h se incluirá en cualquier programa que utilice la biblioteca libcipher.a. El archivo libcipher.h debe contener la definición de las funciones que están en la biblioteca.

Para crear el archivo de encabezado, debemos escribir las definiciones de la función en un editor de texto como gedit. Nombra el archivo “libcipher.h” y guárdalo en el mismo directorio que el archivo libcipher.a.

void cipher_encode(char *text);
void cipher_decode(char *text);

Usando la biblioteca libcipher

La única forma segura de probar nuestra nueva biblioteca es escribir un pequeño programa para usarla. Primero, crearemos un directorio llamado test.

mkdir test

Copiaremos la biblioteca y los archivos de encabezado en el nuevo directorio.

cp libcipher.* ./test

Cambiaremos al nuevo directorio.

cd test

Revisemos que nuestros dos archivos estén aquí.

ls -l

Necesitamos crear un pequeño programa que pueda usar la biblioteca y demostrar que funciona como se esperaba. Escriba las siguientes líneas de texto en un editor. Guarde el contenido del editor en un archivo llamado «test.c» en el directorio de prueba.

#include 
#include 

#include "libcipher.h"

int main(int argc, char *argv[])
{
 char text[]="kirukiru.es loves Linux";

 puts(text);

 cipher_encode(text);
 puts(text);

 cipher_decode(text);
 puts(text);

 exit (0);

} // end of main

El flujo del programa es muy simple:

Incluye el archivo libcipher.h para que pueda ver las definiciones de funciones de la biblioteca.
Crea una cadena llamada «texto» y almacena las palabras «kirukiru.es loves Linux» en ella.
Imprime esa cadena en la pantalla.
llama a la función cipher_encode () para codificar la cadena, e imprime la cadena codificada en la pantalla.
Llama a cipher_decode () para decodificar la cadena e imprime la cadena decodificada en la pantalla.

Para generar el programa de prueba, necesitamos compilar el programa test.cy el enlace en la biblioteca. La opción -o (salida) le dice a gcc cómo llamar al programa ejecutable que genera.

gcc test.c libcipher.a -o test

Si gcc te devuelve silenciosamente al símbolo del sistema, todo está bien. Ahora probemos nuestro programa. Momento de la verdad:

./test

Y vemos el resultado esperado. El programa de prueba imprime el texto sin formato imprime el texto cifrado y luego imprime el texto descifrado. Está usando las funciones dentro de nuestra nueva biblioteca. Nuestra biblioteca está funcionando.

Éxito. Pero, ¿por qué detenerse ahí?

Agregar otro módulo a la biblioteca

Agreguemos otra función a la biblioteca. Agregaremos una función que el programador puede usar para mostrar la versión de la biblioteca que está usando. Necesitaremos crear la nueva función, compilarla y agregar el nuevo archivo de objeto al archivo de biblioteca existente.

Escriba las siguientes líneas en un editor. Guarde el contenido del editor en un archivo llamado cipher_version.c, en el directorio de la biblioteca.

#include 

void cipher_version(void)
{
 puts("kirukiru.es :: VERY INSECURE Cipher Library");
 puts("Version 0.0.1 Alphan");

} // end of cipher_version

Necesitamos agregar la definición de la nueva función al archivo de encabezado libcipher.h. Agregue una nueva línea al final de ese archivo, para que se vea así:

void cipher_encode(char *text);
void cipher_decode(char *text);
void cipher_version(void);

Guarde el archivo libcipher.h modificado.

Necesitamos compilar el archivo cipher_version.c para que tengamos un archivo objeto cipher_version.o.

gcc -c cipher_version.c

Esto crea un archivo cipher_version.o. Podemos agregar el nuevo archivo de objeto a la biblioteca libcipher.a con el siguiente comando. La opción -v (verbosa) hace que el ar usualmente silencioso nos diga lo que ha hecho.

ar -rsv libcipher.a cipher_version.o

El nuevo archivo de objeto se agrega al archivo de biblioteca. ar imprime la confirmación. La «a» significa «agregado».

Podemos usar la opción -t (tabla) para ver qué módulos están dentro del archivo de la biblioteca.

ar -t libcipher.a

Ahora hay tres módulos dentro de nuestro archivo de biblioteca. Hagamos uso de la nueva función.

Usando la función cipher_version ().

Eliminemos la biblioteca antigua y el archivo de encabezado del directorio de prueba, copiemos los archivos nuevos y luego cambiemos de nuevo al directorio de prueba.

Eliminaremos las versiones anteriores de los archivos.

rm ./test/libcipher.*

Copiaremos las nuevas versiones en el directorio de prueba.

cp libcipher.* ./test

Cambiaremos al directorio de prueba.

cd test

Y ahora podemos modificar el programa test.c para que use la nueva función de biblioteca.

Necesitamos agregar una nueva línea al programa test.c que llama a la función cipher_version (). Colocaremos esto antes de la primera colocación (texto); línea.

#include 
#include  

#include "libcipher.h" 

int main(int argc, char *argv[]) 
{
 char text[]="kirukiru.es loves Linux"; 

 // new line added here
 cipher_version(); 

 puts(text); 
 
 cipher_encode(text); 
 puts(text); 
 
 cipher_decode(text); 
 puts(text); 

 exit (0); 

} // end of main

Guarde esto como test.c. Ahora podemos compilarlo y probar que la nueva función está operativa.

gcc test.c libcipher.a -o test

Ejecutemos la nueva versión de prueba:

La nueva función está funcionando. Podemos ver la versión de la biblioteca al comienzo de la salida de prueba.

Pero puede haber un problema.

Reemplazo de un módulo en la biblioteca

Esta no es la primera versión de la biblioteca; es el segundo. Nuestro número de versión es incorrecto. La primera versión no tenía la función cipher_version (). Este lo hace. Así que esta debería ser la versión «0.0.2». Necesitamos reemplazar la función cipher_version () en la biblioteca con una corregida.

Afortunadamente, ar lo hace muy fácil de hacer.

Primero, editemos el archivo cipher_version.c en el directorio de la biblioteca. Cambie el texto «Versión 0.0.1 Alfa» a «Versión 0.0.2 Alfa». Debe tener un aspecto como este:

#include 

void cipher_version(void)
{
 puts("kirukiru.es :: VERY INSECURE Cipher Library");  
 puts("Version 0.0.2 Alphan"); 

} // end of cipher_version

Guarde este archivo. Necesitamos compilarlo nuevamente para crear un nuevo archivo de objeto cipher_version.o.

gcc -c cipher_version.c

Ahora reemplazaremos el objeto cipher_version.o existente en la biblioteca con nuestra versión recién compilada.

Hemos usado la opción -r (agregar con reemplazar) antes, para agregar nuevos módulos a la biblioteca. Cuando lo usamos con un módulo que ya existe en la biblioteca, ar reemplazará la versión anterior por la nueva. La opción -s (índice) actualizará el índice de la biblioteca y la opción -v (detallado) hará que ar nos diga lo que ha hecho.

ar -rsv libcipher.a cipher_version.o

Esta vez ar informa que ha reemplazado el módulo cipher_version.o. La «r» significa reemplazado.

Uso de la función cipher_version () actualizada

Deberíamos utilizar nuestra biblioteca modificada y comprobar que funciona.

Copiaremos los archivos de la biblioteca al directorio de prueba.

cp libcipher.* ./test

Cambiaremos al directorio de prueba.

cd ./test

Necesitamos compilar nuestro programa de prueba nuevamente con nuestra nueva biblioteca.

gcc test.c libcipher.a -o test

Y ahora podemos probar nuestro programa.

./test

El resultado del programa de prueba es lo que esperábamos. El número de versión correcto se muestra en la cadena de versión y las rutinas de cifrado y descifrado están funcionando.

Eliminar módulos de una biblioteca

Parece una pena después de todo eso, pero eliminemos el archivo cipher_version.o del archivo de la biblioteca.

Para hacer esto, usaremos la opción -d (borrar). También usaremos la opción -v (detallada), de modo que ar nos diga lo que ha hecho. También incluiremos la opción -s (índice) para actualizar el índice en el archivo de la biblioteca.

ar -dsv libcipher.a cipher_version.o

ar informa que ha eliminado el módulo. La «d» significa «eliminado».

Si le pedimos a ar que enumere los módulos dentro del archivo de la biblioteca, veremos que volvemos a dos módulos.

ar -t libcipher.a

Si va a eliminar módulos de su biblioteca, recuerde eliminar su definición del archivo de encabezado de la biblioteca.

Comparte tu código

Las bibliotecas hacen que el código se pueda compartir de una manera práctica pero privada. Cualquiera a quien le dé el archivo de la biblioteca y el archivo de encabezado puede usar su biblioteca, pero su código fuente real permanece privado.