Commit d21724d4 authored by Brickner_cp's avatar Brickner_cp

--no commit message

--no commit message
parent 336ea63c
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{8A184AF5-E46C-482C-81A3-76D8CE290104}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>BPacket</RootNamespace>
<AssemblyName>BPacket</AssemblyName>
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Xml.Linq">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data.DataSetExtensions">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Packet.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
\ No newline at end of file
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BPacket
{
public class Packet
{
public Packet(byte[] data, DateTime timestamp)
{
_data = data;
_timestamp = timestamp;
}
public int Length
{
get { return _data.Length; }
}
public DateTime Timestamp
{
get { return _timestamp; }
}
public byte[] Buffer
{
get { return _data; }
}
private readonly byte[] _data;
private readonly DateTime _timestamp;
}
}
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("BoazPacket")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BoazPacket")]
[assembly: AssemblyCopyright("Copyright © 2009")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("662a51ed-d89d-4f59-9a62-612706ee3eb2")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using PcapDotNet;
using BPacket;
namespace WinPcapDotNet.Console
{
class Program
{
/// <summary>
///
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
System.Console.WriteLine("Start");
List<PcapLiveDevice> devices = PcapLiveDevice.AllLocalMachine;
if (devices.Count == 0)
return;
for (int i = 0; i != devices.Count; ++i)
{
PcapLiveDevice device = devices[i];
System.Console.WriteLine(i+1 + ". " + device.Name);
}
int index;
do
{
ConsoleKeyInfo key = System.Console.ReadKey();
index = (key.KeyChar - '1');
} while (index < 0 || index >= devices.Count);
StartReadingFromDevice(devices[index]);
}
private static void StartReadingFromDevice(PcapLiveDevice device)
{
PcapDeviceHandler handler1 = device.Open();
PcapDeviceHandler handler2 = device.Open();
handler1.SetFilter("port 80");
handler2.SetFilter("port 53");
PcapDumpFile dumpFile1 = handler1.OpenDump(@"c:\tmp.pcap");
for (int i = 0; i != 100; ++i)
{
Packet packet;
handler1.GetNextPacket(out packet);
if (packet != null)
{
System.Console.WriteLine("Port 80 Packet Length = " + packet.Length + " Timestamp = " +
packet.Timestamp);
dumpFile1.Dump(packet);
}
handler2.GetNextPacket(out packet);
if (packet != null)
System.Console.WriteLine("Port 53 Packet Length = " + packet.Length + " Timestamp = " + packet.Timestamp);
}
}
}
}
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("WinPcapDotNet.Console")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("WinPcapDotNet.Console")]
[assembly: AssemblyCopyright("Copyright © 2009")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("97b50e85-bf8b-4d86-8e5c-3f84732e9a3d")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProductVersion>9.0.21022</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>WinPcapDotNet.Console</RootNamespace>
<AssemblyName>WinPcapDotNet.Console</AssemblyName>
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<PublishUrl>publish\</PublishUrl>
<Install>true</Install>
<InstallFrom>Disk</InstallFrom>
<UpdateEnabled>false</UpdateEnabled>
<UpdateMode>Foreground</UpdateMode>
<UpdateInterval>7</UpdateInterval>
<UpdateIntervalUnits>Days</UpdateIntervalUnits>
<UpdatePeriodically>false</UpdatePeriodically>
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.0.0.%2a</ApplicationVersion>
<IsWebBootstrapper>false</IsWebBootstrapper>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>..\..\bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>..\..\bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<Reference Include="System.Core">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Xml.Linq">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data.DataSetExtensions">
<RequiredTargetFramework>3.5</RequiredTargetFramework>
</Reference>
<Reference Include="System.Data" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\BPacket\BPacket.csproj">
<Project>{8A184AF5-E46C-482C-81A3-76D8CE290104}</Project>
<Name>BPacket</Name>
</ProjectReference>
<ProjectReference Include="..\PcapDotNet.Core\WinPCapDotNet.Core.vcproj">
<Project>{89C63BE1-AF9A-472E-B256-A4F56B1655A7}</Project>
<Name>PcapDotNet.Core</Name>
</ProjectReference>
</ItemGroup>
<ItemGroup>
<BootstrapperPackage Include="Microsoft.Net.Framework.2.0">
<Visible>False</Visible>
<ProductName>.NET Framework 2.0 %28x86%29</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.0">
<Visible>False</Visible>
<ProductName>.NET Framework 3.0 %28x86%29</ProductName>
<Install>false</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Net.Framework.3.5">
<Visible>False</Visible>
<ProductName>.NET Framework 3.5</ProductName>
<Install>true</Install>
</BootstrapperPackage>
<BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
<Visible>False</Visible>
<ProductName>Windows Installer 3.1</ProductName>
<Install>true</Install>
</BootstrapperPackage>
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
\ No newline at end of file
using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
using namespace System::Runtime::InteropServices;
using namespace System::Security::Permissions;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("WinPCapDotNet")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("")];
[assembly:AssemblyProductAttribute("WinPCapDotNet")];
[assembly:AssemblyCopyrightAttribute("Copyright (c) 2009")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("1.0.*")];
[assembly:ComVisible(false)];
[assembly:CLSCompliantAttribute(true)];
[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];
#include "BpfFilter.h"
#include <stdio.h>
#include <pcap.h>
#include "MarshalingServices.h"
using namespace System;
using namespace PcapDotNet;
BpfFilter::BpfFilter(pcap_t* handler, String^ filterString, IpV4SocketAddress^ netmask)
{
std::string unmanagedFilterString = MarshalingServices::ManagedToUnmanagedString(filterString);
unsigned int netmaskValue = 0;
if (netmask != nullptr)
netmaskValue = netmask->Address;
_bpf = new bpf_program();
try
{
if (pcap_compile(handler, _bpf, const_cast<char*>(unmanagedFilterString.c_str()), 1, netmaskValue) < 0)
{
gcnew ArgumentException("An error has occured when compiling the filter: " + gcnew String(pcap_geterr(handler)));
}
}
catch(...)
{
delete _bpf;
throw;
}
}
BpfFilter::~BpfFilter()
{
delete _bpf;
}
bpf_program& BpfFilter::Bpf::get()
{
return *_bpf;
}
#pragma once
#include "PcapTypedefs.h"
#include "PcapAddress.h"
struct bpf_program;
namespace PcapDotNet
{
public ref class BpfFilter : System::IDisposable
{
public:
BpfFilter(pcap_t* handler, System::String^ filterString, IpV4SocketAddress^ netmask);
~BpfFilter(); // IDisposable
property bpf_program& Bpf
{
bpf_program& get();
}
private:
bpf_program* _bpf;
};
}
\ No newline at end of file
#pragma once
#include "PcapAddress.h"
#include "PcapDeviceHandler.h"
namespace PcapDotNet
{
[System::Flags]
public enum class DeviceFlags : System::UInt32
{
None = 0x00000000,
LoopBack = 0x00000001
};
[System::Flags]
public enum class PcapDeviceOpenFlags : System::Int32
{
None = 0,
PROMISCUOUS = 1, // Defines if the adapter has to go in promiscuous mode.
DATATX_UDP = 2, // Defines if the data trasfer (in case of a remote capture) has to be done with UDP protocol.
NOCAPTURE_RPCAP = 4, // Defines if the remote probe will capture its own generated traffic.
NOCAPTURE_LOCAL = 8, // Defines if the local adapter will capture its own generated traffic.
MAX_RESPONSIVENESS = 16 // This flag configures the adapter for maximum responsiveness.
};
public interface class IPcapDevice
{
property System::String^ Name { System::String^ get(); };
property System::String^ Description { System::String^ get(); };
property DeviceFlags^ Flags { DeviceFlags^ get(); };
property System::Collections::Generic::List<PcapAddress^>^ Addresses { System::Collections::Generic::List<PcapAddress^>^ get(); };
/// <summary>
/// Open a generic source in order to capture / send (WinPcap only) traffic.
/// </summary>
/// <param name="snapLen">length of the packet that has to be retained. For each packet received by the filter, only the first 'snaplen' bytes are stored in the buffer and passed to the user application. For instance, snaplen equal to 100 means that only the first 100 bytes of each packet are stored.</param>
/// <param name="flags">keeps several flags that can be needed for capturing packets.</param>
/// <param name="flags">read timeout in milliseconds. The read timeout is used to arrange that the read not necessarily return immediately when a packet is seen, but that it waits for some amount of time to allow more packets to arrive and to read multiple packets from the OS kernel in one operation. Not all platforms support a read timeout; on platforms that don't, the read timeout is ignored.</param>
PcapDeviceHandler^ Open(int snapLen, PcapDeviceOpenFlags flags, int readTimeout);
/// <summary>
/// Open a generic source in order to capture / send (WinPcap only) traffic.
/// Uses maxmimum snaplen (65536), promiscuous mode and 1 second read timeout.
/// </summary>
PcapDeviceHandler^ Open();
};
}
\ No newline at end of file
#include "MarshalingServices.h"
using namespace System;
using namespace System::Text;
using namespace System::Runtime::InteropServices;
using namespace PcapDotNet;
// static
std::string MarshalingServices::ManagedToUnmanagedString(System::String^ managedString)
{
// Marshal the managed string to unmanaged memory.
array<Byte>^ managedBytes = Encoding::ASCII->GetBytes(managedString);
pin_ptr<Byte> pinManagedBytes = &managedBytes[0];
Byte* unmanagedBytes = pinManagedBytes;
std::string unmanagedString = std::string((char*)unmanagedBytes);
return unmanagedString;
}
// static
array<Byte>^ MarshalingServices::UnamangedToManagedByteArray(const unsigned char* unmanagedByteArray, int offset, int count)
{
array<Byte>^ managedBytes = gcnew array<Byte>(count);
Marshal::Copy((IntPtr)const_cast<unsigned char*>(unmanagedByteArray), managedBytes, offset, count);
return managedBytes;
}
#pragma once
#include <string>
namespace PcapDotNet
{
public ref class MarshalingServices
{
public:
static std::string ManagedToUnmanagedString(System::String^ managedString);
static array<System::Byte>^ UnamangedToManagedByteArray(const unsigned char* unmanagedByteArray, int offset, int count);
};
}
#include "PcapAddress.h"
#include <stdio.h>
#include <pcap.h>
using namespace System;
using namespace System::Text;
using namespace PcapDotNet;
SocketAddress::SocketAddress(unsigned short family)
{
_family = safe_cast<SocketAddressFamily>(family);
}
SocketAddressFamily^ SocketAddress::Family::get()
{
return _family;
}
String^ SocketAddress::ToString()
{
return Family->ToString();
}
IpV4SocketAddress::IpV4SocketAddress(sockaddr *address)
: SocketAddress(address->sa_family)
{
sockaddr_in* ipV4Address = (struct sockaddr_in *)address;
_address = ipV4Address->sin_addr.S_un.S_addr;
}
unsigned int IpV4SocketAddress::Address::get()
{
return _address;
}
String^ IpV4SocketAddress::AddressString::get()
{
StringBuilder^ result = gcnew StringBuilder();
unsigned int address = Address;
result->Append(address % 256);
result->Append(".");
address /= 256;
result->Append(address % 256);
result->Append(".");
address /= 256;
result->Append(address % 256);
result->Append(".");
address /= 256;
result->Append(address % 256);
return result->ToString();
}
String^ IpV4SocketAddress::ToString()
{
StringBuilder^ result = gcnew StringBuilder();
result->Append(SocketAddress::ToString());
result->Append(" ");
result->Append(AddressString);
return result->ToString();
}
PcapAddress::PcapAddress(pcap_addr_t* pcapAddress)
{
SocketAddressFamily family = safe_cast<SocketAddressFamily>(pcapAddress->addr->sa_family);
switch (family)
{
case SocketAddressFamily::INET:
if (pcapAddress->addr)
_address = gcnew IpV4SocketAddress(pcapAddress->addr);
if (pcapAddress->netmask)
_netmask = gcnew IpV4SocketAddress(pcapAddress->netmask);
if (pcapAddress->broadaddr)
_broadcast = gcnew IpV4SocketAddress(pcapAddress->broadaddr);
if (pcapAddress->dstaddr)
_destination = gcnew IpV4SocketAddress(pcapAddress->dstaddr);
break;
default:
throw gcnew NotImplementedException(gcnew String("Device of family ") + family.ToString() + gcnew String(" is unsupported"));
// case SocketAddressFamily::INET6:
//break;
/* case AF_INET:
printf("\tAddress Family Name: AF_INET\n");
if (a->addr)
printf("\tAddress: %s\n",iptos(((struct sockaddr_in *)a->addr)->sin_addr.s_addr));
if (a->netmask)
printf("\tNetmask: %s\n",iptos(((struct sockaddr_in *)a->netmask)->sin_addr.s_addr));
if (a->broadaddr)
printf("\tBroadcast Address: %s\n",iptos(((struct sockaddr_in *)a->broadaddr)->sin_addr.s_addr));
if (a->dstaddr)
printf("\tDestination Address: %s\n",iptos(((struct sockaddr_in *)a->dstaddr)->sin_addr.s_addr));
break;
case AF_INET6:
printf("\tAddress Family Name: AF_INET6\n");
if (a->addr)
printf("\tAddress: %s\n", ip6tos(a->addr, ip6str, sizeof(ip6str)));
break;
default:
printf("\tAddress Family Name: Unknown\n");
break;*/
}
}
SocketAddress^ PcapAddress::Address::get()
{
return _address;
}
SocketAddress^ PcapAddress::Netmask::get()
{
return _netmask;
}
SocketAddress^ PcapAddress::Broadcast::get()
{
return _broadcast;
}
SocketAddress^ PcapAddress::Destination::get()
{
return _destination;
}
String^ PcapAddress::ToString()
{
StringBuilder^ result = gcnew StringBuilder();
if (Address != nullptr)
{
result->Append("Address: ");
result->Append(Address->ToString());
}
if (Netmask != nullptr)
{
if (result->Length != 0)
result->Append(" ");
result->Append("Netmask: ");
result->Append(Netmask->ToString());
}
if (Broadcast != nullptr)
{
if (result->Length != 0)
result->Append(" ");
result->Append("Broadcast: ");
result->Append(Broadcast->ToString());
}
if (Destination != nullptr)
{
if (result->Length != 0)
result->Append(" ");
result->Append("Destination: ");
result->Append(Destination->ToString());
}
return result->ToString();
}
\ No newline at end of file
#pragma once
struct sockaddr;
typedef struct pcap_addr pcap_addr_t;
namespace PcapDotNet
{
public enum class SocketAddressFamily : System::UInt16
{
UNSPEC = 0, // unspecified
UNIX = 1, // local to host (pipes, portals)
INET = 2, // internetwork: UDP, TCP, etc.
IMPLINK = 3, // arpanet imp addresses
PUP = 4, // pup protocols: e.g. BSP
CHAOS = 5, // mit CHAOS protocols
NS = 6, // XEROX NS protocols
IPX = NS, // IPX protocols: IPX, SPX, etc.
ISO = 7, // ISO protocols
OSI = ISO, // OSI is ISO
ECMA = 8, // european computer manufacturers
DATAKIT = 9, // datakit protocols
CCITT = 10, // CCITT protocols, X.25 etc
SNA = 11, // IBM SNA
DECnet = 12, // DECnet
DLI = 13, // Direct data link interface
LAT = 14, // LAT
HYLINK = 15, // NSC Hyperchannel
APPLETALK = 16, // AppleTalk
NETBIOS = 17, // NetBios-style addresses
VOICEVIEW = 18, // VoiceView
FIREFOX = 19, // Protocols from Firefox
UNKNOWN1 = 20, // Somebody is using this!
BAN = 21, // Banyan
ATM = 22, // Native ATM Services
INET6 = 23, // Internetwork Version 6
CLUSTER = 24, // Microsoft Wolfpack
IEEE12844 = 25, // IEEE 1284.4 WG AF
IRDA = 26, // IrDA
NETDES = 28, // Network Designers OSI & gateway
TCNPROCESS = 29,
TCNMESSAGE = 30,
ICLFXBM = 31,
BTH = 32 // Bluetooth RFCOMM/L2CAP protocols
};
public ref class SocketAddress
{
public:
SocketAddress(unsigned short family);
property SocketAddressFamily^ Family
{
SocketAddressFamily^ get();
}
virtual System::String^ ToString() override;
private:
SocketAddressFamily^ _family;
};
public ref class IpV4SocketAddress : SocketAddress
{
public:
IpV4SocketAddress(sockaddr *address);
property unsigned int Address
{
unsigned int get();
}
property System::String^ AddressString
{
System::String^ get();
}
virtual System::String^ ToString() override;
private:
unsigned int _address;
};
public ref class PcapAddress
{
public:
PcapAddress(pcap_addr_t *pcapAddress);
property SocketAddress^ Address
{
SocketAddress^ get();
}
property SocketAddress^ Netmask
{
SocketAddress^ get();
}
property SocketAddress^ Broadcast
{
SocketAddress^ get();
}
property SocketAddress^ Destination
{
SocketAddress^ get();
}
virtual System::String^ ToString() override;
private:
SocketAddress^ _address;
SocketAddress^ _netmask;
SocketAddress^ _broadcast;
SocketAddress^ _destination;
};
}
\ No newline at end of file
#include "PcapDevice.h"
using namespace PcapDotNet;
PcapDeviceHandler^ PcapDevice::Open()
{
return Open(65536, PcapDeviceOpenFlags::PROMISCUOUS, 1000);
}
#pragma once
#include "IPcapDevice.h"
namespace PcapDotNet
{
public ref class PcapDevice abstract : IPcapDevice
{
public:
virtual property System::String^ Name
{
System::String^ get() = 0;
}
virtual property System::String^ Description
{
System::String^ get() = 0;
}
virtual property DeviceFlags^ Flags
{
DeviceFlags^ get() = 0;
}
virtual property System::Collections::Generic::List<PcapAddress^>^ Addresses
{
System::Collections::Generic::List<PcapAddress^>^ get() = 0;
}
virtual PcapDeviceHandler^ Open(int snapLen, PcapDeviceOpenFlags flags, int readTimeout) = 0;
virtual PcapDeviceHandler^ Open();
};
}
\ No newline at end of file
#include "PcapDeviceHandler.h"
#include <stdio.h>
#include <pcap.h>
#include "MarshalingServices.h"
#include "PcapDumpFile.h"
#include "Timestamp.h"
using namespace System;
using namespace BPacket;
using namespace PcapDotNet;
PcapDeviceHandler::PcapDeviceHandler(pcap_t* handler, SocketAddress^ netmask)
{
_handler = handler;
_ipV4Netmask = dynamic_cast<IpV4SocketAddress^>(netmask);
}
DeviceHandlerResult PcapDeviceHandler::GetNextPacket([System::Runtime::InteropServices::Out] Packet^% packet)
{
packet = nullptr;
pcap_pkthdr* packetHeader;
const unsigned char* packetData;
DeviceHandlerResult result = safe_cast<DeviceHandlerResult>(pcap_next_ex(_handler, &packetHeader, &packetData));
if (result != DeviceHandlerResult::Ok)
return result;
timeval pcapTimestamp = packetHeader->ts;
DateTime timestamp;
Timestamp::PcapTimestampToDateTime(packetHeader->ts, timestamp);
array<Byte>^ managedPacketData = MarshalingServices::UnamangedToManagedByteArray(packetData, 0, packetHeader->caplen);
packet = gcnew Packet(managedPacketData, timestamp);
return result;
}
BpfFilter^ PcapDeviceHandler::CreateFilter(String^ filterString)
{
return gcnew BpfFilter(_handler, filterString, _ipV4Netmask);
}
void PcapDeviceHandler::SetFilter(BpfFilter^ filter)
{
if (pcap_setfilter(_handler, &filter->Bpf) < 0)
{
throw gcnew InvalidOperationException("Error setting the filter: " + gcnew String(pcap_geterr(_handler)));
}
}
void PcapDeviceHandler::SetFilter(String^ filterString)
{
BpfFilter^ filter = CreateFilter(filterString);
try
{
SetFilter(filter);
}
finally
{
filter->~BpfFilter();
}
}
PcapDumpFile^ PcapDeviceHandler::OpenDump(System::String^ filename)
{
std::string unmanagedString = MarshalingServices::ManagedToUnmanagedString(filename);
pcap_dumper_t* dumpFile = pcap_dump_open(_handler, unmanagedString.c_str());
if (dumpFile == NULL)
throw gcnew InvalidOperationException("Error opening output file " + filename + " Error: " + gcnew System::String(pcap_geterr(_handler)));
return gcnew PcapDumpFile(dumpFile, filename);
}
#pragma once
#include "PcapAddress.h"
#include "BpfFilter.h"
#include "PcapDumpFile.h"
namespace PcapDotNet
{
public enum class DeviceHandlerResult
{
Ok = 1, // if the packet has been read without problems
Timeout = 0, // if the timeout set with Open() has elapsed.
Error = -1, // if an error occurred
Eof = -2 // if EOF was reached reading from an offline capture
};
public ref class PcapDeviceHandler
{
public:
PcapDeviceHandler(pcap_t* handler, SocketAddress^ netmask);
DeviceHandlerResult GetNextPacket([System::Runtime::InteropServices::Out] BPacket::Packet^% packet);
BpfFilter^ CreateFilter(System::String^ filterString);
void SetFilter(BpfFilter^ filter);
void SetFilter(System::String^ filterString);
PcapDumpFile^ OpenDump(System::String^ filename);
private:
pcap_t* _handler;
IpV4SocketAddress^ _ipV4Netmask;
};
}
\ No newline at end of file
#include "PcapDumpFile.h"
#include <stdio.h>
#include <pcap.h>
#include "Timestamp.h"
#include "MarshalingServices.h"
using namespace System;
using namespace PcapDotNet;
using namespace BPacket;
PcapDumpFile::PcapDumpFile(pcap_dumper_t* handler, System::String^ filename)
{
_handler = handler;
_filename = filename;
}
void PcapDumpFile::Dump(Packet^ packet)
{
pcap_pkthdr header;
Timestamp::DateTimeToPcapTimestamp(packet->Timestamp, header.ts);
header.len = packet->Length;
header.caplen = packet->Length;
std::string unmanagedFilename = MarshalingServices::ManagedToUnmanagedString(_filename);
pin_ptr<Byte> unamangedPacketBytes = &packet->Buffer[0];
pcap_dump(reinterpret_cast<unsigned char*>(_handler), &header, unamangedPacketBytes);
}
\ No newline at end of file
#pragma once
#include "PcapTypedefs.h"
namespace PcapDotNet
{
public ref class PcapDumpFile
{
public:
PcapDumpFile(pcap_dumper_t* handler, System::String^ filename);
void Dump(BPacket::Packet^ packet);
private:
pcap_dumper_t* _handler;
System::String^ _filename;
};
}
\ No newline at end of file
#include "PcapLiveDevice.h"
#include <stdio.h>
#include <pcap.h>
#include <remote-ext.h>
#include <string>
#include "MarshalingServices.h"
using namespace System;
using namespace System::Collections::Generic;
using namespace BPacket;
using namespace PcapDotNet;
List<PcapLiveDevice^>^ PcapLiveDevice::AllLocalMachine::get()
{
pcap_if_t *alldevs;
char errbuf[PCAP_ERRBUF_SIZE];
// Retrieve the device list from the local machine
if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, NULL // auth is not needed
, &alldevs, errbuf) == -1)
{
String^ errorString = gcnew String(errbuf);
throw gcnew InvalidOperationException(String::Format("Error in pcap_findalldevs_ex: %s\n", errorString));
}
List<PcapLiveDevice^>^ result = gcnew List<PcapLiveDevice^>();
for (pcap_if_t *d = alldevs; d != NULL; d = d->next)
{
// IP addresses
List<PcapAddress^>^ addresses = gcnew List<PcapAddress^>();
for (pcap_addr_t *a = d->addresses; a; a = a->next)
{
PcapAddress^ deviceAddress = gcnew PcapAddress(a);
addresses->Add(deviceAddress);
}
result->Add(gcnew PcapLiveDevice(gcnew String(d->name),
gcnew String(d->description),
safe_cast<DeviceFlags>(d->flags),
addresses));
}
// We don't need any more the device list. Free it
pcap_freealldevs(alldevs);
return result;
}
String^ PcapLiveDevice::Name::get()
{
return _name;
}
String^ PcapLiveDevice::Description::get()
{
return _description;
}
DeviceFlags^ PcapLiveDevice::Flags::get()
{
return _flags;
}
List<PcapAddress^>^ PcapLiveDevice::Addresses::get()
{
return _addresses;
}
PcapDeviceHandler^ PcapLiveDevice::Open(int snapLen, PcapDeviceOpenFlags flags, int readTimeout)
{
pcap_t *adhandle;
char errbuf[PCAP_ERRBUF_SIZE];
std::string deviceName = MarshalingServices::ManagedToUnmanagedString(Name);
// Open the device
adhandle = pcap_open(deviceName.c_str(), // name of the device
snapLen, // portion of the packet to capture
// 65536 guarantees that the whole packet will be captured on all the link layers
safe_cast<int>(flags),
readTimeout, // read timeout
NULL, // authentication on the remote machine
errbuf); // error buffer
if (adhandle == NULL)
{
gcnew InvalidOperationException(String::Format("Unable to open the adapter. %s is not supported by WinPcap", Name));
}
SocketAddress^ netmask;
if (Addresses->Count != 0)
netmask = Addresses[0]->Netmask;
return gcnew PcapDeviceHandler(adhandle, netmask);
}
// Private Methods
PcapLiveDevice::PcapLiveDevice(String^ name, String^ description, DeviceFlags^ flags, List<PcapAddress^>^ addresses)
{
_name = name;
_description = description;
_flags = flags;
_addresses = addresses;
}
#pragma once
#include "PcapDevice.h"
namespace PcapDotNet
{
public ref class PcapLiveDevice : PcapDevice
{
public:
static property System::Collections::Generic::List<PcapLiveDevice^>^ AllLocalMachine
{
System::Collections::Generic::List<PcapLiveDevice^>^ get();
}
virtual property System::String^ Name
{
System::String^ get() override;
}
virtual property System::String^ Description
{
System::String^ get() override;
}
virtual property DeviceFlags^ Flags
{
DeviceFlags^ get() override;
}
virtual property System::Collections::Generic::List<PcapAddress^>^ Addresses
{
System::Collections::Generic::List<PcapAddress^>^ get() override;
}
/// <summary>
/// Open a generic source in order to capture / send (WinPcap only) traffic.
/// </summary>
/// <param name="snapLen">length of the packet that has to be retained. For each packet received by the filter, only the first 'snaplen' bytes are stored in the buffer and passed to the user application. For instance, snaplen equal to 100 means that only the first 100 bytes of each packet are stored.</param>
/// <param name="flags">keeps several flags that can be needed for capturing packets.</param>
/// <param name="flags">read timeout in milliseconds. The read timeout is used to arrange that the read not necessarily return immediately when a packet is seen, but that it waits for some amount of time to allow more packets to arrive and to read multiple packets from the OS kernel in one operation. Not all platforms support a read timeout; on platforms that don't, the read timeout is ignored.</param>
virtual PcapDeviceHandler^ Open(int snapLen, PcapDeviceOpenFlags flags, int readTimeout) override;
private:
PcapLiveDevice(System::String^ name, System::String^ description, DeviceFlags^ flags, System::Collections::Generic::List<PcapAddress^>^ addresses);
private:
System::String^ _name;
System::String^ _description;
DeviceFlags^ _flags;
System::Collections::Generic::List<PcapAddress^>^ _addresses;
};
}
\ No newline at end of file
#include "PcapOfflineDevice.h"
#include <stdio.h>
#include <pcap.h>
#include <remote-ext.h>
#include <string>
#include "MarshalingServices.h"
using namespace System;
using namespace System::Collections::Generic;
using namespace PcapDotNet;
PcapOfflineDevice::PcapOfflineDevice(System::String^ filename)
{
_filename = filename;
}
String^ PcapOfflineDevice::Name::get()
{
return _filename;
}
String^ PcapOfflineDevice::Description::get()
{
return String::Empty;
}
DeviceFlags^ PcapOfflineDevice::Flags::get()
{
return DeviceFlags::None;
}
List<PcapAddress^>^ PcapOfflineDevice::Addresses::get()
{
return gcnew List<PcapAddress^>();
}
PcapDeviceHandler^ PcapOfflineDevice::Open(int snapLen, PcapDeviceOpenFlags flags, int readTimeout)
{
std::string unamangedFilename = MarshalingServices::ManagedToUnmanagedString(_filename);
// Create the source string according to the new WinPcap syntax
char source[PCAP_BUF_SIZE];
char errbuf[PCAP_ERRBUF_SIZE];
if ( pcap_createsrcstr( source, // variable that will keep the source string
PCAP_SRC_FILE, // we want to open a file
NULL, // remote host
NULL, // port on the remote host
unamangedFilename.c_str(), // name of the file we want to open
errbuf // error buffer
) != 0)
{
throw gcnew InvalidOperationException("Error creating a source string from filename " + _filename + " Error: " + gcnew String(errbuf));
}
pcap_t *adhandle;
/* Open the capture file */
adhandle = pcap_open(source, // name of the device
snapLen, // portion of the packet to capture
// 65536 guarantees that the whole packet will be captured on all the link layers
safe_cast<int>(flags), // promiscuous mode
readTimeout, // read timeout
NULL, // authentication on the remote machine
errbuf); // error buffer
if (adhandle == NULL)
{
gcnew InvalidOperationException(String::Format("Unable to open the adapter. %s is not supported by WinPcap", Name));
}
return gcnew PcapDeviceHandler(adhandle, nullptr);
}
#pragma once
#include "PcapDevice.h"
namespace PcapDotNet
{
public ref class PcapOfflineDevice : PcapDevice
{
public:
PcapOfflineDevice(System::String^ filename);
virtual property System::String^ Name
{
System::String^ get() override;
}
virtual property System::String^ Description
{
System::String^ get() override;
}
virtual property DeviceFlags^ Flags
{
DeviceFlags^ get() override;
}
virtual property System::Collections::Generic::List<PcapAddress^>^ Addresses
{
System::Collections::Generic::List<PcapAddress^>^ get() override;
}
virtual PcapDeviceHandler^ Open(int snapLen, PcapDeviceOpenFlags flags, int readTimeout) override;
private:
System::String^ _filename;
};
}
\ No newline at end of file
#include "PcapTypedefs.h"
struct pcap{};
struct pcap_dumper{};
private ref class PcapTypeDefs
{
private:
pcap_t *pcap;
pcap_dumper_t *pcap_dumper;
};
\ No newline at end of file
#pragma once
typedef struct pcap_dumper pcap_dumper_t;
typedef struct pcap pcap_t;
#include "Timestamp.h"
#include <stdio.h>
#include <pcap.h>
using namespace System;
using namespace PcapDotNet;
// static
void Timestamp::PcapTimestampToDateTime(const timeval& pcapTimestamp, [System::Runtime::InteropServices::Out] System::DateTime% dateTime)
{
dateTime = DateTime(1970,1,1).Add(TimeSpan::FromSeconds(pcapTimestamp.tv_sec) +
TimeSpan::FromMilliseconds(((double)pcapTimestamp.tv_usec) / 1000));
}
// static
void Timestamp::DateTimeToPcapTimestamp(System::DateTime dateTime, timeval& pcapTimestamp)
{
TimeSpan timespan = dateTime - DateTime(1970,1,1);
pcapTimestamp.tv_sec = (long)timespan.TotalSeconds;
pcapTimestamp.tv_usec = (long)(timespan.Milliseconds * 1000);
}
\ No newline at end of file
#pragma once
struct timeval;
namespace PcapDotNet
{
public ref class Timestamp
{
public:
static void PcapTimestampToDateTime(const timeval& pcapTimestamp, [System::Runtime::InteropServices::Out] System::DateTime% dateTime);
static void DateTimeToPcapTimestamp(System::DateTime dateTime, timeval& pcapTimestamp);
};
}
\ No newline at end of file
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Name="PcapDotNet.Core"
ProjectGUID="{89C63BE1-AF9A-472E-B256-A4F56B1655A7}"
RootNamespace="WinPCapDotNet"
Keyword="ManagedCProj"
TargetFrameworkVersion="196613"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)\..\bin\$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
CharacterSet="1"
ManagedExtensions="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="0"
AdditionalIncludeDirectories="&quot;..\..\3rdParty\WpdPack\Include&quot;"
PreprocessorDefinitions="WIN32;_DEBUG"
RuntimeLibrary="3"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="wpcap.lib $(NOINHERIT)"
LinkIncremental="2"
AdditionalLibraryDirectories="..\..\3rdParty\WpdPack\Lib"
AddModuleNamesToAssembly=""
GenerateDebugInformation="true"
AssemblyDebug="1"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory="$(SolutionDir)\..\bin\$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="2"
CharacterSet="1"
ManagedExtensions="1"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
AdditionalIncludeDirectories="&quot;..\..\3rdParty\WpdPack\Include&quot;"
PreprocessorDefinitions="WIN32;NDEBUG"
RuntimeLibrary="2"
UsePrecompiledHeader="0"
WarningLevel="3"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="wpcap.lib $(NOINHERIT)"
LinkIncremental="1"
AdditionalLibraryDirectories="..\..\3rdParty\WpdPack\Lib"
AddModuleNamesToAssembly=""
GenerateDebugInformation="true"
TargetMachine="1"
/>
<Tool
Name="VCALinkTool"
/>
<Tool
Name="VCManifestTool"
/>
<Tool
Name="VCXDCMakeTool"
/>
<Tool
Name="VCBscMakeTool"
/>
<Tool
Name="VCFxCopTool"
/>
<Tool
Name="VCAppVerifierTool"
/>
<Tool
Name="VCPostBuildEventTool"
/>
</Configuration>
</Configurations>
<References>
<AssemblyReference
RelativePath="System.dll"
AssemblyName="System, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.Data.dll"
AssemblyName="System.Data, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=x86"
MinFrameworkVersion="131072"
/>
<AssemblyReference
RelativePath="System.XML.dll"
AssemblyName="System.Xml, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL"
MinFrameworkVersion="131072"
/>
<ProjectReference
ReferencedProjectIdentifier="{8A184AF5-E46C-482C-81A3-76D8CE290104}"
RelativePathToProject=".\BoazPacket\BPacket.csproj"
/>
</References>
<Files>
<Filter
Name="Source Files"
Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
>
<File
RelativePath=".\AssemblyInfo.cpp"
>
</File>
<File
RelativePath=".\BpfFilter.cpp"
>
</File>
<File
RelativePath=".\BpfFilter.h"
>
</File>
<File
RelativePath=".\IPcapDevice.h"
>
</File>
<File
RelativePath=".\MarshalingServices.cpp"
>
</File>
<File
RelativePath=".\MarshalingServices.h"
>
</File>
<File
RelativePath=".\PcapAddress.cpp"
>
</File>
<File
RelativePath=".\PcapAddress.h"
>
</File>
<File
RelativePath=".\PcapDevice.cpp"
>
</File>
<File
RelativePath=".\PcapDevice.h"
>
</File>
<File
RelativePath=".\PcapDeviceHandler.cpp"
>
</File>
<File
RelativePath=".\PcapDeviceHandler.h"
>
</File>
<File
RelativePath=".\PcapDumpFile.cpp"
>
</File>
<File
RelativePath=".\PcapDumpFile.h"
>
</File>
<File
RelativePath=".\PcapLiveDevice.cpp"
>
</File>
<File
RelativePath=".\PcapLiveDevice.h"
>
</File>
<File
RelativePath=".\PcapOfflineDevice.cpp"
>
</File>
<File
RelativePath=".\PcapOfflineDevice.h"
>
</File>
<File
RelativePath=".\PcapTypedefs.cpp"
>
</File>
<File
RelativePath=".\PcapTypedefs.h"
>
</File>
<File
RelativePath=".\Timestamp.cpp"
>
</File>
<File
RelativePath=".\Timestamp.h"
>
</File>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BPacket", "BPacket\BPacket.csproj", "{8A184AF5-E46C-482C-81A3-76D8CE290104}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WinPcapDotNet.Console", "PcapDotNet.Console\WinPcapDotNet.Console.csproj", "{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PcapDotNet.Core", "PcapDotNet.Core\WinPCapDotNet.Core.vcproj", "{89C63BE1-AF9A-472E-B256-A4F56B1655A7}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Debug|Mixed Platforms = Debug|Mixed Platforms
Debug|Win32 = Debug|Win32
Release|Any CPU = Release|Any CPU
Release|Mixed Platforms = Release|Mixed Platforms
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Debug|Any CPU.Build.0 = Debug|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Debug|Win32.ActiveCfg = Debug|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Release|Any CPU.Build.0 = Release|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{8A184AF5-E46C-482C-81A3-76D8CE290104}.Release|Win32.ActiveCfg = Release|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Debug|Any CPU.Build.0 = Debug|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Debug|Win32.ActiveCfg = Debug|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Release|Any CPU.ActiveCfg = Release|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Release|Any CPU.Build.0 = Release|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Release|Mixed Platforms.Build.0 = Release|Any CPU
{5B4E80EB-DED5-4F20-871A-D9567F3F79DD}.Release|Win32.ActiveCfg = Release|Any CPU
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Debug|Any CPU.ActiveCfg = Debug|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Debug|Mixed Platforms.Build.0 = Debug|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Debug|Win32.ActiveCfg = Debug|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Debug|Win32.Build.0 = Debug|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Release|Any CPU.ActiveCfg = Release|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Release|Mixed Platforms.ActiveCfg = Release|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Release|Mixed Platforms.Build.0 = Release|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Release|Win32.ActiveCfg = Release|Win32
{89C63BE1-AF9A-472E-B256-A4F56B1655A7}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment