extattr 0.1-x86-mingw32

data/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2012, dearblue. All rights reserved.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+conditions are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in
+   the documentation and/or other materials provided with the
+   distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.txt

@@ -0,0 +1,53 @@
+= extattr
+
+extattr is extended attribute operation library for Windows and FreeBSD.
+
+----
+
+extattr は拡張属性を操作するライブラリで、Windows、FreeBSD に対応しています (GNU/Linux はコードを書いてみただけで、試験がまったくされていません)。
+
+サポートされる環境で、統一的なメソッドを提供します。
+
+クラスメソッドに『!』がついているものはシンボリックリンクに対する操作となります。
+
+キーワード引数の <code>namespace</code> を与えると、拡張属性の名前空間を指定できます。規定値は <code>EXTATTR_NAMESPACE_USER</code> で、ほかの値は <code>EXTATTR_NAMESPACE_SYSTEM</code> のみが指定できます (Windows 版では <code>EXTATTR_NAMESPACE_USER</code> のみが指定可能です)。
+
+
+== 拡張属性の属性名を取得:
+
+- File#extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) -> array
+- File.extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) -> array
+- File.extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) -> array
+
+== 拡張属性の要素の大きさを取得:
+
+- File#extattr_size(name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+- File.extattr_size(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+- File.extattr_size!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+
+== 拡張属性の要素を取得:
+
+- File#extattr_get(name, namespace: File::EXTATTR_NAMESPACE_USER) -> data (String)
+- File.extattr_get(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> data (String)
+- File.extattr_get!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> data (String)
+
+== 拡張属性の要素を設定:
+
+- File#extattr_set(name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+- File.extattr_set(path, name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+- File.extattr_set!(path, name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+
+== 拡張属性の要素を削除:
+
+- File#extattr_delete(name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+- File.extattr_delete(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+- File.extattr_delete!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+
+
+== Microsoft Windows における諸注意
+
+Windows 2000 以降でのみ動作します。Windows 9X シリーズでは <code>require "extattr"</code> の段階で例外が発生するでしょう。
+
+リパースポイント (ジャンクションやシンボリックリンク) に対する ADS は要素の取得や設定、削除は出来ません。必ずリンク先に対する操作となります。
+
+128 KiB を超える ADS は取得も設定も出来ません。これは『拡張属性』と捉えた場合、巨大なデータを扱えるべきではないという考えによるためです (本当のところは FreeBSD の拡張属性が最大 64KiB 弱であることが由来です)。巨大な ADS を扱いたい場合は、File.open で自由に読み書きできます (これは ruby に限ったことではなく、Windows による仕様です)。この場合の与えるファイル名は、path + ":" + name という形になります。

data/ext/extattr.bsd

@@ -0,0 +1,186 @@
+#include <sys/types.h>
+#include <sys/extattr.h>
+
+
+static void
+split_name(const char list[], size_t size, void (*func)(void *, VALUE), void *userdata)
+{
+    // Each list entry consists of a single byte containing the length of
+    // the attribute name, followed by the attribute name.
+    // The attribute name is not terminated by ASCII 0 (nul).
+    const char *ptr = list;
+    const char *end = list + size;
+
+    while (ptr < end) {
+        size_t len = (uint8_t)*ptr ++;
+        if (ptr + len > end) { return; }
+        func(userdata, rb_str_new(ptr, len));
+        ptr += len;
+    }
+}
+
+static int
+get_extattr_list_size(int (*extattr_list)(), intptr_t d, int namespace)
+{
+    int size = extattr_list(d, namespace, NULL, 0);
+    if (size < 0) { rb_sys_fail("extattr_list call error"); }
+    return size;
+}
+
+static VALUE
+extattr_list0(int (*extattr_list)(), intptr_t d, int namespace)
+{
+    size_t size = get_extattr_list_size(extattr_list, d, namespace);
+    VALUE buf = rb_str_buf_new(size);
+    char *ptr = RSTRING_PTR(buf);
+
+    ssize_t size1 = extattr_list(d, namespace, ptr, size);
+    if (size1 < 0) { rb_sys_fail("extattr_list call error"); }
+
+    VALUE list = Qnil;
+    if (rb_block_given_p()) {
+        split_name(ptr, size1, (void (*)(void *, VALUE))rb_yield_values, (void *)(1));
+    } else {
+        list = rb_ary_new();
+        split_name(ptr, size1, (void (*)(void *, VALUE))rb_ary_push, (void *)list);
+    }
+    rb_free_tmp_buffer(&buf);
+
+    return list;
+}
+
+static VALUE
+file_extattr_list0(VALUE file, int fd, int namespace)
+{
+    return extattr_list0(extattr_list_fd, fd, namespace);
+}
+
+static VALUE
+file_s_extattr_list0(VALUE path, int namespace)
+{
+    return extattr_list0(extattr_list_file, (intptr_t)StringValueCStr(path), namespace);
+}
+
+static VALUE
+file_s_extattr_list_link0(VALUE path, int namespace)
+{
+    return extattr_list0(extattr_list_link, (intptr_t)StringValueCStr(path), namespace);
+}
+
+
+static VALUE
+extattr_size0(int (*extattr_get)(), intptr_t d, int namespace, VALUE name)
+{
+    ssize_t size = extattr_get(d, namespace, RSTRING_PTR(name), NULL, 0);
+    if (size < 0) { rb_sys_fail("extattr_get call error"); }
+    return SIZET2NUM(size);
+}
+
+static VALUE
+file_extattr_size0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return extattr_size0(extattr_get_fd, fd, namespace, name);
+}
+
+static VALUE
+file_s_extattr_size0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_size0(extattr_get_file, (intptr_t)StringValueCStr(path), namespace, name);
+}
+
+static VALUE
+file_s_extattr_size_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_size0(extattr_get_link, (intptr_t)StringValueCStr(path), namespace, name);
+}
+
+
+static VALUE
+extattr_get0(int (*extattr_get)(), intptr_t d, VALUE path, int namespace, VALUE name)
+{
+    ssize_t size = extattr_get(d, namespace, RSTRING_PTR(name), NULL, 0);
+    if (size < 0) { rb_sys_fail(StringValueCStr(path)); }
+    VALUE buf = rb_str_buf_new(size);
+    size = extattr_get(d, namespace, RSTRING_PTR(name), RSTRING_PTR(buf), size);
+    if (size < 0) { rb_sys_fail(StringValueCStr(path)); }
+    rb_str_set_len(buf, size);
+    return buf;
+}
+
+static VALUE
+file_extattr_get0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return extattr_get0(extattr_get_fd, fd, RFILE(file)->fptr->pathv, namespace, name);
+}
+
+static VALUE
+file_s_extattr_get0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_get0(extattr_get_file, (intptr_t)StringValueCStr(path), path, namespace, name);
+}
+
+static VALUE
+file_s_extattr_get_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_get0(extattr_get_link, (intptr_t)StringValueCStr(path), path, namespace, name);
+}
+
+
+static VALUE
+extattr_set0(int (*extattr_set)(), intptr_t d, int namespace, VALUE name, VALUE data)
+{
+    int status = extattr_set(d, namespace, RSTRING_PTR(name), RSTRING_PTR(data), RSTRING_LEN(data));
+    if (status < 0) { rb_sys_fail("extattr_set call error"); }
+    return Qnil;
+}
+
+static VALUE
+file_extattr_set0(VALUE file, int fd, int namespace, VALUE name, VALUE data)
+{
+    return extattr_set0(extattr_set_fd, fd, namespace, name, data);
+}
+
+static VALUE
+file_s_extattr_set0(VALUE path, int namespace, VALUE name, VALUE data)
+{
+    return extattr_set0(extattr_set_file, (intptr_t)StringValueCStr(path), namespace, name, data);
+}
+
+static VALUE
+file_s_extattr_set_link0(VALUE path, int namespace, VALUE name, VALUE data)
+{
+    return extattr_set0(extattr_set_link, (intptr_t)StringValueCStr(path), namespace, name, data);
+}
+
+
+static VALUE
+extattr_delete0(int (*extattr_delete)(), intptr_t d, int namespace, VALUE name)
+{
+    int status = extattr_delete(d, namespace, RSTRING_PTR(name), NULL, 0);
+    if (status < 0) { rb_sys_fail("extattr_delete call error"); }
+    return Qnil;
+}
+
+static VALUE
+file_extattr_delete0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return extattr_delete0(extattr_delete_fd, fd, namespace, name);
+}
+
+static VALUE
+file_s_extattr_delete0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_delete0(extattr_delete_file, (intptr_t)StringValueCStr(path), namespace, name);
+}
+
+static VALUE
+file_s_extattr_delete_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_delete0(extattr_delete_link, (intptr_t)StringValueCStr(path), namespace, name);
+}
+
+
+static void
+setup(void)
+{
+}

data/ext/extattr.c

@@ -0,0 +1,345 @@
+/* encoding:utf-8 */
+
+/*
+ * extattr.c
+ * AUTHOR:: dearblue <dearblue@zoho.com>
+ * LICENSE:: 2-clause BSD License
+ * WWW:: http://sourceforge.jp/projects/rutsubo
+ */
+
+#include <ruby.h>
+#include <ruby/io.h>
+#include <ruby/intern.h>
+
+
+static VALUE file_extattr_list0(VALUE file, int fd, int namespace);
+static VALUE file_extattr_size0(VALUE file, int fd, int namespace, VALUE name);
+static VALUE file_extattr_get0(VALUE file, int fd, int namespace, VALUE name);
+static VALUE file_extattr_set0(VALUE file, int fd, int namespace, VALUE name, VALUE data);
+static VALUE file_extattr_delete0(VALUE file, int fd, int namespace, VALUE name);
+static VALUE file_s_extattr_list0(VALUE path, int namespace);
+static VALUE file_s_extattr_list_link0(VALUE path, int namespace);
+static VALUE file_s_extattr_size0(VALUE path, int namespace, VALUE name);
+static VALUE file_s_extattr_size_link0(VALUE path, int namespace, VALUE name);
+static VALUE file_s_extattr_get0(VALUE path, int namespace, VALUE name);
+static VALUE file_s_extattr_get_link0(VALUE path, int namespace, VALUE name);
+static VALUE file_s_extattr_set0(VALUE path, int namespace, VALUE name, VALUE data);
+static VALUE file_s_extattr_set_link0(VALUE path, int namespace, VALUE name, VALUE data);
+static VALUE file_s_extattr_delete0(VALUE path, int namespace, VALUE name);
+static VALUE file_s_extattr_delete_link0(VALUE path, int namespace, VALUE name);
+
+// Init_extattr から呼び出される、環境ごとの初期設定。
+static void setup(void);
+
+
+#define RDOC(...)
+
+#define ELEMENTOF(V) (sizeof(V) / sizeof((V)[0]))
+
+
+static inline VALUE
+hash_lookup(VALUE hash, VALUE key, VALUE default_value)
+{
+    if (NIL_P(hash)) {
+        return default_value;
+    } else if (rb_obj_is_kind_of(hash, rb_cHash)) {
+        return rb_hash_lookup2(hash, key, default_value);
+    } else {
+        rb_raise(rb_eTypeError, "not hash");
+    }
+}
+
+static inline int
+file2fd(VALUE file)
+{
+    rb_io_t *fptr;
+    // FIXME: ファイルであることを確認すべき
+    GetOpenFile(file, fptr);
+    return fptr->fd;
+}
+
+
+#if defined(HAVE_SYS_EXTATTR_H)
+#   include "extattr.bsd"
+#elif defined(HAVE_ATTR_XATTR_H)
+#   include "extattr.linux"
+#elif defined(HAVE_WINNT_H)
+#   include "extattr.windows"
+#else
+#   error ruby extattr not supported on your system
+#endif
+
+
+static VALUE SYMnamespace;
+
+
+/*
+ * call-seq:
+ * file.extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ * file.extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
+ *
+ * 開いているファイルの拡張属性名一覧を得ます。
+ *
+ * ブロックが指定された場合、一つ一つの拡張属性名を渡してブロックが評価されます。ブロックの戻り値は無視されます。
+ */
+static VALUE
+file_extattr_list(int argc, VALUE argv[], VALUE file)
+{
+    VALUE opts = Qnil;
+    rb_scan_args(argc, argv, "0:", &opts);
+    return file_extattr_list0(file, file2fd(file),
+                              NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))));
+}
+
+/*
+ * call-seq:
+ * File.extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ * File.extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
+ *
+ * ファイル名を指定すること以外は File#extattr_list と同じです。
+ */
+static VALUE
+file_s_extattr_list(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, opts = Qnil;
+    rb_scan_args(argc, argv, "1:", &path, &opts);
+    return file_s_extattr_list0(StringValue(path),
+                                NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))));
+}
+
+/*
+ * call-seq:
+ * File.extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ * File.extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
+ *
+ * シンボリックリンクに対する操作という以外は、File.extattr_list と同じです。
+ */
+static VALUE
+file_s_extattr_list_link(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, opts = Qnil;
+    rb_scan_args(argc, argv, "1:", &path, &opts);
+    return file_s_extattr_list_link0(StringValue(path),
+                                     NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))));
+}
+
+
+/*
+ * call-seq:
+ * file.extattr_size(name, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ *
+ * 拡張属性の大きさを取得します。
+ */
+static VALUE
+file_extattr_size(int argc, VALUE argv[], VALUE file)
+{
+    VALUE name, opts = Qnil;
+    rb_scan_args(argc, argv, "1:", &name, &opts);
+    return file_extattr_size0(file, file2fd(file),
+                              NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                              StringValue(name));
+}
+
+/*
+ * call-seq:
+ * File.extattr_size(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+ */
+static VALUE
+file_s_extattr_size(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, opts = Qnil;
+    rb_scan_args(argc, argv, "2:", &path, &name, &opts);
+    return file_s_extattr_size0(StringValue(path),
+                                NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                StringValue(name));
+}
+
+/*
+ * call-seq:
+ * File.extattr_size!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+ */
+static VALUE
+file_s_extattr_size_link(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, opts = Qnil;
+    rb_scan_args(argc, argv, "2:", &path, &name, &opts);
+    return file_s_extattr_size_link0(StringValue(path),
+                                     NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                     StringValue(name));
+}
+
+
+/*
+ * call-seq:
+ * file.extattr_get(name, namespace: File::EXTATTR_NAMESPACE_USER) -> data
+ */
+static VALUE
+file_extattr_get(int argc, VALUE argv[], VALUE file)
+{
+    VALUE name, opts = Qnil;
+    rb_scan_args(argc, argv, "1:", &name, &opts);
+    return file_extattr_get0(file, file2fd(file),
+                             NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                             StringValue(name));
+}
+
+/*
+ * call-seq:
+ * File.extattr_get(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> data
+ */
+static VALUE
+file_s_extattr_get(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, opts = Qnil;
+    rb_scan_args(argc, argv, "2:", &path, &name, &opts);
+    return file_s_extattr_get0(StringValue(path),
+                               NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                               StringValue(name));
+}
+
+/*
+ * call-seq:
+ * File.extattr_get!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> data
+ */
+static VALUE
+file_s_extattr_get_link(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, opts = Qnil;
+    rb_scan_args(argc, argv, "2:", &path, &name, &opts);
+    return file_s_extattr_get_link0(StringValue(path),
+                                    NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                    StringValue(name));
+}
+
+
+/*
+ * call-seq:
+ * file.extattr_set(name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ */
+static VALUE
+file_extattr_set(int argc, VALUE argv[], VALUE file)
+{
+    VALUE name, data, opts = Qnil;
+    rb_scan_args(argc, argv, "11:", &name, &data, &opts);
+    return file_extattr_set0(file, file2fd(file),
+                             NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                             StringValue(name),
+                             StringValue(data));
+}
+
+/*
+ * call-seq:
+ * File.extattr_set(path, name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ */
+static VALUE
+file_s_extattr_set(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, data, opts = Qnil;
+    rb_scan_args(argc, argv, "21:", &path, &name, &data, &opts);
+    return file_s_extattr_set0(StringValue(path),
+                               NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                               StringValue(name),
+                               StringValue(data));
+}
+
+/*
+ * call-seq:
+ * File.extattr_set!(path, name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ */
+static VALUE
+file_s_extattr_set_link(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, data, opts = Qnil;
+    rb_scan_args(argc, argv, "21:", &path, &name, &data, &opts);
+    return file_s_extattr_set_link0(StringValue(path),
+                                    NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                    StringValue(name),
+                                    StringValue(data));
+}
+
+
+/*
+ * call-seq:
+ * file.extattr_delete(name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ */
+static VALUE
+file_extattr_delete(int argc, VALUE argv[], VALUE file)
+{
+    VALUE name, opts = Qnil;
+    rb_scan_args(argc, argv, "1:", &name, &opts);
+    return file_extattr_delete0(file, file2fd(file),
+                                NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                StringValue(name));
+}
+
+/*
+ * call-seq:
+ * File.extattr_delete(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ */
+static VALUE
+file_s_extattr_delete(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, opts = Qnil;
+    rb_scan_args(argc, argv, "2:", &path, &name, &opts);
+    return file_s_extattr_delete0(StringValue(path),
+                                  NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                  StringValue(name));
+}
+
+/*
+ * call-seq:
+ * File.extattr_delete!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ */
+static VALUE
+file_s_extattr_delete_link(int argc, VALUE argv[], VALUE file)
+{
+    VALUE path, name, opts = Qnil;
+    rb_scan_args(argc, argv, "2:", &path, &name, &opts);
+    return file_s_extattr_delete_link0(StringValue(path),
+                                       NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER))),
+                                       StringValue(name));
+}
+
+
+/*
+ * Document-class: File
+ *
+ * File クラスに拡張属性を操作するメソッドを追加します。
+ *
+ * 感嘆符(『!』)のついたメソッドは、シンボリックリンクに対する操作となります。
+ *
+ * メソッドにキーワード引数として <code>namespace:</code> を与えることにより、拡張属性の名前空間を指定することが出来ます。
+ * 現在の実装においては <code>EXTATTR_NAMESPACE_USER</code> と <code>EXTATTR_NAMESPACE_SYSTEM</code> のみが利用可能です。
+ */
+
+
+void
+Init_extattr(void)
+{
+    SYMnamespace = ID2SYM(rb_intern("namespace"));
+
+    rb_const_set(rb_cFile, rb_intern("EXTATTR_NAMESPACE_USER"), INT2NUM(EXTATTR_NAMESPACE_USER));
+    rb_const_set(rb_cFile, rb_intern("EXTATTR_NAMESPACE_SYSTEM"), INT2NUM(EXTATTR_NAMESPACE_SYSTEM));
+
+    rb_define_method(rb_cFile, "extattr_list", RUBY_METHOD_FUNC(file_extattr_list), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_list", RUBY_METHOD_FUNC(file_s_extattr_list), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_list!", RUBY_METHOD_FUNC(file_s_extattr_list_link), -1);
+
+    rb_define_method(rb_cFile, "extattr_size", RUBY_METHOD_FUNC(file_extattr_size), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_size", RUBY_METHOD_FUNC(file_s_extattr_size), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_size!", RUBY_METHOD_FUNC(file_s_extattr_size_link), -1);
+
+    rb_define_method(rb_cFile, "extattr_get", RUBY_METHOD_FUNC(file_extattr_get), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_get", RUBY_METHOD_FUNC(file_s_extattr_get), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_get!", RUBY_METHOD_FUNC(file_s_extattr_get_link), -1);
+
+    rb_define_method(rb_cFile, "extattr_set", RUBY_METHOD_FUNC(file_extattr_set), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_set", RUBY_METHOD_FUNC(file_s_extattr_set), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_set!", RUBY_METHOD_FUNC(file_s_extattr_set_link), -1);
+
+    rb_define_method(rb_cFile, "extattr_delete", RUBY_METHOD_FUNC(file_extattr_delete), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_delete", RUBY_METHOD_FUNC(file_s_extattr_delete), -1);
+    rb_define_singleton_method(rb_cFile, "extattr_delete!", RUBY_METHOD_FUNC(file_s_extattr_delete_link), -1);
+
+    setup();
+}

data/ext/extattr.linux

@@ -0,0 +1,209 @@
+#include <sys/types.h>
+#include <attr/xattr.h>
+
+#define EXTATTR_NAMESPACE_USER 0
+#define EXTATTR_NAMESPACE_SYSTEM 1
+
+static VALUE NAMESPACE_USER_PREFIX, NAMESPACE_SYSTEM_PREFIX;
+
+
+static VALUE
+extattr_list0(ssize_t (*func)(), void *d, int namespace)
+{
+    ssize_t size = 65536;
+    VALUE buf = rb_str_buf_new(size);
+    char *ptr = RSTRING_PTR(buf);
+    size = func(d, ptr, size);
+    if (size < 0) { rb_sys_fail("listxattr call error"); }
+
+    VALUE (*reduce)(void *, VALUE);
+    void *first;
+    VALUE list;
+    if (rb_block_given_p()) {
+        reduce = (VALUE (*)(void *, VALUE))rb_yield_values;
+        first = (void *)1;
+        list = Qnil;
+    } else {
+        reduce = (VALUE (*)(void *, VALUE))rb_ary_push;
+        first = (void *)(list = rb_ary_new());
+    }
+
+    const char *end = ptr + size;
+    while (ptr < end) {
+        int len = strlen(ptr);
+        VALUE name;
+        if (namespace == EXTATTR_NAMESPACE_USER && len > 5 && strncmp(ptr, "user.", 5) == 0) {
+            ptr += 5;
+        } else if (namespace == EXTATTR_NAMESPACE_SYSTEM && len > 7 && strncmp(ptr, "system.", 7) == 0) {
+            ptr += 7;
+        } else {
+            ptr += len + 1;
+            continue;
+        }
+
+        name = rb_str_new_cstr(ptr);
+        reduce(first, name);
+        ptr += RSTRING_LEN(name) + 1; // 最後の『+1』は、ヌルバイトの分。
+    }
+
+    return list;
+}
+
+static VALUE
+file_extattr_list0(VALUE file, int fd, int namespace)
+{
+    return extattr_list0(flistxattr, (void *)fd, namespace);
+}
+
+static VALUE
+file_s_extattr_list0(VALUE path, int namespace)
+{
+    return extattr_list0(listxattr, StringValueCStr(path), namespace);
+}
+
+static VALUE
+file_s_extattr_list_link0(VALUE path, int namespace)
+{
+    return extattr_list0(llistxattr, StringValueCStr(path), namespace);
+}
+
+
+static VALUE
+xattr_name(int namespace, VALUE name)
+{
+    switch (namespace) {
+    case EXTATTR_NAMESPACE_USER:
+        return rb_str_plus(NAMESPACE_USER_PREFIX, name);
+    case EXTATTR_NAMESPACE_SYSTEM:
+        return rb_str_plus(NAMESPACE_SYSTEM_PREFIX, name);
+    default:
+        rb_raise(rb_eRuntimeError, "namespace error");
+        return Qnil;
+    }
+}
+
+static VALUE
+extattr_size0(ssize_t (*func)(), void *d, int namespace, VALUE name)
+{
+    name = xattr_name(namespace, name);
+    ssize_t size = func(d, StringValueCStr(name), NULL, 0);
+    if (size < 0) { rb_sys_fail("getxattr call error"); }
+    return SSIZET2NUM(size);
+}
+
+static VALUE
+file_extattr_size0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return extattr_size0(fgetxattr, (void *)fd, namespace, name);
+}
+
+static VALUE
+file_s_extattr_size0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_size0(getxattr, StringValueCStr(path), namespace, name);
+}
+
+static VALUE
+file_s_extattr_size_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_size0(lgetxattr, StringValueCStr(path), namespace, name);
+}
+
+
+static VALUE
+extattr_get0(ssize_t (*func)(), void *d, int namespace, VALUE name)
+{
+    name = xattr_name(namespace, name);
+    ssize_t size = 65536;
+    VALUE buf = rb_str_buf_new(size);
+    char *ptr = RSTRING_PTR(buf);
+    size = func(d, StringValueCStr(name), ptr, size);
+    if (size < 0) { rb_sys_fail("getxattr call error"); }
+    rb_str_set_len(buf, size);
+    return buf;
+}
+
+static VALUE
+file_extattr_get0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return extattr_get0(fgetxattr, (void *)fd, namespace, name);
+}
+
+static VALUE
+file_s_extattr_get0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_get0(getxattr, StringValueCStr(path), namespace, name);
+}
+
+static VALUE
+file_s_extattr_get_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_get0(lgetxattr, StringValueCStr(path), namespace, name);
+}
+
+
+static VALUE
+extattr_set0(int (*func)(), void *d, int namespace, VALUE name, VALUE data)
+{
+    name = xattr_name(namespace, name);
+    int status = func(d, StringValueCStr(name), RSTRING_PTR(data), RSTRING_LEN(data));
+    if (status < 0) { rb_sys_fail("getxattr call error"); }
+    return Qnil;
+}
+
+static VALUE
+file_extattr_set0(VALUE file, int fd, int namespace, VALUE name, VALUE data)
+{
+    return extattr_set0(fsetxattr, (void *)fd, namespace, name, data);
+}
+
+static VALUE
+file_s_extattr_set0(VALUE path, int namespace, VALUE name, VALUE data)
+{
+    return extattr_set0(setxattr, StringValueCStr(path), namespace, name, data);
+}
+
+static VALUE
+file_s_extattr_set_link0(VALUE path, int namespace, VALUE name, VALUE data)
+{
+    return extattr_set0(lsetxattr, StringValueCStr(path), namespace, name, data);
+}
+
+
+static VALUE
+extattr_delete0(int (*func)(), void *d, int namespace, VALUE name)
+{
+    name = xattr_name(namespace, name);
+    int status = func(d, StringValueCStr(name));
+    if (status < 0) { rb_sys_fail("removexattr call error"); }
+    return Qnil;
+}
+
+static VALUE
+file_extattr_delete0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return extattr_delete0(fremovexattr, (void *)fd, namespace, name);
+}
+
+static VALUE
+file_s_extattr_delete0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_delete0(removexattr, StringValueCStr(path), namespace, name);
+}
+
+static VALUE
+file_s_extattr_delete_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_delete0(lremovexattr, StringValueCStr(path), namespace, name);
+}
+
+
+static void
+setup(void)
+{
+    NAMESPACE_USER_PREFIX = rb_str_new_cstr("user.");
+    NAMESPACE_SYSTEM_PREFIX = rb_str_new_cstr("system.");
+
+    rb_gc_register_mark_object(NAMESPACE_USER_PREFIX);
+    rb_gc_register_mark_object(NAMESPACE_SYSTEM_PREFIX);
+}

data/ext/extattr.windows

@@ -0,0 +1,407 @@
+#include <windows.h>
+#include <windowsx.h>
+#include <winnt.h>
+#include <ddk/ntifs.h>
+#include <ddk/winddk.h>
+#include <ntdef.h>
+#include <psapi.h>
+#include <wchar.h>
+
+#define EXTATTR_NAMESPACE_USER 0
+#define EXTATTR_NAMESPACE_SYSTEM 1
+
+/*
+ * ADS は普通のファイルのように扱えるから、extattr とみなして扱う場合は容量の制限を設けることにする。
+ * ruby-extattr で不十分な巨大なデータを扱う場合は File.open で開くことが出来るので必要であればそちらで。
+ * TODO: 最適値を探すべき
+ */
+static const size_t EXTATTR_MAX = 131072;
+
+/*
+ * TODO: バッファサイズの確保量が結構大きめ。最適化をするべき。
+ * TODO: CloseHandle してないところがありすぎ。修正。
+ * TODO: Win9X シリーズだとこのライブラリ読み込みすら出来ない。
+ *       メソッド定義だけは行うようにするべき? (実際に呼び出したら NotImpError 例外を投げる)
+ * リパースポイントって、ADSはつけられないのかな? 操作方法がわからない。
+ */
+
+
+static rb_encoding *ENCutf8p;
+static VALUE ENCutf8;
+static rb_encoding *ENCutf16lep;
+static VALUE ENCutf16le;
+
+
+
+
+static VALUE
+str2wcs(VALUE str)
+{
+    str = rb_str_encode(str, ENCutf16le, 0, Qnil);
+    rb_str_buf_cat(str, "\0", 1);
+    return str;
+}
+
+static VALUE
+str2wpath(VALUE str)
+{
+    str = str2wcs(str);
+    wchar_t *p = (wchar_t *)RSTRING_PTR(str);
+    const wchar_t *end = p + RSTRING_LEN(str) / 2;
+    for (; p < end; p ++) {
+        if (*p == L'/') { *p = L'\\'; }
+    }
+    return str;
+}
+
+#define STR2WPATH(str)                      \
+    ({                                      \
+        (str) = str2wpath(str);             \
+        (const wchar_t *)RSTRING_PTR(str);  \
+    })                                      \
+
+
+static VALUE
+wcs2str(const wchar_t str[], size_t size)
+{
+    if (!str) { return Qnil; }
+    VALUE v = rb_str_new((const char *)str, size * sizeof(str[0]));
+    rb_enc_associate(v, ENCutf16lep);
+
+    return rb_str_encode(v, ENCutf8, ECONV_INVALID_REPLACE | ECONV_UNDEF_REPLACE, Qnil);
+}
+
+static VALUE
+wpath2str(const wchar_t path[], size_t size)
+{
+    VALUE v = wcs2str(path, size);
+    if (NIL_P(v)) { return Qnil; }
+    char *p = RSTRING_PTR(v);
+    const char *end = p + RSTRING_LEN(v);
+    for (; p < end; p ++) {
+        if (*p == '\\') { *p = '/'; }
+    }
+    return v;
+}
+
+/*
+ * ADS 名の先端のコロン『:』と、終端の『:$DATA』を除去してrbuyの文字列を返す。
+ */
+static VALUE
+adsname2str(const wchar_t name[], size_t size)
+{
+    if (name[0] == L':' && wcsncmp(name + size - 6, L":$DATA", 6) == 0) {
+        name += 1;
+        size -= 7;
+    }
+
+    return wpath2str(name, size);
+}
+
+
+static void
+raise_win32_error(DWORD status)
+{
+    rb_raise(rb_eSystemCallError, "Win32 API error - %u (%08Xh)", status, status);
+}
+
+static void
+raise_ntstatus_error(NTSTATUS status)
+{
+    rb_raise(rb_eSystemCallError, "NTSTATUS error - %u (%08Xh)", status, status);
+}
+
+static VALUE
+get_filepath(HANDLE file)
+{
+    DWORD size = 65536;
+    VALUE buf = rb_str_buf_new(size);
+    NTSTATUS status = NtQueryObject(file, 
+                                    ObjectNameInformation,
+                                    RSTRING_PTR(buf),
+                                    size,
+                                    &size);
+    if (status != 0) { raise_ntstatus_error(status); }
+    const OBJECT_NAME_INFORMATION *info = (const OBJECT_NAME_INFORMATION *)RSTRING_PTR(buf);
+    if (wcsnicmp(info->Name.Buffer, L"\\Device\\", 8) == 0) {
+        // 先頭の "/Device/" を "//?/" に置き換える
+        wcsncpy(info->Name.Buffer + 4, L"\\\\?\\", 4);
+        return wpath2str(info->Name.Buffer + 4, info->Name.Length / 2 - 4);
+    } else {
+        return wpath2str(info->Name.Buffer, info->Name.Length / 2);
+    }
+}
+
+static uint64_t
+get_filesize(HANDLE file)
+{
+    BY_HANDLE_FILE_INFORMATION info;
+
+    if (!GetFileInformationByHandle(file, &info)) {
+        raise_win32_error(GetLastError());
+    }
+
+    return ((uint64_t)info.nFileSizeHigh << 32) | info.nFileSizeLow;
+}
+
+static VALUE
+file_close(HANDLE file)
+{
+    /*
+     * rb_ensure から直接呼びたかったけど、呼び出し規約が違うから無理だよね。
+     */
+    CloseHandle(file);
+}
+
+static void
+check_namespace(int namespace)
+{
+    if (namespace != EXTATTR_NAMESPACE_USER) {
+        errno = EPERM;
+        rb_sys_fail(NULL);
+    }
+}
+
+
+static VALUE
+extattr_list0(HANDLE file)
+{
+    VALUE iostatusblock = rb_str_buf_new(4096);
+    VALUE infobuf = rb_str_buf_new(65536);
+    rb_str_set_len(infobuf, 65536);
+    NTSTATUS status = NtQueryInformationFile(file,
+                                             (PIO_STATUS_BLOCK)RSTRING_PTR(iostatusblock),
+                                             RSTRING_PTR(infobuf), RSTRING_LEN(infobuf),
+                                             FileStreamInformation);
+    if (status != 0) { raise_ntstatus_error(status); }
+    const char *ptr = RSTRING_PTR(infobuf);
+    VALUE list = Qnil;
+    if (!rb_block_given_p()) { list = rb_ary_new(); }
+    for (;;) {
+        const FILE_STREAM_INFORMATION *info = (const FILE_STREAM_INFORMATION *)ptr;
+        VALUE name = adsname2str(info->StreamName, info->StreamNameLength / 2);
+        if (RSTRING_LEN(name) > 0) {
+            if (NIL_P(list)) {
+                rb_yield(name);
+            } else {
+                rb_ary_push(list, name);
+            }
+        }
+        size_t size = info->NextEntryOffset;
+        if (size == 0) { break; }
+        ptr += size;
+    }
+    return list;
+}
+
+static VALUE
+extattr_size0(HANDLE file)
+{
+    return ULL2NUM(get_filesize(file));
+}
+
+
+static VALUE
+file_extattr_list0(VALUE file, int fd, int namespace)
+{
+    check_namespace(namespace);
+    HANDLE file1 = (HANDLE)_get_osfhandle(fd);
+    return extattr_list0(file1);
+}
+
+static VALUE
+file_extattr_size0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return file_s_extattr_size0(get_filepath((HANDLE)_get_osfhandle(fd)),
+                                namespace, name);
+}
+
+static VALUE
+file_extattr_get0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return file_s_extattr_get0(get_filepath((HANDLE)_get_osfhandle(fd)),
+                               namespace, name);
+}
+
+static VALUE
+file_extattr_set0(VALUE file, int fd, int namespace, VALUE name, VALUE data)
+{
+    return file_s_extattr_set0(get_filepath((HANDLE)_get_osfhandle(fd)),
+                               namespace, name, data);
+}
+
+static VALUE
+file_extattr_delete0(VALUE file, int fd, int namespace, VALUE name)
+{
+    return file_s_extattr_delete0(get_filepath((HANDLE)_get_osfhandle(fd)),
+                                  namespace, name);
+}
+
+
+static VALUE
+file_s_extattr_list0(VALUE path, int namespace)
+{
+    check_namespace(namespace);
+    HANDLE file = CreateFileW(STR2WPATH(path), 0,
+                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, 3,
+                              FILE_FLAG_BACKUP_SEMANTICS,
+                              0);
+    if (file == INVALID_HANDLE_VALUE) { raise_win32_error(GetLastError()); }
+    return rb_ensure(extattr_list0, (VALUE)file, file_close, (VALUE)file);
+}
+
+static VALUE
+file_s_extattr_list_link0(VALUE path, int namespace)
+{
+    check_namespace(namespace);
+    HANDLE file = CreateFileW(STR2WPATH(path), 0,
+                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, 3,
+                              FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+                              0);
+    if (file == INVALID_HANDLE_VALUE) { raise_win32_error(GetLastError()); }
+    return rb_ensure(extattr_list0, (VALUE)file, file_close, (VALUE)file);
+}
+
+static VALUE
+file_s_extattr_size0(VALUE path, int namespace, VALUE name)
+{
+    check_namespace(namespace);
+    path = rb_str_plus(path, rb_str_new(":", 1));
+    rb_str_append(path, name);
+    HANDLE file = CreateFileW(STR2WPATH(path), 0,
+                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, 3,
+                              FILE_FLAG_BACKUP_SEMANTICS,
+                              0);
+    if (file == INVALID_HANDLE_VALUE) { raise_win32_error(GetLastError()); }
+    return rb_ensure(extattr_size0, (VALUE)file, file_close, (VALUE)file);
+}
+
+static VALUE
+file_s_extattr_size_link0(VALUE path, int namespace, VALUE name)
+{
+    check_namespace(namespace);
+    path = rb_str_plus(path, rb_str_new(":", 1));
+    rb_str_append(path, name);
+    HANDLE file = CreateFileW(STR2WPATH(path), 0,
+                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, 3,
+                              FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT,
+                              0);
+    if (file == INVALID_HANDLE_VALUE) { raise_win32_error(GetLastError()); }
+    return rb_ensure(extattr_size0, (VALUE)file, file_close, (VALUE)file);
+}
+
+
+static VALUE
+extattr_get0(VALUE args[3])
+{
+    HANDLE file = (HANDLE)args[0];
+    int namespace = (int)args[1];
+    VALUE name = args[2];
+    uint64_t size = get_filesize(file);
+    if (size > EXTATTR_MAX) { rb_raise(rb_eSystemCallError, "extattr too huge"); }
+    VALUE buf = rb_str_buf_new(size);
+    DWORD readsize = 0;
+    if (!ReadFile(file, RSTRING_PTR(buf), size, &readsize, NULL)) {
+        raise_win32_error(GetLastError());
+    }
+    rb_str_set_len(buf, readsize);
+    return buf;
+}
+
+static VALUE
+extattr_get1(VALUE path, int flags, int namespace, VALUE name)
+{
+    check_namespace(namespace);
+    path = rb_str_plus(path, rb_str_new(":", 1));
+    rb_str_append(path, name);
+    HANDLE file = CreateFileW(STR2WPATH(path), GENERIC_READ,
+                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, 3,
+                              FILE_FLAG_BACKUP_SEMANTICS | flags,
+                              0);
+    if (file == INVALID_HANDLE_VALUE) { raise_win32_error(GetLastError()); }
+    VALUE args[] = { (VALUE)file, (VALUE)namespace, name, };
+    return rb_ensure(extattr_get0, (VALUE)args, file_close, (VALUE)file);
+}
+
+static VALUE
+file_s_extattr_get0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_get1(path, 0, namespace, name);
+}
+
+static VALUE
+file_s_extattr_get_link0(VALUE path, int namespace, VALUE name)
+{
+    return extattr_get1(path, FILE_FLAG_OPEN_REPARSE_POINT, namespace, name);
+}
+
+static VALUE
+extattr_set0(VALUE args[])
+{
+    HANDLE file = (HANDLE)args[0];
+    int namespace = (int)args[1];
+    VALUE name = (VALUE)args[2];
+    VALUE data = (VALUE)args[3];
+    uint64_t size = RSTRING_LEN(data);
+    if (size > EXTATTR_MAX) { rb_raise(rb_eSystemCallError, "extattr too huge"); }
+    DWORD wrotesize = size;
+    if (!WriteFile(file, RSTRING_PTR(data), size, &wrotesize, NULL)) {
+        raise_win32_error(GetLastError());
+    }
+    return Qnil;
+}
+
+static VALUE
+file_s_extattr_set0(VALUE path, int namespace, VALUE name, VALUE data)
+{
+    check_namespace(namespace);
+    path = rb_str_plus(path, rb_str_new(":", 1));
+    rb_str_append(path, name);
+    HANDLE file = CreateFileW(STR2WPATH(path), GENERIC_WRITE,
+                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL, CREATE_ALWAYS,
+                              FILE_FLAG_BACKUP_SEMANTICS,
+                              0);
+    if (file == INVALID_HANDLE_VALUE) { raise_win32_error(GetLastError()); }
+    VALUE args[] = { (VALUE)file, (VALUE)namespace, name, data };
+    return rb_ensure(extattr_set0, (VALUE)args, file_close, (VALUE)file);
+}
+
+static VALUE
+file_s_extattr_set_link0(VALUE path, int namespace, VALUE name, VALUE data)
+{
+    return file_s_extattr_set0(path, namespace, name, data);
+}
+
+static VALUE
+file_s_extattr_delete0(VALUE path, int namespace, VALUE name)
+{
+    check_namespace(namespace);
+    path = rb_str_plus(path, rb_str_new(":", 1));
+    rb_str_append(path, name);
+    DeleteFileW(STR2WPATH(path));
+    return Qnil;
+}
+
+static VALUE
+file_s_extattr_delete_link0(VALUE path, int namespace, VALUE name)
+{
+    return file_s_extattr_delete0(path, namespace, name);
+}
+
+static void
+setup(void)
+{
+    ENCutf8p = rb_enc_find("UTF-8");
+    ENCutf8 = rb_enc_from_encoding(ENCutf8p);
+    rb_gc_register_address(&ENCutf8);
+
+    ENCutf16lep = rb_enc_find("UTF-16LE");
+    ENCutf16le = rb_enc_from_encoding(ENCutf16lep);
+    rb_gc_register_address(&ENCutf16le);
+}

data/ext/extconf.rb

@@ -0,0 +1,28 @@
+#!ruby
+#vim: set fileencoding:utf-8
+
+raise "require ruby-1.9.3+" unless RUBY_VERSION >= "1.9.3"
+
+require "mkmf"
+
+#$CFLAGS << " -std=c99" 
+
+case
+when have_header("sys/extattr.h")
+when have_header("attr/xattr.h")
+when have_header("winnt.h") && have_header("ntdef.h") && have_header("psapi.h") &&
+     have_header("ddk/ntifs.h") && have_header("ddk/winddk.h") &&
+     have_library("ntoskrnl") && have_library("ntdll") && have_library("psapi")
+else
+    $stderr.puts <<-EOS
+#$0: not supported target.
+\tmust be available either ddk/ntifs.h, sys/extattr.h or attr/xattr.h on your system.
+    EOS
+    exit 1
+end
+
+create_makefile "extattr" or exit 2
+
+
+#$CPPFLAGS << " -Wall -DFUSE_USE_VERSION=26"
+

data/rspecs/extattr.rb

@@ -0,0 +1,53 @@
+#vim: set fileencoding:utf-8
+
+require "tmpdir"
+basedir = File.join(Dir.tmpdir, "ruby-extattr.test-work")
+Dir.mkdir basedir unless File.directory? basedir
+
+require "extattr"
+
+extdata = "abcdefg"
+
+Dir.chdir basedir do
+    describe "file" do
+        file = nil
+        before(:all) do
+            file = File.open("file1", "a")
+        end
+
+        it ".extattr_list" do
+            file.extattr_list.should eq([])
+        end
+
+        after(:all) do
+            file.close
+            file = nil
+        end
+    end
+
+    describe File do
+        it ".extattr_list" do
+            File.extattr_list("file1").should eq([])
+        end
+
+        it ".extattr_set" do
+            File.extattr_set("file1", "ext1", extdata).should nil
+        end
+
+        it ".extattr_list ((2))" do
+            File.extattr_list("file1").should eq(["ext1"])
+        end
+
+        it ".extattr_get" do
+            File.extattr_get("file1", "ext1").should eq(extdata)
+        end
+
+        it ".extattr_delete" do
+            File.extattr_delete("file1", "ext1").should nil
+        end
+
+        it ".extattr_list ((3))" do
+            File.extattr_list("file1").should eq([])
+        end
+    end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: extattr
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  segments: 
+  hash: 
+platform: x86-mingw32
+authors:
+- dearblue
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-02 00:00:00.000000000 Z
+dependencies: []
+description: ! 'extattr is extended attribute operation library for ruby.
+
+  Supported for Microsoft Windows and FreeBSD.
+
+'
+email: dearblue@users.sourceforge.jp
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.txt
+- LICENSE.txt
+- ext/extattr.c
+files:
+- LICENSE.txt
+- README.txt
+- ext/extattr.bsd
+- ext/extattr.c
+- ext/extattr.linux
+- ext/extattr.windows
+- ext/extconf.rb
+- lib/extattr.so
+- rspecs/extattr.rb
+homepage: http://sourceforge.jp/projects/rutsubo/
+licenses:
+- 2-clause BSD License
+post_install_message: 
+rdoc_options:
+- -e
+- UTF-8
+- -m
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+      segments: 
+      hash: 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments: 
+      hash: 
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: extended attribute operation library for ruby
+test_files: []
+has_rdoc: false