void CFileDataIO::WriteTag(const CTag& tag)
{
try
{
WriteUInt8(tag.GetType());
if (!tag.GetName().IsEmpty()) {
WriteString(tag.GetName(),utf8strNone);
} else {
WriteUInt16(1);
WriteUInt8(tag.GetNameID());
}
switch (tag.GetType())
{
case TAGTYPE_HASH16:
// Do NOT use this to transfer any tags for at least half a year!!
WriteHash(CMD4Hash(tag.GetHash()));
break;
case TAGTYPE_STRING:
WriteString(tag.GetStr(), utf8strRaw); // Always UTF8
break;
case TAGTYPE_UINT64:
WriteUInt64(tag.GetInt());
break;
case TAGTYPE_UINT32:
WriteUInt32(tag.GetInt());
break;
case TAGTYPE_FLOAT32:
WriteFloat(tag.GetFloat());
break;
case TAGTYPE_BSOB:
WriteBsob(tag.GetBsob(), tag.GetBsobSize());
break;
case TAGTYPE_UINT16:
WriteUInt16(tag.GetInt());
break;
case TAGTYPE_UINT8:
WriteUInt8(tag.GetInt());
break;
case TAGTYPE_BLOB:
// NOTE: This will break backward compatibility with met files for eMule versions prior to 0.44a
// and any aMule prior to SVN 26/02/2005
WriteUInt32(tag.GetBlobSize());
Write(tag.GetBlob(), tag.GetBlobSize());
break;
default:
//TODO: Support more tag types
// With the if above, this should NEVER happen.
AddLogLineNS(CFormat(wxT("CFileDataIO::WriteTag: Unknown tag: type=0x%02X")) % tag.GetType());
wxFAIL;
break;
}
} catch (...) {
AddLogLineNS(wxT("Exception in CDataIO:WriteTag"));
throw;
}
}
void COutArchive::WriteExtra(const CExtraBlock &extra)
{
if (extra.SubBlocks.Size() != 0)
{
for (int i = 0; i < extra.SubBlocks.Size(); i++)
{
const CExtraSubBlock &subBlock = extra.SubBlocks[i];
WriteUInt16(subBlock.ID);
WriteUInt16((UInt16)subBlock.Data.GetCapacity());
WriteBytes(subBlock.Data, (UInt32)subBlock.Data.GetCapacity());
}
}
}
void BinaryStream::WriteString(std::string what)
{
if(mySetPos > myBuffer.size()) mySetPos = myBuffer.size();
WriteUInt16((uint16_t)what.size());
for(uint16_t i = 0; i < (uint16_t)what.size(); i++)
{
myBuffer.insert(myBuffer.begin()+mySetPos, what[i]);
mySetPos++;
}
myBuffer.insert(myBuffer.begin()+mySetPos, 0);
mySetPos++;
}
void CFileDataIO::WriteStringCore(const char *s, EUtf8Str eEncode, uint8 SizeLen)
{
uint32 sLength = s ? strlen(s) : 0;
uint32 real_length = 0;
if (eEncode == utf8strOptBOM) {
real_length = sLength + 3; // For BOM header.
} else {
real_length = sLength;
}
switch (SizeLen) {
case 0:
// Don't write size.
break;
case sizeof(uint16):
// We must not allow too long strings to be written,
// as this would allow for a buggy clients to "poison"
// us, by sending ISO8859-1 strings that expand to a
// greater than 16b length when converted as UTF-8.
if (real_length > 0xFFFF) {
wxFAIL_MSG(wxT("String is too long to be saved"));
real_length = std::min<uint32>(real_length, 0xFFFF);
if (eEncode == utf8strOptBOM) {
sLength = real_length - 3;
} else {
sLength = real_length;
}
}
WriteUInt16(real_length);
break;
case sizeof(uint32):
WriteUInt32(real_length);
break;
default:
MULE_VALIDATE_PARAMS(false, wxT("Invalid length for string-length field."));
}
// The BOM header must be written even if the string is empty.
if (eEncode == utf8strOptBOM) {
Write(BOMHeader, 3);
}
// Only attempt to write non-NULL strings.
if (sLength) {
// No NULL terminator is written since we explicitly specify the length
Write(s, sLength);
}
}
void COutArchive::WriteCentralHeader(const CItem &item)
{
bool isUnPack64 = item.UnPackSize >= 0xFFFFFFFF;
bool isPack64 = item.PackSize >= 0xFFFFFFFF;
bool isPosition64 = item.LocalHeaderPosition >= 0xFFFFFFFF;
bool isZip64 = isPack64 || isUnPack64 || isPosition64;
WriteUInt32(NSignature::kCentralFileHeader);
WriteByte(item.MadeByVersion.Version);
WriteByte(item.MadeByVersion.HostOS);
WriteByte(item.ExtractVersion.Version);
WriteByte(item.ExtractVersion.HostOS);
WriteUInt16(item.Flags);
WriteUInt16(item.CompressionMethod);
WriteUInt32(item.Time);
WriteUInt32(item.FileCRC);
WriteUInt32(isPack64 ? 0xFFFFFFFF: (UInt32)item.PackSize);
WriteUInt32(isUnPack64 ? 0xFFFFFFFF: (UInt32)item.UnPackSize);
WriteUInt16((UInt16)item.Name.Length());
UInt16 zip64ExtraSize = (UInt16)((isUnPack64 ? 8: 0) + (isPack64 ? 8: 0) + (isPosition64 ? 8: 0));
UInt16 centralExtraSize = (UInt16)(isZip64 ? (4 + zip64ExtraSize) : 0);
centralExtraSize = (UInt16)(centralExtraSize + item.CentralExtra.GetSize());
WriteUInt16(centralExtraSize); // test it;
WriteUInt16((UInt16)item.Comment.GetCapacity());
WriteUInt16(0); // DiskNumberStart;
WriteUInt16(item.InternalAttributes);
WriteUInt32(item.ExternalAttributes);
WriteUInt32(isPosition64 ? 0xFFFFFFFF: (UInt32)item.LocalHeaderPosition);
WriteBytes((const char *)item.Name, item.Name.Length());
if (isZip64)
{
WriteUInt16(NFileHeader::NExtraID::kZip64);
WriteUInt16(zip64ExtraSize);
if(isUnPack64)
WriteUInt64(item.UnPackSize);
if(isPack64)
WriteUInt64(item.PackSize);
if(isPosition64)
WriteUInt64(item.LocalHeaderPosition);
}
WriteExtra(item.CentralExtra);
if (item.Comment.GetCapacity() > 0)
WriteBytes(item.Comment, (UInt32)item.Comment.GetCapacity());
}
HRESULT CLrpStClientImpl::Invoke(MemoryBuffer& buffer)
{
uint32 size = static_cast<uint32>(buffer.GetSize());
if (size < sizeof(uint32))
{
throw runtime_error("Input buffer is too small");
}
buffer.SetPosition(0);
WriteInt32(size - 4, buffer);
buffer.SetPosition(12);
uint16 componentId = ReadUInt16(buffer);
uint16 methodId = ReadUInt16(buffer);
Translate(componentId, methodId);
buffer.SetPosition(12);
WriteUInt16(componentId, buffer);
WriteUInt16(methodId, buffer);
CTimeout timeout(m_operationTimeoutInMs);
if (!SendEx(m_socket, timeout, buffer.GetData(), buffer.GetSize()))
{
closesocket(m_socket);
m_socket = INVALID_SOCKET;
throw runtime_error("Couldn't send data");
}
if (!ReceiveEx(m_socket, timeout, buffer))
{
closesocket(m_socket);
m_socket = INVALID_SOCKET;
throw runtime_error("Couldn't receive data");
}
buffer.SetPosition(12);
const HRESULT result = ReadInt32(buffer);
return result;
}
void COutArchive::WriteCentralDir(const CObjectVector<CItem> &items, const CByteBuffer *comment)
{
SeekTo(m_BasePosition);
UInt64 cdOffset = GetCurrentPosition();
for(int i = 0; i < items.Size(); i++)
WriteCentralHeader(items[i]);
UInt64 cd64EndOffset = GetCurrentPosition();
UInt64 cdSize = cd64EndOffset - cdOffset;
bool cdOffset64 = cdOffset >= 0xFFFFFFFF;
bool cdSize64 = cdSize >= 0xFFFFFFFF;
bool items64 = items.Size() >= 0xFFFF;
bool isZip64 = (cdOffset64 || cdSize64 || items64);
if (isZip64)
{
WriteUInt32(NSignature::kZip64EndOfCentralDir);
WriteUInt64(kZip64EcdSize); // ThisDiskNumber = 0;
WriteUInt16(45); // version
WriteUInt16(45); // version
WriteUInt32(0); // ThisDiskNumber = 0;
WriteUInt32(0); // StartCentralDirectoryDiskNumber;;
WriteUInt64((UInt64)items.Size());
WriteUInt64((UInt64)items.Size());
WriteUInt64((UInt64)cdSize);
WriteUInt64((UInt64)cdOffset);
WriteUInt32(NSignature::kZip64EndOfCentralDirLocator);
WriteUInt32(0); // number of the disk with the start of the zip64 end of central directory
WriteUInt64(cd64EndOffset);
WriteUInt32(1); // total number of disks
}
WriteUInt32(NSignature::kEndOfCentralDir);
WriteUInt16(0); // ThisDiskNumber = 0;
WriteUInt16(0); // StartCentralDirectoryDiskNumber;
WriteUInt16((UInt16)(items64 ? 0xFFFF: items.Size()));
WriteUInt16((UInt16)(items64 ? 0xFFFF: items.Size()));
WriteUInt32(cdSize64 ? 0xFFFFFFFF: (UInt32)cdSize);
WriteUInt32(cdOffset64 ? 0xFFFFFFFF: (UInt32)cdOffset);
UInt32 commentSize = (UInt32)(comment ? comment->GetCapacity() : 0);
WriteUInt16((UInt16)commentSize);
if (commentSize > 0)
WriteBytes((const Byte *)*comment, commentSize);
m_OutBuffer.FlushWithCheck();
}
void COutArchive::WriteLocalHeader(const CLocalItem &item)
{
SeekTo(m_BasePosition);
bool isZip64 = m_IsZip64 || item.PackSize >= 0xFFFFFFFF || item.UnPackSize >= 0xFFFFFFFF;
WriteUInt32(NSignature::kLocalFileHeader);
{
Byte ver = item.ExtractVersion.Version;
if (isZip64 && ver < NFileHeader::NCompressionMethod::kExtractVersion_Zip64)
ver = NFileHeader::NCompressionMethod::kExtractVersion_Zip64;
WriteByte(ver);
}
WriteByte(item.ExtractVersion.HostOS);
WriteUInt16(item.Flags);
WriteUInt16(item.CompressionMethod);
WriteUInt32(item.Time);
WriteUInt32(item.FileCRC);
WriteUInt32(isZip64 ? 0xFFFFFFFF: (UInt32)item.PackSize);
WriteUInt32(isZip64 ? 0xFFFFFFFF: (UInt32)item.UnPackSize);
WriteUInt16((UInt16)item.Name.Length());
{
UInt16 localExtraSize = (UInt16)((isZip64 ? (4 + 16): 0) + item.LocalExtra.GetSize());
if (localExtraSize > m_ExtraSize)
throw CSystemException(E_FAIL);
}
WriteUInt16((UInt16)m_ExtraSize); // test it;
WriteBytes((const char *)item.Name, item.Name.Length());
UInt32 extraPos = 0;
if (isZip64)
{
extraPos += 4 + 16;
WriteUInt16(NFileHeader::NExtraID::kZip64);
WriteUInt16(16);
WriteUInt64(item.UnPackSize);
WriteUInt64(item.PackSize);
}
WriteExtra(item.LocalExtra);
extraPos += (UInt32)item.LocalExtra.GetSize();
for (; extraPos < m_ExtraSize; extraPos++)
WriteByte(0);
m_OutBuffer.FlushWithCheck();
MoveBasePosition(item.PackSize);
SeekTo(m_BasePosition);
}
void WriteInt16(int16_t what) { WriteUInt16((uint16_t)what); }
void COutArchive::WriteCentralHeader(const CItem &item)
{
bool isUnPack64 = item.UnPackSize >= 0xFFFFFFFF;
bool isPack64 = item.PackSize >= 0xFFFFFFFF;
bool isPosition64 = item.LocalHeaderPosition >= 0xFFFFFFFF;
bool isZip64 = isPack64 || isUnPack64 || isPosition64;
WriteUInt32(NSignature::kCentralFileHeader);
WriteByte(item.MadeByVersion.Version);
WriteByte(item.MadeByVersion.HostOS);
{
Byte ver = item.ExtractVersion.Version;
if (isZip64 && ver < NFileHeader::NCompressionMethod::kExtractVersion_Zip64)
ver = NFileHeader::NCompressionMethod::kExtractVersion_Zip64;
WriteByte(ver);
}
WriteByte(item.ExtractVersion.HostOS);
WriteUInt16(item.Flags);
WriteUInt16(item.CompressionMethod);
WriteUInt32(item.Time);
WriteUInt32(item.FileCRC);
WriteUInt32(isPack64 ? 0xFFFFFFFF: (UInt32)item.PackSize);
WriteUInt32(isUnPack64 ? 0xFFFFFFFF: (UInt32)item.UnPackSize);
WriteUInt16((UInt16)item.Name.Length());
UInt16 zip64ExtraSize = (UInt16)((isUnPack64 ? 8: 0) + (isPack64 ? 8: 0) + (isPosition64 ? 8: 0));
const UInt16 kNtfsExtraSize = 4 + 2 + 2 + (3 * 8);
UInt16 centralExtraSize = (UInt16)(isZip64 ? (4 + zip64ExtraSize) : 0) + (item.NtfsTimeIsDefined ? (4 + kNtfsExtraSize) : 0);
centralExtraSize = (UInt16)(centralExtraSize + item.CentralExtra.GetSize());
WriteUInt16(centralExtraSize); // test it;
WriteUInt16((UInt16)item.Comment.GetCapacity());
WriteUInt16(0); // DiskNumberStart;
WriteUInt16(item.InternalAttributes);
WriteUInt32(item.ExternalAttributes);
WriteUInt32(isPosition64 ? 0xFFFFFFFF: (UInt32)item.LocalHeaderPosition);
WriteBytes((const char *)item.Name, item.Name.Length());
if (isZip64)
{
WriteUInt16(NFileHeader::NExtraID::kZip64);
WriteUInt16(zip64ExtraSize);
if(isUnPack64)
WriteUInt64(item.UnPackSize);
if(isPack64)
WriteUInt64(item.PackSize);
if(isPosition64)
WriteUInt64(item.LocalHeaderPosition);
}
if (item.NtfsTimeIsDefined)
{
WriteUInt16(NFileHeader::NExtraID::kNTFS);
WriteUInt16(kNtfsExtraSize);
WriteUInt32(0); // reserved
WriteUInt16(NFileHeader::NNtfsExtra::kTagTime);
WriteUInt16(8 * 3);
WriteUInt32(item.NtfsMTime.dwLowDateTime);
WriteUInt32(item.NtfsMTime.dwHighDateTime);
WriteUInt32(item.NtfsATime.dwLowDateTime);
WriteUInt32(item.NtfsATime.dwHighDateTime);
WriteUInt32(item.NtfsCTime.dwLowDateTime);
WriteUInt32(item.NtfsCTime.dwHighDateTime);
}
WriteExtra(item.CentralExtra);
if (item.Comment.GetCapacity() > 0)
WriteBytes(item.Comment, (UInt32)item.Comment.GetCapacity());
}
void xBinaryWriter::WriteString(const xString& string)
{
xUInt16 length = (xUInt16)string.Length();
WriteUInt16(length);
mStream->Write((void*)string.c_str(), length);
}
void CFileDataIO::WriteString(LPCSTR psz)
{
UINT uLen = strlen(psz);
WriteUInt16((uint16)uLen);
Write(psz, uLen);
}
