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()); } }
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); }