Logo Search packages:      
Sourcecode: ike version File versions  Download package

libike.cpp

/*
 * Copyright (c) 2007
 *      Shrew Soft Inc.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Redistributions in any form must be accompanied by information on
 *    how to obtain complete source code for the software and any
 *    accompanying software that uses the software.  The source code
 *    must either be included in the distribution or be available for no
 *    more than the cost of distribution plus a nominal fee, and must be
 *    freely redistributable under reasonable conditions.  For an
 *    executable file, complete source code means the source code for all
 *    modules it contains.  It does not include source code for modules or
 *    files that typically accompany the major components of the operating
 *    system on which the executable file runs.
 *
 * THIS SOFTWARE IS PROVIDED BY SHREW SOFT INC ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
 * NON-INFRINGEMENT, ARE DISCLAIMED.  IN NO EVENT SHALL SHREW SOFT INC
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 *
 * AUTHOR : Matthew Grooms
 *          mgrooms@shrew.net
 *
 */

#include "libike.h"

void _IKEI_MSG::init( long type )
{
      del();
      header.type = type;
}

long _IKEI_MSG::get_basic( long * value, BDATA * bdata )
{
      IKEI_BASIC basic;
      if( !get( &basic, sizeof( basic ) ) )
            return IPCERR_FAILED;

      if( value != NULL )
            *value = basic.value;

      if( bdata != NULL )
            if( !get( *bdata, basic.bsize ) )
                  return IPCERR_FAILED;

      return IPCERR_OK;
}

long _IKEI_MSG::set_basic( long value, BDATA * bdata )
{
      IKEI_BASIC basic;
      basic.value = value;

      if( bdata != NULL )
            basic.bsize = bdata->size();
      else
            basic.bsize = 0;

      if( !add( &basic, sizeof( basic ) ) )
            return IPCERR_FAILED;

      if( bdata != NULL )
            if( !add( *bdata ) )
                  return IPCERR_FAILED;

      return IPCERR_OK;
}

long _IKEI_MSG::get_struct( long * value, void * sdata, size_t ssize )
{
      IKEI_BASIC basic;
      if( !get( &basic, sizeof( basic ) ) )
            return IPCERR_FAILED;

      if( value != NULL )
            *value = basic.value;

      if( sdata != NULL )
            if( !get( sdata, ssize ) )
                  return IPCERR_FAILED;

      return IPCERR_OK;
}

long _IKEI_MSG::set_struct( long value, void * sdata, size_t ssize )
{
      IKEI_BASIC basic;
      basic.value = value;

      if( sdata != NULL )
            basic.bsize = ssize;
      else
            basic.bsize = 0;

      if( !add( &basic, sizeof( basic ) ) )
            return IPCERR_FAILED;

      if( sdata != NULL )
            if( !add( sdata, ssize ) )
                  return IPCERR_FAILED;

      return IPCERR_OK;
}

long _IKEI_MSG::get_result( long * msgres )
{
      return get_basic( msgres );
}

long _IKEI_MSG::set_result( long msgres )
{
      init( IKEI_MSGID_RESULT );
      return set_basic( msgres );
}

long _IKEI_MSG::get_status( long * status, BDATA * str )
{
      return get_basic( status, str );
}

long _IKEI_MSG::set_status( long status, BDATA * str )
{
      init( IKEI_MSGID_STATUS );
      return set_basic( status, str );
}

long _IKEI_MSG::set_status( long status, char * str )
{
      BDATA text;
      text.set( str, strlen( str ) + 1 );

      return set_status( status, &text );
}

long _IKEI_MSG::get_stats( IKEI_STATS * stats )
{
      return get_struct( 0, stats, sizeof( IKEI_STATS ) );
}

long _IKEI_MSG::set_stats( IKEI_STATS * stats )
{
      init( IKEI_MSGID_STATS );
      return set_struct( 0, stats, sizeof( IKEI_STATS ) );
}

long _IKEI_MSG::get_enable( long * enable )
{
      return get_basic( enable );
}

long _IKEI_MSG::set_enable( long enable )
{
      init( IKEI_MSGID_ENABLE );
      return set_basic( enable );
}

long _IKEI_MSG::get_peer( IKE_PEER * peer )
{
      return get_struct( 0, peer, sizeof( IKE_PEER ) );
}

long _IKEI_MSG::set_peer( IKE_PEER * peer )
{
      init( IKEI_MSGID_PEER );
      return set_struct( 0, peer, sizeof( IKE_PEER ) );
}

long _IKEI_MSG::get_proposal( IKE_PROPOSAL * proposal )
{
      return get_struct( 0, proposal, sizeof( IKE_PROPOSAL ) );
}

long _IKEI_MSG::set_proposal( IKE_PROPOSAL * proposal )
{
      init( IKEI_MSGID_PROPOSAL );
      return set_struct( 0, proposal, sizeof( IKE_PROPOSAL ) );
}

long _IKEI_MSG::get_client( IKE_XCONF * xconf )
{
      return get_struct( 0, xconf, sizeof( IKE_XCONF ) );
}

long _IKEI_MSG::set_client( IKE_XCONF * xconf )
{
      init( IKEI_MSGID_CLIENT );
      return set_struct( 0, xconf, sizeof( IKE_XCONF ) );
}

long _IKEI_MSG::get_network( long * type, IKE_PH2ID * ph2id )
{
      return get_struct( type, ph2id, sizeof( IKE_PH2ID ) );
}

long _IKEI_MSG::set_network( long type, IKE_PH2ID * ph2id )
{
      init( IKEI_MSGID_NETWORK );
      return set_struct( type, ph2id, sizeof( IKE_PH2ID ) );
}

long _IKEI_MSG::get_cfgstr( long * type, BDATA * str )
{
      return get_basic( type, str );
}

long _IKEI_MSG::set_cfgstr( long type, BDATA * str )
{
      init( IKEI_MSGID_CFGSTR );
      return set_basic( type, str );
}

long _IKEI::attach( long timeout )
{
      return ITH_IPCC::attach( IKEI_PIPE_NAME, timeout );
}

void _IKEI::wakeup()
{
      ITH_IPCC::wakeup();
}

void _IKEI::detach()
{
      ITH_IPCC::detach();
}

long _IKEI::recv_message( IKEI_MSG & msg )
{
      msg.oset( 0 );
      msg.size( sizeof( IKEI_HEADER ) );

      size_t size = msg.size();

      long result = io_recv( msg.buff(), size );

      if( ( result == IPCERR_OK ) || ( result == IPCERR_BUFFER ) )
      {
            msg.oset( 0 );
            if( !msg.get( &msg.header, sizeof( IKEI_HEADER ) ) )
                  return IPCERR_FAILED;

            if( msg.header.size > msg.size() )
                  result = IPCERR_BUFFER;
      }

      if( result == IPCERR_BUFFER )
      {
            msg.size( msg.header.size );
            size = msg.size() - sizeof( IKEI_HEADER );

            result = io_recv( msg.buff() + sizeof( IKEI_HEADER ), size );
      }

      return result;
}

long _IKEI::send_message( IKEI_MSG & msg )
{
      msg.header.size = msg.size() + sizeof( msg.header );
      msg.ins( &msg.header, sizeof( msg.header ) );

      return io_send( msg.buff(), msg.header.size );
}

long _IKEI::send_message( IKEI_MSG & msg, long * rslt )
{
      long result;

      result = send_message( msg );
      if( result != IPCERR_OK )
            return result;

      IKEI_MSG msg_rslt;

      result = recv_message( msg_rslt );
      if( result != IPCERR_OK )
            return result;

      return msg_rslt.get_result( rslt );
}

long _IKES::init()
{
      return ITH_IPCS::init( IKEI_PIPE_NAME, false );
}

void _IKES::done()
{
      ITH_IPCS::done();
}

long _IKES::inbound( IKEI ** ikei )
{
      IPCCONN ipcconn;

      long result = ITH_IPCS::inbound( IKEI_PIPE_NAME, ipcconn );

      if( result == IPCERR_OK )
      {
            *ikei = new IKEI;
            if( *ikei == NULL )
                  return IPCERR_FAILED;
      
            (*ikei)->io_conf( ipcconn );
      }

      return result;
}

void _IKES::wakeup()
{
      ITH_IPCS::wakeup();
}

Generated by  Doxygen 1.6.0   Back to index