protected override void Read(LocalObjectContainer file, ByteArrayBuffer reader)
{
NewTimerFileLock(file);
OldEncryptionOff(file);
CheckThreadFileLock(file, reader);
reader.Seek(TransactionPointerOffset);
file.SystemData().TransactionPointer1(reader.ReadInt());
file.SystemData().TransactionPointer2(reader.ReadInt());
reader.Seek(BlocksizeOffset);
file.BlockSizeReadFromFile(reader.ReadInt());
SystemData systemData = file.SystemData();
systemData.ClassCollectionID(reader.ReadInt());
reader.ReadInt();
// was freespace ID, can no longer be read
_variablePart = CreateVariablePart(file);
int variablePartId = reader.ReadInt();
_variablePart.Read(variablePartId, 0);
}
public virtual void TestMarshalling()
{
double expected = 1.1;
ByteArrayBuffer buffer = new ByteArrayBuffer(_handler.LinkLength());
_handler.WriteIndexEntry(Context(), buffer, expected);
buffer.Seek(0);
object actual = _handler.ReadIndexEntry(Context(), buffer);
Assert.AreEqual(expected, actual);
}
public virtual void WritePointer(int id, Slot slot)
{
if (DTrace.enabled)
{
DTrace.WritePointer.Log(id);
DTrace.WritePointer.LogLength(slot);
}
_pointerIo.Seek(0);
_pointerIo.WriteInt(slot.Address());
_pointerIo.WriteInt(slot.Length());
WriteBytes(_pointerIo, id, 0);
}
private static FileHeader DetectFileHeader(LocalObjectContainer file, ByteArrayBuffer
reader)
{
for (int i = 0; i < AvailableFileHeaders.Length; i++)
{
reader.Seek(0);
FileHeader result = AvailableFileHeaders[i].NewOnSignatureMatch(file, reader);
if (result != null)
{
return result;
}
}
return null;
}
private void Resize(int sizeNeeded)
{
int newSize = _delegate.Length() * 2;
if (newSize - _lastOffSet < sizeNeeded)
{
newSize += sizeNeeded;
}
ByteArrayBuffer temp = new ByteArrayBuffer(newSize);
temp.Seek(_lastOffSet);
_delegate.CopyTo(temp, 0, 0, _delegate.Length());
_delegate = temp;
}
public virtual ByteArrayBuffer Marshall(LocalTransaction transaction, IIntIterator4
ids, int count)
{
ByteArrayBuffer buffer = new ByteArrayBuffer(Const4.IntLength + count * Const4.IntLength
);
int sizeOffset = buffer.Offset();
buffer.WriteInt(0);
int written = 0;
while (count > 0 && ids.MoveNext())
{
buffer.WriteInt(ids.CurrentInt());
++written;
--count;
}
buffer.Seek(sizeOffset);
buffer.WriteInt(written);
return buffer;
}
public virtual void TransferLastWriteTo(MarshallingBuffer other, bool storeLengthInLink
)
{
other.AddressInParent(_lastOffSet, storeLengthInLink);
int length = _delegate.Offset() - _lastOffSet;
other.PrepareWrite(length);
int otherOffset = other._delegate.Offset();
System.Array.Copy(_delegate._buffer, _lastOffSet, other._delegate._buffer, otherOffset
, length);
_delegate.Seek(_lastOffSet);
other._delegate.Seek(otherOffset + length);
other._lastOffSet = otherOffset;
}
protected override void Read(LocalObjectContainer container, ByteArrayBuffer reader
)
{
NewTimerFileLock(container);
OldEncryptionOff(container);
CheckThreadFileLock(container, reader);
reader.Seek(BlocksizeOffset);
container.BlockSizeReadFromFile(reader.ReadInt());
SystemData systemData = container.SystemData();
systemData.ClassCollectionID(reader.ReadInt());
container.SystemData().IdSystemType(reader.ReadByte());
_variablePart = CreateVariablePart(container);
int variablePartAddress = reader.ReadInt();
int variablePartLength = reader.ReadInt();
_variablePart.Read(variablePartAddress, variablePartLength);
_transactionPointerAddress = reader.ReadInt();
if (_transactionPointerAddress != 0)
{
ByteArrayBuffer buffer = new ByteArrayBuffer(TransactionPointerLength);
buffer.Read(container, _transactionPointerAddress, 0);
systemData.TransactionPointer1(buffer.ReadInt());
systemData.TransactionPointer2(buffer.ReadInt());
}
}
private void Resize(int sizeNeeded)
{
int newSize = _delegate.Length() * 2;
if (newSize - _lastOffSet < sizeNeeded)
{
newSize += sizeNeeded;
}
ByteArrayBuffer temp = new ByteArrayBuffer(newSize);
temp.Seek(_lastOffSet);
_delegate.CopyTo(temp, 0, 0, _delegate.Length());
_delegate = temp;
}
public void Seek(int offset)
{
_source.Seek(offset);
_target.Seek(offset);
}
private bool CheckSumOK(ByteArrayBuffer buffer, int offset)
{
int initialOffSet = buffer.Offset();
int length = OwnLength();
length -= ChecksumLength;
buffer.Seek(offset);
long readCheckSum = buffer.ReadLong();
int checkSumBeginOffset = buffer.Offset();
byte[] bytes = buffer._buffer;
long calculatedCheckSum = CRC32.CheckSum(bytes, checkSumBeginOffset, length);
buffer.Seek(initialOffSet);
return calculatedCheckSum == readCheckSum;
}
private void WriteIntAt(ByteArrayBuffer target, int offset, int value)
{
int currentOffset = target.Offset();
target.Seek(offset);
target.WriteInt(value);
target.Seek(currentOffset);
}
public virtual void TestLinkOffset()
{
int linkOffset = 7;
MarshallingBuffer buffer = new MarshallingBuffer();
buffer.WriteInt(Data1);
buffer.WriteByte(Data2);
MarshallingBuffer child = buffer.AddChild();
child.WriteInt(Data3);
child.WriteInt(Data4);
MarshallingBuffer grandChild = child.AddChild();
grandChild.WriteInt(Data5);
buffer.MergeChildren(null, 0, linkOffset);
ByteArrayBuffer content = InspectContent(buffer);
ByteArrayBuffer extendedBuffer = new ByteArrayBuffer(content.Length() + linkOffset
);
content.CopyTo(extendedBuffer, 0, linkOffset, content.Length());
extendedBuffer.Seek(linkOffset);
Assert.AreEqual(Data1, extendedBuffer.ReadInt());
Assert.AreEqual(Data2, extendedBuffer.ReadByte());
int address = extendedBuffer.ReadInt();
extendedBuffer.Seek(address);
Assert.AreEqual(Data3, extendedBuffer.ReadInt());
Assert.AreEqual(Data4, extendedBuffer.ReadInt());
address = extendedBuffer.ReadInt();
extendedBuffer.Seek(address);
Assert.AreEqual(Data5, extendedBuffer.ReadInt());
}
private static byte[] BytesToSendFor(string message)
{
LatinStringIO io = new LatinStringIO();
int marshalledStringLength = io.Length(message);
ByteArrayBuffer buffer = new ByteArrayBuffer(marshalledStringLength + Const4.IntLength);
buffer.WriteInt(marshalledStringLength);
io.WriteLengthAndString(buffer, message);
buffer.Seek(0);
return buffer.ReadBytes(buffer.Length());
}
private bool VersionsAreConsistentAndSeek(ByteArrayBuffer buffer)
{
byte[] bytes = buffer._buffer;
int length = OwnLength();
int[] offsets = Offsets();
bool different = false;
for (int i = 0; i < length; i++)
{
byte b = bytes[offsets[0] + i];
for (int j = 1; j < 4; j++)
{
if (b != bytes[offsets[j] + i])
{
different = true;
break;
}
}
}
if (!different)
{
// The following line cements our checksum algorithm in stone.
// Things should be safe enough if we remove the throw.
// If all four versions of the header are the same,
// it's bound to be OK. (unless all bytes are zero or
// greyed out by some kind of overwriting algorithm.)
int firstOffset = 0;
if (!CheckSumOK(buffer, firstOffset))
{
throw new Db4oFileHeaderCorruptionException();
}
return true;
}
bool firstPairDiffers = false;
bool secondPairDiffers = false;
for (int i = 0; i < length; i++)
{
if (bytes[offsets[0] + i] != bytes[offsets[1] + i])
{
firstPairDiffers = true;
}
if (bytes[offsets[2] + i] != bytes[offsets[3] + i])
{
secondPairDiffers = true;
}
}
if (!secondPairDiffers)
{
if (CheckSumOK(buffer, offsets[2]))
{
buffer.Seek(offsets[2]);
return false;
}
}
if (firstPairDiffers)
{
// Should never ever happen, we are toast.
// We could still try to use any random version of
// the header but which one?
// Maybe the first of the second pair could be an
// option for a recovery tool, or it could try all
// versions.
throw new Db4oFileHeaderCorruptionException();
}
if (!CheckSumOK(buffer, 0))
{
throw new Db4oFileHeaderCorruptionException();
}
return false;
}
// Scrolls offset in passed reader to the offset the passed field should
// be read at.
public HandlerVersion SeekToField(Transaction trans, ByteArrayBuffer buffer, FieldMetadata
field)
{
if (buffer == null)
{
return HandlerVersion.Invalid;
}
if (!StandardReferenceTypeHandlerIsUsed())
{
return HandlerVersion.Invalid;
}
buffer.Seek(0);
var oh = new ObjectHeader(_container, buffer);
var res = oh.ClassMetadata().SeekToField(new ObjectHeaderContext(trans, buffer,
oh), field);
if (!res)
{
return HandlerVersion.Invalid;
}
return new HandlerVersion(oh.HandlerVersion());
}
protected virtual void CheckThreadFileLock(LocalObjectContainer container, ByteArrayBuffer
reader)
{
reader.Seek(AccessTimeOffset);
long lastAccessTime = reader.ReadLong();
if (FileHeader.LockedByOtherSession(container, lastAccessTime))
{
_timerFileLock.CheckIfOtherSessionAlive(container, 0, AccessTimeOffset, lastAccessTime
);
}
}
private void Marshall(ByteArrayBuffer buffer, bool shuttingDown)
{
int checkSumOffset = buffer.Offset();
buffer.IncrementOffset(ChecksumLength);
int checkSumBeginOffset = buffer.Offset();
WriteBuffer(buffer, shuttingDown);
int checkSumEndOffSet = buffer.Offset();
byte[] bytes = buffer._buffer;
int length = checkSumEndOffSet - checkSumBeginOffset;
long checkSum = CRC32.CheckSum(bytes, checkSumBeginOffset, length);
buffer.Seek(checkSumOffset);
buffer.WriteLong(checkSum);
buffer.Seek(checkSumEndOffSet);
}