diff options
Diffstat (limited to 'cppe/src')
54 files changed, 6013 insertions, 6009 deletions
diff --git a/cppe/src/IceE/BasicStream.cpp b/cppe/src/IceE/BasicStream.cpp index 62424ac4afd..32a01112f7a 100644 --- a/cppe/src/IceE/BasicStream.cpp +++ b/cppe/src/IceE/BasicStream.cpp @@ -27,23 +27,23 @@ IceInternal::BasicStream::clear() { while(_currentReadEncaps && _currentReadEncaps != &_preAllocatedReadEncaps) { - ReadEncaps* oldEncaps = _currentReadEncaps; - _currentReadEncaps = _currentReadEncaps->previous; - delete oldEncaps; + ReadEncaps* oldEncaps = _currentReadEncaps; + _currentReadEncaps = _currentReadEncaps->previous; + delete oldEncaps; } while(_currentWriteEncaps && _currentWriteEncaps != &_preAllocatedWriteEncaps) { - WriteEncaps* oldEncaps = _currentWriteEncaps; - _currentWriteEncaps = _currentWriteEncaps->previous; - delete oldEncaps; + WriteEncaps* oldEncaps = _currentWriteEncaps; + _currentWriteEncaps = _currentWriteEncaps->previous; + delete oldEncaps; } while(_seqDataStack) { - SeqData* oldSeqData = _seqDataStack; - _seqDataStack = _seqDataStack->previous; - delete oldSeqData; + SeqData* oldSeqData = _seqDataStack; + _seqDataStack = _seqDataStack->previous; + delete oldSeqData; } } @@ -65,34 +65,34 @@ IceInternal::BasicStream::swap(BasicStream& other) if(_currentReadEncaps || other._currentReadEncaps) { - _preAllocatedReadEncaps.swap(other._preAllocatedReadEncaps); + _preAllocatedReadEncaps.swap(other._preAllocatedReadEncaps); - if(!_currentReadEncaps) - { - _currentReadEncaps = &_preAllocatedReadEncaps; - other._currentReadEncaps = 0; - } - else if(!other._currentReadEncaps) - { - other._currentReadEncaps = &other._preAllocatedReadEncaps; - _currentReadEncaps = 0; - } + if(!_currentReadEncaps) + { + _currentReadEncaps = &_preAllocatedReadEncaps; + other._currentReadEncaps = 0; + } + else if(!other._currentReadEncaps) + { + other._currentReadEncaps = &other._preAllocatedReadEncaps; + _currentReadEncaps = 0; + } } if(_currentWriteEncaps || other._currentWriteEncaps) { - _preAllocatedWriteEncaps.swap(other._preAllocatedWriteEncaps); + _preAllocatedWriteEncaps.swap(other._preAllocatedWriteEncaps); - if(!_currentWriteEncaps) - { - _currentWriteEncaps = &_preAllocatedWriteEncaps; - other._currentWriteEncaps = 0; - } - else if(!other._currentWriteEncaps) - { - other._currentWriteEncaps = &other._preAllocatedWriteEncaps; - _currentWriteEncaps = 0; - } + if(!_currentWriteEncaps) + { + _currentWriteEncaps = &_preAllocatedWriteEncaps; + other._currentWriteEncaps = 0; + } + else if(!other._currentWriteEncaps) + { + other._currentWriteEncaps = &other._preAllocatedWriteEncaps; + _currentWriteEncaps = 0; + } } std::swap(_seqDataStack, other._seqDataStack); @@ -152,7 +152,7 @@ IceInternal::BasicStream::startSeq(int numElements, int minSize) { if(numElements == 0) // Optimization to avoid pushing a useless stack frame. { - return; + return; } // @@ -165,17 +165,17 @@ IceInternal::BasicStream::startSeq(int numElements, int minSize) int bytesLeft = static_cast<int>(b.end() - i); if(_seqDataStack->previous == 0) // Outermost sequence { - // - // The sequence must fit within the message. - // - if(numElements * minSize > bytesLeft) - { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); - } + // + // The sequence must fit within the message. + // + if(numElements * minSize > bytesLeft) + { + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + } } else // Nested sequence { - checkSeq(bytesLeft); + checkSeq(bytesLeft); } } @@ -185,17 +185,17 @@ IceInternal::BasicStream::checkFixedSeq(int numElements, int elemSize) int bytesLeft = static_cast<int>(b.end() - i); if(_seqDataStack == 0) // Outermost sequence { - // - // The sequence must fit within the message. - // - if(numElements * elemSize > bytesLeft) - { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); - } + // + // The sequence must fit within the message. + // + if(numElements * elemSize > bytesLeft) + { + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + } } else // Nested sequence { - checkSeq(bytesLeft - numElements * elemSize); + checkSeq(bytesLeft - numElements * elemSize); } } @@ -204,7 +204,7 @@ IceInternal::BasicStream::endSeq(int sz) { if(sz == 0) // Pop only if something was pushed previously. { - return; + return; } // @@ -251,11 +251,11 @@ IceInternal::BasicStream::skipEncaps() read(sz); if(sz < 0) { - throwNegativeSizeException(__FILE__, __LINE__); + throwNegativeSizeException(__FILE__, __LINE__); } if(i - sizeof(Int) + sz > b.end()) { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); } i += sz - sizeof(Int); } @@ -294,7 +294,7 @@ IceInternal::BasicStream::startReadSlice() read(sz); if(sz < 0) { - throwNegativeSizeException(__FILE__, __LINE__); + throwNegativeSizeException(__FILE__, __LINE__); } _readSlice = i - b.begin(); } @@ -311,12 +311,12 @@ IceInternal::BasicStream::skipSlice() read(sz); if(sz < 0) { - throwNegativeSizeException(__FILE__, __LINE__); + throwNegativeSizeException(__FILE__, __LINE__); } i += sz - sizeof(Int); if(i > b.end()) { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); } } @@ -325,9 +325,9 @@ IceInternal::BasicStream::writeBlob(const vector<Byte>& v) { if(!v.empty()) { - Container::size_type pos = b.size(); - resize(pos + v.size()); - memcpy(&b[pos], &v[0], v.size()); + Container::size_type pos = b.size(); + resize(pos + v.size()); + memcpy(&b[pos], &v[0], v.size()); } } @@ -336,16 +336,16 @@ IceInternal::BasicStream::readBlob(vector<Byte>& v, Int sz) { if(sz > 0) { - if(b.end() - i < sz) - { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); - } - vector<Byte>(i, i + sz).swap(v); - i += sz; + if(b.end() - i < sz) + { + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + } + vector<Byte>(i, i + sz).swap(v); + i += sz; } else { - v.clear(); + v.clear(); } } @@ -356,14 +356,14 @@ IceInternal::BasicStream::read(pair<const Byte*, const Byte*>& v) readSize(sz); if(sz > 0) { - checkFixedSeq(sz, 1); - v.first = i; - v.second = i + sz; - i += sz; + checkFixedSeq(sz, 1); + v.first = i; + v.second = i + sz; + i += sz; } else { - v.first = v.second = i; + v.first = v.second = i; } } @@ -374,9 +374,9 @@ IceInternal::BasicStream::write(const Byte* begin, const Byte* end) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz); - memcpy(&b[pos], begin, sz); + Container::size_type pos = b.size(); + resize(pos + sz); + memcpy(&b[pos], begin, sz); } } @@ -387,9 +387,9 @@ IceInternal::BasicStream::write(const vector<bool>& v) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz); - copy(v.begin(), v.end(), b.begin() + pos); + Container::size_type pos = b.size(); + resize(pos + sz); + copy(v.begin(), v.end(), b.begin() + pos); } } @@ -403,7 +403,7 @@ struct BasicStreamWriteBoolHelper { for(int idx = 0; idx < sz; ++idx) { - b[pos + idx] = static_cast<Ice::Byte>(*(begin + idx)); + b[pos + idx] = static_cast<Ice::Byte>(*(begin + idx)); } } }; @@ -428,7 +428,7 @@ IceInternal::BasicStream::write(const bool* begin, const bool* end) { Container::size_type pos = b.size(); resize(pos + sz); - BasicStreamWriteBoolHelper<sizeof(bool)>::write(begin, pos, b, sz); + BasicStreamWriteBoolHelper<sizeof(bool)>::write(begin, pos, b, sz); } } @@ -461,11 +461,11 @@ struct BasicStreamReadBoolHelper bool* array = new bool[sz]; for(int idx = 0; idx < sz; ++idx) { - array[idx] = static_cast<bool>(*(i + idx)); + array[idx] = static_cast<bool>(*(i + idx)); } v.first = array; v.second = array + sz; - return array; + return array; } }; @@ -476,7 +476,7 @@ struct BasicStreamReadBoolHelper<1> { v.first = reinterpret_cast<bool*>(i); v.second = reinterpret_cast<bool*>(i) + sz; - return 0; + return 0; } }; @@ -491,7 +491,7 @@ IceInternal::BasicStream::read(pair<const bool*, const bool*>& v) if(sz > 0) { checkFixedSeq(sz, 1); - result = BasicStreamReadBoolHelper<sizeof(bool)>::read(v, sz, i); + result = BasicStreamReadBoolHelper<sizeof(bool)>::read(v, sz, i); i += sz; } else @@ -524,7 +524,7 @@ IceInternal::BasicStream::read(Short& v) { if(b.end() - i < static_cast<int>(sizeof(Short))) { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); } const Byte* src = &(*i); i += sizeof(Short); @@ -546,19 +546,19 @@ IceInternal::BasicStream::write(const Short* begin, const Short* end) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz * sizeof(Short)); + Container::size_type pos = b.size(); + resize(pos + sz * sizeof(Short)); #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Short) - 1; - Byte* dest = &(*(b.begin() + pos)); - for(int j = 0 ; j < sz ; ++j) - { - *dest++ = *src--; - *dest++ = *src--; - src += 2 * sizeof(Short); - } + const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Short) - 1; + Byte* dest = &(*(b.begin() + pos)); + for(int j = 0 ; j < sz ; ++j) + { + *dest++ = *src--; + *dest++ = *src--; + src += 2 * sizeof(Short); + } #else - memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Short)); + memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Short)); #endif } } @@ -570,26 +570,26 @@ IceInternal::BasicStream::read(vector<Short>& v) readSize(sz); if(sz > 0) { - checkFixedSeq(sz, static_cast<int>(sizeof(Short))); - Container::iterator begin = i; - i += sz * static_cast<int>(sizeof(Short)); - v.resize(sz); + checkFixedSeq(sz, static_cast<int>(sizeof(Short))); + Container::iterator begin = i; + i += sz * static_cast<int>(sizeof(Short)); + v.resize(sz); #ifdef ICE_BIG_ENDIAN - const Byte* src = &(*begin); - Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Short) - 1; - for(int j = 0 ; j < sz ; ++j) - { - *dest-- = *src++; - *dest-- = *src++; - dest += 2 * sizeof(Short); - } + const Byte* src = &(*begin); + Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Short) - 1; + for(int j = 0 ; j < sz ; ++j) + { + *dest-- = *src++; + *dest-- = *src++; + dest += 2 * sizeof(Short); + } #else - copy(begin, i, reinterpret_cast<Byte*>(&v[0])); + copy(begin, i, reinterpret_cast<Byte*>(&v[0])); #endif } else { - v.clear(); + v.clear(); } } @@ -641,21 +641,21 @@ IceInternal::BasicStream::write(const Int* begin, const Int* end) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz * sizeof(Int)); + Container::size_type pos = b.size(); + resize(pos + sz * sizeof(Int)); #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Int) - 1; - Byte* dest = &(*(b.begin() + pos)); - for(int j = 0 ; j < sz ; ++j) - { - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - src += 2 * sizeof(Int); - } + const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Int) - 1; + Byte* dest = &(*(b.begin() + pos)); + for(int j = 0 ; j < sz ; ++j) + { + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + src += 2 * sizeof(Int); + } #else - memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Int)); + memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Int)); #endif } } @@ -667,28 +667,28 @@ IceInternal::BasicStream::read(vector<Int>& v) readSize(sz); if(sz > 0) { - checkFixedSeq(sz, static_cast<int>(sizeof(Int))); - Container::iterator begin = i; - i += sz * static_cast<int>(sizeof(Int)); - v.resize(sz); + checkFixedSeq(sz, static_cast<int>(sizeof(Int))); + Container::iterator begin = i; + i += sz * static_cast<int>(sizeof(Int)); + v.resize(sz); #ifdef ICE_BIG_ENDIAN - const Byte* src = &(*begin); - Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Int) - 1; - for(int j = 0 ; j < sz ; ++j) - { - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - dest += 2 * sizeof(Int); - } + const Byte* src = &(*begin); + Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Int) - 1; + for(int j = 0 ; j < sz ; ++j) + { + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + dest += 2 * sizeof(Int); + } #else - copy(begin, i, reinterpret_cast<Byte*>(&v[0])); + copy(begin, i, reinterpret_cast<Byte*>(&v[0])); #endif } else { - v.clear(); + v.clear(); } } @@ -769,7 +769,7 @@ IceInternal::BasicStream::read(Long& v) { if(b.end() - i < static_cast<int>(sizeof(Long))) { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); } const Byte* src = &(*i); i += sizeof(Long); @@ -803,25 +803,25 @@ IceInternal::BasicStream::write(const Long* begin, const Long* end) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz * sizeof(Long)); + Container::size_type pos = b.size(); + resize(pos + sz * sizeof(Long)); #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Long) - 1; - Byte* dest = &(*(b.begin() + pos)); - for(int j = 0 ; j < sz ; ++j) - { - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - src += 2 * sizeof(Long); - } + const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Long) - 1; + Byte* dest = &(*(b.begin() + pos)); + for(int j = 0 ; j < sz ; ++j) + { + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + src += 2 * sizeof(Long); + } #else - memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Long)); + memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Long)); #endif } } @@ -833,32 +833,32 @@ IceInternal::BasicStream::read(vector<Long>& v) readSize(sz); if(sz > 0) { - checkFixedSeq(sz, static_cast<int>(sizeof(Long))); - Container::iterator begin = i; - i += sz * static_cast<int>(sizeof(Long)); - v.resize(sz); + checkFixedSeq(sz, static_cast<int>(sizeof(Long))); + Container::iterator begin = i; + i += sz * static_cast<int>(sizeof(Long)); + v.resize(sz); #ifdef ICE_BIG_ENDIAN - const Byte* src = &(*begin); - Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Long) - 1; - for(int j = 0 ; j < sz ; ++j) - { - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - dest += 2 * sizeof(Long); - } + const Byte* src = &(*begin); + Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Long) - 1; + for(int j = 0 ; j < sz ; ++j) + { + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + dest += 2 * sizeof(Long); + } #else - copy(begin, i, reinterpret_cast<Byte*>(&v[0])); + copy(begin, i, reinterpret_cast<Byte*>(&v[0])); #endif } else { - v.clear(); + v.clear(); } } @@ -935,7 +935,7 @@ IceInternal::BasicStream::read(Float& v) { if(b.end() - i < static_cast<int>(sizeof(Float))) { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); } const Byte* src = &(*i); i += sizeof(Float); @@ -961,21 +961,21 @@ IceInternal::BasicStream::write(const Float* begin, const Float* end) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz * sizeof(Float)); + Container::size_type pos = b.size(); + resize(pos + sz * sizeof(Float)); #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Float) - 1; - Byte* dest = &(*(b.begin() + pos)); - for(int j = 0 ; j < sz ; ++j) - { - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - src += 2 * sizeof(Float); - } + const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Float) - 1; + Byte* dest = &(*(b.begin() + pos)); + for(int j = 0 ; j < sz ; ++j) + { + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + src += 2 * sizeof(Float); + } #else - memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Float)); + memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Float)); #endif } } @@ -987,28 +987,28 @@ IceInternal::BasicStream::read(vector<Float>& v) readSize(sz); if(sz > 0) { - checkFixedSeq(sz, static_cast<int>(sizeof(Float))); - Container::iterator begin = i; - i += sz * static_cast<int>(sizeof(Float)); - v.resize(sz); + checkFixedSeq(sz, static_cast<int>(sizeof(Float))); + Container::iterator begin = i; + i += sz * static_cast<int>(sizeof(Float)); + v.resize(sz); #ifdef ICE_BIG_ENDIAN - const Byte* src = &(*begin); - Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Float) - 1; - for(int j = 0 ; j < sz ; ++j) - { - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - dest += 2 * sizeof(Float); - } + const Byte* src = &(*begin); + Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Float) - 1; + for(int j = 0 ; j < sz ; ++j) + { + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + dest += 2 * sizeof(Float); + } #else - copy(begin, i, reinterpret_cast<Byte*>(&v[0])); + copy(begin, i, reinterpret_cast<Byte*>(&v[0])); #endif } else { - v.clear(); + v.clear(); } } @@ -1100,7 +1100,7 @@ IceInternal::BasicStream::read(Double& v) { if(b.end() - i < static_cast<int>(sizeof(Double))) { - throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); + throwUnmarshalOutOfBoundsException(__FILE__, __LINE__); } const Byte* src = &(*i); i += sizeof(Double); @@ -1145,28 +1145,28 @@ IceInternal::BasicStream::write(const Double* begin, const Double* end) writeSize(sz); if(sz > 0) { - Container::size_type pos = b.size(); - resize(pos + sz * sizeof(Double)); + Container::size_type pos = b.size(); + resize(pos + sz * sizeof(Double)); #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Double) - 1; - Byte* dest = &(*(b.begin() + pos)); - for(int j = 0 ; j < sz ; ++j) - { - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - src += 2 * sizeof(Double); - } + const Byte* src = reinterpret_cast<const Byte*>(begin) + sizeof(Double) - 1; + Byte* dest = &(*(b.begin() + pos)); + for(int j = 0 ; j < sz ; ++j) + { + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + src += 2 * sizeof(Double); + } #elif defined(__arm__) && defined(__linux) - const Byte* src = reinterpret_cast<const Byte*>(begin); - Byte* dest = &(*(b.begin() + pos)); - for(int j = 0 ; j < sz ; ++j) - { + const Byte* src = reinterpret_cast<const Byte*>(begin); + Byte* dest = &(*(b.begin() + pos)); + for(int j = 0 ; j < sz ; ++j) + { dest[4] = *src++; dest[5] = *src++; dest[6] = *src++; @@ -1176,9 +1176,9 @@ IceInternal::BasicStream::write(const Double* begin, const Double* end) dest[2] = *src++; dest[3] = *src++; dest += sizeof(Double); - } + } #else - memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Double)); + memcpy(&b[pos], reinterpret_cast<const Byte*>(begin), sz * sizeof(Double)); #endif } } @@ -1190,47 +1190,47 @@ IceInternal::BasicStream::read(vector<Double>& v) readSize(sz); if(sz > 0) { - checkFixedSeq(sz, static_cast<int>(sizeof(Double))); - Container::iterator begin = i; - i += sz * static_cast<int>(sizeof(Double)); - v.resize(sz); + checkFixedSeq(sz, static_cast<int>(sizeof(Double))); + Container::iterator begin = i; + i += sz * static_cast<int>(sizeof(Double)); + v.resize(sz); #ifdef ICE_BIG_ENDIAN - const Byte* src = &(*begin); - Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Double) - 1; - for(int j = 0 ; j < sz ; ++j) - { - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - *dest-- = *src++; - dest += 2 * sizeof(Double); - } + const Byte* src = &(*begin); + Byte* dest = reinterpret_cast<Byte*>(&v[0]) + sizeof(Double) - 1; + for(int j = 0 ; j < sz ; ++j) + { + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + *dest-- = *src++; + dest += 2 * sizeof(Double); + } #elif defined(__arm__) && defined(__linux) - const Byte* src = &(*begin); - Byte* dest = reinterpret_cast<Byte*>(&v[0]); - for(int j = 0 ; j < sz ; ++j) - { - dest[4] = *src++; - dest[5] = *src++; - dest[6] = *src++; - dest[7] = *src++; - dest[0] = *src++; - dest[1] = *src++; - dest[2] = *src++; - dest[3] = *src++; - dest += sizeof(Double); - } + const Byte* src = &(*begin); + Byte* dest = reinterpret_cast<Byte*>(&v[0]); + for(int j = 0 ; j < sz ; ++j) + { + dest[4] = *src++; + dest[5] = *src++; + dest[6] = *src++; + dest[7] = *src++; + dest[0] = *src++; + dest[1] = *src++; + dest[2] = *src++; + dest[3] = *src++; + dest += sizeof(Double); + } #else - copy(begin, i, reinterpret_cast<Byte*>(&v[0])); + copy(begin, i, reinterpret_cast<Byte*>(&v[0])); #endif } else { - v.clear(); + v.clear(); } } @@ -1381,10 +1381,10 @@ IceInternal::BasicStream::write(const string* begin, const string* end, bool con writeSize(sz); if(sz > 0) { - for(int i = 0; i < sz; ++i) - { - write(begin[i], convert); - } + for(int i = 0; i < sz; ++i) + { + write(begin[i], convert); + } } } @@ -1395,19 +1395,19 @@ IceInternal::BasicStream::read(vector<string>& v, bool convert) readSize(sz); if(sz > 0) { - startSeq(sz, 1); - v.resize(sz); - for(int i = 0; i < sz; ++i) - { - read(v[i], convert); - checkSeq(); - endElement(); - } - endSeq(sz); + startSeq(sz, 1); + v.resize(sz); + for(int i = 0; i < sz; ++i) + { + read(v[i], convert); + checkSeq(); + endElement(); + } + endSeq(sz); } else { - v.clear(); + v.clear(); } } @@ -1510,7 +1510,7 @@ IceInternal::BasicStream::read(vector<wstring>& v) } else { - v.clear(); + v.clear(); } } @@ -1545,33 +1545,33 @@ IceInternal::BasicStream::throwException() read(id, false); for(;;) { - // - // Look for a factory for this ID. - // - UserExceptionFactoryPtr factory = factoryTable->getExceptionFactory(id); - if(factory) - { - // - // Got factory -- get the factory to instantiate the - // exception, initialize the exception members, and throw - // the exception. - // - try - { - factory->createAndThrow(); - } - catch(UserException& ex) - { - ex.__read(this, false); - assert(!usesClasses); - ex.ice_throw(); - } - } - else - { - skipSlice(); // Slice off what we don't understand. - read(id, false); // Read type id for next slice. - } + // + // Look for a factory for this ID. + // + UserExceptionFactoryPtr factory = factoryTable->getExceptionFactory(id); + if(factory) + { + // + // Got factory -- get the factory to instantiate the + // exception, initialize the exception members, and throw + // the exception. + // + try + { + factory->createAndThrow(); + } + catch(UserException& ex) + { + ex.__read(this, false); + assert(!usesClasses); + ex.ice_throw(); + } + } + else + { + skipSlice(); // Slice off what we don't understand. + read(id, false); // Read type id for next slice. + } } // diff --git a/cppe/src/IceE/Buffer.cpp b/cppe/src/IceE/Buffer.cpp index 55ac2fb2fb6..94025d59d1e 100644 --- a/cppe/src/IceE/Buffer.cpp +++ b/cppe/src/IceE/Buffer.cpp @@ -35,32 +35,32 @@ IceInternal::Buffer::Container::swap(Container& other) #ifdef ICE_SMALL_MESSAGE_BUFFER_OPTIMIZATION if(_buf == _fixed) { - if(other._buf == other._fixed) - { - value_type tmp[ICE_BUFFER_FIXED_SIZE]; - memcpy(tmp, _fixed, _size); - memcpy(_fixed, other._fixed, other._size); - memcpy(other._fixed, tmp, _size); - } - else - { - _buf = other._buf; - memcpy(other._fixed, _fixed, _size); - other._buf = other._fixed; - } + if(other._buf == other._fixed) + { + value_type tmp[ICE_BUFFER_FIXED_SIZE]; + memcpy(tmp, _fixed, _size); + memcpy(_fixed, other._fixed, other._size); + memcpy(other._fixed, tmp, _size); + } + else + { + _buf = other._buf; + memcpy(other._fixed, _fixed, _size); + other._buf = other._fixed; + } } else { - if(other._buf == other._fixed) - { - other._buf = _buf; - memcpy(_fixed, other._fixed, other._size); - _buf = _fixed; - } - else - { - std::swap(_buf, other._buf); - } + if(other._buf == other._fixed) + { + other._buf = _buf; + memcpy(_fixed, other._fixed, other._size); + _buf = _fixed; + } + else + { + std::swap(_buf, other._buf); + } } #else std::swap(_buf, other._buf); @@ -77,8 +77,8 @@ IceInternal::Buffer::Container::clear() #ifdef ICE_SMALL_MESSAGE_BUFFER_OPTIMIZATION if(_buf != _fixed) { - free(_buf); - _buf = _fixed; + free(_buf); + _buf = _fixed; } _size = 0; _capacity = ICE_BUFFER_FIXED_SIZE; @@ -95,43 +95,43 @@ IceInternal::Buffer::Container::reserve(size_type n) { if(n > _capacity) { - _capacity = std::max<size_type>(n, std::min(2 * _capacity, _maxCapacity)); - _capacity = std::max<size_type>(static_cast<size_type>(240), _capacity); + _capacity = std::max<size_type>(n, std::min(2 * _capacity, _maxCapacity)); + _capacity = std::max<size_type>(static_cast<size_type>(240), _capacity); } else if(n < _capacity) { - _capacity = n; + _capacity = n; } else { - return; + return; } #ifdef ICE_SMALL_MESSAGE_BUFFER_OPTIMIZATION if(_buf != _fixed) { - _buf = reinterpret_cast<pointer>(realloc(_buf, _capacity)); + _buf = reinterpret_cast<pointer>(realloc(_buf, _capacity)); } else if(_capacity > ICE_BUFFER_FIXED_SIZE) { - _buf = reinterpret_cast<pointer>(malloc(_capacity)); - memcpy(_buf, _fixed, _size); + _buf = reinterpret_cast<pointer>(malloc(_capacity)); + memcpy(_buf, _fixed, _size); } #else if(_buf) { - _buf = reinterpret_cast<pointer>(realloc(_buf, _capacity)); + _buf = reinterpret_cast<pointer>(realloc(_buf, _capacity)); } else { - _buf = reinterpret_cast<pointer>(malloc(_capacity)); + _buf = reinterpret_cast<pointer>(malloc(_capacity)); } #endif - + if(!_buf) { - SyscallException ex(__FILE__, __LINE__); - ex.error = getSystemErrno(); - throw ex; + SyscallException ex(__FILE__, __LINE__); + ex.error = getSystemErrno(); + throw ex; } } diff --git a/cppe/src/IceE/Communicator.cpp b/cppe/src/IceE/Communicator.cpp index 2bfa0b04ee2..c25d2860d09 100644 --- a/cppe/src/IceE/Communicator.cpp +++ b/cppe/src/IceE/Communicator.cpp @@ -102,9 +102,9 @@ Ice::Communicator::createObjectAdapterWithEndpoints(const string& name, const st { return _instance->objectAdapterFactory()->createObjectAdapter(name, endpoints #ifdef ICEE_HAS_ROUTER - , 0 + , 0 # endif - ); + ); } #ifdef ICEE_HAS_ROUTER @@ -178,12 +178,12 @@ Ice::Communicator::Communicator(const InitializationData& initData) __setNoDelete(true); try { - const_cast<InstancePtr&>(_instance) = new Instance(this, initData); + const_cast<InstancePtr&>(_instance) = new Instance(this, initData); } catch(...) { - __setNoDelete(false); - throw; + __setNoDelete(false); + throw; } __setNoDelete(false); } @@ -192,8 +192,8 @@ Ice::Communicator::~Communicator() { if(!_instance->destroyed()) { - Warning out(_instance->initializationData().logger); - out << "Ice::Communicator::destroy() has not been called"; + Warning out(_instance->initializationData().logger); + out << "Ice::Communicator::destroy() has not been called"; } } @@ -202,11 +202,11 @@ Ice::Communicator::finishSetup(int& argc, char* argv[]) { try { - _instance->finishSetup(argc, argv); + _instance->finishSetup(argc, argv); } catch(...) { - _instance->destroy(); - throw; + _instance->destroy(); + throw; } } diff --git a/cppe/src/IceE/Cond.cpp b/cppe/src/IceE/Cond.cpp index a761cb9f894..760cdd612d8 100644 --- a/cppe/src/IceE/Cond.cpp +++ b/cppe/src/IceE/Cond.cpp @@ -20,7 +20,7 @@ IceUtil::Semaphore::Semaphore(long initial) _sem = CreateSemaphore(0, initial, 0x7fffffff, 0); if(_sem == INVALID_HANDLE_VALUE) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -35,7 +35,7 @@ IceUtil::Semaphore::wait() const int rc = WaitForSingleObject(_sem, INFINITE); if(rc != WAIT_OBJECT_0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -47,7 +47,7 @@ IceUtil::Semaphore::timedWait(const Time& timeout) const int rc = WaitForSingleObject(_sem, msec); if(rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } return rc != WAIT_TIMEOUT; } @@ -58,7 +58,7 @@ IceUtil::Semaphore::post(int count) const int rc = ReleaseSemaphore(_sem, count, 0); if(rc == 0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -97,26 +97,26 @@ IceUtil::Cond::wake(bool broadcast) if(_unblocked != 0) { - _blocked -= _unblocked; - _unblocked = 0; + _blocked -= _unblocked; + _unblocked = 0; } if(_blocked > 0) { - // - // Unblock some number of waiters. - // - _toUnblock = (broadcast) ? _blocked : 1; - _internal.unlock(); - _queue.post(); + // + // Unblock some number of waiters. + // + _toUnblock = (broadcast) ? _blocked : 1; + _internal.unlock(); + _queue.post(); } else { - // - // Otherwise no blocked waiters, release gate & mutex. - // - _gate.post(); - _internal.unlock(); + // + // Otherwise no blocked waiters, release gate & mutex. + // + _gate.post(); + _internal.unlock(); } } @@ -136,26 +136,26 @@ IceUtil::Cond::postWait(bool timedOut) const if(_toUnblock != 0) { - bool last = --_toUnblock == 0; - _internal.unlock(); - - if(timedOut) - { - _queue.wait(); - } - - if(last) - { - _gate.post(); - } - else - { - _queue.post(); - } + bool last = --_toUnblock == 0; + _internal.unlock(); + + if(timedOut) + { + _queue.wait(); + } + + if(last) + { + _gate.post(); + } + else + { + _queue.post(); + } } else { - _internal.unlock(); + _internal.unlock(); } } @@ -164,13 +164,13 @@ IceUtil::Cond::dowait() const { try { - _queue.wait(); - postWait(false); + _queue.wait(); + postWait(false); } catch(...) { - postWait(false); - throw; + postWait(false); + throw; } } @@ -179,14 +179,14 @@ IceUtil::Cond::timedDowait(const Time& timeout) const { try { - bool rc = _queue.timedWait(timeout); - postWait(!rc); - return rc; + bool rc = _queue.timedWait(timeout); + postWait(!rc); + return rc; } catch(...) { - postWait(false); - throw; + postWait(false); + throw; } } @@ -201,19 +201,19 @@ IceUtil::Cond::Cond() rc = pthread_condattr_init(&attr); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } rc = pthread_cond_init(&_cond, &attr); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } rc = pthread_condattr_destroy(&attr); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } } @@ -230,7 +230,7 @@ IceUtil::Cond::signal() int rc = pthread_cond_signal(&_cond); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } } @@ -240,7 +240,7 @@ IceUtil::Cond::broadcast() int rc = pthread_cond_broadcast(&_cond); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } } diff --git a/cppe/src/IceE/Connection.cpp b/cppe/src/IceE/Connection.cpp index 122f61a6aaf..f133b99f572 100644 --- a/cppe/src/IceE/Connection.cpp +++ b/cppe/src/IceE/Connection.cpp @@ -41,13 +41,13 @@ Ice::Connection::waitForValidation() while(_state == StateNotValidated) { - wait(); + wait(); } if(_state >= StateClosing) { - assert(_exception.get()); - _exception->ice_throw(); + assert(_exception.get()); + _exception->ice_throw(); } } @@ -75,18 +75,18 @@ Ice::Connection::destroy(DestructionReason reason) switch(reason) { #ifndef ICEE_PURE_CLIENT - case ObjectAdapterDeactivated: - { - setState(StateClosing, ObjectAdapterDeactivatedException(__FILE__, __LINE__)); - break; - } + case ObjectAdapterDeactivated: + { + setState(StateClosing, ObjectAdapterDeactivatedException(__FILE__, __LINE__)); + break; + } #endif - case CommunicatorDestroyed: - { - setState(StateClosing, CommunicatorDestroyedException(__FILE__, __LINE__)); - break; - } + case CommunicatorDestroyed: + { + setState(StateClosing, CommunicatorDestroyedException(__FILE__, __LINE__)); + break; + } } } @@ -97,25 +97,25 @@ Ice::Connection::close(bool force) if(force) { - setState(StateClosed, ForcedCloseConnectionException(__FILE__, __LINE__)); + setState(StateClosed, ForcedCloseConnectionException(__FILE__, __LINE__)); } else { #ifndef ICEE_PURE_BLOCKING_CLIENT - // - // If we do a graceful shutdown, then we wait until all - // outstanding requests have been completed. Otherwise, the - // CloseConnectionException will cause all outstanding - // requests to be retried, regardless of whether the server - // has processed them or not. - // - while(!_requests.empty()) - { - wait(); - } + // + // If we do a graceful shutdown, then we wait until all + // outstanding requests have been completed. Otherwise, the + // CloseConnectionException will cause all outstanding + // requests to be retried, regardless of whether the server + // has processed them or not. + // + while(!_requests.empty()) + { + wait(); + } #endif - setState(StateClosing, CloseConnectionException(__FILE__, __LINE__)); + setState(StateClosing, CloseConnectionException(__FILE__, __LINE__)); } } @@ -140,32 +140,32 @@ Ice::Connection::isFinished() const #endif { - // - // We can use trylock here, because as long as there are still - // threads operating in this connection object, connection - // destruction is considered as not yet finished. - // - IceUtil::Monitor<IceUtil::Mutex>::TryLock sync(*this); - - if(!sync.acquired()) - { - return false; - } + // + // We can use trylock here, because as long as there are still + // threads operating in this connection object, connection + // destruction is considered as not yet finished. + // + IceUtil::Monitor<IceUtil::Mutex>::TryLock sync(*this); + + if(!sync.acquired()) + { + return false; + } - if(_transceiver != 0 + if(_transceiver != 0 #ifndef ICEE_PURE_BLOCKING_CLIENT - || _dispatchCount != 0 || (_threadPerConnection && _threadPerConnection->isAlive()) + || _dispatchCount != 0 || (_threadPerConnection && _threadPerConnection->isAlive()) #endif - ) - { - return false; - } + ) + { + return false; + } - assert(_state == StateClosed); + assert(_state == StateClosed); #ifndef ICEE_PURE_BLOCKING_CLIENT - threadPerConnection = _threadPerConnection; - _threadPerConnection = 0; + threadPerConnection = _threadPerConnection; + _threadPerConnection = 0; #endif } @@ -200,7 +200,7 @@ Ice::Connection::waitUntilHolding() const while(_state < StateHolding || _dispatchCount > 0) { - wait(); + wait(); } } @@ -214,74 +214,74 @@ Ice::Connection::waitUntilFinished() #endif { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // We wait indefinitely until connection closing has been - // initiated. We also wait indefinitely until all outstanding - // requests are completed. Otherwise we couldn't guarantee - // that there are no outstanding calls when deactivate() is - // called on the servant locators. - // - while(_state < StateClosing || _dispatchCount > 0) - { - wait(); - } - - // - // Now we must wait until close() has been called on the - // transceiver. - // - while(_transceiver) - { - if(_state != StateClosed && _endpoint->timeout() >= 0) - { - IceUtil::Time timeout = IceUtil::Time::milliSeconds(_endpoint->timeout()); - IceUtil::Time waitTime = _stateTime + timeout - IceUtil::Time::now(); - - if(waitTime > IceUtil::Time()) - { - // - // We must wait a bit longer until we close this - // connection. - // - if(!timedWait(waitTime)) - { - setState(StateClosed, CloseTimeoutException(__FILE__, __LINE__)); - } - } - else - { - // - // We already waited long enough, so let's close this - // connection! - // - setState(StateClosed, CloseTimeoutException(__FILE__, __LINE__)); - } - - // - // No return here, we must still wait until close() is - // called on the _transceiver. - // - } - else - { - wait(); - } - } - - assert(_state == StateClosed); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // We wait indefinitely until connection closing has been + // initiated. We also wait indefinitely until all outstanding + // requests are completed. Otherwise we couldn't guarantee + // that there are no outstanding calls when deactivate() is + // called on the servant locators. + // + while(_state < StateClosing || _dispatchCount > 0) + { + wait(); + } + + // + // Now we must wait until close() has been called on the + // transceiver. + // + while(_transceiver) + { + if(_state != StateClosed && _endpoint->timeout() >= 0) + { + IceUtil::Time timeout = IceUtil::Time::milliSeconds(_endpoint->timeout()); + IceUtil::Time waitTime = _stateTime + timeout - IceUtil::Time::now(); + + if(waitTime > IceUtil::Time()) + { + // + // We must wait a bit longer until we close this + // connection. + // + if(!timedWait(waitTime)) + { + setState(StateClosed, CloseTimeoutException(__FILE__, __LINE__)); + } + } + else + { + // + // We already waited long enough, so let's close this + // connection! + // + setState(StateClosed, CloseTimeoutException(__FILE__, __LINE__)); + } + + // + // No return here, we must still wait until close() is + // called on the _transceiver. + // + } + else + { + wait(); + } + } + + assert(_state == StateClosed); #ifndef ICEE_PURE_BLOCKING_CLIENT - threadPerConnection = _threadPerConnection; - _threadPerConnection = 0; + threadPerConnection = _threadPerConnection; + _threadPerConnection = 0; #endif } #ifndef ICEE_PURE_BLOCKING_CLIENT if(threadPerConnection) { - threadPerConnection->getThreadControl().join(); + threadPerConnection->getThreadControl().join(); } #endif } @@ -292,194 +292,194 @@ Ice::Connection::sendRequest(BasicStream* os, Outgoing* out) bool requestSent = false; try { - Lock sendSync(_sendMonitor); - if(!_transceiver) - { - assert(_exception.get()); - // - // If the connection is closed before we even have a chance - // to send our request, we always try to send the request - // again. - // - throw LocalExceptionWrapper(*_exception.get(), true); - } - - Int requestId; - if(out) - { - // - // Create a new unique request ID. - // - requestId = _nextRequestId++; - if(requestId <= 0) - { - _nextRequestId = 1; - requestId = _nextRequestId++; - } - - // - // Fill in the request ID. - // - Byte* dest = &(os->b[0]) + headerSize; + Lock sendSync(_sendMonitor); + if(!_transceiver) + { + assert(_exception.get()); + // + // If the connection is closed before we even have a chance + // to send our request, we always try to send the request + // again. + // + throw LocalExceptionWrapper(*_exception.get(), true); + } + + Int requestId; + if(out) + { + // + // Create a new unique request ID. + // + requestId = _nextRequestId++; + if(requestId <= 0) + { + _nextRequestId = 1; + requestId = _nextRequestId++; + } + + // + // Fill in the request ID. + // + Byte* dest = &(os->b[0]) + headerSize; #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(&requestId) + sizeof(Ice::Int) - 1; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&requestId) + sizeof(Ice::Int) - 1; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest = *src; #else - const Byte* src = reinterpret_cast<const Byte*>(&requestId); - *dest++ = *src++; - *dest++ = *src++; - *dest++ = *src++; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&requestId); + *dest++ = *src++; + *dest++ = *src++; + *dest++ = *src++; + *dest = *src; #endif #ifndef ICEE_PURE_BLOCKING_CLIENT - if(!_blocking) - { - _requestsHint = _requests.insert(_requests.end(), pair<const Int, Outgoing*>(requestId, out)); - } + if(!_blocking) + { + _requestsHint = _requests.insert(_requests.end(), pair<const Int, Outgoing*>(requestId, out)); + } #endif - } + } - // - // Fill in the message size. - // - const Int sz = static_cast<Int>(os->b.size()); - Byte* dest = &(os->b[0]) + 10; + // + // Fill in the message size. + // + const Int sz = static_cast<Int>(os->b.size()); + Byte* dest = &(os->b[0]) + 10; #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(&sz) + sizeof(Ice::Int) - 1; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&sz) + sizeof(Ice::Int) - 1; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest = *src; #else - const Byte* src = reinterpret_cast<const Byte*>(&sz); - *dest++ = *src++; - *dest++ = *src++; - *dest++ = *src++; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&sz); + *dest++ = *src++; + *dest++ = *src++; + *dest++ = *src++; + *dest = *src; #endif - - // - // Send the request. - // - os->i = os->b.begin(); - if(_traceLevels->protocol >= 1) - { - traceRequest("sending request", *os, _logger, _traceLevels); - } - _transceiver->write(*os); - requestSent = true; - - if(!out) - { - return; - } - + + // + // Send the request. + // + os->i = os->b.begin(); + if(_traceLevels->protocol >= 1) + { + traceRequest("sending request", *os, _logger, _traceLevels); + } + _transceiver->write(*os); + requestSent = true; + + if(!out) + { + return; + } + #ifndef ICEE_PURE_BLOCKING_CLIENT - if(_blocking) - { + if(_blocking) + { #endif - // - // Re-use the stream for reading the reply. - // - os->reset(); - - Int receivedRequestId = 0; + // + // Re-use the stream for reading the reply. + // + os->reset(); + + Int receivedRequestId = 0; #ifndef ICEE_PURE_CLIENT - Int invokeNum = 0; - readStreamAndParseMessage(*os, receivedRequestId, invokeNum); - if(invokeNum > 0) - { - throwUnknownMessageException(__FILE__, __LINE__); - } - else if(requestId != receivedRequestId) - { - throwUnknownRequestIdException(__FILE__, __LINE__); - } + Int invokeNum = 0; + readStreamAndParseMessage(*os, receivedRequestId, invokeNum); + if(invokeNum > 0) + { + throwUnknownMessageException(__FILE__, __LINE__); + } + else if(requestId != receivedRequestId) + { + throwUnknownRequestIdException(__FILE__, __LINE__); + } #else - readStreamAndParseMessage(*os, receivedRequestId); - if(requestId != receivedRequestId) - { - throwUnknownRequestIdException(__FILE__, __LINE__); - } + readStreamAndParseMessage(*os, receivedRequestId); + if(requestId != receivedRequestId) + { + throwUnknownRequestIdException(__FILE__, __LINE__); + } #endif - out->finished(*os); + out->finished(*os); #ifndef ICEE_PURE_BLOCKING_CLIENT - } - else - { - // - // Wait until the request has completed, or until the request times out. - // - Int tout = timeout(); - IceUtil::Time expireTime; - if(tout > 0) - { - expireTime = IceUtil::Time::now() + IceUtil::Time::milliSeconds(tout); - } - - while(out->state() == Outgoing::StateInProgress) - { - if(tout > 0) - { - IceUtil::Time now = IceUtil::Time::now(); - if(now < expireTime) - { - _sendMonitor.timedWait(expireTime - now); - } - - // - // Make sure we woke up because of timeout and not another response. - // - if(out->state() == Outgoing::StateInProgress && IceUtil::Time::now() > expireTime) - { - throw TimeoutException(__FILE__, __LINE__); - } - } - else - { - _sendMonitor.wait(); - } - } - } + } + else + { + // + // Wait until the request has completed, or until the request times out. + // + Int tout = timeout(); + IceUtil::Time expireTime; + if(tout > 0) + { + expireTime = IceUtil::Time::now() + IceUtil::Time::milliSeconds(tout); + } + + while(out->state() == Outgoing::StateInProgress) + { + if(tout > 0) + { + IceUtil::Time now = IceUtil::Time::now(); + if(now < expireTime) + { + _sendMonitor.timedWait(expireTime - now); + } + + // + // Make sure we woke up because of timeout and not another response. + // + if(out->state() == Outgoing::StateInProgress && IceUtil::Time::now() > expireTime) + { + throw TimeoutException(__FILE__, __LINE__); + } + } + else + { + _sendMonitor.wait(); + } + } + } #endif } catch(const LocalException& ex) { - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - setState(StateClosed, ex); - assert(_exception.get()); - if(!requestSent) - { - _exception->ice_throw(); - } - } - - // - // If the request was already sent, we don't throw directly - // but instead we set the Outgoing object exception with - // finished(). Throwing directly would break "at-most-once" - // (see also comment in Outgoing.invoke()) - // - IceUtil::Monitor<IceUtil::Mutex>::Lock sendSync(_sendMonitor); + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + setState(StateClosed, ex); + assert(_exception.get()); + if(!requestSent) + { + _exception->ice_throw(); + } + } + + // + // If the request was already sent, we don't throw directly + // but instead we set the Outgoing object exception with + // finished(). Throwing directly would break "at-most-once" + // (see also comment in Outgoing.invoke()) + // + IceUtil::Monitor<IceUtil::Mutex>::Lock sendSync(_sendMonitor); #ifndef ICEE_PURE_BLOCKING_CLIENT - if(_blocking) - { + if(_blocking) + { #endif - out->finished(ex); + out->finished(ex); #ifndef ICEE_PURE_BLOCKING_CLIENT - } - else - { - while(out->state() == Outgoing::StateInProgress) - { - _sendMonitor.wait(); // Wait for the thread to propagate the exception to the Outgoing object. - } - } + } + else + { + while(out->state() == Outgoing::StateInProgress) + { + _sendMonitor.wait(); // Wait for the thread to propagate the exception to the Outgoing object. + } + } #endif } } @@ -496,12 +496,12 @@ Ice::Connection::prepareBatchRequest(BasicStream* os) // while(_batchStreamInUse && !_exception.get()) { - wait(); + wait(); } if(_exception.get()) { - _exception->ice_throw(); + _exception->ice_throw(); } assert(_state > StateNotValidated); @@ -509,15 +509,15 @@ Ice::Connection::prepareBatchRequest(BasicStream* os) if(_batchStream.b.empty()) { - try - { - _batchStream.writeBlob(requestBatchHdr, sizeof(requestBatchHdr)); - } - catch(const LocalException& ex) - { - setState(StateClosed, ex); - ex.ice_throw(); - } + try + { + _batchStream.writeBlob(requestBatchHdr, sizeof(requestBatchHdr)); + } + catch(const LocalException& ex) + { + setState(StateClosed, ex); + ex.ice_throw(); + } } _batchStreamInUse = true; @@ -655,111 +655,111 @@ void Ice::Connection::flushBatchRequestsInternal(bool ignoreInUse) { { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); if(!ignoreInUse) { - while(_batchStreamInUse && !_exception.get()) - { - wait(); - } + while(_batchStreamInUse && !_exception.get()) + { + wait(); + } + } + + if(_exception.get()) + { + _exception->ice_throw(); } - - if(_exception.get()) - { - _exception->ice_throw(); - } - if(_batchStream.b.empty()) - { - return; // Nothing to do. - } + if(_batchStream.b.empty()) + { + return; // Nothing to do. + } - assert(_state > StateNotValidated); - assert(_state < StateClosing); + assert(_state > StateNotValidated); + assert(_state < StateClosing); - _batchStream.i = _batchStream.b.begin(); + _batchStream.i = _batchStream.b.begin(); - // - // Prevent that new batch requests are added while we are - // flushing. - // - _batchStreamInUse = true; + // + // Prevent that new batch requests are added while we are + // flushing. + // + _batchStreamInUse = true; } try { - Lock sendSync(_sendMonitor); + Lock sendSync(_sendMonitor); - if(!_transceiver) // Has the transceiver already been closed? - { - assert(_exception.get()); - _exception->ice_throw(); // The exception is immutable at this point. - } + if(!_transceiver) // Has the transceiver already been closed? + { + assert(_exception.get()); + _exception->ice_throw(); // The exception is immutable at this point. + } - // - // Fill in the number of requests in the batch. - // - Byte* dest = &(_batchStream.b[0]) + headerSize; + // + // Fill in the number of requests in the batch. + // + Byte* dest = &(_batchStream.b[0]) + headerSize; #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(&_batchRequestNum) + sizeof(Ice::Int) - 1; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&_batchRequestNum) + sizeof(Ice::Int) - 1; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest = *src; #else - const Byte* src = reinterpret_cast<const Byte*>(&_batchRequestNum); - *dest++ = *src++; - *dest++ = *src++; - *dest++ = *src++; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&_batchRequestNum); + *dest++ = *src++; + *dest++ = *src++; + *dest++ = *src++; + *dest = *src; #endif - - const Int sz = static_cast<Int>(_batchStream.b.size()); - dest = &(_batchStream.b[0]) + 10; + + const Int sz = static_cast<Int>(_batchStream.b.size()); + dest = &(_batchStream.b[0]) + 10; #ifdef ICE_BIG_ENDIAN - src = reinterpret_cast<const Byte*>(&sz) + sizeof(Ice::Int) - 1; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest = *src; + src = reinterpret_cast<const Byte*>(&sz) + sizeof(Ice::Int) - 1; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest = *src; #else - src = reinterpret_cast<const Byte*>(&sz); - *dest++ = *src++; - *dest++ = *src++; - *dest++ = *src++; - *dest = *src; + src = reinterpret_cast<const Byte*>(&sz); + *dest++ = *src++; + *dest++ = *src++; + *dest++ = *src++; + *dest = *src; #endif - - // - // Send the batch request. - // - _batchStream.i = _batchStream.b.begin(); - if(_traceLevels->protocol >= 1) - { - traceBatchRequest("sending batch request", _batchStream, _logger, _traceLevels); - } - _transceiver->write(_batchStream); + + // + // Send the batch request. + // + _batchStream.i = _batchStream.b.begin(); + if(_traceLevels->protocol >= 1) + { + traceBatchRequest("sending batch request", _batchStream, _logger, _traceLevels); + } + _transceiver->write(_batchStream); } catch(const LocalException& ex) { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - setState(StateClosed, ex); - assert(_exception.get()); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + setState(StateClosed, ex); + assert(_exception.get()); - // - // Since batch requests are all oneways, we - // must report the exception to the caller. - // - _exception->ice_throw(); + // + // Since batch requests are all oneways, we + // must report the exception to the caller. + // + _exception->ice_throw(); } { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - // - // Reset the batch stream, and notify that flushing is over. - // + // + // Reset the batch stream, and notify that flushing is over. + // resetBatch(!ignoreInUse); } } @@ -797,69 +797,69 @@ Ice::Connection::sendResponse(BasicStream* os) { try { - Lock sendSync(_sendMonitor); + Lock sendSync(_sendMonitor); - if(!_transceiver) // Has the transceiver already been closed? - { - assert(_exception.get()); - _exception->ice_throw(); // The exception is immutable at this point. - } + if(!_transceiver) // Has the transceiver already been closed? + { + assert(_exception.get()); + _exception->ice_throw(); // The exception is immutable at this point. + } - const Int sz = static_cast<Int>(os->b.size()); - Byte* dest = &(os->b[0]) + 10; + const Int sz = static_cast<Int>(os->b.size()); + Byte* dest = &(os->b[0]) + 10; #ifdef ICE_BIG_ENDIAN - const Byte* src = reinterpret_cast<const Byte*>(&sz) + sizeof(Ice::Int) - 1; - *dest++ = *src--; - *dest++ = *src--; - *dest++ = *src--; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&sz) + sizeof(Ice::Int) - 1; + *dest++ = *src--; + *dest++ = *src--; + *dest++ = *src--; + *dest = *src; #else - const Byte* src = reinterpret_cast<const Byte*>(&sz); - *dest++ = *src++; - *dest++ = *src++; - *dest++ = *src++; - *dest = *src; + const Byte* src = reinterpret_cast<const Byte*>(&sz); + *dest++ = *src++; + *dest++ = *src++; + *dest++ = *src++; + *dest = *src; #endif - - // - // Send the reply. - // - os->i = os->b.begin(); - if(_traceLevels->protocol >= 1) - { - traceReply("sending reply", *os, _logger, _traceLevels); - } - _transceiver->write(*os); + + // + // Send the reply. + // + os->i = os->b.begin(); + if(_traceLevels->protocol >= 1) + { + traceReply("sending reply", *os, _logger, _traceLevels); + } + _transceiver->write(*os); } catch(const LocalException& ex) { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - setState(StateClosed, ex); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + setState(StateClosed, ex); } { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - assert(_state > StateNotValidated); + assert(_state > StateNotValidated); - try - { - assert(_dispatchCount > 0); - if(--_dispatchCount == 0) - { - notifyAll(); - } - - if(_state == StateClosing && _dispatchCount == 0) - { - initiateShutdown(); - } - } - catch(const LocalException& ex) - { - setState(StateClosed, ex); - } + try + { + assert(_dispatchCount > 0); + if(--_dispatchCount == 0) + { + notifyAll(); + } + + if(_state == StateClosing && _dispatchCount == 0) + { + initiateShutdown(); + } + } + catch(const LocalException& ex) + { + setState(StateClosed, ex); + } } } @@ -872,20 +872,20 @@ Ice::Connection::sendNoResponse() try { - assert(_dispatchCount > 0); - if(--_dispatchCount == 0) - { - notifyAll(); - } + assert(_dispatchCount > 0); + if(--_dispatchCount == 0) + { + notifyAll(); + } - if(_state == StateClosing && _dispatchCount == 0) - { - initiateShutdown(); - } + if(_state == StateClosing && _dispatchCount == 0) + { + initiateShutdown(); + } } catch(const LocalException& ex) { - setState(StateClosed, ex); + setState(StateClosed, ex); } } @@ -916,12 +916,12 @@ Ice::Connection::setAdapter(const ObjectAdapterPtr& adapter) // while(_dispatchCount > 0) { - wait(); + wait(); } if(_exception.get()) { - _exception->ice_throw(); + _exception->ice_throw(); } assert(_state < StateClosing); @@ -946,7 +946,7 @@ Ice::Connection::createProxy(const Identity& ident) const vector<ConnectionPtr> connections; connections.push_back(const_cast<Connection*>(this)); ReferencePtr ref = _instance->referenceFactory()->create(ident, Ice::Context(), "", ReferenceModeTwoway, - connections); + connections); return _instance->proxyFactory()->referenceToProxy(ref); } @@ -972,28 +972,28 @@ Ice::Connection::toString() const #ifndef ICEE_PURE_CLIENT Ice::Connection::Connection(const InstancePtr& instance, - const TransceiverPtr& transceiver, - const EndpointPtr& endpoint, - const ObjectAdapterPtr& adapter) : + const TransceiverPtr& transceiver, + const EndpointPtr& endpoint, + const ObjectAdapterPtr& adapter) : #else Ice::Connection::Connection(const InstancePtr& instance, - const TransceiverPtr& transceiver, - const EndpointPtr& endpoint) : + const TransceiverPtr& transceiver, + const EndpointPtr& endpoint) : #endif - _instance(instance), - _transceiver(transceiver), - _desc(transceiver->toString()), - _type(transceiver->type()), - _endpoint(endpoint), - _logger(_instance->initializationData().logger), // Cached for better performance. - _traceLevels(_instance->traceLevels()), // Cached for better performance. - _warn(_instance->initializationData().properties->getPropertyAsInt("Ice.Warn.Connections") > 0), + _instance(instance), + _transceiver(transceiver), + _desc(transceiver->toString()), + _type(transceiver->type()), + _endpoint(endpoint), + _logger(_instance->initializationData().logger), // Cached for better performance. + _traceLevels(_instance->traceLevels()), // Cached for better performance. + _warn(_instance->initializationData().properties->getPropertyAsInt("Ice.Warn.Connections") > 0), #ifndef ICEE_PURE_CLIENT - _in(_instance.get(), this, _stream, adapter), + _in(_instance.get(), this, _stream, adapter), #endif #ifndef ICEE_PURE_BLOCKING_CLIENT - _stream(_instance.get(), _instance->messageSizeMax() + _stream(_instance.get(), _instance->messageSizeMax() #ifdef ICEE_HAS_WSTRING , _instance->initializationData().stringConverter, _instance->initializationData().wstringConverter #endif @@ -1002,19 +1002,19 @@ Ice::Connection::Connection(const InstancePtr& instance, #ifdef ICEE_HAS_BATCH _batchAutoFlush( _instance->initializationData().properties->getPropertyAsIntWithDefault("Ice.BatchAutoFlush", 1) > 0), - _batchStream(_instance.get(), _instance->messageSizeMax(), + _batchStream(_instance.get(), _instance->messageSizeMax(), #ifdef ICEE_HAS_WSTRING _instance->initializationData().stringConverter, _instance->initializationData().wstringConverter, #endif _batchAutoFlush), - _batchStreamInUse(false), - _batchRequestNum(0), + _batchStreamInUse(false), + _batchRequestNum(0), _batchMarker(0), #endif - _dispatchCount(0), - _state(StateNotValidated), - _stateTime(IceUtil::Time::now()), - _nextRequestId(1) + _dispatchCount(0), + _state(StateNotValidated), + _stateTime(IceUtil::Time::now()), + _nextRequestId(1) #ifndef ICEE_PURE_BLOCKING_CLIENT , _requestsHint(_requests.end()) #endif @@ -1027,18 +1027,18 @@ Ice::Connection::Connection(const InstancePtr& instance, # endif if(_blocking) { - _transceiver->setTimeouts(_endpoint->timeout(), _endpoint->timeout()); + _transceiver->setTimeouts(_endpoint->timeout(), _endpoint->timeout()); } else { #ifdef _WIN32 - // - // On Windows, the recv() call doesn't return if the socket is - // shutdown. We use the timeout to not block indefinitely. - // - _transceiver->setTimeouts(_endpoint->timeout(), _endpoint->timeout()); + // + // On Windows, the recv() call doesn't return if the socket is + // shutdown. We use the timeout to not block indefinitely. + // + _transceiver->setTimeouts(_endpoint->timeout(), _endpoint->timeout()); #else - _transceiver->setTimeouts(-1, _endpoint->timeout()); + _transceiver->setTimeouts(-1, _endpoint->timeout()); #endif } #else @@ -1050,38 +1050,38 @@ Ice::Connection::Connection(const InstancePtr& instance, #else if(_blocking) { - validate(); + validate(); } else { __setNoDelete(true); try { - // - // If we are in thread per connection mode, create the thread - // for this connection. - // - _threadPerConnection = new ThreadPerConnection(this); - _threadPerConnection->start(_instance->threadPerConnectionStackSize()); + // + // If we are in thread per connection mode, create the thread + // for this connection. + // + _threadPerConnection = new ThreadPerConnection(this); + _threadPerConnection->start(_instance->threadPerConnectionStackSize()); } catch(const Ice::Exception& ex) { - { - Error out(_logger); - out << "cannot create thread for connection:\n" << ex.toString(); - } - - try - { - _transceiver->close(); - } - catch(const LocalException&) - { - // Here we ignore any exceptions in close(). - } - - __setNoDelete(false); - ex.ice_throw(); + { + Error out(_logger); + out << "cannot create thread for connection:\n" << ex.toString(); + } + + try + { + _transceiver->close(); + } + catch(const LocalException&) + { + // Here we ignore any exceptions in close(). + } + + __setNoDelete(false); + ex.ice_throw(); } __setNoDelete(false); } @@ -1108,25 +1108,25 @@ Ice::Connection::validate() { IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // The connection might already be closed (e.g.: the communicator - // was destroyed or object adapter deactivated.) - // - assert(_state == StateNotValidated || _state == StateClosed); - if(_state == StateClosed) - { - assert(_exception.get()); - _exception->ice_throw(); - } + + // + // The connection might already be closed (e.g.: the communicator + // was destroyed or object adapter deactivated.) + // + assert(_state == StateNotValidated || _state == StateClosed); + if(_state == StateClosed) + { + assert(_exception.get()); + _exception->ice_throw(); + } if(_in.getAdapter()) { - active = true; // The server side has the active role for connection validation. + active = true; // The server side has the active role for connection validation. } else { - active = false; // The client side has the passive role for connection validation. + active = false; // The client side has the passive role for connection validation. } } #endif @@ -1136,111 +1136,111 @@ Ice::Connection::validate() Int timeout; if(_instance->defaultsAndOverrides()->overrideConnectTimeout) { - timeout = _instance->defaultsAndOverrides()->overrideConnectTimeoutValue; + timeout = _instance->defaultsAndOverrides()->overrideConnectTimeoutValue; } else { - timeout = _endpoint->timeout(); + timeout = _endpoint->timeout(); } #ifndef ICEE_PURE_CLIENT if(active) { - BasicStream os(_instance.get(), _instance->messageSizeMax() + BasicStream os(_instance.get(), _instance->messageSizeMax() #ifdef ICEE_HAS_WSTRING , _instance->initializationData().stringConverter, _instance->initializationData().wstringConverter #endif ); - os.write(magic[0]); - os.write(magic[1]); - os.write(magic[2]); - os.write(magic[3]); - os.write(protocolMajor); - os.write(protocolMinor); - os.write(encodingMajor); - os.write(encodingMinor); - os.write(validateConnectionMsg); - os.write(static_cast<Byte>(0)); // Compression status (always zero for validate connection). - os.write(headerSize); // Message size. - os.i = os.b.begin(); - if(_traceLevels->protocol >= 1) - { - traceHeader("sending validate connection", os, _logger, _traceLevels); - } - try - { - _transceiver->writeWithTimeout(os, timeout); - } - catch(const TimeoutException&) - { - throw ConnectTimeoutException(__FILE__, __LINE__); - } + os.write(magic[0]); + os.write(magic[1]); + os.write(magic[2]); + os.write(magic[3]); + os.write(protocolMajor); + os.write(protocolMinor); + os.write(encodingMajor); + os.write(encodingMinor); + os.write(validateConnectionMsg); + os.write(static_cast<Byte>(0)); // Compression status (always zero for validate connection). + os.write(headerSize); // Message size. + os.i = os.b.begin(); + if(_traceLevels->protocol >= 1) + { + traceHeader("sending validate connection", os, _logger, _traceLevels); + } + try + { + _transceiver->writeWithTimeout(os, timeout); + } + catch(const TimeoutException&) + { + throw ConnectTimeoutException(__FILE__, __LINE__); + } } else #endif { - BasicStream is(_instance.get(), _instance->messageSizeMax() + BasicStream is(_instance.get(), _instance->messageSizeMax() #ifdef ICEE_HAS_WSTRING , _instance->initializationData().stringConverter, _instance->initializationData().wstringConverter #endif ); - is.b.resize(headerSize); - is.i = is.b.begin(); - try - { - _transceiver->readWithTimeout(is, timeout); - } - catch(const TimeoutException&) - { - throw ConnectTimeoutException(__FILE__, __LINE__); - } - assert(is.i == is.b.end()); - is.i = is.b.begin(); - Ice::Byte m[4]; - is.read(m[0]); - is.read(m[1]); - is.read(m[2]); - is.read(m[3]); - if(m[0] != magic[0] || m[1] != magic[1] || m[2] != magic[2] || m[3] != magic[3]) - { - throwBadMagicException(__FILE__, __LINE__, Ice::ByteSeq(&m[0], &m[0] + sizeof(m))); - } - Byte pMajor; - Byte pMinor; - is.read(pMajor); - is.read(pMinor); - if(pMajor != protocolMajor) - { - throwUnsupportedProtocolException(__FILE__, __LINE__, pMajor, pMinor, protocolMajor, protocolMinor); - } - Byte eMajor; - Byte eMinor; - is.read(eMajor); - is.read(eMinor); - if(eMajor != encodingMajor) - { - throwUnsupportedEncodingException(__FILE__, __LINE__, eMajor, eMinor, encodingMajor, encodingMinor); - } - Byte messageType; - is.read(messageType); - if(messageType != validateConnectionMsg) - { - throwConnectionNotValidatedException(__FILE__, __LINE__); - } + is.b.resize(headerSize); + is.i = is.b.begin(); + try + { + _transceiver->readWithTimeout(is, timeout); + } + catch(const TimeoutException&) + { + throw ConnectTimeoutException(__FILE__, __LINE__); + } + assert(is.i == is.b.end()); + is.i = is.b.begin(); + Ice::Byte m[4]; + is.read(m[0]); + is.read(m[1]); + is.read(m[2]); + is.read(m[3]); + if(m[0] != magic[0] || m[1] != magic[1] || m[2] != magic[2] || m[3] != magic[3]) + { + throwBadMagicException(__FILE__, __LINE__, Ice::ByteSeq(&m[0], &m[0] + sizeof(m))); + } + Byte pMajor; + Byte pMinor; + is.read(pMajor); + is.read(pMinor); + if(pMajor != protocolMajor) + { + throwUnsupportedProtocolException(__FILE__, __LINE__, pMajor, pMinor, protocolMajor, protocolMinor); + } + Byte eMajor; + Byte eMinor; + is.read(eMajor); + is.read(eMinor); + if(eMajor != encodingMajor) + { + throwUnsupportedEncodingException(__FILE__, __LINE__, eMajor, eMinor, encodingMajor, encodingMinor); + } + Byte messageType; + is.read(messageType); + if(messageType != validateConnectionMsg) + { + throwConnectionNotValidatedException(__FILE__, __LINE__); + } Byte compress; is.read(compress); // Ignore compression status for validate connection. - Int size; - is.read(size); - if(size != headerSize) - { - throwIllegalMessageSizeException(__FILE__, __LINE__); - } - if(_traceLevels->protocol >= 1) - { - traceHeader("received validate connection", is, _logger, _traceLevels); - } + Int size; + is.read(size); + if(size != headerSize) + { + throwIllegalMessageSizeException(__FILE__, __LINE__); + } + if(_traceLevels->protocol >= 1) + { + traceHeader("received validate connection", is, _logger, _traceLevels); + } } } catch(const LocalException& ex) @@ -1269,41 +1269,41 @@ Ice::Connection::setState(State state, const LocalException& ex) if(_state == state) // Don't switch twice. { - return; + return; } if(!_exception.get()) { - // - // If we are in closed state, an exception must be set. - // - assert(_state != StateClosed); - - _exception.reset(dynamic_cast<LocalException*>(ex.ice_clone())); - - if(_warn) - { - // - // We don't warn if we are not validated. - // - if(_state > StateNotValidated) - { - // - // Don't warn about certain expected exceptions. - // - if(!(dynamic_cast<const CloseConnectionException*>(_exception.get()) || - dynamic_cast<const ForcedCloseConnectionException*>(_exception.get()) || - dynamic_cast<const CommunicatorDestroyedException*>(_exception.get()) || + // + // If we are in closed state, an exception must be set. + // + assert(_state != StateClosed); + + _exception.reset(dynamic_cast<LocalException*>(ex.ice_clone())); + + if(_warn) + { + // + // We don't warn if we are not validated. + // + if(_state > StateNotValidated) + { + // + // Don't warn about certain expected exceptions. + // + if(!(dynamic_cast<const CloseConnectionException*>(_exception.get()) || + dynamic_cast<const ForcedCloseConnectionException*>(_exception.get()) || + dynamic_cast<const CommunicatorDestroyedException*>(_exception.get()) || #ifndef ICEE_PURE_CLIENT - dynamic_cast<const ObjectAdapterDeactivatedException*>(_exception.get()) || + dynamic_cast<const ObjectAdapterDeactivatedException*>(_exception.get()) || #endif - (dynamic_cast<const ConnectionLostException*>(_exception.get()) && _state == StateClosing))) - { - Warning out(_logger); - out << "connection exception:\n" << (*_exception.get()).toString() << "\n" << _desc; - } - } - } + (dynamic_cast<const ConnectionLostException*>(_exception.get()) && _state == StateClosing))) + { + Warning out(_logger); + out << "connection exception:\n" << (*_exception.get()).toString() << "\n" << _desc; + } + } + } } // @@ -1319,91 +1319,91 @@ Ice::Connection::setState(State state) { if(_state == state) // Don't switch twice. { - return; + return; } switch(state) { case StateNotValidated: { - assert(false); - break; + assert(false); + break; } case StateActive: { - // - // Can only switch from holding or not validated to - // active. - // + // + // Can only switch from holding or not validated to + // active. + // #ifdef ICEE_PURE_CLIENT - if(_state != StateNotValidated) - { - return; - } + if(_state != StateNotValidated) + { + return; + } #else - if(_state != StateHolding && _state != StateNotValidated) - { - return; - } + if(_state != StateHolding && _state != StateNotValidated) + { + return; + } #endif - break; + break; } - + #ifndef ICEE_PURE_CLIENT case StateHolding: { - // - // Can only switch from active or not validated to - // holding. - // - if(_state != StateActive && _state != StateNotValidated) - { - return; - } - break; + // + // Can only switch from active or not validated to + // holding. + // + if(_state != StateActive && _state != StateNotValidated) + { + return; + } + break; } #endif case StateClosing: { - // - // Can't change back from closed. - // - if(_state == StateClosed) - { - return; - } - break; + // + // Can't change back from closed. + // + if(_state == StateClosed) + { + return; + } + break; } - + case StateClosed: { - // - // We shutdown both for reading and writing. This will - // unblock and read call with an exception. The thread - // per connection then closes the transceiver. - // - _transceiver->shutdownReadWrite(); + // + // We shutdown both for reading and writing. This will + // unblock and read call with an exception. The thread + // per connection then closes the transceiver. + // + _transceiver->shutdownReadWrite(); - // - // In blocking mode, we close the transceiver now. - // + // + // In blocking mode, we close the transceiver now. + // #ifndef ICEE_PURE_BLOCKING_CLIENT - if(_blocking) + if(_blocking) #endif - { - Lock sync(_sendMonitor); - try - { - _transceiver->close(); - } - catch(const Ice::LocalException&) - { - } - _transceiver = 0; - } - break; + { + Lock sync(_sendMonitor); + try + { + _transceiver->close(); + } + catch(const Ice::LocalException&) + { + } + _transceiver = 0; + } + break; } } @@ -1414,21 +1414,21 @@ Ice::Connection::setState(State state) if(_state == StateClosing && _dispatchCount == 0) { - try - { - initiateShutdown(); + try + { + initiateShutdown(); #ifndef ICEE_PURE_BLOCKING_CLIENT - if(_blocking) + if(_blocking) #endif - { - setState(StateClosed); - } - } - catch(const LocalException& ex) - { - setState(StateClosed, ex); - } + { + setState(StateClosed); + } + } + catch(const LocalException& ex) + { + setState(StateClosed, ex); + } } } @@ -1467,7 +1467,7 @@ Ice::Connection::initiateShutdown() const os.i = os.b.begin(); if(_traceLevels->protocol >= 1) { - traceHeader("sending close connection", os, _logger, _traceLevels); + traceHeader("sending close connection", os, _logger, _traceLevels); } _transceiver->write(os); @@ -1503,20 +1503,20 @@ Ice::Connection::readStreamAndParseMessage(IceInternal::BasicStream& stream, Int stream.readBlob(header, headerSize); if(header[0] != magic[0] || header[1] != magic[1] || header[2] != magic[2] || header[3] != magic[3]) { - throwBadMagicException(__FILE__, __LINE__, Ice::ByteSeq(&header[0], &header[0] + sizeof(magic))); + throwBadMagicException(__FILE__, __LINE__, Ice::ByteSeq(&header[0], &header[0] + sizeof(magic))); } if(header[4] != protocolMajor) { - throwUnsupportedProtocolException(__FILE__, __LINE__, header[4], header[5], protocolMajor, protocolMinor); + throwUnsupportedProtocolException(__FILE__, __LINE__, header[4], header[5], protocolMajor, protocolMinor); } if(header[6] != encodingMajor) { - throwUnsupportedEncodingException(__FILE__, __LINE__, header[6], header[7], encodingMajor, encodingMinor); + throwUnsupportedEncodingException(__FILE__, __LINE__, header[6], header[7], encodingMajor, encodingMinor); } const Byte messageType = header[8]; if(header[9] == 2) { - throw FeatureNotSupportedException(__FILE__, __LINE__, "compression"); + throw FeatureNotSupportedException(__FILE__, __LINE__, "compression"); } Int size; @@ -1524,21 +1524,21 @@ Ice::Connection::readStreamAndParseMessage(IceInternal::BasicStream& stream, Int stream.read(size); if(size < headerSize) { - throwIllegalMessageSizeException(__FILE__, __LINE__); + throwIllegalMessageSizeException(__FILE__, __LINE__); } if(size > static_cast<Int>(_instance->messageSizeMax())) { - throwMemoryLimitException(__FILE__, __LINE__); + throwMemoryLimitException(__FILE__, __LINE__); } if(size > static_cast<Int>(stream.b.size())) { - stream.b.resize(size); + stream.b.resize(size); } stream.i = stream.b.begin() + pos; if(stream.i != stream.b.end()) { - _transceiver->read(stream); + _transceiver->read(stream); } assert(stream.i == stream.b.end()); @@ -1548,74 +1548,74 @@ Ice::Connection::readStreamAndParseMessage(IceInternal::BasicStream& stream, Int { case closeConnectionMsg: { - if(_traceLevels->protocol >= 1) - { - traceHeader("received close connection", stream, _logger, _traceLevels); - } - throw CloseConnectionException(__FILE__, __LINE__); - break; + if(_traceLevels->protocol >= 1) + { + traceHeader("received close connection", stream, _logger, _traceLevels); + } + throw CloseConnectionException(__FILE__, __LINE__); + break; } - + case replyMsg: { - if(_traceLevels->protocol >= 1) - { - traceReply("received reply", stream, _logger, _traceLevels); - } - stream.read(requestId); - break; - } - + if(_traceLevels->protocol >= 1) + { + traceReply("received reply", stream, _logger, _traceLevels); + } + stream.read(requestId); + break; + } + #ifndef ICEE_PURE_CLIENT case requestMsg: { - if(_traceLevels->protocol >= 1) - { - traceRequest("received request", stream, _logger, _traceLevels); - } - stream.read(requestId); - invokeNum = 1; - break; + if(_traceLevels->protocol >= 1) + { + traceRequest("received request", stream, _logger, _traceLevels); + } + stream.read(requestId); + invokeNum = 1; + break; } - + case requestBatchMsg: { - if(_traceLevels->protocol >= 1) - { - traceBatchRequest("received batch request", stream, _logger, _traceLevels); - } - stream.read(invokeNum); - if(invokeNum < 0) - { - invokeNum = 0; - throwNegativeSizeException(__FILE__, __LINE__); - } - break; + if(_traceLevels->protocol >= 1) + { + traceBatchRequest("received batch request", stream, _logger, _traceLevels); + } + stream.read(invokeNum); + if(invokeNum < 0) + { + invokeNum = 0; + throwNegativeSizeException(__FILE__, __LINE__); + } + break; } #endif - + case validateConnectionMsg: { - if(_traceLevels->protocol >= 1) - { - traceHeader("received validate connection", stream, _logger, _traceLevels); - } - if(_warn) - { - Warning out(_logger); - out << "ignoring unexpected validate connection message:\n" << _desc; - } - break; - } - + if(_traceLevels->protocol >= 1) + { + traceHeader("received validate connection", stream, _logger, _traceLevels); + } + if(_warn) + { + Warning out(_logger); + out << "ignoring unexpected validate connection message:\n" << _desc; + } + break; + } + default: { - if(_traceLevels->protocol >= 1) - { - traceHeader("received unknown message\n(invalid, closing connection)", stream, _logger, _traceLevels); - } - throwUnknownMessageException(__FILE__, __LINE__); - break; + if(_traceLevels->protocol >= 1) + { + traceHeader("received unknown message\n(invalid, closing connection)", stream, _logger, _traceLevels); + } + throwUnknownMessageException(__FILE__, __LINE__); + break; } } } @@ -1636,17 +1636,17 @@ Ice::Connection::run() } catch(const LocalException&) { - Lock sync(*this); + Lock sync(*this); assert(_state == StateClosed); - Lock sendSync(_sendMonitor); + Lock sendSync(_sendMonitor); try { - _transceiver->close(); + _transceiver->close(); } catch(const LocalException&) { - // Here we ignore any exceptions in close(). + // Here we ignore any exceptions in close(). } _transceiver = 0; @@ -1660,224 +1660,224 @@ Ice::Connection::run() while(!closed) { - Int requestId = 0; + Int requestId = 0; #ifndef ICEE_PURE_CLIENT - Int invokeNum = 0; - _in.os()->reset(); + Int invokeNum = 0; + _in.os()->reset(); #endif - _stream.reset(); - - // - // Read and parse the next message. We don't need to lock the - // send monitor here as we have the guarantee that - // _transceiver won't be set to 0 by another thread, the - // thread per connection is the only thread that can set - // _transceiver to 0. - // - try - { + _stream.reset(); + + // + // Read and parse the next message. We don't need to lock the + // send monitor here as we have the guarantee that + // _transceiver won't be set to 0 by another thread, the + // thread per connection is the only thread that can set + // _transceiver to 0. + // + try + { #ifndef ICEE_PURE_CLIENT - readStreamAndParseMessage(_stream, requestId, invokeNum); + readStreamAndParseMessage(_stream, requestId, invokeNum); #else - readStreamAndParseMessage(_stream, requestId); + readStreamAndParseMessage(_stream, requestId); #endif - } + } #ifdef _WIN32 - catch(const Ice::TimeoutException&) - { - // - // See the comment in the Connection constructor. This is - // necessary to not block in recv() indefinitely. - // - continue; - } + catch(const Ice::TimeoutException&) + { + // + // See the comment in the Connection constructor. This is + // necessary to not block in recv() indefinitely. + // + continue; + } #endif - catch(const Ice::LocalException& ex) - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - setState(StateClosed, ex); - } - - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - if(_state != StateClosed) - { + catch(const Ice::LocalException& ex) + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + setState(StateClosed, ex); + } + + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + if(_state != StateClosed) + { #ifndef ICEE_PURE_CLIENT - if(invokeNum > 0) // We received a request or a batch request - { - if(_state == StateClosing) - { - if(_traceLevels->protocol >= 1) - { - string req = invokeNum > 1 ? "received batch request" : "received request"; - req += " during closing\n(ignored by server, client will retry)"; - traceRequest( req.c_str(), _stream, _logger, _traceLevels); - } - invokeNum = 0; - } - _dispatchCount += invokeNum; - } - else + if(invokeNum > 0) // We received a request or a batch request + { + if(_state == StateClosing) + { + if(_traceLevels->protocol >= 1) + { + string req = invokeNum > 1 ? "received batch request" : "received request"; + req += " during closing\n(ignored by server, client will retry)"; + traceRequest( req.c_str(), _stream, _logger, _traceLevels); + } + invokeNum = 0; + } + _dispatchCount += invokeNum; + } + else #endif - if(requestId > 0) - { - // - // The message is a reply, we search the Outgoing object waiting - // for this reply and pass it the stream before to notify the - // send monitor to wake up threads waiting for replies. - // - try - { - Lock sync(_sendMonitor); - - map<Int, Outgoing*>::iterator p = _requests.end(); - if(p != _requestsHint) - { - if(_requestsHint->first == requestId) - { - p = _requestsHint; - } - } - - if(p == _requests.end()) - { - p = _requests.find(requestId); - } - - if(p == _requests.end()) - { - throwUnknownRequestIdException(__FILE__, __LINE__); - } - - p->second->finished(_stream); - - if(p == _requestsHint) - { - _requests.erase(p++); - _requestsHint = p; - } - else - { - _requests.erase(p); - } - _sendMonitor.notifyAll(); // Wake up threads waiting in sendRequest() - } - catch(const Ice::LocalException& ex) - { - setState(StateClosed, ex); - } - } - } + if(requestId > 0) + { + // + // The message is a reply, we search the Outgoing object waiting + // for this reply and pass it the stream before to notify the + // send monitor to wake up threads waiting for replies. + // + try + { + Lock sync(_sendMonitor); + + map<Int, Outgoing*>::iterator p = _requests.end(); + if(p != _requestsHint) + { + if(_requestsHint->first == requestId) + { + p = _requestsHint; + } + } + + if(p == _requests.end()) + { + p = _requests.find(requestId); + } + + if(p == _requests.end()) + { + throwUnknownRequestIdException(__FILE__, __LINE__); + } + + p->second->finished(_stream); + + if(p == _requestsHint) + { + _requests.erase(p++); + _requestsHint = p; + } + else + { + _requests.erase(p); + } + _sendMonitor.notifyAll(); // Wake up threads waiting in sendRequest() + } + catch(const Ice::LocalException& ex) + { + setState(StateClosed, ex); + } + } + } #ifndef ICEE_PURE_CLIENT - while(_state == StateHolding) - { - wait(); - } + while(_state == StateHolding) + { + wait(); + } #endif - if(_state == StateClosed) - { - Lock sync(_sendMonitor); - try - { - _transceiver->close(); - } - catch(const LocalException&) - { - } - _transceiver = 0; - notifyAll(); - - // - // We cannot simply return here. We have to make sure - // that all requests are notified about the closed - // connection below. - // - closed = true; - } - - if(_state == StateClosed || _state == StateClosing) - { - Lock sync(_sendMonitor); - assert(_exception.get()); - for(map<Int, Outgoing*>::iterator p = _requests.begin(); p != _requests.end(); ++p) - { - p->second->finished(*_exception.get()); // The exception is immutable at this point. - } - _requests.clear(); - _sendMonitor.notifyAll(); // Wake up threads waiting in sendRequest() - } - } - - // - // Method invocation (or multiple invocations for batch - // messages) must be done outside the thread synchronization, - // so that nested calls are possible. - // + if(_state == StateClosed) + { + Lock sync(_sendMonitor); + try + { + _transceiver->close(); + } + catch(const LocalException&) + { + } + _transceiver = 0; + notifyAll(); + + // + // We cannot simply return here. We have to make sure + // that all requests are notified about the closed + // connection below. + // + closed = true; + } + + if(_state == StateClosed || _state == StateClosing) + { + Lock sync(_sendMonitor); + assert(_exception.get()); + for(map<Int, Outgoing*>::iterator p = _requests.begin(); p != _requests.end(); ++p) + { + p->second->finished(*_exception.get()); // The exception is immutable at this point. + } + _requests.clear(); + _sendMonitor.notifyAll(); // Wake up threads waiting in sendRequest() + } + } + + // + // Method invocation (or multiple invocations for batch + // messages) must be done outside the thread synchronization, + // so that nested calls are possible. + // #ifndef ICEE_PURE_CLIENT - try - { - for(;invokeNum > 0; --invokeNum) - { - // - // Prepare the response if necessary. - // - const bool response = requestId != 0; - if(response) - { - assert(invokeNum == 1); // No further invocations if a response is expected. - - // - // Add the reply header and request id. - // - BasicStream* os = _in.os(); - os->writeBlob(replyHdr, sizeof(replyHdr)); - os->write(requestId); - } - - // - // Dispatch the incoming request. - // - _in.invoke(response, requestId); - } - } - catch(const LocalException& ex) - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - setState(StateClosed, ex); - } - catch(const std::exception& ex) - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - UnknownException uex(__FILE__, __LINE__); - uex.unknown = string("std::exception: ") + ex.what(); - setState(StateClosed, uex); - } - catch(...) - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - UnknownException uex(__FILE__, __LINE__); - uex.unknown = "unknown c++ exception"; - setState(StateClosed, uex); - } - - // - // If invoke() above raised an exception, and therefore neither - // sendResponse() nor sendNoResponse() has been called, then we - // must decrement _dispatchCount here. - // - if(invokeNum > 0) - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - assert(_dispatchCount > 0); - _dispatchCount -= invokeNum; - assert(_dispatchCount >= 0); - if(_dispatchCount == 0) - { - notifyAll(); - } - } + try + { + for(;invokeNum > 0; --invokeNum) + { + // + // Prepare the response if necessary. + // + const bool response = requestId != 0; + if(response) + { + assert(invokeNum == 1); // No further invocations if a response is expected. + + // + // Add the reply header and request id. + // + BasicStream* os = _in.os(); + os->writeBlob(replyHdr, sizeof(replyHdr)); + os->write(requestId); + } + + // + // Dispatch the incoming request. + // + _in.invoke(response, requestId); + } + } + catch(const LocalException& ex) + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + setState(StateClosed, ex); + } + catch(const std::exception& ex) + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + UnknownException uex(__FILE__, __LINE__); + uex.unknown = string("std::exception: ") + ex.what(); + setState(StateClosed, uex); + } + catch(...) + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + UnknownException uex(__FILE__, __LINE__); + uex.unknown = "unknown c++ exception"; + setState(StateClosed, uex); + } + + // + // If invoke() above raised an exception, and therefore neither + // sendResponse() nor sendNoResponse() has been called, then we + // must decrement _dispatchCount here. + // + if(invokeNum > 0) + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + assert(_dispatchCount > 0); + _dispatchCount -= invokeNum; + assert(_dispatchCount >= 0); + if(_dispatchCount == 0) + { + notifyAll(); + } + } #endif } } @@ -1892,22 +1892,22 @@ Ice::Connection::ThreadPerConnection::run() { try { - _connection->run(); + _connection->run(); } catch(const Exception& ex) - { - Error out(_connection->_logger); - out << "exception in thread per connection:\n" << _connection->toString() << ex.toString(); + { + Error out(_connection->_logger); + out << "exception in thread per connection:\n" << _connection->toString() << ex.toString(); } catch(const std::exception& ex) { - Error out(_connection->_logger); - out << "std::exception in thread per connection:\n" << _connection->toString() << ex.what(); + Error out(_connection->_logger); + out << "std::exception in thread per connection:\n" << _connection->toString() << ex.what(); } catch(...) { - Error out(_connection->_logger); - out << "unknown exception in thread per connection:\n" << _connection->toString(); + Error out(_connection->_logger); + out << "unknown exception in thread per connection:\n" << _connection->toString(); } _connection = 0; // Resolve cyclic dependency. diff --git a/cppe/src/IceE/ConvertUTF.cpp b/cppe/src/IceE/ConvertUTF.cpp index 7575bcc5c86..ea3812228b2 100644 --- a/cppe/src/IceE/ConvertUTF.cpp +++ b/cppe/src/IceE/ConvertUTF.cpp @@ -39,10 +39,10 @@ Author: Mark E. Davis, 1994. Rev History: Rick McGowan, fixes & updates May 2001. Sept 2001: fixed const & error conditions per - mods suggested by S. Parent & A. Lillich. + mods suggested by S. Parent & A. Lillich. June 2002: Tim Dodd added detection and handling of incomplete - source sequences, enhanced error detection, added casts - to eliminate compiler warnings. + source sequences, enhanced error detection, added casts + to eliminate compiler warnings. July 2003: slight mods to back out aggressive FFFE detection. Jan 2004: updated switches in from-UTF8 conversions. Oct 2004: updated to use UNI_MAX_LEGAL_UTF32 in UTF-32 conversions. @@ -70,8 +70,8 @@ static const UTF32 halfMask = 0x3FFUL; #define UNI_SUR_HIGH_END (UTF32)0xDBFF #define UNI_SUR_LOW_START (UTF32)0xDC00 #define UNI_SUR_LOW_END (UTF32)0xDFFF -// #define false 0 -// #define true 1 +// #define false 0 +// #define true 1 /* --------------------------------------------------------------------- */ @@ -100,7 +100,7 @@ static const char trailingBytesForUTF8[256] = { * in a UTF-8 sequence. */ static const UTF32 offsetsFromUTF8[6] = { 0x00000000UL, 0x00003080UL, 0x000E2080UL, - 0x03C82080UL, 0xFA082080UL, 0x82082080UL }; + 0x03C82080UL, 0xFA082080UL, 0x82082080UL }; /* * Once the bits are split out into bytes of UTF-8, this is a mask OR-ed @@ -124,67 +124,67 @@ static const UTF8 firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC /* --------------------------------------------------------------------- */ ConversionResult ConvertUTF16toUTF8 ( - const UTF16** sourceStart, const UTF16* sourceEnd, - UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) { + const UTF16** sourceStart, const UTF16* sourceEnd, + UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) { ConversionResult result = conversionOK; const UTF16* source = *sourceStart; UTF8* target = *targetStart; while (source < sourceEnd) { - UTF32 ch; - unsigned short bytesToWrite = 0; - const UTF32 byteMask = 0xBF; - const UTF32 byteMark = 0x80; - const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */ - ch = *source++; - /* If we have a surrogate pair, convert to UTF32 first. */ - if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) { - /* If the 16 bits following the high surrogate are in the source buffer... */ - if (source < sourceEnd) { - UTF32 ch2 = *source; - /* If it's a low surrogate, convert to UTF32. */ - if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) { - ch = ((ch - UNI_SUR_HIGH_START) << halfShift) - + (ch2 - UNI_SUR_LOW_START) + halfBase; - ++source; - } else if (flags == strictConversion) { /* it's an unpaired high surrogate */ - --source; /* return to the illegal value itself */ - result = sourceIllegal; - break; - } - } else { /* We don't have the 16 bits following the high surrogate. */ - --source; /* return to the high surrogate */ - result = sourceExhausted; - break; - } - } else if (flags == strictConversion) { - /* UTF-16 surrogate values are illegal in UTF-32 */ - if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) { - --source; /* return to the illegal value itself */ - result = sourceIllegal; - break; - } - } - /* Figure out how many bytes the result will require */ - if (ch < (UTF32)0x80) { bytesToWrite = 1; - } else if (ch < (UTF32)0x800) { bytesToWrite = 2; - } else if (ch < (UTF32)0x10000) { bytesToWrite = 3; - } else if (ch < (UTF32)0x110000) { bytesToWrite = 4; - } else { bytesToWrite = 3; - ch = UNI_REPLACEMENT_CHAR; - } - - target += bytesToWrite; - if (target > targetEnd) { - source = oldSource; /* Back up source pointer! */ - target -= bytesToWrite; result = targetExhausted; break; - } - switch (bytesToWrite) { /* note: everything falls through. */ - case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; - case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; - case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; - case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]); - } - target += bytesToWrite; + UTF32 ch; + unsigned short bytesToWrite = 0; + const UTF32 byteMask = 0xBF; + const UTF32 byteMark = 0x80; + const UTF16* oldSource = source; /* In case we have to back up because of target overflow. */ + ch = *source++; + /* If we have a surrogate pair, convert to UTF32 first. */ + if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_HIGH_END) { + /* If the 16 bits following the high surrogate are in the source buffer... */ + if (source < sourceEnd) { + UTF32 ch2 = *source; + /* If it's a low surrogate, convert to UTF32. */ + if (ch2 >= UNI_SUR_LOW_START && ch2 <= UNI_SUR_LOW_END) { + ch = ((ch - UNI_SUR_HIGH_START) << halfShift) + + (ch2 - UNI_SUR_LOW_START) + halfBase; + ++source; + } else if (flags == strictConversion) { /* it's an unpaired high surrogate */ + --source; /* return to the illegal value itself */ + result = sourceIllegal; + break; + } + } else { /* We don't have the 16 bits following the high surrogate. */ + --source; /* return to the high surrogate */ + result = sourceExhausted; + break; + } + } else if (flags == strictConversion) { + /* UTF-16 surrogate values are illegal in UTF-32 */ + if (ch >= UNI_SUR_LOW_START && ch <= UNI_SUR_LOW_END) { + --source; /* return to the illegal value itself */ + result = sourceIllegal; + break; + } + } + /* Figure out how many bytes the result will require */ + if (ch < (UTF32)0x80) { bytesToWrite = 1; + } else if (ch < (UTF32)0x800) { bytesToWrite = 2; + } else if (ch < (UTF32)0x10000) { bytesToWrite = 3; + } else if (ch < (UTF32)0x110000) { bytesToWrite = 4; + } else { bytesToWrite = 3; + ch = UNI_REPLACEMENT_CHAR; + } + + target += bytesToWrite; + if (target > targetEnd) { + source = oldSource; /* Back up source pointer! */ + target -= bytesToWrite; result = targetExhausted; break; + } + switch (bytesToWrite) { /* note: everything falls through. */ + case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; + case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; + case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; + case 1: *--target = (UTF8)(ch | firstByteMark[bytesToWrite]); + } + target += bytesToWrite; } *sourceStart = source; *targetStart = target; @@ -209,19 +209,19 @@ static Boolean isLegalUTF8(const UTF8 *source, int length) { const UTF8 *srcptr = source+length; switch (length) { default: return false; - /* Everything else falls through when "true"... */ + /* Everything else falls through when "true"... */ case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false; case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false; case 2: if ((a = (*--srcptr)) > 0xBF) return false; - switch (*source) { - /* no fall-through in this inner switch */ - case 0xE0: if (a < 0xA0) return false; break; - case 0xED: if (a > 0x9F) return false; break; - case 0xF0: if (a < 0x90) return false; break; - case 0xF4: if (a > 0x8F) return false; break; - default: if (a < 0x80) return false; - } + switch (*source) { + /* no fall-through in this inner switch */ + case 0xE0: if (a < 0xA0) return false; break; + case 0xED: if (a > 0x9F) return false; break; + case 0xF0: if (a < 0x90) return false; break; + case 0xF4: if (a > 0x8F) return false; break; + default: if (a < 0x80) return false; + } case 1: if (*source >= 0x80 && *source < 0xC2) return false; } @@ -260,70 +260,70 @@ Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd) { /* --------------------------------------------------------------------- */ ConversionResult ConvertUTF8toUTF16 ( - const UTF8** sourceStart, const UTF8* sourceEnd, - UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) { + const UTF8** sourceStart, const UTF8* sourceEnd, + UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags) { ConversionResult result = conversionOK; const UTF8* source = *sourceStart; UTF16* target = *targetStart; while (source < sourceEnd) { - UTF32 ch = 0; - unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; - if (source + extraBytesToRead >= sourceEnd) { - result = sourceExhausted; break; - } - /* Do this check whether lenient or strict */ - if (! isLegalUTF8(source, extraBytesToRead+1)) { - result = sourceIllegal; - break; - } - /* - * The cases all fall through. See "Note A" below. - */ - switch (extraBytesToRead) { - case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ - case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ - case 3: ch += *source++; ch <<= 6; - case 2: ch += *source++; ch <<= 6; - case 1: ch += *source++; ch <<= 6; - case 0: ch += *source++; - } - ch -= offsetsFromUTF8[extraBytesToRead]; - - if (target >= targetEnd) { - source -= (extraBytesToRead+1); /* Back up source pointer! */ - result = targetExhausted; break; - } - if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */ - /* UTF-16 surrogate values are illegal in UTF-32 */ - if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { - if (flags == strictConversion) { - source -= (extraBytesToRead+1); /* return to the illegal value itself */ - result = sourceIllegal; - break; - } else { - *target++ = UNI_REPLACEMENT_CHAR; - } - } else { - *target++ = (UTF16)ch; /* normal case */ - } - } else if (ch > UNI_MAX_UTF16) { - if (flags == strictConversion) { - result = sourceIllegal; - source -= (extraBytesToRead+1); /* return to the start */ - break; /* Bail out; shouldn't continue */ - } else { - *target++ = UNI_REPLACEMENT_CHAR; - } - } else { - /* target is a character in range 0xFFFF - 0x10FFFF. */ - if (target + 1 >= targetEnd) { - source -= (extraBytesToRead+1); /* Back up source pointer! */ - result = targetExhausted; break; - } - ch -= halfBase; - *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START); - *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START); - } + UTF32 ch = 0; + unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; + if (source + extraBytesToRead >= sourceEnd) { + result = sourceExhausted; break; + } + /* Do this check whether lenient or strict */ + if (! isLegalUTF8(source, extraBytesToRead+1)) { + result = sourceIllegal; + break; + } + /* + * The cases all fall through. See "Note A" below. + */ + switch (extraBytesToRead) { + case 5: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ + case 4: ch += *source++; ch <<= 6; /* remember, illegal UTF-8 */ + case 3: ch += *source++; ch <<= 6; + case 2: ch += *source++; ch <<= 6; + case 1: ch += *source++; ch <<= 6; + case 0: ch += *source++; + } + ch -= offsetsFromUTF8[extraBytesToRead]; + + if (target >= targetEnd) { + source -= (extraBytesToRead+1); /* Back up source pointer! */ + result = targetExhausted; break; + } + if (ch <= UNI_MAX_BMP) { /* Target is a character <= 0xFFFF */ + /* UTF-16 surrogate values are illegal in UTF-32 */ + if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { + if (flags == strictConversion) { + source -= (extraBytesToRead+1); /* return to the illegal value itself */ + result = sourceIllegal; + break; + } else { + *target++ = UNI_REPLACEMENT_CHAR; + } + } else { + *target++ = (UTF16)ch; /* normal case */ + } + } else if (ch > UNI_MAX_UTF16) { + if (flags == strictConversion) { + result = sourceIllegal; + source -= (extraBytesToRead+1); /* return to the start */ + break; /* Bail out; shouldn't continue */ + } else { + *target++ = UNI_REPLACEMENT_CHAR; + } + } else { + /* target is a character in range 0xFFFF - 0x10FFFF. */ + if (target + 1 >= targetEnd) { + source -= (extraBytesToRead+1); /* Back up source pointer! */ + result = targetExhausted; break; + } + ch -= halfBase; + *target++ = (UTF16)((ch >> halfShift) + UNI_SUR_HIGH_START); + *target++ = (UTF16)((ch & halfMask) + UNI_SUR_LOW_START); + } } *sourceStart = source; *targetStart = target; @@ -333,50 +333,50 @@ ConversionResult ConvertUTF8toUTF16 ( /* --------------------------------------------------------------------- */ ConversionResult ConvertUTF32toUTF8 ( - const UTF32** sourceStart, const UTF32* sourceEnd, - UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) { + const UTF32** sourceStart, const UTF32* sourceEnd, + UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags) { ConversionResult result = conversionOK; const UTF32* source = *sourceStart; UTF8* target = *targetStart; while (source < sourceEnd) { - UTF32 ch; - unsigned short bytesToWrite = 0; - const UTF32 byteMask = 0xBF; - const UTF32 byteMark = 0x80; - ch = *source++; - if (flags == strictConversion ) { - /* UTF-16 surrogate values are illegal in UTF-32 */ - if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { - --source; /* return to the illegal value itself */ - result = sourceIllegal; - break; - } - } - /* - * Figure out how many bytes the result will require. Turn any - * illegally large UTF32 things (> Plane 17) into replacement chars. - */ - if (ch < (UTF32)0x80) { bytesToWrite = 1; - } else if (ch < (UTF32)0x800) { bytesToWrite = 2; - } else if (ch < (UTF32)0x10000) { bytesToWrite = 3; - } else if (ch <= UNI_MAX_LEGAL_UTF32) { bytesToWrite = 4; - } else { bytesToWrite = 3; - ch = UNI_REPLACEMENT_CHAR; - result = sourceIllegal; - } - - target += bytesToWrite; - if (target > targetEnd) { - --source; /* Back up source pointer! */ - target -= bytesToWrite; result = targetExhausted; break; - } - switch (bytesToWrite) { /* note: everything falls through. */ - case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; - case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; - case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; - case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]); - } - target += bytesToWrite; + UTF32 ch; + unsigned short bytesToWrite = 0; + const UTF32 byteMask = 0xBF; + const UTF32 byteMark = 0x80; + ch = *source++; + if (flags == strictConversion ) { + /* UTF-16 surrogate values are illegal in UTF-32 */ + if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { + --source; /* return to the illegal value itself */ + result = sourceIllegal; + break; + } + } + /* + * Figure out how many bytes the result will require. Turn any + * illegally large UTF32 things (> Plane 17) into replacement chars. + */ + if (ch < (UTF32)0x80) { bytesToWrite = 1; + } else if (ch < (UTF32)0x800) { bytesToWrite = 2; + } else if (ch < (UTF32)0x10000) { bytesToWrite = 3; + } else if (ch <= UNI_MAX_LEGAL_UTF32) { bytesToWrite = 4; + } else { bytesToWrite = 3; + ch = UNI_REPLACEMENT_CHAR; + result = sourceIllegal; + } + + target += bytesToWrite; + if (target > targetEnd) { + --source; /* Back up source pointer! */ + target -= bytesToWrite; result = targetExhausted; break; + } + switch (bytesToWrite) { /* note: everything falls through. */ + case 4: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; + case 3: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; + case 2: *--target = (UTF8)((ch | byteMark) & byteMask); ch >>= 6; + case 1: *--target = (UTF8) (ch | firstByteMark[bytesToWrite]); + } + target += bytesToWrite; } *sourceStart = source; *targetStart = target; @@ -386,59 +386,59 @@ ConversionResult ConvertUTF32toUTF8 ( /* --------------------------------------------------------------------- */ ConversionResult ConvertUTF8toUTF32 ( - const UTF8** sourceStart, const UTF8* sourceEnd, - UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) { + const UTF8** sourceStart, const UTF8* sourceEnd, + UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags) { ConversionResult result = conversionOK; const UTF8* source = *sourceStart; UTF32* target = *targetStart; while (source < sourceEnd) { - UTF32 ch = 0; - unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; - if (source + extraBytesToRead >= sourceEnd) { - result = sourceExhausted; break; - } - /* Do this check whether lenient or strict */ - if (! isLegalUTF8(source, extraBytesToRead+1)) { - result = sourceIllegal; - break; - } - /* - * The cases all fall through. See "Note A" below. - */ - switch (extraBytesToRead) { - case 5: ch += *source++; ch <<= 6; - case 4: ch += *source++; ch <<= 6; - case 3: ch += *source++; ch <<= 6; - case 2: ch += *source++; ch <<= 6; - case 1: ch += *source++; ch <<= 6; - case 0: ch += *source++; - } - ch -= offsetsFromUTF8[extraBytesToRead]; - - if (target >= targetEnd) { - source -= (extraBytesToRead+1); /* Back up the source pointer! */ - result = targetExhausted; break; - } - if (ch <= UNI_MAX_LEGAL_UTF32) { - /* - * UTF-16 surrogate values are illegal in UTF-32, and anything - * over Plane 17 (> 0x10FFFF) is illegal. - */ - if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { - if (flags == strictConversion) { - source -= (extraBytesToRead+1); /* return to the illegal value itself */ - result = sourceIllegal; - break; - } else { - *target++ = UNI_REPLACEMENT_CHAR; - } - } else { - *target++ = ch; - } - } else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */ - result = sourceIllegal; - *target++ = UNI_REPLACEMENT_CHAR; - } + UTF32 ch = 0; + unsigned short extraBytesToRead = trailingBytesForUTF8[*source]; + if (source + extraBytesToRead >= sourceEnd) { + result = sourceExhausted; break; + } + /* Do this check whether lenient or strict */ + if (! isLegalUTF8(source, extraBytesToRead+1)) { + result = sourceIllegal; + break; + } + /* + * The cases all fall through. See "Note A" below. + */ + switch (extraBytesToRead) { + case 5: ch += *source++; ch <<= 6; + case 4: ch += *source++; ch <<= 6; + case 3: ch += *source++; ch <<= 6; + case 2: ch += *source++; ch <<= 6; + case 1: ch += *source++; ch <<= 6; + case 0: ch += *source++; + } + ch -= offsetsFromUTF8[extraBytesToRead]; + + if (target >= targetEnd) { + source -= (extraBytesToRead+1); /* Back up the source pointer! */ + result = targetExhausted; break; + } + if (ch <= UNI_MAX_LEGAL_UTF32) { + /* + * UTF-16 surrogate values are illegal in UTF-32, and anything + * over Plane 17 (> 0x10FFFF) is illegal. + */ + if (ch >= UNI_SUR_HIGH_START && ch <= UNI_SUR_LOW_END) { + if (flags == strictConversion) { + source -= (extraBytesToRead+1); /* return to the illegal value itself */ + result = sourceIllegal; + break; + } else { + *target++ = UNI_REPLACEMENT_CHAR; + } + } else { + *target++ = ch; + } + } else { /* i.e., ch > UNI_MAX_LEGAL_UTF32 */ + result = sourceIllegal; + *target++ = UNI_REPLACEMENT_CHAR; + } } *sourceStart = source; *targetStart = target; @@ -451,14 +451,14 @@ ConversionResult ConvertUTF8toUTF32 ( The fall-through switches in UTF-8 reading code save a temp variable, some decrements & conditionals. The switches are equivalent to the following loop: - { - int tmpBytesToRead = extraBytesToRead+1; - do { - ch += *source++; - --tmpBytesToRead; - if (tmpBytesToRead) ch <<= 6; - } while (tmpBytesToRead > 0); - } + { + int tmpBytesToRead = extraBytesToRead+1; + do { + ch += *source++; + --tmpBytesToRead; + if (tmpBytesToRead) ch <<= 6; + } while (tmpBytesToRead > 0); + } In UTF-8 writing code, the switches on "bytesToWrite" are similarly unrolled loops. diff --git a/cppe/src/IceE/ConvertUTF.h b/cppe/src/IceE/ConvertUTF.h index 92f461a91e5..07e2c0afcd8 100644 --- a/cppe/src/IceE/ConvertUTF.h +++ b/cppe/src/IceE/ConvertUTF.h @@ -62,12 +62,12 @@ the respective buffers. Input parameters: - sourceStart - pointer to a pointer to the source buffer. - The contents of this are modified on return so that - it points at the next thing to be converted. - targetStart - similarly, pointer to pointer to the target buffer. - sourceEnd, targetEnd - respectively pointers to the ends of the - two buffers, for overflow checking only. + sourceStart - pointer to a pointer to the source buffer. + The contents of this are modified on return so that + it points at the next thing to be converted. + targetStart - similarly, pointer to pointer to the target buffer. + sourceEnd, targetEnd - respectively pointers to the ends of the + two buffers, for overflow checking only. These conversion functions take a ConversionFlags argument. When this flag is set to strict, both irregular sequences and isolated surrogates @@ -84,15 +84,15 @@ they constitute an error. Output parameters: - The value "sourceIllegal" is returned from some routines if the input - sequence is malformed. When "sourceIllegal" is returned, the source - value will point to the illegal value that caused the problem. E.g., - in UTF-8 when a sequence is malformed, it points to the start of the - malformed sequence. + The value "sourceIllegal" is returned from some routines if the input + sequence is malformed. When "sourceIllegal" is returned, the source + value will point to the illegal value that caused the problem. E.g., + in UTF-8 when a sequence is malformed, it points to the start of the + malformed sequence. Author: Mark E. Davis, 1994. Rev History: Rick McGowan, fixes & updates May 2001. - Fixes & updates, Sept 2001. + Fixes & updates, Sept 2001. ------------------------------------------------------------------------ */ @@ -107,10 +107,10 @@ namespace IceUtil { -typedef unsigned int UTF32; /* at least 32 bits */ -typedef unsigned short UTF16; /* at least 16 bits */ -typedef unsigned char UTF8; /* typically 8 bits */ -typedef bool Boolean; /* 0 or 1 */ +typedef unsigned int UTF32; /* at least 32 bits */ +typedef unsigned short UTF16; /* at least 16 bits */ +typedef unsigned char UTF8; /* typically 8 bits */ +typedef bool Boolean; /* 0 or 1 */ /* Some fundamental constants */ #define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD @@ -127,7 +127,7 @@ ConversionResult ConvertUTF8toUTF16( ConversionResult ConvertUTF16toUTF8 ( const UTF16** sourceStart, const UTF16* sourceEnd, UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); - + ConversionResult ConvertUTF8toUTF32( const UTF8** sourceStart, const UTF8* sourceEnd, UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); diff --git a/cppe/src/IceE/Current.cpp b/cppe/src/IceE/Current.cpp index 9b5543f9e39..0ae5348eefb 100644 --- a/cppe/src/IceE/Current.cpp +++ b/cppe/src/IceE/Current.cpp @@ -20,35 +20,35 @@ Ice::Current::operator!=(const Current& __rhs) const { if(this == &__rhs) { - return false; + return false; } if(adapter != __rhs.adapter) { - return true; + return true; } if(con != __rhs.con) { - return true; + return true; } if(id != __rhs.id) { - return true; + return true; } if(facet != __rhs.facet) { - return true; + return true; } if(operation != __rhs.operation) { - return true; + return true; } if(mode != __rhs.mode) { - return true; + return true; } if(ctx != __rhs.ctx) { - return true; + return true; } return false; } @@ -58,63 +58,63 @@ Ice::Current::operator<(const Current& __rhs) const { if(this == &__rhs) { - return false; + return false; } if(adapter < __rhs.adapter) { - return true; + return true; } else if(__rhs.adapter < adapter) { - return false; + return false; } if(con < __rhs.con) { - return true; + return true; } else if(__rhs.con < con) { - return false; + return false; } if(id < __rhs.id) { - return true; + return true; } else if(__rhs.id < id) { - return false; + return false; } if(facet < __rhs.facet) { - return true; + return true; } else if(__rhs.facet < facet) { - return false; + return false; } if(operation < __rhs.operation) { - return true; + return true; } else if(__rhs.operation < operation) { - return false; + return false; } if(mode < __rhs.mode) { - return true; + return true; } else if(__rhs.mode < mode) { - return false; + return false; } if(ctx < __rhs.ctx) { - return true; + return true; } else if(__rhs.ctx < ctx) { - return false; + return false; } return false; } diff --git a/cppe/src/IceE/DefaultsAndOverrides.cpp b/cppe/src/IceE/DefaultsAndOverrides.cpp index 1f1a2e6f75c..7b47da40d5c 100644 --- a/cppe/src/IceE/DefaultsAndOverrides.cpp +++ b/cppe/src/IceE/DefaultsAndOverrides.cpp @@ -34,15 +34,15 @@ IceInternal::DefaultsAndOverrides::DefaultsAndOverrides(const PropertiesPtr& pro value = properties->getProperty("Ice.Override.Timeout"); if(!value.empty()) { - const_cast<bool&>(overrideTimeout) = true; - const_cast<Int&>(overrideTimeoutValue) = properties->getPropertyAsInt("Ice.Override.Timeout"); + const_cast<bool&>(overrideTimeout) = true; + const_cast<Int&>(overrideTimeoutValue) = properties->getPropertyAsInt("Ice.Override.Timeout"); } value = properties->getProperty("Ice.Override.ConnectTimeout"); if(!value.empty()) { - const_cast<bool&>(overrideConnectTimeout) = true; - const_cast<Int&>(overrideConnectTimeoutValue) = properties->getPropertyAsInt("Ice.Override.ConnectTimeout"); + const_cast<bool&>(overrideConnectTimeout) = true; + const_cast<Int&>(overrideConnectTimeoutValue) = properties->getPropertyAsInt("Ice.Override.ConnectTimeout"); } #ifdef ICEE_HAS_LOCATOR diff --git a/cppe/src/IceE/ExceptionBase.cpp b/cppe/src/IceE/ExceptionBase.cpp index 1396a516f3a..83467e3a8a5 100644 --- a/cppe/src/IceE/ExceptionBase.cpp +++ b/cppe/src/IceE/ExceptionBase.cpp @@ -99,12 +99,12 @@ IceUtil::NullHandleException::NullHandleException(const char* file, int line) : if(nullHandleAbort) { #ifdef _WIN32_WCE - // - // WinCE does not appear to have abort() - // - exit(-1); + // + // WinCE does not appear to have abort() + // + exit(-1); #else - abort(); + abort(); #endif } } diff --git a/cppe/src/IceE/FactoryTableDef.cpp b/cppe/src/IceE/FactoryTableDef.cpp index db0ffdfbb8d..127312d6b53 100644 --- a/cppe/src/IceE/FactoryTableDef.cpp +++ b/cppe/src/IceE/FactoryTableDef.cpp @@ -17,11 +17,11 @@ namespace IceInternal { -FactoryTableWrapper factoryTableWrapper; // Single global instance of the wrapper object that - // initializes factoryTable. +FactoryTableWrapper factoryTableWrapper; // Single global instance of the wrapper object that + // initializes factoryTable. -ICE_API FactoryTableDef* factoryTable; // Single global instance of the factory table for - // non-local exceptions and non-abstract classes +ICE_API FactoryTableDef* factoryTable; // Single global instance of the factory table for + // non-local exceptions and non-abstract classes } // @@ -35,11 +35,11 @@ IceInternal::FactoryTableDef::addExceptionFactory(const std::string& t, const Ic EFTable::iterator i = _eft.find(t); if(i == _eft.end()) { - _eft[t] = EFPair(f, 1); + _eft[t] = EFPair(f, 1); } else { - i->second.second++; + i->second.second++; } } @@ -54,23 +54,23 @@ IceInternal::FactoryTableDef::getExceptionFactory(const std::string& t) const #ifdef __APPLE__ if(i == _eft.end()) { - lock.release(); - - // - // Try to find the symbol, if found this should trigger the - // object static constructors to be called. - // - std::string symbol = "__F"; - for(std::string::const_iterator p = t.begin(); p != t.end(); ++p) - { - symbol += ((*p) == ':') ? '_' : *p; - } - symbol += "__initializer"; - dlsym(RTLD_DEFAULT, symbol.c_str()); - - lock.acquire(); - - i = _eft.find(t); + lock.release(); + + // + // Try to find the symbol, if found this should trigger the + // object static constructors to be called. + // + std::string symbol = "__F"; + for(std::string::const_iterator p = t.begin(); p != t.end(); ++p) + { + symbol += ((*p) == ':') ? '_' : *p; + } + symbol += "__initializer"; + dlsym(RTLD_DEFAULT, symbol.c_str()); + + lock.acquire(); + + i = _eft.find(t); } #endif return i != _eft.end() ? i->second.first : IceInternal::UserExceptionFactoryPtr(); @@ -89,10 +89,10 @@ IceInternal::FactoryTableDef::removeExceptionFactory(const std::string& t) EFTable::iterator i = _eft.find(t); if(i != _eft.end()) { - if(--i->second.second == 0) - { - _eft.erase(i); - } + if(--i->second.second == 0) + { + _eft.erase(i); + } } } @@ -122,7 +122,7 @@ IceInternal::FactoryTableWrapper::initialize() IceUtil::StaticMutex::Lock lock(_m); if(_initCount == 0) { - factoryTable = new FactoryTableDef; + factoryTable = new FactoryTableDef; } ++_initCount; } @@ -136,9 +136,9 @@ IceInternal::FactoryTableWrapper::finalize() IceUtil::StaticMutex::Lock lock(_m); if(--_initCount == 0) { - delete factoryTable; + delete factoryTable; } } IceUtil::StaticMutex IceInternal::FactoryTableWrapper::_m = ICE_STATIC_MUTEX_INITIALIZER; -int IceInternal::FactoryTableWrapper::_initCount = 0; // Initialization count +int IceInternal::FactoryTableWrapper::_initCount = 0; // Initialization count diff --git a/cppe/src/IceE/Incoming.cpp b/cppe/src/IceE/Incoming.cpp index 4f5dbb63848..3ea3984b4bf 100644 --- a/cppe/src/IceE/Incoming.cpp +++ b/cppe/src/IceE/Incoming.cpp @@ -45,15 +45,15 @@ IceInternal::Incoming::setAdapter(const Ice::ObjectAdapterPtr& adapter) _adapter = adapter; if(_adapter) { - _servantManager = _adapter->getServantManager().get(); - if(!_servantManager) - { - _adapter = 0; - } + _servantManager = _adapter->getServantManager().get(); + if(!_servantManager) + { + _adapter = 0; + } } else { - _servantManager = 0; + _servantManager = 0; } } @@ -85,26 +85,26 @@ IceInternal::Incoming::invoke(bool response, Int requestId) // string facet; // if(!facetPath.empty()) // { -// if(facetPath.size() > 1) -// { -// throw MarshalException(__FILE__, __LINE__); -// } -// facet.swap(facetPath[0]); +// if(facetPath.size() > 1) +// { +// throw MarshalException(__FILE__, __LINE__); +// } +// facet.swap(facetPath[0]); // } // _current.facet.swap(facet); Int sz; _is.readSize(sz); if(sz > 0) { - if(sz > 1) - { - throw MarshalException(__FILE__, __LINE__); - } - _is.read(_current.facet); + if(sz > 1) + { + throw MarshalException(__FILE__, __LINE__); + } + _is.read(_current.facet); } else { - _current.facet.clear(); + _current.facet.clear(); } _is.read(_current.operation, false); @@ -116,19 +116,19 @@ IceInternal::Incoming::invoke(bool response, Int requestId) _is.readSize(sz); while(sz--) { - pair<const string, string> pr; - _is.read(const_cast<string&>(pr.first)); - _is.read(pr.second); - _current.ctx.insert(_current.ctx.end(), pr); + pair<const string, string> pr; + _is.read(const_cast<string&>(pr.first)); + _is.read(pr.second); + _current.ctx.insert(_current.ctx.end(), pr); } _is.startReadEncaps(); if(response) { - assert(_os.b.size() == headerSize + 4); // Reply status position. - _os.write(replyOK); - _os.startWriteEncaps(); + assert(_os.b.size() == headerSize + 4); // Reply status position. + _os.write(replyOK); + _os.startWriteEncaps(); } @@ -143,294 +143,294 @@ IceInternal::Incoming::invoke(bool response, Int requestId) try { - Ice::ObjectPtr servant; - if(_servantManager) - { - servant = _servantManager->findServant(_current.id, _current.facet); - } - - if(!servant) - { - if(_servantManager && _servantManager->hasServant(_current.id)) - { - replyStatus = replyFacetNotExist; - } - else - { - replyStatus = replyObjectNotExist; - } - } - else - { - dispatchStatus = servant->__dispatch(*this, _current); + Ice::ObjectPtr servant; + if(_servantManager) + { + servant = _servantManager->findServant(_current.id, _current.facet); + } + + if(!servant) + { + if(_servantManager && _servantManager->hasServant(_current.id)) + { + replyStatus = replyFacetNotExist; + } + else + { + replyStatus = replyObjectNotExist; + } + } + else + { + dispatchStatus = servant->__dispatch(*this, _current); if(dispatchStatus == DispatchUserException) { replyStatus = replyUserException; } - } + } } catch(RequestFailedException& ex) { - _is.endReadEncaps(); - - if(ex.id.name.empty()) - { - ex.id = _current.id; - } - - if(ex.facet.empty() && !_current.facet.empty()) - { - ex.facet = _current.facet; - } - - if(ex.operation.empty() && !_current.operation.empty()) - { - ex.operation = _current.operation; - } - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 1) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - if(dynamic_cast<ObjectNotExistException*>(&ex)) - { - _os.write(replyObjectNotExist); - } - else if(dynamic_cast<FacetNotExistException*>(&ex)) - { - _os.write(replyFacetNotExist); - } - else if(dynamic_cast<OperationNotExistException*>(&ex)) - { - _os.write(replyOperationNotExist); - } - else - { - assert(false); - } - - ex.id.__write(&_os); - - // - // For compatibility with the old FacetPath. - // - if(ex.facet.empty()) - { - _os.write(static_cast<string*>(0), static_cast<string*>(0)); - } - else - { - _os.write(&ex.facet, &ex.facet + 1); - } - - _os.write(ex.operation, false); - - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(ex.id.name.empty()) + { + ex.id = _current.id; + } + + if(ex.facet.empty() && !_current.facet.empty()) + { + ex.facet = _current.facet; + } + + if(ex.operation.empty() && !_current.operation.empty()) + { + ex.operation = _current.operation; + } + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 1) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + if(dynamic_cast<ObjectNotExistException*>(&ex)) + { + _os.write(replyObjectNotExist); + } + else if(dynamic_cast<FacetNotExistException*>(&ex)) + { + _os.write(replyFacetNotExist); + } + else if(dynamic_cast<OperationNotExistException*>(&ex)) + { + _os.write(replyOperationNotExist); + } + else + { + assert(false); + } + + ex.id.__write(&_os); + + // + // For compatibility with the old FacetPath. + // + if(ex.facet.empty()) + { + _os.write(static_cast<string*>(0), static_cast<string*>(0)); + } + else + { + _os.write(&ex.facet, &ex.facet + 1); + } + + _os.write(ex.operation, false); + + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const UnknownLocalException& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownLocalException); - _os.write(ex.unknown, false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownLocalException); + _os.write(ex.unknown, false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const UnknownUserException& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownUserException); - _os.write(ex.unknown, false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownUserException); + _os.write(ex.unknown, false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const UnknownException& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownException); - _os.write(ex.unknown, false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownException); + _os.write(ex.unknown, false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const LocalException& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownLocalException); - _os.write(ex.toString(), false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownLocalException); + _os.write(ex.toString(), false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const UserException& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownUserException); - _os.write(ex.toString(), false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownUserException); + _os.write(ex.toString(), false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const Exception& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(ex); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownException); - _os.write(ex.toString(), false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(ex); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownException); + _os.write(ex.toString(), false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(const std::exception& ex) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning(string("std::exception: ") + ex.what()); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownException); - string msg = string("std::exception: ") + ex.what(); - _os.write(msg, false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning(string("std::exception: ") + ex.what()); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownException); + string msg = string("std::exception: ") + ex.what(); + _os.write(msg, false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } catch(...) { - _is.endReadEncaps(); - - if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) - { - __warning("unknown c++ exception"); - } - - if(response) - { - _os.endWriteEncaps(); - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyUnknownException); - _os.write(string("unknown c++ exception"), false); - _connection->sendResponse(&_os); - } - else - { - _connection->sendNoResponse(); - } - - return; + _is.endReadEncaps(); + + if(_os.instance()->initializationData().properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 0) + { + __warning("unknown c++ exception"); + } + + if(response) + { + _os.endWriteEncaps(); + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyUnknownException); + _os.write(string("unknown c++ exception"), false); + _connection->sendResponse(&_os); + } + else + { + _connection->sendNoResponse(); + } + + return; } // @@ -443,42 +443,42 @@ IceInternal::Incoming::invoke(bool response, Int requestId) if(response) { - _os.endWriteEncaps(); - - if(replyStatus != replyOK && replyStatus != replyUserException) - { - assert(replyStatus == replyObjectNotExist || - replyStatus == replyFacetNotExist); - - _os.b.resize(headerSize + 4); // Reply status position. - _os.write(replyStatus); - - _current.id.__write(&_os); - - // - // For compatibility with the old FacetPath. - // - if(_current.facet.empty()) - { - _os.write(static_cast<string*>(0), static_cast<string*>(0)); - } - else - { - _os.write(&_current.facet, &_current.facet + 1); - } - - _os.write(_current.operation, false); - } - else - { - *(_os.b.begin() + headerSize + 4) = replyStatus; // Reply status position. - } - - _connection->sendResponse(&_os); + _os.endWriteEncaps(); + + if(replyStatus != replyOK && replyStatus != replyUserException) + { + assert(replyStatus == replyObjectNotExist || + replyStatus == replyFacetNotExist); + + _os.b.resize(headerSize + 4); // Reply status position. + _os.write(replyStatus); + + _current.id.__write(&_os); + + // + // For compatibility with the old FacetPath. + // + if(_current.facet.empty()) + { + _os.write(static_cast<string*>(0), static_cast<string*>(0)); + } + else + { + _os.write(&_current.facet, &_current.facet + 1); + } + + _os.write(_current.operation, false); + } + else + { + *(_os.b.begin() + headerSize + 4) = replyStatus; // Reply status position. + } + + _connection->sendResponse(&_os); } else { - _connection->sendNoResponse(); + _connection->sendNoResponse(); } } diff --git a/cppe/src/IceE/IncomingConnectionFactory.cpp b/cppe/src/IceE/IncomingConnectionFactory.cpp index 8d124ad232c..d3c9cee90e3 100644 --- a/cppe/src/IceE/IncomingConnectionFactory.cpp +++ b/cppe/src/IceE/IncomingConnectionFactory.cpp @@ -53,22 +53,22 @@ IceInternal::IncomingConnectionFactory::waitUntilHolding() const list<ConnectionPtr> connections; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // First we wait until the connection factory itself is in holding - // state. - // - while(_state < StateHolding) - { - wait(); - } - - // - // We want to wait until all connections are in holding state - // outside the thread synchronization. - // - connections = _connections; + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // First we wait until the connection factory itself is in holding + // state. + // + while(_state < StateHolding) + { + wait(); + } + + // + // We want to wait until all connections are in holding state + // outside the thread synchronization. + // + connections = _connections; } // @@ -84,30 +84,30 @@ IceInternal::IncomingConnectionFactory::waitUntilFinished() list<ConnectionPtr> connections; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // First we wait until the factory is destroyed. If we are using - // an acceptor, we also wait for it to be closed. - // - while(_state != StateClosed || _acceptor) - { - wait(); - } - - threadPerIncomingConnectionFactory = _threadPerIncomingConnectionFactory; - _threadPerIncomingConnectionFactory = 0; - - // - // We want to wait until all connections are finished outside the - // thread synchronization. - // - connections.swap(_connections); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // First we wait until the factory is destroyed. If we are using + // an acceptor, we also wait for it to be closed. + // + while(_state != StateClosed || _acceptor) + { + wait(); + } + + threadPerIncomingConnectionFactory = _threadPerIncomingConnectionFactory; + _threadPerIncomingConnectionFactory = 0; + + // + // We want to wait until all connections are finished outside the + // thread synchronization. + // + connections.swap(_connections); } if(threadPerIncomingConnectionFactory) { - threadPerIncomingConnectionFactory->getThreadControl().join(); + threadPerIncomingConnectionFactory->getThreadControl().join(); } for_each(connections.begin(), connections.end(), Ice::voidMemFun(&Connection::waitUntilFinished)); @@ -131,7 +131,7 @@ IceInternal::IncomingConnectionFactory::connections() const // Only copy connections which have not been destroyed. // remove_copy_if(_connections.begin(), _connections.end(), back_inserter(result), - Ice::constMemFun(&Connection::isDestroyed)); + Ice::constMemFun(&Connection::isDestroyed)); return result; } @@ -143,14 +143,14 @@ IceInternal::IncomingConnectionFactory::flushBatchRequests() for(list<ConnectionPtr>::const_iterator p = c.begin(); p != c.end(); ++p) { - try - { - (*p)->flushBatchRequests(); - } - catch(const LocalException&) - { - // Ignore. - } + try + { + (*p)->flushBatchRequests(); + } + catch(const LocalException&) + { + // Ignore. + } } } @@ -161,7 +161,7 @@ IceInternal::IncomingConnectionFactory::toString() const if(_transceiver) { - return _transceiver->toString(); + return _transceiver->toString(); } assert(_acceptor); @@ -169,8 +169,8 @@ IceInternal::IncomingConnectionFactory::toString() const } IceInternal::IncomingConnectionFactory::IncomingConnectionFactory(const InstancePtr& instance, - const EndpointPtr& endpoint, - const ObjectAdapterPtr& adapter) : + const EndpointPtr& endpoint, + const ObjectAdapterPtr& adapter) : _instance(instance), _endpoint(endpoint), _adapter(adapter), @@ -179,8 +179,8 @@ IceInternal::IncomingConnectionFactory::IncomingConnectionFactory(const Instance { if(_instance->defaultsAndOverrides()->overrideTimeout) { - const_cast<EndpointPtr&>(_endpoint) = - _endpoint->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue); + const_cast<EndpointPtr&>(_endpoint) = + _endpoint->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue); } _acceptor = _endpoint->acceptor(const_cast<EndpointPtr&>(_endpoint)); @@ -190,36 +190,36 @@ IceInternal::IncomingConnectionFactory::IncomingConnectionFactory(const Instance __setNoDelete(true); try { - // - // If we are in thread per connection mode, we also use one - // thread per incoming connection factory, that accepts new - // connections on this endpoint. - // - _threadPerIncomingConnectionFactory = new ThreadPerIncomingConnectionFactory(this); - _threadPerIncomingConnectionFactory->start(_instance->threadPerConnectionStackSize()); + // + // If we are in thread per connection mode, we also use one + // thread per incoming connection factory, that accepts new + // connections on this endpoint. + // + _threadPerIncomingConnectionFactory = new ThreadPerIncomingConnectionFactory(this); + _threadPerIncomingConnectionFactory->start(_instance->threadPerConnectionStackSize()); } catch(const Ice::Exception& ex) { - { - Error out(_instance->initializationData().logger); - out << "cannot create thread for incoming connection factory:\n" << ex.toString(); - } - - try - { - _acceptor->close(); - } - catch(const LocalException&) - { - // Here we ignore any exceptions in close(). - } - - _state = StateClosed; - _acceptor = 0; - _threadPerIncomingConnectionFactory = 0; - - __setNoDelete(false); - ex.ice_throw(); + { + Error out(_instance->initializationData().logger); + out << "cannot create thread for incoming connection factory:\n" << ex.toString(); + } + + try + { + _acceptor->close(); + } + catch(const LocalException&) + { + // Here we ignore any exceptions in close(). + } + + _state = StateClosed; + _acceptor = 0; + _threadPerIncomingConnectionFactory = 0; + + __setNoDelete(false); + ex.ice_throw(); } __setNoDelete(false); } @@ -239,52 +239,52 @@ IceInternal::IncomingConnectionFactory::setState(State state) { if(_state == state) // Don't switch twice. { - return; + return; } switch(state) { - case StateActive: - { - if(_state != StateHolding) // Can only switch from holding to active. - { - return; - } - for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&Connection::activate)); - break; - } - - case StateHolding: - { - if(_state != StateActive) // Can only switch from active to holding. - { - return; - } - for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&Connection::hold)); - break; - } - - case StateClosed: - { - if(_acceptor) - { - // - // Connect to our own acceptor, which unblocks our - // thread per incoming connection factory stuck in accept(). - // - _acceptor->connectToSelf(); - } + case StateActive: + { + if(_state != StateHolding) // Can only switch from holding to active. + { + return; + } + for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&Connection::activate)); + break; + } + + case StateHolding: + { + if(_state != StateActive) // Can only switch from active to holding. + { + return; + } + for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&Connection::hold)); + break; + } + + case StateClosed: + { + if(_acceptor) + { + // + // Connect to our own acceptor, which unblocks our + // thread per incoming connection factory stuck in accept(). + // + _acceptor->connectToSelf(); + } #ifdef _STLP_BEGIN_NAMESPACE - // voidbind2nd is an STLport extension for broken compilers in IceE/Functional.h - for_each(_connections.begin(), _connections.end(), - voidbind2nd(Ice::voidMemFun1(&Connection::destroy), Connection::ObjectAdapterDeactivated)); + // voidbind2nd is an STLport extension for broken compilers in IceE/Functional.h + for_each(_connections.begin(), _connections.end(), + voidbind2nd(Ice::voidMemFun1(&Connection::destroy), Connection::ObjectAdapterDeactivated)); #else - for_each(_connections.begin(), _connections.end(), - bind2nd(Ice::voidMemFun1(&Connection::destroy), Connection::ObjectAdapterDeactivated)); + for_each(_connections.begin(), _connections.end(), + bind2nd(Ice::voidMemFun1(&Connection::destroy), Connection::ObjectAdapterDeactivated)); #endif - break; - } + break; + } } _state = state; @@ -298,109 +298,109 @@ IceInternal::IncomingConnectionFactory::run() while(true) { - // - // We must accept new connections outside the thread - // synchronization, because we use blocking accept. - // - TransceiverPtr transceiver; - try - { - transceiver = _acceptor->accept(); - } - catch(const SocketException&) - { - // Ignore socket exceptions. - } - catch(const TimeoutException&) - { - // Ignore timeouts. - } - catch(const LocalException& ex) - { - // Warn about other Ice local exceptions. - if(_warn) - { - Warning out(_instance->initializationData().logger); - out << "connection exception:\n" << ex.toString() << "\n" << _acceptor->toString(); - } - } - - ConnectionPtr connection; - - { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - while(_state == StateHolding) - { - wait(); - } - - if(_state == StateClosed) - { - if(transceiver) - { - try - { - transceiver->close(); - } - catch(const LocalException&) - { - // Here we ignore any exceptions in close(). - } - } - - try - { - _acceptor->close(); - } - catch(const LocalException& ex) - { - _acceptor = 0; - notifyAll(); - ex.ice_throw(); - } - - _acceptor = 0; - notifyAll(); - return; - } - - assert(_state == StateActive); - - // - // Reap connections for which destruction has completed. - // - _connections.erase(remove_if(_connections.begin(), _connections.end(), - Ice::constMemFun(&Connection::isFinished)), - _connections.end()); - - // - // Create a connection object for the connection. - // - if(transceiver) - { - try - { - connection = new Connection(_instance, transceiver, _endpoint, _adapter); - } - catch(const LocalException&) - { - return; - } - - _connections.push_back(connection); - } - } - - // - // In thread per connection mode, the connection's thread will - // take care of connection validation and activation. We don't - // want to block this thread waiting until validation is - // complete because it is the only thread that can accept - // connections with this factory's acceptor. Therefore we - // don't call validate() and activate() from the connection - // factory in thread per connection mode. - // + // + // We must accept new connections outside the thread + // synchronization, because we use blocking accept. + // + TransceiverPtr transceiver; + try + { + transceiver = _acceptor->accept(); + } + catch(const SocketException&) + { + // Ignore socket exceptions. + } + catch(const TimeoutException&) + { + // Ignore timeouts. + } + catch(const LocalException& ex) + { + // Warn about other Ice local exceptions. + if(_warn) + { + Warning out(_instance->initializationData().logger); + out << "connection exception:\n" << ex.toString() << "\n" << _acceptor->toString(); + } + } + + ConnectionPtr connection; + + { + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + while(_state == StateHolding) + { + wait(); + } + + if(_state == StateClosed) + { + if(transceiver) + { + try + { + transceiver->close(); + } + catch(const LocalException&) + { + // Here we ignore any exceptions in close(). + } + } + + try + { + _acceptor->close(); + } + catch(const LocalException& ex) + { + _acceptor = 0; + notifyAll(); + ex.ice_throw(); + } + + _acceptor = 0; + notifyAll(); + return; + } + + assert(_state == StateActive); + + // + // Reap connections for which destruction has completed. + // + _connections.erase(remove_if(_connections.begin(), _connections.end(), + Ice::constMemFun(&Connection::isFinished)), + _connections.end()); + + // + // Create a connection object for the connection. + // + if(transceiver) + { + try + { + connection = new Connection(_instance, transceiver, _endpoint, _adapter); + } + catch(const LocalException&) + { + return; + } + + _connections.push_back(connection); + } + } + + // + // In thread per connection mode, the connection's thread will + // take care of connection validation and activation. We don't + // want to block this thread waiting until validation is + // complete because it is the only thread that can accept + // connections with this factory's acceptor. Therefore we + // don't call validate() and activate() from the connection + // factory in thread per connection mode. + // } } @@ -415,22 +415,22 @@ IceInternal::IncomingConnectionFactory::ThreadPerIncomingConnectionFactory::run( { try { - _factory->run(); + _factory->run(); } catch(const Exception& ex) - { - Error out(_factory->_instance->initializationData().logger); - out << "exception in thread per incoming connection factory:\n" << _factory->toString() << ex.toString(); + { + Error out(_factory->_instance->initializationData().logger); + out << "exception in thread per incoming connection factory:\n" << _factory->toString() << ex.toString(); } catch(const std::exception& ex) { - Error out(_factory->_instance->initializationData().logger); - out << "std::exception in thread per incoming connection factory:\n" << _factory->toString() << ex.what(); + Error out(_factory->_instance->initializationData().logger); + out << "std::exception in thread per incoming connection factory:\n" << _factory->toString() << ex.what(); } catch(...) { - Error out(_factory->_instance->initializationData().logger); - out << "unknown exception in thread per incoming connection factory:\n" << _factory->toString(); + Error out(_factory->_instance->initializationData().logger); + out << "unknown exception in thread per incoming connection factory:\n" << _factory->toString(); } _factory = 0; // Resolve cyclic dependency. diff --git a/cppe/src/IceE/IncomingConnectionFactory.h b/cppe/src/IceE/IncomingConnectionFactory.h index 766816054fa..0150c81b017 100644 --- a/cppe/src/IceE/IncomingConnectionFactory.h +++ b/cppe/src/IceE/IncomingConnectionFactory.h @@ -55,9 +55,9 @@ private: enum State { - StateActive, - StateHolding, - StateClosed + StateActive, + StateHolding, + StateClosed }; void setState(State); @@ -67,13 +67,13 @@ private: class ThreadPerIncomingConnectionFactory : public IceUtil::Thread { public: - - ThreadPerIncomingConnectionFactory(const IncomingConnectionFactoryPtr&); - virtual void run(); + + ThreadPerIncomingConnectionFactory(const IncomingConnectionFactoryPtr&); + virtual void run(); private: - - IncomingConnectionFactoryPtr _factory; + + IncomingConnectionFactoryPtr _factory; }; friend class ThreadPerIncomingConnectionFactory; IceUtil::ThreadPtr _threadPerIncomingConnectionFactory; diff --git a/cppe/src/IceE/Initialize.cpp b/cppe/src/IceE/Initialize.cpp index 9c10c2e0605..13d09f0e2a8 100644 --- a/cppe/src/IceE/Initialize.cpp +++ b/cppe/src/IceE/Initialize.cpp @@ -56,7 +56,7 @@ Ice::stringSeqToArgs(const StringSeq& args, int& argc, char* argv[]) // if(argv) { - argv[argc] = 0; + argv[argc] = 0; } } @@ -113,7 +113,7 @@ inline void checkIceVersion(Int version) // if(ICEE_INT_VERSION / 100 != version / 100) { - throw VersionMismatchException(__FILE__, __LINE__); + throw VersionMismatchException(__FILE__, __LINE__); } // // The caller's patch level cannot be greater than library's patch level. (Patch level changes are @@ -121,7 +121,7 @@ inline void checkIceVersion(Int version) // if(version % 100 > ICEE_INT_VERSION % 100) { - throw VersionMismatchException(__FILE__, __LINE__); + throw VersionMismatchException(__FILE__, __LINE__); } #endif } @@ -149,42 +149,42 @@ Ice::initialize(StringSeq& args, const InitializationData& initializationData, I CommunicatorPtr communicator; try { - // - // Make a dummy argc/argv. - // (We can't use argsToStringSeq() because that requires an already initialized argv.) - // - int argc = args.size(); - origArgc = argc; - argv = new char*[args.size() + 1]; - int i; - for(i = 0; i != argc; ++i) - { - argv[i] = new char[args[i].size() + 1]; + // + // Make a dummy argc/argv. + // (We can't use argsToStringSeq() because that requires an already initialized argv.) + // + int argc = args.size(); + origArgc = argc; + argv = new char*[args.size() + 1]; + int i; + for(i = 0; i != argc; ++i) + { + argv[i] = new char[args[i].size() + 1]; #if defined(_MSC_VER) && (_MSC_VER >= 1400) - strcpy_s(argv[i], args[i].size() + 1, args[i].c_str()); + strcpy_s(argv[i], args[i].size() + 1, args[i].c_str()); #else - strcpy(argv[i], args[i].c_str()); + strcpy(argv[i], args[i].c_str()); #endif - } - argv[argc] = 0; - - communicator = initialize(argc, argv, initializationData, version); - - args = argsToStringSeq(argc, argv); - - for(i = 0; i < origArgc; ++i) - { - delete[] argv[i]; - } - delete[] argv; + } + argv[argc] = 0; + + communicator = initialize(argc, argv, initializationData, version); + + args = argsToStringSeq(argc, argv); + + for(i = 0; i < origArgc; ++i) + { + delete[] argv[i]; + } + delete[] argv; } catch(...) { - for(int i = 0; i < origArgc; ++i) - { - delete[] argv[i]; - } - delete[] argv; + for(int i = 0; i < origArgc; ++i) + { + delete[] argv[i]; + } + delete[] argv; throw; } return communicator; diff --git a/cppe/src/IceE/Instance.cpp b/cppe/src/IceE/Instance.cpp index 27cc1453802..81221c987bd 100644 --- a/cppe/src/IceE/Instance.cpp +++ b/cppe/src/IceE/Instance.cpp @@ -88,7 +88,7 @@ IceInternal::Instance::routerManager() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _routerManager; @@ -105,7 +105,7 @@ IceInternal::Instance::locatorManager() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _locatorManager; @@ -120,7 +120,7 @@ IceInternal::Instance::referenceFactory() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _referenceFactory; @@ -133,7 +133,7 @@ IceInternal::Instance::proxyFactory() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _proxyFactory; @@ -146,7 +146,7 @@ IceInternal::Instance::outgoingConnectionFactory() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _outgoingConnectionFactory; @@ -160,7 +160,7 @@ IceInternal::Instance::objectAdapterFactory() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _objectAdapterFactory; @@ -183,7 +183,7 @@ IceInternal::Instance::endpointFactory() const if(_state == StateDestroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } return _endpointFactory; @@ -200,16 +200,16 @@ IceInternal::Instance::flushBatchRequests() #endif { - IceUtil::RecMutex::Lock sync(*this); + IceUtil::RecMutex::Lock sync(*this); - if(_state == StateDestroyed) - { - throw CommunicatorDestroyedException(__FILE__, __LINE__); - } + if(_state == StateDestroyed) + { + throw CommunicatorDestroyedException(__FILE__, __LINE__); + } - connectionFactory = _outgoingConnectionFactory; + connectionFactory = _outgoingConnectionFactory; #ifndef ICEE_PURE_CLIENT - adapterFactory = _objectAdapterFactory; + adapterFactory = _objectAdapterFactory; #endif } @@ -337,181 +337,181 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi { try { - __setNoDelete(true); - - IceUtil::StaticMutex::Lock sync(staticMutex); - instanceCount++; - - if(!oneOffDone) - { - // - // StdOut and StdErr redirection - // - - string stdOutFilename = _initData.properties->getProperty("Ice.StdOut"); - string stdErrFilename = _initData.properties->getProperty("Ice.StdErr"); - - if(stdOutFilename != "") - { - FILE * file; + __setNoDelete(true); + + IceUtil::StaticMutex::Lock sync(staticMutex); + instanceCount++; + + if(!oneOffDone) + { + // + // StdOut and StdErr redirection + // + + string stdOutFilename = _initData.properties->getProperty("Ice.StdOut"); + string stdErrFilename = _initData.properties->getProperty("Ice.StdErr"); + + if(stdOutFilename != "") + { + FILE * file; #ifdef _WIN32_WCE - wchar_t* wtext = new wchar_t[sizeof(wchar_t) * stdOutFilename.length()]; - mbstowcs(wtext, stdOutFilename.c_str(), stdOutFilename.length()); - file = _wfreopen(wtext, L"a", stdout); - delete wtext; + wchar_t* wtext = new wchar_t[sizeof(wchar_t) * stdOutFilename.length()]; + mbstowcs(wtext, stdOutFilename.c_str(), stdOutFilename.length()); + file = _wfreopen(wtext, L"a", stdout); + delete wtext; #else - file = freopen(stdOutFilename.c_str(), "a", stdout); -#endif - if(file == 0) - { - SyscallException ex(__FILE__, __LINE__); - ex.error = getSystemErrno(); - throw ex; - } - } - - if(stdErrFilename != "") - { - FILE* file; + file = freopen(stdOutFilename.c_str(), "a", stdout); +#endif + if(file == 0) + { + SyscallException ex(__FILE__, __LINE__); + ex.error = getSystemErrno(); + throw ex; + } + } + + if(stdErrFilename != "") + { + FILE* file; #ifdef _WIN32_WCE - wchar_t* wtext = new wchar_t[sizeof(wchar_t) * stdErrFilename.length()]; - mbstowcs(wtext, stdErrFilename.c_str(), stdErrFilename.length()); - file = _wfreopen(wtext, L"a", stderr); - delete wtext; + wchar_t* wtext = new wchar_t[sizeof(wchar_t) * stdErrFilename.length()]; + mbstowcs(wtext, stdErrFilename.c_str(), stdErrFilename.length()); + file = _wfreopen(wtext, L"a", stderr); + delete wtext; #else - file = freopen(stdErrFilename.c_str(), "a", stderr); -#endif - if(file == 0) - { - SyscallException ex(__FILE__, __LINE__); - ex.error = getSystemErrno(); - throw ex; - } - } - - unsigned int seed = static_cast<unsigned int>(IceUtil::Time::now().toMicroSeconds()); - srand(seed); + file = freopen(stdErrFilename.c_str(), "a", stderr); +#endif + if(file == 0) + { + SyscallException ex(__FILE__, __LINE__); + ex.error = getSystemErrno(); + throw ex; + } + } + + unsigned int seed = static_cast<unsigned int>(IceUtil::Time::now().toMicroSeconds()); + srand(seed); #ifndef _WIN32 - srand48(seed); -#endif - - if(_initData.properties->getPropertyAsInt("Ice.NullHandleAbort") > 0) - { - IceUtil::nullHandleAbort = true; - } - + srand48(seed); +#endif + + if(_initData.properties->getPropertyAsInt("Ice.NullHandleAbort") > 0) + { + IceUtil::nullHandleAbort = true; + } + #ifndef _WIN32 - string newUser = _initData.properties->getProperty("Ice.ChangeUser"); - if(!newUser.empty()) - { - struct passwd* pw = getpwnam(newUser.c_str()); - if(!pw) - { - SyscallException ex(__FILE__, __LINE__); - ex.error = getSystemErrno(); - throw ex; - } - - if(setgid(pw->pw_gid) == -1) - { - SyscallException ex(__FILE__, __LINE__); - ex.error = getSystemErrno(); - throw ex; - } - - if(setuid(pw->pw_uid) == -1) - { - SyscallException ex(__FILE__, __LINE__); - ex.error = getSystemErrno(); - throw ex; - } - } -#endif - oneOffDone = true; - } - - if(instanceCount == 1) - { - + string newUser = _initData.properties->getProperty("Ice.ChangeUser"); + if(!newUser.empty()) + { + struct passwd* pw = getpwnam(newUser.c_str()); + if(!pw) + { + SyscallException ex(__FILE__, __LINE__); + ex.error = getSystemErrno(); + throw ex; + } + + if(setgid(pw->pw_gid) == -1) + { + SyscallException ex(__FILE__, __LINE__); + ex.error = getSystemErrno(); + throw ex; + } + + if(setuid(pw->pw_uid) == -1) + { + SyscallException ex(__FILE__, __LINE__); + ex.error = getSystemErrno(); + throw ex; + } + } +#endif + oneOffDone = true; + } + + if(instanceCount == 1) + { + #ifdef _WIN32 - WORD version = MAKEWORD(1, 1); - WSADATA data; - if(WSAStartup(version, &data) != 0) - { - SocketException ex(__FILE__, __LINE__); - ex.error = WSAGetLastError(); - throw ex; - } -#endif - + WORD version = MAKEWORD(1, 1); + WSADATA data; + if(WSAStartup(version, &data) != 0) + { + SocketException ex(__FILE__, __LINE__); + ex.error = WSAGetLastError(); + throw ex; + } +#endif + #ifndef _WIN32 - struct sigaction action; - action.sa_handler = SIG_IGN; - sigemptyset(&action.sa_mask); - action.sa_flags = 0; - sigaction(SIGPIPE, &action, 0); -#endif - } - - sync.release(); - - - if(!_initData.logger) - { - _initData.logger = new LoggerI(_initData.properties->getProperty("Ice.ProgramName")); - } - - const_cast<TraceLevelsPtr&>(_traceLevels) = new TraceLevels(_initData.properties); - - const_cast<DefaultsAndOverridesPtr&>(_defaultsAndOverrides) = new DefaultsAndOverrides(_initData.properties); - - { - static const int defaultMessageSizeMax = 1024; - Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax); - if(num < 1) - { - const_cast<size_t&>(_messageSizeMax) = defaultMessageSizeMax * 1024; // Ignore non-sensical values. - } - else if(static_cast<size_t>(num) > (size_t)(0x7fffffff / 1024)) - { - const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(0x7fffffff); - } - else - { - // Property is in kilobytes, _messageSizeMax in bytes. - const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(num) * 1024; - } - } + struct sigaction action; + action.sa_handler = SIG_IGN; + sigemptyset(&action.sa_mask); + action.sa_flags = 0; + sigaction(SIGPIPE, &action, 0); +#endif + } + + sync.release(); + + + if(!_initData.logger) + { + _initData.logger = new LoggerI(_initData.properties->getProperty("Ice.ProgramName")); + } + + const_cast<TraceLevelsPtr&>(_traceLevels) = new TraceLevels(_initData.properties); + + const_cast<DefaultsAndOverridesPtr&>(_defaultsAndOverrides) = new DefaultsAndOverrides(_initData.properties); + + { + static const int defaultMessageSizeMax = 1024; + Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax); + if(num < 1) + { + const_cast<size_t&>(_messageSizeMax) = defaultMessageSizeMax * 1024; // Ignore non-sensical values. + } + else if(static_cast<size_t>(num) > (size_t)(0x7fffffff / 1024)) + { + const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(0x7fffffff); + } + else + { + // Property is in kilobytes, _messageSizeMax in bytes. + const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(num) * 1024; + } + } #ifndef ICEE_PURE_BLOCKING_CLIENT - { - Int stackSize = _initData.properties->getPropertyAsInt("Ice.ThreadPerConnection.StackSize"); - if(stackSize < 0) - { - stackSize = 0; - } - const_cast<size_t&>(_threadPerConnectionStackSize) = static_cast<size_t>(stackSize); - } + { + Int stackSize = _initData.properties->getPropertyAsInt("Ice.ThreadPerConnection.StackSize"); + if(stackSize < 0) + { + stackSize = 0; + } + const_cast<size_t&>(_threadPerConnectionStackSize) = static_cast<size_t>(stackSize); + } #endif #ifdef ICEE_HAS_ROUTER - _routerManager = new RouterManager; + _routerManager = new RouterManager; #endif #ifdef ICEE_HAS_LOCATOR - _locatorManager = new LocatorManager; + _locatorManager = new LocatorManager; #endif - _referenceFactory = new ReferenceFactory(this, communicator); + _referenceFactory = new ReferenceFactory(this, communicator); - _proxyFactory = new ProxyFactory(this); + _proxyFactory = new ProxyFactory(this); _endpointFactory = new EndpointFactory(this); - _outgoingConnectionFactory = new OutgoingConnectionFactory(this); + _outgoingConnectionFactory = new OutgoingConnectionFactory(this); #ifndef ICEE_PURE_CLIENT - _objectAdapterFactory = new ObjectAdapterFactory(this, communicator); + _objectAdapterFactory = new ObjectAdapterFactory(this, communicator); #endif #ifdef ICEE_HAS_WSTRING @@ -521,17 +521,17 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi } #endif - __setNoDelete(false); + __setNoDelete(false); } catch(...) { - { - IceUtil::StaticMutex::Lock sync(staticMutex); - --instanceCount; - } - destroy(); - __setNoDelete(false); - throw; + { + IceUtil::StaticMutex::Lock sync(staticMutex); + --instanceCount; + } + destroy(); + __setNoDelete(false); + throw; } } @@ -556,15 +556,15 @@ IceInternal::Instance::~Instance() if(--instanceCount == 0) { #ifdef _WIN32 - WSACleanup(); + WSACleanup(); #endif - + #ifndef _WIN32 - struct sigaction action; - action.sa_handler = SIG_DFL; - sigemptyset(&action.sa_mask); - action.sa_flags = 0; - sigaction(SIGPIPE, &action, 0); + struct sigaction action; + action.sa_handler = SIG_DFL; + sigemptyset(&action.sa_mask); + action.sa_flags = 0; + sigaction(SIGPIPE, &action, 0); #endif } } @@ -580,16 +580,16 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[]) #ifdef ICEE_HAS_ROUTER if(!_defaultsAndOverrides->defaultRouter.empty()) { - _referenceFactory->setDefaultRouter( - RouterPrx::uncheckedCast(_proxyFactory->stringToProxy(_defaultsAndOverrides->defaultRouter))); + _referenceFactory->setDefaultRouter( + RouterPrx::uncheckedCast(_proxyFactory->stringToProxy(_defaultsAndOverrides->defaultRouter))); } #endif #ifdef ICEE_HAS_LOCATOR if(!_defaultsAndOverrides->defaultLocator.empty()) { - _referenceFactory->setDefaultLocator( - LocatorPrx::uncheckedCast(_proxyFactory->stringToProxy(_defaultsAndOverrides->defaultLocator))); + _referenceFactory->setDefaultLocator( + LocatorPrx::uncheckedCast(_proxyFactory->stringToProxy(_defaultsAndOverrides->defaultLocator))); } #endif @@ -600,26 +600,26 @@ IceInternal::Instance::finishSetup(int& argc, char* argv[]) bool printProcessId = false; if(!printProcessIdDone && _initData.properties->getPropertyAsInt("Ice.PrintProcessId") > 0) { - // - // Safe double-check locking (no dependent variable!) - // - IceUtil::StaticMutex::Lock sync(staticMutex); - printProcessId = !printProcessIdDone; - - // - // We anticipate: we want to print it once, and we don't care when. - // - printProcessIdDone = true; + // + // Safe double-check locking (no dependent variable!) + // + IceUtil::StaticMutex::Lock sync(staticMutex); + printProcessId = !printProcessIdDone; + + // + // We anticipate: we want to print it once, and we don't care when. + // + printProcessIdDone = true; } if(printProcessId) { #ifdef _WIN32 - printf("%d\n", _getpid()); + printf("%d\n", _getpid()); #else - printf("%d\n", getpid()); + printf("%d\n", getpid()); #endif - fflush(stdout); + fflush(stdout); } #endif } @@ -628,30 +628,30 @@ void IceInternal::Instance::destroy() { { - IceUtil::RecMutex::Lock sync(*this); - - // - // If the _state is not StateActive then the instance is - // either being destroyed, or has already been destroyed. - // - if(_state != StateActive) - { - return; - } - - // - // We cannot set state to StateDestroyed otherwise instance - // methods called during the destroy process (such as - // outgoingConnectionFactory() from - // ObjectAdapterI::deactivate() will cause an exception. - // - _state = StateDestroyInProgress; + IceUtil::RecMutex::Lock sync(*this); + + // + // If the _state is not StateActive then the instance is + // either being destroyed, or has already been destroyed. + // + if(_state != StateActive) + { + return; + } + + // + // We cannot set state to StateDestroyed otherwise instance + // methods called during the destroy process (such as + // outgoingConnectionFactory() from + // ObjectAdapterI::deactivate() will cause an exception. + // + _state = StateDestroyInProgress; } #ifndef ICEE_PURE_CLIENT if(_objectAdapterFactory) { - _objectAdapterFactory->shutdown(); + _objectAdapterFactory->shutdown(); } if(_outgoingConnectionFactory) @@ -677,46 +677,46 @@ IceInternal::Instance::destroy() #endif { - IceUtil::RecMutex::Lock sync(*this); + IceUtil::RecMutex::Lock sync(*this); #ifndef ICEE_PURE_CLIENT - _objectAdapterFactory = 0; -#endif - _outgoingConnectionFactory = 0; - - if(_referenceFactory) - { - _referenceFactory->destroy(); - _referenceFactory = 0; - } - - // No destroy function defined. - // _proxyFactory->destroy(); - _proxyFactory = 0; - + _objectAdapterFactory = 0; +#endif + _outgoingConnectionFactory = 0; + + if(_referenceFactory) + { + _referenceFactory->destroy(); + _referenceFactory = 0; + } + + // No destroy function defined. + // _proxyFactory->destroy(); + _proxyFactory = 0; + #ifdef ICEE_HAS_ROUTER - if(_routerManager) - { - _routerManager->destroy(); - _routerManager = 0; - } + if(_routerManager) + { + _routerManager->destroy(); + _routerManager = 0; + } #endif #ifdef ICEE_HAS_LOCATOR - if(_locatorManager) - { - _locatorManager->destroy(); - _locatorManager = 0; - } + if(_locatorManager) + { + _locatorManager->destroy(); + _locatorManager = 0; + } #endif - if(_endpointFactory) - { - _endpointFactory->destroy(); - _endpointFactory = 0; - } + if(_endpointFactory) + { + _endpointFactory->destroy(); + _endpointFactory = 0; + } - _state = StateDestroyed; + _state = StateDestroyed; } } diff --git a/cppe/src/IceE/Instance.h b/cppe/src/IceE/Instance.h index 7c6c58efd20..9d844e0266a 100644 --- a/cppe/src/IceE/Instance.h +++ b/cppe/src/IceE/Instance.h @@ -78,9 +78,9 @@ private: enum State { - StateActive, - StateDestroyInProgress, - StateDestroyed + StateActive, + StateDestroyInProgress, + StateDestroyed }; State _state; Ice::InitializationData _initData; // Immutable, not reset by destroy(). diff --git a/cppe/src/IceE/LocalException.cpp b/cppe/src/IceE/LocalException.cpp index c785547149c..d35cf32c2a8 100644 --- a/cppe/src/IceE/LocalException.cpp +++ b/cppe/src/IceE/LocalException.cpp @@ -1502,13 +1502,13 @@ Ice::MemoryLimitException::ice_throw() const void Ice::throwMemoryLimitException(const char* file, int line) { - throw MemoryLimitException(file, line); + throw MemoryLimitException(file, line); } void Ice::throwUnmarshalOutOfBoundsException(const char* file, int line) { - throw MarshalException(file, line, "out of bounds during unmarshaling"); + throw MarshalException(file, line, "out of bounds during unmarshaling"); } void @@ -1644,8 +1644,8 @@ Ice::UnknownException::toString() const out += ":\nunknown exception"; if(!unknown.empty()) { - out += ":\n"; - out += unknown; + out += ":\n"; + out += unknown; } return out; } @@ -1657,8 +1657,8 @@ Ice::UnknownLocalException::toString() const out += ":\nunknown local exception"; if(!unknown.empty()) { - out += ":\n"; - out += unknown; + out += ":\n"; + out += unknown; } return out; } @@ -1670,8 +1670,8 @@ Ice::UnknownUserException::toString() const out += ":\nunknown user exception"; if(!unknown.empty()) { - out += ":\n"; - out += unknown; + out += ":\n"; + out += unknown; } return out; } @@ -1814,7 +1814,7 @@ Ice::SyscallException::toString() const if(error != 0) { out += ":\nsyscall exception: "; - out += errorToString(error); + out += errorToString(error); } return out; } @@ -1842,9 +1842,9 @@ Ice::FileException::toString() const { - out += "\npath: "; + out += "\npath: "; - out += path; + out += path; } @@ -1877,11 +1877,11 @@ Ice::ConnectionLostException::toString() const out += ":\nconnection lost: "; if(error == 0) { - out += "recv() returned zero"; + out += "recv() returned zero"; } else { - out += errorToString(error); + out += errorToString(error); } return out; } @@ -1928,11 +1928,11 @@ Ice::ProtocolException::toString() const out += ":\nprotocol error: "; if(!reason.empty()) { - out += reason; + out += reason; } else { - out += "unknown protocol exception"; + out += "unknown protocol exception"; } return out; } @@ -1973,8 +1973,8 @@ Ice::MarshalException::toString() const out += ":\nprotocol error: error during marshaling or unmarshaling"; if(!reason.empty()) { - out += ":\n"; - out += reason; + out += ":\n"; + out += reason; } return out; } diff --git a/cppe/src/IceE/LocatorInfo.cpp b/cppe/src/IceE/LocatorInfo.cpp index 7dc7f5aa836..5158cb5b510 100644 --- a/cppe/src/IceE/LocatorInfo.cpp +++ b/cppe/src/IceE/LocatorInfo.cpp @@ -53,7 +53,7 @@ IceInternal::LocatorManager::get(const LocatorPrx& loc) { if(!loc) { - return 0; + return 0; } LocatorPrx locator = LocatorPrx::uncheckedCast(loc->ice_locator(0)); // The locator can't be located. @@ -68,38 +68,38 @@ IceInternal::LocatorManager::get(const LocatorPrx& loc) if(_tableHint != _table.end()) { - if(_tableHint->first == locator) - { - p = _tableHint; - } + if(_tableHint->first == locator) + { + p = _tableHint; + } } if(p == _table.end()) { - p = _table.find(locator); + p = _table.find(locator); } if(p == _table.end()) { - // - // Rely on locator identity for the adapter table. We want to - // have only one table per locator (not one per locator - // proxy). - // - map<Identity, LocatorTablePtr>::iterator t = _locatorTables.find(locator->ice_getIdentity()); - if(t == _locatorTables.end()) - { - t = _locatorTables.insert(_locatorTables.begin(), - pair<const Identity, LocatorTablePtr>(locator->ice_getIdentity(), - new LocatorTable())); - } - - _tableHint = _table.insert(_tableHint, - pair<const LocatorPrx, LocatorInfoPtr>(locator, new LocatorInfo(locator, t->second))); + // + // Rely on locator identity for the adapter table. We want to + // have only one table per locator (not one per locator + // proxy). + // + map<Identity, LocatorTablePtr>::iterator t = _locatorTables.find(locator->ice_getIdentity()); + if(t == _locatorTables.end()) + { + t = _locatorTables.insert(_locatorTables.begin(), + pair<const Identity, LocatorTablePtr>(locator->ice_getIdentity(), + new LocatorTable())); + } + + _tableHint = _table.insert(_tableHint, + pair<const LocatorPrx, LocatorInfoPtr>(locator, new LocatorInfo(locator, t->second))); } else { - _tableHint = p; + _tableHint = p; } return _tableHint->second; @@ -112,10 +112,10 @@ IceInternal::LocatorTable::LocatorTable() void IceInternal::LocatorTable::clear() { - IceUtil::Mutex::Lock sync(*this); + IceUtil::Mutex::Lock sync(*this); - _adapterEndpointsMap.clear(); - _objectMap.clear(); + _adapterEndpointsMap.clear(); + _objectMap.clear(); } bool @@ -127,12 +127,12 @@ IceInternal::LocatorTable::getAdapterEndpoints(const string& adapter, vector<End if(p != _adapterEndpointsMap.end()) { - endpoints = p->second; - return true; + endpoints = p->second; + return true; } else { - return false; + return false; } } @@ -152,7 +152,7 @@ IceInternal::LocatorTable::removeAdapterEndpoints(const string& adapter) map<string, vector<EndpointPtr> >::iterator p = _adapterEndpointsMap.find(adapter); if(p == _adapterEndpointsMap.end()) { - return vector<EndpointPtr>(); + return vector<EndpointPtr>(); } vector<EndpointPtr> endpoints = p->second; @@ -171,12 +171,12 @@ IceInternal::LocatorTable::getProxy(const Identity& id, ObjectPrx& proxy) const if(p != _objectMap.end()) { - proxy = p->second; - return true; + proxy = p->second; + return true; } else { - return false; + return false; } } @@ -195,7 +195,7 @@ IceInternal::LocatorTable::removeProxy(const Identity& id) map<Identity, ObjectPrx>::iterator p = _objectMap.find(id); if(p == _objectMap.end()) { - return 0; + return 0; } ObjectPrx proxy = p->second; @@ -254,12 +254,12 @@ IceInternal::LocatorInfo::getLocatorRegistry() if(!_locatorRegistry) // Lazy initialization. { - _locatorRegistry = _locator->getRegistry(); + _locatorRegistry = _locator->getRegistry(); - // - // The locator registry can't be located. - // - _locatorRegistry = LocatorRegistryPrx::uncheckedCast(_locatorRegistry->ice_locator(0)); + // + // The locator registry can't be located. + // + _locatorRegistry = LocatorRegistryPrx::uncheckedCast(_locatorRegistry->ice_locator(0)); } return _locatorRegistry; @@ -274,11 +274,11 @@ IceInternal::LocatorInfo::getEndpoints(const IndirectReferencePtr& ref, bool& ca try { - if(!ref->getAdapterId().empty()) - { - if(!_table->getAdapterEndpoints(ref->getAdapterId(), endpoints)) - { - cached = false; + if(!ref->getAdapterId().empty()) + { + if(!_table->getAdapterEndpoints(ref->getAdapterId(), endpoints)) + { + cached = false; if(ref->getInstance()->traceLevels()->location >= 1) { @@ -287,20 +287,20 @@ IceInternal::LocatorInfo::getEndpoints(const IndirectReferencePtr& ref, bool& ca out << "searching for adapter by id" << "\n"; out << "adapter = " << ref->getAdapterId(); } - - object = _locator->findAdapterById(ref->getAdapterId()); - if(object) - { - endpoints = object->__reference()->getEndpoints(); - _table->addAdapterEndpoints(ref->getAdapterId(), endpoints); - } - } - } - else - { - bool objectCached = true; - if(!_table->getProxy(ref->getIdentity(), object)) - { + + object = _locator->findAdapterById(ref->getAdapterId()); + if(object) + { + endpoints = object->__reference()->getEndpoints(); + _table->addAdapterEndpoints(ref->getAdapterId(), endpoints); + } + } + } + else + { + bool objectCached = true; + if(!_table->getProxy(ref->getIdentity(), object)) + { if(ref->getInstance()->traceLevels()->location >= 1) { @@ -310,37 +310,37 @@ IceInternal::LocatorInfo::getEndpoints(const IndirectReferencePtr& ref, bool& ca out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()); } - objectCached = false; - object = _locator->findObjectById(ref->getIdentity()); - } - - bool endpointsCached = true; - if(object) - { - DirectReferencePtr odr = DirectReferencePtr::dynamicCast(object->__reference()); - if(odr) - { - endpointsCached = false; - endpoints = odr->getEndpoints(); - } - else - { - IndirectReferencePtr oir = IndirectReferencePtr::dynamicCast(object->__reference()); - assert(oir); - if(!oir->getAdapterId().empty()) - { - endpoints = getEndpoints(oir, endpointsCached); - } - } - } - - if(!objectCached && !endpoints.empty()) - { - _table->addProxy(ref->getIdentity(), object); - } - - cached = objectCached || endpointsCached; - } + objectCached = false; + object = _locator->findObjectById(ref->getIdentity()); + } + + bool endpointsCached = true; + if(object) + { + DirectReferencePtr odr = DirectReferencePtr::dynamicCast(object->__reference()); + if(odr) + { + endpointsCached = false; + endpoints = odr->getEndpoints(); + } + else + { + IndirectReferencePtr oir = IndirectReferencePtr::dynamicCast(object->__reference()); + assert(oir); + if(!oir->getAdapterId().empty()) + { + endpoints = getEndpoints(oir, endpointsCached); + } + } + } + + if(!objectCached && !endpoints.empty()) + { + _table->addProxy(ref->getIdentity(), object); + } + + cached = objectCached || endpointsCached; + } } catch(const AdapterNotFoundException&) { @@ -352,10 +352,10 @@ IceInternal::LocatorInfo::getEndpoints(const IndirectReferencePtr& ref, bool& ca out << "adapter = " << ref->getAdapterId(); } - NotRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "object adapter"; - ex.id = ref->getAdapterId(); - throw ex; + NotRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "object adapter"; + ex.id = ref->getAdapterId(); + throw ex; } catch(const ObjectNotFoundException&) { @@ -367,32 +367,32 @@ IceInternal::LocatorInfo::getEndpoints(const IndirectReferencePtr& ref, bool& ca out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()); } - NotRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "object"; - ex.id = ref->getInstance()->identityToString(ref->getIdentity()); - throw ex; + NotRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "object"; + ex.id = ref->getInstance()->identityToString(ref->getIdentity()); + throw ex; } catch(const NotRegisteredException&) { - throw; + throw; } catch(const LocalException& ex) { - if(ref->getInstance()->traceLevels()->location >= 1) - { - Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat); - out << "couldn't contact the locator to retrieve adapter endpoints\n"; - if(!ref) - { - out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()) << "\n"; - } - else - { - out << "adapter = " << ref->getAdapterId() << "\n"; - } - out << "reason = " << ex.toString(); - } - throw; + if(ref->getInstance()->traceLevels()->location >= 1) + { + Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat); + out << "couldn't contact the locator to retrieve adapter endpoints\n"; + if(!ref) + { + out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()) << "\n"; + } + else + { + out << "adapter = " << ref->getAdapterId() << "\n"; + } + out << "reason = " << ex.toString(); + } + throw; } if(ref->getInstance()->traceLevels()->location >= 1) @@ -433,25 +433,25 @@ IceInternal::LocatorInfo::clearObjectCache(const IndirectReferencePtr& ref) { if(ref->getAdapterId().empty()) { - ObjectPrx object = _table->removeProxy(ref->getIdentity()); - if(object) - { - IndirectReferencePtr oir = IndirectReferencePtr::dynamicCast(object->__reference()); - if(oir) - { - if(!oir->getAdapterId().empty()) - { - clearCache(oir); - } - } - else - { - if(ref->getInstance()->traceLevels()->location >= 2) - { - trace("removed endpoints from locator table", ref, object->__reference()->getEndpoints()); - } - } - } + ObjectPrx object = _table->removeProxy(ref->getIdentity()); + if(object) + { + IndirectReferencePtr oir = IndirectReferencePtr::dynamicCast(object->__reference()); + if(oir) + { + if(!oir->getAdapterId().empty()) + { + clearCache(oir); + } + } + else + { + if(ref->getInstance()->traceLevels()->location >= 2) + { + trace("removed endpoints from locator table", ref, object->__reference()->getEndpoints()); + } + } + } } } @@ -460,51 +460,51 @@ IceInternal::LocatorInfo::clearCache(const IndirectReferencePtr& ref) { if(!ref->getAdapterId().empty()) { - vector<EndpointPtr> endpoints = _table->removeAdapterEndpoints(ref->getAdapterId()); + vector<EndpointPtr> endpoints = _table->removeAdapterEndpoints(ref->getAdapterId()); - if(!endpoints.empty() && ref->getInstance()->traceLevels()->location >= 2) - { - trace("removed endpoints from locator table", ref, endpoints); - } + if(!endpoints.empty() && ref->getInstance()->traceLevels()->location >= 2) + { + trace("removed endpoints from locator table", ref, endpoints); + } } else { - ObjectPrx object = _table->removeProxy(ref->getIdentity()); - if(object) - { - IndirectReferencePtr oir = IndirectReferencePtr::dynamicCast(object->__reference()); - if(oir) - { - if(!oir->getAdapterId().empty()) - { - clearCache(oir); - } - } - else - { - if(ref->getInstance()->traceLevels()->location >= 2) - { - trace("removed endpoints from locator table", ref, object->__reference()->getEndpoints()); - } - } - } + ObjectPrx object = _table->removeProxy(ref->getIdentity()); + if(object) + { + IndirectReferencePtr oir = IndirectReferencePtr::dynamicCast(object->__reference()); + if(oir) + { + if(!oir->getAdapterId().empty()) + { + clearCache(oir); + } + } + else + { + if(ref->getInstance()->traceLevels()->location >= 2) + { + trace("removed endpoints from locator table", ref, object->__reference()->getEndpoints()); + } + } + } } } void IceInternal::LocatorInfo::trace(const string& msg, - const IndirectReferencePtr& ref, - const vector<EndpointPtr>& endpoints) + const IndirectReferencePtr& ref, + const vector<EndpointPtr>& endpoints) { Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat); out << msg << "\n"; if(!ref->getAdapterId().empty()) { - out << "adapter = " << ref->getAdapterId() << "\n"; + out << "adapter = " << ref->getAdapterId() << "\n"; } else { - out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()) << "\n"; + out << "object = " << ref->getInstance()->identityToString(ref->getIdentity()) << "\n"; } const char* sep = endpoints.size() > 1 ? ":" : ""; diff --git a/cppe/src/IceE/LoggerI.cpp b/cppe/src/IceE/LoggerI.cpp index f0ad2390f0d..ac09b256e03 100644 --- a/cppe/src/IceE/LoggerI.cpp +++ b/cppe/src/IceE/LoggerI.cpp @@ -20,7 +20,7 @@ Ice::LoggerI::LoggerI(const string& prefix) { if(!prefix.empty()) { - _prefix = prefix + ": "; + _prefix = prefix + ": "; } } @@ -45,8 +45,8 @@ Ice::LoggerI::trace(const string& category, const string& message) string::size_type idx = 0; while((idx = s.find("\n", idx)) != string::npos) { - s.insert(idx + 1, " "); - ++idx; + s.insert(idx + 1, " "); + ++idx; } IceUtil::StaticMutex::Lock sync(globalMutex); diff --git a/cppe/src/IceE/LoggerUtil.cpp b/cppe/src/IceE/LoggerUtil.cpp index 0f59e4374ad..2dabf999fce 100644 --- a/cppe/src/IceE/LoggerUtil.cpp +++ b/cppe/src/IceE/LoggerUtil.cpp @@ -29,7 +29,7 @@ Ice::Print::flush() { if(!_str.empty()) { - _logger->print(_str); + _logger->print(_str); } _str = "";; } @@ -55,7 +55,7 @@ Ice::Warning::flush() { if(!_str.empty()) { - _logger->warning(_str); + _logger->warning(_str); } _str = ""; } @@ -81,7 +81,7 @@ Ice::Error::flush() { if(!_str.empty()) { - _logger->error(_str); + _logger->error(_str); } _str = ""; } @@ -108,7 +108,7 @@ Ice::Trace::flush() { if(!_str.empty()) { - _logger->trace(_category, _str); + _logger->trace(_category, _str); } _str = ""; } diff --git a/cppe/src/IceE/Network.cpp b/cppe/src/IceE/Network.cpp index 10d022bce57..c06e9f99251 100644 --- a/cppe/src/IceE/Network.cpp +++ b/cppe/src/IceE/Network.cpp @@ -161,7 +161,7 @@ IceInternal::connectionLost() errno == ENOTCONN || errno == ESHUTDOWN || errno == ECONNABORTED || - errno == EPIPE; + errno == EPIPE; #endif } @@ -183,9 +183,9 @@ IceInternal::createSocket() fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); if(fd == INVALID_SOCKET) { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } setTcpNoDelay(fd); @@ -215,18 +215,18 @@ IceInternal::closeSocket(SOCKET fd) int error = WSAGetLastError(); if(closesocket(fd) == SOCKET_ERROR) { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } WSASetLastError(error); #else int error = errno; if(close(fd) == SOCKET_ERROR) { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } errno = error; #endif @@ -237,29 +237,29 @@ IceInternal::shutdownSocketWrite(SOCKET fd) { if(shutdown(fd, SHUT_WR) == SOCKET_ERROR) { - // - // Ignore errors indicating that we are shutdown already. - // + // + // Ignore errors indicating that we are shutdown already. + // #if defined(_WIN32) - int error = WSAGetLastError(); - if(error == WSAENOTCONN) - { - return; - } + int error = WSAGetLastError(); + if(error == WSAENOTCONN) + { + return; + } #elif defined(__APPLE__) - if(errno == ENOTCONN || errno == EINVAL) - { - return; - } + if(errno == ENOTCONN || errno == EINVAL) + { + return; + } #else - if(errno == ENOTCONN) - { - return; - } + if(errno == ENOTCONN) + { + return; + } #endif - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } } @@ -268,30 +268,30 @@ IceInternal::shutdownSocketReadWrite(SOCKET fd) { if(shutdown(fd, SHUT_RDWR) == SOCKET_ERROR) { - // - // Ignore errors indicating that we are shutdown already. - // + // + // Ignore errors indicating that we are shutdown already. + // #if defined(_WIN32) - int error = WSAGetLastError(); - if(error == WSAENOTCONN) - { - return; - } + int error = WSAGetLastError(); + if(error == WSAENOTCONN) + { + return; + } #elif defined(__APPLE__) - if(errno == ENOTCONN || errno == EINVAL) - { - return; - } + if(errno == ENOTCONN || errno == EINVAL) + { + return; + } #else - if(errno == ENOTCONN) - { - return; - } + if(errno == ENOTCONN) + { + return; + } #endif - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } } @@ -301,46 +301,46 @@ IceInternal::setBlock(SOCKET fd, bool block) if(block) { #ifdef _WIN32 - unsigned long arg = 0; - if(ioctlsocket(fd, FIONBIO, &arg) == SOCKET_ERROR) + unsigned long arg = 0; + if(ioctlsocket(fd, FIONBIO, &arg) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = WSAGetLastError(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = WSAGetLastError(); + throw ex; } #else - int flags = fcntl(fd, F_GETFL); - flags &= ~O_NONBLOCK; - if(fcntl(fd, F_SETFL, flags) == SOCKET_ERROR) + int flags = fcntl(fd, F_GETFL); + flags &= ~O_NONBLOCK; + if(fcntl(fd, F_SETFL, flags) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = errno; - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = errno; + throw ex; } #endif } else { #ifdef _WIN32 - unsigned long arg = 1; - if(ioctlsocket(fd, FIONBIO, &arg) == SOCKET_ERROR) + unsigned long arg = 1; + if(ioctlsocket(fd, FIONBIO, &arg) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = WSAGetLastError(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = WSAGetLastError(); + throw ex; } #else - int flags = fcntl(fd, F_GETFL); - flags |= O_NONBLOCK; - if(fcntl(fd, F_SETFL, flags) == SOCKET_ERROR) + int flags = fcntl(fd, F_GETFL); + flags |= O_NONBLOCK; + if(fcntl(fd, F_SETFL, flags) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = errno; - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = errno; + throw ex; } #endif } @@ -361,10 +361,10 @@ IceInternal::setTimeout(SOCKET fd, bool recv, int timeout) if(setsockopt(fd, SOL_SOCKET, recv ? SO_RCVTIMEO : SO_SNDTIMEO, (char*)&tt, (int)sizeof(int)) == SOCKET_ERROR) #endif { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } } #endif @@ -375,10 +375,10 @@ IceInternal::setTcpNoDelay(SOCKET fd) int flag = 1; if(setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, int(sizeof(int))) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } } @@ -388,10 +388,10 @@ IceInternal::setKeepAlive(SOCKET fd) int flag = 1; if(setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, int(sizeof(int))) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } } @@ -467,10 +467,10 @@ IceInternal::doBind(SOCKET fd, struct sockaddr_in& addr) { if(bind(fd, reinterpret_cast<struct sockaddr*>(&addr), int(sizeof(addr))) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } socklen_t len = static_cast<socklen_t>(sizeof(addr)); @@ -495,188 +495,188 @@ IceInternal::doConnect(SOCKET fd, struct sockaddr_in& addr, int timeout) WSAEVENT event = WSACreateEvent(); if(event == 0) { - closeSocketNoThrow(fd); + closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = WSAGetLastError(); - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = WSAGetLastError(); + throw ex; } if(WSAEventSelect(fd, event, FD_CONNECT) == SOCKET_ERROR) { - int error = WSAGetLastError(); + int error = WSAGetLastError(); - WSACloseEvent(event); - closeSocketNoThrow(fd); + WSACloseEvent(event); + closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = error; - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = error; + throw ex; } #endif repeatConnect: if(::connect(fd, reinterpret_cast<struct sockaddr*>(&addr), int(sizeof(addr))) == SOCKET_ERROR) { - if(interrupted()) - { - goto repeatConnect; - } - - if(connectInProgress()) - { - int val; + if(interrupted()) + { + goto repeatConnect; + } + + if(connectInProgress()) + { + int val; #ifdef _WIN32 - WSAEVENT events[1]; - events[0] = event; - long tout = (timeout >= 0) ? timeout : WSA_INFINITE; - DWORD rc = WSAWaitForMultipleEvents(1, events, FALSE, tout, FALSE); - if(rc == WSA_WAIT_FAILED) - { - int error = WSAGetLastError(); - - WSACloseEvent(event); - closeSocketNoThrow(fd); - - SocketException ex(__FILE__, __LINE__); - ex.error = error; - throw ex; - } - - if(rc == WSA_WAIT_TIMEOUT) - { - WSACloseEvent(event); - closeSocketNoThrow(fd); - - assert(timeout >= 0); - throw ConnectTimeoutException(__FILE__, __LINE__); - } - assert(rc == WSA_WAIT_EVENT_0); - - WSANETWORKEVENTS nevents; - if(WSAEnumNetworkEvents(fd, event, &nevents) == SOCKET_ERROR) - { - int error = WSAGetLastError(); - WSACloseEvent(event); - closeSocketNoThrow(fd); - - SocketException ex(__FILE__, __LINE__); - ex.error = error; - throw ex; - } - - // - // This is necessary to be able to set the socket in blocking mode. - // - if(WSAEventSelect(fd, event, 0) == SOCKET_ERROR) - { - int error = WSAGetLastError(); - - WSACloseEvent(event); - closeSocketNoThrow(fd); - - SocketException ex(__FILE__, __LINE__); - ex.error = error; - throw ex; - } - - // - // Now we close the event, because we're finished and - // this code be repeated. - // - WSACloseEvent(event); - - assert(nevents.lNetworkEvents & FD_CONNECT); - val = nevents.iErrorCode[FD_CONNECT_BIT]; + WSAEVENT events[1]; + events[0] = event; + long tout = (timeout >= 0) ? timeout : WSA_INFINITE; + DWORD rc = WSAWaitForMultipleEvents(1, events, FALSE, tout, FALSE); + if(rc == WSA_WAIT_FAILED) + { + int error = WSAGetLastError(); + + WSACloseEvent(event); + closeSocketNoThrow(fd); + + SocketException ex(__FILE__, __LINE__); + ex.error = error; + throw ex; + } + + if(rc == WSA_WAIT_TIMEOUT) + { + WSACloseEvent(event); + closeSocketNoThrow(fd); + + assert(timeout >= 0); + throw ConnectTimeoutException(__FILE__, __LINE__); + } + assert(rc == WSA_WAIT_EVENT_0); + + WSANETWORKEVENTS nevents; + if(WSAEnumNetworkEvents(fd, event, &nevents) == SOCKET_ERROR) + { + int error = WSAGetLastError(); + WSACloseEvent(event); + closeSocketNoThrow(fd); + + SocketException ex(__FILE__, __LINE__); + ex.error = error; + throw ex; + } + + // + // This is necessary to be able to set the socket in blocking mode. + // + if(WSAEventSelect(fd, event, 0) == SOCKET_ERROR) + { + int error = WSAGetLastError(); + + WSACloseEvent(event); + closeSocketNoThrow(fd); + + SocketException ex(__FILE__, __LINE__); + ex.error = error; + throw ex; + } + + // + // Now we close the event, because we're finished and + // this code be repeated. + // + WSACloseEvent(event); + + assert(nevents.lNetworkEvents & FD_CONNECT); + val = nevents.iErrorCode[FD_CONNECT_BIT]; #else repeatPoll: struct pollfd pollFd[1]; pollFd[0].fd = fd; pollFd[0].events = POLLOUT; int ret = ::poll(pollFd, 1, timeout); - if(ret == 0) - { - closeSocketNoThrow(fd); - throw ConnectTimeoutException(__FILE__, __LINE__); - } - else if(ret == SOCKET_ERROR) - { - if(interrupted()) - { - goto repeatPoll; - } - - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - + if(ret == 0) + { + closeSocketNoThrow(fd); + throw ConnectTimeoutException(__FILE__, __LINE__); + } + else if(ret == SOCKET_ERROR) + { + if(interrupted()) + { + goto repeatPoll; + } + + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + // // Strange windows bug: The following call to Sleep() is // necessary, otherwise no error is reported through // getsockopt. // //Sleep(0); - socklen_t len = static_cast<socklen_t>(sizeof(int)); - if(getsockopt(fd, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&val), &len) == SOCKET_ERROR) - { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } + socklen_t len = static_cast<socklen_t>(sizeof(int)); + if(getsockopt(fd, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&val), &len) == SOCKET_ERROR) + { + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } #endif - if(val > 0) - { - closeSocketNoThrow(fd); + if(val > 0) + { + closeSocketNoThrow(fd); #ifdef _WIN32 - WSASetLastError(val); + WSASetLastError(val); #else - errno = val; + errno = val; #endif - if(connectionRefused()) - { - ConnectionRefusedException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else if(connectFailed()) - { - ConnectFailedException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else - { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - } - - return; - } + if(connectionRefused()) + { + ConnectionRefusedException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else if(connectFailed()) + { + ConnectFailedException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else + { + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + } + + return; + } - closeSocketNoThrow(fd); - if(connectionRefused()) - { - ConnectionRefusedException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else if(connectFailed()) - { - ConnectFailedException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else - { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } + closeSocketNoThrow(fd); + if(connectionRefused()) + { + ConnectionRefusedException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else if(connectFailed()) + { + ConnectFailedException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else + { + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } } } @@ -692,59 +692,59 @@ IceInternal::getAddress(const string& host, int port, struct sockaddr_in& addr) { #ifdef _WIN32 - // - // Windows XP has getaddrinfo(), but we don't want to require XP to run IceE. - // - - // - // gethostbyname() is thread safe on Windows, with a separate hostent per thread - // - struct hostent* entry; - int retry = 5; - do - { - entry = gethostbyname(host.c_str()); - } - while(entry == 0 && WSAGetLastError() == WSATRY_AGAIN && --retry >= 0); - - if(entry == 0) - { - DNSException ex(__FILE__, __LINE__); - - ex.error = WSAGetLastError(); - ex.host = host; - throw ex; - } - memcpy(&addr.sin_addr, entry->h_addr, entry->h_length); + // + // Windows XP has getaddrinfo(), but we don't want to require XP to run IceE. + // + + // + // gethostbyname() is thread safe on Windows, with a separate hostent per thread + // + struct hostent* entry; + int retry = 5; + do + { + entry = gethostbyname(host.c_str()); + } + while(entry == 0 && WSAGetLastError() == WSATRY_AGAIN && --retry >= 0); + + if(entry == 0) + { + DNSException ex(__FILE__, __LINE__); + + ex.error = WSAGetLastError(); + ex.host = host; + throw ex; + } + memcpy(&addr.sin_addr, entry->h_addr, entry->h_length); #else - struct addrinfo* info = 0; - int retry = 5; - - struct addrinfo hints = { 0 }; - hints.ai_family = PF_INET; - - int rs = 0; - do - { - rs = getaddrinfo(host.c_str(), 0, &hints, &info); - } - while(info == 0 && rs == EAI_AGAIN && --retry >= 0); - - if(rs != 0) - { - DNSException ex(__FILE__, __LINE__); - ex.error = rs; - ex.host = host; - throw ex; - } - - assert(info->ai_family == PF_INET); - struct sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(info->ai_addr); - - addr.sin_addr.s_addr = sin->sin_addr.s_addr; - freeaddrinfo(info); + struct addrinfo* info = 0; + int retry = 5; + + struct addrinfo hints = { 0 }; + hints.ai_family = PF_INET; + + int rs = 0; + do + { + rs = getaddrinfo(host.c_str(), 0, &hints, &info); + } + while(info == 0 && rs == EAI_AGAIN && --retry >= 0); + + if(rs != 0) + { + DNSException ex(__FILE__, __LINE__); + ex.error = rs; + ex.host = host; + throw ex; + } + + assert(info->ai_family == PF_INET); + struct sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(info->ai_addr); + + addr.sin_addr.s_addr = sin->sin_addr.s_addr; + freeaddrinfo(info); #endif } @@ -765,24 +765,24 @@ IceInternal::errorToString(int error) #ifndef _WIN32_WCE if(error < WSABASEERR) { - LPVOID lpMsgBuf = 0; - DWORD ok = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, - error, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language - (LPTSTR)&lpMsgBuf, - 0, - NULL); - if(ok) - { - LPCTSTR msg = (LPCTSTR)lpMsgBuf; - assert(msg && strlen((const char*)msg) > 0); - string result = (const char*)msg; - LocalFree(lpMsgBuf); - return result; - } + LPVOID lpMsgBuf = 0; + DWORD ok = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + error, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR)&lpMsgBuf, + 0, + NULL); + if(ok) + { + LPCTSTR msg = (LPCTSTR)lpMsgBuf; + assert(msg && strlen((const char*)msg) > 0); + string result = (const char*)msg; + LocalFree(lpMsgBuf); + return result; + } } #endif @@ -826,17 +826,17 @@ IceInternal::fdToString(SOCKET fd) { if(fd == INVALID_SOCKET) { - return "<closed>"; + return "<closed>"; } socklen_t localLen = static_cast<socklen_t>(sizeof(struct sockaddr_in)); struct sockaddr_in localAddr; if(getsockname(fd, reinterpret_cast<struct sockaddr*>(&localAddr), &localLen) == SOCKET_ERROR) { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } bool peerNotConnected = false; @@ -844,17 +844,17 @@ IceInternal::fdToString(SOCKET fd) struct sockaddr_in remoteAddr; if(getpeername(fd, reinterpret_cast<struct sockaddr*>(&remoteAddr), &remoteLen) == SOCKET_ERROR) { - if(notConnected()) - { - peerNotConnected = true; - } - else - { - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } + if(notConnected()) + { + peerNotConnected = true; + } + else + { + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } } string s; @@ -862,12 +862,12 @@ IceInternal::fdToString(SOCKET fd) s += addrToString(localAddr); if(peerNotConnected) { - s += "\nremote address = <not connected>"; + s += "\nremote address = <not connected>"; } else { - s += "\nremote address = "; - s += addrToString(remoteAddr); + s += "\nremote address = "; + s += addrToString(remoteAddr); } return s; } @@ -889,7 +889,7 @@ IceInternal::acceptInterrupted() { if(interrupted()) { - return true; + return true; } #ifdef _WIN32 @@ -912,14 +912,14 @@ IceInternal::doAccept(SOCKET fd) repeatAccept: if((ret = ::accept(fd, 0, 0)) == INVALID_SOCKET) { - if(acceptInterrupted()) - { - goto repeatAccept; - } - - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + if(acceptInterrupted()) + { + goto repeatAccept; + } + + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } setTcpNoDelay(ret); @@ -933,15 +933,15 @@ IceInternal::doListen(SOCKET fd, int backlog) repeatListen: if(::listen(fd, backlog) == SOCKET_ERROR) { - if(interrupted()) - { - goto repeatListen; - } - - closeSocketNoThrow(fd); - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; + if(interrupted()) + { + goto repeatListen; + } + + closeSocketNoThrow(fd); + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; } } @@ -989,7 +989,7 @@ IceInternal::getLocalHosts() for (int i = 0; i < addrs->iAddressCount; ++i) { result.push_back( - inetAddrToString(reinterpret_cast<struct sockaddr_in*>(addrs->Address[i].lpSockaddr)->sin_addr)); + inetAddrToString(reinterpret_cast<struct sockaddr_in*>(addrs->Address[i].lpSockaddr)->sin_addr)); } // diff --git a/cppe/src/IceE/Object.cpp b/cppe/src/IceE/Object.cpp index df169ea057e..025db36ba10 100644 --- a/cppe/src/IceE/Object.cpp +++ b/cppe/src/IceE/Object.cpp @@ -126,31 +126,31 @@ DispatchStatus Ice::Object::__dispatch(Incoming& in, const Current& current) { pair<string*, string*> r = - equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation); + equal_range(__all, __all + sizeof(__all) / sizeof(string), current.operation); if(r.first == r.second) { - throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); - } + throw OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation); + } switch(r.first - __all) { case 0: { - return ___ice_id(in, current); + return ___ice_id(in, current); } case 1: { - return ___ice_ids(in, current); + return ___ice_ids(in, current); } case 2: - { - return ___ice_isA(in, current); - } - case 3: - { - return ___ice_ping(in, current); - } + { + return ___ice_isA(in, current); + } + case 3: + { + return ___ice_ping(in, current); + } } assert(false); @@ -163,13 +163,13 @@ operationModeToString(OperationMode mode) switch(mode) { case Normal: - return "::Ice::Normal"; + return "::Ice::Normal"; case Nonmutating: - return "::Ice::Nonmutating"; + return "::Ice::Nonmutating"; case Idempotent: - return "::Ice::Idempotent"; + return "::Ice::Idempotent"; } return "???"; @@ -182,22 +182,22 @@ Ice::Object::__invalidMode(OperationMode expected, OperationMode received) if(expected == Idempotent && received == Nonmutating) { - // - // Fine: typically an old client still using the deprecated nonmutating keyword - // - - // - // Note that expected == Nonmutating and received == Idempotent is not ok: - // the server may still use the deprecated nonmutating keyword to detect updates - // and the client should not break this (deprecated) feature. - // + // + // Fine: typically an old client still using the deprecated nonmutating keyword + // + + // + // Note that expected == Nonmutating and received == Idempotent is not ok: + // the server may still use the deprecated nonmutating keyword to detect updates + // and the client should not break this (deprecated) feature. + // } else { - Ice::MarshalException ex(__FILE__, __LINE__); - ex.reason = Ice::printfToString("unexpected operation mode. expected = %s received = %s", - operationModeToString(expected), operationModeToString(received)); - throw ex; + Ice::MarshalException ex(__FILE__, __LINE__); + ex.reason = Ice::printfToString("unexpected operation mode. expected = %s received = %s", + operationModeToString(expected), operationModeToString(received)); + throw ex; } } @@ -212,10 +212,10 @@ Ice::Blobject::__dispatch(Incoming& in, const Current& current) in.os()->writeBlob(outParams); if(ok) { - return DispatchOK; + return DispatchOK; } else { - return DispatchUserException; + return DispatchUserException; } } diff --git a/cppe/src/IceE/ObjectAdapter.cpp b/cppe/src/IceE/ObjectAdapter.cpp index 2148ecc74bb..a67f4b59a71 100644 --- a/cppe/src/IceE/ObjectAdapter.cpp +++ b/cppe/src/IceE/ObjectAdapter.cpp @@ -67,80 +67,80 @@ Ice::ObjectAdapter::activate() bool printAdapterReady = false; { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); - - checkForDeactivation(); - - // - // If the one off initializations of the adapter are already - // done, we just need to activate the incoming connection - // factories and we're done. - // - if(_activateOneOffDone) - { - for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), - Ice::voidMemFun(&IncomingConnectionFactory::activate)); - return; - } - - // - // One off initializations of the adapter: update the locator - // registry and print the "adapter ready" message. We set the - // _waitForActivate flag to prevent deactivation from other - // threads while these one off initializations are done. - // - _waitForActivate = true; + IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); + + checkForDeactivation(); + + // + // If the one off initializations of the adapter are already + // done, we just need to activate the incoming connection + // factories and we're done. + // + if(_activateOneOffDone) + { + for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), + Ice::voidMemFun(&IncomingConnectionFactory::activate)); + return; + } + + // + // One off initializations of the adapter: update the locator + // registry and print the "adapter ready" message. We set the + // _waitForActivate flag to prevent deactivation from other + // threads while these one off initializations are done. + // + _waitForActivate = true; #ifdef ICEE_HAS_LOCATOR - locatorInfo = _locatorInfo; + locatorInfo = _locatorInfo; #endif - printAdapterReady = _instance->initializationData().properties->getPropertyAsInt("Ice.PrintAdapterReady") > 0; + printAdapterReady = _instance->initializationData().properties->getPropertyAsInt("Ice.PrintAdapterReady") > 0; } #ifdef ICEE_HAS_LOCATOR try { - Ice::Identity dummy; - dummy.name = "dummy"; - updateLocatorRegistry(locatorInfo, createDirectProxy(dummy)); + Ice::Identity dummy; + dummy.name = "dummy"; + updateLocatorRegistry(locatorInfo, createDirectProxy(dummy)); } catch(const Ice::LocalException&) { - // - // If we couldn't update the locator registry, we let the - // exception go through and don't activate the adapter to - // allow to user code to retry activating the adapter - // later. - // - { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); - _waitForActivate = false; - notifyAll(); - } - throw; + // + // If we couldn't update the locator registry, we let the + // exception go through and don't activate the adapter to + // allow to user code to retry activating the adapter + // later. + // + { + IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); + _waitForActivate = false; + notifyAll(); + } + throw; } #endif if(printAdapterReady) { - printf("%s ready\n", _name.c_str()); - fflush(stdout); + printf("%s ready\n", _name.c_str()); + fflush(stdout); } { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); - assert(!_deactivated); // Not possible if _waitForActivate = true; + IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); + assert(!_deactivated); // Not possible if _waitForActivate = true; - // - // Signal threads waiting for the activation. - // - _waitForActivate = false; - notifyAll(); + // + // Signal threads waiting for the activation. + // + _waitForActivate = false; + notifyAll(); - _activateOneOffDone = true; + _activateOneOffDone = true; - for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), - Ice::voidMemFun(&IncomingConnectionFactory::activate)); + for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), + Ice::voidMemFun(&IncomingConnectionFactory::activate)); } } @@ -150,9 +150,9 @@ Ice::ObjectAdapter::hold() IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); checkForDeactivation(); - + for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), - Ice::voidMemFun(&IncomingConnectionFactory::hold)); + Ice::voidMemFun(&IncomingConnectionFactory::hold)); } void @@ -163,7 +163,7 @@ Ice::ObjectAdapter::waitForHold() checkForDeactivation(); for_each(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), - Ice::constVoidMemFun(&IncomingConnectionFactory::waitUntilHolding)); + Ice::constVoidMemFun(&IncomingConnectionFactory::waitUntilHolding)); } void @@ -176,25 +176,25 @@ Ice::ObjectAdapter::deactivate() #endif { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); - - // - // Ignore deactivation requests if the object adapter has already - // been deactivated. - // - if(_deactivated) - { - return; - } - - // - // Wait for activation to complete. This is necessary to not - // get out of order locator updates. - // - while(_waitForActivate) - { - wait(); - } + IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); + + // + // Ignore deactivation requests if the object adapter has already + // been deactivated. + // + if(_deactivated) + { + return; + } + + // + // Wait for activation to complete. This is necessary to not + // get out of order locator updates. + // + while(_waitForActivate) + { + wait(); + } #ifdef ICEE_HAS_ROUTER if(_routerInfo) @@ -212,27 +212,27 @@ Ice::ObjectAdapter::deactivate() #endif incomingConnectionFactories = _incomingConnectionFactories; - outgoingConnectionFactory = _instance->outgoingConnectionFactory(); + outgoingConnectionFactory = _instance->outgoingConnectionFactory(); #ifdef ICEE_HAS_LOCATOR - locatorInfo = _locatorInfo; + locatorInfo = _locatorInfo; #endif - _deactivated = true; - - notifyAll(); + _deactivated = true; + + notifyAll(); } #ifdef ICEE_HAS_LOCATOR try { - updateLocatorRegistry(locatorInfo, 0); + updateLocatorRegistry(locatorInfo, 0); } catch(const Ice::LocalException&) { - // - // We can't throw exceptions in deactivate so we ignore - // failures to update the locator registry. - // + // + // We can't throw exceptions in deactivate so we ignore + // failures to update the locator registry. + // } #endif @@ -242,7 +242,7 @@ Ice::ObjectAdapter::deactivate() // message. // for_each(incomingConnectionFactories.begin(), incomingConnectionFactories.end(), - Ice::voidMemFun(&IncomingConnectionFactory::destroy)); + Ice::voidMemFun(&IncomingConnectionFactory::destroy)); // // Must be called outside the thread synchronization, because @@ -523,8 +523,8 @@ Ice::ObjectAdapter::createReverseProxy(const Identity& ident) const vector<IncomingConnectionFactoryPtr>::const_iterator p; for(p = _incomingConnectionFactories.begin(); p != _incomingConnectionFactories.end(); ++p) { - list<ConnectionPtr> cons = (*p)->connections(); - copy(cons.begin(), cons.end(), back_inserter(connections)); + list<ConnectionPtr> cons = (*p)->connections(); + copy(cons.begin(), cons.end(), back_inserter(connections)); } // @@ -533,7 +533,7 @@ Ice::ObjectAdapter::createReverseProxy(const Identity& ident) const // vector<EndpointPtr> endpoints; ReferencePtr ref = _instance->referenceFactory()->create(ident, Ice::Context(), "", ReferenceModeTwoway, - connections); + connections); return _instance->proxyFactory()->referenceToProxy(ref); } @@ -554,8 +554,8 @@ Ice::ObjectAdapter::flushBatchRequests() { vector<IncomingConnectionFactoryPtr> f; { - IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); - f = _incomingConnectionFactories; + IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this); + f = _incomingConnectionFactories; } for_each(f.begin(), f.end(), Ice::voidMemFun(&IncomingConnectionFactory::flushBatchRequests)); } @@ -583,7 +583,7 @@ Ice::ObjectAdapter::decDirectCount() assert(_directCount > 0); if(--_directCount == 0) { - notifyAll(); + notifyAll(); } } @@ -597,12 +597,12 @@ Ice::ObjectAdapter::getServantManager() const } Ice::ObjectAdapter::ObjectAdapter(const InstancePtr& instance, const CommunicatorPtr& communicator, - const ObjectAdapterFactoryPtr& objectAdapterFactory, - const string& name, const string& endpointInfo + const ObjectAdapterFactoryPtr& objectAdapterFactory, + const string& name, const string& endpointInfo #ifdef ICEE_HAS_ROUTER - , const RouterPrx& router + , const RouterPrx& router #endif - ) : + ) : _deactivated(false), _instance(instance), _communicator(communicator), @@ -670,36 +670,36 @@ Ice::ObjectAdapter::ObjectAdapter(const InstancePtr& instance, const Communicato // _instance->outgoingConnectionFactory()->setRouterInfo(_routerInfo); } - } - else + } + else #endif - { - // - // Parse the endpoints, but don't store them in the adapter. - // The connection factory might change it, for example, to - // fill in the real port number. - // - vector<EndpointPtr> endpoints = parseEndpoints(endpointInfo); - for(vector<EndpointPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p) - { - _incomingConnectionFactories.push_back(new IncomingConnectionFactory(_instance, *p, this)); - } - if(endpoints.empty()) - { - TraceLevelsPtr tl = _instance->traceLevels(); - if(tl->network >= 2) - { - Trace out(_instance->initializationData().logger, tl->networkCat); - out << "created adapter `" << name << "' without endpoints"; - } - } - - // - // Parse published endpoints. These are used in proxies - // instead of the connection factory endpoints. - // - string endpts = _instance->initializationData().properties->getProperty(name + ".PublishedEndpoints"); - _publishedEndpoints = parseEndpoints(endpts); + { + // + // Parse the endpoints, but don't store them in the adapter. + // The connection factory might change it, for example, to + // fill in the real port number. + // + vector<EndpointPtr> endpoints = parseEndpoints(endpointInfo); + for(vector<EndpointPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p) + { + _incomingConnectionFactories.push_back(new IncomingConnectionFactory(_instance, *p, this)); + } + if(endpoints.empty()) + { + TraceLevelsPtr tl = _instance->traceLevels(); + if(tl->network >= 2) + { + Trace out(_instance->initializationData().logger, tl->networkCat); + out << "created adapter `" << name << "' without endpoints"; + } + } + + // + // Parse published endpoints. These are used in proxies + // instead of the connection factory endpoints. + // + string endpts = _instance->initializationData().properties->getProperty(name + ".PublishedEndpoints"); + _publishedEndpoints = parseEndpoints(endpts); if(_publishedEndpoints.empty()) { transform(_incomingConnectionFactories.begin(), _incomingConnectionFactories.end(), @@ -711,26 +711,26 @@ Ice::ObjectAdapter::ObjectAdapter(const InstancePtr& instance, const Communicato // _publishedEndpoints.erase(remove_if(_publishedEndpoints.begin(), _publishedEndpoints.end(), not1(Ice::constMemFun(&Endpoint::publish))), _publishedEndpoints.end()); - } + } #ifdef ICEE_HAS_LOCATOR - string locator = _instance->initializationData().properties->getProperty(_name + ".Locator"); - if(!locator.empty()) - { - setLocator(LocatorPrx::uncheckedCast(_instance->proxyFactory()->stringToProxy(locator))); - } - else - { - setLocator(_instance->referenceFactory()->getDefaultLocator()); - } + string locator = _instance->initializationData().properties->getProperty(_name + ".Locator"); + if(!locator.empty()) + { + setLocator(LocatorPrx::uncheckedCast(_instance->proxyFactory()->stringToProxy(locator))); + } + else + { + setLocator(_instance->referenceFactory()->getDefaultLocator()); + } #endif } catch(...) { - deactivate(); - waitForDeactivate(); - __setNoDelete(false); - throw; + deactivate(); + waitForDeactivate(); + __setNoDelete(false); + throw; } __setNoDelete(false); } @@ -739,21 +739,21 @@ Ice::ObjectAdapter::~ObjectAdapter() { if(!_deactivated) { - Warning out(_instance->initializationData().logger); - out << "object adapter `" << _name << "' has not been deactivated"; + Warning out(_instance->initializationData().logger); + out << "object adapter `" << _name << "' has not been deactivated"; } else if(!_destroyed) { - Warning out(_instance->initializationData().logger); - out << "object adapter `" << _name << "' has not been destroyed"; + Warning out(_instance->initializationData().logger); + out << "object adapter `" << _name << "' has not been destroyed"; } else { - //assert(!_servantManager); // We don't clear this reference, it needs to be immutable. - assert(!_communicator); - assert(_incomingConnectionFactories.empty()); - assert(_directCount == 0); - assert(!_waitForActivate); + //assert(!_servantManager); // We don't clear this reference, it needs to be immutable. + assert(!_communicator); + assert(_incomingConnectionFactories.empty()); + assert(_directCount == 0); + assert(!_waitForActivate); } } @@ -764,16 +764,16 @@ Ice::ObjectAdapter::newProxy(const Identity& ident, const string& facet) const if(_id.empty()) { #endif - return newDirectProxy(ident, facet); + return newDirectProxy(ident, facet); #ifdef ICEE_HAS_LOCATOR } else if(_replicaGroupId.empty()) { - return newIndirectProxy(ident, facet, _id); + return newIndirectProxy(ident, facet, _id); } else { - return newIndirectProxy(ident, facet, _replicaGroupId); + return newIndirectProxy(ident, facet, _replicaGroupId); } #endif } @@ -797,10 +797,10 @@ Ice::ObjectAdapter::newDirectProxy(const Identity& ident, const string& facet) c // #ifdef ICEE_HAS_ROUTER ReferencePtr ref = _instance->referenceFactory()->create(ident, Ice::Context(), facet, ReferenceModeTwoway, - false, endpoints, 0); + false, endpoints, 0); #else ReferencePtr ref = _instance->referenceFactory()->create(ident, Ice::Context(), facet, ReferenceModeTwoway, - false, endpoints); + false, endpoints); #endif return _instance->proxyFactory()->referenceToProxy(ref); @@ -816,11 +816,11 @@ Ice::ObjectAdapter::newIndirectProxy(const Identity& ident, const string& facet, #ifdef ICEE_HAS_ROUTER ReferencePtr ref = _instance->referenceFactory()->create(ident, Ice::Context(), facet, ReferenceModeTwoway, false, id, 0, - _locatorInfo); + _locatorInfo); #else ReferencePtr ref = _instance->referenceFactory()->create(ident, Ice::Context(), facet, ReferenceModeTwoway, false, id, - _locatorInfo); + _locatorInfo); #endif // @@ -835,9 +835,9 @@ Ice::ObjectAdapter::checkForDeactivation() const { if(_deactivated) { - ObjectAdapterDeactivatedException ex(__FILE__, __LINE__); - ex.name = _name; - throw ex; + ObjectAdapterDeactivatedException ex(__FILE__, __LINE__); + ex.name = _name; + throw ex; } } @@ -864,38 +864,38 @@ Ice::ObjectAdapter::parseEndpoints(const string& str) const vector<EndpointPtr> endpoints; while(end < endpts.length()) { - const string delim = " \t\n\r"; - - beg = endpts.find_first_not_of(delim, end); - if(beg == string::npos) - { - break; - } - - end = endpts.find(':', beg); - if(end == string::npos) - { - end = endpts.length(); - } - - if(end == beg) - { - ++end; - continue; - } - - string s = endpts.substr(beg, end - beg); - EndpointPtr endp = _instance->endpointFactory()->create(s); - if(endp == 0) - { - EndpointParseException ex(__FILE__, __LINE__); - ex.str = s; - throw ex; - } + const string delim = " \t\n\r"; + + beg = endpts.find_first_not_of(delim, end); + if(beg == string::npos) + { + break; + } + + end = endpts.find(':', beg); + if(end == string::npos) + { + end = endpts.length(); + } + + if(end == beg) + { + ++end; + continue; + } + + string s = endpts.substr(beg, end - beg); + EndpointPtr endp = _instance->endpointFactory()->create(s); + if(endp == 0) + { + EndpointParseException ex(__FILE__, __LINE__); + ex.str = s; + throw ex; + } vector<EndpointPtr> endps = endp->expand(true); endpoints.insert(endpoints.end(), endps.begin(), endps.end()); - ++end; + ++end; } return endpoints; @@ -907,7 +907,7 @@ ObjectAdapter::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locatorI { if(_id.empty()) { - return; // Nothing to update. + return; // Nothing to update. } // @@ -924,42 +924,42 @@ ObjectAdapter::updateLocatorRegistry(const IceInternal::LocatorInfoPtr& locatorI LocatorRegistryPrx locatorRegistry = locatorInfo ? locatorInfo->getLocatorRegistry() : LocatorRegistryPrx(); if(!locatorRegistry) { - return; + return; } if(!_id.empty()) { - try - { - if(_replicaGroupId.empty()) - { - locatorRegistry->setAdapterDirectProxy(_id, proxy); - } - else - { - locatorRegistry->setReplicatedAdapterDirectProxy(_id, _replicaGroupId, proxy); - } - } - catch(const AdapterNotFoundException&) - { - NotRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "object adapter"; - ex.id = _id; - throw ex; - } - catch(const InvalidReplicaGroupIdException&) - { - NotRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "replica group"; - ex.id = _replicaGroupId; - throw ex; - } - catch(const AdapterAlreadyActiveException&) - { - ObjectAdapterIdInUseException ex(__FILE__, __LINE__); - ex.id = _id; - throw ex; - } + try + { + if(_replicaGroupId.empty()) + { + locatorRegistry->setAdapterDirectProxy(_id, proxy); + } + else + { + locatorRegistry->setReplicatedAdapterDirectProxy(_id, _replicaGroupId, proxy); + } + } + catch(const AdapterNotFoundException&) + { + NotRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "object adapter"; + ex.id = _id; + throw ex; + } + catch(const InvalidReplicaGroupIdException&) + { + NotRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "replica group"; + ex.id = _replicaGroupId; + throw ex; + } + catch(const AdapterAlreadyActiveException&) + { + ObjectAdapterIdInUseException ex(__FILE__, __LINE__); + ex.id = _id; + throw ex; + } } } #endif diff --git a/cppe/src/IceE/ObjectAdapterFactory.cpp b/cppe/src/IceE/ObjectAdapterFactory.cpp index b2a23adbfeb..e53feb3be0c 100644 --- a/cppe/src/IceE/ObjectAdapterFactory.cpp +++ b/cppe/src/IceE/ObjectAdapterFactory.cpp @@ -24,23 +24,23 @@ IceInternal::ObjectAdapterFactory::shutdown() map<string, ObjectAdapterPtr> adapters; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // Ignore shutdown requests if the object adapter factory has - // already been shut down. - // - if(!_instance) - { - return; - } - - adapters = _adapters; - - _instance = 0; - _communicator = 0; - - notifyAll(); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // Ignore shutdown requests if the object adapter factory has + // already been shut down. + // + if(!_instance) + { + return; + } + + adapters = _adapters; + + _instance = 0; + _communicator = 0; + + notifyAll(); } // @@ -48,10 +48,10 @@ IceInternal::ObjectAdapterFactory::shutdown() // deadlocks. // //for_each(adapters.begin(), adapters.end(), - //Ice::secondVoidMemFun<const string, ObjectAdapter>(&ObjectAdapter::deactivate)); + //Ice::secondVoidMemFun<const string, ObjectAdapter>(&ObjectAdapter::deactivate)); for(map<string, ObjectAdapterPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p) { - p->second->deactivate(); + p->second->deactivate(); } } @@ -60,25 +60,25 @@ void IceInternal::ObjectAdapterFactory::waitForShutdown() { { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // First we wait for the shutdown of the factory itself. - // - while(_instance) - { - wait(); - } - - // - // If some other thread is currently shutting down, we wait - // until this thread is finished. - // - while(_waitForShutdown) - { - wait(); - } - _waitForShutdown = true; + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // First we wait for the shutdown of the factory itself. + // + while(_instance) + { + wait(); + } + + // + // If some other thread is currently shutting down, we wait + // until this thread is finished. + // + while(_waitForShutdown) + { + wait(); + } + _waitForShutdown = true; } // @@ -86,17 +86,17 @@ IceInternal::ObjectAdapterFactory::waitForShutdown() // for(map<string, ObjectAdapterPtr>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) { - p->second->waitForDeactivate(); + p->second->waitForDeactivate(); } { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - // - // Signal that waiting is complete. - // - _waitForShutdown = false; - notifyAll(); + // + // Signal that waiting is complete. + // + _waitForShutdown = false; + notifyAll(); } } @@ -130,35 +130,35 @@ IceInternal::ObjectAdapterFactory::destroy() // for(map<string, ObjectAdapterPtr>::const_iterator p = adapters.begin(); p != adapters.end(); ++p) { - p->second->destroy(); + p->second->destroy(); } } ObjectAdapterPtr IceInternal::ObjectAdapterFactory::createObjectAdapter(const string& name, const string& endpoints #ifdef ICEE_HAS_ROUTER - , const RouterPrx& router + , const RouterPrx& router #endif - ) + ) { IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); if(!_instance) { - throw ObjectAdapterDeactivatedException(__FILE__, __LINE__); + throw ObjectAdapterDeactivatedException(__FILE__, __LINE__); } map<string, ObjectAdapterPtr>::iterator p = _adapters.find(name); if(p != _adapters.end()) { - throw AlreadyRegisteredException(__FILE__, __LINE__, "object adapter", name); + throw AlreadyRegisteredException(__FILE__, __LINE__, "object adapter", name); } ObjectAdapterPtr adapter = new ObjectAdapter(_instance, _communicator, this, name, endpoints #ifdef ICEE_HAS_ROUTER - , router + , router #endif - ); + ); _adapters.insert(make_pair(name, adapter)); return adapter; } @@ -182,7 +182,7 @@ struct FlushAdapter { void operator() (ObjectAdapterPtr p) { - p->flushBatchRequests(); + p->flushBatchRequests(); } }; @@ -193,18 +193,18 @@ IceInternal::ObjectAdapterFactory::flushBatchRequests() const { list<ObjectAdapterPtr> a; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - for(map<string, ObjectAdapterPtr>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) - { - a.push_back(p->second); - } + for(map<string, ObjectAdapterPtr>::const_iterator p = _adapters.begin(); p != _adapters.end(); ++p) + { + a.push_back(p->second); + } } for_each(a.begin(), a.end(), FlushAdapter()); } IceInternal::ObjectAdapterFactory::ObjectAdapterFactory(const InstancePtr& instance, - const CommunicatorPtr& communicator) : + const CommunicatorPtr& communicator) : _instance(instance), _communicator(communicator), _waitForShutdown(false) diff --git a/cppe/src/IceE/ObjectAdapterFactory.h b/cppe/src/IceE/ObjectAdapterFactory.h index 8bf700c5d84..5bf7be7bc6b 100644 --- a/cppe/src/IceE/ObjectAdapterFactory.h +++ b/cppe/src/IceE/ObjectAdapterFactory.h @@ -36,9 +36,9 @@ public: ::Ice::ObjectAdapterPtr createObjectAdapter(const std::string&, const std::string& #ifdef ICEE_HAS_ROUTER - , const ::Ice::RouterPrx& + , const ::Ice::RouterPrx& #endif - ); + ); void removeObjectAdapter(const std::string&); void flushBatchRequests() const; diff --git a/cppe/src/IceE/Outgoing.cpp b/cppe/src/IceE/Outgoing.cpp index 2bf572dfab2..19b7d9a07ee 100644 --- a/cppe/src/IceE/Outgoing.cpp +++ b/cppe/src/IceE/Outgoing.cpp @@ -45,7 +45,7 @@ IceInternal::LocalExceptionWrapper::retry() const } IceInternal::Outgoing::Outgoing(Connection* connection, Reference* ref, const string& operation, - OperationMode mode, const Context* context) : + OperationMode mode, const Context* context) : _connection(connection), _reference(ref), _state(StateUnsent), @@ -58,26 +58,26 @@ IceInternal::Outgoing::Outgoing(Connection* connection, Reference* ref, const st { switch(_reference->getMode()) { - case ReferenceModeTwoway: - case ReferenceModeOneway: - { - _stream.writeBlob(requestHdr, sizeof(requestHdr)); - break; - } + case ReferenceModeTwoway: + case ReferenceModeOneway: + { + _stream.writeBlob(requestHdr, sizeof(requestHdr)); + break; + } - case ReferenceModeBatchOneway: + case ReferenceModeBatchOneway: #ifdef ICEE_HAS_BATCH - { - _connection->prepareBatchRequest(&_stream); - break; - } + { + _connection->prepareBatchRequest(&_stream); + break; + } #endif - case ReferenceModeDatagram: - case ReferenceModeBatchDatagram: - { - assert(false); - break; - } + case ReferenceModeDatagram: + case ReferenceModeBatchDatagram: + { + assert(false); + break; + } } // _reference->getIdentity().__write(&_stream); @@ -91,12 +91,12 @@ IceInternal::Outgoing::Outgoing(Connection* connection, Reference* ref, const st // if(_reference->getFacet().empty()) { - _stream.writeSize(0); + _stream.writeSize(0); } else { - _stream.writeSize(1); - _stream.write(_reference->getFacet()); + _stream.writeSize(1); + _stream.write(_reference->getFacet()); } _stream.write(operation, false); @@ -112,8 +112,8 @@ IceInternal::Outgoing::Outgoing(Connection* connection, Reference* ref, const st Context::const_iterator p; for(p = context->begin(); p != context->end(); ++p) { - _stream.write(p->first); - _stream.write(p->second); + _stream.write(p->first); + _stream.write(p->second); } // @@ -134,86 +134,86 @@ IceInternal::Outgoing::invoke() switch(_reference->getMode()) { - case ReferenceModeTwoway: - { - // - // We let all exceptions raised by sending directly - // propagate to the caller, because they can be retried - // without violating "at-most-once". In case of such - // exceptions, the connection object does not call back on - // this object, so we don't need to lock the mutex, keep - // track of state, or save exceptions. - // - _connection->sendRequest(&_stream, this); + case ReferenceModeTwoway: + { + // + // We let all exceptions raised by sending directly + // propagate to the caller, because they can be retried + // without violating "at-most-once". In case of such + // exceptions, the connection object does not call back on + // this object, so we don't need to lock the mutex, keep + // track of state, or save exceptions. + // + _connection->sendRequest(&_stream, this); - if(_exception.get()) - { - // - // A CloseConnectionException indicates graceful - // server shutdown, and is therefore always repeatable - // without violating "at-most-once". That's because by - // sending a close connection message, the server - // guarantees that all outstanding requests can safely - // be repeated. - // - // An ObjectNotExistException can always be retried as - // well without violating "at-most-once". - // - if(dynamic_cast<CloseConnectionException*>(_exception.get()) || - dynamic_cast<ObjectNotExistException*>(_exception.get())) - { - _exception->ice_throw(); - } - - // - // Throw the exception wrapped in a LocalExceptionWrapper, to - // indicate that the request cannot be resent without - // potentially violating the "at-most-once" principle. - // - throw LocalExceptionWrapper(*_exception.get(), false); - } - - if(_state == StateUserException) - { - return false; - } + if(_exception.get()) + { + // + // A CloseConnectionException indicates graceful + // server shutdown, and is therefore always repeatable + // without violating "at-most-once". That's because by + // sending a close connection message, the server + // guarantees that all outstanding requests can safely + // be repeated. + // + // An ObjectNotExistException can always be retried as + // well without violating "at-most-once". + // + if(dynamic_cast<CloseConnectionException*>(_exception.get()) || + dynamic_cast<ObjectNotExistException*>(_exception.get())) + { + _exception->ice_throw(); + } + + // + // Throw the exception wrapped in a LocalExceptionWrapper, to + // indicate that the request cannot be resent without + // potentially violating the "at-most-once" principle. + // + throw LocalExceptionWrapper(*_exception.get(), false); + } + + if(_state == StateUserException) + { + return false; + } - assert(_state == StateOK); - break; - } - - case ReferenceModeOneway: - { - // - // For oneway requests, the connection object - // never calls back on this object. Therefore we don't - // need to lock the mutex or save exceptions. We simply - // let all exceptions from sending propagate to the - // caller, because such exceptions can be retried without - // violating "at-most-once". - // - _connection->sendRequest(&_stream, 0); - break; - } + assert(_state == StateOK); + break; + } + + case ReferenceModeOneway: + { + // + // For oneway requests, the connection object + // never calls back on this object. Therefore we don't + // need to lock the mutex or save exceptions. We simply + // let all exceptions from sending propagate to the + // caller, because such exceptions can be retried without + // violating "at-most-once". + // + _connection->sendRequest(&_stream, 0); + break; + } - case ReferenceModeBatchOneway: + case ReferenceModeBatchOneway: #ifdef ICEE_HAS_BATCH - { - // - // For batch oneways, the same rules as for - // regular oneways (see comment above) - // apply. - // - _connection->finishBatchRequest(&_stream); - break; - } + { + // + // For batch oneways, the same rules as for + // regular oneways (see comment above) + // apply. + // + _connection->finishBatchRequest(&_stream); + break; + } #endif - case ReferenceModeDatagram: - case ReferenceModeBatchDatagram: - { - assert(false); - return false; - } + case ReferenceModeDatagram: + case ReferenceModeBatchDatagram: + { + assert(false); + return false; + } } return true; @@ -232,14 +232,14 @@ IceInternal::Outgoing::abort(const LocalException& ex) #ifdef ICEE_HAS_BATCH if(_reference->getMode() == ReferenceModeBatchOneway) { - _connection->abortBatchRequest(); - - // - // If we abort a batch requests, we cannot retry, because not - // only the batch request that caused the problem will be - // aborted, but all other requests in the batch as well. - // - throw LocalExceptionWrapper(ex, false); + _connection->abortBatchRequest(); + + // + // If we abort a batch requests, we cannot retry, because not + // only the batch request that caused the problem will be + // aborted, but all other requests in the batch as well. + // + throw LocalExceptionWrapper(ex, false); } #endif @@ -257,7 +257,7 @@ IceInternal::Outgoing::finished(BasicStream& is) // if(&is != &_stream) { - _stream.swap(is); + _stream.swap(is); } Byte replyStatus; @@ -265,153 +265,153 @@ IceInternal::Outgoing::finished(BasicStream& is) switch(replyStatus) { - case replyOK: - { - // - // Input and output parameters are always sent in an - // encapsulation, which makes it possible to forward - // oneway requests as blobs. - // - _stream.startReadEncaps(); - _state = StateOK; // The state must be set last, in case there is an exception. - break; - } - - case replyUserException: - { - // - // Input and output parameters are always sent in an - // encapsulation, which makes it possible to forward - // oneway requests as blobs. - // - _stream.startReadEncaps(); - _state = StateUserException; // The state must be set last, in case there is an exception. - break; - } - - case replyObjectNotExist: - case replyFacetNotExist: - case replyOperationNotExist: - { - // - // Don't read the exception members directly into the - // exception. Otherwise if reading fails and raises an - // exception, you will have a memory leak. - // - Identity ident; - ident.__read(&_stream); + case replyOK: + { + // + // Input and output parameters are always sent in an + // encapsulation, which makes it possible to forward + // oneway requests as blobs. + // + _stream.startReadEncaps(); + _state = StateOK; // The state must be set last, in case there is an exception. + break; + } + + case replyUserException: + { + // + // Input and output parameters are always sent in an + // encapsulation, which makes it possible to forward + // oneway requests as blobs. + // + _stream.startReadEncaps(); + _state = StateUserException; // The state must be set last, in case there is an exception. + break; + } + + case replyObjectNotExist: + case replyFacetNotExist: + case replyOperationNotExist: + { + // + // Don't read the exception members directly into the + // exception. Otherwise if reading fails and raises an + // exception, you will have a memory leak. + // + Identity ident; + ident.__read(&_stream); - // - // For compatibility with the old FacetPath. - // - vector<string> facetPath; - _stream.read(facetPath); - string facet; - if(!facetPath.empty()) - { - if(facetPath.size() > 1) - { - throw MarshalException(__FILE__, __LINE__); - } - facet.swap(facetPath[0]); - } + // + // For compatibility with the old FacetPath. + // + vector<string> facetPath; + _stream.read(facetPath); + string facet; + if(!facetPath.empty()) + { + if(facetPath.size() > 1) + { + throw MarshalException(__FILE__, __LINE__); + } + facet.swap(facetPath[0]); + } - string operation; - _stream.read(operation, false); - - RequestFailedException* ex; - switch(replyStatus) - { - case replyObjectNotExist: - { - ex = new ObjectNotExistException(__FILE__, __LINE__); - break; - } - - case replyFacetNotExist: - { - ex = new FacetNotExistException(__FILE__, __LINE__); - break; - } - - case replyOperationNotExist: - { - ex = new OperationNotExistException(__FILE__, __LINE__); - break; - } - - default: - { - ex = 0; // To keep the compiler from complaining. - assert(false); - break; - } - } - - ex->id = ident; - ex->facet = facet; - ex->operation = operation; - _exception.reset(ex); + string operation; + _stream.read(operation, false); + + RequestFailedException* ex; + switch(replyStatus) + { + case replyObjectNotExist: + { + ex = new ObjectNotExistException(__FILE__, __LINE__); + break; + } + + case replyFacetNotExist: + { + ex = new FacetNotExistException(__FILE__, __LINE__); + break; + } + + case replyOperationNotExist: + { + ex = new OperationNotExistException(__FILE__, __LINE__); + break; + } + + default: + { + ex = 0; // To keep the compiler from complaining. + assert(false); + break; + } + } + + ex->id = ident; + ex->facet = facet; + ex->operation = operation; + _exception.reset(ex); - _state = StateLocalException; // The state must be set last, in case there is an exception. - break; - } - - case replyUnknownException: - case replyUnknownLocalException: - case replyUnknownUserException: - { - // - // Don't read the exception members directly into the - // exception. Otherwise if reading fails and raises an - // exception, you will have a memory leak. - // - string unknown; - _stream.read(unknown, false); - - UnknownException* ex; - switch(replyStatus) - { - case replyUnknownException: - { - ex = new UnknownException(__FILE__, __LINE__); - break; - } - - case replyUnknownLocalException: - { - ex = new UnknownLocalException(__FILE__, __LINE__); - break; - } - - case replyUnknownUserException: - { - ex = new UnknownUserException(__FILE__, __LINE__); - break; - } - - default: - { - ex = 0; // To keep the compiler from complaining. - assert(false); - break; - } - } - - ex->unknown = unknown; - _exception.reset(ex); + _state = StateLocalException; // The state must be set last, in case there is an exception. + break; + } + + case replyUnknownException: + case replyUnknownLocalException: + case replyUnknownUserException: + { + // + // Don't read the exception members directly into the + // exception. Otherwise if reading fails and raises an + // exception, you will have a memory leak. + // + string unknown; + _stream.read(unknown, false); + + UnknownException* ex; + switch(replyStatus) + { + case replyUnknownException: + { + ex = new UnknownException(__FILE__, __LINE__); + break; + } + + case replyUnknownLocalException: + { + ex = new UnknownLocalException(__FILE__, __LINE__); + break; + } + + case replyUnknownUserException: + { + ex = new UnknownUserException(__FILE__, __LINE__); + break; + } + + default: + { + ex = 0; // To keep the compiler from complaining. + assert(false); + break; + } + } + + ex->unknown = unknown; + _exception.reset(ex); - _state = StateLocalException; // The state must be set last, in case there is an exception. - break; - } - - default: - { - //_exception.reset(new UnknownReplyStatusException(__FILE__, __LINE__)); - _exception.reset(new ProtocolException(__FILE__, __LINE__, "unknown reply status")); - _state = StateLocalException; - break; - } + _state = StateLocalException; // The state must be set last, in case there is an exception. + break; + } + + default: + { + //_exception.reset(new UnknownReplyStatusException(__FILE__, __LINE__)); + _exception.reset(new ProtocolException(__FILE__, __LINE__, "unknown reply status")); + _state = StateLocalException; + break; + } } } diff --git a/cppe/src/IceE/OutgoingConnectionFactory.cpp b/cppe/src/IceE/OutgoingConnectionFactory.cpp index 5c86c452c77..79b3696c73c 100644 --- a/cppe/src/IceE/OutgoingConnectionFactory.cpp +++ b/cppe/src/IceE/OutgoingConnectionFactory.cpp @@ -36,18 +36,18 @@ IceInternal::OutgoingConnectionFactory::destroy() if(_destroyed) { - return; + return; } #ifdef _STLP_BEGIN_NAMESPACE // voidbind2nd is an STLport extension for broken compilers in IceE/Functional.h for_each(_connections.begin(), _connections.end(), - voidbind2nd(Ice::secondVoidMemFun1<EndpointPtr, Connection, Connection::DestructionReason> - (&Connection::destroy), Connection::CommunicatorDestroyed)); + voidbind2nd(Ice::secondVoidMemFun1<EndpointPtr, Connection, Connection::DestructionReason> + (&Connection::destroy), Connection::CommunicatorDestroyed)); #else for_each(_connections.begin(), _connections.end(), - bind2nd(Ice::secondVoidMemFun1<const EndpointPtr, Connection, Connection::DestructionReason> - (&Connection::destroy), Connection::CommunicatorDestroyed)); + bind2nd(Ice::secondVoidMemFun1<const EndpointPtr, Connection, Connection::DestructionReason> + (&Connection::destroy), Connection::CommunicatorDestroyed)); #endif _destroyed = true; @@ -60,27 +60,27 @@ IceInternal::OutgoingConnectionFactory::waitUntilFinished() multimap<EndpointPtr, ConnectionPtr> connections; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // First we wait until the factory is destroyed. We also wait - // until there are no pending connections anymore. Only then - // we can be sure the _connections contains all connections. - // - while(!_destroyed || !_pending.empty()) - { - wait(); - } - - // - // We want to wait until all connections are finished outside the - // thread synchronization. - // - connections.swap(_connections); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // First we wait until the factory is destroyed. We also wait + // until there are no pending connections anymore. Only then + // we can be sure the _connections contains all connections. + // + while(!_destroyed || !_pending.empty()) + { + wait(); + } + + // + // We want to wait until all connections are finished outside the + // thread synchronization. + // + connections.swap(_connections); } for_each(connections.begin(), connections.end(), - Ice::secondVoidMemFun<const EndpointPtr, Connection>(&Connection::waitUntilFinished)); + Ice::secondVoidMemFun<const EndpointPtr, Connection>(&Connection::waitUntilFinished)); } ConnectionPtr @@ -90,130 +90,130 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointPtr>& endpts vector<EndpointPtr> endpoints = endpts; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - if(_destroyed) - { - throw CommunicatorDestroyedException(__FILE__, __LINE__); - } - - // - // Reap connections for which destruction has completed. - // - std::multimap<EndpointPtr, ConnectionPtr>::iterator p = _connections.begin(); - while(p != _connections.end()) - { - if(p->second->isFinished()) - { - _connections.erase(p++); - } - else - { - ++p; - } - } - - // - // Modify endpoints with overrides. - // - vector<EndpointPtr>::iterator q; - for(q = endpoints.begin(); q != endpoints.end(); ++q) - { - if(_instance->defaultsAndOverrides()->overrideTimeout) - { - *q = (*q)->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue); - } - } - - // - // Search for existing connections. - // - vector<EndpointPtr>::const_iterator r; - for(q = endpoints.begin(), r = endpts.begin(); q != endpoints.end(); ++q, ++r) - { - pair<multimap<EndpointPtr, ConnectionPtr>::iterator, - multimap<EndpointPtr, ConnectionPtr>::iterator> pr = _connections.equal_range(*q); - - while(pr.first != pr.second) - { - // - // Don't return connections for which destruction has - // been initiated. - // - if(!pr.first->second->isDestroyed()) - { - return pr.first->second; - } - - ++pr.first; - } - } - - // - // If some other thread is currently trying to establish a - // connection to any of our endpoints, we wait until this - // thread is finished. - // - bool searchAgain = false; - while(!_destroyed) - { - for(q = endpoints.begin(); q != endpoints.end(); ++q) - { - if(_pending.find(*q) != _pending.end()) - { - break; - } - } - - if(q == endpoints.end()) - { - break; - } - - searchAgain = true; - - wait(); - } - - if(_destroyed) - { - throw CommunicatorDestroyedException(__FILE__, __LINE__); - } - - // - // Search for existing connections again if we waited above, - // as new connections might have been added in the meantime. - // - if(searchAgain) - { - for(q = endpoints.begin(), r = endpts.begin(); q != endpoints.end(); ++q, ++r) - { - pair<multimap<EndpointPtr, ConnectionPtr>::iterator, - multimap<EndpointPtr, ConnectionPtr>::iterator> pr = _connections.equal_range(*q); - - while(pr.first != pr.second) - { - // - // Don't return connections for which destruction has - // been initiated. - // - if(!pr.first->second->isDestroyed()) - { - return pr.first->second; - } - - ++pr.first; - } - } - } - - // - // No connection to any of our endpoints exists yet, so we - // will try to create one. To avoid that other threads try to - // create connections to the same endpoints, we add our - // endpoints to _pending. - // - _pending.insert(endpoints.begin(), endpoints.end()); + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + if(_destroyed) + { + throw CommunicatorDestroyedException(__FILE__, __LINE__); + } + + // + // Reap connections for which destruction has completed. + // + std::multimap<EndpointPtr, ConnectionPtr>::iterator p = _connections.begin(); + while(p != _connections.end()) + { + if(p->second->isFinished()) + { + _connections.erase(p++); + } + else + { + ++p; + } + } + + // + // Modify endpoints with overrides. + // + vector<EndpointPtr>::iterator q; + for(q = endpoints.begin(); q != endpoints.end(); ++q) + { + if(_instance->defaultsAndOverrides()->overrideTimeout) + { + *q = (*q)->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue); + } + } + + // + // Search for existing connections. + // + vector<EndpointPtr>::const_iterator r; + for(q = endpoints.begin(), r = endpts.begin(); q != endpoints.end(); ++q, ++r) + { + pair<multimap<EndpointPtr, ConnectionPtr>::iterator, + multimap<EndpointPtr, ConnectionPtr>::iterator> pr = _connections.equal_range(*q); + + while(pr.first != pr.second) + { + // + // Don't return connections for which destruction has + // been initiated. + // + if(!pr.first->second->isDestroyed()) + { + return pr.first->second; + } + + ++pr.first; + } + } + + // + // If some other thread is currently trying to establish a + // connection to any of our endpoints, we wait until this + // thread is finished. + // + bool searchAgain = false; + while(!_destroyed) + { + for(q = endpoints.begin(); q != endpoints.end(); ++q) + { + if(_pending.find(*q) != _pending.end()) + { + break; + } + } + + if(q == endpoints.end()) + { + break; + } + + searchAgain = true; + + wait(); + } + + if(_destroyed) + { + throw CommunicatorDestroyedException(__FILE__, __LINE__); + } + + // + // Search for existing connections again if we waited above, + // as new connections might have been added in the meantime. + // + if(searchAgain) + { + for(q = endpoints.begin(), r = endpts.begin(); q != endpoints.end(); ++q, ++r) + { + pair<multimap<EndpointPtr, ConnectionPtr>::iterator, + multimap<EndpointPtr, ConnectionPtr>::iterator> pr = _connections.equal_range(*q); + + while(pr.first != pr.second) + { + // + // Don't return connections for which destruction has + // been initiated. + // + if(!pr.first->second->isDestroyed()) + { + return pr.first->second; + } + + ++pr.first; + } + } + } + + // + // No connection to any of our endpoints exists yet, so we + // will try to create one. To avoid that other threads try to + // create connections to the same endpoints, we add our + // endpoints to _pending. + // + _pending.insert(endpoints.begin(), endpoints.end()); } ConnectionPtr connection; @@ -223,104 +223,104 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointPtr>& endpts vector<EndpointPtr>::const_iterator r; for(q = endpoints.begin(), r = endpts.begin(); q != endpoints.end(); ++q, ++r) { - EndpointPtr endpoint = *q; - - try - { - ConnectorPtr connector = endpoint->connector(); - assert(connector); - - Int timeout; - if(_instance->defaultsAndOverrides()->overrideConnectTimeout) - { - timeout = _instance->defaultsAndOverrides()->overrideConnectTimeoutValue; - } - // It is not necessary to check for overrideTimeout, - // the endpoint has already been modified with this - // override, if set. - else - { - timeout = endpoint->timeout(); - } - - TransceiverPtr transceiver = connector->connect(timeout); - assert(transceiver); + EndpointPtr endpoint = *q; + + try + { + ConnectorPtr connector = endpoint->connector(); + assert(connector); + + Int timeout; + if(_instance->defaultsAndOverrides()->overrideConnectTimeout) + { + timeout = _instance->defaultsAndOverrides()->overrideConnectTimeoutValue; + } + // It is not necessary to check for overrideTimeout, + // the endpoint has already been modified with this + // override, if set. + else + { + timeout = endpoint->timeout(); + } + + TransceiverPtr transceiver = connector->connect(timeout); + assert(transceiver); #ifdef ICEE_PURE_CLIENT - connection = new Connection(_instance, transceiver, endpoint); + connection = new Connection(_instance, transceiver, endpoint); #else - connection = new Connection(_instance, transceiver, endpoint, 0); + connection = new Connection(_instance, transceiver, endpoint, 0); #endif - // - // Wait for the connection to be validated by the - // connection thread. Once the connection has been - // validated it will be activated also. - // - connection->waitForValidation(); - break; - } - catch(const LocalException& ex) - { - exception.reset(dynamic_cast<LocalException*>(ex.ice_clone())); - - // - // If a connection object was constructed, then validate() - // must have raised the exception. - // - if(connection) - { - connection->waitUntilFinished(); // We must call waitUntilFinished() for cleanup. - connection = 0; - } - } - - TraceLevelsPtr traceLevels = _instance->traceLevels(); - if(traceLevels->retry >= 2) - { - Trace out(_instance->initializationData().logger, traceLevels->retryCat); - - out << "connection to endpoint failed"; - if(q + 1 != endpoints.end()) - { - out << ", trying next endpoint\n"; - } - else - { - out << " and no more endpoints to try\n"; - } - out << (*exception.get()).toString(); - } + // + // Wait for the connection to be validated by the + // connection thread. Once the connection has been + // validated it will be activated also. + // + connection->waitForValidation(); + break; + } + catch(const LocalException& ex) + { + exception.reset(dynamic_cast<LocalException*>(ex.ice_clone())); + + // + // If a connection object was constructed, then validate() + // must have raised the exception. + // + if(connection) + { + connection->waitUntilFinished(); // We must call waitUntilFinished() for cleanup. + connection = 0; + } + } + + TraceLevelsPtr traceLevels = _instance->traceLevels(); + if(traceLevels->retry >= 2) + { + Trace out(_instance->initializationData().logger, traceLevels->retryCat); + + out << "connection to endpoint failed"; + if(q + 1 != endpoints.end()) + { + out << ", trying next endpoint\n"; + } + else + { + out << " and no more endpoints to try\n"; + } + out << (*exception.get()).toString(); + } } { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - // - // Signal other threads that we are done with trying to - // establish connections to our endpoints. - // - for(q = endpoints.begin(); q != endpoints.end(); ++q) - { - _pending.erase(*q); - } - notifyAll(); - - if(!connection) - { - assert(exception.get()); - exception->ice_throw(); - } - else - { - _connections.insert(_connections.end(), - pair<const EndpointPtr, ConnectionPtr>(connection->endpoint(), connection)); - - if(_destroyed) - { - connection->destroy(Connection::CommunicatorDestroyed); - throw CommunicatorDestroyedException(__FILE__, __LINE__); - } - } + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + // + // Signal other threads that we are done with trying to + // establish connections to our endpoints. + // + for(q = endpoints.begin(); q != endpoints.end(); ++q) + { + _pending.erase(*q); + } + notifyAll(); + + if(!connection) + { + assert(exception.get()); + exception->ice_throw(); + } + else + { + _connections.insert(_connections.end(), + pair<const EndpointPtr, ConnectionPtr>(connection->endpoint(), connection)); + + if(_destroyed) + { + connection->destroy(Connection::CommunicatorDestroyed); + throw CommunicatorDestroyedException(__FILE__, __LINE__); + } + } } assert(connection); @@ -336,7 +336,7 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route if(_destroyed) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } assert(routerInfo); @@ -353,34 +353,34 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route vector<EndpointPtr>::const_iterator p; for(p = endpoints.begin(); p != endpoints.end(); ++p) { - EndpointPtr endpoint = *p; + EndpointPtr endpoint = *p; - // - // Modify endpoints with overrides. - // - if(_instance->defaultsAndOverrides()->overrideTimeout) - { - endpoint = endpoint->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue); - } + // + // Modify endpoints with overrides. + // + if(_instance->defaultsAndOverrides()->overrideTimeout) + { + endpoint = endpoint->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue); + } #ifndef ICEE_PURE_CLIENT - pair<multimap<EndpointPtr, ConnectionPtr>::iterator, - multimap<EndpointPtr, ConnectionPtr>::iterator> pr = _connections.equal_range(endpoint); - - while(pr.first != pr.second) - { - try - { - pr.first->second->setAdapter(adapter); - } - catch(const Ice::LocalException&) - { - // - // Ignore, the connection is being closed or closed. - // - } - ++pr.first; - } + pair<multimap<EndpointPtr, ConnectionPtr>::iterator, + multimap<EndpointPtr, ConnectionPtr>::iterator> pr = _connections.equal_range(endpoint); + + while(pr.first != pr.second) + { + try + { + pr.first->second->setAdapter(adapter); + } + catch(const Ice::LocalException&) + { + // + // Ignore, the connection is being closed or closed. + // + } + ++pr.first; + } #endif } } @@ -394,26 +394,26 @@ IceInternal::OutgoingConnectionFactory::flushBatchRequests() list<ConnectionPtr> c; { - IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); - - for(std::multimap<EndpointPtr, ConnectionPtr>::const_iterator p = _connections.begin(); - p != _connections.end(); - ++p) - { - c.push_back(p->second); - } + IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this); + + for(std::multimap<EndpointPtr, ConnectionPtr>::const_iterator p = _connections.begin(); + p != _connections.end(); + ++p) + { + c.push_back(p->second); + } } for(list<ConnectionPtr>::const_iterator p = c.begin(); p != c.end(); ++p) { - try - { - (*p)->flushBatchRequests(); - } - catch(const LocalException&) - { - // Ignore. - } + try + { + (*p)->flushBatchRequests(); + } + catch(const LocalException&) + { + // Ignore. + } } } #endif @@ -439,24 +439,24 @@ IceInternal::OutgoingConnectionFactory::removeAdapter(const ObjectAdapterPtr& ad if(_destroyed) { - return; + return; } for(multimap<EndpointPtr, ConnectionPtr>::const_iterator p = _connections.begin(); p != _connections.end(); ++p) { - if(p->second->getAdapter() == adapter) - { - try - { - p->second->setAdapter(0); - } - catch(const Ice::LocalException&) - { - // - // Ignore, the connection is being closed or closed. - // - } - } + if(p->second->getAdapter() == adapter) + { + try + { + p->second->setAdapter(0); + } + catch(const Ice::LocalException&) + { + // + // Ignore, the connection is being closed or closed. + // + } + } } } diff --git a/cppe/src/IceE/Properties.cpp b/cppe/src/IceE/Properties.cpp index 58e439b7046..c9058e2a932 100644 --- a/cppe/src/IceE/Properties.cpp +++ b/cppe/src/IceE/Properties.cpp @@ -27,11 +27,11 @@ Ice::Properties::getProperty(const string& key) map<string, string>::const_iterator p = _properties.find(key); if(p != _properties.end()) { - return p->second; + return p->second; } else { - return string(); + return string(); } } @@ -43,11 +43,11 @@ Ice::Properties::getPropertyWithDefault(const string& key, const string& value) map<string, string>::const_iterator p = _properties.find(key); if(p != _properties.end()) { - return p->second; + return p->second; } else { - return value; + return value; } } @@ -65,7 +65,7 @@ Ice::Properties::getPropertyAsIntWithDefault(const string& key, Int value) map<string, string>::const_iterator p = _properties.find(key); if(p != _properties.end()) { - value = atoi(p->second.c_str()); + value = atoi(p->second.c_str()); } return value; @@ -94,7 +94,7 @@ Ice::Properties::setProperty(const string& key, const string& value) { if(key.empty()) { - return; + return; } IceUtil::Mutex::Lock sync(*this); @@ -104,11 +104,11 @@ Ice::Properties::setProperty(const string& key, const string& value) // if(!value.empty()) { - _properties[key] = value; + _properties[key] = value; } else { - _properties.erase(key); + _properties.erase(key); } } @@ -122,7 +122,7 @@ Ice::Properties::getCommandLineOptions() map<string, string>::const_iterator p; for(p = _properties.begin(); p != _properties.end(); ++p) { - result.push_back("--" + p->first + "=" + p->second); + result.push_back("--" + p->first + "=" + p->second); } return result; } @@ -133,7 +133,7 @@ Ice::Properties::parseCommandLineOptions(const string& prefix, const StringSeq& string pfx = prefix; if(!pfx.empty() && pfx[pfx.size() - 1] != '.') { - pfx += '.'; + pfx += '.'; } pfx = "--" + pfx; @@ -176,7 +176,7 @@ Ice::Properties::load(const std::string& file) if(!in) { FileException ex(__FILE__, __LINE__); - ex.path = file; + ex.path = file; ex.error = getSystemErrno(); throw ex; } @@ -184,7 +184,7 @@ Ice::Properties::load(const std::string& file) char line[1024]; while(fgets(line, 1024, in) != NULL) { - parseLine(line + parseLine(line #ifdef ICEE_HAS_WSTRING , _converter #endif @@ -226,7 +226,7 @@ Ice::Properties::Properties(StringSeq& args, const PropertiesPtr& defaults { if(defaults != 0) { - _properties = defaults->getPropertiesForPrefix(""); + _properties = defaults->getPropertiesForPrefix(""); } StringSeq::iterator q = args.begin(); @@ -239,7 +239,7 @@ Ice::Properties::Properties(StringSeq& args, const PropertiesPtr& defaults // string name = *q; replace(name.begin(), name.end(), '\\', '/'); - setProperty("Ice.ProgramName", name); + setProperty("Ice.ProgramName", name); } StringSeq tmp; @@ -258,27 +258,27 @@ Ice::Properties::Properties(StringSeq& args, const PropertiesPtr& defaults , 0 #endif ); - loadConfigFiles = true; + loadConfigFiles = true; } else { - tmp.push_back(s); + tmp.push_back(s); } - ++q; + ++q; } args = tmp; if(!loadConfigFiles) { - // - // If Ice.Config is not set, load from ICE_CONFIG (if set) - // - loadConfigFiles = (_properties.find("Ice.Config") == _properties.end()); + // + // If Ice.Config is not set, load from ICE_CONFIG (if set) + // + loadConfigFiles = (_properties.find("Ice.Config") == _properties.end()); } if(loadConfigFiles) { - loadConfig(); + loadConfig(); } args = parseIceCommandLineOptions(args); @@ -335,7 +335,11 @@ Ice::Properties::parseLine(const string& line } string key = IceUtil::trim(s.substr(0, split)); - string value = IceUtil::trim(s.substr(split + 1, s.length() - split - 1)); + string value; + if(split < s.length() - 2) + { + value = IceUtil::trim(s.substr(split + 1, s.length() - split - 1)); + } #ifdef ICEE_HAS_WSTRING if(converter) diff --git a/cppe/src/IceE/Protocol.cpp b/cppe/src/IceE/Protocol.cpp index 12bfd645fb8..309614511ce 100644 --- a/cppe/src/IceE/Protocol.cpp +++ b/cppe/src/IceE/Protocol.cpp @@ -12,7 +12,7 @@ namespace IceInternal { -const Ice::Byte magic[] = { 0x49, 0x63, 0x65, 0x50 }; // 'I', 'c', 'e', 'P' +const Ice::Byte magic[] = { 0x49, 0x63, 0x65, 0x50 }; // 'I', 'c', 'e', 'P' const Ice::Byte requestHdr[] = { diff --git a/cppe/src/IceE/Proxy.cpp b/cppe/src/IceE/Proxy.cpp index 6ba2127a000..af83c170b36 100644 --- a/cppe/src/IceE/Proxy.cpp +++ b/cppe/src/IceE/Proxy.cpp @@ -36,8 +36,8 @@ Ice::__write(::IceInternal::BasicStream* __os, const ::Ice::Context& v, ::Ice::_ ::Ice::Context::const_iterator p; for(p = v.begin(); p != v.end(); ++p) { - __os->write(p->first); - __os->write(p->second); + __os->write(p->first); + __os->write(p->second); } } @@ -48,10 +48,10 @@ Ice::__read(::IceInternal::BasicStream* __is, ::Ice::Context& v, ::Ice::__U__Con __is->readSize(sz); while(sz--) { - ::std::pair<const ::std::string, ::std::string> pair; - __is->read(const_cast< ::std::string&>(pair.first)); - ::Ice::Context::iterator __i = v.insert(v.end(), pair); - __is->read(__i->second); + ::std::pair<const ::std::string, ::std::string> pair; + __is->read(const_cast< ::std::string&>(pair.first)); + ::Ice::Context::iterator __i = v.insert(v.end(), pair); + __is->read(__i->second); } } @@ -68,23 +68,23 @@ IceInternal::checkedCastImpl(const ObjectPrx& b, const string& f, const string& if(b) { - ObjectPrx bb = b->ice_facet(f); - try - { - if(bb->ice_isA(typeId)) - { - return bb; - } + ObjectPrx bb = b->ice_facet(f); + try + { + if(bb->ice_isA(typeId)) + { + return bb; + } #ifndef NDEBUG - else - { - assert(typeId != "::Ice::Object"); - } + else + { + assert(typeId != "::Ice::Object"); + } #endif - } - catch(const FacetNotExistException&) - { - } + } + catch(const FacetNotExistException&) + { + } } return 0; } @@ -102,23 +102,23 @@ IceInternal::checkedCastImpl(const ObjectPrx& b, const string& f, const string& if(b) { - ObjectPrx bb = b->ice_facet(f); - try - { - if(bb->ice_isA(typeId, ctx)) - { - return bb; - } + ObjectPrx bb = b->ice_facet(f); + try + { + if(bb->ice_isA(typeId, ctx)) + { + return bb; + } #ifndef NDEBUG - else - { - assert(typeId != "::Ice::Object"); - } + else + { + assert(typeId != "::Ice::Object"); + } #endif - } - catch(const FacetNotExistException&) - { - } + } + catch(const FacetNotExistException&) + { + } } return 0; } @@ -160,11 +160,11 @@ IceProxy::Ice::Object::ice_isA(const string& __id, const Context* __context) while(true) { ConnectionPtr __connection; - try - { - __checkTwowayOnly("ice_isA"); - static const string __operation("ice_isA"); - __connection = ice_getConnection(); + try + { + __checkTwowayOnly("ice_isA"); + static const string __operation("ice_isA"); + __connection = ice_getConnection(); Outgoing __og(__connection.get(), _reference.get(), __operation, ::Ice::Nonmutating, __context); BasicStream* __stream = __og.stream(); try @@ -181,14 +181,14 @@ IceProxy::Ice::Object::ice_isA(const string& __id, const Context* __context) { if(!__ok) { - try - { + try + { __stream->throwException(); - } - catch(const ::Ice::UserException& __ex) - { - throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); - } + } + catch(const ::Ice::UserException& __ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); + } } __stream->read(__ret); } @@ -203,20 +203,20 @@ IceProxy::Ice::Object::ice_isA(const string& __id, const Context* __context) } #endif return __ret; - } - catch(const LocalExceptionWrapper& __ex) - { - __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); - } - catch(const LocalException& __ex) - { - __handleException(__connection, __ex, __cnt); - } + } + catch(const LocalExceptionWrapper& __ex) + { + __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); + } + catch(const LocalException& __ex) + { + __handleException(__connection, __ex, __cnt); + } #if defined(_MSC_VER) && defined(_M_ARM) // ARM bug. - catch(...) - { - throw; - } + catch(...) + { + throw; + } #endif } } @@ -228,10 +228,10 @@ IceProxy::Ice::Object::ice_ping(const Context* __context) while(true) { ConnectionPtr __connection; - try - { + try + { static const string __operation("ice_ping"); - __connection = ice_getConnection(); + __connection = ice_getConnection(); Outgoing __og(__connection.get(), _reference.get(), __operation, ::Ice::Nonmutating, __context); bool __ok = __og.invoke(); try @@ -239,14 +239,14 @@ IceProxy::Ice::Object::ice_ping(const Context* __context) BasicStream* __is = __og.stream(); if(!__ok) { - try - { + try + { __is->throwException(); - } - catch(const ::Ice::UserException& __ex) - { - throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); - } + } + catch(const ::Ice::UserException& __ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); + } } } catch(const ::Ice::LocalException& __ex) @@ -259,21 +259,21 @@ IceProxy::Ice::Object::ice_ping(const Context* __context) throw; } #endif - return; - } - catch(const LocalExceptionWrapper& __ex) - { - __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); - } - catch(const LocalException& __ex) - { - __handleException(__connection, __ex, __cnt); - } + return; + } + catch(const LocalExceptionWrapper& __ex) + { + __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); + } + catch(const LocalException& __ex) + { + __handleException(__connection, __ex, __cnt); + } #if defined(_MSC_VER) && defined(_M_ARM) // ARM bug. - catch(...) - { - throw; - } + catch(...) + { + throw; + } #endif } } @@ -285,11 +285,11 @@ IceProxy::Ice::Object::ice_ids(const Context* __context) while(true) { ConnectionPtr __connection; - try - { - __checkTwowayOnly("ice_ids"); + try + { + __checkTwowayOnly("ice_ids"); static const string __operation("ice_ids"); - __connection = ice_getConnection(); + __connection = ice_getConnection(); Outgoing __og(__connection.get(), _reference.get(), __operation, ::Ice::Nonmutating, __context); vector<string> __ret; bool __ok = __og.invoke(); @@ -298,14 +298,14 @@ IceProxy::Ice::Object::ice_ids(const Context* __context) BasicStream* __is = __og.stream(); if(!__ok) { - try - { + try + { __is->throwException(); - } - catch(const ::Ice::UserException& __ex) - { - throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); - } + } + catch(const ::Ice::UserException& __ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); + } } __is->read(__ret, false); } @@ -320,20 +320,20 @@ IceProxy::Ice::Object::ice_ids(const Context* __context) } #endif return __ret; - } - catch(const LocalExceptionWrapper& __ex) - { - __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); - } - catch(const LocalException& __ex) - { - __handleException(__connection, __ex, __cnt); - } + } + catch(const LocalExceptionWrapper& __ex) + { + __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); + } + catch(const LocalException& __ex) + { + __handleException(__connection, __ex, __cnt); + } #if defined(_MSC_VER) && defined(_M_ARM) // ARM bug. - catch(...) - { - throw; - } + catch(...) + { + throw; + } #endif } } @@ -345,11 +345,11 @@ IceProxy::Ice::Object::ice_id(const Context* __context) while(true) { ConnectionPtr __connection; - try - { - __checkTwowayOnly("ice_id"); + try + { + __checkTwowayOnly("ice_id"); static const string __operation("ice_id"); - __connection = ice_getConnection(); + __connection = ice_getConnection(); Outgoing __og(__connection.get(), _reference.get(), __operation, ::Ice::Nonmutating, __context); string __ret; bool __ok = __og.invoke(); @@ -358,14 +358,14 @@ IceProxy::Ice::Object::ice_id(const Context* __context) BasicStream* __is = __og.stream(); if(!__ok) { - try - { + try + { __is->throwException(); - } - catch(const ::Ice::UserException& __ex) - { - throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); - } + } + catch(const ::Ice::UserException& __ex) + { + throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name()); + } } __is->read(__ret, false); } @@ -380,20 +380,20 @@ IceProxy::Ice::Object::ice_id(const Context* __context) } #endif return __ret; - } - catch(const LocalExceptionWrapper& __ex) - { - __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); - } - catch(const LocalException& __ex) - { - __handleException(__connection, __ex, __cnt); - } + } + catch(const LocalExceptionWrapper& __ex) + { + __handleExceptionWrapperRelaxed(__connection, __ex, __cnt); + } + catch(const LocalException& __ex) + { + __handleException(__connection, __ex, __cnt); + } #if defined(_MSC_VER) && defined(_M_ARM) // ARM bug. - catch(...) - { - throw; - } + catch(...) + { + throw; + } #endif } } @@ -427,13 +427,13 @@ IceProxy::Ice::Object::ice_identity(const Identity& newIdentity) const } if(newIdentity == _reference->getIdentity()) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(_reference->changeIdentity(newIdentity)); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(_reference->changeIdentity(newIdentity)); + return proxy; } } @@ -448,13 +448,13 @@ IceProxy::Ice::Object::ice_facet(const string& newFacet) const { if(newFacet == _reference->getFacet()) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(_reference->changeFacet(newFacet)); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(_reference->changeFacet(newFacet)); + return proxy; } } @@ -473,13 +473,13 @@ IceProxy::Ice::Object::ice_router(const RouterPrx& router) const ReferencePtr ref = _reference->changeRouter(router); if(ref == _reference) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(ref); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(ref); + return proxy; } } @@ -499,13 +499,13 @@ IceProxy::Ice::Object::ice_adapterId(const string& adapterId) const ReferencePtr ref = _reference->changeAdapterId(adapterId); if(ref == _reference) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(ref); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(ref); + return proxy; } } @@ -522,13 +522,13 @@ IceProxy::Ice::Object::ice_locator(const LocatorPrx& locator) const ReferencePtr ref = _reference->changeLocator(locator); if(ref == _reference) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(ref); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(ref); + return proxy; } } @@ -561,13 +561,13 @@ IceProxy::Ice::Object::ice_timeout(int t) const ReferencePtr ref = _reference->changeTimeout(t); if(ref == _reference) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(ref); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(ref); + return proxy; } } @@ -610,10 +610,10 @@ IceProxy::Ice::Object::__copyFrom(const ObjectPrx& from) ConnectionPtr con; { - ::IceUtil::Mutex::Lock sync(*from.get()); + ::IceUtil::Mutex::Lock sync(*from.get()); - ref = from->_reference; - con = from->_connection; + ref = from->_reference; + con = from->_connection; } // @@ -645,13 +645,13 @@ IceProxy::Ice::Object::__handleException(const ConnectionPtr& connection, const ProxyFactoryPtr proxyFactory = _reference->getInstance()->proxyFactory(); if(proxyFactory) { - proxyFactory->checkRetryAfterException(ex, _reference, cnt); + proxyFactory->checkRetryAfterException(ex, _reference, cnt); } else { - // - // The communicator is already destroyed, so we cannot retry. - // + // + // The communicator is already destroyed, so we cannot retry. + // ex.ice_throw(); } } @@ -703,8 +703,8 @@ IceProxy::Ice::Object::__checkTwowayOnly(const char* name) const if(!ice_isTwoway()) { TwowayOnlyException ex(__FILE__, __LINE__); - ex.operation = name; - throw ex; + ex.operation = name; + throw ex; } } @@ -719,13 +719,13 @@ IceProxy::Ice::Object::changeMode(ReferenceMode newMode) const { if(_reference->getMode() == newMode) { - return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); + return ObjectPrx(const_cast< ::IceProxy::Ice::Object*>(this)); } else { - ObjectPrx proxy(new ::IceProxy::Ice::Object()); - proxy->setup(_reference->changeMode(newMode)); - return proxy; + ObjectPrx proxy(new ::IceProxy::Ice::Object()); + proxy->setup(_reference->changeMode(newMode)); + return proxy; } } @@ -734,19 +734,19 @@ Ice::proxyIdentityLess(const ObjectPrx& lhs, const ObjectPrx& rhs) { if(!lhs && !rhs) { - return false; + return false; } else if(!lhs && rhs) { - return true; + return true; } else if(lhs && !rhs) { - return false; + return false; } else { - return lhs->ice_getIdentity() < rhs->ice_getIdentity(); + return lhs->ice_getIdentity() < rhs->ice_getIdentity(); } } @@ -755,19 +755,19 @@ Ice::proxyIdentityEqual(const ObjectPrx& lhs, const ObjectPrx& rhs) { if(!lhs && !rhs) { - return true; + return true; } else if(!lhs && rhs) { - return false; + return false; } else if(lhs && !rhs) { - return false; + return false; } else { - return lhs->ice_getIdentity() == rhs->ice_getIdentity(); + return lhs->ice_getIdentity() == rhs->ice_getIdentity(); } } @@ -776,43 +776,43 @@ Ice::proxyIdentityAndFacetLess(const ObjectPrx& lhs, const ObjectPrx& rhs) { if(!lhs && !rhs) { - return false; + return false; } else if(!lhs && rhs) { - return true; + return true; } else if(lhs && !rhs) { - return false; + return false; } else { - Identity lhsIdentity = lhs->ice_getIdentity(); - Identity rhsIdentity = rhs->ice_getIdentity(); - - if(lhsIdentity < rhsIdentity) - { - return true; - } - else if(rhsIdentity < lhsIdentity) - { - return false; - } - - string lhsFacet = lhs->ice_getFacet(); - string rhsFacet = rhs->ice_getFacet(); - - if(lhsFacet < rhsFacet) - { - return true; - } - else if(rhsFacet < lhsFacet) - { - return false; - } - - return false; + Identity lhsIdentity = lhs->ice_getIdentity(); + Identity rhsIdentity = rhs->ice_getIdentity(); + + if(lhsIdentity < rhsIdentity) + { + return true; + } + else if(rhsIdentity < lhsIdentity) + { + return false; + } + + string lhsFacet = lhs->ice_getFacet(); + string rhsFacet = rhs->ice_getFacet(); + + if(lhsFacet < rhsFacet) + { + return true; + } + else if(rhsFacet < lhsFacet) + { + return false; + } + + return false; } } @@ -821,32 +821,32 @@ Ice::proxyIdentityAndFacetEqual(const ObjectPrx& lhs, const ObjectPrx& rhs) { if(!lhs && !rhs) { - return true; + return true; } else if(!lhs && rhs) { - return false; + return false; } else if(lhs && !rhs) { - return false; + return false; } else { - Identity lhsIdentity = lhs->ice_getIdentity(); - Identity rhsIdentity = rhs->ice_getIdentity(); - - if(lhsIdentity == rhsIdentity) - { - string lhsFacet = lhs->ice_getFacet(); - string rhsFacet = rhs->ice_getFacet(); - - if(lhsFacet == rhsFacet) - { - return true; - } - } - - return false; + Identity lhsIdentity = lhs->ice_getIdentity(); + Identity rhsIdentity = rhs->ice_getIdentity(); + + if(lhsIdentity == rhsIdentity) + { + string lhsFacet = lhs->ice_getFacet(); + string rhsFacet = rhs->ice_getFacet(); + + if(lhsFacet == rhsFacet) + { + return true; + } + } + + return false; } } diff --git a/cppe/src/IceE/ProxyFactory.cpp b/cppe/src/IceE/ProxyFactory.cpp index 564f40ec857..3ca7b7a2d23 100644 --- a/cppe/src/IceE/ProxyFactory.cpp +++ b/cppe/src/IceE/ProxyFactory.cpp @@ -39,11 +39,11 @@ IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const { if(proxy) { - return proxy->__reference()->toString(); + return proxy->__reference()->toString(); } else { - return ""; + return ""; } } @@ -69,13 +69,13 @@ IceInternal::ProxyFactory::proxyToStream(const ObjectPrx& proxy, BasicStream* s) { if(proxy) { - proxy->__reference()->getIdentity().__write(s); - proxy->__reference()->streamWrite(s); + proxy->__reference()->getIdentity().__write(s); + proxy->__reference()->streamWrite(s); } else { - Identity ident; - ident.__write(s); + Identity ident; + ident.__write(s); } } @@ -105,15 +105,15 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co if(one) { #ifdef ICEE_HAS_LOCATOR - LocatorInfoPtr li = ref->getLocatorInfo(); - if(li) - { - // - // We retry ObjectNotExistException if the reference is indirect. - // - li->clearObjectCache(IndirectReferencePtr::dynamicCast(ref)); - } - else + LocatorInfoPtr li = ref->getLocatorInfo(); + if(li) + { + // + // We retry ObjectNotExistException if the reference is indirect. + // + li->clearObjectCache(IndirectReferencePtr::dynamicCast(ref)); + } + else #endif #ifdef ICEE_HAS_ROUTER if(ref->getRouterInfo() && one->operation == "ice_add_proxy") @@ -133,14 +133,14 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co } return; // We must always retry, so we don't look at the retry count. } - else + else #endif - { - // - // For all other cases, we don't retry ObjectNotExistException - // - ex.ice_throw(); - } + { + // + // For all other cases, we don't retry ObjectNotExistException + // + ex.ice_throw(); + } } else #endif @@ -150,7 +150,7 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co // We don't retry other *NotExistException, which are all // derived from RequestFailedException. // - ex.ice_throw(); + ex.ice_throw(); } // @@ -177,7 +177,7 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex, co // if(dynamic_cast<const MarshalException*>(&ex)) { - ex.ice_throw(); + ex.ice_throw(); } ++cnt; @@ -225,41 +225,41 @@ IceInternal::ProxyFactory::ProxyFactory(const InstancePtr& instance) : while(true) { - const string delim = " \t"; + const string delim = " \t"; - beg = str.find_first_not_of(delim, end); - if(beg == string::npos) - { - if(_retryIntervals.empty()) - { - _retryIntervals.push_back(0); - } - break; - } + beg = str.find_first_not_of(delim, end); + if(beg == string::npos) + { + if(_retryIntervals.empty()) + { + _retryIntervals.push_back(0); + } + break; + } - end = str.find_first_of(delim, beg); - if(end == string::npos) - { - end = str.length(); - } - - if(beg == end) - { - break; - } + end = str.find_first_of(delim, beg); + if(end == string::npos) + { + end = str.length(); + } + + if(beg == end) + { + break; + } - string value = str.substr(beg, end - beg); - int v = atoi(value.c_str()); + string value = str.substr(beg, end - beg); + int v = atoi(value.c_str()); - // - // If -1 is the first value, no retry and wait intervals. - // - if(v == -1 && _retryIntervals.empty()) - { - break; - } + // + // If -1 is the first value, no retry and wait intervals. + // + if(v == -1 && _retryIntervals.empty()) + { + break; + } - _retryIntervals.push_back(v > 0 ? v : 0); + _retryIntervals.push_back(v > 0 ? v : 0); } } diff --git a/cppe/src/IceE/RecMutex.cpp b/cppe/src/IceE/RecMutex.cpp index 28528f31c4e..bf526d2b8a4 100644 --- a/cppe/src/IceE/RecMutex.cpp +++ b/cppe/src/IceE/RecMutex.cpp @@ -34,7 +34,7 @@ IceUtil::RecMutex::lock() const EnterCriticalSection(&_mutex); if(++_count > 1) { - LeaveCriticalSection(&_mutex); + LeaveCriticalSection(&_mutex); } } @@ -43,11 +43,11 @@ IceUtil::RecMutex::tryLock() const { if(!TryEnterCriticalSection(&_mutex)) { - return false; + return false; } if(++_count > 1) { - LeaveCriticalSection(&_mutex); + LeaveCriticalSection(&_mutex); } return true; } @@ -57,7 +57,7 @@ IceUtil::RecMutex::unlock() const { if(--_count == 0) { - LeaveCriticalSection(&_mutex); + LeaveCriticalSection(&_mutex); } } @@ -84,7 +84,7 @@ IceUtil::RecMutex::RecMutex() : _mutex = CreateMutex(0, false, 0); if(_mutex == 0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -94,7 +94,7 @@ IceUtil::RecMutex::~RecMutex() BOOL rc = CloseHandle(_mutex); if(rc == 0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -104,23 +104,23 @@ IceUtil::RecMutex::lock() const DWORD rc = WaitForSingleObject(_mutex, INFINITE); if(rc != WAIT_OBJECT_0) { - if(rc == WAIT_FAILED) - { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); - } - else - { - throw ThreadSyscallException(__FILE__, __LINE__, 0); - } + if(rc == WAIT_FAILED) + { + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + } + else + { + throw ThreadSyscallException(__FILE__, __LINE__, 0); + } } if(++_count > 1) { - BOOL rc2 = ReleaseMutex(_mutex); - if(rc2 == 0) - { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); - } + BOOL rc2 = ReleaseMutex(_mutex); + if(rc2 == 0) + { + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + } } } @@ -130,15 +130,15 @@ IceUtil::RecMutex::tryLock() const DWORD rc = WaitForSingleObject(_mutex, 0); if(rc != WAIT_OBJECT_0) { - return false; + return false; } if(++_count > 1) { - BOOL rc2 = ReleaseMutex(_mutex); - if(rc2 == 0) - { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); - } + BOOL rc2 = ReleaseMutex(_mutex); + if(rc2 == 0) + { + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + } } return true; } @@ -148,11 +148,11 @@ IceUtil::RecMutex::unlock() const { if(--_count == 0) { - BOOL rc = ReleaseMutex(_mutex); - if(rc == 0) - { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); - } + BOOL rc = ReleaseMutex(_mutex); + if(rc == 0) + { + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + } } } @@ -164,7 +164,7 @@ IceUtil::RecMutex::unlock(LockState& state) const BOOL rc = ReleaseMutex(_mutex); if(rc == 0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -174,14 +174,14 @@ IceUtil::RecMutex::lock(LockState& state) const DWORD rc = WaitForSingleObject(_mutex, INFINITE); if(rc != WAIT_OBJECT_0) { - if(rc == WAIT_FAILED) - { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); - } - else - { - throw ThreadSyscallException(__FILE__, __LINE__, 0); - } + if(rc == WAIT_FAILED) + { + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + } + else + { + throw ThreadSyscallException(__FILE__, __LINE__, 0); + } } _count = state.count; @@ -203,19 +203,19 @@ IceUtil::RecMutex::RecMutex() : rc = pthread_mutexattr_init(&attr); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } #endif rc = pthread_mutex_init(&_mutex, &attr); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } #if defined(__linux) && !defined(__USE_UNIX98) @@ -224,7 +224,7 @@ IceUtil::RecMutex::RecMutex() : rc = pthread_mutexattr_destroy(&attr); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } #endif } @@ -243,12 +243,12 @@ IceUtil::RecMutex::lock() const int rc = pthread_mutex_lock(&_mutex); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } if(++_count > 1) { - rc = pthread_mutex_unlock(&_mutex); - assert(rc == 0); + rc = pthread_mutex_unlock(&_mutex); + assert(rc == 0); } } @@ -259,18 +259,18 @@ IceUtil::RecMutex::tryLock() const bool result = (rc == 0); if(!result) { - if(rc != EBUSY) - { - throw ThreadSyscallException(__FILE__, __LINE__, rc); - } + if(rc != EBUSY) + { + throw ThreadSyscallException(__FILE__, __LINE__, rc); + } } else if(++_count > 1) { - rc = pthread_mutex_unlock(&_mutex); - if(rc != 0) - { - throw ThreadSyscallException(__FILE__, __LINE__, rc); - } + rc = pthread_mutex_unlock(&_mutex); + if(rc != 0) + { + throw ThreadSyscallException(__FILE__, __LINE__, rc); + } } return result; } @@ -280,9 +280,9 @@ IceUtil::RecMutex::unlock() const { if(--_count == 0) { - int rc = 0; // Prevent warnings when NDEBUG is defined. - rc = pthread_mutex_unlock(&_mutex); - assert(rc == 0); + int rc = 0; // Prevent warnings when NDEBUG is defined. + rc = pthread_mutex_unlock(&_mutex); + assert(rc == 0); } } diff --git a/cppe/src/IceE/Reference.cpp b/cppe/src/IceE/Reference.cpp index 1b10d06a667..1d780684b61 100644 --- a/cppe/src/IceE/Reference.cpp +++ b/cppe/src/IceE/Reference.cpp @@ -78,7 +78,7 @@ IceInternal::Reference::changeMode(ReferenceMode newMode) const { if(newMode == _mode) { - return ReferencePtr(const_cast<Reference*>(this)); + return ReferencePtr(const_cast<Reference*>(this)); } ReferencePtr r = _instance->referenceFactory()->copy(this); r->_mode = newMode; @@ -90,7 +90,7 @@ IceInternal::Reference::changeSecure(bool newSecure) const { if(newSecure == _secure) { - return ReferencePtr(const_cast<Reference*>(this)); + return ReferencePtr(const_cast<Reference*>(this)); } ReferencePtr r = _instance->referenceFactory()->copy(this); r->_secure = newSecure; @@ -102,7 +102,7 @@ IceInternal::Reference::changeIdentity(const Identity& newIdentity) const { if(newIdentity == _identity) { - return ReferencePtr(const_cast<Reference*>(this)); + return ReferencePtr(const_cast<Reference*>(this)); } ReferencePtr r = _instance->referenceFactory()->copy(this); r->_identity = newIdentity; @@ -114,7 +114,7 @@ IceInternal::Reference::changeFacet(const string& newFacet) const { if(newFacet == _facet) { - return ReferencePtr(const_cast<Reference*>(this)); + return ReferencePtr(const_cast<Reference*>(this)); } ReferencePtr r = _instance->referenceFactory()->copy(this); r->_facet = newFacet; @@ -126,7 +126,7 @@ IceInternal::Reference::changeTimeout(int newTimeout) const { if(_overrideTimeout && newTimeout == _timeout) { - return ReferencePtr(const_cast<Reference*>(this)); + return ReferencePtr(const_cast<Reference*>(this)); } ReferencePtr r = getInstance()->referenceFactory()->copy(this); r->_timeout = newTimeout; @@ -161,19 +161,19 @@ Reference::hash() const for(q = _context.begin(); q != _context.end(); ++q) { - for(p = q->first.begin(); p != q->first.end(); ++p) - { - h = 5 * h + *p; - } - for(p = q->second.begin(); p != q->second.end(); ++p) - { - h = 5 * h + *p; - } + for(p = q->first.begin(); p != q->first.end(); ++p) + { + h = 5 * h + *p; + } + for(p = q->second.begin(); p != q->second.end(); ++p) + { + h = 5 * h + *p; + } } for(p = _facet.begin(); p != _facet.end(); ++p) { - h = 5 * h + *p; + h = 5 * h + *p; } h = 5 * h + static_cast<Int>(getSecure()); @@ -197,11 +197,11 @@ IceInternal::Reference::streamWrite(BasicStream* s) const // if(_facet.empty()) { - s->write(static_cast<string*>(0), static_cast<string*>(0)); + s->write(static_cast<string*>(0), static_cast<string*>(0)); } else { - s->write(&_facet, &_facet + 1); + s->write(&_facet, &_facet + 1); } s->write(static_cast<Byte>(_mode)); @@ -225,7 +225,7 @@ IceInternal::Reference::toString() const if(id.find_first_of(" :@") != string::npos) { s += "\""; - s += id; + s += id; s += "\""; } else @@ -237,11 +237,11 @@ IceInternal::Reference::toString() const { s += " -f "; - // - // If the encoded facet string contains characters which - // the reference parser uses as separators, then we enclose - // the facet string in quotes. - // + // + // If the encoded facet string contains characters which + // the reference parser uses as separators, then we enclose + // the facet string in quotes. + // string fs = _facet; #ifdef ICEE_HAS_WSTRING if(_instance->initializationData().stringConverter) @@ -252,55 +252,55 @@ IceInternal::Reference::toString() const fs = string(reinterpret_cast<const char*>(buffer.getBuffer()), last - buffer.getBuffer()); } #endif - fs = IceUtil::escapeString(fs, ""); - if(fs.find_first_of(" :@") != string::npos) - { + fs = IceUtil::escapeString(fs, ""); + if(fs.find_first_of(" :@") != string::npos) + { s += "\""; - s += fs; + s += fs; s += "\""; - } - else - { - s += fs; - } + } + else + { + s += fs; + } } switch(_mode) { - case ReferenceModeTwoway: - { - s += " -t"; - break; - } - - case ReferenceModeOneway: - { - s += " -o"; - break; - } - - case ReferenceModeBatchOneway: - { - s += " -O"; - break; - } - - case ReferenceModeDatagram: - { - s += " -d"; - break; - } - - case ReferenceModeBatchDatagram: - { - s += " -D"; - break; - } + case ReferenceModeTwoway: + { + s += " -t"; + break; + } + + case ReferenceModeOneway: + { + s += " -o"; + break; + } + + case ReferenceModeBatchOneway: + { + s += " -O"; + break; + } + + case ReferenceModeDatagram: + { + s += " -d"; + break; + } + + case ReferenceModeBatchDatagram: + { + s += " -D"; + break; + } } if(getSecure()) { - s += " -s"; + s += " -s"; } return s; @@ -317,37 +317,37 @@ IceInternal::Reference::operator==(const Reference& r) const if(getType() != r.getType()) { - return false; + return false; } if(_mode != r._mode) { - return false; + return false; } if(_secure != r._secure) { - return false; + return false; } if(_identity != r._identity) { - return false; + return false; } if(_context != r._context) { - return false; + return false; } if(_facet != r._facet) { - return false; + return false; } if(_overrideTimeout != r._overrideTimeout || _overrideTimeout && _timeout != r._timeout) { - return false; + return false; } return true; @@ -362,83 +362,83 @@ IceInternal::Reference::operator<(const Reference& r) const if(_mode < r._mode) { - return true; + return true; } else if(r._mode < _mode) { - return false; + return false; } if(!_secure && r._secure) { - return true; + return true; } else if(r._secure < _secure) { - return false; + return false; } if(_identity < r._identity) { - return true; + return true; } else if(r._identity < _identity) { - return false; + return false; } if(_context < r._context) { - return true; + return true; } else if(r._context < _context) { - return false; + return false; } if(_facet < r._facet) { - return true; + return true; } else if(r._facet < _facet) { - return false; + return false; } if(!_overrideTimeout && r._overrideTimeout) { - return true; + return true; } else if(r._overrideTimeout < _overrideTimeout) { - return false; + return false; } else if(_overrideTimeout) { - if(_timeout < r._timeout) - { - return true; - } - else if(r._timeout < _timeout) - { - return false; - } + if(_timeout < r._timeout) + { + return true; + } + else if(r._timeout < _timeout) + { + return false; + } } if(getType() < r.getType()) { - return true; + return true; } else if(r.getType() < getType()) { - return false; + return false; } return false; } IceInternal::Reference::Reference(const InstancePtr& inst, const CommunicatorPtr& com, const Identity& ident, - const Context& context, const string& fs, ReferenceMode md, bool sec) : + const Context& context, const string& fs, ReferenceMode md, bool sec) : _hashInitialized(false), _instance(inst), _communicator(com), @@ -474,18 +474,18 @@ IceInternal::Reference::applyOverrides(vector<EndpointPtr>& endpts) const // for(vector<EndpointPtr>::iterator p = endpts.begin(); p != endpts.end(); ++p) { - if(_overrideTimeout) - { - *p = (*p)->timeout(_timeout); - } + if(_overrideTimeout) + { + *p = (*p)->timeout(_timeout); + } } } IceUtil::Shared* IceInternal::upCast(IceInternal::FixedReference* p) { return p; } IceInternal::FixedReference::FixedReference(const InstancePtr& inst, const CommunicatorPtr& com, const Identity& ident, - const Context& context, const string& fs, ReferenceMode md, - const vector<ConnectionPtr>& fixedConns) : + const Context& context, const string& fs, ReferenceMode md, + const vector<ConnectionPtr>& fixedConns) : Reference(inst, com, ident, context, fs, md, false), _fixedConnections(fixedConns) { @@ -594,9 +594,9 @@ IceInternal::FixedReference::getConnection() const #ifndef ICEE_HAS_BATCH case ReferenceModeBatchDatagram: case ReferenceModeBatchOneway: - { - throw FeatureNotSupportedException(__FILE__, __LINE__, "batch proxy mode"); - } + { + throw FeatureNotSupportedException(__FILE__, __LINE__, "batch proxy mode"); + } #endif } @@ -619,28 +619,28 @@ IceInternal::FixedReference::getConnection() const vector<ConnectionPtr> secureConnections; while(p != connections.end()) { - if((*p)->endpoint()->secure()) - { - secureConnections.push_back(*p); - p = connections.erase(p); - } - else - { - ++p; - } + if((*p)->endpoint()->secure()) + { + secureConnections.push_back(*p); + p = connections.erase(p); + } + else + { + ++p; + } } if(getSecure()) { - connections.swap(secureConnections); + connections.swap(secureConnections); } else { - connections.insert(connections.end(), secureConnections.begin(), secureConnections.end()); + connections.insert(connections.end(), secureConnections.begin(), secureConnections.end()); } if(connections.empty()) { - throw NoEndpointException(__FILE__, __LINE__); // No stringified representation for fixed proxies. + throw NoEndpointException(__FILE__, __LINE__); // No stringified representation for fixed proxies. } ConnectionPtr connection = connections[0]; @@ -680,7 +680,7 @@ IceInternal::FixedReference::operator<(const Reference& r) const { const FixedReference* rhs = dynamic_cast<const FixedReference*>(&r); assert(rhs); - return _fixedConnections < rhs->_fixedConnections; + return _fixedConnections < rhs->_fixedConnections; } return false; } @@ -706,10 +706,10 @@ IceInternal::RoutableReference::getRoutedEndpoints() const if(_routerInfo) { // - // If we route, we send everything to the router's client - // proxy endpoints. - // - return _routerInfo->getClientEndpoints(); + // If we route, we send everything to the router's client + // proxy endpoints. + // + return _routerInfo->getClientEndpoints(); } return vector<EndpointPtr>(); } @@ -720,7 +720,7 @@ IceInternal::RoutableReference::changeRouter(const RouterPrx& newRouter) const RouterInfoPtr newRouterInfo = getInstance()->routerManager()->get(newRouter); if(newRouterInfo == _routerInfo) { - return RoutableReferencePtr(const_cast<RoutableReference*>(this)); + return RoutableReferencePtr(const_cast<RoutableReference*>(this)); } RoutableReferencePtr r = RoutableReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this)); r->_routerInfo = newRouterInfo; @@ -763,14 +763,14 @@ IceInternal::RoutableReference::operator<(const Reference& r) const { const RoutableReference* rhs = dynamic_cast<const RoutableReference*>(&r); assert(rhs); - return _routerInfo < rhs->_routerInfo; + return _routerInfo < rhs->_routerInfo; } return false; } IceInternal::RoutableReference::RoutableReference(const InstancePtr& inst, const CommunicatorPtr& com, - const Identity& ident, const Context& context, const string& fs, - ReferenceMode md, bool sec, const RouterInfoPtr& rtrInfo) : + const Identity& ident, const Context& context, const string& fs, + ReferenceMode md, bool sec, const RouterInfoPtr& rtrInfo) : Reference(inst, com, ident, context, fs, md, sec), _routerInfo(rtrInfo) { } @@ -786,9 +786,9 @@ IceUtil::Shared* IceInternal::upCast(IceInternal::DirectReference* p) { return p #ifdef ICEE_HAS_ROUTER IceInternal::DirectReference::DirectReference(const InstancePtr& inst, const CommunicatorPtr& com, - const Identity& ident, const Context& context, const string& fs, ReferenceMode md, - bool sec, const vector<EndpointPtr>& endpts, - const RouterInfoPtr& rtrInfo) : + const Identity& ident, const Context& context, const string& fs, ReferenceMode md, + bool sec, const vector<EndpointPtr>& endpts, + const RouterInfoPtr& rtrInfo) : RoutableReference(inst, com, ident, context, fs, md, sec, rtrInfo), _endpoints(endpts) @@ -796,8 +796,8 @@ IceInternal::DirectReference::DirectReference(const InstancePtr& inst, const Com } #else IceInternal::DirectReference::DirectReference(const InstancePtr& inst, const CommunicatorPtr& com, - const Identity& ident, const Context& context, const string& fs, ReferenceMode md, - bool sec, const vector<EndpointPtr>& endpts) : + const Identity& ident, const Context& context, const string& fs, ReferenceMode md, + bool sec, const vector<EndpointPtr>& endpts) : Reference(inst, com, ident, context, fs, md, sec), _endpoints(endpts) { @@ -834,7 +834,7 @@ DirectReference::changeAdapterId(const string& newAdapterId) const return getInstance()->referenceFactory()->create(getIdentity(), *getContext(), getFacet(), getMode(), getSecure(), newAdapterId, #ifdef ICEE_HAS_ROUTER - getRouterInfo(), + getRouterInfo(), #endif locatorInfo); } @@ -858,12 +858,12 @@ IceInternal::DirectReference::changeTimeout(int newTimeout) const DirectReferencePtr r = DirectReferencePtr::dynamicCast(Parent::changeTimeout(newTimeout)); if(r.get() != this) // Also override the timeout on the endpoints if it was updated. { - vector<EndpointPtr> newEndpoints; - for(vector<EndpointPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p) - { - newEndpoints.push_back((*p)->timeout(newTimeout)); - } - r->_endpoints = newEndpoints; + vector<EndpointPtr> newEndpoints; + for(vector<EndpointPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p) + { + newEndpoints.push_back((*p)->timeout(newTimeout)); + } + r->_endpoints = newEndpoints; } return r; } @@ -877,14 +877,14 @@ IceInternal::DirectReference::streamWrite(BasicStream* s) const s->writeSize(sz); if(sz) { - for(vector<EndpointPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p) - { - (*p)->streamWrite(s); - } + for(vector<EndpointPtr>::const_iterator p = _endpoints.begin(); p != _endpoints.end(); ++p) + { + (*p)->streamWrite(s); + } } else { - s->write(string("")); // Adapter id. + s->write(string("")); // Adapter id. } } @@ -896,12 +896,12 @@ IceInternal::DirectReference::toString() const vector<EndpointPtr>::const_iterator p; for(p = _endpoints.begin(); p != _endpoints.end(); ++p) { - string endp = (*p)->toString(); - if(!endp.empty()) - { - result.append(":"); - result.append(endp); - } + string endp = (*p)->toString(); + if(!endp.empty()) + { + result.append(":"); + result.append(endp); + } } return result; } @@ -915,7 +915,7 @@ IceInternal::DirectReference::getConnection() const if(endpts.empty()) { - endpts = _endpoints; // Endpoint overrides are already applied on these endpoints. + endpts = _endpoints; // Endpoint overrides are already applied on these endpoints. } #else vector<EndpointPtr> endpts = _endpoints; @@ -975,8 +975,8 @@ IceInternal::DirectReference::operator<(const Reference& r) const if(Parent::operator==(r)) { const DirectReference* rhs = dynamic_cast<const DirectReference*>(&r); - assert(rhs); - return _endpoints < rhs->_endpoints; + assert(rhs); + return _endpoints < rhs->_endpoints; } return false; } @@ -998,9 +998,9 @@ IceUtil::Shared* IceInternal::upCast(IceInternal::IndirectReference* p) { return #ifdef ICEE_HAS_ROUTER IceInternal::IndirectReference::IndirectReference(const InstancePtr& inst, const CommunicatorPtr& com, - const Identity& ident, const Context& context, const string& fs, - ReferenceMode md, bool sec, const string& adptid, - const RouterInfoPtr& rtrInfo, const LocatorInfoPtr& locInfo) : + const Identity& ident, const Context& context, const string& fs, + ReferenceMode md, bool sec, const string& adptid, + const RouterInfoPtr& rtrInfo, const LocatorInfoPtr& locInfo) : RoutableReference(inst, com, ident, context, fs, md, sec, rtrInfo), _adapterId(adptid), _locatorInfo(locInfo) @@ -1008,9 +1008,9 @@ IceInternal::IndirectReference::IndirectReference(const InstancePtr& inst, const } #else IceInternal::IndirectReference::IndirectReference(const InstancePtr& inst, const CommunicatorPtr& com, - const Identity& ident, const Context& context, const string& fs, - ReferenceMode md, bool sec, const string& adptid, - const LocatorInfoPtr& locInfo) : + const Identity& ident, const Context& context, const string& fs, + ReferenceMode md, bool sec, const string& adptid, + const LocatorInfoPtr& locInfo) : Reference(inst, com, ident, context, fs, md, sec), _adapterId(adptid), _locatorInfo(locInfo) @@ -1054,7 +1054,7 @@ IceInternal::IndirectReference::changeLocator(const LocatorPrx& newLocator) cons LocatorInfoPtr newLocatorInfo = getInstance()->locatorManager()->get(newLocator); if(newLocatorInfo == _locatorInfo) { - return IndirectReferencePtr(const_cast<IndirectReference*>(this)); + return IndirectReferencePtr(const_cast<IndirectReference*>(this)); } IndirectReferencePtr r = IndirectReferencePtr::dynamicCast(getInstance()->referenceFactory()->copy(this)); r->_locatorInfo = newLocatorInfo; @@ -1098,13 +1098,13 @@ IceInternal::IndirectReference::toString() const a = IceUtil::escapeString(a, ""); if(a.find_first_of(" ") != string::npos) { - result.append("\""); - result.append(a); - result.append("\""); + result.append("\""); + result.append(a); + result.append("\""); } else { - result.append(_adapterId); + result.append(_adapterId); } return result; } @@ -1117,58 +1117,58 @@ IceInternal::IndirectReference::getConnection() const while(true) { #ifdef ICEE_HAS_ROUTER - vector<EndpointPtr> endpts = Parent::getRoutedEndpoints(); + vector<EndpointPtr> endpts = Parent::getRoutedEndpoints(); #else - vector<EndpointPtr> endpts; + vector<EndpointPtr> endpts; #endif - bool cached = false; - if(endpts.empty() && _locatorInfo) - { - const IndirectReferencePtr self = const_cast<IndirectReference*>(this); - endpts = _locatorInfo->getEndpoints(self, cached); - } - - applyOverrides(endpts); - - vector<EndpointPtr> filteredEndpoints = filterEndpoints(endpts, getMode(), getSecure()); - if(filteredEndpoints.empty()) - { - throw NoEndpointException(__FILE__, __LINE__, toString()); - } - - try - { - OutgoingConnectionFactoryPtr factory = getInstance()->outgoingConnectionFactory(); - connection = factory->create(filteredEndpoints); - assert(connection); - } - catch(const LocalException& ex) - { + bool cached = false; + if(endpts.empty() && _locatorInfo) + { + const IndirectReferencePtr self = const_cast<IndirectReference*>(this); + endpts = _locatorInfo->getEndpoints(self, cached); + } + + applyOverrides(endpts); + + vector<EndpointPtr> filteredEndpoints = filterEndpoints(endpts, getMode(), getSecure()); + if(filteredEndpoints.empty()) + { + throw NoEndpointException(__FILE__, __LINE__, toString()); + } + + try + { + OutgoingConnectionFactoryPtr factory = getInstance()->outgoingConnectionFactory(); + connection = factory->create(filteredEndpoints); + assert(connection); + } + catch(const LocalException& ex) + { #ifdef ICEE_HAS_ROUTER - if(!getRouterInfo()) + if(!getRouterInfo()) #endif - { - assert(_locatorInfo); - const IndirectReferencePtr self = const_cast<IndirectReference*>(this); - _locatorInfo->clearCache(self); - - if(cached) - { - TraceLevelsPtr traceLevels = getInstance()->traceLevels(); - if(traceLevels->retry >= 2) - { - Trace out(getInstance()->initializationData().logger, traceLevels->retryCat); - out << "connection to cached endpoints failed\n" - << "removing endpoints from cache and trying one more time\n" << ex.toString(); - } - continue; - } - } - - throw; - } - - break; + { + assert(_locatorInfo); + const IndirectReferencePtr self = const_cast<IndirectReference*>(this); + _locatorInfo->clearCache(self); + + if(cached) + { + TraceLevelsPtr traceLevels = getInstance()->traceLevels(); + if(traceLevels->retry >= 2) + { + Trace out(getInstance()->initializationData().logger, traceLevels->retryCat); + out << "connection to cached endpoints failed\n" + << "removing endpoints from cache and trying one more time\n" << ex.toString(); + } + continue; + } + } + + throw; + } + + break; } #if defined(ICEE_HAS_ROUTER) && !defined(ICEE_PURE_CLIENT) @@ -1238,16 +1238,16 @@ IceInternal::IndirectReference::operator<(const Reference& r) const if(Parent::operator==(r)) { const IndirectReference* rhs = dynamic_cast<const IndirectReference*>(&r); - assert(rhs); - if(_adapterId < rhs->_adapterId) - { - return true; - } - else if(rhs->_adapterId < _adapterId) - { - return false; - } - return _locatorInfo < rhs->_locatorInfo; + assert(rhs); + if(_adapterId < rhs->_adapterId) + { + return true; + } + else if(rhs->_adapterId < _adapterId) + { + return false; + } + return _locatorInfo < rhs->_locatorInfo; } return false; } @@ -1305,18 +1305,18 @@ IceInternal::filterEndpoints(const vector<EndpointPtr>& allEndpoints, ReferenceM // // Filter out non-datagram endpoints. // - endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), - not1(Ice::constMemFun(&Endpoint::datagram))), - endpoints.end()); + endpoints.erase(remove_if(endpoints.begin(), endpoints.end(), + not1(Ice::constMemFun(&Endpoint::datagram))), + endpoints.end()); break; } #ifndef ICEE_HAS_BATCH case ReferenceModeBatchDatagram: case ReferenceModeBatchOneway: - { - throw FeatureNotSupportedException(__FILE__, __LINE__, "batch proxy mode"); - } + { + throw FeatureNotSupportedException(__FILE__, __LINE__, "batch proxy mode"); + } #endif } @@ -1339,23 +1339,23 @@ IceInternal::filterEndpoints(const vector<EndpointPtr>& allEndpoints, ReferenceM vector<EndpointPtr> secureEndpoints; while(p != endpoints.end()) { - if((*p)->secure()) - { - secureEndpoints.push_back(*p); - p = endpoints.erase(p); - } - else - { - ++p; - } + if((*p)->secure()) + { + secureEndpoints.push_back(*p); + p = endpoints.erase(p); + } + else + { + ++p; + } } if(sec) { - endpoints.swap(secureEndpoints); + endpoints.swap(secureEndpoints); } else { - endpoints.insert(endpoints.end(), secureEndpoints.begin(), secureEndpoints.end()); + endpoints.insert(endpoints.end(), secureEndpoints.begin(), secureEndpoints.end()); } return endpoints; diff --git a/cppe/src/IceE/Reference.h b/cppe/src/IceE/Reference.h index 443799e6582..933c4ac4330 100644 --- a/cppe/src/IceE/Reference.h +++ b/cppe/src/IceE/Reference.h @@ -38,9 +38,9 @@ public: enum Type { - TypeDirect, - TypeIndirect, - TypeFixed + TypeDirect, + TypeIndirect, + TypeFixed }; // @@ -49,12 +49,12 @@ public: // // enum Mode // { -// ModeTwoway, -// ModeOneway, -// ModeBatchOneway, -// ModeDatagram, -// ModeBatchDatagram, -// ModeLast = ModeBatchDatagram +// ModeTwoway, +// ModeOneway, +// ModeBatchOneway, +// ModeDatagram, +// ModeBatchDatagram, +// ModeLast = ModeBatchDatagram // }; ReferenceMode getMode() const { return _mode; } @@ -122,7 +122,7 @@ public: protected: Reference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const Ice::Context&, - const std::string&, ReferenceMode, bool); + const std::string&, ReferenceMode, bool); Reference(const Reference&); void applyOverrides(std::vector<EndpointPtr>&) const; @@ -158,7 +158,7 @@ class FixedReference : public Reference public: FixedReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const Ice::Context&, - const std::string&, ReferenceMode, const std::vector<Ice::ConnectionPtr>&); + const std::string&, ReferenceMode, const std::vector<Ice::ConnectionPtr>&); virtual Type getType() const; virtual std::vector<EndpointPtr> getEndpoints() const; @@ -214,7 +214,7 @@ public: protected: RoutableReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const Ice::Context&, - const std::string&, ReferenceMode, bool, const RouterInfoPtr&); + const std::string&, ReferenceMode, bool, const RouterInfoPtr&); RoutableReference(const RoutableReference&); @@ -234,11 +234,11 @@ class DirectReference : public: DirectReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const Ice::Context&, - const std::string&, ReferenceMode, bool, const std::vector<EndpointPtr>& + const std::string&, ReferenceMode, bool, const std::vector<EndpointPtr>& #ifdef ICEE_HAS_ROUTER - , const RouterInfoPtr& + , const RouterInfoPtr& #endif - ); + ); virtual Type getType() const; virtual std::vector<EndpointPtr> getEndpoints() const; @@ -286,11 +286,11 @@ class IndirectReference : public: IndirectReference(const InstancePtr&, const Ice::CommunicatorPtr&, const Ice::Identity&, const Ice::Context&, - const std::string&, ReferenceMode, bool, const std::string& + const std::string&, ReferenceMode, bool, const std::string& #ifdef ICEE_HAS_ROUTER - , const RouterInfoPtr& + , const RouterInfoPtr& #endif - , const LocatorInfoPtr&); + , const LocatorInfoPtr&); virtual LocatorInfoPtr getLocatorInfo() const { return _locatorInfo; } diff --git a/cppe/src/IceE/ReferenceFactory.cpp b/cppe/src/IceE/ReferenceFactory.cpp index 9667390915a..1820be6c1a1 100644 --- a/cppe/src/IceE/ReferenceFactory.cpp +++ b/cppe/src/IceE/ReferenceFactory.cpp @@ -39,7 +39,7 @@ IceInternal::ReferenceFactory::copy(const Reference* r) const if(!_instance) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } const Ice::Identity& ident = r->getIdentity(); @@ -53,21 +53,21 @@ IceInternal::ReferenceFactory::copy(const Reference* r) const ReferencePtr IceInternal::ReferenceFactory::create(const Identity& ident, - const Context& context, - const string& facet, - ReferenceMode mode, - bool secure, - const vector<EndpointPtr>& endpoints + const Context& context, + const string& facet, + ReferenceMode mode, + bool secure, + const vector<EndpointPtr>& endpoints #ifdef ICEE_HAS_ROUTER - , const RouterInfoPtr& routerInfo + , const RouterInfoPtr& routerInfo #endif - ) + ) { Mutex::Lock sync(*this); if(!_instance) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } if(ident.name.empty() && ident.category.empty()) @@ -89,21 +89,21 @@ IceInternal::ReferenceFactory::create(const Identity& ident, ReferencePtr IceInternal::ReferenceFactory::create(const Identity& ident, - const Context& context, - const string& facet, - ReferenceMode mode, - bool secure, - const string& adapterId + const Context& context, + const string& facet, + ReferenceMode mode, + bool secure, + const string& adapterId #ifdef ICEE_HAS_ROUTER - , const RouterInfoPtr& routerInfo + , const RouterInfoPtr& routerInfo #endif - , const LocatorInfoPtr& locatorInfo) + , const LocatorInfoPtr& locatorInfo) { Mutex::Lock sync(*this); if(!_instance) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } if(ident.name.empty() && ident.category.empty()) @@ -116,7 +116,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, // #ifdef ICEE_HAS_ROUTER return new IndirectReference(_instance, _communicator, ident, context, facet, mode, secure, adapterId, routerInfo, - locatorInfo); + locatorInfo); #else return new IndirectReference(_instance, _communicator, ident, context, facet, mode, secure, adapterId, locatorInfo); #endif @@ -126,16 +126,16 @@ IceInternal::ReferenceFactory::create(const Identity& ident, ReferencePtr IceInternal::ReferenceFactory::create(const Identity& ident, - const Context& context, - const string& facet, - ReferenceMode mode, - const vector<Ice::ConnectionPtr>& fixedConnections) + const Context& context, + const string& facet, + ReferenceMode mode, + const vector<Ice::ConnectionPtr>& fixedConnections) { Mutex::Lock sync(*this); if(!_instance) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } if(ident.name.empty() && ident.category.empty()) @@ -166,7 +166,7 @@ IceInternal::ReferenceFactory::create(const string& str) beg = s.find_first_not_of(delim, end); if(beg == string::npos) { - throw ProxyParseException(__FILE__, __LINE__, str); + throw ProxyParseException(__FILE__, __LINE__, str); } // @@ -177,7 +177,7 @@ IceInternal::ReferenceFactory::create(const string& str) end = IceUtil::checkQuote(s, beg); if(end == string::npos) { - throw ProxyParseException(__FILE__, __LINE__, str); + throw ProxyParseException(__FILE__, __LINE__, str); } else if(end == 0) { @@ -197,7 +197,7 @@ IceInternal::ReferenceFactory::create(const string& str) if(beg == end) { - throw ProxyParseException(__FILE__, __LINE__, str); + throw ProxyParseException(__FILE__, __LINE__, str); } // @@ -238,50 +238,50 @@ IceInternal::ReferenceFactory::create(const string& str) while(true) { - beg = s.find_first_not_of(delim, end); - if(beg == string::npos) - { - break; - } + beg = s.find_first_not_of(delim, end); + if(beg == string::npos) + { + break; + } if(s[beg] == ':' || s[beg] == '@') { break; } - end = s.find_first_of(delim + ":@", beg); - if(end == string::npos) - { - end = s.length(); - } - - if(beg == end) - { - break; - } - - string option = s.substr(beg, end - beg); - if(option.length() != 2 || option[0] != '-') - { + end = s.find_first_of(delim + ":@", beg); + if(end == string::npos) + { + end = s.length(); + } + + if(beg == end) + { + break; + } + + string option = s.substr(beg, end - beg); + if(option.length() != 2 || option[0] != '-') + { throw ProxyParseException(__FILE__, __LINE__, str); - } + } // // Check for the presence of an option argument. The // argument may be enclosed in single or double // quotation marks. // - string argument; - string::size_type argumentBeg = s.find_first_not_of(delim, end); - if(argumentBeg != string::npos) - { + string argument; + string::size_type argumentBeg = s.find_first_not_of(delim, end); + if(argumentBeg != string::npos) + { if(s[argumentBeg] != '@' && s[argumentBeg] != ':' && s[argumentBeg] != '-') { beg = argumentBeg; end = IceUtil::checkQuote(s, beg); if(end == string::npos) { - throw ProxyParseException(__FILE__, __LINE__, str); + throw ProxyParseException(__FILE__, __LINE__, str); } else if(end == 0) { @@ -298,26 +298,26 @@ IceInternal::ReferenceFactory::create(const string& str) argument = s.substr(beg, end - beg); end++; // Skip trailing quote } - } - } - - // - // If any new options are added here, - // IceInternal::Reference::toString() and its derived classes must be updated as well. - // - switch(option[1]) - { - case 'f': - { - if(argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - - if(!IceUtil::unescapeString(argument, 0, argument.size(), facet)) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } + } + } + + // + // If any new options are added here, + // IceInternal::Reference::toString() and its derived classes must be updated as well. + // + switch(option[1]) + { + case 'f': + { + if(argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + + if(!IceUtil::unescapeString(argument, 0, argument.size(), facet)) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } #ifdef ICEE_HAS_WSTRING if(_instance->initializationData().stringConverter) { @@ -328,74 +328,74 @@ IceInternal::ReferenceFactory::create(const string& str) facet = tmpFacet; } #endif - break; - } - - case 't': - { - if(!argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - mode = ReferenceModeTwoway; - break; - } - - case 'o': - { - if(!argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - mode = ReferenceModeOneway; - break; - } - - case 'O': - { - if(!argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - mode = ReferenceModeBatchOneway; - break; - } - - case 'd': - { - if(!argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - mode = ReferenceModeDatagram; - break; - } - - case 'D': - { - if(!argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - mode = ReferenceModeBatchDatagram; - break; - } - - case 's': - { - if(!argument.empty()) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - secure = true; - break; - } - - default: - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - } + break; + } + + case 't': + { + if(!argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + mode = ReferenceModeTwoway; + break; + } + + case 'o': + { + if(!argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + mode = ReferenceModeOneway; + break; + } + + case 'O': + { + if(!argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + mode = ReferenceModeBatchOneway; + break; + } + + case 'd': + { + if(!argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + mode = ReferenceModeDatagram; + break; + } + + case 'D': + { + if(!argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + mode = ReferenceModeBatchDatagram; + break; + } + + case 's': + { + if(!argument.empty()) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + secure = true; + break; + } + + default: + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + } } #ifdef ICEE_HAS_ROUTER @@ -409,111 +409,111 @@ IceInternal::ReferenceFactory::create(const string& str) { #ifdef ICEE_HAS_LOCATOR # ifdef ICEE_HAS_ROUTER - return create(ident, Ice::Context(), facet, mode, secure, "", routerInfo, locatorInfo); + return create(ident, Ice::Context(), facet, mode, secure, "", routerInfo, locatorInfo); # else - return create(ident, Ice::Context(), facet, mode, secure, "", locatorInfo); + return create(ident, Ice::Context(), facet, mode, secure, "", locatorInfo); # endif -#else +#else throw FeatureNotSupportedException(__FILE__, __LINE__, - "indirect proxy `" + str + "' (no locator support built-in)"); + "indirect proxy `" + str + "' (no locator support built-in)"); #endif } vector<EndpointPtr> endpoints; switch(s[beg]) { - case ':': - { - vector<string> unknownEndpoints; - end = beg; - - while(end < s.length() && s[end] == ':') - { - beg = end + 1; - - end = s.find(':', beg); - if(end == string::npos) - { - end = s.length(); - } - - string es = s.substr(beg, end - beg); - EndpointPtr endp = _instance->endpointFactory()->create(es); - if(endp != 0) - { - vector<EndpointPtr> endps = endp->expand(false); - endpoints.insert(endpoints.end(), endps.begin(), endps.end()); - } - else - { - unknownEndpoints.push_back(es); - } - } - if(endpoints.size() == 0) - { - throw EndpointParseException(__FILE__, __LINE__, unknownEndpoints.front()); - } - else if(unknownEndpoints.size() != 0 && - _instance->initializationData().properties->getPropertyAsIntWithDefault( - "Ice.Warn.Endpoints", 1) > 0) - { - Warning out(_instance->initializationData().logger); - out << "Proxy contains unknown endpoints:"; - for(unsigned int idx = 0; idx < unknownEndpoints.size(); ++idx) - { - out << " `" << unknownEndpoints[idx] << "'"; - } - } + case ':': + { + vector<string> unknownEndpoints; + end = beg; + + while(end < s.length() && s[end] == ':') + { + beg = end + 1; + + end = s.find(':', beg); + if(end == string::npos) + { + end = s.length(); + } + + string es = s.substr(beg, end - beg); + EndpointPtr endp = _instance->endpointFactory()->create(es); + if(endp != 0) + { + vector<EndpointPtr> endps = endp->expand(false); + endpoints.insert(endpoints.end(), endps.begin(), endps.end()); + } + else + { + unknownEndpoints.push_back(es); + } + } + if(endpoints.size() == 0) + { + throw EndpointParseException(__FILE__, __LINE__, unknownEndpoints.front()); + } + else if(unknownEndpoints.size() != 0 && + _instance->initializationData().properties->getPropertyAsIntWithDefault( + "Ice.Warn.Endpoints", 1) > 0) + { + Warning out(_instance->initializationData().logger); + out << "Proxy contains unknown endpoints:"; + for(unsigned int idx = 0; idx < unknownEndpoints.size(); ++idx) + { + out << " `" << unknownEndpoints[idx] << "'"; + } + } #ifdef ICEE_HAS_ROUTER - return create(ident, Ice::Context(), facet, mode, secure, endpoints, routerInfo); + return create(ident, Ice::Context(), facet, mode, secure, endpoints, routerInfo); #else - return create(ident, Ice::Context(), facet, mode, secure, endpoints); + return create(ident, Ice::Context(), facet, mode, secure, endpoints); #endif - break; - } + break; + } - case '@': - { + case '@': + { #ifdef ICEE_HAS_LOCATOR - beg = s.find_first_not_of(delim, beg + 1); - if(beg == string::npos) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } + beg = s.find_first_not_of(delim, beg + 1); + if(beg == string::npos) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } string adapterstr; - end = IceUtil::checkQuote(s, beg); - if(end == string::npos) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } - else if(end == 0) - { - end = s.find_first_of(delim, beg); - if(end == string::npos) - { - end = s.size(); - } + end = IceUtil::checkQuote(s, beg); + if(end == string::npos) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } + else if(end == 0) + { + end = s.find_first_of(delim, beg); + if(end == string::npos) + { + end = s.size(); + } adapterstr = s.substr(beg, end - beg); - } - else - { - beg++; // Skip leading quote + } + else + { + beg++; // Skip leading quote adapterstr = s.substr(beg, end - beg); end++; // Skip trailing quote. - } + } // Check for trailing whitespace. if(end != string::npos && s.find_first_not_of(delim, end) != string::npos) { - throw ProxyParseException(__FILE__, __LINE__, str); + throw ProxyParseException(__FILE__, __LINE__, str); } - if(!IceUtil::unescapeString(adapterstr, 0, adapterstr.size(), adapter) || adapter.size() == 0) - { - throw ProxyParseException(__FILE__, __LINE__, str); - } + if(!IceUtil::unescapeString(adapterstr, 0, adapterstr.size(), adapter) || adapter.size() == 0) + { + throw ProxyParseException(__FILE__, __LINE__, str); + } #ifdef ICEE_HAS_WSTRING if(_instance->initializationData().stringConverter) { @@ -526,21 +526,21 @@ IceInternal::ReferenceFactory::create(const string& str) #endif #ifdef ICEE_HAS_ROUTER - return create(ident, Ice::Context(), facet, mode, secure, adapter, routerInfo, locatorInfo); + return create(ident, Ice::Context(), facet, mode, secure, adapter, routerInfo, locatorInfo); #else - return create(ident, Ice::Context(), facet, mode, secure, adapter, locatorInfo); + return create(ident, Ice::Context(), facet, mode, secure, adapter, locatorInfo); #endif #else throw FeatureNotSupportedException(__FILE__, __LINE__, - "indirect proxy `" + str + "' (no locator support built-in)"); + "indirect proxy `" + str + "' (no locator support built-in)"); #endif - break; - } + break; + } - default: - { - throw ProxyParseException(__FILE__, __LINE__, str); - } + default: + { + throw ProxyParseException(__FILE__, __LINE__, str); + } } return 0; // Unreachable, fixes compiler warning. @@ -603,7 +603,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s) if(ident.name.empty() && ident.category.empty()) { - return 0; + return 0; } // @@ -614,11 +614,11 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s) string facet; if(!facetPath.empty()) { - if(facetPath.size() > 1) - { - throwProxyUnmarshalException(__FILE__, __LINE__); - } - facet.swap(facetPath[0]); + if(facetPath.size() > 1) + { + throwProxyUnmarshalException(__FILE__, __LINE__); + } + facet.swap(facetPath[0]); } Byte modeAsByte; @@ -626,7 +626,7 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s) ReferenceMode mode = static_cast<ReferenceMode>(modeAsByte); if(mode < 0 || mode > ReferenceModeLast) { - throwProxyUnmarshalException(__FILE__, __LINE__); + throwProxyUnmarshalException(__FILE__, __LINE__); } vector<EndpointPtr> endpoints; @@ -644,30 +644,30 @@ IceInternal::ReferenceFactory::create(const Identity& ident, BasicStream* s) if(sz > 0) { - endpoints.reserve(sz); - while(sz--) - { - EndpointPtr endpoint = _instance->endpointFactory()->read(s); - endpoints.push_back(endpoint); - } + endpoints.reserve(sz); + while(sz--) + { + EndpointPtr endpoint = _instance->endpointFactory()->read(s); + endpoints.push_back(endpoint); + } #ifdef ICEE_HAS_ROUTER - return create(ident, Ice::Context(), facet, mode, secure, endpoints, routerInfo); + return create(ident, Ice::Context(), facet, mode, secure, endpoints, routerInfo); #else - return create(ident, Ice::Context(), facet, mode, secure, endpoints); + return create(ident, Ice::Context(), facet, mode, secure, endpoints); #endif } else { #ifdef ICEE_HAS_LOCATOR - LocatorInfoPtr locatorInfo = _instance->locatorManager()->get(getDefaultLocator()); - s->read(adapterId); + LocatorInfoPtr locatorInfo = _instance->locatorManager()->get(getDefaultLocator()); + s->read(adapterId); # ifdef ICEE_HAS_ROUTER - return create(ident, Ice::Context(), facet, mode, secure, adapterId, routerInfo, locatorInfo); + return create(ident, Ice::Context(), facet, mode, secure, adapterId, routerInfo, locatorInfo); # else - return create(ident, Ice::Context(), facet, mode, secure, adapterId, locatorInfo); + return create(ident, Ice::Context(), facet, mode, secure, adapterId, locatorInfo); # endif #else - throwProxyUnmarshalException(__FILE__, __LINE__); + throwProxyUnmarshalException(__FILE__, __LINE__); return 0; // Unreachable, fixes compiler warning. #endif } @@ -710,7 +710,7 @@ IceInternal::ReferenceFactory::getDefaultLocator() const #endif IceInternal::ReferenceFactory::ReferenceFactory(const InstancePtr& instance, - const CommunicatorPtr& communicator) : + const CommunicatorPtr& communicator) : _instance(instance), _communicator(communicator) { @@ -723,7 +723,7 @@ IceInternal::ReferenceFactory::destroy() if(!_instance) { - throw CommunicatorDestroyedException(__FILE__, __LINE__); + throw CommunicatorDestroyedException(__FILE__, __LINE__); } _instance = 0; diff --git a/cppe/src/IceE/ReferenceFactory.h b/cppe/src/IceE/ReferenceFactory.h index 4127e453deb..d3f1ce82b3d 100644 --- a/cppe/src/IceE/ReferenceFactory.h +++ b/cppe/src/IceE/ReferenceFactory.h @@ -34,19 +34,19 @@ public: ReferencePtr create(const ::Ice::Identity&, const Ice::Context&, const ::std::string&, ReferenceMode, bool, const ::std::vector<EndpointPtr>& #ifdef ICEE_HAS_ROUTER - , const RouterInfoPtr& + , const RouterInfoPtr& #endif - ); + ); // // Create an indirect reference. // #ifdef ICEE_HAS_LOCATOR ReferencePtr create(const ::Ice::Identity&, const Ice::Context&, const ::std::string&, ReferenceMode, bool, - const ::std::string& + const ::std::string& #ifdef ICEE_HAS_ROUTER - , const RouterInfoPtr& + , const RouterInfoPtr& #endif - , const LocatorInfoPtr&); + , const LocatorInfoPtr&); #endif // // Create a fixed reference. diff --git a/cppe/src/IceE/RouterInfo.cpp b/cppe/src/IceE/RouterInfo.cpp index 508c93387e6..c96d1ff2acb 100644 --- a/cppe/src/IceE/RouterInfo.cpp +++ b/cppe/src/IceE/RouterInfo.cpp @@ -46,7 +46,7 @@ IceInternal::RouterManager::get(const RouterPrx& rtr) { if(!rtr) { - return 0; + return 0; } RouterPrx router = RouterPrx::uncheckedCast(rtr->ice_router(0)); // The router cannot be routed. @@ -57,24 +57,24 @@ IceInternal::RouterManager::get(const RouterPrx& rtr) if(_tableHint != _table.end()) { - if(_tableHint->first == router) - { - p = _tableHint; - } + if(_tableHint->first == router) + { + p = _tableHint; + } } if(p == _table.end()) { - p = _table.find(router); + p = _table.find(router); } if(p == _table.end()) { - _tableHint = _table.insert(_tableHint, pair<const RouterPrx, RouterInfoPtr>(router, new RouterInfo(router))); + _tableHint = _table.insert(_tableHint, pair<const RouterPrx, RouterInfoPtr>(router, new RouterInfo(router))); } else { - _tableHint = p; + _tableHint = p; } return _tableHint->second; @@ -86,26 +86,26 @@ IceInternal::RouterManager::erase(const RouterPrx& rtr) RouterInfoPtr info; if(rtr) { - RouterPrx router = RouterPrx::uncheckedCast(rtr->ice_router(0)); // The router cannot be routed. - IceUtil::Mutex::Lock sync(*this); - - map<RouterPrx, RouterInfoPtr>::iterator p = _table.end(); - if(_tableHint != _table.end() && _tableHint->first == router) - { - p = _tableHint; - _tableHint = _table.end(); - } - - if(p == _table.end()) - { - p = _table.find(router); - } - - if(p != _table.end()) - { - info = p->second; - _table.erase(p); - } + RouterPrx router = RouterPrx::uncheckedCast(rtr->ice_router(0)); // The router cannot be routed. + IceUtil::Mutex::Lock sync(*this); + + map<RouterPrx, RouterInfoPtr>::iterator p = _table.end(); + if(_tableHint != _table.end() && _tableHint->first == router) + { + p = _tableHint; + _tableHint = _table.end(); + } + + if(p == _table.end()) + { + p = _table.find(router); + } + + if(p != _table.end()) + { + info = p->second; + _table.erase(p); + } } return info; @@ -164,24 +164,24 @@ IceInternal::RouterInfo::getClientEndpoints() if(_clientEndpoints.size() == 0) // Lazy initialization. { - ObjectPrx clientProxy = _router->getClientProxy(); - if(!clientProxy) - { + ObjectPrx clientProxy = _router->getClientProxy(); + if(!clientProxy) + { // // If getClientProxy() return nil, use router endpoints. // _clientEndpoints = _router->__reference()->getEndpoints(); - } + } else { - clientProxy = clientProxy->ice_router(0); // The client proxy cannot be routed. + clientProxy = clientProxy->ice_router(0); // The client proxy cannot be routed. - // - // In order to avoid creating a new connection to the router, - // we must use the same timeout as the already existing - // connection. - // - clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout()); + // + // In order to avoid creating a new connection to the router, + // we must use the same timeout as the already existing + // connection. + // + clientProxy = clientProxy->ice_timeout(_router->ice_getConnection()->timeout()); _clientEndpoints = clientProxy->__reference()->getEndpoints(); } @@ -197,13 +197,13 @@ IceInternal::RouterInfo::getServerEndpoints() if(_serverEndpoints.size() == 0) // Lazy initialization. { - ObjectPrx serverProxy = _router->getServerProxy(); - if(!serverProxy) - { - throw NoEndpointException(__FILE__, __LINE__); - } + ObjectPrx serverProxy = _router->getServerProxy(); + if(!serverProxy) + { + throw NoEndpointException(__FILE__, __LINE__); + } - serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed. + serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed. _serverEndpoints = serverProxy->__reference()->getEndpoints(); } diff --git a/cppe/src/IceE/ServantManager.cpp b/cppe/src/IceE/ServantManager.cpp index 98a233cc77e..4eacee31ea7 100644 --- a/cppe/src/IceE/ServantManager.cpp +++ b/cppe/src/IceE/ServantManager.cpp @@ -29,26 +29,26 @@ IceInternal::ServantManager::addServant(const ObjectPtr& object, const Identity& if(p == _servantMapMap.end() || p->first != ident) { - p = _servantMapMap.find(ident); + p = _servantMapMap.find(ident); } if(p == _servantMapMap.end()) { - p = _servantMapMap.insert(_servantMapMapHint, pair<const Identity, FacetMap>(ident, FacetMap())); + p = _servantMapMap.insert(_servantMapMapHint, pair<const Identity, FacetMap>(ident, FacetMap())); } else { - if(p->second.find(facet) != p->second.end()) - { - AlreadyRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "servant"; - ex.id = _instance->identityToString(ident); - if(!facet.empty()) - { - ex.id += " -f " + IceUtil::escapeString(facet, ""); - } - throw ex; - } + if(p->second.find(facet) != p->second.end()) + { + AlreadyRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "servant"; + ex.id = _instance->identityToString(ident); + if(!facet.empty()) + { + ex.id += " -f " + IceUtil::escapeString(facet, ""); + } + throw ex; + } } _servantMapMapHint = p; @@ -75,19 +75,19 @@ IceInternal::ServantManager::removeServant(const Identity& ident, const string& if(p == _servantMapMap.end() || p->first != ident) { - p = _servantMapMap.find(ident); + p = _servantMapMap.find(ident); } if(p == _servantMapMap.end() || (q = p->second.find(facet)) == p->second.end()) { - NotRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "servant"; - ex.id = _instance->identityToString(ident); - if(!facet.empty()) - { - ex.id += " -f " + IceUtil::escapeString(facet, ""); - } - throw ex; + NotRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "servant"; + ex.id = _instance->identityToString(ident); + if(!facet.empty()) + { + ex.id += " -f " + IceUtil::escapeString(facet, ""); + } + throw ex; } servant = q->second; @@ -95,15 +95,15 @@ IceInternal::ServantManager::removeServant(const Identity& ident, const string& if(p->second.empty()) { - if(p == _servantMapMapHint) - { - _servantMapMap.erase(p++); - _servantMapMapHint = p; - } - else - { - _servantMapMap.erase(p); - } + if(p == _servantMapMapHint) + { + _servantMapMap.erase(p++); + _servantMapMapHint = p; + } + else + { + _servantMapMap.erase(p); + } } return servant; } @@ -119,27 +119,27 @@ IceInternal::ServantManager::removeAllFacets(const Identity& ident) if(p == _servantMapMap.end() || p->first != ident) { - p = _servantMapMap.find(ident); + p = _servantMapMap.find(ident); } if(p == _servantMapMap.end()) { - NotRegisteredException ex(__FILE__, __LINE__); - ex.kindOfObject = "servant"; - ex.id = _instance->identityToString(ident); - throw ex; + NotRegisteredException ex(__FILE__, __LINE__); + ex.kindOfObject = "servant"; + ex.id = _instance->identityToString(ident); + throw ex; } FacetMap result = p->second; if(p == _servantMapMapHint) { - _servantMapMap.erase(p++); - _servantMapMapHint = p; + _servantMapMap.erase(p++); + _servantMapMapHint = p; } else { - _servantMapMap.erase(p); + _servantMapMap.erase(p); } return result; @@ -155,7 +155,7 @@ IceInternal::ServantManager::findServant(const Identity& ident, const string& fa // requests from bidir connections. This method might be called if // requests are received over the bidir connection after the // adapter was deactivated. - // + // //assert(_instance); // Must not be called after destruction. ServantMapMap::iterator p = _servantMapMapHint; @@ -165,17 +165,17 @@ IceInternal::ServantManager::findServant(const Identity& ident, const string& fa if(p == servantMapMap.end() || p->first != ident) { - p = servantMapMap.find(ident); + p = servantMapMap.find(ident); } if(p == servantMapMap.end() || (q = p->second.find(facet)) == p->second.end()) { - return 0; + return 0; } else { - _servantMapMapHint = p; - return q->second; + _servantMapMapHint = p; + return q->second; } } @@ -192,17 +192,17 @@ IceInternal::ServantManager::findAllFacets(const Identity& ident) const if(p == servantMapMap.end() || p->first != ident) { - p = servantMapMap.find(ident); + p = servantMapMap.find(ident); } if(p == servantMapMap.end()) { - return FacetMap(); + return FacetMap(); } else { - _servantMapMapHint = p; - return p->second; + _servantMapMapHint = p; + return p->second; } } @@ -216,7 +216,7 @@ IceInternal::ServantManager::hasServant(const Identity& ident) const // requests from bidir connections. This method might be called if // requests are received over the bidir connection after the // adapter was deactivated. - // + // //assert(_instance); // Must not be called after destruction. ServantMapMap::iterator p = _servantMapMapHint; @@ -224,18 +224,18 @@ IceInternal::ServantManager::hasServant(const Identity& ident) const if(p == servantMapMap.end() || p->first != ident) { - p = servantMapMap.find(ident); + p = servantMapMap.find(ident); } if(p == servantMapMap.end()) { - return false; + return false; } else { - _servantMapMapHint = p; - assert(!p->second.empty()); - return true; + _servantMapMapHint = p; + assert(!p->second.empty()); + return true; } } @@ -262,14 +262,14 @@ IceInternal::ServantManager::destroy() ServantMapMap servantMapMap; { - IceUtil::Mutex::Lock sync(*this); - - assert(_instance); // Must not be called after destruction. - - servantMapMap.swap(_servantMapMap); - _servantMapMapHint = _servantMapMap.end(); - - _instance = 0; + IceUtil::Mutex::Lock sync(*this); + + assert(_instance); // Must not be called after destruction. + + servantMapMap.swap(_servantMapMap); + _servantMapMapHint = _servantMapMap.end(); + + _instance = 0; } // diff --git a/cppe/src/IceE/StaticMutex.cpp b/cppe/src/IceE/StaticMutex.cpp index 6e51c9b132a..26ea365d03b 100644 --- a/cppe/src/IceE/StaticMutex.cpp +++ b/cppe/src/IceE/StaticMutex.cpp @@ -17,7 +17,7 @@ void IceUtil::StaticMutex::initialize() const // CRITICAL_SECTION* newCriticalSection = new CRITICAL_SECTION; InitializeCriticalSection(newCriticalSection); - + // // Then assign it to _mutex // Note that Windows performs a full memory barrier before the assignment; @@ -25,11 +25,11 @@ void IceUtil::StaticMutex::initialize() const // if(InterlockedCompareExchangePointer(reinterpret_cast<void**>(&_mutex), newCriticalSection, 0) != 0) { - // - // Another thread was doing the same thing - // - DeleteCriticalSection(newCriticalSection); - delete newCriticalSection; + // + // Another thread was doing the same thing + // + DeleteCriticalSection(newCriticalSection); + delete newCriticalSection; } // diff --git a/cppe/src/IceE/StringConverter.cpp b/cppe/src/IceE/StringConverter.cpp index 837773b8e03..adf1c6d319a 100644 --- a/cppe/src/IceE/StringConverter.cpp +++ b/cppe/src/IceE/StringConverter.cpp @@ -23,8 +23,8 @@ namespace Ice Byte* UnicodeWstringConverter::toUTF8(const wchar_t* sourceStart, - const wchar_t* sourceEnd, - UTF8Buffer& buffer) const + const wchar_t* sourceEnd, + UTF8Buffer& buffer) const { // // The "chunk size" is the maximum of the number of characters in the @@ -38,51 +38,51 @@ UnicodeWstringConverter::toUTF8(const wchar_t* sourceStart, ConversionResult result; while((result = - convertUTFWstringToUTF8(sourceStart, sourceEnd, - targetStart, targetEnd, lenientConversion)) - == targetExhausted) + convertUTFWstringToUTF8(sourceStart, sourceEnd, + targetStart, targetEnd, lenientConversion)) + == targetExhausted) { - targetStart = buffer.getMoreBytes(chunkSize, targetStart); - targetEnd = targetStart + chunkSize; + targetStart = buffer.getMoreBytes(chunkSize, targetStart); + targetEnd = targetStart + chunkSize; } - + switch(result) { - case conversionOK: - break; - case sourceExhausted: - throw StringConversionException(__FILE__, __LINE__, "wide string source exhausted"); - case sourceIllegal: - throw StringConversionException(__FILE__, __LINE__, "wide string source illegal"); - default: - { - assert(0); - throw StringConversionException(__FILE__, __LINE__); - } + case conversionOK: + break; + case sourceExhausted: + throw StringConversionException(__FILE__, __LINE__, "wide string source exhausted"); + case sourceIllegal: + throw StringConversionException(__FILE__, __LINE__, "wide string source illegal"); + default: + { + assert(0); + throw StringConversionException(__FILE__, __LINE__); + } } return targetStart; } void UnicodeWstringConverter::fromUTF8(const Byte* sourceStart, const Byte* sourceEnd, - wstring& target) const + wstring& target) const { ConversionResult result = - convertUTF8ToUTFWstring(sourceStart, sourceEnd, target, lenientConversion); + convertUTF8ToUTFWstring(sourceStart, sourceEnd, target, lenientConversion); switch(result) - { - case conversionOK: - break; - case sourceExhausted: - throw StringConversionException(__FILE__, __LINE__, "UTF-8 string source exhausted"); - case sourceIllegal: - throw StringConversionException(__FILE__, __LINE__, "UTF-8 string source illegal"); - default: - { - assert(0); - throw StringConversionException(__FILE__, __LINE__); - } + { + case conversionOK: + break; + case sourceExhausted: + throw StringConversionException(__FILE__, __LINE__, "UTF-8 string source exhausted"); + case sourceIllegal: + throw StringConversionException(__FILE__, __LINE__, "UTF-8 string source illegal"); + default: + { + assert(0); + throw StringConversionException(__FILE__, __LINE__); + } } } diff --git a/cppe/src/IceE/StringUtil.cpp b/cppe/src/IceE/StringUtil.cpp index c728e3151a2..7cce1177fd6 100644 --- a/cppe/src/IceE/StringUtil.cpp +++ b/cppe/src/IceE/StringUtil.cpp @@ -42,86 +42,86 @@ encodeChar(string::value_type b, string& s, const string& special) { switch(b) { - case '\\': - { - s.append("\\\\"); - break; - } - - case '\'': - { - s.append("\\'"); - break; - } - - case '"': - { - s.append("\\\""); - break; - } - - case '\b': - { - s.append("\\b"); - break; - } - - case '\f': - { - s.append("\\f"); - break; - } - - case '\n': - { - s.append("\\n"); - break; - } - - case '\r': - { - s.append("\\r"); - break; - } - - case '\t': - { - s.append("\\t"); - break; - } - - default: - { - unsigned char i = static_cast<unsigned char>(b); - if(!(i >= 32 && i <= 126)) - { - s.push_back('\\'); - string octal = toOctalString(i); - // - // Add leading zeroes so that we avoid problems during - // decoding. For example, consider the escaped string - // \0013 (i.e., a character with value 1 followed by the - // character '3'). If the leading zeroes were omitted, the - // result would be incorrectly interpreted as a single - // character with value 11. - // - for(string::size_type j = octal.size(); j < 3; j++) - { - s.push_back('0'); - } - s.append(octal); - } - else if(special.find(b) != string::npos) - { - s.push_back('\\'); - s.push_back(b); - } - else - { - s.push_back(b); - } - break; - } + case '\\': + { + s.append("\\\\"); + break; + } + + case '\'': + { + s.append("\\'"); + break; + } + + case '"': + { + s.append("\\\""); + break; + } + + case '\b': + { + s.append("\\b"); + break; + } + + case '\f': + { + s.append("\\f"); + break; + } + + case '\n': + { + s.append("\\n"); + break; + } + + case '\r': + { + s.append("\\r"); + break; + } + + case '\t': + { + s.append("\\t"); + break; + } + + default: + { + unsigned char i = static_cast<unsigned char>(b); + if(!(i >= 32 && i <= 126)) + { + s.push_back('\\'); + string octal = toOctalString(i); + // + // Add leading zeroes so that we avoid problems during + // decoding. For example, consider the escaped string + // \0013 (i.e., a character with value 1 followed by the + // character '3'). If the leading zeroes were omitted, the + // result would be incorrectly interpreted as a single + // character with value 11. + // + for(string::size_type j = octal.size(); j < 3; j++) + { + s.push_back('0'); + } + s.append(octal); + } + else if(special.find(b) != string::npos) + { + s.push_back('\\'); + s.push_back(b); + } + else + { + s.push_back(b); + } + break; + } } } @@ -136,16 +136,16 @@ IceUtil::escapeString(const string& s, const string& special) string::size_type i; for(i = 0; i < special.size(); ++i) { - if(static_cast<unsigned char>(special[i]) < 32 || static_cast<unsigned char>(special[i]) > 126) - { - throw IllegalArgumentException(__FILE__, __LINE__, "special characters must be in ASCII range 32-126"); - } + if(static_cast<unsigned char>(special[i]) < 32 || static_cast<unsigned char>(special[i]) > 126) + { + throw IllegalArgumentException(__FILE__, __LINE__, "special characters must be in ASCII range 32-126"); + } } string result; for(i = 0; i < s.size(); ++i) { - encodeChar(s[i], result, special); + encodeChar(s[i], result, special); } return result; @@ -178,86 +178,86 @@ decodeChar(const string& s, string::size_type start, string::size_type end, stri if(s[start] != '\\') { - c = checkChar(s[start++]); + c = checkChar(s[start++]); } else { - if(start + 1 == end) - { - throw IllegalArgumentException(__FILE__, __LINE__, "trailing backslash in argument"); - } - switch(s[++start]) - { - case '\\': - case '\'': - case '"': - { - c = s[start++]; - break; - } - case 'b': - { - ++start; - c = '\b'; - break; - } - case 'f': - { - ++start; - c = '\f'; - break; - } - case 'n': - { - ++start; - c = '\n'; - break; - } - case 'r': - { - ++start; - c = '\r'; - break; - } - case 't': - { - ++start; - c = '\t'; - break; - } - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - { - int oct = 0; - for(int j = 0; j < 3 && start < end; ++j) - { - int charVal = s[start++] - '0'; - if(charVal < 0 || charVal > 7) - { - --start; - break; - } - oct = oct * 8 + charVal; - } - if(oct > 255) - { - throw IllegalArgumentException(__FILE__, __LINE__, "octal value out of range"); - } - c = (char)oct; - break; - } - default: - { - c = checkChar(s[start++]); - break; - } - } + if(start + 1 == end) + { + throw IllegalArgumentException(__FILE__, __LINE__, "trailing backslash in argument"); + } + switch(s[++start]) + { + case '\\': + case '\'': + case '"': + { + c = s[start++]; + break; + } + case 'b': + { + ++start; + c = '\b'; + break; + } + case 'f': + { + ++start; + c = '\f'; + break; + } + case 'n': + { + ++start; + c = '\n'; + break; + } + case 'r': + { + ++start; + c = '\r'; + break; + } + case 't': + { + ++start; + c = '\t'; + break; + } + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + int oct = 0; + for(int j = 0; j < 3 && start < end; ++j) + { + int charVal = s[start++] - '0'; + if(charVal < 0 || charVal > 7) + { + --start; + break; + } + oct = oct * 8 + charVal; + } + if(oct > 255) + { + throw IllegalArgumentException(__FILE__, __LINE__, "octal value out of range"); + } + c = (char)oct; + break; + } + default: + { + c = checkChar(s[start++]); + break; + } + } } nextStart = start; return c; @@ -271,7 +271,7 @@ static void decodeString(const string& s, string::size_type start, string::size_ { while(start < end) { - sb.push_back(decodeChar(s, start, end, start)); + sb.push_back(decodeChar(s, start, end, start)); } } @@ -291,20 +291,20 @@ IceUtil::unescapeString(const string& s, string::size_type start, string::size_t } if(start > end) { - throw IllegalArgumentException(__FILE__, __LINE__, "start offset must <= end offset"); + throw IllegalArgumentException(__FILE__, __LINE__, "start offset must <= end offset"); } result.reserve(end - start); try { - result.clear(); - decodeString(s, start, end, result); - return true; + result.clear(); + decodeString(s, start, end, result); + return true; } catch(...) { - return false; + return false; } } @@ -373,29 +373,29 @@ IceUtil::match(const string& s, const string& pat, bool matchPeriod) do { if(pat[patIndex] == '*') - { - // - // Don't allow matching x..y against x.*.y if requested -- star matches non-empty sequence only. - // - if(!matchPeriod && s[sIndex] == '.') - { - return false; - } - while(sIndex < s.size() && (matchPeriod || s[sIndex] != '.')) - { - ++sIndex; - } - patIndex++; - } - else - { - if(pat[patIndex] != s[sIndex]) - { - return false; - } - ++sIndex; - ++patIndex; - } + { + // + // Don't allow matching x..y against x.*.y if requested -- star matches non-empty sequence only. + // + if(!matchPeriod && s[sIndex] == '.') + { + return false; + } + while(sIndex < s.size() && (matchPeriod || s[sIndex] != '.')) + { + ++sIndex; + } + patIndex++; + } + else + { + if(pat[patIndex] != s[sIndex]) + { + return false; + } + ++sIndex; + ++patIndex; + } } while(sIndex < s.size() && patIndex < pat.size()); diff --git a/cppe/src/IceE/Thread.cpp b/cppe/src/IceE/Thread.cpp index 1b195cd44b7..c3ca404c47b 100644 --- a/cppe/src/IceE/Thread.cpp +++ b/cppe/src/IceE/Thread.cpp @@ -44,13 +44,13 @@ IceUtil::ThreadControl::join() { if(_handle == 0) { - throw BadThreadControlException(__FILE__, __LINE__); + throw BadThreadControlException(__FILE__, __LINE__); } int rc = WaitForSingleObject(_handle, INFINITE); if(rc != WAIT_OBJECT_0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } detach(); @@ -61,12 +61,12 @@ IceUtil::ThreadControl::detach() { if(_handle == 0) { - throw BadThreadControlException(__FILE__, __LINE__); + throw BadThreadControlException(__FILE__, __LINE__); } if(CloseHandle(_handle) == 0) { - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } } @@ -120,7 +120,7 @@ WINAPI startHook(void* arg) try { - IceUtil::Thread* rawThread = static_cast<IceUtil::Thread*>(arg); + IceUtil::Thread* rawThread = static_cast<IceUtil::Thread*>(arg); // // Initialize the random number generator in each thread. @@ -128,25 +128,25 @@ WINAPI startHook(void* arg) unsigned int seed = static_cast<unsigned int>(IceUtil::Time::now().toMicroSeconds()); srand(seed); - // - // Ensure that the thread doesn't go away until run() has - // completed. - // - thread = rawThread; - - // - // See the comment in IceUtil::Thread::start() for details. - // - rawThread->__decRef(); - thread->run(); + // + // Ensure that the thread doesn't go away until run() has + // completed. + // + thread = rawThread; + + // + // See the comment in IceUtil::Thread::start() for details. + // + rawThread->__decRef(); + thread->run(); } catch(const IceUtil::Exception& e) { - fprintf(stderr, "IceUtil::Thread::run(): uncaught exception: %s\n", e.toString().c_str()); + fprintf(stderr, "IceUtil::Thread::run(): uncaught exception: %s\n", e.toString().c_str()); } catch(...) { - fprintf(stderr, "IceUtil::Thread::run(): uncaught exception\n"); + fprintf(stderr, "IceUtil::Thread::run(): uncaught exception\n"); } thread->_done(); @@ -169,7 +169,7 @@ IceUtil::Thread::start(size_t stackSize) if(_started) { - throw ThreadStartedException(__FILE__, __LINE__); + throw ThreadStartedException(__FILE__, __LINE__); } // @@ -185,26 +185,26 @@ IceUtil::Thread::start(size_t stackSize) #ifdef _WIN32_WCE _handle = CreateThread(0, stackSize, - startHook, this, 0, &_id); + startHook, this, 0, &_id); #else unsigned int id; _handle = - reinterpret_cast<HANDLE>( - _beginthreadex(0, - static_cast<unsigned int>(stackSize), - startHook, this, 0, &id)); + reinterpret_cast<HANDLE>( + _beginthreadex(0, + static_cast<unsigned int>(stackSize), + startHook, this, 0, &id)); _id = id; #endif if(_handle == 0) { - __decRef(); - throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); + __decRef(); + throw ThreadSyscallException(__FILE__, __LINE__, GetLastError()); } _started = true; _running = true; - + return ThreadControl(_handle, _id); } @@ -214,7 +214,7 @@ IceUtil::Thread::getThreadControl() const IceUtil::Mutex::Lock lock(_stateMutex); if(!_started) { - throw ThreadNotStartedException(__FILE__, __LINE__); + throw ThreadNotStartedException(__FILE__, __LINE__); } return ThreadControl(_handle, _id); } @@ -283,14 +283,14 @@ IceUtil::ThreadControl::join() { if(!_detachable) { - throw BadThreadControlException(__FILE__, __LINE__); + throw BadThreadControlException(__FILE__, __LINE__); } void* ignore = 0; int rc = pthread_join(_thread, &ignore); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } } @@ -299,13 +299,13 @@ IceUtil::ThreadControl::detach() { if(!_detachable) { - throw BadThreadControlException(__FILE__, __LINE__); + throw BadThreadControlException(__FILE__, __LINE__); } int rc = pthread_detach(_thread); if(rc != 0) { - throw ThreadSyscallException(__FILE__, __LINE__, rc); + throw ThreadSyscallException(__FILE__, __LINE__, rc); } } @@ -354,23 +354,23 @@ startHook(void* arg) try { - IceUtil::Thread* rawThread = static_cast<IceUtil::Thread*>(arg); + IceUtil::Thread* rawThread = static_cast<IceUtil::Thread*>(arg); - thread = rawThread; + thread = rawThread; - // - // See the comment in IceUtil::Thread::start() for details. - // - rawThread->__decRef(); - thread->run(); + // + // See the comment in IceUtil::Thread::start() for details. + // + rawThread->__decRef(); + thread->run(); } catch(const IceUtil::Exception& e) { - fprintf(stderr, "IceUtil::Thread::run(): uncaught exception: %s\n", e.toString().c_str()); + fprintf(stderr, "IceUtil::Thread::run(): uncaught exception: %s\n", e.toString().c_str()); } catch(...) { - fprintf(stderr, "IceUtil::Thread::run(): uncaught exception\n"); + fprintf(stderr, "IceUtil::Thread::run(): uncaught exception\n"); } thread->_done(); @@ -390,7 +390,7 @@ IceUtil::Thread::start(size_t stackSize) if(_started) { - throw ThreadStartedException(__FILE__, __LINE__); + throw ThreadStartedException(__FILE__, __LINE__); } // @@ -406,34 +406,34 @@ IceUtil::Thread::start(size_t stackSize) if(stackSize > 0) { - pthread_attr_t attr; - int rc = pthread_attr_init(&attr); - if(rc != 0) - { - __decRef(); - throw ThreadSyscallException(__FILE__, __LINE__, rc); - } - rc = pthread_attr_setstacksize(&attr, stackSize); - if(rc != 0) - { - __decRef(); - throw ThreadSyscallException(__FILE__, __LINE__, rc); - } - rc = pthread_create(&_thread, &attr, startHook, this); - if(rc != 0) - { - __decRef(); - throw ThreadSyscallException(__FILE__, __LINE__, rc); - } + pthread_attr_t attr; + int rc = pthread_attr_init(&attr); + if(rc != 0) + { + __decRef(); + throw ThreadSyscallException(__FILE__, __LINE__, rc); + } + rc = pthread_attr_setstacksize(&attr, stackSize); + if(rc != 0) + { + __decRef(); + throw ThreadSyscallException(__FILE__, __LINE__, rc); + } + rc = pthread_create(&_thread, &attr, startHook, this); + if(rc != 0) + { + __decRef(); + throw ThreadSyscallException(__FILE__, __LINE__, rc); + } } else { - int rc = pthread_create(&_thread, 0, startHook, this); - if(rc != 0) - { - __decRef(); - throw ThreadSyscallException(__FILE__, __LINE__, rc); - } + int rc = pthread_create(&_thread, 0, startHook, this); + if(rc != 0) + { + __decRef(); + throw ThreadSyscallException(__FILE__, __LINE__, rc); + } } _started = true; @@ -448,7 +448,7 @@ IceUtil::Thread::getThreadControl() const IceUtil::Mutex::Lock lock(_stateMutex); if(!_started) { - throw ThreadNotStartedException(__FILE__, __LINE__); + throw ThreadNotStartedException(__FILE__, __LINE__); } return ThreadControl(_thread); } diff --git a/cppe/src/IceE/ThreadException.cpp b/cppe/src/IceE/ThreadException.cpp index 0cde7200156..1915f7f6431 100644 --- a/cppe/src/IceE/ThreadException.cpp +++ b/cppe/src/IceE/ThreadException.cpp @@ -32,33 +32,33 @@ IceUtil::ThreadSyscallException::toString() const string out = Exception::toString(); if(_error != 0) { - out += ":\nthread syscall exception: "; + out += ":\nthread syscall exception: "; #ifdef _WIN32_WCE - out += Ice::printfToString("thread error: %d", _error); + out += Ice::printfToString("thread error: %d", _error); #elif defined(_WIN32) - LPVOID lpMsgBuf = 0; - DWORD ok = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, - _error, - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language - (LPTSTR)&lpMsgBuf, - 0, - NULL); - - if(ok) - { - LPCTSTR msg = (LPCTSTR)lpMsgBuf; - assert(msg && strlen((char*)msg) > 0); - out += reinterpret_cast<const char*>(msg); - LocalFree(lpMsgBuf); - } - else - { - out += "unknown thread error: "; - out += Ice::printfToString("error=%d", _error); - } + LPVOID lpMsgBuf = 0; + DWORD ok = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + _error, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language + (LPTSTR)&lpMsgBuf, + 0, + NULL); + + if(ok) + { + LPCTSTR msg = (LPCTSTR)lpMsgBuf; + assert(msg && strlen((char*)msg) > 0); + out += reinterpret_cast<const char*>(msg); + LocalFree(lpMsgBuf); + } + else + { + out += "unknown thread error: "; + out += Ice::printfToString("error=%d", _error); + } #else out += strerror(_error); #endif diff --git a/cppe/src/IceE/TraceUtil.cpp b/cppe/src/IceE/TraceUtil.cpp index fe5f9e2b68f..f0267bdf595 100644 --- a/cppe/src/IceE/TraceUtil.cpp +++ b/cppe/src/IceE/TraceUtil.cpp @@ -55,29 +55,29 @@ printRequestHeader(string& s, BasicStream& stream) s += Ice::printfToString("\nmode = %d ", static_cast<int>(mode)); switch(mode) { - case Normal: - { - s += "(normal)"; - break; - } - - case Nonmutating: - { - s += "(nonmutating)"; - break; - } - - case Idempotent: - { - s += "(idempotent)"; - break; - } - - default: - { - s += "(unknown)"; - break; - } + case Normal: + { + s += "(normal)"; + break; + } + + case Nonmutating: + { + s += "(nonmutating)"; + break; + } + + case Idempotent: + { + s += "(idempotent)"; + break; + } + + default: + { + s += "(unknown)"; + break; + } } Int sz; @@ -85,16 +85,16 @@ printRequestHeader(string& s, BasicStream& stream) s += "\ncontext = "; while(sz--) { - pair<string, string> pair; - stream.read(pair.first); - stream.read(pair.second); - s += pair.first; - s += "/"; - s += pair.second; - if(sz) - { - s += ", "; - } + pair<string, string> pair; + stream.read(pair.first); + stream.read(pair.second); + s += pair.first; + s += "/"; + s += pair.second; + if(sz) + { + s += ", "; + } } } @@ -102,7 +102,7 @@ static void printHeader(string& s, BasicStream& stream) { Byte magicNumber; - stream.read(magicNumber); // Don't bother printing the magic number + stream.read(magicNumber); // Don't bother printing the magic number stream.read(magicNumber); stream.read(magicNumber); stream.read(magicNumber); @@ -127,41 +127,41 @@ printHeader(string& s, BasicStream& stream) switch(type) { - case requestMsg: - { - s += "(request)"; - break; - } - - case requestBatchMsg: - { - s += "(batch request)"; - break; - } - - case replyMsg: - { - s += "(reply)"; - break; - } - - case closeConnectionMsg: - { - s += "(close connection)"; - break; - } - - case validateConnectionMsg: - { - s += "(validate connection)"; - break; - } - - default: - { - s += "(unknown)"; - break; - } + case requestMsg: + { + s += "(request)"; + break; + } + + case requestBatchMsg: + { + s += "(batch request)"; + break; + } + + case replyMsg: + { + s += "(reply)"; + break; + } + + case closeConnectionMsg: + { + s += "(close connection)"; + break; + } + + case validateConnectionMsg: + { + s += "(validate connection)"; + break; + } + + default: + { + s += "(unknown)"; + break; + } } Byte compress; @@ -170,29 +170,29 @@ printHeader(string& s, BasicStream& stream) switch(compress) { - case 0: - { - s += "(not compressed; do not compress response, if any)"; - break; - } - - case 1: - { - s += "(not compressed; compress response, if any)"; - break; - } - - case 2: - { - s += "(compressed; compress response, if any)"; - break; - } - - default: - { - s += "(unknown)"; - break; - } + case 0: + { + s += "(not compressed; do not compress response, if any)"; + break; + } + + case 1: + { + s += "(not compressed; compress response, if any)"; + break; + } + + case 2: + { + s += "(compressed; compress response, if any)"; + break; + } + + default: + { + s += "(unknown)"; + break; + } } Int size; @@ -202,7 +202,7 @@ printHeader(string& s, BasicStream& stream) void IceInternal::traceHeader(const char* heading, const BasicStream& str, const LoggerPtr& logger, - const TraceLevelsPtr& tl) + const TraceLevelsPtr& tl) { BasicStream& stream = const_cast<BasicStream&>(str); BasicStream::Container::iterator p = stream.i; @@ -217,7 +217,7 @@ IceInternal::traceHeader(const char* heading, const BasicStream& str, const Logg void IceInternal::traceRequest(const char* heading, const BasicStream& str, const LoggerPtr& logger, - const TraceLevelsPtr& tl) + const TraceLevelsPtr& tl) { BasicStream& stream = const_cast<BasicStream&>(str); BasicStream::Container::iterator p = stream.i; @@ -231,7 +231,7 @@ IceInternal::traceRequest(const char* heading, const BasicStream& str, const Log s += Ice::printfToString("\nrequest id = %d", requestId); if(requestId == 0) { - s += " (oneway)"; + s += " (oneway)"; } printRequestHeader(s, stream); @@ -243,7 +243,7 @@ IceInternal::traceRequest(const char* heading, const BasicStream& str, const Log #ifdef ICEE_HAS_BATCH void IceInternal::traceBatchRequest(const char* heading, const BasicStream& str, const LoggerPtr& logger, - const TraceLevelsPtr& tl) + const TraceLevelsPtr& tl) { BasicStream& stream = const_cast<BasicStream&>(str); BasicStream::Container::iterator p = stream.i; @@ -258,9 +258,9 @@ IceInternal::traceBatchRequest(const char* heading, const BasicStream& str, cons for(int i = 0; i < batchRequestNum; ++i) { - s += Ice::printfToString("\nrequest #%d:", i); - printRequestHeader(s, stream); - stream.skipEncaps(); + s += Ice::printfToString("\nrequest #%d:", i); + printRequestHeader(s, stream); + stream.skipEncaps(); } logger->trace(tl->protocolCat, s); @@ -270,7 +270,7 @@ IceInternal::traceBatchRequest(const char* heading, const BasicStream& str, cons void IceInternal::traceReply(const char* heading, const BasicStream& str, const LoggerPtr& logger, - const TraceLevelsPtr& tl) + const TraceLevelsPtr& tl) { BasicStream& stream = const_cast<BasicStream&>(str); BasicStream::Container::iterator p = stream.i; @@ -290,93 +290,93 @@ IceInternal::traceReply(const char* heading, const BasicStream& str, const Logge { case replyOK: { - s += "(ok)"; - break; + s += "(ok)"; + break; } case replyUserException: { - s += "(user exception)"; - break; + s += "(user exception)"; + break; } case replyObjectNotExist: case replyFacetNotExist: case replyOperationNotExist: { - switch(replyStatus) - { - case replyObjectNotExist: - { - s += "(object not exist)"; - break; - } - - case replyFacetNotExist: - { - s += "(facet not exist)"; - break; - } - - case replyOperationNotExist: - { - s += "(operation not exist)"; - break; - } - - default: - { - assert(false); - break; - } - } - - printIdentityFacetOperation(s, stream); - break; + switch(replyStatus) + { + case replyObjectNotExist: + { + s += "(object not exist)"; + break; + } + + case replyFacetNotExist: + { + s += "(facet not exist)"; + break; + } + + case replyOperationNotExist: + { + s += "(operation not exist)"; + break; + } + + default: + { + assert(false); + break; + } + } + + printIdentityFacetOperation(s, stream); + break; } case replyUnknownException: case replyUnknownLocalException: case replyUnknownUserException: { - switch(replyStatus) - { - case replyUnknownException: - { - s += "(unknown exception)"; - break; - } - - case replyUnknownLocalException: - { - s += "(unknown local exception)"; - break; - } - - case replyUnknownUserException: - { - s += "(unknown user exception)"; - break; - } - - default: - { - assert(false); - break; - } - } - - string unknown; - stream.read(unknown); - s += "\nunknown = "; - s += unknown; - break; + switch(replyStatus) + { + case replyUnknownException: + { + s += "(unknown exception)"; + break; + } + + case replyUnknownLocalException: + { + s += "(unknown local exception)"; + break; + } + + case replyUnknownUserException: + { + s += "(unknown user exception)"; + break; + } + + default: + { + assert(false); + break; + } + } + + string unknown; + stream.read(unknown); + s += "\nunknown = "; + s += unknown; + break; } default: { - s += "(unknown)"; - break; + s += "(unknown)"; + break; } } diff --git a/cppe/src/IceE/Transceiver.h b/cppe/src/IceE/Transceiver.h index 36a7ecaa8bf..a3cbbaafdec 100644 --- a/cppe/src/IceE/Transceiver.h +++ b/cppe/src/IceE/Transceiver.h @@ -45,12 +45,12 @@ public: void write(Buffer& buf) { - writeWithTimeout(buf, _writeTimeout); + writeWithTimeout(buf, _writeTimeout); } void read(Buffer& buf) { - readWithTimeout(buf, _readTimeout); + readWithTimeout(buf, _readTimeout); } std::string type() const; diff --git a/cppe/src/IceE/UUID.cpp b/cppe/src/IceE/UUID.cpp index de7fba90512..d3847e581cd 100644 --- a/cppe/src/IceE/UUID.cpp +++ b/cppe/src/IceE/UUID.cpp @@ -42,11 +42,11 @@ inline void halfByteToHex(unsigned char hb, char*& hexBuffer) { if(hb < 10) { - *hexBuffer++ = '0' + hb; + *hexBuffer++ = '0' + hb; } else { - *hexBuffer++ = 'A' + (hb - 10); + *hexBuffer++ = 'A' + (hb - 10); } } @@ -54,8 +54,8 @@ inline void bytesToHex(unsigned char* bytes, size_t len, char*& hexBuffer) { for(size_t i = 0; i < len; i++) { - halfByteToHex((bytes[i] & 0xF0) >> 4, hexBuffer); - halfByteToHex((bytes[i] & 0x0F), hexBuffer); + halfByteToHex((bytes[i] & 0xF0) >> 4, hexBuffer); + halfByteToHex((bytes[i] & 0x0F), hexBuffer); } } @@ -84,12 +84,12 @@ public: ~UUIDCleanup() { - IceUtil::StaticMutex::Lock lock(staticMutex); - if(cryptProv != 0) - { - CryptReleaseContext(cryptProv, 0); - cryptProv = 0; - } + IceUtil::StaticMutex::Lock lock(staticMutex); + if(cryptProv != 0) + { + CryptReleaseContext(cryptProv, 0); + cryptProv = 0; + } } }; @@ -125,12 +125,12 @@ public: ~UUIDCleanup() { - IceUtil::StaticMutex::Lock lock(staticMutex); - if(fd != -1) - { - close(fd); - fd = -1; - } + IceUtil::StaticMutex::Lock lock(staticMutex); + if(fd != -1) + { + close(fd); + fd = -1; + } } }; static UUIDCleanup uuidCleanup; @@ -179,12 +179,12 @@ IceUtil::generateUUID() struct UUID { - unsigned char timeLow[4]; - unsigned char timeMid[2]; - unsigned char timeHighAndVersion[2]; - unsigned char clockSeqHiAndReserved; - unsigned char clockSeqLow; - unsigned char node[6]; + unsigned char timeLow[4]; + unsigned char timeMid[2]; + unsigned char timeHighAndVersion[2]; + unsigned char clockSeqHiAndReserved; + unsigned char clockSeqLow; + unsigned char node[6]; }; UUID uuid; @@ -199,74 +199,74 @@ IceUtil::generateUUID() HCRYPTPROV localProv; { - IceUtil::StaticMutex::Lock lock(staticMutex); - if(cryptProv == 0) - { - if(!CryptAcquireContext(&cryptProv, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) - { - throw UUIDGenerationException(__FILE__, __LINE__); - } - } - localProv = cryptProv; + IceUtil::StaticMutex::Lock lock(staticMutex); + if(cryptProv == 0) + { + if(!CryptAcquireContext(&cryptProv, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) + { + throw UUIDGenerationException(__FILE__, __LINE__); + } + } + localProv = cryptProv; } memset(buffer, 0, 16); if(!CryptGenRandom(localProv, 16, (unsigned char*)buffer)) { - throw UUIDGenerationException(__FILE__, __LINE__); + throw UUIDGenerationException(__FILE__, __LINE__); } #else { - // - // Serialize access to /dev/urandom; see comment above. - // - IceUtil::StaticMutex::Lock lock(staticMutex); - if(fd == -1) - { - fd = open("/dev/urandom", O_RDONLY); - if (fd == -1) - { - assert(0); - throw UUIDGenerationException(__FILE__, __LINE__); - } - - // - // Initialize myPid as well - // - pid_t pid = getpid(); - myPid[0] = (pid >> 8) & 0x7F; - myPid[1] = pid & 0xFF; - } - - - // - // Limit the number of attempts to 20 reads to avoid - // a potential "for ever" loop - // - while(reads <= 20 && index != sizeof(UUID)) - { - ssize_t bytesRead = read(fd, buffer + index, sizeof(UUID) - index); - - if(bytesRead == -1 && errno != EINTR) - { - int err = errno; - fprintf(stderr, "Reading /dev/urandom returned %s\n", strerror(err)); - assert(0); - throw UUIDGenerationException(__FILE__, __LINE__); - } - else - { - index += bytesRead; - reads++; - } - } + // + // Serialize access to /dev/urandom; see comment above. + // + IceUtil::StaticMutex::Lock lock(staticMutex); + if(fd == -1) + { + fd = open("/dev/urandom", O_RDONLY); + if (fd == -1) + { + assert(0); + throw UUIDGenerationException(__FILE__, __LINE__); + } + + // + // Initialize myPid as well + // + pid_t pid = getpid(); + myPid[0] = (pid >> 8) & 0x7F; + myPid[1] = pid & 0xFF; + } + + + // + // Limit the number of attempts to 20 reads to avoid + // a potential "for ever" loop + // + while(reads <= 20 && index != sizeof(UUID)) + { + ssize_t bytesRead = read(fd, buffer + index, sizeof(UUID) - index); + + if(bytesRead == -1 && errno != EINTR) + { + int err = errno; + fprintf(stderr, "Reading /dev/urandom returned %s\n", strerror(err)); + assert(0); + throw UUIDGenerationException(__FILE__, __LINE__); + } + else + { + index += bytesRead; + reads++; + } + } } - + if (index != sizeof(UUID)) { - assert(0); - throw UUIDGenerationException(__FILE__, __LINE__); + assert(0); + throw UUIDGenerationException(__FILE__, __LINE__); } // diff --git a/cppe/src/IceE/Unicode.cpp b/cppe/src/IceE/Unicode.cpp index c1a17286041..facd380e1a3 100644 --- a/cppe/src/IceE/Unicode.cpp +++ b/cppe/src/IceE/Unicode.cpp @@ -27,35 +27,35 @@ template<size_t wcharSize> struct WstringHelper { static ConversionResult toUTF8( - const wchar_t*& sourceStart, const wchar_t* sourceEnd, - Byte*& targetStart, Byte* targetEnd, ConversionFlags flags); + const wchar_t*& sourceStart, const wchar_t* sourceEnd, + Byte*& targetStart, Byte* targetEnd, ConversionFlags flags); static ConversionResult fromUTF8( - const Byte*& sourceStart, const Byte* sourceEnd, - wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags); + const Byte*& sourceStart, const Byte* sourceEnd, + wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags); }; template<> struct WstringHelper<2> { static ConversionResult toUTF8( - const wchar_t*& sourceStart, const wchar_t* sourceEnd, - Byte*& targetStart, Byte* targetEnd, ConversionFlags flags) + const wchar_t*& sourceStart, const wchar_t* sourceEnd, + Byte*& targetStart, Byte* targetEnd, ConversionFlags flags) { - return ConvertUTF16toUTF8( - reinterpret_cast<const UTF16**>(&sourceStart), - reinterpret_cast<const UTF16*>(sourceEnd), - &targetStart, targetEnd, flags); + return ConvertUTF16toUTF8( + reinterpret_cast<const UTF16**>(&sourceStart), + reinterpret_cast<const UTF16*>(sourceEnd), + &targetStart, targetEnd, flags); } static ConversionResult fromUTF8( - const Byte*& sourceStart, const Byte* sourceEnd, - wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags) + const Byte*& sourceStart, const Byte* sourceEnd, + wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags) { - return ConvertUTF8toUTF16( - &sourceStart, sourceEnd, - reinterpret_cast<UTF16**>(&targetStart), - reinterpret_cast<UTF16*>(targetEnd), flags); + return ConvertUTF8toUTF16( + &sourceStart, sourceEnd, + reinterpret_cast<UTF16**>(&targetStart), + reinterpret_cast<UTF16*>(targetEnd), flags); } }; @@ -63,23 +63,23 @@ template<> struct WstringHelper<4> { static ConversionResult toUTF8( - const wchar_t*& sourceStart, const wchar_t* sourceEnd, - Byte*& targetStart, Byte* targetEnd, ConversionFlags flags) + const wchar_t*& sourceStart, const wchar_t* sourceEnd, + Byte*& targetStart, Byte* targetEnd, ConversionFlags flags) { - return ConvertUTF32toUTF8( - reinterpret_cast<const UTF32**>(&sourceStart), - reinterpret_cast<const UTF32*>(sourceEnd), - &targetStart, targetEnd, flags); + return ConvertUTF32toUTF8( + reinterpret_cast<const UTF32**>(&sourceStart), + reinterpret_cast<const UTF32*>(sourceEnd), + &targetStart, targetEnd, flags); } static ConversionResult fromUTF8( - const Byte*& sourceStart, const Byte* sourceEnd, - wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags) + const Byte*& sourceStart, const Byte* sourceEnd, + wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags) { - return ConvertUTF8toUTF32( - &sourceStart, sourceEnd, - reinterpret_cast<UTF32**>(&targetStart), - reinterpret_cast<UTF32*>(targetEnd), flags); + return ConvertUTF8toUTF32( + &sourceStart, sourceEnd, + reinterpret_cast<UTF32**>(&targetStart), + reinterpret_cast<UTF32*>(targetEnd), flags); } }; } @@ -94,7 +94,7 @@ IceUtil::convertUTFWstringToUTF8( Byte*& targetStart, Byte* targetEnd, ConversionFlags flags) { return WstringHelper<sizeof(wchar_t)>::toUTF8( - sourceStart, sourceEnd, targetStart, targetEnd, flags); + sourceStart, sourceEnd, targetStart, targetEnd, flags); } ConversionResult @@ -103,12 +103,12 @@ IceUtil::convertUTF8ToUTFWstring( wchar_t*& targetStart, wchar_t* targetEnd, ConversionFlags flags) { return WstringHelper<sizeof(wchar_t)>::fromUTF8( - sourceStart, sourceEnd, targetStart, targetEnd, flags); + sourceStart, sourceEnd, targetStart, targetEnd, flags); } ConversionResult IceUtil::convertUTF8ToUTFWstring(const Byte*& sourceStart, const Byte* sourceEnd, - std::wstring& target, ConversionFlags flags) + std::wstring& target, ConversionFlags flags) { // // Could be reimplemented without this temporary wchar_t buffer @@ -119,13 +119,13 @@ IceUtil::convertUTF8ToUTFWstring(const Byte*& sourceStart, const Byte* sourceEnd wchar_t* targetEnd = targetStart + size; ConversionResult result = - convertUTF8ToUTFWstring(sourceStart, sourceEnd, targetStart, - targetEnd, flags); + convertUTF8ToUTFWstring(sourceStart, sourceEnd, targetStart, + targetEnd, flags); if(result == conversionOK) { - std::wstring s(outBuf, static_cast<size_t>(targetStart - outBuf)); - s.swap(target); + std::wstring s(outBuf, static_cast<size_t>(targetStart - outBuf)); + s.swap(target); } delete[] outBuf; return result; @@ -139,7 +139,7 @@ IceUtil::convertUTF8ToUTFWstring(const Byte*& sourceStart, const Byte* sourceEnd const char* IceUtil::UTFConversionException::_name = "IceUtil::UTFConversionException"; IceUtil::UTFConversionException::UTFConversionException(const char* file, int line, - ConversionResult cr): + ConversionResult cr): Exception(file, line), _conversionResult(cr) {} @@ -156,18 +156,18 @@ IceUtil::UTFConversionException::toString() const string str = Exception::toString(); switch(_conversionResult) { - case sourceExhausted: - str += ": source exhausted"; - break; - case targetExhausted: - str += ": target exhausted"; - break; - case sourceIllegal: - str += ": illegal source"; - break; - default: - assert(0); - break; + case sourceExhausted: + str += ": source exhausted"; + break; + case targetExhausted: + str += ": target exhausted"; + break; + case sourceIllegal: + str += ": illegal source"; + break; + default: + assert(0); + break; }; return str; } @@ -205,18 +205,18 @@ IceUtil::wstringToString(const wstring& wstr) const wchar_t* sourceStart = wstr.data(); ConversionResult cr = - convertUTFWstringToUTF8( - sourceStart, sourceStart + wstr.size(), - targetStart, targetEnd, lenientConversion); - + convertUTFWstringToUTF8( + sourceStart, sourceStart + wstr.size(), + targetStart, targetEnd, lenientConversion); + if(cr != conversionOK) { - delete[] outBuf; - throw UTFConversionException(__FILE__, __LINE__, cr); + delete[] outBuf; + throw UTFConversionException(__FILE__, __LINE__, cr); } string s(reinterpret_cast<char*>(outBuf), - static_cast<size_t>(targetStart - outBuf)); + static_cast<size_t>(targetStart - outBuf)); s.swap(target); delete[] outBuf; return target; @@ -229,12 +229,12 @@ IceUtil::stringToWstring(const string& str) const Byte* sourceStart = reinterpret_cast<const Byte*>(str.data()); ConversionResult cr - = convertUTF8ToUTFWstring(sourceStart, sourceStart + str.size(), - result, lenientConversion); + = convertUTF8ToUTFWstring(sourceStart, sourceStart + str.size(), + result, lenientConversion); if(cr != conversionOK) { - throw UTFConversionException(__FILE__, __LINE__, cr); + throw UTFConversionException(__FILE__, __LINE__, cr); } return result; } diff --git a/cppe/src/IceE/UnknownEndpoint.cpp b/cppe/src/IceE/UnknownEndpoint.cpp index dee2bd5004f..3792a012c16 100644 --- a/cppe/src/IceE/UnknownEndpoint.cpp +++ b/cppe/src/IceE/UnknownEndpoint.cpp @@ -114,12 +114,12 @@ IceInternal::UnknownEndpoint::operator==(const Endpoint& r) const const UnknownEndpoint* p = dynamic_cast<const UnknownEndpoint*>(&r); if(!p) { - return false; + return false; } if(this == p) { - return true; + return true; } if(_type != p->_type) @@ -129,7 +129,7 @@ IceInternal::UnknownEndpoint::operator==(const Endpoint& r) const if(_rawBytes != p->_rawBytes) { - return false; + return false; } return true; @@ -152,25 +152,25 @@ IceInternal::UnknownEndpoint::operator<(const Endpoint& r) const if(this == p) { - return false; + return false; } if(_type < p->_type) { - return true; + return true; } else if(p->_type < _type) { - return false; + return false; } if(_rawBytes < p->_rawBytes) { - return true; + return true; } else if(p->_rawBytes < _rawBytes) { - return false; + return false; } return false; diff --git a/cppe/src/TcpTransport/Acceptor.cpp b/cppe/src/TcpTransport/Acceptor.cpp index 28f2b74b43a..477eb7b7adb 100644 --- a/cppe/src/TcpTransport/Acceptor.cpp +++ b/cppe/src/TcpTransport/Acceptor.cpp @@ -32,8 +32,8 @@ IceInternal::Acceptor::close() { if(_traceLevels->network >= 1) { - Trace out(_logger, _traceLevels->networkCat); - out << "stopping to accept tcp connections at " << toString(); + Trace out(_logger, _traceLevels->networkCat); + out << "stopping to accept tcp connections at " << toString(); } SOCKET fd = _fd; @@ -46,18 +46,18 @@ IceInternal::Acceptor::listen() { try { - doListen(_fd, _backlog); + doListen(_fd, _backlog); } catch(...) { - _fd = INVALID_SOCKET; - throw; + _fd = INVALID_SOCKET; + throw; } if(_traceLevels->network >= 1) { - Trace out(_logger, _traceLevels->networkCat); - out << "accepting tcp connections at " << toString(); + Trace out(_logger, _traceLevels->networkCat); + out << "accepting tcp connections at " << toString(); } } @@ -72,8 +72,8 @@ IceInternal::Acceptor::accept() if(_traceLevels->network >= 1) { - Trace out(_logger, _traceLevels->networkCat); - out << "accepted tcp connection\n" << fdToString(fd); + Trace out(_logger, _traceLevels->networkCat); + out << "accepted tcp connection\n" << fdToString(fd); } return new Transceiver(_instance, fd); @@ -113,8 +113,8 @@ IceInternal::Acceptor::Acceptor(const InstancePtr& instance, const string& host, try { - _fd = createSocket(); - getAddress(host, port, _addr); + _fd = createSocket(); + getAddress(host, port, _addr); setTcpBufSize(_fd, _instance->initializationData().properties, _logger); #ifndef _WIN32 // @@ -131,17 +131,17 @@ IceInternal::Acceptor::Acceptor(const InstancePtr& instance, const string& host, // setReuseAddress(_fd, true); #endif - if(_traceLevels->network >= 2) - { - Trace out(_logger, _traceLevels->networkCat); - out << "attempting to bind to tcp socket " << toString(); - } - doBind(_fd, _addr); + if(_traceLevels->network >= 2) + { + Trace out(_logger, _traceLevels->networkCat); + out << "attempting to bind to tcp socket " << toString(); + } + doBind(_fd, _addr); } catch(...) { - _fd = INVALID_SOCKET; - throw; + _fd = INVALID_SOCKET; + throw; } } diff --git a/cppe/src/TcpTransport/Connector.cpp b/cppe/src/TcpTransport/Connector.cpp index 98d3b95a364..52209fcda50 100644 --- a/cppe/src/TcpTransport/Connector.cpp +++ b/cppe/src/TcpTransport/Connector.cpp @@ -26,8 +26,8 @@ Connector::connect(int timeout) { if(_traceLevels->network >= 2) { - Trace out(_logger, _traceLevels->networkCat); - out << "trying to establish tcp connection to " << toString(); + Trace out(_logger, _traceLevels->networkCat); + out << "trying to establish tcp connection to " << toString(); } SOCKET fd = createSocket(); @@ -40,8 +40,8 @@ Connector::connect(int timeout) if(_traceLevels->network >= 1) { - Trace out(_logger, _traceLevels->networkCat); - out << "tcp connection established\n" << fdToString(fd); + Trace out(_logger, _traceLevels->networkCat); + out << "tcp connection established\n" << fdToString(fd); } return new Transceiver(_instance, fd); diff --git a/cppe/src/TcpTransport/EndpointFactory.cpp b/cppe/src/TcpTransport/EndpointFactory.cpp index 7ac68524733..c6207020d38 100644 --- a/cppe/src/TcpTransport/EndpointFactory.cpp +++ b/cppe/src/TcpTransport/EndpointFactory.cpp @@ -51,7 +51,7 @@ IceInternal::EndpointFactory::create(const std::string& str) const if(protocol == "default" || protocol == "tcp") { - return new TcpEndpoint(_instance, str.substr(end)); + return new TcpEndpoint(_instance, str.substr(end)); } return 0; diff --git a/cppe/src/TcpTransport/TcpEndpoint.cpp b/cppe/src/TcpTransport/TcpEndpoint.cpp index 93e4a9efdca..88adf42bf94 100644 --- a/cppe/src/TcpTransport/TcpEndpoint.cpp +++ b/cppe/src/TcpTransport/TcpEndpoint.cpp @@ -46,90 +46,90 @@ IceInternal::TcpEndpoint::TcpEndpoint(const InstancePtr& instance, const string& while(true) { - beg = str.find_first_not_of(delim, end); - if(beg == string::npos) - { - break; - } - - end = str.find_first_of(delim, beg); - if(end == string::npos) - { - end = str.length(); - } - - string option = str.substr(beg, end - beg); - if(option.length() != 2 || option[0] != '-') - { - EndpointParseException ex(__FILE__, __LINE__); - ex.str = "tcp " + str; - throw ex; - } - - string argument; - string::size_type argumentBeg = str.find_first_not_of(delim, end); - if(argumentBeg != string::npos && str[argumentBeg] != '-') - { - beg = argumentBeg; - end = str.find_first_of(delim, beg); - if(end == string::npos) - { - end = str.length(); - } - argument = str.substr(beg, end - beg); - } - - switch(option[1]) - { - case 'h': - { - if(argument.empty()) - { - EndpointParseException ex(__FILE__, __LINE__); - ex.str = "tcp " + str; - throw ex; - } - const_cast<string&>(_host) = argument; - break; - } - - case 'p': - { - const_cast<Int&>(_port) = atoi(argument.c_str()); - if(_port <= 0 || _port > 65535) - { - EndpointParseException ex(__FILE__, __LINE__); - ex.str = "tcp " + str; - throw ex; - } - break; - } - - case 't': - { - const_cast<Int&>(_timeout) = atoi(argument.c_str()); - if(_timeout == 0) - { - EndpointParseException ex(__FILE__, __LINE__); - ex.str = "tcp " + str; - throw ex; - } - break; - } - - case 'z': - { - // Ignore compression flag. - break; - } - - default: - { - EndpointParseException ex(__FILE__, __LINE__); - ex.str = "tcp " + str; - throw ex; - } - } + beg = str.find_first_not_of(delim, end); + if(beg == string::npos) + { + break; + } + + end = str.find_first_of(delim, beg); + if(end == string::npos) + { + end = str.length(); + } + + string option = str.substr(beg, end - beg); + if(option.length() != 2 || option[0] != '-') + { + EndpointParseException ex(__FILE__, __LINE__); + ex.str = "tcp " + str; + throw ex; + } + + string argument; + string::size_type argumentBeg = str.find_first_not_of(delim, end); + if(argumentBeg != string::npos && str[argumentBeg] != '-') + { + beg = argumentBeg; + end = str.find_first_of(delim, beg); + if(end == string::npos) + { + end = str.length(); + } + argument = str.substr(beg, end - beg); + } + + switch(option[1]) + { + case 'h': + { + if(argument.empty()) + { + EndpointParseException ex(__FILE__, __LINE__); + ex.str = "tcp " + str; + throw ex; + } + const_cast<string&>(_host) = argument; + break; + } + + case 'p': + { + const_cast<Int&>(_port) = atoi(argument.c_str()); + if(_port <= 0 || _port > 65535) + { + EndpointParseException ex(__FILE__, __LINE__); + ex.str = "tcp " + str; + throw ex; + } + break; + } + + case 't': + { + const_cast<Int&>(_timeout) = atoi(argument.c_str()); + if(_timeout == 0) + { + EndpointParseException ex(__FILE__, __LINE__); + ex.str = "tcp " + str; + throw ex; + } + break; + } + + case 'z': + { + // Ignore compression flag. + break; + } + + default: + { + EndpointParseException ex(__FILE__, __LINE__); + ex.str = "tcp " + str; + throw ex; + } + } } } @@ -194,11 +194,11 @@ IceInternal::TcpEndpoint::timeout(Int timeout) const { if(timeout == _timeout) { - return const_cast<TcpEndpoint*>(this); + return const_cast<TcpEndpoint*>(this); } else { - return new TcpEndpoint(_instance, _host, _port, timeout, _publish); + return new TcpEndpoint(_instance, _host, _port, timeout, _publish); } } @@ -232,42 +232,42 @@ IceInternal::TcpEndpoint::operator==(const Endpoint& r) const const TcpEndpoint* p = dynamic_cast<const TcpEndpoint*>(&r); if(!p) { - return false; + return false; } if(this == p) { - return true; + return true; } if(_port != p->_port) { - return false; + return false; } if(_timeout != p->_timeout) { - return false; + return false; } if(_host != p->_host) { - // - // We do the most time-consuming part of the comparison last. - // - struct sockaddr_in laddr; - struct sockaddr_in raddr; - try - { - getAddress(_host, _port, laddr); - getAddress(p->_host, p->_port, raddr); - } - catch(const DNSException&) - { - return false; - } - - return compareAddress(laddr, raddr); + // + // We do the most time-consuming part of the comparison last. + // + struct sockaddr_in laddr; + struct sockaddr_in raddr; + try + { + getAddress(_host, _port, laddr); + getAddress(p->_host, p->_port, raddr); + } + catch(const DNSException&) + { + return false; + } + + return compareAddress(laddr, raddr); } return true; @@ -285,63 +285,63 @@ IceInternal::TcpEndpoint::operator<(const Endpoint& r) const const TcpEndpoint* p = dynamic_cast<const TcpEndpoint*>(&r); if(!p) { - return type() < r.type(); + return type() < r.type(); } if(this == p) { - return false; + return false; } if(_port < p->_port) { - return true; + return true; } else if(p->_port < _port) { - return false; + return false; } if(_timeout < p->_timeout) { - return true; + return true; } else if(p->_timeout < _timeout) { - return false; + return false; } if(_host != p->_host) { - // - // We do the most time-consuming part of the comparison last. - // - struct sockaddr_in laddr; - try - { - getAddress(_host, _port, laddr); - } - catch(const DNSException&) - { - } - - struct sockaddr_in raddr; - try - { - getAddress(p->_host, p->_port, raddr); - } - catch(const DNSException&) - { - } - - if(laddr.sin_addr.s_addr < raddr.sin_addr.s_addr) - { - return true; - } - else if(raddr.sin_addr.s_addr < laddr.sin_addr.s_addr) - { - return false; - } + // + // We do the most time-consuming part of the comparison last. + // + struct sockaddr_in laddr; + try + { + getAddress(_host, _port, laddr); + } + catch(const DNSException&) + { + } + + struct sockaddr_in raddr; + try + { + getAddress(p->_host, p->_port, raddr); + } + catch(const DNSException&) + { + } + + if(laddr.sin_addr.s_addr < raddr.sin_addr.s_addr) + { + return true; + } + else if(raddr.sin_addr.s_addr < laddr.sin_addr.s_addr) + { + return false; + } } return false; @@ -355,14 +355,14 @@ IceInternal::TcpEndpoint::expand(bool server) const const_cast<string&>(_host) = _instance->defaultsAndOverrides()->defaultHost; if(_host.empty()) { - if(server) - { + if(server) + { const_cast<string&>(_host) = "0.0.0.0"; - } - else - { + } + else + { const_cast<string&>(_host) = "127.0.0.1"; - } + } } } else if(_host == "*") diff --git a/cppe/src/TcpTransport/Transceiver.cpp b/cppe/src/TcpTransport/Transceiver.cpp index 6ab0d9b06c8..fa31d1cdd29 100644 --- a/cppe/src/TcpTransport/Transceiver.cpp +++ b/cppe/src/TcpTransport/Transceiver.cpp @@ -48,8 +48,8 @@ IceInternal::Transceiver::close() { if(_traceLevels->network >= 1) { - Trace out(_logger, _traceLevels->networkCat); - out << "closing tcp connection\n" << toString(); + Trace out(_logger, _traceLevels->networkCat); + out << "closing tcp connection\n" << toString(); } #ifdef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS @@ -67,13 +67,13 @@ IceInternal::Transceiver::close() assert(_fd != INVALID_SOCKET); try { - closeSocket(_fd); - _fd = INVALID_SOCKET; + closeSocket(_fd); + _fd = INVALID_SOCKET; } catch(const SocketException&) { - _fd = INVALID_SOCKET; - throw; + _fd = INVALID_SOCKET; + throw; } } @@ -82,8 +82,8 @@ IceInternal::Transceiver::shutdownWrite() { if(_traceLevels->network >= 2) { - Trace out(_logger, _traceLevels->networkCat); - out << "shutting down tcp connection for writing\n" << toString(); + Trace out(_logger, _traceLevels->networkCat); + out << "shutting down tcp connection for writing\n" << toString(); } assert(_fd != INVALID_SOCKET); @@ -95,8 +95,8 @@ IceInternal::Transceiver::shutdownReadWrite() { if(_traceLevels->network >= 2) { - Trace out(_logger, _traceLevels->networkCat); - out << "shutting down tcp connection for reading and writing\n" << toString(); + Trace out(_logger, _traceLevels->networkCat); + out << "shutting down tcp connection for reading and writing\n" << toString(); } assert(_fd != INVALID_SOCKET); @@ -115,113 +115,113 @@ IceInternal::Transceiver::writeWithTimeout(Buffer& buf, int timeout) // if(packetSize > _maxPacketSize) { - packetSize = _maxPacketSize; + packetSize = _maxPacketSize; } #endif #ifndef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS if(timeout > 0 && timeout != _writeTimeout) { - setTimeout(_fd, false, timeout); + setTimeout(_fd, false, timeout); } try - { + { #endif - while(buf.i != buf.b.end()) - { - repeatSend: - assert(_fd != INVALID_SOCKET); - ssize_t ret = ::send(_fd, reinterpret_cast<const char*>(&*buf.i), packetSize, 0); - - if(ret == 0) - { - ConnectionLostException ex(__FILE__, __LINE__); - ex.error = 0; - throw ex; - } - - if(ret == SOCKET_ERROR) - { - if(interrupted()) - { - goto repeatSend; - } - - if(noBuffers() && packetSize > 1024) - { - packetSize /= 2; - goto repeatSend; - } - + while(buf.i != buf.b.end()) + { + repeatSend: + assert(_fd != INVALID_SOCKET); + ssize_t ret = ::send(_fd, reinterpret_cast<const char*>(&*buf.i), packetSize, 0); + + if(ret == 0) + { + ConnectionLostException ex(__FILE__, __LINE__); + ex.error = 0; + throw ex; + } + + if(ret == SOCKET_ERROR) + { + if(interrupted()) + { + goto repeatSend; + } + + if(noBuffers() && packetSize > 1024) + { + packetSize /= 2; + goto repeatSend; + } + #ifndef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS - if(timedout()) - { - throw TimeoutException(__FILE__, __LINE__); - } + if(timedout()) + { + throw TimeoutException(__FILE__, __LINE__); + } #else - if(wouldBlock()) - { - doSelect(false, timeout > 0 ? timeout : _writeTimeout); - continue; - } + if(wouldBlock()) + { + doSelect(false, timeout > 0 ? timeout : _writeTimeout); + continue; + } #endif - if(connectionLost()) - { - ConnectionLostException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else - { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - } - - if(_traceLevels->network >= 3) - { - Trace out(_logger, _traceLevels->networkCat); - out << Ice::printfToString("sent %d of %d", ret, packetSize) << " bytes via tcp\n" << toString(); - } - - buf.i += ret; - - if(packetSize > buf.b.end() - buf.i) - { - packetSize = static_cast<Buffer::Container::difference_type>(buf.b.end() - buf.i); - } - } + if(connectionLost()) + { + ConnectionLostException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else + { + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + } + + if(_traceLevels->network >= 3) + { + Trace out(_logger, _traceLevels->networkCat); + out << Ice::printfToString("sent %d of %d", ret, packetSize) << " bytes via tcp\n" << toString(); + } + + buf.i += ret; + + if(packetSize > buf.b.end() - buf.i) + { + packetSize = static_cast<Buffer::Container::difference_type>(buf.b.end() - buf.i); + } + } #ifndef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS } catch(const Ice::LocalException&) { - if(timeout > 0 && timeout != _writeTimeout) - { - try - { - setTimeout(_fd, false, _writeTimeout); - } - catch(const Ice::LocalException&) - { - // IGNORE - } - } - throw; + if(timeout > 0 && timeout != _writeTimeout) + { + try + { + setTimeout(_fd, false, _writeTimeout); + } + catch(const Ice::LocalException&) + { + // IGNORE + } + } + throw; } if(timeout > 0 && timeout != _writeTimeout) { - try - { - setTimeout(_fd, false, _writeTimeout); - } - catch(const Ice::LocalException&) - { - // IGNORE - } + try + { + setTimeout(_fd, false, _writeTimeout); + } + catch(const Ice::LocalException&) + { + // IGNORE + } } #endif } @@ -232,129 +232,129 @@ IceInternal::Transceiver::readWithTimeout(Buffer& buf, int timeout) assert(timeout != 0); Buffer::Container::difference_type packetSize = - static_cast<Buffer::Container::difference_type>(buf.b.end() - buf.i); + static_cast<Buffer::Container::difference_type>(buf.b.end() - buf.i); #ifndef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS if(timeout > 0 && timeout != _readTimeout) { - setTimeout(_fd, true, timeout); + setTimeout(_fd, true, timeout); } try { #endif - while(buf.i != buf.b.end()) - { - repeatRead: - assert(_fd != INVALID_SOCKET); - ssize_t ret = ::recv(_fd, reinterpret_cast<char*>(&*buf.i), packetSize, 0); - - if(ret == 0) - { - // - // If the connection is lost when reading data, we shut - // down the write end of the socket. This helps to unblock - // threads that are stuck in send() or select() while - // sending data. Note: I don't really understand why - // send() or select() sometimes don't detect a connection - // loss. Therefore this helper to make them detect it. - // - //assert(_fd != INVALID_SOCKET); - //shutdownSocketReadWrite(_fd); - - ConnectionLostException ex(__FILE__, __LINE__); - ex.error = 0; - throw ex; - } - - if(ret == SOCKET_ERROR) - { - if(interrupted()) - { - goto repeatRead; - } - - if(noBuffers() && packetSize > 1024) - { - packetSize /= 2; - goto repeatRead; - } - + while(buf.i != buf.b.end()) + { + repeatRead: + assert(_fd != INVALID_SOCKET); + ssize_t ret = ::recv(_fd, reinterpret_cast<char*>(&*buf.i), packetSize, 0); + + if(ret == 0) + { + // + // If the connection is lost when reading data, we shut + // down the write end of the socket. This helps to unblock + // threads that are stuck in send() or select() while + // sending data. Note: I don't really understand why + // send() or select() sometimes don't detect a connection + // loss. Therefore this helper to make them detect it. + // + //assert(_fd != INVALID_SOCKET); + //shutdownSocketReadWrite(_fd); + + ConnectionLostException ex(__FILE__, __LINE__); + ex.error = 0; + throw ex; + } + + if(ret == SOCKET_ERROR) + { + if(interrupted()) + { + goto repeatRead; + } + + if(noBuffers() && packetSize > 1024) + { + packetSize /= 2; + goto repeatRead; + } + #ifndef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS - if(timedout()) - { - throw TimeoutException(__FILE__, __LINE__); - } + if(timedout()) + { + throw TimeoutException(__FILE__, __LINE__); + } #else - if(wouldBlock()) - { - doSelect(true, timeout > 0 ? timeout : _readTimeout); - continue; - } + if(wouldBlock()) + { + doSelect(true, timeout > 0 ? timeout : _readTimeout); + continue; + } #endif - - if(connectionLost()) - { - // - // See the commment above about shutting down the - // socket if the connection is lost while reading - // data. - // - //assert(_fd != INVALID_SOCKET); - //shutdownSocketReadWrite(_fd); - - ConnectionLostException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else - { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - } - - if(_traceLevels->network >= 3) - { - Trace out(_logger, _traceLevels->networkCat); - out << Ice::printfToString("received %d of %d", ret, packetSize) << " bytes via tcp\n" << toString(); - } - - buf.i += ret; - - if(packetSize > buf.b.end() - buf.i) - { - packetSize = static_cast<Buffer::Container::difference_type>(buf.b.end() - buf.i); - } - } + + if(connectionLost()) + { + // + // See the commment above about shutting down the + // socket if the connection is lost while reading + // data. + // + //assert(_fd != INVALID_SOCKET); + //shutdownSocketReadWrite(_fd); + + ConnectionLostException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else + { + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + } + + if(_traceLevels->network >= 3) + { + Trace out(_logger, _traceLevels->networkCat); + out << Ice::printfToString("received %d of %d", ret, packetSize) << " bytes via tcp\n" << toString(); + } + + buf.i += ret; + + if(packetSize > buf.b.end() - buf.i) + { + packetSize = static_cast<Buffer::Container::difference_type>(buf.b.end() - buf.i); + } + } #ifndef ICEE_USE_SELECT_OR_POLL_FOR_TIMEOUTS } catch(const Ice::LocalException&) { - if(timeout > 0 && timeout != _readTimeout) - { - try - { - setTimeout(_fd, true, _readTimeout); - } - catch(const Ice::LocalException&) - { - // IGNORE - } - } - throw; + if(timeout > 0 && timeout != _readTimeout) + { + try + { + setTimeout(_fd, true, _readTimeout); + } + catch(const Ice::LocalException&) + { + // IGNORE + } + } + throw; } if(timeout > 0 && timeout != _readTimeout) { - try - { - setTimeout(_fd, true, _readTimeout); - } - catch(const Ice::LocalException&) - { - // IGNORE - } + try + { + setTimeout(_fd, true, _readTimeout); + } + catch(const Ice::LocalException&) + { + // IGNORE + } } #endif } @@ -386,24 +386,24 @@ IceInternal::Transceiver::Transceiver(const InstancePtr& instance, SOCKET fd) : _writeEvent = WSACreateEvent(); if(_event == 0 || _readEvent == 0 || _writeEvent == 0) { - int error = WSAGetLastError(); - if(_event != 0) - { - WSACloseEvent(_event); - } - if(_readEvent != 0) - { - WSACloseEvent(_readEvent); - } - if(_writeEvent != 0) - { - WSACloseEvent(_writeEvent); - } - closeSocket(_fd); - - SocketException ex(__FILE__, __LINE__); - ex.error = error; - throw ex; + int error = WSAGetLastError(); + if(_event != 0) + { + WSACloseEvent(_event); + } + if(_readEvent != 0) + { + WSACloseEvent(_readEvent); + } + if(_writeEvent != 0) + { + WSACloseEvent(_writeEvent); + } + closeSocket(_fd); + + SocketException ex(__FILE__, __LINE__); + ex.error = error; + throw ex; } // @@ -411,16 +411,16 @@ IceInternal::Transceiver::Transceiver(const InstancePtr& instance, SOCKET fd) : // if(WSAEventSelect(_fd, _event, FD_READ|FD_WRITE|FD_CLOSE) == SOCKET_ERROR) { - int error = WSAGetLastError(); + int error = WSAGetLastError(); - WSACloseEvent(_event); - WSACloseEvent(_readEvent); - WSACloseEvent(_writeEvent); - closeSocket(_fd); + WSACloseEvent(_event); + WSACloseEvent(_readEvent); + WSACloseEvent(_writeEvent); + closeSocket(_fd); - SocketException ex(__FILE__, __LINE__); - ex.error = error; - throw ex; + SocketException ex(__FILE__, __LINE__); + ex.error = error; + throw ex; } #else FD_ZERO(&_wFdSet); @@ -461,151 +461,151 @@ IceInternal::Transceiver::doSelect(bool read, int timeout) while(true) { #ifdef _WIN32 - // - // This code is basically the same as the code in - // ::send above. Check that for detailed comments. - // - WSAEVENT events[2]; - events[0] = _event; - events[1] = read ? _readEvent : _writeEvent; - long tout = (timeout >= 0) ? timeout : WSA_INFINITE; - DWORD rc = WSAWaitForMultipleEvents(2, events, FALSE, tout, FALSE); - if(rc == WSA_WAIT_FAILED) - { - SocketException ex(__FILE__, __LINE__); - ex.error = WSAGetLastError(); - throw ex; - } - if(rc == WSA_WAIT_TIMEOUT) - { - assert(timeout >= 0); - throw TimeoutException(__FILE__, __LINE__); - } - - if(rc == WSA_WAIT_EVENT_0) - { - WSANETWORKEVENTS nevents; - if(WSAEnumNetworkEvents(_fd, _event, &nevents) == SOCKET_ERROR) - { - SocketException ex(__FILE__, __LINE__); - ex.error = WSAGetLastError(); - throw ex; - } - - // - // If we're selecting for reading and have consumed a WRITE - // event, set the _writeEvent event. Otherwise, if we're - // selecting for writing have consumed a READ event, set the - // _readEvent event. - // - if(read && nevents.lNetworkEvents & FD_WRITE) - { - WSASetEvent(_writeEvent); - } - else if(!read && nevents.lNetworkEvents & FD_READ) - { - WSASetEvent(_readEvent); - } - - - // - // This checks for an error on the fd (this would - // be same as recv itself returning an error). In - // the event of an error we set the error code, - // and repeat the error handling. - // - if(read && nevents.lNetworkEvents & FD_READ && nevents.iErrorCode[FD_READ_BIT] != 0) - { - WSASetLastError(nevents.iErrorCode[FD_READ_BIT]); - } - else if(!read && nevents.lNetworkEvents & FD_WRITE && nevents.iErrorCode[FD_WRITE_BIT] != 0) - { - WSASetLastError(nevents.iErrorCode[FD_WRITE_BIT]); - } - else if(nevents.lNetworkEvents & FD_CLOSE && nevents.iErrorCode[FD_CLOSE_BIT] != 0) - { - WSASetLastError(nevents.iErrorCode[FD_CLOSE_BIT]); - } - else - { - return; // No errors: we're done. - } - - if(interrupted()) - { - continue; - } - - if(connectionLost()) - { - // - // See the commment above about shutting down the - // socket if the connection is lost while reading - // data. - // - //assert(_fd != INVALID_SOCKET); - //shutdownSocketReadWrite(_fd); - - ConnectionLostException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - else - { - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - } - else - { - // - // Otherwise the _readEvent or _writeEvent is set, reset it. - // - if(read) - { - WSAResetEvent(_readEvent); - } - else - { - WSAResetEvent(_writeEvent); - } - return; - } + // + // This code is basically the same as the code in + // ::send above. Check that for detailed comments. + // + WSAEVENT events[2]; + events[0] = _event; + events[1] = read ? _readEvent : _writeEvent; + long tout = (timeout >= 0) ? timeout : WSA_INFINITE; + DWORD rc = WSAWaitForMultipleEvents(2, events, FALSE, tout, FALSE); + if(rc == WSA_WAIT_FAILED) + { + SocketException ex(__FILE__, __LINE__); + ex.error = WSAGetLastError(); + throw ex; + } + if(rc == WSA_WAIT_TIMEOUT) + { + assert(timeout >= 0); + throw TimeoutException(__FILE__, __LINE__); + } + + if(rc == WSA_WAIT_EVENT_0) + { + WSANETWORKEVENTS nevents; + if(WSAEnumNetworkEvents(_fd, _event, &nevents) == SOCKET_ERROR) + { + SocketException ex(__FILE__, __LINE__); + ex.error = WSAGetLastError(); + throw ex; + } + + // + // If we're selecting for reading and have consumed a WRITE + // event, set the _writeEvent event. Otherwise, if we're + // selecting for writing have consumed a READ event, set the + // _readEvent event. + // + if(read && nevents.lNetworkEvents & FD_WRITE) + { + WSASetEvent(_writeEvent); + } + else if(!read && nevents.lNetworkEvents & FD_READ) + { + WSASetEvent(_readEvent); + } + + + // + // This checks for an error on the fd (this would + // be same as recv itself returning an error). In + // the event of an error we set the error code, + // and repeat the error handling. + // + if(read && nevents.lNetworkEvents & FD_READ && nevents.iErrorCode[FD_READ_BIT] != 0) + { + WSASetLastError(nevents.iErrorCode[FD_READ_BIT]); + } + else if(!read && nevents.lNetworkEvents & FD_WRITE && nevents.iErrorCode[FD_WRITE_BIT] != 0) + { + WSASetLastError(nevents.iErrorCode[FD_WRITE_BIT]); + } + else if(nevents.lNetworkEvents & FD_CLOSE && nevents.iErrorCode[FD_CLOSE_BIT] != 0) + { + WSASetLastError(nevents.iErrorCode[FD_CLOSE_BIT]); + } + else + { + return; // No errors: we're done. + } + + if(interrupted()) + { + continue; + } + + if(connectionLost()) + { + // + // See the commment above about shutting down the + // socket if the connection is lost while reading + // data. + // + //assert(_fd != INVALID_SOCKET); + //shutdownSocketReadWrite(_fd); + + ConnectionLostException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + else + { + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + } + else + { + // + // Otherwise the _readEvent or _writeEvent is set, reset it. + // + if(read) + { + WSAResetEvent(_readEvent); + } + else + { + WSAResetEvent(_writeEvent); + } + return; + } #else - int rs; - assert(_fd != INVALID_SOCKET); - if(read) - { - FD_SET(_fd, &_rFdSet); - } - else - { - FD_SET(_fd, &_wFdSet); - } - + int rs; + assert(_fd != INVALID_SOCKET); + if(read) + { + FD_SET(_fd, &_rFdSet); + } + else + { + FD_SET(_fd, &_wFdSet); + } + struct pollfd pollFd[1]; pollFd[0].fd = _fd; pollFd[0].events = read ? POLLIN : POLLOUT; rs = ::poll(pollFd, 1, timeout); - if(rs == SOCKET_ERROR) - { - if(interrupted()) - { - continue; - } - - SocketException ex(__FILE__, __LINE__); - ex.error = getSocketErrno(); - throw ex; - } - - if(rs == 0) - { - throw TimeoutException(__FILE__, __LINE__); - } - - return; + if(rs == SOCKET_ERROR) + { + if(interrupted()) + { + continue; + } + + SocketException ex(__FILE__, __LINE__); + ex.error = getSocketErrno(); + throw ex; + } + + if(rs == 0) + { + throw TimeoutException(__FILE__, __LINE__); + } + + return; #endif } } |