/*

* Copyright (c) 2005-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:   

* System Includes

*

*/

#include <stdio.h>

#include <assert.h>

#include <rpc/types.h>

/****************************************************************************************

 * 

 * Local Includes

 * 

 ***************************************************************************************/

#include "CCHostexecuteasync.h"

/****************************************************************************************

 * 

 * Implementation

 * 

 ***************************************************************************************/

CCHostexecuteasync::CCHostexecuteasync()

{

	cl = NULL;

	iLastRPCError.re_status = RPC_SUCCESS;

}

CCHostexecuteasync::~CCHostexecuteasync()

{

	assert( cl == NULL );

}

char *CCHostexecuteasync::GetLastRPCError( int *aIntErr )

{

	struct rpc_err rpcerr;

	// check that the handle is valid

	if( cl == NULL ) {

		return NULL;

	}

	// pass the aIntErr

	if( aIntErr != NULL ) {

		clnt_geterr( cl, &rpcerr );

		*aIntErr = rpcerr.re_status;

	}

	// return the errorstring

	return clnt_sperror( cl, NULL );

}

int CCHostexecuteasync::Connect( string aRemoteHost )

{

	// check that we are not already connected

	if( cl != NULL ) {

		return ERR_STUB_ALREADY_CONNECTED;

	}

	// start the rpc library

	rpc_nt_init();

	// connect to the service

	cl = clnt_create( aRemoteHost.c_str(), HOSTEXECUTEASYNC, HOSTEXECUTEASYNC_VERSION, "tcp" );

	if( cl == NULL ) {

		rpc_nt_exit();

		return ERR_FAILED_TO_CONNECT;

	}

	// done

	return ERR_NONE;

}

int CCHostexecuteasync::Disconnect( )

{

	// check that we are connected

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// cleanup the client handle

	clnt_destroy( cl );

	cl = NULL;

	rpc_nt_exit();

	// done

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: ss_startuprpcservice

 * 

 ***************************************************************************************/

int CCHostexecuteasync::ss_startuprpcservice( TStartupInfo aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *ss_startuprpcservice_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: sc_shutdownrpcservice

 * 

 ***************************************************************************************/

int CCHostexecuteasync::sc_shutdownrpcservice( int aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *sc_shutdownrpcservice_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: list_devices

 * 

 ***************************************************************************************/

int CCHostexecuteasync::list_devices( TComponentList *rv )

{

	struct rpc_err rerr;

	int aArgs = 0;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *list_devices_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: cstr_startprocess

 * 

 ***************************************************************************************/

int CCHostexecuteasync::cstr_startprocess( char *aArgs, TResult *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *cstr_startprocess_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: dstr_removeprocess

 * 

 ***************************************************************************************/

int CCHostexecuteasync::dstr_removeprocess( int aArgs, TResult *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *dstr_removeprocess_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: killprocess

 * 

 ***************************************************************************************/

int CCHostexecuteasync::killprocess( int aArgs, TResult *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *killprocess_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: stopprocess

 * 

 ***************************************************************************************/

int CCHostexecuteasync::stopprocess( int aArgs, TResult *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *stopprocess_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: getprocessinfo

 * 

 ***************************************************************************************/

int CCHostexecuteasync::getprocessinfo( int aArgs, THostExecuteAsyncProcessInfo *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *getprocessinfo_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: getstandardoutput

 * 

 ***************************************************************************************/

int CCHostexecuteasync::getstandardoutput( int aArgs, TVarData *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *getstandardoutput_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: getstandarderror

 * 

 ***************************************************************************************/

int CCHostexecuteasync::getstandarderror( int aArgs, TVarData *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *getstandarderror_9( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}