更新を再開しようかと思ったのだが、まだネタがないので仕方なくblog風に先日撮った写真(芝公園にて、2009年4月3日)で茶を濁す。

昨年も書いているように、サイト自体をCMSかblogツールにいい加減移行したいと本当は思っていて、そのくせ時間がないので踏み切れないでいる。

VS2008はやっと自分のPCにインストールしたところで、昨年書いた課題に取りかかる以前の段階で1年以上足踏みしてしまっている。その間に生活環境が変化したため、以前描いていた計画も、実装に取りかかる遙か以前の段階で既に再検討を余儀なくされている。具体的には、DICEに関して、ある部分のみC++/CLIを用いて.NET化することを考えていた。それというのも、ネイティブコードもそろそろ潮時かと考えて、C++を利用する部分を徐々に縮小させることを意図していたからであった。現在もその方針自体は誤りではなかったと考えているが、今それを為すべきか、そのための時間があるかということを熟慮すると、同じ時間を使うにしても他にやらなければならないことがあるのではないかというのが今回至った結論である。

また、去年計画・調査だけ行って結局頓挫したものとして、どのみち日の目を見ないだろうから忘れないうちに書いてしまうと、RTMPをDICEに実装することを考えていた。それというのも、抽象サーバーフレームワークであるDICEのプロトコル実装の試金石として商業的に意味のありそうなプロトコルを是非実装しておきたかったのと、 Flashとの親和性を高めておきたかったという事情がある。サーバー用のソフトウェアスタック(と.NETで作った簡易クライアント)しかコントロールできない私にとって、Flash + JavaScriptはクライアントアプリ作成のためのRAD環境たり得た。ところが状況は変わり、C++の非常に有望なクライアント用ソフトウェアスタックが自由なライセンスの元で利用できることになり、今はそれをどう活かすかについて思案している。勘の良い諸兄ならそれが何かもうお分かりだろう。

本記事の環境はVS2005(VC8)である。PHPはPHP 5.25を用いた。PHP組み込みに関する公式の資料はPHPマニュアル第7章に存在する。46節の”Zend API: Hacking the Core of PHP“に変数の操作に関して記述がある。ところが、現時点のPHPマニュアルには、組み込みの際の初期化についてすら解説がない。PHPソースコードを展開した際にphp-5.2.5\sapi\embedフォルダに見つかるphp_embed.hならびにphp_embed.cを参照すると、初期化/終了マクロがあり、初期化の際にsapi_startup関数を呼んでいるのが分かる。これはmain\SAPI.hならびにSAPI.cに定義されており、引数となる構造体_sapi_module_structにコールバックを登録してPHPのSAPI(Server API)を初期化している。そのコールバックの中でも、php_embed_ub_writeがprintなどの出力を受ける関数で、php_embed.c内ではphp_embed_ub_writeを経由してphp_embed_single_writeに至り、標準出力へ出力されている。つまりそこをオーバライドしてやればユーザ側でスクリプトの出力を受け取れるのであり、基本的にはRuby組み込みで使われる方法と同一だが、PHPはSAPIフレームワークの中でインターフェイスをユーザ側に提供している点が異なる。

ユーザコードの概要が掴めたところで、次にPHP組み込みに必要な環境を作らなければならない。先に書いておくが、ここにまず問題がある。PHPのソースコードをダウンロードしてローカルに展開した後に、マニュアルのWindows上でのビルド方法に従ってビルドを行う。win32build.zipと bindlib_w32.zipもビルドに必要なGNUツールなどを含んでいるので所定の場所へ展開しておく必要がある。ビルドには、Visual C++ツールのコマンドプロンプトを使用する。今回は組み込みを行うので、WSHを経由してconfigure.jsを呼び出しmakeの設定を行う際に、--enable-embedを引数に加えることになる。

ところが、そのままビルドを始めると、エラーが出てストップしてしまう。エラーコードを見ると、libxmlに問題が起こっているらしい。そこで libxml2をダウンロードしてパスを通すも、やはりビルドが通らない。今度はどうやらiconvが必要なようで、最新版libiconvをダウンロー ドしてみると、なんと以前は入っていたVC++サポートがどういうわけか削除されていた。mingwでビルドせよとあるので試してみたがどうも上手くいかない。しかも、ダウンロード元がGNUだったことを思い出し、これはライセンス的にまずいのではないかと後から気付いた。iconvに由来するコードが PHPのスタティックライブラリに含まれているとすれば、PHP組み込みを行った時点でLGPLに汚染され、ユーザプログラムの配布に支障が出てしまう。 そこで、仕方なく--without-libxmlをconfigure.jsのオプションに加え、XMLサポートを諦めた。調べてみると、iconv自体はPHP 5からPHP本体に組み込まれており、php-5.2.5\ext\iconvを見る限りクリーンルーム実装がなされている。このあたりlibxmlもどうにかできないものかと思うがここでは深く追及しない。

libxml/iconvの問題以外にもビルドプロセスには問題があり、ZLIBの関数も使用できないので--disable-zlibで無効にする。これでようやくphp-5.2.5\Release_TSないしphp-5.2.5\Debug_TSに、アプリケーションにリンクするスタティックライブラリ(php5embed.lib)と実行時に必要なdllファイル(php5ts.dll)が出来上がる。次にVC++の設定として、メニューの「ツール | オプション」からVC++のディレクトリにlibファイルの場所を追加し、さらにプロジェクト設定内のincludeファイルのフォルダにphp-5.2.5\、php-5.2.5\sapi\embed、php-5.2.5\Zend、php-5.2.5\TSRMを加える。さらに、PHP_WIN32、ZEND_WIN32各シンボルの定義が必要となる。また、実際には、VC8からtime_tが64ビットになっているため_USE_32BIT_TIME_Tも定義しなければクライアントコードのビルドは成功しない。以上でどうにか環境が整ったので、以下のコードがPHP組み込みのサンプルとしてビルド、実行できる。

#include <stdio.h>
#include <tchar.h>

#include <iostream>
#include <string>
#include <cstdio>

#include <php.h>
#include <php_embed.h>

using namespace std;

static int php_ub_write(const char* str, unsigned int str_length TSRMLS_DC)
{
	string s(str, str_length);

	cout << s;

	return str_length;
}

static void php_log_message(char* message)
{
	cerr << "php_log_message: " << message  << endl;
}

static void php_sapi_error(int type, const char* fmt, ...)
{
	va_list va;
	va_start(va, fmt);
	printf("php_sapi_error: ");
	vprintf(fmt, va);
	va_end(va);
}

int _tmain(int argc, _TCHAR* argv[])
{
	php_embed_module.ub_write = php_ub_write;
	php_embed_module.log_message = php_log_message;
	php_embed_module.sapi_error = php_sapi_error;

	char* argv2[] = {""};

	PHP_EMBED_START_BLOCK(0, argv2);

	zval* v = NULL;

	MAKE_STD_ZVAL(v);
	ZVAL_STRING(v, "Hello", 1);
	ZEND_SET_SYMBOL(&amp;EG(symbol_table), "hello", v);

	zend_eval_string("print \"$hello \";$hello = \"World\";", NULL, "" TSRMLS_CC);

	if (v->type == IS_STRING)
	{
		cout << string(v->value.str.val, v->value.str.len) << endl;
	}

	PHP_EMBED_END_BLOCK();

    return 0;
}

PHP関係のヘッダは他の標準ヘッダの後に置かなければエラーが出るようだ。コードの内容は、上述のように出力関数をオーバライドし、さらに$helloという名称の変数を作成して操作し最終的にHello Worldを表示するというたわいのないものである。PHP_EMBED_START_BLOCK、PHP_EMBED_END_BLOCKが初期化、終了のマクロで、内部でzend_first_try/zend_catchのブロックを作っているので変数のスコープに注意しなければならない。前回のPerl組み込みの場合だとPerlでの例外をラップする仕組みを自前で作る必要があったのに対し、PHPの方はZendが面倒を見てくれる点は有り難い。

とはいえ、このようにしてビルドした物だとPHP 5の特徴的機能であるところのXMLがおそらく使用できない事はかなりの損失である。そこで、次に考えられる方法として、PHPの配布バイナリ内のライブラリを利用するという道がある。PHPの配布バイナリには、(一体どうやってビルドしたのかは謎だが)php5embed.libとphp5ts.dllが含まれているのである。Dependency Walkerでphp5ts.dllを覗いてみてもCライブラリがスタティックリンクされているので一見使い勝手が良いように見える。ところが、落とし穴があり、デバッグ版だとVC++のdllが異なってくるので、これを使った場合正常にデバッグが出来なくなってしまう。そこで、開発の際には自分でビルドしたlibファイルを使い、リリース版は配布バイナリの方を利用することになる。

しかし、拍子抜けではあるが、最終的にDICEでは上述のようなストレートな組み込み方法は採らなかった。というのも、不透明なライセンスの問題に加え、上述のやり方ではPHPスクリプトやASP(Active Server Pages)の最も有用な機能である、コードブロックのHTML埋め込みが出来ないのである(出来る方法があるのかも知れないがそれは本稿の範囲を超える)。これではこちらで配布するWebサーバに組み込んで利用するという本来の目的にそぐわない。そこで、結局DICEの方にISAPIエクステンションのサポートを入れ、ISAPIを経由してPHPをロードする形に落ち着いた。PHPはSAPIという組み込みインタフェイスを用意しており、PHPの配布バイナリにはISAPIエクステンションのdllが含まれている。この組み込み方法であればライセンス問題は完全にクリーンであり、PHP設定ファイルの読み込みなどの付随的処理もPHP側で全て自動的に行ってくれる。PHPはかなり素直なISAPIアクセスしか行わないので、別にwebサーバへの組み込み用途ではなくても、Windows上で ライセンスが気になる場合等はPHPそのものの組み込みの代わりにISAPIを経由してコントロールするのも一つの有力な選択肢ではないかと思う。他方で、配布を目的とせずサーバ側でのみ利用する場合はライセンスに関する問題はもちろん発生しないため、最初に取り上げた組み込み手順もそれはそれで有用となる局面もあるだろう。

他人の作ったツールを使う場合の居心地の悪さというものはソフトウェアを書く際に利用するミドルウェアについてもしばしば感じることになる。オープンソースでソースコードとシンボルが手に入るならともかくそうでない場合は、いや手に入る場合であったとしても、分厚いミドルウェアの利用者はハッカーたることを強制されてしまう。その意味ではWindowsというものも巨大なミドルウェアであって、最近はMSDNのMicrosoft社員blogで様々な情報公開が行われていて助かることしきりである。しかし実態として見れば、不十分なAPIドキュメントあるいはAPIそのものについての補遺を非公式の場で行うことは現状を追認するエクスキューズでしかない。ミドルウェアによってもたらされる利益がある一方で、ミドルウェアを原因とするフラストレーションは相手がはっきりしているだけに顕在化しやすい。Windowsのような、選択の余地がないケースでは尚更である。

DICEについて言うと、今回からSSPIを使うのをやめてOpenSSLに切り替えた。もう1つの変更は逆方向で、これまで8年間C++を用いる開発には常にSTLportを使い続けてきたのをやめて、今回からVC++のC++ライブラリを使うように変更した。VS2005からSxSになってインストールが面倒になったにも関わらず、である。C++標準ライブラリの変更自体は、これまでデバッグの関係で両対応にしていたので何ら問題はない。STLportの利点 は、かつてVC6時代にあったiostreamやロケールのバグが修正されていたり、SGI STL譲りのhash_map、ropeといったコンテナ、それからmalloc呼び出しを抑えるノードアロケータ、さらに名称の由来である移植性などで ある。加えて、後年メインテナーが変更になって以来、iostreamのさらなる修正やbig fileサポート、組み込みプラットフォームサポート、ユニットテスト追加、basic_stringのスタティックバッファ、+=ではなく+でbasic_stringを繋げる場合の最適化、ノードアロケータのロックフリー化、など様々な改良が施されてきた。VC++添付のライブラリはDinkumwareという会社のOEMで、そこのP.J. Plauger氏(以前Cマガジンで連載があった)が去年だったかニュースグループでSTLportの状況をかなり口汚く大人げないスタンスで論難し、反論に遭っていたのを見たことがある。

STLportを捨てることを決めたのは、VS2008の機能リスト中に、STLとマネージド型のマーシャリングが自動的になされるといった.NET絡みの親和性を見つけて、これはもう避けられないと感じた事による。STLportを使っていると、他のC++ライブラリと併せて使った場合に問題が起こることが多く、その度に苦しめられたという問題に関しては、長年使ってきたという既成事実のおかげでどうにか切り抜けられてきていた。それでも、マルチコア環境でSTLportノー ドアロケータが実際は標準mallocに劣るというテスト結果(OSのヒープアロケータの薄いラッパーであるmallocの方がスレッドやスレッドローカルデータについてよく知っているのだから当たり前だ)や、VC++がC++例外のソースコードを提供していないせいでSTLportを使う場合もVC++のdllが丸ごと必要になるという問題は以前から不愉快に思っていた。ノードアロケータはユーザランドでのメモリリークになるが、引き替えにパフォーマンスが得られるならと思い許容していたにもかかわらず、実は期待した効果を得られていないというのは特にショックだった。また、DICEではそもそもiostreamを使っていないのでその部分でのSTLportの恩恵は全くない。STLportをやめてみてまず最初に判明したのは、これまでIntellisenseが正常に機能しなかった原因はSTLportにあったということだ。てっきりLokiが問題なのだと思い込んでいたが、そうではなかった。当然、MSVCのC++ライブラリだとSTLコンテナやbasic_stringの中身もデバッガで易々と見ることが出来る。唯一勿体ないと感じるのはbasic_stringの最適化くらいだけれども、どうしても無ければならないという類の物でもない。むしろ、デバッガでbasic_stringの中身を見るときに一々スタティックバッファとダイナミックバッファの両方を見たりせずに済むようになって、せいせいした。unordered associative container (hash_map)も今後TR1絡みで動いていくだろうから変更にはいい機会だったと思う。

他方、VS2008には困ったこともあった。ATL属性が廃止になっていて、実はDICEのサービスはこれを使っている。しかし、実際に汚い物なので、廃止されるのもむべなるかなといったところである。今回のDICEは、こういったWindows世界での波風からできるだけ逃れるというのも一つのテーマになっていて、上記のMSVCのC++ライブラリへの回帰は残念ながらそれに逆行するが、このページの2006年11月30日の項で述べたWeb UIへの移行はついに達成した。Web UIでカバーしきれない部分は、これもMicrosoftの束縛の象徴であるMFCを使っていたDICEAdminShellを廃止し、DICE Managerという、機能を最低限に絞ったヘルパーアプリケーションをC#/Windows Formsで作って新たに入れた。2006年11月30日の項でも書いたようにMFCは本当に無茶苦茶で、DICEAdminShell廃止も MFCに直接起因している。VS2003からVS2005に移行したときにビルドし直したところ、実行ファイルがXPでは動くのにWindows Server 2003では動かないようになってしまったのだ。VS2008では驚くべき事にMFCがまだ残っていて機能拡張までされているそうだが、この辺で引導を渡してやっていた方が結果的に各方面が幸せだったのではないか。DICEの.NET WebアプリケーションコンテナもVS2005移行に伴って.NET Framework 1.1から2.0に移行し、マネージドコード部分に多少書き換えを要した。.NET Framework 3.5が2.0ベースであるのは賢明な方針である。

Web UIは、それなりに道具が揃うとかなり楽に作れる。今回は勉強を兼ねて、prototype.jsに代表される外部のAJAXライブラリは一切使わず、自前でフレームワークを 作った。どのみちIDEが無いのだから大して手間は変わらない。無意味にファットなライブラリに興味はなく、また標準ライブラリを書き換えてあったり、一 旦導入すると以降はそのライブラリのスタイルを強要されたりするのも煩わしい。道具の一つとして、PHPのSmartyのようなテンプレートエンジンを JavaScriptでXHTMLのカスタムタグとDOMを利用して作ろうと思ったところ、XML名前空間やxhtmlについてIEはIE7でもサポートがろくになされていないのがわかり、またFirefoxにせよapplication/xml+xhtmlが必要になるため、仕方なくspanタグを使って作った。もう一つテンプレートエンジン絡みで参ったのは、<p>などのブロックタグが実行時にJavaScriptによって他のブロックタグの内側に挿入されると、IEが「未知の実行時エラー」を出すことだ。勿論規格的には正しい動作だが、普段はエラーに寛容なIEらしからぬ振る舞いで、VSのデバッガでもよくわからない部分へ行くので、原因を探すのに苦労した。

今のところWeb UIは通常のwebページの外見で、Web IRCクライアントで利用したときにせいぜいタブインターフェイスをサポートするくらいだが、将来的にはWebデスクトップに必要なMDIをサポートできるように、ウィジェットクラスの階層を定義できたらと思っている。今回は、デモとして、管理者用にリモートファイルダウンロードマネージャを入れた。 GetRightやIrvineのようなダウンロードマネージャアプリケーションに似た機能をWebから利用できる。サポート機能はまだプリミティブで、ベーシック認証やリザルトコード302などはサポー トしていないが、HTTP/1.1のchunked encodingは完全にサポートしているので、Perl/Rubyで以前書いたツールのスーパーセットになっている。

Web UIについて書いていて今気付いたが、DICEに新しいライブラリをもう一つ導入している。メンバー登録時に表示されるCAPTCHAを、GDI+を使って実装した。今回Vistaを正式サポートした際に、諸々の理由でWindows 2000を動作環境から外したので、これが可能になった。とはいえGDIを使えば済む話でパフォーマンスもそちらの方が有利ではあるものの、GDI+は何かと楽である。オープンソースの画像ライブラリだと、最近はFirefoxなどで使われている、ハードウェアアクセラレーションが入ったCairoが一番有名だろうか。ただ、これも他のオープンソースライブラリの例に漏れずlibpngなどに依存しているので、環境を作るのに労力が要る。昔FreeBSD のサーバで使うC++の掲示板用にCAPTCHAを入れた時にはpaintlibというクロスプラットフォームライブラリを使っていて、これは2年前に開発中止になってしまっている。

さて、今後は、DICEについてもう一段さらにジャンプを予定している。それが済んだらようやっと頻繁にリリースを出来る環境が出来るのではないかと思う。ゲームの方は、かなりの長期間離れていた後に、最近UT3が出たので下手ながらたまにオンライン対戦をやっている。UT2004は時間の無駄遣いが恐ろしくなりアンインストールするほどにプレイしたので今回も期待していたが、若干物足りない。売り上げは残念な結果に終わっているのでいよいよPCゲームも(MMOとSteamで買えるゲーム以外は)終焉に至ったかと感慨深い。

For me, the main concern about OpenSSL had been its putative close relationship with the BSD socket architecture that is not compatible with asynchronous sockets and I/O completion ports. Another concern was about OpenSSL’s vulnerabilities against security breaches. OpenSSL has been an active target by crackers and one of the most scrutinized library. Not that Microsoft’s implementation is any better, but as far as I know OpenSSL gets many security advisories about it through its update history.

On the other hand, SSPI’s complex nature as an abstraction layer for multiple protocols had been a growing pain. Since the DICE is built with I/O completion ports, it was pretty messy to embed SSPI negotiation in combination with asynchronous sockets. After the sour experience of implementing IRC over SSL with SSPI on asynchrounous sockets and I/O completion ports some years ago, I was not so thrilled to touch it again to implement HTTPS. I needed a better, simpler framework to get the job done.

In updating the DICE to 0.9.0.0 after a long hiatus, I took the new version as a chance to address awkward points that had been long overlooked, sometimes even breaking compatibility with older versions. One of such problems in the DICE was SSL-related implementation. That’s why I took a second look at OpenSSL. Though it may contain unknown security flaws, its core cryptographic functions are actively upgraded to the latest standard spec unlike Microsoft’s implementation. Also it’s nice in terms of compiler/linker global optimization that the source code is available.

So what is the key to the actual usage of OpenSSL in asynchronous sockets? I browsed the sparse user manual and found the necessary tool for me: memory BIO.

BIO is an “I/O abstraction, it hides many of the underlying I/O details from an application” according to the OpenSSL document (What does B in BIO stand for anyway?). Also a “memory BIO is a source/sink BIO which uses memory for its I/O.” This basically means you can do SSL negotiation without touching a BSD socket or other platform-specific stuff at all. All you need to do is feed encrypted data into a memory BIO until it’s ready to dump something meaningful decrypted out of it.

While the title of this article mentions “asynchronous”, the sample code below uses traditional synchronous sockets. In fact, the simple abstraction by memory BIO allows smooth transition from synchronous sockets to asynchronous sockets since buffering memory BIO is exactly the same process as parsing a plain message by waiting for a whole message packet to arrive in asynchronous callbacks. In addition, you had to manually set up an SSL handshake at the beginning of a connection by yourself in SSPI while BIO in OpenSSL completely hides it from a client code. I could replace SSPI with OpenSSL for the already implemented IRC over SSL, and then could implement HTTPS in the latest version of the DICE by making the flow described in this sample code asynchronous.

The only caveat in making it asynchronous is it’s a bit difficult to support SSL renegotiation. Though it’s rare, sometimes SSL resets SSL properties at the middle of connection to make it difficult for crackers to collect necessary data. When it happens, you have to save the context such as a partially decrypted message, then do handshake again, and go back to where you originally were by restoring the original state in a new SSL context. In synchronous connection all these steps can occur between 2 braces in a certain function, but in asynchronous sockets it’s hard to suspend it by saving the context and resume it from the original point, since you have to juggle many more states in your session state machine to fully support renegotiation.

This test code of a synchronous HTTPS server was written and tested with VS2005 SP1 on Windows XP SP2. You have to build OpenSSL by obtaining its source code prior to building this sample. The OpenSSL version I used was 0.9.8g. After building OpenSSL, you have to add libeay32.lib and ssleay32.lib in the out32 folder under the OpenSSL source root directory to the linker input option in the VC++ project of the sample code, in addition to ws2_32.lib for Winsock 2.

// openssltest.cpp

// InitializeCriticalSectionAndSpinCount
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#endif _WIN32_WINNT

#include <windows.h>

#include <tchar.h>

#include <openssl/ssl.h>
#include <openssl/err.h>

#include <iostream>
#include <string>

using namespace std;

To use OpenSSL in a multithread application you have to implement necessary synchronization primitives for OpenSSL with your platform-supplied functions. In this sample application, I used CRITICAL_SECTION and InitializeCriticalSectionAndSpinCount available in Windows 2000 and later. Its wrapper class Synchronizer does synchronization in various OpenSSL callbacks.

class Synchronizer
{
private:
	CRITICAL_SECTION lock_;

public:
	__forceinline Synchronizer()
	{
		InitializeCriticalSectionAndSpinCount(&lock_, 4000);
	}
	__forceinline ~Synchronizer()
	{
		DeleteCriticalSection(&lock_);
	}

	__forceinline void acquire()
	{
		__try
		{
			EnterCriticalSection(&lock_);
		}
		__except (EXCEPTION_EXECUTE_HANDLER)
		{
		}
	}

	__forceinline void release()
	{
		LeaveCriticalSection(&lock_);
	}
};

static Synchronizer* openssl_locks = 0;

struct CRYPTO_dynlock_value
{
	Synchronizer s;
};

static void funcOpenSSLLockingCallback(
	int mode,
	int type,
	const char* file,
	int line
)
{
	if (mode & CRYPTO_LOCK)
		openssl_locks[type].acquire();
	else
		openssl_locks[type].release();
}

static unsigned long funcOpenSSLIDCallback(void)
{
	return GetCurrentThreadId();
}

static CRYPTO_dynlock_value* funcOpenSSLDynCreateCallback(
	const char* file,
	int line
)
{
	return new CRYPTO_dynlock_value;
}

static void funcOpenSSLDynDestroyCallback(
	CRYPTO_dynlock_value* l,
	const char* file,
	int line
)
{
    delete l;
}

static void funcOpenSSLDynLockCallback(
	int mode,
	CRYPTO_dynlock_value* l,
	const char* file,
	int line
)
{
	if (mode & CRYPTO_LOCK)
		l->s.acquire();
	else
		l->s.release();
}

A function to get an EVP_PKEY RSA private key object.

EVP_PKEY* get_evp_pkey(RSA* rsa, int priv)
{
	RSA* key = (priv ? RSAPrivateKey_dup(rsa): RSAPublicKey_dup(rsa));
	if (!key)
		goto error;

	EVP_PKEY* pkey = EVP_PKEY_new();
	if (!pkey)
		goto error;

	if (!(EVP_PKEY_assign_RSA(pkey, key)))
		goto error;

	return pkey;

error:
	if (pkey)
		EVP_PKEY_free(pkey);

	if (key)
		RSA_free(key);

	return NULL;
}

A function to generate an X509-format certificate and RSA public key. It’s signed by a private key.

static X509* create_certificate(
	RSA* rsa,
	RSA* rsaSign,
	const char* cname,
	const char* cnameSign,
	const char* pszOrgName,
	unsigned int certLifetime
)
{
	time_t start_time = time(NULL);
	time_t end_time = start_time + certLifetime;

	EVP_PKEY* sign_pkey = get_evp_pkey(rsaSign, 1);
	if (!sign_pkey)
		goto error;

	EVP_PKEY* pkey = get_evp_pkey(rsa, 0);
	if (!pkey)
		goto error;

	X509* x509 = X509_new();
	if (!x509)
		goto error;
	if (!(X509_set_version(x509, 2)))
		goto error;
	if (!(ASN1_INTEGER_set(X509_get_serialNumber(x509), (long)start_time)))
		goto error;

	X509_NAME* name = X509_NAME_new();
	if (!name)
		goto error;

	int nid = OBJ_txt2nid("organizationName");
	if (nid == NID_undef)
		goto error;
	if (!(X509_NAME_add_entry_by_NID(name, nid, MBSTRING_ASC, (unsigned char*)pszOrgName, -1, -1, 0)))
		goto error;
	if ((nid = OBJ_txt2nid("commonName")) == NID_undef)
		goto error;
	if (!(X509_NAME_add_entry_by_NID(name, nid, MBSTRING_ASC, (unsigned char*)cname, -1, -1, 0)))
		goto error;
	if (!(X509_set_subject_name(x509, name)))
		goto error;

	X509_NAME* name_issuer = X509_NAME_new();
	if (!name_issuer)
		goto error;
	if ((nid = OBJ_txt2nid("organizationName")) == NID_undef)
		goto error;
	if (!(X509_NAME_add_entry_by_NID(name_issuer, nid, MBSTRING_ASC, (unsigned char*)pszOrgName, -1, -1, 0)))
		goto error;
	if ((nid = OBJ_txt2nid("commonName")) == NID_undef)
		goto error;
	if (!(X509_NAME_add_entry_by_NID(name_issuer, nid, MBSTRING_ASC, (unsigned char*)cnameSign, -1, -1, 0)))
		goto error;
	if (!(X509_set_issuer_name(x509, name_issuer)))
		goto error;

	if (!X509_time_adj(X509_get_notBefore(x509), 0, &start_time))
		goto error;

	if (!X509_time_adj(X509_get_notAfter(x509), 0, &end_time))
		goto error;
	if (!X509_set_pubkey(x509, pkey))
		goto error;
	if (!X509_sign(x509, sign_pkey, EVP_sha1()))
		goto error;

	goto done;

error:
	if (x509)
	{
		X509_free(x509);
		x509 = NULL;
	}

done:
	if (sign_pkey)
		EVP_PKEY_free(sign_pkey);
	if (pkey)
		EVP_PKEY_free(pkey);
	if (name)
		X509_NAME_free(name);
	if (name_issuer)
		X509_NAME_free(name_issuer);

	return x509;
}

An error report function for an SSL object.

void reportError(SSL* ssl, int result)
{
	if (result <= 0)
	{
		int error = SSL_get_error(ssl, result);

		switch (error)
		{
			case SSL_ERROR_ZERO_RETURN:
				cout << "SSL_ERROR_ZERO_RETURN" << endl;
				break;
			case SSL_ERROR_NONE:
				cout << "SSL_ERROR_NONE" << endl;
				break;
			case SSL_ERROR_WANT_READ:
				cout << "SSL_ERROR_WANT_READ" << endl;
				break;
			default:
			{
				char buffer[256];

				while (error != 0)
				{
					ERR_error_string_n(error, buffer, sizeof(buffer));

					cout << "Error: " << error << " - " << buffer << endl;

					error = ERR_get_error();
				}
			}

			break;
		}
	}
}

The main function begins by setting up OpenSSL synchronization primitives, then creates a new SSL context object SSL_CTX. This global OpenSSL context should not be mistaken as the per-connection context object SSL that will be introduced later.

int _tmain(int argc, _TCHAR* argv[])
{
#ifdef _DEBUG
	// OpenSSL internal memory-leak checkers
	CRYPTO_malloc_debug_init();
	CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);
	CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
#endif

	openssl_locks = new Synchronizer[CRYPTO_num_locks()];

	// callbacks for static lock
	CRYPTO_set_locking_callback(funcOpenSSLLockingCallback);
	CRYPTO_set_id_callback(funcOpenSSLIDCallback);

	// callbacks for dynamic lock
	CRYPTO_set_dynlock_create_callback(funcOpenSSLDynCreateCallback);
	CRYPTO_set_dynlock_destroy_callback(funcOpenSSLDynDestroyCallback);
	CRYPTO_set_dynlock_lock_callback(funcOpenSSLDynLockCallback);

	// Load algorithms and error strings.
	SSL_load_error_strings();
	SSL_library_init();

	// Compatible with SSLv2, SSLv3 and TLSv1
	SSL_METHOD* method = SSLv23_server_method();

	// Create new context from method.
	SSL_CTX* ctx = SSL_CTX_new(method);

	// SSL_new() creates a new SSL structure which is needed to hold the data for a TLS/SSL connection.
	// The new structure inherits the settings of the underlying context ctx: connection method (SSLv2/v3/TLSv1),
	// options, verification settings, timeout settings.

The next thing to do is key-pair/certificate generation for public key en/decryption. This sample application uses a self-signed certificate to omit the need of a valid certificate.

	RSA* rsa = RSA_generate_key(1024, 65537, NULL, NULL);
	if (!rsa)
	{
		cerr << "RSA_generate_key" << endl;
		return 1;
	}

	const char* pszCommonName = "test name";
	X509* cert = create_certificate(rsa, rsa, pszCommonName, pszCommonName, "DICE", 3 * 365 * 24 * 60 * 60 /* 3 years */);
	if (!cert)
	{
		cerr << "Couldn't create a certificate" << endl;
		return 1;
	}

	///////////////////////////////////////////////////////////////////////////

	if (SSL_CTX_use_RSAPrivateKey(ctx, rsa) <= 0)
	{
		ERR_print_errors_fp(stderr);
		return 1;
	}

	if (SSL_CTX_use_certificate(ctx, cert) <= 0)
	{
		ERR_print_errors_fp(stderr);
		return 1;
	}

	RSA_free(rsa);

	X509_free(cert);

	if (!SSL_CTX_check_private_key(ctx))
	{
		cerr << "Private key is invalid." << endl;
		return 1;
	}
	else
		cout << "Private key is OK" << endl;

	//////////////////////////////////////////////////////////////////////////////////

Setting up Winsock 2 and a listener socket to create a network server.

	cout << "Preparing socket" << endl;

	WORD wVersionRequested = MAKEWORD(2,1);
	WSADATA wsaData;
	int nRet = WSAStartup(wVersionRequested, &amp;wsaData);

	if (wsaData.wVersion != wVersionRequested)
	{
		cerr << "Wrong version" << endl;
		return 1;
	}

	SOCKET	listenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (listenSocket == INVALID_SOCKET)
	{
		cerr << "socket()" << endl;
		return 1;
	}

	SOCKADDR_IN saServer;
	saServer.sin_family = AF_INET;
	saServer.sin_addr.s_addr = INADDR_ANY;
	saServer.sin_port = htons(443);

	nRet = bind(listenSocket, (LPSOCKADDR)&amp;saServer, sizeof(struct sockaddr));
	if (nRet == SOCKET_ERROR)
	{
		closesocket(listenSocket);
		cerr << "bind()" << endl;
		return 1;
	}

	nRet = listen(listenSocket, SOMAXCONN);
	if (nRet == SOCKET_ERROR)
	{
		closesocket(listenSocket);
		cerr << "listen()" << endl;
		return 1;
	}

	bool bQuit = false;

	cout << "Ready" << endl;

Everything is ready, now let’s get into the actual server connection loop. When it accepts a new connection, it creates a new SSL object that encapsulates a single SSL connection. Also it creates memory BIO buffers for input and output.

	while (1)
	{
		SSL* ssl = SSL_new(ctx);
		BIO* bioIn = BIO_new(BIO_s_mem());
		BIO* bioOut = BIO_new(BIO_s_mem());

		// SSL_set_bio() connects the BIOs rbio and wbio for the read and write operations of the TLS/SSL
		// (encrypted) side of ssl.
		SSL_set_bio(ssl, bioIn, bioOut);

		SSL_set_accept_state(ssl);

		SOCKET remoteSocket = accept(
			listenSocket,
			NULL,
			NULL
		);

		if (remoteSocket == INVALID_SOCKET)
		{
			closesocket(listenSocket);
			cerr << "accept()" << endl;
			return 1;
		}

		cout << "Accepted" << endl;

		char szBuf[128];

		memset(szBuf, 0, sizeof(szBuf));

		bool bHandShakeOver = false;
		bool bReplyOver = false;

		const char* reply = "HTTP/1.0 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 14\r\nConnection: close\r\n\r\nthis is a test";

		string strBuffer;

		while (1)
		{
			nRet = recv(remoteSocket, szBuf, sizeof(szBuf),	0);
			if (nRet == SOCKET_ERROR)
			{
				cerr << "recv() - SOCKET_ERROR" << endl;
				break;
			}

			if (nRet > 0)
			{
				int bufferUsed = BIO_write(bioIn, szBuf, nRet);
				if (bufferUsed == -1 || bufferUsed == -2 || bufferUsed == 0)
				{
					// error
				}

				// SSL read loop
				while (1)
				{
					// SSL_read() tries to read num bytes from the specified ssl into the buffer buf.
					int bytesOut = SSL_read(ssl, (void*)szBuf, sizeof(szBuf));
					if (bytesOut > 0)
					{
						strBuffer.append(szBuf, bytesOut);

						if ((strBuffer.size() > 4 &amp;&amp; strBuffer.find("\r\n\r\n", strBuffer.size() - 4) != string::npos)
							|| (strBuffer.size() > 2 &amp;&amp; strBuffer.find("\n\n", strBuffer.size() - 2) != string::npos)
						)
						{
							cout << "message size: " << strBuffer.size() << endl << "message: " << strBuffer << endl;

							bReplyOver = true;

							if (strBuffer.find("quit") != string::npos)
								bQuit = true;

							// SSL_write() writes num bytes from the buffer buf into the specified ssl connection.
							int result = SSL_write(ssl, reply, strlen(reply));
							if (result <= 0)
							{
								reportError(ssl, result);
								bReplyOver = true;
							}

							break;
						}
					}
					else
					{
						if (SSL_want_read(ssl))
						{
							cout << "SSL_want_read" << endl;
						}
						else
						{
							reportError(ssl, bytesOut);
							bReplyOver = true;
							break;
						}

						if (!bHandShakeOver &amp;&amp; SSL_is_init_finished(ssl))
						{
							cout << "Handshake has been finished" << endl;
							bHandShakeOver = true;

							char cipdesc[128];
							SSL_CIPHER* sc = SSL_get_current_cipher(ssl);
							if (sc)
								cout << "encryption: " << SSL_CIPHER_description(sc, cipdesc, sizeof(cipdesc)) << endl;
						}

						break;
					}
				}
			}
			else if (nRet == 0)
			{ // the connection has been gracefully closed
				break;
			}

			while (1)
			{
				// BIO_ctrl_pending() returns the number of bytes buffered in a BIO.
				size_t pending = BIO_ctrl_pending(bioOut);
				if (pending > 0)
				{
					cout << "BIO_ctrl_pending(bioOut) == " << pending << endl;

					//  BIO_read() attempts to read len bytes from BIO b and places the data in buf.
					int bytesToSend = BIO_read(bioOut, (void*)szBuf, sizeof(szBuf) > pending ? pending : sizeof(szBuf));
					if (bytesToSend > 0)
					{
						cout << "BIO_read(bioOut) == " << bytesToSend << endl;

						int sent = 0;
						while (1)
						{
							nRet = send(remoteSocket, szBuf + sent, bytesToSend, 0);
							if (nRet == SOCKET_ERROR)
							{
								bReplyOver = true;
								cerr << "send() - SOCKET_ERROR" << endl;
								break;
							}
							else
							{
								sent += nRet;
								bytesToSend -= nRet;
								if (bytesToSend == 0)
									break;
							}
						}
					}
					else if (!BIO_should_retry(bioOut))
					{// BIO_should_retry() is true if the call that produced this condition should then be retried at a later time.
						reportError(ssl, bytesToSend);
					}
				}
				else
				{
					cout << "BIO_ctrl_pending(bioOut) == 0" << endl;
					break;
				}
			}

			if (bReplyOver)
			{
				cout << "post-reply" << endl;
				break;
			}
		}

After it’s done you have to clean up all resources. If there’s a memory leak, CRYPTO_mem_leaks_fp will print it out.

		closesocket(remoteSocket);

		// this frees associated BIO too, so no need for BIO_free
		SSL_free(ssl);

		if (bQuit)
			break;
	}

	closesocket(listenSocket);

	WSACleanup();

	//////////////////////////////////////////////////////////////////////////////////

	SSL_CTX_free(ctx);

	CRYPTO_set_dynlock_create_callback(NULL);
	CRYPTO_set_dynlock_destroy_callback(NULL);
	CRYPTO_set_dynlock_lock_callback(NULL);

	CRYPTO_set_locking_callback(NULL);
	CRYPTO_set_id_callback(NULL);

	delete[] openssl_locks;
	openssl_locks = 0;

	EVP_cleanup();
	CRYPTO_cleanup_all_ex_data();
	ERR_remove_state(0);
	ERR_free_strings();

#ifdef _DEBUG
	CRYPTO_mem_leaks_fp(stdout);
#endif

	return 0;
}

When you run this sample code it listens to the standard HTTPS port 443. Start with a web browser and open “https://127.0.0.1/” to see how an SSL connection is processed. To stop this server, put “quit” in a request URL (“https://127.0.0.1/quit”).

But people can never be lazy enough, setting it up with context information each time will soon become a boring task especially when you want to asynchronously call a member function of a C++ object. But it’s not possible to make it completelly dynamic, either. You have to manually write a wrapper function, since QueueUserWorkItem is a mere C function that knows jack about C++. This article introduces a minimalistic toolkit AsyncDelegate.h that lends itself to solving this issue by using C++ templates.

To use AsyncDelegate.h, declare an asynchronously called member function and define an inner class for context information. This inner class can have a ctor/dtor if needed.

#include <string>
#include "AsyncDelegate.h"

class X
{
public:

// ...

	struct ContextY : AsyncDelegateContextHeader<X>
	{ // you can add parameters as members.
		std::string strParameter_;
	};

	void callbackY(ContextY* pContext);
};

X::callbackY is defined like this in a .cpp file:

void X::callbackY(ContextY* pContext)
{
	// do something with pContext_->strParameter_
}

Now you can activate it anywhere you want where a pointer to a target X object is available.

X* p = new X;

// ...

{
	AsyncDelegate<
		X,
		X::ContextY,
		&amp;amp;X::callbackY
	> c(p);

	c.pContext_->strParameter_ = &quot;parameter&quot;;

	// an asynchronous call to X::callbackY is implicitly initiated here by the destructor of c
}

X::callbackY is called in the context of the specific X object p with a ContextY object as a parameter. In other words, AsyncDelegate.h is a tool to do deferred execution of this member function call.

X* p = new X;

ContextY pContext;

p->callbackY(pContext);

Let’s take a look at the actual AsyncDelegate.h.

// AsyncDelegate.h

#ifndef CALC_ASYNCDELEGATE_H
#define CALC_ASYNCDELEGATE_H

#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#endif _WIN32_WINNT

#include <windows.h>

AsyncDelegateContextHeader is inserted before a context object as a hidden information header that knows to which object this call belongs.

template <class T>
struct AsyncDelegateContextHeader
{
	T* pSelf_;
};

This class casts a void parameter into T and destructs it at the end of a function call.

template <class T>
class AsyncDelegateContextCleaner
{
private:
	AsyncDelegateContextCleaner() {}
public:
	T* pContext_;

	explicit AsyncDelegateContextCleaner(LPVOID lpParameter) : pContext_((T*)lpParameter) {}
	~AsyncDelegateContextCleaner()
	{
		delete(pContext_);
	}
};

MemFunPointerCreator is a class to make a C++ member function pointer type from 2 template parameter types. This class is required to put a member function pointer in the template parameters of queueUserWorkItemThreadProc.

template <class T, class C>
struct MemFunPointerCreator
{
	typedef void (T::* ClientMemFunPointerType)(C*);
};

This function template creates a function called by QueueUserWorkItem. A C++ member function pointer created by MemFunPointerCreator is set as a non-type template parameter.

template <class T, class C, typename MemFunPointerCreator<T, C>::ClientMemFunPointerType pMemberFunction>
DWORD WINAPI queueUserWorkItemThreadProc(LPVOID lpParameter)
{
	AsyncDelegateContextCleaner<C> c(lpParameter);

	((c.pContext_->pSelf_)->*pMemberFunction)(c.pContext_);

	return 1;
}

This is the main class exposed to a user. If bLong is true QueueUserWorkItem is called with WT_EXECUTELONGFUNCTION that implies spawning a new thread which is the default behavior of this tool.

template <
	class T,
	class C,
	typename MemFunPointerCreator<T, C>::ClientMemFunPointerType pMemberFunction,
	bool bLong_ = true
>
struct AsyncDelegate
{
	C* pContext_;

	explicit AsyncDelegate(T* p)
	{
		pContext_ = new C;
		pContext_->pSelf_ = p;
	}

	~AsyncDelegate()
	{
		QueueUserWorkItem(
			queueUserWorkItemThreadProc<T, C, pMemberFunction>, // starting address
			pContext_, // function data
			bLong_ ? WT_EXECUTELONGFUNCTION : WT_EXECUTEDEFAULT // worker options
		);
	}
};

#endif CALC_ASYNCDELEGATE_H

It may be counter-intuitive to call this tool a “delegate” as it doesn’t support copy and other smart pointer properties, but it’s OK for me because its usage is limited to kicking a worker thread immediately.

その時点まで一旦遡ってから改めて俯瞰すると、最近のWebサービスを巡る再評価の流れもそれがどうしたと斜に構えやすい。XMLも5年くらい前に流行り、当時はXMLスキーマが今後重要になると言われていたが、そのあたりの知識が役に立つ局面が以後拡大したとは思えない。そういうわけで、この辺りの物事は個人的な関心からは長いこと外れていた。2007年の現在それらはつまらない玩具のようなものに留まるのか、それとも個人ユーザにとって真に使える道具なのか。近頃の各種Webサービスは、APIを開放し、プレスリリースを出して客寄せを行い、利用者が増えたら閉じるという、提供企業による手軽な宣伝活動の産物であり、個人ユーザ囲い込みの道具である。それを利用する個人の動機はWeb広告業界に投じられている金で、その量が5年前とは相当異なる以上、以前とは位相が異なってはいるわけだ。Webサービス同士の競争が起こり良質なサービスが数多く提供されるまでになれば面白くなるかもしれない。しかし、Webサービスを介して提供される元ネタが数少ない企業に独占されている現状では、そんなシナリオが実現する蓋然性は低く、バリエーションの少ない似通ったWebサービスを「マッシュアップ」と称してデプロイする個人は、IT企業の走狗として活動しながら細々と広告収入を稼 ぐことになる。

今回の試みでは、「はてな」 の認証WebサービスAPIと、「はてな」のキーワードWebサービスAPIを利用している。1つ目のWebアプリケーションは、「はてな」認証APIを 利用した、「はてな」ユーザが特定の他ユーザに外部サーバを介して任意のデータファイルを渡すためのファイルアップローダである。言語はRubyで、RubyのWebサーバMongrelのモジュールとして書かれている。もう1つのWebアプリケーションは、はてなキーワードAPIを利用した穴埋めクイズ作成と、はてなキーワード連想グラフの視覚化を行う。言語はPerlで、PerlのWebサーバPOE::Component::Server::HTTPのモジュールとして書かれている。

これらは、双方ともスクリプト内でWebサーバモジュールをインクルードするので、コンソールからrubyなりperlなりを通してスクリプトを実行すればそのまま動作し、ホスト用のWebサーバを別途必要としない。起動時に設定ファイルの内容を読んで、以降はWebサーバの一部としてリクエストに応じるWebアプリケーションである。前回のPerlとRubyの比較ではマルチスレッドと組み込みがポイントだったのに対し、今回は、Webアプリケーションの作成と簡易Webサーバという、Webアプリケーションをめぐる 環境の比較を行うという趣向だ。マルチスレッドに関しては、Mongrelが当然のようにマルチスレッドで、モジュールも対応が必要なのに対し、POEの 方はマルチスレッドに対応していないようである。

双方のWebサーバともプロダクション環境に適した性能を有するサーバではなく、またここで解説するWebアプリケーションはXSS対策や SQLインジェクション対策などのセキュリティ上のケアを欠いているので、あくまで各WebサービスAPIの動作サンプルとしてのみ御覧いた だきたい。ソースコードの文字コードは双方ともUTF-8で、Windows XP SP2上にて作成し、Microsoft Internet Explorer 7ならびにFirefox 3.0a1 trunk build 20061218で動作確認している。「はてな」のWeb APIの仕様は本記事を書いた2006年末の時点のものに依っているので、仕様変更によって任意の時点でこれらのアプリケーションが動かなくなっている可能性もある。

では一つ目の、Rubyアプリケーションの方から見ていこう。hatenawebapp1.confは設定ファイルで、YAMLフォーマットである。Webサーバのポートや、認証APIに与えるキー、データベースファイル名などを設定する。

# hatenawebapp1.conf
#
# configuration file for hatenawebapp1.rb

# Bound address
bound_address: "127.0.0.1"

# Bound port
bound_port: 80

# API key for Hatena Auth
api_key: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# Private key for Hatena Auth
private_key: "xxxxxxxxxxxxxxxx"

# File name for the SQLite database
db_filename: "hatenawebapp1.db"

# Path for uploaded files
file_store_path: "./store"

以下はスクリプト本体hatenawebapp1.rbで、ruby 1.8.5 (2006-12-04 patchlevel 2) [i386-mswin32]で動作確認した。必要ライブラリは、
RubyGems-0.9.0
mongrel-0.3.13.3-mswin32
sqlite3-ruby-1.1.0-mswin32
hatenaapiauth-0.1.0
uuidtools-1.0.0
scrapi-1.2.0
と、rubygemsツールで取得可能な依存ライブラリである。尚、sqlite3のライブラリのバイナリが別途必要で、Windowsの場合はスクリプトのディレクトリにsqlite3.dllを、Unixの場合もSQLite公式サイトで入手できるライブラリのバイナリをパスの通った場所へ置く必要がある。また、Mongrelは0.3.13.3を使用しているが、アップデートが頻繁なので異なるバージョンは不具合が出る可能性もある。

=begin

hatenawebapp1.rb

Sample Web Application 1 with Hatena Web Service API : File Transfer between Hatena Users

by RyuK (klassphere[at.mark]gmail.com)

http://zzz.zggg.com/

http://aiueo.da.ru/

[Requirements (tested on Microsoft Windows XP)]

ruby 1.8.5 (2006-12-04 patchlevel 2) [i386-mswin32]

mongrel-0.3.13.3-mswin32
sqlite3-ruby-1.1.0-mswin32
hatenaapiauth-0.1.0
uuidtools-1.0.0
scrapi-1.2.0

... and other dependent Ruby gems

=end

require 'rubygems'

require 'mongrel'
require 'yaml'
require 'sync'
require 'fileutils'
require 'pathname'
require 'sqlite3'
require 'hatena/api/auth'
require 'uuidtools'
require 'scrapi'

YAMLの設定ファイルをロードし、SQLiteデータベースのテーブルを無ければ新規作成する。

conf_filename = $PROGRAM_NAME.clone
begin
	$conf = YAML.load_file conf_filename.sub!(/\.rb/, '.conf')

	pn = Pathname.new($conf["file_store_path"])
	begin
		$conf["file_store_path"] = pn.realpath
	rescue SystemCallError
		Dir.mkdir(pn.to_s, 0701)
		$conf["file_store_path"] = pn.realpath
	end

	$db = SQLite3::Database.new($conf["db_filename"])

rescue Exception => e
	STDERR.puts e.to_s
	exit(1)
end

# ofn = original file name, rfn = real file name

begin
	$db.execute(<<SQL
create table files(
	sender TEXT,
	receiver TEXT,
	ofn TEXT,
	rfn TEXT,
	date INTEGER,
	size INTEGER
);
SQL
	)
rescue SQLite3::SQLException => e
	if e.to_s != "table files already exists"
		puts e.to_s
		exit(1)
	end
end

$db.extend(Sync_m)

Webサーバのモジュールなので、データベースアクセスのためのグローバルオブジェクト$dbはSync_mを使用してマルチスレッド対応にしておく。アップロードされてくるファイルのファイルサイズと、受け取り済みのデータのサイズとを保存するために、Structクラスを使ってDownloadProgressという構造体を作っておく。さらに、$download_progressというHashのオブジェクトを生成し、このオブジェクトがQUERY_STRINGリクエストパラメータとDownloadProgressオブジェクトとの対応表を保存する。$download_progressは、デザインパターンで言うところのObserverパターンで、ダウンロード状況のview(MVCの’V')として複数のwebからのリクエストによって同時に参照される可能性があるため、同じようにマルチスレッド対応にしなければならない。

$verified_users_ipaddress = Hash.new # ip - user
$verified_users_ipaddress.extend(Sync_m)

$existent_users = Hash.new # user - dummy
$existent_users.extend(Sync_m)

DownloadProgress = Struct.new("DownloadProgress", :total_size, :current_size)

$download_progress = Hash.new
$download_progress.extend(Sync_m) # user - DP

「はてな」の認証APIの初期化関数を呼び出し、次いで表示するページ内のヘッダをそのままヒアドキュメントを使ってスクリプト内に書いている。

$hatena_auth = Hatena::API::Auth.new(:api_key => $conf["api_key"], :secret => $conf["private_key"])

$page_head =<<EOS
<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>#{$PROGRAM_NAME}</title>
</head>
<body>
<p>Proof of Concept: File Transfer between Hatena Users</p>
EOS

$page_end =<<EOS
</body>
</html>
EOS

def page_head_with_onload(onload)
	<<EOS
<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>#{$PROGRAM_NAME}</title>
</head>
<body onload="#{onload}">
<p>Proof of Concept: File Transfer between Hatena Users</p>
EOS

end

以下に、Mongrelのハンドラ関数群が続く。各種デフォルトハンドラをオーバーライドすることにより、WebアプリケーションはMongrelの動作をカスタマイズするというのがMongrelモジュールの基本コンセプトである。まずは、ユーザが最初にサーバのルートパス(‘/’)にアクセスしたときに、「はてな」のIDとパスワードを認証APIに対して差し出すように促す。processというメソッドが ユーザ定義フィルタの役割を果たし、requestを受けてresponseを返す。

# Mongrel handlers #########################################

class RootHandler < Mongrel::HttpHandler
	def process(request, response)
		response.start do |head, out|
			head["Content-Type"] = "text/html"

			out << <<EOS
#{$page_head}

<p>If you are a Hatena user and want to transfer a file to another user,
<a href=\"#{$hatena_auth.uri_to_login}\">please follow this link</a> to the uploader.</p>

#{$page_end}
EOS
		end
	end
end

このスクリプトの一番最後にMongrel起動時の初期設定を行う部分があるので、そこを見てもらうとして、このUploaderHandlerは、”/uploader” というパスにアクセスした場合のハンドラである。リクエスト中のクエリ文字列(request.params["QUERY_STRING"])を解析し、認証情報 を取り出して「はてな」認証APIに与える。「はてな」ユーザとして認証されると、$verified_users_ipaddressハッシュ表にリモートIPアドレスとユーザ名の組が保存される。ちなみに、このアプリケーションはIPアドレス1つあたり1ユーザとして認識しており、まともなセッション管理を行っていないので、実際に使用するには厳密なセッション管理が必要である。

class UploaderHandler < Mongrel::HttpHandler
	def show_error(response, message)
		response.start do |head, out|
			head["Content-Type"] = "text/html"
			out << message
		end
	end

	def process(request, response)
		unknown_error_page =<<EOS
#{$page_head}

<p>Error: Unknown Error</p>
<script language="JavaScript">
<!--
history.go(-1)
//-->
</script>

#{$page_end}
EOS

		auth_error_page =<<EOS
#{$page_head}

<p>Error: Authorization Failed</p>

#{$page_end}
EOS

		cert_key = ""
		if request.params["QUERY_STRING"] =~ /cert=([^&amp;]+)/
			cert_key = $1
		else
			show_error(response, unknown_error_page)
			return
		end

		user = nil
		begin
			user = $hatena_auth.login(cert_key)
		rescue Hatena::API::AuthError
			show_error(response, auth_error_page)
			return
		end

		$verified_users_ipaddress.synchronize() do
			if $verified_users_ipaddress.size > 10000
				$verified_users_ipaddress.clear
			end
			$verified_users_ipaddress[request.params[Mongrel::Const::REMOTE_ADDR]] = user['name']
		end

このページのヘッダはJavaScriptを含んでいて、AJAXの簡単なフレームワークと、「はてな」ユーザ名の実在性を確かめるメソッド、ファイルのアップロード状態をポーリングしながら進捗バーを動的に表示するメソッドなどを含む。AJAXによる画面遷移無しのファイルアップロードを実現するために、ファイルのアップロード先を隠しiframeにするというテクニックが使用されている。

		response.start do |head, out|
			head["Content-Type"] = "text/html"

			results =<<EOS
#{page_head_with_onload("setup('#{user['name']}')")}
<script language="JavaScript">
<!--

var isMozilla = navigator.userAgent.indexOf('Gecko') != -1;
var isIE = window.ActiveXObject;

function createHttpRequest()
{
	if (isIE)
	{
		try
		{ // CLSID_XMLHTTP
			// v 3.0
			return new ActiveXObject("Msxml2.XMLHTTP");
		}
		catch (e)
		{
			try
			{// v 2.x
				return new ActiveXObject("Microsoft.XMLHTTP");
			}
			catch (e2)
			{
				return null;
			}
		}
	}
	else if (window.XMLHttpRequest) // non-IE
	{
		var hr = new XMLHttpRequest();
		if (isMozilla)
			hr.overrideMimeType('text/xml');
		return hr;
	}
	else
	{
		return null;
	}
}

function sendHTTP(data, method, uri, callback, async, caller)
{
	var hr = createHttpRequest();

	var args = new Array();
	args.push(hr);
	for (var i = 6; i < arguments.length; ++i)
	{
		args.push(arguments[i]);
	}

	try
	{
		hr.open(method, uri, async);
		hr.setRequestHeader("If-Modified-Since", "Thu, 01 Jun 1970 00:00:00 GMT");

		hr.onreadystatechange = function()
		{
			if (hr.readyState == 4)
			{
				callback.apply(caller, args);
			}
		}

		hr.send(data);
		delete hr;
	}
	catch(e)
	{
		alert("sendHTTP: " + e);
	}
}

function setup(owner_name)
{
	loadFileList(owner_name);
	checkUsername();
}

var filename = "";
var query_progress = "";
var time_start = 0;

function startPolling(form)
{
	if (form.filename.value == "")
	{
		alert("Invalid file name");
		return;
	}

	if (form.receiver.value == "")
	{
		alert("Invalid user name");
		return;
	}

	var x = document.getElementById("hidden_div");
	if (x)
		document.body.removeChild(x);

	var d = document.createElement('div');
	d.setAttribute("id", "hidden_div");
	d.innerHTML='<iframe id="hidden_iframe" name="hidden_iframe" style="display: none; width: 0px; height: 0px; border: 0px"></iframe>';
	document.body.appendChild(d);

	form.button_upload.disabled = true;
	filename = form.filename.value;

	document.getElementById("form_area").innerHTML = ("<p>Uploading <b>" + filename + "</b></p>");

	query_progress = (form.sender.value + '&amp;' + form.receiver.value + '&amp;' + filename);

	form.action = ("/receiver?" + query_progress);

	var d = new Date();
	time_start = d.getTime();

	form.submit();

	pollDownloadProgress();
}

pollDownloadProgress関数を1秒毎にタイマー呼び出しして/query_progressへAJAX問い合わせを行い、 ダウンロード済みのファイルサイズを更新しつつ進捗バーを伸ばす。

function pollDownloadProgress()
{
	sendHTTP('', 'POST', './query_progress' + '?' + query_progress, pollDownloadProgressCallback, true);

	if (filename != "")
		setTimeout("pollDownloadProgress();", 1000);
}

function pollDownloadProgressCallback(hr)
{
	var nodelist = hr.responseXML.getElementsByTagName("f");
	if (!nodelist || nodelist.length == 0)
		return;

	var current_size = 0;
	var total_size = 0;

	for (var i = 0; i < nodelist.length; ++i)
	{
		var n = nodelist.item(i);
		if (n == null)
			return;

		var nn = n.firstChild;
		if (nn == null)
			return;

		while (nn != null)
		{
			// nn.textContent == Mozilla only
			// NODE_TEXT == 3 || NODE_CDATA_SECTION == 4
			if (nn != null &amp;&amp; (nn.nodeType == 3 || nn.nodeType == 4))
			{
				if (nn.nodeValue != "")
				{
					var matched = nn.nodeValue.match(/(\\d+)\\/(\\d+)/);
					if (matched)
					{
						current_size = parseInt(matched[1], 10);
						total_size = parseInt(matched[2], 10);

						setProgressBar(current_size, total_size);
					}
				}
			}

			nn = nn.nextSibling;
		}
	}
}

function setProgressBar(received_size, total_size)
{
	document.getElementById("d2").style.width = 400 * (received_size / total_size) + "px";

	var d = new Date();
	var elapsed_time = (d.getTime() - time_start) / 1000;
	if (elapsed_time <= 0)
		elapsed_time = 1;

	var speed = parseInt(received_size / elapsed_time / 1024, 10);

	if (400 * (received_size / total_size) >= 75)
		document.getElementById("d1").innerHTML
			= "<font size=-1>" + parseInt(received_size / total_size * 100) + "% (" + speed.toString() + "KB/s)</font>";
}

“/check_username”というパスに、あるユーザ名が実在の「はてな」ユーザかどうか確かめるサービス(後述のCheckUsernameHandler)が動いているので、そこに対してAJAXで問い合わせを行う。

var checked_user = "";
var check_username_requesting = false;

// onchange doesn't work until the focus is out
function checkUsername()
{
	if (document.getElementById("receiver").value != ""
    	&& document.getElementById("receiver").value != checked_user && !check_username_requesting)
	{
		check_username_requesting = true;
		checked_user = document.getElementById("receiver").value;
		document.getElementById("form_area").innerHTML = ("<p><blink>Checking if <b"
        		+ checked_user + "</b> is an existing Hatena user...</blink></p>");
		sendHTTP(checked_user, 'POST', './check_username', checkUsernameCallback, true);
	}

	setTimeout(checkUsername, 3000);
}

function isNotUser()
{
	document.getElementById("form_area").innerHTML = ("<p><b>" + checked_user + "</b> is not a Hatena user.</p>");
	document.getElementById("button_upload").disabled = true;
}

function checkUsernameCallback(hr)
{
	// Can't use responseXML.getElementById() -
	// For responseXML.getElementById() to return an element with the matching id value, XMLHttpRequest
	// implementations must be aware of the underlying schema/DTD that defines an id attribute of type ID.
	// Currently browsers are not schema/DTD aware for XMLHttpRequests, although they support well-known DTDs
	// like HTML and XHTML for documents.

	var nodelist = hr.responseXML.getElementsByTagName("r");
	if (!nodelist || nodelist.length == 0)
		isNotUser();

	check_username_requesting = false;
	for (var i = 0; i < nodelist.length; ++i)
	{
		var n = nodelist.item(i);
		if (n == null)
		{
			isNotUser();
			continue;
		}

		var nn = n.firstChild;
		if (nn == null)
		{
			isNotUser();
			continue;
		}

		while (nn != null)
		{
			// nn.textContent == Mozilla only
			// NODE_TEXT == 3 || NODE_CDATA_SECTION == 4
			if (nn != null &amp;&amp; (nn.nodeType == 3 || nn.nodeType == 4))
			{
				if (nn.nodeValue != "")
				{
					document.getElementById("button_upload").disabled = false;
					checked_user = nn.nodeValue;
					document.getElementById("receiver").value = nn.nodeValue;
					document.getElementById("form_area").innerHTML = ("<p><b>" + checked_user + "</b> is an existing Hatena user.</p>");
				}
			}

			nn = nn.nextSibling;
		}
	}

	check_username_requesting = false;
}

function loadFileList(owner_name)
{
	sendHTTP('', 'POST', './list_files' + '?' + owner_name, loadFileListCallback, true);
}

function unixtime2localdate(t)
{
	var d = new Date;
	d.setTime(t * 1000);
	return d.toLocaleString();
}

function loadFileListCallback(hr)
{
	var out = "";

	var nodelist = hr.responseXML.getElementsByTagName("myfile");
	if (nodelist)
	{
		out += "<p>Your files sent to other users:</p>";
		for (var i = 0; i < nodelist.length; ++i)
		{
			var e = nodelist.item(i);
			out += "<p><a href='./downloader/";
			out += e.getAttribute("rfn");
			out += "'><b>";
			out += e.getAttribute("ofn");
			out += "</b></a> (Size: ";
			out += Math.floor(parseInt(e.getAttribute("size"), 10) / 1024).toString();
			out += "KB - To: <a target='_blank' href='http://www.hatena.ne.jp/user?userid=";
			out += e.getAttribute("r");
			out += "'>";
			out += e.getAttribute("r");
			out += "</a> - Date: ";
			out += unixtime2localdate(parseInt(e.getAttribute("d"), 10));
			out += ")</p>";
		}
		if (nodelist.length == 0)
			out += "<p>(no files)</p>";
	}

	nodelist = hr.responseXML.getElementsByTagName("sentfile");
	if (nodelist)
	{
		out += "<p>Files sent to you from other users:</p>";
		for (var i = 0; i < nodelist.length; ++i)
		{
			var e = nodelist.item(i);
			out += "<p><a href='./downloader/";
			out += e.getAttribute("rfn");
			out += "'><b>";
			out += e.getAttribute("ofn");
			out += "</b></a> (Size: ";
			out += Math.floor(parseInt(e.getAttribute("size"), 10) / 1024).toString();
			out += "KB - From: <a target='_blank' href='http://www.hatena.ne.jp/user?userid=";
			out += e.getAttribute("s");
			out += "'>";
			out += e.getAttribute("s");
			out += "</a> - Date: ";
			out += unixtime2localdate(parseInt(e.getAttribute("d"), 10));
			out += ")</p>";
		}
		if (nodelist.length == 0)
			out += "<p>(no files)</p>";
	}

	document.getElementById("files_list").innerHTML = out;
}

//-->
</script>

<p>Welcome <b>#{user['name']}</b> @ Hatena.</p>
<p>You are now authorized to upload a file to transfer to another Hatena user.</p>

<span id="form_area"><p>Fill in the name of the receiving user and upload a file.</p></span>

<p>
<!-- the colon at the end of startPolling() is required. -->
<form method="POST" id="file_form" action="" enctype="multipart/form-data"
	target="hidden_iframe" onsubmit="startPolling(this); return false;">
<input type="hidden" name="sender" value="#{user['name']}">
Receiving Hatena User: <input type="text" id="receiver" name="receiver" size="16"><br><br>
File to upload: <input type="file" name="filename" size="80">
<input type="submit" id="button_upload" value="Upload this file" disabled>
</form>
</p>

<p>
<div id="empty" style="background-color: #cccccc; border: 1px solid black; height: 30px; width: 400px; padding: 0px;" align="left"/>
<div id="d2" style="position: relative; top: 0px; left: 0px; background-color: #333333;
height: 30px; width: 0px; padding-top: 5px; padding: 0px;"/>
<div id="d1" style="position: relative; top: 0px; left: 0px; color: #f0ffff; height: 30px; text-align: center; font: bold;
	padding: 0px; padding-top: 5px;"/></div></div></div>
</p>

<span id="files_list"></span>

#{$page_end}
EOS
			out << results
		end
	end
end

“/downloader”でアクセスできる、他ユーザが自分宛にアップロードしたファイルを受け取りダウンロードするためのURLのハンドラを定義する。

class DownloaderHandler < Mongrel::DirHandler
	def initialize(path, listing_allowed=true, index_html="index.html")
		super(path, listing_allowed, index_html)

		#Mongrel::DirHandler::add_mime_type(".zip", "application/zip")
		#Mongrel::DirHandler::add_mime_type(".rar", "application/x-rar-compressed")
		#Mongrel::DirHandler::add_mime_type(".lzh", "application/x-lzh");
		#Mongrel::DirHandler::add_mime_type(".xml", "text/xml");
	end

	def process(request, response)
		user = nil
		$verified_users_ipaddress.synchronize(Sync_m::SH) do
			if $verified_users_ipaddress.include?(request.params[Mongrel::Const::REMOTE_ADDR])
				user = $verified_users_ipaddress[request.params[Mongrel::Const::REMOTE_ADDR]]
			end
		end

		unless user
			response.reset
			response.start do |head, out|
				head["Content-Type"] = "text/html"
				out << "Authorization Failed - <a href=\"#{$hatena_auth.uri_to_login}\">Verify again</a>"
			end
			return
		end

		req_method = request.params[Mongrel::Const::REQUEST_METHOD] || Mongrel::Const::GET
		req_path = can_serve request.params[Mongrel::Const::PATH_INFO]

		if not req_path
			response.reset
			response.start(404) do |head, out|
				out << "File not found"
			end
     		else
			original_filename = ""
			real_filename = request.params[Mongrel::Const::PATH_INFO].clone
			real_filename.gsub!("/", "");

			if real_filename =~ /[^a-zA-Z0-9_-\.]/ || user =~ /[^a-zA-Z0-9_-]/
				response.reset
				response.start(403) do |head, out|
					out << "Invalid Request"
				end
				return
			end

			$db.synchronize(Sync_m::SH) do
				$db.execute("select * from files where rfn = '#{real_filename}' AND receiver = '#{user}'") do |row|
					original_filename = row[2]
				end
			end

			if original_filename == ""
				response.reset
				response.start(403) do |head, out|
					out << "Not Authorized"
				end
				return
			end

			response.header["Content-Disposition"] = "filename=\"#{original_filename}\"";
			begin
				if req_method == Mongrel::Const::HEAD
					send_file(req_path, request, response, true)
				elsif req_method == Mongrel::Const::GET
					send_file(req_path, request, response, false)
				else
					response.start(403) {|head, out| out.write(Mongrel::ONLY_HEAD_GET) }
				end
			rescue => details
				STDERR.puts "Error sending file #{req_path}: #{details}"
			end
		end
	end
end

“/receiver”のパスが、ユーザがファイルをアップロードする対象である。 request_progressメソッドはリクエストのデータを一定量受け取る度にMongrelが呼び出すイベントコールバックで、これをオーバーライドすることによって、アップロードされてくるファイルのアップロード済みデータ量の数値を逐次更新する。Mongrel::CGIWrapperを 使用してHTMLフォームから送信されてくるデータを解析しているが、使用したMongrelのバージョンではファイルをアップロードしている場合に正常 にそれぞれのクエリ要素を受け取れないというバグがあるので、迂回策として生のデータを正規表現で検索している。ファイルのダウンロードが済むと、Mongrel::CGIWrapperの仕様に従って、アップロードされてきたファイルのサイズに応じ、一時バッファもしくは一時ファイルから、実際のファイル保存先へとデータを移す。

class ReceiverHandler < Mongrel::HttpHandler
	def initialize
		@request_notify = true
	end

	def request_progress(params, clen, total)
		$download_progress.synchronize() do
			if $download_progress.size > 1000
				$download_progress.clear
			end
			$download_progress[params["QUERY_STRING"]] = Struct::DownloadProgress.new(total, total - clen)
		end
	end

	def gen_stored_filename()
		return UUID.timestamp_create.to_s
	end

	def process(request, response)
		cgi = Mongrel::CGIWrapper.new(request, response)

		# can't use cgi["sender"] and cgi["receiver"] for multipart/form-data due to a possible bug of Mongrel 0.3.13.3

		sender = nil
		receiver = nil
		original_filename = nil

		if request.params["QUERY_STRING"] =~ /^([^&amp;]+)&amp;([^&amp;]+)&amp;(.+)/
			sender = $1
			receiver = $2
			original_filename = $3
			original_filename.gsub!("'", "")
			original_filename.gsub!(/.*\\/, "")
			original_filename.gsub!(".*/", "")
		end

		if sender =~ /[^a-zA-Z0-9_-]/ || receiver =~ /[^a-zA-Z0-9_-]/ || original_filename =~ /[^a-zA-Z0-9_-\.\\]/
			response.reset
			response.start(403) do |head, out|
				out << "Invalid Request"
			end
			return
		end

		$verified_users_ipaddress.synchronize(Sync_m::SH) do
			if $verified_users_ipaddress.include?(request.params[Mongrel::Const::REMOTE_ADDR])
				if sender != $verified_users_ipaddress[request.params[Mongrel::Const::REMOTE_ADDR]]
					sender = nil
				end
			else
				sender = nil
			end
		end

		$existent_users.synchronize(Sync_m::SH) do
			unless $existent_users.include?(receiver)
				receiver = nil
			end
		end

		unless sender &amp;&amp; receiver &amp;&amp; original_filename
			response.start do |head, out|
				head["Content-Type"] = "text/html"

				out << <<EOS
#{$page_head}

<script language="JavaScript">
<!--

parent.document.getElementById("form_area").innerHTML
		= ("<p>An authorization error happened in uploading <b>" + parent.filename
        	+ "</b>. <a href=\\"#{$hatena_auth.uri_to_login}\\">Please retry</a></p>");
parent.filename = "";
parent.setProgressBar(0, 0);

//-->
</script>

#{$page_end}
EOS
			end
			return
		end

		$download_progress.synchronize() do
			$download_progress.delete(request.params["QUERY_STRING"])
		end

		file = cgi['filename']

		real_filename = gen_stored_filename()

		begin
			if file.size >= 10240 then
				FileUtils.cp(file.path, $conf["file_store_path"] + real_filename)
			else
				open($conf["file_store_path"] + real_filename, "wb") do |fh|
					fh.write(file.read)
	       	 		end
			end

			$db.synchronize() do
				$db.transaction do |d|
					d.execute("insert into files values('#{sender}', '#{receiver}',
                    	'#{original_filename}', '#{real_filename}', #{Time.now.tv_sec}, #{file.size})")
				end
			end
		rescue Exception => e
			p e
			puts e.backtrace
		end

		response.start do |head, out|
			head["Content-Type"] = "text/html"

			out << <<EOS
#{$page_head}

<script language="JavaScript">
<!--

parent.document.getElementById("form_area").innerHTML = ("<p><b>"
+ parent.filename + "</b> has been successfully uploaded.</p>");
parent.filename = "";
parent.setProgressBar(#{file.size}, #{file.size});
parent.loadFileList('#{sender}');
parent.document.getElementById("button_upload").disabled = false;

//-->
</script>

#{$page_end}
EOS
		end
	end
end

scrapiのWindows版で1モジュールのdllの読み込みに不具合があるので、問題になるメソッドfind_tidyをここで上書き修正している。この辺は動的言語の面目躍如と言うべきだが、濫用すると収拾が付かなくなるので個人的にはやむをえない場合以外やるべきではないと思っている。

# Redefine the find_tidy method in scrapi for Windows to load the correct dll first
module Scraper
	module Reader
		module_function

		def find_tidy()
			return if Tidy.path

			begin
				$LOAD_PATH.each do |path|
					if path =~ /scrapi/ && path =~ /lib$/
						if Config::CONFIG['arch'] =~ /mswin/
							Tidy.path = File.join(path, "/tidy", "libtidy.dll")
						else
							Tidy.path = File.join(path, "/tidy", "libtidy.so")
						end
						break
					end
				end
			rescue LoadError => e
				puts e.to_s
			end
		end
	end
end

あるユーザ名が「はてな」の実在のユーザかどうか確かめるためのwebサービスAPIを「はてな」では提供していないので、「はてな」上に該当ユーザのメンバーページが存在するかどうか、scrapiによるスクレイピングを行って強引に確かめることで代用する。

class CheckUsernameHandler < Mongrel::HttpHandler

	@@scraper = Scraper.define do
		process "td[align='center'] a[href='/q']", :ret => :text
		result :ret
	end

	def process(request, response)
		verified = false
		$verified_users_ipaddress.synchronize(Sync_m::SH) do
			if $verified_users_ipaddress.include?(request.params[Mongrel::Const::REMOTE_ADDR])
				verified = true
			end
		end

		unless verified
			response.start(403) do |head, out|
				out.write("Not Authorized")
			end
			return
		end

		found = false
		$existent_users.synchronize(Sync_m::SH) do
			found = $existent_users.include?(request.body.string)
		end

		unless found
			uri = "http://www.hatena.ne.jp/user?userid="
			uri += request.body.string # StringIO

			found = (@@scraper.scrape(URI.parse(uri)) == nil)

			$existent_users.synchronize() do
				if $existent_users.size > 1000
					$existent_users.clear()
				end
				$existent_users[request.body.string] = 1
			end
		end

		response.start do |head, out|
			head["Content-Type"] = "text/xml"
			out.write(
            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><r>#{found ? request.body.string : ""}</r>")
		end
	end
end

自分がアップロード中のファイルの進捗状況を示すXMLを返すハンドラを定義する。

class QueryProgressHandler < Mongrel::HttpHandler
	def process(request, response)
		$verified_users_ipaddress.synchronize(Sync_m::SH) do
			unless $verified_users_ipaddress.include?(request.params[Mongrel::Const::REMOTE_ADDR])
				response.start(403) do |head, out|
					out.write("Not Authorized")
				end
				return
			end
		end

		found = false
		$download_progress.synchronize(Sync_m::SH) do
			if $download_progress.include?(request.params["QUERY_STRING"])
				found = $download_progress[request.params["QUERY_STRING"]]
			end
		end

		response.start do |head, out|
			head["Content-Type"] = "text/xml"
			if found
				out.write(
    "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><f>#{found.current_size}/#{found.total_size}</f>")
			else
				out.write("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><f></f>")
			end
		end
	end
end

自分宛に他ユーザがアップロードしたファイルの一覧を表示するハンドラを定義する。

class  ListFilesHandler < Mongrel::HttpHandler
	def process(request, response)
		$verified_users_ipaddress.synchronize(Sync_m::SH) do
			if $verified_users_ipaddress.include?(request.params[Mongrel::Const::REMOTE_ADDR])
				if $verified_users_ipaddress[request.params[Mongrel::Const::REMOTE_ADDR]] != request.params["QUERY_STRING"]
					response.start(403) do |head, out|
						out.write("Not Authorized")
					end
					return
				end
			else
				response.start(403) do |head, out|
					out.write("Not Authorized")
				end
				return
			end
		end

		if request.params["QUERY_STRING"] =~ /[^a-zA-Z0-9_-\.\\]/
			response.reset
			response.start(403) do |head, out|
				out << "Invalid Request"
			end
			return
		end

		xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><files>'

		$db.synchronize(Sync_m::SH) do
			$db.execute("select * from files where sender = '#{request.params["QUERY_STRING"]}'") do |row|
				xml += "<myfile r=\"#{row[1]}\" ofn=\"#{row[2]}\" rfn=\"#{row[3]}\" d=\"#{row[4]}\" size=\"#{row[5]}\"/>"
			end
			$db.execute("select * from files where receiver = '#{request.params["QUERY_STRING"]}'") do |row|
				xml += "<sentfile s=\"#{row[0]}\" ofn=\"#{row[2]}\" rfn=\"#{row[3]}\" d=\"#{row[4]}\" size=\"#{row[5]}\"/>"
			end
		end

		xml += "</files>"

		response.start do |head, out|
			head["Content-Type"] = "text/xml"
			out.write(xml)
		end
	end
end

Mongrelの起動設定と起動、終了処理。どのパス(URI)がどのハンドラクラスによって定義されているか、ここで指定する。

#stats = Mongrel::StatisticsFilter.new(:sample_rate => 1)

# new(defaults={}, &blk)
# You pass in initial defaults and then a block to continue configuring.
config = Mongrel::Configurator.new :host => $conf["bound_address"], :port => $conf["bound_port"] do
	listener do
		uri "/", :handler => RootHandler.new
		#uri "/", :handler => Mongrel::DeflateFilter.new # This messes up IE
		#uri "/", :handler => stats

		uri "/uploader", :handler => UploaderHandler.new

		uri "/downloader", :handler => DownloaderHandler.new($conf["file_store_path"], false)

		uri "/receiver", :handler => ReceiverHandler.new

		uri "/check_username", :handler => CheckUsernameHandler.new

		uri "/query_progress", :handler => QueryProgressHandler.new

		uri "/list_files", :handler => ListFilesHandler.new

		#uri "/status", :handler => Mongrel::StatusHandler.new(:stats_filter => stats)
	end

	trap("INT") { stop }
	run
end

puts "Mongrel running on #{$conf["bound_address"]}:#{$conf["bound_port"]}"

config.join

hatenawebapp1.rbは以上である。 スクリプトを動作させると、Mongrelが設定ファイル内のポートで起動するので、Webブラウザでアクセスすると、「はてな」認証を促すリンクが表示される。それをクリックし、認証を通過すると、コールバックURLのhttp://127.0.0.1/uploaderに転送され、そこでファイルのアップロードが可能となる。自分の送信済みファイルと、自分宛に他ユーザが送信したファイルのリストもそこに表示されている。ファイルをアップロードする と、AJAXを利用して画面遷移無しで進捗表示とアップロード完了後のリスト更新が行われる。尚、ごく稀に特定のファイルでアップロードが失敗することがあるようだが、MongrelのCGIWrapperのバグに起因する問題でありMongrel側の修正を待つしかない。

つぎに、Perl webアプリの方を見ていくことにする。まずは、設定ファイルのhatenawebapp2.confである。Rubyアプリの方と同様に、YAML形式を用いてサーバのポートなどを設定している。

# hatenawebapp2.conf
#
# configuration file for hatenawebapp2.pl

# Bound port
bound_port: 80

# JavaScript directory name (not path)
javascript_directory: jsdir

# Mask for a hidden text in a quiz question
quiz_mask: "<font color=red>******</font>"

スクリプト本体はhatenawebapp2.plである。perl, v5.8.8 built for MSWin32-x86-multi-threadで動作を確認している。

必要ライブラリは、Perl 5.8の他に、
YAML::Syck
POE::Component::Server::HTTP
HTTP::Status
XML::RSS
XMLRPC::Lite
LWP::Simple
MeCab
URI::Escape
threads::shared
Thread::Semaphore
のそれぞれCPANシェルを使って入手できる最新バージョンと、各々が依存するライブラリである。オープンソース形態素解析エンジンMeCabは、ナマズのブログで入手可能な0.92のWindows用バイナリと辞書を使用させていただいた。尚、Windows下ではMeCabがShiftJISでビルドされている ため辞書もShiftJIS版を使用し、スクリプト内で必要な変換を行ったが、他プラットフォームでテストする場合はMeCab、辞書ともUTF-8版が必要である。また、JavaScriptのグラフ視覚化ライブラリであるJSVizと、ツールチップライブラリboxoverを利用しており、これらはスクリプト下にjsdirという名称のディレクトリを作ってその中へ全て展開する必要がある。

=pod

hatenawebapp2.pl

Sample Web Application 2 with Hatena Web Service API : Hatena Keyword Quiz & Visualization

by RyuK (klassphere[at.mark]gmail.com)

http://zzz.zggg.com/

http://aiueo.da.ru/

[Requirements (tested on Microsoft Windows XP)]

Mecab is compiled with ShiftJIS with the ShiftJIS dictionary.
For platforms other than Windows, use UTF-8 for Mecab and its dic.

=cut

use 5.8.0;

use strict;
use warnings;

use utf8;
use Encode;

use YAML::Syck;
use POE::Component::Server::HTTP;
use HTTP::Status;
use XML::RSS;
use XMLRPC::Lite;
use LWP::Simple;
use MeCab;
use URI::Escape;

$YAML::Syck::ImplicitTyping = 1;

my %quiz_answer = (); # IP address - answer

my $conf = YAML::Syck::LoadFile("hatenawebapp2.conf");

ここでは、日本語UTF-8文字列を使うときにUTF-8に対応していないXMLRPC::LiteとSOAP::Lite内で問題がある箇所の関数を動的に上書き修正している。

# Patches some functions in XMLRPC::Lite and SOAP::Lite to pass a UTF-8 Japanese string
# in its HTTP transport that is a subclass of LWP::UserAgent
$SOAP::Constants::DO_NOT_USE_LWP_LENGTH_HACK = 1;

{
	my $s =<<'SUBDOC';
package XMLRPC::Serializer;

sub new
{
	my $self = shift;

	unless (ref $self)
	{
		my $class = ref($self) || $self;
		$self = $class->SUPER::new(
			typelookup =>
			{
				base64 => [10, sub {1}, 'as_string'],
				int    => [20, sub {$_[0] =~ /^[+-]?\d+$/}, 'as_int'],
				double => [30, sub {$_[0] =~ /^(-?(?:\d+(?:\.\d*)?|\.\d+)|([+-]?)(?=\d|\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?)$/}, 'as_double'],
				dateTime => [35, sub {$_[0] =~ /^\d{8}T\d\d:\d\d:\d\d$/}, 'as_dateTime'],
				string => [40, sub {1}, 'as_string'],
			},
			attr => {},
			namespaces => {},
			@_,
		);
	}

	return $self;
}

1;

package SOAP::Utils;

sub bytelength
{
	return length($_[0]);
}

1;

SUBDOC

	no warnings;
	local $^W = 0;
	eval "$s";
	use warnings;
}

Webサーバの設定を行うとともに、Webサーバ上の各パス毎にハンドラ関数を登録している。

my $aliases = POE::Component::Server::HTTP->new(
	Port => $conf->{bound_port},
	ContentHandler =>
	{
		'/' => \&handlerRoot,
		'/viz' => \&handlerViz,
		'/quiz' => \&handlerQuiz,
		'/answer' => \&handlerAnswer,
		'/assoc' => \&handlerAssoc,
		'/search' => \&handlerSearch
	},
	Headers => { Server => 'My Server' },
);

これは穴埋めクイズの問題を作る関数で、要は、「はてなキーワード」内の日本語文に対しMeCabで形態素解析を行って、見つかった名詞の部分を隠すことによって穴埋め問題にするという至極単純な仕組みである。

sub makeQuiz
{
	my $s = shift;
	my $ip = shift;

	my $sjis = ($^O =~ /mswin/i);
	if ($sjis)
	{
		utf8::encode($s);
		Encode::from_to($s, 'utf8', 'shiftjis');
	}

	my $m = new MeCab::Tagger("");
	my $n = $m->parseToNode($s);

	my @fragments = ();

	my $count = 0;
	while ($n = $n->{next})
	{
		if (defined($n->{surface}))
		{
			my $w = $n->{surface};
			my $f = $n->{feature};

			if ($sjis)
			{
				Encode::from_to($f, 'shiftjis', 'utf8');
				utf8::decode($f);

				Encode::from_to($w, 'shiftjis', 'utf8');
				utf8::decode($w);
			}

			if ($f =~ /^名詞/ && length($w) >= 2)
			{
				push @fragments, [$w, 1];
				++$count;
			}
			else
			{
				push @fragments, [$w, 0];
			}
		}
	}

	if ($count == 0)
	{
		return "";
	}

	my $masked_index = int(rand $count);

	my $final = "";
	my $current_noun_index = 0;
	foreach my $f (@fragments)
	{
		if ($f->[1] == 0)
		{
			$final .= $f->[0];
		}
		elsif ($current_noun_index++ == $masked_index)
		{
			$final .= $conf->{quiz_mask};

			if (keys(%quiz_answer) > 1000)
			{
				%quiz_answer = ();
			}

			$quiz_answer{$ip} = $f->[0];
		}
		else
		{
			$final .= $f->[0];
		}
	}

	return $final;
}

webサーバのルートURLのハンドラ。ユーザが任意の単語を入力すると「はてなキーワード」を検索し、キーワード間の連想グラフをロードする。

sub handlerRoot
{
	my ($request, $response) = @_;
	$response->code(RC_OK);

	my $out = "";
	my $jsdir = $conf->{javascript_directory};

	if ($request->uri =~ /$jsdir\/([^\/]+)$/)
	{
		my $f = $1;
		if (!open(FILE, "./$jsdir/$f"))
		{
			return RC_DENY;
		}

		while (<FILE>)
		{
			$out .= $_;
		}

		$response->content($out);
		$response->header('Content-type' => "application/x-javascript");

		close(FILE);

		return RC_OK;
	}

	$out =<<'HEREDOC';
<html>
<head>
<title>Hatena web app 2</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

<script language="JavaScript">
<!--

function setup()
{

}

function resizeIframe(f)
{
	if (document.body.clientWidth)
	{
		f.style.width = document.body.clientWidth + "px";
		f.style.height = (document.body.clientHeight - 100) + "px";
	}
}

function resizeIframe2(f)
{
	if (document.body.clientWidth)
	{
		f.style.width = document.body.clientWidth + "px";
	}
}

//-->

</script>

<style type="text/css">

body
{
	margin: 0;
	padding: 0;
	overflow: hidden;
}

p
{
	text-decoration: none;
	font-size: 13px;
	font-weight: normal;
	font-family: Verdana, Geneva, san-serif;
	line-height: 150%;
	margin-top: 0px;
	margin-bottom: 1em;
	padding-left: 8px;
	padding-right: 8px;
}

form
{
	margin: 0;
	padding: 0;
}

</style>
</head>
<body onload="setup();" onresize="resizeIframe(document.getElementById('ifr'));resizeIframe2(document.getElementById('quiz'));">
<br>
<p>Proof of Concept: Hatena Keyword Quiz &amp; Visualization</p>

<form onsubmit="frames.ifr.hatenaKeywords.getKeywords(this.word.value); return false;">
<p>はてなキーワード内から検索したい単語を <input type="text" id="word" size="40"> に入力し
<input type="submit" value="検索"> して、見つかった単語をクリックして下さい。
</p>
</form>
<p>(キーワードのノードはマウスでドラッグ可能です)</p>
<iframe src="/quiz" id="quiz" name="quiz" width="1000" height="160" scrolling="yes" valign="top"
 onload="resizeIframe2(this);"></iframe>
<iframe src="/viz" id="ifr" name="ifr" width="1000" height="600" scrolling="yes" valign="top"
 onload="resizeIframe(this);"></iframe>

</body>
</html>

HEREDOC

	$response->content($out);

	return RC_OK;
}

GETリクエストで呼び出されると必要なJavaScriptを表示し、POSTリクエストの場合は入力された単語を「はてなキーワード」で検索した後、キーワードのRSSデータから説明文を抜き出してクイズを作成表示する。

sub handlerQuiz
{
	my ($request, $response) = @_;
	$response->code(RC_OK);

	my $out = "";

	if ($request->method =~ /get/i)
	{
		$out =<<'HEREDOC';
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

<script language="JavaScript">
<!--

var isIE = window.ActiveXObject;
var isMozilla = navigator.userAgent.indexOf('Gecko') != -1;

function createHttpRequest()
{
	if (isIE)
	{
		try
		{ // CLSID_XMLHTTP
			// v 3.0
			return new ActiveXObject("Msxml2.XMLHTTP");
		}
		catch (e)
		{
			try
			{// v 2.x
				return new ActiveXObject("Microsoft.XMLHTTP");
			}
			catch (e2)
			{
				return null;
			}
		}
	}
	else if (window.XMLHttpRequest) // non-IE
	{
		var hr = new XMLHttpRequest();
		if (isMozilla)
			hr.overrideMimeType('text/xml');

		return hr;
	}
	else
	{
		return null;
	}
}

function sendHTTP(data, method, uri, callback, async, caller)
{
	var hr = createHttpRequest();

	var args = new Array();
	args.push(hr);
	for (var i = 6; i < arguments.length; ++i)
	{
		args.push(arguments[i]);
	}

	try
	{
		hr.open(method, uri, async);
		hr.setRequestHeader("If-Modified-Since", "Thu, 01 Jun 1970 00:00:00 GMT");

		hr.onreadystatechange = function()
		{
			if (hr.readyState == 4)
			{
				callback.apply(caller, args);
			}
		}

		hr.send(data);
		delete hr;
	}
	catch(e)
	{
		alert("sendHTTP: " + e);
	}
}

function getTextContent(xml)
{
	if (xml)
	{
		if (xml.textContent)
			return xml.textContent; // Mozilla
		// IE
		if (xml.innerText)
			return xml.innerText;
		if (xml.text)
			return xml.text;
	}
}

function setup()
{

}

function checkAnswer(answer)
{
	sendHTTP(answer, "POST", "/answer", checkAnswerCallback, true, this, answer);
}

function checkAnswerCallback(request)
{
	var nodelist = request.responseXML.getElementsByTagName("a");
	if (nodelist &amp;&amp; nodelist.length != 0)
	{
		for (var i = 0; i < nodelist.length &amp;&amp; i < 10; ++i)
		{
			var e = nodelist.item(i);
			if (e.getAttribute("r") == "true")
			{
				alert("正解");
			}
			else
			{
				var answer = "";
				var n = e.firstChild;
				while (n != null)
				{
					// n.textContent == Mozilla only
					// NODE_TEXT == 3 || NODE_CDATA_SECTION == 4
					if (n != null &amp;&amp; (n.nodeType == 3 || n.nodeType == 4))
					{
						answer = n.nodeValue;
					}

					n = n.nextSibling;
				}

				alert("不正解 - 解答: " + answer);
			}
		}
	}
}

//-->

</script>

<style type="text/css">

body
{
	margin: 0;
	padding: 0;
	overflow: hidden;
}

p
{
	text-decoration: none;
	font-size: 13px;
	font-weight: normal;
	font-family: Verdana, Geneva, san-serif;
	line-height: 150%;
	margin-top: 0px;
	margin-bottom: 1em;
	padding-left: 8px;
	padding-right: 8px;
}

form
{
	margin: 0;
	padding: 0;
}

</style>
</head>
<body onload="setup();">
<span id="quiz"></span>
</body>
</html>

HEREDOC

	}
	else
	{
		$response->header('Content-Type' => 'text/xml');
		$out = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<r>\n";

		my $w = $request->content;
		utf8::decode($w);
		$w =~ tr/Ａ-Ｚａ-ｚ０-９/A-Za-z0-9/;
		$w = URI::Escape::uri_escape_utf8($w);

		my $content = get("http://d.hatena.ne.jp/keyword?word=$w&amp;mode=rss&amp;ie=utf8");
		if ($content)
		{
			my $rss = new XML::RSS;

			utf8::decode($content);

			$rss->parse($content);

			my $item = ${$rss->{items}}[0];

			for my $item (@{$rss->{items}})
			{
				$out .= "<i a='";
				$out .= $item->{link};
				$out .= "'>";

				if (defined($item->{title}))
				{
					$out .= "<t><![CDATA[";

					my $t = $item->{title};
					utf8::decode($t);
					$t =~ s/]]>/]]>/g;
					$out .= $t;

					$out .= "]]></t>\n";
				}

				if (defined($item->{description}))
				{
					$out .= "<d><![CDATA[";

					my $d = $item->{description};
					utf8::decode($d);
					$d =~ s/]]>/]]>/g;
					$d =~ s|<a[^>]+>||g;

					$out .= makeQuiz($d, $request->{connection}->{remote_ip});

					$out .= "]]></d>";
				}

				$out .= "</i>\n";
			}
		}

		$out .= "</r>";
	}

	$response->content($out);

	return RC_OK;
}

JSVizによって「はてなキーワード」の連想グラフを視覚化した物を表示する画面のハンドラ。

sub handlerViz
{
	my ($request, $response) = @_;
	$response->code(RC_OK);

	my $out = "";
	my $jsdir = $conf->{javascript_directory};

	if ($request->uri =~ /$jsdir\/([^\/]+)$/)
	{
		my $f = $1;
		if (!open(FILE, "./$jsdir/$f"))
		{
			return RC_DENY;
		}

		while (<FILE>)
		{
			$out .= $_;
		}

		$response->content($out);
		$response->header('Content-type' => "application/x-javascript");

		close(FILE);

		return RC_OK;
	}

	$out =<<'HEREDOC';
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />

<script language="JavaScript" src="/jsdir/DataGraph.js"></script>
<script language="JavaScript" src="/jsdir/Magnet.js"></script>
<script language="JavaScript" src="/jsdir/Spring.js"></script>
<script language="JavaScript" src="/jsdir/Particle.js"></script>
<script language="JavaScript" src="/jsdir/ParticleModel.js"></script>
<script language="JavaScript" src="/jsdir/Timer.js"></script>
<script language="JavaScript" src="/jsdir/EventHandler.js"></script>
<script language="JavaScript" src="/jsdir/HTMLGraphView.js"></script>
<script language="JavaScript" src="/jsdir/SVGGraphView.js"></script>
<script language="JavaScript" src="/jsdir/RungeKuttaIntegrator.js"></script>
<script language="JavaScript" src="/jsdir/Control.js"></script>
<script language="JavaScript" src="/jsdir/boxover.js"></script>

<script language="JavaScript">
<!--

var isIE = window.ActiveXObject;
var isMozilla = navigator.userAgent.indexOf('Gecko') != -1;

// Suppress IE6 SP1 flicker
if (isIE)
{
	try
	{
		document.execCommand("BackgroundImageCache", false, true);
	}
	catch (e)
	{

	}
}

function createHttpRequest()
{
	if (isIE)
	{
		try
		{ // CLSID_XMLHTTP
			// v 3.0
			return new ActiveXObject("Msxml2.XMLHTTP");
		}
		catch (e)
		{
			try
			{// v 2.x
				return new ActiveXObject("Microsoft.XMLHTTP");
			}
			catch (e2)
			{
				return null;
			}
		}
	}
	else if (window.XMLHttpRequest) // non-IE
	{
		var hr = new XMLHttpRequest();
		if (isMozilla)
			hr.overrideMimeType('text/xml');

		return hr;
	}
	else
	{
		return null;
	}
}

function sendHTTP(data, method, uri, callback, async, caller)
{
	var hr = createHttpRequest();

	var args = new Array();
	args.push(hr);
	for (var i = 6; i < arguments.length; ++i)
	{
		args.push(arguments[i]);
	}

	try
	{
		hr.open(method, uri, async);
		hr.setRequestHeader("If-Modified-Since", "Thu, 01 Jun 1970 00:00:00 GMT");

		hr.onreadystatechange = function()
		{
			if (hr.readyState == 4)
			{
				callback.apply(caller, args);
			}
		}

		hr.send(data);
		delete hr;
	}
	catch(e)
	{
		alert("sendHTTP: " + e);
	}
}

function getTextContent(xml)
{
	if (xml)
	{
		if (xml.textContent)
			return xml.textContent; // Mozilla
		// IE
		if (xml.innerText)
			return xml.innerText;
		if (xml.text)
			return xml.text;
	}
}

var HatenaKeywords = function(dataGraph, particleModel)
{
	this.init(dataGraph, particleModel);
}

HatenaKeywords.prototype =
{
	init: function(dataGraph, particleModel)
	{
		this.dataGraph = dataGraph;
		this.particleModel = particleModel;

		this.TRAVERSE_DEPTH = 1;
		this.MAX_PRODUCTS_ORIGIN = 8;
		this.MAX_PRODUCTS_PER_SIMILARITY = 8;
		this.MAX_NODES = 20;

		this.nodesByName = {};
		this.nodesCount = 0;
	},

	search: function(keyword)
	{
		document.getElementById('searchResults').innerHTML = "";
		document.getElementById('keywordResults').style.display = "none";

		parent.document.getElementById('word').value = keyword;

		this.particleModel.clear();
		this.nodesByName = {};
		this.nodesCount = 0;

		if (this.particleModel.timer.interupt)
			this.particleModel.timer.start();

		var node = new DataGraphNode(true, 2);
		node.keyword = keyword;

		this.dataGraph.addNode(node);
		this.nodesByName[keyword] = node;
		this.getSimilarKeywords(keyword, 0);

		sendHTTP(keyword, "POST", "/quiz", this.getQuizCallback, true, this, keyword);
	},

	getQuizCallback : function(request)
	{
		var nodelist = request.responseXML.getElementsByTagName("i");
		if (nodelist &amp;&amp; nodelist.length != 0)
		{
			for (var i = 0; i < nodelist.length &amp;&amp; i < 10; ++i)
			{
				var e = nodelist.item(i);
				var keyword = getTextContent(e.getElementsByTagName("t")[0]);
				if (!keyword)
					keyword = "";

				var desc = getTextContent(e.getElementsByTagName("d")[0]);
				if (!desc)
					desc = "";

				parent.frames.quiz.document.getElementById('quiz').innerHTML
                	= "<p>クイズ: 隠された単語は何でしょう?</p><p>"
                    + desc
                    + "</p><form onsubmit=\"checkAnswer(this.answer.value);return false;\"><p>"
                    + "あなたの答え: <input id=\"answer\" type=\"text\" size=\"20\"><input type=\"submit\""
                    + " value=\"解答をチェック\"></p></form>";
			}
		}
	},

	getKeywords : function(keyword)
	{
		document.getElementById('searchResults').innerHTML = "<p><blink>Searching...</blink></p>";

		this.particleModel.clear();
		this.nodesByName = {};
		this.nodesCount = 0;

		if (this.particleModel.timer.interupt)
			this.particleModel.timer.start();

		sendHTTP(keyword, "POST", "/search", this.getKeywordsCallback, true, this, keyword);
	},

	getKeywordsCallback : function(request)
	{
		document.getElementById('searchResults').innerHTML = "";

		var nodelist = request.responseXML.getElementsByTagName("i");
		if (nodelist &amp;&amp; nodelist.length != 0)
		{
			var h = document.createElement('p');
			h.innerHTML = (nodelist.length.toString() + "個のキーワードが見つかりました。クリックすると関係する単語群を探せます。");
			document.getElementById('searchResults').appendChild(h);

			for (var i = 0; i < nodelist.length &amp;&amp; i < 10; ++i)
			{
				var e = nodelist.item(i);
				var keyword = getTextContent(e.getElementsByTagName("t")[0]);
				if (!keyword)
					keyword = "";

				var desc = getTextContent(e.getElementsByTagName("d")[0]);
				if (!desc)
					desc = "";

				var r = document.createElement('div');
				r.className = "keyword";
				var title = ("fade=[on] header=[" + keyword.replace(/[/g, "").replace(/]/g, "")
                + "] body=[" + desc.replace(/[/g, "").replace(/]/g, "") + "]");
				r.setAttribute("title", title);
				r.setAttribute("style", "padding-left: 50px;");
				r.innerHTML = '<p onclick="' +
					"hatenaKeywords.search('" + keyword.replace(/"/g, '"') + "')" + '">'
                    + "<b><a onmouseover=\"this.style.textDecoration = 'underline'\" onmouseout=\"this.style.textDecoration = 'none'\">"
                    + keyword + '</b></a></p>';

				document.getElementById('searchResults').appendChild(r);

			}
		}
	},

	getSimilarKeywords: function(word, ordinal)
	{
		sendHTTP(word, "POST", "/assoc", this.getSimilarKeywordsCallback, true, this, word, ordinal);
	},

	getSimilarKeywordsCallback: function(request, parentWord, ordinal)
	{
		var max = this.MAX_PRODUCTS_PER_SIMILARITY;
		if (ordinal == 0)
			max = this.MAX_PRODUCTS_ORIGIN;

		var nodelist = request.responseXML.getElementsByTagName("related");
		for (var i = 0; i < nodelist.length &amp;&amp; i < max &amp;&amp; this.nodesCount < this.MAX_NODES; i++)
		{
			var word = nodelist[i].getAttribute("w");

			if (this.nodesByName[word])
			{
				var node = this.nodesByName[word];
				this.dataGraph.addEdge(node, this.nodesByName[parentWord]);
			}
			else
			{
				var node = new DataGraphNode(false, 1);
				node.keyword = word;

				node.addEdge(this.nodesByName[parentWord], 1);
				this.dataGraph.addNode(node);
				this.nodesCount++;

				this.nodesByName[word] = node;

				if (ordinal < this.TRAVERSE_DEPTH)
					this.getSimilarKeywords(word, ordinal + 1);
			}
		}
	}
}

var hatenaKeywords;

function setup()
{
	var FRAME_WIDTH;
	var FRAME_HEIGHT;

	if (document.all)
	{
		FRAME_WIDTH = document.body.offsetWidth - 10;
		FRAME_HEIGHT = document.documentElement.offsetHeight - 10 - 28;
	}
	else
	{
		FRAME_WIDTH = window.innerWidth - 10;
		FRAME_HEIGHT = window.innerHeight - 10 - 28;
	}

	var view = document.implementation.hasFeature("org.w3c.dom.svg", '1.1') ?
		new SVGGraphView(0, 26, FRAME_WIDTH, FRAME_HEIGHT, true)
		: new HTMLGraphView(0, 26, FRAME_WIDTH, FRAME_HEIGHT, true);

	var particleModel = new ParticleModel(view);
	particleModel.start();

	var control = new Control(particleModel, view);
	var dataGraph = new DataGraph();

	hatenaKeywords = new HatenaKeywords(dataGraph, particleModel);

	var nodeHandler = new NodeHandler(dataGraph, particleModel, view, control);
	dataGraph.subscribe(nodeHandler);

	var buildTimer = new Timer(150);
	buildTimer.subscribe(nodeHandler);
	buildTimer.start();
}

var NodeHandler = function( dataGraph, particleModel, view, control )
{
	this.dataGraph = dataGraph;
	this.particleModel = particleModel;
	this.view = view;

	this.nodeQueue = new Array();
	this.relationshipQueue = new Array();

	this['newDataGraphNode'] = function(dataGraphNode)
	{
		this.enqueueNode(dataGraphNode);
	}

	this['newDataGraphEdge'] = function(nodeA, nodeB)
	{
		this.enqueueRelationship(nodeA, nodeB);
	}

	this['enqueueNode'] = function(dataGraphNode)
	{
		this.nodeQueue.push(dataGraphNode);
	}

	this['enqueueRelationship'] = function(nodeA, nodeB)
	{
		this.relationshipQueue.push({'nodeA': nodeA, 'nodeB': nodeB});
	}

	this['dequeueNode'] = function()
	{
		var node = this.nodeQueue.shift();

		if (node)
		{
			this.addParticle(node);
			return true;
		}

		return false;
	}

	this['dequeueRelationship'] = function()
	{
		var edge = this.relationshipQueue.shift();
		if (edge)
			this.addSimilarity(.05, edge.nodeA, edge.nodeB);
	}

	this.update = function()
	{
		var nodes = this.dequeueNode();
		if (!nodes)
			this.dequeueRelationship();
	}

	this['addParticle'] = function(dataGraphNode)
	{
		particle = this.particleModel.makeParticle(dataGraphNode.mass, 0, 0);
		dataGraphNode.particle = particle;

		if (dataGraphNode.fixed)
			particle.fixed = true;

		var rx = Math.random() * 2 - 1;
		var ry = Math.random() * 2 - 1;
		particle.positionX = rx - 50 / this.view.skew;
		particle.positionY = ry;

		for (var j = 0, l = this.particleModel.particles.length; j < l; j++)
		{
			if (this.particleModel.particles[j] != particle)
				this.particleModel.makeMagnet(particle, this.particleModel.particles[j], -30000, 64);
		}

		var particleParent = false;

		for (var c in dataGraphNode.edges)
		{
			if (!particleParent)
			{
				particleParent = true;
				particle.positionX = dataGraphNode.edges[c].particle.positionX + rx;
				particle.positionY = dataGraphNode.edges[c].particle.positionY + ry;
			}

			this.addSimilarity(.2, dataGraphNode, dataGraphNode.edges[c]);
		}

		var keyword = dataGraphNode.keyword;
		if (!keyword) {keyword = "";}

		var n = document.createElement('div');
		n.style.position = "absolute";
		n.className = "keyword";
		n.innerHTML = '<div onclick="'
        + "hatenaKeywords.search('" + keyword.replace(/"/g,'"') + "')"
        + "\"><a onmouseover=\"this.style.textDecoration = 'underline'\" onmouseout=\"this.style.textDecoration = 'none'\">"
        + keyword + '</a></div>';
		n.onmousedown = new EventHandler(control, control.handleMouseDownEvent, particle.id)
		dataGraphNode.viewNode = this.view.addNode(particle, n, 25, isIE ? 10 : 30);

		//particle.width = dataGraphNode.viewNode.offsetWidth;
		//particle.height = dataGraphNode.viewNode.offsetHeight;

		return dataGraphNode;
	},

	this['addSimilarity'] = function(springConstant, nodeA, nodeB)
	{
		particleModel.makeSpring(nodeA.particle, nodeB.particle, springConstant, .2, 80);

		var props = document.implementation.hasFeature("org.w3c.dom.svg", '1.1') ?
		{
				'stroke': "#bbbbbb",
				'stroke-width': '2px',
				'stroke-dasharray': '2, 8'
		}
		:
		{
				'pixelColor': "#aaaaaa",
				'pixelWidth': '2px',
				'pixelHeight': '2px',
				'pixels': 15
		};

		this.view.addEdge(nodeA.particle, nodeB.particle, props);
	}
}

//-->

</script>

<style type="text/css">

body
{
	margin: 0;
	padding: 0;
	overflow: hidden;
}

p
{
	text-decoration: none;
	font-size: 13px;
	font-weight: normal;
	font-family: Verdana, Geneva, san-serif;
	line-height: 150%;
	margin-top: 0px;
	margin-bottom: 1em;
	padding-left: 8px;
	padding-right: 8px;
}

form
{
	margin: 0;
	padding: 0;
}

div.keyword
{
	font-family: Verdana, Geneva, san-serif;
	font-weight: bold;
	font-size: 14px;
	text-align: left;
	background-repeat: no-repeat;
	cursor: hand;
}

#keywordResults
{
	display: none;
	color: #000000;
	border-top: 0px;
}

</style>
</head>

<body onload="setup();">
<div id="searchResults"></div>
<div id="keywordResults"></div>
</body>
</html>

HEREDOC

	$response->content($out);

	return RC_OK;
}

「はてなキーワード」で検索を行うためのAJAXコールバックを定義する。JSVizはこれを呼び出して見つかった関連単語を次々と検索し、単語のグラフに新しいノードを付け加えていく。

sub handlerSearch
{
	my ($request, $response) = @_;
	$response->code(RC_OK);

	if ($request->method =~ /get/i)
	{
		return RC_DENY;
	}

	$response->header('Content-Type' => 'text/xml');
	my $out = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<r>\n";

	my $w = $request->content;
	utf8::decode($w);
	$w =~ tr/Ａ-Ｚａ-ｚ０-９/A-Za-z0-9/;
	$w = URI::Escape::uri_escape_utf8($w);

	my $content = get("http://search.hatena.ne.jp/keyword?word=$w&amp;mode=rss&amp;ie=utf8&amp;page=1");
	if ($content)
	{
		my $rss = new XML::RSS;

		utf8::decode($content);

		$rss->parse($content);

		for my $item (@{$rss->{items}})
		{
			$out .= "<i a='";
			$out .= $item->{link};
			$out .= "'>";

			if (defined($item->{title}))
			{
				$out .= "<t><![CDATA[";

				my $t = $item->{title};
				utf8::decode($t);
				$t =~ s/]]>/]]>/g;
				$out .= $t;

				$out .= "]]></t>\n";
			}

			if (defined($item->{description}))
			{
				$out .= "<d><![CDATA[";

				my $d = $item->{description};
				utf8::decode($d);
				$d =~ s/]]>/]]>/g;
				$out .= $d;

				$out .= "]]></d>";
			}

			$out .= "</i>\n";
		}
	}

	$out .= "</r>";

	$response->content($out);

	return RC_OK;
}

関連単語を「はてな」の関連キーワードAPIを用いて探すためのハンドラ。「はてな」のコードサンプルで推奨されているようにXMLRPC::Liteモ ジュールを使って検索するが、私が試した限りでは「ディスク」など一部単語で問題が起こるようで、いささか実用性に欠ける。

sub handlerAssoc
{
	my ($request, $response) = @_;
	$response->code(RC_OK);

	if ($request->method =~ /get/i)
	{
		return RC_DENY;
	}

	$response->header('Content-Type' => 'text/xml');
	my $out = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<r>\n";

	my $w = $request->content;
	utf8::decode($w);
	$w =~ tr/Ａ-Ｚａ-ｚ０-９/A-Za-z0-9/;
	utf8::encode($w);

	# XML::Parser employed by XMLRPC::Lite has troubles for some words such as "ディスク".
	# Probably should avoid XMLRPC::Lite and use another module instead in future.
	eval
	{
		my $res = XMLRPC::Lite->new->proxy('http://d.hatena.ne.jp/xmlrpc')->call(
		        'hatena.getSimilarWord', {wordlist => [$w]}
		);

		unless ($res->fault)
		{
			foreach (@{$res->result->{wordlist}})
			{
				if (defined($_->{word}))
				{
					$out .= "<related w='";
					$out .= $_->{word};
					$out .= "'/>\n";
				}
			}
		}
	};
	warn $@ if $@;

	$out .= "</r>";

	$response->content($out);

	return RC_OK;
}

クイズの答えが正しいかどうか判定し、正解/不正解を返すAJAXコールバックURLのハンドラ。

sub handlerAnswer
{
	my ($request, $response) = @_;
	$response->code(RC_OK);

	if ($request->method =~ /get/i)
	{
		return RC_DENY;
	}

	$response->header('Content-Type' => 'text/xml');
	my $out = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<r>\n";

	if (exists($quiz_answer{$request->{connection}->{remote_ip}}))
	{
		my $user_input = $request->content;
		utf8::decode($user_input);

		if ($quiz_answer{$request->{connection}->{remote_ip}} eq $user_input)
		{
			$out .= "<a r=\"true\"/>";
		}
		else
		{
			my $answer = $quiz_answer{$request->{connection}->{remote_ip}};
			$answer =~ s/]]//g;
			$out .= "<a r=\"false\"><![CDATA[" . $answer . "]]></a>";
		}
	}

	$out .= "</r>";

	$response->content($out);

	return RC_OK;
}

POE::Kernel->run;
exit;

最後にPOE::Kernelを呼び出し、サーバを起動する。

2つを書いてみての感想は、モジュール周りの扱いがRubyの方が簡潔で、完成された印象を持った。Perlの方はかなり入り組んでいてモジュールのインストールだけで小一時間かかってしまう(ほとんどがPOEに起因しているが、XML関連モジュールの層も相当ファットである印象を受ける)。Perlの方だけUTF-8を扱う必要がある点も、各モジュールの問題が噴出し、Perlにとって不利な結果となった。もちろんRubyも Mongrelの完成度が低いといった問題はあるものの、Webアプリケーションそのものの問題ではないし、それを言えばPOEは完全にMongrelに劣るので、Webアプリケーションテスト環境を含めた評価としては、やはりRubyの方が洗練されている。今回は順当にRubyに軍配が上がる結果となった。これでRubyそのもののパフォーマンスが向上すれば鬼に金棒といえるだろう。

MongrelというRubyのモジュールがあって、これはWebサーバの機能を持っている。似たようなモジュールとしてWEBrickというのがあるけれどもMongrelの方が新しくまたパフォーマンスも高いらしいというので昨日拾って中身を見てみるとmongrel(雑種)という名前に何か関係があるのかHTTPパーザの部分だけC拡張として実装してある。ソケット周りの部分をもCにしない理由は不明だが、大量のデータを処理するホットスポットをCにするという方針自体は 正しい。
だが、こうしたCを使っているモジュールの常か、クロスプラットフォーム対応はおざなりなようでWin32版のバイナリの提供が若干遅 れている。とあるテストをWin32版で行っていて不具合らしき現象に突き当たったので自分で新しい物をビルドしようと思いRubyForgeのSVNから未リリースのバージョンを取ってきた。どうやらメジャーバージョンアップを控えているようで色々中身が増えている。C拡張ソースコードがあるext\http11フォルダのextconf.rbがmkmfライブラリによるMakefile生成スクリプトなのでこれをRubyで実行する。(ちなみにRuby本体はRuby-mswin32 のビルドを使用している。) ところがエラーが出てMakefileを作ってくれない。mkmf.logを見るとc.libと いうのがおかしいようだ。とどのつまりUnixのCライブラリが前提になっていてWindowsでのビルドは全く無視されていると思われる。ドキュメントはビルドについて何も触れていないので、オフィシャルのWin32版がどうやってビルドされたのかすらわからない。仕方ないので試行錯誤してextconf.rb内のhave_libraryの第一引数をlibcpmt(VC++のマルチスレッドリリース版Cライブラリ)にしてやるとコンフリクトも無くどうにかMakefile を作ってくれる。nmakeによるビルドの際はRuby本体のlib\ruby\1.8\i386-mswin32フォルダにあるconfig.h 先頭のコンパイラバージョンチェックにひっかかるので、これを編集してコメントアウトする必要がある。Makefile自体もまだ不完全で、ライブラリがエクスポートする関数を示すdefファイルをRubyで生成する手順になっているのが、Rubyインタプリタへのパスに空白と スラッシュが含まれているためにうまく動作せず、そのまま実行するとライブラリのバイナリ(http11.so)はできるものの何も関数が入っていないという状態になってしまう。そこで二重引用符でRubyインタプリタのパスを囲みスラッシュを\に変えなければならない。これでようやくまともなhttp11.soが出来上がるのでこれをMongrelのlibフォルダへ移動する。

最新版でチェックしても問題は解決しなかった。その問題とは、Firefoxではページが表示されるのにIE7だととにかく「ページを 表示できない」というDNSエラーの表示が出てどうにもならないというものである。タイムアウトはしていないのでソケット接続はしているようである。ま た、Windowsファイアウォールも適切に設定してあり、それ以前にファイアウォールの内側でテストしているのだから関係があるはずもない。冒頭に述べ たように幸いソケット部分はRubyなので簡単にデバッグできそうかな等と思い始めた頃にはたと思い当たりMongrel::Configuratorで指定しているリクエストチェインからMongrel::DeflateFilterを抜いてみる。これでやっとIE7でページを開くことが出来た。どうやらFirefoxと異なり圧縮モードへのIE7の対応に問題があったらしい。このライブラリが金を払う必要のある製品でないことだけが不幸中の幸いである。だが失った時間は帰ってこない。

新しいアプリケーションはもちろんDICEの部品を積極的に活用する。今度はクライアントとしての側面を強調したアプリケーションにな る予定だ。開発スタイルも、DICEのようにドキュメントも含めて完成したパッケージとするのではなくて、もっとカジュアルでインクリメンタルなものにしたい。それこそbloggerがblogを毎日記すように、頻繁に少しずつ更新したプログラムをアップロードしたい。セットアップもzipアーカイブの中身を取り出すだけの簡単な物が良いかもしれない。DICEでは一旦更新するとなるとドキュ メントやパッケージの更新も必要で大がかりになり、アプリケーションそのもののスピーディな更新ができなかった。気がついたら、自分が軽んじていたアジャ イルソフトウェア開発のようなスタイルに惹かれていたのは何とも皮肉だ。こだわりやプライドを捨てることのなんと大変なことか。歳を取ってわかることはあると実感する。ツールの研究は十分やった。だから、こだわりを捨てて謙虚に、より多くの人に必要とされるようなソフトウェアを書きたい。応用(application)というのがキーワードだ。

しかしながら、より良いツールに対する興味も完全に失われたわけではなくて、どうやればクライアント向けの使いやすいユーザインター フェイスを作れるかについて、もうかなりの時間悩んでいる。最初に設定したユーザインターフェイスの要件は、1. ユーザが自由に改変できるものであること 2. 短期間で要素技術が陳腐化しないこと である。この要件に合致するには何を選べばよいか、悩み続けている。ユーザによる改変可能性については、ユーザインターフェイスはユーザが常に触れる物なのでユーザが好き勝手に改変できるのが最良だろうという価値判断による。改変可能性の程度としては、スキン変更といった見栄えのみの変更に留まらず、ユーザとアプリ ケーションコア間でのインターフェイスとしてのデータストリームを全てユーザが制御できるようにしたい。ある意味Unixシェルのリダイレクトやパイプの概念と同じである。プログラム全体をオープンソースにすれば原理的にこの問題は解決するが、それをせずに、アプリケーションの一定部分のみプログラマブル にしたいというわけだ。パフォーマンス上の観点からも、パフォーマンスの要る部分はネイティブコンパイル済みで、それ以外はユーザが自由に変更できるとい う構成は理にかなっている。何よりそんなアプリケーションがあったら私自身が欲しい。

DICEを最初にリリースしたときから管理用GUIクライアントとして添付しているDICEAdminShellはMFCで作られているC++アプリケーションである。当然ユーザによる改変は出来ないし、MFCというライブラリは今ではほとんど進歩の望めない陳腐化したテクノロジになっ てしまっている。これではいかにも面白くない。そこで、次に候補になるのは.NETだ。2004年にはDICEが.NETコンポーネントを ホストできるようにした。これはWebサーバ向けの機能として入れた物でWebアプリケーション実行が主用途だが、GUIを持ちユーザの デスクトップとインタラクトするアプリケーションも実行できる。現在のMS SQLサーバはストアドプロシージャをC#などで記述でき、同じようにDICEもCLRをホストしている。CodeDomを用いてC#などのソース コードをコンパイルしてアセンブリにした上でロードし実行する機能も入れてあるので、ユーザによるコード改変も容易である。問題は、GUIのコードを Windows Formsで開発するのが良いことなのかということだ。あと1年もすればWPF/XAMLがWindowsアプリケーションの標準ユーザインターフェイス定義言語になることは目に見えている。もう一つの可能性として、C#やC++/COMでIEコンポーネントを使う、あるいはGecko/XULでアプリケーションを構築するという道がある。IEコンポーネントの方は私自身が日常的にIEを使っていない関係上IEウィジェット の見栄えや挙動に縛られるのは個人的に嫌だし、Mozillaの方はお世辞にも開発サポートが豊富とは言い難くまたランタイムの 配布サイズも大きくなってしまいそうだ。

そこで、最後に検討しているのはWeb UIである。DICEにはIEとFirefoxの双方で使えるWeb IRCクライアントを作って入れた。これはJavaScriptでタブ切り替えのUIを構成し、AJAXのHTTPリクエストではなくFlashでサーバ本体との通信を行っている。画面遷移も勿論無い。DICEにはWebサーバ機能があるので、リモート用途でなくともWeb UIを簡単に付けられるというわけだ。もちろん、通信を暗号化すればインターネットを経由したリモートアクセスのためのUIと しても使える。Web UIの短所は、右クリックコンテクストメニューがフックできない場合があること、クリップボードやサウンド再生が使えないことである。クリップボードやサウンド再生は、リモートからアクセスするのではなくローカルで動かす場合なら本体の方で処理すればよいのでそれなりに対処できるが、右クリックコンテクストメニューはブラウザ自身のメニューとの 兼ね合いで問題がある。その点のみ無視すれば、基本的に、フレームバッファの内容に直接演算を適用しないと得られない特殊な視覚効果を除き、普通のデスクトップアプリケーション並みのリッチなUIをWeb UIでも実現できる。残る課題はFlashとサーバとの通信の暗号化くらいだけれども、それも目処が付いている。そういうわけで、今考えているデザインは、UIはWebブラウザを使って、それでカバーできない部分は上記の.NET CLRホスティングでC#ソースコードを公開しユーザが改変できるようにしたいと思っている。アプリケーションのコアは今まで 通りC++で、パフォーマンスの要らない部分は可能な限り.NETの方へ回す。このページの下にある私が書いた2004年の文章では 「C++が格下の存在になりつつある」などと書いているが、実態は全然そんなことはなかったようで、Windows Vistaですら.NETは一定の範囲に留められている。DICEにPerlも組み 込んだし、要は臨機応変というわけだ。フットワークの軽さなら自信がある。

以上が今後公開しようと思っているアプリケーションの話。このサイトで他にやっているのはプログラミング関係の雑文の公開だが、一番反響があるのは意外なことにSSLの証明書を証明書ストアに入れる方法の記事だっ た。資料が無くて困っているのは皆同じのようである。開発者が感謝のメールをくれたりする。中には記事の範囲を超えてあれこれと相談をし てくる人もいた。自分でビジネスをやっている人間は自分で問題解決して欲しいところだ。とは言っても私もFirefoxのBugzillaではオープンソースプロジェクトなのを良いことにかなり好き勝手な注文を付けたりしているので人のことは言えない。他人のリポートしたバグのプロパティを変更する権限を私は持っているので、他人のバグには介入するわで余計始末が悪い。

最近は諸々の理由で全くPCゲームをやっていない。一方で、ゲーム機のハードウェアへの興味が約2年前から非常に高まった。メインストリームPCがようやく並列プログラミングに入ろうかという時期に、ゲーム機は既に3コアとか9コアといった並列性の高いアーキテクチャをCPUに採用している。GPUの並列性はさらに高い。また、パフォーマンスがとかく軽視されがちなWebなどの プログラミングと異なり、パフォーマンスが何時の時代も追及されるのはゲームの分野である。ネットワークプログラミングも、MMOGやオンラインFPSなど一つのワールドイメージを維持しようとした場合の負荷は非常に高い。というわけでここ2年はBeyond3DのConsole Forumに入り浸っている。ここはゲームコンソール関連のフォーラムの中では世界で一番参加者の平均年齢並びに精神年齢が 高いのではないかと思われるフォーラムで、PS3やXbox 360の開発者もよく投稿しており、メモリのレイテンシにまで気を配るハードウェアに密着したプログラミングの話題は非常に勉強になる。ゲーム機の話題は技術的な物も含め日本発のものも多く、私はよく日本語記事の英訳を提供しているのでそれが各方面から喜ばれているようだ。Beyond3D自体はリアルタイム3Dグラフィックスハードウェア専門サイトで、業界人御用達のような場所である。

IRCも約2年前からあまりやっていない。今でも海外のネット上の情報の一番濃い部分がIRCにあるという点は変わらないが、それでもWebのフォーラムが爆発的に普及してきているという印象がある。6、7年前は、日本の方が掲示板は進歩していたと思う。 ところがそれ以降は海外の掲示板がCMSの進歩やPHPの台頭と相俟ってWebサイトの必需品となり、発展してきた。 imageshackとかimagevenue のようなイメージホスティングサービスも掲示板貼り付けを前提としてPHP掲示板用のBBコードを用意してくれる。海外の掲示板カルチャーは確固たるメンバー管理システムと組み合わさっていて、運用にはデータベースが必須である。CMSと親和性が高いのも当たり前だ。日本に見られる2chのような一様な匿名空間やSNSと称した出会い系サービスの作る空間、blogの散漫な空間とは一線を画した、社会的でかつ開かれた議論を行うための空間がそこにはある。こうなってくると、TCP/IPに乗せるのはHTTP だけで良く、IRC等は要らないのではないかという疑念も生じるかも知れない。しかし、Webフォーラム とIRCの微妙な差異は依然として残っており、通信のオーバーヘッドの多寡を除けば、その差異とは、IRCではチャンネルのメンバーリストがリアルタイム に更新されメンバーの出入りがリアルタイムに宣言されるという点である。IRCはメンバーのプレゼンスをも模している。この参加者の居るライブ感という差異が残る限り、IRCが滅びることはない。一方で、Second LifeやWorld of Warcraftのような3Dの専用 クライアントによるリアルタイムコミュニケーションも、10年前には失敗したが回線品質が向上した現在はクリティカルマス に達しようかというところまで来ているようだ。それでも、無駄な部分を省いたコミュニケーションの需要は残るはずであり、むしろ参入障壁が十分に低ければシンプルなものがリッチなものを出し抜く可能性が十分にある。Web IRCクライアントにはそのような展望も込めている。

The second half is for a bit more advanced programming topic; it’s about how to write a C++ application with an embedded Perl or Ruby interpreter. Simply embedding them is not rocket science, but using them in an effective manner is not a very easy task right now because of the implementations of these languages. If you are familiar with .NET you might know it’s embedded-friendly with AppDomain and COM interfaces. On the other hand you have only raw C interfaces for these scripting languages, let alone scarce documents. As for Perl embedding, the sample code is based on the version I actually implemented in the web server of the DICE. Since it’s realized by the mixture of C++ code and Perl hack, it requires some knowledge of C/C++, advanced Perl programming, and Perl internals. But don’t be scared, I’ll annotate most lines in the code to make it useful for as many people as possible because it’s the very purpose of this article! Last but not least, the platform for those experiments is Microsoft Windows XP and Visual C++ 7.1. But due to the platform-neutral nature of these scripting languages most things should be applicable to any platforms.

Though Microsoft Windows is my primary desktop, I still use the Perl scripting language to make a code snippet for a trivial text manipulation task such as list generation in the shell or some network test. I know the Ruby object-oriented scripting language has become one of the hot topics among tech-savvy people, but I’d prefered Perl just because I was familiar with it for longer time through developing Perl CGI applications in the earlier part of my programming history. My most preferred programming language is by far C++, but it’s not exactly handy to write a tiny application. I like C# and .NET too, but it’s still overkill. Dynamic languages have certain drawbacks and I would like to criticise them, but it’s true dynamic languages are sweet.

There are many scripting languages, Perl, Ruby, Python, PHP… First Python is out, I don’t like significant whitespaces because I do lots of indents for an aesthetic reason only. Next I drop PHP, its focus seems to be the companionship with Apache and nothing else. Ruby is cool, but I didn’t like the begin…end block. Braces can be used for blocks, but not in other places. Basically I’m too fond of the C-style (or Algol-style) syntax. Perl 5 is a clumsy procedural scripting language built on the C-like syntax, and the only point I applaud in Perl is that it recommends the C-like syntax (albeit with a little difference here and there) if you try to be consistent. If I could use Ruby with C/Java like syntax I’d completely abandon Perl anyday. But it didn’t happen.

Besides, object-orientedness in Ruby doesn’t matter in a small code snippet, since humans are not that dumb and can use non-object-oriented, non-intuitive expressions. Well it’s not totally useless, but it makes more sense in the other situations. When you are building a huge software stack or a huge loosely-coupled software network, capsulation is very important. There are other goodies in Ruby, but I couldn’t care less about esoteric syntax sugars. So is Perl the perfect language for writing a code snippet? It has to be tested how perfect it is anyway.

One day I noticed my favorite download manager application for Windows didn’t support chunked HTTP transfer properly. The downloader / web site grabber application, Irvine, is an excellent Japanese software but the development halted a few years ago. Its document said it would support it in future, but it’s apparent that it wouldn’t arrive for a while. If I have enough time I want to develop an HTTP download manager just for myself in C# or something, but it’s not possible then. What I needed at that time was downloading many files off a web site that is configured to send all files in chunked transfer. Therefore I began evaluation of a network library of Perl to see if it can do chunked transfer. If it can, I can just write a short Perl script to get the result I want. But it doesn’t end there, as I had to download hundreds of files it’s preferable that it downloads multiple files at the same time just like the aforementioned Windows application. I knew Perl had implemented multithreading years ago, but still had the impression that it might be awkward. So this is a nice occasion to do an experiment for these 2 points: HTTP networking and multithreading.

Thinking about them, it came to my mind that I’d read somewhere that Ruby supports them out of the box. Ruby supports multithreading even in DOS by its own non-native threads. Also Ruby’s library can handle networking with ease, as far as I knew. I’d known how Ruby works and what kind of things are available for it for years but didn’t write a Ruby code as Perl was sufficient for my use. On the other hand I knew the transition to Perl 6 was not exactly smooth and I’d waited years for it to come but eventually the whole Perl scene got out of my interest when I was into other things. So this is a good occasion to test Ruby for myself and see how my prejudice against it which I wrote above about its non-C-like appearance can stand and if I can move to Ruby for my code snippets.

So let’s write a multithreaded download manager for Perl. First, we must choose how to download files. Since my purpose is to get an application that can handle chunked transfer properly and just that, it’s obvious I can’t bother to write a complicated network negotiation with basic Perl Socket classes! libwww-perl (LWP) is a set of Perl modules which provides API to write a web client. I tested if it can download a file from the web site from which the Windows downloader application failed to download a file and fortunately it worked. I forget if the standard Perl distribution for Windows available from ActiveState has LWP, if it’s not installed you have to download it from the author’s page at the CPAN and build it with the nmake of Visual C++ (probably freely available from Microsoft) from the command line. With libwww-perl you can control a web client object to surf the web.

Another thing to look at is how Perl’s multithreading works. Perldoc has a tutorial for Perl multithreading, perlthrtut. This document has most of the info you need to program a multithread application. If there’s only one point which is specific to the Perl thread, it’s that memory space is not shared by threads unlike usual thread implementations. All usual premitives that are used in multithreaded programming is available in there. For more info about thread-related modules in Perl such as threads::shared, see their documents from the author’s page at CPAN.

By the way I first tried to make my downloader application in this way – it spawns multiple worker threads from the main thread and suspends the main thread by putting a blocking semaphore (by setting the counter value 0) in it, then a worker thread downloads a file in the download queue, and it spawns another thread at the end of a thread, finally when the queue becomes empty the semaphore in the main thread is lifted, then all threads are joined and the main thread ends. The number of worker threads is kept at the same number throughout execution. But it didn’t work, as the Perl interpreter crashes at the end of execution everytime I run it though it can download all the files in the list. For writing a native multithread application for Microsoft Windows this should work, but in Perl’s case you have to join all threads without spawning a new thread from a running thread. I first thought it’s caused by a bug in the thread module and browsed the forum for the module, and what I found was there are non-thread-safe modules which can’t be used in Perl threads. libwww-perl looks like that and if I removed it the program ended without an error. Seeking the solution I downloaded the latest version of the threads module from the author’s page and built it. I tested threads-1.42 which was the latest at the time I wrote the Perl script. It had a small problem when compiling it with VC++, it couldn’t detect the existence of a C compiler even though I used the command console provided in the Microsoft Platform SDK. The solution is to edit Makefile.pl and skip the have_cc subroutine. Then you can compile and install it. But it had still the same crash. Without a choice I abandoned this design and decided to use the more traditional, pthread-esque design.

In this actual design of the script, it spawns worker threads and they get in infinite loops that pick up a job from a job queue one by one. The main thread blocks by calling the join function on these worker threads. This looks fairly simple even from the description of it and may look better than what I described above, but I prefer a more asynchoronous style if it works. I wrote it and this time it worked flawlessly without a crash and resource leaks. The following is the code. It’s tested with the Win32 version of Perl 5.8.8 available from ActiveState, threads-1.42 module, and libwww-perl-5.805 module.

The simple user configuration section comes at the top.

# user configuration begin ################################

# You have to list the URLs for the files to be downloaded in a file named
# "download_files.txt" and put it in the same directory as this script.

my $username = "";
my $password = "";

my $number_of_threads = 3;
my $download_interval_sec = 3;

my $download_list_filename = "download_files.txt";

my $storage_directory = 'E:\program\src\downloader\store'; # set "" for the current directory

my $user_agent_string = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)";

# user configuration end ##################################
 

$username and $password are for basic authentication at password-protected pages. $number_of_threads tells how much worker threads do the downloading work simultaneously. You can set how many seconds it waits before making a new download connection in $download_interval.

After user configuration options, you have to load necessary modules and other tools useful throughout this application.

use strict;
use warnings;

use threads;
use threads::shared;
#use Thread::Queue;
use Thread::Semaphore;

use LWP::UserAgent;
use Cwd;

my $current_directory = Cwd::getcwd();

if (!$storage_directory)
{
	$storage_directory = $current_directory;
}

$| = 1;

my @download_queue : shared; # used for optimization instead of Thread::Queue

my $sem_download_queue = new Thread::Semaphore;
my $sem_stdout = new Thread::Semaphore;

my $last_download_time : shared = 0;
	  

The strict and warnings modules are in action here to ban obscure expressions which are often seen in Perl hacks. While this is a relatively short script it’s always nice that minor things don’t bother users. $| = 1 expression is what you always see in Perl scripts that process realtime I/O. It prevents buffering and forces Perl to issue more I/O calls. The synchoronized download queue where all jobs are put and fetched from in the serial manner is @download_queue. To make it accessible from multiple threads, you have to mark it explicitly with the shared keyword and this is Perl-specific way as I wrote above. Actually Perl already has a useful tool for a situation like this as the Thread::Queue module, it’s absent as I control the scope of synchonization explicitly to gain a bit better performance. So it requires a semaphore object as a synchronization primitive, $sem_download_queue. $sem_stdout is the semaphore to synchronize the standard output, since multiple threads try to print text reports simultaneously. $last_download_time is the variable used to force threads to put an interval between downloads as explained in the configuration options.

The next part is the main loop of the script.

print "Perl threads version: " . $threads::VERSION . "\n";

open(IN, $current_directory . "\\" . $download_list_filename) || die("Can't open " . $download_list_filename);

while (<IN>)
{
	chomp;
	if ($_ =~ /^http:/i)
	{
		push @download_queue, $_;
	}
}

close(IN);

print @download_queue . " URIs have been loaded from the download list\n";

for (my $i = 0; $i < $number_of_threads; ++$i)
{
	new threads(\&amp;download_thread_func);
}

foreach my $thr (threads->list)
{
	if ($thr->tid)
	{
		$thr->join;
	}
}

print "Download completed\n";

################################################################
	 

Very short, don’t you think? It’s cooler that there are less things to tweak than to be error-prone. It reads the content of the URL list and puts all of them in the download job queue. Then spawns worker threads, and waits them by calling join. As the join function blocks, the main thread can stay in memory waiting all worker threads to return from the work. If it didn’t block, the main thread would just exit and the whole program would halt leaking thread resources.

A spawned worker thread calls the function referenced as download_thread_func. Let’s see the part that does the heavy work.

sub print_ts
{
	$sem_stdout->down;
	my $tid = threads->self->tid();
	print ($tid . ": " . shift @_);
	$sem_stdout->up;
}

sub download_thread_func
{
	for (;;)
	{
		my $u = "";
		my $sleep_time = 0;

		$sem_download_queue->down;

		if (@download_queue == 0)
		{
			$sem_download_queue->up;
			print_ts "The download queue is empty\n";
			return;
		}
		else
		{
			$u = shift @download_queue;

			# $last_download_time is protected by $sem_download_queue
			my $t = time();
			if ($t < $last_download_time)
			{
				$sleep_time = $last_download_time - $t + $download_interval_sec;
			}
			else
			{
				if ($t - $last_download_time < $download_interval_sec)
				{
					$sleep_time = $download_interval_sec - ($t - $last_download_time);
				}
				$last_download_time = $t + $sleep_time;
			}
		}

		$sem_download_queue->up;

		if ($sleep_time)
		{
			print_ts "Sleeping for " . $sleep_time ." seconds\n";
			sleep($sleep_time);
		}

		download_uri($u);
	}
}
	

print_ts is just a debug output function mainly used to show HTTP headers. It’s a print functon synchronized by a semaphore. The download_thread_func subroutine fetches a job from the job queue then consumes it. It continues to do it until the queue gets empty. The part that tests and modifies the download queue is synchronized by a single semaphore. The actual download is handled by the download_uri subroutine desctibed below.

sub download_uri
{
	my $uri = shift @_;

	print_ts "Downloading $uri\n";

	my $ua = new LWP::UserAgent;
	$ua->cookie_jar({});

	my $req = new HTTP::Request(GET => $uri);
	$req->header(
		"User-Agent" => $user_agent_string,
		"Accept" => 'image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*',
		"Accept-Charset" => 'iso-8859-1,*,utf-8',
		"Accept-Language" => 'en-US'
	);

	if ($username)
	{
		$req->authorization_basic($username, $password);
	}

	my $response = $ua->request($req);

	if ($response->is_success)
	{
		print_ts "header begin-----------------------------------------\n"
			. $response->headers_as_string
			. "header end-------------------------------------------\n";

		my $is_chunked = (
			($response->header('Transfer-Encoding') && $response->header('Transfer-Encoding') =~ /Chunked/i)
				|| ($response->header('Client-Transfer-Encoding') && $response->header('Client-Transfer-Encoding') =~ /Chunked/i)
			)
					? 1 : 0;

		if ($response->header('Content-Length') && $response->header('Content-Length') == 0 && !$is_chunked)
		{
			print_ts "Content-Length is zero\n";
		}
		else
		{
			my $image_name = "tmp.bin";
			if ($uri =~ /\/([^\/]+)$/)
			{
				$image_name = $1;
			}

			if ($response->header('Content-Disposition'))
			{
				if ($response->header('Content-Disposition') =~ /filename=(.+)/i)
				{
					$image_name = $1;
					$image_name =~ s/"//g;
				}
			}

			if (!open(OUT, ">$storage_directory\\$image_name"))
			{
				print_ts "open error : $storage_directory\\$image_name\n";
				exit();
			}
			else
			{
				binmode(OUT);
				#my $fsize = $response->header('Content-Length');
				if (!defined(syswrite OUT, $response->content, length($response->content)))
				{
					print_ts "syswrite error : $storage_directory\\$image_name\n";
				}
				syswrite OUT, $response->content, length($response->content);
				close(OUT);

				print_ts "Downloaded $image_name\n";
			}
		}
	}
	else
	{
		my $st = $response->status_line;
		print_ts "Error: $uri : $st\n";
	}
}
	  

It instantiates an object of the LWP::UserAgent class to do HTTP negotiation and sets necessary HTTP headers for it. After a request is sent, the object receives an HTTP response header and body. As the purpose of this script is to download a file off of a setver that does chunked transfer, it does check if it founds an HTTP header line that indicates it, Transfer-Encoding or Client-Transfer-Encoding. In a chunked transfer, a real file name is communicated by a Content-Disposition header, so it scans this header too. When all necessary info are available the rest thing to do is to save received data into a file. If it’s a binary file, you have to call binmode to set the file handle in the binary mode on Windows. The data length can be obtained by a Content-Length header for a nomal HTTP response but the chunked transfer is the method to send a file without sending a Content-Length header. Conveniently the data size is already known by the length of $response->content data.

That’s all for the Perl downloader script. It’s about 200 lines and it works, no big deal. So let’s move onto the next task, porting it to Ruby.

Before writing the code, as Japanese is my 1st language I went to the Japanese side of the Ruby HQ, ruby-lang.org for the Ruby language/library refererence. It’s known that Ruby was invented in Japan and some non-Japanese users often complain the help documents of Ruby are rather weak compared to Perl and Python in a language comparison war. But the reality is, the Japanese documents for Ruby are downright terrible. At least the official manual is very sparse and unorganized. Probably mailing lists and code samples in Japanese may carry beefier contents than English equivalents, but the Japanese documents at ruby-lang.org are not something you yearn for and I actually found English documents linked from the English side are more useful.

Writing a Ruby code immediately after writing a Perl code is a bit puzzling experience. In Ruby, the @ prefix means an instance variable (or an object property, in a more usual object-oriented lingo) unlike the array expression in Perl. In Ruby it’s about a variable scope and in Perl it’s about a data type. I like Ruby’s scope which is more object-oriented and cleaner than Perl’s one which is heavily dependent on its symbol table and often the source of dirty hacks. But the main problem is besides that. It’s about braces. As I wrote at the beginning of this article I like braces and would like to use it as much as I can do. But Ruby only allows it at blocks and I often trip on it by using braces where it accepts only do...end. Another thing is, Ruby doesn’t require you to end a line with a semicolon, but when you put an unwanted carriage-return it just emits syntax errors and stops. So you can’t hit the Enter key just to tidy up the layout. It is especially problematic when you declare a block parameter for a block which is one of the main selling points of Ruby. So my advice for writing a Ruby code is: don’t use braces and don’t hit the Enter key too often.

Let’s take a look at the Ruby version. The user configuration part is at the beginning and it won’t need much explanation as it’s almost identical to the Perl version. Some variables are declared as instance variables of the main function as they are used not before declaration in some methods. In the Ruby version, HTTP negotiation is handled by the standard net/http library which, fortunately again, can download chunked transfer files. thread is Ruby’s intrinsic class for multithread programming. uri is a small utility class to handle a URI. Net::HTTP.version_1_2 is the pragma to instruct net/http to use the newer implementation. if $0 == __FILE__ line is an include guard but it means nothing in this demo. This script is tested with Ruby 1.8.5.

# user configuration begin ################################

@username = ""
@password = ""

number_of_threads = 3
@download_interval_sec = 3

download_list_filename = "download_files.txt"

@storage_directory = 'E:\program\src\downloader\store' # set "" for the current directory

@user_agent_string = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)"

# user configuration end ##################################

require 'net/http'
require 'thread'
require 'uri'

Net::HTTP.version_1_2

if $0 == __FILE__
	  

The following section contains the Ruby versions of the functions with the same name as in the Perl version. The only difference is it uses synchronization primitives (mutex) more intuitively.

def puts_ts(x)
	@mutex_pt.synchronize do
		puts Thread.current.object_id.to_s + ": " + x
	end
end

def download_thread_func
	while true do
		u = ""
		sleep_time = 0

		@mutex_dq.synchronize do
			if @download_queue.empty?
				puts_ts "The download queue is empty"
				return
			else
				u = @download_queue.shift
				# @last_download_time is protected by @mutex_dq
				t = Time.now.gmtime.to_i
				if t < @last_download_time
					sleep_time = @last_download_time - t + @download_interval_sec
				else
					if t - @last_download_time < @download_interval_sec
						sleep_time = @download_interval_sec - (t - @last_download_time)
					end
					@last_download_time = t + sleep_time
				end
			end
		end

		if sleep_time != 0
			puts_ts "Sleeping for " + sleep_time.to_s + " seconds"
			sleep sleep_time
		end

		download_uri u
	end
end
	  

The next section is again the function with the same name as the Perl version, but its content is a little different.

def download_uri(uri)

	puts_ts "Downloading #{uri}"

	req = Net::HTTP::Get.new(URI.parse(uri).path)

	req["User-Agent"] = @user_agent_string
	req["Accept"] = 'image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/png, */*'
	req["Accept-Charset"] = 'iso-8859-1,*,utf-8'
	req["Accept-Language"] = 'en-US'

	req.basic_auth @username, @password unless @username.empty?

	begin
		Net::HTTP.start(URI.parse(uri).host, 80) do |http|
			http.request(req) do |res|
				h = "#{res.code} #{res.message}\nheader begin-----------------------------------------\n"

				is_chunked = false
				filename = ""
				res.canonical_each do |n, v|
					h += (n + ": " + v + "\n")
					if n =~ /Transfer-Encoding/i && v =~ /Chunked/i
						is_chunked = true
					end
					if n =~ /Content-Disposition/i && v =~ /filename=(.+)/i
						filename = $1
						filename.gsub(/^"|"$/, '')
					end
				end
				h += "header end-------------------------------------------"
				puts_ts h

				unless res.code == "200"
					return
				end

				if filename == "" && uri =~ /\/([^\/]+)$/
					filename = @storage_directory + "\\" + $1
				end

				open(filename, "wb") do |file|
					res.read_body do |str|
						file.write str
					end
				end
			end
		end
	rescue Exception => e
		puts_ts e.to_s
	end

end
	  

By processing a code block the Net::HTTP class can process an incoming HTTP response-body stream in multiple small chunks as the read_body function of the Net::HTTPResponse class returns. It means you don’t have to store the whole received file in memory before dumping it onto a file unlike the Perl version. This can be an advantage when a downloaded file is large.

The rest covers the main function. I think you can see the pattern here and it needs no further explanation. << is a useful overloaded operator to push an element to the end of an array just like stack manipulation.

# main begin #############################################################
@mutex_pt = Mutex::new

if @storage_directory.empty?
	@storage_directory = Dir.pwd
end

@download_queue = []
@mutex_dq = Mutex::new
@last_download_time = 0;

File.foreach(download_list_filename) {|line|
	@download_queue << line.chomp if line.match(/^http:/i)
}

threads = []

for i in 1..number_of_threads
	threads << Thread::start do download_thread_func end
end

for i in 1..number_of_threads
	threads[i - 1].join
end

# main end ###############################################################
end
	  

That’s all for the Ruby version.

Now how do they compare? The first thing to be noticed is the script length. The Perl version is over 200 lines and 4,890 bytes. The Ruby version is under 150 lines and 3,383 bytes. The second point is the performance as they are multithreaded to squeeze extra performance in the first place. I used them to download dozens of files and the Perl version used about 15MB RAM and the Ruby version occupied only 5MB. This is probably due to the difference of downloading methods between 2 network libraries (whole download vs partial), but also due to the implementation of interpreter threads in these languages, since 15MB RAM usage is a bit too high for downloading files around 100KB. The speed seemed a tie, but in some cases the Perl version was faster and the Ruby version stuttered. Probably it can be attributed to file I/O and some context-switching awkwardness in the Ruby version.

My final verdict on this subject is, Ruby is the winner, contrary to some of the possible doubts I suggested above. Of course I still don’t like begin...end, but if you like the way Java programs are written I guess you like Ruby too. Ruby is even nicer than Java. Basically there’s nothing Ruby can’t do except for Perl-specific symbolic hacks. Why not just jump ship and switch to Ruby for good?

But this discourse doesn’t end there. Ruby is certainly a new kid on the block (well not very new actually but leave it at that now) that presents great opportunities. Even then, there may be something useful in an older and proven tool. My server application, DICE, ended up with an embedded Perl interpreter instead of Ruby. DICE has already had a Common Language Runtime (CLR) embedded since years ago, but for the upcoming new version I planned to add something new to make a bullet point for the update list as it took over a year to prepare a new version. Though at first I wanted to embed PHP which is fairly popular for a web application because of the affinity with the Apache HTTPd, I abandoned that idea for now as the information about PHP embedding seemed scarce on the web. (BTW I downloaded the source code of the PHP5 and browsed it, it’s not much bigger than the source code of the DICE in size which was a surprise for me.) So the candidates are, as you expect, Ruby and Perl. What I’d like to accomplish is embedding an interpreter in the DICE and making it process a web application, but not executing it for every request ala CGI. However, the merit of including such an interpreter is that it can support existing applications available without writing a new code. The DICE has a CLR embedded in it to execute a web application, but it requires a user to write a stub code, or an entire application. This time I want existing CGI applications to run on the DICE. Therefore the goal is to add mod_perl or mod_ruby like capability to it. The requirements are

1. The interpreter is persistent.
2. All input from the standard input and all output to the standard output must be hooked by the DICE because stdin/stdout are the points where CGI scripts interact with an internet user through a web server.

This section of this article begins with Ruby. Before writing a code for embedding Ruby, you have to learn the license of Ruby. It adopts the dual license by the GPL and the other BSD-like license. It seems you can do whatever with Ruby if you don’t choose GPL, but in reality it’s not that simple. The current Ruby implementation (1.8) contains the GNU regular expression library and it forces you to make your application GPLed if you just embed a Ruby interpreter as is. Actually there’s a workaround and it’s very simple. The current development version of Ruby (1.9) has the Oniguruma regular expressions library which is under the BSD license to avoid this license issue. If you choose to stick to 1.8, the source code of Oniguruma version 2.x is available for download, it can be integrated it onto Ruby 1.8 source codes (the instruction is in the Onigruma document). After building the whole Ruby, you can open the binary (msvcr71-ruby19.dll if you use VC++ 7.1 and Ruby 1.9) with Dependency Walker to see if it has Onigruma symbols (prefixed with Onig) and not GNU regex ones.

The first thing you have to do is to download the Ruby source code. Because of the reason I wrote above I recommend the 1.9 development nightly snapshot (snapshot.tar.gz) found in the download page of the ruby-lang.org. Then obviously you have to learn how to embed Ruby somewhere for embedding Ruby. The particular document I referred to when I wrote my sample code was magazine articles written by Shugo Maeda, the author of mod_ruby. They are found around here and here at Mr. Maeda’s web site, and his VIM patch is here. They discuss how he embedded Ruby into the vi-clone editor VIM. Unfortunately they are in Japanese though they have some code samples. And this is the real horror story, I couldn’t find other detailed Japanese documents for embedding Ruby. Actually the English EmbedRuby article at the Ruby Garden is probably the second best source of info on this matter. After you read the tutorial, you can download the C source code of mod_ruby to learn how a real-world application hosts a Ruby interpreter though it may be hard for those who are not familiar with how an Apache module works.

In addition to the basics of embedding Ruby, Maeda’s article offers how to interrupt the standard output of Ruby and trap it to feed to VIM instead of the console screen. Ruby’s outputs are all assigned in the $> special variable and its real body in the C implementation of Ruby is the object named rb_defout. By hooking the write method of this object you can trap all Ruby outputs to the standard output. But how? You can do that by the rb_define_singleton_method function defined in the class.c of the Ruby source code. It defines a “singleton method” which is a special method for a special object, which is rb_defout in this case. Also you can redefine each output method in Ruby if you will by the rb_define_global_function function. It’s useful to preserve the way each output method behaves differently. If you read the source code of mod_ruby you’ll notice it actually redefines all related methods in Ruby with respective hook functions. VALUE is a Ruby type which can hold any Ruby object which is something like the VARIANT type in COM, or the void* type in C.

-- class.c --
void
rb_define_singleton_method(VALUE obj, const char *name, VALUE (*func)(ANYARGS), int argc)
{
    rb_define_method(rb_singleton_class(obj), name, func, argc);
}

void
rb_define_method(VALUE klass, const char *name, VALUE (*func)(ANYARGS), int argc)
{
    rb_add_method(klass, rb_intern(name), NEW_CFUNC(func, argc), NOEX_PUBLIC);
}

void
rb_define_global_function(const char *name, VALUE (*func)(ANYARGS), int argc)
{
    rb_define_module_function(rb_mKernel, name, func, argc);
}
-- eval.c --

void
rb_add_method(VALUE klass, ID mid, NODE *node, int noex)
{

}
	  

To build a C++ code with a Ruby interpreter embedded, you need Ruby header files, the Ruby static library and the Ruby dynamic link library. The header file, ruby.h, is found in the root directory of the Ruby source code archive. The static/dynamic libraries can be obtained by building the Ruby source code. To build it on Windows, open your VC++/Platform SDK build environment console and run the configure.bat in the win32 directory then type nmake. You get msvcr71-ruby19.lib for the static library and msvcr71-ruby19.dll for the dll. Note that it doesn’t produce a static library for static linking. These are release builds that refer to the release version of the MS C-runtime library. I tried to build a debug version by editing the makefile by changing the compiler option /MD to /MDd but the build stopped in building one of .exe. It seemed to have created libraries at least, but I couldn’t link it with an embedding C++ code in the Debug mode nor in the Release mode.

Once the Ruby library is ready you have to set up your build environment for your Ruby-embedded application. Set the root directory of the Ruby source code in your include path and set the library path in your LIB directory (In VC++ it’s in Tool | Options | Projects | VC++ Directories | Library files). As the resulted executable requires msvcr71-ruby19.dll to run you should copy it in the working directory by yourself. For the C-runtime library, you have to choose the multi-threaded DLL or the multi-threaded debug DLL since Ruby’s memory manager is built with the multithread version of the library. Unfortunately the library built by the default makefile has conflicts with other library in the Debug mode with the multi-threaded debug DLL (/MDd). You have to address it by putting libcmtd.lib in Linker | Input | Ignore Specific Library in the VC++ project options for the Debug mode. In the Release mode it’s not required, but it still issues linker warnings LNK4049. I tried to create a project file by myself but failed to do that as the Ruby I built couldn’t get the current directory as it can’t access some APIs. I hope these issues with Windows are resolved in the future.

The environment is ready, let’s see the actual C++ code. This sample code is written for a Ruby 1.9 development snapshot and doesn’t work with Ruby 1.8 as there are significant changes in the Ruby source code in 1.9. What this code does is fairly simple, initializes a Ruby interpreter, loads and execute a Ruby script, then destroys the interpreter. It includes necessary files at the beginning. For the sake of simpleness I included the library file by the pragma, but it may be safe to do in in the project setting if your project contains many files that can conflict with it. (Actually for Perl embedding it didn’t work if I did this.) In addition to the ruby.h, standard C++ headers are included for utility functions.

#pragma comment(lib, "E:\\program\\lib\\rubylib\\ruby_win32\\usr\\lib\\msvcr71-ruby19-static.lib")

extern "C" {

#include <ruby.h>

}

#include <iostream>
#include <string>

using namespace std;
	  

First, output hook functions are defined.

VALUE ruby_write_hook(VALUE self, VALUE str)
{
	str = rb_obj_as_string(str);
	cout << string(RSTRING_PTR(str), RSTRING_LEN(str));

	return Qnil;
}

VALUE ruby_p_hook(int argc, VALUE *argv, VALUE self)
{
	VALUE str = rb_str_new("", 0);

	for (int i = 0; i < argc; i++)
	{
		if (i > 0)
			rb_str_cat(str, ", ", 2);

		rb_str_concat(str, rb_inspect(argv[i]));
	}

	cout << RSTRING_PTR(str);

	return Qnil;
}

ruby_write_hook is a function to hook the singleton method of rb_defout as explained already. It extracts a char* pointer and its length from a Ruby string that is assigned to this special object, and outputs it by itself with cout. Qnil is the null value in the Ruby C implementation. ruby_p_hook is defined to redefine the kernel method p that is used to print the state of an object in a human readable form like ToString method in C#/Java. It create a new Ruby string by rb_str_new and enumerates its elements by adding them by rb_str_concat.

init_ruby is the function that initializes the Ruby interpreter. ruby_init_loadpath initializes the library path of Ruby. show_error_pos and show_exception_info are the functions that shows detailed error information just like what you get when you feed an erroneous Ruby script to the Ruby interpreter.

void init_ruby()
{
	ruby_init();
	ruby_init_loadpath();
}

void show_error_pos()
{
	ID this_func = rb_frame_this_func();

	if (ruby_sourcefile)
	{
		if (this_func)
		{
			cout << ruby_sourcefile << ":" << ruby_sourceline << ":in" << rb_id2name(this_func) << endl;
		}
		else
		{
			cout << ruby_sourcefile << ":" << ruby_sourceline << endl;
		}
	}
}

void show_exception_info()
{
	if (NIL_P(ruby_errinfo))
		return;

	VALUE errat = rb_funcall(ruby_errinfo, rb_intern("backtrace"), 0);
	if (!NIL_P(errat))
	{
		VALUE mesg = (RARRAY_PTR(errat))[0];

		if (NIL_P(mesg))
		{
			show_error_pos();
		}
		else
		{
			cout << string(RSTRING_PTR(mesg), RSTRING_LEN(mesg));
		}
	}

	VALUE eclass = CLASS_OF(ruby_errinfo);

	char* einfo;
	int elen;
	int state;
	VALUE estr = rb_protect(rb_obj_as_string, ruby_errinfo, &amp;state);
	if (state)
	{
		einfo = "";
		elen = 0;
	}
	else
	{
		einfo = RSTRING_PTR(estr);
		elen = RSTRING_LEN(estr);
	}

	if (eclass == rb_eRuntimeError &amp;&amp; elen == 0)
	{
		cout << ": unhandled exception" << endl;
	}
	else
	{
		VALUE epath;

		epath = rb_class_path(eclass);
		if (elen == 0)
		{
			cout << ": " << string(RSTRING_PTR(epath), RSTRING_LEN(epath)) << endl;
		}
		else
		{
			char* tail  = 0;
			int len = elen;

			if ((RSTRING_PTR(epath))[0] == '#')
				epath = 0;

			if (tail = strchr(einfo, '\n'))
			{
				len = tail - einfo;
				tail++;
			}

			cout << ": " << string(einfo, len);
			if (epath)
			{
				cout << " (" << string(RSTRING_PTR(epath), RSTRING_LEN(epath)) << endl;
			}

			if (tail)
			{
				cout << string(tail, elen - len - 1) << endl;
			}
		}
	}

	if (!NIL_P(errat))
	{
		const int TRACE_HEAD = 8;
		const int TRACE_TAIL = 5;
		const int TRACE_MAX = TRACE_HEAD + TRACE_TAIL + 5;

		RArray* ep = RARRAY(errat);

		long len =  RARRAY_LEN(errat);
		for (int i = 1; i < len; ++i)
		{
			if (TYPE((RARRAY_PTR(errat))[i]) == T_STRING)
			{
				cout << "  from " << string(RSTRING_PTR((RARRAY_PTR(errat))[i]), RSTRING_LEN((RARRAY_PTR(errat))[i])) << endl;
			}

			if (i == TRACE_HEAD &amp;&amp; len > TRACE_MAX)
			{
				cout << "   ... " << len - TRACE_HEAD - TRACE_TAIL << "ld levels..." << endl;
				i = len - TRACE_TAIL;
			}
		}
	}
}

The last part is the function that loads and executes a Ruby script (execute_ruby) and the main function. It registers output hook functions in the Ruby interpreter by rb_define_singleton_method and rb_define_global_function.

void execute_ruby(const char* pScriptName)
{
	int state = 0;

	extern VALUE rb_defout;

	typedef VALUE (*rubyfunc)(...);

	rb_defout = rb_obj_alloc(rb_cObject);
	rb_define_singleton_method(rb_defout, "write", (rubyfunc)ruby_write_hook, 1);
	rb_define_global_function("p", (rubyfunc)ruby_p_hook, -1);

	// Always need a full path
	rb_load_protect(rb_str_new2(pScriptName), 0, &state);
	if (state)
	{
		switch (state)
		{
		case 0x1: // TAG_RETURN
			cout << "unexpected return" << endl;
			show_error_pos();
			break;
		case 0x2: // TAG_BREAK
			cout << "unexpected break" << endl;
			show_error_pos();
			break;
		case 0x3: // TAG_NEXT
			cout << "unexpected next" << endl;
			show_error_pos();
			break;
		case 0x4: // TAG_RETRY
			cout << "retry outside of rescue clause" << endl;
			show_error_pos();
			break;
		case 0x5: // TAG_REDO
			cout << "unexpected redo" << endl;
			show_error_pos();
			break;
		case 0x6: // TAG_RAISE
		case 0x8: // TAG_FATAL
			show_exception_info();
			break;
		default:
			cout << "unknown longjmp status " << state << endl;
			break;
		}
	}

	rb_gc();
}

int _tmain(int argc, _TCHAR* argv[])
{
	init_ruby();

	execute_ruby("test.rb");

	ruby_finalize();

	return 0;
}

The rb_load_protect function is the protected version of the rb_load function and it doesn’t cause a segmentation fault even when loading fails. Unless there’s a special reason you should always use the protected version of Ruby functions. After evaluation of a script is done, it shows error information if any. rb_gc is called at the end to invoke the garbage collector.

When this program is executed it loads the “test.rb” Ruby script and executes it. I tested it with a simple script that does print some strings and apparently it could output characters through the redefined hook functions. I thought that my experiment was a success and I’d move onto writing the real code for embedding Ruby. But I did one more test. It was to feed the Ruby downloader script which I described above to this test code. To my surprise, it halted with the “memory error” in the Ruby interpreter. I have no idea what’s wrong, but apparently the culprit was the net/http library. As the library path is in the $LOAD_PATH variable it’s not a loading error. At this point I had no idea what happned and wanted to debug it, but the Ruby library is compiled without debug symbols as explained at the beginning of this section. I was really disappointed in this result as I thought the experiment was almost a success. Eventually I abandoned the idea of embedding Ruby into my application. It is known that the Ruby author himself admits that the weakness of the current Ruby implementation is in embedding because it can’t have multiple interpreters side by side, but I didn’t know there was such a basic problem. It’s expected the next version of the Ruby VM addresses some of the issues in embedding, but apparently it’s far off in 2008. There may be some workaround to this if I look more carefully into the mod_ruby source code, but I lost my energy for further research for the time being. If you know a solution please email me, thanks in advance.

The last hope is naturally on Perl. First you need the source code of Perl. I used a Perl development snapshot available at here but snapshots of the development trunk in this directory often fail to build or pass the test. After looking at the latest version number of the stable release at Perl.com , you may pick up the latest stable snapshot in another directory. You can find exactly which snapshot is broken at the perl.perl5.porters newsgroup.

To build it on Windows, edit the Makefile in the win32 direcrtory (in most cases just editing the install path and the compiler selection are enough). Then open a VC++/Platform SDK build environment console and type nmake to stard the building process. After it’s done nmake test to test it and type nmake install to build and install all Perl libraries and the Perl interpreter into the install path you specified in the Makefile.

The overall information on how to embed a Perl interpreter into your C/C++ application is available in the perlembed document. However, I recommend you to read perlgut and perlcall before going to perlembed. Also perlapi may be useful for a reference. perlgut explains how the C implementation of Perl represents Perl’s data types and subroutines in C. perlcall explains how to call Perl subroutines from C. If you still have questions after reading these documents, you can always grep the Perl source code for functions, function macros and their notes.

For an actual embedding code sample, mod_perl is probably the most complete. If you read mod_perl.c in the src\modules\perl directory of mod_perl 2, you see the modperl_response_handler_cgi function is the main functon that executes a Perl CGI script. The basic flow of this function is

1. Setup environmental variables to pass to Perl
2. Override Perl’s standard input and standard output
3. Process an HTTP request to a Perl CGI
4. Restore everything back

Basically it’s in line with what I wrote as what I wanted to do earlier in this article. Apache does most of these things by directly manipulating Perl by a C code. But I don’t need as much security as the Apache module does. Right now the DICE is a server to host its owner’s code and nothing else and don’t have to watch naughty users. Also I don’t intend to run multiple interpreters for now as the context switching method by PERL_SET_CONTEXT in the current Perl implementation sucks. It’s based on heavy use of macro and it forces me to use some nasty macro hacks. Even with a single interpreter, it’s not a fun to integrate a C++ code that has a Perl interpreter in a larger project. The Perl source code predetermines the name of the interpreter object as “my_perl” and predefined macros can’t take other names, so you have to assign your a Perl interpreter pointer to a local variable PerlInterpreter* my_perl everytime you want to do something with it. Also the perl header file redefines many symbols for its own API, which means if your C++ class has a member function named write it conflicts with Perl. So my advice is, don’t include perl.h in a header file that is included by many other files in your project. Include it at the beginning of a .cpp source code file and put all Perl-related things in it. But how can you define a class that has a pointer to a Perl interpreter as its property? You can put a char* or something equivalent in the place of the pointer to an interpreter in your class declaration and cast it to PerlInterpreter* everytime you use it in the .cpp source file.

I decided to offload most of the sandbox work to Perl to keep the C++ part simple. The basic design is like this:

1. The Perl interpreter in the DICE loads a setup Perl script which does STDIN/STDOUT hooks and has other necessary utilities for sandboxing a Perl script
2. Whenever a CGI script is called, if it’s the first time the Perl interpreter evaluates it as a subroutine in a unique package by using eval in Perl and caches the compiled code. If it is an already compiled code in the cache, it just returns a reference to it.
3. The Perl interpreter executes the compiled Perl code by dereferencing the subroutine reference and the C++ part gets the output by reading a Perl variable that has all Perl output. The C++ part is protected and synchronized by a critical section and you don’t have to worry about this Perl variable is destroyed by others (though there’s certain performance penalty)

Let’s take a look at the Perl setup script (EmbeddedPerlSandbox.pl). This script is the one actually used in the DICE but a newer version may be included in actual package, to see how it works you should download the DICE and run its web server by yourself. First, it defines the package EmbeddedPerlSandboxOut that is used to intercept and overrides the standard out (STDOUT in Perl). The required Perl version is specified as 5.8.0, but I’m not sure if this script works for a lower version of Perl or not.

# EmbeddedPerlSandbox for DICE
# (c) RyuK 2006 All Rights Reserved
#
# klassphere[at.mark]gmail.com
# http://aiueo.da.ru/
# http://zzz.zggg.com/
#
# This file is not redistributable.
#

use 5.8.0;

package EmbeddedPerlSandboxOut;

sub TIEHANDLE
{
	my $classname = shift;
	my $buffer = "";
	bless \$buffer, $classname;
}

sub PRINT
{
	my $buffer = shift;
	my $s = shift;
	$$buffer .= $s;
}

sub PRINTF
{
	my $buffer = shift;
	my $s = shift;
	$$buffer .= sprintf($s, @_);
}

sub WRITE
{
	my ($buffer, $data, $len, $offset) = @_;

	if (!defined($len))
	{
		$len = length($data);
	}

	if (!defined($offset))
	{
		$offset = 0;
	}

	$$buffer .= substr($data, $offset, $len);
}

sub READLINE
{
	my $buffer = shift;
	return $$buffer;
}

sub BINMODE
{
	# does nothing
	return 1;
}

sub CLOSE
{
	my $buffer = shift;
	undef $buffer;
}

sub DESTROY
{
	my $buffer = shift;
	undef $buffer;
}
	  

When a Perl script is executed, this class is associated with STDOUT by the tie Perl function which calls the TIEHANDLE subroutine. It creates an object which is just a scalar value that works as a buffer to hold the content of the standard output. After that, if print tries to write something onto STDOUT the PRINT function in this class is called. READLINE is called by <>.

The next section defines EmbeddedPerlSandboxIn to override the standard input in the same way.

package EmbeddedPerlSandboxIn;

sub TIEHANDLE
{
	my $classname = shift;
	my $buffer = shift;
	bless \$buffer, $classname;
}

sub READLINE
{
	my $buffer = shift;

	# substr EXPR,OFFSET,LENGTH,REPLACEMENT
	return (length($$buffer) ? substr(
		$$buffer,
		0,
		(defined($/) ? index($$buffer, "$/"): length($$buffer) - 1) + 1,
		""
	)
		: undef);
}

sub READ
{
	my ($buffer, $len, $offset) = ($_[0], $_[2], $_[3]);

	if (!defined($offset))
	{
		$offset = 0;
	}

	if ($len > length($$buffer))
	{
		$len = length($$buffer);
	}

	# You can use the substr() function as an lvalue
	substr($_[1], $offset, $len) = substr($$buffer, 0, $len, "");

	return $len;
}

sub GETC
{
	my $buffer = shift;
	return (length($$buffer) ? substr(
		$$buffer,
		0,
		1,
		""
	)
		: undef);
}

sub BINMODE
{
	# does nothing
	return 1;
}

sub CLOSE
{
	my $buffer = shift;
	undef $buffer;
}

sub DESTROY
{
	my $buffer = shift;
	undef $buffer;
}

The TIEHANDLE function receives a scalar value as the content of the standard input when it’s associated with STDIN with tie and holds it. For READ, the second parameter ($_[1]) is the reference (not a “reference” in the Perl, but in the broader computer science terminology) to the receiving variable as Perl subroutines are call-by-reference.

From here on the main class EmbeddedPerlSandbox is defined.

package EmbeddedPerlSandbox;

$SANDBOX_OUTPUT = "";

%CODE_STORE = {};

BEGIN
{
	push @INC, Win32::GetCwd() . "\\perl_lib";

	*CORE::GLOBAL::exit = \&EmbeddedPerlSandbox::exit;
	*CORE::GLOBAL::flock = \&EmbeddedPerlSandbox::flock;
}

$sandbox_output is the global package variable that holds the standard output. The C++ part retrieves the output of a Perl user script by referencing this variable later. %CODE_STORE is a cache that holds compiled Perl scripts with its unique package name as a key. The BEGIN block evaluated when this setup script is loaded by the C++ code. @INC is the array of library paths it adds the “perl_lib” directory under the current directory to it. To obtain the current directory it uses Win32::GetCwd which is a function in a builtin class in the Windows version of Perl without loading the Cwd module. Also it overrides the exit and the flock builtin functions by assigning subroutine references to their type globs. The exit function ends the Perl interpreter by calling exit() in C, which means not only the Perl interpreter but also the entire application just ends if it’s called. Such a situation must be avoided for an obvious reason. The flock function should work in theory even in the Windows version, but when I tested it it stopped execution there by an unknown reason. As I explained already the C++ section is synchronized by a critical section, therefore the Perl section is synchronized too. I decided to trap flock and substitute it with a functon that does nothing.

The next subroutine is necessary to make a user script behave like a Perl CGI. If a persistent interpreter just executes the same compiled code 2 times, all global variables persist in the second execution. For example,

if (!defined($var))
{
	$var = 1;
}

print "$var\n";

$var++;

if this code is executed repeatedly in a persistent interpreter the displayed number continues to increase. This behavior is OK for a Java servlet and other persistent web applications, but not desirable for emulating a Perl CGI. To stop it, it has to clear global package variables previously defined in the package before executing a user code. This cleanupSymbolTable subroutine does it by scanning the symbol table hash (also called “stash” in the Perl jargon) of the user code package. In the Perl language, the reflection system is very easily available in the form of the symbol table and it’s almost too exposed if you ask me. Though I don’t like it as it can be a source of nasty Perl hacks, the reflection itself is certainly a necessary feature when creating a plugin system or a self-contained virtual world (Matrix, anyone?).

sub cleanupSymbolTable
{
	my $id = shift;

	while (my ($name, $glob_entry) = each %{$id . "::"})
	{
		local *v = $glob_entry;
		if (defined($v))
		{
			undef $v;
		}

		if (defined(@v))
		{
			undef @v;
		}

		if (defined(%v))
		{
			undef %v;
		}
	}
}

$id is the name of the user code package. It enumerates all symbols in that package and receives a typeglob for its symbol (See the “Symbol Tables” in perlmod). Then if there is a variable (scalar/array/hash) defined within that typeglob it’s undefined. Note that it tests all value types as there may be a typeglob that has variables of all the 3 types defined.

The next subroutine compiles a user code as the name suggests.

sub compile
{
	my ($id, $content, $current_dir) = @_;

	if (!length($content))
	{
		return $CODE_STORE{$id};
	}

	local $SIG{__WARN__} = \&warn;

	# the part undefining global variables must come before $content,
	# otherwise $content can't contain 'use strict'
	my $sandbox =<< "SBOX";
package $id;
sub __wrapper
{
	EmbeddedPerlSandbox::cleanupSymbolTable("$id");
	\@ARGV = \@_;
	$content ;
}
SBOX

	my @tmp = @INC;
	push @INC, $current_dir;
	eval $sandbox;
	@INC = @tmp;

	if ($@)
	{
		my $e = $@;
		if ($e !~ /via package/ &amp;&amp; $e =~ /line (\d+)/)
		{
			my $n = $1;
			my $m = $n - 6;
			$e =~ s/line $n/line $m/g;
		}

		$e =~ s/\(eval \d+\) //g;

		$SANDBOX_OUTPUT = "Content-Type: text/plain\n\nPerl Compilation Error: " . $e . "\n";
	}

	return $CODE_STORE{$id} = *{$id . "::__wrapper"}{CODE}; # CODE reference - see perlsub
}

$id is the unique package name for this script. It has to be a unique name not to conflict with other scripts compiled later in this interpreter instance. $content is the actual Perl CGI script content. If it’s empty it just returns the already compiled code for this unique package name. In the actual implementation in the DICE the C++ part checks the file time of a script to see if it has to be reloaded or not, but you can implement it in Perl too if you want. Though it may not be necessary the __WARN__ signal is trapped with the warn subroutine to suppress a potential interrupt. The $sandbox here document is the code that wraps the usercode into a unique package that has only a wrapper subroutine code in it. The user code is embedded in this wrapper function and placed after the symbol table cleaner function that is explained above. In this “here document” you have to add “\” to a variable you don’t want to be evaluated at the time of the definition of $sandbox. $current_dir has the current directory for this script. Since the use function in Perl is evaluated in the compile time you have to add the current directory particular to this script to @INC here and restores after the evaluation of the user code by eval. If the script has an error, $@ has the error information. When the evaluation is done, the reference to the compiled code can be obtained by getting the “CODE” entry in the subroutine’s typeglob.

These subroutines are just utility functions. clearCodeStore is a function that clears the code store as the name suggests. When you run a persistent interpreter you can call this function to reclaim unused resources. addRuntimeError is an error reporting function in executing a user code.

sub clearCodeStore
{
	%CODE_STORE = ();
}

sub addRuntimeError
{
	my $e = shift;
	if (length($SANDBOX_OUTPUT))
	{
		if ($SANDBOX_OUTPUT !~ /Perl Runtime Error/)
		{
			$SANDBOX_OUTPUT .= "Perl Runtime Error: " . $e . "\n";
		}
	}
	else
	{
		$SANDBOX_OUTPUT = "Content-Type: text/plain\n\nPerl Runtime Error: " . $e . "\n";
	}
}
	  

The execute subroutine executes a compiled user code.

sub execute
{
	my ($id, $compiled, $stdin, $env, $current_dir, $clear_codestore) = @_;

	local $SIG{__WARN__} = \&warn;

	if (!chdir($current_dir))
	{
		addRuntimeError("chdir: " . $current_dir);
		return;
	}

	my $oh = tie(*STDOUT, "EmbeddedPerlSandboxOut");
	my $ih = tie(*STDIN, "EmbeddedPerlSandboxIn", $stdin);

	my %env_vars = ();
	foreach my $kv (split(/\n/, $env))
	{
		if ($kv =~ /([^=]+)=(.+)/)
		{
			$env_vars{$1} = $2;
		}
	}

	%main::ENV = %env_vars;

	my @tmp = @INC;
	push @INC, $current_dir;
	eval {$compiled->();}; # you need this semicolon...
	@INC = @tmp;

	if ($@)
	{
		unless ($@ =~ /EmbeddedPerlSandbox::exit/)
		{
			my $e = $@;
			if ($e !~ /via package/ && $e =~ /line (\d+)/)
			{
				my $n = $1;
				my $m = $n - 6;
				$e =~ s/line $n/line $m/g;
			}

			$e =~ s/\(eval \d+\) //g;

			addRuntimeError($e);
		}
	}

	undef $ih;
	untie *STDIN;

	if (!$@)
	{
		$SANDBOX_OUTPUT = <STDOUT>;
	}

	undef $oh;
	untie *STDOUT;

	if ($clear_codestore)
	{
		clearCodeStore();
	}
}
	  

First it changes the current directory to the directory of the user script by calling chdir. I tried to move the current directory in the C++ side by the SetCurrentDirectory Windows API and the PerlDir_chdir Perl C API, however for some reason the Perl side was not affected by them. Then it overrides the standard input and the standard output by using tie and the EmbeddedPerlSandboxIn and EmbeddedPerlSandboxOut classes as explained already. Unfortunately it seems not to be able to override the implicit STDIN expression in <> so it’s required to specify in a user script. $stdin passes the content of the standard input which is the input by a web user in the case of a web server. $env has the content of environmental variables for CGI. As it’s passed in a scalar value delimited by ‘\n’ and ‘=’ it’s parsed and stored in the %main::ENV hash to which a CGI code refers. $compiled is the code reference and it’s invoked by $compiled->() subroutine expression in the eval block. After it’s done the content of the standard output is saved in $SANDBOX_OUTPUT then the standard input and the standard output are restored.

The last section is for the hook functions for these dangerous global functions.

sub exit
{
	$SANDBOX_OUTPUT = <STDOUT>;
	die("EmbeddedPerlSandbox::exit");
}

sub flock
{
	# does nothing
	return 1;
}

sub warn
{
	die("Perl Warning: " . $_[0] . "\n");
}

1;

The exit function saves the content of the standard output in $SANDBOX_OUTPUT and stops execution by the die function. As the die function can be trapped by eval, the exit function can be emulated this way. flock does nothing and warn is almost the same with exit. A Perl module has to return 1 at the end.

That’s all for the Perl side (EmbeddedPerlSandbox.pl). Let’s check out the C++ sample code that drives a Perl interpreter. To build it you have to add the Perl source code directory to the header include directories of your project and have to add the perl59.lib static library to your linker input. The resultant executable requires perl59.dll to run.

#include <string>
#include <cstdio>

using namespace std;

#include <EXTERN.h>
#include <perl.h>

EXTERN_C void xs_init (pTHX);
EXTERN_C void boot_DynaLoader (pTHX_ CV* cv);

EXTERN_C void xs_init(pTHX)
{
	char *file = __FILE__;
	dXSUB_SYS;

	/* DynaLoader is a special case */
	newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
}
	  

The xs_init glue code is just what you get by the ExtUtils::Embed tool (See “Using Perl modules, which themselves use C libraries, from your C program” in perlembed).

int _tmain(int argc, _TCHAR* argv[])
{
	int argc_perl = 0;
	char* embedding[] = {"", "E:\\program\\src\\perlembedtest2\\EmbeddedPerlSandbox.pl"};

	PERL_SYS_INIT(&argc_perl, (char***)embedding);

	PerlInterpreter* my_perl = perl_alloc();
	perl_construct(my_perl);

	PL_exit_flags |= PERL_EXIT_DESTRUCT_END;

	perl_parse(my_perl, xs_init, 2, embedding, NULL);
	perl_run(my_perl);

The embedding char pointer array is the argument list passed to the Perl interpreter. In the second parameter it set the path of the EmbeddedPerlSandbox.pl. Then it creates a Perl interpreter and runs it.

The next part calls the EmbeddedPerlSandbox::compile subroutine in the Perl side to compile a Perl script. The unique package name for this script is in id and the script content is in content for the sake of this sample code.

	const char* id = "test";
	string content(
		"my $data = ''; read(STDIN, $data, 2); print \"$data\n\"; print getc(STDIN) . \"\n\";"
		"while (<STDIN>) {print ($i++ . ': ' . $_);}"
		"open FH, '>log.txt';print FH 'test'; close(FH);"
	);

	dSP;

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(sv_2mortal(newSVpv(id, 0)));
	// don't use 0 as the second argument since Perl uses strlen for 0
	XPUSHs(sv_2mortal(newSVpv(content.c_str(), content.size())));

	PUTBACK;

	call_pv("EmbeddedPerlSandbox::compile", G_EVAL);

	SPAGAIN;

	SV* sandbox = 0;
	if (SvTRUE(ERRSV))
	{
		POPs; // see perlcall for G_EVAL

		printf("ERRSV\n");
		printf(SvPVX(ERRSV));
		return 0;
	}
	else
	{
		sandbox = newSVsv(POPs);
	}

	PUTBACK;
	FREETMPS;
	LEAVE;
	  

It pushs two strings id and content in a locally copied Perl stack. The newSVpv function creates a new Perl scalar value for a string (pv: pointer value). If you set 0 for the second parameter it uses C strlen() to calculate the length of the string pointer by a char* pointer. Since a Perl script can contain a null character (though unlikely) this sample gives the length of the script explicitly by using C++ basic_string for content. When the parameters are ready, it puts the stack back to Perl by the PUTBACK macro and calls the subroutine by call_pv. See the details for Perl stack manipulation in perlcall. If call_pv is successful it pops the return value from the stack and assigns it to a new Perl scalar value sandbox that holds a compiled Perl code reference.

In this section it actually execute the compiled Perl code. in is a C++ basic_string object that has an emulated standard input. env is supposed to have environmental variables, but this sample code omits it. new_dir is the current directory for this Perl code. As the sample Perl script fiddles with a file, it is created in this directory. Though the EmbeddedPerlSandbox::execute in Perl takes 6 parameters, the 6th parameter is omitted again for this sample. It calls EmbeddedPerlSandbox::execute with 5 arguments with no return value expected (G_VOID).

	string in("abcHello world\nI think\nTherefore I am\n");

	string env;

	string new_dir("E:\\program\\src\\perlembedtest2\\Debug");

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);

	XPUSHs(sv_2mortal(newSVpv(id, 0)));
	XPUSHs(sandbox);
	XPUSHs(sv_2mortal(newSVpv(in.c_str(), in.size())));
	XPUSHs(sv_2mortal(newSVpv(env.c_str(), env.size())));
	XPUSHs(sv_2mortal(newSVpv(new_dir.c_str(), new_dir.size())));

	PUTBACK;

	call_pv("EmbeddedPerlSandbox::execute", G_VOID);

	SPAGAIN;

	STRLEN n_a;
	const char* output = SvPV(get_sv("EmbeddedPerlSandbox::SANDBOX_OUTPUT", FALSE), n_a);
	int len = (int)n_a;
	printf("returned: %d bytes\n", len);

	// it can contain a null character
	for (int i = 0; i < len; ++i)
	{
		if (i == 0)
			printf("[%c", output[i]);
		else
			printf("%c", output[i]);
	}
	if (len != 0)
		printf("]\n");

	PUTBACK;
	FREETMPS;
	LEAVE;
	  	  

After EmbeddedPerlSandbox::execute is executed, it retrieves the Perl scalar value of EmbeddedPerlSandbox::SANDBOX_OUTPUT by calling get_sv and converting it into a char* by SvPV. output is the string that holds the standard output of the Perl script.

	PL_perl_destruct_level = 0;

	perl_destruct(my_perl);
	perl_free(my_perl);
	PERL_SYS_TERM();

	return 0;
}

When the work is done it frees the Perl interpreter. It’s the end of the C++ sample code. This works flawlessly including using Perl modules, and I implemented it in the DICE with some additional attention for a persistent interpreter.

The winner for this round is Perl. But it’s not free from a problem, for example its header file redefines common API names with C macros and are not include-friendly. Also it’s not designed to host multiple interpreters from the beginning and plagued with excessive C macro use. I hope these issues can be solved in Perl 6 with a new VM (Parrot), just like Ruby’s new VM (YARV) plans. If Perl 6 becomes the mainstream this article has to be rewritten since the embedding method should be fairly different from the current one, though I somehow doubt the likelihood that Perl 6 becomes too popular. One thing for sure is I’m satisfied with the relative robustness of Perl for now.

そもそもHTMLやHTTPというwebの標準がここまで貧しい設計でなければ特定ブラウザで動作するしないといった些細な事柄につい て無意味な議論を重ねる必要は生じなかったはずだ。HTMLベース技術の大半がプラットフォーム間の互換性の維持に労力を費やしている状況はある観点から 見れば極めて寒々しい。例えばblogのデファクト標準であるトラックバックという設備は技術的なメリットではなくそれが標準として流布しているという政 治的状況によって生かされているのである。その現状を一旦忘れ、例えば全てのwebページが別個のソフトウェアアプリケーションだったらどうだろうか。 HTMLがチューリング完全なプログラミング言語で、全てのwebページが自己が利用できるサーバまたはクライアント上の資源を理解しつつ位置透過的・自 律的にサービスを提供していたら?

マイクロソフトのActiveX(現在は.NET)やSunのJavaはネットワーク化されたソフトウェアコンポーネントの世界の端緒 を開くことを期待された技術だった。ところが様々な政治的要因によりそれらの技術がwebを席巻することは最早あり得ない状況となっている。ブラウザの備 えるソフトウェアスタックのサポートはECMAScriptとW3C DOM/CSSのサポートに留まり、webページそのものはXMLに見られるようにますますデータ化の傾向を強めるかに見える。その傾向と一線を画するの がActiveXコンテナに収まってIE上で動作するAdobe Flashである。 2001年にリリースされたWindows XPをインストールして最初に表示されるプロダクトツアーはMacromedia Flashで駆動されていた。Flashオブジェクトを作成するためのActionScriptは現在3.0までバージョンアップし、Java並のプログ ラマビリティを備える。実装のパフォーマンスもJavaアプレットと比較して高く、webアプリケーションのユーザビリティを阻害するストレスがほとんど ない。セキュリティもこれまで見る限り申し分ない(ActiveXコンポーネントと違ってデコンパイルが容易な点を除けば)。Flex 2 SDKは無料化され、誰でも無料でFlashアプリケーションを開発できる。先日のMozilla FoundationへのActionScript VM寄贈も記憶に新しい。その上サーバサイドActionScriptがMacromedia製品以外にも拡がることにでもなれば、Flashがwebの 覇者となる未来も決して遠くないだろう。あるいは現在既にそうなっているかもしれない。

しかしFlashとてwebの基幹技術のHTMLと融合したわけではなく、両者の間の溝は厳然として存在する。webブラウザのプラグ インとして実装されているFlashその他の技術は、HTMLベースの技術と異なり、webブラウザのUI上では異物感を感じさせる。ブラウザ自身の提供 するUIウィジェットの中でプラグインの表示領域のみが浮いて見えることを始め、表示フォントの違い、右クリック時のコンテクストメニューの違い、 Javaアプレットの場合は起動自体の遅さなど、枚挙にいとまがない。そもそもコンテンツホルダーの要求でテクストのコピーが禁止になっているなど、風通 しの悪さも感じさせられることがあるかもしれない。これも過渡期の現象で遠い将来にはFlashが全てのUIを覆い尽くすことになるのだろうか。 Flashがプロプライエタリな技術に留まる限りこの展望は全く荒唐無稽といえる。AJAXの定義をJavaScriptによるwebブラウザのUI操作 全般に拡張する動きに見られるように、ECMAScriptのスタックがツールも含めて十分に成長してくれば、webのUIにダイナミックで柔軟なプログ ラマビリティを与える道具としてのFlashは存在意義を失ってしまう。そして、歴史をひもとけばFlashのプログラミング言語 ActionScript自体がECMAScriptから派生している(ただし2.0でクラスライブラリ階層や強い型付けが導入されたため現在の ActionScriptはプロトタイプベースではない)。つまり、現時点では、Flashを擁するAdobe社が、Microsoftとその他の対立に 乗じていわば「漁夫の利」を得た状況となっているわけだ。そして、この不安定な均衡に満足しないAdobeは既に先手を打ち、将来にわたりFlashの支 配を保証するために、オープンなTamarin Projectに打って出た。

この現状を認識した上で冒頭のサーバプッシュの話に戻ると、かつてのサーバプッシュに現在最も近い技術はweb上のストリーミング映像 サイトで目にすることが出来る。ただし、これらは実際はサーバプッシュではなくクライアントプルでプロトコル上実装されていることもあるのでストリーミン グ即サーバプッシュを意味するわけではない。ここでもプラットフォーム中立性やコンテンツホルダの要請により、QuicktimeやWindows Media Playerオブジェクトのwebページへの埋め込みではなく、FlashによるFlash Videoフォーマットのストリーミングが一般的になりつつある。HTTPではない(あるいはHTTPトンネリングされた)プロトコルを喋るストリーミン グサーバとwebブラウザの間をFlashが取り持っている。webブラウザがそれ自身でリッチなアニメーションや動画を処理する標準的方式が存在しない 以上、先に述べたUI上でのFlashの異物感もやむを得ないと言えるし、このストリーミングは基本的にFlash内で完結している。しかし、イメージ/ バイナリベースではない、テクストベースのサーバプッシュについてはどうか。

DICEのwebサーバ 部分にIRCチャンネルのwebインターフェイス機能を画面遷移無しで持たせようと考えたとき、真っ先に頭をよぎったのはNetscapeブラウザが持っ ていたサーバプッシュ機能だった。もちろん、Internet Explorerでは対応していないこの方式は使用することはできない。また、DICEは 一つのサーバでIRCインターフェイスとwebインターフェイスの両方を別々のポートから同時に提供するのでJavaアプレットやFlashのセキュリ ティサンドボックスの制限をクリアできるとはいえ、それらプラグインでIRCクライアントのUIを作った場合のUIの異物感、不統一感は避けたい。逆に、 HTML寄りの方法としてAJAXを使う場合、新しいメッセージがチャンネルに存在していないか調べるためにサーバに対し一定時間毎に XMLHTTPRequestで接続を張ってテストするというポーリングを行わなければならない。これはスマートではないし、サーバへの負荷が高い。 AJAXの最悪の使用法だ。

あるいは、サーバプッシュを真似る古典的な手法として、HTTPの接続を切らずに隠しIFRAMEやXMLHTTPRequestによ る接続先にサーバからJavaScriptの文を一つ一つ送らせ、フレームやXMLHttpRequestのプロパティといったローカル受信バッファへの ポーリングを一定時間毎に行うことにより、サーバ自体へのポーリングを回避しつつ動的なページの更新をエミュレートするというものがある。AJAXに飽き 足らないユーザの中にはこの手法をCometあるいはHTTPストリーミングなどと呼んでAJAXのパターンに含めようという動きもあり、例えばPushletは それを系統的にまとめ上げたツールキットである。しかしこの方法はいわゆるハックの部類に属し、ブラウザの読み込み表示が表示されたままになるという問題 の他、クライアント側のタイムアウト時間、バッファリングや同時接続数制限といった仕様に依存する。実装上も、CGIなどのwebアプリケーションとして 長時間スレッドをsleepさせるようなものはパフォーマンスの観点から論外である上に、DICE自体に実装するにも煩雑すぎる。

IRCチャンネルにwebインターフェイスを設ける際の注意点として、上記のようなクライアントやサーバ側の仕様上の問題に加え、IRCチャンネルのセキュリティの問題がある。従来はDICEの webインターフェイスからIRCチャンネルへ発言を投稿するには、サーバがJavaScriptとスタイルシートで文字列(機械的な読み取りが困難なよ うにノイズを加えてある)を描き、投稿者にそれを一々読ませて投稿時に記入させ、HTTPのPOSTで投稿させていた。故意の連続投稿やスパムを未然に防 止するためである。しかしweb掲示板ならともかくリアルタイム性が売りのIRCにこの形式はそぐわない。HTTPストリーミングと組み合わせた場合には 輪をかけて非効率である。当然実装も複雑になる。IRC側ではプロクシサーバのチェックまで行っているにも関わらず、web側のユーザの参加資格には何の 制約もないのも問題だ。また、IRCチャンネル内でwebのユーザをアクセス禁止にすることも容易ではない。

そこで、Flashをソケット通信のバックエンドのみに用いてブラウザをIRCサービスへ直接接続させ、ユーザインターフェイスは JavaScriptによるDOM操作で構築することを考えた。ページに不可視のFlashオブジェクトを埋め込み、FlashはソケットでIRCサービ スのポートへ接続し、通常のIRCクライアント同様に振る舞う。ただしFlashは出来る限りネットワークプロクシの役割に留め、IRCクライアントとし てのプログラミングはJavaScript側で行う。この方法ならばプラットフォーム間の差異を最小に留めつつIRCチャンネルのwebインターフェイス を提供でき、セキュリティや実装上のオーバーヘッドも低い。テクストベースのwebインターフェイスにFlashプラグインを接ぎ木することによるUI上 の拒絶反応も当然無い。サーバにIRCクライアントとして接続する以前に取得する必要のある動的な情報(例えばIRCのポート)のみAJAXで取得すれば よい。UIはスクリプト言語のJavaScriptで制御されているのでFlashと異なりコンパイル無しでサーバ管理者が自由に編集でき、アプリケー ションの配布には都合がよいという利点もある。

早速コードを見てみよう。以下、DICEに 添付しているIRCクライアントwebアプリケーションのAdobe Flash 9向けFlashオブジェクトProxyIRCのActionScript 3.0ソースコードProxyIRC.asを解説していく。最初IRCProxyという名称で作成していたが何故かエラーが発生したのでProxyIRC という名称に変更した。ビルドには、最近無償配布が開始されたコマンドライン開発ツールAdobe Flex SDKを使用する。 コンパイル時のコマンドラインオプションは mxmlc -default-size 1 1 -default-frame-rate=30 -default-background-color=0xFFFFFF ProxyIRC.as とでもすればよいだろう。

package
{
	import flash.display.*;
	import flash.external.*;
	import flash.net.*;
	import flash.events.*;
	import flash.utils.*;

	// class name may conflict with the JavaScript engine for IE
	// when ExternalInterface is in use, be careful to test different names
	public class ProxyIRC extends Sprite
	{
		private var socket:Socket;
		private var receivedMessageBuffer:String;
		private var isJIS:Boolean;

		public function ProxyIRC()
		{
			socket = new Socket();
			configureListeners(socket);
			isJIS = false;

			receivedMessageBuffer = new String();

			// It seems the JS engine for IE has a serious problem with the functionName argument.
			// Don't use an existing JS function name.
			ExternalInterface.addCallback("testLoopback", loopbackToJavaScript);
			ExternalInterface.addCallback("connectIRC", connect);
			ExternalInterface.addCallback("sendIRC", send);
			ExternalInterface.addCallback("setJIS", setCharacterEncoding);
			ExternalInterface.addCallback("quitIRC", disconnect);
		}
	 

ActionScript 3.0は前述のようにJavaScript風からJava風に進化したような言語なのでJavaを知っているならばほとんど言語仕様を見なくてもライブラ リリファレンスから必要な道具を拾うだけで直ちにプログラミングを開始できるだろう。型が変数名の後に付くとか、XMLをソースコード内に直接記入できる とかというような程度の違いしかない。このクラスProxyIRCはFlashのディスプレイリストの最も単純な基本クラスSpriteを継承し、3つのプロパティを保持している。socketは文字通り接続対象に接続するためのTCP/IPソケットであり、receivedMessageBufferは送られてきたデータを解析するために溜めておくバッファである。isJISは、 日本語で行われるIRCのエンコーディングは通常JISのため、文字列は全てutf-8で内部的に扱われるJavaScriptとやりとりするときに日本 語向けの相互変換を行うか否かのユーザ設定を保持するためのフラグである。コンストラクタ内での一連の ExternalInterface.addCallbackの呼び出しは、JavaScriptの関数名とFlashのメソッドとの関連付けを登録し、 JavaScriptからFlashの関数名を呼び出せるようにするための準備である。

		public function loopbackToJavaScript():void
		{
			ExternalInterface.call("loopbackFromFlash");
		}

		public function setCharacterEncoding(jis:Boolean):void
		{
			isJIS = jis;
		}

		public function connect(host:String, port:uint):void
		{
			if (socket.connected)
			{
				socket.writeUTFBytes("QUIT\n");
				socket.flush();
				socket.close();
			}

			socket.connect(host, port);
		}

		public function disconnect():void
		{
			if (!socket.connected)
				return;

			socket.writeUTFBytes("QUIT\n");
			socket.flush();
			socket.close();
		}

loopbackToJavaScriptはFlashが正常に動作しているかJavaScript側から調べるためのメソッドである。JavaScript側から呼び出されると逆にJavaScript側のloopbackFromFlash関数を実行する。connectは サーバへの接続を実行するための関数だが、IRCクライアントのUIの実装上、接続中には接続開始のボタンが切断ボタンになっているので、接続中に呼び出 されると接続を直ちに切断するようにしてある。この部分はJavaScriptのUIのことを考慮せず分離すべきだったかも知れない。disconnectメソッドは単純にサーバから切断するためのメソッドである。ちなみにIRCはテクストベースのプロトコルで一つ一つのメッセージは’\n’で区切られる。QUITは最も単純なメッセージである。プロトコルの詳細はRFC 2812を参照して頂きたい。

	  	private function configureListeners(dispatcher:IEventDispatcher):void
		{
			dispatcher.addEventListener(Event.CLOSE, closeHandler);
			dispatcher.addEventListener(Event.CONNECT, connectHandler);
			dispatcher.addEventListener(ProgressEvent.SOCKET_DATA, dataHandler);
			dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
			dispatcher.addEventListener(ProgressEvent.PROGRESS, progressHandler);
			dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
		}

		public function send(utf8string:String):void
		{
			if (isJIS)
			{
				var b:ByteArray = new ByteArray();
				b.writeMultiByte(utf8string + "\n", "iso-2022-jp");
				socket.writeBytes(b, b.bytesAvailable);
			}
			else
				socket.writeUTFBytes(utf8string + "\n");
			socket.flush();
		}

		private function closeHandler(event:Event):void
		{
			ExternalInterface.call("onClose");
		}

		private function connectHandler(event:Event):void
		{
			ExternalInterface.call("onConnect");
		}

configureListenersメソッドは、引数で指定されたオブジェクトに起こったイベントを監視するためのイベントリスナをまとめて登録するための初期化メソッドで、既に見たようにProxyIRCのコンストラクタで呼ばれる。引数はソケットオブジェクトなので、ソケットが切断される、ソケットがデータを受信する等のイベントに対してそれぞれの処理メソッドの参照を関連付けている。sendはサーバに対して文字列を送信するためのメソッドで、JavaScript側からutf-8で送られてきた文字列を、JISエンコーディングが有効になっている場合はByteArrayクラスのwriteMultibyteメソッドを利用してJIS(iso-2022-jp)エンコーディングに変換してから送信する。それが必要ない場合はそのままutf-8文字列として送信している。closeHandler、connectHandlerはJavaScript側にソケットの切断・接続を通知するための処理メソッドである。

		private function dataHandler(event:ProgressEvent):void
		{
			var buffer:String = new String();
			if (isJIS)
				buffer = socket.readMultiByte(event.bytesLoaded, "iso-2022-jp");
			else
				buffer = socket.readUTFBytes(event.bytesLoaded);

			var c:String = new String();
			for (var i:uint = 0; i < buffer.length; ++i)
			{
				c = buffer.charAt(i);
				if (c == "\n" || c == "\r")
				{
					if (receivedMessageBuffer.length != 0)
					{
						if (receivedMessageBuffer.length >= 4
							&amp;&amp; receivedMessageBuffer.substring(0, 4).toUpperCase().localeCompare("PING") == 0)
							send("PONG");
						else
							ExternalInterface.call("output", receivedMessageBuffer);
					}
					receivedMessageBuffer = "";
				}
				else
					receivedMessageBuffer += c;
			}
		}

		private function progressHandler(event:ProgressEvent):void
		{
			//  trace("progressHandler loaded:" + event.bytesLoaded + " total: " + event.bytesTotal);
		}

		private function ioErrorHandler(event:IOErrorEvent):void
		{
			ExternalInterface.call("reportError", "I/O Error: " + event);
		}

     		private function securityErrorHandler(event:SecurityErrorEvent):void
		{
			ExternalInterface.call("reportError", "Security Error: " + event);
		}
	}
}
		 

dataHandlerメソッドはやや複雑だが、サーバからデータを受信したときの処理を記述したメソッド である。JISエンコーディングが有効なときはJISとしてソケットからバッファへ読み込み、そうでなければutf-8文字列として読み込む。ループ処理 はバッファから個々のIRCメッセージを切り出すためのもので、メッセージ区切りの改行文字を見つけると一つメッセージを受け取ったと判断して JavaScript側の処理関数outputを呼び出している。ただし例外として、PINGというIRCメッセージを受け取ると、JavaScript側に通知せずPONGと いうメッセージを送り返す。これはIRCの接続維持メカニズムで、一定時間活動がないと回線が接続されているかどうかのポーリングが行われるというもので ある。JavaScript側へ渡すことも出来るが、無駄なオーバーヘッドとなるのでここではFlash側で適切に処理している。ioErrorHandlerはI/Oエラー時の処理メソッド、securityErrorHandlerは Flashのセキュリティ違反が起こったときに呼ばれるメソッドである。Javaアプレットと同じく、Flashのセキュリティサンドボックスはソケット の接続をアプレットがホストされているサーバと同じドメインのサーバに制限しているので、それに違反するとソケットにセキュリティエラーが起こる。ただ し、Flashの場合は、接続先外部サーバがルートにXMLのクロスドメインポリシーファイルを持っていればこの制限は回避できるため、外部サーバに接続 するよう指示された場合Flashはまずクロスドメインポリシーファイルを探索し、見つからないとセキュリティエラーを発生させる。

ソケット通信と日本語JISエンコーディング変換を行うバックエンドのFlashコードは以上である。今度は、JavaScriptで構築された ユーザインターフェイスを見ていこう。基本的な動作イメージは、よくあるGUIのIRCクライアントのように、チャンネルの内容を表示するバッファとチャ ンネルのメンバーを表示するコラムがあり、さらに発言を入力したりするための操作パネルが下部にある。さらにチャンネルやその他のタブ画面の切り替えを行 うために、Windowsのタスクバーのようにタブを列挙したバーが操作パネルの下部に付属している。最初から存在する消去できない特殊なタブとして、ヘ ルプファイル表示タブ(help)、生の通信ログを書き出すためのタブ(raw)、IRCサーバーが発したメッセージを表示するためのタブ (status)、チャンネルリスト表示用タブ(channels)がある。これらの要素を、JavaScriptによるDOM操作で、Internet Explorer 6またはFirefox 2以上を対象としたIRCクライアントwebアプリケーションとして駆動する。

IRCクライアント本体のコードを見る前に、AJAXやDOM関係の簡易ユーティリティメソッドをまとめたJavaScriptファイルdice.jsをまず提示しておく。IRCクライアントの方ではここに登場するメソッドを使用している。

var isMozilla = navigator.userAgent.indexOf('Gecko') != -1;
var isIE = window.ActiveXObject;

function createHttpRequest()
{
	if (isIE)
	{
		try
		{ // CLSID_XMLHTTP
			// v 3.0
			return new ActiveXObject("Msxml2.XMLHTTP");
		}
		catch (e)
		{
			try
			{// v 2.x
				return new ActiveXObject("Microsoft.XMLHTTP");
			}
			catch (e2)
			{
				return null;
			}
		}
	}
	else if (window.XMLHttpRequest) // non-IE
	{
		var hr = new XMLHttpRequest();
		if (isMozilla)
			hr.overrideMimeType('text/xml');
		return hr;
	}
	else
	{
		return null;
	}
}

function getInnerHTML(id)
{
//	if (isIE)
//	{
		return document.getElementById(id).innerHTML;
//	}

/* For old Mozilla compatibility
	var html = "";
	node = document.getElementById(id);
	for (var i = 0; i < node.childNodes.length; ++i)
		html += getOuterHTML(node.childNodes.item(i));

	return html;*/
}

/* For old Mozilla compatibility
function getOuterHTML(node)
{
	var s = "";

	switch (node.nodeType)
	{
		case 1: // ELEMENT_NODE
			s += "<" + node.nodeName;
			for (var i = 0; i < node.attributes.length; ++i)
			{
				if (node.attributes.item(i).nodeValue != null)
				{
					s += " "
					s += node.attributes.item(i).nodeName;
					s += "=\"";
					s += node.attributes.item(i).nodeValue;
					s += "\"";
				}
			}

			if (node.childNodes.length == 0
				&amp;&amp; (node.nodeName == "IMG"
					|| node.nodeName == "HR"
					|| node.nodeName == "BR"
					|| node.nodeName == "INPUT"
			))
				s += ">";
			else
			{
				s += ">";
				s += getInnerHTML(node);
				s += "<" + node.nodeName + ">"
			}
			break;
		case 3:	//TEXT_NODE
			s += node.nodeValue;
			break;
		case 4: // CDATA_SECTION_NODE
			s += "<![CDATA[" + node.nodeValue + "]]>";
			break;
		case 5: // ENTITY_REFERENCE_NODE
			s += "&amp;" + node.nodeName + ";"
			break;
		case 8: // COMMENT_NODE
			s += "<!--" + node.nodeValue + "-->"
			break;
	}

	return s;
}
*/

function replaceElement(id, html)
{
//	if (isIE)
//	{
		document.getElementById(id).innerHTML = html;
//	}
/* For old Mozilla compatibility
	else
	{
		var e = document.createElement('span');
		e.setAttribute('id', 'temp');

		var range = document.createRange();
		range.selectNodeContents(document.body);
		range.collapse(true);
		e.appendChild(range.createContextualFragment(html));

		var outer = document.getElementById(id);
		while (outer.firstChild)
			outer.removeChild(outer.firstChild);
		outer.appendChild(e);
	}*/
}

function appendElement(id, html)
{
//	if (isIE)
//	{
		document.getElementById(id).innerHTML += html;
//	}
/* For old Mozilla compatibility
	else
	{
		var e = document.createElement('span');
		e.setAttribute('id', 'temp');
		var range = document.createRange();
		range.selectNodeContents(document.body);
		range.collapse(true);
		e.appendChild(range.createContextualFragment(html));
		document.getElementById(id).appendChild(e);
	}*/
}

function sendHTTP(data, method, fileName, callback, async)
{
	var hr = createHttpRequest();
	hr.open(method, fileName, async);
	hr.setRequestHeader("If-Modified-Since", "Thu, 01 Jun 1970 00:00:00 GMT");
	hr.onreadystatechange = function()
	{
		if (hr.readyState == 4)
		{
			callback(hr);
		}
	}

	hr.send(data)
}

// replace an element in an HTML document with a text node in an AJAX XML response
// that has the same tag name as the ID of the aforementioned HTML element
function replaceElementByAjaxTagName(hr, tagname)
{
	var nodelist = hr.responseXML.getElementsByTagName(tagname);
	if (nodelist != null)
	{
		var x = nodelist.length;
		for (var i = 0; i < x; ++i)
		{
			var n = nodelist.item(i);
			var nn = n.firstChild;
			// NODE_TEXT == 3 || NODE_CDATA_SECTION == 4
			while (nn != null &amp;&amp; (nn.nodeType == 3 || nn.nodeType == 4))
			{
				replaceElement(tagname, nn.nodeValue);
				nn = nn.nextSibling;
			}
		}
	}
}

function getAjaxTextNodeByTagName(hr, tagname)
{
	var nodelist = hr.responseXML.getElementsByTagName(tagname);
	if (nodelist == null)
		return null;

	return nodelist.item(0).firstChild.nodeValue;

	//return nodelist.item(0).textContent; // IE fails
}

function unixtime2localdate(t)
{
	var d = new Date;
	d.setTime(t * 1000);

	return d.toLocaleString();

	//var h = String(d.getHours());
	//if (h.length == 1)
	//	h = "0" + h;

	//var m = String(d.getMinutes());
	//if (m.length == 1)
	//	m = "0" + h;

	//var s = String(d.getSeconds());
	//if (s.length == 1)
	//	s = "0" + h;

	//return String(d.getYear() % 1900 + 1900) + "/"
	//	+ String(d.getMonth() + 1) + "/"
	//	+ d.getDate() + " "
	//	+ h + ":"
    	//	+ m + ":"
	//	+ s;
}
	  

御覧のように、かなりの部分がコメント化されて消されているのは、MozillaがinnerHTMLをサポートしていなかった時代から使っていた互換性維持のためのコードを省略したことによる。innerHTML自体はあくまで非標準だが、今回はあえて古いブラウザは切り捨てておそらく効率的であろうinnerHTMLを使用するという道を選んだ。

ここから、JavaScriptによるIRCクライアントのコードを含んだHTMLファイルirc_client.htmlを見ていく。

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Web IRC Client for KLassphere DICE</title>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta HTTP-EQUIV="PRAGMA" CONTENT="NO-CACHE">
<meta HTTP-EQUIV="Expires" CONTENT="Mon, 04 Dec 1999 21:29:02 GMT">

<style type="text/css"><!--
td, form, input, button, #tabs
{
	font-size: 12px;
	font-family: Verdana, Geneva, Arial, sans-serif;
}
-->
</style>
</head>
<script language="JavaScript" src="dice.js"></script>
<script language="JavaScript">
<!--
/*

Flash/Javascript IRC Client for KLassphere DICE - (c) RyuK 2006 - 2007 All Rights Reserved

klassphere[at.mark]gmail.com

http://zzz.zggg.com/

http://aiueo.da.ru/

This file is not redistributable.

*/

var flashIsEnabled = false;
var isConnected = false;

var mapChannelBuffer = new Object();
var mapSpecialBuffer = new Object();
var mapPrivateMessageBuffer = new Object();

var helpBuffer = new ChannelBuffer;
var rawBuffer = new ChannelBuffer("(This is the buffer where raw server outputs are dumped in)<br>");
var statusBuffer = new ChannelBuffer("(This is the buffer where current status is logged)<br>");

var channelListHeader = ("Channel List<br><br>Push the button to load the list from the server after a connection is established.<br>Click a channel name in the list to join in.<br>"
	+ "<button onClick=\"loadChannelList();\">Refresh the channel list</button><br><br>");
var channelListBuffer = new ChannelBuffer(channelListHeader);

var myNick = "";
var currentTab = "";
var serverName = "";
		  

まず、グローバル変数の定義から行う。mapChannelBufferは汎用のObjectとして生成さ れるが、実際にはを連想配列として使用され、キーはチャンネル名(IRCチャンネル名は全て’#'という接頭辞が付く – 従ってJavaScriptオブジェクトのプロパティ名としては不適当なので、チャンネル名に対応したオブジェクトのアクセスは.#testではなく ["#test"]のように角括弧で行う)、キーに対応するエントリはIRCチャンネルの表示ウィンドウを表すオブジェクトとする予定である。同様に、mapSpecialBufferは先に述べた特殊なタブの表示ウィンドウを保持する。mapPrivateMessageBufferは、他のIRCユーザと1対1のプライベートメッセージを交わすための表示画面を保持する、ユーザ名をキーとした連想配列となる。helpBuffer、rawBuffer、statusBuffer、channelListBufferはそれぞれの特殊タブの実体で、後で定義されるChannelBufferというクラスのオブジェクトを個々に保持する。ChannelBufferは文字通りチャンネルの中身を保持するためのオブジェクトで、ここでは一々オブジェクトを特殊化せずにそのまま他の種類のタブにも流用している。myNickはIRCサーバ上での自分のニックネーム、currentTabは現在選択され表示されているタブの名称、serverNameは接続先サーバ名である。

さて、ここで説明の便宜上、irc_client.htmlの最下部に置いてあるHTMLデザインの部分を先に出しておく。デザインの 概要は、先に基本動作イメージとして述べたとおりである。冒頭にFlashのProxyIRCが配置され、1ピクセルの大きさなのでユーザからは見えな い。(尚、フラッシュのファイル名についている”?1″はwebブラウザによるFlashオブジェクトのキャッシュを抑制するためのもので、 irc_client.htmlの冒頭のヘッダにもキャッシュを抑制するためのmetaタグが置いてある。開発中に頻繁にFlashを更新するためにブラ ウザのキャッシュを抑制すべく置いたが、実際に機能する場合としない場合があるようだ。)チャンネル表示ウィンドウとして主に利用される、IDがcurrentBufferの 要素内に、helpタブの内容は既に記述されており、アプリケーションは開始時にこの要素のHTMLを読み込んでヘルプファイルとする。また、チャンネル 表示ウィンドウの右上にはXボタンがあり、これを押すとそのタブが消去されるのはWindowsなどのGUIの慣例に拠っている。例えばチャンネルのタブ の場合、そのチャンネルから離脱するという効果が得られる。

<body onLoad="setup();" onkeydown="onKeyDown(event);">

<OBJECT classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" id="ProxyIRC" width="1" height="1"
codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,0,0">
	<PARAM name="movie" value="ProxyIRC.swf?1">
	<PARAM name="quality" value="high">
	<PARAM name="bgcolor" value="#ffffff">
	<PARAM name="allowScriptAccess" value="sameDomain">
	<param name="src" value="ProxyIRC.swf?1">
	<EMBED src="ProxyIRC.swf?1" quality="high" bgcolor="#ffffff" width="1" height="1" name="ProxyIRC" align="middle
" play="true" loop="false" quality="high" allowScriptAccess="sameDomain" type="application/x-shockwave-flash" pluginspage="http://www.macromedia.com/go/getflashplayer">
</OBJECT>

<table width="100%" height="85%" border="1" cellpadding="0">
<tr>
    <td width="100%" height="1%" colspan="2" bgcolor="#0066FF">
	<table width="100%" border="0" cellspacing="0">
	<tr>
		<td bgcolor="#0066FF"><font color="#ffffff"><b><span id="buffer_title"></span></b></font></td>
		<td width="1%"><button onClick="onXButtonClick();">X</button></td>
   	</tr>
	</table>
	</td>
</tr>
  <tr>
    <td width="85%" height="460" style="vertical-align: top;"><p><span id="currentBuffer"><b>Welcome to the Web IRC Client for the KLassphere DICE</b><br>
<br><font size=-1>
Usage:<br>
<br>
* This client requires <b>Internet Explorer 6</b> or <b>Firefox 1.5</b> or higher, and <b>Adobe Flash 9</b> plug-in to run. Also <b>JavaScript</b>
 must be enabled in the web browser options.<br><br>
* There are tabs at the bottom of this page, "<b>help</b>", "<b>raw</b>", "<b>status</b>", and "<b>channels</b>". Click them to open. The "help"
 tab is this page and has the user manual. "raw" is the buffer where raw server outputs are dumped in. "status" is where current status is logged,
 such as negotiation with an IRC server. "channels" is for the channel list for the IRC server.<br><br>
* Enter your nick name for IRC in the box on the right of "<b>Nick Name</b>". Then press the "<b>Connect</b>" button to connect to the IRC server.
 The boxes on the right are for IRC server name and port.<br><br>
* After the connection is established, you are transferred to the "status" tab and can see server messages. Then you can retrieve it the channel
 list and join channels from the "channels" tab. Alternatively, or when you want to create a new channel, you can specify the channel name directly
 in the box on the right of the "Join Channels" button and join in it by pressing the button. A channel name has to start with "#".<br><br>
* When you've joined a channel, a new tab is added in the tab bar at the bottom of this page. You can switch channels by clicking tabs.<br><br>
* To speak in a channel, write down your message in the "<b>Message</b>" box and press the Enter key or push the "Send" button.<br><br>
* To exchange private messages with a channel member, click a user name in the channel member list and type in a message.<br><br>
* The "Unicode (UTF-8)" / "Japanese Multibyte (JIS)" radio buttons are used to change the message encoding. Set it to "Unicode (UTF-8)"
 if your channel's encoding is Unicode.<br><br>
* When you check the "Raw Message" checkbox this client sends the text entered as is to the IRC server. This command is useful to enter
 an IRC command which is not supported by this client. Alternatively you can send a message with "/quote " prefix to gain the same effect.<br><br>
* If you want to erase the content of the current tab, push the "Clear This Buffer" button.<br><br>
* To part from a channel, click the "X" button on the upper right of the tab.<br><br>
* If you are done with chat, push the "Disconnect" button to quit.<br><br>
</font>
</span></p></td>
    <td width="15%" style="vertical-align: bottom;"> <p><span id="members"></span></p></td>
  </tr>
</table>
<form onSubmit="return false;"><input type="button" onclick="connect();" id="buttonConnect" value="(initializing)">
 <input type="text" id="IRCHost" value=""> : <input type="text" id="IRCPort" value="" size="5"> Nick Name <input type="text" id="nick" value="" size="16">
   <input type="button" onclick="joinChannel();" id="buttonJoin" value="Join Channel">
 <input type="text" id="channelName" size="32" onFocus="this.value = '';" value="(enter a channel name here)"><br>
Message <input type="text" id="message" size="80"><input type="button" onclick="sendMessage();" value="Send"><br>
<input type="radio" name="charset" value="utf-8" onclick="setCharset(false)"> Unicode (UTF-8)
<input type="radio" name="charset" value="JIS" onclick="setCharset(true)" checked> Japanese Multibyte (JIS) <input type="checkbox" id="raw"> Raw Message
 <input type="button" onClick="onClearThisBuffer();" id="buttonClearBuffer" value="Clear this buffer"></form>
<span id="tabs"></span>
</body></html>

再びJavaScriptコードへ戻ろう。初期化関連の関数がまず登場する。

function callProxyIRC()
{
	// IE6 doesn't need this method, but FF3 does
	if (isIE)
	{
		return window["ProxyIRC"];
	}
	else
	{
		return document["ProxyIRC"];
	}
}

function setup()
{
	mapSpecialBuffer["help"] = helpBuffer;
	helpBuffer.buffer = getInnerHTML("currentBuffer");

	mapSpecialBuffer["raw"] = rawBuffer;
	mapSpecialBuffer["status"] = statusBuffer;
	mapSpecialBuffer["channels"] = channelListBuffer;

	var date = new Date;
	document.getElementById("nick").value = ("guest" + date.getTime().toString().slice(-5));

	renderTabs();
	switchTab("help");

	sendHTTP( '' , 'GET', './irc_address', fillServerAddress, true);

	// For Firefox 2 and lower, the initialization of Flash is so slow
	// that the setup function must be delayed.
	setTimeout('setupFlash()', 1000);
}

function setupFlash()
{
	callProxyIRC().testLoopback();

	if (!flashIsEnabled)
		setTimeout('setupFlash()', 2000);
}

function loopbackFromFlash()
{
	flashIsEnabled = true;
	document.getElementById("buttonConnect").value = "Connect";
}

function fillServerAddress(hr)
{
	document.getElementById("IRCHost").value = getAjaxTextNodeByTagName(hr, "IRCHost");
	document.getElementById("IRCPort").value = getAjaxTextNodeByTagName(hr, "IRCPort");
}
	   

callProxyIRCはFlashのProxyIRCオブジェクトをJavaScriptからの呼び出し対象として取得する関数で、ブラウザ間の扱いの違いを吸収するためのラッパーである。isIEはdice.js内で定義されているフラグで、Internet Explorerに対してtrueとなる。IEの場合は全てのドキュメントオブジェクトはwindowに格納されており、Firefoxの場合はdocumentになる。setupは このアプリケーションの初期化関数で、HTMLからonLoadで呼び出され、まずそれぞれのタブ群をまとめる連想配列に各々の表示ウィンドウのオブジェ クトを入れる。それから、ユーザのニックネーム欄には”guest”で始まるランダムな文字列が設定される。タブ群の準備が出来たところでrenderTabsを呼び出し、タブを列挙したバーの描画を行い、helpタブへタブを切り替える。最後に、webサーバの/irc_addressというファイルを取得するようAJAXで要求を送っている。DICEのwebサービスは/irc_addressでIRCサービスのアドレスとポートをXMLファイルとして返すので、fillServerAddress関 数はこの情報を得てフォームの接続先ホスト・ポート欄に記入する。setup関数の最後には、Flash内のtestLoopback関数を呼び出すこと により、Flashがこのブラウザで有効になっているか調べている。Firefox 3やIE6/7ではsetTimeoutで実行を遅らせる必要はないが、Firefox 2だとFlashの初期化がbodyタグでのonloadのタイミングより若干遅れるため、2秒の実行待ち時間を入れている。

続いて、ChannelBufferクラスの定義を行う。

// ChannelMember class
function ChannelMember(px, n)
{
	var obj =
	{
		prefix : px,
		nick : n
	};
	return obj;
}

// ChannelBuffer class
function ChannelBuffer(buf)
{
	if (buf == null)
		buf = "";

	var obj =
	{
		buffer : buf,
		members : new Array(),

		addMember : function(m) // m: ChannelMember object
		{
			this.members.push(m);
		},

		// returns the removed channel member object if it's successful
		removeMember : function(n) // n: nick
		{ // don't use splice for compatibility
			var ret = false;
			var c = new Array();
			for (var i in this.members)
			{
				if (ret)
					c.push(this.members[i]);
				else if (this.members[i].nick != n)
					c.push(this.members[i]);
				else
					ret = this.members[i];
			}

			if (ret)
				this.members = c;

			return ret;
		},

		sortMembers : function()
		{
			this.members.sort(this.compareMember);
		},

		compareMember : function(a, b)
		{
			if (a.prefix == "@" && b.prefix != "@")
				return -1;
			if (a.prefix == "+" && b.prefix == "")
				return -1;
			if (a.prefix == "" && b.prefix != "")
				return 1;

			if (b.prefix == "@" && a.prefix != "@")
				return 1;
			if (b.prefix == "+" && a.prefix == "")
				return 1;
			if (b.prefix == "" && a.prefix != "")
				return -1;

			//return (a.nick - b.nick); // this doesn't work in IE6

			if (b.nick > a.nick)
				return -1;
			else if (b.nick == a.nick)
				return 0;
			else
				return 1;
		},

		setMemberMode : function(nick, mode)
		{
			for (var i in this.members)
			{
				if (this.members[i].nick == nick)
				{
					if (mode.charAt(0) == "+")
					{
						switch (mode.charAt(1))
						{
						case "o":
							this.members[i].prefix = "@";
							break;
						case "v":
							this.members[i].prefix = "+";
							break;
						}
					}
					else
						this.members[i].prefix = "";

					return;
				}
			}
		},

		getMemberPrefix : function(nick)
		{
			for (var i in this.members)
			{
				if (this.members[i].nick == nick)
				{
					return this.members[i].prefix;
				}
			}

			return "";
		},

		// these rendering functions force update when the parameter is omitted.
		renderMembers : function(bufferName)
		{
			var ret = (this.members.length == 0 ? "" : "[members]<br>");

			for (var i in this.members)
			{
				ret += "<a style=\"text-decoration: none;\" href=\"#\" onclick=\"openPrivateMessage('";
				ret += (this.members[i].nick + "@" + serverName);
				ret += "')\">";
				ret += (this.members[i].nick == myNick
					? ("<font color=\"red\">" + this.members[i].prefix + this.members[i].nick + "</font>")
						: (this.members[i].prefix + this.members[i].nick));
				ret += "</a>";
				ret += "<br>";
			}

			if (!bufferName || currentTab == bufferName)
			{
				replaceElement("members", ret);
			}
		},

		renderBuffer : function(bufferName)
		{
			if (!bufferName || currentTab == bufferName)
			{
				replaceElement("currentBuffer", this.buffer);
			}
		},

		render : function(bufferName)
		{
			if (!bufferName || currentTab == bufferName)
			{
				replaceElement("currentBuffer", this.buffer);
				this.renderMembers();
			}
		},

		renderTab : function(i)
		{
			var t = "<span style=\"border: 1px solid gray; padding: 0px 2px 4px 4px; margin: 3px 3px 3px 3px\"><a style=\"text-decoration: none;\" href=\"#\" onclick=\"switchTab('";
			t += i;
			t += "')\">";
			t += i;
			t += "</a></span>";
			return t;
		}
	};
	return obj;
}
	  

JavaScriptはプロトタイプベースの言語でクラスというものが存在せず、いつでもオブジェクトのプロパティやメソッド、また継 承に使用されるプロトタイプメソッドを付けたり外したりできるので、あるプロパティのセットを持つオブジェクトを返すという、クラスのコンストラクタ風の メソッドを定義することによってオブジェクト指向を模することになる。ここではJSONデータフォーマットの元となったオブジェクト記法でクラスのプロパ ティやメソッドオブジェクトを列挙している。ChannelMemberクラスはチャンネル参加メンバーリストの個々のメンバーを表すオブジェクトで、prefixとnickの2つのプロパティを持つ。IRCのチャンネル参加者は階級毎に異なる接頭辞が付くのでその接頭辞とニックネームの双方を別々に保持するための2つのプロパティである。ChannelBufferクラスは先に出てきたチャンネル表示ウインドウのデータを保持するためのクラスである。bufferはチャンネルのログなどが表示されるメインの領域のデータを保持するためのバッファで、membersはChannelMemberの 配列を保持するチャンネル参加者リストである。チャンネルメンバー追加、メンバーリストのソートなどの一連のメンバーリスト操作メソッドの後に、メンバー リスト、メイン領域、タブ列挙バーの中の個々のタブの描画を担当するレンダリングメソッドが続く。これらレンダリングメソッドは、対象のタブが現在表示さ れているときのみdice.jsのreplaceElement関数を使用してDOMを操作し表示領域を更新する。

function getCurrentTimeString()
{
	var ret = "";
	var d = new Date();
	var tmp = d.getHours();
	if (tmp < 10)
		tmp = "0" + tmp;
	ret += tmp;
	ret += ":";
	tmp = d.getMinutes();
	if (tmp < 10)
		tmp = "0" + tmp;
	ret += tmp;
	ret += ":";
	tmp = d.getSeconds();
	if (tmp < 10)
		tmp = "0" + tmp;
	ret += tmp;
	return ret;
}

function refreshCurrentBuffer(bufferName, buffer)
{
	if (currentTab == bufferName)
		replaceElement("currentBuffer", buffer);
}

function passOutputStatusBuffer(s, raw)
{
	if (raw)
	{
		statusBuffer.buffer += ("[" + getCurrentTimeString() + "] " + s);
		refreshCurrentBuffer("status", statusBuffer.buffer);
		return;
	}

	var matched = s.match(/\S+\s+:*(.*)/);
	if (matched == null)
	{
		mapSpecialBuffer["status"].buffer += ("[" + getCurrentTimeString() + "] " + s);
		return;
	}

	statusBuffer.buffer += ("[" + getCurrentTimeString() + "] " + matched[1] + "<br>");
	refreshCurrentBuffer("status", statusBuffer.buffer);
}

function passOutputRawBuffer(s)
{
	rawBuffer.buffer += ("[" + getCurrentTimeString() + "] " + s + "<br>");
	refreshCurrentBuffer("raw", rawBuffer.buffer);
}

function escapeHTML(s)
{
    return s.split("<").join("&amp;lt;").split(">").join("&amp;gt;");
}
	  

これらはユーティリティ関数群である。getCurrentTimeStringはタイムスタンプ用文字列を生成し、refreshCurrentBufferはタブが現在表示されているときのみ画面を更新する。passOutputStatusBufferはstatusタブへ、passOutputRawBufferはrawタブへそれぞれ文字列を出力する。escapeHTMLはIRCサーバから送られてくる文字列がブラウザによってHTMLとして解釈されないように全てサニタイズするためのフィルタ関数である。

// this function is called from Flash
function output(s)
{
	s = escapeHTML(s);

	// matched[1] : prefix, matched[2] : command, matched[3] : parameter
	var matched = s.match(/^:(\S+)\s(\S+)\s*(.*)/);
	if (matched == null)
		return;

	if (serverName == "")
		serverName = matched[1];

	passOutputRawBuffer("<font color=red>" + matched[1]
			+ "</font> <font color=blue>" + matched[2]
			+ "</font> <font color=green>" + matched[3] + "</font>");

	switch (matched[2])
	{
	case "JOIN":
		onJOIN(matched[1], matched[3]);
		break;
	case "KICK":
		onKICK(matched[1], matched[3]);
		break;
	case "MODE":
		onMODE(matched[1], matched[3]);
		break;
	case "NICK":
		onNICK(matched[1], matched[3]);
		break;
	case "NOTICE":
		onNOTICE(matched[1], matched[3]);
		break;
	case "PART":
		onPART(matched[1], matched[3]);
		break;
	case "PRIVMSG":
		onPRIVMSG(matched[1], matched[3]);
		break;
	case "QUIT":
		onQUIT(matched[1], matched[3]);
		break;
	case "332": // RPL_TOPIC
		onTOPIC(matched[3]);
		break;
	case "353": // RPL_NAMREPLY
		onNAMREPLY(matched[3]);
		break;
	case "001": // RPL_WELCOME
		onWELCOME(matched[1], matched[3]);
		break;
	case "002": // RPL_YOURHOST
	case "003": // RPL_CREATED
	case "004": // RPL_MYINFO
	case "005": // RPL_BOUNCE / RPL_ISUPPORT

	case "251": // RPL_LUSERCLIENT
	case "254": // RPL_LUSERCHANNELS
	case "255": // RPL_LUSERME

	case "375": // RPL_MOTDSTART
	case "372": // RPL_MOTD
	case "376": // RPL_MOTDSTART
		passOutputStatusBuffer(matched[3]);
		break;
	default:

		break;
	}
}

function reportError(s)
{
	statusBuffer.buffer += ("[" + getCurrentTimeString() + "] " + s + "<br>");
	refreshCurrentBuffer("status", statusBuffer.buffer);
}
	  

outputは、先にProxyIRCの解説で登場した、FlashがIRCサーバーからデータを受け取ったときに呼ばれる関数である。ここで正規表現を用いてIRCメッセージを解析し、得られたコマンドに基づいてそれぞれのコマンド処理関数へ処理を分岐させる。reportErrorはエラーをstatusタブに書き出す関数である。

function renderTabs()
{
	var t = "";

	for (var i in mapSpecialBuffer)
	{
		t += mapSpecialBuffer[i].renderTab(i);
	}

	for (var i in mapChannelBuffer)
	{
		t += mapChannelBuffer[i].renderTab(i);
	}

	for (var i in mapPrivateMessageBuffer)
	{
		t += mapPrivateMessageBuffer[i].renderTab(i);
	}

	replaceElement("tabs", t);
}

function setCurrentBuffer(name)
{
	currentTab = name;
	replaceElement("buffer_title", name);
}

function switchTab(name)
{
	for (var i in mapSpecialBuffer)
	{
		if (name == i)
		{
			setCurrentBuffer(name);
			mapSpecialBuffer[name].render();
			return;
		}
	}

	for (var i in mapChannelBuffer)
	{
		if (name == i)
		{
			setCurrentBuffer(name);
			mapChannelBuffer[name].render();
			return;
		}
	}

	for (var i in mapPrivateMessageBuffer)
	{
		if (name == i)
		{
			setCurrentBuffer(name);
			mapPrivateMessageBuffer[name].render();
			return;
		}
	}

	alert("Invalid tab");
}

function setCharset(jis)
{
	callProxyIRC().setJIS(jis);
}
	  	  

renderTabsは特殊タブ、チャンネルタブ、プライベートメッセージタブの順でタブ列挙バーの描画を行う。setCurrentBufferは現在のタブを設定するとともに表示ウィンドウのタイトルバーに表示されている文字列を現在のタブの名称に更新する。switchTabはユーザがタブを押したときに呼ばれる関数で、目的のタブを探して表示する。setCharsetはFlashが日本語JISエンコーディングを文字列に適用するか否かを設定する。

function connect()
{
	if (!flashIsEnabled)
	{
		callProxyIRC().testLoopback();

		if (!flashIsEnabled)
		{
			alert("This client requires Adobe Flash Player 9 and a JavaScript-enabled web browser!");
			return;
		}
	}

	document.getElementById("buttonConnect").blur();

	if (isConnected)
	{
		if (!confirm("Do you really want to disconnect?"))
			return;

		callProxyIRC().quitIRC();
		onClose();
		return;
	}

	var n = document.getElementsByName("charset");
	for (var i = 0; i < n.length; ++i)
	{
		if (n.item(i).checked)
			callProxyIRC().setJIS(n.item(i).value == "JIS" ? true : false);
	}

	var h = document.getElementById("IRCHost").value;
	if (!h || h == "")
	{
		alert("Invalid host name");
		return;
	}

	var p = document.getElementById("IRCPort").value;
	if (!p || p == "")
	{
		alert("Invalid port");
		return;
	}

	callProxyIRC().connectIRC(h, parseInt(p, 10));
}

function onConnect()
{
	isConnected = true;
	document.getElementById("buttonConnect").value = "Disconnect";

	switchTab("status");

	myNick = document.getElementById("nick").value;

	send("USER " + myNick + " " + myNick + " " + myNick + ":" + myNick);
	send("NICK " + myNick);
}

function onClose()
{
	isConnected = false;
	document.getElementById("buttonConnect").value = "Connect";

	mapChannelBuffer = new Object();
	renderTabs();

	switchTab("status");
	passOutputStatusBuffer("<br>* Disconnected<br><br>", true);

	serverName = "";
	myNick = "";
}
	  

connectはユーザが接続ボタンを押したときに呼ばれる関数で、接続中に呼ばれると接続を切断するはたらきもある。フォームのホスト欄、ポート欄からそれぞれデータを取得し、Flash側のメソッドを呼び出してIRCサーバへの接続を開始する。onConnect、onCloseはそれぞれサーバに接続したとき、切断されたときにFlash側から呼び出される関数で、前者はニックネームを設定するIRCコマンドをサーバへ送信し、後者はチャンネルリストをクリアしてタブ列挙バーを再描画し、画面に切断の表示を出して終了処理を行う。

function joinChannel()
{
	document.getElementById("buttonJoin").blur();

	if (!isConnected)
	{
		alert("Not connected");
		return;
	}

	if (document.getElementById("channelName").value == "")
	{
		alert("No channel specified");
		return;
	}

	if (document.getElementById("channelName").value.charAt(0) != '#')
	{
		alert("Invalid channel name - it must begin with '#'");
		return;
	}

	send("JOIN " + document.getElementById("channelName").value);
}

function send(s)
{
	passOutputRawBuffer("(send) " + s);

	callProxyIRC().sendIRC(s);
}

function sendMessage()
{
	var m = document.getElementById("message").value;
	if (m == "")
		return;

	if (document.getElementById("raw").checked)
	{
		document.getElementById("message").value = "";
		send(m);
		return;
	}

	var matched = m.match(/\/quote\s+(.*)/i);
	if (matched)
	{
		document.getElementById("message").value = "";
		send(matched[1]);
		return;
	}

	for (var i in mapSpecialBuffer)
	{
		if (currentTab == i)
		{
			send(m);
			return;
		}
	}

	for (var i in mapChannelBuffer)
	{
		if (currentTab == i)
		{
			var c = mapChannelBuffer[currentTab];
			if (!c)
				return;

			c.buffer += "[";
			c.buffer += getCurrentTimeString();
			c.buffer += "] <";
			c.buffer += myNick;
			c.buffer += "> ";
			c.buffer += m;
			c.buffer += "<br>";

			c.renderBuffer(currentTab);

			document.getElementById("message").value = "";
			send("PRIVMSG " + currentTab + " :" + m);
			return;
		}
	}

	for (var i in mapPrivateMessageBuffer)
	{
		if (currentTab == i)
		{
			var pm = mapPrivateMessageBuffer[currentTab];
			if (!pm)
				return;

			matched = currentTab.match(/([^@]+)@/);
			if (!matched)
				return;

			pm.buffer += ("[" + getCurrentTimeString() + "] ");
			pm.buffer += "<";
			pm.buffer += myNick;
			pm.buffer += "> ";
			pm.buffer += m;
			pm.buffer += "<br>";

			pm.renderBuffer(currentTab);

			document.getElementById("message").value = "";
			send("PRIVMSG " + matched[1] + " :" + m);
			return;
		}
	}
}
	  

joinChannelはユーザが操作パネルから参加対象チャンネルを明示的に選んでチャンネルに参加することを選んだ場合に呼ばれる関数である。sendは裸の文字列をサーバへ送信する関数で、sendMessageは ユーザが操作パネルのメッセージ欄に文字列を記入しEnterキーを押すか送信ボタンを押したときに呼ばれる関数である。IRCサーバはユーザが送信して きたメッセージをそのユーザ自身へエコーしないので、クライアントが自分で自分の発したメッセージを画面に書き出してやる必要がある。

function onJOIN(prefix, param)
{
	var matched = prefix.match(/([^!]+)!(\S+)/);
	if (matched == null)
		return;

	if (matched[1] == myNick)
	{
		var c = new ChannelBuffer("");

		c.buffer += ("[" + getCurrentTimeString() + "] ");
		c.buffer += "<font color=\"green\">* Now talking in ";
		c.buffer += param;
		c.buffer += "</font><br>";

		mapChannelBuffer[param] = c;

		renderTabs();
		switchTab(param);
		send("MODE " + param);
		//send("WHO " + param);
	}
	else
	{
		var c = mapChannelBuffer[param];
		if (!c)
			return;

		c.buffer += ("[" + getCurrentTimeString() + "] ");
		c.buffer += "<font color=\"green\">* Joins: ";
		c.buffer += matched[1];
		c.buffer += " (";
		c.buffer += matched[2];
		c.buffer += ")</font><br>";

		c.addMember(ChannelMember("", matched[1]));
		c.sortMembers();

		c.render(param);
	}
}

function onPART(prefix, param)
{
	var matched = prefix.match(/([^!]+)!(\S+)/);
	if (matched == null)
		return;

	var c = mapChannelBuffer[param];
	if (!c)
		return;

	c.buffer += ("[" + getCurrentTimeString() + "] ");
	c.buffer += "<font color=\"green\">* Parts: ";
	c.buffer += matched[1];
	c.buffer += " (";
	c.buffer += matched[2];
	c.buffer += ")</font><br>";

	c.removeMember(matched[1]);
	c.sortMembers();

	c.render(param);
}

function onKICK(prefix, param)
{
	var matched = prefix.match(/([^!]+)!(\S+)/);
	if (matched == null)
		return;

	var nick = matched[1];

	matched = param.match(/(\S+)\s+(\S+)\s+:(.*)/);
	if (matched == null || matched[1] == null || matched[2] == null)
		return;

	if (matched[2] == myNick)
	{
		delete mapChannelBuffer[matched[1]];

		var s = c.buffer += ("[" + getCurrentTimeString() + "] <font color=\"green\">* You were kicked from ");
		s += matched[1];
		s += " by ";
		s += nick;

		if (matched[3])
		{
			s += " (";
			s += matched[3];
			s += ")";
		}

		s += "</font><br>";

		passOutputStatusBuffer(s, true);

		renderTabs();
		switchTab("status");

		return;
	}

	var c = mapChannelBuffer[matched[1]];
	if (!c)
		return;

	c.buffer += ("[" + getCurrentTimeString() + "] ");
	c.buffer += "<font color=\"green\">* ";
	c.buffer += matched[2];
	c.buffer += " was kicked by ";
	c.buffer += nick;

	if (matched[3])
	{
		c.buffer += " (";
		c.buffer += matched[3];
		c.buffer += ")";
	}

	c.buffer += "</font><br>";

	c.removeMember(matched[2]);
	c.sortMembers();

	c.render(param);
}

function onQUIT(prefix, param)
{
	var matched = prefix.match(/([^!]+)!/);
	if (matched == null)
		return;

	var nick = matched[1];
	for (var i in mapChannelBuffer)
	{
		var c = mapChannelBuffer[i];
		if (c.removeMember(nick))
		{
			c.buffer += ("[" + getCurrentTimeString() + "] ");
			c.buffer += "<font color=\"blue\">*** Quits: ";
			c.buffer += matched[1];
			c.buffer += " (";
			c.buffer += ((param.length != 0 &amp;&amp; param.charAt(0) == ":") ? param.substr(1): param);
			c.buffer += ")</font><br>";

			c.sortMembers();
			c.render(i);
		}
	}
}
	  

これらはユーザの入退出に関連するメッセージを受け取ったときの処理関数である。onJOINはユーザがチャンネルに参加してきたときに送られるメッセージで、自分がチャンネルに参加成功したときも送られてくるためそれぞれについて処理する必要がある。onPARTはユーザがチャンネルから退出したというメッセージ、onKICKはチャンネルから強制的に出されたというメッセージを処理する。onQUITはあるユーザがIRCサーバ自体から退出したというメッセージで、onPARTと異なりそのユーザが参加していた全てのチャンネルについて影響を考慮してやる必要がある。

function onMODE(prefix, param)
{
	var matched = prefix.match(/([^!]+)/);
	if (matched == null)
		return;

	var subject = matched[1];

	matched = param.match(/(\S+)\s+(\S+)\s+(\S*)/);
	if (matched == null)
		return;

	var c = mapChannelBuffer[matched[1]];
	if (!c)
		return;

	// channel mode
	if (!matched[3])
	{
		c.buffer += ("[" + getCurrentTimeString() + "] ");
		c.buffer += "<font color=\"green\">* ";
		c.buffer += subject;
		c.buffer += " sets mode: ";
		c.buffer += matched[2];
		c.buffer += "</font><br>";

		c.renderBuffer(matched[1]);
		return;
	}

	// user mode

	c.buffer += ("[" + getCurrentTimeString() + "] ");
	c.buffer += "<font color=\"green\">* ";
	c.buffer += subject;
	c.buffer += " sets mode: ";
	c.buffer += matched[2];
	c.buffer += " ";
	c.buffer += matched[3];
	c.buffer += "</font><br>";

	c.setMemberMode(matched[3], matched[2]);
	c.sortMembers();

	c.render(matched[1]);
}

function onNICK(prefix, param)
{
	var matched = prefix.match(/([^!]+)!/);
	if (matched == null)
		return;

	var subject = matched[1];

	matched = param.match(/:(\S+)/);
	if (matched == null)
		return;

	var newNick = matched[1];

	var m = ("[" + getCurrentTimeString() + "] <font color=\"green\">* ");
	m += subject;
	m += " is now known as ";
	m += newNick;
	m += "</font><br>";

	if (subject == myNick)
	{
		myNick = newNick;
		document.getElementById("nick").value = myNick;
	}

	for (var i in mapChannelBuffer)
	{
		var c = mapChannelBuffer[i];
		var removed = c.removeMember(subject);
		if (removed)
		{
			c.buffer += m;
			c.addMember(ChannelMember(removed.prefix, newNick));
			c.sortMembers();
			c.render(i);
		}
	}
}
	 

onMODEはチャンネルまたはユーザのモードが変化したとき、onNICKはユーザがニックネームを変更したときに送られるメッセージを処理する。ユーザのニックネーム変更はonQUIT同様に全ての関係チャンネルで処理しなければならない。

function onNOTICE(prefix, param)
{
	var matched = prefix.match(/([^!]+)/);
	if (matched == null)
		return;

	var nick = matched[1];

	matched = param.match(/(\S+)\s+:(.*)/);
	if (matched == null)
	{
		passOutputStatusBuffer("-" + serverName + "- " + param.substr(1) + "<br>", true);
		return;
	}

	var c = mapChannelBuffer[matched[1]];
	if (!c)
	{
		delete mapChannelBuffer[matched[1]];
		passOutputStatusBuffer("-" + nick + "- " + matched[2] + "<br>", true);
		return;
	}

	c.buffer += ("[" + getCurrentTimeString() + "] ");
	c.buffer += "-> (";
	c.buffer += nick;
	c.buffer += ") ";
	c.buffer += matched[2];
	c.buffer += "<br>";

	c.renderBuffer(matched[1]);
}

function onPRIVMSG(prefix, param)
{
	var matched = prefix.match(/([^!]+)/);
	if (matched == null)
		return;

	var nick = matched[1];

	matched = param.match(/(\S+)\s+:(.*)/);
	if (matched == null)
		return;

	var c = mapChannelBuffer[matched[1]];
	if (!c)
	{
		if (matched[1] == myNick)
		{ // private message
			var pm = mapPrivateMessageBuffer[nick + "@" + serverName];
			if (pm)
			{
				pm.buffer += ("[" + getCurrentTimeString() + "] ");
				pm.buffer += "<";
				pm.buffer += nick;
				pm.buffer += "> ";
				pm.buffer += matched[2];
				pm.buffer += "<br>";

				pm.renderBuffer(nick + "@" + serverName);
			}
			else
			{
				var pm = new ChannelBuffer("");
				pm.buffer += ("[" + getCurrentTimeString() + "] ");
				pm.buffer += "<";
				pm.buffer += nick;
				pm.buffer += "> ";
				pm.buffer += matched[2];
				pm.buffer += "<br>";

				mapPrivateMessageBuffer[nick + "@" + serverName] = pm;

				renderTabs();
			}
		}
		return;
	}

	c.buffer += "[";
	c.buffer += getCurrentTimeString();
	c.buffer += "] <";
	c.buffer += c.getMemberPrefix(nick);
	c.buffer += nick;
	c.buffer += "> ";
	c.buffer += matched[2];
	c.buffer += "<br>";

	c.renderBuffer(matched[1]);
}

function openPrivateMessage(target)
{
	if (serverName == "")
	{
		alert("Not connected");
		return;
	}

	var matched = target.match(/([^@]+)/);
	if (!matched)
		return;

	var pm = mapPrivateMessageBuffer[matched[1] + "@" + serverName];
	if (!pm)
	{
		var pm = new ChannelBuffer("");
		mapPrivateMessageBuffer[matched[1] + "@" + serverName] = pm;

		renderTabs();
	}

	switchTab(matched[1] + "@" + serverName);
}
	  

IRCのチャンネル内で発言するにはPRIVMSGによるかNOTICEによるかのどちらかであり、onNOTICEはそのうちNOTICEメッセージを、onPRIVMSGは PRIVMSGメッセージを扱う。PRIVMSGメッセージは引数がユーザの時には1対1のプライベートメッセージのためのメッセージとしても使用され る。このプライベートメッセージを受け取ると、対象ユーザと会話するためのタブが存在しない場合は新たに1対1会話用のタブを生成してmapPrivateMessageBufferへ追加する。openPrivateMessageはユーザがチャンネル参加者リストの中の1対1で会話したいメンバーをクリックしたときに新しくタブを生成する関数である。

function onTOPIC(param)
{
	var matched = param.match(/\S+\s+(\S+)\s+:(.*)/);
	if (matched == null)
		return;

	var c = mapChannelBuffer[matched[1]];
	if (!c)
		return;

	c.buffer += "[Topic] ";
	c.buffer += matched[2];
	c.buffer += "<br><br>";

	c.render(matched[1]);
}

function onNAMREPLY(param)
{
	var matched = param.match(/=\s+(\S+)\s+:(.+)/);
	if (matched == null)
		return;

	var c = mapChannelBuffer[matched[1]];
	if (!c)
		return;

	var a = matched[2].split(" ");
	for (var i in a)
	{
		switch (a[i].charAt(0))
		{
		case "@":
			c.addMember(ChannelMember("@", a[i].substr(1)));
			break;
		case "+":
			c.addMember(ChannelMember("+", a[i].substr(1)));
			break;
		default:
			c.addMember(ChannelMember("", a[i]));
			break;
		}
	}

	c.sortMembers();
	c.renderMembers(matched[1]);
}

function onWELCOME(prefix, param)
{
	// it's not necessarily true that welcome message is the first one the server sents in
	if (serverName != prefix)
		serverName = prefix;

	var matched = param.match(/(\S+)\s+:*/);
	if (matched != null)
	{
		myNick = matched[1];
		document.getElementById("nick").value = myNick;
	}

	passOutputStatusBuffer(param);
}
	  

onTOPICはチャンネルトピックを通知するメッセージを、onNAMEREPLYはチャンネル参加者を列挙するメッセージを処理する。双方ともチャンネル参加時に送られてくるメッセージである。それに対し、onWELCOMEは申請したニックネームがサーバに登録されサーバに受容されたときに送られてくるもので、ユーザのニックネームを含んでおり、申請したニックネームを重複などの理由によりサーバが勝手に変更した場合にも対処できるようにしてある。

function onXButtonClick()
{
	for (var i in mapSpecialBuffer)
	{
		if (i == currentTab)
		{
			alert("This tab can't be closed");
			return;
		}
	}

	for (var i in mapChannelBuffer)
	{
		if (i == currentTab)
		{
			send("PART " + currentTab);

			delete mapChannelBuffer[currentTab];

			renderTabs();
			switchTab("status");
			return;
		}
	}

	for (var i in mapPrivateMessageBuffer)
	{
		if (i == currentTab)
		{
			delete mapPrivateMessageBuffer[currentTab];

			renderTabs();
			switchTab("status");
			return;
		}
	}

	alert("Invalid buffer");
}

function onClearThisBuffer()
{
	document.getElementById("buttonClearBuffer").blur();

	if (!confirm("Do you really want to clear the content of the current buffer?"))
		return;

	for (var i in mapSpecialBuffer)
	{
		if (currentTab == i)
		{
			mapSpecialBuffer[currentTab].buffer = "";
			mapSpecialBuffer[currentTab].renderBuffer(currentTab);
			return;
		}
	}

	for (var i in mapChannelBuffer)
	{
		if (currentTab == i)
		{
			mapChannelBuffer[currentTab].buffer = "";
			mapChannelBuffer[currentTab].renderBuffer(currentTab);
			return;
		}
	}

	for (var i in mapPrivateMessageBuffer)
	{
		if (currentTab == i)
		{
			mapPrivateMessageBuffer[currentTab].buffer = "";
			mapPrivateMessageBuffer[currentTab].renderBuffer(currentTab);
			return;
		}
	}

	alert("Invalid buffer");
}
	  

onXButtonClickは、上述のように、タブ右上のXボタンを押すとそのタブを閉じることが出来るというもので、同時にそのタブが表象していたチャンネルを離脱するようになっている。onClearThisBufferは、操作パネルのタブの内容をクリアするボタンを押したときの動作を記述している。

function loadChannelList()
{
	if (!isConnected)
	{
		alert("Not connected");
		return;
	}

	channelListBuffer.buffer += "Now loading...";
	refreshCurrentBuffer("channels", channelListBuffer.buffer);

	sendHTTP('' , 'GET', './channels', showChannels, true);
}

function showChannels(hr)
{
	var nodelist = hr.responseXML.getElementsByTagName("Channel");
	if (!nodelist)
	{
		channelListBuffer.buffer = channelListHeader;
		channelListBuffer.buffer += "Currently there are no channels on the server.";
		refreshCurrentBuffer("channels", channelListBuffer.buffer);

		return;
	}

	var output = nodelist.length.toString();
	output += (nodelist.length == 1 ? " channel has been retrieved.<br><br>" : " channels have been retrieved.<br><br>");

	for (var i = 0; i < nodelist.length; ++i)
	{
		var n = nodelist.item(i);
		if (n == null)
			continue;

		var users = n.getAttribute("Users");

		var nn = n.firstChild;
		var name = "";
		var topic = "";

		while (nn != null)
		{
			if (nn.nodeName == "Name")
			{
				// nn.textContent == Mozilla only
				var a = nn.firstChild;
				// NODE_TEXT == 3 || NODE_CDATA_SECTION == 4
				while (a != null &amp;&amp; (a.nodeType == 3 || a.nodeType == 4))
				{
					name = a.nodeValue;
					a = a.nextSibling;
				}
			}
			else if (nn.nodeName == "Topic")
			{
				var a = nn.firstChild;
				// NODE_TEXT == 3 || NODE_CDATA_SECTION == 4
				while (a != null &amp;&amp; (a.nodeType == 3 || a.nodeType == 4))
				{
					topic = a.nodeValue;
					a = a.nextSibling;
				}
			}

			nn = nn.nextSibling;
		}

		output += (i + 1).toString();
		output += ". ";
		output += "<a style=\"text-decoration: none;\" href=\"#\" onclick=\"joinChannelFromList('#";
		output += name;
		output += "')\">#";
		output += name;
		output += "</a> ";
		output += topic;
		output += " (";
		output += users;
		output += " users)<br><br>";
	}

	channelListBuffer.buffer = channelListHeader;
	channelListBuffer.buffer += output;

	refreshCurrentBuffer("channels", channelListBuffer.buffer);
}

function joinChannelFromList(channelName)
{
	for (var i in mapChannelBuffer)
	{
		if (i == channelName)
		{
			switchTab(channelName);
			return;
		}
	}

	send("JOIN " + channelName);
}
	  

loadChannelListは、AJAXでサーバからIRCチャンネルリストを得る関数である。DICEは、/channelsパスにアクセスするとIRCチャンネルリストをXMLで返す。IRC側にもチャンネルリストを得るコマンドは勿論存在するが、ここでは元々webチャンネルブラウザのために実装したインターフェイスを再利用している。そのコールバック関数がshowChannelsで、AJAXリクエスト完了時に受け取ったXMLを処理する。joinChannelFromListは、チャンネルリスト上のチャンネル名をクリックしたときに呼ばれる関数で、目的のチャンネルへユーザを参加させる。

function onKeyDown(e)
{
	if (e.keyCode == 13 && isConnected) // Enter
	{
		sendMessage();
	}
}
 

これがJavaScriptコードの最後の部分で、先に挙げたHTMLのデザイン部分が後に続く。onKeyDownはキー入力を監視し、Enterキーが押されるとメッセージ欄に記入されているメッセージを送信する。このバージョンではIEだとEnterキー押下時に音が鳴るが、formタグの使用を止めれば回避できる。このIRCクライアントwebアプリケーションはDICEのパッケージに同梱されているので、デザインも一新されている最新版での実際の動作はDICEをインストールして確かめてみて欲しい(本記事で掲載しているバージョンのActionScriptコードに存在する日本語JISコードの取り扱いに関するバグはそちらでは修正済みである)。

AJAXやWeb 2.0と形容されるものを超えた先にあるものは何か? webブラウザがHTTPではないプロトコルのサーバに自由に接続することが当たり前のようになるとき、webブラウザはwebを超えたプラットフォーム となり、webそのものの刷新が起こるのではないか。そのときwebブラウザはwebブラウザではない他の物に、webはwebではない他の存在になって いるのかもしれない。

(2008-04-11追記) 現時点で、Adobe Flash Player 9.0.124.0でのFlashのセキュリティ仕様変更により、本稿のクライアントを動作させるにはサーバ側の対応が必要となる。DICEではバージョン0.9.1.1で対応完了している。