Subversion Repositories general

Compare Revisions

Ignore whitespace Rev 1420 → Rev 1421

/WlanListener/trunk/Logger.cpp
0,0 → 1,22
#include <windows.h>
 
#include "Main.h"
#include "Logger.h"
 
HANDLE hEventLog;
 
// ====================================================================================================================
bool InitLogger()
{
hEventLog = RegisterEventSource(NULL, SERVICE_NAME);
 
return (hEventLog != NULL);
}
 
// ====================================================================================================================
void Log(LPCSTR pMessage)
{
LPCSTR pStrings[1] = { pMessage };
 
ReportEvent(hEventLog, EVENTLOG_INFORMATION_TYPE, 0, 1, NULL, 1, 0, (LPCSTR*)pStrings, NULL);
}
/WlanListener/trunk/Wlan.cpp
0,0 → 1,223
#include <windows.h>
#include <stdio.h>
#include <wlanapi.h>
#include <winnls.h>
#include <map>
#include <string>
 
#include "Wlan.h"
#include "WlanInterface.h"
#include "Main.h"
#include "Logger.h"
#include "Config.h"
 
WlanClient wlanClient;
 
// ====================================================================================================================
bool cmpGuid::operator()(const GUID& first, const GUID& second) const
{
if(first.Data1 < second.Data1
|| first.Data2 < second.Data2
|| first.Data3 < second.Data3)
{
return true;
}
 
for(int i = 0; i < sizeof(first.Data4) / sizeof(first.Data4[0]); ++i) {
if(first.Data4[i] < second.Data4[i]) return true;
}
 
return false;
}
 
// ====================================================================================================================
WlanClient::WlanClient()
{
dNegotiatedVersion = 0;
}
 
// ====================================================================================================================
bool WlanClient::Start()
{
if(!StartClient()) {
return false;
}
 
if(!UpdateInterfaces()) {
return false;
}
 
if(!RegisterCallback()) {
return false;
}
 
return true;
}
 
// ====================================================================================================================
bool WlanClient::StartClient()
{
DWORD dClientVersion = 1;
DWORD rtn = WlanOpenHandle(dClientVersion, NULL, &dNegotiatedVersion, &hClientHandle);
if(rtn != ERROR_SUCCESS) {
Log("Cannot init WLAN");
return false;
}
 
return true;
}
 
// ====================================================================================================================
bool WlanClient::UpdateInterfaces()
{
PWLAN_INTERFACE_INFO_LIST pInterfaceList = NULL;
DWORD rtn = WlanEnumInterfaces(hClientHandle, NULL, &pInterfaceList);
if(rtn != ERROR_SUCCESS) {
Log("Cannot enum interfaces");
return false;
}
 
for(pInterfaceList->dwIndex = 0; pInterfaceList->dwIndex < pInterfaceList->dwNumberOfItems; ++pInterfaceList->dwIndex) {
PWLAN_INTERFACE_INFO pInterfaceInfo = &pInterfaceList->InterfaceInfo[pInterfaceList->dwIndex];
WlanInterface& interf = GetInterface(pInterfaceInfo->InterfaceGuid);
if(pInterfaceInfo->isState == wlan_interface_state_connected) {
interf.Connect();
}
}
 
return true;
}
 
// ====================================================================================================================
WLAN_CONNECTION_ATTRIBUTES WlanClient::GetCurrentConnection(const GUID& interfaceGuid) const
{
WLAN_CONNECTION_ATTRIBUTES res;
 
DWORD size = 0;
PVOID pData = NULL;
 
if(ERROR_SUCCESS != WlanQueryInterface(hClientHandle, &interfaceGuid, wlan_intf_opcode_current_connection, NULL, &size, &pData, NULL)) {
memset(&res, 0, sizeof(res));
}
else {
memcpy(&res, pData, sizeof(res));
}
 
WlanFreeMemory(pData);
 
return res;
}
 
// ====================================================================================================================
VOID WINAPI WlanClient::WlanNotificationCallback(PWLAN_NOTIFICATION_DATA pData, PVOID pContext)
{
((WlanClient*)pContext)->Callback(pData);
}
 
// ====================================================================================================================
void WlanClient::Callback(PWLAN_NOTIFICATION_DATA pData)
{
if(WLAN_NOTIFICATION_SOURCE_ACM == pData->NotificationSource) {
WLAN_NOTIFICATION_ACM acmCode = (WLAN_NOTIFICATION_ACM)pData->NotificationCode;
 
if(wlan_notification_acm_connection_complete == acmCode) {
WlanInterface& interf = GetInterface(pData->InterfaceGuid);
interf.Connect();
CallHandlers(interf, true);
}
else if(wlan_notification_acm_disconnected == acmCode) {
WlanInterface interf = GetInterface(pData->InterfaceGuid);
CallHandlers(interf, false);
interf.Disconnect();
}
}
}
 
// ====================================================================================================================
WlanInterface& WlanClient::GetInterface(const GUID& interfaceGuid)
{
interfaces_t::iterator found = interfaces.find(interfaceGuid);
if(found == interfaces.end()) {
interfaces[interfaceGuid] = WlanInterface(this, interfaceGuid);
found = interfaces.find(interfaceGuid);
}
 
return found->second;
}
 
// ====================================================================================================================
std::string WlanClient::SsidToString(const DOT11_SSID& ssid)
{
if(!ssid.ucSSID || ssid.uSSIDLength == 0) {
return std::string();
}
else {
return std::string((char*)ssid.ucSSID, ssid.uSSIDLength);
}
}
 
// ====================================================================================================================
void WlanClient::CallHandlers(WlanInterface& interf, bool isConnected)
{
std::string networkSsid = SsidToString(interf.networkSsid);
 
Exec(config.runScript, isConnected, networkSsid);
}
 
// ====================================================================================================================
void WlanClient::Exec(std::string command, bool isConnected, std::string networkSsid)
{
if(command.size() == 0) return;
 
std::string cmdLine;
cmdLine.append("/c ").append(command).append(" ")
.append(isConnected ? "connected" : "disconnected").append(" ")
.append(networkSsid);
 
char buffer[32768];
if(cmdLine.size() >= sizeof(buffer)) {
Log("Command too long");
return;
}
 
strcpy_s(buffer, sizeof(buffer), cmdLine.c_str());
 
STARTUPINFO si;
PROCESS_INFORMATION pi;
 
memset(&si, 0, sizeof(si));
si.cb = sizeof(si);
memset(&pi, 0, sizeof(pi));
 
if(!CreateProcess("cmd.exe", buffer, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi)) {
char buffer[1024];
sprintf_s(buffer, "Cannot start %s", command.c_str());
Log(buffer);
}
else {
WaitForSingleObject(pi.hProcess, INFINITE);
 
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
}
}
 
// ====================================================================================================================
bool WlanClient::RegisterCallback()
{
DWORD prevSrc;
 
return (ERROR_SUCCESS == WlanRegisterNotification(hClientHandle,
WLAN_NOTIFICATION_SOURCE_ACM, false, WlanClient::WlanNotificationCallback, this, NULL, &prevSrc));
}
 
// === interface functions ============================================================================================
bool ServiceStart()
{
return wlanClient.Start();
}
 
void ServiceStop()
{
}
/WlanListener/trunk/WlanListener.sln
0,0 → 1,20

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual C++ Express 2008
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "WlanListener", "WlanListener.vcproj", "{44A3E8AD-7FD3-4F34-BB43-9607CA9C4D90}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{44A3E8AD-7FD3-4F34-BB43-9607CA9C4D90}.Debug|Win32.ActiveCfg = Debug|Win32
{44A3E8AD-7FD3-4F34-BB43-9607CA9C4D90}.Debug|Win32.Build.0 = Debug|Win32
{44A3E8AD-7FD3-4F34-BB43-9607CA9C4D90}.Release|Win32.ActiveCfg = Release|Win32
{44A3E8AD-7FD3-4F34-BB43-9607CA9C4D90}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
/WlanListener/trunk/wlan_callback.bat
0,0 → 1,3
@echo off
 
echo %1 %2 >> c:\wlan_callback.log
/WlanListener/trunk/InterfaceId.h
0,0 → 1,18
#ifndef _WLAN_LISTENER_HEADER_INTERFACE_ID_
#define _WLAN_LISTENER_HEADER_INTERFACE_ID_
 
#include <windows.h>
 
class InterfaceId
{
public:
GUID guid;
 
InterfaceId();
InterfaceId(const GUID& guid_);
InterfaceId(const InterfaceId& origin);
InterfaceId& operator=(const InterfaceId& origin);
bool operator<(const InterfaceId& second);
};
 
#endif /* _WLAN_LISTENER_HEADER_INTERFACE_ID_ */
/WlanListener/trunk/WlanInterface.cpp
0,0 → 1,61
#include <windows.h>
#include <wlanapi.h>
 
#include "WlanInterface.h"
#include "Wlan.h"
 
// ====================================================================================================================
WlanInterface::WlanInterface()
: wlanClient(NULL), isConnected(false)
{
memset(&interfaceGuid, 0, sizeof(interfaceGuid));
memset(&networkSsid, 0, sizeof(networkSsid));
}
 
// ====================================================================================================================
WlanInterface::WlanInterface(const WlanClient* wlanClient_, const GUID& interfaceGuid_)
: wlanClient(wlanClient_), interfaceGuid(interfaceGuid_), isConnected(false)
{
memcpy(&interfaceGuid, &interfaceGuid_, sizeof(interfaceGuid_));
memset(&networkSsid, 0, sizeof(networkSsid));
}
 
// ====================================================================================================================
WlanInterface& WlanInterface::operator=(const WlanInterface& origin)
{
if(this != &origin) {
wlanClient = origin.wlanClient;
isConnected = origin.isConnected;
memcpy(&interfaceGuid, &origin.interfaceGuid, sizeof(interfaceGuid));
memcpy(&networkSsid, &origin.networkSsid, sizeof(networkSsid));
}
 
return *this;
}
 
// ====================================================================================================================
void WlanInterface::UpdateNetworkSsid()
{
WLAN_CONNECTION_ATTRIBUTES conn = wlanClient->GetCurrentConnection(interfaceGuid);
if(conn.wlanAssociationAttributes.dot11Ssid.uSSIDLength > 0) {
memcpy(&networkSsid, &conn.wlanAssociationAttributes.dot11Ssid, sizeof(networkSsid));
}
else {
Disconnect();
}
}
 
// ====================================================================================================================
void WlanInterface::Connect()
{
isConnected = true;
UpdateNetworkSsid();
}
 
// ====================================================================================================================
void WlanInterface::Disconnect()
{
isConnected = false;
memset(&networkSsid, 0, sizeof(networkSsid));
}
/WlanListener/trunk/Logger.h
0,0 → 1,7
#ifndef _WLAN_LISTENER_HEADER_LOGGER_
#define _WLAN_LISTENER_HEADER_LOGGER_
 
bool InitLogger();
void Log(LPCSTR pMessage);
 
#endif /* _WLAN_LISTENER_HEADER_LOGGER_ */
/WlanListener/trunk/Main.cpp
0,0 → 1,118
#include <windows.h>
#include <stdio.h>
 
#include "Main.h"
#include "Wlan.h"
#include "Logger.h"
#include "Config.h"
 
SERVICE_STATUS serviceStatus;
SERVICE_STATUS_HANDLE hServiceStatus;
HANDLE hStopEvent = NULL;
Config config;
bool isStandalone;
 
// ====================================================================================================================
void ServiceExit(DWORD exitCode)
{
ServiceStop();
serviceStatus.dwCurrentState = SERVICE_STOPPED;
serviceStatus.dwWin32ExitCode = exitCode;
SetServiceStatus(hServiceStatus, &serviceStatus);
}
 
// ====================================================================================================================
VOID WINAPI ControlHandler(DWORD dwCtrl)
{
switch(dwCtrl) {
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN:
serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
SetServiceStatus(hServiceStatus, &serviceStatus);
SetEvent(hStopEvent);
break;
}
}
 
// ====================================================================================================================
bool Init()
{
hStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if(!hStopEvent) {
return false;
}
 
if(!ServiceStart()) {
return false;
}
 
return true;
}
 
// ====================================================================================================================
void Process()
{
WaitForSingleObject(hStopEvent, INFINITE);
ServiceExit(NO_ERROR);
}
 
// ====================================================================================================================
VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv)
{
serviceStatus.dwServiceType = SERVICE_WIN32;
serviceStatus.dwCurrentState = SERVICE_START_PENDING;
serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
serviceStatus.dwWin32ExitCode = 0;
serviceStatus.dwServiceSpecificExitCode = 0;
serviceStatus.dwCheckPoint = 0;
serviceStatus.dwWaitHint = 0;
hServiceStatus = RegisterServiceCtrlHandler(SERVICE_NAME, ControlHandler);
if(!hServiceStatus) {
return;
}
 
if(!Init()) {
ServiceExit(-1);
}
 
serviceStatus.dwCurrentState = SERVICE_RUNNING;
SetServiceStatus(hServiceStatus, &serviceStatus);
 
Process();
}
 
// ====================================================================================================================
void main(int argc, const char** argv)
{
// parse command line
isStandalone = false;
for(int i = 1; i < argc; ++i) {
std::string param(argv[i]);
 
if(param == "/standalone" || param == "/s") {
isStandalone = true;
}
}
 
config.Load();
config.ParseCmdLine(argc, argv);
 
if(!InitLogger()) {
return;
}
 
if(isStandalone) {
if(Init()) {
//Process();
}
}
else {
SERVICE_TABLE_ENTRY serviceTable[] = {
{ SERVICE_NAME, ServiceMain },
{ NULL, NULL }
};
 
StartServiceCtrlDispatcher(serviceTable);
}
}
/WlanListener/trunk/Config.cpp
0,0 → 1,44
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <string>
 
#include "Config.h"
#include "Logger.h"
 
// ====================================================================================================================
Config::Config()
{
}
 
// ====================================================================================================================
void Config::Load()
{
HKEY hKey;
 
if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Services\\WlanListener\\Config", 0, KEY_QUERY_VALUE | KEY_NOTIFY, &hKey))
{
char buffer[MAX_PATH];
DWORD size = sizeof(buffer);
DWORD type;
 
if(ERROR_SUCCESS == RegQueryValueEx(hKey, "RunScript", 0, &type, (LPBYTE)buffer, &size)) {
runScript.assign(buffer, 0, size);
}
}
 
RegCloseKey(hKey);
}
 
// ====================================================================================================================
void Config::ParseCmdLine(int argc, const char** argv)
{
for(int i = 1; i < argc; ++i) {
std::string param(argv[i]);
 
if(param.length() > 0 && param[0] != '/') {
runScript = param;
}
}
}
/WlanListener/trunk/Wlan.h
0,0 → 1,48
#ifndef _WLAN_LISTENER_HEADER_WLAN_
#define _WLAN_LISTENER_HEADER_WLAN_
 
#include <windows.h>
#include <wlanapi.h>
#include <map>
#include <string>
 
#include "WlanInterface.h"
 
// interface to the service code
bool ServiceStart();
void ServiceStop();
 
struct cmpGuid
{
bool operator()(const GUID& first, const GUID& second) const;
};
 
class WlanClient
{
private:
HANDLE hClientHandle;
DWORD dNegotiatedVersion;
 
typedef std::map<GUID, WlanInterface, cmpGuid> interfaces_t;
interfaces_t interfaces;
 
bool StartClient();
bool UpdateInterfaces();
bool RegisterCallback();
void Callback(PWLAN_NOTIFICATION_DATA pData);
void CallHandlers(WlanInterface& interf, bool isConnected);
WlanInterface& GetInterface(const GUID& interfaceGuid);
std::string SsidToString(const DOT11_SSID& ssid);
void WlanClient::Exec(std::string command, bool isConnected, std::string networkSsid);
 
static VOID WINAPI WlanNotificationCallback(PWLAN_NOTIFICATION_DATA pData, PVOID pContext);
 
public:
WlanClient();
 
bool Start();
 
WLAN_CONNECTION_ATTRIBUTES GetCurrentConnection(const GUID& interfaceGuid) const;
};
 
#endif /* _WLAN_LISTENER_HEADER_WLAN_ */
/WlanListener/trunk/WlanInterface.h
0,0 → 1,31
#ifndef _WLAN_LISTENER_HEADER_WLAN_INTERFACE_
#define _WLAN_LISTENER_HEADER_WLAN_INTERFACE_
 
#include <windows.h>
#include <wlanapi.h>
 
class WlanClient;
 
class WlanInterface
{
private:
const WlanClient* wlanClient;
 
public:
GUID interfaceGuid;
DOT11_SSID networkSsid;
bool isConnected;
 
private:
void UpdateNetworkSsid();
 
public:
WlanInterface();
WlanInterface(const WlanClient* wlanClient_, const GUID& interfaceGuid_);
WlanInterface& operator=(const WlanInterface& origin);
 
void Connect();
void Disconnect();
};
 
#endif /* _WLAN_LISTENER_HEADER_WLAN_INTERFACE_ */
/WlanListener/trunk/WlanListener.vcproj
0,0 → 1,231
<?xml version="1.0" encoding="Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9,00"
Name="WlanListener"
ProjectGUID="{44A3E8AD-7FD3-4F34-BB43-9607CA9C4D90}"
RootNamespace="WlanListener"
TargetFrameworkVersion="131072"
>
<Platforms>
<Platform
Name="Win32"
/>
</Platforms>
<ToolFiles>
</ToolFiles>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory="$(SolutionDir)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="2"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="1"
FavorSizeOrSpeed="2"
StringPooling="true"
MinimalRebuild="false"
BasicRuntimeChecks="0"
RuntimeLibrary="2"
BufferSecurityCheck="false"
WarningLevel="3"
Detect64BitPortabilityProblems="false"
DebugInformationFormat="0"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Advapi32.lib Wlanapi.lib"
LinkIncremental="1"
GenerateDebugInformation="false"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
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)$(ConfigurationName)"
IntermediateDirectory="$(ConfigurationName)"
ConfigurationType="1"
CharacterSet="2"
WholeProgramOptimization="1"
>
<Tool
Name="VCPreBuildEventTool"
/>
<Tool
Name="VCCustomBuildTool"
/>
<Tool
Name="VCXMLDataGeneratorTool"
/>
<Tool
Name="VCWebServiceProxyGeneratorTool"
/>
<Tool
Name="VCMIDLTool"
/>
<Tool
Name="VCCLCompilerTool"
Optimization="1"
FavorSizeOrSpeed="2"
RuntimeLibrary="2"
WarningLevel="3"
Detect64BitPortabilityProblems="true"
DebugInformationFormat="3"
/>
<Tool
Name="VCManagedResourceCompilerTool"
/>
<Tool
Name="VCResourceCompilerTool"
/>
<Tool
Name="VCPreLinkEventTool"
/>
<Tool
Name="VCLinkerTool"
AdditionalDependencies="Advapi32.lib Wlanapi.lib"
GenerateDebugInformation="true"
OptimizeReferences="2"
EnableCOMDATFolding="2"
RandomizedBaseAddress="1"
DataExecutionPrevention="0"
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>
</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=".\Config.cpp"
>
</File>
<File
RelativePath=".\Logger.cpp"
>
</File>
<File
RelativePath=".\Main.cpp"
>
</File>
<File
RelativePath=".\Wlan.cpp"
>
</File>
<File
RelativePath=".\WlanInterface.cpp"
>
</File>
</Filter>
<Filter
Name="Header Files"
Filter="h;hpp;hxx;hm;inl;inc;xsd"
UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
>
<File
RelativePath=".\Config.h"
>
</File>
<File
RelativePath=".\Logger.h"
>
</File>
<File
RelativePath=".\Main.h"
>
</File>
<File
RelativePath=".\Wlan.h"
>
</File>
<File
RelativePath=".\WlanInterface.h"
>
</File>
</Filter>
<Filter
Name="Resource Files"
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
>
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
/WlanListener/trunk/Main.h
0,0 → 1,12
#ifndef _WLAN_LISTENER_HEADER_MAIN_
#define _WLAN_LISTENER_HEADER_MAIN_
 
#include <windows.h>
 
#include "Config.h"
 
#define SERVICE_NAME "WlanListener"
 
extern Config config;
 
#endif /* _WLAN_LISTENER_HEADER_MAIN_ */
/WlanListener/trunk/Config.h
0,0 → 1,17
#ifndef _WLAN_LISTENER_HEADER_CONFIG_
#define _WLAN_LISTENER_HEADER_CONFIG_
 
#include <string>
 
class Config
{
public:
std::string runScript;
 
Config();
 
void Load();
void ParseCmdLine(int argc, const char** argv);
};
 
#endif /* _WLAN_LISTENER_HEADER_CONFIG_ */
/WlanListener/trunk/InterfaceId.cpp
0,0 → 1,29
#include <windows.h>
#include <wlanapi.h>
 
#include "InterfaceId.h"
 
InterfaceId::InterfaceId()
{
memset(&guid, 0, sizeof(guid));
}
 
InterfaceId::InterfaceId(const GUID& guid_)
{
memcpy(&guid, &guid_, sizeof(guid));
}
 
InterfaceId::InterfaceId(const InterfaceId& origin)
{
memcpy(&guid, &origin.guid, sizeof(guid));
}
 
InterfaceId& InterfaceId::operator=(const InterfaceId& origin)
{
if(this != &origin) {
memcpy(&guid, &origin.guid, sizeof(guid));
}
 
return *this;
}