mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-10-29 15:21:53 +00:00
cefda8c965
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@18931 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
728 lines
15 KiB
C++
728 lines
15 KiB
C++
/*
|
|
* Copyright (C) 2005-2010 Alfresco Software Limited.
|
|
*
|
|
* This file is part of Alfresco
|
|
*
|
|
* Alfresco is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Alfresco is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Alfresco. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "util\DataBuffer.h"
|
|
#include "util\Exception.h"
|
|
|
|
using namespace Alfresco;
|
|
using namespace std;
|
|
|
|
// Use a macro for buffer overflow checks
|
|
|
|
#define CHECK_BUFFER(sz) {if ((( m_buflen + m_offset) - m_pos) < sz) throw ArrayIndexOutOfBoundsException(__FILE__, __LINE__, L"DataBuffer overflow"); }
|
|
#define CHECK_BUFFER_POS(pos,sz) {if ((( m_buflen + m_offset) - pos) < sz) throw ArrayIndexOutOfBoundsException(__FILE__, __LINE__, L"DataBuffer overflow"); }
|
|
|
|
#define EXTEND_CHECK(sz) {if ((( m_buflen + m_offset) - m_pos) < sz) extendBuffer(); }
|
|
#define EXTEND_CHECK_POS(pos,sz) {if ((( m_buflen + m_offset) - pos) < sz) extendBuffer(); }
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param siz unsigned int
|
|
*/
|
|
DataBuffer::DataBuffer( unsigned int siz) {
|
|
m_buf = new unsigned char[siz];
|
|
m_buflen = siz;
|
|
|
|
m_owner = true;
|
|
|
|
m_pos = 0;
|
|
m_endpos = 0;
|
|
m_offset = 0;
|
|
}
|
|
|
|
/**
|
|
* Class constructor
|
|
*
|
|
* @param buf BUFPTR
|
|
* @param off BUFPOS
|
|
* @param len BUFLEN
|
|
*/
|
|
DataBuffer::DataBuffer( BUFPTR buf, BUFPOS off, BUFLEN len) {
|
|
m_buf = buf;
|
|
m_buflen = len;
|
|
|
|
m_owner = false;
|
|
|
|
m_pos = off;
|
|
m_offset = off;
|
|
m_endpos = off + len;
|
|
}
|
|
|
|
/**
|
|
* Class destructor
|
|
*/
|
|
DataBuffer::~DataBuffer() {
|
|
|
|
// Delete the buffer, if owned by this object
|
|
|
|
if ( m_owner == true && m_buf != NULL)
|
|
delete[] m_buf;
|
|
}
|
|
|
|
/**
|
|
* Return the buffer length
|
|
*
|
|
* @return BUFLEN
|
|
*/
|
|
BUFLEN DataBuffer::getLength( void) const {
|
|
if ( m_endpos != 0)
|
|
return m_endpos - m_offset;
|
|
return m_pos - m_offset;
|
|
}
|
|
|
|
/**
|
|
* Return the length in words
|
|
*
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int DataBuffer::getLengthInWords( void) const {
|
|
return getLength() / 2;
|
|
}
|
|
|
|
/**
|
|
* Return the available buffer length
|
|
*
|
|
* @return BUFLEN
|
|
*/
|
|
BUFLEN DataBuffer::getAvailableLength( void) const {
|
|
if ( m_endpos == 0)
|
|
return 0;
|
|
return m_endpos - m_pos;
|
|
}
|
|
|
|
/**
|
|
* Get a byte from the buffer and advance the buffer pointer
|
|
*
|
|
* @return unsigned char
|
|
*/
|
|
unsigned char DataBuffer::getByte( void) {
|
|
|
|
// Check if there is enough space in the buffer for the data
|
|
|
|
CHECK_BUFFER(1);
|
|
|
|
// Return the data
|
|
|
|
return (unsigned int) m_buf[m_pos++];
|
|
}
|
|
|
|
/**
|
|
* Get a short/16bit value from the buffer and advance the buffer pointer
|
|
*
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int DataBuffer::getShort( void) {
|
|
|
|
// Check if there is enough space in the buffer for the data
|
|
|
|
CHECK_BUFFER(2);
|
|
|
|
// Get a short value from the buffer
|
|
|
|
unsigned int sval = DataPacker::getIntelShort( m_buf, m_pos);
|
|
m_pos += 2;
|
|
return sval;
|
|
}
|
|
|
|
/**
|
|
* Get an integer from the buffer and advance the buffer pointer
|
|
*
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int DataBuffer::getInt( void) {
|
|
|
|
// Check if there is enough space in the buffer for the data
|
|
|
|
CHECK_BUFFER(4);
|
|
|
|
// Get a short value from the buffer
|
|
|
|
unsigned int ival = DataPacker::getIntelInt( m_buf, m_pos);
|
|
m_pos += 4;
|
|
return ival;
|
|
}
|
|
|
|
/**
|
|
* Get a long from the buffer and advance the buffer pointer
|
|
*
|
|
* @return LONG64
|
|
*/
|
|
LONG64 DataBuffer::getLong( void) {
|
|
|
|
// Check if there is enough space in the buffer for the data
|
|
|
|
CHECK_BUFFER(8);
|
|
|
|
// Get a long value from the buffer
|
|
|
|
LONG64 lval = DataPacker::getIntelLong( m_buf, m_pos);
|
|
m_pos += 8;
|
|
return lval;
|
|
}
|
|
|
|
/**
|
|
* Get a string from the buffer and advance the buffer pointer
|
|
*
|
|
* @param uni bool
|
|
* @return String
|
|
*/
|
|
String DataBuffer::getString( bool uni) {
|
|
return getString( getAvailableLength(), uni);
|
|
}
|
|
|
|
/**
|
|
* Get a string from the buffer and advance the buffer pointer
|
|
*
|
|
* @param maxlen unsigned int
|
|
* @param uni bool
|
|
* @return String
|
|
*/
|
|
String DataBuffer::getString( unsigned int maxlen, bool uni) {
|
|
|
|
// Check for Unicode or ASCII
|
|
|
|
String ret;
|
|
unsigned int availLen = 0;
|
|
|
|
if ( uni) {
|
|
|
|
// Word align the current buffer position, calculate the available length
|
|
|
|
m_pos = DataPacker::wordAlign(m_pos);
|
|
availLen = (m_endpos - m_pos) / 2;
|
|
if ( availLen < maxlen)
|
|
maxlen = availLen;
|
|
|
|
ret = DataPacker::getUnicodeString(m_buf, m_pos, maxlen);
|
|
if ( ret.length() < maxlen)
|
|
m_pos += (ret.length() * 2) + 2;
|
|
else
|
|
m_pos += maxlen * 2;
|
|
}
|
|
else {
|
|
|
|
// Calculate the available length
|
|
|
|
availLen = m_endpos - m_pos;
|
|
if ( availLen < maxlen)
|
|
maxlen = availLen;
|
|
|
|
// Unpack the ASCII string
|
|
|
|
ret = DataPacker::getString(m_buf, m_pos, maxlen);
|
|
if ( ret.length() < maxlen)
|
|
m_pos += ret.length() + 1;
|
|
else
|
|
m_pos += maxlen;
|
|
}
|
|
|
|
// Return the string
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Get a short value at the specified buffer position
|
|
*
|
|
* @param idx unsigned int
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int DataBuffer::getShortAt( unsigned int idx) {
|
|
|
|
// Check if there is enough data in the buffer
|
|
|
|
BUFPOS pos = m_offset + (idx * 2);
|
|
CHECK_BUFFER_POS(pos, 2);
|
|
|
|
// Unpack the short value
|
|
|
|
return DataPacker::getIntelShort(m_buf, pos);
|
|
}
|
|
|
|
/**
|
|
* Get an integer value at the specified buffer position
|
|
*
|
|
* @param idx unsigned int
|
|
* @return unsigned int
|
|
*/
|
|
unsigned int DataBuffer::getIntAt( unsigned int idx) {
|
|
|
|
// Check if there is enough data in the buffer
|
|
|
|
BUFPOS pos = m_offset + (idx * 4);
|
|
CHECK_BUFFER_POS(pos, 4);
|
|
|
|
// Unpack the integer value
|
|
|
|
return DataPacker::getIntelInt(m_buf, pos);
|
|
}
|
|
|
|
/**
|
|
* Get a long value at the specified buffer position
|
|
*
|
|
* @param idx unsigned int
|
|
* @return LONG64
|
|
*/
|
|
LONG64 DataBuffer::getLongAt( unsigned int idx) {
|
|
|
|
// Check if there is enough data in the buffer
|
|
|
|
BUFPOS pos = m_offset + (idx * 8);
|
|
CHECK_BUFFER_POS(pos, 8);
|
|
|
|
// Unpack the long value
|
|
|
|
return DataPacker::getIntelLong(m_buf, pos);
|
|
}
|
|
|
|
/**
|
|
* Append a byte to the buffer and advance the buffer pointer
|
|
*
|
|
* @param byt unsigned char
|
|
*/
|
|
void DataBuffer::putByte( unsigned char byt) {
|
|
|
|
// Check if the buffer needs extending
|
|
|
|
EXTEND_CHECK(1);
|
|
|
|
// Pack the data, update the buffer pointer
|
|
|
|
m_buf[m_pos++] = byt;
|
|
}
|
|
|
|
/**
|
|
* Append a short to the buffer and advance the buffer pointer
|
|
*
|
|
* @param sval unsigned int
|
|
*/
|
|
void DataBuffer::putShort( unsigned int sval) {
|
|
|
|
// Check if the buffer needs extending
|
|
|
|
EXTEND_CHECK(2);
|
|
|
|
// Pack the data, update the buffer pointer
|
|
|
|
DataPacker::putIntelShort( sval, m_buf, m_pos);
|
|
m_pos += 2;
|
|
}
|
|
|
|
/**
|
|
* Append an integer to the buffer and advance the buffer pointer
|
|
*
|
|
* @param ival unsigned int
|
|
*/
|
|
void DataBuffer::putInt( unsigned int ival) {
|
|
|
|
// Check if the buffer needs extending
|
|
|
|
EXTEND_CHECK(4);
|
|
|
|
// Pack the data, update the buffer pointer
|
|
|
|
DataPacker::putIntelInt( ival, m_buf, m_pos);
|
|
m_pos += 4;
|
|
}
|
|
|
|
/**
|
|
* Append a long to the buffer and advance the buffer pointer
|
|
*
|
|
* @param lval LONG64
|
|
*/
|
|
void DataBuffer::putLong( LONG64 lval) {
|
|
|
|
// Check if the buffer needs extending
|
|
|
|
EXTEND_CHECK(8);
|
|
|
|
// Pack the data, update the buffer pointer
|
|
|
|
DataPacker::putIntelLong( lval, m_buf, m_pos);
|
|
m_pos += 8;
|
|
}
|
|
|
|
/**
|
|
* Put a short value into the buffer at the specified position
|
|
*
|
|
* @param idx unsigned int
|
|
* @param sval unsigned int
|
|
*/
|
|
void DataBuffer::putShortAt( unsigned int idx, unsigned int sval) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
BUFPOS pos = m_offset + (idx * 2);
|
|
EXTEND_CHECK_POS(pos,2);
|
|
|
|
// Pack the short value
|
|
|
|
DataPacker::putIntelShort(sval, m_buf, pos);
|
|
}
|
|
|
|
/**
|
|
* Put an integer value into the buffer at the specified position
|
|
*
|
|
* @param idx unsigned int
|
|
* @param ival unsigned int
|
|
*/
|
|
void DataBuffer::putIntAt( unsigned int idx, unsigned int ival) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
BUFPOS pos = m_offset + (idx * 4);
|
|
EXTEND_CHECK_POS(pos,4);
|
|
|
|
// Pack the integer value
|
|
|
|
DataPacker::putIntelInt(ival, m_buf, pos);
|
|
}
|
|
|
|
/**
|
|
* Put a long value into the buffer at the specified position
|
|
*
|
|
* @param idx unsigned int
|
|
* @param lval LONG64
|
|
*/
|
|
void DataBuffer::putLongAt( unsigned int idx, LONG64 lval) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
BUFPOS pos = m_offset + (idx * 8);
|
|
EXTEND_CHECK_POS(pos,8);
|
|
|
|
// Pack the long value
|
|
|
|
DataPacker::putIntelLong(lval, m_buf, pos);
|
|
}
|
|
|
|
/**
|
|
* Append a string to the buffer and advance the buffer pointer
|
|
*
|
|
* @param str const String&
|
|
* @param uni bool
|
|
* @param nulTerm bool
|
|
*/
|
|
void DataBuffer::putString( const String& str, bool uni, bool nulTerm) {
|
|
|
|
// Check for Unicode or ASCII
|
|
|
|
if ( uni) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
unsigned int bytLen = str.length() * 2;
|
|
if ( m_buflen - m_pos < bytLen)
|
|
extendBuffer(bytLen + 4);
|
|
|
|
// Word align the buffer position, pack the Unicode string
|
|
|
|
m_pos = DataPacker::wordAlign(m_pos);
|
|
DataPacker::putString(str, m_buf, m_pos, nulTerm, true);
|
|
m_pos += (str.length() * 2);
|
|
if ( nulTerm)
|
|
m_pos += 2;
|
|
}
|
|
else {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
if ( m_buflen - m_pos < str.length())
|
|
extendBuffer(str.length() + 2);
|
|
|
|
// Pack the ASCII string
|
|
|
|
DataPacker::putString(str, m_buf, m_pos, nulTerm);
|
|
m_pos += str.length();
|
|
if ( nulTerm)
|
|
m_pos++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a fixed length string to the buffer and advance the buffer pointer
|
|
*
|
|
* @param str const String&
|
|
* @param len unsigned int
|
|
*/
|
|
void DataBuffer::putFixedString( const String& str, unsigned int len) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
if ( m_buflen - m_pos < str.length())
|
|
extendBuffer(str.length() + 2);
|
|
|
|
// Pack the ASCII string
|
|
|
|
DataPacker::putString(str, m_buf, m_pos);
|
|
m_pos += len;
|
|
|
|
// Pad the string to the required length
|
|
|
|
while ( len > str.length()) {
|
|
m_buf[m_pos++] = 0;
|
|
len--;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Put a string into the buffer at the specified position
|
|
*
|
|
* @param str const String&
|
|
* @param pos BUFPOS
|
|
* @param uni bool
|
|
* @param nulTerm bool
|
|
* @return BUFPOS
|
|
*/
|
|
BUFPOS DataBuffer::putStringAt( const String& str, BUFPOS pos, bool uni, bool nulTerm) {
|
|
|
|
// Check for Unicode or ASCII
|
|
|
|
BUFPOS retPos = 0;
|
|
|
|
if ( uni) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
unsigned int bytLen = str.length() * 2;
|
|
if ( m_buflen - pos < bytLen)
|
|
extendBuffer(bytLen + 4);
|
|
|
|
// Word align the buffer position, pack the Unicode string
|
|
|
|
pos = DataPacker::wordAlign(pos);
|
|
retPos = DataPacker::putString(str, m_buf, pos, nulTerm);
|
|
}
|
|
else {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
if ( m_buflen - pos < str.length())
|
|
extendBuffer(str.length() + 2);
|
|
|
|
// Pack the ASCII string
|
|
|
|
retPos = DataPacker::putString(str, m_buf, pos, nulTerm);
|
|
}
|
|
|
|
// Return the end of string buffer position
|
|
|
|
return retPos;
|
|
}
|
|
|
|
/**
|
|
* Put a fixed length string into the buffer at the specified position
|
|
*
|
|
* @param str const String&
|
|
* @param len unsigned int
|
|
* @param pos BUFPOS
|
|
* @return BUFPOS
|
|
*/
|
|
BUFPOS DataBuffer::putFixedStringAt( const String& str, unsigned int len, BUFPOS pos) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
if ( m_buflen - pos < str.length())
|
|
extendBuffer(str.length() + 2);
|
|
|
|
// Pack the ASCII string
|
|
|
|
pos = DataPacker::putString(str, m_buf, pos);
|
|
|
|
// Pad the string
|
|
|
|
while ( len > str.length()) {
|
|
m_buf[pos++] = 0;
|
|
len--;
|
|
}
|
|
|
|
// Return the end of string buffer position
|
|
|
|
return pos;
|
|
}
|
|
|
|
/**
|
|
* Put a string pointer into the buffer
|
|
*
|
|
* @param off unsigned int
|
|
*/
|
|
void DataBuffer::putStringPointer( unsigned int off) {
|
|
|
|
// Calculate the offset from the start of the data buffer to the string position
|
|
|
|
DataPacker::putIntelInt(off - m_offset, m_buf, m_pos);
|
|
m_pos += 4;
|
|
}
|
|
|
|
/**
|
|
* Append a block of nulls to the buffer and advance the buffer pointer
|
|
*
|
|
* @param cnt unsigned int
|
|
*/
|
|
void DataBuffer::putZeros( unsigned int cnt) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
if ( m_buflen - m_pos < cnt)
|
|
extendBuffer(cnt);
|
|
|
|
// Pack the zero bytes
|
|
|
|
for ( unsigned int i = 0; i < cnt; i++)
|
|
m_buf[m_pos++] = 0;
|
|
}
|
|
|
|
/**
|
|
* Word align the buffer pointer
|
|
*
|
|
*/
|
|
void DataBuffer::wordAlign( void) {
|
|
m_pos = DataPacker::wordAlign(m_pos);
|
|
}
|
|
|
|
/**
|
|
* Longword align the buffer pointer
|
|
*
|
|
*/
|
|
void DataBuffer::longwordAlign( void) {
|
|
m_pos = DataPacker::longwordAlign(m_pos);
|
|
}
|
|
|
|
/**
|
|
* Append a block of byte data to the buffer and advance the buffer pointer
|
|
*
|
|
* @param buf BUFPTR
|
|
* @param off BUFPOS
|
|
* @param len BUFLEN
|
|
*/
|
|
void DataBuffer::appendData( BUFPTR buf, BUFPOS off, BUFLEN len) {
|
|
|
|
// Check if there is enough space in the buffer
|
|
|
|
if ( m_buflen - m_pos < len)
|
|
extendBuffer(len);
|
|
|
|
// Copy the data to the buffer and update the current write position
|
|
|
|
memcpy( m_buf + m_pos, buf + off, len);
|
|
m_pos += len;
|
|
}
|
|
|
|
/**
|
|
* Copy data to the user buffer and advance the buffer pointer
|
|
*
|
|
* @param buf BUFPTR
|
|
* @param pos BUFPOS
|
|
* @param cnt unsigned int
|
|
*/
|
|
unsigned int DataBuffer::copyData( BUFPTR buf, BUFPOS pos, unsigned int cnt) {
|
|
|
|
// Check if there is any more data to copy
|
|
|
|
if ( m_pos == m_endpos)
|
|
return 0;
|
|
|
|
// Calculate the amount of data to copy
|
|
|
|
unsigned int siz = m_endpos - m_pos;
|
|
if ( siz > cnt)
|
|
siz = cnt;
|
|
|
|
// Copy the data to the user buffer and update the current read position
|
|
|
|
memcpy( buf + pos, m_buf + m_pos, siz);
|
|
m_pos += siz;
|
|
|
|
// Return the amount of data copied
|
|
|
|
return siz;
|
|
}
|
|
|
|
/**
|
|
* Advance the buffer pointer by the specified amount
|
|
*
|
|
* @param len unsigned int
|
|
*/
|
|
void DataBuffer::skipBytes( unsigned int len) {
|
|
|
|
// Check if there is enough data in the buffer
|
|
|
|
CHECK_BUFFER(len);
|
|
|
|
// Skip bytes
|
|
|
|
m_pos += len;
|
|
}
|
|
|
|
/**
|
|
* Set the end of buffer position
|
|
*/
|
|
void DataBuffer::setEndOfBuffer( void) {
|
|
m_endpos = m_pos;
|
|
m_pos = m_offset;
|
|
}
|
|
|
|
/**
|
|
* Set the buffer length
|
|
*
|
|
* @param len BUFLEN
|
|
*/
|
|
void DataBuffer::setLength( BUFLEN len) {
|
|
m_pos = m_offset + len;
|
|
}
|
|
|
|
/**
|
|
* Extend the buffer by the specified amount by reallocating the buffer and copying the existing
|
|
* data to the new buffer
|
|
*
|
|
* @param ext BUFLEN
|
|
*/
|
|
void DataBuffer::extendBuffer( BUFLEN ext) {
|
|
|
|
// Create a new buffer of the required size
|
|
|
|
BUFLEN newlen = m_buflen + ext;
|
|
BUFPTR newBuf = new unsigned char[newlen];
|
|
|
|
// Copy the data from the current buffer to the new buffer
|
|
|
|
memcpy( newBuf, m_buf, m_buflen);
|
|
|
|
// Check if the previous buffer was owned by this object
|
|
|
|
if ( m_owner)
|
|
delete[] m_buf;
|
|
|
|
// Set the new buffer to be the main buffer
|
|
|
|
m_buf = newBuf;
|
|
m_buflen = newlen;
|
|
m_owner = true;
|
|
}
|
|
|
|
/**
|
|
* Extend the buffer doubling the current size by reallocating the buffer and copying the existing
|
|
* data to the new buffer
|
|
*
|
|
*/
|
|
void DataBuffer::extendBuffer( void) {
|
|
extendBuffer( m_buflen * 2);
|
|
}
|