open() を使う
perlipc - Perl のプロセス間通信 (シグナル, fifo, パイプ, 安全な副プロセス, ソケット, セマフォ)
Perl の基本的な IPC 機能は、古きよき UNIX のシグナル、名前付きパイプ、 パイプ、Berkeley ソケットルーチン、 SysV IPC コールから構成されています。 これら各々ははっきりと異なる状況で使われます。
Perl は単純なシグナルハンドリングモデルを使っています: %SIG という ハッシュは、ユーザーがインストールしたシグナルハンドラの名前、 もしくはハンドラに対するリファレンスを保持します。 これらのハンドラは、起動されたシグナルの名前を引数として呼び出されます。 シグナルは control-C や control-Z のような特定のキーボードシーケンスで 意識的に生成することもできますし、他のプロセスがシグナルを 送ることもあります。 あるいは子プロセスが終了したとか、プロセスがスタックを使いきった、 ファイルサイズ制限に引っ掛かったといった特殊なイベントが発生したときに、 カーネルが自動的にシグナルを発生させることもあります。
例えば割り込みシグナル(interrupt signal)をトラップするには、 以下の例のようにハンドラを設定します:
sub catch_zap {
my $signame = shift;
$shucks++;
die "Somebody sent me a SIG$signame";
}
$SIG{INT} = 'catch_zap'; # could fail in modules
$SIG{INT} = \&catch_zap; # best strategy
Perl 5.7.3 以前では、自分のハンドラの中を使うことができます。 私たちが認識していることは、グローバル変数に設定した後で例外を 引き起こすということだけであることに注意してください。 これは、ほとんどのシステム上ではライブラリ、とくにメモリ割り付けや 入出力に関するものは再入可能ではないためです。 これは、あなたのハンドラ内のほとんど あらゆること が理論的には メモリフォールトやそれに続くコアダンブを引き起こす可能性が あるということです - 以下の 保留シグナル(安全なシグナル) を 参照してください。
あなたの使っているシステムにおけるシグナルの名称は kill -l に
よってリストアップされます。
あるいはコンフィグモジュールから取得することもできます。
名前を得るための番号によって添え字づけされる @signame というリストと
番号を得るための名前によって添え字づけされる %signo というテーブルを
セットアップします。
use Config;
defined $Config{sig_name} || die "No sigs?";
foreach $name (split(' ', $Config{sig_name})) {
$signo{$name} = $i;
$signame[$i] = $name;
$i++;
}
ですから、17 番のシグナルと SIGALRM が同一であるかどうかは以下のようにして チェックできます:
print "signal #17 = $signame[17]\n";
if ($signo{ALRM}) {
print "SIGALRM is $signo{ALRM}\n";
}
ハンドラとして 'IGNORE' や 'DEFAULT' といった文字列を
代入することも選択できます。
これらのハンドラは、perl がシグナルを破棄させるようにしたり
デフォルトの動作を行うようにさせるものです。
ほとんどの UNIX プラットフォームでは、CHLD(CLD の場合もあり)
シグナルは 'IGNORE' の値に対応するような特別な振る舞いをします。
そのようなプラットフォームでは 'IGNORE' に $SIG{CHLD} を
設定することによって、親プロセスが wait() に失敗したようなときに
ゾンビプロセスができることを防ぎます(子プロセスは自動的に
刈り取られます)。
$SIG{CHLD} を 'IGNORE' を設定して wait() を呼び出すことによって、
このようなプラットフォームでは -1 が通常返されます。
KILL シグナルや STOP シグナル(TSTP ではない)のような幾つかのシグナルは、
トラップすることも無視することもできません。
一時的にシグナルを無視するための戦略は local() 文を使うというものです。
これはその local() 文を囲むブロックから出たときに、自動的に元の状態に
復帰します。
(local() による値は ブロックの内側から呼び出された関数に
“引き継がれる”(inherited) ことを忘れないでください)。
sub precious {
local $SIG{INT} = 'IGNORE';
&more_functions;
}
sub more_functions {
# interrupts still ignored, for now...
}
負のプロセス ID に対してシグナルを送ることは、UNIX プロセスグループ 全体にシグナルを送ることになります。 以下のコードは、カレントのプロセスグループに属する全てのプロセスに hang-up シグナルを送出します(そして、$SIG{HUP} に IGNORE を設定するので、 自分自身を kill することはありません)。
{
local $SIG{HUP} = 'IGNORE';
kill HUP => -$$;
# snazzy writing of: kill('HUP', -$$)
}
この他の興味深いシグナルは、シグナル番号 0 です。 これは実際には子プロセスに影響を及ぼすことはありませんが、UID が 生きているのか、あるいは変更されたのかのチェックを行います。
unless (kill 0 => $kid_pid) {
warn "something wicked happened to $kid_pid";
}
送り先のプロセスの UID が、送り元と同じではない場合、たとえプロセスが
生きていても、シグナルを送る権限がないので、シグナル番号 0 は失敗します。
失敗の原因は、%! を使って決定できます。
unless (kill 0 => $pid or $!{EPERM}) {
warn "$pid looks dead";
}
単純なシグナルハンドラには無名関数を使いたくなるかもしれません:
$SIG{INT} = sub { die "\nOutta here!\n" };
しかしこれは、自分自身を再インストールする必要があるような、もっと複雑な
ハンドラに対しては問題になる可能性があります。
Perl のシグナル機構は現在のところ C ライブラリの signal(3) 関数に基づいた
ものなので、関数が“ぶっ壊れた”ような、つまり、より新しくて信頼性のある
BSD 形式や POSIX 形式ではなく古くて信用できない SysV 方式の振る舞いを
するようなものシステムで実行するような不運な立場になるかもしれません。
そのため、以下のようにシグナルハンドラを書いて人を守っているものを
見るでしょう:
sub REAPER {
$waitedpid = wait;
# loathe SysV: it makes us not only reinstate
# the handler, but place it after the wait
$SIG{CHLD} = \&REAPER;
}
$SIG{CHLD} = \&REAPER;
# now do something that forks...
あるいはもっとましなように:
use POSIX ":sys_wait_h";
sub REAPER {
my $child;
# If a second child dies while in the signal handler caused by the
# first death, we won't get another signal. So must loop here else
# we will leave the unreaped child as a zombie. And the next time
# two children die we get another zombie. And so on.
while (($child = waitpid(-1,WNOHANG)) > 0) {
$Kid_Status{$child} = $?;
}
$SIG{CHLD} = \&REAPER; # still loathe SysV
}
$SIG{CHLD} = \&REAPER;
# do something that forks...
UNIX では、シグナルハンドラはタイムアウトのためにも使われます。
eval{} ブロックの中では安全に保護されいる間に、alarm シグナルを
トラップするためにシグナルハンドラを設定して、その後で解放される
秒数をスケジューリングします。
それからブロッキング操作を試して、
それが完了したら eval{} ブロックを抜ける前に alarm をクリアーします。
設定した時間が経ってしまった場合には、他の言語における longjmp() や
throw() を使ったときと同じようにブロックを抜けるために die() を
使います。
例を挙げましょう:
eval {
local $SIG{ALRM} = sub { die "alarm clock restart" };
alarm 10;
flock(FH, 2); # blocking write lock
alarm 0;
};
if ($@ and $@ !~ /alarm clock restart/) { die }
時間切れを起こした操作が system() か qx() なら、このテクニックはゾンビを
生成する傾向があります。
もしそれが問題なら、自力で fork() と exec() を行って、エラーの起きた
子プロセスを kill する必要があるでしょう。
より複雑なシグナル処理のためには、標準の POSIX モジュールを確かめると よいかもしれません。 嘆かわしいことにこれはほとんどアンドキュメントな状態ですが、Perl の ソース配布キットにある t/lib/posix.t というファイルには幾つかの サンプルがあります。
普通システムブート時に起動し、システムシャットダウン時に終了するプロセスの
ことをデーモン(daemon: Disk And Execution MONitor)と呼びます。
もしデーモンプロセスに設定ファイルがあり、それがプロセスが開始してから
変更された場合、プロセスを止めることなく、プロセスに設定ファイルを
再読み込みすることを知らせる方法があるべきです。
多くのデーモンはこの機構を SIGHUP シグナルハンドラを使って
提供しています。
デーモンにファイルを再読み込みしてほしい場合、単にデーモンに
SIGHUP シグナルを送ります。
全てのプラットフォームにおいて、シグナル配送の後自動的に(ネイティブな)
シグナルハンドラを再設定するわけではありません。
これは、ハンドラは最初にシグナルが送られたときにのみ動作することを
意味します。
この問題の解決策は、もし利用可能であれば、振る舞いが明確である
POSIX シグナルハンドラを使うことです。
以下の例は、SIGHUP を受け取る毎に再起動するという単純なデーモンを
実装しています。
実際のコードはサブルーチン code() に置かれていて、どのように動作するかを
示し、実際のコードと置き換えられるように、単にデバッグ情報を出力します。
#!/usr/bin/perl -w
use POSIX (); use FindBin (); use File::Basename (); use File::Spec::Functions;
$|=1;
# make the daemon cross-platform, so exec always calls the script # itself with the right path, no matter how the script was invoked. my $script = File::Basename::basename($0); my $SELF = catfile $FindBin::Bin, $script;
# POSIX unmasks the sigprocmask properly
my $sigset = POSIX::SigSet->new();
my $action = POSIX::SigAction->new('sigHUP_handler',
$sigset,
&POSIX::SA_NODEFER);
POSIX::sigaction(&POSIX::SIGHUP, $action);
sub sigHUP_handler {
print "got SIGHUP\n";
exec($SELF, @ARGV) or die "Couldn't restart: $!\n";
}
code();
sub code {
print "PID: $$\n";
print "ARGV: @ARGV\n";
my $c = 0;
while (++$c) {
sleep 2;
print "$c\n";
}
}
__END__
名前付きパイプ(しばしば FIFO として参照されます)は、同じマシン上での プロセス間通信のための古い UNIX IPC 機構です。 これは通常の無名パイプの接続と同様に動作しますが、ファイル名を使って プロセスのランデブーが行われ、関連づける必要がないという点が異なります。
名前付きパイプを生成するには、POSIX::mkfifo() 関数を使ってください。
use POSIX qw(mkfifo);
mkfifo($path, 0700) or die "mkfifo $path failed: $!";
一部のシステムでは Unix コマンド mknod(1) か、システムによっては
mkfifo(1) を使えます。
これらはあなたの通常パス(normal path)に置くことはできません。
# system return val is backwards, so && not ||
#
$ENV{PATH} .= ":/etc:/usr/etc";
if ( system('mknod', $path, 'p')
&& system('mkfifo', $path) )
{
die "mk{nod,fifo} $path failed";
}
fifo は、あるプロセスをそれとは関係ない別のプロセスに接続したいときに 便利です。 fifo をオープンしたとき、プログラムはもう一方の端点に何かが 置かれるまでブロックされます。
たとえば、.signature というファイルを、もう一方の端点に Perl プログラムが置かれている名前付きパイプに接続したいとしましょう。 このとき、任意のプログラムが任意の時点で(メイラー、ニューズリーダー、 finger プログラムなどのように)そのファイルを読み出そうとしますから、 読み出しプログラムはブロックをしてからあなたのプログラムが新しい シグネチャーを提供するようにしなければなりません。 誰か(もしくは何か)が間違って私たちのfifoを削除したりしないかどうかを 監視するために -p という pipe-cheching ファイルテストを使用します。
chdir; # go home
$FIFO = '.signature';
while (1) {
unless (-p $FIFO) {
unlink $FIFO;
require POSIX;
POSIX::mkfifo($FIFO, 0700)
or die "can't mkfifo $FIFO: $!";
}
# next line blocks until there's a reader
open (FIFO, "> $FIFO") || die "can't write $FIFO: $!";
print FIFO "John Smith (smith\@host.org)\n", `fortune -s`;
close FIFO;
sleep 2; # to avoid dup signals
}
Perl 5.7.3 以前の Perl では、シグナルを取り扱う Perl プログラムを
インストールすることによって、あなたは二つの危険性に直面することに
なりました。
第一に、再入可能なライブラリ関数を備えたシステムは数少ないこと。
Perl がある関数(malloc(3) や printf(3) など)を実行中にシグナル割り込みが
あったとすると、あなたのシグナルハンドラは同じ関数を
再度呼び出し、結果として予測のつかない動作になる可能性があります。
第二に、Perl 自身も最低レベルにおいては再入可能に
なっていないということです。
Perl が自分の内部構造を操作しているときにシグナル割り込みが
あったとすると、これもまた予測のつかない動作になるでしょう。
あなたの取りうる手段が二つありました:
偏執狂的になるか現実的になるかです。
偏執狂的アプローチは、あなたのシグナルハンドラの中でできるだけ
少ないことを行うというものでした。
既に値をもって存在している整数変数に値を設定してリターンします。
これは単にリスタートするような遅いシステムコールの中にいるときには
助けになりません。
これはつまり、ハンドラの外に longjmp(3) するには die する必要が
あるということです。
これは本当の偏執狂というのにはちょっとおおげさですが、ハンドラ中で
die を排除します。
現実的なアプローチは「リスクがあるのは分かってるけどさ、便利なら
いいじゃない」というもので、シグナルハンドラ中で行いたいことを
全て行い、コアダンプを掃除する準備をしてから再度行うというものでした。
Perl 5.7.3 以降では、この問題を避けるために、シグナルは「保留」されます -- これは、システムによってシグナルが (Perl を実装している C コードに) 配送されると、フラグをセットして、ハンドラは直ちに返ります。 それから、Perl インタプリタの戦略的に「安全な」地点 (例えば、新しいオペコードを実行しようとしている時点) で、 フラグをチェックして、%SIG の Perl レベルハンドラを実行します。 「保留」スキームは、Perl インタプリタが安全な状態にあって、ハンドラが 呼び出されたときにシステムライブラリの中ではないことが分かっているので、 シグナルハンドラのコーディングが遥かに柔軟になります。 しかし、実装は以下の方向で以前の Perl と異なります:
Perl インタプリタは、もし長時間実行されるオペコード (例えばとても長い文字列での正規表現操作)の途中でシグナルが 到着すると、新しいオペコードを実行しようとする時にのみシグナルフラグを 見るので、シグナルは現在のオペコードが完了するまで現れません。
注意: もしどのような種類のシグナルでも(例えば高精度のタイマーから)
1 つのオペコードの間に複数回発生した場合、そのシグナルのハンドラは
オペコードの完了後 1 度しか呼び出されず、その他の実体は破棄されます。
さらに、システムのシグナルキューがあふれたために
あるオペコードが完了時に、発生したけれどもまだ捕捉されていない
(従ってまだ保留されていない)シグナルがあると
これらのシグナルが引き続くオペコードの間捕捉および保留され、時々
驚くべき結果となることがあります。
例えば、alarm(0) はアラームの発生を止めますが、
発生したけれどもまだ捕捉していないアラームの配達がキャンセルしないので、
alarm(0) を呼び出した後にもアラームが配送されることがあります。
これは現在の実装の副作用であり、将来のバージョンの Perl では
変更されるかもしれないので、この段落に記述された振る舞いに依存しては
いけません。
(INT control-C などで) シグナルが配送されると、
OS は (Perl <> 演算子の実装で使われている) read のような
I/O 操作を中断します。
古い Perl ではハンドラをすぐに呼び出します
(そして read はうまく動くので「安全ではない」ことはありません)。
「保留」スキームではハンドラはすぐに呼び出されず、
もし Perl がシステムの stdio ライブラリを使っていると、ライブラリは
Perl に返って %SIG ハンドラを呼び出しする機会なしに read を
再起動します。
もしこれが起きた場合、解決法は、I/O を行うときにー
- 少なくともシグナルで中断できるようにしたいハンドルで -
:perlio 層を使うことです
(:perlio 層はシグナルフラグをチェックして、I/O 操作を続行する前に
%SIG ハンドラを呼び出します。)
Perl 5.7.3 以降ではデフォルトでは自動的に :perlio 層が使われることに
注意してください。
gethostbyname() のようなネットワークライブラリ関数は独自のタイムアウト
実装を持っていることが知られているので、あなたのタイムアウトと
競合するかもしれないことに注意してください。
もしこのような関数で問題が起きた場合は、Perl の安全なシグナルを回避する
POSIX sigaction() 関数を試すことができます
(これは上述の、メモリ破壊の可能性があるということに注意してください)。
$SIG{ALRM} をセットする代わりに:
local $SIG{ALRM} = sub { die "alarm" };
以下のようなことを試してみてください:
use POSIX qw(SIGALRM);
POSIX::sigaction(SIGALRM,
POSIX::SigAction->new(sub { die "alarm" }))
or die "Error setting SIGALRM handler: $!\n";
安全なシグナルの振る舞いを局所的に無効にするもう一つの方法は
CPAN の Perl::Unsafe::Signals モジュールを使うことです
(全てのシグナルに影響を与えます)。
これに対応しているシステムでは、より古いバージョンの Perl では %SIG
ハンドラを設定するときに SA_RESTART フラグを使います。
これは、再起動可能なシステムコールではシグナルが配送されたときに
戻るのではなく続行することを意味します。
保留シグナルを素早く配送するために、
Perl 5.7.3 以降では SA_RESTART を 使っていません。
結果として、再起動可能なシステムコールは、いままで成功していたところでも
($! に EINTR をセットして) 失敗することがあります。
デフォルトの :perlio 層では read, write, close は上述したように
再試行し、中断された wait と waitpid の呼び出しは常に
再試行されることに注意してください。
SEGV, ILL, BUS のようなシグナルは、仮想メモリやその他の「障害」の結果として 生成されます。 これらは普通致命的で、Perl-レベルのハンドラができることはほとんど ないので、これらを保留しようとせず、直ちに配送します。
OS によっては、ある種のシグナルハンドラは返る前に「何かをする」ことに
なっているものもあります。
1 つの例としては、CHLD や CLD は子プロセスが完了したことを示しています。
OS によっては、シグナルハンドルは完了した子プロセスのために
wait することを想定されているものもあります。
このようなシステムでは保留シグナルスキームはこれらのシグナルでは
動作しません(wait しません)。
再び、問題は、wait していない完了した子プロセスがあるかのようにシグナルが
再び発生することでループのように見えます。
もし、メモリ破壊の可能性にもかかわらず、古いシグナルの振る舞いが
ほしいなら、環境変数 PERL_SIGNALS を "unsafe" に設定してください
(Perl 5.8.1 からの新機能です)。
open() を使うPerlの open() 文は、その第二引数でパイプシンボルを前置するか末尾に
付加することによって、一方向のプロセス間通信のために使うことができます。
以下の例は、書き込みを行いたい子プロセスを起動させるやり方です:
open(SPOOLER, "| cat -v | lpr -h 2>/dev/null")
|| die "can't fork: $!";
local $SIG{PIPE} = sub { die "spooler pipe broke" };
print SPOOLER "stuff\n";
close SPOOLER || die "bad spool: $! $?";
そして以下の例はそこから読み込みを行いたい子プロセスを起動する方法です:
open(STATUS, "netstat -an 2>&1 |")
|| die "can't fork: $!";
while (<STATUS>) {
next if /^(tcp|udp)/;
print;
}
close STATUS || die "bad netstat: $! $?";
特定のプログラムの一つが @ARGV にあるファイル名を期待している Perl スクリプトであっていいのなら、賢いプログラマは以下のように 書くこともできます:
% program f1 "cmd1|" - f2 "cmd2|" f3 < tmpfile
そしてそれを呼んだシェルには関係なく、この Perl プログラムは f1 という ファイル、cmd1 というプロセス、標準入力(この例では tmpfile)、 f2 というファイル、cmd2 というコマンド、f3 というファイルから 読み込みを行います。 すごくいいよね?
読み込みのためのパイプを開くために、逆クォートを使って同じことが できることに気がつくかもしれません:
print grep { !/^(tcp|udp)/ } `netstat -an 2>&1`;
die "bad netstat" if $?;
その推測は表面的には正しいことのように見えるかも知れませんが、一度に メモリにすべてを読み込む必要がないので、一度にファイルの一行や 一レコードを処理するには(最初の例のほうが)より効率的なのです。 同様にプロセス全体の制御を与えるので、あなたが望めば早い時期に 子プロセスを kill することができます。
open() と close() の戻り値をチェックするときは注意してください。
パイプに対して 書き込み をしたのなら、SIGPIPE をトラップすべきです。
そうしなければ、存在しないコマンドに対するパイプを起動したときに
起こることについて考え込むことになるでしょう: open() はほとんどの
場合成功すると見込まれるでしょうが(これは fork() の成功だけを
反映します)、あなたの出力はその後で壮観に(spectacularly)失敗するでしょう。
コマンドは、実際には exec() が失敗している別のプロセスで
実行されているので、Perl はコマンドがうまく動いているかどうかを
知ることはできません。
したがって、偽のコマンド(bugus command)の読み手はすぐに end of file を
受け取り、偽のコマンドに対する書き手は事前に取り扱っておくべき
シグナルを発生させるでしょう。
以下の例を考えてみましょう:
open(FH, "|bogus") or die "can't fork: $!";
print FH "bang\n" or die "can't write: $!";
close FH or die "can't close: $!";
これはクローズするまで爆発せず、爆発すると SIGPIPE を発生させます。 これを捕らえるには、以下のようにします:
$SIG{PIPE} = 'IGNORE';
open(FH, "|bogus") or die "can't fork: $!";
print FH "bang\n" or die "can't write: $!";
close FH or die "can't close: status=$?";
メインプロセスと子プロセスで同じファイルハンドル STDIN, STDOUT, STDERR を共有します。 両方のプロセスが同時にそれらのハンドルにアクセスしようとした場合、 おかしな事が発生する可能性があります。 あなたは子プロセスのためにファイルハンドルのクローズと再オープンにしたいと 考えるかもしれません。 これは、open() を使ってパイプをオープンすることによって対処することが できますが、一部のシステムにおいては子プロセスはその親プロセスよりも 長生きすることはできません。
以下のようにしてコマンドをバックグラウンドで実行することができます:
system("cmd &");
コマンドの STDOUT と STDERR (とあなたの使うシェルによっては STDIN も)は その親プロセスのものと同一になります。 double-fork の実行によって、SIGCHLD を捕捉する必要はありません (詳しくは後述します)。
一部の場合(例えばサーバープロセスのスタート)、親プロセスと子プロセスを
完全に無関係のものにしたいことがあるでしょう。
これはしばしばデーモン化と呼ばれます。
礼儀正しいデーモンはルートディレクトリに chdir() (そのため実行ファイルの
あったディレクトリを含むファイルシステムのアンマウントを邪魔することが
ありません)し、その標準ファイル記述子を /fdev/null に
リダイレクトします。
use POSIX 'setsid';
sub daemonize {
chdir '/' or die "Can't chdir to /: $!";
open STDIN, '/dev/null' or die "Can't read /dev/null: $!";
open STDOUT, '>/dev/null'
or die "Can't write to /dev/null: $!";
defined(my $pid = fork) or die "Can't fork: $!";
exit if $pid;
die "Can't start a new session: $!" if setsid == -1;
open STDERR, '>&STDOUT' or die "Can't dup stdout: $!";
}
fork() はプロセスグループリーダー(もしそうなら setsid() は
失敗するでしょう)でないことを保証するために
setsid() の前になければなりません。
あなたの使っているシステムが sesid() 関数を持っていないのであれば、
/dev/tty をオープンして TIONCNOTTY ioctl() を代わりに使います。
詳しくは tty(4) を参照してください。
非 UNIX ユーザーはあなたの OS の Process モジュールをチェックして 他の解決策を探しましょう。
もう一つの、IPC のための興味深いアプローチはマルチプロセスになって
それぞれの間で通信を行う単一のプログラムを作るというものです。
open() 関数は "-|" や "|-" といったファイル引数を非常に
おもしろいことを行うために受け付けます: これはあなたがオープンした
ファイルハンドのための子プロセスをfork()するのです。
その子プロセスは親プロセスと同じプログラムを実行します。
これはたとえば、仮定された UID や GID のもとで実行する際に安全にファイルを
オープンするのに便利です。
マイナスに対するパイプをオープンすると、あなたはオープンした
ファイルハンドルに書き込みができ、子プロセスはそれを自分の STDIN に
見いだします。
マイナス からの パイプをオープンした場合には、子プロセスがその
STDOUT に書き出したものがオープンしたファイルハンドルから
読みだしすることができるのです。
use English '-no_match_vars';
my $sleep_count = 0;
do {
$pid = open(KID_TO_WRITE, "|-");
unless (defined $pid) {
warn "cannot fork: $!";
die "bailing out" if $sleep_count++ > 6;
sleep 10;
}
} until defined $pid;
if ($pid) { # parent
print KID_TO_WRITE @some_data;
close(KID_TO_WRITE) || warn "kid exited $?";
} else { # child
($EUID, $EGID) = ($UID, $GID); # suid progs only
open (FILE, "> /safe/file")
|| die "can't open /safe/file: $!";
while (<STDIN>) {
print FILE; # child's STDIN is parent's KID_TO_WRITE
}
exit; # don't forget this
}
このやり方を行うもう一つの一般的な例は、シェルのインターフェース抜きで
何かを実行する必要があるときでしょう。
system() を使うとそれは直接的なものですが、パイプのオープンや
バッククォートを安全に使うことができません。
これはシェルがあなたの引数を触るのを止める方法がないからです。
代わりに、exec() を直接呼び出す低レベルな制御を使います。
以下の例は、読み込み用の安全なバッククォートやパイプオープンのものです:
# add error processing as above
$pid = open(KID_TO_READ, "-|");
if ($pid) { # parent
while (<KID_TO_READ>) {
# do something interesting
}
close(KID_TO_READ) || warn "kid exited $?";
} else { # child
($EUID, $EGID) = ($UID, $GID); # suid only
exec($program, @options, @args)
|| die "can't exec program: $!";
# NOTREACHED
}
そして以下の例は、書き込み用の安全なバッククォートや パイプオープンのものです:
# add error processing as above
$pid = open(KID_TO_WRITE, "|-");
$SIG{PIPE} = sub { die "whoops, $program pipe broke" };
if ($pid) { # parent
for (@data) {
print KID_TO_WRITE;
}
close(KID_TO_WRITE) || warn "kid exited $?";
} else { # child
($EUID, $EGID) = ($UID, $GID);
exec($program, @options, @args)
|| die "can't exec program: $!";
# NOTREACHED
}
この形式の open() を使っているプロセスや、それどころか
あらゆる pipe() の使用と複数のサブプロセスをデッドロックさせるのは
とても簡単です。
上述の例は、単純で、exec() を呼び出しているので「安全」です。
一般的な安全のための原則については パイプのデッドロックを避ける を
参照してください; しかし、Safe Pipe Opens については追加のコツがあります。
特に、open FH, "|-" を使ってパイプを開くと、不要な書き込みを閉じるために
単に親プロセスで close() を使えません。
このコードを考えます:
$pid = open WRITER, "|-";
defined $pid or die "fork failed; $!";
if ($pid) {
if (my $sub_pid = fork()) {
close WRITER;
# do something else...
}
else {
# write to WRITER...
exit;
}
}
else {
# do something with STDIN...
exit;
}
上述の例で、真の親は WRITER ファイルハンドルに書き込みたくないので、
閉じます。
しかし、WRITER は open FH, "|-" を使って開かれているので、
特殊な振る舞いをします: これを閉じると waitpid() (waitpid in perlfunc を
参照してください) を呼び出し、サブプロセスが終了するのを待ちます。
もし子プロセスが "do something else" とマークした部分で何かを
待っていると、デッドロックになります。
これはまた、より複雑なコードでの中間のサブプロセスで問題になります;
これはグローバルな破壊の間に全ての開いているファイルハンドルに対して
waitpid() を呼び出します; 順序は予測不能です。
これを解決するために、以下のように、pipe(), fork(), ファイル記述子を
一つずつ設定する open() を手動で使わなければなりません:
pipe(READER, WRITER);
$pid = fork();
defined $pid or die "fork failed; $!";
if ($pid) {
close READER;
if (my $sub_pid = fork()) {
close WRITER;
}
else {
# write to WRITER...
exit;
}
# write to WRITER...
}
else {
open STDIN, "<&READER";
close WRITER;
# do something...
exit;
}
Perl 5.8.0 から パイプのために open のリスト形式を使えます;
以下のような文法で:
open KID_PS, "-|", "ps", "aux" or die $!;
ps(1) コマンドを fork し(3 以上の引数の open() のようにシェルを
起動することなく)、KID_PS ファイルハンドル経由で標準出力を読み込みます。
コマンドパイプに書き込むための対応する文法 ("-|" の代わりに
"|-") も実装されています。
これらの操作は UNIX の fork でいっぱいで、その fork が他のシステムでは 適切に実装されていない可能性があるのだということに注意してください。 それに加えて、これらのやり方は本当のマルチスレッドではありません。 スレッドについてより学びたいのであれば、後述する SEE ALSO の章で 言及されている modules ファイルを参照してください。
一般的に、複数のサブプロセスがあるなら、プロセス間通信のために 作ったパイプの書き込み側が必要のないプロセスではそれを開かないようにする ためにとても慎重になる必要があります。
この理由は、パイプから読み込んで EOF を想定している子プロセスは決して EOF を受け取ることはなく、従って決して終了しないからです。 一つのプロセスがパイプを閉じるのは閉じるために十分ではありません; EOF を読み込むには、パイプを開いた最後のプロセスが閉じる必要があります。
この時間のほとんどを避けるのを助ける unix に組み込みの機能が
いくつかあります。
例えば、ファイルハンドルには 'close on exec' フラグ (Perl では $^F
perlvar を使って 全体として 設定します) があるので、明示的に
子 program の STDIN, STDOUT, STDERR へ向いていなかったファイルハンドルを
自動的に閉じます。
従って、プロセスが実際に書いているのでない限り、全てのパイプの
書き込み側では常に明示的に直ちに close() を呼び出してください。
もし明示的に close() を呼び出していないなら、Perl は未だにグローバルな
破壊時に全てのファイルハンドルに対して close() を呼び出します。
先に警告したように、これらのファイルハンドルが Safe Pipe Open で
開かれているなら、これらは waitpid() を呼び出して、再びデッドロックの
可能性があります。
これは、片方向通信に対してうまく働きます。 では双方向通信は? あなたがやりたいだろうとまず考えることは、実際にはうまくいきません:
open(PROG_FOR_READING_AND_WRITING, "| some program |")
この状態で use warnings プラグマか -w フラグを使うのを忘れてしまうと、
以下のような診断メッセージを得る機会を逃すことになるでしょう。
Can't do bidirectional pipe at -e line 1.
本当にこういったことをしたいのなら、標準の open2() というライブラリ関数を
使うことで、パイプの両方の端点を得ることができます。
三方向(tridirectional)の入出力のための open3() もあるので、子プロセスの
STDERR を捕捉することもできるのですが、そのためには 不格好な
select() ループが必要となり、Perl の通常の入力操作を行うことが
できません。
open2() のソースを見てみれば、それが全ての接続を生成するために
UNIX での pipe() と exec() のような低水準のプリミティブを使っていることに
気がつくでしょう。
これは socketpair() を使うより効率が格段に良いのですが、移植性という面では
見劣りします。
open2() と open3() は UNIX システムやその他の POSIX に従ったシステムを
除いてはおそらく動作しないでしょう。
以下は open2() を使った例です:
use FileHandle;
use IPC::Open2;
$pid = open2(*Reader, *Writer, "cat -u -n" );
print Writer "stuff\n";
$got = <Reader>;
これに関する問題は、UNIX のバッファリングが実際にはある時点に至るまで
留まるということにあります。
ファイルハンドル Writer を自動フラッシュにしたとしても、もう一方の
端点にあるプロセスは送られたデータを適当なタイミングで
受け取ることになります; 一般的に云って、全てのことに関して即座に
反応するように強制することはできません。
上記の例では、バッファリングをしないようにするために -u フラグを
cat に与えることができたのでそれができました。
パイプ越しに使われることを想定して設計された UNIX コマンドは非常に
少数なので、この例のようなことは、両端のあるパイプのもう一方の端点にある
プログラムを自分自身で書かない限りはほとんどできないのです。
この解決策は非標準の Comm.pl ライブラリです。 これはあなたのプログラムをより信頼性のあるものとするために 擬似 TTY を使います:
require 'Comm.pl';
$ph = open_proc('cat -n');
for (1..10) {
print $ph "a line\n";
print "got back ", scalar <$ph>;
}
このやり方では、あなたが使おうとしているプログラムのソースコードを
いじくりまわすような必要はありません。
Comm ライブラリには他にも expect() や interact() といった関数もあります。
後述する SEE ALSO の章にある説明の最寄りの CPAN で、このライブラリ(と
その後継者と期待している IPC::Chat) を見つけてください。
CPAN にあるより新しいモジュール Expect.pm はこの問題に対処するものです。 このモジュールは他に IO:Pty、IO::Stty という二つの CPAN モジュールを 必要とします。 このモジュールは、ターミナルデバイスドライバと応答するような プログラムと対話するために、擬似端末をセットアップします。 もしあなたの使っているシステムがこういったものをサポートしているのであれば、 そちらを使った方が良いでしょう。
もし望むのなら、低レベルなシステムコール pipe() や fork() を
手作業で行うために使うことができます。
以下の例は単に説明のためのものですが、STDIN や STDOOUT に対する
適切なハンドルを再オープンすることができ、さらに別のプロセスを
呼び出すことができます。
#!/usr/bin/perl -w
# pipe1 - bidirectional communication using two pipe pairs
# designed for the socketpair-challenged
use IO::Handle; # thousands of lines just for autoflush :-(
pipe(PARENT_RDR, CHILD_WTR); # XXX: failure?
pipe(CHILD_RDR, PARENT_WTR); # XXX: failure?
CHILD_WTR->autoflush(1);
PARENT_WTR->autoflush(1);
if ($pid = fork) {
close PARENT_RDR; close PARENT_WTR;
print CHILD_WTR "Parent Pid $$ is sending this\n";
chomp($line = <CHILD_RDR>);
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 = <PARENT_RDR>);
print "Child Pid $$ just read this: `$line'\n";
print PARENT_WTR "Child Pid $$ is sending this\n";
close PARENT_RDR; close PARENT_WTR;
exit;
}
しかし実際に二つの pipe の呼び出しを行う必要はありません。
あなたの使っているシステムが socketpair() システムコールを
サポートしていれば、それがあなたの代わりに作業を行ってくれます。
#!/usr/bin/perl -w
# pipe2 - bidirectional communication using socketpair
# "the best ones always go both ways"
use Socket;
use IO::Handle; # thousands of lines just for autoflush :-(
# We say AF_UNIX because although *_LOCAL is the
# POSIX 1003.1g form of the constant, many machines
# still don't have it.
socketpair(CHILD, PARENT, AF_UNIX, SOCK_STREAM, PF_UNSPEC)
or die "socketpair: $!";
CHILD->autoflush(1);
PARENT->autoflush(1);
if ($pid = fork) {
close PARENT;
print CHILD "Parent Pid $$ is sending this\n";
chomp($line = <CHILD>);
print "Parent Pid $$ just read this: `$line'\n";
close CHILD;
waitpid($pid,0);
} else {
die "cannot fork: $!" unless defined $pid;
close CHILD;
chomp($line = <PARENT>);
print "Child Pid $$ just read this: `$line'\n";
print PARENT "Child Pid $$ is sending this\n";
close PARENT;
exit;
}
UNIX から派生したオペレーティングシステムに限定されることはない (例えば PC では WinSock が(幾つかの VMS ライブラリのように) ソケットサポートを提供しています)にも関らず、あなたが使っている システムではソケットが使えないかもしれません。 その場合、この項に書かれていることはあなたの役には立たないでしょう。 ソケットを使えば、仮想回路(つまり TCP ストリーム)やデータグラム(UDP パケット)の両方が可能になります。 使っているシステムに、より一層依存することになるかもしれません。
ソケットを扱うための Perl の関数呼び出しは対応する C でのシステムコールと 同じ名前を持っています。 しかし、引数に関しては二つの理由によって異なるものとなっています: 第一に、Perl のファイルハンドルは C のファイル記述子とは 異なる働きをするものである。 第二に、Perl はすでに文字列の長さを知っているので、その情報を渡す 必要がない、というものです。
Perl における古いソケットプログラムに関連する大きな問題とは、一部の
定数の値として(著しく移植性を損なってしまう)ハードコードされたものが
使われていたということです。
$AF_INET = 2 のように陽に何かを設定しているプログラムを見た事があれば、
あなたはそれが大きなトラブルになるということを知っているでしょう:
より優れたやり方は Socket モジュールを使うというものです。
これは、あなたが必要とするであろう様々な定数や関数に対するより信頼の置ける
アクセスを提供します。
NNTP や SMTP のように既に存在しているプロトコルのためにサーバー/ クライアントを書くのでなければ、あなたの作るサーバーがどのようにして クライアントが通話を終えたときを知ったり、その反対のことを 知るのかということを考えておくべきでしょう。 ほとんどのプロトコルは一行のメッセージと返事(片方のプロセスは、 “\n”を受け取ったときにもう一つのプロセスでの処理が終了したことを 知ります)か、空行に置かれたピリオドで終端される("\n.\n" がメッセージ/返事を 終端する)複数行メッセージと返事に基づいています。
インターネットでの行終端子は "\015\012" です。 UNIX で使われる ASCII のバリエーションでは、通常は“\r\n”のように 記述しますが、他のシステムでは、“\r\n”は"\015\015\012" だったり、 "\012\012\015" だったりあるいはまったく違うものであったりします。 “\015\012”は標準的な書き方(あなたが書いたままのものになります)ですが、 入力中にある独立した“\012”を受け付けることも推奨されています(が、 あなたが要求するときにはそれを穏やかなものにしましょう)。 このマニュアルページにあるプログラムについて、常に最善のものを 使ってはいませんが、あなたが Mac を使っているのでなければ 気にすることはないでしょう。
自分の使っているシステムの外側にあるもマシンにまでクライアント- サーバーの通信を広げたい場合には Internet-domain ソケットを使います。
以下のプログラムは、Internet-domain ソケットを使った TCP クライアントの 例です:
#!/usr/bin/perl -w
use strict;
use Socket;
my ($remote,$port, $iaddr, $paddr, $proto, $line);
$remote = shift || 'localhost';
$port = shift || 2345; # random port
if ($port =~ /\D/) { $port = getservbyname($port, 'tcp') }
die "No port" unless $port;
$iaddr = inet_aton($remote) || die "no host: $remote";
$paddr = sockaddr_in($port, $iaddr);
$proto = getprotobyname('tcp');
socket(SOCK, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
connect(SOCK, $paddr) || die "connect: $!";
while (defined($line = <SOCK>)) {
print $line;
}
close (SOCK) || die "close: $!";
exit;
そして以下に挙げるのが上記のクライアントと対応するサーバーです。 ここではアドレスを INADDR_ANY としているので、カーネルは multihomed hosts 上の適切なインターフェースを選択することができます。 (ファイヤーウォールやゲイトウェイの外側のように)特定のインターフェースを 使いたいのであれば、この部分を、自分の使いたい本当のアドレスで 埋めるようにすべきです。
#!/usr/bin/perl -Tw
use strict;
BEGIN { $ENV{PATH} = '/usr/ucb:/bin' }
use Socket;
use Carp;
my $EOL = "\015\012";
sub logmsg { print "$0 $$: @_ at ", scalar localtime, "\n" }
my $port = shift || 2345;
my $proto = getprotobyname('tcp');
($port) = $port =~ /^(\d+)$/ or die "invalid port";
socket(Server, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
setsockopt(Server, SOL_SOCKET, SO_REUSEADDR,
pack("l", 1)) || die "setsockopt: $!";
bind(Server, sockaddr_in($port, INADDR_ANY)) || die "bind: $!";
listen(Server,SOMAXCONN) || die "listen: $!";
logmsg "server started on port $port";
my $paddr;
$SIG{CHLD} = \&REAPER;
for ( ; $paddr = accept(Client,Server); close Client) {
my($port,$iaddr) = sockaddr_in($paddr);
my $name = gethostbyaddr($iaddr,AF_INET);
logmsg "connection from $name [",
inet_ntoa($iaddr), "]
at port $port";
print Client "Hello there, $name, it's now ",
scalar localtime, $EOL;
}
以下の例はマルチスレッドバージョンです。 これはほとんどの典型的なサーバーがそうであるようにマルチスレッドに なっていて、クライアントのリクエストを処理するためにスレイブサーバーを spawn(fork) します。 このため、マスターサーバーは新しいクライアントに対してサービスするために 即座に復帰できます。
#!/usr/bin/perl -Tw
use strict;
BEGIN { $ENV{PATH} = '/usr/ucb:/bin' }
use Socket;
use Carp;
my $EOL = "\015\012";
sub spawn; # forward declaration
sub logmsg { print "$0 $$: @_ at ", scalar localtime, "\n" }
my $port = shift || 2345;
my $proto = getprotobyname('tcp');
($port) = $port =~ /^(\d+)$/ or die "invalid port";
socket(Server, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
setsockopt(Server, SOL_SOCKET, SO_REUSEADDR,
pack("l", 1)) || die "setsockopt: $!";
bind(Server, sockaddr_in($port, INADDR_ANY)) || die "bind: $!";
listen(Server,SOMAXCONN) || die "listen: $!";
logmsg "server started on port $port";
my $waitedpid = 0;
my $paddr;
use POSIX ":sys_wait_h";
use Errno;
sub REAPER {
local $!; # don't let waitpid() overwrite current error
while ((my $pid = waitpid(-1,WNOHANG)) > 0 && WIFEXITED($?)) {
logmsg "reaped $waitedpid" . ($? ? " with exit $?" : '');
}
$SIG{CHLD} = \&REAPER; # loathe SysV
}
$SIG{CHLD} = \&REAPER;
while(1) {
$paddr = accept(Client, Server) || do {
# try again if accept() returned because a signal was received
next if $!{EINTR};
die "accept: $!";
};
my ($port, $iaddr) = sockaddr_in($paddr);
my $name = gethostbyaddr($iaddr, AF_INET);
logmsg "connection from $name [",
inet_ntoa($iaddr),
"] at port $port";
spawn sub {
$|=1;
print "Hello there, $name, it's now ", scalar localtime, $EOL;
exec '/usr/games/fortune' # XXX: `wrong' line terminators
or confess "can't exec fortune: $!";
};
close Client;
}
sub spawn {
my $coderef = shift;
unless (@_ == 0 && $coderef && ref($coderef) eq 'CODE') {
confess "usage: spawn CODEREF";
}
my $pid;
if (! defined($pid = fork)) {
logmsg "cannot fork: $!";
return;
}
elsif ($pid) {
logmsg "begat $pid";
return; # I'm the parent
}
# else I'm the child -- go spawn
open(STDIN, "<&Client") || die "can't dup client to stdin";
open(STDOUT, ">&Client") || die "can't dup client to stdout";
## open(STDERR, ">&STDOUT") || die "can't dup stdout to stderr";
exit &$coderef();
}
このサーバーはリクエストがくる度に fork() を使って子バージョンの複製を
行うので、問題を取り除きます。
このやり方は、あなたが常に望んではいないかもしれませんが、一度に多くの
リクエストを処理することができます。
fork()を使わなかったとしても、listen() は多くの一時停止した
コネクション(pending connections) を扱えます。
サーバーを fork するので、死んだ子供(UNIX 世界ではゾンビと呼ばれるもの)の
後始末に関して注意深くする必要があります。
なぜなら、そうしなければプロセステーブルがすぐに埋めつくされることに
なるからです。
ここで REAPER サブルーチンは終了した全ての子プロセスのために
waitpid() を呼び出すために使われ、従って子プロセスがきれいに終了し、
ゾンビの集団に加わらないことを確実にします。
while ループの中で accept() を呼び出して、偽の値を返すかどうかを
チェックします。
これは普通報告する必要のあるシステムエラーを示しています。
しかし、Perl 5.7.3 で導入された安全なシグナル(上述の
保留シグナル(安全なシグナル) を参照してください) の導入は、
プロセスがシグナルを受信した場合にも accept() が中断されうることを
意味します。
これは典型的には、fork した子プロセスの一つが終了して、親プロセスに
CHLD シグナルを通知した場合に起こります。
もし accept() がシグナルで中断されると、$! に EINTR がセットされます。
これが起きた場合、次の反復と次の accept() の呼び出しを安全に続行できます。
シグナルハンドラコードが $! を変更しないようにしないと、このテストが
ほぼ確実に失敗するということは重要です。
REAPER サブルーチンでは waitpid() を呼び出す前にローカル版の $! を
作成しています。
waitpid() が $! に ECHILD をセットすると(これはどの子プロセスも待っていない
ときに必然的に発生します)、これは元の値を変更せず、ローカルなコピーを
更新します。
setuid やsetgid をされていない状態で実行されているとしても、汚染検査 (perlsec を参照)をするために -T フラグを使うことをお勧めします。 これは、サーバーやその他の他の誰かのために実行される(CGI スクリプトのような) プログラムに対しては常に良い考えになります。 なぜならそうすることによって、外部の人間があなたのシステムに入ってくる ことができる可能性を減らすからです。
もう一つの TCP クライアントを見てみましょう。 これは複数の異なるマシン上の TCP の“time”サービスに接続してクライアントが 走っているシステムと時計がどれくらい違っているのを出力します:
#!/usr/bin/perl -w
use strict;
use Socket;
my $SECS_of_70_YEARS = 2208988800;
sub ctime { scalar localtime(shift) }
my $iaddr = gethostbyname('localhost');
my $proto = getprotobyname('tcp');
my $port = getservbyname('time', 'tcp');
my $paddr = sockaddr_in(0, $iaddr);
my($host);
$| = 1;
printf "%-24s %8s %s\n", "localhost", 0, ctime(time());
foreach $host (@ARGV) {
printf "%-24s ", $host;
my $hisiaddr = inet_aton($host) || die "unknown host";
my $hispaddr = sockaddr_in($port, $hisiaddr);
socket(SOCKET, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
connect(SOCKET, $hispaddr) || die "bind: $!";
my $rtime = ' ';
read(SOCKET, $rtime, 4);
close(SOCKET);
my $histime = unpack("N", $rtime) - $SECS_of_70_YEARS;
printf "%8d %s\n", $histime - time, ctime($histime);
}
Internet-domain のサーバーとクライアントは良いものですが、ローカル
コミュニケーションに関してはどうでしょうか?
同じようにセットアップすることができますが、同じ様に(通信を)行うことは
できません。
UNIX ドメインソケットはカレントホストにローカルで、しばしばパイプを
実装するために内部的に使われています。
Internet ドメインソケットとは異なり、UNIX ドメインソケットは、
ls(1) を使ってファイルシステムの中で見つけることができます。
% ls -l /dev/log
srw-rw-rw- 1 root 0 Oct 31 07:23 /dev/log
これを、Perl のファイルテスト -S を使って行えます:
unless ( -S '/dev/log' ) {
die "something's wicked with the log system";
}
UNIX ドメインクライアントの例です:
#!/usr/bin/perl -w
use Socket;
use strict;
my ($rendezvous, $line);
$rendezvous = shift || 'catsock';
socket(SOCK, PF_UNIX, SOCK_STREAM, 0) || die "socket: $!";
connect(SOCK, sockaddr_un($rendezvous)) || die "connect: $!";
while (defined($line = <SOCK>)) {
print $line;
}
exit;
そして対応するサーバーです。 ここで、あなたはやっかいなネットワーク終端子について思い煩う 必要はありません。 なぜなら、UNIX のドメインソケットはローカルホストにおいて完全に 満たされるものであって、そのため、全てはうまくいくのです。
#!/usr/bin/perl -Tw
use strict;
use Socket;
use Carp;
BEGIN { $ENV{PATH} = '/usr/ucb:/bin' }
sub spawn; # forward declaration
sub logmsg { print "$0 $$: @_ at ", scalar localtime, "\n" }
my $NAME = 'catsock';
my $uaddr = sockaddr_un($NAME);
my $proto = getprotobyname('tcp');
socket(Server,PF_UNIX,SOCK_STREAM,0) || die "socket: $!";
unlink($NAME);
bind (Server, $uaddr) || die "bind: $!";
listen(Server,SOMAXCONN) || die "listen: $!";
logmsg "server started on $NAME";
my $waitedpid;
use POSIX ":sys_wait_h";
sub REAPER {
my $child;
while (($waitedpid = waitpid(-1,WNOHANG)) > 0) {
logmsg "reaped $waitedpid" . ($? ? " with exit $?" : '');
}
$SIG{CHLD} = \&REAPER; # loathe SysV
}
$SIG{CHLD} = \&REAPER;
for ( $waitedpid = 0;
accept(Client,Server) || $waitedpid;
$waitedpid = 0, close Client)
{
next if $waitedpid;
logmsg "connection on $NAME";
spawn sub {
print "Hello there, it's now ", scalar localtime, "\n";
exec '/usr/games/fortune' or die "can't exec fortune: $!";
};
}
sub spawn {
my $coderef = shift;
unless (@_ == 0 && $coderef && ref($coderef) eq 'CODE') {
confess "usage: spawn CODEREF";
}
my $pid;
if (!defined($pid = fork)) {
logmsg "cannot fork: $!";
return;
} elsif ($pid) {
logmsg "begat $pid";
return; # I'm the parent
}
# else I'm the child -- go spawn
open(STDIN, "<&Client") || die "can't dup client to stdin";
open(STDOUT, ">&Client") || die "can't dup client to stdout";
## open(STDERR, ">&STDOUT") || die "can't dup stdout to stderr";
exit &$coderef();
}
見てわかるように、Internet domain TCP サーバーとほとんど同じです。
実際には、まったく変っていない幾つかの重複した関数 spawn(),
logmsg(), ctime(), REAPER() を取り除いてあります。
ではなぜ、単純な名前付きパイプではなく UNIX ドメインソケットを
使いたがるのでしょうか?
その理由は、名前付きパイプがあなたにセッションを与えないからです。
あなたはあるプロセスから来たデータと、それとは別のプロセスからきた
データとを区別することができません。
ソケットプログラミングを行うことで、クライアント毎に別々のセッションを
持てるようになります: これが accept() が二つの引数を取る理由です。
例えば、CGI インターフェースを通してのみ World Wide Web からアクセスされる、 長時間実行されているデータベースサーバーデーモンを持っているとしましょう。 この場合、あなたの好きなようにチェックやログの記録を実行するような小さく、 単純な CGI プログラムを持って、UNIX ドメインクライアントとして振る舞う プライベートなサーバーに接続させるといったことができるでしょう。
ソケットプログラミングに対する高水準インターフェースのために、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 など。
以下の例は“localhost”というホスト名の 13 番ポートにある“dyatime” サービスに対する TCP コネクションを作成するクライアントで、そのサーバーが 提供するデータをすべて出力します。
#!/usr/bin/perl -w
use IO::Socket;
$remote = IO::Socket::INET->new(
Proto => "tcp",
PeerAddr => "localhost",
PeerPort => "daytime(13)",
)
or die "cannot connect to daytime port at localhost";
while ( <$remote> ) { print }
このプログラムを実行すると、以下のような返事が返ってくるでしょう:
Wed May 14 08:40:46 MDT 1997
new コンストラクターに対するパラメーターの意味を説明します:
Protoこれは使用するプロトコルです。 この例では、私たちはストリーム指向のコネクション、つまり、昔ながらの普通の ファイルのように振る舞うものを使いたいので、ソケットは TCP ソケットに 接続されたものを扱います。 ソケットにはこれ以外のタイプもあることに注意してください。 たとえば、UDP プロトコルは(メッセージ送信に使われている) データグラムソケットを作成するために使うことができます。
PeerAddrこれはサーバーが実行されているリモートホストの、インターネットアドレス
もしくは名前です。
これを "www.perl.com" のような長い名前で指定することも
"204.148.40.9" のようなアドレスで指定することもできます。
先の例で使った "localhost" は、常に自分が使用している現在のマシンを
意味する特別なホスト名です。
ローカルホストに対するインターネットアドレスは "127.1" で、こちらを
使うこともできます。
PeerPortこれは接続したいサービスの名称、もしくはポート番号です。
私たちは先の例で、きちんと設定されたシステムサービスの使える
システムでなら "daytime" を使うこともできました
[FOOTNOTE: UNIXでは /etc/services にシステムサービスファイルがあります]。
しかし、実際には括弧でくくって (13) というポート番号の指定を行っていました。
単に番号を使っても同様に動作するのですが、定数は注意深いプログラマを
神経質にさせてしまいます。
コンストラクター new の戻り値が、while ループの中のファイル
ハンドルとしてどのように使われているかということに気がつきましたか?
これは間接ファイルハンドルと呼ばれるもので、ファイルハンドルを保持している
スカラー変数です。
これは、通常のファイルハンドルと同様のやり方で使うことができます。
例えば、以下のようにすれば一行読み込みができます:
$line = <$handle>;
残りの行全ての読み込みは以下のようにします:
@lines = <$handle>;
データを一行送るには以下のようにします:
print $handle "some data\n";
以下の例は、ドキュメントをそこから取るリモートホストと、そのホストから 取得するドキュメントのリストを引数に取る単純なクライアントです。 これは先の例よりも興味深いものです。 なぜなら、この例においてはサーバーの反応をフェッチする前に最初に何かを サーバーに送信するからです。
#!/usr/bin/perl -w
use IO::Socket;
unless (@ARGV > 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;
}
ここでは、“http”サービスを提供する web サーバーがその標準ポートである
80 番ポートを使っていると仮定しています。
あなたの使っている web サーバーが異なるポート(例えば 1080 とか 8080 とか)を
使用しているのであれば、名前付きパラメータペアにしてPeerPort => 8080
のような形式で指定すべきでしょう。
autoflush メソッドがソケットに対して使われます。
そうしなければシステムは私たちが送信した出力を
バッファリングしてしまうでしょう(あなたが Mac を使っているのであれば、
ネットワーク越しにデータを送信するプログラム中にあるすべての
"\n" を "\015\012" に変更する必要もあります)。
サーバーへの接続は、このプロセスの最初の一部分でしかありません: 一度接続されてしまえば、サーバーの言語を使うべきなのです。 ネットワーク上の各サーバーは、入力として期待しているそれぞれの小さな コマンド言語を持っています。 HTTP 構文において最初にサーバーに送信するのは "GET" です。 この場合、単純に指定されたドキュメントのそれぞれをリクエストします。 そう、私たちは実際には、たとえ同じホストであったとしてもドキュメント毎に 新しいコネクションを作成しています。 これが HTTP を使うときに常にそうしなければならない方法なのです。 最近のwebブラウザーではコネクションを開いたままちょっとの間リモートサーバーを 離れるリクエストをすることができますが、サーバーはそのようなリクエストを 処理しなければならないというわけではありません。
以下に挙げるのは、私たちがwebgetと呼ぶであろうプログラムを 実行した例です。
% webget www.perl.com /guanaco.html
HTTP/1.1 404 File Not Found
Date: Thu, 08 May 1997 18:02:32 GMT
Server: Apache/1.2b6
Connection: close
Content-type: text/html
<HEAD><TITLE>404 File Not Found</TITLE></HEAD>
<BODY><H1>File Not Found</H1>
The requested URL /guanaco.html was not found on this server.<P>
</BODY>
これは特定のドキュメントを見つけられないというものですからあまり 面白いものでもありません。 でも、長いレスポンスをここに載せるわけにもいかないでしょう。
このプログラムの全機能バージョン(fully-featured version)は、CPAN にある LWP モジュール中の lwp-request というプログラムを見るとよいでしょう。
一つのコマンドを送信し、一つの返答を得るというのであれば具合が良いのですが、 完全に対話的な何かを設定し、telnet のように動作するものはどうでしょうか? ここでできるのは、ある一行をタイプして答を得て、別の行をタイプしてそれに 対する答を得て…というやり方です。
このクライアントは既に出てきた二つのものよりも複雑ですが、あなたが
強力な fork 呼び出しをサポートしているシステムを使っているのであれば、
解決策は乱暴なものではありません。
通信したいなんらかのサービスに対してコネクションを作ってしまえば、プロセスの
複製を作るために fork を呼び出します。
それによる二つのプロセスはそれぞれ、非常に単純なジョブを行います:
親プロセスはソケットから入力されたすべてを標準出力にコピーし、子プロセスは
標準入力をソケットへと同じようにコピーします。
ただ一つのプロセスを使ったときに同じことをするのは 非常に
難しいでしょう。
なぜなら、二つのことを行う一つのプロセスのためのプログラムよりも
一つのことを行う二つのプロセスのためのプログラムのほうが
簡単だからです(この keep-it-simple 法則は UNIX 文化の要石で、良い
ソフトウェアエンジニアが使うように、(UNIX が)他のシステムよりも広く
使われていることの理由でしょう)。
プログラムの例です:
#!/usr/bin/perl -w
use strict;
use IO::Socket;
my ($host, $port, $kidpid, $handle, $line);
unless (@ARGV == 2) { die "usage: $0 host port" }
($host, $port) = @ARGV;
# create a tcp connection to the specified host and port
$handle = IO::Socket::INET->new(Proto => "tcp",
PeerAddr => $host,
PeerPort => $port)
or die "can't connect to port $port on $host: $!";
$handle->autoflush(1); # so output gets there right away
print STDERR "[Connected to $host:$port]\n";
# split the program into two processes, identical twins
die "can't fork: $!" unless defined($kidpid = fork());
# the if{} block runs only in the parent process
if ($kidpid) {
# copy the socket to standard output
while (defined ($line = <$handle>)) {
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 = <STDIN>)) {
print $handle $line;
}
}
親プロセスの if ブロックにある kill 関数は、リモートサーバーが
コネクションを終了してクローズしてすぐに子プロセス(else ブロックを
実行しています)にシグナルを送るためのものです。
リモートサーバーが一度に一バイト送っていて、そして、あなたが改行を
待つことなしに即座にデータを必要とする(そうそうないことでしょうが)のなら、
while ループを以下のようなものに置き換えたくなるでしょう:
my $byte;
while (sysread($handle, $byte, 1) == 1) {
print STDOUT $byte;
}
読み出しのために一バイト毎にシステムコールを行うのは実に非効率的ですが、 説明するのに簡単でとりあえずは動くのです:
常にそうであるように、サーバーのセッティングはクライアントを実行するよりも
ほんのちょっと手間がかかります。
ここで使うのは、サーバーが特定のポートで接続を待つだけという特殊な種類の
ソケットを作成するというモデルです。
これは、IO::Socket::INET->new() というメソッドをはっきりと異なる
引数を付けて呼び出してからクライアントを実行することで行います。
これは使用するプロトコルです。
クライアントと同様、ここでは "tcp" を指定します。
LocalPort 引数でローカルポートを指定します。
これはサーバーにしたいサービス名かポート番号のいずれかです(UNIX では、
1024 未満のポートはスーパーユーザー限定です)。
私たちのサンプルでは 9000 番ポートを使いますが、あなたの使っているシステムで
重複しなければ好きな番号を使うことができます。
もし既に使われているポートを使おうとすれば、"Address already in use" の
ようなメッセージを得ることとなるでしょう。
UNIX では、netstat -a コマンドを使ってサービスが現在使っているサーバーを
見ることができます。
Listen パラメーターは、クライアントを待たせておいて受け付けることのできる
コネクションの最大数を設定します。
電話の呼び出しを考えてみてください。
低水準ソケットモジュールは SOMAXCONN というそのシステムの最大値を表す
特殊なシンボルを持っています。
Reuse パラメーターは、システムがバッファーをクリアするための時間を
掛けずに私たちのサーバーを手作業で再起動するのに必要です。
上で述べたパラメーターを持った汎用のサーバーソケットが生成されれば、
そのサーバーは接続される新たなクライアントを待ちます。
accept メソッドにあるサーバーブロックはリモートクライアントからの
双方向接続を許可します(バッファリングを抑制するためにハンドルに対して
autoflush することを忘れないように)。
ユーザーに親切にするために、私たちのサーバーはコマンドの入力のプロンプトを
表示します。
ほとんどのサーバーはこうしたことをしていません。
プロンプトには改行がないので、上の例にあったような対話的な
クライアントの類では sysread を使う必要があるでしょう。
このサーバーは五種類のコマンドのいずれか一つを取り、クライアントに対して (コマンドに応じた)出力を行います。 多くのネットワークサーバーとは異なり、このサーバープログラムは一度に一つの クライアントしか扱えないということに注意してください。 マルチスレッド化されたサーバーはらくだ本の第六章でカバーされています。
以下プログラムです。
#!/usr/bin/perl -w use IO::Socket; use Net::hostent; # for OO version of gethostbyaddr
$PORT = 9000; # pick something not in use
$server = IO::Socket::INET->new( Proto => 'tcp',
LocalPort => $PORT,
Listen => SOMAXCONN,
Reuse => 1);
die "can't setup server" unless $server; print "[Server $0 accepting clients]\n";
while ($client = $server->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 通信はオーバーヘッドが低いものの、メッセージがすべて到着するという 保証がなく到着の順序もきちんと保たれていることも保証されてないために 信頼性もまた劣るものになっています。 それでも、UDP には一度に宛て先ホストの塊全体 (通常はローカルサブネット)に対して“ブロードキャスト”、“マルチキャスト”が できるということを含め、TCPに対する幾つかのアドバンテージがあります。 信頼性に関して過度に関心を持ち、作成するメッセージシステムに検査機構を 組み込もうというのであれば、むしろ TCP を使うようにした方がよいでしょう。
UDP はバイトストリーム ではなく 、そのように扱うべきでもないことに
注意してください。
これは stdio(つまり print() やその親戚) のような内部バッファリング付きの
I/O 機構を特に扱いにくくします。
以下の例のように、syswrite() か、よりよい send() を使ってください。
以下に挙げた UDP プログラムは先に挙げたインターネト TCP クライアントの 例と似ていますが、一度に一つのホストをチェックするのではなく、 マルチキャストをシミュレートし、かつ、select() を入出力のタイムアウト待ちの ために使うことにより非同期的にたくさんのチェックを行います。 TCP でこれと同じことを行うには、ホスト毎に異なるソケットハンドルを 使わなければならないでしょう。
#!/usr/bin/perl -w
use strict;
use Socket;
use Sys::Hostname;
my ( $count, $hisiaddr, $hispaddr, $histime,
$host, $iaddr, $paddr, $port, $proto,
$rin, $rout, $rtime, $SECS_of_70_YEARS);
$SECS_of_70_YEARS = 2208988800;
$iaddr = gethostbyname(hostname());
$proto = getprotobyname('udp');
$port = getservbyname('time', 'udp');
$paddr = sockaddr_in(0, $iaddr); # 0 means let kernel pick
socket(SOCKET, PF_INET, SOCK_DGRAM, $proto) || die "socket: $!";
bind(SOCKET, $paddr) || die "bind: $!";
$| = 1;
printf "%-12s %8s %s\n", "localhost", 0, scalar localtime time;
$count = 0;
for $host (@ARGV) {
$count++;
$hisiaddr = inet_aton($host) || die "unknown host";
$hispaddr = sockaddr_in($port, $hisiaddr);
defined(send(SOCKET, 0, 0, $hispaddr)) || die "send $host: $!";
}
$rin = '';
vec($rin, fileno(SOCKET), 1) = 1;
# timeout after 10.0 seconds
while ($count && select($rout = $rin, undef, undef, 10.0)) {
$rtime = '';
($hispaddr = recv(SOCKET, $rtime, 4, 0)) || die "recv: $!";
($port, $hisiaddr) = sockaddr_in($hispaddr);
$host = gethostbyaddr($hisiaddr, AF_INET);
$histime = unpack("N", $rtime) - $SECS_of_70_YEARS;
printf "%-12s ", $host;
printf "%8d %s\n", $histime - time, scalar localtime($histime);
$count--;
}
この例では一切再試行を行わないので、到達可能なホストへの接続に 失敗することがあることに注意してください。 これのもっとも有名な原因は、もし接続するホストのリストの数が十分に大きいと、 送信ホストのキューが混雑することです。
System V IPC はソケットとしてはそれ程広く使われてはいませんが、
幾つかの興味深い使用法があります。
ただし、System V の IPC や Berkley の mmap() を(異なる幾つかのプロセスの
間で変数を共有するための)共有メモリを持つ目的のために効率良く
使うことはできません。
なぜなら Perl が、あなたが望まないときに文字列の再割り付けをやってしまう
可能性があるからです。
共有メモリの使い方を例示する小さな例です。
use IPC::SysV qw(IPC_PRIVATE IPC_RMID S_IRUSR S_IWUSR);
$size = 2000;
$id = shmget(IPC_PRIVATE, $size, S_IRUSR|S_IWUSR) || die "$!";
print "shm key $id\n";
$message = "Message #1";
shmwrite($id, $message, 0, 60) || die "$!";
print "wrote: '$message'\n";
shmread($id, $buff, 0, 60) || die "$!";
print "read : '$buff'\n";
# the buffer of shmread is zero-character end-padded.
substr($buff, index($buff, "\0")) = '';
print "un" unless $buff eq $message;
print "swell\n";
print "deleting shm $id\n";
shmctl($id, IPC_RMID, 0) || die "$!";
以下はセマフォの例です:
use IPC::SysV qw(IPC_CREAT);
$IPC_KEY = 1234;
$id = semget($IPC_KEY, 10, 0666 | IPC_CREAT ) || die "$!";
print "shm key $id\n";
二つ以上のプロセスで動作するように、このコードを分割されたファイルに 置きます。 そのファイルを take と呼びます:
# create a semaphore
$IPC_KEY = 1234;
$id = semget($IPC_KEY, 0 , 0 );
die if !defined($id);
$semnum = 0;
$semflag = 0;
# 'take' semaphore
# wait for semaphore to be zero
$semop = 0;
$opstring1 = pack("s!s!s!", $semnum, $semop, $semflag);
# Increment the semaphore count
$semop = 1;
$opstring2 = pack("s!s!s!", $semnum, $semop, $semflag);
$opstring = $opstring1 . $opstring2;
semop($id,$opstring) || die "$!";
このコードを、二つ以上のプロセスで実行できるように別のファイルに 置きます。 このファイルを give と呼びます。
# 'give' the semaphore
# run this in the original process and you will see
# that the second process continues
$IPC_KEY = 1234;
$id = semget($IPC_KEY, 0, 0);
die if !defined($id);
$semnum = 0;
$semflag = 0;
# Decrement the semaphore count
$semop = -1;
$opstring = pack("s!s!s!", $semnum, $semop, $semflag);
semop($id,$opstring) || die "$!";
ここで例示した System V の IPC コードははるかな昔に書かれたもので、 へぼなものに見えます。 より現代的なものについては、Perl 5.005 から含まれている IPC::SysV モジュールを参照してください。
SysV メッセージキューを例示する簡単な例です:
use IPC::SysV qw(IPC_PRIVATE IPC_RMID IPC_CREAT S_IRUSR S_IWUSR);
my $id = msgget(IPC_PRIVATE, IPC_CREAT | S_IRUSR | S_IWUSR);
my $sent = "message";
my $type_sent = 1234;
my $rcvd;
my $type_rcvd;
if (defined $id) {
if (msgsnd($id, pack("l! a*", $type_sent, $sent), 0)) {
if (msgrcv($id, $rcvd, 60, 0, 0)) {
($type_rcvd, $rcvd) = unpack("l! a*", $rcvd);
if ($rcvd eq $sent) {
print "okay\n";
} else {
print "not okay\n";
}
} else {
die "# msgrcv failed\n";
}
} else {
die "# msgsnd failed\n";
}
msgctl($id, IPC_RMID, 0) || die "# msgctl failed: $!\n";
} else {
die "# msgget failed\n";
}
これらのルーチンのほとんどは物静かですが、何かに失敗した場合には
あなたのプログラムを終了させてしまったり捕捉されない例外を
引き起こしたりする代わりに undef を返します(実際には、新しい
Socket 変換関数の幾つかは不正な引数に対して croak() します)。
したがって要点は、これらの関数の戻り値を確認すべきであるということです。
ソケットプログラムは常に最良の成功(optimal success)のためにこのやり方で
始め、そしてサーバーに対して pound-bang line (#! の行のこと)に
汚染検査フラグ -T を追加することを忘れないようにしてください。
#!/usr/bin/perl -Tw
use strict;
use sigtrap;
use Socket;
これらのルーチンは全て、システム固有の移植性問題を作り出します。 他の場所で説明したように、Perl の振る舞いは使用しているCライブラリに 左右されます。 System V のおかしなシグナルのセマンティクスを仮定することと、単純な TCP および UDP ソケット操作に終始するようにすることがおそらくは最も 安全なもののでしょう。 たとえば、あなたが自分のプログラムに移植性を持たせるようにしたいのであれば、 ローカルな UDP データグラムのソケットを通してファイル記述子を 渡すようなことをしようとしてはいけないということです。
Tom Christiansen (Larry Wall による元の文書の部分的な名残と、 Perl Porters による示唆と共に)
ネットワークに関する事柄はまだまだたくさんあります。 ここにあることはスタートでしかありません。
Richard Stevens による非常に重要な教科書 Unix Network Programming, 2nd Edition, Volume 1 (Prentice-Hall から出版されています)があります。 ネットワークに関するほとんどの本は、C プログラマを対象としている点に 注意してください。 Perl への変換は、読者の宿題として残しておきます。
IO::Socket(3) マニュアルページにはオブジェクトライブラリの説明があり、
Socket(3) には低水準のソケットに対するインターフェースの説明があります。
perlfunc にある関数の他にも、至近にある CPAN サイトで
modules ファイルをチェックしたほうが良いでしょう(perlmodlib を
参照するか、CPAN がどこにあるかの説明がある Perl FAQ を見ると
よいでしょう)。
modlues ファイルの第 5 章は "Networking, Device Control (modems), and Interprocess Communication" に充てられていて、バンドルされなかった多くのネットワーク関連モジュール、 チャット と Expect operations, CGI プログラミング, DCE, FTP, IPC, NNTP, Proxy, Ptty, RPC, SNMP, SMTP, Telnet, スレッド、 そして ToolTalk を含んでいます。