perlipc - Perl interprocess communication (signals, fifos, pipes, safe subprocesses, sockets, and semaphores) perlipc - Perl interprocess communication (signals, fifos, pipes, safe subprocesses, sockets, and semaphores) perlipc - Perl のプロセス間通信 (シグナル, fifo, パイプ, 安全な副プロセス, ソケット, セマフォ) DESCRIPTION The basic IPC facilities of Perl are built out of the good old Unix signals, named pipes, pipe opens, the Berkeley socket routines, and SysV IPC calls. Each is used in slightly different situations. Perl の基本的な IPC 機能は、古きよき UNIX のシグナル、名前付きパイプ、 パイプ、Berkeley ソケットルーチン、 SysV IPC コールから構成されています。 これら各々ははっきりと異なる状況で使われます。 Signals (シグナル) Perl uses a simple signal handling model: the %SIG hash contains names or references of user-installed signal handlers. These handlers will be called with an argument which is the name of the signal that triggered it. A signal may be generated intentionally from a particular keyboard sequence like control-C or control-Z, sent to you from another process, or triggered automatically by the kernel when special events transpire, like a child process exiting, your process running out of stack space, or hitting file size limit. Perl は単純なシグナルハンドリングモデルを使っています: %SIG という ハッシュは、ユーザーがインストールしたシグナルハンドラの名前、 もしくはハンドラに対するリファレンスを保持します。 これらのハンドラは、起動されたシグナルの名前を引数として呼び出されます。 シグナルは control-C や control-Z のような特定のキーボードシーケンスで 意識的に生成することもできますし、他のプロセスがシグナルを 送ることもあります。 あるいは子プロセスが終了したとか、プロセスがスタックを使いきった、 ファイルサイズ制限に引っ掛かったといった特殊なイベントが発生したときに、 カーネルが自動的にシグナルを発生させることもあります。 For example, to trap an interrupt signal, set up a handler like this: 例えば割り込みシグナル(interrupt signal)をトラップするには、 以下の例のようにハンドラを設定します: Prior to Perl 5.7.3 it was necessary to do as little as you possibly could in your handler; notice how all we do is set a global variable and then raise an exception. That's because on most systems, libraries are not re-entrant; particularly, memory allocation and I/O routines are not. That meant that doing nearly anything in your handler could in theory trigger a memory fault and subsequent core dump - see /Deferred Signals (Safe Signals) below. Perl 5.7.3 以前では、自分のハンドラの中を使うことができます。 私たちが認識していることは、グローバル変数に設定した後で例外を 引き起こすということだけであることに注意してください。 これは、ほとんどのシステム上ではライブラリ、とくにメモリ割り付けや 入出力に関するものは再入可能ではないためです。 これは、あなたのハンドラ内のほとんど あらゆること が理論的には メモリフォールトやそれに続くコアダンブを引き起こす可能性が あるということです - 以下の /Deferred Signals (Safe Signals) を 参照してください。 The names of the signals are the ones listed out by kill -l on your system, or you can retrieve them from the Config module. Set up an @signame list indexed by number to get the name and a %signo table indexed by name to get the number: あなたの使っているシステムにおけるシグナルの名称は kill -l に よってリストアップされます。 あるいはコンフィグモジュールから取得することもできます。 名前を得るための番号によって添え字づけされる @signame というリストと 番号を得るための名前によって添え字づけされる %signo というテーブルを セットアップします。 So to check whether signal 17 and SIGALRM were the same, do just this: ですから、17 番のシグナルと SIGALRM が同一であるかどうかは以下のようにして チェックできます: You may also choose to assign the strings 'IGNORE' or 'DEFAULT' as the handler, in which case Perl will try to discard the signal or do the default thing. ハンドラとして 'IGNORE' や 'DEFAULT' といった文字列を 代入することも選択できます。 これらのハンドラは、perl がシグナルを破棄させるようにしたり デフォルトの動作を行うようにさせるものです。 On most Unix platforms, the CHLD (sometimes also known as CLD) signal has special behavior with respect to a value of 'IGNORE'. Setting $SIG{CHLD} to 'IGNORE' on such a platform has the effect of not creating zombie processes when the parent process fails to wait() on its child processes (i.e. child processes are automatically reaped). Calling wait() with $SIG{CHLD} set to 'IGNORE' usually returns -1 on such platforms. ほとんどの UNIX プラットフォームでは、CHLD(CLD の場合もあり) シグナルは 'IGNORE' の値に対応するような特別な振る舞いをします。 そのようなプラットフォームでは 'IGNORE' に $SIG{CHLD} を 設定することによって、親プロセスが wait() に失敗したようなときに ゾンビプロセスができることを防ぎます(子プロセスは自動的に 刈り取られます)。 $SIG{CHLD} を 'IGNORE' を設定して wait() を呼び出すことによって、 このようなプラットフォームでは -1 が通常返されます。 Some signals can be neither trapped nor ignored, such as the KILL and STOP (but not the TSTP) signals. One strategy for temporarily ignoring signals is to use a local() statement, which will be automatically restored once your block is exited. (Remember that local() values are "inherited" by functions called from within that block.) KILL シグナルや STOP シグナル(TSTP ではない)のような幾つかのシグナルは、 トラップすることも無視することもできません。 一時的にシグナルを無視するための戦略は local() 文を使うというものです。 これはその local() 文を囲むブロックから出たときに、自動的に元の状態に 復帰します。 (local() による値は ブロックの内側から呼び出された関数に “引き継がれる”(inherited) ことを忘れないでください)。 Sending a signal to a negative process ID means that you send the signal to the entire Unix process-group. This code sends a hang-up signal to all processes in the current process group (and sets $SIG{HUP} to IGNORE so it doesn't kill itself): 負のプロセス ID に対してシグナルを送ることは、UNIX プロセスグループ 全体にシグナルを送ることになります。 以下のコードは、カレントのプロセスグループに属する全てのプロセスに hang-up シグナルを送出します(そして、$SIG{HUP} に IGNORE を設定するので、 自分自身を kill することはありません)。 -$$; # snazzy writing of: kill('HUP', -$$) } ]]> Another interesting signal to send is signal number zero. This doesn't actually affect a child process, but instead checks whether it's alive or has changed its UID. この他の興味深いシグナルは、シグナル番号 0 です。 これは実際には子プロセスに影響を及ぼすことはありませんが、UID が 生きているのか、あるいは変更されたのかのチェックを行います。 $kid_pid) { warn "something wicked happened to $kid_pid"; } ]]> When directed at a process whose UID is not identical to that of the sending process, signal number zero may fail because you lack permission to send the signal, even though the process is alive. You may be able to determine the cause of failure using %!. 送り先のプロセスの UID が、送り元と同じではない場合、たとえプロセスが 生きていても、シグナルを送る権限がないので、シグナル番号 0 は失敗します。 失敗の原因は、%! を使って決定できます。 $pid or $!{EPERM}) { warn "$pid looks dead"; } ]]> You might also want to employ anonymous functions for simple signal handlers: 単純なシグナルハンドラには無名関数を使いたくなるかもしれません: But that will be problematic for the more complicated handlers that need to reinstall themselves. Because Perl's signal mechanism is currently based on the signal(3) function from the C library, you may sometimes be so unfortunate as to run on systems where that function is "broken", that is, it behaves in the old unreliable SysV way rather than the newer, more reasonable BSD and POSIX fashion. So you'll see defensive people writing signal handlers like this: しかしこれは、自分自身を再インストールする必要があるような、もっと複雑な ハンドラに対しては問題になる可能性があります。 Perl のシグナル機構は現在のところ C ライブラリの signal(3) 関数に基づいた ものなので、関数が“ぶっ壊れた”ような、つまり、より新しくて信頼性のある BSD 形式や POSIX 形式ではなく古くて信用できない SysV 方式の振る舞いを するようなものシステムで実行するような不運な立場になるかもしれません。 そのため、以下のようにシグナルハンドラを書いて人を守っているものを 見るでしょう: or better still: あるいはもっとましなように: 0) { $Kid_Status{$child} = $?; } $SIG{CHLD} = \&REAPER; # still loathe sysV } $SIG{CHLD} = \&REAPER; # do something that forks... ]]> Signal handling is also used for timeouts in Unix, While safely protected within an eval{} block, you set a signal handler to trap alarm signals and then schedule to have one delivered to you in some number of seconds. Then try your blocking operation, clearing the alarm when it's done but not before you've exited your eval{} block. If it goes off, you'll use die() to jump out of the block, much as you might using longjmp() or throw() in other languages. UNIX では、シグナルハンドラはタイムアウトのためにも使われます。 eval{} ブロックの中では安全に保護されいる間に、alarm シグナルを トラップするためにシグナルハンドラを設定して、その後で解放される 秒数をスケジューリングします。 それからブロッキング操作を試して、 それが完了したら eval{} ブロックを抜ける前に alarm をクリアーします。 設定した時間が経ってしまった場合には、他の言語における longjmp() や throw() を使ったときと同じようにブロックを抜けるために die() を 使います。 Here's an example: 例を挙げましょう: If the operation being timed out is system() or qx(), this technique is liable to generate zombies. If this matters to you, you'll need to do your own fork() and exec(), and kill the errant child process. 時間切れを起こした操作が system() か qx() なら、このテクニックはゾンビを 生成する傾向があります。 もしそれが問題なら、自力で fork() と exec() を行って、エラーの起きた 子プロセスを kill する必要があるでしょう。 For more complex signal handling, you might see the standard POSIX module. Lamentably, this is almost entirely undocumented, but the t/lib/posix.t file from the Perl source distribution has some examples in it. より複雑なシグナル処理のためには、標準の POSIX モジュールを確かめると よいかもしれません。 嘆かわしいことにこれはほとんどアンドキュメントな状態ですが、Perl の ソース配布キットにある t/lib/posix.t というファイルには幾つかの サンプルがあります。 Handling the SIGHUP Signal in Daemons (デーモンで SIGHUP シグナルを扱う) A process that usually starts when the system boots and shuts down when the system is shut down is called a daemon (Disk And Execution MONitor). If a daemon process has a configuration file which is modified after the process has been started, there should be a way to tell that process to re-read its configuration file, without stopping the process. Many daemons provide this mechanism using the SIGHUP signal handler. When you want to tell the daemon to re-read the file you simply send it the SIGHUP signal. 普通システムブート時に起動し、システムシャットダウン時に終了するプロセスの ことをデーモン(daemon: Disk And Execution MONitor)と呼びます。 もしデーモンプロセスに設定ファイルがあり、それがプロセスが開始してから 変更された場合、プロセスを止めることなく、プロセスに設定ファイルを 再読み込みすることを知らせる方法があるべきです。 多くのデーモンはこの機構を SIGHUP シグナルハンドラを使って 提供しています。 デーモンにファイルを再読み込みしてほしい場合、単にデーモンに SIGHUP シグナルを送ります。 Not all platforms automatically reinstall their (native) signal handlers after a signal delivery. This means that the handler works only the first time the signal is sent. The solution to this problem is to use POSIX signal handlers if available, their behaviour is well-defined. 全てのプラットフォームにおいて、シグナル配送の後自動的に(ネイティブな) シグナルハンドラを再設定するわけではありません。 これは、ハンドラは最初にシグナルが送られたときにのみ動作することを 意味します。 この問題の解決策は、もし利用可能であれば、振る舞いが明確である POSIX シグナルハンドラを使うことです。 The following example implements a simple daemon, which restarts itself every time the SIGHUP signal is received. The actual code is located in the subroutine code(), which simply prints some debug info to show that it works and should be replaced with the real code. 以下の例は、SIGHUP を受け取る毎に再起動するという単純なデーモンを 実装しています。 実際のコードはサブルーチン code() に置かれていて、どのように動作するかを 示し、実際のコードと置き換えられるように、単にデバッグ情報を出力します。 new(); my $action = POSIX::SigAction->new('sigHUP_handler', $sigset, &POSIX::SA_NODEFER); POSIX::sigaction(&POSIX::SIGHUP, $action); ]]> Named Pipes (名前付きパイプ) A named pipe (often referred to as a FIFO) is an old Unix IPC mechanism for processes communicating on the same machine. It works just like a regular, connected anonymous pipes, except that the processes rendezvous using a filename and don't have to be related. 名前付きパイプ(しばしば FIFO として参照されます)は、同じマシン上での プロセス間通信のための古い UNIX IPC 機構です。 これは通常の無名パイプの接続と同様に動作しますが、ファイル名を使って プロセスのランデブーが行われ、関連づける必要がないという点が異なります。 To create a named pipe, use the POSIX::mkfifo() function. 名前付きパイプを生成するには、POSIX::mkfifo() 関数を使ってください。 You can also use the Unix command mknod(1) or on some systems, mkfifo(1). These may not be in your normal path. 一部のシステムでは Unix コマンド mknod(1) か、システムによっては mkfifo(1) を使えます。 これらはあなたの通常パス(normal path)に置くことはできません。 A fifo is convenient when you want to connect a process to an unrelated one. When you open a fifo, the program will block until there's something on the other end. fifo は、あるプロセスをそれとは関係ない別のプロセスに接続したいときに 便利です。 fifo をオープンしたとき、プログラムはもう一方の端点に何かが 置かれるまでブロックされます。 For example, let's say you'd like to have your .signature file be a named pipe that has a Perl program on the other end. Now every time any program (like a mailer, news reader, finger program, etc.) tries to read from that file, the reading program will block and your program will supply the new signature. We'll use the pipe-checking file test -p to find out whether anyone (or anything) has accidentally removed our fifo. たとえば、.signature というファイルを、もう一方の端点に Perl プログラムが置かれている名前付きパイプに接続したいとしましょう。 このとき、任意のプログラムが任意の時点で(メイラー、ニューズリーダー、 finger プログラムなどのように)そのファイルを読み出そうとしますから、 読み出しプログラムはブロックをしてからあなたのプログラムが新しい シグネチャーを提供するようにしなければなりません。 誰か(もしくは何か)が間違って私たちのfifoを削除したりしないかどうかを 監視するために -p という pipe-cheching ファイルテストを使用します。 $FIFO") || die "can't write $FIFO: $!"; print FIFO "John Smith (smith\@host.org)\n", `fortune -s`; close FIFO; sleep 2; # to avoid dup signals } ]]> Deferred Signals (Safe Signals) (保留シグナル(安全なシグナル)) In Perls before Perl 5.7.3 by installing Perl code to deal with signals, you were exposing yourself to danger from two things. First, few system library functions are re-entrant. If the signal interrupts while Perl is executing one function (like malloc(3) or printf(3)), and your signal handler then calls the same function again, you could get unpredictable behavior--often, a core dump. Second, Perl isn't itself re-entrant at the lowest levels. If the signal interrupts Perl while Perl is changing its own internal data structures, similarly unpredictable behaviour may result. Perl 5.7.3 以前の Perl では、シグナルを取り扱う Perl プログラムを インストールすることによって、あなたは二つの危険性に直面することに なりました。 第一に、再入可能なライブラリ関数を備えたシステムは数少ないこと。 Perl がある関数(malloc(3) や printf(3) など)を実行中にシグナル割り込みが あったとすると、あなたのシグナルハンドラは同じ関数を 再度呼び出し、結果として予測のつかない動作になる可能性があります。 第二に、Perl 自身も最低レベルにおいては再入可能に なっていないということです。 Perl が自分の内部構造を操作しているときにシグナル割り込みが あったとすると、これもまた予測のつかない動作になるでしょう。 There were two things you could do, knowing this: be paranoid or be pragmatic. The paranoid approach was to do as little as possible in your signal handler. Set an existing integer variable that already has a value, and return. This doesn't help you if you're in a slow system call, which will just restart. That means you have to die to longjmp(3) out of the handler. Even this is a little cavalier for the true paranoiac, who avoids die in a handler because the system is out to get you. The pragmatic approach was to say "I know the risks, but prefer the convenience", and to do anything you wanted in your signal handler, and be prepared to clean up core dumps now and again. あなたの取りうる手段が二つありました: 偏執狂的になるか現実的になるかです。 偏執狂的アプローチは、あなたのシグナルハンドラの中でできるだけ 少ないことを行うというものでした。 既に値をもって存在している整数変数に値を設定してリターンします。 これは単にリスタートするような遅いシステムコールの中にいるときには 助けになりません。 これはつまり、ハンドラの外に longjmp(3) するには die する必要が あるということです。 これは本当の偏執狂というのにはちょっとおおげさですが、ハンドラ中で die を排除します。 現実的なアプローチは「リスクがあるのは分かってるけどさ、便利なら いいじゃない」というもので、シグナルハンドラ中で行いたいことを 全て行い、コアダンプを掃除する準備をしてから再度行うというものでした。 In Perl 5.7.3 and later to avoid these problems signals are "deferred"-- that is when the signal is delivered to the process by the system (to the C code that implements Perl) a flag is set, and the handler returns immediately. Then at strategic "safe" points in the Perl interpreter (e.g. when it is about to execute a new opcode) the flags are checked and the Perl level handler from %SIG is executed. The "deferred" scheme allows much more flexibility in the coding of signal handler as we know Perl interpreter is in a safe state, and that we are not in a system library function when the handler is called. However the implementation does differ from previous Perls in the following ways: Perl 5.7.3 以降では、この問題を避けるために、シグナルは「保留」されます -- これは、システムによってシグナルが (Perl を実装している C コードに) 配送されると、フラグをセットして、ハンドラは直ちに返ります。 それから、Perl インタプリタの戦略的に「安全な」地点 (例えば、新しいオペコードを実行しようとしている時点) で、 フラグをチェックして、%SIG の Perl レベルハンドラを実行します。 「保留」スキームは、Perl インタプリタが安全な状態にあって、ハンドラが 呼び出されたときにシステムライブラリの中ではないことが分かっているので、 シグナルハンドラのコーディングが遥かに柔軟になります。 しかし、実装は以下の方向で以前の Perl と異なります: Long-running opcodes (長時間実行されるオペコード) As the Perl interpreter only looks at the signal flags when it is about to execute a new opcode, a signal that arrives during a long-running opcode (e.g. a regular expression operation on a very large string) will not be seen until the current opcode completes. Perl インタプリタは、もし長時間実行されるオペコード (例えばとても長い文字列での正規表現操作)の途中でシグナルが 到着すると、新しいオペコードを実行しようとする時にのみシグナルフラグを 見るので、シグナルは現在のオペコードが完了するまで現れません。 N.B. If a signal of any given type fires multiple times during an opcode (such as from a fine-grained timer), the handler for that signal will only be called once after the opcode completes, and all the other instances will be discarded. Furthermore, if your system's signal queue gets flooded to the point that there are signals that have been raised but not yet caught (and thus not deferred) at the time an opcode completes, those signals may well be caught and deferred during subsequent opcodes, with sometimes surprising results. For example, you may see alarms delivered even after calling alarm(0) as the latter stops the raising of alarms but does not cancel the delivery of alarms raised but not yet caught. Do not depend on the behaviors described in this paragraph as they are side effects of the current implementation and may change in future versions of Perl. 注意: もしどのような種類のシグナルでも(例えば高精度のタイマーから) 1 つのオペコードの間に複数回発生した場合、そのシグナルのハンドラは オペコードの完了後 1 度しか呼び出されず、その他の実体は破棄されます。 さらに、システムのシグナルキューがあふれたために あるオペコードが完了時に、発生したけれどもまだ捕捉されていない (従ってまだ保留されていない)シグナルがあると これらのシグナルが引き続くオペコードの間捕捉および保留され、時々 驚くべき結果となることがあります。 例えば、alarm(0) はアラームの発生を止めますが、 発生したけれどもまだ捕捉していないアラームの配達がキャンセルしないので、 alarm(0) を呼び出した後にもアラームが配送されることがあります。 これは現在の実装の副作用であり、将来のバージョンの Perl では 変更されるかもしれないので、この段落に記述された振る舞いに依存しては いけません。 Interrupting IO (I/O 割り込み) When a signal is delivered (e.g. INT control-C) the operating system breaks into IO operations like read (used to implement Perls <> operator). On older Perls the handler was called immediately (and as read is not "unsafe" this worked well). With the "deferred" scheme the handler is not called immediately, and if Perl is using system's stdio library that library may re-start the read without returning to Perl and giving it a chance to call the %SIG handler. If this happens on your system the solution is to use :perlio layer to do IO - at least on those handles which you want to be able to break into with signals. (The :perlio layer checks the signal flags and calls %SIG handlers before resuming IO operation.) (INT control-C などで) シグナルが配送されると、 OS は (Perl <> 演算子の実装で使われている) read のような I/O 操作を中断します。 古い Perl ではハンドラをすぐに呼び出します (そして read はうまく動くので「安全ではない」ことはありません)。 「保留」スキームではハンドラはすぐに呼び出されず、 もし Perl がシステムの stdio ライブラリを使っていると、ライブラリは Perl に返って %SIG ハンドラを呼び出しする機会なしに read を 再起動します。 もしこれが起きた場合、解決法は、I/O を行うときにー - 少なくともシグナルで中断できるようにしたいハンドルで - :perlio 層を使うことです (:perlio 層はシグナルフラグをチェックして、I/O 操作を続行する前に %SIG ハンドラを呼び出します。) Note that the default in Perl 5.7.3 and later is to automatically use the :perlio layer. Perl 5.7.3 以降ではデフォルトでは自動的に :perlio 層が使われることに 注意してください。 Note that some networking library functions like gethostbyname() are known to have their own implementations of timeouts which may conflict with your timeouts. If you are having problems with such functions, you can try using the POSIX sigaction() function, which bypasses the Perl safe signals (note that this means subjecting yourself to possible memory corruption, as described above). Instead of setting $SIG{ALRM}: gethostbyname() のようなネットワークライブラリ関数は独自のタイムアウト 実装を持っていることが知られているので、あなたのタイムアウトと 競合するかもしれないことに注意してください。 もしこのような関数で問題が起きた場合は、Perl の安全なシグナルを回避する POSIX sigaction() 関数を試すことができます (これは上述の、メモリ破壊の可能性があるということに注意してください)。 $SIG{ALRM} をセットする代わりに: try something like the following: 以下のようなことを試してみてください: new(sub { die "alarm" })) or die "Error setting SIGALRM handler: $!\n"; ]]> Another way to disable the safe signal behavior locally is to use the Perl::Unsafe::Signals module from CPAN (which will affect all signals). 安全なシグナルの振る舞いを局所的に無効にするもう一つの方法は CPAN の Perl::Unsafe::Signals モジュールを使うことです (全てのシグナルに影響を与えます)。 Restartable system calls (再起動可能なシステムコール) On systems that supported it, older versions of Perl used the SA_RESTART flag when installing %SIG handlers. This meant that restartable system calls would continue rather than returning when a signal arrived. In order to deliver deferred signals promptly, Perl 5.7.3 and later do not use SA_RESTART. Consequently, restartable system calls can fail (with $! set to EINTR) in places where they previously would have succeeded. これに対応しているシステムでは、より古いバージョンの Perl では %SIG ハンドラを設定するときに SA_RESTART フラグを使います。 これは、再起動可能なシステムコールではシグナルが配送されたときに 戻るのではなく続行することを意味します。 保留シグナルを素早く配送するために、 Perl 5.7.3 以降では SA_RESTART を 使っていません。 結果として、再起動可能なシステムコールは、いままで成功していたところでも ($! に EINTR をセットして) 失敗することがあります。 Note that the default :perlio layer will retry read, write and close as described above and that interrupted wait and waitpid calls will always be retried. デフォルトの :perlio 層では read, write, close は上述したように 再試行し、中断された wait と waitpid の呼び出しは常に 再試行されることに注意してください。 Signals as "faults" (「障害」としてのシグナル) Certain signals, e.g. SEGV, ILL, and BUS, are generated as a result of virtual memory or other "faults". These are normally fatal and there is little a Perl-level handler can do with them, so Perl now delivers them immediately rather than attempting to defer them. SEGV, ILL, BUS のようなシグナルは、仮想メモリやその他の「障害」の結果として 生成されます。 これらは普通致命的で、Perl-レベルのハンドラができることはほとんど ないので、これらを保留しようとせず、直ちに配送します。 Signals triggered by operating system state (OS の状態によって発生するシグナル) On some operating systems certain signal handlers are supposed to "do something" before returning. One example can be CHLD or CLD which indicates a child process has completed. On some operating systems the signal handler is expected to wait for the completed child process. On such systems the deferred signal scheme will not work for those signals (it does not do the wait). Again the failure will look like a loop as the operating system will re-issue the signal as there are un-waited-for completed child processes. OS によっては、ある種のシグナルハンドラは返る前に「何かをする」ことに なっているものもあります。 1 つの例としては、CHLD や CLD は子プロセスが完了したことを示しています。 OS によっては、シグナルハンドルは完了した子プロセスのために wait することを想定されているものもあります。 このようなシステムでは保留シグナルスキームはこれらのシグナルでは 動作しません(wait しません)。 再び、問題は、wait していない完了した子プロセスがあるかのようにシグナルが 再び発生することでループのように見えます。 If you want the old signal behaviour back regardless of possible memory corruption, set the environment variable PERL_SIGNALS to "unsafe" (a new feature since Perl 5.8.1). もし、メモリ破壊の可能性にもかかわらず、古いシグナルの振る舞いが ほしいなら、環境変数 PERL_SIGNALS を "unsafe" に設定してください (Perl 5.8.1 からの新機能です)。 Using open() for IPC (IPC のために open() を使う) Perl's basic open() statement can also be used for unidirectional interprocess communication by either appending or prepending a pipe symbol to the second argument to open(). Here's how to start something up in a child process you intend to write to: Perlの open() 文は、その第二引数でパイプシンボルを前置するか末尾に 付加することによって、一方向のプロセス間通信のために使うことができます。 以下の例は、書き込みを行いたい子プロセスを起動させるやり方です: /dev/null") || die "can't fork: $!"; local $SIG{PIPE} = sub { die "spooler pipe broke" }; print SPOOLER "stuff\n"; close SPOOLER || die "bad spool: $! $?"; ]]> And here's how to start up a child process you intend to read from: そして以下の例はそこから読み込みを行いたい子プロセスを起動する方法です: &1 |") || die "can't fork: $!"; while () { next if /^(tcp|udp)/; print; } close STATUS || die "bad netstat: $! $?"; ]]> If one can be sure that a particular program is a Perl script that is expecting filenames in @ARGV, the clever programmer can write something like this: 特定のプログラムの一つが @ARGV にあるファイル名を期待している Perl スクリプトであっていいのなら、賢いプログラマは以下のように 書くこともできます: and irrespective of which shell it's called from, the Perl program will read from the file f1, the process cmd1, standard input (tmpfile in this case), the f2 file, the cmd2 command, and finally the f3 file. Pretty nifty, eh? そしてそれを呼んだシェルには関係なく、この Perl プログラムは f1 という ファイル、cmd1 というプロセス、標準入力(この例では tmpfile)、 f2 というファイル、cmd2 というコマンド、f3 というファイルから 読み込みを行います。 すごくいいよね? You might notice that you could use backticks for much the same effect as opening a pipe for reading: 読み込みのためのパイプを開くために、逆クォートを使って同じことが できることに気がつくかもしれません: &1`; die "bad netstat" if $?; ]]> While this is true on the surface, it's much more efficient to process the file one line or record at a time because then you don't have to read the whole thing into memory at once. It also gives you finer control of the whole process, letting you to kill off the child process early if you'd like. その推測は表面的には正しいことのように見えるかも知れませんが、一度に メモリにすべてを読み込む必要がないので、一度にファイルの一行や 一レコードを処理するには(最初の例のほうが)より効率的なのです。 同様にプロセス全体の制御を与えるので、あなたが望めば早い時期に 子プロセスを kill することができます。 Be careful to check both the open() and the close() return values. If you're writing to a pipe, you should also trap SIGPIPE. Otherwise, think of what happens when you start up a pipe to a command that doesn't exist: the open() will in all likelihood succeed (it only reflects the fork()'s success), but then your output will fail--spectacularly. Perl can't know whether the command worked because your command is actually running in a separate process whose exec() might have failed. Therefore, while readers of bogus commands return just a quick end of file, writers to bogus command will trigger a signal they'd better be prepared to handle. Consider: open() と close() の戻り値をチェックするときは注意してください。 パイプに対して 書き込み をしたのなら、SIGPIPE をトラップすべきです。 そうしなければ、存在しないコマンドに対するパイプを起動したときに 起こることについて考え込むことになるでしょう: open() はほとんどの 場合成功すると見込まれるでしょうが(これは fork() の成功だけを 反映します)、あなたの出力はその後で壮観に(spectacularly)失敗するでしょう。 コマンドは、実際には exec() が失敗している別のプロセスで 実行されているので、Perl はコマンドがうまく動いているかどうかを 知ることはできません。 したがって、偽のコマンド(bugus command)の読み手はすぐに end of file を 受け取り、偽のコマンドに対する書き手は事前に取り扱っておくべき シグナルを発生させるでしょう。 以下の例を考えてみましょう: That won't blow up until the close, and it will blow up with a SIGPIPE. To catch it, you could use this: これはクローズするまで爆発せず、爆発すると SIGPIPE を発生させます。 これを捕らえるには、以下のようにします: Filehandles (ファイルハンドル) Both the main process and any child processes it forks share the same STDIN, STDOUT, and STDERR filehandles. If both processes try to access them at once, strange things can happen. You may also want to close or reopen the filehandles for the child. You can get around this by opening your pipe with open(), but on some systems this means that the child process cannot outlive the parent. メインプロセスと子プロセスで同じファイルハンドル STDIN, STDOUT, STDERR を共有します。 両方のプロセスが同時にそれらのハンドルにアクセスしようとした場合、 おかしな事が発生する可能性があります。 あなたは子プロセスのためにファイルハンドルのクローズと再オープンにしたいと 考えるかもしれません。 これは、open() を使ってパイプをオープンすることによって対処することが できますが、一部のシステムにおいては子プロセスはその親プロセスよりも 長生きすることはできません。 Background Processes (バックグラウンドプロセス) You can run a command in the background with: 以下のようにしてコマンドをバックグラウンドで実行することができます: The command's STDOUT and STDERR (and possibly STDIN, depending on your shell) will be the same as the parent's. You won't need to catch SIGCHLD because of the double-fork taking place (see below for more details). コマンドの STDOUT と STDERR (とあなたの使うシェルによっては STDIN も)は その親プロセスのものと同一になります。 double-fork の実行によって、SIGCHLD を捕捉する必要はありません (詳しくは後述します)。 Complete Dissociation of Child from Parent (子の親からの完全な分離) In some cases (starting server processes, for instance) you'll want to completely dissociate the child process from the parent. This is often called daemonization. A well behaved daemon will also chdir() to the root directory (so it doesn't prevent unmounting the filesystem containing the directory from which it was launched) and redirect its standard file descriptors from and to /dev/null (so that random output doesn't wind up on the user's terminal). 一部の場合(例えばサーバープロセスのスタート)、親プロセスと子プロセスを 完全に無関係のものにしたいことがあるでしょう。 これはしばしばデーモン化と呼ばれます。 礼儀正しいデーモンはルートディレクトリに chdir() (そのため実行ファイルの あったディレクトリを含むファイルシステムのアンマウントを邪魔することが ありません)し、その標準ファイル記述子を /fdev/null に リダイレクトします。 /dev/null' or die "Can't write to /dev/null: $!"; defined(my $pid = fork) or die "Can't fork: $!"; exit if $pid; setsid or die "Can't start a new session: $!"; open STDERR, '>&STDOUT' or die "Can't dup stdout: $!"; } ]]> The fork() has to come before the setsid() to ensure that you aren't a process group leader (the setsid() will fail if you are). If your system doesn't have the setsid() function, open /dev/tty and use the TIOCNOTTY ioctl() on it instead. See tty(4) for details. fork() はプロセスグループリーダー(もしそうなら setsid() は 失敗するでしょう)でないことを保証するために setsid() の前になければなりません。 あなたの使っているシステムが sesid() 関数を持っていないのであれば、 /dev/tty をオープンして TIONCNOTTY ioctl() を代わりに使います。 詳しくは tty(4) を参照してください。 Non-Unix users should check their Your_OS::Process module for other solutions. 非 UNIX ユーザーはあなたの OS の Process モジュールをチェックして 他の解決策を探しましょう。 Safe Pipe Opens (安全なパイプオープン) Another interesting approach to IPC is making your single program go multiprocess and communicate between (or even amongst) yourselves. The open() function will accept a file argument of either "-|" or "|-" to do a very interesting thing: it forks a child connected to the filehandle you've opened. The child is running the same program as the parent. This is useful for safely opening a file when running under an assumed UID or GID, for example. If you open a pipe to minus, you can write to the filehandle you opened and your kid will find it in his STDIN. If you open a pipe from minus, you can read from the filehandle you opened whatever your kid writes to his STDOUT. もう一つの、IPC のための興味深いアプローチはマルチプロセスになって それぞれの間で通信を行う単一のプログラムを作るというものです。 open() 関数は "-|" や "|-" といったファイル引数を非常に おもしろいことを行うために受け付けます: これはあなたがオープンした ファイルハンドのための子プロセスをfork()するのです。 その子プロセスは親プロセスと同じプログラムを実行します。 これはたとえば、仮定された UID や GID のもとで実行する際に安全にファイルを オープンするのに便利です。 マイナスに対するパイプをオープンすると、あなたはオープンした ファイルハンドルに書き込みができ、子プロセスはそれを自分の STDIN に 見いだします。 マイナス からの パイプをオープンした場合には、子プロセスがその STDOUT に書き出したものがオープンしたファイルハンドルから 読みだしすることができるのです。 6; sleep 10; } } until defined $pid; ]]> /safe/file") || die "can't open /safe/file: $!"; while () { print FILE; # child's STDIN is parent's KID } exit; # don't forget this } ]]> Another common use for this construct is when you need to execute something without the shell's interference. With system(), it's straightforward, but you can't use a pipe open or backticks safely. That's because there's no way to stop the shell from getting its hands on your arguments. Instead, use lower-level control to call exec() directly. このやり方を行うもう一つの一般的な例は、シェルのインターフェース抜きで 何かを実行する必要があるときでしょう。 system() を使うとそれは直接的なものですが、パイプのオープンや バッククォートを安全に使うことができません。 これはシェルがあなたの引数を触るのを止める方法がないからです。 代わりに、exec() を直接呼び出す低レベルな制御を使います。 Here's a safe backtick or pipe open for read: 以下の例は、読み込み用の安全なバッククォートやパイプオープンのものです: ) { # do something interesting } close(KID_TO_READ) || warn "kid exited $?"; ]]> And here's a safe pipe open for writing: そして以下の例は、書き込み用の安全なバッククォートや パイプオープンのものです: Since Perl 5.8.0, you can also use the list form of open for pipes : the syntax Perl 5.8.0 から パイプのために open のリスト形式を使えます; 以下のような文法で: forks the ps(1) command (without spawning a shell, as there are more than three arguments to open()), and reads its standard output via the KID_PS filehandle. The corresponding syntax to write to command pipes (with "|-" in place of "-|") is also implemented. ps(1) コマンドを fork し(3 以上の引数の open() のようにシェルを 起動することなく)、KID_PS ファイルハンドル経由で標準出力を読み込みます。 コマンドパイプに書き込むための対応する文法 ("-|" の代わりに "|-") も実装されています。 Note that these operations are full Unix forks, which means they may not be correctly implemented on alien systems. Additionally, these are not true multithreading. If you'd like to learn more about threading, see the modules file mentioned below in the SEE ALSO section. これらの操作は UNIX の fork でいっぱいで、その fork が他のシステムでは 適切に実装されていない可能性があるのだということに注意してください。 それに加えて、これらのやり方は本当のマルチスレッドではありません。 スレッドについてより学びたいのであれば、後述する SEE ALSO の章で 言及されている modules ファイルを参照してください。 Bidirectional Communication with Another Process (他のプロセスとの双方向通信) While this works reasonably well for unidirectional communication, what about bidirectional communication? The obvious thing you'd like to do doesn't actually work: これは、片方向通信に対してうまく働きます。 では双方向通信は? あなたがやりたいだろうとまず考えることは、実際にはうまくいきません: and if you forget to use the use warnings pragma or the -w flag, then you'll miss out entirely on the diagnostic message: この状態で use warnings プラグマか -w フラグを使うのを忘れてしまうと、 以下のような診断メッセージを得る機会を逃すことになるでしょう。 If you really want to, you can use the standard open2() library function to catch both ends. There's also an open3() for tridirectional I/O so you can also catch your child's STDERR, but doing so would then require an awkward select() loop and wouldn't allow you to use normal Perl input operations. 本当にこういったことをしたいのなら、標準の open2() というライブラリ関数を 使うことで、パイプの両方の端点を得ることができます。 三方向(tridirectional)の入出力のための open3() もあるので、子プロセスの STDERR を捕捉することもできるのですが、そのためには 不格好な select() ループが必要となり、Perl の通常の入力操作を行うことが できません。 If you look at its source, you'll see that open2() uses low-level primitives like Unix pipe() and exec() calls to create all the connections. While it might have been slightly more efficient by using socketpair(), it would have then been even less portable than it already is. The open2() and open3() functions are unlikely to work anywhere except on a Unix system or some other one purporting to be POSIX compliant. open2() のソースを見てみれば、それが全ての接続を生成するために UNIX での pipe() と exec() のような低水準のプリミティブを使っていることに 気がつくでしょう。 これは socketpair() を使うより効率が格段に良いのですが、移植性という面では 見劣りします。 open2() と open3() は UNIX システムやその他の POSIX に従ったシステムを 除いてはおそらく動作しないでしょう。 Here's an example of using open2(): 以下は open2() を使った例です: ; ]]> The problem with this is that Unix buffering is really going to ruin your day. Even though your Writer filehandle is auto-flushed, and the process on the other end will get your data in a timely manner, you can't usually do anything to force it to give it back to you in a similarly quick fashion. In this case, we could, because we gave cat a -u flag to make it unbuffered. But very few Unix commands are designed to operate over pipes, so this seldom works unless you yourself wrote the program on the other end of the double-ended pipe. これに関する問題は、UNIX のバッファリングが実際にはある時点に至るまで 留まるということにあります。 ファイルハンドル Writer を自動フラッシュにしたとしても、もう一方の 端点にあるプロセスは送られたデータを適当なタイミングで 受け取ることになります; 一般的に云って、全てのことに関して即座に 反応するように強制することはできません。 上記の例では、バッファリングをしないようにするために -u フラグを cat に与えることができたのでそれができました。 パイプ越しに使われることを想定して設計された UNIX コマンドは非常に 少数なので、この例のようなことは、両端のあるパイプのもう一方の端点にある プログラムを自分自身で書かない限りはほとんどできないのです。 A solution to this is the nonstandard Comm.pl library. It uses pseudo-ttys to make your program behave more reasonably: この解決策は非標準の Comm.pl ライブラリです。 これはあなたのプログラムをより信頼性のあるものとするために 擬似 TTY を使います: ; } ]]> This way you don't have to have control over the source code of the program you're using. The Comm library also has expect() and interact() functions. Find the library (and we hope its successor IPC::Chat) at your nearest CPAN archive as detailed in the SEE ALSO section below. このやり方では、あなたが使おうとしているプログラムのソースコードを いじくりまわすような必要はありません。 Comm ライブラリには他にも expect() や interact() といった関数もあります。 後述する SEE ALSO の章にある説明の最寄りの CPAN で、このライブラリ(と その後継者と期待している IPC::Chat) を見つけてください。 The newer Expect.pm module from CPAN also addresses this kind of thing. This module requires two other modules from CPAN: IO::Pty and IO::Stty. It sets up a pseudo-terminal to interact with programs that insist on using talking to the terminal device driver. If your system is amongst those supported, this may be your best bet. CPAN にあるより新しいモジュール Expect.pm はこの問題に対処するものです。 このモジュールは他に IO:Pty、IO::Stty という二つの CPAN モジュールを 必要とします。 このモジュールは、ターミナルデバイスドライバと応答するような プログラムと対話するために、擬似端末をセットアップします。 もしあなたの使っているシステムがこういったものをサポートしているのであれば、 そちらを使った方が良いでしょう。 Bidirectional Communication with Yourself (自分で双方向通信する) If you want, you may make low-level pipe() and fork() to stitch this together by hand. This example only talks to itself, but you could reopen the appropriate handles to STDIN and STDOUT and call other processes. もし望むのなら、低レベルなシステムコール pipe() や fork() を 手作業で行うために使うことができます。 以下の例は単に説明のためのものですが、STDIN や STDOOUT に対する 適切なハンドルを再オープンすることができ、さらに別のプロセスを 呼び出すことができます。 autoflush(1); PARENT_WTR->autoflush(1); ]]> ); print "Parent Pid $$ just read this: `$line'\n"; close CHILD_RDR; close CHILD_WTR; waitpid($pid,0); } else { die "cannot fork: $!" unless defined $pid; close CHILD_RDR; close CHILD_WTR; chomp($line = ); print "Child Pid $$ just read this: `$line'\n"; print PARENT_WTR "Child Pid $$ is sending this\n"; close PARENT_RDR; close PARENT_WTR; exit; } ]]> But you don't actually have to make two pipe calls. If you have the socketpair() system call, it will do this all for you. しかし実際に二つの pipe の呼び出しを行う必要はありません。 あなたの使っているシステムが socketpair() システムコールを サポートしていれば、それがあなたの代わりに作業を行ってくれます。 autoflush(1); PARENT->autoflush(1); ]]> ); print "Parent Pid $$ just read this: `$line'\n"; close CHILD; waitpid($pid,0); } else { die "cannot fork: $!" unless defined $pid; close CHILD; chomp($line = ); print "Child Pid $$ just read this: `$line'\n"; print PARENT "Child Pid $$ is sending this\n"; close PARENT; exit; } ]]> Sockets: Client/Server Communication (ソケット: クライアント/サーバー通信) While not limited to Unix-derived operating systems (e.g., WinSock on PCs provides socket support, as do some VMS libraries), you may not have sockets on your system, in which case this section probably isn't going to do you much good. With sockets, you can do both virtual circuits (i.e., TCP streams) and datagrams (i.e., UDP packets). You may be able to do even more depending on your system. UNIX から派生したオペレーティングシステムに限定されることはない (例えば PC では WinSock が(幾つかの VMS ライブラリのように) ソケットサポートを提供しています)にも関らず、あなたが使っている システムではソケットが使えないかもしれません。 その場合、この項に書かれていることはあなたの役には立たないでしょう。 ソケットを使えば、仮想回路(つまり TCP ストリーム)やデータグラム(UDP パケット)の両方が可能になります。 使っているシステムに、より一層依存することになるかもしれません。 The Perl function calls for dealing with sockets have the same names as the corresponding system calls in C, but their arguments tend to differ for two reasons: first, Perl filehandles work differently than C file descriptors. Second, Perl already knows the length of its strings, so you don't need to pass that information. ソケットを扱うための Perl の関数呼び出しは対応する C でのシステムコールと 同じ名前を持っています。 しかし、引数に関しては二つの理由によって異なるものとなっています: 第一に、Perl のファイルハンドルは C のファイル記述子とは 異なる働きをするものである。 第二に、Perl はすでに文字列の長さを知っているので、その情報を渡す 必要がない、というものです。 One of the major problems with old socket code in Perl was that it used hard-coded values for some of the constants, which severely hurt portability. If you ever see code that does anything like explicitly setting $AF_INET = 2, you know you're in for big trouble: An immeasurably superior approach is to use the Socket module, which more reliably grants access to various constants and functions you'll need. Perl における古いソケットプログラムに関連する大きな問題とは、一部の 定数の値として(著しく移植性を損なってしまう)ハードコードされたものが 使われていたということです。 $AF_INET = 2 のように陽に何かを設定しているプログラムを見た事があれば、 あなたはそれが大きなトラブルになるということを知っているでしょう: より優れたやり方は Socket モジュールを使うというものです。 これは、あなたが必要とするであろう様々な定数や関数に対するより信頼の置ける アクセスを提供します。 If you're not writing a server/client for an existing protocol like NNTP or SMTP, you should give some thought to how your server will know when the client has finished talking, and vice-versa. Most protocols are based on one-line messages and responses (so one party knows the other has finished when a "\n" is received) or multi-line messages and responses that end with a period on an empty line ("\n.\n" terminates a message/response). NNTP や SMTP のように既に存在しているプロトコルのためにサーバー/ クライアントを書くのでなければ、あなたの作るサーバーがどのようにして クライアントが通話を終えたときを知ったり、その反対のことを 知るのかということを考えておくべきでしょう。 ほとんどのプロトコルは一行のメッセージと返事(片方のプロセスは、 “\n”を受け取ったときにもう一つのプロセスでの処理が終了したことを 知ります)か、空行に置かれたピリオドで終端される("\n.\n" がメッセージ/返事を 終端する)複数行メッセージと返事に基づいています。 Internet Line Terminators (インターネットの行終端子) The Internet line terminator is "\015\012". Under ASCII variants of Unix, that could usually be written as "\r\n", but under other systems, "\r\n" might at times be "\015\015\012", "\012\012\015", or something completely different. The standards specify writing "\015\012" to be conformant (be strict in what you provide), but they also recommend accepting a lone "\012" on input (but be lenient in what you require). We haven't always been very good about that in the code in this manpage, but unless you're on a Mac, you'll probably be ok. インターネットでの行終端子は "\015\012" です。 UNIX で使われる ASCII のバリエーションでは、通常は“\r\n”のように 記述しますが、他のシステムでは、“\r\n”は"\015\015\012" だったり、 "\012\012\015" だったりあるいはまったく違うものであったりします。 “\015\012”は標準的な書き方(あなたが書いたままのものになります)ですが、 入力中にある独立した“\012”を受け付けることも推奨されています(が、 あなたが要求するときにはそれを穏やかなものにしましょう)。 このマニュアルページにあるプログラムについて、常に最善のものを 使ってはいませんが、あなたが Mac を使っているのでなければ 気にすることはないでしょう。 Internet TCP Clients and Servers (インターネットの TCP クライアントとサーバー) Use Internet-domain sockets when you want to do client-server communication that might extend to machines outside of your own system. 自分の使っているシステムの外側にあるもマシンにまでクライアント- サーバーの通信を広げたい場合には Internet-domain ソケットを使います。 Here's a sample TCP client using Internet-domain sockets: 以下のプログラムは、Internet-domain ソケットを使った TCP クライアントの 例です: )) { print $line; } ]]> And here's a corresponding server to go along with it. We'll leave the address as INADDR_ANY so that the kernel can choose the appropriate interface on multihomed hosts. If you want sit on a particular interface (like the external side of a gateway or firewall machine), you should fill this in with your real address instead. そして以下に挙げるのが上記のクライアントと対応するサーバーです。 ここではアドレスを INADDR_ANY としているので、カーネルは multihomed hosts 上の適切なインターフェースを選択することができます。 (ファイヤーウォールやゲイトウェイの外側のように)特定のインターフェースを 使いたいのであれば、この部分を、自分の使いたい本当のアドレスで 埋めるようにすべきです。 And here's a multithreaded version. It's multithreaded in that like most typical servers, it spawns (forks) a slave server to handle the client request so that the master server can quickly go back to service a new client. 以下の例はマルチスレッドバージョンです。 これはほとんどの典型的なサーバーがそうであるようにマルチスレッドに なっていて、クライアントのリクエストを処理するためにスレイブサーバーを spawn(fork) します。 このため、マスターサーバーは新しいクライアントに対してサービスするために 即座に復帰できます。 0 && WIFEXITED($?)) { logmsg "reaped $waitedpid" . ($? ? " with exit $?" : ''); } $SIG{CHLD} = \&REAPER; # loathe sysV } ]]> &Client") || die "can't dup client to stdout"; ## open(STDERR, ">&STDOUT") || die "can't dup stdout to stderr"; exit &$coderef(); } ]]> This server takes the trouble to clone off a child version via fork() for each incoming request. That way it can handle many requests at once, which you might not always want. Even if you don't fork(), the listen() will allow that many pending connections. Forking servers have to be particularly careful about cleaning up their dead children (called "zombies" in Unix parlance), because otherwise you'll quickly fill up your process table. The REAPER subroutine is used here to call waitpid() for any child processes that have finished, thereby ensuring that they terminate cleanly and don't join the ranks of the living dead. このサーバーはリクエストがくる度に fork() を使って子バージョンの複製を 行うので、問題を取り除きます。 このやり方は、あなたが常に望んではいないかもしれませんが、一度に多くの リクエストを処理することができます。 fork()を使わなかったとしても、listen() は多くの一時停止した コネクション(pending connections) を扱えます。 サーバーを fork するので、死んだ子供(UNIX 世界ではゾンビと呼ばれるもの)の 後始末に関して注意深くする必要があります。 なぜなら、そうしなければプロセステーブルがすぐに埋めつくされることに なるからです。 ここで REAPER サブルーチンは終了した全ての子プロセスのために waitpid() を呼び出すために使われ、従って子プロセスがきれいに終了し、 ゾンビの集団に加わらないことを確実にします。 Within the while loop we call accept() and check to see if it returns a false value. This would normally indicate a system error that needs to be reported. However the introduction of safe signals (see /Deferred Signals (Safe Signals) above) in Perl 5.7.3 means that accept() may also be interrupted when the process receives a signal. This typically happens when one of the forked sub-processes exits and notifies the parent process with a CHLD signal. while ループの中で accept() を呼び出して、偽の値を返すかどうかを チェックします。 これは普通報告する必要のあるシステムエラーを示しています。 しかし、Perl 5.7.3 で導入された安全なシグナル(上述の /Deferred Signals (Safe Signals) を参照してください) の導入は、 プロセスがシグナルを受信した場合にも accept() が中断されうることを 意味します。 これは典型的には、fork した子プロセスの一つが終了して、親プロセスに CHLD シグナルを通知した場合に起こります。 If accept() is interrupted by a signal then $! will be set to EINTR. If this happens then we can safely continue to the next iteration of the loop and another call to accept(). It is important that your signal handling code doesn't modify the value of $! or this test will most likely fail. In the REAPER subroutine we create a local version of $! before calling waitpid(). When waitpid() sets $! to ECHILD (as it inevitably does when it has no more children waiting), it will update the local copy leaving the original unchanged. もし accept() がシグナルで中断されると、$! に EINTR がセットされます。 これが起きた場合、次の反復と次の accept() の呼び出しを安全に続行できます。 シグナルハンドラコードが $! を変更しないようにしないと、このテストが ほぼ確実に失敗するということは重要です。 REAPER サブルーチンでは waitpid() を呼び出す前にローカル版の $! を 作成しています。 waitpid() が $! に ECHILD をセットすると(これはどの子プロセスも待っていない ときに必然的に発生します)、これは元の値を変更せず、ローカルなコピーを 更新します。 We suggest that you use the -T flag to use taint checking (see perlsec) even if we aren't running setuid or setgid. This is always a good idea for servers and other programs run on behalf of someone else (like CGI scripts), because it lessens the chances that people from the outside will be able to compromise your system. setuid やsetgid をされていない状態で実行されているとしても、汚染検査 (perlsec を参照)をするために -T フラグを使うことをお勧めします。 これは、サーバーやその他の他の誰かのために実行される(CGI スクリプトのような) プログラムに対しては常に良い考えになります。 なぜならそうすることによって、外部の人間があなたのシステムに入ってくる ことができる可能性を減らすからです。 Let's look at another TCP client. This one connects to the TCP "time" service on a number of different machines and shows how far their clocks differ from the system on which it's being run: もう一つの TCP クライアントを見てみましょう。 これは複数の異なるマシン上の TCP の“time”サービスに接続してクライアントが 走っているシステムと時計がどれくらい違っているのを出力します: Unix-Domain TCP Clients and Servers (UNIX ドメインの TCP クライアントとサーバー) That's fine for Internet-domain clients and servers, but what about local communications? While you can use the same setup, sometimes you don't want to. Unix-domain sockets are local to the current host, and are often used internally to implement pipes. Unlike Internet domain sockets, Unix domain sockets can show up in the file system with an ls(1) listing. Internet-domain のサーバーとクライアントは良いものですが、ローカル コミュニケーションに関してはどうでしょうか? 同じようにセットアップすることができますが、同じ様に(通信を)行うことは できません。 UNIX ドメインソケットはカレントホストにローカルで、しばしばパイプを 実装するために内部的に使われています。 Internet ドメインソケットとは異なり、UNIX ドメインソケットは、 ls(1) を使ってファイルシステムの中で見つけることができます。 You can test for these with Perl's -S file test: これを、Perl のファイルテスト -S を使って行えます: Here's a sample Unix-domain client: UNIX ドメインクライアントの例です: )) { print $line; } exit; ]]> And here's a corresponding server. You don't have to worry about silly network terminators here because Unix domain sockets are guaranteed to be on the localhost, and thus everything works right. そして対応するサーバーです。 ここで、あなたはやっかいなネットワーク終端子について思い煩う 必要はありません。 なぜなら、UNIX のドメインソケットはローカルホストにおいて完全に 満たされるものであって、そのため、全てはうまくいくのです。 0) { logmsg "reaped $waitedpid" . ($? ? " with exit $?" : ''); } $SIG{CHLD} = \&REAPER; # loathe sysV } ]]> &Client") || die "can't dup client to stdout"; ## open(STDERR, ">&STDOUT") || die "can't dup stdout to stderr"; exit &$coderef(); } ]]> As you see, it's remarkably similar to the Internet domain TCP server, so much so, in fact, that we've omitted several duplicate functions--spawn(), logmsg(), ctime(), and REAPER()--which are exactly the same as in the other server. 見てわかるように、Internet domain TCP サーバーとほとんど同じです。 実際には、まったく変っていない幾つかの重複した関数 spawn(), logmsg(), ctime(), REAPER() を取り除いてあります。 So why would you ever want to use a Unix domain socket instead of a simpler named pipe? Because a named pipe doesn't give you sessions. You can't tell one process's data from another's. With socket programming, you get a separate session for each client: that's why accept() takes two arguments. ではなぜ、単純な名前付きパイプではなく UNIX ドメインソケットを 使いたがるのでしょうか? その理由は、名前付きパイプがあなたにセッションを与えないからです。 あなたはあるプロセスから来たデータと、それとは別のプロセスからきた データとを区別することができません。 ソケットプログラミングを行うことで、クライアント毎に別々のセッションを 持てるようになります: これが accept() が二つの引数を取る理由です。 For example, let's say that you have a long running database server daemon that you want folks from the World Wide Web to be able to access, but only if they go through a CGI interface. You'd have a small, simple CGI program that does whatever checks and logging you feel like, and then acts as a Unix-domain client and connects to your private server. 例えば、CGI インターフェースを通してのみ World Wide Web からアクセスされる、 長時間実行されているデータベースサーバーデーモンを持っているとしましょう。 この場合、あなたの好きなようにチェックやログの記録を実行するような小さく、 単純な CGI プログラムを持って、UNIX ドメインクライアントとして振る舞う プライベートなサーバーに接続させるといったことができるでしょう。 TCP Clients with IO::Socket (IO::Socket を使った TCP クライアント) For those preferring a higher-level interface to socket programming, the IO::Socket module provides an object-oriented approach. IO::Socket is included as part of the standard Perl distribution as of the 5.004 release. If you're running an earlier version of Perl, just fetch IO::Socket from CPAN, where you'll also find modules providing easy interfaces to the following systems: DNS, FTP, Ident (RFC 931), NIS and NISPlus, NNTP, Ping, POP3, SMTP, SNMP, SSLeay, Telnet, and Time--just to name a few. ソケットプログラミングに対する高水準インターフェースのために、IO::Socket モジュールはオブジェクト指向アプローチを提供します。 IO::Socket モジュールはリリース 5.004 の標準 Perl 配布キットの一部として 含まれています。 あなたが以前のバージョンの Perl を使っているのであれば、 CPAN から IO::Socket を入手します。 そこでは、以下に挙げるようなシステムに対する簡単なインターフェースを 提供するシステムも見つけることができるでしょう: DNS, FTP, Ident (RFC 931), NIS, NISPlus, NNTP, Ping, POP3, SMTP, SNMP, SSLeay, Telnet, Time など。 A Simple Client (単純なクライアント) Here's a client that creates a TCP connection to the "daytime" service at port 13 of the host name "localhost" and prints out everything that the server there cares to provide. 以下の例は“localhost”というホスト名の 13 番ポートにある“dyatime” サービスに対する TCP コネクションを作成するクライアントで、そのサーバーが 提供するデータをすべて出力します。 new( Proto => "tcp", PeerAddr => "localhost", PeerPort => "daytime(13)", ) or die "cannot connect to daytime port at localhost"; while ( <$remote> ) { print } ]]> When you run this program, you should get something back that looks like this: このプログラムを実行すると、以下のような返事が返ってくるでしょう: Here are what those parameters to the new constructor mean: new コンストラクターに対するパラメーターの意味を説明します: Proto This is which protocol to use. In this case, the socket handle returned will be connected to a TCP socket, because we want a stream-oriented connection, that is, one that acts pretty much like a plain old file. Not all sockets are this of this type. For example, the UDP protocol can be used to make a datagram socket, used for message-passing. これは使用するプロトコルです。 この例では、私たちはストリーム指向のコネクション、つまり、昔ながらの普通の ファイルのように振る舞うものを使いたいので、ソケットは TCP ソケットに 接続されたものを扱います。 ソケットにはこれ以外のタイプもあることに注意してください。 たとえば、UDP プロトコルは(メッセージ送信に使われている) データグラムソケットを作成するために使うことができます。 PeerAddr This is the name or Internet address of the remote host the server is running on. We could have specified a longer name like "www.perl.com", or an address like "204.148.40.9". For demonstration purposes, we've used the special hostname "localhost", which should always mean the current machine you're running on. The corresponding Internet address for localhost is "127.1", if you'd rather use that. これはサーバーが実行されているリモートホストの、インターネットアドレス もしくは名前です。 これを "www.perl.com" のような長い名前で指定することも "204.148.40.9" のようなアドレスで指定することもできます。 先の例で使った "localhost" は、常に自分が使用している現在のマシンを 意味する特別なホスト名です。 ローカルホストに対するインターネットアドレスは "127.1" で、こちらを 使うこともできます。 PeerPort This is the service name or port number we'd like to connect to. We could have gotten away with using just "daytime" on systems with a well-configured system services file,[FOOTNOTE: The system services file is in /etc/services under Unix] but just in case, we've specified the port number (13) in parentheses. Using just the number would also have worked, but constant numbers make careful programmers nervous. これは接続したいサービスの名称、もしくはポート番号です。 私たちは先の例で、きちんと設定されたシステムサービスの使える システムでなら "daytime" を使うこともできました [FOOTNOTE: UNIXでは /etc/services にシステムサービスファイルがあります]。 しかし、実際には括弧でくくって (13) というポート番号の指定を行っていました。 単に番号を使っても同様に動作するのですが、定数は注意深いプログラマを 神経質にさせてしまいます。 Notice how the return value from the new constructor is used as a filehandle in the while loop? That's what's called an indirect filehandle, a scalar variable containing a filehandle. You can use it the same way you would a normal filehandle. For example, you can read one line from it this way: コンストラクター new の戻り値が、while ループの中のファイル ハンドルとしてどのように使われているかということに気がつきましたか? これは間接ファイルハンドルと呼ばれるもので、ファイルハンドルを保持している スカラー変数です。 これは、通常のファイルハンドルと同様のやり方で使うことができます。 例えば、以下のようにすれば一行読み込みができます: ; ]]> all remaining lines from is this way: 残りの行全ての読み込みは以下のようにします: ; ]]> and send a line of data to it this way: データを一行送るには以下のようにします: A Webget Client (Webget クライアント) Here's a simple client that takes a remote host to fetch a document from, and then a list of documents to get from that host. This is a more interesting client than the previous one because it first sends something to the server before fetching the server's response. 以下の例は、ドキュメントをそこから取るリモートホストと、そのホストから 取得するドキュメントのリストを引数に取る単純なクライアントです。 これは先の例よりも興味深いものです。 なぜなら、この例においてはサーバーの反応をフェッチする前に最初に何かを サーバーに送信するからです。 1) { die "usage: $0 host document ..." } $host = shift(@ARGV); $EOL = "\015\012"; $BLANK = $EOL x 2; foreach $document ( @ARGV ) { $remote = IO::Socket::INET->new( Proto => "tcp", PeerAddr => $host, PeerPort => "http(80)", ); unless ($remote) { die "cannot connect to http daemon on $host" } $remote->autoflush(1); print $remote "GET $document HTTP/1.0" . $BLANK; while ( <$remote> ) { print } close $remote; } ]]> The web server handing the "http" service, which is assumed to be at its standard port, number 80. If the web server you're trying to connect to is at a different port (like 1080 or 8080), you should specify as the named-parameter pair, PeerPort => 8080. The autoflush method is used on the socket because otherwise the system would buffer up the output we sent it. (If you're on a Mac, you'll also need to change every "\n" in your code that sends data over the network to be a "\015\012" instead.) ここでは、“http”サービスを提供する web サーバーがその標準ポートである 80 番ポートを使っていると仮定しています。 あなたの使っている web サーバーが異なるポート(例えば 1080 とか 8080 とか)を 使用しているのであれば、名前付きパラメータペアにしてPeerPort => 8080 のような形式で指定すべきでしょう。 autoflush メソッドがソケットに対して使われます。 そうしなければシステムは私たちが送信した出力を バッファリングしてしまうでしょう(あなたが Mac を使っているのであれば、 ネットワーク越しにデータを送信するプログラム中にあるすべての "\n" を "\015\012" に変更する必要もあります)。 Connecting to the server is only the first part of the process: once you have the connection, you have to use the server's language. Each server on the network has its own little command language that it expects as input. The string that we send to the server starting with "GET" is in HTTP syntax. In this case, we simply request each specified document. Yes, we really are making a new connection for each document, even though it's the same host. That's the way you always used to have to speak HTTP. Recent versions of web browsers may request that the remote server leave the connection open a little while, but the server doesn't have to honor such a request. サーバーへの接続は、このプロセスの最初の一部分でしかありません: 一度接続されてしまえば、サーバーの言語を使うべきなのです。 ネットワーク上の各サーバーは、入力として期待しているそれぞれの小さな コマンド言語を持っています。 HTTP 構文において最初にサーバーに送信するのは "GET" です。 この場合、単純に指定されたドキュメントのそれぞれをリクエストします。 そう、私たちは実際には、たとえ同じホストであったとしてもドキュメント毎に 新しいコネクションを作成しています。 これが HTTP を使うときに常にそうしなければならない方法なのです。 最近のwebブラウザーではコネクションを開いたままちょっとの間リモートサーバーを 離れるリクエストをすることができますが、サーバーはそのようなリクエストを 処理しなければならないというわけではありません。 Here's an example of running that program, which we'll call webget: 以下に挙げるのは、私たちがwebgetと呼ぶであろうプログラムを 実行した例です。 404 File Not Found

File Not Found

The requested URL /guanaco.html was not found on this server.

]]> Ok, so that's not very interesting, because it didn't find that particular document. But a long response wouldn't have fit on this page. これは特定のドキュメントを見つけられないというものですからあまり 面白いものでもありません。 でも、長いレスポンスをここに載せるわけにもいかないでしょう。 For a more fully-featured version of this program, you should look to the lwp-request program included with the LWP modules from CPAN. このプログラムの全機能バージョン(fully-featured version)は、CPAN にある LWP モジュール中の lwp-request というプログラムを見るとよいでしょう。 Interactive Client with IO::Socket (IO::Socket を使った対話的クライアント) Well, that's all fine if you want to send one command and get one answer, but what about setting up something fully interactive, somewhat like the way telnet works? That way you can type a line, get the answer, type a line, get the answer, etc. 一つのコマンドを送信し、一つの返答を得るというのであれば具合が良いのですが、 完全に対話的な何かを設定し、telnet のように動作するものはどうでしょうか? ここでできるのは、ある一行をタイプして答を得て、別の行をタイプしてそれに 対する答を得て…というやり方です。 This client is more complicated than the two we've done so far, but if you're on a system that supports the powerful fork call, the solution isn't that rough. Once you've made the connection to whatever service you'd like to chat with, call fork to clone your process. Each of these two identical process has a very simple job to do: the parent copies everything from the socket to standard output, while the child simultaneously copies everything from standard input to the socket. To accomplish the same thing using just one process would be much harder, because it's easier to code two processes to do one thing than it is to code one process to do two things. (This keep-it-simple principle a cornerstones of the Unix philosophy, and good software engineering as well, which is probably why it's spread to other systems.) このクライアントは既に出てきた二つのものよりも複雑ですが、あなたが 強力な fork 呼び出しをサポートしているシステムを使っているのであれば、 解決策は乱暴なものではありません。 通信したいなんらかのサービスに対してコネクションを作ってしまえば、プロセスの 複製を作るために fork を呼び出します。 それによる二つのプロセスはそれぞれ、非常に単純なジョブを行います: 親プロセスはソケットから入力されたすべてを標準出力にコピーし、子プロセスは 標準入力をソケットへと同じようにコピーします。 ただ一つのプロセスを使ったときに同じことをするのは 非常に 難しいでしょう。 なぜなら、二つのことを行う一つのプロセスのためのプログラムよりも 一つのことを行う二つのプロセスのためのプログラムのほうが 簡単だからです(この keep-it-simple 法則は UNIX 文化の要石で、良い ソフトウェアエンジニアが使うように、(UNIX が)他のシステムよりも広く 使われていることの理由でしょう)。 Here's the code: プログラムの例です: new(Proto => "tcp", PeerAddr => $host, PeerPort => $port) or die "can't connect to port $port on $host: $!"; ]]> autoflush(1); # so output gets there right away print STDERR "[Connected to $host:$port]\n"; ]]> )) { print STDOUT $line; } kill("TERM", $kidpid); # send SIGTERM to child } # the else{} block runs only in the child process else { # copy standard input to the socket while (defined ($line = )) { print $handle $line; } } ]]> The kill function in the parent's if block is there to send a signal to our child process (current running in the else block) as soon as the remote server has closed its end of the connection. 親プロセスの if ブロックにある kill 関数は、リモートサーバーが コネクションを終了してクローズしてすぐに子プロセス(else ブロックを 実行しています)にシグナルを送るためのものです。 If the remote server sends data a byte at time, and you need that data immediately without waiting for a newline (which might not happen), you may wish to replace the while loop in the parent with the following: リモートサーバーが一度に一バイト送っていて、そして、あなたが改行を 待つことなしに即座にデータを必要とする(そうそうないことでしょうが)のなら、 while ループを以下のようなものに置き換えたくなるでしょう: Making a system call for each byte you want to read is not very efficient (to put it mildly) but is the simplest to explain and works reasonably well. 読み出しのために一バイト毎にシステムコールを行うのは実に非効率的ですが、 説明するのに簡単でとりあえずは動くのです: TCP Servers with IO::Socket (IO::Socket を使った TCP サーバー) As always, setting up a server is little bit more involved than running a client. The model is that the server creates a special kind of socket that does nothing but listen on a particular port for incoming connections. It does this by calling the IO::Socket::INET->new() method with slightly different arguments than the client did. 常にそうであるように、サーバーのセッティングはクライアントを実行するよりも ほんのちょっと手間がかかります。 ここで使うのは、サーバーが特定のポートで接続を待つだけという特殊な種類の ソケットを作成するというモデルです。 これは、IO::Socket::INET->new() というメソッドをはっきりと異なる 引数を付けて呼び出してからクライアントを実行することで行います。 Proto This is which protocol to use. Like our clients, we'll still specify "tcp" here. これは使用するプロトコルです。 クライアントと同様、ここでは "tcp" を指定します。 LocalPort We specify a local port in the LocalPort argument, which we didn't do for the client. This is service name or port number for which you want to be the server. (Under Unix, ports under 1024 are restricted to the superuser.) In our sample, we'll use port 9000, but you can use any port that's not currently in use on your system. If you try to use one already in used, you'll get an "Address already in use" message. Under Unix, the netstat -a command will show which services current have servers. LocalPort 引数でローカルポートを指定します。 これはサーバーにしたいサービス名かポート番号のいずれかです(UNIX では、 1024 未満のポートはスーパーユーザー限定です)。 私たちのサンプルでは 9000 番ポートを使いますが、あなたの使っているシステムで 重複しなければ好きな番号を使うことができます。 もし既に使われているポートを使おうとすれば、"Address already in use" の ようなメッセージを得ることとなるでしょう。 UNIX では、netstat -a コマンドを使ってサービスが現在使っているサーバーを 見ることができます。 Listen The Listen parameter is set to the maximum number of pending connections we can accept until we turn away incoming clients. Think of it as a call-waiting queue for your telephone. The low-level Socket module has a special symbol for the system maximum, which is SOMAXCONN. Listen パラメーターは、クライアントを待たせておいて受け付けることのできる コネクションの最大数を設定します。 電話の呼び出しを考えてみてください。 低水準ソケットモジュールは SOMAXCONN というそのシステムの最大値を表す 特殊なシンボルを持っています。 Reuse The Reuse parameter is needed so that we restart our server manually without waiting a few minutes to allow system buffers to clear out. Reuse パラメーターは、システムがバッファーをクリアするための時間を 掛けずに私たちのサーバーを手作業で再起動するのに必要です。 Once the generic server socket has been created using the parameters listed above, the server then waits for a new client to connect to it. The server blocks in the accept method, which eventually accepts a bidirectional connection from the remote client. (Make sure to autoflush this handle to circumvent buffering.) 上で述べたパラメーターを持った汎用のサーバーソケットが生成されれば、 そのサーバーは接続される新たなクライアントを待ちます。 accept メソッドにあるサーバーブロックはリモートクライアントからの 双方向接続を許可します(バッファリングを抑制するためにハンドルに対して autoflush することを忘れないように)。 To add to user-friendliness, our server prompts the user for commands. Most servers don't do this. Because of the prompt without a newline, you'll have to use the sysread variant of the interactive client above. ユーザーに親切にするために、私たちのサーバーはコマンドの入力のプロンプトを 表示します。 ほとんどのサーバーはこうしたことをしていません。 プロンプトには改行がないので、上の例にあったような対話的な クライアントの類では sysread を使う必要があるでしょう。 This server accepts one of five different commands, sending output back to the client. Note that unlike most network servers, this one only handles one incoming client at a time. Multithreaded servers are covered in Chapter 6 of the Camel. このサーバーは五種類のコマンドのいずれか一つを取り、クライアントに対して (コマンドに応じた)出力を行います。 多くのネットワークサーバーとは異なり、このサーバープログラムは一度に一つの クライアントしか扱えないということに注意してください。 マルチスレッド化されたサーバーはらくだ本の第六章でカバーされています。 Here's the code. We'll 以下プログラムです。 new( Proto => 'tcp', LocalPort => $PORT, Listen => SOMAXCONN, Reuse => 1); ]]> accept()) { $client->autoflush(1); print $client "Welcome to $0; type help for command list.\n"; $hostinfo = gethostbyaddr($client->peeraddr); printf "[Connect from %s]\n", $hostinfo ? $hostinfo->name : $client->peerhost; print $client "Command? "; while ( <$client>) { next unless /\S/; # blank line if (/quit|exit/i) { last; } elsif (/date|time/i) { printf $client "%s\n", scalar localtime; } elsif (/who/i ) { print $client `who 2>&1`; } elsif (/cookie/i ) { print $client `/usr/games/fortune 2>&1`; } elsif (/motd/i ) { print $client `cat /etc/motd 2>&1`; } else { print $client "Commands: quit date who cookie motd\n"; } } continue { print $client "Command? "; } close $client; } ]]> UDP: Message Passing (UDP: メッセージ配送) Another kind of client-server setup is one that uses not connections, but messages. UDP communications involve much lower overhead but also provide less reliability, as there are no promises that messages will arrive at all, let alone in order and unmangled. Still, UDP offers some advantages over TCP, including being able to "broadcast" or "multicast" to a whole bunch of destination hosts at once (usually on your local subnet). If you find yourself overly concerned about reliability and start building checks into your message system, then you probably should use just TCP to start with. クライアント・サーバーをセットアップするもう一つの種類はコネクションではなく メッセージを使うものです。 UDP 通信はオーバーヘッドが低いものの、メッセージがすべて到着するという 保証がなく到着の順序もきちんと保たれていることも保証されてないために 信頼性もまた劣るものになっています。 それでも、UDP には一度に宛て先ホストの塊全体 (通常はローカルサブネット)に対して“ブロードキャスト”、“マルチキャスト”が できるということを含め、TCPに対する幾つかのアドバンテージがあります。 信頼性に関して過度に関心を持ち、作成するメッセージシステムに検査機構を 組み込もうというのであれば、むしろ TCP を使うようにした方がよいでしょう。 Note that UDP datagrams are not a bytestream and should not be treated as such. This makes using I/O mechanisms with internal buffering like stdio (i.e. print() and friends) especially cumbersome. Use syswrite(), or better send(), like in the example below. UDP はバイトストリーム ではなく 、そのように扱うべきでもないことに 注意してください。 これは stdio(つまり print() やその親戚) のような内部バッファリング付きの I/O 機構を特に扱いにくくします。 以下の例のように、syswrite() か、よりよい send() を使ってください。 Here's a UDP program similar to the sample Internet TCP client given earlier. However, instead of checking one host at a time, the UDP version will check many of them asynchronously by simulating a multicast and then using select() to do a timed-out wait for I/O. To do something similar with TCP, you'd have to use a different socket handle for each host. 以下に挙げた UDP プログラムは先に挙げたインターネト TCP クライアントの 例と似ていますが、一度に一つのホストをチェックするのではなく、 マルチキャストをシミュレートし、かつ、select() を入出力のタイムアウト待ちの ために使うことにより非同期的にたくさんのチェックを行います。 TCP でこれと同じことを行うには、ホスト毎に異なるソケットハンドルを 使わなければならないでしょう。 Note that this example does not include any retries and may consequently fail to contact a reachable host. The most prominent reason for this is congestion of the queues on the sending host if the number of list of hosts to contact is sufficiently large. この例では一切再試行を行わないので、到達可能なホストへの接続に 失敗することがあることに注意してください。 これのもっとも有名な原因は、もし接続するホストのリストの数が十分に大きいと、 送信ホストのキューが混雑することです。 SysV IPC While System V IPC isn't so widely used as sockets, it still has some interesting uses. You can't, however, effectively use SysV IPC or Berkeley mmap() to have shared memory so as to share a variable amongst several processes. That's because Perl would reallocate your string when you weren't wanting it to. System V IPC はソケットとしてはそれ程広く使われてはいませんが、 幾つかの興味深い使用法があります。 ただし、System V の IPC や Berkley の mmap() を(異なる幾つかのプロセスの 間で変数を共有するための)共有メモリを持つ目的のために効率良く 使うことはできません。 なぜなら Perl が、あなたが望まないときに文字列の再割り付けをやってしまう 可能性があるからです。 Here's a small example showing shared memory usage. 共有メモリの使い方を例示する小さな例です。 Here's an example of a semaphore: 以下はセマフォの例です: Put this code in a separate file to be run in more than one process. Call the file take: 二つ以上のプロセスで動作するように、このコードを分割されたファイルに 置きます。 そのファイルを take と呼びます: Put this code in a separate file to be run in more than one process. Call this file give: このコードを、二つ以上のプロセスで実行できるように別のファイルに 置きます。 このファイルを give と呼びます。 The SysV IPC code above was written long ago, and it's definitely clunky looking. For a more modern look, see the IPC::SysV module which is included with Perl starting from Perl 5.005. ここで例示した System V の IPC コードははるかな昔に書かれたもので、 へぼなものに見えます。 より現代的なものについては、Perl 5.005 から含まれている IPC::SysV モジュールを参照してください。 A small example demonstrating SysV message queues: SysV メッセージキューを例示する簡単な例です: NOTES Most of these routines quietly but politely return undef when they fail instead of causing your program to die right then and there due to an uncaught exception. (Actually, some of the new Socket conversion functions croak() on bad arguments.) It is therefore essential to check return values from these functions. Always begin your socket programs this way for optimal success, and don't forget to add -T taint checking flag to the #! line for servers: これらのルーチンのほとんどは物静かですが、何かに失敗した場合には あなたのプログラムを終了させてしまったり捕捉されない例外を 引き起こしたりする代わりに undef を返します(実際には、新しい Socket 変換関数の幾つかは不正な引数に対して croak() します)。 したがって要点は、これらの関数の戻り値を確認すべきであるということです。 ソケットプログラムは常に最良の成功(optimal success)のためにこのやり方で 始め、そしてサーバーに対して pound-bang line (#! の行のこと)に 汚染検査フラグ -T を追加することを忘れないようにしてください。 BUGS All these routines create system-specific portability problems. As noted elsewhere, Perl is at the mercy of your C libraries for much of its system behaviour. It's probably safest to assume broken SysV semantics for signals and to stick with simple TCP and UDP socket operations; e.g., don't try to pass open file descriptors over a local UDP datagram socket if you want your code to stand a chance of being portable. これらのルーチンは全て、システム固有の移植性問題を作り出します。 他の場所で説明したように、Perl の振る舞いは使用しているCライブラリに 左右されます。 System V のおかしなシグナルのセマンティクスを仮定することと、単純な TCP および UDP ソケット操作に終始するようにすることがおそらくは最も 安全なもののでしょう。 たとえば、あなたが自分のプログラムに移植性を持たせるようにしたいのであれば、 ローカルな UDP データグラムのソケットを通してファイル記述子を 渡すようなことをしようとしてはいけないということです。 AUTHOR Tom Christiansen, with occasional vestiges of Larry Wall's original version and suggestions from the Perl Porters. Tom Christiansen (Larry Wall による元の文書の部分的な名残と、 Perl Porters による示唆と共に) SEE ALSO There's a lot more to networking than this, but this should get you started. ネットワークに関する事柄はまだまだたくさんあります。 ここにあることはスタートでしかありません。 For intrepid programmers, the indispensable textbook is Unix Network Programming, 2nd Edition, Volume 1 by W. Richard Stevens (published by Prentice-Hall). Note that most books on networking address the subject from the perspective of a C programmer; translation to Perl is left as an exercise for the reader. Richard Stevens による非常に重要な教科書 Unix Network Programming, 2nd Edition, Volume 1 (Prentice-Hall から出版されています)があります。 ネットワークに関するほとんどの本は、C プログラマを対象としている点に 注意してください。 Perl への変換は、読者の宿題として残しておきます。 The IO::Socket(3) manpage describes the object library, and the Socket(3) manpage describes the low-level interface to sockets. Besides the obvious functions in perlfunc, you should also check out the modules file at your nearest CPAN site. (See perlmodlib or best yet, the Perl FAQ for a description of what CPAN is and where to get it.) IO::Socket(3) マニュアルページにはオブジェクトライブラリの説明があり、 Socket(3) には低水準のソケットに対するインターフェースの説明があります。 perlfunc にある関数の他にも、至近にある CPAN サイトで modules ファイルをチェックしたほうが良いでしょう(perlmodlib を 参照するか、CPAN がどこにあるかの説明がある Perl FAQ を見ると よいでしょう)。 Section 5 of the modules file is devoted to "Networking, Device Control (modems), and Interprocess Communication", and contains numerous unbundled modules numerous networking modules, Chat and Expect operations, CGI programming, DCE, FTP, IPC, NNTP, Proxy, Ptty, RPC, SNMP, SMTP, Telnet, Threads, and ToolTalk--just to name a few. modlues ファイルの第 5 章は "Networking, Device Control (modems), and Interprocess Communication" に充てられていて、バンドルされなかった多くのネットワーク関連モジュール、 チャット と Expect operations, CGI プログラミング, DCE, FTP, IPC, NNTP, Proxy, Ptty, RPC, SNMP, SMTP, Telnet, スレッド、 そして ToolTalk を含んでいます。 Created: KIMURA Koichi Updated: Kentaro Shirakata <argrath@ub32.org>