int StreamConverterBuf::writeToDevice(char c)
{
poco_assert_dbg (_pOstr);
if (_sequenceLength == 0)
{
int n = _inEncoding.characterMap()[(unsigned char) c];
if (n == -1)
{
++_errors;
return -1;
}
_buffer[0] = (unsigned char) c;
_sequenceLength = n < 0 ? -n : 1;
_pos = 1;
}
else _buffer[_pos++] = (unsigned char) c;
if (_pos == _sequenceLength)
{
int uc = _inEncoding.convert(_buffer);
if (uc == -1)
{
++_errors;
return -1;
}
int n = _outEncoding.convert(uc, _buffer, sizeof(_buffer));
if (n == 0) n = _outEncoding.convert(_defaultChar, _buffer, sizeof(_buffer));
poco_assert_dbg (n <= sizeof(_buffer));
_pOstr->write((char*) _buffer, n);
_sequenceLength = 0;
_pos = 0;
}
return charToInt(c);
}
int StreamConverterBuf::writeToDevice(char c)
{
poco_assert_dbg (_pOstr);
_buffer[_pos++] = (unsigned char) c;
if (_sequenceLength == 0 || _sequenceLength == _pos)
{
int n = _inEncoding.queryConvert(_buffer, _pos);
if (-1 <= n)
{
int uc = n;
if (-1 == n)
{
++_errors;
return -1;
}
int n1 = _outEncoding.convert(uc, _buffer, sizeof(_buffer));
if (n1 == 0) n1 = _outEncoding.convert(_defaultChar, _buffer, sizeof(_buffer));
poco_assert_dbg (n1 <= sizeof(_buffer));
_pOstr->write((char*) _buffer, n1);
_sequenceLength = 0;
_pos = 0;
}
else
{
_sequenceLength = -n;
}
}
return charToInt(c);
}
CodeGenerator::FwdDecl::FwdDecl(const std::string& inc, const std::string& cN, const std::string& ns):
includeFile(inc),
className(cN),
fullNameSpace(ns)
{
poco_assert_dbg (!includeFile.empty());
poco_assert_dbg (!className.empty());
}
std::string URIUtility::createURIPath(const Identifiable::ObjectId& oid, const Identifiable::TypeId& tid, const std::string& protocol)
{
poco_assert_dbg(!oid.empty());
poco_assert_dbg(!tid.empty());
poco_assert_dbg(!protocol.empty());
std::string result("/");
result += protocol;
result += '/';
result += tid;
result += '/';
result += oid;
return result;
}
ZipLocalFileHeader::ZipLocalFileHeader(std::istream& inp, bool assumeHeaderRead, ParseCallback& callback):
_forceZip64(false),
_rawHeader(),
_startPos(inp.tellg()),
_endPos(-1),
_fileName(),
_lastModifiedAt(),
_extraField(),
_crc32(0),
_compressedSize(0),
_uncompressedSize(0)
{
poco_assert_dbg( (EXTRA_FIELD_POS+EXTRA_FIELD_LENGTH) == FULLHEADER_SIZE);
if (assumeHeaderRead)
_startPos -= ZipCommon::HEADER_SIZE;
parse(inp, assumeHeaderRead);
bool ok = callback.handleZipEntry(inp, *this);
if (ok)
{
if (searchCRCAndSizesAfterData())
{
char header[ZipCommon::HEADER_SIZE]={'\x00', '\x00', '\x00', '\x00'};
inp.read(header, ZipCommon::HEADER_SIZE);
if (std::memcmp(header, ZipDataInfo64::HEADER, sizeof(header)) == 0)
{
ZipDataInfo64 nfo(inp, true);
setCRC(nfo.getCRC32());
setCompressedSize(nfo.getCompressedSize());
setUncompressedSize(nfo.getUncompressedSize());
}
else
{
ZipDataInfo nfo(inp, true);
setCRC(nfo.getCRC32());
setCompressedSize(nfo.getCompressedSize());
setUncompressedSize(nfo.getUncompressedSize());
}
}
}
else
{
poco_assert_dbg(!searchCRCAndSizesAfterData());
ZipUtil::sync(inp);
}
_endPos = _startPos + getHeaderSize() + _compressedSize; // exclude the data block!
}
bool RWLockImpl::tryWriteLockImpl()
{
addWriter();
HANDLE h[2];
h[0] = _mutex;
h[1] = _writeEvent;
switch (WaitForMultipleObjects(2, h, TRUE, 1))
{
case WAIT_OBJECT_0:
case WAIT_OBJECT_0 + 1:
--_writersWaiting;
++_readers;
++_writers;
ResetEvent(_readEvent);
ResetEvent(_writeEvent);
ReleaseMutex(_mutex);
poco_assert_dbg(_writers == 1);
return true;
case WAIT_TIMEOUT:
removeWriter();
return false;
default:
removeWriter();
throw SystemException("cannot lock reader/writer lock");
}
}
void SessionImpl::open(const std::string& connect)
{
if (connect != connectionString())
{
if (isConnected())
throw InvalidAccessException("Session already connected");
if (!connect.empty())
setConnectionString(connect);
}
poco_assert_dbg (!connectionString().empty());
try
{
ActiveConnector connector(connectionString(), &_pDB);
ActiveResult<int> result = connector.connect();
if (!result.tryWait(getLoginTimeout() * 1000))
throw ConnectionFailedException("Timed out.");
int rc = result.data();
if (rc != 0)
{
close();
Utility::throwException(rc);
}
}
catch (SQLiteException& ex)
{
throw ConnectionFailedException(ex.displayText());
}
_connected = true;
}
Var Var::parseObject(const std::string& val, std::string::size_type& pos)
{
poco_assert_dbg (val[pos] == '{');
++pos;
skipWhiteSpace(val, pos);
DynamicStruct aStruct;
while (val[pos] != '}' && pos < val.size())
{
std::string key = parseString(val, pos);
skipWhiteSpace(val, pos);
if (val[pos] != ':')
throw DataFormatException("Incorrect object, must contain: key : value pairs");
++pos; // skip past :
Var value = parse(val, pos);
aStruct.insert(key, value);
skipWhiteSpace(val, pos);
if (val[pos] == ',')
{
++pos;
skipWhiteSpace(val, pos);
}
}
if (val[pos] != '}')
throw DataFormatException("Unterminated object");
++pos;
return aStruct;
}
bool FrameQueue::handleFrame(Connection::Ptr pConnection, Frame::Ptr pFrame)
{
poco_assert_dbg (pConnection == _pConnection);
if ((_frameType == 0 || pFrame->type() == _frameType) && pFrame->channel() == _channel)
{
{
Poco::FastMutex::ScopedLock lock(_mutex);
int rounds = 0;
while (_queue.size() == MAX_QUEUE_SIZE && rounds < 100)
{
Poco::ScopedUnlock<Poco::FastMutex> unlock(_mutex);
Poco::Thread::sleep(5);
rounds++;
}
if (_queue.size() < MAX_QUEUE_SIZE)
{
_queue.push_back(pFrame);
_sema.set();
return true;
}
}
}
return false;
}
void ConfigurationMapper::enumerate(const std::string& key, Keys& range) const
{
std::string cKey(key);
if (!cKey.empty()) cKey += '.';
std::string::size_type keyLen = cKey.length();
if (keyLen < _toPrefix.length())
{
if (_toPrefix.compare(0, keyLen, cKey) == 0)
{
std::string::size_type pos = _toPrefix.find_first_of('.', keyLen);
poco_assert_dbg(pos != std::string::npos);
range.push_back(_toPrefix.substr(keyLen, pos - keyLen));
}
}
else
{
std::string translatedKey;
if (cKey == _toPrefix)
{
translatedKey = _fromPrefix;
if (!translatedKey.empty())
translatedKey.resize(translatedKey.length() - 1);
}
else translatedKey = translateKey(key);
_pConfig->enumerate(translatedKey, range);
}
}
void ParseHandler::startArray()
{
Array::Ptr newArr = new Array();
if ( _stack.empty() ) // The first array
{
_result = newArr;
}
else
{
Var parent = _stack.top();
if ( parent.type() == typeid(Array::Ptr) )
{
Array::Ptr arr = parent.extract<Array::Ptr>();
arr->add(newArr);
}
else if ( parent.type() == typeid(Object::Ptr) )
{
poco_assert_dbg(!_key.empty());
Object::Ptr obj = parent.extract<Object::Ptr>();
obj->set(_key, newArr);
_key.clear();
}
}
_stack.push(newArr);
}
std::string ZipUtil::fakeZLibInitString(ZipCommon::CompressionLevel cl)
{
std::string init(2, ' ');
// compression info:
// deflate is used, bit 0-3: 0x08
// dictionary size is always 32k: calc ld2(32k)-8 = ld2(2^15) - 8 = 15 - 8 = 7 --> bit 4-7: 0x70
init[0] = '\x78';
// now fake flags
// bits 0-4 check bits: set them so that init[0]*256+init[1] % 31 == 0
// bit 5: preset dictionary? always no for us, set to 0
// bits 6-7: compression level: 00 very fast, 01 fast, 10 normal, 11 best
if (cl == ZipCommon::CL_SUPERFAST)
init[1] = '\x00';
else if (cl == ZipCommon::CL_FAST)
init[1] = '\x40';
else if (cl == ZipCommon::CL_NORMAL)
init[1] = '\x80';
else
init[1] = '\xc0';
// now set the last 5 bits
Poco::UInt16 tmpVal = ((Poco::UInt16)init[0])*256+((unsigned char)init[1]);
char checkBits = (31 - (char)(tmpVal%31));
init[1] |= checkBits; // set the lower 5 bits
tmpVal = ((Poco::UInt16)init[0])*256+((unsigned char)init[1]);
poco_assert_dbg ((tmpVal % 31) == 0);
return init;
}
void ZipLocalFileHeader::setFileName(const std::string& fileName, bool isDirectory)
{
poco_assert (!fileName.empty());
Poco::Path aPath(fileName);
if (isDirectory)
{
aPath.makeDirectory();
setCRC(0);
setCompressedSize(0);
setUncompressedSize(0);
setCompressionMethod(ZipCommon::CM_STORE);
setCompressionLevel(ZipCommon::CL_NORMAL);
}
else
{
aPath.makeFile();
}
_fileName = aPath.toString(Poco::Path::PATH_UNIX);
if (_fileName[0] == '/')
_fileName = _fileName.substr(1);
if (isDirectory)
{
poco_assert_dbg (_fileName[_fileName.size()-1] == '/');
}
setFileNameLength(static_cast<Poco::UInt16>(_fileName.size()));
}
void MQFunctions::inq(MQHCONN conn, MQHOBJ obj, MQLONG selectorCount, MQLONG* selectors, MQLONG intAttrCount, MQLONG* intAttrs, MQLONG charAttrLength, PMQCHAR charAttrs, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_inqFn != NULL);
_inqFn(conn, obj, selectorCount, selectors, intAttrCount, intAttrs, charAttrLength, charAttrs, cc, rc);
trace("", "MQINQ", cc, rc);
}
void MQFunctions::get(MQHCONN conn, MQHOBJ obj, MQMD* md, MQGMO* options, MQLONG size, MQBYTE* buffer, MQLONG* dataLength, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_getFn != NULL);
_getFn(conn, obj, md, options, size, buffer, dataLength, cc, rc);
trace("", "MQGET", cc, rc);
}
void MQFunctions::inqmp(MQHCONN conn, MQHMSG hmsg, MQIMPO* options, MQCHARV* name, MQPD* propDesc, MQLONG* type, MQLONG valueLength, MQBYTE* value, MQLONG* dataLength, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_inqMpFn != NULL);
_inqMpFn(conn, hmsg, options, name, propDesc, type, valueLength, value, dataLength, cc, rc);
trace("", "MQINQMP", cc, rc);
}
void MQFunctions::dltmp(MQHCONN conn, MQHMSG hmsg, MQDMPO* options, MQCHARV* name, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_dltMpFn != NULL);
_dltMpFn(conn, hmsg, options, name, cc, rc);
trace("", "MQDLTMP", cc, rc);
}
void MQFunctions::setmp(MQHCONN conn, MQHMSG hmsg, MQSMPO* options, MQCHARV* name, MQPD* propDesc, MQLONG type, MQLONG valueLength, MQBYTE* value, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_setMpFn != NULL);
_setMpFn(conn, hmsg, options, name, propDesc, type, valueLength, value, cc, rc);
trace("", "MQSETMP", cc, rc);
}
void MQFunctions::dltmh(MQHCONN conn, MQHMSG* hmsg, MQDMHO* options, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_dltMhFn != NULL);
_dltMhFn(conn, hmsg, options, cc, rc);
trace("", "MQDLTMH", cc, rc);
}
void MQFunctions::crtmh(MQHCONN conn, MQCMHO* options, MQHMSG* hmsg, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_crtMhFn != NULL);
_crtMhFn(conn, options, hmsg, cc, rc);
trace("", "MQCRTMH", cc, rc);
}
void MQFunctions::ctl(MQHCONN conn, MQLONG operation, MQCTLO* options, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_ctlFn != NULL);
_ctlFn(conn, operation, options, cc, rc);
trace("", "MQCTL", cc, rc);
}
void MQFunctions::cb(MQHCONN conn, MQLONG operation, MQCBD* callbackDesc, MQHOBJ obj, MQMD* md, MQGMO* gmo, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_cbFn != NULL);
_cbFn(conn, operation, callbackDesc, obj, md, gmo, cc, rc);
trace("", "MQCB", cc, rc);
}
void MQFunctions::close(MQHCONN conn, MQHOBJ* obj, MQLONG options, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_closeFn != NULL);
_closeFn(conn, obj, options, cc, rc);
trace("", "MQCLOSE", cc, rc);
}
void MQFunctions::put(MQHCONN conn, MQHOBJ obj, MQMD* md, MQPMO* options, MQLONG size, MQBYTE* buffer, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_putFn != NULL);
_putFn(conn, obj, md, options, size, buffer, cc, rc);
trace("", "MQPUT", cc, rc);
}
void MQFunctions::conn(char* qmgrName, MQHCONN* hconn, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_connFn != NULL);
_connFn(qmgrName, hconn, cc, rc);
trace(qmgrName, "MQCONN", cc, rc);
}
void MQFunctions::disc(PMQHCONN conn, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_discFn != NULL);
_discFn(conn, cc, rc);
trace("", "MQDISC", cc, rc);
}
ZipArchive::ZipArchive(std::istream& in, ParseCallback& pc):
_entries(),
_infos(),
_disks()
{
poco_assert_dbg (in);
parse(in, pc);
}
void MQFunctions::connx(char* qmgrName, MQCNO* connectOpts, MQHCONN* hconn, MQLONG* cc, MQLONG* rc)
{
poco_assert_dbg(_connxFn != NULL);
_connxFn(qmgrName, connectOpts, hconn, cc, rc);
trace(qmgrName, "MQCONNX", cc, rc);
}
int StreamConverterBuf::readFromDevice()
{
poco_assert_dbg (_pIstr);
if (_pos < _sequenceLength) return _buffer[_pos++];
_pos = 0;
_sequenceLength = 0;
int c = _pIstr->get();
if (c == -1) return -1;
poco_assert (c < 256);
int uc;
int n = _inEncoding.characterMap()[c];
if (n == -1)
{
uc = _defaultChar;
++_errors;
}
else if (n >= 0)
uc = n;
else
{
poco_assert_dbg(-n <= sizeof(_buffer));
_buffer[0] = (unsigned char) c;
_pIstr->read((char*) _buffer + 1, -n - 1);
if (_pIstr->gcount() == -n - 1)
{
uc = _inEncoding.convert(_buffer);
if (uc == -1) uc = _defaultChar;
}
else
{
uc = _defaultChar;
++_errors;
}
}
_sequenceLength = _outEncoding.convert(uc, _buffer, sizeof(_buffer));
if (_sequenceLength == 0)
_sequenceLength = _outEncoding.convert(_defaultChar, _buffer, sizeof(_buffer));
if (_sequenceLength == 0)
return -1;
else
return _buffer[_pos++];
}
ZipArchive::ZipArchive(std::istream& in):
_entries(),
_infos(),
_disks()
{
poco_assert_dbg (in);
SkipCallback skip;
parse(in, skip);
}
