public SoftwareBreakpoint(IntPtr address, BreakpointHandler handler)
{
Contract.Requires(handler != null);
Address = address;
this.handler = handler;
}
public void RemoveBreakpoint(MethodBase method, int ilOffset)
{
Breakpoint b = new Breakpoint(method, ilOffset);
if (Breakpoints.Contains(b))
{
Breakpoints.Remove(b);
BreakpointHandler temp = BookmarkRemoved;
if (temp != null)
{
temp(method, ilOffset);
}
}
}
public void AddBreakpoint(MethodBase method, int ilOffset)
{
Breakpoint b = new Breakpoint(method, ilOffset);
if (!Breakpoints.Contains(b))
{
Breakpoints.Add(b);
BreakpointHandler temp = BookmarkAdded;
if (temp != null)
{
temp(method, ilOffset);
}
}
}
public HardwareBreakpoint(IntPtr address, HardwareBreakpointRegister register, HardwareBreakpointTrigger trigger, HardwareBreakpointSize size, BreakpointHandler handler)
{
Contract.Requires(handler != null);
if (register == HardwareBreakpointRegister.InvalidRegister)
{
throw new InvalidOperationException();
}
Address = address;
Register = register;
Trigger = trigger;
Size = size;
this.handler = handler;
}
public async Task SendAsync_ShouldRetryWithNewToken_WhenRefreshedWhileRequesting()
{
// Arrange
var breakpointHandler = new BreakpointHandler {
InnerHandler = _innerHandler
};
var requestBreakpoint = breakpointHandler.Breakpoint;
var breakpointTokenClient = new BreakpointTokenClient(_tokenClient);
var tokenClientBreakpoint = breakpointTokenClient.Breakpoint;
var handler = new UnauthorizedResponseHandler(breakpointTokenClient, _tokenStorage, _userStorage)
{
InnerHandler = breakpointHandler
};
var client = new HttpClient(handler)
{
BaseAddress = _baseAddress
};
_tokenClient.RefreshTokenAsync(Arg.Any <CancellationToken>())
.Returns(ApiResponseResult <RefreshTokenResponse> .Ok(
new RefreshTokenResponse {
AccessToken = "New access token", RefreshToken = "New refresh token"
}));
var response = new HttpResponseMessage(HttpStatusCode.OK);
// Act
var task1 = Task.CompletedTask;
var task2 = Task.CompletedTask;
try
{
// Sending first request and pausing it
var request1 = new HttpRequestMessage(HttpMethod.Get, "/vpn");
task1 = client.SendAsync(request1);
var request1Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
// Sending second request and pausing it
var request2 = new HttpRequestMessage(HttpMethod.Get, "/profiles");
task2 = client.SendAsync(request2);
var request2Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
// Continue first request and get Unauthorized
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/vpn")
.Respond(HttpStatusCode.Unauthorized);
request1Hit.Continue();
// First request initiated token refresh
await tokenClientBreakpoint.WaitForHitAndContinue().TimeoutAfter(TestTimeout);
// First request retried with new tokens
request1Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/vpn")
.WithHeaders("Authorization", "Bearer New access token")
.Respond(req => response);
request1Hit.Continue();
await task1.TimeoutAfter(TestTimeout);
// Second request continues and gets Unauthorized
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/profiles")
.Respond(HttpStatusCode.Unauthorized);
request2Hit.Continue();
// Second request retried with new access token
request2Hit = await requestBreakpoint.WaitForHit().TimeoutAfter(TestTimeout);
_innerHandler.Expect(HttpMethod.Get, "https://api.protonvpn.ch/profiles")
.WithHeaders("Authorization", "Bearer New access token")
.Respond(req => response);
request2Hit.Continue();
}
finally
{
await task1.TimeoutAfter(TestTimeout);
await task2.TimeoutAfter(TestTimeout);
}
// Assert
await _tokenClient.Received(1).RefreshTokenAsync(Arg.Any <CancellationToken>());
_innerHandler.VerifyNoOutstandingExpectation();
}
void BreakpointWrapper(object sender, EventArgs e)
{
BreakpointHandler?.Invoke(this, e);
}
public void FindCodeByBreakpoint(IntPtr address, int size, HardwareBreakpointTrigger trigger)
{
var register = GetUsableDebugRegister();
if (register == HardwareBreakpointRegister.InvalidRegister)
{
throw new NoHardwareBreakpointAvailableException();
}
var breakpointList = SplitBreakpoint(address, size);
var fcf = new FoundCodeForm(process, breakpointList[0].Address, trigger);
var localBreakpoints = new List <IBreakpoint>();
fcf.Stop += (sender, e) =>
{
lock (localBreakpoints)
{
foreach (var bp in localBreakpoints)
{
RemoveBreakpoint(bp);
}
localBreakpoints.Clear();
}
};
BreakpointHandler handler = delegate(IBreakpoint bp, ref DebugEvent evt)
{
fcf.AddRecord(evt.ExceptionInfo);
};
var breakpoint = new HardwareBreakpoint(breakpointList[0].Address, register, trigger, (HardwareBreakpointSize)breakpointList[0].Size, handler);
try
{
AddBreakpoint(breakpoint);
localBreakpoints.Add(breakpoint);
fcf.Show();
}
catch
{
fcf.Dispose();
throw;
}
if (breakpointList.Count > 1)
{
foreach (var split in breakpointList.Skip(1))
{
register = GetUsableDebugRegister();
if (register == HardwareBreakpointRegister.InvalidRegister)
{
break;
}
breakpoint = new HardwareBreakpoint(split.Address, register, trigger, (HardwareBreakpointSize)split.Size, handler);
AddBreakpoint(breakpoint);
localBreakpoints.Add(breakpoint);
}
}
}
