[neons]

Thanks,I appreciate your answers. Because my poor English, I post my whole code,actually the main code is supplyed by zeroc.I want to see my code acts as the simple demo in the IceGrid sample directory which is also supplyed by zeroc.

chat.ice

#ifndef CHAT_ICE
#define CHAT_ICE

#include <Glacier2/Session.ice>

module Demo
{

interface ChatCallback
{
    void message(string data);
};

interface ChatSession extends Glacier2::Session
{
    bool setCallback(ChatCallback* callback);
    void say(string data,string user);
};

};

#endif

ChatSessionI.h

#ifndef CHAT_SESSION_I_H
#define CHAT_SESSION_I_H

#include <Chat.h>

class ChatSessionI : public Demo::ChatSession, public IceUtil::Mutex
{
public:

    ChatSessionI(const std::string&);

    virtual bool setCallback(const Demo::ChatCallbackPrx&, const Ice::Current&);
	virtual void say(const std::string&, const std::string&,const Ice::Current&);
    virtual void destroy(const Ice::Current&);

private:

    const std::string _userId;
    Demo::ChatCallbackPrx _callback;
};

#endif

ChatSessionI.cpp

#include <Ice/Ice.h>
#include <ChatSessionI.h>
#include <list>

using namespace std;
using namespace Demo;

class ChatRoom;
typedef IceUtil::Handle<ChatRoom> ChatRoomPtr;

class ChatRoom : public IceUtil::Mutex, public IceUtil::Shared
{
public:

    static ChatRoomPtr& instance();

    void enter(const Demo::ChatCallbackPrx&);
    void leave(const Demo::ChatCallbackPrx&);
    void message(const string&) const;

private:
    
    list<Demo::ChatCallbackPrx> _members;

    static ChatRoomPtr _instance;
    static IceUtil::StaticMutex _instanceMutex;
};

ChatRoomPtr ChatRoom::_instance;
IceUtil::StaticMutex ChatRoom::_instanceMutex = ICE_STATIC_MUTEX_INITIALIZER;

ChatRoomPtr&
ChatRoom::instance()
{
... ...
}

void
ChatRoom::enter(const ChatCallbackPrx& callback)
{
... ...
}

void
ChatRoom::leave(const ChatCallbackPrx& callback)
{
... ...
}

void
ChatRoom::message(const string& data) const
{
... ...
}

ChatSessionI::ChatSessionI(const string& userId) :
    _userId(userId)
{
}

void
ChatSessionI::setCallback(const ChatCallbackPrx& callback, const Ice::Current& current)
{
... ...
}

void
ChatSessionI::say(const string& data, const Ice::Current&)
{
 ... ...
}

void
ChatSessionI::destroy(const Ice::Current& current)
{
 ... ...
}

Server.cpp

#include <Ice/Ice.h>
#include <Glacier2/PermissionsVerifier.h>
#include <ChatSessionI.h>

using namespace std;
using namespace Demo;

class ChatSessionManagerI : public Glacier2::SessionManager
{
public:

    virtual Glacier2::SessionPrx
    create(const string& userId, const Glacier2::SessionControlPrx&, const Ice::Current& current)
    {
        return Glacier2::SessionPrx::uncheckedCast(current.adapter->addWithUUID(new ChatSessionI(userId)));
    }
};

class ChatServer : public Ice::Application
{
public:

    virtual int
    run(int, char*[])
    {
        Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("ChatServer");
        
        adapter->add(new ChatSessionManagerI, communicator()->stringToIdentity("ChatSessionManager"));
        adapter->activate();
        communicator()->waitForShutdown();
        
        return EXIT_SUCCESS;
    }
};

int
main(int argc, char* argv[])
{
    ChatServer app;
    return app.main(argc, argv, "config.server");
}

Client.cpp

#include <IceUtil/IceUtil.h>
#include <Ice/Ice.h>
#include <Glacier2/Router.h>
#include <Chat.h>

using namespace std;
using namespace Demo;

class SessionPingThread : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
{
... ...
};
typedef IceUtil::Handle<SessionPingThread> SessionPingThreadPtr;

class ChatCallbackI : public ChatCallback
{
public:

    virtual void
    message(const string& data, const Ice::Current&)
    {
        cout << data << endl;
    }
};

class ChatClient : public Ice::Application
{
public:

    virtual int
    run(int argc, char* argv[])
    {

        callbackOnInterrupt();

        {
            IceUtil::Mutex::Lock sync(_mutex);
            Ice::RouterPrx defaultRouter = communicator()->getDefaultRouter();
            if(!defaultRouter)
            {
                cerr << argv[0] << ": no default router set" << endl;
                return EXIT_FAILURE;
            }
            
            _router = Glacier2::RouterPrx::checkedCast(defaultRouter);
            if(!_router)
            {
                cerr << argv[0] << ": configured router is not a Glacier2 router" << endl;
                return EXIT_FAILURE;
            }
        }

        ChatSessionPrx session;
        while(true)
        {
            cout << "This demo accepts any user-id / password combination.\n";

            string id;
            cout << "user id: " << flush;
            getline(cin, id);
            id = trim(id);

            string pw;
            cout << "password: " << flush;
            getline(cin, pw);
            pw = trim(pw);

            try
            {
                session = ChatSessionPrx::uncheckedCast(_router->createSession(id, pw));
                break;
            }
            catch(const Glacier2::PermissionDeniedException& ex)
            {
                cout << "permission denied:\n" << ex.reason << endl;
            }
        }

        {
            IceUtil::Mutex::Lock sync(_mutex);
            _ping = new SessionPingThread(session, (long)_router->getSessionTimeout() / 2);
            _ping->start();
        }

        Ice::Identity callbackReceiverIdent;
        callbackReceiverIdent.name = "callbackReceiver";
        callbackReceiverIdent.category = _router->getCategoryForClient();

        Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Chat.Client");
        ChatCallbackPrx callback = ChatCallbackPrx::uncheckedCast(
            adapter->add(new ChatCallbackI, callbackReceiverIdent));
        adapter->activate();

        session->setCallback(callback);

        menu();

        try
        {
            do
            {
                string s;
                cout << "==> ";
                getline(cin, s);
                s = trim(s);
                if(!s.empty())
                {
                    if(s[0] == '/')
                    {
                        if(s == "/quit")
                        {
                            break;
                        }
                        menu();
                    }
                    else
                    {
                        session->say(s);
                    }
                }
            }
            while(cin.good());

            cleanup();
        }
        catch(const Ice::Exception& ex)
        {
            cerr << ex << endl;
            cleanup();

            return EXIT_FAILURE;
        }
        return EXIT_SUCCESS;
    }

    virtual void
    interruptCallback(int)
    {
          ... ...
    }

private:

    void
    cleanup()
    {
           ... ...
    }

    void
    menu()
    {
        cout << "enter /quit to exit." << endl;
    }

    string
    trim(const string& s)
    {
         ... ...
    }

    IceUtil::Mutex _mutex;
    Glacier2::RouterPrx _router;
    SessionPingThreadPtr _ping;
};

int
main(int argc, char* argv[])
{
    ChatClient app;
    return app.main(argc, argv, "config.client");
}