rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/corba/idl/sysex.lua

@@ -0,0 +1,21 @@
+local pairs = pairs
+
+local idl  = require "oil.corba.idl"
+local giop = require "oil.corba.giop"                                           --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.corba.idl.sysex"
+
+--------------------------------------------------------------------------------
+
+name = "CORBA"
+repID = "IDL:omg.org/CORBA:1.0"
+idl.module(_M)
+
+--------------------------------------------------------------------------------
+
+for name, repID in pairs(giop.SystemExceptionIDs) do
+	definitions[name] = idl.except{
+		{name = "minor_code_value" , type = idl.ulong },
+		{name = "completion_status", type = idl.ulong },
+	}
+end

data/vendor/lua/lib/lua/oil/corba/iiop/Profiler.lua

@@ -0,0 +1,200 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : IIOP Profile Encoder/Decoder                                      --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   See section 15.7 of CORBA 3.0 specification.                             --
+--------------------------------------------------------------------------------
+-- profiler:Facet
+-- 	stream:string encode(profile:table, [version:number])
+-- 	profile:table decode(stream:string)
+-- 	objkey:string belongsto(profile:string, orbcfg:table)
+-- 	result:boolean equivalent(profile1:string, profile2:string)
+-- 	profile:table decodeurl(url:string)
+-- 
+-- codec:Receptacle
+-- 	encoder:object encoder([encapsulated:boolean])
+-- 	decoder:object decoder(stream:string, [encapsulated:boolean])
+--------------------------------------------------------------------------------
+
+local ipairs   = ipairs
+local tonumber = tonumber
+
+local string = require "string"
+
+local oo        = require "oil.oo"
+local idl       = require "oil.corba.idl"
+local Exception = require "oil.corba.giop.Exception"                            --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.corba.iiop.Profiler", oo.class)
+
+--------------------------------------------------------------------------------
+-- IIOP profile structure
+
+local Empty = {}
+
+local Tag = 0
+
+local TaggedComponentSeq = idl.sequence{idl.struct{
+	{name = "tag"           , type = idl.ulong   },
+	{name = "component_data", type = idl.OctetSeq},
+}}
+
+local ProfileBody_v1_ = {
+	-- Note: First profile structure field is read/write directly
+	[0] = idl.struct{
+		--{name = "iiop_version", type = idl.Version },
+		{name = "host"        , type = idl.string  },
+		{name = "port"        , type = idl.ushort  },
+		{name = "object_key"  , type = idl.OctetSeq},
+	},
+	[1] = idl.struct{
+		--{name = "iiop_version", type = idl.Version       },
+		{name = "host"        , type = idl.string        },
+		{name = "port"        , type = idl.ushort        },
+		{name = "object_key"  , type = idl.OctetSeq      },
+		{name = "components"  , type = TaggedComponentSeq},
+	},
+}
+ProfileBody_v1_[2] = ProfileBody_v1_[1] -- same as IIOP 1.1
+ProfileBody_v1_[3] = ProfileBody_v1_[1] -- same as IIOP 1.1
+
+--------------------------------------------------------------------------------
+-- IIOP profile encode/decode
+
+function encode(self, profiles, object_key, config, minor)
+	if not minor then minor = 0 end
+	local profileidl = ProfileBody_v1_[minor]
+	if profileidl then
+		local port = config.refport or config.port
+		for _, addr in ipairs(config.addresses) do
+			local profile = {
+				components = Empty,
+				host = addr,
+				port = port,
+				object_key = object_key
+			}
+			local encoder = self.codec:encoder(true)
+			encoder:struct({major=1, minor=minor}, idl.Version)
+			encoder:struct(profile, profileidl)
+			profiles[#profiles+1] = {
+				tag          = Tag,
+				profile_data = encoder:getdata(),
+			}
+		end
+		return true
+	else
+		return nil, Exception{ "INTERNAL", minor_code_value = 0,
+			message = "IIOP minor version not supported",
+			reason = "version",
+			protocol = "IIOP",
+			version = minor,
+		}
+	end
+end
+
+function decode(self, profile)
+	local decoder = self.codec:decoder(profile, true)
+	local version = decoder:struct(idl.Version)
+	local profileidl = ProfileBody_v1_[version.minor]
+
+	if version.major ~= 1 or not profileidl then
+		return nil, Exception{ "INTERNAL", minor_code_value = 0,
+			reason = "version",
+			message = "IIOP version not supported",
+			protocol = "IIOP",
+			version = version,
+		}
+	end
+
+	profile = decoder:struct(profileidl)
+	profile.iiop_version = version -- add read version directly
+
+	return profile, profile.object_key
+end
+
+--------------------------------------------------------------------------------
+-- IIOP profile and local ORB config match
+
+function belongsto(self, profile, config)
+	local objectkey
+	profile, objectkey = self:decode(profile)
+	if config.addresses[profile.host] and profile.port == config.port then
+		return objectkey
+	end
+end
+
+--------------------------------------------------------------------------------
+-- IIOP profile are equivalent
+
+function equivalent(self, profile1, profile2)
+	local objectkey1, objectkey2
+	profile1, objectkey1 = self:decode(profile1)
+	profile2, objectkey2 = self:decode(profile2)
+	return objectkey1 == objectkey2 and
+	       profile1.host == profile2.host and
+	       profile1.port == profile2.port
+end
+
+--------------------------------------------------------------------------------
+-- IIOP corbaloc URL decoder
+
+function decodeurl(self, data)
+	local temp, objectkey = string.match(data, "^([^/]*)/(.*)$")
+	if temp
+		then data = temp
+		else objectkey = "" -- TODO:[maia] is this correct?
+	end
+	local major, minor
+	major, minor, temp = string.match(data, "^(%d+).(%d+)@(.+)$")
+	if not minor then
+		minor = 0
+	else
+		minor = tonumber(minor)
+	end
+	local profileidl = ProfileBody_v1_[minor]
+	if (major and major ~= "1") or (not profileidl) then
+		return nil, Exception{ "INTERNAL", minor_code_value = 0,
+			message = "IIOP version not supported",
+			reason = "version",
+			protocol = "IIOP",
+			major = major,
+			minor = minor,
+			version = major.."."..minor
+		}
+	end
+	if temp then data = temp end
+	local host, port = string.match(data, "^([^:]+):(%d*)$")
+	if port then
+		port = tonumber(port)
+	else
+		port = 2809
+		if data == ""
+			then host = "*"
+			else host = data
+		end
+	end
+	
+	temp = self.codec:encoder(true)
+	temp:struct({major=1,minor=minor}, idl.Version)
+	temp:struct({
+		components = Empty,
+		host = host,
+		port = port,
+		object_key = objectkey
+	}, profileidl)
+	return {
+		tag = Tag,
+		profile_data = temp:getdata(),
+	}
+end

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

@@ -0,0 +1,158 @@
+
+local unpack = unpack
+
+local oo       = require "oil.oo"
+local giop     = require "oil.corba.giop"
+local Listener = require "oil.corba.giop.Listener"                              --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.corba.intercepted.Listener"
+
+oo.class(_M, Listener)
+
+--------------------------------------------------------------------------------
+
+local LocationForwardTypes = { giop.IOR }
+local ReplyID = giop.ReplyID
+
+local Empty = {}
+
+--------------------------------------------------------------------------------
+
+function __init(self, ...)
+	self = oo.rawnew(self, ...)
+	local Request = self.Request
+	self.Request = oo.class({}, Request)
+	function self.Request.preinvoke(request, iface, member, object)
+		local objkey, opname = Request.preinvoke(request, iface, member)
+		request.interface = iface
+		request.member = member
+		request.target = object
+		self:interceptrequest(request, objkey == nil)
+		if request.success == nil then
+			return objkey, opname
+		end
+	end
+	return self
+end
+
+--------------------------------------------------------------------------------
+
+function interceptrequest(self, request, failed)
+	local interceptor = self.interceptor
+	if interceptor then
+		local intercepted = {
+			service_context   = request.service_context,
+			request_id        = request.request_id,
+			response_expected = request.response_expected,
+			object_key        = request.object_key,
+			operation_name    = request.operation,
+			servant           = request.target,
+			interface         = request.interface,
+			interface_name    = request.interface and request.interface.absolute_name,
+			operation         = request.member,
+			parameters        = not failed and {n=request.n,request:params()} or nil,
+		}
+		request.intercepted = intercepted
+		if interceptor.receiverequest then                                          --[[VERBOSE]] verbose:interceptors(true, "intercepting request marshaling")
+			interceptor:receiverequest(intercepted)
+			if intercepted.success ~= nil then                                        --[[VERBOSE]] verbose:interceptors("interception request was canceled")
+				request.success = intercepted.success
+				-- update returned values
+				local results = intercepted.results or {}
+				request.n = results.n or #results
+				for i = 1, request.n do
+					request[i] = results[i]
+				end
+				request.intercepted = nil -- this should cancel the reply interception
+				request.reply_service_context = intercepted.reply_service_context
+			elseif intercepted.forward_reference then                                 --[[VERBOSE]] verbose:interceptors("interceptor forwarded the request")
+				request.success = false   -- this should cancel the operation dispatch
+				request.intercepted = nil -- this should cancel the reply interception
+				request.reply_service_context = intercepted.reply_service_context
+				request.forward_reference = intercepted.forward_reference
+			else
+				-- update parameter values
+				local parameters = intercepted.parameters
+				if parameters then
+					request.n = parameters.n or #parameters
+					for i = 1, request.n do
+						request[i] = parameters[i]
+					end
+				end
+				-- update operation being invoked
+				if intercepted.operation ~= request.member then                         --[[VERBOSE]] verbose:interceptors("interceptor changed invoked operation")
+					local operation = intercepted.operation
+					request.operation  = operation.name
+					request.inputs     = operation.inputs
+					request.outputs    = operation.outputs
+					request.exceptions = operation.exceptions
+				end
+				-- update GIOP message fields
+				request.service_context = intercepted.service_context
+				request.object_key = intercepted.object_key
+			end                                                                       --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+		end
+	end
+end
+
+--------------------------------------------------------------------------------
+
+function interceptreply(self, request, body)
+	local intercepted = request.intercepted
+	if intercepted then
+		request.intercepted = nil
+		local interceptor = self.interceptor
+		if interceptor and interceptor.sendreply then
+			intercepted.reply_status = request.reply_status
+			intercepted.success      = request.success
+			if request.reply_status == "SYSTEM_EXCEPTION" then
+				intercepted.results = { n = 1, body[1] }
+			else
+				intercepted.results = { n = request.n, unpack(request, 1, request.n) }
+			end                                                                       --[[VERBOSE]] verbose:interceptors(true, "intercepting reply marshaling")
+			interceptor:sendreply(intercepted)                                        --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+			local reference = intercepted.forward_reference
+			if reference then
+				request.forward_reference = reference
+			else
+				request.success = intercepted.success
+				-- update returned values
+				local results = intercepted.results or {}
+				request.n = results.n or #results
+				for i = 1, request.n do
+					request[i] = results[i]
+				end
+			end
+			-- update GIOP message fields
+			request.reply_service_context = intercepted.reply_service_context
+			return true
+		end
+	end
+end
+
+function makereply(self, request)
+	local types, body
+	local reference = request.forward_reference
+	if reference then
+		request.reply_status = "LOCATION_FORWARD"
+		request.service_context = Empty
+		return LocationForwardTypes, { reference }
+	end
+	local header, types, body = Listener.handlereply(self, request)
+	if header ~= request then
+		request.reply_status    = header.reply_status
+		request.service_context = header.service_context
+	end
+	return types, body
+end
+
+function handlereply(self, request)
+	local types, body = self:makereply(request)
+	if self:interceptreply(request, body) then
+		types, body = self:makereply(request)
+		if request.reply_service_context then
+			request.service_context = request.reply_service_context
+		end
+	end
+	return request, types, body
+end

data/vendor/lua/lib/lua/oil/corba/intercepted/Requester.lua

@@ -0,0 +1,181 @@
+
+local select = select
+local unpack = unpack
+
+local oo        = require "oil.oo"
+local giop      = require "oil.corba.giop"
+local Requester = require "oil.corba.giop.Requester"                            --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.corba.intercepted.Requester"
+
+oo.class(_M, Requester)
+
+--------------------------------------------------------------------------------
+
+local RequestID = giop.RequestID
+
+local Empty = {}
+
+--------------------------------------------------------------------------------
+
+function interceptrequest(self, reference, operation, request)
+	local interceptor = self.interceptor
+	if interceptor then
+		local interface = operation.defined_in
+		local intercepted = {
+			reference         = reference,
+			operation         = operation,
+			profile_tag       = reference._profiletag,
+			profile_data      = reference._profiledata,
+			interface         = interface,
+			interface_name    = interface and interface.absolute_name,
+			request_id        = request.request_id,
+			response_expected = request.response_expected,
+			object_key        = request.object_key,
+			operation_name    = request.operation,
+			parameters        = { n = request.n, unpack(request, 1, request.n) },
+		}
+		request.intercepted = intercepted
+		if interceptor.sendrequest then                                             --[[VERBOSE]] verbose:interceptors(true, "intercepting request being sent")
+			interceptor:sendrequest(intercepted)
+			if intercepted.success ~= nil then                                        --[[VERBOSE]] verbose:interceptors("interception request was canceled")
+				request.success = intercepted.success
+				-- update returned values
+				local results = intercepted.results or {}
+				request.n = results.n or #results
+				for i = 1, request.n do
+					request[i] = results[i]
+				end
+			else
+				-- update parameter values
+				local parameters = intercepted.parameters
+				request.n = parameters.n or #parameters
+				for i = 1, request.n do
+					request[i] = parameters[i]
+				end
+				-- update operation being invoked
+				if intercepted.operation and intercepted.operation ~= operation then
+					operation = intercepted.operation
+					interface = operation.defined_in
+					intercepted.interface      = interface
+					intercepted.interface_name = interface and interface.absolute_name
+					intercepted.operation_name = operation.name
+					request.operation  = operation.name
+					request.inputs     = operation.inputs
+					request.outputs    = operation.outputs
+					request.exceptions = operation.exceptions
+				end
+				-- update GIOP message fields
+				request.object_key           = intercepted.object_key
+				request.response_expected    = intercepted.response_expected
+				request.service_context      = intercepted.service_context or
+				                               request.service_context
+				request.requesting_principal = intercepted.requesting_principal or
+				                               request.requesting_principal             --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+			end
+		end
+		return intercepted
+	end
+end
+
+function sendrequest(self, reference, operation, ...)
+	local result, except = self:getchannel(reference)
+	local channel = result
+	local request = self:makerequest(channel, reference._objectkey, operation,...)--[[VERBOSE]] verbose:invoke(true, "request ",request.request_id," for operation '",operation.name,"'")
+	local intercepted = self:interceptrequest(reference, operation, request)
+	if intercepted then
+		if request.success ~= nil then                                              --[[VERBOSE]] verbose:interceptors(false, "interception ended (results provided!)")
+			channel = nil
+			result = request
+		else
+			local reference = intercepted.forward_reference
+			if reference then                                                           --[[VERBOSE]] verbose:interceptors("intercepted request forwarded")
+				if request.channel then
+					unregister(request.channel, request.request_id)
+				end
+				result, except = self:getchannel(reference)
+				if result then
+					intercepted.object_key = reference._objectkey
+					intercepted.profile_tag = reference._profiletag
+					intercepted.profile_data = reference._profiledata
+					channel = result
+					request.object_key = except
+					if request.response_expected then
+						register(channel, request)
+					else
+						request.request_id = 0
+					end
+				else
+					channel = nil
+				end
+			elseif not request.response_expected and request.channel then               --[[VERBOSE]] verbose:interceptors("interception canceled expected response")
+				unregister(request.channel, request.request_id)
+				request.request_id = 0
+			elseif request.response_expected and not request.channel and channel then   --[[VERBOSE]] verbose:interceptors("interception asked for an expected response")
+				register(channel, request)
+			end
+			intercepted.request_id = request.request_id
+		end
+	end
+	if channel then
+		result, except = self:sendmsg(channel, RequestID, request,
+		                              request.inputs, request)
+		if result then
+			if not request.response_expected then
+				request.success = true
+				request.n = 0
+			end
+			result, except = request, nil
+		else
+			unregister(channel, request.request_id)
+		end
+	end
+	if not result then
+		request.success = false
+		request.n = 1
+		request[1] = except
+		result, except = request, nil
+	end                                                                           --[[VERBOSE]] verbose:invoke(false)
+	if result and result.success ~= nil then
+		result.service_context = nil
+		self:interceptreply(result, result)
+	end
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+
+function interceptreply(self, request, header)
+	local intercepted = request.intercepted
+	if intercepted then
+		request.intercepted = nil
+		local interceptor = self.interceptor
+		if interceptor and interceptor.receivereply then
+			if header.service_context then
+				intercepted.reply_service_context = header.service_context
+			end
+			intercepted.reply_status          = header.reply_status
+			intercepted.success               = request.success
+			intercepted.results = {
+				n = request.n,
+				unpack(request, 1, request.n),
+			}
+			interceptor:receivereply(intercepted)
+			request.success = intercepted.success
+			-- update returned values
+			local results = intercepted.results or {}
+			request.n = results.n or #results
+			for i = 1, request.n do
+				request[i] = results[i]
+			end
+		end
+	end
+end
+
+function doreply(self, request, header, decoder)
+	local success, except = Requester.doreply(self, request, header, decoder)
+	if success then
+		self:interceptreply(request, header)
+	end
+	return success, except
+end