npgrt 0.0.3 → 0.0.4

data/lib/npgrt/require.rb~

@@ -6,8 +6,31 @@ module NPGRT
 			super a
 		end
 
-		alias primitive_require require
+		ADDPATH = []
+
+		def binary_forms(a)
+			w = NPGRT::PlatformWidth.to_s
+			[ a, a+".dll", a+".so", 
+     			  File.basename(a) + "_" + w + File.extname(a),
+			  File.basename(a) + "_" + w + ".dll",
+			  File.basename(a) + "_" + w + ".so"
+			]
+		end
 
+		def require_binary(a)
+			path = binary_forms(a).inject([]){|ret, v|
+				ret.concat Gem.find_files v
+			}
+			v = path.map{|x| 
+				FileTest.file?(x) ? NPGRT.normalize_pathsep_os(File.dirname(x)) : nil
+			}.compact - ADDPATH
+			ENV['path'] += ";" + v.join(";")
+			ADDPATH.concat v
+		end
+
+		alias primitive_require require
+		private :primitive_require
+		
 		def require(a)
 		     primitive_require(a) do |x|
                         try_build  x

data/lib/npgrt/version.rb

@@ -1,3 +1,5 @@
 module NPGRT
-  VERSION = "0.0.3"
+  VERSION       = "0.0.4"
+  PlatformWidth = [nil].pack("p").size * 8
+  PtrType = PlatformWidth == 32 ? "L" : "Q"
 end

data/lib/npgrt/version.rb~

@@ -1,3 +1,5 @@
 module NPGRT
-  VERSION = "0.0.3"
+  VERSION       = "0.0.3"
+  PlatformWidth = [nil].pack("p").size * 8
+  PtrType = PlatformWidth == 32 ? "L" : "Q"
 end

data/lib/npgrt/win32api.rb

@@ -1,16 +1,32 @@
 module NPGRT
 	require 'Win32API' unless defined? ::Win32API
 	module Win32API
+		
 		W = ::Win32API
 		class API
 			def initialize(dll, func, param = nil, ret = "L")
-				@dll, @func, @param, @ret = dll, func, param, ret
-				
+				@dll, @func, @param, @ret = dll, func, param, ret	
+			end
+
+			def findapi(dll, func, param, ret)
+				[dll, File.basename(dll) + "_" + NPGRT::PlatformWidth.to_s + File.extname(dll)].each{|d|
+					[func, func + "A", func + "W"].each{|f|
+						if (a = begin 
+						       W.new(d, f, param, ret)
+						     rescue LoadError, RuntimeError
+							nil
+						     end 
+						   )
+							return a
+						end
+					}
+				}
+				raise Errno::ENOENT, " NPGRT::API: Can't find a proper DLL for #{dll}!#{func}"
 			end
 
 			def call(*args)
 				param = @param || guess(args)
-				@api ||= W.new(@dll, @func, param, @ret)
+				@api ||= findapi(@dll, @func, param, @ret)
 				@api.call(*args)
 			end
 
@@ -27,13 +43,16 @@ module NPGRT
 		    API.new dll, func, params, ret
 		end
 		
+		def checked_api(dll, func, params = nil, ret = "L", info = "Error!", exclass = RuntimeError)
+			lambda{|*a| raise exclass, info if 0 != API.new(dll, func, params, ret).call(*a)}
+		end
 		def addressof(dll, func)
 			dl = api('kernel32', 'GetModuleHandle').call(dll) 
 			dl = (dl == 0) ? dl : api('kernel32', 'LoadLibrary').call(dll)	
 			api('kernel32', 'GetProcAddress').call dl, func
 		end
 
-		def memwrite(addr, buf, len = buf.size)
+		def memwrite(addr, buf, len = buf.length)
 			api('Kernel32', 'RtlMoveMemory').call addr, buf, len
 		end
 
@@ -52,13 +71,13 @@ module NPGRT
 			memread(grant_all(addr, size), size)
 		end
 
-		def memwrite!(addr, buf, len = buf.size)
-			memread(grant_all(addr, len), buf, len)
+		def memwrite!(addr, buf, len = buf.length)
+			memwrite(grant_all(addr, len), buf, len)
 		end
 
 		CP_UTF8 = {cp: 65001, suffix:"\0", encoding: "utf-8"}
-		CP_ANSI = {cp: 0, suffix:"\0", encoding: "ascii-8bit"}
-		CP_OEM  = CP_ANSI
+		CP_ANSI = {cp: 0, suffix:"\0", encoding: "us-ascii"}
+		CP_ACP = CP_OEM  = CP_ANSI
 		CP_GBK  = {cp: 65001, suffix: "\0", encoding: "gbk"}
 		
 		def to_unicode(string, codepage = CP_UTF8)
@@ -72,14 +91,13 @@ module NPGRT
 			len = api('Kernel32', 'WideCharToMultiByte').call codepage[:cp], 0, string, -1, 0, 0, 0, 0
 			buf = "\0"*len
 			api('Kernel32',  'WideCharToMultiByte').call codepage[:cp], 0, string, -1, buf, len, 0, 0
-			b = buf[0..-1].sub(/\0+$/){}
-			if b.respond_to?(:force_encoding)
-				b.force_encoding(defined?($RGSS_SCRIPTS) ?
+			if buf.respond_to?(:force_encoding)
+				buf.force_encoding(defined?($RGSS_SCRIPTS) ?
 					         'utf-8' : 	 
 						 codepage[:encoding])
 			else
-				b
-			end
+				buf
+			end[0..-1].sub(/\0+$/){}
 		end
 
 		def strread(addr)
@@ -92,13 +110,314 @@ module NPGRT
 			to_codepage(memread(addr, len*2+2))
 		end
 
-	        	
+		INI_VALUE_MAX = 2048
+	        def iniread(app, key, ini = "Game.ini")
+			buf = "\0\0"*INI_VALUE_MAX
+			ini = normalize_pathsep_os ini
+			app, key, ini = [app, key, ini].map{|x| to_unicode(x + "\0\0")+"\0\0"}
+			len = api('kernel32', 'GetPrivateProfileStringW').call(app, key, "", buf, INI_VALUE_MAX, ini)
+			to_codepage buf
+		end	
 
+		def iniwrite(app, key, value, ini = "Game.ini")
+			ini = normalize_pathsep_os ini
+			app, key, value, ini = [app, key, value, ini].map{|x| to_unicode(x + "\0\0")+"\0\0"}	
+    			api('kernel32', 'WritePrivateProfileStringW').call(
+				app, key, value, ini
+			)
+		end
 
 
+		module REG
+			HKEY_CLASSES_ROOT,
+			HKEY_CURRENT_USER,
+			HKEY_LOCAL_MACHINE,
+			HKEY_USERS,
+			HKEY_PERFORMANCE_DATA,
+			HKEY_CURRENT_CONFIG,
+			HKEY_DYN_DATA	= *(0x80000000..0x80000010)
+
+			HKCR = HKEY_CLASSES_ROOT
+			HKCU = HKEY_CURRENT_USER
+			HKLM = HKEY_LOCAL_MACHINE
+
+			REG_NONE = 0
+			REG_SZ = 1
+			REG_EXPAND_SZ = 2
+			REG_BINARY = 3
+			REG_DWORD = 4
+			REG_DWORD_BIG_ENDIAN = 5
+			REG_MULTI_SZ = 7
+
+
+			ESUCCESS = 0
+			EMOREDATA = 234
+			BYTEINC = 4096
+		end
+
+		def regopenkey(path, valuename)
+			path =~ /([^\\]*)\\(.*)/
+			whole, main, child = *$~
+			main = REG.const_get(main)
+			key = [0].pack(NPGRT::PtrType)
+			child = to_unicode(child + "\0\0")+"\0\0"
+			valuename = case valuename
+				when 0, nil
+					0
+				else
+					to_unicode(valuename+"\0\0")+"\0\0"
+				end
+			checked_api(
+				'advapi32', 'RegOpenKeyW', nil, 'L', "Open Key #{path} Error!"
+			).call(
+			       	main, child, key
+			)
+			key = key.unpack(NPGRT::PtrType).first
+			[key, valuename]
+		end
+
+		def regclosekey(key)
+			api('advapi32', 'RegCloseKey').call key
+		end
+		def regread(path, valuename = 0, type = :REG_SZ)	
+			type = REG.const_get(type) if Symbol === type	
+			key, valuename = regopenkey(path, valuename)
+			len = REG::BYTEINC
+			plen = [len].pack(NPGRT::PtrType)
+			buf = "\0\0"*len
+			ptype = [type].pack(NPGRT::PtrType)
+			ret = api('advapi32', 'RegQueryValueExW').call(key, valuename, 0, ptype, buf, plen)
+			while ret == REG::EMOREDATA
+				len += REG::BYTEINC
+				plen =  [len].pack(NPGRT::PtrType)
+				buf = "\0\0"*len
+				ret = api('advapi32', 'RegQueryValueExW').call(key, valuename, 0, ptype, buf, plen)
+			
+			end
+			if ret == REG::ESUCCESS
+				return buf[0, plen.unpack(NPGRT::PtrType).first*2]
+			else
+				raise "Query Key #{path} failed"
+			end
+		ensure
+			regclosekey key
+		end
+
+		def regstrread(type, valuename = "")
+			val = regread(type, valuename)
+			to_codepage val + "\0\0"
+		end
+
+		def regwrite(path, valuename = nil, value = "", type = :REG_SZ)
+			key, valuename = regopenkey(path, valuename)
+			type = REG.const_get(type) if Symbol === type	
+			raise "RegWrite #{path} Error!" if 0 != api('advapi32', 'RegSetValueExW').call(
+				key,
+				valuename,
+				0,
+				type,
+				value,
+				value.length
+			)
+			return true
+		ensure
+			regclosekey key
+		end
+
+		def regstrwrite(path, valuename = nil, value = "")
+			regwrite(path, valuename, to_unicode(value+"\0\0")+"\0\0", :REG_SZ)
+		end
+
+		extend self
+		Win32File = Struct.new(:read, :write, :close, :flush)
+		ReadFile  = api('kernel32', 'ReadFile')
+		WriteFile = api('kernel32', 'WriteFile')
+		CloseFile = api('Kernel32', 'CloseHandle')
+		TYPE_VOIDP = NPGRT::PtrType
+		OS64 = TYPE_VOIDP == "Q"
+		PTRLEN = OS64 ? 8 : 4
+
+		def hfileread(handle, len)
+			buf = "\0"*len
+			llen = [0].pack(TYPE_VOIDP)
+		 	ret = ReadFile.call(handle, buf, len, llen, 0)
+			outlen = llen.unpack(TYPE_VOIDP).first
+			ret != 0 ? buf[0, outlen] : nil
+		end	
+
+		def hfilewrite(handle, buf, len = buf.to_str.length)
+			llen = [0].pack(TYPE_VOIDP)
+			ret = WriteFile.call(handle, buf.to_str, len, llen, 0)
+			outlen = llen.unpack(TYPE_VOIDP).first
+			ret != 0 ? outlen : nil
+		end
+
+		def hfilereada(handle, len)
+			ret = hfileread(handle, len)
+			!ret ? ret : to_codepage(to_unicode(ret+"\0\0", CP_ACP)+"\0\0")
+		end
+
+		def hfilereadw(handle, len)
+			ret = hfileread(handle, len)
+			!ret ? ret : to_codepage(ret+"\0\0")
+		end
+
+
+		STARTUPINFOTYPE = {
+			:sizeof => OS64 ? 104 : 68,
+			:show   => OS64 ? 64  : 48,
+			:handles => OS64 ? [80, 88, 96] : [56, 60, 64]
+		}
+
+		CreatePipe = api('Kernel32', 'CreatePipe')
+		def winpipe
+			buf = "\0"*(PTRLEN*2)
+			sa = [8+PTRLEN, nil, 1].pack(TYPE_VOIDP + "p" + TYPE_VOIDP)
+			addr = [buf].pack("p").unpack(TYPE_VOIDP).first
+			CreatePipe.call addr, addr+PTRLEN, sa, 1
+			ret = buf.unpack(TYPE_VOIDP*2)
+			{:in => ret[0], :out => ret[1]}
+		end
+		def open3(path, dir = nil, env = nil)
+			si = "\0"*STARTUPINFOTYPE[:sizeof]
+			api('Kernel32', 'GetStartupInfoW').call si
+			si[STARTUPINFOTYPE[:show], 2] = [0].pack("S")
+		        stdin, stdout, stderr = winpipe, winpipe, winpipe
+			si[STARTUPINFOTYPE[:handles][0], PTRLEN] = [stdin[:in]].pack(TYPE_VOIDP)
+			si[STARTUPINFOTYPE[:handles][1], PTRLEN] = [stdout[:out]].pack(TYPE_VOIDP)
+			si[STARTUPINFOTYPE[:handles][2], PTRLEN] = [stderr[:out]].pack(TYPE_VOIDP)
+			pi = "\0"*PTRLEN*4
+			path = 	to_unicode(path + "\0\0")+"\0\0"
+			dir = 	dir == nil ? nil : to_unicode(dir + "\0\0")+"\0\0"
+			env = env == nil ? nil : to_unicode(env + "\0\0")+"\0\0"
+			api('Kernel32', 'CreateProcessW').call(
+				0,
+				path,
+				0,
+				0,
+				1,
+				0,
+				0,
+				dir,
+				si,
+				pi,
+			)
+			CloseFile.call(stdin[:in])
+			CloseFile.call(stdout[:out])
+			CloseFile.call(stderr[:out])
+			u = pi.unpack(TYPE_VOIDP*4)
+			proc_info = Hash[ [:process, :thread, :pid, :tid].zip(u) ]
+			CloseFile.call(proc_info[:process])
+			CloseFile.call(proc_info[:thread])
+			ret = yield stdin[:out], stdout[:in], stderr[:in], proc_info
+			api('Kernel32', 'TerminateProcess').call proc_info[:process], ret
+		end
+
+		def popen(path, dir = nil, env = nil)
+			open3 path, dir, env do |a, b, c, d|
+				yield a,b
+			end
+		end
+			
+		CloseSocket = api('ws2_32', 'closesocket')
+		OpenSocket  = api('ws2_32', 'socket')
+		Connect     = api('ws2_32', 'connect')
+		Send        = api('ws2_32', 'send')
+		Recv        = api('ws2_32', 'recv')
+		def udpnew(addr = nil)
+			addr = sockaddr(*addr) if Array === addr
+			so = OpenSocket.call 2, 2, 0
+			Connect.call so, addr, addr.size if addr
+			so
+		end
+
+		def tcpnew(addr = nil)
+			addr = sockaddr(*addr) if Array === addr
+			so = OpenSocket.call 2, 1, 6
+			Connect.call so, addr, addr.size if addr
+			so
+		end
+		
+		def sockaddr(host, port)
+			[2, port, *host].pack("snCCCCx8")
+		end
+
+		def udpclose(u)
+			CloseSocket.call u
+		end
+
+		def tcpclose(u)
+			CloseSocket.call u
+		end
+
+		def socketwrite(h, buf)
+			Send.call h, buf, buf.length, 0
+		end
+
+		def socketread(h, size)
+			buf = "\0" * size
+			ret = Recv.call h, buf, size, 0
+			case ret
+			when -1, 0
+				nil
+			else
+				buf[0, ret]
+			end
+		end
 	
-	
+
+		def simplehttpread(addr, hostname = addr[/http:\/\/([^\/]*)/, 1], 
+			           resource = addr[/http:\/\/([^\/]*)(.*)$/, 2])
+			request = "GET #{resource} HTTP/1.1\r\n"\
+				  "host:#{hostname}\r\n"\
+				  "\r\n\r\n\r\n\r\n"
+			t = tcpnew
+		        if hostname[0][/[0-9]/]
+				u = addr = api('ws2_32', 'inet_addr').call(
+					to_codepage(to_unicode(hostname+"\0\0")+"\0", CP_ANSI)+"\0"
+				)
+			else
+				hostent = api('ws2_32', 'gethostbyname').call(
+					to_codepage(to_unicode(hostname+"\0\0")+"\0", CP_ANSI)+"\0"
+				)
+
+			        addr = memread(hostent+PTRLEN*3, PTRLEN)
+				addr = addr.unpack(TYPE_VOIDP).first
+				addr = memread(addr, PTRLEN)
+				addr = addr.unpack(TYPE_VOIDP).first
+				addr = memread(addr, PTRLEN)
+				u = addr.unpack("L").first
+			end		
+			uaddr =  [2, 0, 0, 80, u].pack("CCCCLx8")
+			
+			raise "Can't connect to Server " if -1 == Connect.call(t, uaddr, 16)
+		        socketwrite t, request
+		        responseheader = ""
+			while v = socketread(t, 20480)	
+				responseheader << v
+				if pos = responseheader.index("\r\n\r\n")
+					responsebody   = responseheader[pos+4..-1]
+					responseheader = responseheader[0...pos]
+					break
+				end
+				yield responseheader, nil if block_given?
+			end
+
+			if !(length = responseheader[/Content-length:\s*(\d+)/i, 1])
+				length = 1e100
+			else
+				length = length.to_i
+			end
+			
+			while responsebody.length < length && (v = socketread(t, 20480)) 
+				responsebody << v
+				yield responseheader, responsebody if block_given?
+			end
+			tcpclose t
+			true
+		end	
+
+		
 	end
 
-	extend Win32API
 end