rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/corba/giop/Exception.lua

@@ -0,0 +1,25 @@
+local oo        = require "oil.oo"
+local Exception = require "oil.Exception"
+local assert    = require "oil.assert"
+local giop      = require "oil.corba.giop"                                      --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.corba.giop.Exception", oo.class)
+
+__concat   = Exception.__concat
+__tostring = Exception.__tostring
+
+minor_code_value = 0
+completion_status = 2
+
+function __init(self, except, ...)
+	if except then
+		local sysex = giop.SystemExceptionIDs[ except[1] ]
+		if sysex then
+			except[1] = sysex
+			except.exception_id = sysex
+		end
+	end
+	return Exception.__init(self, except, ...)
+end
+
+assert.Exception = _M -- use GIOP exception as the default exception

data/vendor/lua/lib/lua/oil/corba/giop/Indexer.lua

@@ -0,0 +1,63 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : CORBA Interface Indexer                                           --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- members:Receptacle
+-- 	member:table valueof(interface:table, name:string)
+--------------------------------------------------------------------------------
+
+local oo      = require "oil.oo"
+local giop    = require "oil.corba.giop"
+local Indexer = require "oil.corba.idl.Indexer"                                 --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.corba.giop.Indexer"
+
+oo.class(_M, Indexer)
+
+local CurrentInterface
+
+function giop.ObjectOperations._is_a:implementation(repid)
+	local interface = CurrentInterface -- get current interface
+	CurrentInterface = nil             -- clear current interface
+	if interface then
+		for base in interface:hierarchy() do
+			if base.repID == repid then
+				return true
+			end
+		end
+	end
+	return false
+end
+
+function giop.ObjectOperations._interface:implementation()
+	local interface = CurrentInterface -- get current interface
+	CurrentInterface = nil             -- clear current interface
+	return interface
+end
+
+function giop.ObjectOperations._non_existent:implementation()
+	return false
+end
+
+function giop.ObjectOperations._component:implementation()
+	return nil
+end
+
+function valueof(self, interface, name)
+	local operation = Indexer.valueof(self, interface, name)
+	if not operation then
+		CurrentInterface = interface -- setup current interface to be used by impls.
+		operation = giop.ObjectOperations[name]
+	end
+	return operation
+end

data/vendor/lua/lib/lua/oil/corba/giop/Listener.lua

@@ -0,0 +1,343 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Server-side CORBA GIOP Protocol                                   --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   See chapter 15 of CORBA 3.0 specification.                               --
+--------------------------------------------------------------------------------
+-- listener:Facet
+-- 	configs:table default([configs:table])
+-- 	channel:object, [except:table] getchannel(configs:table)
+-- 	success:boolean, [except:table] freeaccess(configs:table)
+-- 	success:boolean, [except:table] freechannel(channel:object)
+-- 	request:object, [except:table], [requests:table] = getrequest(channel:object, [probe:boolean])
+-- 
+-- channels:HashReceptacle
+-- 	channel:object retieve(configs:table)
+-- 	channel:object dispose(configs:table)
+-- 	configs:table default([configs:table])
+--------------------------------------------------------------------------------
+
+local assert   = assert
+local ipairs   = ipairs
+local pairs    = pairs
+local select   = select
+local type     = type
+local unpack   = unpack
+local stderr   = io and io.stderr
+
+local table = require "table"
+
+local oo        = require "oil.oo"
+local bit       = require "oil.bit"
+local idl       = require "oil.corba.idl"
+local giop      = require "oil.corba.giop"
+local Exception = require "oil.corba.giop.Exception"
+local Messenger = require "oil.corba.giop.Messenger"                            --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.corba.giop.Listener"
+
+oo.class(_M, Messenger)
+
+--------------------------------------------------------------------------------
+
+local RequestID          = giop.RequestID
+local ReplyID            = giop.ReplyID
+local LocateRequestID    = giop.LocateRequestID
+local LocateReplyID      = giop.LocateReplyID
+local CancelRequestID    = giop.CancelRequestID
+local CloseConnectionID  = giop.CloseConnectionID
+local MessageErrorID     = giop.MessageErrorID
+local MessageType        = giop.MessageType
+local SystemExceptionIDs = giop.SystemExceptionIDs
+
+local COMPLETED_YES   = 0
+local COMPLETED_NO    = 1
+local COMPLETED_MAYBE = 2
+
+local Empty = {}
+
+local SystemExceptions = {}
+
+for _, repID in pairs(SystemExceptionIDs) do
+	SystemExceptions[repID] = true
+end
+
+--------------------------------------------------------------------------------
+
+function setupaccess(self, configs)
+	local channels = self.channels[configs and configs.tag or 0]
+	if channels then
+		return channels:default(configs)
+	else
+		return nil, Exception{ "IMP_LIMIT", minor_code_value = 1,
+			message = "no supported GIOP profile found for configuration",
+			reason = "protocol",
+			configuration = configs,
+		}
+	end
+end
+
+function freeaccess(self, accesspoint)                                          --[[VERBOSE]] verbose:listen(true, "closing all channels with accesspoint ",accesspoint)
+	local channels = self.channels[accesspoint.tag or 0]
+	local result, except = channels:dispose(accesspoint)
+	if result then
+		for _, channel in ipairs(result) do
+			result, except = self:sendmsg(channel, CloseConnectionID)
+			if not result and except.reason ~= "closed" then
+				break
+			end
+		end
+	end                                                                           --[[VERBOSE]] verbose:listen(false)
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+
+function getchannel(self, accesspoint, probe)                                   --[[VERBOSE]] verbose:listen(true, "get channel from accesspoint ",accesspoint)
+	local result, except = self.channels[accesspoint.tag or 0]
+	if result then
+		result, except = result:retrieve(accesspoint, probe)
+	else
+		except = Exception{ "IMP_LIMIT", minor_code_value = 1,
+			message = "no supported GIOP profile found for accesspoint",
+			reason = "protocol",
+			accesspoint = accesspoint,
+		}
+	end                                                                           --[[VERBOSE]] verbose:listen(false)
+	return result, except
+end
+
+function putchannel(self, channel)                                              --[[VERBOSE]] verbose:listen "put channel back"
+	return channel:release()
+end
+
+function freechannel(self, channel)                                             --[[VERBOSE]] verbose:listen "close channel"
+	if table.maxn(channel) > 0 then
+		channel.freed = true
+		return true
+	else
+		return self:sendmsg(channel, CloseConnectionID)
+	end
+end
+
+--------------------------------------------------------------------------------
+
+local SysExReply = {
+	service_context = Empty,
+	request_id      = nil, -- defined later
+	reply_status    = "SYSTEM_EXCEPTION",
+}
+local SysExType = { giop.SystemExceptionIDL }
+local SysExBody = { n = 1, --[[defined later]] }
+
+function sysexreply(self, requestid, body)                                      --[[VERBOSE]] verbose:listen("new system exception ",body[1]," for request ",requestid)
+	SysExReply.request_id = requestid
+	SysExBody[1] = body
+	body.exception_id = body[1]
+	return SysExReply, SysExType, SysExBody
+end
+
+--------------------------------------------------------------------------------
+
+Request = oo.class{ n = 0, pcall = pcall }
+
+function Request:preinvoke(iface, member)
+	if iface ~= nil then
+		local inputs = member.inputs
+		local count = #inputs
+		self.n = count
+		self.outputs = member.outputs
+		self.exceptions = member.exceptions
+		local decoder = self.decoder
+		for i = 1, count do
+			local ok, result = self.pcall(decoder.get, decoder, inputs[i])
+			if not ok then
+				assert(type(result) == "table", result)
+				self.success = false
+				self.n = 1
+				self[1] = result
+				return -- request cancelled
+			end
+			self[i] = result
+		end
+		return self.object_key, self.operation
+	end
+end
+
+function Request:params()
+	return unpack(self, 1, self.n)
+end
+
+function Request:results(success, ...)
+	local count = select("#", ...)
+	self.success = success
+	self.n = count
+	for i = 1, count do
+		self[i] = select(i, ...)
+	end
+end
+
+--------------------------------------------------------------------------------
+
+function getrequest(self, channel, probe)                                       --[[VERBOSE]] verbose:listen(true, "get request from channel")
+	local result, except = true, nil
+	if channel:trylock("read", not probe) then
+		if not probe or channel:probe() then
+			local bypassed = false
+			local msgid, header, decoder = self:receivemsg(channel)
+			if msgid == RequestID then
+				local requestid = header.request_id
+				if not channel[requestid] then
+					header.decoder = decoder
+					if header.response_expected then
+						header.channel = channel
+						channel[requestid] = header                                         --[[VERBOSE]] else verbose:listen "no response expected"
+					end
+					result, except = self.Request(header)
+				else                                                                    --[[VERBOSE]] verbose:listen("got replicated request id ",requestid)
+					result, except = self:sendmsg(channel, MessageErrorID)
+					bypassed = result
+				end
+			elseif msgid == CancelRequestID then                                      --[[VERBOSE]] verbose:listen("got cancelling of request ",header.request_id)
+				channel[header.request_id] = nil
+				result, except = true, nil
+				bypassed = true
+			elseif msgid == LocateRequestID then                                      --[[VERBOSE]] verbose:listen("got locate request ",header.request_id)
+				local reply = { request_id = header.request_id }
+				if self.servants:retrieve(header.object_key)
+					then reply.locate_status = "OBJECT_HERE"
+					else reply.locate_status = "UNKNOWN_OBJECT"
+				end
+				reply[1] = reply
+				result, except = self:sendmsg(channel, LocateReplyID, reply)
+				bypassed = result
+			elseif result == MessageErrorID then                                      --[[VERBOSE]] verbose:listen "got message error notification"
+				result, except = self:sendmsg(channel, CloseConnectionID)
+				bypassed = result
+			elseif MessageType[msgid] then                                            --[[VERBOSE]] verbose:listen("got unknown message ",msgid,", sending message error notification")
+				result, except = self:sendmsg(channel, MessageErrorID)
+				bypassed = result
+			else
+				result, except = nil, header
+			end
+			
+			if bypassed then                                                          --[[VERBOSE]] verbose:listen(false, "reissuing request read")
+				return self:getrequest(channel, probe)
+			elseif not result and except.reason == "closed" then                      --[[VERBOSE]] verbose:listen("client closed the connection")
+				result, except = true, nil
+			end
+		end
+		channel:freelock("read")
+	end                                                                           --[[VERBOSE]] verbose:listen(false)
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+
+local ExceptionReplyTypes = { idl.string }
+local ExceptionReplyBody = { n = 2, --[[defined later]] }
+
+function handlereply(self, request)
+	if request.success then                                                       --[[VERBOSE]] verbose:listen "got successful results"
+		request.service_context = Empty
+		request.reply_status = "NO_EXCEPTION"
+		return request, request.outputs, request
+	else
+		local requestid = request.request_id
+		local except = request[1]
+		local extype = type(except)
+		if extype == "table" then                                                   --[[VERBOSE]] verbose:listen("got exception ",except)
+			local excepttype = request.exceptions
+			excepttype = excepttype and excepttype[ except[1] ]
+			if excepttype then
+				request.service_context = Empty
+				request.reply_status = "USER_EXCEPTION"
+				ExceptionReplyTypes[2] = excepttype
+				ExceptionReplyBody[1] = except[1]
+				ExceptionReplyBody[2] = except
+				return request, ExceptionReplyTypes, ExceptionReplyBody
+			else
+				if except.reason == "badkey" then
+					except[1] = "IDL:omg.org/CORBA/OBJECT_NOT_EXIST:1.0"
+					except.minor_code_value  = 1
+					except.completion_status = COMPLETED_NO
+				elseif except.reason == "noimplement" then
+					except[1] = "IDL:omg.org/CORBA/NO_IMPLEMENT:1.0"
+					except.minor_code_value  = 1
+					except.completion_status = COMPLETED_NO
+				elseif except.reason == "badoperation" then
+					except[1] = "IDL:omg.org/CORBA/BAD_OPERATION:1.0"
+					except.minor_code_value  = 1
+					except.completion_status = COMPLETED_NO
+				elseif except.reason == "badrequestid" then
+					except[1] = "IDL:omg.org/CORBA/INTERNAL:1.0"
+					except.minor_code_value  = 1
+					except.completion_status = COMPLETED_NO
+				elseif not SystemExceptions[ except[1] ] then                           --[[VERBOSE]] verbose:listen("got unexpected exception ",except)
+					except[1] = "IDL:omg.org/CORBA/UNKNOWN:1.0"
+					except.minor_code_value  = 0
+					except.completion_status = COMPLETED_MAYBE                            --[[VERBOSE]] else verbose:listen("got system exception ",except)
+				end
+				return self:sysexreply(requestid, except)
+			end
+		elseif extype == "string" then                                              --[[VERBOSE]] verbose:listen("got unexpected error ", except)
+			if stderr then stderr:write(except, "\n") end
+			return self:sysexreply(requestid, {
+				"IDL:omg.org/CORBA/UNKNOWN:1.0",
+				minor_code_value = 0,
+				completion_status = COMPLETED_MAYBE,
+				message = "servant error: "..except,
+				reason = "servant",
+				operation = operation,
+				servant = servant,
+				error = except,
+			})
+		else                                                                        --[[VERBOSE]] verbose:listen("got illegal exception ", except)
+			return self:sysexreply(requestid, {
+				"IDL:omg.org/CORBA/UNKNOWN:1.0",
+				minor_code_value = 0,
+				completion_status = COMPLETED_MAYBE,
+				message = "invalid exception, got "..extype,
+				reason = "exception",
+				exception = except,
+			})
+		end
+	end
+end
+
+function sendreply(self, request)                                               --[[VERBOSE]] verbose:listen(true, "got reply for request ",request.request_id)
+	local success, except = true, nil
+	local channel = request.channel
+	local requestid = request.request_id
+	if channel and channel[requestid] == request then
+		success, except = self:sendmsg(channel, ReplyID,
+		                               self:handlereply(request))
+		if success then
+			channel[requestid] = nil
+			if channel.freed and table.maxn(channel) == 0 then                        --[[VERBOSE]] verbose:listen "all pending requests replied, connection being closed"
+				success, except = self:sendmsg(channel, CloseConnectionID)
+			end
+		elseif SystemExceptions[ except[1] ] then                                   --[[VERBOSE]] verbose:listen("got system exception ",except," at reply send")
+			except.completion_status = COMPLETED_YES
+			success, except = self:sendmsg(channel, ReplyID,
+			                               self:sysexreply(requestid, except))
+		end
+	else                                                                          --[[VERBOSE]] verbose:listen("no pending request found with id ",requestid,", reply discarded")
+		success = true
+	end
+	if not success and except.reason == "closed" then
+		success, except = true, nil
+	end                                                                           --[[VERBOSE]] verbose:listen(false)
+	return success, except
+end

data/vendor/lua/lib/lua/oil/corba/giop/Messenger.lua

@@ -0,0 +1,228 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Client-side CORBA GIOP Protocol                                   --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   See section 15.4.1 of CORBA 3.0 specification.                           --
+--------------------------------------------------------------------------------
+-- messenger:Facet
+-- 	success:booelan, [except:table] = sendmsg(channel:object, type:number, header:table, types:table, values)
+-- 	type:number, header:table, decoder:object = receivemsg(channel:object , [wait:boolean])
+-- 
+-- codec:Receptacle
+-- 	encoder:object encoder()
+-- 	decoder:object decoder(stream:string)
+--------------------------------------------------------------------------------
+
+local assert   = assert
+local ipairs   = ipairs
+local luapcall = pcall
+local select   = select
+local type     = type
+
+local oo        = require "oil.oo"
+local bit       = require "oil.bit"
+local giop      = require "oil.corba.giop"
+local Exception = require "oil.corba.giop.Exception"                            --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.corba.giop.Messenger", oo.class)
+
+pcall = luapcall
+
+--------------------------------------------------------------------------------
+
+magictag    = giop.MagicTag
+headersize  = giop.HeaderSize
+headertype  = giop.Header_v1_[0]
+messagetype = giop.MessageHeader_v1_[0]
+
+header = {
+	magic        = magictag,
+	GIOP_version = {major=1, minor=0},
+	byte_order   = (bit.endianess() == "little"),
+	message_type = nil, -- defined later
+	message_size = nil, -- defined later
+}
+
+--------------------------------------------------------------------------------
+
+function sendmsg(self, channel, msgtype, message, types, values)                --[[VERBOSE]] verbose:message(true, "send message ",msgtype," ",message)
+	--
+	-- Create GIOP message body
+	--
+	local encoder = self.codec:encoder()
+	encoder:shift(self.headersize) -- alignment accordingly to GIOP header size
+	if message then
+		encoder:put(message, self.messagetype[msgtype])
+	end
+	if types then
+		local count = values.n or #values
+		for index, idltype in ipairs(types) do
+			local value
+			if index <= count then
+				value = values[index]
+			end
+			local ok, errmsg = self.pcall(encoder.put, encoder, value, idltype)
+			if not ok then
+				assert(type(errmsg) == "table", errmsg)
+				return nil, errmsg
+			end
+		end
+	end
+	local stream = encoder:getdata()
+	
+	--
+	-- Create GIOP message header
+	--
+	local header = self.header
+	header.message_size = #stream
+	header.message_type = msgtype
+	encoder = self.codec:encoder()
+	encoder:struct(header, self.headertype)
+	stream = encoder:getdata()..stream
+	
+	--
+	-- Send stream over the channel
+	--
+	local success, except, reset
+	repeat
+		channel:trylock("write", true)
+		success, except = channel:send(stream)
+		if not success then
+			if except == "closed" then
+				-- only clients have 'reset' op.
+				if reset == nil and channel.reset then
+					success, except = channel:reset()
+					if success then
+						reset, success, except = true, nil, nil 
+					end
+				else
+					channel:close()
+				end
+			end
+		-- else
+			--TODO:[maia] How can I assure that someone is actually listening
+			--            to this channel? Because if the server has closed
+			--            the connection, we have received a FIN, but the RST
+			--            may not have been received yet, so we might be sending
+			--            data to a socket no one is listening to. (see page 132
+			--            of R. Stevens, UNIX network programming, 2nd ed, 1997)
+		end
+		channel:freelock("write")
+	until success or except
+	if except then
+		except = Exception{ "COMM_FAILURE", minor_code_value = 0,
+			message = "unable to write into connection ("..except..")",
+			reason = "closed",
+			connection = channel,
+		}
+	end                                                                           --[[VERBOSE]] verbose:message(false)
+	
+	return success, except
+end
+
+--------------------------------------------------------------------------------
+
+function receivemsg(self, channel)                                              --[[VERBOSE]] verbose:message(true, "receive message from channel")
+	local success, except = channel:receive(self.headersize)
+	if success then
+		local decoder = self.codec:decoder(success)
+		--
+		-- Read GIOP message header
+		--
+		local header = self.headertype
+		local magic = decoder:array(header[1].type)
+		if magic == self.magictag then
+			local version = decoder:struct(header[2].type)
+			if version.major == 1 and version.minor == 0 then
+				decoder:order(decoder:boolean())
+				local type = decoder:octet()
+				local size = decoder:ulong()
+				--
+				-- Read GIOP message body
+				--
+				if size > 0 then
+					success, except = channel:receive(size)
+				else
+					success, except = "", nil
+				end
+				if success then
+					decoder:append(success)
+					success = type
+					header = self.messagetype[type]
+					if header then
+						except = decoder:struct(header)
+						channel = decoder
+					elseif header == nil then
+						success = nil
+						except = Exception{ "INTERNAL", minor_code_value = 0,
+							message = "GIOP 1.0 message type not supported",
+							reason = "messageid",
+							major = version.major,
+							minor = version.minor,
+							type = type,
+						}
+					end
+				else
+					if except == "closed" then channel:close() end
+					except = Exception{ "COMM_FAILURE", minor_code_value = 0,
+						message = "unable to read from connection ("..except..")",
+						reason = "closed",
+						connection = channel,
+					}
+				end
+			else
+				success = nil
+				except = Exception{ "INTERNAL", minor_code_value = 0,
+					message = "GIOP version not supported",
+					reason = "version",
+					procotol = "GIOP",
+					version = version,
+				}
+			end
+		else
+			success = nil
+			except = Exception{ "MARSHAL", minor_code_value = 8,
+				message = "illegal GIOP message magic tag",
+				reason = "magictag",
+				tag = magic,
+			}
+		end
+	else
+		if except == "closed" then channel:close() end
+		except = Exception{ "COMM_FAILURE", minor_code_value = 0,
+			message = "unable to read from connection",
+			reason = except,
+			connection = channel,
+		}
+	end                                                                           --[[VERBOSE]] verbose:message(false, "got message ",success, except)
+	return success, except, channel
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+--[[VERBOSE]] function verbose.custom:message(...)
+--[[VERBOSE]] 	local viewer = self.viewer
+--[[VERBOSE]] 	local output = viewer.output
+--[[VERBOSE]] 	for i = 1, select("#", ...) do
+--[[VERBOSE]] 		local value = select(i, ...)
+--[[VERBOSE]] 		if giop.MessageType[value] then
+--[[VERBOSE]] 			output:write(giop.MessageType[value])
+--[[VERBOSE]] 		elseif type(value) == "string" then
+--[[VERBOSE]] 			output:write(value)
+--[[VERBOSE]] 		else
+--[[VERBOSE]] 			viewer:write(value)
+--[[VERBOSE]] 		end
+--[[VERBOSE]] 	end
+--[[VERBOSE]] end