public BaseSelectedRequestEditorAction(TVRequestsList requestList, DataGridView dataGrid)
{
_requestList = requestList;
_dataGrid = dataGrid;
_dataSource = requestList.DataSource;
_requestEventsQueueSize = requestList.RequestEventsQueueSize;
}
/// <summary>
/// Exports data from the specified source to the specifies strems
/// </summary>
/// <param name="source"></param>
/// <param name="stream"></param>
/// <param name="overwriteScheme">Wether to overrite existing http scheme</param>
/// <param name="isSSL">Wether the request is secure or not. This will overrite the http scheme of the request if applicable</param>
/// <param name="newHost">New host for the request</param>
/// <param name="newPort">New port for the request</param>
protected virtual void Export(ITrafficDataAccessor source, Stream stream, bool overwriteScheme, bool isSSL, string newHost, int newPort)
{
TVRequestInfo info;
int i = -1;
string overridenScheme = isSSL ? "https" : "http";
//using an xml writer for memory concerns
XmlWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
writer.WriteStartDocument();
writer.WriteComment(String.Format("Automatically created by Traffic Viewer SDK at {0}", DateTime.Now));
writer.WriteComment(String.Format("Number of requests in file {0}", source.RequestCount));
writer.WriteStartElement("requests");
while ((info = source.GetNext(ref i)) != null)
{
string scheme = info.IsHttps ? "https" : "http";
scheme = overwriteScheme ? overridenScheme : scheme;
//get the request information
byte[] data = source.LoadRequestData(info.Id);
if (data != null)
{
HttpRequestInfo reqInfo = new HttpRequestInfo(data);
reqInfo.IsSecure = scheme == "https";
WriteRequest(writer, newHost, newPort, scheme, reqInfo);
}
}
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Flush();
}
public ExternalBrowserListener(ITrafficDataAccessor source, BaseProxy proxy = null, bool hideControls = false)
{
InitializeComponent();
if (hideControls)
{
_checkTrapReq.Visible = _checkTrapResp.Visible = _labelTrap.Visible = _textTrapMatch.Visible = _checkTrackReqContext.Visible = false;
this.MinimumSize = new Size(this.Width, this.Height / 2);
this.Size = this.MaximumSize = this.MinimumSize;
}
if (proxy != null)
{
_proxy = proxy;
}
else
{
_proxy = new AdvancedExploreProxy(TrafficViewer.Instance.Options.TrafficServerIp, TrafficViewer.Instance.Options.TrafficServerPort, source);
if (TrafficViewerOptions.Instance.UseProxy)
{
WebProxy webProxy = new WebProxy(TrafficViewerOptions.Instance.HttpProxyServer, TrafficViewerOptions.Instance.HttpProxyPort);
_proxy.NetworkSettings.WebProxy = webProxy;
}
_proxy.NetworkSettings.CertificateValidationCallback = new RemoteCertificateValidationCallback(SSLValidationCallback.ValidateRemoteCertificate);
}
StartProxy();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="forwardingHost">The hosts thar requests will be sent to</param>
/// <param name="forwardingPort">The forwarding port</param>
/// <param name="host">The host of the proxy</param>
/// <param name="port">The port of the proxy</param>
/// <param name="dataStore">Data store where the requests will be saved</param>
public ReverseProxy(string host, int port, int securePort, ITrafficDataAccessor dataStore) :
base(host, port, securePort)
{
ExtraOptions.Add(ReverseProxy.FORWARDING_HOST_OPT, String.Empty);
ExtraOptions.Add(ReverseProxy.FORWARDING_PORT_OPT, String.Empty);
_dataStore = dataStore;
}
public void TestLineSearchInRequestNoRegex()
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "GET /a1 HTTP/1.1\r\nHeader1: a1";
string secondRequest = "GET /a2 HTTP/1.1\r\nHeader1: a2";
tvf.AddRequestResponse(firstRequest, "HTTP 200 OK");
tvf.AddRequestResponse(secondRequest, "HTTP 200 OK");
Assert.AreEqual(2, tvf.RequestCount);
LineSearcher searcher = new LineSearcher();
LineMatches result = new LineMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.Request, false, "a1"));
searcher.Search(tvf, criteriaSet, result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(0, result[0].RequestId);
Assert.AreEqual(0, result[1].RequestId);
Assert.AreEqual(1, result[0].MatchCoordinatesList.Count);
Assert.AreEqual(1, result[1].MatchCoordinatesList.Count);
Assert.AreEqual("a1", firstRequest.Substring(result[0].MatchCoordinatesList[0].MatchPosition, result[0].MatchCoordinatesList[0].MatchLength));
Assert.AreEqual("a1", firstRequest.Substring(result[1].MatchCoordinatesList[0].MatchPosition, result[1].MatchCoordinatesList[0].MatchLength));
}
public void TestRequestLineAfterReplace()
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "GET http://site.com/a1 HTTP/1.1\r\nHeader1: a1";
tvf.AddRequestResponse(firstRequest, String.Empty);
TVRequestInfo reqInfo = tvf.GetRequestInfo(0);
Assert.AreEqual("GET http://site.com/a1 HTTP/1.1", reqInfo.RequestLine);
Assert.AreEqual(1, tvf.RequestCount);
LineSearcher searcher = new LineSearcher();
LineMatches result = new LineMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.RequestLine, true, "a1|a=2|<r>2</r>"));
searcher.Search(tvf, criteriaSet, result);
tvf.Replace(result, "replacement");
firstRequest = Constants.DefaultEncoding.GetString(tvf.LoadRequestData(0));
Assert.AreEqual("GET http://site.com/replacement HTTP/1.1\r\nHeader1: a1", firstRequest);
Assert.AreEqual("GET http://site.com/replacement HTTP/1.1", reqInfo.RequestLine);
}
/// <summary>
/// Sends http request asynchroneusly
/// </summary>
/// <param name="param"></param>
private void SendAsync(object param)
{
object[] paramArray = param as object[];
if (paramArray == null || paramArray.Length != 2)
{
return;
}
ITrafficDataAccessor source = paramArray[0] as ITrafficDataAccessor;
Queue <TVRequestInfo> requestsToSend = paramArray[1] as Queue <TVRequestInfo>;
if (source == null || requestsToSend == null)
{
return;
}
while (true)
{
TVRequestInfo info = null;
lock (_lock)
{
if (requestsToSend.Count == 0)
{
return;
}
info = requestsToSend.Dequeue();
}
if (info != null)
{
SendRequest(source, info);
}
}
}
/// <summary>
/// Executes the parsing operation
/// </summary>
/// <param name="pathOfFileToImport"></param>
/// <param name="currentFile"></param>
/// <param name="options"></param>
public void Parse(string pathOfFileToImport, ITrafficDataAccessor currentFile, ParsingOptions options)
{
_options = options;
var exclusions = options.GetExclusions();
_status = TrafficParserStatus.Running;
Har har = HarConvert.DeserializeFromFile(pathOfFileToImport);
foreach (Entry entry in har.Log.Entries)
{
try
{
if (!IsExcluded(entry.Request.Url, exclusions))
{
AddRequest(currentFile, entry);
}
}
catch (Exception ex)
{
SdkSettings.Instance.Logger.Log(TraceLevel.Error, "URI Parser - Failed to add request: {0}", ex.Message);
}
}
_status = TrafficParserStatus.Stopped;
}
/// <summary>
/// Loads the entities view
/// </summary>
/// <param name="requestText"></param>
/// <param name="responseText"></param>
public void LoadEntitiesView(int requestId, ITrafficDataAccessor accessor, string requestText)
{
this.Invoke((MethodInvoker) delegate
{
_pageEntitiesView.LoadRequest(requestId, accessor, requestText);
});
}
public void TestLineSearchMultipleMatchesPerLineRegex()
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "POST /a1/a1 HTTP/1.1\r\nHeader1: a1\r\n\r\na=1";
string firstResponse = "HTTP 200 OK\r\n<r>1</r>";
tvf.AddRequestResponse(firstRequest, firstResponse);
Assert.AreEqual(1, tvf.RequestCount);
LineSearcher searcher = new LineSearcher();
LineMatches result = new LineMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.RequestLine, true, @"a\d"));
searcher.Search(tvf, criteriaSet, result);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(2, result[0].MatchCoordinatesList.Count);
}
public void TestRequestSearchMultipleTexts()
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "POST /a1 HTTP/1.1\r\nHeader1: a1\r\n\r\na=1";
string secondRequest = "POST /a2 HTTP/1.1\r\nHeader1: a2\r\n\r\na=1&b=2";
string firstResponse = "HTTP 200 OK\r\n<r>1</r>";
string secondResponse = "HTTP 200 OK\r\n<r>2</r>";
tvf.AddRequestResponse(firstRequest, firstResponse);
tvf.AddRequestResponse(secondRequest, secondResponse);
Assert.AreEqual(2, tvf.RequestCount);
RequestSearcher searcher = new RequestSearcher();
RequestMatches result = new RequestMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.RequestBody, false, "a=1"));
criteriaSet.Add(new SearchCriteria(SearchContext.RequestBody, false, "b=2"));
searcher.Search(tvf, criteriaSet, result);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(1, result[0]);
}
/// <summary>
/// Gets a memory stream to search in for the specified context
/// </summary>
/// <param name="dataSource"></param>
/// <param name="header"></param>
/// <param name="context"></param>
/// <returns></returns>
protected MemoryStream GetMemoryStream(ITrafficDataAccessor dataSource, TVRequestInfo header, SearchContext context)
{
MemoryStream toBeSearched;
if (context == SearchContext.Request || context == SearchContext.RequestBody)
{
toBeSearched = new MemoryStream(dataSource.LoadRequestData(header.Id));
}
else if (context == SearchContext.Response)
{
toBeSearched = new MemoryStream(dataSource.LoadResponseData(header.Id));
}
else
{
toBeSearched = new MemoryStream();
byte[] data = dataSource.LoadRequestData(header.Id);
toBeSearched.Write(data, 0, data.Length);
data = Constants.DefaultEncoding.GetBytes(Environment.NewLine);
toBeSearched.Write(data, 0, data.Length);
data = dataSource.LoadResponseData(header.Id);
toBeSearched.Write(data, 0, data.Length);
//reset the prosition so readline can start from the beggining
toBeSearched.Position = 0;
}
return(toBeSearched);
}
/// <summary>
/// Creates a connection that will forward the request to the specified host and port
/// </summary>
/// <param name="fwHost"></param>
/// <param name="fwPort"></param>
/// <param name="client"></param>
/// <param name="isSecure"></param>
/// <param name="dataStore"></param>
/// <param name="networkSettings"></param>
/// <param name="parentProxy"></param>
public TrackingReverseProxyConnection(TcpClient client, bool isSecure, ITrafficDataAccessor dataStore, INetworkSettings networkSettings, IHttpProxy parentProxy)
: base(client, isSecure, dataStore, Resources.TrackingReverseProxyDescription, networkSettings, false)
{
_dataStore = dataStore;
_parentProxy = parentProxy;
_networkSettings = networkSettings;
}
/// <summary>
/// Performs a search
/// </summary>
/// <param name="dataSource">Traffic data accesssor</param>
/// <param name="criteriaSet">Set of criteria for the search</param>
/// <param name="result">The search result</param>
public void Search(ITrafficDataAccessor dataSource, SearchCriteriaSet criteriaSet, ISearchResult result)
{
_stopSearch = false;
//check the search results cache
int hash = GetSearchHash(dataSource, criteriaSet);
ICacheable entry = SearchResultCache.Instance.GetEntry(hash);
ISearchResult cachedResult = null;
if (entry != null)
{
cachedResult = entry.Reserve() as ISearchResult;
entry.Release();
}
if (cachedResult == null)
{
//check for a subset
SearchSubset subset = GetSearchSubset(criteriaSet);
if (subset == null)
{
FullSearch(dataSource, criteriaSet, result);
}
else
{
SubsetSearch(dataSource, criteriaSet, result, subset);
}
//cache the search
SearchResultCache.Instance.Add(hash, new CacheEntry(result));
}
else
{
result.AddRange(cachedResult);
}
}
private static void ReplaceTest(string replacement)
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "GET /a1 HTTP/1.1\r\nHeader1: a1";
string secondRequest = "GET /a2 HTTP/1.1\r\nHeader1: a2";
string firstResponse = "HTTP 200 OK\r\n<r>1</r>";
string secondResponse = "HTTP 200 OK\r\n<r>2</r><tag><r>3</r>";
tvf.AddRequestResponse(firstRequest, firstResponse);
tvf.AddRequestResponse(secondRequest, secondResponse);
Assert.AreEqual(2, tvf.RequestCount);
LineSearcher searcher = new LineSearcher();
LineMatches result = new LineMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.Full, true, @"a1|a=2|<r>\d</r>"));
searcher.Search(tvf, criteriaSet, result);
tvf.Replace(result, replacement);
firstRequest = Constants.DefaultEncoding.GetString(tvf.LoadRequestData(0));
secondRequest = Constants.DefaultEncoding.GetString(tvf.LoadRequestData(1));
firstResponse = Constants.DefaultEncoding.GetString(tvf.LoadResponseData(0));
secondResponse = Constants.DefaultEncoding.GetString(tvf.LoadResponseData(1));
Assert.AreEqual("GET /" + replacement + " HTTP/1.1\r\nHeader1: " + replacement, firstRequest);
Assert.AreEqual("HTTP 200 OK\r\n" + replacement + "<tag>" + replacement, secondResponse);
}
public void TestLineSearchInResponseRegex()
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "POST /a1 HTTP/1.1\r\nHeader1: a1\r\n\r\na=1";
string secondRequest = "POST /a2 HTTP/1.1\r\nHeader1: a2\r\n\r\na=2";
string firstResponse = "HTTP 200 OK\r\n<r>1</r>";
string secondResponse = "HTTP 200 OK\r\n<r>2</r>";
tvf.AddRequestResponse(firstRequest, firstResponse);
tvf.AddRequestResponse(secondRequest, secondResponse);
Assert.AreEqual(2, tvf.RequestCount);
LineSearcher searcher = new LineSearcher();
LineMatches result = new LineMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.Response, true, @"<r>\d+</r>|a1"));
searcher.Search(tvf, criteriaSet, result);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(0, result[0].RequestId);
Assert.AreEqual(SearchContext.Response, result[0].Context);
Assert.AreEqual(1, result[0].MatchCoordinatesList.Count);
Assert.AreEqual("<r>2</r>", secondResponse.Substring(result[1].MatchCoordinatesList[0].MatchPosition, result[1].MatchCoordinatesList[0].MatchLength));
}
public void TestReplaceInvalidCoords()
{
TrafficViewer.Instance.NewTvf();
ITrafficDataAccessor tvf = TrafficViewer.Instance.TrafficViewerFile;
string firstRequest = "GET /a1 HTTP/1.1\r\nHeader1: a1";
string firstResponse = "HTTP 200 OK\r\n<r>2</r><tag><r>3</r>";
tvf.AddRequestResponse(firstRequest, firstResponse);
LineSearcher searcher = new LineSearcher();
LineMatches result = new LineMatches();
SearchCriteriaSet criteriaSet = new SearchCriteriaSet();
criteriaSet.Add(new SearchCriteria(SearchContext.Full, true, @"a1|a=2|<r>\d</r>"));
searcher.Search(tvf, criteriaSet, result);
(tvf as TrafficViewerFile).Clear(false);
Assert.AreEqual(0, tvf.RequestCount);
string secondRequest = "GET /a2 HTTP/1.1\r\nHeader1: a2";
string secondResponse = "HTTP 200 OK\r\n<r>1</r>";
tvf.AddRequestResponse(secondRequest, secondResponse);
Assert.AreEqual(1, tvf.RequestCount);
//this should not cause an exception
tvf.Replace(result, "");
}
public void Execute(ITrafficDataAccessor curDataAccessor,
List <TVRequestInfo> selectedRequests,
IHttpClientFactory curHttpClientFactory)
{
var setupForm = new ScriptCrawlerForm(curDataAccessor);
setupForm.Show();
}
public SimpleDiffForm(ITrafficDataAccessor source, int indexOfFirst, int indexOfSecond)
{
InitializeComponent();
_source = source;
_currFirstIndex = Math.Min(indexOfFirst, indexOfSecond);
_currSecondIndex = Math.Max(indexOfFirst, indexOfSecond);
DoDiff(_currFirstIndex, _currSecondIndex);
}
/// <summary>
/// Contructor
/// </summary>
/// <param name="module"></param>
/// <param name="source"></param>
public AnalysisProcessingPage(IAnalysisModule module, ITrafficDataAccessor source)
{
InitializeComponent();
_module = module;
_source = source;
_module.LogEvent += new AnalysisModuleLogEvent(ModuleLogEvent);
}
/// <summary>
/// Searches the entire data accessor for the specified criteria
/// </summary>
/// <param name="dataSource"></param>
/// <param name="criteriaSet"></param>
/// <param name="result"></param>
private void FullSearch(ITrafficDataAccessor dataSource, SearchCriteriaSet criteriaSet, ISearchResult result)
{
TVRequestInfo header;
int currReqId = -1;
while ((header = dataSource.GetNext(ref currReqId)) != null && !_stopSearch)
{
RequestMatches(dataSource, header, criteriaSet, result);
}
}
/// <summary>
/// Constructor for the manual proxy connection
/// </summary>
/// <param name="tcpClient">TCP client being used</param>
/// <param name="isSecure">Whether the connection is secure or not</param>
/// <param name="dataStore">The data store being used</param>
/// <param name="description">Description to add to the data store for each request</param>
/// <param name="networkSettings">Network settings to be used for the connection</param>
public ManualExploreProxyConnection(TcpClient tcpClient,
bool isSecure,
ITrafficDataAccessor dataStore,
string description,
INetworkSettings networkSettings)
: base(tcpClient, isSecure, dataStore, description)
{
_httpClient = new WebRequestClient();
_httpClient.SetNetworkSettings(networkSettings);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sourceStore"></param>
/// <param name="saveStore"></param>
public TrafficStoreProxy(ITrafficDataAccessor sourceStore, ITrafficDataAccessor saveStore)
:
this(
sourceStore,
saveStore,
TrafficViewerOptions.Instance.TrafficServerIp,
TrafficViewerOptions.Instance.TrafficServerPort,
TrafficViewerOptions.Instance.TrafficServerPortSecure
)
{
}
/// <summary>
/// Starts the parsing operation
/// </summary>
/// <param name="scantPath"></param>
/// <param name="currentFile"></param>
/// <param name="profile"></param>
public void Parse(string scantPath, ITrafficDataAccessor currentFile, ParsingOptions profile)
{
_profile = profile;
_configFile = new XmlDocument();
_configFile.XmlResolver = null;
_configFile.Load(scantPath);
_tvFile = currentFile;
HandleAppScanSettings();
HandleASESettings();
}
/// <summary>
/// Sends all the requests in the attached file
/// </summary>
/// <param name="source"></param>
public void Send(ITrafficDataAccessor source)
{
int id = -1;
TVRequestInfo info = null;
PatternTracker.Instance.PatternsToTrack = source.Profile.GetTrackingPatterns();
while ((info = source.GetNext(ref id)) != null)
{
SendRequest(source, info);
}
}
/// <summary>
/// Creates a proxy connection that retrieves data from a traffic data store
/// </summary>
/// <param name="sourceStore">The store to obtain the data from</param>
/// <param name="matchMode">The way requests will be matched</param>
/// <param name="ignoreAuth">Whether to ignore authentication</param>
/// <param name="client">TCP client for the connection</param>
/// <param name="isSecure">Whether to secure the stream</param>
/// <param name="saveStore">Data store to seve information to</param>
/// <param name="requestDescription">Description to be used for the request in the save store</param>
public TrafficStoreProxyConnection(
ITrafficDataAccessor sourceStore,
TrafficServerMode matchMode,
bool ignoreAuth,
TcpClient client,
bool isSecure,
ITrafficDataAccessor saveStore,
string requestDescription
)
: base(client, isSecure, saveStore, requestDescription)
{
_httpClient = new TrafficStoreHttpClient(sourceStore, matchMode, ignoreAuth);
}
private void AddRequest(ITrafficDataAccessor currentFile, Uri uri, string fullQuery, string format)
{
string request = String.Format(format, uri.AbsolutePath, fullQuery, uri.Host, uri.Port);
HttpRequestInfo requestInfo = new HttpRequestInfo(request);
TVRequestInfo tvReqInfo = new TVRequestInfo();
tvReqInfo.Description = Resources.UriParserDescription;
tvReqInfo.RequestLine = HttpRequestInfo.GetRequestLine(request);
tvReqInfo.ThreadId = "N/A";
tvReqInfo.RequestTime = DateTime.Now;
tvReqInfo.IsHttps = String.Compare(uri.Scheme, "https", true) == 0;
currentFile.AddRequestInfo(tvReqInfo);
currentFile.SaveRequest(tvReqInfo.Id, requestInfo.ToArray(false));
}
/// <summary>
/// Creates a connection
/// </summary>
/// <param name="client">TCP client to use</param>
/// <param name="isSecure">Whether to use SSL or not</param>
/// <param name="dataStore">Data store to save requests/responses to or to read from</param>
/// <param name="requestDescription">Description added to the data store</param>
public BaseProxyConnection(TcpClient client, bool isSecure, ITrafficDataAccessor dataStore, string requestDescription)
{
_client = client;
_clientStreamWrapper = new HttpProxyClientStreamWrapper(_client);
_isSecure = isSecure;
_trafficDataStore = dataStore;
_requestDescription = requestDescription;
_requestBuilder = new ByteArrayBuilder();
if (dataStore != null)
{
_exclusions = dataStore.Profile.GetExclusions();
}
HttpServerConsole.Instance.WriteLine(LogMessageType.Information,
"Inbound connection from {0}", ((IPEndPoint)client.Client.RemoteEndPoint).Address);
}
/// <summary>
/// Searches only in the specified subset
/// </summary>
/// <param name="dataSource"></param>
/// <param name="criteriaSet"></param>
/// <param name="result"></param>
/// <param name="subset"></param>
private void SubsetSearch(ITrafficDataAccessor dataSource, SearchCriteriaSet criteriaSet, ISearchResult result, SearchSubset subset)
{
foreach (int reqId in subset)
{
TVRequestInfo header = dataSource.GetRequestInfo(reqId);
if (_stopSearch)
{
break;
}
if (header != null)
{
RequestMatches(dataSource, header, criteriaSet, result);
}
}
}
public void Execute(ITrafficDataAccessor curDataAccessor,
List <TVRequestInfo> selectedRequests,
IHttpClientFactory curHttpClientFactory)
{
if (selectedRequests.Count < 1)
{
ErrorBox.ShowDialog(Resources.SelectOneRequest);
return;
}
Fuzzer fuzzer = new Fuzzer();
fuzzer.Requests = selectedRequests;
fuzzer.DataAccessor = curDataAccessor;
fuzzer.Show();
}
