extattr 0.1.2 → 0.2

data/ext/extattr-xattr.h

@@ -0,0 +1,229 @@
+#include <sys/types.h>
+#if HAVE_ATTR_XATTR_H
+#   include <attr/xattr.h>
+#else
+#   include <sys/xattr.h>
+#endif
+
+enum {
+    EXTATTR_NAMESPACE_USER,
+    EXTATTR_NAMESPACE_SYSTEM,
+    EXTATTR_NAMESPACE_TRUSTED,
+    EXTATTR_NAMESPACE_SECURITY,
+};
+
+
+static VALUE NAMESPACE_USER_PREFIX, NAMESPACE_SYSTEM_PREFIX;
+
+
+static VALUE
+xattr_name(int namespace1, VALUE name)
+{
+    switch (namespace1) {
+    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, "namespace1 error");
+        return Qnil;
+    }
+}
+
+
+static inline void
+extattr_list_name(const char *ptr, size_t size, VALUE infection_source, int namespace1, VALUE (*func)(void *, VALUE), void *user)
+{
+    const char *end = ptr + size;
+    while (ptr < end) {
+        int len = strlen(ptr);
+        // if (len > (end - ptr)) { ... } // TODO
+        if (namespace1 == EXTATTR_NAMESPACE_USER && len > 5 && strncmp(ptr, "user.", 5) == 0) {
+            ptr += 5;
+        } else if (namespace1 == EXTATTR_NAMESPACE_SYSTEM && len > 7 && strncmp(ptr, "system.", 7) == 0) {
+            ptr += 7;
+        } else {
+            ptr += len + 1;
+            continue;
+        }
+
+        VALUE name = rb_str_new_cstr(ptr);
+        OBJ_INFECT(name, infection_source);
+        func(user, name);
+        ptr += RSTRING_LEN(name) + 1; // 最後の『+1』は、ヌルバイトの分。
+    }
+}
+
+static VALUE
+extattr_list_common(ssize_t (*func)(), void *d, VALUE infection_source, int namespace1)
+{
+    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"); }
+
+    if (rb_block_given_p()) {
+        extattr_list_name(ptr, size, infection_source, namespace1,
+                          (VALUE (*)(void *, VALUE))rb_yield_values,
+                          (void *)1);
+        return Qnil;
+    } else {
+        VALUE list = rb_ary_new();
+        OBJ_INFECT(list, infection_source);
+        extattr_list_name(ptr, size, infection_source, namespace1,
+                          (VALUE (*)(void *, VALUE))rb_ary_push,
+                          (void *)list);
+        return list;
+    }
+}
+
+static VALUE
+file_extattr_list_main(VALUE file, int fd, int namespace1)
+{
+    return extattr_list_common(flistxattr, (void *)fd,
+                               file, namespace1);
+}
+
+static VALUE
+file_s_extattr_list_main(VALUE path, int namespace1)
+{
+    return extattr_list_common(listxattr, StringValueCStr(path),
+                               path, namespace1);
+}
+
+static VALUE
+file_s_extattr_list_link_main(VALUE path, int namespace1)
+{
+    return extattr_list_common(llistxattr, StringValueCStr(path),
+                               path, namespace1);
+}
+
+
+static VALUE
+extattr_size_common(ssize_t (*func)(), void *d, int namespace1, VALUE name)
+{
+    name = xattr_name(namespace1, 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_size_main(VALUE file, int fd, int namespace1, VALUE name)
+{
+    return extattr_size_common(fgetxattr, (void *)fd, namespace1, name);
+}
+
+static VALUE
+file_s_extattr_size_main(VALUE path, int namespace1, VALUE name)
+{
+    return extattr_size_common(getxattr, StringValueCStr(path), namespace1, name);
+}
+
+static VALUE
+file_s_extattr_size_link_main(VALUE path, int namespace1, VALUE name)
+{
+    return extattr_size_common(lgetxattr, StringValueCStr(path), namespace1, name);
+}
+
+
+static VALUE
+extattr_get_common(ssize_t (*func)(), void *d, int namespace1, VALUE name)
+{
+    name = xattr_name(namespace1, 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_get_main(VALUE file, int fd, int namespace1, VALUE name)
+{
+    return extattr_get_common(fgetxattr, (void *)fd, namespace1, name);
+}
+
+static VALUE
+file_s_extattr_get_main(VALUE path, int namespace1, VALUE name)
+{
+    return extattr_get_common(getxattr, StringValueCStr(path), namespace1, name);
+}
+
+static VALUE
+file_s_extattr_get_link_main(VALUE path, int namespace1, VALUE name)
+{
+    return extattr_get_common(lgetxattr, StringValueCStr(path), namespace1, name);
+}
+
+
+static VALUE
+extattr_set_common(int (*func)(), void *d, int namespace1, VALUE name, VALUE data)
+{
+    name = xattr_name(namespace1, name);
+    int status = func(d, StringValueCStr(name), RSTRING_PTR(data), RSTRING_LEN(data), 0);
+    if (status < 0) { rb_sys_fail("setxattr call error"); }
+    return Qnil;
+}
+
+static VALUE
+file_extattr_set_main(VALUE file, int fd, int namespace1, VALUE name, VALUE data)
+{
+    return extattr_set_common(fsetxattr, (void *)fd, namespace1, name, data);
+}
+
+static VALUE
+file_s_extattr_set_main(VALUE path, int namespace1, VALUE name, VALUE data)
+{
+    return extattr_set_common(setxattr, StringValueCStr(path), namespace1, name, data);
+}
+
+static VALUE
+file_s_extattr_set_link_main(VALUE path, int namespace1, VALUE name, VALUE data)
+{
+    return extattr_set_common(lsetxattr, StringValueCStr(path), namespace1, name, data);
+}
+
+
+static VALUE
+extattr_delete_common(int (*func)(), void *d, int namespace1, VALUE name)
+{
+    name = xattr_name(namespace1, name);
+    int status = func(d, StringValueCStr(name));
+    if (status < 0) { rb_sys_fail("removexattr call error"); }
+    return Qnil;
+}
+
+static VALUE
+file_extattr_delete_main(VALUE file, int fd, int namespace1, VALUE name)
+{
+    return extattr_delete_common(fremovexattr, (void *)fd, namespace1, name);
+}
+
+static VALUE
+file_s_extattr_delete_main(VALUE path, int namespace1, VALUE name)
+{
+    return extattr_delete_common(removexattr, StringValueCStr(path), namespace1, name);
+}
+
+static VALUE
+file_s_extattr_delete_link_main(VALUE path, int namespace1, VALUE name)
+{
+    return extattr_delete_common(lremovexattr, StringValueCStr(path), namespace1, name);
+}
+
+
+static void
+ext_init_implement(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);
+
+    rb_define_const(rb_cFile, "EXTATTR_IMPLEMANT", rb_str_freeze(rb_str_new_cstr("xattr")));
+}

data/ext/extattr.c

@@ -12,30 +12,32 @@
 #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);
+static VALUE file_extattr_list_main(VALUE file, int fd, int namespace1);
+static VALUE file_extattr_size_main(VALUE file, int fd, int namespace1, VALUE name);
+static VALUE file_extattr_get_main(VALUE file, int fd, int namespace1, VALUE name);
+static VALUE file_extattr_set_main(VALUE file, int fd, int namespace1, VALUE name, VALUE data);
+static VALUE file_extattr_delete_main(VALUE file, int fd, int namespace1, VALUE name);
+static VALUE file_s_extattr_list_main(VALUE path, int namespace1);
+static VALUE file_s_extattr_list_link_main(VALUE path, int namespace1);
+static VALUE file_s_extattr_size_main(VALUE path, int namespace1, VALUE name);
+static VALUE file_s_extattr_size_link_main(VALUE path, int namespace1, VALUE name);
+static VALUE file_s_extattr_get_main(VALUE path, int namespace1, VALUE name);
+static VALUE file_s_extattr_get_link_main(VALUE path, int namespace1, VALUE name);
+static VALUE file_s_extattr_set_main(VALUE path, int namespace1, VALUE name, VALUE data);
+static VALUE file_s_extattr_set_link_main(VALUE path, int namespace1, VALUE name, VALUE data);
+static VALUE file_s_extattr_delete_main(VALUE path, int namespace1, VALUE name);
+static VALUE file_s_extattr_delete_link_main(VALUE path, int namespace1, VALUE name);
 
 // Init_extattr から呼び出される、環境ごとの初期設定。
-static void setup(void);
+static void ext_init_implement(void);
 
 
 #define RDOC(...)
 
 #define ELEMENTOF(V) (sizeof(V) / sizeof((V)[0]))
 
+#define LOGF(FORMAT, ...) { fprintf(stderr, "%s:%d:%s: " FORMAT "\n", __FILE__, __LINE__, __func__, __VA_ARGS__); }
+
 
 static inline VALUE
 hash_lookup(VALUE hash, VALUE key, VALUE default_value)
@@ -58,25 +60,126 @@ file2fd(VALUE file)
     return fptr->fd;
 }
 
+static inline void
+ext_error_extattr(int err, VALUE filepath, VALUE attrname)
+{
+    errno = err;
+    if (NIL_P(filepath)) {
+        filepath = rb_str_new_cstr("<?>");
+    } else {
+        filepath = rb_get_path_no_checksafe(filepath);
+    }
+    VALUE mesg = rb_sprintf("%s [%s]", StringValueCStr(filepath), StringValueCStr(attrname));
+    rb_sys_fail(StringValueCStr(mesg));
+}
+
+static inline void
+ext_error_namespace(VALUE path, int namespace1)
+{
+    ext_error_extattr(EPERM, path, rb_sprintf("namespace=%d", namespace1));
+}
+
 
 #if defined(HAVE_SYS_EXTATTR_H)
-#   include "extattr.bsd"
+#   include "extattr-extattr.h"
 #elif defined(HAVE_WINNT_H)
-#   include "extattr.windows"
+#   include "extattr-windows.h"
 #elif defined(HAVE_ATTR_XATTR_H) || defined(HAVE_SYS_XATTR_H)
-#   include "extattr.linux"
+#   include "extattr-xattr.h"
 #else
-#   error ruby extattr not supported on your system
+#   error ruby-extattr not supported on your system
 #endif
 
 
 static VALUE SYMnamespace;
 
+static int
+ext_get_namespace(VALUE opts)
+{
+    return NUM2INT(hash_lookup(opts, SYMnamespace, INT2NUM(EXTATTR_NAMESPACE_USER)));
+}
+
+static void
+ext_check_file_security(VALUE file, VALUE name, VALUE data)
+{
+    /*
+     * - file が汚染されていない場合、他のオブジェクトも汚染されていてはならない。
+     * - file が汚染されている場合、他のオブジェクトの汚染に左右されない。
+     * - $SAFE が4以上の場合、非汚染オブジェクトがあれば失敗する。
+     *
+     *      file name data | list    get     set     delete
+     *      -    -    -    | yes     yes     yes     yes
+     *      -    -    T    |                 no
+     *      -    T    -    |         no      no      no
+     *      -    T    T    |                 no
+     *      T    -    -    | yes     yes     yes     yes
+     *      T    -    T    |                 yes
+     *      T    T    -    |         yes     yes     yes
+     *      T    T    T    |                 yes
+     */
+
+    int safe = rb_safe_level();
+
+    // $SAFE < 1 であれば、常に成功する
+    if (safe < 1) {
+        return;
+    }
+
+    // 0 < $SAFE < 4 であれば、file が汚染されていれば常に成功、
+    // そうでなければ name と data は非汚染状態でなければならない
+    if (safe < 4) {
+        if (OBJ_TAINTED(file)) {
+            return;
+        }
+        if (OBJ_TAINTED(name) || OBJ_TAINTED(data)) {
+            rb_insecure_operation();
+        }
+        return;
+    }
+
+    // $SAFE は 4以上。すべてのオブジェクトが汚染されていなければならない
+    if (!OBJ_TAINTED(file) ||
+        (!NIL_P(name) && !OBJ_TAINTED(name)) ||
+        (!NIL_P(data) && !OBJ_TAINTED(data))) {
+
+        rb_insecure_operation();
+    }
+}
+
+static void
+ext_check_path_security(VALUE path, VALUE name, VALUE data)
+{
+    /*
+     * - すべてのオブジェクトが汚染されていない状態でなければならない。
+     * - $SAFE が4以上の場合、常に失敗する。
+     *
+     *      path name data | list    get     set     delete
+     *      -    -    -    | yes     yes     yes     yes
+     *      -    -    T    |                 no
+     *      -    T    -    |         no      no      no
+     *      -    T    T    |                 no
+     *      T    -    -    | no      no      no      no
+     *      T    -    T    |                 no
+     *      T    T    -    |         no      no      no
+     *      T    T    T    |                 no
+     */
+
+    int safe = rb_safe_level();
+    if (safe < 1) { return; }
+    if (safe < 4) {
+        if (OBJ_TAINTED(path) || OBJ_TAINTED(name) || OBJ_TAINTED(data)) {
+            rb_insecure_operation();
+        }
+    } else {
+        rb_insecure_operation();
+    }
+}
+
 
 /*
  * call-seq:
- * file.extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) -> names array
- * file.extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
+ *  extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ *  extattr_list(namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
  *
  * 開いているファイルの拡張属性名一覧を得ます。
  *
@@ -87,14 +190,15 @@ 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))));
+    ext_check_file_security(file, Qnil, Qnil);
+    return file_extattr_list_main(file, file2fd(file),
+                                  ext_get_namespace(opts));
 }
 
 /*
  * call-seq:
- * File.extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
- * File.extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
+ *  extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ *  extattr_list(path, namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
  *
  * ファイル名を指定すること以外は File#extattr_list と同じです。
  */
@@ -103,14 +207,15 @@ 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))));
+    ext_check_path_security(path, Qnil, Qnil);
+    return file_s_extattr_list_main(StringValue(path),
+                                    ext_get_namespace(opts));
 }
 
 /*
  * call-seq:
- * File.extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
- * File.extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
+ *  extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ *  extattr_list!(path, namespace: File::EXTATTR_NAMESPACE_USER) { |name| ... } -> nil
  *
  * シンボリックリンクに対する操作という以外は、File.extattr_list と同じです。
  */
@@ -119,14 +224,15 @@ 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))));
+    ext_check_path_security(path, Qnil, Qnil);
+    return file_s_extattr_list_link_main(StringValue(path),
+                                         ext_get_namespace(opts));
 }
 
 
 /*
  * call-seq:
- * file.extattr_size(name, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
+ *  extattr_size(name, namespace: File::EXTATTR_NAMESPACE_USER) -> names array
  *
  * 拡張属性の大きさを取得します。
  */
@@ -135,191 +241,210 @@ 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));
+    ext_check_file_security(file, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    return file_extattr_size_main(file, file2fd(file),
+                                  ext_get_namespace(opts),
+                                  StringValue(name));
 }
 
 /*
  * call-seq:
- * File.extattr_size(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+ *  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));
+    ext_check_path_security(path, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    return file_s_extattr_size_main(StringValue(path),
+                                    ext_get_namespace(opts),
+                                    StringValue(name));
 }
 
 /*
  * call-seq:
- * File.extattr_size!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> size
+ *  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));
+    ext_check_path_security(path, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    return file_s_extattr_size_link_main(StringValue(path),
+                                         ext_get_namespace(opts),
+                                         StringValue(name));
 }
 
 
 /*
  * call-seq:
- * file.extattr_get(name, namespace: File::EXTATTR_NAMESPACE_USER) -> data
+ *  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));
+    ext_check_file_security(file, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    VALUE v = file_extattr_get_main(file, file2fd(file),
+                                    ext_get_namespace(opts),
+                                    StringValue(name));
+    OBJ_INFECT(v, file);
+    return v;
 }
 
 /*
  * call-seq:
- * File.extattr_get(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> data
+ *  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));
+    ext_check_path_security(path, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    VALUE v = file_s_extattr_get_main(StringValue(path),
+                                      ext_get_namespace(opts),
+                                      StringValue(name));
+    OBJ_INFECT(v, path);
+    return v;
 }
 
 /*
  * call-seq:
- * File.extattr_get!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> data
+ *  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));
+    ext_check_path_security(path, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    VALUE v = file_s_extattr_get_link_main(StringValue(path),
+                                           ext_get_namespace(opts),
+                                           StringValue(name));
+    OBJ_INFECT(v, path);
+    return v;
 }
 
 
 /*
  * call-seq:
- * file.extattr_set(name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ *  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));
+    rb_scan_args(argc, argv, "2:", &name, &data, &opts);
+    ext_check_file_security(file, name, data);
+    Check_Type(name, RUBY_T_STRING);
+    return file_extattr_set_main(file, file2fd(file),
+                                 ext_get_namespace(opts),
+                                 StringValue(name),
+                                 StringValue(data));
 }
 
 /*
  * call-seq:
- * File.extattr_set(path, name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ *  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));
+    rb_scan_args(argc, argv, "3:", &path, &name, &data, &opts);
+    ext_check_path_security(path, name, data);
+    Check_Type(name, RUBY_T_STRING);
+    return file_s_extattr_set_main(StringValue(path),
+                                   ext_get_namespace(opts),
+                                   StringValue(name),
+                                   StringValue(data));
 }
 
 /*
  * call-seq:
- * File.extattr_set!(path, name, data, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ *  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));
+    rb_scan_args(argc, argv, "3:", &path, &name, &data, &opts);
+    ext_check_path_security(path, name, data);
+    Check_Type(name, RUBY_T_STRING);
+    return file_s_extattr_set_link_main(StringValue(path),
+                                        ext_get_namespace(opts),
+                                        StringValue(name),
+                                        StringValue(data));
 }
 
 
 /*
  * call-seq:
- * file.extattr_delete(name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ *  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));
+    ext_check_file_security(file, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    return file_extattr_delete_main(file, file2fd(file),
+                                    ext_get_namespace(opts),
+                                    StringValue(name));
 }
 
 /*
  * call-seq:
- * File.extattr_delete(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ *  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));
+    ext_check_path_security(path, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    return file_s_extattr_delete_main(StringValue(path),
+                                      ext_get_namespace(opts),
+                                      StringValue(name));
 }
 
 /*
  * call-seq:
- * File.extattr_delete!(path, name, namespace: File::EXTATTR_NAMESPACE_USER) -> nil
+ *  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));
+    ext_check_path_security(path, name, Qnil);
+    Check_Type(name, RUBY_T_STRING);
+    return file_s_extattr_delete_link_main(StringValue(path),
+                                           ext_get_namespace(opts),
+                                           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"));
+    SYMnamespace = ID2SYM(rb_intern_const("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_const(rb_cFile, "EXTATTR_NAMESPACE_USER", INT2NUM(EXTATTR_NAMESPACE_USER));
+    rb_define_const(rb_cFile, "EXTATTR_NAMESPACE_SYSTEM", INT2NUM(EXTATTR_NAMESPACE_SYSTEM));
+    rb_define_const(rb_cFile, "EXTATTR_VERSION", rb_str_freeze(rb_str_new_cstr("0.2")));
 
     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);
@@ -341,5 +466,5 @@ Init_extattr(void)
     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();
+    ext_init_implement();
 }