Beispiel #1
0
t_stat i8259_raiseint(I8259* chip,int level)
{
    int32 bit, isr, myprio;

    TRACE_PRINT1(DBG_PIC_II,"Request INT level=%d",level);

    if (chip->state != 5) return SCPE_OK; /* not yet initialized, ignore interrupts */
    bit = 1<<level;
    if (chip->imr & bit) return SCPE_OK; /* inhibited */
    chip->isr = (chip->isr | bit) & 0xff; /* request this interrupt level */

    /* bit7=prio7 => bitN = prioN   
       bit7=prio6 => bitN = prioN-1
       ...
       bit7=prio0 => bitN = prioN-7
    */   
    isr = (chip->isr<<8) | chip->isr; /* simple rotation */
    isr = isr << (7-level); /* shift level bit into bit 15 */
    myprio = chip->prio - 7 + level; if (myprio < 0) myprio += 8;
    if (!(isr & priomask[myprio])) { /* higher interrupt is pending */
        if (chip->autoint) {
            TRACE_PRINT1(DBG_PIC_IO,"Raise AUTOINT level=%d",chip->intlevel);
            return m68k_raise_autoint(chip->intlevel);
        } else {
            TRACE_PRINT2(DBG_PIC_IO,"Raise VECTORINT level=%d vector=%x",chip->intlevel,chip->intvector);
            return m68k_raise_vectorint(chip->intlevel,chip->intvector);
        }
    }
    return SCPE_OK;
}
Beispiel #2
0
t_stat i8251_read(I8251* chip,int port,uint32* value)
{
    if (port==0) { /* data read */
        *value = chip->ibuf;
        chip->status &= ~I8251_ST_RXRDY; /* mark read buffer as empty */
        TRACE_PRINT1(DBG_UART_RD,"RD DATA = 0x%02x",*value);
    } else { /* status read */
        *value = chip->status & 0xff;
        TRACE_PRINT1(DBG_UART_RD,"RD STATUS = 0x%02x",*value);
    }
    return SCPE_OK;
}
Beispiel #3
0
static t_stat u39_callc(I8255* chip,int rw)
{
    if (rw==1) {
        if (I8255_FALLEDGE(portc,U39C_STROBE)) {
            sagelp_output(&sagelp_unit);
            TRACE_PRINT1(DBG_PP_RDC,"RD PortC: STROBE-=%d",chip->portc&U39C_STROBE?1:0);
        }
        if (I8255_RISEEDGE(portc,U39C_SI)) {
/*          printf("rising edge on SI: PC=%x!\n",PCX);*/
            TRACE_PRINT1(DBG_PP_RDC,"RD PortC: SI+=%d",chip->portc&U39C_SI?1:0);
            sage_raiseint(SI_PICINT);
        }
    }
    return SCPE_OK;
}
Beispiel #4
0
static t_stat u39_calla(I8255* chip, int rw)
{
    if (rw) {
        sagelp_unit.buf = chip->porta;
        TRACE_PRINT1(DBG_PP_WRA,"WR PortA = 0x%x",chip->porta);
    }
    return SCPE_OK;
}
Beispiel #5
0
// enumerate wireless interfaces
UINT EnumInterface(HANDLE hClient, WLAN_INTERFACE_INFO sInfo[64])
{
	TRACE_ENTER();

	DWORD dwError = ERROR_SUCCESS;
	PWLAN_INTERFACE_INFO_LIST pIntfList = NULL;
	UINT i = 0;

	__try
	{
		// enumerate wireless interfaces
		if ((dwError = My_WlanEnumInterfaces(
			hClient,
			NULL,               // reserved
			&pIntfList
			)) != ERROR_SUCCESS)
		{
			TRACE_PRINT1("My_WlanEnumInterfaces: error, errCode = 0x%08x.", dwError);
			__leave;
		}

		// print out interface information
		for (i = 0; i < pIntfList->dwNumberOfItems; i++)
		{
			memcpy(&sInfo[i], &pIntfList->InterfaceInfo[i], sizeof(WLAN_INTERFACE_INFO));
		}

		TRACE_PRINT1("My_WlanEnumInterfaces: pIntfList->dwNumberOfItems = %d.", pIntfList->dwNumberOfItems);
		TRACE_EXIT();
		return pIntfList->dwNumberOfItems;
	}
	__finally
	{
		// clean up
		if (pIntfList != NULL)
		{
			My_WlanFreeMemory(pIntfList);
		}
	}

	TRACE_PRINT1("My_WlanEnumInterfaces: pIntfList->dwNumberOfItems = %d.", pIntfList->dwNumberOfItems);
	TRACE_EXIT();
	return 0;
}
Beispiel #6
0
// open a WLAN client handle and check version
DWORD
OpenHandleAndCheckVersion(
PHANDLE phClient
)
{
	TRACE_ENTER();

	DWORD dwError = ERROR_SUCCESS;
	DWORD dwServiceVersion;
	HANDLE hClient = NULL;

	__try
	{
		*phClient = NULL;

		// open a handle to the service
		if ((dwError = My_WlanOpenHandle(
			WLAN_API_VERSION,
			NULL,               // reserved
			&dwServiceVersion,
			&hClient
			)) != ERROR_SUCCESS)
		{
			TRACE_PRINT1("My_WlanOpenHandle: error, errCode = 0x%08x.", dwError);
			__leave;
		}

		// check service version
		if (WLAN_API_VERSION_MAJOR(dwServiceVersion) < WLAN_API_VERSION_MAJOR(WLAN_API_VERSION_2_0))
		{
			// No-op, because the version check is for demonstration purpose only.
			// You can add your own logic here.
		}

		*phClient = hClient;

		// set hClient to NULL so it will not be closed
		hClient = NULL;
	}
	__finally
	{
		if (hClient != NULL)
		{
			// clean up
			My_WlanCloseHandle(
				hClient,
				NULL            // reserved
				);
		}
	}

	TRACE_EXIT();
	return dwError;
}
Beispiel #7
0
BOOL initWlanFunctions()
{
	BOOL bRet;

	TRACE_ENTER();

	// Get a handle to the packet DLL module.
	hinstLib = LoadLibrary(TEXT("wlanapi.dll"));

	// If the handle is valid, try to get the function address.  
	if (hinstLib != NULL)
	{
		My_WlanOpenHandle = (MY_WLANOPENHANDLE)GetProcAddress(hinstLib, "WlanOpenHandle");
		My_WlanCloseHandle = (MY_WLANCLOSEHANDLE)GetProcAddress(hinstLib, "WlanCloseHandle");
		My_WlanEnumInterfaces = (MY_WLANENUMINTERFACES)GetProcAddress(hinstLib, "WlanEnumInterfaces");
		My_WlanFreeMemory = (MY_WLANFREEMEMORY)GetProcAddress(hinstLib, "WlanFreeMemory");
		// If the function address is valid, call the function.  

		if (My_WlanOpenHandle != NULL &&
			My_WlanCloseHandle != NULL &&
			My_WlanEnumInterfaces != NULL &&
			My_WlanFreeMemory != NULL)
		{
			bRet = TRUE;
		}
		else
		{
			TRACE_PRINT1("GetProcAddress: error, errCode = 0x%08x.", GetLastError());
			bRet = FALSE;
		}
	}
	else
	{
		TRACE_PRINT1("LoadLibrary: error, errCode = 0x%08x.", GetLastError());
		bRet = FALSE;
	}

	TRACE_EXIT();
	return bRet;
}
Beispiel #8
0
NetCfg::NetCfg() : m_pINetCfg(0)
{
	TRACE_ENTER();

	HRESULT hr = S_OK;

	hr = m_pINetCfg.CoCreateInstance(CLSID_CNetCfg);

	if(!SUCCEEDED(hr))
	{
		TRACE_PRINT1("INetCfg::CoCreateInstance: error, errCode = 0x%08x.", hr);
		throw 1;
	}

	hr = m_pINetCfg.QueryInterface(&m_pLock);

	if (!SUCCEEDED(hr))
	{
		TRACE_PRINT1("INetCfg::QueryInterface: error, errCode = 0x%08x.", hr);
		throw 2;
	}

	// Note that this call can block.
	hr = m_pLock->AcquireWriteLock(INFINITE, NPCAP_LOOPBACK_APP_NAME, NULL);
	if (!SUCCEEDED(hr))
	{
		TRACE_PRINT1("INetCfgLock::AcquireWriteLock: error, errCode = 0x%08x.", hr);
		throw 3;
	}

	hr = m_pINetCfg->Initialize(NULL);

	if(!SUCCEEDED(hr))
	{
		TRACE_PRINT1("INetCfg::Initialize: error, errCode = 0x%08x.", hr);
		throw 4;
	}

	TRACE_EXIT();
}
Beispiel #9
0
COM::COM()
{
	TRACE_ENTER();

	HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);

	if(!SUCCEEDED(hr))
	{
		TRACE_PRINT1("CoInitializeEx: error, errCode = 0x%08x.", hr);
	}

	TRACE_EXIT();
}
Beispiel #10
0
BOOL EraseLoopbackRecord()
{
	TRACE_ENTER();
	BOOL rv = TRUE;
#ifndef NPF_NPCAP_RUN_IN_WINPCAP_MODE
	HKEY hKey;
	DWORD type;
	char buffer[BUFSIZE];
	DWORD size = sizeof(buffer);
	DWORD dwWinPcapMode = 0;

	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, NPCAP_SERVICE_REG_KEY_NAME _T("\\Parameters"), 0, KEY_READ, &hKey) == ERROR_SUCCESS)
	{
		if (RegQueryValueExA(hKey, "WinPcapCompatible", 0, &type,  (LPBYTE)buffer, &size) == ERROR_SUCCESS && type == REG_DWORD)
		{
			dwWinPcapMode = *((DWORD *) buffer);
		}
		else
		{
			TRACE_PRINT1("RegQueryValueExA(WinPcapCompatible) failed or not REG_DWORD: %#x\n", GetLastError());
			dwWinPcapMode = 0;
		}

		RegCloseKey(hKey);
	}
	else
	{
		TRACE_PRINT2("%s\\Parameters) failed: %#x\n", NPCAP_SERVICE_REG_KEY_NAME, GetLastError());
		dwWinPcapMode = 0;
	}

	if (dwWinPcapMode != 0 && !DeleteValueFromRegistry(_T("SYSTEM\\CurrentControlSet\\Services\\npf\\Parameters"), NPCAP_REG_LOOPBACK_VALUE_NAME))
	{
		rv = FALSE;
	}
#endif /* ifndef NPF_NPCAP_RUN_IN_WINPCAP_MODE */

	if (!DeleteValueFromRegistry(NPCAP_REG_KEY_NAME, NPCAP_REG_LOOPBACK_VALUE_NAME))
	{
		rv = FALSE;
	}

	if (!DeleteValueFromRegistry(NPCAP_SERVICE_REG_KEY_NAME _T("\\Parameters"), NPCAP_REG_LOOPBACK_VALUE_NAME))
	{
		rv = FALSE;
	}

	TRACE_EXIT();
	return rv;
}
Beispiel #11
0
NetCfg::~NetCfg()
{
	TRACE_ENTER();

	HRESULT hr = S_OK;

	if(m_pINetCfg)
	{
		hr = m_pINetCfg->Uninitialize();
		if(!SUCCEEDED(hr))
		{
			TRACE_PRINT1("INetCfg::Uninitialize: error, errCode = 0x%08x.", hr);
		}

		hr = m_pLock->ReleaseWriteLock();
		if (!SUCCEEDED(hr))
		{
			TRACE_PRINT1("INetCfgLock::ReleaseWriteLock: error, errCode = 0x%08x.", hr);
		}
	}

	TRACE_EXIT();
}
Beispiel #12
0
BOOL writeWlanAdapterGuidsToRegistry()
{
	TRACE_ENTER();

	vector<tstring> nstrWlanAdapterGuids = getWlanAdapterGuids();
	if (nstrWlanAdapterGuids.size() == 0)
	{
		TRACE_PRINT1("getWlanAdapterGuids: error, nstrWlanAdapterGuids.size() = %d.", nstrWlanAdapterGuids.size());
		TRACE_EXIT();
		return FALSE;
	}

	for (size_t i = 0; i < nstrWlanAdapterGuids.size(); i++)
	{
		nstrWlanAdapterGuids[i] = _T("\\Device\\{") + nstrWlanAdapterGuids[i] + _T("}");
	}

	tstring strGuidText = printAdapterNames(nstrWlanAdapterGuids);

	TRACE_PRINT1("AddFlagToRegistry_Dot11Adapters: executing, strGuidText = %s.", strGuidText.c_str());
	TRACE_EXIT();
	return AddFlagToRegistry_Dot11Adapters(strGuidText.c_str());

}
Beispiel #13
0
BOOL AddFlagToRegistry_Service(tstring strDeviceName)
{
	TRACE_ENTER();
	BOOL rv = TRUE;
#ifndef NPF_NPCAP_RUN_IN_WINPCAP_MODE
	/* If this is *not* the WinPcap-API compatible build, then it's the native
	 * build, which is responsible for installing and recording the loopback
	 * interface so that both drivers can access it. */
	HKEY hKey;
	DWORD type;
	char buffer[BUFSIZE];
	DWORD size = sizeof(buffer);
	DWORD dwWinPcapMode = 0;


	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, NPCAP_SERVICE_REG_KEY_NAME _T("\\Parameters"), 0, KEY_READ, &hKey) == ERROR_SUCCESS)
	{
		if (RegQueryValueExA(hKey, "WinPcapCompatible", 0, &type,  (LPBYTE)buffer, &size) == ERROR_SUCCESS && type == REG_DWORD)
		{
			dwWinPcapMode = *((DWORD *) buffer);
		}
		else
		{
			TRACE_PRINT1("RegQueryValueExA(WinPcapCompatible) failed or not REG_DWORD: %#x\n", GetLastError());
			dwWinPcapMode = 0;
		}

		RegCloseKey(hKey);
	}
	else
	{
		TRACE_PRINT2("%s\\Parameters) failed: %#x\n", NPCAP_SERVICE_REG_KEY_NAME, GetLastError());
		dwWinPcapMode = 0;
	}

	if (dwWinPcapMode != 0) {
		rv = WriteStrToRegistry(_T("SYSTEM\\CurrentControlSet\\Services\\npf\\Parameters"), NPCAP_REG_LOOPBACK_VALUE_NAME, tstring(_T("\\Device\\") + strDeviceName).c_str(), KEY_WRITE);
	}
#endif /* ifndef NPF_NPCAP_RUN_IN_WINPCAP_MODE */

	rv = WriteStrToRegistry(NPCAP_SERVICE_REG_KEY_NAME _T("\\Parameters"), NPCAP_REG_LOOPBACK_VALUE_NAME, tstring(_T("\\Device\\") + strDeviceName).c_str(), KEY_WRITE) && rv;

	TRACE_EXIT();
	return rv;
}
Beispiel #14
0
static t_stat u39_ckmode(I8255* chip,uint32 data)
{
    TRACE_PRINT1(DBG_PP_MODE,"WR Mode: 0x%x",data);
    
    /* BIOS initializes port A as input, later LP is initialized to output */
    if (!(data==0x82 || data==0x92)) {
        /* hardwired:
         * d7=1 -- mode set flag
         * d6=0 -+ group a mode 0: basic I/O
         * d5=0 -+
         * d4=0 -- port a = output / input
         * d3=0 -- port c upper = output
         * d2=0 -- group b mode 0: basic I/O
         * d1=1 -- port b = input
         * d0=0 -- port c lower = output
         */
        printf("u39_ckmode: unsupported ctrl=0x%02x\n",data);
        return STOP_IMPL;
    }
    chip->portc = 0; /* reset port */
    return SCPE_OK;
}
Beispiel #15
0
static t_stat u39_callb(I8255* chip, int rw)
{
    if (rw==0) { /* only when reading port */
        /* propagate FDC Write Protect */
        int portb = 0;
        I8272_DRIVE_INFO* dip = &u21.drive[u21.fdc_curdrv];
        if (dip->uptr && (dip->uptr->flags & UNIT_I8272_WLK)) {
            portb |= U39B_WP;
            TRACE_PRINT1(DBG_PP_RDB,"RD PortB: WP+=%d",(portb&U39B_WP)?1:0);
        }
            
        /* propagate FDC interrupt */
        if (u21.irqflag) {
            portb |= U39B_FDI;
            TRACE_PRINT0(DBG_PP_RDB,"RD PortB: FDI+=1");
        } else {
            TRACE_PRINT0(DBG_PP_RDB,"RD PortB: FDI+=0");
        }
        chip->portb = portb;
    }
    return SCPE_OK;
}
Beispiel #16
0
vector<tstring> getWlanAdapterGuids()
{
	TRACE_ENTER();

	HANDLE hClient = NULL;
	WLAN_INTERFACE_INFO sInfo[64];
	RPC_TSTR strGuid = NULL;
	vector<tstring> nstrWlanAdapterGuids;

	if (!initWlanFunctions())
	{
		TRACE_PRINT("initWlanFunctions: error.");
		TRACE_EXIT();
		return nstrWlanAdapterGuids;
	}

	if (OpenHandleAndCheckVersion(&hClient) != ERROR_SUCCESS)
	{
		TRACE_PRINT("OpenHandleAndCheckVersion: error.");
		TRACE_EXIT();
		return nstrWlanAdapterGuids;
	}

	UINT nCount = EnumInterface(hClient, sInfo);
	for (UINT i = 0; i < nCount; ++i)
	{
		if (UuidToString(&sInfo[i].InterfaceGuid, &strGuid) == RPC_S_OK)
		{
			TRACE_PRINT1("EnumInterface: executing, strGuid = %s.", (TCHAR*) strGuid);
			nstrWlanAdapterGuids.push_back((TCHAR*) strGuid);
			RpcStringFree(&strGuid);
		}
	}

	TRACE_EXIT();
	return nstrWlanAdapterGuids;
}
Beispiel #17
0
t_stat i8251_write(I8251* chip,int port,uint32 value)
{
    int bits;

    if (port==0) { /* data port */
        chip->obuf = value & chip->bitmask;
        TRACE_PRINT1(DBG_UART_WR,"WR DATA = 0x%02x",chip->obuf);
        if (chip->init==3) { /* is fully initialized */
            if ((chip->mode & I8251_MODE_BAUD)==I8251_MODE_SYNC) {
                sim_printf("i8251: sync mode not implemented\n");
                return STOP_IMPL;
            }
            if (chip->cmd & I8251_CMD_TXEN) {
                /* transmit data */
                chip->status &= ~(I8251_ST_TXEMPTY|I8251_ST_TXRDY);
                sim_activate(chip->out,chip->out->wait);
            }
        }
        return SCPE_OK;
    } else { /* control port */
        switch (chip->init) {
        case 0: /* expect mode word */
            chip->mode = value; 
            TRACE_PRINT1(DBG_UART_WR,"WR MODE = 0x%02x",value);
            chip->init = (value & I8251_MODE_BAUD)==I8251_MODE_SYNC ? 1 : 3;
            bits = (chip->mode & I8251_AMODE_BITS) >> 2;
            chip->bitmask = i8251_bitmask[bits];
            break;
        case 1: /* expect sync1 */
            chip->sync1 = value;
            TRACE_PRINT1(DBG_UART_WR,"WR SYNC1 = 0x%02x",value);
            chip->init = 2;
            break;
        case 2: /* expect sync2 */
            chip->sync2 = value;
            TRACE_PRINT1(DBG_UART_WR,"WR SYNC2 = 0x%02x",value);
            chip->init = 3;
            break;
        case 3: /* expect cmd word */
            chip->cmd = value;
            TRACE_PRINT1(DBG_UART_WR,"WR CMD = 0x%02x",value);
            if (value & I8251_CMD_EH) {
                sim_printf("i8251: hunt mode not implemented\n");
                return STOP_IMPL;
            }
            if (value & I8251_CMD_IR)
                chip->init = 0;
            if (value & I8251_CMD_ER)
                chip->status &= ~(I8251_ST_FE|I8251_ST_OE|I8251_ST_PE);
            if (value & I8251_CMD_SBRK)
                sim_printf("i8251: BREAK sent\n");
            if (value & I8251_CMD_RXE) {
                sim_activate(chip->in,chip->in->wait);
            } else {
                if (!chip->oob) sim_cancel(chip->in);
            }
            if (value & I8251_CMD_TXEN) {
                if (!(chip->status & I8251_ST_TXEMPTY))
                    sim_activate(chip->out,chip->out->wait);
                else {
                    chip->status |= I8251_ST_TXRDY;
                    if (chip->txint) chip->txint(chip);
                }
            } else {
                chip->status &= ~I8251_ST_TXRDY;
                sim_cancel(chip->out);
            }
            }
            return SCPE_OK;
    }
}
Beispiel #18
0
BOOL EnumerateComponents(CComPtr<INetCfg>& pINetCfg, const GUID* pguidClass)
{
	TRACE_ENTER();

	/*	cout << "\n\nEnumerating " << GUID2Str(pguidClass) << " class:\n" << endl;*/

	// IEnumNetCfgComponent provides methods that enumerate the INetCfgComponent interfaces 
	// for network components of a particular type installed on the operating system. 
	// Types of network components include network cards, protocols, services, and clients.
	CComPtr<IEnumNetCfgComponent> pIEnumNetCfgComponent;

	// get enumeration containing network components of the provided class (GUID)
	HRESULT hr = pINetCfg->EnumComponents(pguidClass, &pIEnumNetCfgComponent);

	if(!SUCCEEDED(hr))
	{
		TRACE_PRINT1("INetCfg::EnumComponents: error, errCode = 0x%08x.", hr);
		throw 1;
	} 

	// INetCfgComponent interface provides methods that control and retrieve 
	// information about a network component.
	CComPtr<INetCfgComponent> pINetCfgComponent;

	unsigned int nIndex = 1;
	BOOL bFound = FALSE;
	BOOL bFailed = FALSE;
	// retrieve the next specified number of INetCfgComponent interfaces in the enumeration sequence.
	while(pIEnumNetCfgComponent->Next(1, &pINetCfgComponent, 0) == S_OK)
	{
		/*		cout << GUID2Desc(pguidClass) << " "<< nIndex++ << ":\n";*/

// 		LPWSTR pszDisplayName = NULL;
// 		pINetCfgComponent->GetDisplayName(&pszDisplayName);
// 		wcout << L"\tDisplay name: " << wstring(pszDisplayName) << L'\n';
// 		CoTaskMemFree(pszDisplayName);

		LPWSTR pszBindName = NULL;
		pINetCfgComponent->GetBindName(&pszBindName);
//		wcout << L"\tBind name: " << wstring(pszBindName) << L'\n';

// 		DWORD dwCharacteristics = 0;
// 		pINetCfgComponent->GetCharacteristics(&dwCharacteristics);
// 		cout << "\tCharacteristics: " << dwCharacteristics << '\n';
// 
// 		GUID guid;  
// 		pINetCfgComponent->GetClassGuid(&guid);
// 		cout << "\tClass GUID: " << guid.Data1 << '-' << guid.Data2 << '-'
// 			<< guid.Data3 << '-' << (unsigned int) guid.Data4 << '\n';
// 
// 		ULONG ulDeviceStatus = 0;
// 		pINetCfgComponent->GetDeviceStatus(&ulDeviceStatus);
// 		cout << "\tDevice Status: " << ulDeviceStatus << '\n';
// 
// 		LPWSTR pszHelpText = NULL;
// 		pINetCfgComponent->GetHelpText(&pszHelpText);
// 		wcout << L"\tHelp Text: " << wstring(pszHelpText) << L'\n';
// 		CoTaskMemFree(pszHelpText);
// 
// 		LPWSTR pszID = NULL;
// 		pINetCfgComponent->GetId(&pszID);
// 		wcout << L"\tID: " << wstring(pszID) << L'\n';
// 		CoTaskMemFree(pszID);
// 
// 		pINetCfgComponent->GetInstanceGuid(&guid);
// 		cout << "\tInstance GUID: " << guid.Data1 << '-' << guid.Data2 << '-'
// 			<< guid.Data3 << '-' << (unsigned int) guid.Data4 << '\n';

		LPWSTR pszPndDevNodeId = NULL;
		hr = pINetCfgComponent->GetPnpDevNodeId(&pszPndDevNodeId);
		if (!SUCCEEDED(hr))
		{
			TRACE_PRINT1("GetPnpDevNodeId failed: %#x", hr);
			TRACE_EXIT();
			return FALSE;
		}
//		wcout << L"\tPNP Device Node ID: " << wstring(pszPndDevNodeId) << L'\n';

		int iDevID = getIntDevID(pszPndDevNodeId);
		TRACE_PRINT4("INetCfgComponent::GetPnpDevNodeId: executing, pszPndDevNodeId = %s, iDevID = %d, g_NpcapAdapterID = %d, pszBindName = %ws.",
			pszPndDevNodeId, iDevID, g_NpcapAdapterID, pszBindName);
		if (g_NpcapAdapterID == iDevID)
		{
			bFound = TRUE;

			TRACE_PRINT2("INetCfgComponent::SetDisplayName: executing, g_NpcapAdapterID = iDevID = %d, pszBindName = %ws.", g_NpcapAdapterID, pszBindName);
			hr = pINetCfgComponent->SetDisplayName(NPCAP_LOOPBACK_ADAPTER_NAME);

			if (hr != S_OK)
			{
				TRACE_PRINT1("INetCfgComponent::SetDisplayName: error, errCode = 0x%08x.", hr);
				bFailed = TRUE;
			}

			if (!AddFlagToRegistry(pszBindName))
			{
				TRACE_PRINT1("AddFlagToRegistry: error, pszBindName = %ws.", pszBindName);
				bFailed = TRUE;
			}

 			if (!AddFlagToRegistry_Service(pszBindName))
 			{
				TRACE_PRINT1("AddFlagToRegistry_Service: error, pszBindName = %ws.", pszBindName);
 				bFailed = TRUE;
 			}

			if (!RenameLoopbackNetwork(pszBindName))
			{
				TRACE_PRINT1("RenameLoopbackNetwork: error, pszBindName = %ws.", pszBindName);
				bFailed = TRUE;
			}
		}

		CoTaskMemFree(pszBindName);
		CoTaskMemFree(pszPndDevNodeId);
		pINetCfgComponent.Release();

		if (bFound)
		{
			TRACE_EXIT();
			return !bFailed;
		}
	}

	TRACE_EXIT();
	return FALSE;
}