protected virtual void OnConnectionStatusChangedEvent(RasConnectionState state)
{
if (ConnectionStatusChanged != null)
{
ConnectionStatusChanged(state);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RasConnectionState"/> class.
/// </summary>
/// <param name="connectionState">The state of the connection.</param>
/// <param name="device">The device through which the connection has been established.</param>
/// <param name="phoneNumber">The phone number dialed for this specific connection.</param>
/// <param name="localEndpoint">Optional. The local client endpoint information of a virtual private network (VPN) tunnel.</param>
/// <param name="remoteEndpoint">Optional. The remote client endpoint information of a virtual private network (VPN) tunnel.</param>
/// <param name="connectionSubState">The state of an Internet Key Exchange version2 (IKEv2) virtual private network (VPN) tunnel.</param>
public RasConnectionStatus(RasConnectionState connectionState, RasDevice device, string phoneNumber, IPAddress localEndpoint, IPAddress remoteEndpoint, RasConnectionSubState connectionSubState)
{
ConnectionState = connectionState;
Device = device ?? throw new ArgumentNullException(nameof(device));
PhoneNumber = phoneNumber;
LocalEndPoint = localEndpoint;
RemoteEndPoint = remoteEndpoint;
ConnectionSubState = connectionSubState;
}
/// <summary>
/// Initializes a new instance of the <see cref="DotRas.StateChangedEventArgs"/> class.
/// </summary>
/// <param name="callbackId">The application defined value that was specified during dialing.</param>
/// <param name="subEntryId">The one-based index for the phone book entry associated with this connection.</param>
/// <param name="handle">The handle of the connection.</param>
/// <param name="state">The state the remote access connection is about to enter.</param>
/// <param name="errorCode">The error code (if any) that occurred.</param>
/// <param name="errorMessage">The error message of the <paramref name="errorCode"/> that occurred.</param>
/// <param name="extendedErrorCode">The extended error code (if any) that occurred.</param>
internal StateChangedEventArgs(IntPtr callbackId, int subEntryId, RasHandle handle, RasConnectionState state, int errorCode, string errorMessage, int extendedErrorCode)
{
this.CallbackId = callbackId;
this.SubEntryId = subEntryId;
this.Handle = handle;
this.State = state;
this.ErrorCode = errorCode;
this.ErrorMessage = errorMessage;
this.ExtendedErrorCode = extendedErrorCode;
}
/// <summary>
/// Initializes a new instance of the <see cref="DotRas.StateChangedEventArgs"/> class.
/// </summary>
/// <param name="callbackId">The application defined value that was specified during dialing.</param>
/// <param name="subEntryId">The one-based index for the phone book entry associated with this connection.</param>
/// <param name="handle">The handle of the connection.</param>
/// <param name="state">The state the remote access connection is about to enter.</param>
/// <param name="errorCode">The error code (if any) that occurred.</param>
/// <param name="errorMessage">The error message of the <paramref name="errorCode"/> that occurred.</param>
/// <param name="extendedErrorCode">The extended error code (if any) that occurred.</param>
internal StateChangedEventArgs(IntPtr callbackId, int subEntryId, RasHandle handle, RasConnectionState state, int errorCode, string errorMessage, int extendedErrorCode)
{
CallbackId = callbackId;
SubEntryId = subEntryId;
Handle = handle;
State = state;
ErrorCode = errorCode;
ErrorMessage = errorMessage;
ExtendedErrorCode = extendedErrorCode;
}
/// <summary>
/// Initializes a new instance of the <see cref="RasDialCallbackTraceEvent"/> class.
/// </summary>
/// <param name="result">The result of the callback.</param>
/// <param name="callbackId">The callback id.</param>
/// <param name="subEntryId">The subentry id.</param>
/// <param name="dangerousHandle">The dangerous handle.</param>
/// <param name="message">The message.</param>
/// <param name="state">The state.</param>
/// <param name="errorCode">The error code.</param>
/// <param name="extendedErrorCode">The extended error code.</param>
public RasDialCallbackTraceEvent(bool result, IntPtr callbackId, int subEntryId, IntPtr dangerousHandle, int message, RasConnectionState state, int errorCode, int extendedErrorCode)
{
Result = result;
CallbackId = callbackId;
SubEntryId = subEntryId;
DangerousHandle = dangerousHandle;
Message = message;
State = state;
ErrorCode = errorCode;
ExtendedErrorCode = extendedErrorCode;
}
/// <summary>
/// Initializes a new instance of the <see cref="RasDialCallbackTraceEvent"/> class.
/// </summary>
/// <param name="result">The result of the callback.</param>
/// <param name="callbackId">The callback id.</param>
/// <param name="subEntryId">The subentry id.</param>
/// <param name="dangerousHandle">The dangerous handle.</param>
/// <param name="message">The message.</param>
/// <param name="state">The state.</param>
/// <param name="errorCode">The error code.</param>
/// <param name="extendedErrorCode">The extended error code.</param>
public RasDialCallbackTraceEvent(bool result, IntPtr callbackId, int subEntryId, IntPtr dangerousHandle, int message, RasConnectionState state, int errorCode, int extendedErrorCode)
{
this.Result = result;
this.CallbackId = callbackId;
this.SubEntryId = subEntryId;
this.DangerousHandle = dangerousHandle;
this.Message = message;
this.State = state;
this.ErrorCode = errorCode;
this.ExtendedErrorCode = extendedErrorCode;
}
public void DialAsyncCancelTest()
{
// Set the state at which to signal the connection should be cancelled.
this.signalOnState = RasConnectionState.DeviceConnected;
this.target.EntryName = entryName;
this.target.Credentials = TestUtilities.GetValidCredentials();
this.target.DialAsync();
// Wait until the state of the connection has reached the appropriate point.
this.stateWaitHandle.WaitOne();
this.target.DialAsyncCancel();
// Now wait for the call to be completed to prevent a race condition.
this.waitHandle.WaitOne();
Assert.IsTrue(this.cancelled);
Assert.IsFalse(this.connected);
Assert.IsFalse(this.timedOut);
Assert.IsNull(this.error);
}
public bool OnCallback(IntPtr dwCallbackId, int dwSubEntry, IntPtr hrasconn, uint message, RasConnectionState rascs, int dwError, int dwExtendedError)
{
GuardMustNotBeDisposed();
GuardMustBeInitialized();
WaitForHandleToBeTransferred();
try
{
GuardRequestShouldNotBeCancelled();
GuardErrorCodeMustBeZero(dwError);
ExecuteStateChangedCallback(rascs);
if (HasConnectionCompleted(rascs))
{
SetConnectionResult();
}
}
catch (Exception ex)
{
HangUpConnection();
SetExceptionResult(ex);
}
return(!Completed);
}
private static bool HasConnectionCompleted(RasConnectionState connectionState)
{
return(connectionState == RasConnectionState.Connected);
}
private void ExecuteStateChangedCallback(RasConnectionState connectionState)
{
onStateChangedCallback(new StateChangedEventArgs(connectionState));
}
//---------------------------------------------------------------------------------------
void StateChanged(RasConnectionState state, int sNo)
{
labelInfo.Text = state.ToString();
progressBar1.Value = (int)((sNo) * (100.0 / 12));
}
private bool RasDialCallback(IntPtr callbackId, int subEntryId, IntPtr dangerousHandle, int message, RasConnectionState state, int errorCode, int extendedErrorCode)
{
bool retval = true;
lock (this.syncRoot)
{
RasHandle connectionHandle = null;
try
{
connectionHandle = new RasHandle(dangerousHandle, subEntryId > 1);
if (!this.IsBusy)
{
// The connection is no longer being dialed, stop receiving notifications for this connection attempt.
retval = false;
}
else
{
string errorMessage = null;
if (errorCode != NativeMethods.SUCCESS)
{
errorMessage = RasHelper.Default.GetRasErrorString(errorCode);
}
StateChangedEventArgs e = new StateChangedEventArgs(callbackId, subEntryId, connectionHandle, state, errorCode, errorMessage, extendedErrorCode);
this.OnStateChanged(e);
if (errorCode != NativeMethods.SUCCESS)
{
this.Abort();
this.PostCompleted(new RasDialException(errorCode, extendedErrorCode), false, false, false);
retval = false;
}
else if (state == RasConnectionState.Connected)
{
this.PostCompleted(null, false, false, true);
}
}
}
catch (Exception ex)
{
this.OnError(new System.IO.ErrorEventArgs(ex));
}
finally
{
DiagnosticTrace.Default.TraceEvent(TraceEventType.Verbose, new RasDialCallbackTraceEvent(retval, callbackId, subEntryId, dangerousHandle, message, state, errorCode, extendedErrorCode));
if (connectionHandle != null)
{
connectionHandle.Dispose();
}
}
}
return(retval);
}
public void DialAsyncCancelTest()
{
// Set the state at which to signal the connection should be cancelled.
this.signalOnState = RasConnectionState.DeviceConnected;
this.target.EntryName = entryName;
this.target.Credentials = TestUtilities.GetValidCredentials();
this.target.DialAsync();
// Wait until the state of the connection has reached the appropriate point.
this.stateWaitHandle.WaitOne();
this.target.DialAsyncCancel();
// Now wait for the call to be completed to prevent a race condition.
this.waitHandle.WaitOne();
Assert.IsTrue(this.cancelled);
Assert.IsFalse(this.connected);
Assert.IsFalse(this.timedOut);
Assert.IsNull(this.error);
}
private bool RasDialCallback(IntPtr callbackId, int subEntryId, IntPtr dangerousHandle, int message, RasConnectionState state, int errorCode, int extendedErrorCode)
{
bool retval = true;
lock (this.syncRoot)
{
RasHandle connectionHandle = null;
try
{
connectionHandle = new RasHandle(dangerousHandle, subEntryId > 1);
if (!this.IsBusy)
{
// The connection is no longer being dialed, stop receiving notifications for this connection attempt.
retval = false;
}
else
{
string errorMessage = null;
if (errorCode != NativeMethods.SUCCESS)
{
errorMessage = RasHelper.Instance.GetRasErrorString(errorCode);
}
DME.Dialer.StateChangedEventArgs e = new DME.Dialer.StateChangedEventArgs(callbackId, subEntryId, connectionHandle, state, errorCode, errorMessage, extendedErrorCode);
this.OnStateChanged(e);
if (errorCode != NativeMethods.SUCCESS)
{
this.Abort();
this.PostCompleted(new RasDialException(errorCode, extendedErrorCode), false, false, false);
retval = false;
}
else if (state == RasConnectionState.Connected)
{
this.PostCompleted(null, false, false, true);
}
}
}
catch (Exception ex)
{
this.OnError(new System.IO.ErrorEventArgs(ex));
}
finally
{
if (connectionHandle != null)
{
connectionHandle.Dispose();
}
}
}
return retval;
}
public bool OnCallback(IntPtr dwCallbackId, int dwSubEntry, IntPtr hrasconn, uint message, RasConnectionState rascs, int dwError, int dwExtendedError)
{
var occurredOn = DateTime.Now;
var result = AttachedObject.OnCallback(dwCallbackId, dwSubEntry, hrasconn, message, rascs, dwError, dwExtendedError);
var callbackEvent = new RasDialCallbackCompletedTraceEvent
{
OccurredOn = occurredOn,
Result = result
};
callbackEvent.Args.Add(nameof(dwCallbackId), dwCallbackId);
callbackEvent.Args.Add(nameof(dwSubEntry), dwSubEntry);
callbackEvent.Args.Add(nameof(hrasconn), hrasconn);
callbackEvent.Args.Add(nameof(message), message);
callbackEvent.Args.Add(nameof(rascs), rascs);
callbackEvent.Args.Add(nameof(dwError), dwError);
callbackEvent.Args.Add(nameof(dwExtendedError), dwExtendedError);
LogVerbose(callbackEvent);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="StateChangedEventArgs"/> class.
/// </summary>
/// <param name="state">The state of the connection.</param>
public StateChangedEventArgs(RasConnectionState state)
{
State = state;
}
protected virtual void OnConnectionStatusChangedEvent(RasConnectionState state)
{
if (ConnectionStatusChanged != null)
{
ConnectionStatusChanged(state);
}
}
