C++でSoapは、マイノリティ？

ここんところ、プラットフォームに依存しない Soap ライブラリというテーマで、どハマリしてます。axis2 の wsdl2c では、xsd ファイル中の、abstract が処理できませんでした。GML の Filter も曲者でして、abstract な choise で４つのタイプに派生して、それぞれが、また、abstract で複雑に派生していきます。中には BinaryOp, UnaryOp とかもあって、SentenceStatement(文)とExpression(式)までXMLで表現しているので、人手でコードを補完して書くレベルを超えてます。あわよくばパッチを当ててやろうか？と思って、SchemaCompiler.java を読んでみたもののパッと修正できる代物では無さそうでした。C++ のコードは、XSLT を使って処理しているようでしたが、xsd:include を使ってないので、ごった煮でコードが読みにくい。
　で、まともに処理できたのは、gSOAP でした。SOAP Toolkit を使って ISAPI Extension を記述し、mod_isapi を利用するという手もあるとは思いますが…。
　はたと、思い出したように akaxsio2 引っ張り出してみたんですが、コンパイル通りませんでした。strcpy とか使っている部分は、string.h を include する。アドレス計算している部分は、int から stddef.h の ptrdiff_t に変える。unsigned int でなく size_t を使うといったあたりまでは、パッチを当てれそうでしたが、mutable output_file& の部分が、ちょっと厳しくて挫折しました。const output_file& に変えて、const_cast 使えば、なんとかなるかも…。でも gml のスキーマを通すのは、並大抵の事ではなく、akaxiso2 も通さなかったような記憶があります。akaxiso もちょろちょろソースを見たのですが、相当な大作です…。今なら、fusion とか使って、もっとクールに表現できそうな気もするけど、xml ライブラリは、しんどいですわ。
　お前、OpenSoap にパッチ当ててたやん？どないしてん？と思っている方もいるかもしれないので、触れておくと、ComplexType と array がサポートされていないので、使えませんでした。

放射能の航空測量の結果感想

　10月に入って、東京も含めて航空測量の結果が公表されているようである。久しぶりにデータを見てみたが、その感想を述べてみようと思う。静観すると書いておいて、何故言及するか？というと、ヒステリック過ぎる人が多いからで、書いておいた方がいいかなと思ったからである。現在はセシウムの分布もだいぶ落ちてきており、福島を中心とした一部が高いだけである。日本の気候は雨が多いので、だいぶ流れたのではないかと思う。
　また、除染の効果なのか、野菜のベクレル数も下がってきているので、３～６月ほど気にする事も無くなってきたように思う。魚に関しては、引き続き注視したいが、全体としては、良い方向に流れているのではないだろうか？
　東京などは、トンデルの論文でも有意な結果かどうかわからない程度の量である事がわかる。
　今頃になって、大騒ぎしているが、正直、反応が遅すぎるだろうと思う。もう線量は落ちてきていて、外部からちょろっと被曝する分には、どうって事は無いと思う。そういう意味では、つくづく事故直後の対応が残念でならない。SPEEDIの結果を有効活用できたはずである。発表してたとしても、せいぜい「痛いニュース」で大騒ぎされたぐらいで、日本ではパニックになる事は無かっただろうに…。
　尚、汚染の高い地域に関して、安全と言えるのかどうかについては、また別問題である。これについては、引き続き静観しようと思います。

XMLのschemaに日本語の要素名は、いい迷惑 on apache axis2c

正常な前処理トークンとなりませんの続き
要素名が日本語になっている部分を修正し、文法上エラーにならないようにして、wsdl2c で生成したソースファイルの中で、axis2_extension_mapper.c に対して、マッピングの修正をかける事にします。自動生成なので、コピペ・コーディングの変数名に修正をかけるのは、ちょっとしんどいので、boost preprocessor の出番です。

        /**
         * axis2_extension_mapper.c
         *
         * This file was auto-generated from WSDL
         * by the Apache Axis2/Java version: 1.6.1  Built on : Aug 31, 2011 (12:23:23 CEST)
         */

        #include "axis2_extension_mapper.h"

        #include "adb_foo_type0.h"
        #include "adb_foo_type1.h"
        #include "adb_Bar.h"
        
        // ここ
        #include <boost/preprocessor.hpp>
        #include <boost/preprocessor/cat.hpp>
        #include <boost/preprocessor/seq/for_each.hpp>
        #include <boost/preprocessor/tuple/elem.hpp>
        #include <boost/preprocessor/stringize.hpp>

#define TYPE_LIST \
(("要素名に","adb_要素名に",foo_type0))\
(("日本語を","adb_日本語を",foo_type1))\
(("使うなゴラー","adb_使うなゴラー",bar))

#define ADB_CREATE_MACRO(r,data,elem)  \
   if(0 == axutil_strcmp(type, BOOST_PP_TUPLE_ELEM(3,0,elem))) { \
       return (adb_type_t*) BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_create(env))); \
   }

#define ADB_CREATE_DEFAULT_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(default_type, BOOST_PP_TUPLE_ELEM(3,0,elem))) { \
       return (adb_type_t*) BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_create(env))); \
   }

#define ADB_FREE_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(adb_type_get_type(_object), BOOST_PP_TUPLE_ELEM(3,1,elem))) { \
       return BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_free_obj))( \
              (BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_t))*) _object, env); \
   }

#define ADB_FREE_DEFAULT_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(default_type, BOOST_PP_TUPLE_ELEM(3,1,elem))) { \
       return BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_free_obj))( \
              (BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_t))*) _object, env); \
   }

#define ADB_DESERIALIZE_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(adb_type_get_type(_object), BOOST_PP_TUPLE_ELEM(3,1,elem))) { \
       return BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_deserialize_obj))( \
              (BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_t))*) _object, env, dp_parent, dp_is_early_node_valid, dont_care_minoccurs); \
   }

#define ADB_DESERIALIZE_DEFAULT_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(default_type, BOOST_PP_TUPLE_ELEM(3,1,elem))) { \
       return BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_deserialize_obj))( \
              (BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_t))*) _object, env, dp_parent, dp_is_early_node_valid, dont_care_minoccurs); \
   }

#define ADB_SERIALIZE_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(adb_type_get_type(_object), BOOST_PP_TUPLE_ELEM(3,1,elem))) { \
       return BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_serialize_obj))( \
              (BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_t))*) _object, env, om_node, om_element, tag_closed, namespaces, next_ns_index); \
   }

#define ADB_SERIALIZE_DEFAULT_MACRO(r,data,elem) \
   if(0 == axutil_strcmp(default_type, BOOST_PP_TUPLE_ELEM(3,1,elem))) { \
       return BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_serialize_obj))( \
              (BOOST_PP_CAT(adb_,BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(3,2,elem),_t))*) _object, env, om_node, om_element, tag_closed, namespaces, next_ns_index); \
   }

        struct adb_type
        {
            axis2_char_t *property_Type;
        };

        /**
         * Auxiliary function to determine an ADB object type from its Axiom node.
         * @param env pointer to environment struct
         * @param node double pointer to the parent node to deserialize
         * @return type name on success, else NULL
         */
        axis2_char_t *AXIS2_CALL
        axis2_extension_mapper_type_from_node(
            const axutil_env_t *env,
            axiom_node_t** node)
        {
            axiom_node_t *parent = *node;
            axutil_qname_t *element_qname = NULL;
            axiom_element_t *element = NULL;

            axutil_hash_index_t *hi;
            void *val;
            axiom_attribute_t *type_attr;
            axutil_hash_t *ht;
            axis2_char_t *temp;
            axis2_char_t *type;

            while(parent && axiom_node_get_node_type(parent, env) != AXIOM_ELEMENT)
            {
                parent = axiom_node_get_next_sibling(parent, env);
            }

            if (NULL == parent)
            {
                /* This should be checked before everything */
                AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
                            "Failed in building adb object : "
                            "NULL elemenet can not be passed to deserialize");
                return AXIS2_FAILURE;
            }

            element = (axiom_element_t *)axiom_node_get_data_element(parent, env);

            ht = axiom_element_get_all_attributes(element, env);

            if (ht == NULL)
                return NULL;

            for (hi = axutil_hash_first(ht, env); hi; hi = axutil_hash_next(env, hi)) {
                axis2_char_t *localpart;
                axutil_hash_this(hi, NULL, NULL, &val);
                type_attr = (axiom_attribute_t *)val;
                localpart = axutil_qname_get_localpart(axiom_attribute_get_qname(type_attr, env), env);
                if (axutil_strcmp(localpart, "type") == 0) break;
            }

            type = axiom_attribute_get_value(type_attr, env);
            if (type != NULL && (temp = axutil_strchr(type, ':')) != NULL)
            {
                if (axutil_strchr(temp, ':') != NULL)
                    type = temp + 1; /* Pointer arithmetic */
            }

            return type;
        }

        axis2_char_t* AXIS2_CALL
        adb_type_get_type(const adb_type_t *object)
        {
            if (object != NULL)
              return object->property_Type;

            return NULL;
        }

        adb_type_t* AXIS2_CALL
        axis2_extension_mapper_create_from_node(
            const axutil_env_t *env,
            axiom_node_t** node,
            axis2_char_t *default_type)
        {
            axis2_char_t *type = axis2_extension_mapper_type_from_node(env, node);

            if (type != NULL)
            {
              // ここ
              BOOST_PP_SEQ_FOR_EACH(ADB_CREATE_MACRO, _, TYPE_LIST)
            }
            // ここ
            BOOST_PP_SEQ_FOR_EACH(ADB_CREATE_DEFAULT_MACRO, _, TYPE_LIST)

            return NULL;
        }

        axis2_status_t AXIS2_CALL
        axis2_extension_mapper_free(
            adb_type_t* _object,
            const axutil_env_t *env,
            axis2_char_t *default_type)
        {
            if (_object != NULL && adb_type_get_type(_object) != NULL)
            {
              // ここ
              BOOST_PP_SEQ_FOR_EACH(ADB_FREE_MACRO, _, TYPE_LIST)
            }
            // ここ
            BOOST_PP_SEQ_FOR_EACH(ADB_FREE_DEFAULT_MACRO, _, TYPE_LIST)

            return AXIS2_FAILURE;
        }

        axis2_status_t AXIS2_CALL
        axis2_extension_mapper_deserialize(
            adb_type_t* _object,
            const axutil_env_t *env,
            axiom_node_t** dp_parent,
            axis2_bool_t *dp_is_early_node_valid,
            axis2_bool_t dont_care_minoccurs,
            axis2_char_t *default_type)
        {
            if (_object != NULL && adb_type_get_type(_object) != NULL)
            {
                // ここ
                BOOST_PP_SEQ_FOR_EACH(ADB_DESERIALIZE_MACRO, _, TYPE_LIST)
            }
            // ここ
            BOOST_PP_SEQ_FOR_EACH(ADB_DESERIALIZE_DEFAULT_MACRO, _, TYPE_LIST)

            return AXIS2_FAILURE;
        }

        axiom_node_t* AXIS2_CALL
        axis2_extension_mapper_serialize(
            adb_type_t* _object,
            const axutil_env_t *env,
            axiom_node_t* om_node,
            axiom_element_t *om_element,
            int tag_closed,
            axutil_hash_t *namespaces,
            int *next_ns_index,
            axis2_char_t *default_type)
        {
            if (_object != NULL && adb_type_get_type(_object) != NULL)
            {
                // ここ
                BOOST_PP_SEQ_FOR_EACH(ADB_SERIALIZE_MACRO, _, TYPE_LIST) 
            }
            // ここ
            BOOST_PP_SEQ_FOR_EACH(ADB_SERIALIZE_DEFAULT_MACRO, _, TYPE_LIST) 

            return AXIS2_FAILURE;
        }
    

こういうのって、精神的に消耗しますね…

正常な前処理トークンとなりません

XML のスキーマ定義ファイルの要素名に日本語を使うやつがいて、そのおかげで、apache axis2 を使って、wsdlファイルからcソースを自動生成したのだが、ファイル名と変数名が日本語で出力されてしまった。ぬぉーーーっ、設計したやつ何考えとんじゃーと怒りながら、対策を考えた末、boost preprocessor で対処するのが一番だろうとテストしてみたが、一筋縄ではない。こういう設計した人に限って、別にXMLの仕様には反していませんよね？とか言いそうな気がして、ひとり、ぼやきまくっていた…。
　どこで詰まってるんやろ？と追試していると、どうやらマクロ展開する過程で、１回処理した直後に、規格通りかどうかのチェックが入っているからと推察する。

#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/stringize.hpp>

#define TYPE_LIST \
((システム,1))\
((x,2))\
((y,4))\
((z,3))

#define MACRO(r, data, elem) BOOST_PP_STRINGIZE(BOOST_PP_CAT(BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,elem), _hoge_),BOOST_PP_TUPLE_ELEM(2,1,elem)))

BOOST_PP_SEQ_FOR_EACH(MACRO, _, TYPE_LIST)

x.cpp:14:1: エラー: "�" と "_hoge_" を貼付けましたが正常な前処理トークンとなりません

　こいつを避けるためには、日本語部分は最初から文字列リテラルとして記述しておく必要がありそうだ。幸い、日本語部分の表現は、１種類につき2通りしかないので、BOOST_PP_TUPLE_ELEM で対処しても、そんなにしんどくなさそうだ。
UTF-8 が標準ならば…と、ちょっと考えてしまう一幕でした。

いろいろ

　iTunes の環境を Windows から MacBook に変更しました。家での環境は、まじめに MacBook をメインにしようと思っています。Scansnap は、mac バージョンを間違って買ったのですが、心のどこかで確信的間違えたのではないか？と思うようになりました。

本日は、「大震災の後で人生について語るということ」と「日本の未来について話そう」の２冊を購入した。G＋の方で紹介してもらった「虐殺器官」も、ちょい前にゲットした。どうでもいい事ですが、Web+DB 本屋に置いてなくて、がっくし...

ギリシャの暴動を見ていると、「ないものねだり論者」というのは、世界的な潮流なのではないか？と、同意したくなってきました。違和感を感じている部分と、同意したい部分と２通りあります。日本の震災の放射能に関する考え方の分断では、２通りの人間がいるという事なのかもしれないです。他人を心配する事で、安全とする人たちへの態度を硬化させるグループと、単純に文句を言うだけのグループです。前者の中にも、好きになれない例外の人はいますけど...。隣人への愛という点では、前者のグループも、そこからスタートしているので、そこを見間違えてはいけないと思います。それだけです。
隣国の韓国も、なかなかのものです。韓国の現状を見ていると、グローバル競争の元に、やりたいようにやったらLG電子やサムスンなど、市場を制覇する事ができたが、気がつけば、制覇した分だけ未曾有の借金が残っていて、LG電子は赤字転落で、液晶パネルの競争は国家的なダンピングだったのではないか？とも思えてきます。円高やべぇと騒いでたけども、実は白川総裁の考え方が正しくて、世界中の皆が間違っていたのでは？とも思えてきます。経済は雲をつかむようで、ほんと難しいです。世界経済もDQNが牛耳っていた？？？

カダフィ大佐の死体の写真を見ていて、スマートフォンに取り囲まれている様子が象徴的だと感じました。皆さんは、いかがでしょうか？拡散するのは、いいけれど、せめて、ワンクッション置いた方がいいとも思います。

追記:ひとの弱みにつけ込んで、商売するような人は、カウントしていません。

XMLを処理するのに…

Windows で C++ にて XML を処理しようと思ったら、考えられそうな選択肢がいくつかあります。

• LibXML2
• Expat
• MSXML
• TinyXML
• XMLLite
• Xerces-C++

そこで、なるべくならプラットフォームを固定して書きたくないので、MSXML と XMLLite が候補から外れます。
LibXML2 でやろうとしたら、ICU か iconv あたりをなんとかしないといけません。正直 iconv はmsvc でコンパイルするのが困難です。libiconv for windows ありますが、vc で、すんなりコンパイルが通りません。じゃあ ICU だわさ？って、ICUを使おうとすると、icu.lib が無いとか変なリンクエラーが出て萎えてしまいます。ICU も大げさな感じがして、使うのをちょっと躊躇われるのという事情もあります。
おまえ、選り好みが激しすぎと怒られそうですが、Xerces-C++ も、なんか、あんまり好きじゃないんです。
TinyXML もいいんですけど、ちょっと考えてしまう…（こんな事ばかり書いてると、いい加減に袋叩きにあいそう）。

そうすると残されたのは、Expat って事になります。ところが、この Expat って、SJIS に対応していないんですよね…。APIで日本語対応するって事も可能なんですが、なんというか、どうもしっくり来ない。XMLの構文を解析するついでに、文字コード変換もやりましょうという思想なんで、1文字か2文字づつコード変換の処理をしなきゃならない。これ、文字コード変換ライブラリのメンテナンスも考えたら、結構大変です。SJIS に限って言えば、SJIS第一バイトの場合は２バイト処理します。なんつーか、もやもや～とするんですよねー。

で、結論は何かと言うと、そもそも wchar_t が嫌い。これに尽きるんですわ。UTF-8 は、ほんと良く出来てると思います。

結局、自分の好みでやってくと、「文字コード変換」と「expatで遊ぼ」を組み合わせて、こんな感じになってしまいました。ただ、encoding の指定が全然関係ないやん…って部分が気に入りません。

#include <iostream>
#include <string>
#include <vector>
#include <expat.h>
#include <boost/shared_ptr.hpp>
#include <boost/foreach.hpp>

#include "codepage.hpp"
#include "wconv.hpp"

class xml_node;

class xml_node {
public:
  xml_node( const XML_Char* name ) : node_name_(name) {}
public:
  std::basic_string<XML_Char>  node_name_;
  std::basic_string<XML_Char>  node_value_;
  std::vector< boost::shared_ptr<xml_node> > childs_;
};


class xml_holder {
public:
  std::vector< boost::shared_ptr<xml_node> >  stack_;
  boost::shared_ptr<xml_node>  current_;
};

void starter(void* userData, const XML_Char* name, const XML_Char* attrs[]) {
  xml_holder* holder = reinterpret_cast<xml_holder*>(userData);
  holder->stack_.push_back( holder->current_ );
  boost::shared_ptr<xml_node> element( new xml_node( name ) );
  holder->current_->childs_.push_back( element );
  holder->current_ = element;
}

void ender( void* userData, const XML_Char* name) {
  xml_holder* holder = reinterpret_cast<xml_holder*>(userData);
  holder->current_ = holder->stack_.back();
  holder->stack_.pop_back();
}

void data( void* userData, const XML_Char* s, int len ) {
  xml_holder* holder = reinterpret_cast<xml_holder*>(userData);
  holder->current_->node_value_.assign( s, s + len );
}

void trace( int depth, boost::shared_ptr<xml_node> elem ) {
  for( int i = 0; i < depth; ++i ) { std::cout << " "; }
  std::cout << elem->node_name_ << ":" << code_to_code<CP_ACP,CP_UTF8>(elem->node_value_) << std::endl;
  BOOST_FOREACH( boost::shared_ptr<xml_node> e, elem->childs_ ) {
    trace( depth+1, e );
  }
}

bool parse_xml( const std::string& xml ) {
  xml_holder holder;
  holder.current_ = boost::shared_ptr<xml_node>( new xml_node( "root" ) );
  XML_Parser  parser = XML_ParserCreate("UTF-8");
  if( !parser ) return false;
  XML_SetUserData( parser, &holder );
  XML_SetElementHandler( parser, starter, ender );
  XML_SetCharacterDataHandler( parser, data );
  int iseof = 0;
  XML_Parse( parser, xml.c_str(), xml.size(), iseof );
  XML_ParserFree( parser );
  trace( 0, holder.current_ );
  return !iseof;
}

#include <fstream>

int main(int argc, char* argv[] ) {
  if( argc != 2 ) return 1;
  std::ifstream ifs( argv[1] );
  std::string xml;
  std::string line;
  while( ifs.good() ) {
    std::getline( ifs, line );
    xml += line;
    //std::cout << line << std::endl;
  }
  //std::cout << std::endl;

  parse_xml( code_to_code<CP_UTF8,CP_ACP>(xml) );

  return 0;
}

spirit::qi raw 習作

#include <iostream>
#include <boost/spirit/include/qi.hpp>


int main() {
  std::string src = "123456789";
  int a, b, c;
  
  namespace qi = boost::spirit::qi;
  bool result = qi::phrase_parse( 
    src.begin(), src.end(), 
    qi::raw[ qi::repeat(2)[qi::digit] ]
    >> qi::raw[ qi::digit >> qi::digit ]
    >> qi::int_
    ,
    qi::ascii::space,
    a, b, c
  );

  if( result )  std::cout << a << "," << b << "," << c << std::endl;
  else std::cout << "fault" << std::endl;

  return 0;
}

boost::range 習作３ (reference)

#include <boost/assign.hpp>
#include <boost/bind.hpp>
#include <limits>
#include <iostream>
#include <vector>
#include <boost/range/algorithm/for_each.hpp>
#include <boost/foreach.hpp>
#include <boost/ref.hpp>

struct minmax {
private:
  int max_;
  int min_;
public:
  minmax() : min_(std::numeric_limits<int>::max()), max_(std::numeric_limits<int>::min()) {}
  void operator() (int val) {
    min_ = std::min( min_, val );
    max_ = std::max( max_, val );
  }

  int get_min() const { return min_; }
  int get_max() const { return max_; }

};

int main(int argc, const char* argv[]) {
  using namespace boost::assign;

  std::vector<int> input;
  input += 1,2,3,4,5,6,7,8,9;

  {
    minmax mm;

    std::cout << "range foreach with functor" << std::endl;
    boost::for_each( input, mm );
    std::cout << mm.get_min() << "," << mm.get_max() << std::endl;
  }
  {
    minmax mm;
    std::cout << "range foreach with bind" << std::endl;
    boost::for_each( input, boost::bind( &minmax::operator(), &mm, _1 ) );
    std::cout << mm.get_min() << "," << mm.get_max() << std::endl;
  }
  {
    minmax mm;
    std::cout << "macro base foreach" << std::endl;
    BOOST_FOREACH( int val, input ) {
      mm( val );
    }
    std::cout << mm.get_min() << "," << mm.get_max() << std::endl;
  }
  return 0;
}

追記：これは、1,9 の集合を返す関数に変形すべき？

mod_auth_kerb で統合認証

1.構成について

ドメイン名：foo.local
ドメイン・コントローラ：dom1.foo.local, dom2.foo.local
DNSサーバ：dom1.foo.local, dom2.foo.local
大文字ドメイン名:FOO
Windows Server は 2003 Server 以上を想定して書いている。
これに対し、CentOS で Apache環境を構築し、連帯する

2.必要モジュールのインストール

$ yum install mod_auth_kerb

3.Windows Domain Server 上での作業

ドメインのユーザとして、kerblinux1というアカウントを作成します。このアカウントは、統合認証のためだけに使用されるので、パスワードを入力する事がありません。よって、パスワードは長くして耐久性を持たせるようにします。

C:\>ktpass 
 –princ HTTP/linux1.foo.local@FOO.LOCAL 
 –mapuser kerblinux1@FOO.LOCAL
 -crypto RC4-HMAC-NT
 -ptype KRB5_NT_PRINCIPAL
 -pass nagai.nagai.password.wo.sextutei.suru
 -out e:\USBDISK\linux1.keytab

として、統合認証で必要なアカウントのkeytabファイルを作成します。

4.Kerberos設定

/etc/krb5.confを設定します。

[libdefaults]
 default_realm = FOO.LOCAL
 dns_lookup_realm = false
 dns_lookup_kdc = false
 ticket_life_time = 24h
 forwardable = yes

[domain_realm]
 foo.local = FOO.LOCAL
 .foo.local = FOO.LOCAL

[realms]
      # 実験した環境では、dom1.foo.local とURIをフル修飾すると
      # サーバを正しく認識しなかった。
 FOO.LOCAL = {
  kdc = dom1
  kdc = dom2
  admin_server = dom1
 }

手順 3. で作成した linux1.keytab ファイルを /etc/httpd/conf にコピーします。

$ cp /usbdisk/linux1.keytab /etc/httpd/conf/linux1.keytab
$ chown apache:apache /etc/httpd/conf/linux1.keytab
$ chmod 640 /etc/httpd/conf/linux1.keytab

実際にケルベロス認証が通るかチェックを行います。valid_user は、実際の有効なアカウントに置き換えて試します。

$ kinit valid_user@FOO.LOCAL

5.Active DirectoryでのSSPI認証

認証すべきディレクトリに、以下の設定を施します。ここでは、”.htaccess”というファイルを作成し、そこに制約を加える事にします。この他に、httpd.conf のディレクティブとして記述する方法もありますが、基本は変わりません。

AuthType           Kerberos
AuthName           "Kerberos Login"
KrbAuthRealms      FOO.LOCAL
KrbServiceName     HTTP/linux1.foo.local
KrbMethodNegotiate On
KrbMethodK5Passwd  Off
Krb5KeyTab         /etc/httpd/conf/linux1.keytab
Require            valid-user

これで、「統合Windows認証を使用する」設定になっている(IEデフォルトのようです)Internet Explorerからアクセスすると統合認証でアクセスされるようになります。尚、ゾーンがイントラゾーンかどうかの判定には、URL に「.」が含まれているかどうか？が基準となっているようです。よって、本例では、「http://linux1.foo.local/」ではなく「http://linux1/」でアクセスしないとシングルサインオンになりません。

6．認証後のアクセス制限に関して

　mod_auth_kerbによる統合認証では、認証が通っても、あくまでActiveDirectoryに認証してもらった正規のユーザ名の情報がセットされるのみです。ウェブ上のシステムでは、このユーザ名をキーとして、権限の制約を別途管理する事になります。


参考文献
http://grolmsnet.de/kerbtut/
http://www.dokuwiki.org/auth:ad


追伸：Bloggerプレビューできねぇーぜ、どうやって確認すんねん？？？くっそー

もやもやっと

　なんとなくですが、「当事者性ｖｓないものねだり論者」の云わんとする事がわかった気がした。要するに、お客様感覚が抜けずに、ダダをこねるだけの人が多いのだ。実際に行動を起こさなければならないのだが、そこへの思慮が欠けている。今の時代、経営者感覚が求められる時代なのだが、想像力も無ければ思考も足りないのだ。知者ではあるけども、賢者ではない。まぁ、実際に問題を解決するためには、何か行動を起こさなければならないので、知者から愚者と批判されるかもしれんが・・・。
　焼却灰や下水道の高レベル放射能セシウム１３７＋１３４は、どこかに破棄しなければならない。原発事故を起こした「ふくいち」近辺にまとめるのが、客観的にみて最も妥当な方法であると思うのだが、福島県民は嫌だと大多数の人が反対しているという。半数はセシウム１３４だとして、半分の量は無視したとして、半減期３０年なので、＊万ベクレルの下水汚泥であれば、1/2~10 = 1/1024 すれば、だいたいの人に害が無いレベルまで落ちる。その間、同様に汚染されすぎた土地を除染するのは、並大抵の事ではないし、わざわざ汚染されていない土地に放射能を運ぶのは、経済的に見てもリスク的に見ても、全く非効率きわまる。誰かが、こういう事は、きちんと説明してやらなければならない。
　気に入らないという理由で絡んでくる人は、エネルギーを費やすベクトルが違っているのだ。

　こういう理解をした上で、あえて「当事者性ｖｓないものねだり論者」論は、３割ほど有害だと感じている。まず、みんなの言う事は、間違っているように見えて、案外正しいのである。内田樹先生の「陰謀史観」も、何の事を指して言っているのか、私にはサッパリわからない。これこそ話を単純化しすぎではないか？

もやっと

　ここんところ、ほとんど、独り言に近い、とりとめのない事ばっかり書いてます。こういうのって、後から読むと、あんまし面白くないんですが…（汗）

　今日は本屋に行って「Googleの脳みそ」と、「Unity入門」を買ってきました。「Googleの脳みそ」は、本屋で手に取った瞬間にピンときました。3.11以後、非常に残念な論調が多くてゲンナリしている所なので、感情論では無い視点から、今を読んでみたかったのでチョイスしました。「Unity入門」の方は、完全に趣味です。ゲームを開発しようとか、そんな事、全く考えていません。癒しのための写経本にするつもりです。時間無いかもしんないけど…。

　Google+ つながりが面白いけど、正直SNSは、自分には向いていないかもしれない(^^;。どうなんだろ…？実際のGoogle+の使われ方と、Googleが想定して設計した使われ方が違うような気がしています。

　Google では、同じ志向を持った人がサークルで繋がって、切り分けていく世界をデザインしたと思ってます。だから、基本は繋がる人は何らかの知人で、どの分野で繋がりたいかユーザは知っているという前提が成立しているはずです。
　ところが、実際に使っている人は twitter と似た感覚で、この人面白そうだからフォローしてみようという感覚が強いと感じてます。こちらからフォローをする前に、どのサークルに入れたら良いものか、もの凄く判断に悩みます。まさか、IT系の話で盛り上がりたい人に、バリバリのプログラミングの話題を投稿するのは気が引けるので、基本情報やストリームを見て判断してますが、わかんねぇです…。

　もひとつ迷うのが、どこに向けて投稿しようか？って事。基本はブログに書いていくつもりです。なので、Google+での発言のS/N比は、どうしても落ちちゃう。ここは、ブログをしている人と、していない人で発信能力に格差が出てくるのかなぁーと…。ブログにポストした事を転送するのも手ですが、それじゃーGoogle+をする意味が無い。

Symfony2勉強中

　訳あって、Symfony2を勉強してます。いろいろとフレームワークを見てきましたが、Symfony2は、なかなかよくできている感触を得てます。メタキャッシュの機構も優れている感じで、twigも書きやすいのかなぁと。

　今のところ使う予定は無いですが、mongodbにも対応しています。

　と、近況を書きましたが、本当は、ここからが本題だったりして・・・
放射能の問題は静観する事にしました。５年は結論が出ないだろうと考えてます。私は当事者では無いので、語る資格などないのでしょう。色々な意見を見ますが、読むにつけて、呆れると共に嫌な気分になります。せめてデータだけは、ちゃんと取って検証できるようにしてもらいたいものです。現代は、データ実証主義です。データなんか取っても無駄という思考ではなく、まずはデータを取ってみよう、そこから何がわかるか、検証してみよう・・・です。