Added database storage from PCAP file. Tests included.

WhiteNoise.Storage/DatabaseWorker.cs

@@ -0,0 +1,190 @@
// 
// DatabaseWorker.cs
//  
// Author:
//       Bryan Allred <bryan.allred@gmail.com>
// 
// Copyright (c) 2011 Bryan Allred
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using SharpPcap;
using SharpPcap.LibPcap;
using WhiteNoise.Domain.Abstract;
using WhiteNoise.Domain.Entities;
namespace WhiteNoise.Storage
{
	/// <summary>
	/// Database worker.
	/// </summary>
	public class DatabaseWorker : BackgroundWorker
	{
		/// <summary>
		/// The packet repository.
		/// </summary>
		private static IPacketRepository _repository;
		
		/// <summary>
		/// Gets or sets the devices.
		/// </summary>
		/// <value>
		/// The devices.
		/// </value>
		private ICollection<ICaptureDevice> _deviceFiles { get; set; }
		
		/// <summary>
		/// Gets or sets the version.
		/// </summary>
		/// <value>
		/// The version.
		/// </value>
		public string Version { get; private set; }
		
		/// <summary>
		/// Initializes a new instance of the <see cref="WhiteNoise.Storage.DatabaseWorker"/> class.
		/// </summary>
		/// <param name='repository'>
		/// Repository.
		/// </param>
		public DatabaseWorker(IPacketRepository repository)
		{
			_repository = repository;
			this._deviceFiles = new List<ICaptureDevice>();
			this.Version = SharpPcap.Version.VersionString;
			
			this.WorkerReportsProgress = true;
			this.WorkerSupportsCancellation = true;
		}
		
		/// <summary>
		/// Captures the device file.
		/// </summary>
		/// <param name='file'>
		/// File.
		/// </param>
		public void CaptureDeviceFile(string file)
		{
			this.CaptureDeviceFile(new FileInfo(file));
		}
		
		/// <summary>
		/// Captures the device file.
		/// </summary>
		/// <param name='file'>
		/// File.
		/// </param>
		public void CaptureDeviceFile(FileInfo file)
		{
			if (file.Exists)
			{
				ICaptureDevice device = null;
				
				try
				{
					// Listen to the device file.
					device = new CaptureFileReaderDevice(file.FullName);
					
					// Add event handler(s).
					device.OnPacketArrival += new PacketArrivalEventHandler(Device_OnPacketArrival);
					
					// Open device file and start capturing.
					device.Open();
					device.StartCapture();
				}
				catch (Exception ex)
				{
					Debug.WriteLine(ex.Message);
				}
				finally
				{
					// Clean-up.
					if (device != null && device.Started)
					{
						this._deviceFiles.Add(device);
					}
				}
			}
		}
		
		/// <summary>
		/// Stop all listening devices.
		/// </summary>
		public void Stop()
		{
			foreach (ICaptureDevice device in this._deviceFiles)
			{
				if (device.Started)
				{
					device.StopCapture();
				}
			}
		}
		
		/// <summary>
		/// Raises the do work event.
		/// </summary>
		/// <param name='e'>
		/// Work event arguments.
		/// </param>
		protected override void OnDoWork (DoWorkEventArgs e)
		{
			// TODO: Add the working portion (possibly pull from previous areas).
			base.OnDoWork(e);
		}
		
		/// <summary>
		/// Device the on packet arrival.
		/// </summary>
		/// <param name='sender'>
		/// Sender.
		/// </param>
		/// <param name='e'>
		/// Capture event arguments.
		/// </param>
		private static void Device_OnPacketArrival(object sender, CaptureEventArgs e)
		{
			Debug.WriteLine("Received {0} bytes.", e.Packet.Data.Length);
			
			try
			{
				// Dump to the file.
				_repository.Add(new WhiteNoise.Domain.Entities.Packet() 
				{ 
					Type = e.Packet.LinkLayerType.ToString(),
					Data = e.Packet.Data
				}); 
			}
			catch (Exception ex)
			{
				// Let the developer know!!!
				Debug.WriteLine(ex.Message);
			}
			finally
			{
				// Clean up.
			}
		}
	}
}

WhiteNoise.Storage/WhiteNoise.Storage.csproj

@@ -30,15 +30,22 @@
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="Iesi.Collections">
      <HintPath>..\Resources\Iesi.Collections.dll</HintPath>
    <Reference Include="PacketDotNet">
      <HintPath>..\Resources\PacketDotNet.dll</HintPath>
    </Reference>
    <Reference Include="NHibernate">
      <HintPath>..\Resources\NHibernate.dll</HintPath>
    <Reference Include="SharpPcap">
      <HintPath>..\Resources\SharpPcap.dll</HintPath>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AssemblyInfo.cs" />
    <Compile Include="DatabaseWorker.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <ItemGroup>
    <ProjectReference Include="..\WhiteNoise.Domain\WhiteNoise.Domain.csproj">
      <Project>{0686B6EA-7782-45FE-A990-A06EAD8A57C6}</Project>
      <Name>WhiteNoise.Domain</Name>
    </ProjectReference>
  </ItemGroup>
</Project>

WhiteNoise.Test/Listen/DeviceWorkerTests.cs

@@ -0,0 +1,184 @@
// 
// DeviceWorkerTests.cs
//  
// Author:
//       Bryan Allred <bryan.allred@gmail.com>
// 
// Copyright (c) 2011 Bryan Allred
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using NUnit.Framework;
using WhiteNoise.Listen;
namespace WhiteNoise.Test.Listen
{
	/// <summary>
	/// Device worker tests.
	/// </summary>
	[TestFixture]
	public class DeviceWorkerTests
	{
		/// <summary>
		/// The device worker with lazy loading.
		/// </summary>
		private DeviceWorker _lazyWorker;
		
		/// <summary>
		/// The device worker.
		/// </summary>
		private DeviceWorker _worker;
		
		/// <summary>
		/// Test fixture setup.
		/// </summary>
		[TestFixtureSetUp]
		public void TestFixtureSetup()
		{
			this._lazyWorker = new DeviceWorker(lazyLoad: true);
			
			try
			{
				this._worker = new DeviceWorker();
			}
			catch
			{
				this._worker = null;
			}
		}
		
		/// <summary>
		/// Checks for the dependecies to be installed.
		/// </summary>
		[Test]
		public void AreDependeciesInstalled()
		{
			Assert.That(this._worker, Is.Not.Null, "TcpDump or WinPcap is not installed (run as root on *nix systems)!");
		}
		
		/// <summary>
		/// Determines whether this instance has devices.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance has devices; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void HasDevices()
		{
			Assert.That(this._worker, Is.Not.Null);
			Assert.That(this._worker.Devices.Count, Is.GreaterThan(0));
		}
		
		/// <summary>
		/// Determines whether this instance has version.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance has version; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void HasVersion()
		{
			Assert.That(!string.IsNullOrWhiteSpace(this._lazyWorker.Version));
		}
		
		/// <summary>
		/// Determines whether this instance has defaults.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance has defaults; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void HasDefaults()
		{
			Assert.That(!string.IsNullOrWhiteSpace(this._lazyWorker.FileName));
			Assert.That(this._lazyWorker.Timeout, Is.EqualTo(1000));
			Assert.That(this._lazyWorker.Filter, Is.EqualTo("ip and tcp"));
		}
		
		/// <summary>
		/// Determines whether this instance can refresh.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance can refresh; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void CanRefresh()
		{
			bool refreshed = true;
			
			try
			{
				this._worker.Refresh();
			}
			catch
			{
				refreshed = false;
			}
			
			Assert.That(refreshed, Is.EqualTo(true));
		}
		
		/// <summary>
		/// Determines whether this instance can capture device.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance can capture device; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void CanCaptureDevice()
		{
			bool captured = true;
			
			try
			{
				this._worker.CaptureDevice(1);
			}
			catch
			{
				captured = false;
			}
			
			Assert.That(captured, Is.EqualTo(true));
		}
		
		/// <summary>
		/// Determines whether this instance can stop captures.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance can stop captures; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void CanStopCaptures()
		{
			bool stopped = true;
			
			try
			{
				this._worker.Stop();
			}
			catch
			{
				stopped = false;
			}
			
			Assert.That(stopped, Is.EqualTo(true));
		}
	}
}

WhiteNoise.Test/Storage/DatabaseWorkerTests.cs

@@ -0,0 +1,118 @@
// 
// DatabaseWorkerTests.cs
//  
// Author:
//       Bryan Allred <bryan.allred@gmail.com>
// 
// Copyright (c) 2011 Bryan Allred
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using NUnit.Framework;
using WhiteNoise.Storage;
using WhiteNoise.Test.TestHelpers;
namespace WhiteNoise.Test.Storage
{
	/// <summary>
	/// Database worker tests.
	/// </summary>
	[TestFixture]
	public class DatabaseWorkerTests
	{
		/// <summary>
		/// The database worker.
		/// </summary>
		private DatabaseWorker _worker;
		
		/// <summary>
		/// Test fixture setup.
		/// </summary>
		[TestFixtureSetUp]
		public void TestFixtureSetup()
		{
			this._worker = new DatabaseWorker(null);
		}
		
		/// <summary>
		/// Determines whether this instance has version.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance has version; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void HasVersion()
		{
			Assert.That(!string.IsNullOrWhiteSpace(this._worker.Version));
		}
		
		/// <summary>
		/// Determines whether this instance can capture device file.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance can capture device file; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void CanCaptureDeviceFile()
		{
			bool started = true;
			
			try
			{
				this._worker.CaptureDeviceFile(Global.CaptureFile);
			}
			catch
			{
				started = false;
			}
			
			// Clean up if necessary.
			if (started)
			{
				this._worker.Stop();
			}
			
			Assert.That(started, Is.EqualTo(true));
		}
		
		/// <summary>
		/// Determines whether this instance can stop captures.
		/// </summary>
		/// <returns>
		/// <c>true</c> if this instance can stop captures; otherwise, <c>false</c>.
		/// </returns>
		[Test]
		public void CanStopCaptures()
		{
			bool stopped = true;
			
			try
			{
				this._worker.Stop();
			}
			catch
			{
				stopped = false;
			}
			
			Assert.That(stopped, Is.EqualTo(true));
		}
	}
}

WhiteNoise.Test/TestHelpers/Global.cs

@@ -31,6 +31,11 @@ namespace WhiteNoise.Test.TestHelpers
	/// </summary>
	public static class Global
	{
		/// <summary>
		/// Constant capture file.
		/// </summary>
		public const string CaptureFile = @"results.pcap";
		
		/// <summary>
		/// Constant connection string.
		/// </summary>

WhiteNoise.Test/WhiteNoise.Test.csproj

@@ -68,6 +68,8 @@
    <Compile Include="Domain\Concrete\DbRepositoryTests.cs" />
    <Compile Include="Domain\Concrete\DbPacketRepositoryTests.cs" />
    <Compile Include="TestHelpers\Global.cs" />
    <Compile Include="Listen\DeviceWorkerTests.cs" />
    <Compile Include="Storage\DatabaseWorkerTests.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <ItemGroup>