// TranxMgr.cpp: implementation for the CTranxMgr
//
// Copyright (c)1997-2001 Microsoft Corporation
//
//////////////////////////////////////////////////////////////////////
#include "precomp.h"
#include "TranxMgr.h"
#include "FilterMM.h"
#include "FilterTr.h"
#include "FilterTun.h"
#include "PolicyMM.h"
#include "PolicyQM.h"
#include "AuthMM.h"


/*
Routine Description: 

Name:

    CTranxManager::ExecMethod

Functionality:

    This is our C++ class implmeneting Nsp_TranxManager WMI class which
    can execute methods. The class is defined to support "rollback".

Virtual:
    
    Yes (part of IIPSecObjectImpl)

Arguments:

    pNamespace  - our namespace.

    pszMethod   - The name of the method.

    pCtx        - COM interface pointer by WMI and needed for various WMI APIs

    pInParams   - COM interface pointer to the input parameter object.

    pSink       - COM interface pointer for notifying WMI about results.

Return Value:

    Success:

        Various success codes indicating the result.

    Failure:

        Various errors may occur. We return various error code to indicate such errors.


Notes:
    
    Even if errors happen amid the rolling back execution, we will continue. However, we will
    return the first error.

*/

HRESULT 
CTranxManager::ExecMethod (
    IN IWbemServices    * pNamespace,
    IN LPCWSTR            pszMethod,
    IN IWbemContext     * pCtx,
    IN IWbemClassObject * pInParams,
    IN IWbemObjectSink  * pSink
    )
{
    if (pszMethod == NULL || *pszMethod == L'\0')
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    else if (_wcsicmp(pszMethod, g_pszRollback) != 0)   
    {
        //
        // we only support Rollback method
        //

        //
        // $undone:shawnwu, don't check in this code. This is to test
        //


        /*
        if (_wcsicmp(pszMethod, L"ParseXMLFile") == 0)
        {
            if (pInParams == NULL)
            {
                return WBEM_E_INVALID_PARAMETER;
            }

            CComVariant varInput;
            HRESULT hrIgnore = pInParams->Get(L"InputFile", 0, &varInput, NULL, NULL);

            if (SUCCEEDED(hrIgnore) && varInput.vt == VT_BSTR && varInput.bstrVal != NULL)
            {
                CComVariant varOutput;
                hrIgnore = pInParams->Get(L"OutputFile", 0, &varOutput, NULL, NULL);
                
                if (SUCCEEDED(hrIgnore) && varOutput.vt == VT_BSTR && varOutput.bstrVal != NULL)
                {
                    CComVariant varArea;
                    hrIgnore = pInParams->Get(L"Area", 0, &varArea, NULL, NULL);

                    //
                    // allow the section to be empty - meaning all areas.
                    //

                    if (FAILED(hrIgnore) || varArea.vt != VT_BSTR || varArea.bstrVal == NULL)
                    {
                        varArea.Clear();
                        varArea.vt = VT_BSTR;
                        varArea.bstrVal = NULL;
                    }

                    //
                    // get element info we care about
                    //

                    CComVariant varElement;
                    hrIgnore = pInParams->Get(L"Element", 0, &varElement, NULL, NULL);

                    //
                    // allow the element to be empty - meaning every element.
                    //

                    if (FAILED(hrIgnore) || varElement.vt != VT_BSTR || varElement.bstrVal == NULL)
                    {
                        varElement.Clear();
                        varElement.vt = VT_BSTR;
                        varElement.bstrVal = NULL;
                    }

                    CComVariant varSingleArea;
                    hrIgnore = pInParams->Get(L"SingleArea", 0, &varSingleArea, NULL, NULL);

                    bool bSingleArea = false;

                    if (SUCCEEDED(hrIgnore) && varSingleArea.vt == VT_BOOL)
                    {
                        bSingleArea = (varSingleArea.boolVal == VARIANT_TRUE);
                    }

                    return ParseXMLFile(varInput.bstrVal, varOutput.bstrVal, varArea.bstrVal, varElement.bstrVal, bSingleArea);

                }
            }
            return WBEM_E_INVALID_METHOD_PARAMETERS;
        }
        */

        return WBEM_E_NOT_SUPPORTED;
    }
    else if (pInParams == NULL)
    {
        return WBEM_E_INVALID_PARAMETER;
    }

    //
    // we are executing g_pszRollback ("Rollback") method
    //

    //
    // get the in parameters (rollback token and rollback flag)
    //

    CComVariant varToken, varClearAll;

    //
    // if no token, then we will use the GUID_NULL as the token
    //

    HRESULT hr = pInParams->Get(g_pszTokenGuid, 0, &varToken, NULL, NULL);

    //
    // We require the input parameter object to be of good type.
    // We won't tolerate a wrong type of data, either, even though
    // we can live with missing token, though.
    //

    if (FAILED(hr) || SUCCEEDED(hr) && varToken.vt != VT_BSTR)
    {
        return WBEM_E_INVALID_OBJECT;
    }
    else if (SUCCEEDED(hr) && varToken.bstrVal == NULL || *(varToken.bstrVal) == L'\0')
    {
        varToken.Clear();

        varToken = pszRollbackAll;
    }


    //
    // we will allow the flag to be missing. 
    // In that case, it is equivalent to false, meaning not to clear all
    //

    bool bClearAll = false;
    hr = pInParams->Get(g_pszClearAll, 0, &varClearAll, NULL, NULL);
    if (SUCCEEDED(hr) && varClearAll.vt == VT_BOOL)
    {
        bClearAll = (varClearAll.boolVal == VARIANT_TRUE);
    }

    //
    // will return the first error
    //

    HRESULT hrFirstError = WBEM_NO_ERROR;

    //
    // rollback MM filters first
    //

    hr = CIPSecFilter::Rollback(pNamespace, varToken.bstrVal, bClearAll);
    if (FAILED(hr))
    {
        hrFirstError = hr;
    }

    //
    // rollback policies
    //

    hr = CIPSecPolicy::Rollback(pNamespace, varToken.bstrVal, bClearAll);
    if (FAILED(hr) && SUCCEEDED(hrFirstError))
    {
        hrFirstError = hr;
    }

    //
    // rollback main mode authentication
    //

    hr = CAuthMM::Rollback(pNamespace, varToken.bstrVal, bClearAll);

    return FAILED(hrFirstError) ? hrFirstError : hr;
}


/*
Routine Description: 

Name:

    CMMPolicy::ParseXMLFile

Functionality:

    Testing the MSXML parser.

Virtual:
    
    No.

Arguments:

    pszInput    - The input file (XML) name.

    pszOutput   - We will write the parsing result into this output file.

Return Value:

    Success:

        Various success codes indicating the result.

    Failure:

        Various errors may occur. We return various error code to indicate such errors.


Notes:
    
    This is just for testing.



HRESULT 
CTranxManager::ParseXMLFile (
    IN LPCWSTR pszInput, 
    IN LPCWSTR pszOutput,
    IN LPCWSTR pszArea,
    IN LPCWSTR pszElement,
    IN bool    bSingleArea
    )
{
    CComPtr<ISAXXMLReader> srpRdr;

    HRESULT hr = ::CoCreateInstance(
								CLSID_SAXXMLReader, 
								NULL, 
								CLSCTX_ALL, 
								IID_ISAXXMLReader, 
								(void **)&srpRdr);

	if (SUCCEEDED(hr)) 
    {
		CComObject<CXMLContent> * pXMLContent;
        hr = CComObject<CXMLContent>::CreateInstance(&pXMLContent);

        if (SUCCEEDED(hr))
        {
            CComPtr<ISAXContentHandler> srpHandler;
            pXMLContent->AddRef();

            if (S_OK == pXMLContent->QueryInterface(IID_ISAXContentHandler, (void**)&srpHandler))
            {
		        hr = srpRdr->putContentHandler(srpHandler);
            }
            else
            {
                hr = WBEM_E_NOT_SUPPORTED;
            }

            if (SUCCEEDED(hr))
            {
                pXMLContent->SetOutputFile(pszOutput);
                pXMLContent->SetSection(pszArea, pszElement, bSingleArea);
            }

            pXMLContent->Release();

            //
            // CXMLErrorHandler * pEH;
            // hr = srpRdr->putErrorHandler(pDH);
		    // CXMLDTDHandler * pDH;
		    // hr = srpRdr->putDTDHandler(pDH);
            //
		    
		    if (SUCCEEDED(hr))
            {
                hr = srpRdr->parseURL(pszInput);

                //
                // we allow parseURL to fail because we may stop processing
                // in the middle of parsing XML.
                //

                if (FAILED(hr) && pXMLContent->ParseComplete())
                {
                    hr = WBEM_S_FALSE;
                }
            }
        }
	}

    return SUCCEEDED(hr) ? WBEM_NO_ERROR : hr;
}


*/



/*


//----------------------------------------------------------------------------------
// Implementation for CFileStream
//----------------------------------------------------------------------------------

bool 
CFileStream::Open (
    IN LPCWSTR  pszName, 
    IN bool     bRead = true
    )
{
    this->m_bRead = bRead;
    long len;

    if (pszName == NULL)
    {
        m_hFile = GetStdHandle(STD_INPUT_HANDLE);
    }
    else
    { 
        if (bRead)
        {
		    m_hFile = ::CreateFile( 
                                   pszName,
			                       GENERIC_READ,
			                       FILE_SHARE_READ,
			                       NULL,
			                       OPEN_EXISTING,
			                       FILE_ATTRIBUTE_NORMAL,
			                       NULL
                                  );
        }
        else
        {
		    m_hFile = ::CreateFile(
			                       pszName,
			                       GENERIC_WRITE,
			                       FILE_SHARE_READ,
			                       NULL,
			                       CREATE_ALWAYS,
			                       FILE_ATTRIBUTE_NORMAL,
			                       NULL
                                  );
        }
    }
    return (m_hFile == INVALID_HANDLE_VALUE) ? false : true;
}

HRESULT 
CFileStream::Read ( 
    OUT void  * pv,
    IN  ULONG   cb,
    OUT ULONG * pcbRead
    )
{	
    if (!read) 
    {
        return E_FAIL;
    }

    DWORD len = 0;

	BOOL rc = ReadFile(
			           m_hFile,	// handle of file to read 
			           pv,	    // address of buffer that receives data  
			           cb,	    // number of bytes to read 
			           &len,	// address of number of bytes read 
			           NULL 	// address of structure for data 
		              );

    *pcbRead = len;

    if (*pcbRead == 0) 
    {
        return S_FALSE;
    }

	return (rc) ? S_OK : E_FAIL;
}
    
HRESULT 
CFileStream::Write ( 
    IN  const void * pv,
    IN  ULONG        cb,
    OUT ULONG      * pcbWritten
    )
{
    if (read) 
    {
        return E_FAIL;
    }

	BOOL rc = WriteFile(
			            m_hFile,	// handle of file to write 
			            pv,	        // address of buffer that contains data  
			            cb,	        // number of bytes to write 
			            pcbWritten,	// address of number of bytes written 
			            NULL 	    // address of structure for overlapped I/O  
		               );

	return (rc) ? S_OK : E_FAIL;
}
*/