installpassthru.cpp

NDIS IMD中间层驱动自动安装程序

    ZeroMemory( &OboToken,
                sizeof(OboToken) );
    OboToken.Type = OBO_USER;

    //
    // Get component's setup class reference.
    //

    hr = pnc->QueryNetCfgClass ( pguidClass,
                                 IID_INetCfgClassSetup,
                                 (void**)&pncClassSetup );
    if ( hr == S_OK ) {

        hr = pncClassSetup->Install( szComponentId,
                                     &OboToken,
                                     0,
                                     0,       // Upgrade from build number.
                                     NULL,    // Answerfile name
                                     NULL,    // Answerfile section name
                                     &pncc ); // Reference after the component
        if ( S_OK == hr ) {                   // is installed.

            //
            // we don't need to use pncc (INetCfgComponent), release it
            //

            ReleaseRef( pncc );
        }

        ReleaseRef( pncClassSetup );
    }

    return hr;
}


HRESULT CInstallPassthru::HrUninstallNetComponent(IN INetCfg* pnc,
                                IN LPTSTR szComponentId)
{
    INetCfgComponent    *pncc = NULL;
    INetCfgClass        *pncClass = NULL;
    INetCfgClassSetup   *pncClassSetup = NULL;
    OBO_TOKEN           OboToken;
    GUID                guidClass;
    HRESULT             hr = S_OK;

    //
    // OBO_TOKEN specifies on whose behalf this
    // component is being installed.
    // Set it to OBO_USER so that szComponentId will be installed
    // on behalf of the user.
    //

    ZeroMemory( &OboToken,sizeof(OboToken));
    OboToken.Type = OBO_USER;
    // Get the component's reference.
    hr = pnc->FindComponent( szComponentId, &pncc );

    if (S_OK != hr)
	{
		ShowError(_TEXT("Can't find Component"));
		return hr;
	}
	

	// Get the component's class GUID.
	hr = pncc->GetClassGuid( &guidClass );
	if ( hr != S_OK )
	{
		ShowError(_TEXT("Can't Get ClassGuid"));
		return hr;
	}

	// Get component's class reference.
	hr = pnc->QueryNetCfgClass( &guidClass,
		IID_INetCfgClass,
		(void**)&pncClass );
	if ( hr != S_OK ){
		ShowError(_TEXT("Can't Get class reference"));
		return hr;
	}

	// Get Setup reference.
	hr = pncClass->QueryInterface(IID_INetCfgClassSetup,(void**)&pncClassSetup );
	if ( hr != S_OK )
	{
		ShowError(_TEXT("Can't Get Setup reference"));
		return hr;
	}

	hr = pncClassSetup->DeInstall( pncc,
		&OboToken,
		NULL);
	if ( hr != S_OK )
	{
		ShowError(_TEXT("Install"));
		return hr;
	}
	hr = pnc->Apply();
	ReleaseRef( pncClassSetup );
	ReleaseRef( pncClass );
	ReleaseRef( pncc );
	

    return hr;
}

HRESULT CInstallPassthru::HrGetComponentEnum (INetCfg* pnc,
                            IN const GUID* pguidClass,
                            OUT IEnumNetCfgComponent **ppencc)
{
    INetCfgClass  *pncclass;
    HRESULT       hr;

    *ppencc = NULL;

    //
    // Get the class reference.
    //

    hr = pnc->QueryNetCfgClass( pguidClass,
                                IID_INetCfgClass,
                                (PVOID *)&pncclass );

    if ( hr == S_OK ) {

        //
        // Get the enumerator reference.
        //

        hr = pncclass->EnumComponents( ppencc );

        //
        // We don't need the class reference any more.
        //

        ReleaseRef( pncclass );
    }

    return hr;
}

HRESULT CInstallPassthru::HrGetFirstComponent (IN IEnumNetCfgComponent* pencc,
                             OUT INetCfgComponent **ppncc)
{
    HRESULT  hr;
    ULONG    ulCount;

    *ppncc = NULL;

    pencc->Reset();

    hr = pencc->Next( 1,ppncc,&ulCount );
    return hr;
}

HRESULT CInstallPassthru::HrGetNextComponent (IN IEnumNetCfgComponent* pencc,
                            OUT INetCfgComponent **ppncc)
{
    HRESULT  hr;
    ULONG    ulCount;

    *ppncc = NULL;

    hr = pencc->Next(1,ppncc,&ulCount );
    return hr;
}

HRESULT CInstallPassthru::HrFindNetComponentByPnpId (IN INetCfg *pnc,
                                   IN LPWSTR lpszPnpDevNodeId,
                                   OUT INetCfgComponent **ppncc)
{
    IEnumNetCfgComponent    *pencc;
    LPWSTR                  pszPnpId;
    HRESULT                 hr;
    BOOL                    fFound;

    hr = HrGetComponentEnum( pnc,
                             &GUID_DEVCLASS_NET,
                             &pencc );
    if ( hr == S_OK ) {

        hr = HrGetFirstComponent( pencc, ppncc );
        fFound = FALSE;
        while( hr == S_OK ) {
            hr = (*ppncc)->GetPnpDevNodeId( &pszPnpId );
            if ( hr == S_OK ) {
                fFound = wcscmp( pszPnpId, lpszPnpDevNodeId ) == 0;
                CoTaskMemFree( pszPnpId );
                if ( fFound ) {
                    break;
                }
            }
            else {
                hr = S_OK;
            }

            ReleaseRef( *ppncc );
            hr = HrGetNextComponent( pencc, ppncc );
        }

        ReleaseRef( pencc );
    }

    return hr;
}


HRESULT CInstallPassthru::HrGetBindingPathEnum (IN INetCfgComponent *pncc,
                              IN DWORD dwBindingType,
                              OUT IEnumNetCfgBindingPath **ppencbp)
{
    INetCfgComponentBindings *pnccb = NULL;
    HRESULT                  hr;

    *ppencbp = NULL;

    //
    // Get component's binding.
    //

    hr = pncc->QueryInterface( IID_INetCfgComponentBindings,
                               (PVOID *)&pnccb );

    if ( hr == S_OK ) {

        //
        // Get binding path enumerator reference.
        //

        hr = pnccb->EnumBindingPaths( dwBindingType,
                                      ppencbp );

        ReleaseRef( pnccb );
    }

    return hr;
}


HRESULT CInstallPassthru::HrGetFirstBindingPath (IN IEnumNetCfgBindingPath *pencbp,
                               OUT INetCfgBindingPath **ppncbp)
{
    ULONG   ulCount;
    HRESULT hr;

    *ppncbp = NULL;

    pencbp->Reset();
    hr = pencbp->Next( 1,ppncbp, &ulCount );

    return hr;
}

HRESULT CInstallPassthru::HrGetNextBindingPath (IN IEnumNetCfgBindingPath *pencbp,
                              OUT INetCfgBindingPath **ppncbp)
{
    ULONG   ulCount;
    HRESULT hr;

    *ppncbp = NULL;
    hr = pencbp->Next( 1,ppncbp,&ulCount );

    return hr;
}


HRESULT CInstallPassthru::HrGetBindingInterfaceEnum (IN INetCfgBindingPath *pncbp,
                                   OUT IEnumNetCfgBindingInterface **ppencbi)
{
    HRESULT hr;
    *ppencbi = NULL;
    hr = pncbp->EnumBindingInterfaces( ppencbi );
    return hr;
}

HRESULT CInstallPassthru::HrGetFirstBindingInterface (IN IEnumNetCfgBindingInterface *pencbi,
                                    OUT INetCfgBindingInterface **ppncbi)
{
    ULONG   ulCount;
    HRESULT hr;

    *ppncbi = NULL;
    pencbi->Reset();
    hr = pencbi->Next( 1,ppncbi,&ulCount );

    return hr;
}


HRESULT CInstallPassthru::HrGetNextBindingInterface (IN IEnumNetCfgBindingInterface *pencbi,
                                   OUT INetCfgBindingInterface **ppncbi)
{
    ULONG   ulCount;
    HRESULT hr;
    *ppncbi = NULL;
    hr = pencbi->Next(1,ppncbi,&ulCount );

    return hr;
}

VOID CInstallPassthru::ReleaseRef (IN IUnknown* punk)
{
    if ( punk ) {
        punk->Release();
    }
    return;
}



HRESULT CInstallPassthru::GetPnpID(LPTSTR lpszInfFile,LPTSTR *lppszPnpID)
{
    HINF    hInf;
    LPTSTR  lpszModelSection;
    HRESULT hr;
	
    *lppszPnpID = NULL;
	
    hInf = SetupOpenInfFile(lpszInfFile,
		NULL,
		INF_STYLE_WIN4,
		NULL );
	
    if ( hInf == INVALID_HANDLE_VALUE )
    {	
		ShowError(_TEXT("error1"));
        return HRESULT_FROM_WIN32(GetLastError());
    }
	
    hr = GetKeyValue( hInf,
		_TEXT("Manufacturer"),
		NULL,
		1,
		&lpszModelSection );
	
    if ( hr == S_OK )
    {
        hr = GetKeyValue( hInf,
			lpszModelSection,
			NULL,
			2,
			lppszPnpID );
		if (hr != S_OK )
		{
			ShowError(_TEXT("error3"));
		}
        CoTaskMemFree( lpszModelSection );
    }
	else ShowError(_TEXT("error2"));
	
    SetupCloseInfFile( hInf );
    return hr;
}


HRESULT CInstallPassthru::GetKeyValue (HINF hInf,LPTSTR lpszSection,LPTSTR lpszKey,DWORD  dwIndex,LPTSTR *lppszValue)
{
    INFCONTEXT  infCtx;
	DWORD dwSizeNeeded;
    HRESULT     hr;
	
    *lppszValue = NULL;
	
    if ( SetupFindFirstLine(hInf,
		lpszSection,
		lpszKey,
		&infCtx) == FALSE )
    {
        return HRESULT_FROM_WIN32(GetLastError());
    }
	
    if ( SetupGetStringField(&infCtx,
		dwIndex,
		NULL,
		0,
		&dwSizeNeeded) )
    {
        *lppszValue = (LPWSTR)CoTaskMemAlloc( sizeof(WCHAR) * dwSizeNeeded );
		
        if ( !*lppszValue  )
        {
			return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
        }
		
        if ( SetupGetStringField(&infCtx,
			dwIndex,
			*lppszValue,
			dwSizeNeeded,
			NULL) == FALSE )
        {
			
            hr = HRESULT_FROM_WIN32(GetLastError());
			
            CoTaskMemFree( *lppszValue );
            *lppszValue = NULL;
        }
        else
        {
            hr = S_OK;
        }
    }
    else
    {
        DWORD dwErr = GetLastError();
        hr = HRESULT_FROM_WIN32(dwErr);
    }	
    return hr;
}

void CInstallPassthru::ShowError(TCHAR * errMsg)
{	
	TCHAR lpMsgBuf[256]={0};
	DWORD dw = ::GetLastError();
	FormatMessage(  
		FORMAT_MESSAGE_FROM_SYSTEM,
		NULL,
		dw,
		MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), // Default language
		lpMsgBuf,
		sizeof(lpMsgBuf),
		NULL 
		);
	MessageBox(m_hwnd,lpMsgBuf,errMsg,MB_OK | MB_ICONINFORMATION);
	
	
}