/*

* 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:  

* Switches

* System Includes

*

*/

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <signal.h>

#include <sys/socket.h>

#include <sys/ioctl.h>

#include <net/if.h>

#include <assert.h>

#include <string.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <ctype.h>

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

 *

 * Local Includes

 *

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

#include "CInterfaceAlias.h"

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

 *

 * Macro Functions

 *

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

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

 *

 * Definitions

 *

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

#define MAXALIASNAME                  64

#define MAXALIASCOUNT                 1024

#define MAXINTERFACECOUNT             1024

#define ETHERNET_INTERFACE_PREFIX     "eth"

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

 *

 * IMPLEMENTATION: CInterfaceAlias

 *

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

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

 *

 * PUBLIC: CInterfaceAlias

 *

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

CInterfaceAlias::CInterfaceAlias()

{

  iState = IAS_INIT;

  iBaseInterfaceIndex = 0;

  iAliasIndex = 0;

}

CInterfaceAlias::~CInterfaceAlias()

{

  assert( iState != IAS_UP );

}

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

 *

 * PUBLIC: CreateNewInterfaceAlias

 *

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

TInterfaceAliasError CInterfaceAlias::CreateNewInterfaceAlias( int aBaseInterfaceIndex, int aNetMask, int aHostAddress, int *aAliasIndex, int *aErrorCode )

{

  int alias_index;

  char alias_name_temp[MAXALIASNAME];

  int sockfd;

  int err;

  struct sockaddr_in base_interface_addr;

  struct ifreq ifr;

  struct sockaddr_in *saddr;

  TInterfaceAliasError rv;

  // check the state

  if( iState != IAS_INIT ) {

    return IE_INVALID_STATE;

  }

  // check the params

  assert( aAliasIndex != NULL );

  assert( aErrorCode != NULL );

  *aErrorCode = 0;

  *aAliasIndex = -1;

  if( aBaseInterfaceIndex < 0 ) {

    return IE_INVALID_PARAM;

  }

  // get a free alias index

  rv = GetFreeAliasIndex( aBaseInterfaceIndex, &alias_index, aErrorCode );

  if( rv != IE_NONE ) {

    return rv;

  }

  // get the address of the base interface

  rv = GetBaseInterfaceAddress( aBaseInterfaceIndex, &base_interface_addr, aErrorCode );

  if( rv != IE_NONE ) {

    return rv;

  }

  // now strip off the host part and replace with the passed host address

  base_interface_addr.sin_addr.s_addr = ChangeHostAddress( base_interface_addr.sin_addr.s_addr, aNetMask, aHostAddress ); 

  // setup the interface name

  sprintf( alias_name_temp, "eth%d:%d", aBaseInterfaceIndex, alias_index );

  assert( (strlen(alias_name_temp) + 1) < IFNAMSIZ );

  // create a socket to make ioctl calls on

  sockfd = socket( AF_INET, SOCK_DGRAM, 0 );

  if( sockfd <= 0 ) {

    *aErrorCode = errno;

    return IE_SOCKET_FAILED;

  }

  // setup the request

  memcpy( ifr.ifr_name, alias_name_temp, strlen(alias_name_temp) + 1 );

  saddr = (struct sockaddr_in*)(&(ifr.ifr_addr));

  saddr->sin_family = AF_INET;

  saddr->sin_port = 0;

  saddr->sin_addr = base_interface_addr.sin_addr;

  // make the ioctl call

  err = ioctl( sockfd, SIOCSIFADDR, &ifr );

  close( sockfd );

  if( err == -1 ) {

    *aErrorCode = errno;

    return IE_IOCTL_FAILED;

  }

  // update the state vars

  iState = IAS_UP;

  iBaseInterfaceIndex = aBaseInterfaceIndex;

  *aAliasIndex = iAliasIndex = alias_index;

  iInterfaceName = alias_name_temp;

  iInterfaceAddress = inet_ntoa( base_interface_addr.sin_addr );

  // done

  return IE_NONE;

}

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

 *

 * PUBLIC:  DestroyInterfaceAlias

 *

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

TInterfaceAliasError CInterfaceAlias::DestroyInterfaceAlias( int *aErrorCode )

{

  int sockfd;

  int err;

  struct ifreq ifr;

  char ifn[64];

  // check state

  if( iState != IAS_UP ) {

    return IE_INVALID_STATE;

  }

  // check params

  assert( aErrorCode != NULL );

  *aErrorCode = 0;

  // create a socket to make ioctl calls on

  sockfd = socket( AF_INET, SOCK_DGRAM, 0 );

  assert( sockfd >= 0 );

  // setup the request record

  sprintf( ifn, "eth%d:%d", iBaseInterfaceIndex, iAliasIndex );

  memcpy( ifr.ifr_name, ifn, strlen(ifn) + 1 );

  ifr.ifr_flags = 0;

  // get the current flags - this is very important since most flags actually go straight through to

  // base interface - so we need to keep this and just clear the IFF_UP flag which is local to the alias

  err = ioctl( sockfd, SIOCGIFFLAGS, &ifr );

  if( err == -1 ) {

    iState = IAS_DOWN;

    *aErrorCode = errno;

    close( sockfd );

    return IE_IOCTL_FAILED;

  }

  // mask out the IFF_UP flag

  ifr.ifr_flags &= ~IFF_UP; 

  // make the ioctl calls 

  err = ioctl( sockfd, SIOCSIFFLAGS, &ifr );

  close( sockfd );

  if( err == -1 ) {

    iState = IAS_DOWN;

    *aErrorCode = errno;

    return IE_IOCTL_FAILED;

  }

  // otherwise done

  iState = IAS_DOWN;

  return IE_NONE;

}

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

 *

 * PUBLIC:  GetInterfaceIndex

 *

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

TInterfaceAliasError CInterfaceAlias::GetInterfaceIndex( int *aBaseInterfaceIndex, int *aAliasIndex )

{

  // check params

  assert( aBaseInterfaceIndex != NULL );

  assert( aAliasIndex != NULL );

  // check state

  if( iState == IAS_INIT ) {

    return IE_INVALID_STATE;

  }

  // return info

  *aBaseInterfaceIndex = iBaseInterfaceIndex;

  *aAliasIndex = iAliasIndex;

  return IE_NONE;

}

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

 *

 * PUBLIC:  GetInterfaceName

 *

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

TInterfaceAliasError CInterfaceAlias::GetInterfaceName( string *aInterfaceName )

{

  assert( aInterfaceName != NULL );

  if( iState == IAS_INIT ) {

    return IE_INVALID_STATE;

  }

  *aInterfaceName = iInterfaceName;

  return IE_NONE;

}

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

 *

 * PUBLIC:  GetInterfaceAddress

 *

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

TInterfaceAliasError CInterfaceAlias::GetInterfaceAddress( string *aInterfaceAddress )

{

  assert( aInterfaceAddress != NULL );

  if( iState == IAS_INIT ) {

    return IE_INVALID_STATE;

  }

  *aInterfaceAddress = iInterfaceAddress;

  return IE_NONE;

}

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

 *

 * PRIVATE: ParseInterfaceName

 *

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

int CInterfaceAlias::ParseInterfaceName( char *aInterfaceName, int *aBaseIndex, int *aAliasIndex )

{

  int rv;

  // check params

  assert( aInterfaceName != NULL );

  assert( aBaseIndex != NULL );

  assert( aAliasIndex != NULL );

  // init params

  *aBaseIndex = *aAliasIndex = -1;

  // do the scanf

  rv = sscanf( aInterfaceName, "eth%d:%d", aBaseIndex, aAliasIndex );

  // return valid if at least a base index was read

  if( rv >= 1 ) {

    return 1;

  }

  return 0;

}

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

 *

 * PRIVATE: GetInterfaceList

 *

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

TInterfaceAliasError CInterfaceAlias::GetInterfaceList( char *aInterfaceBuffer, int aInputBufferLength, int *aOutputBufferLength, int *aErrorCode )

{

  int sockfd;

  int err;

  struct ifconf ifc;

  // check params

  assert( aInterfaceBuffer != NULL );

  assert( aOutputBufferLength != NULL );

  assert( aErrorCode != NULL );

  // set the params

  *aOutputBufferLength = *aErrorCode = 0;

  // create a socket to make ioctl calls on

  sockfd = socket( AF_INET, SOCK_DGRAM, 0 );

  if( sockfd <= 0 ) {

    *aErrorCode = errno;

    return IE_SOCKET_FAILED;

  }

  // do the ioctl() call to retrieve all the interfaces

  ifc.ifc_len = aInputBufferLength;

  ifc.ifc_buf = aInterfaceBuffer;

  err = ioctl( sockfd, SIOCGIFCONF, &ifc );

  close( sockfd );

  if( err == -1 ) {

    *aErrorCode = errno;

    return IE_IOCTL_FAILED;

  }

  // call was successful, set the output buffer length

  *aOutputBufferLength = ifc.ifc_len;

  // done

  return IE_NONE;

}

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

 *

 * PRIVATE: GetFreeAliasIndex

 *

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

TInterfaceAliasError CInterfaceAlias::GetFreeAliasIndex( int aBaseInterfaceIndex, int *aAliasIndex, int *aErrorCode )

{

  TInterfaceAliasError rv;

  struct ifreq ifr[MAXINTERFACECOUNT];  

  char alias_status[MAXALIASCOUNT];

  int is_valid, base_index, alias_index, interface_count, i;

  int base_index_found = 0;

  int current_alias_count = 0;

  // check and set params

  assert( aAliasIndex != NULL );

  assert( aErrorCode != NULL );

  *aAliasIndex = 0;

  *aErrorCode = 0;

  // clear the arrays

  memset( alias_status, 0, sizeof(alias_status) );

  // get the interface list

  rv = GetInterfaceList( (char*)ifr, sizeof(ifr), &interface_count, aErrorCode );

  if( rv != IE_NONE ) {

    return rv;

  }

  interface_count = interface_count / sizeof(struct ifreq);

  // for each interface entry...

  for( i = 0; i < interface_count; i++ ) {

    // parse the name of the interface

    is_valid = ParseInterfaceName( (ifr[i]).ifr_name, &base_index, &alias_index );

    // process the interface

    if( (is_valid) && (base_index == aBaseInterfaceIndex) ) {

      base_index_found = 1;

      if( alias_index >= 0 ) {

	assert( alias_index < MAXALIASCOUNT );

	alias_status[alias_index] = 1;

	current_alias_count++;

      }

    }

  }

  // see if there are any free aliases

  if( current_alias_count == MAXALIASCOUNT ) {

    return IE_NO_FREE_ALIAS;

  }

  // otherwise return the first free alias

  for( i = 0; i < MAXALIASCOUNT; i++ ) {

    if( alias_status[i] == 0 )

      break;

  }

  assert( i < MAXALIASCOUNT );

  // done

  *aAliasIndex = i;

  return IE_NONE;

}

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

 *

 * PRIVATE: GetBaseInterfaceAddress

 *

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

TInterfaceAliasError CInterfaceAlias::GetBaseInterfaceAddress( int aBaseInterfaceIndex, struct sockaddr_in *aInterfaceAddress, int *aErrorCode )

{

  int sockfd, err;

  struct ifreq ifr;

  // check args

  assert( aInterfaceAddress != NULL );

  assert( aErrorCode != NULL );

  *aErrorCode = 0;

  // create the interface name

  memset( &ifr, 0, sizeof(ifr) );

  snprintf( ifr.ifr_name, IFNAMSIZ, "eth%d", aBaseInterfaceIndex );

  // create a socket to make the ioctl calls on

  sockfd = socket( AF_INET, SOCK_DGRAM, 0 );

  if( sockfd <= 0 ) {

    *aErrorCode = errno;

    return IE_SOCKET_FAILED;

  }

  // make the ioctl call

  err = ioctl( sockfd, SIOCGIFADDR, &ifr );

  close( sockfd );

  if( err == -1 ) {

    *aErrorCode = errno;

    return IE_IOCTL_FAILED;

  }

  // save the address

  *aInterfaceAddress = *((struct sockaddr_in*)(&ifr.ifr_addr));

  // done

  return IE_NONE;

}

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

 *

 * PRIVATE: ChangeHostAddress

 *

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

int CInterfaceAlias::ChangeHostAddress( int aBaseAddress, int aNetMask, int aHostAddress )

{

  int hostmask = 0;

  int netmask = 0;

  int rv;

  // create masks for the netpart and the hostpart

  netmask = NetmaskFromBitcount( aNetMask );

  hostmask = ~netmask;

  // now create the address

  rv = ntohl( aBaseAddress );

  rv &= netmask;

  rv |= (aHostAddress & hostmask);

  rv = htonl( rv );

  return rv;

}

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

 *

 * PRIVATE: NetmaskFromBitcount

 *

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

int CInterfaceAlias::NetmaskFromBitcount( int aBitCount )

{

  int i, netmask = 0;

  for( netmask = 0, i = 0; i < aBitCount; i++ ) {

    netmask |= 1<<(31-i);

  }

  return netmask;

}