module broadcast{
        interface messages {
                /* Abfragen aller Nachrichten */
                string getmessages(in string rechnerid, out boolean getall);
                /* Senden einer Nachricht */
                long dropmessage(in string message, in long msgID);
                /* Abfragen der eindeutigen Nachrichtennummer */
                long getmsgid(in string rechnerid);
        };
};

klappt au. Heraus kamen die automatisch generierten Klassen messages.h und .cpp . Hab ich ans Ende ran gestellt weil ich denke das der Fehler in der Klasse client_test.cpp liegt. Die hab ich dann selber geschrieben und immer wieder kommt der mit den Meldungen:

client_test.cpp:40: Fehler: »messages_var« wurde in diesem Gültigkeitsbereich nicht definiert
client_test.cpp:40: Fehler: expected `;' before »f«
client_test.cpp:42: Fehler: »getmessages« wurde in diesem Gültigkeitsbereich nicht definiert

Prinzipeill gesehen müsste er darauf zugreifen können.
Das ganze basiert auf dem Beispiel von:
http://cplus.kompf.de/corbatut.html

#include <CORBA.h>
#include "messages.h"
#include <coss/CosNaming.h>

#include <iostream> 

using namespace std;

int main( int argc, char **argv)
{
    CORBA::ORB_var orb = CORBA::ORB_init( argc, argv);

    int rc = 0;
    if (argc != 3) {
        cerr << "usage: " << argv[0] << " name number\n";
        exit(1);
    }
    try {
        // resolve the naming service
        CORBA::Object_var nsobj =
            orb->resolve_initial_references ("NameService");
        if (CORBA::is_nil( nsobj)) {
            cerr << "can't resolve NameService\n";
            exit(1);
        }
        // narrow the root naming context
        CosNaming::NamingContext_var nc =
            CosNaming::NamingContext::_narrow (nsobj);

        // create a name component
        CosNaming::Name name;
        name.length (1);
        name[0].id = CORBA::string_dup ("TestServer");
        name[0].kind = CORBA::string_dup ("");

        CORBA::Object_var obj = nc->resolve( name);

        messages_var f = messages::_narrow( obj);

	getmessages(argv[1], argv[2]); 
	 }
    catch(CORBA::SystemException_catch& ex)
    {
        ex -> _print(cerr);
        cerr << endl;
        rc = 1;
    }

    return rc;
}

die messages.cpp:

/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2006 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <messages.h>

using namespace std;

//--------------------------------------------------------
//  Implementation of stubs
//--------------------------------------------------------

/*
 * Base interface for class messages
 */

broadcast::messages::~messages()
{
}

void *
broadcast::messages::_narrow_helper( const char *_repoid )
{
  if( strcmp( _repoid, "IDL:broadcast/messages:1.0" ) == 0 )
    return (void *)this;
  return NULL;
}

broadcast::messages_ptr
broadcast::messages::_narrow( CORBA::Object_ptr _obj )
{
  broadcast::messages_ptr _o;
  if( !CORBA::is_nil( _obj ) ) {
    void *_p;
    if( (_p = _obj->_narrow_helper( "IDL:broadcast/messages:1.0" )))
      return _duplicate( (broadcast::messages_ptr) _p );
    if (!strcmp (_obj->_repoid(), "IDL:broadcast/messages:1.0") || _obj->_is_a_remote ("IDL:broadcast/messages:1.0")) {
      _o = new broadcast::messages_stub;
      _o->CORBA::Object::operator=( *_obj );
      return _o;
    }
  }
  return _nil();
}

broadcast::messages_ptr
broadcast::messages::_narrow( CORBA::AbstractBase_ptr _obj )
{
  return _narrow (_obj->_to_object());
}

class _Marshaller_broadcast_messages : public ::CORBA::StaticTypeInfo {
    typedef broadcast::messages_ptr _MICO_T;
  public:
    ~_Marshaller_broadcast_messages();
    StaticValueType create () const;
    void assign (StaticValueType dst, const StaticValueType src) const;
    void free (StaticValueType) const;
    void release (StaticValueType) const;
    ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
    void marshal (::CORBA::DataEncoder &, StaticValueType) const;
};

_Marshaller_broadcast_messages::~_Marshaller_broadcast_messages()
{
}

::CORBA::StaticValueType _Marshaller_broadcast_messages::create() const
{
  return (StaticValueType) new _MICO_T( 0 );
}

void _Marshaller_broadcast_messages::assign( StaticValueType d, const StaticValueType s ) const
{
  *(_MICO_T*) d = ::broadcast::messages::_duplicate( *(_MICO_T*) s );
}

void _Marshaller_broadcast_messages::free( StaticValueType v ) const
{
  ::CORBA::release( *(_MICO_T *) v );
  delete (_MICO_T*) v;
}

void _Marshaller_broadcast_messages::release( StaticValueType v ) const
{
  ::CORBA::release( *(_MICO_T *) v );
}

::CORBA::Boolean _Marshaller_broadcast_messages::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
{
  ::CORBA::Object_ptr obj;
  if (!::CORBA::_stc_Object->demarshal(dc, &obj))
    return FALSE;
  *(_MICO_T *) v = ::broadcast::messages::_narrow( obj );
  ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v);
  ::CORBA::release (obj);
  return ret;
}

void _Marshaller_broadcast_messages::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
{
  ::CORBA::Object_ptr obj = *(_MICO_T *) v;
  ::CORBA::_stc_Object->marshal( ec, &obj );
}

::CORBA::StaticTypeInfo *_marshaller_broadcast_messages;

/*
 * Stub interface for class messages
 */

broadcast::messages_stub::~messages_stub()
{
}

#ifndef MICO_CONF_NO_POA

void *
POA_broadcast::messages::_narrow_helper (const char * repoid)
{
  if (strcmp (repoid, "IDL:broadcast/messages:1.0") == 0) {
    return (void *) this;
  }
  return NULL;
}

POA_broadcast::messages *
POA_broadcast::messages::_narrow (PortableServer::Servant serv) 
{
  void * p;
  if ((p = serv->_narrow_helper ("IDL:broadcast/messages:1.0")) != NULL) {
    serv->_add_ref ();
    return (POA_broadcast::messages *) p;
  }
  return NULL;
}

broadcast::messages_stub_clp::messages_stub_clp ()
{
}

broadcast::messages_stub_clp::messages_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
  : CORBA::Object(*obj), PortableServer::StubBase(poa)
{
}

broadcast::messages_stub_clp::~messages_stub_clp ()
{
}

#endif // MICO_CONF_NO_POA

char* broadcast::messages_stub::getmessages( const char* _par_rechnerid, CORBA::Boolean_out _par_getall )
{
  CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid );
  CORBA::StaticAny _sa_getall( CORBA::_stc_boolean, &_par_getall );
  char* _res = NULL;
  CORBA::StaticAny __res( CORBA::_stc_string, &_res );

  CORBA::StaticRequest __req( this, "getmessages" );
  __req.add_in_arg( &_sa_rechnerid );
  __req.add_out_arg( &_sa_getall );
  __req.set_result( &__res );

  __req.invoke();

  mico_sii_throw( &__req, 
    0);
  return _res;
}

#ifndef MICO_CONF_NO_POA

char*
broadcast::messages_stub_clp::getmessages( const char* _par_rechnerid, CORBA::Boolean_out _par_getall )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_broadcast::messages * _myserv = POA_broadcast::messages::_narrow (_serv);
    if (_myserv) {
      char* __res;

      #ifdef HAVE_EXCEPTIONS
      try {
      #endif
        __res = _myserv->getmessages(_par_rechnerid, _par_getall);
      #ifdef HAVE_EXCEPTIONS
      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }
      #endif

      _myserv->_remove_ref();
      _postinvoke ();
      return __res;
    }
    _postinvoke ();
  }

  return broadcast::messages_stub::getmessages(_par_rechnerid, _par_getall);
}

#endif // MICO_CONF_NO_POA

CORBA::Long broadcast::messages_stub::dropmessage( const char* _par_message, CORBA::Long _par_msgID )
{
  CORBA::StaticAny _sa_message( CORBA::_stc_string, &_par_message );
  CORBA::StaticAny _sa_msgID( CORBA::_stc_long, &_par_msgID );
  CORBA::Long _res;
  CORBA::StaticAny __res( CORBA::_stc_long, &_res );

  CORBA::StaticRequest __req( this, "dropmessage" );
  __req.add_in_arg( &_sa_message );
  __req.add_in_arg( &_sa_msgID );
  __req.set_result( &__res );

  __req.invoke();

  mico_sii_throw( &__req, 
    0);
  return _res;
}

#ifndef MICO_CONF_NO_POA

CORBA::Long
broadcast::messages_stub_clp::dropmessage( const char* _par_message, CORBA::Long _par_msgID )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_broadcast::messages * _myserv = POA_broadcast::messages::_narrow (_serv);
    if (_myserv) {
      CORBA::Long __res;

      #ifdef HAVE_EXCEPTIONS
      try {
      #endif
        __res = _myserv->dropmessage(_par_message, _par_msgID);
      #ifdef HAVE_EXCEPTIONS
      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }
      #endif

      _myserv->_remove_ref();
      _postinvoke ();
      return __res;
    }
    _postinvoke ();
  }

  return broadcast::messages_stub::dropmessage(_par_message, _par_msgID);
}

#endif // MICO_CONF_NO_POA

CORBA::Long broadcast::messages_stub::getmsgid( const char* _par_rechnerid )
{
  CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid );
  CORBA::Long _res;
  CORBA::StaticAny __res( CORBA::_stc_long, &_res );

  CORBA::StaticRequest __req( this, "getmsgid" );
  __req.add_in_arg( &_sa_rechnerid );
  __req.set_result( &__res );

  __req.invoke();

  mico_sii_throw( &__req, 
    0);
  return _res;
}

#ifndef MICO_CONF_NO_POA

CORBA::Long
broadcast::messages_stub_clp::getmsgid( const char* _par_rechnerid )
{
  PortableServer::Servant _serv = _preinvoke ();
  if (_serv) {
    POA_broadcast::messages * _myserv = POA_broadcast::messages::_narrow (_serv);
    if (_myserv) {
      CORBA::Long __res;

      #ifdef HAVE_EXCEPTIONS
      try {
      #endif
        __res = _myserv->getmsgid(_par_rechnerid);
      #ifdef HAVE_EXCEPTIONS
      }
      catch (...) {
        _myserv->_remove_ref();
        _postinvoke();
        throw;
      }
      #endif

      _myserv->_remove_ref();
      _postinvoke ();
      return __res;
    }
    _postinvoke ();
  }

  return broadcast::messages_stub::getmsgid(_par_rechnerid);
}

#endif // MICO_CONF_NO_POA

struct __tc_init_MESSAGES {
  __tc_init_MESSAGES()
  {
    _marshaller_broadcast_messages = new _Marshaller_broadcast_messages;
  }

  ~__tc_init_MESSAGES()
  {
    delete static_cast<_Marshaller_broadcast_messages*>(_marshaller_broadcast_messages);
  }
};

static __tc_init_MESSAGES __init_MESSAGES;

//--------------------------------------------------------
//  Implementation of skeletons
//--------------------------------------------------------

// PortableServer Skeleton Class for interface broadcast::messages
POA_broadcast::messages::~messages()
{
}

::broadcast::messages_ptr
POA_broadcast::messages::_this ()
{
  CORBA::Object_var obj = PortableServer::ServantBase::_this();
  return ::broadcast::messages::_narrow (obj);
}

CORBA::Boolean
POA_broadcast::messages::_is_a (const char * repoid)
{
  if (strcmp (repoid, "IDL:broadcast/messages:1.0") == 0) {
    return TRUE;
  }
  return FALSE;
}

CORBA::InterfaceDef_ptr
POA_broadcast::messages::_get_interface ()
{
  CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:broadcast/messages:1.0");

  if (CORBA::is_nil (ifd)) {
    mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
  }

  return ifd;
}

CORBA::RepositoryId
POA_broadcast::messages::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
{
  return CORBA::string_dup ("IDL:broadcast/messages:1.0");
}

CORBA::Object_ptr
POA_broadcast::messages::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
{
  return new ::broadcast::messages_stub_clp (poa, obj);
}

bool
POA_broadcast::messages::dispatch (CORBA::StaticServerRequest_ptr __req)
{
  #ifdef HAVE_EXCEPTIONS
  try {
  #endif
    if( strcmp( __req->op_name(), "getmessages" ) == 0 ) {
      CORBA::String_var _par_rechnerid;
      CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid._for_demarshal() );
      CORBA::Boolean _par_getall;
      CORBA::StaticAny _sa_getall( CORBA::_stc_boolean, &_par_getall );

      char* _res;
      CORBA::StaticAny __res( CORBA::_stc_string, &_res );
      __req->add_in_arg( &_sa_rechnerid );
      __req->add_out_arg( &_sa_getall );
      __req->set_result( &__res );

      if( !__req->read_args() )
        return true;

      _res = getmessages( _par_rechnerid.inout(), _par_getall );
      __req->write_results();
      CORBA::string_free( _res );
      return true;
    }
    if( strcmp( __req->op_name(), "dropmessage" ) == 0 ) {
      CORBA::String_var _par_message;
      CORBA::StaticAny _sa_message( CORBA::_stc_string, &_par_message._for_demarshal() );
      CORBA::Long _par_msgID;
      CORBA::StaticAny _sa_msgID( CORBA::_stc_long, &_par_msgID );

      CORBA::Long _res;
      CORBA::StaticAny __res( CORBA::_stc_long, &_res );
      __req->add_in_arg( &_sa_message );
      __req->add_in_arg( &_sa_msgID );
      __req->set_result( &__res );

      if( !__req->read_args() )
        return true;

      _res = dropmessage( _par_message.inout(), _par_msgID );
      __req->write_results();
      return true;
    }
    if( strcmp( __req->op_name(), "getmsgid" ) == 0 ) {
      CORBA::String_var _par_rechnerid;
      CORBA::StaticAny _sa_rechnerid( CORBA::_stc_string, &_par_rechnerid._for_demarshal() );

      CORBA::Long _res;
      CORBA::StaticAny __res( CORBA::_stc_long, &_res );
      __req->add_in_arg( &_sa_rechnerid );
      __req->set_result( &__res );

      if( !__req->read_args() )
        return true;

      _res = getmsgid( _par_rechnerid.inout() );
      __req->write_results();
      return true;
    }
  #ifdef HAVE_EXCEPTIONS
  } catch( CORBA::SystemException_catch &_ex ) {
    __req->set_exception( _ex->_clone() );
    __req->write_results();
    return true;
  } catch( ... ) {
    CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE);
    __req->set_exception (_ex->_clone());
    __req->write_results ();
    return true;
  }
  #endif

  return false;
}

void
POA_broadcast::messages::invoke (CORBA::StaticServerRequest_ptr __req)
{
  if (dispatch (__req)) {
      return;
  }

  CORBA::Exception * ex = 
    new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
  __req->set_exception (ex);
  __req->write_results();
}

und die messages.h

/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2006 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __MESSAGES_H__
#define __MESSAGES_H__

namespace broadcast
{

class messages;
typedef messages *messages_ptr;
typedef messages_ptr messagesRef;
typedef ObjVar< messages > messages_var;
typedef ObjOut< messages > messages_out;

}

namespace broadcast
{

/*
 * Base class and common definitions for interface messages
 */

class messages : 
  virtual public CORBA::Object
{
  public:
    virtual ~messages();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef messages_ptr _ptr_type;
    typedef messages_var _var_type;
    #endif

    static messages_ptr _narrow( CORBA::Object_ptr obj );
    static messages_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static messages_ptr _duplicate( messages_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static messages_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual char* getmessages( const char* rechnerid, CORBA::Boolean_out getall ) = 0;
    virtual CORBA::Long dropmessage( const char* message, CORBA::Long msgID ) = 0;
    virtual CORBA::Long getmsgid( const char* rechnerid ) = 0;

  protected:
    messages() {};
  private:
    messages( const messages& );
    void operator=( const messages& );
};

// Stub for interface messages
class messages_stub:
  virtual public messages
{
  public:
    virtual ~messages_stub();
    char* getmessages( const char* rechnerid, CORBA::Boolean_out getall );
    CORBA::Long dropmessage( const char* message, CORBA::Long msgID );
    CORBA::Long getmsgid( const char* rechnerid );

  private:
    void operator=( const messages_stub& );
};

#ifndef MICO_CONF_NO_POA

class messages_stub_clp :
  virtual public messages_stub,
  virtual public PortableServer::StubBase
{
  public:
    messages_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~messages_stub_clp ();
    char* getmessages( const char* rechnerid, CORBA::Boolean_out getall );
    CORBA::Long dropmessage( const char* message, CORBA::Long msgID );
    CORBA::Long getmsgid( const char* rechnerid );

  protected:
    messages_stub_clp ();
  private:
    void operator=( const messages_stub_clp & );
};

#endif // MICO_CONF_NO_POA

}

#ifndef MICO_CONF_NO_POA

namespace POA_broadcast
{

class messages : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~messages ();
    broadcast::messages_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static messages * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual char* getmessages( const char* rechnerid, CORBA::Boolean_out getall ) = 0;
    virtual CORBA::Long dropmessage( const char* message, CORBA::Long msgID ) = 0;
    virtual CORBA::Long getmsgid( const char* rechnerid ) = 0;

  protected:
    messages () {};

  private:
    messages (const messages &);
    void operator= (const messages &);
};

}

#endif // MICO_CONF_NO_POA

extern CORBA::StaticTypeInfo *_marshaller_broadcast_messages;

#endif