def open_secure_channel(self, params):
self.logger.info("open_secure_channel")
request = ua.OpenSecureChannelRequest()
request.Parameters = params
# use callback to make sure channel security parameters are set immedialty
# and we do no get race conditions
def clb(future):
response = struct_from_binary(ua.OpenSecureChannelResponse,
future.result())
response.ResponseHeader.ServiceResult.check()
self._connection.set_channel(response.Parameters,
params.RequestType,
params.ClientNonce)
clb.future.set_result(response)
clb.future = Future(
) # hack to have a variable only shared between a callback and us
self._send_request(request,
message_type=ua.MessageType.SecureOpen,
callback=clb)
# wait for our callbackto finish rexecuting before returning
response = clb.future.result(self.timeout)
response.ResponseHeader.ServiceResult.check()
return response.Parameters
def get_request(client):
""" Assemble an OpenSecureChannelRequest for the specified client
:param client: client object containing the channel parameters
:return: binary OpenSecureChannelRequest
"""
params = ua.OpenSecureChannelParameters()
params.ClientProtocolVersion = 0
params.RequestType = ua.SecurityTokenRequestType.Issue
params.SecurityMode = client.security_policy.Mode
params.RequestedLifetime = client.secure_channel_timeout
nonce = utils.create_nonce(client.security_policy.symmetric_key_size)
params.ClientNonce = nonce
request = ua.OpenSecureChannelRequest()
request.Parameters = params
request.RequestHeader = client.uaclient._uasocket._create_request_header()
try:
binreq = struct_to_binary(request)
except Exception:
# reset request handle if any error
# see self._create_request_header
client.uaclient._uasocket._request_handle -= 1
raise
return binreq
def open_secure_channel(self, params):
self.logger.info("open_secure_channel")
request = ua.OpenSecureChannelRequest()
request.Parameters = params
future = self._send_request(request, message_type=ua.MessageType.SecureOpen)
response = ua.OpenSecureChannelResponse.from_binary(future.result(self.timeout))
response.ResponseHeader.ServiceResult.check()
self._connection.set_channel(response.Parameters)
return response.Parameters
def open_secure_channel(self, params):
self.logger.info("open_secure_channel")
request = ua.OpenSecureChannelRequest()
request.Parameters = params
future = self._send_request(request, message_type=ua.MessageType.SecureOpen)
# FIXME: we have a race condition here
# we can get a packet with the new token id before we reach to store it..
response = ua.OpenSecureChannelResponse.from_binary(future.result(self.timeout))
response.ResponseHeader.ServiceResult.check()
self._connection.set_channel(response.Parameters)
return response.Parameters
