/// <summary> /// Puts down a record representing an event connected with the specified Security Session Parameters. /// </summary> /// <param name="author">The author.</param> /// <param name="type">The type of the event(Subcategory).</param> /// <param name="exception">The exception associated with the event.</param> /// <param name="message">The message associated with the event.</param> /// <param name="remote">The remote host participating in the event.</param> /// <param name="sourceThreadId">The id of the thread where the invocation was made.</param> /// <param name="sourceThreadName">The name of the thread.</param> /// <param name="securitySessionParameters">The Security Session Parameters.</param> /// <param name="description">The description of the event.</param> /// <param name="parameters">Parameters to the description.</param> public void WriteSecuritySessionParametersEvent(string author, LogMessageType type, Exception exception, Message message, HostInformation remote, int sourceThreadId, string sourceThreadName, SecuritySessionParameters securitySessionParameters, string description, params object[] parameters) { if (message == null || securitySessionParameters == null) { this.WriteImplementationWarningEvent("BinaryLogWriter.WriteMessageCreatedEvent", LogMessageType.Error, null, sourceThreadId, sourceThreadName, "The message or SSP is not provided. Stack trace: " + Environment.StackTrace); return; } lock (this._streamLock) { this.WriteRecordHeader(BinaryRecordVersion.SecuritySessionParameters, LogCategory.Security, type, author); this.WriteException(exception); this.WriteMessageSeqNo(message); this.WriteHostInformationId(remote); this.BinaryWriter.Write((int)sourceThreadId); this.WriteString(sourceThreadName); this.WriteSecuritySessionParameters(securitySessionParameters); this.WriteStringWithParameters(description, parameters); this.BinaryWriter.Flush(); } }
/// <summary> /// Returns an instance of the SecuritySessionParameters class brought to conformity with channels' settings. /// </summary> /// <param name="securitySessionParameters">Source parameters.</param> /// <returns>Fixed parameters.</returns> public SecuritySessionParameters FixSecuritySessionParameters(SecuritySessionParameters securitySessionParameters) { SecuritySessionAttributes fixedAttributes = (SecuritySessionAttributes)( ((int)securitySessionParameters.Attributes | (int)this.ForcedSecuritySessionAttributes) & ~((int)this.ProhibitedSecuritySessionAttributes)); return(new SecuritySessionParameters(securitySessionParameters.Name, fixedAttributes, TimeSpan.MinValue, securitySessionParameters.GenuineConnectionType, securitySessionParameters.ConnectionName, TimeSpan.MinValue, securitySessionParameters.RemoteTransportUser)); }
/// <summary> /// Puts down Security Session Parameters. /// </summary> /// <param name="parameters">The Security Session Parameters.</param> private void WriteSecuritySessionParameters(SecuritySessionParameters parameters) { this.BinaryWriter.Write((bool)(parameters != null)); if (parameters != null) { this.WriteString(parameters.Name); this.BinaryWriter.Write((int)parameters.GenuineConnectionType); this.WriteString(parameters.ConnectionName); this.BinaryWriter.Write((long)parameters.Timeout.Ticks); this.BinaryWriter.Write((int)parameters.Attributes); this.BinaryWriter.Write((long)parameters.CloseAfterInactivity.Ticks); } }
private void CheckState() { try { SecuritySessionParameters parameters = new SecuritySessionParameters( SecuritySessionServices.DefaultContext.Name, SecuritySessionAttributes.None, TimeSpan.FromSeconds(5)); using (new SecurityContextKeeper(parameters)) { while (true) { try { if (ClientEnvironment.ServerStateService.CanInteract) { if (ClientEnvironment.ServerStateService.ServerReady) { SetState(ServerState.Ready); } else { SetState(ServerState.Starting); } } else { SetState(ServerState.Starting); } } catch (ThreadAbortException) { return; } catch (Exception ex) { SetState(ServerState.Unavailable); } if (_FinishChecking.WaitOne(1000, false)) { return; } } } } catch (ThreadAbortException) { } }
public void RemoteInvocationWithCompressionAndPostfix() { // test compression var parameters = new SecuritySessionParameters( SecuritySessionServices.DefaultContext.Name, SecuritySessionAttributes.EnableCompression, TimeSpan.FromSeconds(5)); var proxy = (IService)Activator.GetObject(typeof(IService), ServiceUriRem); using (new SecurityContextKeeper(parameters)) { var greeting = proxy.Greeting("Compressed World"); Assert.AreEqual("Hello, Compressed World!", greeting); } }
public void RemoteInvocationWithCompressionAndPostfix() { // test compression var parameters = new SecuritySessionParameters( SecuritySessionServices.DefaultContext.Name, SecuritySessionAttributes.EnableCompression, TimeSpan.FromSeconds(5)); // note: localhost url doesn't work because it resolves to IPv6 address var proxy = (IService)Activator.GetObject(typeof(IService), "ghttp://127.0.0.1:8739/GxttpTestService.rem"); using (new SecurityContextKeeper(parameters)) { var greeting = proxy.Greeting("Compressed World"); Assert.AreEqual("Goodbye, Compressed World!", greeting); } }
public LoginResult ChangePassword(string oldPassword, string newPassword) { LoginResult res; SecuritySessionParameters oldParams = SecuritySessionServices.SetCurrentSecurityContext( new SecuritySessionParameters("/BAUMAX/SES", SecuritySessionAttributes.ForceSync, TimeSpan.MinValue, GenuineConnectionType.Persistent, null, TimeSpan.FromSeconds(10))); try { res = _RemoteSvc.ChangePassword(oldPassword, newPassword); } finally { SecuritySessionServices.SetCurrentSecurityContext(oldParams); } return(res); }
public void RemoteInvocationWithCompression() { // test compression var parameters = new SecuritySessionParameters( SecuritySessionServices.DefaultContext.Name, SecuritySessionAttributes.EnableCompression, TimeSpan.FromSeconds(5)); // note: localhost url should now work, although it may be resolved to IPv6 address var proxy = (IService)Activator.GetObject(typeof(IService), ServiceUri); using (new SecurityContextKeeper(parameters)) { var greeting = proxy.Greeting("Compressed World"); Assert.AreEqual("Hello, Compressed World!", greeting); } }
public LoginResult LoginVersionCheck(string login, string password, out User resultUser, Version clientVersion) { _SvcAccess = null; _LogonUser = null; LoginResult res; SecuritySessionParameters oldParams = SecuritySessionServices.SetCurrentSecurityContext( new SecuritySessionParameters("/BAUMAX/SES", SecuritySessionAttributes.ForceSync, TimeSpan.MinValue, GenuineConnectionType.Persistent, null, TimeSpan.FromSeconds(10))); try { res = _RemoteSvc.LoginVersionCheck(login, password, out resultUser, clientVersion); _LogonUser = resultUser; } finally { SecuritySessionServices.SetCurrentSecurityContext(oldParams); } return(res); }
/// <summary> /// Sends a message to the remote host. /// </summary> /// <param name="message">The message to be sent.</param> public void Send(Message message) { #if TRIAL _messagesBeingSent[message.MessageId] = message; #endif BinaryLogWriter binaryLogWriter = this.ITransportContext.BinaryLogWriter; try { using (new ReaderAutoLocker(this._disposeLock)) { if (this._disposed) { throw OperationException.WrapException(this._disposeReason); } } SecuritySession session = null; if (this._disposed) { throw OperationException.WrapException(this._disposeReason); } // get the security session descriptor if (message.SecuritySessionParameters == null) { SecuritySessionParameters securitySessionParameters = SecuritySessionServices.GetCurrentSecurityContext(); if (securitySessionParameters == null) { securitySessionParameters = message.Recipient.SecuritySessionParameters; } if (securitySessionParameters == null) { securitySessionParameters = this.ITransportContext.SecuritySessionParameters; } if (securitySessionParameters == null) { securitySessionParameters = SecuritySessionServices.DefaultSecuritySession; } message.SecuritySessionParameters = securitySessionParameters; } // LOG: if (binaryLogWriter != null && binaryLogWriter[LogCategory.MessageProcessing] > 0) { binaryLogWriter.WriteSecuritySessionParametersEvent("ConnectionManager.Send", LogMessageType.SecuritySessionParametersAssembled, null, message, message.Recipient, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, message.SecuritySessionParameters, "Security Session Parameters have been assembled."); } // determine the type of sending message.IsSynchronous = (message.SecuritySessionParameters.Attributes & SecuritySessionAttributes.ForceSync) != 0 || (message.IsSynchronous && (message.SecuritySessionParameters.Attributes & SecuritySessionAttributes.ForceAsync) == 0); // the time until invocation times out if (!message.FinishTime_Initialized) { TimeSpan messageTimeout = message.SecuritySessionParameters.Timeout; if (messageTimeout == TimeSpan.MinValue) { messageTimeout = (TimeSpan)this.ITransportContext.IParameterProvider[GenuineParameter.InvocationTimeout]; } message.FinishTime = GenuineUtility.GetTimeout(messageTimeout); message.FinishTime_Initialized = true; } // checks whether the message has been already processed by Security Session if (message.SerializedContent == null) { session = message.Recipient.GetSecuritySession(message.SecuritySessionParameters.Name, this.ITransportContext.IKeyStore); if (!session.IsEstablished) { if (binaryLogWriter != null && binaryLogWriter[LogCategory.Security] > 0) { binaryLogWriter.WriteEvent(LogCategory.Security, "ConnectionManager.Send", LogMessageType.SecuritySessionHasNotBeenEstablishedYet, null, message, message.Recipient, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, session, session.Name, -1, 0, 0, 0, null, null, null, null, "The requested Security Session is not established."); } session.InitiateEstablishingSecuritySession(message.SecuritySessionParameters); // if it's a sync sending, then wait until security session will be established if (message.IsSynchronous) { int timeSpanToWait = GenuineUtility.GetMillisecondsLeft(message.FinishTime); if (timeSpanToWait <= 0) { throw GenuineExceptions.Get_Send_ServerDidNotReply(); } // wait until Security Session will be established or a failure will be detected int firedEvent = 0; if (message.CancelSending != null) { firedEvent = WaitHandle.WaitAny(new WaitHandle[] { session.IsEstablishedEvent, session.Failed, message.CancelSending }, timeSpanToWait, false); } else { firedEvent = WaitHandle.WaitAny(new WaitHandle[] { session.IsEstablishedEvent, session.Failed }, timeSpanToWait, false); } if (firedEvent == WaitHandle.WaitTimeout) { throw GenuineExceptions.Get_Send_ServerDidNotReply(); } // analyze the problem, if any Exception exception = session.ReasonOfFailure; if (firedEvent == 1) { if (exception != null) { throw OperationException.WrapException(exception); } else { throw GenuineExceptions.Get_Security_ContextWasNotEstablished(session.Name); } } // if the message has been cancelled, let the sender to understand the reason if (firedEvent == 2) { return; } } else if (!session.IsEstablished) { // it's async and SS still isn't established session.PutMessageToAwaitingQueue(message); return; } } } // if serialization is necessary if (message.SerializedContent == null) { // serialize the message GenuineChunkedStream serializedMessageStream = new GenuineChunkedStream(false); MessageCoder.Serialize(serializedMessageStream, message, (message.SecuritySessionParameters.Attributes & SecuritySessionAttributes.EnableCompression) != 0); // save the name of the Security Session GenuineChunkedStream resultStream = new GenuineChunkedStream(false); BinaryWriter writer = new BinaryWriter(resultStream); writer.Write(message.SecuritySessionParameters.Name); session.Encrypt(serializedMessageStream, resultStream); message.SerializedContent = resultStream; // LOG: put down the log record if (binaryLogWriter != null && binaryLogWriter[LogCategory.Security] > 0) { binaryLogWriter.WriteEvent(LogCategory.Security, "ConnectionManager.Send", LogMessageType.SecuritySessionApplied, null, message, message.Recipient, binaryLogWriter[LogCategory.Security] > 1 ? message.SerializedContent : null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, session, session.Name, -1, 0, 0, 0, null, null, null, null, "The message has been processed by the established Security Session."); } } #if TRIAL if (message.MessageId > 3005) { throw GenuineExceptions.Get_Channel_TrialConditionExceeded("The maximum number of messages restriction has been exceeded. You can not send more than 3000 messages using TRIAL version."); } #endif message.Sender = this.Local; this.InternalSend(message); } catch (Exception ex) { if (binaryLogWriter != null && binaryLogWriter[LogCategory.Security] > 0) { binaryLogWriter.WriteEvent(LogCategory.MessageProcessing, "ConnectionManager.Send", LogMessageType.Error, ex, message, message.Recipient, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, -1, 0, 0, 0, null, null, null, null, "An exception occurred while processing the message."); } throw; } }