/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Class representing a server that uses addr2line.exe.
*
*/

#include "../inc/cataddr2lineserver.h"
#include "../inc/CATBase.h"

// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
CATAddr2lineServer::CATAddr2lineServer()
{
	LOG_FUNC_ENTRY("CATAddr2lineServer::CATAddr2lineServer");
	m_bProcessCreated = false;

	// Pipe handles.
	m_hChildErroutRd = 0;
	m_hChildErroutRdDup = 0;
	m_hChildErroutWr = 0;
	m_hChildStdinRd = 0;
	m_hChildStdinWr = 0;
	m_hChildStdinWrDup = 0;
	m_hChildStdoutRd = 0;
	m_hChildStdoutWr = 0;
	m_hChildStdoutRdDup = 0;
	
	m_hSaveErrout = 0;
	m_hSaveStdin = 0;
	m_hSaveStdout = 0;

    // Set the bInheritHandle flag so pipe handles are inherited.
    m_saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    m_saAttr.bInheritHandle = TRUE;
    m_saAttr.lpSecurityDescriptor = NULL;

	// Symbol file.
	m_sFullPathAndBinaryName = "";
}
// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
CATAddr2lineServer::~CATAddr2lineServer()
{
	LOG_FUNC_ENTRY("CATAddr2lineServer::~CATAddr2lineServer");
	// Close the pipe handle so the child process stops reading.
    CloseHandle(m_hChildStdinWrDup);
    // Close the write end of the pipe
    CloseHandle(m_hChildStdoutWr);
    // Close the write end of the error pipe
	CloseHandle(m_hChildErroutWr);
}
bool CATAddr2lineServer::Initialize( const string& sFullPathAndBinaryName )
{
    LOG_FUNC_ENTRY("CATAddr2lineServer::Initialize");
	BOOL fSuccess;
	m_sFullPathAndBinaryName = sFullPathAndBinaryName;

    // The steps for redirecting child process's STDOUT:
    //     1. Save current STDOUT, to be restored later.
    //     2. Create anonymous pipe to be STDOUT for child process.
    //     3. Set STDOUT of the parent process to be write handle to
    //        the pipe, so it is inherited by the child process.
    //     4. Create a noninheritable duplicate of the read handle and
    //        close the inheritable read handle.
 
    // Save the handle to the current STDOUT. 
    m_hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE); 

    // Create a pipe for the child process's STDOUT.
    if (! CreatePipe(&m_hChildStdoutRd, &m_hChildStdoutWr, &m_saAttr, 0))
		return PrintErrorAndExit( "Stdout pipe creation failed\n" );

    // Set a write handle to the pipe to be STDOUT.
   if (! SetStdHandle(STD_OUTPUT_HANDLE, m_hChildStdoutWr))
		return PrintErrorAndExit( "Redirecting STDOUT failed\n" );

    // Create noninheritable read handle and close the inheritable read
    // handle.
    fSuccess = DuplicateHandle(GetCurrentProcess(), m_hChildStdoutRd,
        GetCurrentProcess(), &m_hChildStdoutRdDup , 0,
        FALSE,
        DUPLICATE_SAME_ACCESS);
    if( !fSuccess )
		return PrintErrorAndExit( "DuplicateHandle failed" );
    CloseHandle(m_hChildStdoutRd);

    // The steps for redirecting child process's STDIN:
    //     1.  Save current STDIN, to be restored later.
    //     2.  Create anonymous pipe to be STDIN for child process.
    //     3.  Set STDIN of the parent to be the read handle to the
    //         pipe, so it is inherited by the child process.
    //     4.  Create a noninheritable duplicate of the write handle,
    //         and close the inheritable write handle.
 
    // Save the handle to the current STDIN.
    m_hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);

    // Create a pipe for the child process's STDIN.
    if (! CreatePipe(&m_hChildStdinRd, &m_hChildStdinWr, &m_saAttr, 0))
		return PrintErrorAndExit( "Stdin pipe creation failed\n" );
 
    // Set a read handle to the pipe to be STDIN. 
    if (! SetStdHandle(STD_INPUT_HANDLE, m_hChildStdinRd)) 
		return PrintErrorAndExit( "Redirecting Stdin failed\n" ); 
 
    // Duplicate the write handle to the pipe so it is not inherited. 
	
    fSuccess = DuplicateHandle(GetCurrentProcess(), m_hChildStdinWr, 
        GetCurrentProcess(), &m_hChildStdinWrDup, 0, 
        FALSE,                  // not inherited 
        DUPLICATE_SAME_ACCESS); 
    if (! fSuccess) 
		return PrintErrorAndExit( "DuplicateHandle failed\n" );

    CloseHandle(m_hChildStdinWr);
 
    // The steps for redirecting child process's ERROUT:
    //     1. Save current STDOUT, to be restored later.
    //     2. Create anonymous pipe to be STDOUT for child process.
    //     3. Set STDOUT of the parent process to be write handle to
    //        the pipe, so it is inherited by the child process.
    //     4. Create a noninheritable duplicate of the read handle and
    //        close the inheritable read handle.
 
    // Save the handle to the current STDOUT. 
    m_hSaveErrout = GetStdHandle( STD_ERROR_HANDLE ); 

    // Create a pipe for the child process's ERROUT.
    if (! CreatePipe(&m_hChildErroutRd, &m_hChildErroutWr, &m_saAttr, 0))
		return PrintErrorAndExit( "Errout pipe creation failed\n" );

    // Set a write handle to the pipe to be ERROUT.
   if (! SetStdHandle(STD_ERROR_HANDLE, m_hChildErroutWr))
		return PrintErrorAndExit( "Redirecting ERROUT failed\n" );

    // Create noninheritable read handle and close the inheritable read
    // handle.
   
    fSuccess = DuplicateHandle(GetCurrentProcess(), m_hChildErroutRd,
        GetCurrentProcess(), &m_hChildErroutRdDup , 0,
        FALSE,
        DUPLICATE_SAME_ACCESS);
    if( !fSuccess )
		return PrintErrorAndExit( "DuplicateHandle failed" );
    
	CloseHandle(m_hChildErroutRd);
	CloseHandle(m_hChildErroutRdDup);
	
	// Now create the child process. 
    fSuccess = CreateChildProcess();
    if (!fSuccess )
		return PrintErrorAndExit( "Create process failed\n" );
 
    // After process creation, restore the saved STDIN and STDOUT.
	if (! SetStdHandle(STD_INPUT_HANDLE, m_hSaveStdin))
        return PrintErrorAndExit( "Re-redirecting Stdin failed\n" );

	if (! SetStdHandle(STD_OUTPUT_HANDLE, m_hSaveStdout))
       return PrintErrorAndExit( "Re-redirecting Stdout failed\n" );

	if (! SetStdHandle(STD_ERROR_HANDLE, m_hSaveErrout))
       return PrintErrorAndExit( "Re-redirecting Stderrout failed\n" );

	m_bProcessCreated = true;
    return true;
}
BOOL CATAddr2lineServer::CreateChildProcess() 
{ 
    LOG_FUNC_ENTRY("CATAddr2lineServer::CreateChildProcess");
    PROCESS_INFORMATION piProcInfo; 
    STARTUPINFO siStartInfo;
    BOOL bFuncRetn = FALSE; 
 
    // Set up members of the PROCESS_INFORMATION structure.
    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
 
	// Set up members of the STARTUPINFO structure.
    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
    siStartInfo.cb = sizeof(STARTUPINFO); 
 
	//atool.exe:s path + filename
	char buffer[MAX_PATH];

	GetModuleFileName( NULL, buffer, MAX_PATH );

	string sCommand( buffer );

	//Remove 'atool.exe'
	size_t tPos = sCommand.rfind( "\\" );
	if ( tPos != string::npos )
		sCommand.resize( sCommand.rfind( "\\" )+1 );
	else
		sCommand.clear();

	sCommand.append( "addr2line.exe" );

	//addr2line file exists
	if( !CATBase::FileExists( sCommand.c_str() ) )
		return PrintErrorAndExit( "File not found addr2line.exe\n" );

	//Sym file exists
	if( !CATBase::FileExists( m_sFullPathAndBinaryName.c_str() ) )
	{
		string sTemp( "File not found " );
		sTemp.append( m_sFullPathAndBinaryName );
		sTemp.append( "\n" );
		return PrintErrorAndExit( sTemp );
	}

	sCommand.append(" -f -C -e ");
	sCommand.append( m_sFullPathAndBinaryName );

	// Create the child process. 
    bFuncRetn = CreateProcess(NULL,
		(LPSTR)sCommand.c_str(), // command line
        NULL,          // process security attributes
        NULL,          // primary thread security attributes
        TRUE,          // handles are inherited
        0,             // creation flags
        NULL,          // use parent's environment
        NULL,          // use parent's current directory
        &siStartInfo,  // STARTUPINFO pointer
        &piProcInfo);  // receives PROCESS_INFORMATION

    if (bFuncRetn == 0)
    {
       //CreateProcess failed
       return false;
    }
    else
    {
       CloseHandle(piProcInfo.hProcess);
       CloseHandle(piProcInfo.hThread);
       return bFuncRetn;
    }
}
VOID CATAddr2lineServer::WriteToPipe( const string& sAddress ) 
{ 
	LOG_LOW_FUNC_ENTRY("CATAddr2lineServer::WriteToPipe");
    DWORD dwRead, dwWritten;
    CHAR chBuf[2]; //This is for enter key

    //Write data to a pipe. 
    dwRead = (DWORD)sAddress.length();
	WriteFile(m_hChildStdinWrDup, sAddress.c_str(), dwRead, &dwWritten, NULL);

	chBuf[0] = 0x0A; //Enter
	chBuf[1] = 0; //NULL
	//Write enter key to a pipe
	WriteFile(m_hChildStdinWrDup, chBuf, 1, &dwWritten, NULL);
} 
string CATAddr2lineServer::ReadFromPipe(VOID) 
{
	LOG_LOW_FUNC_ENTRY("CATAddr2lineServer::ReadFromPipe");
	string s;
	DWORD dwRead;
    CHAR chBuf[BUFSIZE];
    // Read output from the child process, and save data to string.
    ReadFile( m_hChildStdoutRdDup, chBuf, BUFSIZE, &dwRead, NULL);
	s.append( chBuf );
    return s;
}
bool CATAddr2lineServer::GetProcessCreatedState( void )
{
	LOG_LOW_FUNC_ENTRY("CATAddr2lineServer::GetProcessCreatedState");
	return m_bProcessCreated;
}
bool CATAddr2lineServer::PrintErrorAndExit( const string sInput )
{
	LOG_FUNC_ENTRY("CATAddr2lineServer::PrintErrorAndExit");
	cout << AT_MSG << sInput;
	return false;
}