trunk/maint-guide/maint-guide.pt-br.sgml

<!DOCTYPE debiandoc PUBLIC "-//DebianDoc//DTD DebianDoc//EN" [

        <!-- textual data entities -->
        <!-- first definition wins in SGML -->
<!ENTITY % default  SYSTEM "default.ent">  %default;

]>
<!-- CVS revision of this document "$Revision: 1.20 $"  -->
<!-- CVS revision of original english document "*.**"  -->


<debiandoc>

 <book>

  <titlepag>

   <title>Guia do Novo Mantenedor Debian</title>

   <author>Josip Rodin <email/joy-mg@debian.org/
   </author>
   <author>Traduzido por: Mahdi <email/mahdi@dcc.ufmg.br/
   </author>
   <author>Revisado por: Priscilla Pimenta <email/priscilla@minaslivre.org/
   </author>

   <version>version 1.2, 6 April 2002.</version>

   <copyright>
   <copyrightsummary>Copyright &copy; 1998-2002 Josip Rodin.</copyrightsummary>

 <p>Este documento pode ser utilizado sob os termos do GNU General Public License versão 2 ou superior.
  <p>Este documento foi criado utilizando os seguintes documentos como exemplos:

   <p>Making a Debian Package (AKA the Debmake Manual), copyright &copy;
   1997 Jaldhar Vyas.

   <p>The New-Maintainer's Debian Packaging Howto, copyright &copy; 1997
   Will Lowe.
   </copyright>

  </titlepag>

  <toc sect>

  <chapt id="start">Começando do jeito certo:

  <p>O intuito deste documento é descrever a construção de um pacote Debian para o usuário comum do Debian,aspirante desenvolvedor. Ele utiliza uma linguagem bastante informal e é bem ilustrado com exemplos funcionais.
  Existe um velho ditado Romano,<em>Longum iter est per preaecepta, breve et efficax per exempla!</em> (É um longo caminho o das regras, mas curto e eficiente se exemplificado!).

  <p>Um dos fatores que fazem do Debian uma distribuição diferenciada é o seu sistema de pacotes. Mesmo já existindo uma vasta quantidade de programas já distribuídos no formato Debian, as vezes é necessário instalar programas que não o são.
  Você deve estar imaginando como criar seus próprios pacotes, e talvez pense que seja uma tarefa um tanto difícil. Bem, se você é realmente um iniciante no Linux, é complicado, mas se você já tivesse alguma experiência você nem estaria lendo esta documentação agora; :-)
  Você precisa saber algo sobre programação em Unix, mas certamente não precisa ser um especialista.

  <p> Uma coisa é certa, entretanto: para criar e manter pacotes Debian você precisa de bastante tempo. Não cometa erros. Para o nosso sistema funcionar corretamente, os mantenedores precisam ser tanto tecnicamente competentes como aplicados.

  <p> Este documento irá explicar passo a passo (mesmo os que a princípio alguns pareçam irrelevantes) e irá ajudá-lo a criar um primeiro pacote e ganhar alguma experiência na criação das próximas distribuições desse mesmo pacote ou até mesmo de outros pacotes.

  <p>Novas versões deste documento deverão estar sempre disponíveis em
  <url name="http://www.debian.org/doc/maint-guide/" id="http://www.debian.org/doc/maint-guide/">
  e no pacote `<package/maint-guide-pt/'.
  <!-- Translation in <this language> is also available in the
       `<package/maint-guide-xy/' package. -->

  <sect id="needprogs">Programas que você precisa para o desenvolvimento:

  <p> Antes de mais nada, você deve estar certo de que tem instalado alguns pacotes adicionais necessários para o desenvolvimento. Note que a lista não contém nenhum pacote marcado 'essential' ou 'required' - supomos que você já tenha tais pacotes instalados.

  <p> Esta revisão deste documento foi atualizada para os pacotes no Debian ('sid')

  <p> Os seguintes pacotes vêm na instalação padrão do Debian, e você provavelmente já os tem. Mesmo assim, é prudente conferir com`dpkg -s &lt;package&gt;`.

  <list>
  <item><package/dpkg-dev/ - este pacote contém ferramentas necessárias para desempacotar, construir e enviar arquivos-fonte do Debian. (veja
  <manref name="dpkg-source" section="1">)

  <item><package/file/ - este prático programa pode determinar o tipo de um arquivo.
  (veja <manref name="file" section="1">)

  <item><package/gcc/ - O Compilador C GNU, necessário se o seu programa, como muitos outros, foi escrito em C.
  (veja <manref name="gcc" section="1">)
  Este pacote irá também instalar vários outros pacotes, como
  <package/binutils/ que contém programas utilizados para compilar e montar
  arquivos-objeto.(veja `info binutils` no pacote <package/binutils-doc/ )
  e <package/cpp/, o preprocessador C. (veja <manref name="cpp" section="1">)

  <item><package/g++/ - O Compilador C++ GNU, necessário se o seu programa foi escrito em C++. (veja <manref name="g++" section="1">)

  <item><package/libc6-dev/ - as bibliotecas para o C e arquivos de header que o gcc precisa criar arquivos-objeto.(veja `info libc` no pacote <package/glibc-doc/ )

  <item><package/make/ - normalmente a criação de um programa é feito em várias etapas, e assim sendo é melhor utilizar este programa para automatizar as etapas criando um Makefile ao invés de executar os comandos sempre. (veja `info make`)

  <item><package/patch/ - esta ferramenta é muito útil para analisar um arquivo contendo uma lista de diferenças (criado pelo programa diff) e aplica-la no arquivo original, produzindo uma versão "patcheada".
  (veja <manref name="patch" section="1">)

  <item><package/perl/ - Perl é uma das linguagens de scripting interpretadas mais utilizadas nos sistemas baseados em Unix atuais. (veja <manref name="perl" section="1">)
  </list>

  <p> Você provavelmente vai querer instalar os seguintes pacotes também:

  <list>
  <item><package/autoconf/ e <package/automake/ - muitos dos programas atuais utilizam scripts de configuração e Makefiles preprocessados com ajuda desses programas. (veja `info autoconf`, `info automake`)

  <item><package/dh-make/ and <package/debhelper/ - dh-make é necessário para criar o esqueleto do nosso pacote-exemplo e vai utilizar algumas ferramentas do debhelper para criação de pacotes. Elas não são essenciais para a criação de pacotes, mas são <strong>fortemente</strong> recomendadas para novos mantenedores. Elas tornam todo o processo muito mais fácil de começar e controlar, no final das contas. (veja <manref name="dh_make" section="1">,
  <manref name="debhelper" section="1">, /usr/share/doc/debhelper/README)

  <item><package/devscripts/ - este pacote contém alguns scripts muito úteis que podem ser de interesse para os mantenedores, mas não são necessários para a criação de pacotes. (veja /usr/share/doc/devscripts/README.gz)

  <item><package/fakeroot/ - este utilitário permite que você emule ser usuário root, o que é necessário em algumas etapas do processo de criação. (veja <manref name="fakeroot" section="1">)

  <item><package/gnupg/ - uma ferramenta que permite que você <em>assine</em> digitalmente seus pacotes.
  Isto é especialmente importante se você quer distribui-los para outras pessoas, e você certamente o fará quando seu trabalho for incluído na distribuição Debian. (veja <manref name="gpg" section="1">)

  <item><package/g77/ - o compilador Fortran 77 GNU, necessário se o seu programa foi escrito em Fortran.
  (see <manref name="g77" section="1">)

  <item><package/gpc/ - o compilador Pascal GNU, necessário se o seu programa foi escrito em Pascal. É bom notar também o pacote <package/fp-compiler/, o compilador Pascal gratuito, que exerce a mesma função igualmente bem. (veja <manref name="gpc" section="1">, <manref name="ppc386" section="1">)

  <item><package/xutils/ - alguns programas, normalmente os criados para o X11, também utilizam esses programas para gerar Makefiles de conjuntos de funções de macro.(see <manref name="imake" section="1">,
  <manref name="xmkmf" section="1">)

  <item><package/lintian/ - este é o testador de pacotes Debian. Ele permite que você saiba se cometeu alguns dos erros mais comuns, depois de criado o pacote, e explica os erros encontrados. (veja <manref name="lintian" section="1">,
  /usr/share/doc/lintian/lintian.html/index.html)
  </list>

  <p>O seguinte pacote é uma documentação <em>muito</em> importante que você deve ler junto com este documento: 
  
  <list>
  <item><package/debian-policy/ - o Policy contém explanações sobre a estrutura e conteúdo do repositório Debian, muitas questões sobre arquitetura de sistemas operacionais, a hierarquia padrão do sistema de arquivos (que diz onde cada arquivo e diretório deve ficar) etc.
  Para você, o importante é que ele descreve os pre-requisitos que cada pacote deve satisfazer para ser incluído na distribuição. (veja /usr/share/doc/debian-policy/policy.html/index.html)

  <item><package/developers-reference/ - para todos os casos não especificamente sobre detalhes técnicos de empacotamento, como a estrutura do repositório, como renomear, tornar órfão adotar pacotes, como fazer NMUs, como tratar de bugs, onde e quando enviar os pacotes, etc.
  (veja /usr/share/doc/developers-reference/developers-reference.html/index.html)
  </list>

  <p>As curtas descrições que são dadas acima servem apenas para apresentar-lhe o que cada pacote faz. Antes de continuar, por favor leia cuidadosamente a documentação de cada programa, pelomenos na parte do uso padrão. Pode parecer muita coisa para estudar, mas isto lhe será de <em>enorme</em> valia no final.

  <p>Nota: <package/debmake/ é um pacote que contém alguns programas similares ao dh-make, mas seu uso específico <strong>não é</strong>
  tratado neste documento, porque ele é <em>obsoleto</em>. Para mais informações, veja
  <url name="the Debmake manual" id="http://www.debian.org/~jaldhar/">
  
  <sect id="otherinfo">Outras informações:

  <p>Existem dois tipos de pacotes que você pode criar: fonte e binários.
  Um pacote fonte contém um código-fonte que você possa compilar.
  Um pacote binário contém somente o programa pronto. Não confunda os termos, como o código-fonte do programa e o pacote-fonte do programa. Por favor leia outros manuais se você precisa de maiores informações sobre essa terminologia.

  <p>No Debian, o termo 'mantenedor' é usado para uma pessoa que cria pacotes, 'autor' para a pessoa que criou o programa e 'mantenedor superior' para a pessoa que atualmente mantém o programa fora do Debian. Normalmente o autor e o mantenedor superior são a mesma pessoa - e as vezes até mesmo o mantenedor é a mesma pessoa. Se você criou um programa, e que colocá-lo no Debian, sinta-se a vontade para enviar-nos sua aplicação para se tornar um mantenedor.

  <p>Depois que você criou o seu pacote (ou enquanto o faz), você terá de se tornar um mantenedor oficial da Debian para que seu programa seja colocado na proxima distribuição do Debian (se o seu programa é realmente útil, por que não?). Esse processo é tratado na Referência do Desenvolvedor (Developer's Reference). Por favor leia-o.

  <chapt id="first">Primeiros passos

  <sect id="choose">Escolha seu programa

  <p>Você provavelmente escolheu o pacote que quer criar. A primeira coisa que você precisa fazer é conferir se o pacote já não está na distribuição. Se você usa a distribuição 'stable', talvez seja melhor vc ir na
  <url name="página de busca de pacotes Debian" id="http://www.debian.org/distrib/packages">.
  Se você usa a distribuição 'unstable' <strong>atual</strong> confira com os seguintes comandos:
  <example>
  dpkg -s program
  dpkg -l '*program*'
  </example>

  <p>Se o pacote já existe, bem, é só instalar! :-) Se ele estiver órfão -- se seu mantenedor estiver marcado no "Grupo QA do Debian", você pode adotá-lo. Consulte a
  <url name="lista de pacotes órfãos" id="http://www.debian.org/devel/wnpp/orphaned">
  e a
  <url name="lista de pacotes para adoção" id="http://www.debian.org/devel/wnpp/rfa_bypackage">
  para verificar se o pacote está realmente disponível.

  <p>Se você pode adotar o pacote, pegue o seu código-fonte (com algo como, 
  <tt/apt-get source packagename/) e analise-o. Este documento infelizmente não inclui informações sobre adoção de pacotes. Felizmente você não deve ter problemas descobrindo como o pacote funciona uma vez que alguém já fez todo o trabalho inicial para você. Mesmo assim continue lendo, muito do que vem a seguir ainda será aplicável para você.

  <p>Se o pacote ainda não existe, e você gostaria de vê-lo no Debian, prossiga como seguinte:

  <list>
  <item>Confira se ninguém mais está trabalhando no pacote na
  <url name="lista de pacotes em desenvolvimento" id="http://www.de.debian.org/devel/wnpp/being_packaged">.
  Se alguém já está criando-o, entre em contato com essa pessoa se você achar desejável. Senão - procure outro programa interessante que ninguém mantém ainda.
  </item>

  <item>Programas <strong>têm</strong> de ter uma licença, se possível gratuita como descrito no
  <url name="Guia Debian de Software Livre" id="http://www.debian.org/social_contract#guidelines">.
  Se o programa não concorda com alguma dessas regras, mas ainda assim pode ser distribuído, ele ainda pode ser incluído nas seções 'contrib' ou 'non-free'. Se você ainda não tem certeza sobre onde ele deve ser incluído, envie o texto da licença para <email/debian-legal@lists.debian.org/ e peça ajuda.
  </item>

  <item>Programas certamente <strong>não</strong> devem ser executados com privilégios de root (setuid root), ou ainda melhor - eles não devem precisar depender de nenhum privilégio específico (nem setuid nem setgid)
  </item>

  <item>Programas não devem ser daemons, nem nada que tenha de ir para diretórios */sbin, nem abrir portas como root.</item>

  <item>Programas devem estar na forma executável, bibliotecas são mais difíceis de lidar.</item>

  <item>Tudo deve ser bem documentado, e/ou o código tem de ser bem legível e inteligível.</item>

  <item>Você deve entrar em contato com o(s) autor(es) do programa para confirmar se eles concordam com o seu empacotamento. É importante ser possível o contato com o(s) autor(es) no caso de quaisquer problemas específicos do programa, então não faça pacotes de software sem suporte. </item>

  <item>E por último, mas não menos importante, você deve ter certeza que o tudo funciona corretamente, utilizando algum tempo.</item>
  </list>

  <p>Obviamente tudo isso são medidas de segurança, e têm como intuito evitar usuários zangados com você, se você fez algo errado em algum daemon setuid root...
  Quando você tiver mais experiência na criação de pacotes, você poderá criar tais pacotes, mas mesmo os desenvolvedores mais experientes consultam a lista debian-mentors quando em dúvida. E as pessoas lá ficarão felizes em poder ajudar.

  <p>Para mais ajuda sobre isso, leia a Referência do Desenvolvedor (Developer's Reference).

  <sect id="getit">Pegue o programa e teste

  <p>A primeira coisa a ser feita é encontrar e baixar o pacote original. Eu presudo que você já tem o código-fonte pego na página do autor. Códigos-fonte para software livre em Unix normalmente vêm no formato tar/gzip, com a extensão .tar.gz, e normalmente contém um subdiretório com o nome nome_do_programa-versão e todos os códigos-fonte dele dentro. Se o código-fonte do seu programa vem em outro tipo de arquivamento (como por exemplo um arquivo de extensão ".Z" ou ".zip"), desempacote-o com as ferramentas adequadas ou peça ajuda na lista debian-mentors se você não tem certeza de como desempacota-lo corretamente (dica: execute 'file arquivo.extensão').

  <p>Como exemplo, eu usarei um programa chamado 'gentoo', um manipulador de arquivos para o X em GTK+. Note que o programa já está empacotado, e mudou bastante desde a última versão em que este texto foi escrito.

  <p>Crie um subdiretório no seu home chamado 'debian' ou 'deb' ou algo que você ache mais apropriado (ex: ~/gentoo/ seria suficiente neste caso). Coloque o arquivo baixado dentro dele, e descompacte-o (com 'tar zxf gentoo-0.9.12.tar.tz'). Certifique-se que não ocorreram erros, mesmo os mais "irrelevantes", pois provavelmente poderão ocorrer erros nos sistemas de outras pessoas, que têm ferramentas de desempacotamento que podem ou não ignorar tais anomalias.

  <p>Agora você tem outro subdiretório, chamado 'gentoo-0.9.12'. Mude para esse diretório e leia <strong>cuidadosamente</strong> a documentação fornecida. Normalmente existem arquivos chamados README*, INSTALL*, *.lsm ou *.html. Você deve encontrar instruções de como compilar e instalar o programa corretamente (provavelmente eles irão assumir que você quer instalar o programa no diretório /usr/local/bin , mas você não fará isso. Mais sobre isso será dito em <ref id="destdir">).

  <p>O processo varia de programa para programa, mas vários programas atuais vem com um script 'configure' que configura o código-fonte de acordo com o seu sistema e garante que seu sistema tem condições de compilar o programa. Após configurar o código-fonte com './configure', os programas são normalmente compilados com 'make'. Alguns deles suportam 'make check', para rodar incluindo auto-testes. A instalação nos devidos diretórios de destino são normalmente feitos com 'make install'.
  
  <p>Agora tente compilar e executar seu programa, para garantir que ele funciona corretamente e não interfere em nada enquanto ele está sendo instalado ou executado.

  <p>Normalmente você também pode executar 'make clean' (ou melhor ainda 'make distclean') para limpar o diretório de compilação. Algumas vezes você pode inclusive executar um 'make uninstall' para remover todos os arquivos instalados.

  <sect id="namever">Nome do pacote e versão

  <p>Você deve começar empacotando com um diretório de código-fonte completamente limpo, ou simplesmente com um código-fonte recém descompactado.
  
  <p>Para que o pacote seja criado corretamente, você deve tornar o nome do programa caixa-baixa (se já não for), e deve mover o diretório fonte para &lt;nome_do_pacote&gt;-&lt;versão&gt;.
  
  <p>Se o nome do programa utiliza mais de uma palavra, reduza-o para uma palavra ou abrevie-o. Por exemplo, o programa "Pequeno Editor do John para X" pode ser nomeado "xpedjohn", ou "xeditorjohn" ou qualquer outra coisa que você decidir, desde que o nome tenha um nome razoável, como 20 caracteres.

  <p>Verifique também a versão exata do programa (para ser incluída na versão do pacote). Se este software não utiliza versões numeradas tipo X.Y.Z, mas algo como uma data, sinta-se a vontade para utilizar essa data como a versão, sufixada com "0.0." (para o caso de alguem superior na manutenção do programa resolver um dia distribuir uma versão tipo 1.0). Dessa forma, se a distribuição ou imagem do programa é do dia 19/12/1998, você pode utilizar a versão como sendo 0.0.19981219.

  <p>Alguns programas nem têm uma versão definida, caso o qual você deve entrar em contado com o mantenedor superior para certificar-se de algum outro eventual sistema de revisão por ele utilizado.

  <sect id="dh_make">"Debianização" inicial

  <p>Certifique-se que você está no diretório do código-fonte do programa e execute:

  <p><example>
  dh_make -e seu.endereço@de.mantenedor -f ../gentoo-0.9.12.tar.gz
  </example>

  <p>Obviamente você deve substituir "seu.endereço@de.mantenedor" com o seu endereço de e-mail a ser incluído no changelog, outros arquivos e no nome do arquivo com o nome do seu código-fonte. Veja <manref name="dh_make" section="1"> para maiores informações.
 
  <p>Algumas informações serão mostradas. Vai ser perguntado que tipo de pacote você quer criar. O gentoo é um pacote de um único binário - ele só cria um arquivo binário, e logo um arquivo .db -, logo, vamos selecionar a primeira opção utilizando a tecla 's'. Confira a informação impressa na tela e confirme pressionando &lt;enter&gt;.

  <p>Novamente, como novo mantenedor, não é recomendável que você crie pacotes de múltiplos binários ou bibliotecas. Não é muito complicado, mas exige um pouco mais de conhecimento, e assim sendo não será descrito aqui.

  <p>Note que você deve executar o dh_make <strong>somente uma vez</strong>, e que ele não se comportará corretamente se você executá-lo novamente num diretório já "debianizado". Isso também significa que você irá utilizar um método diferente para criar uma nova revisão ou versão do seu pacote no futuro. Leia mais sobre isso em <ref id="update">

  <chapt id="modify">Modificando o código-fonte

  <p>Normalmente, os programa são instalados em subdiretórios em /usr/local , mas os pacotes do Debian não devem utilizar esse diretório, uma vez que ele é reservado ao uso privado dos administradores do sistema. Isto significa que você terá de dar uma lhada no sistema de construção do seu programa, normalmente começando com o Makefile. Este é o script <manref name="make" section="1"> que você irá utilizar para automatizar a compilação do seu programa. Para maiores informações sobre Makefiles, leia <ref id="rules">.

  <p>Note que se o seu programa utiliza o GNU <manref name="automake" section="1"> e/ou <manref name="autoconf" section="1">, o código-fonte incluirá os arquivos Makefile.am e/ou Makefile.in, respectivamente, e você terá de modificar esses arquivos também. Isto acontece pois cada execução do automake irá reescrever o makefile.in com alguma informação gerada a partir do Makefile.am, e cada execução do ./configure irá fazer o mesmo com os Makefiles, com informações do Makefile.in. Editando arquivos Makefile.am exigem algum conhecimento sobre o automake, que você pode adquirir no info do automake; ao passo que editar arquivos Makefile.in são mais ou menos a mesma coisa que editar Makefiles, tomando cuidado com as variáveis (ex: qualquer string entre '@'s, como @CFLAGS@ ou @LN_S@, que são substituídos com a informação propriamente dita de cada execução do ./configure).

  <p>Note também que foge ao nosso escopo aqui descrever <em>todos</em> os detalhes sobre correção de códigos, mas existem alguns problemas que normalmente são encontrados.

  <sect id="destdir">Instalação em um subdiretório

  <p>A maioria dos programas tem algum modo de ser instalados na estrutura de diretório existente do seu sistema, de modo que seus binários são incluídos no seu $PATH e sua documentação se encontre em lugares comuns. Se você fizer isso, entretanto, seu programa será instalado junto com tudo o mais que já esteja no seu sistema. Isso tornaria difícil para que as ferramentas de empacotamento descobrissem quais arquivos pertencem ou não ao seu pacote.

  <p>Portanto você precisa fazer algo mais: instalar o programa dentro num subdiretório temporário de onde as ferramentas de mantenedor irão trabalhar no pacote .deb. Tudo que estiver nesse diretório irá ser instalado no sistema do usuário quando eles instalarem o pacote. A única diferença é que o dpkg vai estar instalando os arquivos no diretório raiz.

  <p>Este diretório temporário é normalmente criado dentro do seu diretório debian/, na árvore de diretórios e código-fonte descompactada. Ele é normalmente chamado <file>debian/nome_do_pacote</file>.

  <p>Tenha em mente que mesmo que você tenha que fazer o programa ser instalado em debian/nome_do_pacote, ele ainda precisa se comportar corretamente quando colocado no diretório raiz (ex: quando instalado do pacote .deb. Logo, você não deve deixar que o sistema de construção utilize strings como <tt>/home/me/gentoo-0.9.12/usr/share/gentoo</tt> nos arquivos do pacote.

  <p>Com programas que utilizam o GNU autoconf, isto será bastante fácil. A maioria destes programas tem Makefiles que são como padrão definidos para permitir que a instalação seja feita num diretório aleatório, tendo em mente que /usr (por exemplo) é o prefixo canônico. O dh_make, quando detectar que seu programa utiliza o autoconf, irá definir os comandos para fazer tudo isso automaticamente, de forma que você pode inclusive saltar a leitura desta seção, mas com outros programas, você provavelmente terá de analisar e editar os Makefiles.

  <p>Eis a parte relevante do Makefile do gentoo:

  <p><example>
  # Onde colocar o binário durante o 'make install'?
  BIN     = /usr/local/bin

  # Onde colocar os ícones durante o 'make install'?
  ICONS   = /usr/local/share/gentoo
  </example>

  <p>Nota-se que os arquivos estão definidos para serem instalados em <file>/usr/local</file>. Mude tais caminhos para:
  <p><example>
  # Onde colocar o binário durante o 'make install'?
  BIN     = $(DESTDIR)/usr/bin
 
  # Onde colocar os ícones durante o 'make install'?
  ICONS   = $(DESTDIR)/usr/share/gentoo
  </example>

  <p>Mas porque em tal diretório, e não algum outro? Porque os pacotes debian nunca instalam pacotes em <file>/usr/local</file> -- essa árvore de diretórios é reservada ao uso do administrados do sistema. Tais arquivos, no Debian, devem ser colocados em <file>/usr</file>.

  <p>A localização mais exata para binários, ícones, documentação, etc, é especificada na Hierarquia Padrão de Sistemas de Arquivos (Filesystem Hierarchy Stanrdart - FHS - veja /usr/share/doc/debian-policy/fhs). Eu recomendo que você procure e leia as seções que podem insteressar ao seu pacote.

  <p>Então nós devemos instalar o binário em /usr/bin no lugar de /usr/local/bin, os manuais em /usr/share/man/man1 ao invés de /usr/local/man/man1, etc. Note que, como o gentoo não fornece um manual em seu Makefile, e o Debian-Policy exige que todo programa tenha um, nós faremos um, mais tarde, e o instalaremos em/usr/share/man/man1.

  <p>Alguns programas não usam variáveis no Makefile para definir caminhos como estes. Isto significa que você talvez tenha de editar alguns arquivos-fonte em C para que eles utilizem os caminhos adequados. Mas onde procurar, e exatamente o que procurar? Você pode resolver isso executando:

  <p><example>
  grep -nr -e 'usr/local/lib' --include='*.[c|h]' .
  </example>

  <p>O Grep irá executar recursivamente por toda a árvore do código e dizer-lhe o nome e a linha do arquivo quando encontrar uma ocorrência.

  <p>Edite esses arquivos e substitua /usr/local/* com usr/* e pronto. Tome cuidado para não mexer no resto do código! :-)

  <p>Depois disso você deve encontrar o alvo de instalação (procure pela linha começa com 'install:', o que normalmente funciona) e renomeie todas as referências a diretórios que não aqueles definidos no topo do Makefile. Antes, o alvo de instalação do gentoo continha:

  <p><example>
  install:        gentoo
                  install ./gentoo $(BIN)
                  install icons/* $(ICONS)
                  install gentoorc-example $(HOME)/.gentoorc
  </example>

  <p>Depois da mudança, passou a conter:
  <example>
  install:        gentoo-target
                  install -d $(BIN) $(ICONS) $(DESTDIR)/etc
                  install ./gentoo $(BIN)
                  install -m644 icons/* $(ICONS)
                  install -m644 gentoorc-example $(DESTDIR)/etc/gentoorc
  </example>

  <p>Você certamente notou que agora tem um comando <tt>install -d</tt> antes dos outros comandos semelhantes. O Makefile original não tinha isso porque normalmente o diretório /usr/local/bin e outros diretórios já existiam no sistema onde alguém executasse o 'make install'. Entretante, como nós vamos instalar o programa em nosso próprio diretório vazio (ou não existente), nós teremos de criar cada um desses diretórios.

  <p>Nós podemos inclusive adicionar outras coisas no final da regra, como a instalação de documentação adicional, que os autores algumas vezes omitem:

  <p><example>
                  install -d $(DESTDIR)/usr/share/doc/gentoo/html
                  cp -a docs/* $(DESTDIR)/usr/share/doc/gentoo/html
  </example>

  <p>Um leitor atento notará que eu troquei 'gentoo' para 'gentoo-target' na linha de 'install:'. Isto é chamado de correção de bug não-relacionado. :-)

  <p>Sempre que você fizer mudanças que não são especificamente relacionado ao pacote Debian, certifique-se de manda-las para o mantenedor superior para que elas possam ser incluídas na próxima revisão do programa e serem úteis para todo mundo. Lembre-se também de fazer suas mudanças de modo não específico ao Debian ou Linux (ou até mesmo Unix!) antes de enviá-las -- faça-as portáveis. Isto tornará suas correções mais fáceis de serem aplicadas.

  <p>Note que você não tem de enviar os arquivos de debian/* ao mantenedor superior.

  <sect id="difflibs">Mudando bibliotecas

  <p>Existe um outro problema comum: bibliotecas muitas vezes variam de plataforma para plataforma. Por exemplo, um Makefile faz referência a uma biblioteca que não existe em sistemas Debian. Neste caso, nós precisamos muda-la para uma biblioteca que existe no Debian, e serve pra mesma coisa.

  <p>Assim sendo, se existe alguma linha no Makefile do seu programa (ou Makefile.in) que tenha algo como isto (e o seu programa não compile):

  <p><example>
  LIBS = -lcurses -lalgumacoisa -lalgumaoutracoisa
  </example>

  <p>Mude-a para isso, e provavelmente funcionará:
  <p><example>
  LIBS = -lncurses -lalgumacoisa -lalgumaoutracoisa
  </example>

  <p>(o autor percebe que este não é um bom exemplo, considerando que nosso pacote libncurses agora cria um symlink para libcurses.so, mas ele não pode encontrar nada melhor. Sugestões são muito bem vindas :-)

  <chapt id="dreq">Coisas necessárias no debian/

  <p>Agora existe um novo subdiretório no diretório-fonte do programa chamado 'debian'. Existem alguns arquivos nesse diretório que nós devemos editar para personalizar o comportamento do nosso pacote. Os mais importantes deles são 'control', 'changelog', 'copyright' e 'rules', que são necessários para todos os pacotes.

  <sect id="control">arquivo 'control'

  <p>Este arquivo contém vários valores que o <prgn/dpkg/, <prgn/dselect/ e outras ferramentas de controle de pacotes irão utilizar para administrar o pacote.

  <p>Eis o arquivo de controle que o dh_make criou para nós:

  <p><example>
  1  Source: gentoo
  2  Section: unknown
  3  Priority: optional
  4  Maintainer: Josip Rodin &lt;joy-mg@debian.org&gt;
  5  Build-Depends: debhelper (>> 3.0.0)
  6  Standards-Version: 3.5.2
  7
  8  Package: gentoo
  9  Architecture: any
  10 Depends: ${shlibs:Depends}
  11 Description: &lt;insert up to 60 chars description&gt;
  12  &lt;insert long description, indented with spaces&gt;
  </example>
(eu adicionei os números das linhas)

  <p>As linhas 1-6 são as informações de controle para o pacote.

  <p>A linha 1 é o nome do pacote.

  <p>A linha 2 é a seção da distribuição em que o pacote será incluído.

  <p>Como você deve ter notado, o Debian é dividido em seções: main (a seção de software livre), non-free (os softwares gratuitos, mas não-livres) e contrib (software livre que depende de software não-livre). Dentro dessas, existem subseções lógicas que descrevem brevemente o tipo de pacote guardam. Então temos 'admin' para ferramentas de administradores, 'base' para ferramentas básicas, 'devel' para ferramentas de programação, 'doc' para documentação, 'libs' para bibliotecas, 'mail' para clientes e daemons de email, 'net' para aplicativos e daemons de rede, 'x11' para programas gráficos que não se enquadram em outras categorias, e muitas outras.

  <p>Então vamos alterá-lo para x11. (um prefixo 'main/' é implícito, e logo podemos omiti-lo.)

  <p>A linha 3 descreve o quão importante que o usuário instale este pacote. Leia o Debian-Policy para orientação no preenchimento desta lacuna. A prioridade 'optional' normalmente caberá para novos pacotes.

  <p>Seção e prioridade são utilizados por frontends como o <prgn/dselect/ quando eles ordenam e selecionam os pacotes padrão. Assim que você enviar o pacote para o Debian, o valor dessas duas lacunas poderá ser alterada pelos mantenedores do repositório, caso o qual você será notificado por email.
  
  <p>Como este pacote é de prioridade normal e não entra em conflito com nada, nós deixaremos a lacuna preenchida como 'optional'.

  <p>A linha 4 é o nome e endereço de email do mantenedor. Certifique-se que este campo contenha um cabeçalho 'To:' válido para um email, porque depois que você enviar o pacote, o sistema de procura de bugs utilizará ele para enviar emails de bugs para você. evite utilizar vírgulas, '&'s e parênteses.

  <p>A 5ª linha contém a lista dos pacotes necessários para construir o seu pacote. Alguns pacotes, como o gcc e o make são implícitos, veja o pacote <package/build-essential/ para detalhes. Se algum compilador ou ferramenta não-padrão for necessária para construir o seu pacote, você deve adicioná-lo à linha 'Build-Depends'. Múltiplas entradas são separadas por vírgulas; leia a seguir para uma explicação das dependências binárias para saber mais sobre a sintaxe deste campo.

  <p>Você também pode ter Build-depends-Indep, Build-Conflicts e outros campos aqui. Estas informações serão utilizadas pelo software de criação automática de pacotes do Debian para criar os pacotes binários para outras plataformas de computadores. Veja o Debian-Policy para mais informações sobre as dependências de compilação e a Referência do Desenvolvedor para mais informações sobre outras plataformas (arquiteturas) e como portar software para elas.

  <p>Eis um hack que você pode utilizar para descobrir quais pacotes o seu pacotes precisa para ser compilado:
  <example>
  strace -f -o /tmp/log ./configure
  # or make instead of ./configure, if the package doesn't use autoconf
  for x in `dpkg -S $(grep open /tmp/log|\
                      perl -pe 's!.* open\(\"([^\"]*).*!$1!' |\
                      grep "^/"| sort | uniq|\
                      grep -v "^\(/tmp\|/dev\|/proc\)" ) 2>/dev/null|\
                      cut -f1 -d":"| sort | uniq`; \
        do \
          echo -n "$x (>=" `dpkg -s $x|grep ^Version|cut -f2 -d":"` "), "; \
        done
  </example>

  <p>O gentoo precisa dos pacotes <package/xlibs-dev/,<package/libgtk1.2-dev/ e <package/libglib1.2-dev/ para ser compilado, portanto vamos adiciona-los após o pacote <package/debhelper/.

  <p>A linha 6 é a versão do padrão do Debian-Policy que este pacote segue. As verões do Debian-Policy que você lê enquanto cria seu pacote.

  <p>A linha 8 é o nome do seu pacote binário. Isto normalmente é a mesma coisa que o nome do pacote-fonte, mas não precisa ser necessariamente desta forma.

  <p>A linha 9 descreve as arquiteturas de CPU para que o pacote binário pode ser compilado. Nós deixaremos este como 'any' pois <manref name="dpkg-gencontrol" section="1"> preencherá este campo com o valor adequado para qualquer máquina em que este pacote seja compilado.

  <p>Se o seu pacote é independente de arquitetura (por exemplo, um script shell ou Perl, ou um documento), mude este para 'all', e leia mais tarde em <ref id="rules"> sobre a utilização da regra 'binary-indep' ao invés da 'binary-arch' para construir o pacote.

  <p>A linha 10 mostra uma das funcionalidades mais poderosas do sistema de empacotamento do Debian. Os pacotes podem relacionar-se uns com os outros de várias formas. Além da 'Depends:', outros campos relacionais são 'Recommends:', 'Suggests:', 'Pre-Depends:', 'Conflicts:', 'Provides:', e 'Replaces:'.

  <p>As ferramentas de manutenção de pacotes normalmente se comportam da mesma maneira quando lidando com essas relações; se não, será explicado.
  (veja <manref name="dpkg" section="8">, <manref name="dselect" section="8">,
  <manref name="apt" section="8">, <manref name="aptitude" section="1"> etc.)

  <p>Eis o que as dependencias significam:

  <p><list>
  <item>Depends:
  <p>O pacote não será instalado a menos que os pacotes de que ele depende estejam instalados. Use isso se o seu programa não rodará de forma alguma (ou terá sérias implicações) a menos que um pacote em particular esteja presente.</item>

  <item>Recommends:
  <p>Os Frontends como o dselect ou o aptitude irão perguntar-lhe se você deseja instalar os pacotes recomendados junto com o seu pacote; o dselect vai inclusive insistir. O dpkg e o apt-get vão ignorar este campo. Use isso para pacotes que não são estritamente necessários, mas são tipicamente utilizados com o seu programa.</item>

  <item>Suggests:
  <p>Quando um usuário instala o seu programa, todos os frontends vão pergutar-lhe se ele deseja instalar os pacotes sugeridos. O dpkg e o apt-get não vão. use isso para pacotes que vão funcionar bem com o seu programa, mas não são de forma alguma necessários.</item>

  <item>Pre-Depends:
  <p>Este é mais forte que o 'Depends:'. O pacote não será instalado a menos que os pacotes de que ele "pre-depende" estejam instalados <em>e corretamente configurados</em> use isso <strong>muito</strong> pouco e somente após discutir isso na lista do debian-devel. Leia-se: não use isso. :-)</item>

  <item>Conflicts:
  <p>O pacote não será instalado até que todos os pacotes com que ele conflite sejam removidos. Use isso se o seu programa absolutamente não rodará ou causará sérios problemas se um pacote em particular esteja presente.</item>

  <item>Provides:
  <p>para alguns tipos de pacotes existem muitos nomes virtuais que podem ser definidos. Você pode obter a lista completa no arquivo /usr/share/doc/debian-policy/virtual-package-name-list.txt.gz . Use isso se o seu programa fornece uma função existente em um pacote virtual. </item>

  <item>Replaces:
  <p>Use isso quando o seu programa substitui arquivos de outro pacote, ou substitui competamente outro pacote (utilizado juntamente com 'Conflicts'). Arquivos de outros pacotes listados serão sobreescritos com os arquivos do seu pacote.
  </item>
  </list>

  <p>Todos estes campos tem uma sintaxe uniforme. Eles são uma lista de nomes de pacotes separados por vírgulas. Estes nomes de pacotes podem inclusive ser listas de nomes de pacotes alternativos, serados por simbolos de pipe (barras verticais '<tt>|</tt>).

  <p>Os campos podem restringir sua aplicabilidade a versões particulares de cada pacote listado. Essas versões são listadas entre parênteses após cada nome de pacote individualmente, e devem conter uma relação da seguinte lista seguida pelo número da versão. As relações permitidas são:
  <tt>&lt;&lt;</tt>, <tt>&lt;=</tt>, <tt>=</tt>, <tt>&gt;=</tt> e
  <tt>&gt;&gt;</tt> para anterior, anterior ou igual, exatamente igual, mais nova ou igual e igual, respectivamente. Por exemplo,

  <p><example>
  Depends: foo (>= 1.2), libbar1 (= 1.3.4)
  Conflicts: baz
  Recommends: libbaz4 (>> 4.0.7)
  Suggests: quux
  Replaces: quux (<< 5), quux-foo (<= 7.6)
  </example>
  
  <p>Finalmente, a última funcionalidade que você precisa saber é ${shlibs:Depends}. Depois que seu pacote for compilado e instalado no diretório temporário, <manref name="dh_shlibdeps" section="1"> irá procurar por binários e bibliotecas nesse diretório, determinar as dependências de bibliotecas compartilhadas e detectar em quais pacotes elas estão, como libc6 ou xlib6g. Ele irá passar a lista para o <manref name="dh_gencontrol" section="1"> que irá preencher o campo adequadamente, e você não terá de se precupar mais com isso.

  <p>Dito tudo isto, podemos deixar a linha 'Depends:' exatamente como ela está agora, e inserir outra linha após ela com <tt>Suggests: file</tt>, pois o gentoo pode utilizar algumas funcionalidade fornecidas por este programa/pacote.

  <p>A linha 11 é uma breve descrição. A maioria das telas das pessoas são de 80 colunas de largura, então esta descrição não deve ser maior que 60 caracteres. Eu mudarei este campo para "mantenedor de arquivos com interface completamente configurável para X utilizando GTK+".
  <!-- quoted should not have been translated. osamu -->

  <p>A linha 12 é onde a descrição detalhada entra. Este deve ser um parágrafo que fornece maiores informações sobre o pacote. A coluna 1 de cada linha deve estar vazia. Não podem haver linhas em branco, mas você pode colocar um único '.' (ponto) numa coluna para simular isto. Além disso, não pode haver mais de uma linha em branco após a descrição detalhada.

  <p>Finalmente, eis o arquivo de controle atualizado:

  <p><example>
  1  Source: gentoo
  2  Section: x11
  3  Priority: optional
  4  Maintainer: Josip Rodin &lt;joy-mg@debian.org&gt;
  5  Build-Depends: debhelper (>> 3.0.0), xlibs-dev, libgtk1.2-dev, libglib1.2-dev
  6  Standards-Version: 3.5.2
  7
  8  Package: gentoo
  9  Architecture: any
  10 Depends: ${shlibs:Depends}
  11 Suggests: file
  12 Description: mantenedor de arquivos com interface completamente configurável para X utilizando GTK+
  13  o gentoo é um mantenedor de arquivos para Linux escrito totalmente em C puro. Ele
  14  utiliza o toolkit GTK+ para todas as suas necessidades de interface. O gentoo fornece
  15  uma interface 100% configurável; sem necessidade de editar arquivos de configuração manualmente ou
  16  reiniciar o programa. O gentoo suporta a identificação do tipo de vários
  17  arquivos (utilizando extensão, expressões regulares, ou o comando 'file'),
  18  e pode exibir arquivos de diferentes tipos com diferentes cores e ícones.
  19  .
  20  O gentoo adota alguns temas do clássico mantenedor de arquivos do Amiga
  21  "Directory OPUS" (escrito por Jonathan Potter).
  </example>
  (Eu adicionei os números das linhas.)
  <!-- Description: should not have been translated. osamu -->

  <sect id="copyright">O arquivo `copyright'

  <p>Este arquivo contém informação sobre os recursos superiores do pacote, informações de copyright e licença. Seu formato não é tratado no Debian-Policy, mas seu conteúdo é (seção 12.5 "Informações de Copyright").

  <p>O dh_make criou o seguinte arquivo padrão:

  <p><example>
  1  This package was debianized by Josip Rodin &lt;joy-mg@debian.org&gt; on
  2  Wed, 11 Nov 1998 21:02:14 +0100.
  3
  4  It was downloaded from &lt;fill in ftp site&gt;
  5
  6  Upstream Author(s): &lt;put author(s) name and email here&gt;
  7
  8  Copyright:
  9
  10 &lt;Must follow here&gt;
  </example>
  (Eu coloquei os números das linhas)

  <p>As coisas importantes a serem adicionadas a este arquivo são o lugar de onde você pegou o pacote, as informações de copyright e a licença do pacote. Você deve incluir a licença completa, a menos que seja um software livre de licença comum, como GNU GPL ou LPL, ou a licença artística do BSD, onde você pode simplesmente fazer referência à licença adequada ao diretório /usr/share/common-licenses/ que existe em todo sistema Debian.

  <p>Eis como o arquivo de copyright do gentoo ficaria:

  <p><example>
  1  This package was debianized by Josip Rodin &lt;joy-mg@debian.org&gt; on
  2  Wed, 11 Nov 1998 21:02:14 +0100.
  3
  4  It was downloaded from: ftp://ftp.obsession.se/gentoo/
  5
  6  Upstream author: Emil Brink &lt;emil@obsession.se&gt;
  7
  8  Este software é copyright (c) 1998-99 por Emil Brink, Obsession
  9  Development.
  10
  11 Você é livre para distribuir este software sob os termos da
  12 GNU General Public License.
  13 Em sistemas Debian, o texto completo da GNU General Public
  14 License pode ser encontrado em '/usr/share/common-licenses/GPL'
  </example>
  (Eu adicionei os números das linhas.)

  <sect id="changelog">O arquivo `changelog'

  <p>Este arquivo é necessário, e tem um formato especial descrito no Debian-Policy seção 4.4 'debian/changelog'. Este formato é utilizado pelo dpkg e outros programas para obter o número da versão, revisão, distribuição e urgência do seu pacote.

  <p>Para você, também é importante, desde que é bom ter documentadas todas as mudanças que você fez. Este arquivo ajudará as pessoas que baixam o seu pacote a ver se existem questões sobre o pacote que eles devam saber. Ele será salvo como `/usr/share/doc/gentoo/changelog.Debian.gz' no pacote binário.

  <p>O dh_make criou o seguinte arquivo padrão:

  <p><example>
  1  gentoo (0.9.12-1) unstable; urgency=low
  2
  3   * Initial Release.
  4
  5  -- Josip Rodin &lt;joy-mg@debian.org&gt;  Wed, 11 Nov 1998 21:02:14 +0100
  6
  </example>
  (Eu adicionei os números das linhas.)

  <p>A linha 1 é o nome do pacote, versão, distribuição e urgência. O nome deve ser o mesmo nome do pacote-fonte, a distribuição pode ser ou 'unstable' (ou até mesmo 'experimental'), e a urgência não deve ser mudada para nada acima de 'low'. :-)
  
  <p>As linhas 3-5 são a entrada de log, onde você deve documentar as mudanças feitas nessa revisão do pacote (não as mudanças superiores - existe um arquivo especial para este propósito, criado pelos autores, que você instalará depois em /usr/share/doc/gentoo/changelog.gz). Novas linhas devem ser inseridas logo antes da linha mais alta que começa com um asterisco ('*'). Você pode faze-lo com o <manref name="dch" section="1">, ou manualmente com um editor de texto.

  <p>Você terá algo como isso, no final das contas:
  You will end up with something like this:

  <p><example>
  1  gentoo (0.9.12-1) unstable; urgency=low
  2
  3   * Initial Release.
  4   * Este é o meu primeiro pacote Debian.
  5   * Ajustado o Makefile para corrigir problemas de $DESTDIR.
  6
  7  -- Josip Rodin &lt;joy-mg@debian.org&gt; Wed, 11 Nov 1998 21:02:14 +0100
  8
  </example>
  (Eu inseri os números das linhas.)

  <p>Você pode ler mais sobre a atualização do arquivo de changelog mais tard em 
  <ref id="update">.

  <sect id="rules">O arquivo `rules'

  <p>Nós precisamos dar uma olhada nas regras exatas que o <manref name="dpkg-buildpackage" section="1"> irá seguir para criar efetivamente o pacote. Este arquivo é, na verdade, outro Makefile, mas diferente do fornecido pelo autor do código-fonte. Diferentemente dos outros arquivos no debian, este arquivo tem de ser executável.

  <p>Todo arquivo 'rules', como qualquer outro Makefile, consiste em várias regras que especificam como tratar do código-fonte. Cada regra consistem em alvos, nomes de arquivos ou nomes de ações que devem ser seguidas (ex: 'build:' ou 'install:'). Regras que você quer que sejam invocadas como argumentos de linhas de comando (por exemplo, './debian/rules build' ou 'make -f rules install'). Depois do nome do alvo, você pode listar as dependências, programas ou arquivos de que a regra depende. Depois disso, podem haver quantos comandos forem necessários, indentados com &lt;tab&gt;. Uma nova regra começa com a declaração do alvo na primeira coluna. Linhas vazias e começadas com '#'s (hashs) são tratadas como comentários e são ignoradas.

  <p>Você provavelment está confuso agora, mas isso tudo ficará mais claro com a análiso do arquivo 'rules' que o dh_make nos dá como padrão. Você deve também ler a info do 'make' para maiores informações.

  <p>A parte importante de saber sobre o arquivo 'rules' criado pelo dh_make, é que ele é somente uma sugestão. Ele funcionará para pacotes simples, mas para os mais complicados, não tenha medo de adicionar ou retirar coisas para satisfazer às suas necessidades. A única coisa que não deve mudar são os nomes das regras, pois todas as ferramentas usam estes nomes, que são exigidos no Debian-Policy.

  <p> Eis (aproximadamente) como o debian/rules padrão que o dh_make gerou para nós é:

  <p><example>
&makefile;
  </example>
  (Eu adicionei os números das linhas.)

  <p>Você provavelmente já tem intimidade com linhas como a linha 1 de scripts shell e Perl. Ela diz ao sistema operacional que esse arquivo é para ser processado com o /usr/bin/make.

  <p>O significado das variáveis DH_* mencionadas nas linhas 8 e 9 deve ser evidente para a breve descrição. Para maiores informações sobre o DH_COMPAT leia a seção 'Níveis de compatibilidade do Debhelper' no manual <manref name="debhelper" section="1">.

  <p>As linhas 11-16 são o esqueleto do suporte para parâmetros do DEB_BUILD_OPTIONS, descritos no Debian-Policy seção 10.1 'Binários'. Basicamente, essas coisas controlam se os binários devem ser construídos com a tabela de símbolos, ou se eles devem ser retirados na instalação. Novamente, este é somente um esqueleto, uma dica de que você deve faze-lo. Você deve conferir como os sistemas de construçao superiores tratam da inclusão da tabela de símbolos e da sua retirada na instalação, ou implementar isso você mesmo.

  <p>Normalmente, você podedizer ao gcc para compilar com '-g' usando a variável CFLAGS -- se este é o caso do seu pacote, extenda a variável <em>concatenando</em> <tt>CFLAGS="$(CFLAGS)"</tt> à invocação do $(MAKE) na regra de construção (veja abaixo). Alternativamente, se o seu pacote usa um script de configuração do autoconf, você pode passá-lo <em>concatenando antes</em> do string acima na invocação do './configure' na regra de construção.

  <p>Para a remoção, os programas são normalmente configurados para se instalarem sem a remoção da tabela de símbolos, e normalmente sem uma opção para mudar isso. Felizmente, você ainda tem o <manref name="dh_strip" section="1"> que irá detectar quando o flag DEB_BUILD_OPTIONS=nostrip está definido e sair silenciosamente.

  <p>As linhas 18-26 descrevem a regra 'build' (e sua regra-filho 'build-stamp'), que executa o make com a o Makefile próprio do programa para compila-lo. Vamos falar sobre o comentado exemplo docbook-to-man mais tardem em <ref id="manpage">.

  <p>A regra 'clean', como especificado nas linhas 28-36, limpa qualquer binário não mais necessário ou coisas geradas automaticamente, deixadas após a construção do pacote. Esta regra deve funcionar todas as vezes (mesmo quando a árvore do código-fonte <em/is/ cleaned up!), portanto use as opções para forçar (ex: para o rm, é '-f'), ou faça o make ignorar valores de retorno (falhas) utilizando um '-' na frente do nome do comando.

  <p>O processo de instalação , a regra 'install', começa na linha 38. Basicamente, ela executa a regra 'install' do Makefile do programa, mas instala ele no diretório <tt>$(CURDIR)/debian/gentoo</tt> - por isso especificamos $(DESTDIR) como a a raiz do diretório de instalação no Makefile do gentoo.

  <p>Como os comentários sugerem, a regra 'binary-indep', na linha 48, é usada para construir pacotes independentes de arquitetura. Como nós não temos nenhum, nada será feito aqui.

  <p>Na próxima regra - 'binary-arch', nas linhas 52-79, nas quais nós executamos muitos utilitários pequenos do pacote debhelper para executar várias operações nos arquivos do seu pacote para fazer o pacote concordante com o Debian-Policy.

  <p>Se o seu pacote é um 'Architecture: all', você precisa incluir todos os comandos para construir o pacote na regra 'binary-indep', e deixar a regra 'binary-arch' vazia.
  
  <p>Os nomes dos programas do debhelper começam com 'dh_', e o resto é a descrição do que o utilitário faz em particular. E bastante auto-explicativo, mas eis algumas explicações adicionais:

  <list>
  <item><manref name="dh_testdir" section="1"> confere se você está no diretório correto (ex: o diretório superior do código-fonte),
  <item><manref name="dh_testroot" section="1"> confere se você tem permissões de root necessárias para os alvos 'binary-arch', 'binary-indep' e 'clean',
  <item><manref name="dh_installman" section="1"> copiará os manuais para os devidos lugares no diretório de destino. Você só precisa dizer onde eles estão, relativamente ao diretório superior do código-fonte,
  <item><manref name="dh_strip" section="1"> retira as tabelas de símbolos dos arquivos executáveis e bibliotecas, para torná-los menores.
  <item><manref name="dh_compress" section="1"> compacta os manuais e documentações maiores que 4kb com o <manref name="gzip" section="1">,
  <item><manref name="dh_installdeb" section="1"> copia os arquivos relacionados com o pacote (ex: os scripts de mantenedor) para o diretório <file>debian/gentoo/DEBIAN</file>,
  <item><manref name="dh_shlibdeps" section="1"> calcula as dependências de bibliotecas compartilhadas das bibliotecas e arquivos executáveis.
  <item><manref name="dh_gencontrol" section="1"> instala uma versão com ajuste-fino do arquivo de controle em <file>debian/gentoo/DEBIAN</file>,
  <item><manref name="dh_md5sums" section="1"> gera um MD5 checksum para todos os arquivos do pacote.
  </list>

  <p>Para informações mais completas sobre o que todos esses scripts dh_* fazem, e quais são suas opções, por favor leia seus respectivos manuais. Existem alguns outros (possivelmente muito úteis) scripts dh_* que não são mencionados aqui. Se você precisar deles, leia a documentação do debhelper.

  <p>A seção binary-arch é onde você realmente deve comentar ou remover quaisquer linhas que chamem funcionalidades que você não precisa. Para o gentoo, eu comentarei as linhas sobre exemplos, cron, init, man e info, simplesmente porque o gentoo não precisa delas. Além disso, na linha 68, eu irei substituir 'Changelog' com 'FIXES', porque esse é o nome real do arquivo de changelog superior.

  <p>As últimas duas linhas (junto com quaisquer outras não explicadas) são somente algumas coisas mais ou menos necessárias, considerando que você pode ler o manual do make, e o Debian-Policy. Por enquanto, elas não são importantes de se conhecer.

  <chapt id="dother">Outros arquivo no debian/

  <p>Você pode notar que existem vários outros arquivos no subdiretório debian/, a maioria deles com o sufixo '.ex', o que significa que eles são exemplos. Dê uma olhada em todos eles. Se você deseja, ou precisa, utilizar alguma de suas funcionalidades,

  <list>
    <item>olhe também sua documentação (dica: leia o Debian-Policy),
    <item>se necessário, modifique os arquivos para satisfazer suas necessidades,
    <item>renomeie-os para remover o sufixo '.ex', se eles o tiverem,
    <item>modifique o arquivo 'rules', se necessário.
  </list>

  <p>Alguns desses arquivos, os mais utilizados, são explicados nas seções seguintes:

  <sect id="readme">README.Debian

  <p>Quaiquer outros detalhes ou discrepâncias entre o pacote original e a sua versão debianizada deve ser documentada aqui.

  <p>O dh_make criou um arquivo padrão, como seguinte:

  <p><example>
  gentoo for Debian
  -----------------

  &lt;notas possíveis acerca deste pacote - se nenhuma, apague este arquivo.&gt;

   -- Josip Rodin &lt;joy-mg@debian.org&gt;, Wed, 11 Nov 1998 21:02:14 +0100
  </example>

  <p>Como não temos nada para colocar aqui, apagaremos o arquivo.

  <sect id="conffiles">conffiles.ex

  <p>Uma das coisas mais irritantes em software é quando você gasta muito tempo e esforço personalizando o seu programa, e uma nova versão dele desfaz todas as suas mudanças. O Debian resolve esse problema marcando os arquivos de configurações de forma que, quando você atualiza um pacote, você será perguntado se quer manter sua configuração antiga ou não.

  <p>O modo se fazer isso num pacote é colocando o caminho completo de cada arquivo de configuração (normalmente em /etc), um por linha, num arquivo chamado <tt/conffiles/. O gentoo tem um arquivo de configuração, /etc/gentoorc, enós vaos adicioná-lo no arquivo <tt/conffiles/.

  <p>Se o seu programa utiliza arquivos de configuração mas também os sobrescreve por conta própria, é melhor não marcá-los nos 'conffiles' pois senão o dpkg irá perguntar aos usuários se eles querem verificar as mudanças o tempo todo.

  <p>Se o programa que você está empacotando precisa que todo usuário modifique o arquivo para funcionar, considere também não marcar o arquivo no 'conffiles'.

  <p>Você pode pode utilizar exemplos de arquivos de configuração dos 'scripts de mantenedor'. Para maiores informações veja <ref id="maintscripts">.

  <p>Se o seu programa não tem arquivos de configurações, você pode apagar o arquivo <tt/conffiles/ do diretório debian/.

  <sect id="crond">cron.d.ex

  <p>Se o seu pacote precisa agendar tarefas regularmente para funcionar adequadamente, você pode usar este arquivo para definir isso.

  <p>Note que isso não inclui rotação de logs; para isso, veja
  <manref name="dh_installlogrotate" section="1"> e
  <manref name="logrotate" section="8">.

  <p>Se não, remova este arquivo.

  <sect id="dirs">dirs

  <p>Este arquivo especifica os diretórios que nós precisamos mas o processo de instalação normal (make install), por algum motivo, não cria.

  <p>Por padrão, ele é como seguinte:

  <p><example>
  usr/bin
  usr/sbin
  </example>

  <p>Note que a barra precedente não é incluída. Nós normalmente teríamos alterado para ficar como seguinte:

  <p><example>
  usr/bin
  usr/man/man1
  </example>
  
  <p>mas estes diretórios já são criados no Makefile, e portanto não precisamos deste arquivo e vamos então apagá-lo.

  <sect id="docs">docs

  <p>Este arquivo especifica os nomes dos arquivos de documentação que o dh_installdocs irá instalar no diretório temporário para nós.

  <p>Por padrão, ele incluirá todos os arquivos existentes no topo do diretório-fonte que são chamados 'BUGS', 'README*', 'TODO', etc.

  <p>Para o gentoo, eu também incluí mais coisas:

  <p><example>
  BUGS
  CONFIG-CHANGES
  CREDITS
  ONEWS
  README
  README.gtkrc
  TODO
  </example>
  
  <p>Nós podemos também remover este arquivo e listas estes arquivo no comando <tt/dh_installdocs/ do arquivo <tt/rules/, como seguinte:

  <p><example>
        dh_installdocs BUGS CONFIG-CHANGES CREDITS ONEWS README \
                       README.gtkrc TODO
  </example>

  <p>Entretando, infelizmente você pode não ter arquivos deste tipo no código-fonte do seu pacote. Neste caso, você pode remover este arquivo. Mas não remova a invocação do <tt/dh_installdocs/ do arquivo <tt/rules/ pois ele é utilizado para instalar o arquivo de <tt/copyright/ e outras coisas.

  <sect id="emacsen">emacsen-*.ex

  <p>Se o seu pacote fornece arquivos do Emacs que pode ser 'bytecompilados' no momento da instalação do pacote, você pode utilizar estes arquivos para definir isso.

  <p>Eles são instalados no diretório temporário pelo <manref name="dh_installemacsen" section="1">, portanto não se esqueça de descomentar essa linha no arquivo <tt/rules/ se você quer utilizar isso.

  <p>Se você não precisa destes, remova-os.

  <sect id="initd">init.d.ex

  <p>Se o seu pacote é um daemon que precisa ser executado na inicialização do sistema, você obviamente desobedeceu minha recomendação inicial, não é mesmo? :-)

  <p>Isto é meramente um esqueleto genérico para um script <file>/etc/init.d/</file>, e você provavelmente terá de editá-lo muito. Ele é instalado no diretório temporário pelo <manref name="dh_installinit" section="1">.

  <p>Se você não precisa disto, remova o arquivo.

  <sect id="manpage">manpage.1.ex, manpage.sgml.ex

  <p>Seu(s) programa(s) devem ter manuais. Se não têm, cada um destes arquivos são modelos que você pode preencher.

  <p>Manuis são normalmente escritos em <manref name="nroff" section="1">. O exemplo <tt/manpage.1.ex/ é escrito em nroff também. Você o manual <manref name="man" section="7"> para uma breve descrição de como editar um destes arquivos.

  <p>Se, por outro lado, você prefere escrever em sgml ao invés de nroff, você pode usar o modelo <tt/manpage.sgml.ex/. Se você for fazer isso, você tem de:
  <list>
    <item>instalar o pacote <package/docbook-to-man/
    <item>adicionar o <tt/docbook-to-man/ á linha <tt/Build-Depends/ do arquivo <tt/control/
    <item>remover a o comentário da invocação do docbook-to-man na regra 'build' do seu arquivo <tt/rules/
  </list>

  <p>E lembre-se de renomear o arquivo para algo como <tt/gentoo.sgml/!

  <p>O nome do arquivo final do maual deve incluir o nome do programa que está documentando, e portanto nós iremos renomeá-lo de 'manpage' para 'gentoo'. O nome do arquivo também inclui '.1' como o primeiro sufixo, o que significa que é um manual para um comando de usuário. Certifique-se de verificar que seção é, de fato, a correta. Eis uma pequena lista de seções de manuais.

  <p><example>
  Section |     Description       |     Notes
     1     Comandos de usuário      Comando executáveis ou scripts.
     2     Chamadas de sistema      Funções fornecidas pelo kernel.
     3     Chamadas de biblioteca   Funções dentro de bibliotecas do sistema.
     4     Arquivos especiais       Normalmente encontrados em /dev
     5     Formatos de arquivo      Ex: o formato do /etc/passwd
     6     Jogos                    Ou outros programas frívolos
     7     Pacotes de Macro         Como macros.
     8     Administração de sistema Programas típicamente executados como root.
     9     Rotinas de Kernel        Chamadas internas e não-padronizadas.
  </example>
  
  <p>Então o manual do gentoo deve ser chamado <tt/gentoo.1/. Não existia um manual gentoo.1 no fonte original, então eu o escrevi utilizando a informação do exemplo e da documentação.

  <sect id="menu">menu.ex

  <p>Usuários de sistemas X-Window normalmente tem um manipulador de janelas com um menu que pode ser personalizado para executar programas. Se eles tiverem o pacote do Debian <package/menu/, um conjunto de menus para programa no sistema será criado para eles.

  <p>Eis o arquivo <tt/menu.ex/ padrão que o dh_make criou:
  
  <p><example>
  ?package(gentoo):needs=X11|text|vc|wm section=Apps/see-menu-manual\
    title="gentoo" command="/usr/bin/gentoo"
  </example>

  <p>O primeiro campo após o caractere de dois-pontos é 'needs', e especifica que tipo de interface o programa precisa. Mude isto para uma das alternativas listadas, como 'text' ou 'X11'.

  <p>O seguinte é 'section', onde as entradas de menu e submenus devem aparecer. A lista atual de seções está em:
  <file>/usr/share/doc/debian-policy/menu-policy.html/ch2.html#s2.1</file>

  <p>O campo 'title' é o nome do programa. Você pode começar este em caixa alta, se quiser, desde que seja curto.

  <p>Finalmente, o campo 'command' é o comando que executa o programa.

  <p>Agora nós iremos mudar a entrada de menu para o seguinte:

  <p><example>
  ?package(gentoo): needs=X11 section=Apps/Tools title="Gentoo" command="gentoo"
  </example>

  <p>Você pode também adicionar outros campos como 'logtitle', 'icon', 'hints', etc.
  Veja <manref name="menufile" section="5">,
  <manref name="update-menus" section="1">
  e <file>/usr/share/doc/debian-policy/menu-policy.html/</file> para maiores informações.

  <sect id="watch">watch.ex

  <p>Este arquivo é utilizado para configurar os programas <manref name="uscan" section="1">
  e <manref name="uupdate" section="1">  (no pacote <package/devscripts/). Estes são utilizados para monitorar o site de onde você pegou o código-fonte original.

  <p>Eis o que eu coloco nele:

  <p><example>
  # Arquivo de controle de monitoramento para o uscan
  # Site                Diretório        Padrão                        Versão        Script
  ftp.obsession.se        /gentoo                gentoo-(.*)\.tar\.gz        debian        uupdate
  </example>

  <p>Dica: conecte à internet, e tente rodar o 'uscan' no diretório do programa assim que você criar o arquivo. E leia os manuais! :)

  <sect id="doc-base">ex.package.doc-base

  <p>Se o seu pacote tem outra documentação fora o manual e info, você deve utilizar o arquivo '<package/doc-base/' para registrá-lo, de forma que o usuário possa encontrá-la com, por exemplo, <manref name="dhelp" section="1">, <manref name="dwww" section="1"> ou <manref name="doccentral" section="1">.

  <p>Isto normalmente inclui arquivos HTML, PS ou PDF, distribuídos em <file>/usr/share/doc/nome_do_pacote/</file>

  <p>Eis como ficaria o arquivo do doc-base do gentoo:

  <p><example>
  Document: gentoo
  Title: Manual do Gentoo
  Author: Emil Brink
  Abstract: Este manual descreve o que o Gentoo é, e como pode ser utilizado.
  Section: Apps/Tools

  Format: HTML
  Index: /usr/share/doc/gentoo/html/index.html
  Files: /usr/share/doc/gentoo/html/*.html
  </example>

  <p>Para maiores informações sobre esse formato, veja 
  <manref name="install-docs" section="8"> e o manual do <package/doc-base/,
  em <file>/usr/share/doc/doc-base/doc-base.html/</file>.

  <sect id="maintscripts">postinst.ex, preinst.ex, postrm.ex, prerm.ex

  <p>Estes arquivos são chamados scripts de mantenção. Eles são scripts que são postos na área de controle do pacote e executados pelo <prgn/dpkg/ quando seu pacote é instalado, atualizado ou removido.

  <p>Por enquanto, você deve evitar qualquer edição manual dos scripts de manutenção se você puder, pois eles tendem a ficar complexos. Para maiores informações leia o capítulo 6 do Debian-Policy e analise estes arquivos de exemplo fornecidos pelo dh_make.

  <chapt id="build">Construíndo o pacote

  <p>Agora devemos estar prontos para construir o pacote.

  <sect id="completebuild">Reconstrução completa

  <p>Mude para o diretório principal do programa e execute o seguinte comando:

  <p><example>
  dpkg-buildpackage -rfakeroot
  </example>

  <p>Isto fará tudo para você. Ele irá:
  <list>
    <item>limpar a árvore do código-fonte (debian/rules clean), utilizando o <prgn/fakeroot/
    <item>construir o pacote-fonte (dpkg-source -b)
    <item>compilar o programa (debian/rules build)
    <item>construir o pacote-binários (debian/rules binary), utilizando <prgn/fakeroot/
    <item>validar o código-fonte arquivo <tt/.dsc/, utilizando <prgn/gnupg/
    <item>criar e validar o arquivo <tt/.changes/ para ser enviado, utilizando <prgn/dpkg-genchanges/ e <prgn/gnupg/
  </list>

  <p>A única entrada sua que será necessária será a sua frase-senha de GPG, duas vezes.

  <p>Feito tudo isso, você verá os seguintes arquivos no diretório acima (<tt>~/debian/</tt>):

  <p><list>
  <item><em>gentoo_0.9.12.orig.tar.gz</em>

  <p>Este é o código-fonte original, compactado, meramente renomeado para o acima de forma a seguir o padrão Debian. Note que este foi criado utilizando a opção '-f' no <prgn/dh_make/ quando nós o executamos inicialmente.

  <item><em>gentoo_0.9.12-1.dsc</em>

  <p>Este é o resumo do conteúdo do código-fonte. O arquivo é gerado do seu arquivo 'control', e será utilizado quando o código-fonte for desempacotado com o <manref name="dpkg-source" section="1">. Este arquivo é validado com o PGP, de forma que as pessoas podem ter certeza que ele é realmente o seu.

  <item><em>gentoo_0.9.12-1.diff.gz</em>

  <p>Este arquivo compactado contém cada uma das modificações que você fez no código-fonte, no formato conhecido como "diff unificado". Ele é feito e utilizado pelo <manref name="dpkg-source" section="1">. ATENÇÃO: se você não nomear o pacote compactado (tarball) orignal como nomedopacote_versao.orig.tar.gz, o <prgn/dpkg-source/ irá falhar na geração do arquivo .diff.gz!

  <p>Se alguém quiser recriar o seu pacote desde o início, eles podem facilmente faze-lo utilizando os três arquivos acima. O procedimento de extração é trivial: copie os três arquivos em algum lugar e execute <tt>dpkg-source -x gentoo_0.9.12-1.dsc</tt>.

  <item><em>gentoo_0.9.12-1_i386.deb</em>

  <p>Este é o seu pacote binário completo. Você pode utilizar o <prgn/dpkg/ para instalá-lo e removê-lo como qualquer outro pacote.

  <item><em>gentoo_0.9.12-1_i386.changes</em>

  <p>Este arquivo descreve todas as modificações feitas na revisão atual do pacote, e é utilizado pelo programa de manutenção do arquivo FTP da Debian para instalar os pacotes binário e fonte. Ele é parcialmente gerado a partir do arquivo 'changelog' e do arquivo '.dsc'. Este arquivo é validado utilizando PGP, de forma que as pessoas podem ter certeza que ele é realmente seu.

  <p>A medida que você for trabalhando no pacote, o seu comportamento irá mudar e novas funcionalidades serão adicionadas. As pessoas que baixarem o seu pacote poderão olhar neste arquivo e rapidamente ver o que foi alterado. Os programas de manutenção do arquivo da Debian também irão enviar o conteúdo deste arquivo para a lista debian-devel-changes.
  </list>

  <p>Os longos strings numéricos nos arquivos .dsc e .changes são as validações MD5 para os arquivos mencionados.
  Uma pessoa que baixar os seus arquivos podem testá-los com <manref name="md5sum" section="1"> e se os números não coincidirem, eles saberão que o arquivo está corrompido ou que alguém mexeu nele sem autorização.

  <sect id="quickrebuild">Reconstrução rápida

  <p>Quando o pacote for grande, você pode não querer reconstruí-lo completamente toda vez que você mudar alguma coisa no arquivo <file>debian/rules</file>. Para fins de testes, você pode criar um arquivo .deb sem ter de reconstruir todo o código e pacote-fonte da seguinte forma:

  <p><example>
  fakeroot debian/rules binary
  </example>

  <p>Assim que você terminar suas modificações, lembre-se de reconstruir o pacote como descrito anteriormente, o procedimento correto. Você pode não conseguir enviá-lo corretamente se você simplesmente enviar os arquivos .deb construídos dessa forma.

  <chapt id="checkit">Procurando por erros no pacote

  <p>Execute o <manref name="lintian" section="1"> no seu arquivo .changes ; este programa irá verificar o pacote procurando por uma série de erros comuns de empacotamento. O comando é:
  
  <p><example>
  lintian -i gentoo_0.9.12-1_i386.changes
  </example>
  
  <p>Obviamente você deve substituir o nome do arquivo .changes pelo gerado para o seu pacote. Se forem mostrados erros (linhas começadas com E:), leia a descrição (as linhas N:), corrija os erros, e reconstrua o pacote como descrito em <ref id="completebuild">. Se aparecerem linhas começadas com W:, são advertências, e você deve "afinar" o seu pacote ou certificar-se que as advertências são desnecessárias (e fazer objeções no Lintian; veja a documentação para mais detalhes.).

  <p>Note que você pode construir o pacote com o <prgn/dpkg-buildpackage/ e executar o <prgn/lintian/ ao mesmo tempo com um só comando com <manref name="debuild" section="1">.

  <p>Olhe dentro do pacote utilizando um manipulador de arquivos como o <manref name="mc" section="1">, ou desempacote-o num diretório temporário utilizando o <manref name="dpkg-deb" section="1">. Procure por arquivos desnecessários, tanto no pacote binário quanto no fonte. Muitas vezes o lixo não é eliminado corretamente; ajuste o seu arquivo 'rules' para compensar isso. Dicas: 'zgrep ^+++ ../gentoo_0.9.12-1.dif.gz' lhe dará uma lista de modificações/adições nos arquivos-fonte, e 'dpkg-deb -c gentoo_0.9.12-1_i386.deb' irá listar os arquivos no pacote binário.

  <p>Instale o pacote e teste-o, ex: utilizando o comando <manref name="debi" section="1"> como root. Tente instalar e executa-lo em outras máquinas diferentes e observe com atenção as advertências e/ou erros durante a instalação e execução.

  <chapt id="upload">Enviando o pacote

  <p>Agora que você já testou completamente o seu novo pacote, você está pronto para começar a preencher o formulário de novo mantenedor do Debian, descrito em <url id="http://www.debian.org/devel/join/newmaint">

  <p>Assim que você se tornar um desenvolvedor oficial, você precisará enviar o pacote para o arquivo da Debian. Você pode fazer isso manualmente, mas é mais fácil usar as ferramentas de automatização fornecidos, como o
  <manref name="dupload" section="1"> ou <manref name="dput" section="1">.
  Vamos descrever como é feito com o <prgn/dupload/.

  <p>Primeiro você tem de configurar o dupload. Você pode tanto editar o arquivo de configuração global <file>/etc/dupload.conf</file>, ou ter o seu próprio arquivo <file>~/.dupload.conf</file> com as configurações que você deseja personalizar. Coloque algo como o seguinte neste arquivo:

  <p><example>
  package config;

  $default_host = "ftp-master";

  $cfg{"ftp-master"}{"login"} = "seunomedeusuariodebian";

  $cfg{"non-us"}{"login"} = "seunomedeusuariodebian";

  1;
  </example>

  <p>Obviamente você deve substituir minhas configurações pessoais pelas suas, e ler o manual 
  <manref name="dupload.conf" section="5"> para entender o que cada uma dessas opções significa.

  <p>A opção $default_host é a que precisa de mais atenção -- ela determina qual file de upload será usada como padrão. "ftp-master" é a primária, mas é possível que você queira usar outra mais rápida. Para mais informações sobre files de upload, leia a Referência do Desenvolvedor (Developer's Reference), na seção "Uploading a package", em <file>/usr/share/doc/developers-reference/developers-reference.html/ch-upload.en.html#s-uploading</file>

  <p>Conecte então ao seu provedor de internet e execute o comando:
  
  <p><example>
  dupload gentoo_0.9.12-1_i386.changes
  </example>

  <p>O <prgn/dupload/ verifica se as validações MD5 dos arquivos coincidem com aquelas do arquivo .changes, e irá advertí-lo a reconstruir o pacote como descrito em <ref id="completebuild">, caso não coincidam, para que o pacote possa ser devidamente enviado.

  <p>Se você enviar para o "ftp-master", o <prgn/dupload/ irá pedir pela sua senha nas máquinas da Debian, e então irá enviar os pacotes.

  <chapt id="update">Atualizando o pacote

  <sect id="newrevision">Nova revisão Debian

  <p>Digamos que um relatório de bug foi preenchido contra o seu pacote, #54321, e descreve um problema que você pode solucionar. Para criar uma nova revisão de pacote Debian você precisa:

  <list>
  <item>Corrigir o problema no pacote-fonte, é claro.

  <item>Adicionar uma nova revisão no topo do arquivo de changelog, por exemplo com "dch -i', ou explícitamente com "dch -v &lt;versão&gt;-&lt;revisão&gt;' e então inserir os comentário utilizando o seu editor de textos favorito.

  <p>Dica: Como obter a data no formato adequado?
  Use `822-date`, ou `date -R`.

  <item>Inclua uma breve descrição do bug e sua solução na entrada do changelog, seguido por "Closes: #54321". Dessa forma, o relatório de bug será "automágicamente" fechado pelo software de manutenção do arquivo no momento em que seu pacote for aceito no arquivo Debian.

  <item>Repita o que você fez em <ref id="completebuild">, <ref id="checkit">,e <ref id="upload">. A diferença é que, desta vez, o arquivo-fonte não será incluído, uma vez que ele não mudou e já existe no arquivo da Debian.
  </list>

  <sect id="newupstream">Nova distribuição do programa

  <p>Agora vamos considerar uma situação diferente, um pouco mais complicada - uma nova versão do software foi lançada, e obviamente você a quer empacotada. Você precisa fazer o seguinte:

  <list>
  <item>Baixar o novo código-fonte e colocar o arquivo compactado (tarball) (ex: chamado 'gentoo-0.9.13.tar.gz') no diretório acima da árvore do código fonte antigo (ex: ~/debian/).

  <item>Entre no diretório do código-fonte antigo e execute:

  <example>
  uupdate -u gentoo-0.9.13.tar.gz
  </example>

  <p>Obviamente, substitua esse nome de arquivo com o nome do seu novo código-fonte do programa. O <manref name="uupdate" section="1"> irá renomear o arquivo devidamente, tentar aplicar todas as diferenças do arquivo .diff.gz antigo e atualizar o novo arquivo debian/changelog.

  <item>Mude para o diretório '../gentoo-0.9.14', a nova árvore de código-fonte, e repita o que você fez em <ref id="completebuild">, <ref id="checkit">, e <ref id="upload">.
  </list>

  <p>Note que se você definiu um arquivo 'debian/watch' como descrito em <ref id="watch">, você pode executar o <manref name="uscan" section="1"> para "automágicamente" procurar por novos códigos-fonte, baixar eles, e executar o <prgn/uupdate/.

  <sect id="upgrading">Verificando atualizações de pacotes

  <p>Quando você constrói uma nova versão de um pacote, você deve fazer o seguinte para verificar que o pacote pode ser atualizado de forma segura:

  <list>
    <item>atualizar o pacote antigo
    <item>reinstalar o pacote antigo, e então removê-lo
    <item>instalar o novo pacote
    <item>removê-lo e o reinstalar novamente,
    <item>executar um "purge" nele.
  </list>

  <p>Tenha em mente que se o seu pacote já foi previamente distribuído no Debian, as pessoas irão atualizar para o seu pacote a partir da última versão do Debian com frequência. Lembre-se de testar as atualizações a partir dessas versões também.

  <chapt id="helpme">Onde pedir ajuda

  <p>Antes de decidir pedir ajuda em algum lugar público, por favor leia toda a documentação disponível. Isso inclui
  a os arquivos em <file>/usr/share/doc/dpkg</file>, <file>/usr/share/doc/debian</file>, <file>/usr/share/doc/package/*</file>, os manuais e infos de todos os programas mencionados nesse documento.

  <p>Se você tem perguntas sobre o empacotamento e não pode encontrar respostas na documentação, você pode faze-las na lista Debian Mentors em <email/debian-mentors@lists.debian.org/. Os desenvolvedores Debian mais experientes ficarão felizes em poder ajudar, mas leia a documentação antes de fazer perguntas!

  <p>Veja <url id="http://lists.debian.org/debian-mentors/"> para maiores informações sobre essa lista.

  <p>Quando você receber relatórios de bugs (sim, relatórios de bugs de verdade!), você saberá que é hora de entrar no <url name="Debian Bug Tracking System" id="http://www.debian.org/Bugs/"> e ler a documentação de lá, para poder lidar com os relatórios eficientemente. Eu recomendo fortemente que você leia a Referência do Desenvolvedor (Developers Reference) no capítulo "Tratando de Bugs" (Handling Bugs", em <file>/usr/share/doc/developers-reference/developers-reference.html/ch-bug-handling.en.html</file>

  <p>Se você ainda tem perguntas, faça-as na lista do Debian Developers em <email/debian-devel@lists.debian.org/. Veja <url id="http://lists.debian.org/debian-devel/"> para maiores informações sobre esta lista.

  <p>Mesmo se você fez um bom trabalho, é hora de começar a rezar. Porque? Porque em poucas horas (ou dias) os usuários de todo o mundo começarão a usar o seu pacote, e se você cometeu algum erro grave será bombardeado por milhares de usuários Debian irritados... Brincadeira! :-)

  <p>Relaxe e se prepare para relatórios de bugs, pois ainda tem muito trabalho a ser feito antes que seu pacote esteja completamente de acordo com a política do Debian (novamente, leia a <em>documentação de verdade</em> para detalhes.). Boa sorte!

 </book>

</debiandoc>