/*

* 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 "CCMncontroller.h"

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

 * 

 * Implementation

 * 

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

CCMncontroller::CCMncontroller()

{

	cl = NULL;

	iLastRPCError.re_status = RPC_SUCCESS;

}

CCMncontroller::~CCMncontroller()

{

	assert( cl == NULL );

}

char *CCMncontroller::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 CCMncontroller::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(), MNCONTROLLER, MNCONTROLLER_VERSION, "tcp" );

	if( cl == NULL ) {

		rpc_nt_exit();

		return ERR_FAILED_TO_CONNECT;

	}

	// done

	return ERR_NONE;

}

int CCMncontroller::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 CCMncontroller::ss_startuprpcservice( int *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 = *ss_startuprpcservice_5( &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 CCMncontroller::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_5( &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 CCMncontroller::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_5( &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_createagent

 * 

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

int CCMncontroller::cstr_createagent( TResult *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 = *cstr_createagent_5( &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_removeagent

 * 

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

int CCMncontroller::dstr_removeagent( 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 = *dstr_removeagent_5( &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: startmobileagent

 * 

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

int CCMncontroller::startmobileagent( 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 = *startmobileagent_5( &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: stopmobileagent

 * 

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

int CCMncontroller::stopmobileagent( 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 = *stopmobileagent_5( &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: getmobileagentstatus

 * 

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

int CCMncontroller::getmobileagentstatus( 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 = *getmobileagentstatus_5( &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: setsingleoption

 * 

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

int CCMncontroller::setsingleoption( TOptionDesc 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 = *setsingleoption_5( &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: removesingleoption

 * 

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

int CCMncontroller::removesingleoption( TOptionDesc 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 = *removesingleoption_5( &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: addlistoption

 * 

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

int CCMncontroller::addlistoption( TOptionDesc 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 = *addlistoption_5( &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: removelistoption

 * 

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

int CCMncontroller::removelistoption( TOptionDesc 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 = *removelistoption_5( &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: sethomeaddress

 * 

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

int CCMncontroller::sethomeaddress( THomeAddressDesc 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 = *sethomeaddress_5( &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: getcareofaddress