[update] maint-guide.ja.sgml (1/5)

[Taketoshi Sano <kgh12351@xxxxxxxxxxx>]

佐野＠浜松です。

ようやく Debian New Maintainers' Guide 日本語訳の更新が
最後まで到達しました。

とりあえずこれで commit しておきますが、もし気のついた
点があれば御指摘をお願いします。

オリジナル (英語版) が 1755 行 (76097bytes)、
日本語訳は 2218 行 (90908bytes) ありますので、
chapt 2 つずつに分割して送ります。

  ====== Japanese translation ======

<!doctype debiandoc system>

<debiandoc>

 <book>

  <titlepag>

   <title>Debian メンテナ入門</title>

   <author>Josip Rodin <email/jrodin@xxxxxxxxxxxxx/
   </author>

   <author> 翻訳: 八田真行 <email/mhatta@debian.or.jp/
   </author>

   <author> 日本語訳更新 (v1.2): 佐野武俊 <email/sano@debian.org/
   </author>

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

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

   <p>この文書は GNU 一般公有使用許諾書、バージョン 2 かそれ以降が
   規定する条件の下で利用できます。
   
   <p>この文書は以下の二つの文書を参考として書かれました。

   <p>Debian パッケージの作り方 (Debmake マニュアル)、
   Copyright &copy; 1997 Jaldhar Vyas.

   <p>新米メンテナのための Debian パッケージング Howto、
   Copyright &copy; 1997 Will Lowe.
  </copyright>

  </titlepag>

  <toc sect>

  <chapt id="start">まずは「正しいやり方で」始めよう

  <p>この文書では、Debian パッケージを作るにはどうしたらよいか、
  一般的な Debian ユーザと開発者予備軍を対象に解説しようと思います。
  小難しい専門用語はできるだけ避けて、実用的な例を多く用いて説明していく
  つもりです。ことわざにもあるように、<em>百聞は一見にしかず</em>
  ですからね!

  <p>Debian が Linux ディストリビューションの最高峰と呼ばれる
  までになった理由のひとつがそのパッケージ管理システムです。
  すでに膨大な数のソフトウェアが Debian	パッケージとして配布されて
  いますが、まだパッケージ化されていないソフトウェアをインストール
  しなければならないこともあるでしょう。
  あるいは、どうやったら自分でパッケージが作れるんだろう、とか
  それはとても難しいことなんじゃないか、などと考えたことがあるかも
  しれません。まあ、もしあなたが本当に駆け出しの Linux ユーザ
  ならば困難な仕事でしょうが、でもそうだったら今ごろこんな文書
  読んでませんて :-)

  パッケージを作成するには Unix のプログラミングについてある程度
  知っている必要がありますが、神様みたいに精通している必要は
  全くありません。

  <p>ただ、確かなことがひとつあります。Debian パッケージを
     きちんと作成し、保守していくには、手間を惜しんではならない、
     ということです。間違えないでください。Debian のシステムを
     うまく動かしていくためには、メンテナーは技術的に有能である
     だけでなく、勤勉であることも必要なのです。

  <p>この文書では (最初は関係無さそうに思えることまで) どんな
  細かい手順も余さず説明します。
  ともかく一つ作ってしまえば、あとは次のリリース、そして
  他のパッケージへと経験を積んでいけばよいのです。

  <p>この文書の最新版は常に以下の場所からネットワーク経由で入手できます。
  <url name="http://www.debian.org/doc/maint-guide/"; id="http://www.debian.org/doc/maint-guide/";>
  また、 「<package/maint-guide/」パッケージにも含まれています。
  日本語訳は「<package/maint-guide-ja/」パッケージの中にあります。

  <sect id="needprogs">開発に必要なプログラム

  <p>何かを始める前に、開発作業を行なうために必要な、
  以下に挙げるようなパッケージがきちんとインストールされていることを
  まず確かめておかなければいけません。
  以下のリストには「essential」または「required」なパッケージが
  含まれていないことに注意してください。
    - これらのパッケージは既にインストールされていることを前提と
  しています。

  <p>この文書の現在のバージョンは Debian 2.2 (`potato') および
  3.0 (`woody') に含まれるパッケージを対象に更新されています。

  <p>以下のパッケージは Debian の「標準」(standard) インストール
  構成に含まれており、すでに (それらが依存する他のパッケージと
  いっしょに) システムに含まれているはずです。
  しかし、念のために「dpkg -s &lt;パッケージ名&gt;」で確認して
  おきましょう。

  <list>
  <item><package/dpkg-dev/ - このパッケージには Debian ソース
  パッケージを展開、構築、アップロードするために必要なツール群が
  含まれています。
  (詳しくは <manref name="dpkg-source" section="1"> を参照)。

  <item><package/file/ - この便利なプログラムを使うと
  そのファイルがどういう形式のものか判定することが
  できます
  (詳しくは <manref name="file" section="1"> を参照)。

  <item><package/gcc/ - GNU C コンパイラ。あなたのプログラムが
  他の多くのプログラムと同様に C 言語で書かれている場合、必要と
  なります。(詳しくは <manref name="gcc" section="1"> を参照)
  このパッケージは、たとえばプログラムの「素」となるオブジェクト
  ファイルをアセンブル、リンクするための <package/binutils/
  (<package/binutils-doc/ パッケージをインストールして
   「info binutils」すれば詳細な説明を読めます)、
  C プリプロセッサ <package/cpp/ 
  (詳しくは <manref name="cpp" section="1"> を参照)
  など他のパッケージをいくつか一緒に「引き連れて」きます。

  <item><package/g++/  - GNU C++ コンパイラ。あなたの
  プログラムが C++ 言語で書かれている場合に必要です。
  (詳しくは <manref name="g++" section="1"> を参照)

  <item><package/libc6-dev/ - gcc がオブジェクトファイルを
  生成してリンクするために必要な C ライブラリとヘッダファイル
  が含まれています。(<package/glibc-doc/ パッケージを
  インストールして「info libc」すればマニュアルが読めます)

  <item><package/make/ - ふつう、プログラムはいくつかの手順を踏んで
  生成されます。同じコマンドを何度も何度も繰り返し入力する代わりに、
  make プログラムを使えば「Makefile」を書くことで手続きを自動化
  することができます。(詳しくは「info make」)

  <item><package/patch/ - このとても有用なユーティリティは
  オリジナルとの差異が列挙されたファイル (diff プログラムによって生成) を
  読み込んでオリジナルのファイルに適用し、変更された (パッチの当たった)
  バージョンを作成します。
  (詳しくは <manref name="patch" section="1"> を参照)。

  <item><package/perl/ - Perl は今日の Un*x システムにおいてもっとも
  使われているインタープリタ型スクリプト言語のひとつで、その強力さは
  しばしば「Unix のスイス軍用チェーンソー」と形容されるほどです
  (詳しくは <manref name="perl" section="1">を参照)。
  </list>

  <p>たぶん、以下のパッケージもインストールしたくなるでしょう。

  <list>
  <item><package/autoconf/ と <package/automake/ - 
  多くの新しいプログラムがこれらのプログラムを使って
  前処理される設定スクリプトや Makefile を利用しています。
  (詳しくは「info autoconf」および「info automake」)

  <item><package/dh-make/ と <package/debhelper/ - 
  dh-make はあとで説明するパッケージのひな型を用意するのに
  必要となります。またこのひな型ではパッケージを生成する
  ために debhelper ツールをいくつか使います。
  これらを使わなくてもパッケージ作成は可能ですが、
  初めてパッケージを作る方には利用を
  <strong>強く</strong> お勧めします。
  パッケージを作るのも、以後パッケージを管理するのも
  ずっと簡単になるからです。
  (詳しくは <manref name="dh_make" section="1">、
  <manref name="debhelper" section="1">、
  /usr/share/doc/debhelper/README を参照)

  <item><package/devscripts/ - このパッケージは
  メンテナにとって便利であると思われるいくつかの
  有用で優れたスクリプトを含んでいますが、だから
  といってパッケージを作成するために必須という
  わけではありません。
  (詳しくは /usr/share/doc/devscripts/README.gz 参照)。

  <item><package/fakeroot/ - このユーティリティを使うと、
  パッケージを作成する際に何度か必要となる root 権限を
  エミュレートすることができます。
  (詳しくは <manref name="fakeroot" section="1"> を参照)

  <item><package/gnupg/ - このツールを使うと、自分の
  パッケージに「デジタル <em>署名</em>」を付けることが
  できます。もしあなたが自分の作成したパッケージを他の
  人々に配布したいのなら、これは特に重要です。
  また、Debian ディストリビューションにあなたの作成した
  パッケージが含まれるようになった時には、確実にこの
  デジタル署名をすることになります。
  (詳しくは <manref name="gpg" section="1"> を参照)

  <item><package/g77/ - GNU Fortran 77 コンパイラ。あなたの
  プログラムが Fortran 言語で書かれている場合に必要です。
  (詳しくは <manref name="g77" section="1"> を参照)

  <item><package/gpc/ - GNU Pascal コンパイラ。あなたの
  プログラムが Pascal 言語で書かれている場合に必要です。
  ここで注目に値するのは <package/fp-compiler/、
  Free Pascal コンパイラで、こちらもまたこの作業に適して
  います。
  (詳しくは <manref name="gpc" section="1"> および
  <manref name="ppc386" section="1"> を参照)

  <item><package/imake/ および <package/xmkmf/ - 
  ある種のプログラム (通常 X11 のために開発されたもの) は、
  これらのプログラムを利用して、マクロ関数の組み合わせから
  Makefile 群を生成します。
  (詳しくは <manref name="imake" section="1">、
  <manref name="xmkmf" section="1"> を参照)

  <item><package/lintian/ - これは Debian パッケージチェッカで、
  あなたが構築したパッケージを調べて、その中にありがちなミスが
  見つかったらそれを指摘し、その問題について説明してくれます
  (詳しくは <manref name="lintian" section="1">、
  /usr/share/doc/lintian/lintian.html/index.html を参照)。
  </list>

  <p>さて、以下はこの文書と合わせて読むべき<em>とても重要</em>な
  文書です。

  <list>
  <item><package/debian-policy/ - Debian ポリシーマニュアル。
  Debian アーカイブの構造と内容、OS の設計に関するいくつかの問題、
  あるいは「ファイルシステム体系基準」(Filesystem Hierarchy Standard、
  個々のファイルやディレクトリがどこにあるべきかを規定した文書)
  についてなどいろいろ載っていますが、
  さしあたって重要なことは、ディストリビューションに含まれるために
  それぞれのパッケージが満たすべき必要条件の説明です
  (詳しくは /usr/share/doc/debian-policy/policy.html/index.html を参照)。

  <item><em>developers-reference</em> - 開発者リファレンス。
  例えばアーカイブの構造、パッケージ名の変更方法、
  パッケージの選び方、メンテナを降りるにはどうしたらよいか、
  どうやって NMU をするか、バグとのつき合い方、
  いつどこにアップロードすればよいかなどなど、特に技術的な事柄以外の
  パッケージ化についてのありとあらゆる情報がここにあります。
  (詳しくは /usr/share/doc/developers-reference/developers-reference.html/index.html を参照)
  </list>

  <p>上記の簡単な説明は、それぞれのパッケージが何をするのか紹介
  するだけのものです。先に進む前にどうかそれぞれのプログラムに
  付属の文書を徹底的に熟読し、標準的な使い方だけでも理解しておいて
  ください。きついと思われるかも知れませんが、あとになればきっと
  <em>読んでてよかったなあ</em>と思うことでしょう。

  注意: <package/debmake/ は dh-make と似た働きをする
  いくつかのプログラムを含むパッケージですが、現在では
  このパッケージを <em>使うべきでない</em> とされているため、
  この文書では <strong>説明しません</strong>。
  <package/debmake/ について詳しく知りたい人は
  <url name="Debmake マニュアル" id="http://www.debian.org/~jaldhar/";>
  を参照してください。

  <sect id="otherinfo">その他知っておくべきこと

  <p>これから作ろうとするのは 2 種類のパッケージで、それぞれ
  ソースパッケージ、バイナリパッケージと呼ばれています。
  ソースパッケージはコンパイルしてプログラムになるソースコードが
  含まれます。バイナリパッケージにはでき上がったプログラムそのものです。
  紛らわしい言葉ですが、「プログラムのソース」と
  「プログラムのソースパッケージ」を混同しないようにしましょう!
  もし用語についてもっと知りたければ他のマニュアル類を参照してください。
  
  <p>Debian では、「メンテナ(maintainer)」と言う用語はパッケージを
  作る人を示し、「上流作者(upstream author)」とはプログラムそれ自身を
  作った人を指します。そして「上流メンテナ(upstream maintainer)」
  というのは Debian の外部で現在プログラムそのものを管理している人の
  ことです。
  たいていの場合、作者と上流メンテナは同一人物ですが、メンテナすらも
  同じという場合もあり得ます。
  もしあなたが何かのプログラムを書いて、それを Debian に入れたいと
  考えたならば、Debian プロジェクトに参加してメンテナになってください。

  <p>もしディストリビューションの次のリリースにあなたのプログラムを
  含めたい(そのプログラムが有用なら、ぜひ!)ならば、パッケージを
  構築したあとに(あるいはしている最中でも構いませんが)
  正式な Debian メンテナになる必要があります。その手続きは
  開発者リファレンスで説明されていますので、そちらを参照してください。

  <chapt id="first">はじめの一歩

  <sect id="choose">パッケージ化するプログラムの選定

  <p>パッケージにしたいプログラムについてはすでに各自お考えがあると
  思います。まず最初にしなければならないことは、そのパッケージが
  すでにディストリビューションに収録されていないかどうか確認することです。
  もしあなたが「安定版」を使っているのなら、
  たぶん
  <url name="パッケージ検索ページ" id="http://www.debian.org/distrib/packages";>
  に行って調べるのが最上の策です。
  ((訳注: <url name="Debian JP パッケージ" id="http://www.debian.or.jp/Packages.html";>
  もついでに見ておくといいかもしれません。))
  もしあなたが<strong>現在の</strong>「開発版」ディストリビューションを使って
  いるのなら、以下のコマンドを使って調べてみてください。

  <example>
  dpkg -s プログラム名
  dpkg -l '*プログラム名*'
  </example>

  <p>もしパッケージが既に存在していたら、インストールしましょう！ :-)
  もしそのパッケージが「みなし子」にされていたら (もしメンテナの名前が
  「Debian QA Group」になっていたら)、そのパッケージを引き取ることが
  できるかもしれません。
  <url name="みなしごにされたパッケージ"
         id="http://www.debian.org/devel/wnpp/orphaned";>
  および
  <url name="引き取り手を探しているパッケージ"
         id="http://www.debian.org/devel/wnpp/rfa_bypackage";>
  を調べて、本当にそのパッケージが引き取ってくれるメンテナを
  待っている状態なのかどうか、確認してください。

  <p>もしパッケージを引き取ることができたら、
  (<tt/apt-get source パッケージ名/ などの方法で) 
  ソースを入手して、調べてみてください。
  残念ながらこの文書ではパッケージを引き取ることについて
  わかりやすく説明してはいません。ありがたいことに、既に
  誰かがあなたのためにパッケージを準備してくれたわけですから、
  そのパッケージがどのように動作するのか理解することはそれほど
  難しくはないでしょう。
  とはいえ、そうした場合でもこの文書に書かれた多くのアドバイスは
  そのまま通用しますから、このまま読み進んでいってください。
  
  <p>もしあなたの選んだプログラムがまだパッケージ化されていない
  もので、それを Debian に入れたいと決めたなら、以下のチェック
  項目について確認してください。
  
  <list>
  <item><url name="作業中のパッケージ" 
             id="http://www.debian.org/devel/wnpp/being_packaged";>
  ((訳注:
  <url id="http://www.debian.or.jp/devel/prospective-packages.html";
     name="作業を必要としているパッケージ"> も見ておきましょう))、
  を見て、誰か他の人が同じプログラムのパッケージを作っていないかどうか
  確かめてください。もし誰か作っていたら、必要に応じて連絡をとって
  ください。もしその必要が無ければ、まだ誰も手をつけていない
  他の面白いプログラムを探して再チャレンジです。</item>

  <item>プログラムはライセンスを<strong>与えられていなければなりません</strong>。
  そのライセンスが
  <url name="Debian フリーソフトウェアガイドライン、DFSG" 
       id="http://www.debian.org/social_contract#guidelines";>
  に示された基準を満たす「フリー」なものであれば言うことなしです。
  ((訳注: 日本のミラーサイトは
   <url name="Debian フリーソフトウェアガイドライン" id="http://www.jp.debian.org/social_contract#guidelines";>
   にあります))

  もしガイドラインにそぐわない点があっても、ライセンスが
  プログラムの配布を許可している場合には、Debian の「contrib」や
  「non-free」のセクションに含めることができます。
  もしどのセクションに入れるべきか迷ったら、
  <email/debian-legal@list.debian.org/ で聞いてみてください。
  </item>
  
  <item>動作のために setuid root が必要なプログラムを
  パッケージ作成の最初の練習問題として選ぶべきでは
  <strong>ありません</strong>。

  さらに言えば、すべての場面において setuid や setgid でさえも
  必要とすべきではありません。</item>

  <item>デーモンとして動作するプログラムや、システム管理者の
  ための専用のコマンド (*/sbin ディレクトリに含まれるもの)、
  また root 特権を使ってポートを開くプログラムは、すくなくとも
  最初は避けておいたほうが賢明です。
  </item>

  <item>バイナリ実行形式として使えるプログラムを選びましょう。
  ライブラリをパッケージ化するのはずっと難しいのです。
  </item>

  <item>ちゃんとした説明書きのあること。あるいは理解可能な
  ソースコードであること (つまり、コードに書かれた処理の流れが
  混乱していないこと)。</item>

  <item>プログラムの作者に連絡をとってパッケージ化の承諾をもらいましょう。
  何かプログラムそのものに起因する問題が発生した際に、作者にいろいろ聞けると
  いうことは重要なので、由来のはっきりしないソフトウェアの断片をパッケージ化
  するのはやめておきましょう。
  </item>

  <item>そして最後に、といってもこれが重要なのですが、
  ちゃんと動くかどうか確かめましょう。そして何回か試してみましょう。
  </item>
  </list>

  <p>もちろんこれらのことは安全策というだけのことです。筆者としては、
  何も知らないままにパッケージ化しておまけにミスった
  ある種の setuid デーモンのせいで
  怒り狂ったユーザからあなたに向けて抗議殺到というような事態を
  回避したいのです。
  パッケージ化についてもっと経験を積めば、こうしたパッケージも
  作れるようになるでしょう。しかし、どんなに老練な開発者だって
  何か分からないことがあれば debian-mentors メーリングリストで
  質問するのです。そこには喜んで手助けしてくれる人々がいます。

  <p>もっと詳しい話は、開発者リファレンスに載っていますので
     そちらを参照してください。

  <sect id="getit">プログラムを手にいれて、試してみる

  <p>さて、最初にすべきことは、オリジナルのソースを探してダウンロード
  することです。ここでは作者のホームページからすでにソースファイルを入手した
  として話を進めます。
  フリーな Unix 用プログラムのソースはふつう tar/gzip 形式で提供されています。
  拡張子は .tar.gz で、普通は「プログラム名-バージョン」という
  サブディレクトリを含んでいます。そこにすべてのソースが入っているわけです。
  もしあなたのプログラムのソースが他の種類のアーカイブで提供されていたら
  (例えばファイル名が ".Z" とか ".zip" で終わっていたら)、
  適切なツールで展開しましょう。どうやって展開したらよいのか
  良く分からなかったら debian-mentors メーリングリストで聞いてみましょう
  (ヒント: 「file アーカイブ名.拡張子」を実行してみるとよいかも)。

  <p>さて本稿では、「gentoo」というプログラムを例にとって説明しようと
  思います。これは X11 上で動く GTK+ を使用したファイルマネージャです。
  ちなみにこのプログラムはすでにパッケージ化されており、また、
  この文書が最初に書かれた時点から比べると大幅に改変が加えられていることに
  注意してください。

  <p> 自分のホームディレクトリ以下に 'debian'、'deb'、または何か適当だと
  思われる名前のサブディレクトリを作りましょう (今回の場合には ~/gentoo/
  としても良いでしょう)。
  ダウンロードしたアーカイブをここにコピーし、
  「tar xzf gentoo-0.9.12.tar.gz」を実行して展開してください。
  この時 (一見「無関係」に思えるようなものも含めて) エラーは一切
  発生しないということを確認しておいてください。
  もしエラーが起きたら、それは他の人々のシステム上で展開する際にもおそらく
  エラーが起きるということです。そしてそこで使われている展開用のツールは
  こういった異常を無視するかも知れませんし、無視してくれないかもしれません。
  
  <p>さて、「gentoo-0.9.12」という別のサブディレクトリができました。
  展開したディレクトリに移って、提供されているドキュメントを
  <strong>徹底的に</strong>読みましょう。
  通常は README*、INSTALL*、*.lsm、*.html などといった名前の
  ファイルがあり、
  それらの文書の中に、どうやったら正しくコンパイルできるのか、
  どうインストールすればよいのかといった情報が見つかるはずです。
  (たぶん /usr/local/bin にインストールするものとして説明されています
が、
  そうしてはいけません。これについては <ref id="destdir"> を
  参照してください)。

  <p>プログラムによって構築の手順は代わりますが、最近のプログラムだと
  「configure」スクリプトが付属していることがあります。
  このスクリプトはソースをあなたのシステムに合わせて設定し、
  このままコンパイルできるかどうかをチェックします。
  たいていのプログラムは「./configure」を実行してソースコードの
  設定を行なった後、「make」を実行してコンパイルします。
  「make check」でプログラムのソースツリーに含まれている
  自己診断テストを実行できるものもあります。
  目的のディレクトリへのインストールは一般に「make install」によって
  実行されます。

  <p>さあ、試しにプログラムをコンパイルし、実行してみましょう。
  インストール中や実行中に他の何かを壊してしまうことが無いかどうか、
  またちゃんと動作するかどうか、などを確認してください。

  <p>それから、たいていの場合は「make clean」(「make distclean」を
  使えるならそのほうが良いです) を実行すると、コンパイル用の
  ディレクトリをきれいにしてくれます。さらに「make uninstall」を
  実行するとインストールされたファイルをすべて削除できることさえも
  あります。

  <sect id="namever">パッケージ名とバージョン

  <p>パッケージ化の作業は完全にクリーンな (オリジナルのままの)
  ソースディレクトリ、簡単に言えば新しく展開したソースから
  始めるべきです。

  <p>パッケージをきちんと作るためには、(もしまだそうなっていなければ) 
  プログラム名がすべて小文字になるよう、オリジナルの名前から
  変更しておかなければいけません。
  またソースディレクトリ名を &lt;パッケージ名&gt;-&lt;バージョン&gt; に
  変更しておきましょう。
  
  <p>もしプログラムの名前が一語以上で構成されていたら、
  一つの語につなげるか省略形にしましょう。
  例えば、「John's little editor for X」というソフトウェアならば
   johnledx とか jle4x というようにしましょう。あまり長すぎない程度、
  せいぜい 20 文字くらいまでの長さで、適当に決めて下されば結構です。

  <p>プログラムの正確なバージョンもチェックしましょう
  (パッケージのバージョンに含めるために)。
  もしそのソフトウェアが「バージョン X.Y.Z」という形式で番号付けされて
  おらず、ある種の日付で区別されている場合には、バージョン番号として
  "0.0." にその日付を続けたものを使ってもいいでしょう
  (先頭に "0.0." を付けておくのは、上流の開発者たちがある日
  1.0 のような素敵なバージョンをリリースすると決めた場合に備えての
  ことです。) つまり、もしリリースの、あるいはスナップショットの
  日付が 1998 年の 12 月 19 日だったら、0.0.19981219 としておけば
  結構です。

  <p>およそバージョン番号に使えそうな情報がまったくないと言う場合、
  上流メンテナに連絡をとって彼らが何か他のリビジョン管理手段を
  使っているかどうか聞いてみましょう。

  <sect id="dh_make">最初の「Debian 化」

  <p>現在の作業ディレクトリがプログラムのソースディレクトリである
  ことを確認し、以下を実行してください。

  <p><example>
  dh_make -e your.maintainer@address -f ../gentoo-0.9.12.tar.gz
  </example>
   
  <p>もちろん、"your.maintainer@address" の部分は changelog の
  エントリやその他のファイルに記載するための、あなたの電子メール
  アドレスに置き換えてくさい。またファイル名はあなたがパッケージ化
  しようとしているプログラムのオリジナルソースアーカイブの名前に
  置き換えてください。
  詳細は <manref name="dh_make" section="1"> を参照してください。

  <p>画面にはいろいろ表示されて、あなたが作ろうとしているパッケージ
  がどういう種類のものか聞いてきます。gentoo は 単一バイナリパッケージ - 
  すなわちパッケージに含まれるバイナリが一つだけで、一つの .deb ファイル
  のみが作成される - ですので最初の選択肢を選び、「s」キーを押しましょう。
  その後、画面に表示される情報をよく読み、確認したら &lt;enter&gt; を押して
  ください。

  <p>初めてパッケージを作るというときには、マルチバイナリパッケージや
  ライブラリに手を出さない方が無難です。この話は前にもしましたね。
  実際には作業自体はそれほど大変ではないのですが、ちょっとだけ
  より多くの知識が必要になります。そのため、ここではその作業について
  一切説明しません。

  <p>dh_make の実行は <strong>ただ一度だけ</strong> です。注意して
  ください。既に「Debian 化」された同じディレクトリで再び実行すると、
  正しく動作しないでしょう。これはつまり、将来パッケージの改訂版や
  新バージョンをリリースする時には別の方法を使うことになる、という
  ことでもあります。パッケージの更新作業についての詳細は後で説明する
  <ref id="update"> の部分を読んでください。

  ====== Original version ======

<!doctype debiandoc system>

<debiandoc>

 <book>

  <titlepag>

   <title>Debian New Maintainers' Guide</title>

   <author>Josip Rodin <email/jrodin@xxxxxxxxxxxxx/
   </author>
<!--
   <author>Translated by: [put your name here] <email/[put your e-mail here]/
   </author>
  -->

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

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

   <p>This document may be used under the terms the GNU General Public License
   version 2 or higher.

   <p>This document was made using with these two documents as examples:

   <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">Getting started The Right Way

  <p>This document tries to describe building of a Debian package to the
  common Debian user, and wannabe developer. It uses pretty common language,
  and it's well covered with working examples.
  There is an old Roman saying, <em>Longum
  iter est per preaecepta, breve et efficax per exempla!</em> (It's a long way
  by the rules, but short and efficient with examples!).

  <p>One of the things that makes Debian such a top-notch Linux distribution
  is its package system. While there is a vast quantity of software already
  in the Debian format, sometimes you need to install software that isn't.
  You may be wondering how you can make your own packages and perhaps you
  think it is a very difficult task. Well, if you are a real novice on Linux,
  it is hard, but if you were rookie, you wouldn't be reading this doc now. :-)
  You do need to know a little about Unix programming but you certainly
  don't need to be a wizard.

  <p>One thing is certain, though: to properly create and maintain Debian
  packages you need man hours. Make no mistake, for our system to work the
  maintainers need to be both technically competent and dilligent.

  <p>This document will explain every little (at first maybe irrelevant)
  step, and help you create that first package, and to gain some experience
  in building next releases of that and maybe other packages later on.

  <p>Newer versions of this document should always be available online at
  <url name="http://www.debian.org/doc/maint-guide/"; id="http://www.debian.org/doc/maint-guide/";>
  and in the `<package/maint-guide/' package.
  <!-- Translation in <this language> is also available in the
       `<package/maint-guide-xy/' package. -->

  <sect id="needprogs">Programs you need for development

  <p>Before you start anything, you should make sure that you have properly
  installed some additional packages needed for development. Note that the
  list doesn't contain any packages marked `essential' or `required' - we
  expect that you have those installed already.

  <p>This revision of this document has been updated for the packages in
  Debian 2.2 (`potato') and 3.0 (`woody').

  <p>The following packages come with the standard Debian installation,
  so you probably have them already (along with any additional packages
  they depend on).
  Still, you should check with `dpkg -s &lt;package&gt;`.

  <list>
  <item><package/dpkg-dev/ - this package contains the tools needed to unpack,
  build and upload Debian source packages. (see
  <manref name="dpkg-source" section="1">)

  <item><package/file/ - this handy program can determine what type a file is.
  (see <manref name="file" section="1">)

  <item><package/gcc/ - the GNU C compiler, necessary if your program like
  most others is written in the C programming language.
  (see <manref name="gcc" section="1">)
  This package will also "pull in" several other packages such as
  <package/binutils/ which includes programs used to assemble and link
  object files (see `info binutils` in the <package/binutils-doc/ package)
  and <package/cpp/, the C preprocessor. (see <manref name="cpp" section="1">)

  <item><package/g++/ - the GNU C++ compiler, necessary if your program
  is written in C++. (see <manref name="g++" section="1">)

  <item><package/libc6-dev/ - the C libraries and header files gcc needs to
  link with to create object files. (see `info libc` in the
  <package/glibc-doc/ package)

  <item><package/make/ - usually creation of a program takes several steps,
  so rather than having to type out the same commands over and over again,
  you can use this program to automate the process, creating `Makefile's.
  (see `info make`)

  <item><package/patch/ - this very useful utility will take file containing
  a difference listing (produced by the diff program) and apply it to the
  original file, producing a patched version. (see <manref name="patch" section="1">)

  <item><package/perl/ - Perl is one of the most used interpreted scripting
  languages on today's Unix-like systems, often referred to as "Unix's Swiss Army
  Chainsaw". (see <manref name="perl" section="1">)
  </list>

  <p>You'll probably want to install the following packages, too:

  <list>
  <item><package/autoconf/ and <package/automake/ - many newer programs use
  configure scripts and Makefiles preprocessed with help of programs like
  these. (see `info autoconf`, `info automake`)

  <item><package/dh-make/ and <package/debhelper/ - dh-make is necessary to
  create the skeleton of our example package, and it will use some the
  debhelper tools for creating packages. They are not essential for creation
  of packages, but it is <strong>highly</strong> recommended for new
  maintainers. It makes the whole process very much easier to start, and
  control afterwards. (see <manref name="dh_make" section="1">,
  <manref name="debhelper" section="1">, /usr/share/doc/debhelper/README)

  <item><package/devscripts/ - this package contain some nice and useful
  scripts that can be helpful to the maintainers, but they are also not
  necessary for building packages. (see /usr/share/doc/devscripts/README.gz)

  <item><package/fakeroot/ - this utility lets you emulate being root which
  is necessary for some parts of the build process. (see
  <manref name="fakeroot" section="1">)

  <item><package/gnupg/ - a tool that enables you to digitally <em>sign</em>
  packages. This is especially important if you want to distribute it to
  other people, and you will certainly be doing that when your work gets
  included in the Debian distribution. (see <manref name="gpg" section="1">)

  <item><package/g77/ - the GNU Fortran 77 compiler, necessary if your
  program is written in Fortran. (see <manref name="g77" section="1">)

  <item><package/gpc/ - the GNU Pascal compiler, necessary if your
  program is written in Pascal. Worthy of note here is <package/fp-compiler/,
  the Free Pascal Compiler, which is also good at this task.
  (see <manref name="gpc" section="1">, <manref name="ppc386" section="1">)

  <item><package/imake/ and <package/xmkmf/ - some programs, usually those
  made for X11, also use these programs to generate Makefiles from sets of
  macro functions. (see <manref name="imake" section="1">,
  <manref name="xmkmf" section="1">)

  <item><package/lintian/ - this is the Debian package checker that can let
  you know of any common mistakes after you build the package, and explain
  the errors found. (see <manref name="lintian" section="1">,
  /usr/share/doc/lintian/lintian.html/index.html)
  </list>

  <p>The following is the <em>very important</em> documentation which you
  should read along with this document:

  <list>
  <item><package/debian-policy/ - the Policy includes explanations of the
  structure and contents of the Debian archive, several OS design issues,
  the Filesystem Hierarchy Standard (which says where each file and
  directory should be) etc.
  For you, the most important thing is that it describes requirements that
  each package must satisfy to be included in the distribution.
  (see /usr/share/doc/debian-policy/policy.html/index.html)

  <item><package/developers-reference/ - for all matters not specifically
  about the technical details of packaging, like the structure of the
  archive, how to rename, orphan, pick up packages, how to do NMUs, how to
  manage bugs, when and where to upload etc.
  (see /usr/share/doc/developers-reference/developers-reference.html/index.html)
  </list>

  <p>The short descriptions that are given above only serve to introduce
  you to what each package does. Before continuing please thoroughly read
  the documentation of each program, at least the standard usage.
  It may seem like heavy going now, but later on you'll be <em>very</em>
  glad you read it.

  <p>Note: <package/debmake/ is a package that contains some programs that
  function similar to dh-make, but its specific use is <strong>not</strong>
  covered in this document, because it is <em>deprecated</em>. Please refer
  to <url name="the Debmake manual" id="http://www.debian.org/~jaldhar/";>
  for more information.

  <sect id="otherinfo">Other information

  <p>There are two types of packages you can make, source and binary.
  A source package contains code which you can compile into a program.
  A binary package contains just the finished program. Don't mix terms
  like source of the program and the source package of the program!
  Please read the other manuals if you need more details on terminology.

  <p>In Debian, the term `maintainer' is used for the person who makes
  packages, `upstream author' for the person that made the program, and
  `upstream maintainer' for the person who currently maintains that program,
  outside of Debian. Usually author and the upstream maintainer are the
  same person - and sometimes even the maintainer is the same person.
  If you made a program, and want it to get in Debian, feel free to submit
  your application to become a maintainer.

  <p>After you build your package (or while doing that), you will have
  to become an official Debian maintainer if you wish your program to get
  into the next distribution (if the program is useful, why not?).
  That process is explained in Developer's Reference. Please read it.

  <chapt id="first">First steps

  <sect id="choose">Choose your program

  <p>You have probably chosen the package you want to create. The first
  thing you need to do is check if the package is in the distribution already.
  If you use the `stable' distribution, maybe it's best that you go to the
  <url name="package search page" id="http://www.debian.org/distrib/packages";>.
  If you use <strong>current</strong> `unstable' distribution, check it out
  with these commands:
  <example>
  dpkg -s program
  dpkg -l '*program*'
  </example>

  <p>If the package already exists, well, install it! :-) If it happens to
  be orphaned -- if its maintainer is set to "Debian QA Group", you should
  be able to pick it up. Consult
  <url name="the list of orphaned packages" id="http://www.debian.org/devel/wnpp/orphaned";>
  and
  <url name="the list of packages up for adoption" id="http://www.debian.org/devel/wnpp/rfa_bypackage";>
  to verify that the package is indeed up for grabs.

  <p>If you are able to adopt the package, get the sources (with something
  like <tt/apt-get source packagename/) and examine them. This document
  unfortunately doesn't include comprehensive information about adopting
  packages. Thankfully you shouldn't have a hard time figuring out how the
  package works since someone has already done the initial set up for you.
  Keep reading, though, a lot of the advice below will still be applicable
  for your case.

  <p>If the package is new, and you decide you'd like to see it in Debian,
  proceed as follows:

  <list>
  <item>check if no one else is working on the package already at
  <url name="the list of packages being worked on" id="http://www.de.debian.org/devel/wnpp/being_packaged";>.
  If someone's already on it, contact them if you feel you need to.
  If not - find another interesting program that nobody maintains.
  </item>

  <item>program <strong>must</strong> have a license, if possible free as
  according to the <url name="Debian Free Software Guidelines" id="http://www.debian.org/social_contract#guidelines";>.
  If it doesn't conform to some of these rules but it can be distributed
  anyway, it could still can be included in the `contrib' or `non-free'
  sections. If you are unsure about where should it go, post the license
  text on <email/debian-legal@lists.debian.org/ and ask for advice.
  </item>

  <item>program certainly should <strong>not</strong> run setuid root, or
  even better - it shouldn't need to be setuid or setgid to anything.</item>

  <item>program should not be a daemon, or something that goes in */sbin
  directories, or open a port as root.</item>

  <item>program should result in binary executable form, libraries are
  harder to handle.</item>

  <item>it should be well documented, or and the code needs to be
  understandable (i.e. not obfuscated).</item>

  <item>you should contact program's author(s) to check if they agree
  with packaging it. It is important to be able to consult with author(s)
  about the program in case of any program specific problems, so don't
  try to package unmaintained pieces of software.</item>

  <item>and last but not the least, you must know that it works, and
  have it tried for some time.</item>
  </list>

  <p>Of course, these things are just safety measures, and intended to save
  you from raging users if you do something wrong in some setuid daemon...
  When you gain some more experience in packaging, you'll be able to do such
  packages, but even the experienced developers consult the debian-mentors
  mailing list when they are in doubt. And people there will gladly help.

  <p>For more help about these, check in Developer's Reference.

  <sect id="getit">Get the program, and try it out

  <p>So the first thing to do is to find and download the original package.
  I presume that you already have the source file that you picked up at
  the author's homepage. Sources for free Unix programs usually come in
  tar/gzip format, with extension .tar.gz, and usually contain the
  subdirectory called program-version and all the sources in it. If your
  program's source comes as some other sort of archive (for instance, the
  filename ends in ".Z" or ".zip"), unpack it with appropriate
  tools, or ask on the debian-mentors mailing list if you're not sure how to unpack it
  correctly (hint: issue `file archive.extension`).

  <p>As an example, I'll use program called `gentoo', an X GTK+ file
  manager. Note that the program is already packaged, and has changed
  substantially from the version while this text was first written.

  <p>Create a subdirectory under your home directory named 'debian' or 'deb'
  or anything you find appropriate (e.g. just ~/gentoo/ would do fine in
  this case). Place the downloaded archive in it, and uncompress it (with
  `tar xzf gentoo-0.9.12.tar.gz`). Make sure there are no errors, even some
  "irrelevant" ones, because there will most probably be problems unpacking
  on other people's systems, whose unpacking tools may or may not ignore
  those anomalies.

  <p>Now you have another subdirectory, called 'gentoo-0.9.12'. Change to
  that directory and <strong>thoroughly</strong> read the provided
  documentation. Usually there exist files named README*, INSTALL*, *.lsm
  or *.html. You must find instructions on how to correctly compile and
  install the program (most probably they'll assume you want to install to
  /usr/local/bin directory; you won't be doing that, but more on that later
  in <ref id="destdir">).

  <p>The process varies from program to program, but a lot of modern
  programs come with a `configure' script that configures the source under
  your system and makes sure that your system is in condition to compile it.
  After configuring with `./configure`, programs are usually compiled
  with `make`. Some of them support `make check`, to run included
  self-checks. Installation in destination directories is usually done with
  `make install`.
  
  <p>Now try to compile and run your program, to make sure it works properly
  and doesn't break something else while it's installing or running.

  <p>Also, you can usually run `make clean` (or better `make distclean`) to
  clean up the build directory. Sometimes there's even a `make uninstall`
  which can be used to remove all the installed files.

  <sect id="namever">Package name and version

  <p>You should start packaging with a completely clean (pristine) source
  directory, or simply with freshly unpacked sources.
  
  <p>For the package to be built correctly, you must make the program's
  original name lowercase (if it isn't already), and you should move the
  source directory to &lt;packagename&gt;-&lt;version&gt;.
  
  <p>If the program name consists of more than one word, contract them to one
  word, or make an abbreviation. For example, program "John's little editor
  for X" package would be named johnledx, or jle4x, or whatever you decide,
  as long as it's under some reasonable limit, e.g. 20 characters.

  <p>Also check for the exact version of the program (to be included in the
  package version). If that piece of software is not numbered with versions
  like X.Y.Z, but with some kind of date, feel free to use that date as the
  version number, prepended with a "0.0." (just in case upstream people one
  day decide to release a nice version like 1.0). So, if the release or
  snapshot date was 19th of December, 1998, you can use the version string
  of 0.0.19981219.

  <p>Some programs won't be numbered at all, in which case you
  should contact the upstream maintainer to see if they've got some other
  revision-tracking method.

  <sect id="dh_make">Initial "debianization"

  <p>Make sure you're in the program source directory, and issue this:

  <p><example>
  dh_make -e your.maintainer@address -f ../gentoo-0.9.12.tar.gz
  </example>

  <p>Of course, replace the string "your.maintainer@address" with your
  e-mail address for inclusion in the changelog entry and other files,
  and the filename with the name of your original source archive. See
  <manref name="dh_make" section="1"> for details.
 
  <p>Some information will come up. It will ask you what sort of package you
  want to create. Gentoo is a single binary package - it creates only one
  binary, and thus one .deb file - so we will select the first option, with
  the `s' key, check the information on the screen and confirm with pressing
  &lt;enter&gt;.

  <p>Once again, as a new maintainer you are discouraged from creating
  packages with multiple binary packages, or libraries. It's not too hard,
  but it does require a bit more knowledge,
  so we won't describe all of it here.

  <p>Please note that you should run dh_make <strong>only once</strong>,
  and that it won't behave correctly if you run it again in the same,
  already "debianized", directory. That also means that you will use a
  different method to release a new revision or a new version of your
  package in the future. Read more about that later in <ref id="update">

  ====== End ======

--
   ＃ わたしのおうちは浜松市、アカウミガメもやってくる
    <kgh12351@xxxxxxxxxxx> : Taketoshi Sano (佐野　武俊)