uvrb 0.1.0

data/lib/uv/timer.rb

@@ -0,0 +1,48 @@
+module UV
+  class Timer
+    include Handle
+
+    def start(timeout, repeat, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(Integer, timeout, "timeout must be an Integer")
+      assert_type(Integer, repeat, "repeat must be an Integer")
+
+      @timer_block = block
+
+      check_result! UV.timer_start(handle, callback(:on_timer), timeout, repeat)
+
+      self
+    end
+
+    def stop
+      check_result! UV.timer_stop(handle)
+
+      self
+    end
+
+    def again
+      check_result! UV.timer_again(handle)
+
+      self
+    end
+
+    def repeat=(repeat)
+      assert_type(Integer, repeat, "repeat must be an Integer")
+
+      check_result! UV.timer_set_repeat(handle, repeat)
+
+      self
+    end
+
+    def repeat
+      UV.timer_get_repeat(handle)
+    end
+
+    private
+
+    def on_timer(handle, status)
+      @timer_block.call(check_result(status))
+    end
+  end
+end

data/lib/uv/tty.rb

@@ -0,0 +1,30 @@
+module UV
+  class TTY
+    include Stream
+
+    def enable_raw_mode
+      check_result! UV.tty_set_mode(handle, 1)
+
+      self
+    end
+
+    def disable_raw_mode
+      check_result! UV.tty_set_mode(handle, 0)
+
+      self
+    end
+
+    def reset_mode
+      UV.tty_reset_mode
+
+      self
+    end
+
+    def winsize
+      width = FFI::MemoryPointer.new(:int)
+      height = FFI::MemoryPointer.new(:int)
+      UV.tty_get_winsize(handle, width, height)
+      [width.get_int(0), height.get_int(0)]
+    end
+  end
+end

data/lib/uv/types.rb

@@ -0,0 +1,249 @@
+module FFI::Platform
+  def self.linux?
+    IS_LINUX
+  end
+end
+
+module UV
+  require 'uv/types/linux.rb' if FFI::Platform.linux?
+  require 'uv/types/unix.rb' if FFI::Platform.unix?
+  require 'uv/types/darwin_x64.rb' if FFI::Platform.mac? and FFI::Platform::ARCH == 'x86_64'
+  require 'uv/types/windows.rb' if FFI::Platform.windows?
+
+  enum :uv_handle_type, [
+    :uv_unknown_handle, 0,
+    :uv_async,
+    :uv_check,
+    :uv_fs_event,
+    :uv_idle,
+    :uv_pipe,
+    :uv_poll,
+    :uv_prepare,
+    :uv_process,
+    :uv_tcp,
+    :uv_timer,
+    :uv_tty,
+    :uv_udp,
+    :uv_ares_task,
+    :uv_file,
+    :uv_handle_type_max
+  ]
+  enum :uv_req_type, [
+    :uv_unknown_req, 0,
+    :uv_connect,
+    :uv_write,
+    :uv_shutdown,
+    :uv_udp_send,
+    :uv_fs,
+    :uv_work,
+    :uv_getaddrinfo,
+    :uv_req_type_private,
+    :uv_req_type_max
+  ]
+  enum :uv_membership, [
+    :uv_leave_group, 0,
+    :uv_join_group
+  ]
+  enum :uv_err_code, [
+    :UNKNOWN, -1,
+    :OK, 0,
+    :EOF, 1,
+    :EADDRINFO, 2,
+    :EACCES, 3,
+    :EAGAIN, 4,
+    :EADDRINUSE, 5,
+    :EADDRNOTAVAIL, 6,
+    :EAFNOSUPPORT, 7,
+    :EALREADY, 8,
+    :EBADF, 9,
+    :EBUSY, 10,
+    :ECONNABORTED, 11,
+    :ECONNREFUSED, 12,
+    :ECONNRESET, 13,
+    :EDESTADDRREQ, 14,
+    :EFAULT, 15,
+    :EHOSTUNREACH, 16,
+    :EINTR, 17,
+    :EINVAL, 18,
+    :EISCONN, 19,
+    :EMFILE, 20,
+    :EMSGSIZE, 21,
+    :ENETDOWN, 22,
+    :ENETUNREACH, 23,
+    :ENFILE, 24,
+    :ENOBUFS, 25,
+    :ENOMEM, 26,
+    :ENOTDIR, 27,
+    :EISDIR, 28,
+    :ENONET, 29,
+    :ENOTCONN, 31,
+    :ENOTSOCK, 32,
+    :ENOTSUP, 33,
+    :ENOENT, 34,
+    :ENOSYS, 35,
+    :EPIPE, 36,
+    :EPROTO, 37,
+    :EPROTONOSUPPORT, 38,
+    :EPROTOTYPE, 39,
+    :ETIMEDOUT, 40,
+    :ECHARSET, 41,
+    :EAIFAMNOSUPPORT, 42,
+    :EAISERVICE, 44,
+    :EAISOCKTYPE, 45,
+    :ESHUTDOWN, 46,
+    :EEXIST, 47,
+    :ESRCH, 48,
+    :ENAMETOOLONG, 49,
+    :EPERM, 50,
+    :ELOOP, 51,
+    :EXDEV, 52,
+    :ENOTEMPTY, 53,
+    :ENOSPC, 54,
+    :EIO, 55,
+    :EROFS, 56,
+    :UV_MAX_ERRORS
+  ]
+  enum :uv_fs_type, [
+    :UV_FS_UNKNOWN, -1,
+    :UV_FS_CUSTOM,
+    :UV_FS_OPEN,
+    :UV_FS_CLOSE,
+    :UV_FS_READ,
+    :UV_FS_WRITE,
+    :UV_FS_SENDFILE,
+    :UV_FS_STAT,
+    :UV_FS_LSTAT,
+    :UV_FS_FSTAT,
+    :UV_FS_FTRUNCATE,
+    :UV_FS_UTIME,
+    :UV_FS_FUTIME,
+    :UV_FS_CHMOD,
+    :UV_FS_FCHMOD,
+    :UV_FS_FSYNC,
+    :UV_FS_FDATASYNC,
+    :UV_FS_UNLINK,
+    :UV_FS_RMDIR,
+    :UV_FS_MKDIR,
+    :UV_FS_RENAME,
+    :UV_FS_READDIR,
+    :UV_FS_LINK,
+    :UV_FS_SYMLINK,
+    :UV_FS_READLINK,
+    :UV_FS_CHOWN,
+    :UV_FS_FCHOWN
+  ]
+  enum :uv_fs_event, [
+    :UV_RENAME, 1,
+    :UV_CHANGE, 2
+  ]
+
+  typedef UvBuf.by_value, :uv_buf_t
+  typedef UvFSStat.by_value, :uv_fs_stat_t
+
+  class UvErr < FFI::Struct
+    layout :code, :uv_err_code,
+           :sys_errno_, :int
+  end
+
+  typedef UvErr.by_value, :uv_err_t
+
+  class Sockaddr < FFI::Struct
+    layout :sa_len, :uint8,
+           :sa_family, :sa_family_t,
+           :sa_data, [:char, 14]
+  end
+
+  class InAddr < FFI::Struct
+    layout :s_addr, :in_addr_t
+  end
+
+  class SockaddrIn < FFI::Struct
+    layout :sin_len, :uint8,
+           :sin_family, :sa_family_t,
+           :sin_port, :in_port_t,
+           :sin_addr, InAddr,
+           :sin_zero, [:char, 8]
+  end
+
+  typedef SockaddrIn.by_value, :sockaddr_in
+
+  class U6Addr < FFI::Union
+    layout :__u6_addr8, [:uint8, 16],
+           :__u6_addr16, [:uint16, 8]
+  end
+
+  class In6Addr < FFI::Struct
+    layout :__u6_addr, U6Addr
+  end
+
+  class SockaddrIn6 < FFI::Struct
+    layout :sin6_len, :uint8,
+           :sin6_family, :sa_family_t,
+           :sin6_port, :in_port_t,
+           :sin6_flowinfo, :uint32,
+           :sin6_addr, In6Addr,
+           :sin6_scope_id, :uint32
+  end
+
+  typedef SockaddrIn6.by_value, :sockaddr_in6
+
+  typedef :pointer, :uv_handle_t
+  typedef :pointer, :uv_fs_event_t
+  typedef :pointer, :uv_stream_t
+  typedef :pointer, :uv_tcp_t
+  typedef :pointer, :uv_udp_t
+  typedef :pointer, :uv_tty_t
+  typedef :pointer, :uv_pipe_t
+  typedef :pointer, :uv_prepare_t
+  typedef :pointer, :uv_check_t
+  typedef :pointer, :uv_idle_t
+  typedef :pointer, :uv_async_t
+  typedef :pointer, :uv_timer_t
+  typedef :pointer, :uv_process_t
+  typedef :pointer, :uv_getaddrinfo_cb
+  typedef :pointer, :addrinfo
+  typedef :pointer, :uv_fs_t
+  typedef :pointer, :uv_work_t
+  typedef :pointer, :uv_loop_t
+  typedef :pointer, :uv_shutdown_t
+  typedef :pointer, :uv_write_t
+  typedef :pointer, :uv_connect_t
+  typedef :pointer, :uv_udp_send_t
+  typedef :int,     :uv_file
+  typedef :pointer, :ares_channel
+  typedef :pointer, :ares_options
+  typedef :pointer, :uv_getaddrinfo_t
+  typedef :pointer, :uv_options_t
+  typedef :pointer, :uv_cpu_info_t
+  typedef :pointer, :uv_interface_address_t
+  typedef :pointer, :uv_fs_t
+  typedef :pointer, :uv_lib_t
+  typedef :pointer, :uv_mutex_t
+  typedef :pointer, :uv_rwlock_t
+  typedef :pointer, :uv_once_t
+  typedef :pointer, :uv_thread_t
+  typedef :int,     :status
+
+  callback :uv_alloc_cb,       [:uv_handle_t, :size_t],                            :uv_buf_t
+  callback :uv_read_cb,        [:uv_stream_t, :ssize_t, :uv_buf_t],                :void
+  callback :uv_read2_cb,       [:uv_pipe_t, :ssize_t, :uv_buf_t, :uv_handle_type], :void
+  callback :uv_write_cb,       [:uv_write_t, :status],                             :void
+  callback :uv_connect_cb,     [:uv_connect_t, :status],                           :void
+  callback :uv_shutdown_cb,    [:uv_shutdown_t, :status],                          :void
+  callback :uv_connection_cb,  [:uv_stream_t, :status],                            :void
+  callback :uv_close_cb,       [:uv_handle_t],                                     :void
+  callback :uv_timer_cb,       [:uv_timer_t, :status],                             :void
+  callback :uv_async_cb,       [:uv_async_t, :status],                             :void
+  callback :uv_prepare_cb,     [:uv_prepare_t, :status],                           :void
+  callback :uv_check_cb,       [:uv_check_t, :status],                             :void
+  callback :uv_idle_cb,        [:uv_idle_t, :status],                              :void
+  callback :uv_getaddrinfo_cb, [:uv_getaddrinfo_t, :status, :addrinfo],            :void
+  callback :uv_exit_cb,        [:uv_process_t, :int, :int],                        :void
+  callback :uv_fs_cb,          [:uv_fs_t],                                         :void
+  callback :uv_work_cb,        [:uv_work_t],                                       :void
+  callback :uv_after_work_cb,  [:uv_work_t],                                       :void
+  callback :uv_fs_event_cb,    [:uv_fs_event_t, :string, :int, :int],              :void
+  callback :uv_udp_send_cb,    [:uv_udp_send_t, :int],                             :void
+  callback :uv_udp_recv_cb,    [:uv_udp_t, :ssize_t, :uv_buf_t, :pointer, :uint],  :void
+  callback :uv_cb,             [],                                                 :void
+end

data/lib/uv/types/darwin_x64.rb

@@ -0,0 +1,10 @@
+module UV
+  class UvFSStat < FFI::Struct
+    layout :st_dev, :dev_t, :st_mode, :mode_t, :st_nlink, :nlink_t,
+    :st_ino, :ino_t, :st_uid, :uid_t, :st_gid, :gid_t, :st_rdev,
+    :dev_t, :st_atime, :time_t, :st_mtime, :time_t, :st_ctime,
+    :time_t, :st_size, :off_t, :st_blocks, :blkcnt_t, :st_blksize,
+    :blksize_t, :st_flags, :uint32, :st_gen, :uint32, :st_lspare,
+    :int32, :st_qspare_0, :int64, :st_qspare_1, :int64
+  end
+end

data/lib/uv/types/linux.rb

@@ -0,0 +1,6 @@
+module UV
+  # blksize_t, in_addr_t is not yet part of types.conf on linux
+  typedef :long, :blksize_t
+  typedef :uint32, :in_addr_t
+  typedef :ushort, :in_port_t
+end

data/lib/uv/types/unix.rb

@@ -0,0 +1,12 @@
+module UV
+  class UvBuf < FFI::Struct
+    layout :base, :pointer, :len, :size_t
+  end
+
+  class UvFSStat < FFI::Struct
+    layout :st_dev, :dev_t, :st_ino, :ino_t, :st_mode, :mode_t, :st_nlink, :nlink_t,
+    :st_uid, :uid_t, :st_gid, :gid_t, :st_rdev, :dev_t, :st_size, :off_t,
+    :st_blksize, :blksize_t, :st_blocks, :blkcnt_t, :st_atime, :time_t,
+    :st_mtime, :time_t, :st_ctime, :time_t
+  end
+end

data/lib/uv/types/windows.rb

@@ -0,0 +1,13 @@
+module UV
+  # win32 has a different uv_buf_t layout to everything else.
+  class UvBuf < FFI::Struct
+    layout :len, :ulong, :base, :pointer
+  end
+
+  # win32 uses _stati64
+  class UvFSStat < FFI::Struct
+    layout :st_gid, :gid_t, :st_atime, :time_t, :st_ctime, :time_t, :st_dev, :dev_t,
+    :st_ino, :ino_t, :st_mode, :mode_t, :st_mtime, :time_t, :st_nlink, :nlink_t,
+    :st_rdev, :dev_t, :st_size, :off_t, :st_uid, :uid_t
+  end
+end

data/lib/uv/udp.rb

@@ -0,0 +1,215 @@
+module UV
+  class UDP
+    include Handle, Net
+
+    def bind(ip, port, ipv6_only = false)
+      assert_type(String, ip, "ip must be a String")
+      assert_type(Integer, port, "port must be an Integer")
+      assert_boolean(ipv6_only, "ipv6_only must be a Boolean")
+
+      @socket = create_socket(IPAddr.new(ip), port)
+      @socket.bind(ipv6_only)
+
+      self
+    end
+
+    def sockname
+      sockaddr, len = get_sockaddr_and_len
+      check_result! UV.udp_getsockname(handle, sockaddr, len)
+      get_ip_and_port(UV::Sockaddr.new(sockaddr), len.get_int(0))
+    end
+
+    def join(multicast_address, interface_address)
+      assert_type(String, multicast_address, "multicast_address must be a String")
+      assert_type(String, interface_address, "interface_address must be a String")
+
+      check_result! UV.udp_set_membership(handle, multicast_address, interface_address, :uv_join_group)
+
+      self
+    end
+
+    def leave(multicast_address, interface_address)
+      assert_type(String, multicast_address, "multicast_address must be a String")
+      assert_type(String, interface_address, "interface_address must be a String")
+
+      check_result! UV.udp_set_membership(handle, multicast_address, interface_address, :uv_leave_group)
+
+      self
+    end
+
+    def start_recv(&block)
+      assert_block(block)
+      assert_arity(4, block)
+
+      @recv_block = block
+
+      check_result! UV.udp_recv_start(handle, callback(:on_allocate), callback(:on_recv))
+
+      self
+    end
+
+    def stop_recv
+      check_result! UV.udp_recv_stop(handle)
+    end
+
+    def send(ip, port, data, &block)
+      assert_block(block)
+      assert_arity(1, block)
+      assert_type(String, ip, "ip must be a String")
+      assert_type(Integer, port, "port must be an Integer")
+      assert_type(String, data, "data must be a String")
+
+      @send_block = block
+
+      @socket = create_socket(IPAddr.new(ip), port)
+      @socket.send(data, callback(:on_send))
+
+      self
+    end
+
+    def enable_multicast_loop
+      check_result! UV.udp_set_multicast_loop(handle, 1)
+
+      self
+    end
+
+    def disable_multicast_loop
+      check_result! UV.udp_set_multicast_loop(handle, 0)
+
+      self
+    end
+
+    def multicast_ttl=(ttl)
+      assert_type(Integer, ttl, "ttl must be an Integer")
+
+      check_result! UV.udp_set_multicast_ttl(handle, ttl)
+
+      self
+    end
+
+    def enable_broadcast
+      check_result! UV.udp_set_broadcast(handle, 1)
+
+      self
+    end
+
+    def disable_broadcast
+      check_result! UV.udp_set_broadcast(handle, 0)
+
+      self
+    end
+
+    def ttl=(ttl)
+      assert_type(Integer, ttl, "ttl must be an Integer")
+
+      check_result! UV.udp_set_ttl(handle, Integer(ttl))
+
+      self
+    end
+
+    private
+
+    def on_allocate(client, suggested_size)
+      UV.buf_init(UV.malloc(suggested_size), suggested_size)
+    end
+
+    def on_recv(handle, nread, buf, sockaddr, flags)
+      e = check_result(nread)
+      base = buf[:base]
+      unless e
+        data = base.read_string(nread)
+      end
+      UV.free(base)
+      unless sockaddr.null?
+        ip, port = get_ip_and_port(UV::Sockaddr.new(sockaddr))
+      end
+      @recv_block.call(e, data, ip, port)
+    end
+
+    def on_send(req, status)
+      UV.free(req)
+      @send_block.call(check_result(status))
+    end
+
+    def create_socket(ip, port)
+      if ip.ipv4?
+        Socket4.new(@loop, handle, ip, port)
+      else
+        Socket6.new(@loop, handle, ip, port)
+      end
+    end
+
+    module SocketMethods
+      include Resource
+
+      def initialize(loop, udp, ip, port)
+        @loop, @udp, @sockaddr = loop, udp, ip_addr(ip.to_s, port)
+      end
+
+      def bind(ipv6_only = false)
+        check_result! udp_bind(ipv6_only)
+      end
+
+      def send(data, callback)
+        check_result! udp_send(data, callback)
+      end
+
+      private
+      def send_req
+        UV.create_request(:uv_udp_send)
+      end
+
+      def buf_init(data)
+        UV.buf_init(FFI::MemoryPointer.from_string(data), data.respond_to?(:bytesize) ? data.bytesize : data.size)
+      end
+    end
+
+    class Socket4
+      include SocketMethods
+
+      private
+      def ip_addr(ip, port)
+        UV.ip4_addr(ip, port)
+      end
+
+      def udp_bind(ipv6_only)
+        UV.udp_bind(@udp, @sockaddr, 0)
+      end
+
+      def udp_send(data, callback)
+        UV.udp_send(
+          send_req,
+          @udp,
+          buf_init(data),
+          1,
+          @sockaddr,
+          callback
+        )
+      end
+    end
+
+    class Socket6 < Socket
+      include SocketMethods
+
+      private
+      def ip_addr(ip, port)
+        UV.ip6_addr(ip, port)
+      end
+
+      def udp_bind(ipv6_only)
+        UV.udp_bind6(@udp, @sockaddr, ipv6_only ? 1 : 0)
+      end
+
+      def udp_send(data, callback)
+        UV.udp_send6(
+          send_req,
+          @udp,
+          buf_init(data),
+          1,
+          @sockaddr,
+          callback
+        )
+      end
+    end
+  end
+end