public virtual bool LoadLowestLevelHashs(FileDataIO fileInput)
{
if (DataSize <= BaseSize)
{ // sanity
// lowest level, read hash
Hash.Read(fileInput);
//theApp.AddDebugLogLine(false,Hash.GetString());
HashValid = true;
return(true);
}
else
{
ulong nBlocks = DataSize / BaseSize + ((DataSize % BaseSize != 0) ? (ulong)1 : (ulong)0);
ulong nLeft = (((IsLeftBranch) ? nBlocks + 1 : nBlocks) / 2) * BaseSize;
ulong nRight = DataSize - nLeft;
if (LeftTree == null)
{
LeftTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nLeft, true, (nLeft <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
if (RightTree == null)
{
RightTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nRight, false, (nRight <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
return(LeftTree.LoadLowestLevelHashs(fileInput) &&
RightTree.LoadLowestLevelHashs(fileInput));
}
}
public virtual bool WriteLowestLevelHashs(FileDataIO fileDataOut, uint wHashIdent, bool bNoIdent, bool b32BitIdent)
{
wHashIdent <<= 1;
wHashIdent |= (IsLeftBranch) ? (uint)1 : (uint)0;
if (LeftTree == null && RightTree == null)
{
if (DataSize <= BaseSize && HashValid)
{
if (!bNoIdent && !b32BitIdent)
{
fileDataOut.WriteUInt16((ushort)wHashIdent);
}
else if (!bNoIdent && b32BitIdent)
{
fileDataOut.WriteUInt32(wHashIdent);
}
Hash.Write(fileDataOut);
return(true);
}
else
{
return(false);
}
}
else if (LeftTree == null || RightTree == null)
{
return(false);
}
else
{
return(LeftTree.WriteLowestLevelHashs(fileDataOut, wHashIdent, bNoIdent, b32BitIdent) &&
RightTree.WriteLowestLevelHashs(fileDataOut, wHashIdent, bNoIdent, b32BitIdent));
}
}
public void WriteCollectionInfo(FileDataIO out_data)
{
out_data.WriteUInt32(Convert.ToUInt32(tagList_.Count));
foreach (Tag tag in tagList_)
{
tag.WriteNewEd2kTag(out_data, Utf8StrEnum.utf8strRaw);
}
}
public bool CreatePartRecoveryData(ulong nStartPos, ulong nSize, FileDataIO fileDataOut, uint wHashIdent, bool b32BitIdent)
{
if (nStartPos + nSize > DataSize)
{ // sanity
return(false);
}
if (nSize > DataSize)
{ // sanity
return(false);
}
if (nStartPos == 0 && nSize == DataSize)
{
// this is the searched part, now write all blocks of this part
// hashident for this level will be adjsuted by WriteLowestLevelHash
return(WriteLowestLevelHashs(fileDataOut, wHashIdent, false, b32BitIdent));
}
else if (DataSize <= BaseSize)
{ // sanity
// this is already the last level, cant go deeper
return(false);
}
else
{
wHashIdent <<= 1;
wHashIdent |= (IsLeftBranch) ? (uint)1 : (uint)0;
ulong nBlocks = DataSize / BaseSize + ((DataSize % BaseSize != 0) ? (ulong)1 : (ulong)0);
ulong nLeft = (((IsLeftBranch) ? nBlocks + 1 : nBlocks) / 2) * BaseSize;
ulong nRight = DataSize - nLeft;
if (leftTree_ == null || rightTree_ == null)
{
return(false);
}
if (nStartPos < nLeft)
{
if (nStartPos + nSize > nLeft || !rightTree_.HashValid)
{ // sanity
return(false);
}
rightTree_.WriteHash(fileDataOut, wHashIdent, b32BitIdent);
return(leftTree_.CreatePartRecoveryData(nStartPos, nSize, fileDataOut, wHashIdent, b32BitIdent));
}
else
{
nStartPos -= nLeft;
if (nStartPos + nSize > nRight || !leftTree_.HashValid)
{ // sanity
return(false);
}
leftTree_.WriteHash(fileDataOut, wHashIdent, b32BitIdent);
return(rightTree_.CreatePartRecoveryData(nStartPos, nSize, fileDataOut, wHashIdent, b32BitIdent));
}
}
}
public static bool WriteOptED2KUTF8Tag(FileDataIO file,
string filename, byte uTagName)
{
if (!NeedUTF8String(filename))
{
return(false);
}
Tag tag = MpdObjectManager.CreateTag(uTagName, filename);
tag.WriteTagToFile(file, Utf8StrEnum.utf8strOptBOM);
return(true);
}
public void WriteHash(FileDataIO fileDataOut, uint wHashIdent, bool b32BitIdent)
{
wHashIdent <<= 1;
wHashIdent |= (IsLeftBranch) ? (uint)1 : (uint)0;
if (!b32BitIdent)
{
fileDataOut.WriteUInt16((ushort)wHashIdent);
}
else
{
fileDataOut.WriteUInt32(wHashIdent);
}
Hash.Write(fileDataOut);
}
public void Write(FileDataIO file)
{
file.Write(RawHash);
}
public void Read(FileDataIO file)
{
file.Read(RawHash);
}
public bool SetHash(FileDataIO fileInput, uint wHashIdent, sbyte nLevel, bool bAllowOverwrite)
{
if (nLevel == -1)
{
// first call, check how many level we need to go
byte i;
for (i = 0; i != 32 && (wHashIdent & 0x80000000) == 0; i++)
{
wHashIdent <<= 1;
}
if (i > 31)
{
//TODO:Log
//theApp.QueueDebugLogLine(/*DLP_HIGH,*/ false, _T("CAICHHashTree::SetHash - found invalid HashIdent (0)"));
return(false);
}
else
{
nLevel = (sbyte)(31 - i);
}
}
if (nLevel == 0)
{
// this is the searched hash
if (HashValid && !bAllowOverwrite)
{
// not allowed to overwrite this hash, however move the filepointer by reading a hash
AICHHash hash = MuleApplication.Instance.AICHObjectManager.CreateAICHHash(fileInput);
return(true);
}
Hash.Read(fileInput);
HashValid = true;
return(true);
}
else if (DataSize <= BaseSize)
{ // sanity
// this is already the last level, cant go deeper
return(false);
}
else
{
// adjust ident to point the path to the next node
wHashIdent <<= 1;
nLevel--;
ulong nBlocks = DataSize / BaseSize + ((DataSize % BaseSize != 0) ? (ulong)1 : (ulong)0);
ulong nLeft = (((IsLeftBranch) ? nBlocks + 1 : nBlocks) / 2) * BaseSize;
ulong nRight = DataSize - nLeft;
if ((wHashIdent & 0x80000000) > 0)
{
if (LeftTree == null)
{
LeftTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nLeft, true, (nLeft <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
return(LeftTree.SetHash(fileInput, wHashIdent, nLevel));
}
else
{
if (RightTree == null)
{
RightTree = MuleApplication.Instance.AICHObjectManager.CreateAICHHashTree(nRight, false, (nRight <= MuleConstants.PARTSIZE) ? MuleConstants.EMBLOCKSIZE : MuleConstants.PARTSIZE);
}
return(RightTree.SetHash(fileInput, wHashIdent, nLevel));
}
}
}
public bool SetHash(FileDataIO fileInput, uint wHashIdent)
{
return(SetHash(fileInput, wHashIdent, -1));
}
public bool SetHash(FileDataIO fileInput, uint wHashIdent, sbyte nLevel)
{
return(SetHash(fileInput, wHashIdent, nLevel, true));
}
