BinaryReader.cpp

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "Qt.h"
#include "BinaryReader.h"
#include "Imports.cpp"

BinaryReader::BinaryReader (const QByteArray &rawData)
    : BinaryReaderBase (rawData, LittleEndian)
{
}


QUuid BinaryReader::readUuid()
{
    QUuid uuid;
    setByteOrder (BigEndian);
    uuid.data1 = readUInt32();
    uuid.data2 = readUInt16();
    uuid.data3 = readUInt16();
    uuid.data4[0] = readByte();
    uuid.data4[1] = readByte();
    uuid.data4[2] = readByte();
    uuid.data4[3] = readByte();
    uuid.data4[4] = readByte();
    uuid.data4[5] = readByte();
    uuid.data4[6] = readByte();
    uuid.data4[7] = readByte();
    setByteOrder (LittleEndian);
    return uuid;
}


QHostAddress BinaryReader::readIPv4Address()
{
    setByteOrder (BigEndian);
    QHostAddress address (readUInt32());
    setByteOrder (LittleEndian);
    return address;
}


GgepBlock BinaryReader::readGgepBlock()
{
    if(lookAhead (1) != GgepBlock::MagicByte)
        return GgepBlock();
    readByte(); // Eat the GgepBlock::MagicByte.

    GgepBlock block;
    uchar flags = 0;
    QByteArray id;
    int dataLength = 0;
    while (!(flags & Extensions::Ggep::LastExtension)) {
        if (!readGgepBlockExtensionHeader (flags, id))
            return GgepBlock();

        if (!readGgepBlockDataLength (dataLength))
            return GgepBlock();

        QByteArray rawData = readBytes (dataLength);
        auto_ptr <Extensions::Ggep> extension;
        extension.reset (Extensions::Ggep::fromId (id, flags, rawData));
        Q_ASSERT (extension.get() != 0);
        block.addExtension (*extension);
    }
    return block;
}


bool BinaryReader::readGgepBlockExtensionHeader (uchar &flags, QByteArray &id)
{
    flags = readByte();
    int idLength = flags & Extensions::Ggep::IDLength;
    // ID must not be zero length.
    if (idLength == 0)
        return false;
    id = readBytes(idLength);
    return true;
}


bool BinaryReader::readGgepBlockDataLength (int &dataLength)
{
    bool readMore = false;
    int bytesRead = 0;
    dataLength = 0; // We'll be ORing so make sure it's reset.
    do {
        char byte = readByte();
        dataLength = (dataLength << 6) | (byte & 0x3F);
        readMore = (byte & 0x40) != 0x40;
        bytesRead++;
    } while (readMore && bytesRead < 3);
    // The data length encoding was corrupt if readMore is still true:
    return readMore == false;
}


QueryData BinaryReader::readQueryData()
{
    QByteArray bytes = readAll();
    return readHugeGemBlock (bytes);
}


MinSpeed BinaryReader::readMinSpeed()
{
    MinSpeed speed;
    uchar byte = readByte();
    if (byte & 0x80) {
        speed.isValid = true;
        speed.isFirewalled              = byte & 0x40;
        speed.wantXmlMetadata           = byte & 0x20;
        speed.isLeafGuidedDynamicQuery  = byte & 0x10;
        speed.isAllowedGgepH            = byte & 0x08;
        speed.isOutOfBoundQuery         = byte & 0x04;
        speed.maxQueryHits              = readByte();
    }  else {
        readByte(); // invalid speed, ignore next byte
    }
    return speed;
}


VendorCode BinaryReader::readVendorCode()
{
    return VendorCode (readBytes (VendorCode::VendorCodeLength));
}


ResultSet BinaryReader::readQueryHitsResultSet (int hitsNumber)
{
    ResultSet resultSet;
    Result result;
    for(int i=0;i<hitsNumber;++i)
    {
        result.fileIndex        = readUInt32();
        result.fileSize         = readUInt32();
        result.fullFileName     = readString();
        const QByteArray bytes  = readString ('\0');

        result.resultData = readHugeGemBlock (bytes);
        resultSet.append (result);
    }
    return resultSet;
}


QueryHitsData BinaryReader::readQueryHitsData()
{
    QueryHitsData   queryHitsData;

    // Read the serventId from the last 16 bytes.
    setReadOrigin (ReadFromEnd);
    QByteArray tempBytes = readBytes(16);
    queryHitsData.serventId = BinaryReader (tempBytes).readUuid();
    setReadOrigin (ReadFromStart);

    // Return if no more data is available (everything but serventId is Null).
    if(!canRead(1))
        return queryHitsData;

    // Read the vendorCode
    queryHitsData.vendorCode = readVendorCode();
    uchar openAreaSize  = readByte();

    // Read openAreaFlags
    uchar flags1 = readByte();
    uchar flags2 = readByte();

    bool hasGgep = false;
    if (flags1 & 0x20) hasGgep = flags2 & 0x20;
    if (flags1 & 0x10) queryHitsData.flagUploadSpeed = flags2 & 0x10;
    if (flags1 & 0x08) queryHitsData.flagHaveUploaded = flags2 & 0x08;
    if (flags1 & 0x04) queryHitsData.flagBusy = flags2 & 0x04;
    if (flags2 & 0x01) queryHitsData.flagPush = flags1 & 0x01;

    // See if there's an xmlBlock in the private area:
    int xmlLength = 0;
    // \todo Changing '\x04' to '4' in any of the test in BinaryReaderTest would
    // not result in a failing test! The reason is that we just read the value
    // and check >= 4. We do not later verify whether that nuber of bytes has
    // been read! Should we run such a check?
    if(openAreaSize >= 4)
        xmlLength = readUInt16();

    // Read a GgepBlock if one is available:
    if(hasGgep) {
        while(canRead(1)) {
            // \todo Could it contain multiple GGEP blocks?? If yes, couldn't
            // we better modify readGgepBlock() to read-and-combine any number
            // of subesquent GGEP blocks?
            if(lookAhead(1) == GgepBlock::MagicByte) {
                // Read the GgepBlock one the MacigByte is found:
                queryHitsData.ggepBlock = readGgepBlock();
                break;
            } else {
                // Just read the unknown private data:
                queryHitsData.privateVendor.append (readByte());
            }
        }
    }

    // Read any XML data if available:
    if(xmlLength > 0) {
        setReadOrigin (ReadFromEnd);
        readByte(); 
        queryHitsData.xmlData = readBytes (xmlLength - 1);
        setReadOrigin (ReadFromStart);
    }

    // Append all data between the GgepBlock and the XML data to privateVendor.
    queryHitsData.privateVendor.append (readAll());
    return queryHitsData;
}


HugeGemBlock BinaryReader::readHugeGemBlock (const QByteArray &bytes)
{
    HugeGemBlock block;
    const int bytesLength = bytes.length();
    // For each '\x1c' separated extension:
    for (int pos = 0, nextPos = 0; pos < bytesLength; pos = nextPos + 1) {
        nextPos = bytes.indexOf ('\x1c', pos);
        // No more '\x1c', or this is a GGEP block, that's the last extension:
        if (nextPos < 0 || bytes [pos] == '\xc3')
            nextPos = bytesLength; // Assume a '\x1c' terminates bytes.

        // The extension consists of all bytes up to but excluding the '\x1c':
        QByteArray extension = bytes.mid (pos, nextPos - pos);
        if (extension.isEmpty())
            continue;

        // The extension is a GGEP block:
        if (extension.startsWith ('\xc3')) {
            BinaryReader reader (extension);
            block.ggepBlock = reader.readGgepBlock();
            // If readGgepBlock() failed, then we got a Null GgepBlock. If not
            // all bytes from extension were read, then we just silently ignore
            // them.
            break; // Last extension, break the loop
        }

        // Remove trailing null byte if one exists (may happen in a Query):
        if (extension.endsWith ('\0'))
            extension.chop (1);

        if (extension.startsWith ("urn:"))
            block.urnList += extension;
        // \todo GnutellaProtocol-v0.4-r1.8 A.2.4. says:
        // "URLs MAY also be used, but they should only use well-known and
        // registered schemes (such as "http:" or "ftp:")"
        // else if (extension.startsWith ("http:") || extension.startsWith ("ftp:"))
        else if (extension.startsWith ('<') || extension.startsWith ('{'))
            block.xmlList += extension;
        else
            block.unknownList += extension;
    }
    return block;
}

Copyright © 2006 Peter Dimov.
Powered by Doxygen.