win32-symlink 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08a2aebcc89a9a0521a80869c5f9c045a6774374
+  data.tar.gz: 4aebff75b3ccd259ae3983f1577b959829f150e1
+SHA512:
+  metadata.gz: 2a9451a6762f0cf0153dc760008a2f2e36f41a7884154db1bd0b6293b56d72ead206be01eecf60b8eef46ee37dffa9e308b133471be389d364167ffa7eafb4a4
+  data.tar.gz: 7e1af87d5b5cc8ffcdc135182b6563ec4a8cbc7bd42a074ac27684955ee7f5d3cf7a1eddb637c54506d0676a769acd195f18eef62a9ee90856bdafbf430d7dc6

data/Gemfile

@@ -0,0 +1,5 @@
+# -*- ruby -*-
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in win32-symlink.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 boris
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Win32::Symlink
+
+Since the standard ruby library lacks symlink functions on Windows, this
+little library attempts to fill the gap.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'win32-symlink'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install win32-symlink
+
+## Usage
+
+This library implements the following functons that mimic their ruby
+counterparts:
+
+    readlink(link_name) -> file_name
+    symlink?(link_name) -> true or false
+    symlink(old_name, new_name) -> 0
+

data/Rakefile

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$gemspec = Bundler.load_gemspec('win32-symlink.gemspec')
+
+Rake::TestTask.new do |t|
+  t.warning = true
+end
+
+load 'tasks/ext.rake'
+
+task :default => [:compile, :test]

data/ext/win32/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+
+if CONFIG['CXXFLAGS'] == '$(cxxflags)'
+  CONFIG['CXXFLAGS'] = CONFIG['cxxflags'].clone
+end
+
+# these are not relevant for C++
+CONFIG['warnflags'].sub! '-Wdeclaration-after-statement', ''
+CONFIG['warnflags'].sub! '-Wimplicit-function-declaration', ''
+
+try_cppflags $CPPFLAGS.sub(/_WIN32_WINNT=\S+/, '_WIN32_WINNT=0x600')
+create_makefile 'win32_symlink'

data/ext/win32/win32-symlink.cpp

@@ -0,0 +1,297 @@
+#include "ruby.h"
+
+#define filecp_to_wstr(str, plen) cstr_to_wstr(filecp(), str, -1, plen)
+
+typedef BOOL (WINAPI* create_symbolic_linkW_t)(LPWSTR src, LPWSTR dest, DWORD flags);
+create_symbolic_linkW_t create_symbolic_linkW = NULL;
+
+
+typedef struct _REPARSE_DATA_BUFFER
+{
+	ULONG ReparseTag;
+	USHORT ReparseDataLength;
+	USHORT Reserved;
+	union
+	{
+		struct
+		{
+			USHORT SubstituteNameOffset;
+			USHORT SubstituteNameLength;
+			USHORT PrintNameOffset;
+			USHORT PrintNameLength;
+			ULONG Flags;
+			WCHAR PathBuffer[1];
+		} SymbolicLinkReparseBuffer;
+		struct
+		{
+			USHORT SubstituteNameOffset;
+			USHORT SubstituteNameLength;
+			USHORT PrintNameOffset;
+			USHORT PrintNameLength;
+			WCHAR PathBuffer[1];
+		} MountPointReparseBuffer;
+		struct
+		{
+			UCHAR DataBuffer[1];
+		} GenericReparseBuffer;
+	} DUMMYUNIONNAME;
+} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
+
+
+static inline UINT
+filecp(void)
+{
+	UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+	return cp;
+}
+
+static wchar_t *
+cstr_to_wstr(UINT code_page, const char *str, int clen, int *wstr_len)
+{
+	int len;
+	wchar_t* wstr;
+
+	len = MultiByteToWideChar(code_page, 0, str, clen, NULL, 0);
+	wstr = (wchar_t *)xmalloc(len * sizeof(wchar_t));
+
+	MultiByteToWideChar(code_page, 0, str, clen, wstr, len);
+	if( wstr_len )
+		*wstr_len = len;
+	return wstr;
+}
+
+static VALUE
+wstr_to_str(UINT code_page, const wchar_t* wstr, int clen)
+{
+	int len, term_len;
+	VALUE v;
+	term_len = clen < 0 ? 1 : 0;
+	len = WideCharToMultiByte(code_page, 0, wstr, clen, NULL, 0, NULL, NULL) - term_len;
+	v = rb_str_new(NULL, len);
+	WideCharToMultiByte(code_page, 0, wstr, clen, RSTRING_PTR(v), len + term_len, NULL, NULL);
+	return v;
+}
+
+static VALUE
+make_error_str(VALUE klass, const char* fmt, ...)
+{
+	VALUE exc;
+	VALUE str;
+
+	va_list va;
+	va_start(va, fmt);
+	str = rb_vsprintf(fmt, va);
+	va_end(va);
+	exc = rb_exc_new3(klass, str);
+	rb_str_free(str);
+	return exc;
+}
+
+static VALUE
+make_api_error(const char* msg)
+{
+	DWORD w32_err;
+	int myerrno;
+	w32_err = GetLastError();
+	myerrno = rb_w32_map_errno(w32_err);
+	return rb_syserr_new( myerrno == EINVAL ? w32_err : myerrno, msg);
+}
+
+static wchar_t*
+resolve_api_path(wchar_t* path)
+{
+	if( 0 == wcsncmp(L"\\??\\UNC\\", path, 8) )
+	{
+		path += 6;
+		*path =  L'\\';
+	}
+	else if( 0 == wcsncmp(L"\\??\\", path, 4) )
+	{
+		path += 4;
+	}
+	return path;
+}
+
+static VALUE
+win32_readlink(const char* file)
+{
+	VALUE error = Qnil;
+	VALUE target = Qnil;
+	HANDLE h = INVALID_HANDLE_VALUE;
+	bool ok = true;
+	REPARSE_DATA_BUFFER* buf = NULL;
+	const size_t buf_size = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
+
+	buf = (REPARSE_DATA_BUFFER*)xmalloc(buf_size);
+	if(ok)
+	{
+		const DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
+		const DWORD access_mode = FILE_READ_EA;
+		const DWORD attributes =
+				  FILE_FLAG_BACKUP_SEMANTICS
+				| FILE_ATTRIBUTE_REPARSE_POINT
+				| FILE_FLAG_OPEN_REPARSE_POINT;
+
+		h = CreateFile( file, access_mode, share_mode,
+			0, OPEN_EXISTING, attributes, NULL);
+
+		if(!(ok = (h != INVALID_HANDLE_VALUE)))
+		{
+			error = make_api_error(file);
+		}
+	}
+
+	if(ok)
+	{
+		DWORD returned_size;
+		ok = 0 != DeviceIoControl (h, FSCTL_GET_REPARSE_POINT,
+			NULL, 0, buf, buf_size, &returned_size, NULL);
+		if(!ok)
+		{
+			error = make_api_error(file);
+		}
+	}
+	if(ok)
+	{
+		wchar_t* raw_target = NULL;
+		long target_len = 0;
+
+		switch (buf->ReparseTag)
+		{
+		case IO_REPARSE_TAG_MOUNT_POINT:
+		{
+			raw_target = &buf->MountPointReparseBuffer.PathBuffer[
+				buf->MountPointReparseBuffer.SubstituteNameOffset / sizeof(wchar_t)];
+			target_len = buf->MountPointReparseBuffer.SubstituteNameLength / sizeof(wchar_t);
+			break;
+		}
+		case IO_REPARSE_TAG_SYMLINK:
+		{
+			raw_target = &buf->SymbolicLinkReparseBuffer.PathBuffer[
+				buf->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(wchar_t)];
+			target_len = buf->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(wchar_t);
+			break;
+		}
+		default:
+			ok = false;
+			error = make_error_str(rb_eIOError, "file %s is not a symlink", file);
+		}
+		if(ok)
+		{
+			wchar_t* resolved;
+			resolved = resolve_api_path(raw_target);
+			target_len -= resolved - raw_target;
+			target = wstr_to_str(filecp(), resolved, target_len);
+		}
+	}
+
+
+	if( h != INVALID_HANDLE_VALUE )
+	{
+		CloseHandle(h);
+	}
+	xfree(buf);
+
+	if( !NIL_P(error) )
+	{
+		rb_exc_raise(error);
+	}
+	return target;
+}
+
+static VALUE
+rb_readlink(VALUE mod, VALUE file)
+{
+	(void)mod;
+	FilePathValue(file);
+	file = rb_str_encode_ospath(file);
+	return win32_readlink(RSTRING_PTR(file));
+}
+
+static VALUE
+rb_symlink_p(VALUE mod, VALUE file)
+{
+	(void)mod;
+	DWORD attrs;
+	FilePathValue(file);
+	file = rb_str_encode_ospath(file);
+	attrs = GetFileAttributes(RSTRING_PTR(file));
+	if( attrs == INVALID_FILE_ATTRIBUTES )
+	{
+		rb_exc_raise(make_api_error(RSTRING_PTR(file)));
+	}
+	return (attrs & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
+}
+
+static bool
+is_directory(wchar_t* path)
+{
+	HANDLE h = INVALID_HANDLE_VALUE;
+	WIN32_FIND_DATAW fd;
+	h = FindFirstFileW(path, &fd);
+	if( h != INVALID_HANDLE_VALUE )
+	{
+		FindClose(h);
+		return (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0 ;
+	}
+	return false;
+}
+
+static VALUE
+rb_symlink(VALUE mod, VALUE target, VALUE symlink)
+{
+	(void)mod;
+
+	VALUE error = Qnil;
+	wchar_t* wtarget = NULL;
+	wchar_t* wsymlink = NULL;
+	BOOL res;
+	DWORD flags = 0;
+
+	target = FilePathValue(target);
+	symlink = FilePathValue(symlink);
+	target = rb_str_encode_ospath(target);
+	symlink = rb_str_encode_ospath(symlink);
+
+	wtarget = filecp_to_wstr(RSTRING_PTR(target), NULL);
+	wsymlink = filecp_to_wstr(RSTRING_PTR(symlink), NULL);
+
+	if( is_directory(wsymlink) )
+	{
+		flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
+	}
+	res = create_symbolic_linkW(wsymlink, wtarget, flags);
+	if( !res )
+	{
+		error = make_api_error(RSTRING_PTR(target));
+	}
+
+	xfree(wtarget);
+	xfree(wsymlink);
+
+	if( !NIL_P(error) )
+	{
+		rb_exc_raise(error);
+	}
+	return INT2FIX(0);
+}
+
+extern "C" void
+Init_win32_symlink()
+{
+	VALUE mod_win32;
+	VALUE mod;
+
+	mod_win32 = rb_define_module("Win32");
+	mod = rb_define_module_under(mod_win32, "Symlink");
+
+	rb_define_module_function(mod, "readlink", RUBY_METHOD_FUNC(rb_readlink), 1);
+	rb_define_module_function(mod, "symlink?", RUBY_METHOD_FUNC(rb_symlink_p), 1);
+
+	create_symbolic_linkW = (create_symbolic_linkW_t)GetProcAddress(
+		GetModuleHandle("kernel32.dll"), "CreateSymbolicLinkW");
+	if( create_symbolic_linkW )
+	{
+		rb_define_module_function(mod, "symlink", RUBY_METHOD_FUNC(rb_symlink), 2);
+	}
+}

data/lib/win32/symlink.rb

@@ -0,0 +1,2 @@
+require_relative 'symlink/win32_symlink'
+require_relative 'symlink/version'

data/lib/win32/symlink/version.rb

@@ -0,0 +1,12 @@
+module Win32
+  module Symlink
+    module Version
+      MAJOR = 0
+      MINOR = 1
+      PATCH = 0
+      BUILD = nil
+      STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join '.'
+    end
+    VERSION = Version::STRING
+  end
+end

data/tasks/ext.rake

@@ -0,0 +1,7 @@
+# -*- ruby -*-
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('win32_symlink', $gemspec) do |ext|
+  ext.ext_dir = 'ext/win32'
+  ext.lib_dir = 'lib/win32/symlink'
+end
+

data/test/test_win32_symlink.rb

@@ -0,0 +1,60 @@
+$LOAD_PATH.unshift File.join(File.dirname(File.dirname(__FILE__)), 'ext')
+
+# puts $LOAD_PATH
+
+require 'test/unit'
+require 'win32/symlink'
+include Win32
+
+class Errno::E4390 < SystemCallError
+  # The file is not a reparse point
+end
+class Errno::E1314 < SystemCallError
+  # A required privilege is not set
+end
+
+class TC_Win32Symlink < Test::Unit::TestCase
+
+  def setup
+    @users_dir = File.join(ENV['SYSTEMDRIVE'], '/Users')    
+  end
+
+  def test_bad_args
+    assert_raises(Errno::ENOENT) {Symlink.symlink? ""}
+    assert_raises(TypeError) { Symlink.symlink? nil }
+    assert_raises(TypeError) { Symlink.symlink?(Object.new) }
+    assert_raises(TypeError) { Symlink.symlink "", nil }
+    assert_raises(TypeError) { Symlink.symlink nil, "" }
+  end
+
+  def test_system_links
+    assert(Symlink.symlink?(File.join(@users_dir, "All Users")))
+    assert(!Symlink.symlink?(ENV['WINDIR']))
+  end
+
+  def test_readlink
+    assert_equal(Symlink.readlink(File.join(@users_dir, "All Users")), ENV['ALLUSERSPROFILE'])
+  end
+
+  def test_nonlink
+    assert_raises(Errno::E4390) { Symlink.readlink(ENV['WINDIR']) }
+  end
+
+  def test_makelink
+    Dir.chdir(ENV["TMP"]) do
+      IO::write("symlink-test-file", "test")
+      begin
+        Symlink.symlink("symlink-test-file", "symlink-test-symlink") 
+        assert(Symlink.symlink? "symlink-test-symlink")
+      rescue Errno::E1314 => e
+        skip e.message
+      end
+    end
+  end
+
+  def teardown
+    Dir.glob(File.join(ENV['TMP'], 'symlink-test*')).each {|f| File::unlink f}
+  end
+
+end
+

data/win32-symlink.gemspec

@@ -0,0 +1,35 @@
+# -*- ruby -*-
+require File.expand_path('../lib/win32/symlink/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Boris Kropivnitsky']
+  gem.email         = ['boris.kro@gmail.com']
+  gem.description   = <<DESC
+Symlink functions for Windows (Vista and above)
+DESC
+  gem.summary       = 'symlink functions for Windows'
+  gem.homepage      = ''
+
+  gem.files         = %w{
+Gemfile
+LICENSE
+README.md
+Rakefile
+ext/win32/extconf.rb
+ext/win32/win32-symlink.cpp
+lib/win32/symlink.rb
+lib/win32/symlink/version.rb
+lib/win32/symlink/win32_symlink.so
+tasks/ext.rake
+test/test_win32_symlink.rb
+win32-symlink.gemspec
+}
+  gem.extensions    = ['ext/win32/extconf.rb']
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'win32-symlink'
+  gem.require_paths = ['lib']
+  gem.version       = Win32::Symlink::VERSION
+  gem.licenses      = ['MIT']
+  gem.add_development_dependency 'bundler'
+  gem.add_development_dependency 'rake-compiler'
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: win32-symlink
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Boris Kropivnitsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Symlink functions for Windows (Vista and above)
+email:
+- boris.kro@gmail.com
+executables: []
+extensions:
+- ext/win32/extconf.rb
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ext/win32/extconf.rb
+- ext/win32/win32-symlink.cpp
+- lib/win32/symlink.rb
+- lib/win32/symlink/version.rb
+- lib/win32/symlink/win32_symlink.so
+- tasks/ext.rake
+- test/test_win32_symlink.rb
+- win32-symlink.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: symlink functions for Windows
+test_files:
+- test/test_win32_symlink.rb