fdpass 0.1.0

data/README

@@ -0,0 +1,35 @@
+= Libarchive/Ruby
+
+== Description
+
+This is a library to transmit the file descriptor between the processes. 
+
+== Example
+=== Server (Reciever)
+  require 'fdpass'
+  
+  begin
+    fdpass = FDPass.server('/tmp/fdpass.sock')
+  
+    t = Thread.fork {
+      loop do
+        fd = fdpass.recv
+        io = IO.open(fd)
+        io.puts('%s: %s' % [fd, __FILE__])
+      end
+    }
+
+    t.join
+  ensure
+    fdpass.close
+  end
+
+== Client (Sender)
+  require 'fdpass'
+  
+  begin
+    fdpass = FDPass.client('/tmp/fdpass.sock')
+    fdpass.send($stderr.fileno)
+  ensure
+    fdpass.close if fdpass.closed?
+  end

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS += ' -Wall '
+create_makefile('fdpass')

data/ext/fdpass.c

@@ -0,0 +1,25 @@
+#include "fdpass.h"
+
+VALUE rb_mFDPass;
+VALUE rb_eFDPassError;
+extern VALUE rb_cFDPassServer;
+extern VALUE rb_cFDPassClient;
+
+static VALUE rb_fdpass_server(VALUE self, VALUE path) {
+  return rb_funcall(rb_cFDPassServer, rb_intern("new"), 1, path);
+}
+
+static VALUE rb_fdpass_client(VALUE self, VALUE path) {
+  return rb_funcall(rb_cFDPassClient, rb_intern("new"), 1, path);
+}
+
+void Init_fdpass() {
+  rb_mFDPass = rb_define_module("FDPass");
+  rb_define_module_function(rb_mFDPass, "server", rb_fdpass_server, 1);
+  rb_define_module_function(rb_mFDPass, "client", rb_fdpass_client, 1);
+
+  rb_eFDPassError = rb_define_class_under(rb_mFDPass, "Error", rb_eStandardError);
+
+  Init_fdpass_server();
+  Init_fdpass_client();
+}

data/ext/fdpass.h

@@ -0,0 +1,26 @@
+#ifndef __FDPASS_H__
+#define __FDPASS_C__
+
+#include <string.h>
+
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <errno.h>
+
+#include <ruby.h>
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+void Init_fdpass_server();
+void Init_fdpass_client();
+
+#endif // __FDPASS_H__

data/ext/fdpass_client.c

@@ -0,0 +1,88 @@
+#include "fdpass.h"
+#include "fdpass_socket.h"
+
+extern VALUE rb_mFDPass;
+extern VALUE rb_eFDPassError;
+VALUE rb_cFDPassClient;
+
+static VALUE rd_fdpass_client_initialize(VALUE self, VALUE path) {
+  struct fdpass_socket *p;
+  char *cpath;
+  int sock;
+  struct sockaddr_un addr;
+
+  Data_Get_Struct(self, struct fdpass_socket, p);
+
+  Check_Type(path, T_STRING);
+  cpath = RSTRING_PTR(path);
+
+  sock = socket(PF_UNIX, SOCK_DGRAM, 0);
+
+  if (sock < 0) {
+    rb_raise(rb_eFDPassError, "%s", strerror(errno));
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sun_family = AF_UNIX;
+  strncpy(addr.sun_path, cpath, sizeof(addr.sun_path) - 1);
+  addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
+
+  if (connect(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+    rb_raise(rb_eFDPassError, "%s", strerror(errno));
+  }
+
+  p->sock = sock;
+  p->closed = 0;
+  p->path = path;
+  p->is_server = 0;
+
+  return Qnil;
+}
+
+static VALUE rb_fdpass_client_send(VALUE self, VALUE fd) {
+  struct fdpass_socket *p;
+  struct msghdr msg = { 0 };
+  struct cmsghdr *cmsg;
+  char cmsgbuf[CMSG_SPACE(sizeof(int))];
+  int ifd, *cmsg_data;
+  struct iovec iov;
+
+  ifd = NUM2INT(fd);
+
+  Data_Get_Struct(self, struct fdpass_socket, p);
+  Check_Socket(p);
+
+  iov.iov_base = "\0";
+  iov.iov_len = 1;
+
+  msg.msg_name = NULL;
+  msg.msg_namelen = 0;
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = cmsgbuf;
+  msg.msg_controllen = sizeof(cmsgbuf);
+
+  cmsg = CMSG_FIRSTHDR(&msg);
+  cmsg->cmsg_len = CMSG_LEN(sizeof(int));
+  cmsg->cmsg_level = SOL_SOCKET;
+  cmsg->cmsg_type = SCM_RIGHTS;
+
+  cmsg_data = (int *) CMSG_DATA(cmsg);
+  *cmsg_data = ifd;
+  msg.msg_controllen = cmsg->cmsg_len;
+  
+  if (sendmsg(p->sock, &msg, 0) < 0) { 
+    rb_raise(rb_eFDPassError, "%s", strerror(errno));
+  }
+
+  return Qnil;
+}
+
+void Init_fdpass_client() {
+  rb_cFDPassClient = rb_define_class_under(rb_mFDPass, "Client", rb_cObject);
+  rb_define_alloc_func(rb_cFDPassClient, fdpass_socket_alloc);
+  rb_define_private_method(rb_cFDPassClient, "initialize", rd_fdpass_client_initialize, 1);
+  rb_define_method(rb_cFDPassClient, "close", rd_fdpass_socket_close, 0);
+  rb_define_method(rb_cFDPassClient, "closed?", rd_fdpass_socket_is_closed, 0);
+  rb_define_method(rb_cFDPassClient, "send", rb_fdpass_client_send, 1);
+}

data/ext/fdpass_server.c

@@ -0,0 +1,81 @@
+#include "fdpass.h"
+#include "fdpass_socket.h"
+
+extern VALUE rb_mFDPass;
+extern VALUE rb_eFDPassError;
+VALUE rb_cFDPassServer;
+
+static VALUE rd_fdpass_server_initialize(VALUE self, VALUE path) {
+  struct fdpass_socket *p;
+  char *cpath;
+  int sock;
+  struct sockaddr_un addr;
+
+  Data_Get_Struct(self, struct fdpass_socket, p);
+
+  Check_Type(path, T_STRING);
+  cpath = RSTRING_PTR(path);
+
+  sock = socket(PF_UNIX, SOCK_DGRAM, 0);
+
+  if (sock < 0) {
+    rb_raise(rb_eFDPassError, "%s", strerror(errno));
+  }
+
+  memset(&addr, 0, sizeof(addr));
+  addr.sun_family = AF_UNIX;
+  strncpy(addr.sun_path, cpath, sizeof(addr.sun_path) - 1);
+  addr.sun_path[sizeof(addr.sun_path) - 1] = '\0';
+
+  if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+    rb_raise(rb_eFDPassError, "%s", strerror(errno));
+  }
+
+  p->sock = sock;
+  p->closed = 0;
+  p->path = path;
+  p->is_server = 1;
+
+  return Qnil;
+}
+
+static VALUE rb_fdpass_server_recv(VALUE self) {
+  struct fdpass_socket *p;
+  struct msghdr msg = { 0 };
+  struct cmsghdr *cmsg;
+  char cmsgbuf[CMSG_SPACE(sizeof(int))];
+  int *cmsg_data;
+  struct iovec iov;
+  char iov_data[1];
+
+  Data_Get_Struct(self, struct fdpass_socket, p);
+  Check_Socket(p);
+
+  iov.iov_base = iov_data;
+  iov.iov_len = sizeof(iov_data);
+
+  msg.msg_name = NULL;
+  msg.msg_namelen = 0;
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  msg.msg_control = cmsgbuf;
+  msg.msg_controllen = sizeof(cmsgbuf);
+
+  if (recvmsg(p->sock, &msg, MSG_WAITALL) < 0) { 
+    rb_raise(rb_eFDPassError, "%s", strerror(errno));
+  }
+
+  cmsg = CMSG_FIRSTHDR(&msg);
+  cmsg_data = (int *) CMSG_DATA(cmsg);
+
+  return INT2NUM(*cmsg_data);
+}
+
+void Init_fdpass_server() {
+  rb_cFDPassServer = rb_define_class_under(rb_mFDPass, "Server", rb_cObject);
+  rb_define_alloc_func(rb_cFDPassServer, fdpass_socket_alloc);
+  rb_define_private_method(rb_cFDPassServer, "initialize", rd_fdpass_server_initialize, 1);
+  rb_define_method(rb_cFDPassServer, "close", rd_fdpass_socket_close, 0);
+  rb_define_method(rb_cFDPassServer, "closed?", rd_fdpass_socket_is_closed, 0);
+  rb_define_method(rb_cFDPassServer, "recv", rb_fdpass_server_recv, 0);
+}

data/ext/fdpass_socket.c

@@ -0,0 +1,64 @@
+#include "fdpass_socket.h"
+
+extern VALUE rb_eFDPassError;
+
+static void unlink_socket(struct fdpass_socket *p) {
+#ifdef S_ISSOCK
+  char *cpath;
+  struct stat st;
+
+  if (!p->is_server || NIL_P(p->path)) {
+    return;
+  }
+
+  Check_Type(p->path, T_STRING);
+  cpath = RSTRING_PTR(p->path);
+
+  if (stat(cpath, &st) == 0 && S_ISSOCK(st.st_mode)) {
+    unlink(cpath);
+  }
+#endif
+}
+
+static void fdpass_socket_mark(struct fdpass_socket *p) {
+  rb_gc_mark(p->path);
+}
+
+static void fdpass_socket_free(struct fdpass_socket *p) {
+  if (!p->closed) {
+    close(p->sock);
+    unlink_socket(p);
+  }
+
+  xfree(p);
+}
+
+VALUE fdpass_socket_alloc(VALUE klass) {
+  struct fdpass_socket *p = ALLOC(struct fdpass_socket);
+  p->sock = -1;
+  p->closed = 1;
+  p->path = Qnil;
+  return Data_Wrap_Struct(klass, fdpass_socket_mark, fdpass_socket_free, p);
+}
+
+VALUE rd_fdpass_socket_close(VALUE self) {
+  struct fdpass_socket *p;
+
+  Data_Get_Struct(self, struct fdpass_socket, p);
+
+  if (!p->closed) {
+    close(p->sock);
+    unlink_socket(p);
+    p->sock = -1;
+    p->closed = 1;
+    p->path = Qnil;
+  }
+
+  return Qnil;
+}
+
+VALUE rd_fdpass_socket_is_closed(VALUE self) {
+  struct fdpass_socket *p;
+  Data_Get_Struct(self, struct fdpass_socket, p);
+  return p->closed ? Qtrue : Qfalse;
+}

data/ext/fdpass_socket.h

@@ -0,0 +1,24 @@
+#ifndef __FDPASS_SOCKET_H__
+#define __FDPASS_SOCKET_C__
+
+#include "fdpass.h"
+
+struct fdpass_socket {
+  int sock;
+  int closed;
+  VALUE path;
+  int is_server;
+};
+
+#define Check_Socket(p) do { \
+  if ((p)->sock < 0 || (p)->closed || NIL_P((p)->path)) { \
+    rb_raise(rb_eFDPassError, "Invalid socket"); \
+  } \
+  Check_Type((p)->path, T_STRING); \
+} while(0)
+
+VALUE fdpass_socket_alloc(VALUE klass);
+VALUE rd_fdpass_socket_close(VALUE self);
+VALUE rd_fdpass_socket_is_closed(VALUE self);
+
+#endif // __FDPASS_SOCKET_H__

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: fdpass
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-01 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sgwr_dts@yahoo.co.jp
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/fdpass.c
+- ext/fdpass_client.c
+- ext/fdpass_server.c
+- ext/fdpass_socket.c
+- ext/fdpass.h
+- ext/fdpass_socket.h
+- ext/extconf.rb
+- README
+has_rdoc: true
+homepage: https://github.com/winebarrel/fdpass
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: This is a library to transmit the file descriptor between the processes.
+test_files: []
+