zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/ImplicitContextI.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_IMPLICIT_CONTEXT_I_H
 #define ICE_IMPLICIT_CONTEXT_I_H
@@ -18,12 +13,14 @@ namespace Ice
 //
 // The base class for all ImplicitContext implementations
 //
+class ImplicitContextI;
+ICE_DEFINE_PTR(ImplicitContextIPtr,ImplicitContextI);
 
 class ImplicitContextI : public ImplicitContext
 {
 public:
-    
-    static ImplicitContextI* create(const std::string&);
+
+    static ImplicitContextIPtr create(const std::string&);
 
 #ifdef _WIN32
     static void cleanupThread();
@@ -34,7 +31,7 @@ public:
     // (entries in the given context overwrite entries in
     // the underlying context)
     //
-    virtual void write(const Context&, ::IceInternal::BasicStream*) const = 0;
+    virtual void write(const Context&, ::Ice::OutputStream*) const = 0;
 
     //
     // Combines the underlying context plus the given context
@@ -45,7 +42,7 @@ public:
 
 };
 
-typedef IceInternal::Handle<ImplicitContextI> ImplicitContextIPtr;
+ICE_DEFINE_PTR(ImplicitContextIPtr, ImplicitContextI);
 
 }
 #endif

data/ext/ice/cpp/src/Ice/Incoming.cpp

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/Incoming.h>
 #include <Ice/IncomingAsync.h>
@@ -22,7 +17,7 @@
 #include <Ice/Protocol.h>
 #include <Ice/ReplyStatus.h>
 #include <Ice/ResponseHandler.h>
-#include <IceUtil/StringUtil.h>
+#include <Ice/StringUtil.h>
 #include <typeinfo>
 
 using namespace std;
@@ -33,109 +28,98 @@ using namespace IceInternal;
 namespace IceUtilInternal
 {
 
-extern bool ICE_UTIL_API printStackTraces;
+extern bool printStackTraces;
+
+}
 
+#ifdef ICE_CPP11_MAPPING
+Ice::MarshaledResult::MarshaledResult(const Ice::Current& current) :
+    ostr(make_shared<Ice::OutputStream>(current.adapter->getCommunicator(), Ice::currentProtocolEncoding))
+{
+    ostr->writeBlob(replyHdr, sizeof(replyHdr));
+    ostr->write(current.requestId);
+    ostr->write(replyOK);
 }
+#endif
 
 IceInternal::IncomingBase::IncomingBase(Instance* instance, ResponseHandler* responseHandler,
                                         Ice::Connection* connection, const ObjectAdapterPtr& adapter,
                                         bool response, Byte compress, Int requestId) :
     _response(response),
     _compress(compress),
+    _format(Ice::ICE_ENUM(FormatType, DefaultFormat)),
     _os(instance, Ice::currentProtocolEncoding),
     _responseHandler(responseHandler)
 {
     _current.adapter = adapter;
+#ifdef ICE_CPP11_MAPPING
+    ::Ice::ConnectionI* conn = dynamic_cast<::Ice::ConnectionI*>(connection);
+    _current.con = conn ? conn->shared_from_this() : nullptr;
+#else
     _current.con = connection;
+#endif
     _current.requestId = requestId;
+    _current.encoding.major = 0;
+    _current.encoding.minor = 0;
 }
 
-IceInternal::IncomingBase::IncomingBase(IncomingBase& in) :
-    _current(in._current), // copy
-    _os(in._os.instance(), Ice::currentProtocolEncoding),
-    _interceptorAsyncCallbackQueue(in._interceptorAsyncCallbackQueue) // copy
-{
-    __adopt(in); // adopt everything else
-}
-
-void
-IceInternal::IncomingBase::__adopt(IncomingBase& other)
+IceInternal::IncomingBase::IncomingBase(IncomingBase& other) :
+    IceUtil::noncopyable(), // TODO, remove noncopyable base class
+    _current(other._current),
+    _servant(other._servant),
+    _locator(other._locator),
+    _cookie(other._cookie),
+    _response(other._response),
+    _compress(other._compress),
+    _format(other._format),
+    _os(other._os.instance(), Ice::currentProtocolEncoding),
+    _responseHandler(other._responseHandler),
+    _interceptorCBs(other._interceptorCBs)
 {
     _observer.adopt(other._observer);
-
-    _servant = other._servant;
-    other._servant = 0;
-
-    _locator = other._locator;
-    other._locator = 0;
-
-    _cookie = other._cookie;
-    other._cookie = 0;
-
-    _response = other._response;
-    other._response = false;
-
-    _compress = other._compress;
-    other._compress = 0;
-
-    _os.swap(other._os);
-
-    _responseHandler = other._responseHandler;
-    other._responseHandler = 0;
 }
 
-BasicStream*
-IncomingBase::__startWriteParams(FormatType format)
+OutputStream*
+IncomingBase::startWriteParams()
 {
     if(!_response)
     {
         throw MarshalException(__FILE__, __LINE__, "can't marshal out parameters for oneway dispatch");
     }
 
-    assert(_os.b.size() == headerSize + 4); // Reply status position.
     assert(_current.encoding >= Ice::Encoding_1_0); // Encoding for reply is known.
-    _os.write(static_cast<Ice::Byte>(0));
-    _os.startWriteEncaps(_current.encoding, format);
 
-    //
-    // We still return the stream even if no response is expected. The
-    // servant code might still write some out parameters if for
-    // example a method with out parameters somehow and erroneously
-    // invoked as oneway (or if the invocation is invoked on a
-    // blobject and the blobject erroneously writes a response).
-    //
+    _os.writeBlob(replyHdr, sizeof(replyHdr));
+    _os.write(_current.requestId);
+    _os.write(replyOK);
+    _os.startEncapsulation(_current.encoding, _format);
     return &_os;
 }
 
 void
-IncomingBase::__endWriteParams(bool ok)
+IncomingBase::endWriteParams()
 {
-    if(!ok)
-    {
-        _observer.userException();
-    }
-
     if(_response)
     {
-        *(_os.b.begin() + headerSize + 4) = ok ? replyOK : replyUserException; // Reply status position.
-        _os.endWriteEncaps();
+        _os.endEncapsulation();
     }
 }
 
 void
-IncomingBase::__writeEmptyParams()
+IncomingBase::writeEmptyParams()
 {
     if(_response)
     {
-        assert(_os.b.size() == headerSize + 4); // Reply status position.
         assert(_current.encoding >= Ice::Encoding_1_0); // Encoding for reply is known.
+        _os.writeBlob(replyHdr, sizeof(replyHdr));
+        _os.write(_current.requestId);
         _os.write(replyOK);
-        _os.writeEmptyEncaps(_current.encoding);
+        _os.writeEmptyEncapsulation(_current.encoding);
     }
 }
 
 void
-IncomingBase::__writeParamEncaps(const Byte* v, Ice::Int sz, bool ok)
+IncomingBase::writeParamEncaps(const Byte* v, Ice::Int sz, bool ok)
 {
     if(!ok)
     {
@@ -144,47 +128,118 @@ IncomingBase::__writeParamEncaps(const Byte* v, Ice::Int sz, bool ok)
 
     if(_response)
     {
-        assert(_os.b.size() == headerSize + 4); // Reply status position.
         assert(_current.encoding >= Ice::Encoding_1_0); // Encoding for reply is known.
+        _os.writeBlob(replyHdr, sizeof(replyHdr));
+        _os.write(_current.requestId);
         _os.write(ok ? replyOK : replyUserException);
         if(sz == 0)
         {
-            _os.writeEmptyEncaps(_current.encoding);
+            _os.writeEmptyEncapsulation(_current.encoding);
+        }
+        else
+        {
+            _os.writeEncapsulation(v, sz);
+        }
+    }
+}
+
+#ifdef ICE_CPP11_MAPPING
+void
+IceInternal::IncomingBase::setMarshaledResult(const Ice::MarshaledResult& result)
+{
+    result.getOutputStream()->swap(_os);
+}
+#endif
+
+void
+IceInternal::IncomingBase::response(bool amd)
+{
+    try
+    {
+        if(_locator && !servantLocatorFinished(amd))
+        {
+            return;
+        }
+
+        assert(_responseHandler);
+        if(_response)
+        {
+            _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
+            _responseHandler->sendResponse(_current.requestId, &_os, _compress, amd);
         }
         else
         {
-            _os.writeEncaps(v, sz);
+            _responseHandler->sendNoResponse();
+        }
+    }
+    catch(const LocalException& ex)
+    {
+        _responseHandler->invokeException(_current.requestId, ex, 1, amd); // Fatal invocation exception
+    }
+
+    _observer.detach();
+    _responseHandler = 0;
+}
+
+void
+IceInternal::IncomingBase::exception(const std::exception& exc, bool amd)
+{
+    try
+    {
+        if(_locator && !servantLocatorFinished(amd))
+        {
+            return;
         }
+        handleException(exc, amd);
+    }
+    catch(const LocalException& ex)
+    {
+        _responseHandler->invokeException(_current.requestId, ex, 1, amd);  // Fatal invocation exception
     }
 }
 
 void
-IncomingBase::__writeUserException(const Ice::UserException& ex, Ice::FormatType format)
+IceInternal::IncomingBase::exception(const string& msg, bool amd)
 {
-    ::IceInternal::BasicStream* __os = __startWriteParams(format);
-    __os->write(ex);
-    __endWriteParams(false);
+    try
+    {
+        if(_locator && !servantLocatorFinished(amd))
+        {
+            return;
+        }
+        handleException(msg, amd);
+    }
+    catch(const LocalException& ex)
+    {
+        _responseHandler->invokeException(_current.requestId, ex, 1, amd);  // Fatal invocation exception
+    }
 }
 
 void
-IceInternal::IncomingBase::__warning(const Exception& ex) const
+IceInternal::IncomingBase::warning(const Exception& ex) const
 {
     Warning out(_os.instance()->initializationData().logger);
 
+    ToStringMode toStringMode = _os.instance()->toStringMode();
+
     out << "dispatch exception: " << ex;
-    out << "\nidentity: " << _os.instance()->identityToString(_current.id);
-    out << "\nfacet: " << IceUtilInternal::escapeString(_current.facet, "");
+    out << "\nidentity: " << identityToString(_current.id, toStringMode);
+    out << "\nfacet: ";
+    out << escapeString(_current.facet, "", toStringMode);
     out << "\noperation: " << _current.operation;
 
     if(_current.con)
     {
         try
         {
-            Ice::ConnectionInfoPtr connInfo = _current.con->getInfo();
-            Ice::IPConnectionInfoPtr ipConnInfo = Ice::IPConnectionInfoPtr::dynamicCast(connInfo);
-            if(ipConnInfo)
+            for(Ice::ConnectionInfoPtr connInfo = _current.con->getInfo(); connInfo; connInfo = connInfo->underlying)
             {
-                out << "\nremote host: " << ipConnInfo->remoteAddress << " remote port: " << ipConnInfo->remotePort;
+                Ice::IPConnectionInfoPtr ipConnInfo = ICE_DYNAMIC_CAST(Ice::IPConnectionInfo, connInfo);
+                if(ipConnInfo)
+                {
+                    out << "\nremote host: " << ipConnInfo->remoteAddress << " remote port: " << ipConnInfo->remotePort;
+                    break;
+                }
             }
         }
         catch(const Ice::LocalException&)
@@ -195,28 +250,32 @@ IceInternal::IncomingBase::__warning(const Exception& ex) const
 }
 
 void
-IceInternal::IncomingBase::__warning(const string& msg) const
+IceInternal::IncomingBase::warning(const string& msg) const
 {
     Warning out(_os.instance()->initializationData().logger);
+    ToStringMode toStringMode = _os.instance()->toStringMode();
 
     out << "dispatch exception: " << msg;
-    out << "\nidentity: " << _os.instance()->identityToString(_current.id);
-    out << "\nfacet: " << IceUtilInternal::escapeString(_current.facet, "");
+    out << "\nidentity: " << identityToString(_current.id, toStringMode);
+    out << "\nfacet: " << escapeString(_current.facet, "", toStringMode);
     out << "\noperation: " << _current.operation;
 
     if(_current.con)
     {
-        Ice::ConnectionInfoPtr connInfo = _current.con->getInfo();
-        Ice::IPConnectionInfoPtr ipConnInfo = Ice::IPConnectionInfoPtr::dynamicCast(connInfo);
-        if(ipConnInfo)
+        for(Ice::ConnectionInfoPtr connInfo = _current.con->getInfo(); connInfo; connInfo = connInfo->underlying)
         {
-            out << "\nremote host: " << ipConnInfo->remoteAddress << " remote port: " << ipConnInfo->remotePort;
+            Ice::IPConnectionInfoPtr ipConnInfo = ICE_DYNAMIC_CAST(Ice::IPConnectionInfo, connInfo);
+            if(ipConnInfo)
+            {
+                out << "\nremote host: " << ipConnInfo->remoteAddress << " remote port: " << ipConnInfo->remotePort;
+                break;
+            }
         }
     }
 }
 
 bool
-IceInternal::IncomingBase::__servantLocatorFinished(bool amd)
+IceInternal::IncomingBase::servantLocatorFinished(bool amd)
 {
     assert(_locator && _servant);
     try
@@ -224,49 +283,27 @@ IceInternal::IncomingBase::__servantLocatorFinished(bool amd)
         _locator->finished(_current, _servant, _cookie);
         return true;
     }
-    catch(const UserException& ex)
-    {
-        assert(_responseHandler);
-
-        _observer.userException();
-
-        //
-        // The operation may have already marshaled a reply; we must overwrite that reply.
-        //
-        if(_response)
-        {
-            _os.b.resize(headerSize + 4); // Reply status position.
-            _os.write(replyUserException);
-            _os.startWriteEncaps(_current.encoding, DefaultFormat);
-            _os.write(ex);
-            _os.endWriteEncaps();
-            _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
-            _responseHandler->sendResponse(_current.requestId, &_os, _compress, amd);
-        }
-        else
-        {
-            _responseHandler->sendNoResponse();
-        }
-
-        _observer.detach();
-        _responseHandler = 0;
-    }
     catch(const std::exception& ex)
     {
-        __handleException(ex, amd);
+        handleException(ex, amd);
     }
     catch(...)
     {
-        __handleException(amd);
+        handleException("unknown c++ exception", amd);
     }
     return false;
 }
 
 void
-IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd)
+IceInternal::IncomingBase::handleException(const std::exception& exc, bool amd)
 {
     assert(_responseHandler);
 
+    // Reset the stream, it's possible the marshalling of the response failed and left
+    // the stream in an unknown state.
+    _os.clear();
+    _os.b.clear();
+
     if(const SystemException* ex = dynamic_cast<const SystemException*>(&exc))
     {
         if(_responseHandler->systemException(_current.requestId, *ex, amd))
@@ -297,17 +334,18 @@ IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd
 
         if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 1)
         {
-            __warning(*rfe);
+            warning(*rfe);
         }
 
         if(_observer)
         {
-            _observer.failed(rfe->ice_name());
+            _observer.failed(rfe->ice_id());
         }
 
         if(_response)
         {
-            _os.b.resize(headerSize + 4); // Reply status position.
+            _os.writeBlob(replyHdr, sizeof(replyHdr));
+            _os.write(_current.requestId);
             if(dynamic_cast<ObjectNotExistException*>(rfe))
             {
                 _os.write(replyObjectNotExist);
@@ -349,21 +387,45 @@ IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd
             _responseHandler->sendNoResponse();
         }
     }
+    else if(const UserException* uex = dynamic_cast<const UserException*>(&exc))
+    {
+        _observer.userException();
+
+        //
+        // The operation may have already marshaled a reply; we must overwrite that reply.
+        //
+        if(_response)
+        {
+            _os.writeBlob(replyHdr, sizeof(replyHdr));
+            _os.write(_current.requestId);
+            _os.write(replyUserException);
+            _os.startEncapsulation(_current.encoding, _format);
+            _os.write(*uex);
+            _os.endEncapsulation();
+            _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
+            _responseHandler->sendResponse(_current.requestId, &_os, _compress, amd);
+        }
+        else
+        {
+            _responseHandler->sendNoResponse();
+        }
+    }
     else if(const Exception* ex = dynamic_cast<const Exception*>(&exc))
     {
         if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
         {
-            __warning(*ex);
+            warning(*ex);
         }
 
         if(_observer)
         {
-            _observer.failed(ex->ice_name());
+            _observer.failed(ex->ice_id());
         }
 
         if(_response)
         {
-            _os.b.resize(headerSize + 4); // Reply status position.
+            _os.writeBlob(replyHdr, sizeof(replyHdr));
+            _os.write(_current.requestId);
             if(const UnknownLocalException* ule = dynamic_cast<const UnknownLocalException*>(&exc))
             {
                 _os.write(replyUnknownLocalException);
@@ -390,11 +452,11 @@ IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd
                 }
                 _os.write(str.str(), false);
             }
-            else if(const UserException* ue = dynamic_cast<const UserException*>(&exc))
+            else if(const UserException* use = dynamic_cast<const UserException*>(&exc))
             {
                 _os.write(replyUnknownUserException);
                 ostringstream str;
-                str << *ue;
+                str << *use;
                 if(IceUtilInternal::printStackTraces)
                 {
                     str <<  '\n' << ex->ice_stackTrace();
@@ -425,7 +487,7 @@ IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd
     {
         if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
         {
-            __warning(string("std::exception: ") + exc.what());
+            warning(string("std::exception: ") + exc.what());
         }
 
         if(_observer)
@@ -435,7 +497,8 @@ IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd
 
         if(_response)
         {
-            _os.b.resize(headerSize + 4); // Reply status position.
+            _os.writeBlob(replyHdr, sizeof(replyHdr));
+            _os.write(_current.requestId);
             _os.write(replyUnknownException);
             ostringstream str;
             str << "std::exception: " << exc.what();
@@ -455,15 +518,20 @@ IceInternal::IncomingBase::__handleException(const std::exception& exc, bool amd
 }
 
 void
-IceInternal::IncomingBase::__handleException(bool amd)
+IceInternal::IncomingBase::handleException(const string& msg, bool amd)
 {
     if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
     {
-        __warning("unknown c++ exception");
+        warning(msg);
     }
 
     assert(_responseHandler);
 
+    // Reset the stream, it's possible the marshalling of the response failed and left
+    // the stream in an unknown state.
+    _os.clear();
+    _os.b.clear();
+
     if(_observer)
     {
         _observer.failed("unknown");
@@ -471,9 +539,10 @@ IceInternal::IncomingBase::__handleException(bool amd)
 
     if(_response)
     {
-        _os.b.resize(headerSize + 4); // Reply status position.
+        _os.writeBlob(replyHdr, sizeof(replyHdr));
+        _os.write(_current.requestId);
         _os.write(replyUnknownException);
-        string reason = "unknown c++ exception";
+        string reason = msg;
         _os.write(reason, false);
         _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
         _responseHandler->sendResponse(_current.requestId, &_os, _compress, amd);
@@ -487,37 +556,31 @@ IceInternal::IncomingBase::__handleException(bool amd)
     _responseHandler = 0;
 }
 
-
 IceInternal::Incoming::Incoming(Instance* instance, ResponseHandler* responseHandler, Ice::Connection* connection,
                                 const ObjectAdapterPtr& adapter, bool response, Byte compress, Int requestId) :
     IncomingBase(instance, responseHandler, connection, adapter, response, compress, requestId),
     _inParamPos(0)
 {
-    //
-    // Prepare the response if necessary.
-    //
-    if(response)
-    {
-        _os.writeBlob(replyHdr, sizeof(replyHdr));
-
-        //
-        // Add the request ID.
-        //
-        _os.write(requestId);
-    }
 }
 
-
+#ifdef ICE_CPP11_MAPPING
+void
+IceInternal::Incoming::push(function<bool()> response, function<bool(exception_ptr)> exception)
+{
+    _interceptorCBs.push_front(make_pair(response, exception));
+}
+#else
 void
 IceInternal::Incoming::push(const Ice::DispatchInterceptorAsyncCallbackPtr& cb)
 {
-    _interceptorAsyncCallbackQueue.push_front(cb);
+    _interceptorCBs.push_front(cb);
 }
+#endif
 
 void
 IceInternal::Incoming::pop()
 {
-    _interceptorAsyncCallbackQueue.pop_front();
+    _interceptorCBs.pop_front();
 }
 
 void
@@ -532,45 +595,25 @@ IceInternal::Incoming::startOver()
     }
     else
     {
-        killAsync();
+        // Reset input stream's position and clear response
+        if(_inAsync)
+        {
+            _inAsync->kill(*this);
+            _inAsync = 0;
+        }
+        _os.clear();
+        _os.b.clear();
 
-        //
-        // Let's rewind _is and clean-up _os
-        //
         _is->i = _inParamPos;
-        _os.b.resize(headerSize + 4); // Reply status position.
-    }
-}
-
-void
-IceInternal::Incoming::killAsync()
-{
-    //
-    // Always runs in the dispatch thread
-    //
-    if(_cb != 0)
-    {
-        //
-        // May raise ResponseSentException
-        //
-        _cb->__deactivate(*this);
-        _cb = 0;
     }
 }
 
 void
-IceInternal::Incoming::setActive(IncomingAsync& cb)
-{
-    assert(_cb == 0);
-    _cb = &cb; // acquires a ref-count
-}
-
-void
-IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, BasicStream* stream)
+IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, InputStream* stream)
 {
     _is = stream;
 
-    BasicStream::Container::iterator start = _is->i;
+    InputStream::Container::iterator start = _is->i;
 
     //
     // Read the current.
@@ -614,11 +657,11 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, BasicStre
     if(obsv)
     {
         // Read the parameter encapsulation size.
-        Ice::Int sz;
-        _is->read(sz);
+        Ice::Int encapsSize;
+        _is->read(encapsSize);
         _is->i -= 4;
 
-        _observer.attach(obsv->getDispatchObserver(_current, static_cast<Int>(_is->i - start + sz)));
+        _observer.attach(obsv->getDispatchObserver(_current, static_cast<Int>(_is->i - start + encapsSize)));
     }
 
     //
@@ -644,72 +687,26 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, BasicStre
                 {
                     _servant = _locator->locate(_current, _cookie);
                 }
-                catch(const UserException& ex)
-                {
-                    Ice::EncodingVersion encoding = _is->skipEncaps(); // Required for batch requests.
-
-                    _observer.userException();
-
-                    if(_response)
-                    {
-                        _os.write(replyUserException);
-                        _os.startWriteEncaps(encoding, DefaultFormat);
-                        _os.write(ex);
-                        _os.endWriteEncaps();
-                        _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
-                        _responseHandler->sendResponse(_current.requestId, &_os, _compress, false);
-                    }
-                    else
-                    {
-                        _responseHandler->sendNoResponse();
-                    }
-
-                    _observer.detach();
-                    _responseHandler = 0;
-                    return;
-                }
                 catch(const std::exception& ex)
                 {
-                    _is->skipEncaps(); // Required for batch requests.
-                    __handleException(ex, false);
+                    skipReadParams(); // Required for batch requests.
+                    handleException(ex, false);
                     return;
                 }
                 catch(...)
                 {
-                    _is->skipEncaps(); // Required for batch requests.
-                    __handleException(false);
+                    skipReadParams(); // Required for batch requests.
+                    handleException("unknown c++ exception", false);
                     return;
                 }
             }
         }
     }
 
-    try
+    if(!_servant)
     {
-        if(_servant)
-        {
-            //
-            // DispatchAsync is a "pseudo dispatch status", used internally only
-            // to indicate async dispatch.
-            //
-            if(_servant->__dispatch(*this, _current) == DispatchAsync)
-            {
-                return;
-            }
-
-            if(_locator && !__servantLocatorFinished(false))
-            {
-                return;
-            }
-        }
-        else
+        try
         {
-            //
-            // Skip the input parameters, this is required for reading
-            // the next batch request if dispatching batch requests.
-            //
-            _is->skipEncaps();
-
             if(servantManager && servantManager->hasServant(_current.id))
             {
                 throw FacetNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
@@ -719,44 +716,76 @@ IceInternal::Incoming::invoke(const ServantManagerPtr& servantManager, BasicStre
                 throw ObjectNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
             }
         }
-    }
-    catch(const std::exception& ex)
-    {
-        if(_servant && _locator && !__servantLocatorFinished(false))
+        catch(const Ice::LocalException& ex)
         {
+            skipReadParams(); // Required for batch requests
+            handleException(ex, false);
             return;
         }
-        __handleException(ex, false);
-        return;
     }
-    catch(...)
+
+    try
     {
-        if(_servant && _locator && !__servantLocatorFinished(false))
+        //
+        // Dispatch in the incoming call
+        //
+        _servant->_iceDispatch(*this, _current);
+
+        //
+        // If the request was not dispatched asynchronously, send the response.
+        //
+        if(!_inAsync)
         {
-            return;
+            response(false);
         }
-        __handleException(false);
-        return;
     }
-
-    //
-    // Don't put the code below into the try block above. Exceptions
-    // in the code below are considered fatal, and must propagate to
-    // the caller of this operation.
-    //
-
-    if(_response)
+    catch(const std::exception& ex)
     {
-        _observer.reply(static_cast<Int>(_os.b.size() - headerSize - 4));
-        _responseHandler->sendResponse(_current.requestId, &_os, _compress, false);
+        if(_inAsync)
+        {
+            try
+            {
+                _inAsync->kill(*this);
+            }
+            catch(const Ice::ResponseSentException&)
+            {
+                const Ice::PropertiesPtr properties = _os.instance()->initializationData().properties;
+                if(properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
+                {
+                    if(const IceUtil::Exception* exc = dynamic_cast<const IceUtil::Exception*>(&ex))
+                    {
+                        warning(*exc);
+                    }
+                    else
+                    {
+                        warning(string("std::exception: ") + ex.what());
+                    }
+                }
+                return;
+            }
+        }
+        exception(ex, false);
     }
-    else
+    catch(...)
     {
-        _responseHandler->sendNoResponse();
+        if(_inAsync)
+        {
+            try
+            {
+                _inAsync->kill(*this);
+            }
+            catch(const Ice::ResponseSentException&)
+            {
+                const Ice::PropertiesPtr properties = _os.instance()->initializationData().properties;
+                if(properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0)
+                {
+                    warning("unknown c++ exception");
+                }
+                return;
+            }
+        }
+        exception("unknown c++ exception", false);
     }
-
-    _observer.detach();
-    _responseHandler = 0;
 }
 
 const Current&