Como usar o comando ar do Linux para criar bibliotecas estáticas

Use o comando ar do Linux para criar bibliotecas de funções ao desenvolver um software. Este tutorial mostrará como criar uma biblioteca estática, modificá-la e usá-la em um programa, completo com código de amostra.

O comando ar é um verdadeiro veterano - existe desde 1971. O nome refere-se ao uso original pretendido para a ferramenta, que era criar arquivos compactados. Um arquivo archive é um único arquivo que atua como um contêiner para outros arquivos. Às vezes, para muitos outros arquivos. Os arquivos podem ser adicionados, removidos ou extraídos do arquivo. As pessoas que procuram esse tipo de funcionalidade não usam mais ar. Esse papel foi assumido por outros utilitários como tar.

O comando ar ainda é usado para alguns fins de especialista. ar é usado para criar bibliotecas estáticas. Estes são usados ​​no desenvolvimento de software. E ar também é usado para criar arquivos de pacotes, como os arquivos ".deb" usados ​​na distribuição Debian Linux e seus derivados, como o Ubuntu.

Vamos executar as etapas necessárias para criar e modificar uma biblioteca estática e demonstrar como usar a biblioteca em um programa. Para fazer isso, precisamos de um requisito para que a biblioteca estática seja cumprida. O objetivo desta biblioteca é codificar strings de texto e decodificar textos codificados.

Por favor, note que este é um hack rápido e sujo para fins de demonstração. Não use essa criptografia para nada que seja valioso. É a cifra de substituição mais simples do mundo, onde A se torna B, B se torna C e assim por diante.

RELACIONADO: Como compactar e extrair arquivos usando o comando tar no Linux

As funções cipher_encode () e cipher_decode ()

Nós vamos estar trabalhando em um diretório chamado "biblioteca", e depois vamos criar um subdiretório chamado "teste".

Temos dois arquivos neste diretório. Em um arquivo de texto chamado cipher_encode.c, temos a função cipher_encode ():

 void cipher_encode (char * text) {para (int i = 0; texto [i]! = 0x0; i ++ ) {texto [i] ++; }} // fim do cipher_encode 

A função cipher_decode () correspondente está em um arquivo de texto chamado cipher_decode.c:

 void cipher_decode (char * text) {para ( int i = 0; texto [i]! = 0x0; i ++) {texto [i] -; }} // end of cipher_decode 

Arquivos que contêm instruções de programação são chamados de arquivos de código-fonte. Nós vamos fazer um arquivo de biblioteca chamado libcipher.a. Ele conterá as versões compiladas desses dois arquivos de código-fonte. Também criaremos um pequeno arquivo de texto chamado libcipher.h. Este é um arquivo de cabeçalho contendo as definições das duas funções em nossa nova biblioteca.

Qualquer pessoa com a biblioteca e o arquivo de cabeçalho poderá usar as duas funções em seus próprios programas. Eles não precisam reinventar a roda e reescrever as funções; eles simplesmente fazem uso das cópias em nossa biblioteca.

Compilando os arquivos cipher_encode.c e cipher_decode.c

Para compilar os arquivos de código fonte, usaremos o gcc, o GNU padrão. compilador. A opção -c (compilar, sem link) diz ao gcc para compilar os arquivos e depois parar. Ele produz um arquivo intermediário de cada arquivo de código-fonte chamado arquivo de objeto. O linker do gcc geralmente pega todos os arquivos de objetos e os liga para criar um programa executável. Estamos pulando essa etapa usando a opção -c. Precisamos apenas dos arquivos objeto.

Vamos verificar se temos os arquivos que pensamos fazer.

 ls -l 

Os dois arquivos de código-fonte estão presentes neste diretório. Vamos usar o gcc para compilá-los em arquivos objeto.

 gcc -c cipher_encode.c 

 gcc -c cipher_decode.c 

não deve haver saída do gcc se tudo correr bem.

Isso gera dois arquivos objeto com o mesmo nome dos arquivos de código fonte, mas com extensões “.o”. Estes são os arquivos que precisamos adicionar ao arquivo da biblioteca.

 ls -l 

Criando a biblioteca libcipher.a

]

Para criar o arquivo de biblioteca - que é na verdade um arquivo - nós usaremos ar.

Estamos usando a opção -c (create) para criar o arquivo de biblioteca, o -r (add com substituir) opção para adicionar os arquivos para o arquivo de biblioteca, e a opção -s (index) para criar um índice dos arquivos dentro do arquivo de biblioteca.

Vamos chamar o arquivo da biblioteca libcipher. uma. Nós fornecemos esse nome na linha de comando, juntamente com os nomes dos arquivos de objeto que vamos adicionar à biblioteca.

 ar -crs libcipher.a cifra_encode.o cifra_decode.o 

IMAGEM_4

Se listarmos os arquivos no diretório, veremos que agora temos uma libcipher .a arquivo.

ls -l

Se usarmos a opção -t (table) com ar, poderemos ver os módulos dentro do arquivo de biblioteca .

 ar -t libcipher.a 

Criando o arquivo de cabeçalho libcipher.h

O libcipher.h O arquivo será incluído em qualquer programa que use a biblioteca libcipher.a. O arquivo libcipher.h deve conter a definição das funções que estão na biblioteca.

Para criar o arquivo de cabeçalho, devemos digitar as definições da função em um editor de texto como o gedit. Nomeie o arquivo “libcipher.h” e salve-o no mesmo diretório que o arquivo libcipher.a.

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

Usando a biblioteca libcipher

A única maneira segura de testar nossa nova biblioteca é escrever um pequeno programa para usá-la. Primeiro, criaremos um diretório chamado test.

 teste mkdir 

Copiaremos os arquivos de biblioteca e cabeçalho para o novo diretório.

 cp libcipher. * ./Test

Vamos mudar para o novo diretório.

 teste de cd 

Vamos verificar se nossos dois arquivos estão aqui.

 ls -l 

IMAGEM_7

Precisamos criar um pequeno programa que possa usar a biblioteca e provar que ela funciona como esperado. Digite as seguintes linhas de texto em um editor. Salve o conteúdo do editor em um arquivo chamado “test.c” no diretório de teste.

 #include < stdio.h > #include < stdlib.h > #include "libcipher.h" int main (argc int, char * argv []) {char text [] = "Como Geek adora Linux"; puts (texto); cipher_encode (text); puts (texto); cipher_decode (text); puts (texto); saída (0); } // fim do main 

O fluxo do programa é muito simples:

• Inclui o arquivo libcipher.h para que ele possa ver as definições das funções da biblioteca.
• Cria uma string chamada "text" e armazena as palavras "How-To Geek loves Linux" nela.
• Imprime essa string na tela.
• chama a função cipher_encode () para codificar a string e imprime a string codificada na tela.
• Chama cipher_decode () para decodificar a string e imprime a string decodificada na tela.

Para gerar o programa de teste, precisamos compilar o programa test.c e criar um link na biblioteca. A opção -o (output) diz ao gcc como chamar o programa executável que ele gera.

 gcc test.c libcipher.a -o teste 

Se o gcc retornar silenciosamente para o prompt de comando, tudo estará bem. Agora vamos testar nosso programa. Momento da verdade:

 ./ teste 

E vemos a saída esperada. O programa de teste imprime o texto sem formatação imprime o texto criptografado e imprime o texto descriptografado. Está usando as funções dentro de nossa nova biblioteca. Nossa biblioteca está funcionando.

Sucesso. Mas por que parar aí?

Adicionando outro módulo à biblioteca

Vamos adicionar outra função à biblioteca. Adicionaremos uma função que o programador pode usar para exibir a versão da biblioteca que estão usando. Precisamos criar a nova função, compilá-la e adicionar o novo arquivo de objeto ao arquivo de biblioteca existente.

Digite as seguintes linhas em um editor. Salve o conteúdo do editor em um arquivo chamado cipher_version.c, no diretório da biblioteca.

 #include < stdio.h > void cipher_version (void) {puts ("How-To Geek :: MUITO INSECURE Cipher Library"); puts ("Versão 0.0.1 Alfa \ n"); } // fim de cipher_version 

Precisamos adicionar a definição da nova função ao arquivo de cabeçalho libcipher.h. Adicione uma nova linha ao final do arquivo, para que fique assim:

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

Salve o arquivo libcipher.h modificado.

Precisamos compilar o arquivo cipher_version.c para que tenhamos um arquivo de objeto cipher_version.o.

[PRÉ] gcc -c cipher_version.c

Isto cria um arquivo cipher_version.o. Podemos adicionar o novo arquivo de objeto à biblioteca libcipher.a com o seguinte comando. A opção -v (verbose) faz com que o ar geralmente silencioso nos diga o que ele fez.

 ar -rsv libcipher.a cipher_version.o 

O novo arquivo objeto é adicionado ao arquivo da biblioteca. ar imprime a confirmação. O "a" significa "adicionado".

Podemos usar a opção -t (table) para ver quais módulos estão dentro do arquivo da biblioteca.

 ar -t libcipher.a [/ PRE ] 
 
 
 Agora existem três módulos dentro do nosso arquivo de biblioteca. Vamos fazer uso da nova função.  
 Usando a função cipher_version (). 
 
 Vamos remover a biblioteca antiga e o arquivo de cabeçalho do diretório de teste, copiar os novos arquivos e, em seguida, voltar ao diretório de teste.  
 Excluiremos as versões antigas do arquivos.  
 
 rm ./test/libcipher.*
Vamos copiar as novas versões para o diretório de teste.  
 
 cp libcipher. * ./test
Vamos mudar para o diretório de teste.  
 
 teste de cd 
 
 
 
 agora podemos modificar o programa test.c para que ele use a nova função de biblioteca.  
 Precisamos adicionar uma nova linha ao programa test.c que chama a função cipher_version (). Colocaremos isso antes das primeiras colocações (texto); linha.  
 
 #include < stdio.h > #include < stdlib.h > #include "libcipher.h" int main (argc int, char * argv []) {char text [] = "Como Geek adora Linux"; // nova linha adicionada aqui cipher_version (); puts (texto); cipher_encode (text); puts (texto); cipher_decode (text); puts (texto); saída (0); } // fim do main 
 
 Salve isso como test.c. Agora podemos compilá-lo e testar se a nova função está operacional.  
 
 gcc teste.c libcipher.a -o teste 
 
 IMAGEM_16  
 Vamos execute a nova versão do teste:  
 
 
 A nova função está funcionando. Podemos ver a versão da biblioteca no início da saída do teste.  
 Mas pode haver um problema.  
 Substituindo um módulo na biblioteca 
 
 Esta não é a primeira versão da biblioteca; é o segundo. Nosso número de versão está incorreto. A primeira versão não tinha nenhuma função cipher_version () nela. Este faz. Portanto, esta deve ser a versão “0.0.2”. Precisamos substituir a função cipher_version () na biblioteca por uma corrigida.  
 Felizmente, ar torna isso muito fácil de fazer.  
 Primeiro, vamos editar o arquivo cipher_version.c no diretório da biblioteca. Altere o texto "Versão 0.0.1 Alfa" para "Versão 0.0.2 Alfa". Deverá ter esta aparência:  
 
 #include < stdio.h > void cipher_version (void) {puts ("How-To Geek :: MUITO INSECURE Cipher Library"); puts ("Versão 0.0.2 Alfa \ n"); } // fim de cipher_version 
 
 Salve este arquivo. Precisamos compilá-lo novamente para criar um novo arquivo de objeto cipher_version.o.  
 [PRÉ] gcc -c cipher_version.c 

Agora vamos substitua o objeto cipher_version.o existente na biblioteca pela nossa versão recém-compilada.

Nós usamos a opção -r (add com replace) antes, para adicionar novos módulos à biblioteca. Quando o usamos com um módulo que já existe na biblioteca, o ar substituirá a versão antiga pela nova. A opção -s (index) atualizará o índice da biblioteca e a opção -v (verbose) fará com que nos digam o que ele fez.

 ar -rsv libcipher.a cipher_version.o 

Desta vez reporta que substituiu o módulo cipher_version.o. O "r" significa substituído.

Usando a função cipher_version () atualizada

Devemos usar nossa biblioteca modificada e verificar se ela funciona.

Vamos copiar os arquivos da biblioteca para o diretório de teste.

 cp libcipher. * ./test

Vamos mudar para o diretório de teste.

 cd ./test

Precisamos compilar nosso programa de teste novamente com nossa nova biblioteca.

 gcc test.c libcipher.a -o test 

E agora podemos testar nosso programa.

 ./ teste 

A saída do programa de teste é o que esperávamos. O número da versão correta está aparecendo na string de versão, e as rotinas de criptografia e descriptografia estão funcionando.

Apagando módulos de uma biblioteca

Parece uma pena depois disso, mas vamos apagar o arquivo cipher_version.o a partir do arquivo da biblioteca.

Para fazer isso, usaremos a opção -d (delete). Também usaremos a opção -v (verbose) para que nos digam o que ela fez. Também incluiremos a opção -s (index) para atualizar o índice no arquivo da biblioteca.

 ar -dsv libcipher.a cipher_version.o 

ar informa que removeu o módulo. O "d" significa "excluído".

Se pedirmos para listar os módulos dentro do arquivo da biblioteca, veremos que estamos de volta a dois módulos.

 ar -t libcipher.a 

IMAGEM_23

Se você for excluir os módulos da sua biblioteca, lembre-se de remover a definição deles do arquivo de cabeçalho da biblioteca. / p>

Compartilhe seu código

As bibliotecas tornam o código compartilhável de maneira prática, mas privada. Qualquer pessoa que você forneça ao arquivo de biblioteca e ao arquivo de cabeçalho pode usar sua biblioteca, mas seu código-fonte real permanece privado.

LER NEXT & rsaquo; O que é um pecado profundo e devo me preocupar? & Rsaquo; Como funcionam os testes de velocidade da Internet? (e quão precisos são eles?) & rsaquo; Como Transmitir o UFC 239 Jon Jones vs Santos Online & rsaquo; Como verificar a força do seu sinal Wi-Fi & rsaquo; O que é “Upscaling” em uma TV e como ela funciona?

Via: How to Geek