Пример #1
0
bool KTar::KTarPrivate::readLonglink(char *buffer,QByteArray &longlink) {
  qint64 n = 0;
  //qDebug() << "reading longlink from pos " << q->device()->pos();
  QIODevice *dev = q->device();
  // read size of longlink from size field in header
  // size is in bytes including the trailing null (which we ignore)
  qint64 size = QByteArray( buffer + 0x7c, 12 ).trimmed().toLongLong( 0, 8 /*octal*/ );

  size--;    // ignore trailing null
  longlink.resize(size);
  qint64 offset = 0;
  while (size > 0) {
    int chunksize = qMin(size, 0x200LL);
    n = dev->read( longlink.data() + offset, chunksize );
    if (n == -1) return false;
    size -= chunksize;
    offset += 0x200;
  }/*wend*/
  // jump over the rest
  const int skip = 0x200 - (n % 0x200);
  if (skip <= 0x200) {
    if (dev->read(buffer,skip) != skip)
        return false;
  }
  return true;
}
Пример #2
0
int EventStream::load(QIODevice &source)
{
    uint8_t sig[4];
    int32_t size;
    int offset;
    struct evt_file_header file_header;

    if (source.read((char *)&file_header, sizeof(file_header)) != sizeof(file_header)) {
        qDebug() << "Unable to read file header: " << source.errorString();
        return -1;
    }

    if (memcmp(&file_header.magic1, EVENT_HDR_1, sizeof(file_header.magic1))) {
        qDebug() << "Error: File signature doesn't match";
        qDebug("%x%x%x%x vs %x%x%x%x\n", 
                file_header.magic1[0], file_header.magic1[1],
                file_header.magic1[2], file_header.magic1[3],
                EVENT_HDR_1[0], EVENT_HDR_1[1],
                EVENT_HDR_1[2], EVENT_HDR_1[3]);
        return -1;
    }

    size = _ntohl(file_header.count);

	for (offset=0; offset<size; offset++) {
        uint32_t addr;
        if (source.read((char *)&addr, sizeof(addr)) != sizeof(addr)) {
            qDebug() << "Unable to read addr table: " << source.errorString();
            return -1;
        }
        addr = _ntohl(addr);
        _offsets.append(addr);
    }
    
	if (source.read((char *)sig, sizeof(sig)) != sizeof(sig)) {
        qDebug() << "Unable to read stream: " << source.errorString();
        return -1;
    }

    if (memcmp(sig, EVENT_HDR_2, sizeof(sig))) {
        qDebug() << "Error: Main signature doesn't match";
        qDebug("%x%x%x%x vs %x%x%x%x\n", sig[0], sig[1], sig[2], sig[3],
                EVENT_HDR_2[0], EVENT_HDR_2[1], EVENT_HDR_2[2], EVENT_HDR_2[3]);
        return -1;
    }

    for (offset=0; offset<size; offset++) {
        Event e(source, this);
        _events.append(e);
    }

    _currentEvents = _events;

    return 0;
}
Пример #3
0
QVariant Message::parseValue(QIODevice &data, const quint8 wireType,
                             const Types::ScalarType scalarType,
                             const QString &tagPath) const
{
    // A small sanity check. In this case, the wireType will take precedence.
    if ((scalarType != Types::Unknown) &&
        (wireType != Types::LengthDelimeted) &&
        (wireType != Types::getWireType(scalarType))) {
        qWarning() << tagPath << "wire type" << wireType << "does not match "
            "expected wire type" << Types::getWireType(scalarType) << "for "
            "scalar type" << scalarType;
    }

    switch (wireType) {
    case Types::Varint: // int32, int64, uint32, uint64, sint32, sint64, bool, enum.
        switch (scalarType) {
        case Types::Int32:      return parseStandardVarint(data);
        case Types::Int64:      return parseStandardVarint(data);
        case Types::Uint32:     return parseUnsignedVarint(data);
        case Types::Uint64:     return parseUnsignedVarint(data);
        case Types::Sint32:     return parseSignedVarint(data);
        case Types::Sint64:     return parseSignedVarint(data);
        case Types::Bool:       return parseStandardVarint(data);
        case Types::Enumerator: return parseStandardVarint(data);
        default:                return parseStandardVarint(data);
        }
        break;
    case Types::SixtyFourBit: // fixed64, sfixed64, double.
        switch (scalarType) {
        case Types::Fixed64:  return parseFixedNumber<quint64>(data);
        case Types::Sfixed64: return parseFixedNumber<qint64>(data);
        case Types::Double:   return parseFixedNumber<double>(data);
        default:              return data.read(8); // The raw 8-byte sequence.
        }
        break;
    case Types::LengthDelimeted: // string, bytes, embedded messages, packed repeated fields.
        return parseLengthDelimitedValue(data, scalarType, tagPath);
    case Types::StartGroup: // deprecated.
        return parse(data, tagPath + pathSeparator);
    case Types::EndGroup: // deprecated.
        return QVariant(); // Caller will need to end the group started previously.
    case Types::ThirtyTwoBit: // fixed32, sfixed32, float.
        switch (scalarType) {
        case Types::Fixed32:  return parseFixedNumber<quint32>(data);
        case Types::Sfixed32: return parseFixedNumber<qint32>(data);
        case Types::Float:    return parseFixedNumber<float>(data);
        default:              return data.read(4); // The raw 4-byte sequence.
        }
        break;
    }
    qWarning() << "invalid wireType:" << wireType << "(tagPath:" << tagPath << ')';
    return QVariant();
}
Пример #4
0
void KArchiveFile::copyTo(const QString& dest) const
{
  QFile f( dest + QLatin1Char('/')  + name() );
  if ( f.open( QIODevice::ReadWrite | QIODevice::Truncate ) )
  {
      QIODevice* inputDev = createDevice();

      // Read and write data in chunks to minimize memory usage
      const qint64 chunkSize = 1024 * 1024;
      qint64 remainingSize = d->size;
      QByteArray array;
      array.resize( int( qMin( chunkSize, remainingSize ) ) );

      while ( remainingSize > 0 ) {
          const qint64 currentChunkSize = qMin( chunkSize, remainingSize );
          const qint64 n = inputDev->read( array.data(), currentChunkSize );
          Q_ASSERT( n == currentChunkSize );
          f.write( array.data(), currentChunkSize );
          remainingSize -= currentChunkSize;
      }
      f.close();

      delete inputDev;
  }
}
Пример #5
0
bool CharArchive::openAnimBoneCount()
{
    if (!isOpen()) {
        qWarning() << "CharArchive::openAnimBoneCount" << "archive not opened";
        return false;
    }

    _animBoneCount.clear();

    LgpIterator it = _io.iterator();
    while(it.hasNext()) {
        it.next();
        const QString &fileName = it.fileName();
        if(fileName.endsWith(".a", Qt::CaseInsensitive)) {
            QCoreApplication::processEvents();
            QIODevice *aFile = it.file();
            if(aFile && aFile->open(QIODevice::ReadOnly)) {
                quint32 boneCount;
                if(!aFile->seek(8) ||
                        aFile->read((char *)&boneCount, 4) != 4) {
                    qWarning() << "CharArchive::openAnimBoneCount" << "animation error" << fileName;
                    continue;
                }
                _animBoneCount.insert(boneCount, fileName.left(fileName.size()-2).toUpper());
            } else {
                return false;
            }
        }
    }

    return true;
}
Пример #6
0
void KoImageDataPrivate::copyToTemporary(QIODevice &device)
{
    delete temporaryFile;
    temporaryFile = new KTemporaryFile();
    temporaryFile->setPrefix("KoImageData");
    if (!temporaryFile->open()) {
        kWarning(30006) << "open temporary file for writing failed";
        errorCode = KoImageData::StorageFailed;
        return;
    }
    QCryptographicHash md5(QCryptographicHash::Md5);
    char buf[8096];
    while (true) {
        device.waitForReadyRead(-1);
        qint64 bytes = device.read(buf, sizeof(buf));
        if (bytes <= 0)
            break; // done!
        md5.addData(buf, bytes);
        do {
            bytes -= temporaryFile->write(buf, bytes);
        } while (bytes > 0);
    }
    key = KoImageDataPrivate::generateKey(md5.result());

    temporaryFile->close();

    //QFileInfo fi(*temporaryFile);
    dataStoreState = StateNotLoaded;
}
Пример #7
0
const QByteArray& QxtMailAttachment::rawData() const
{
    if (qxt_d->content == 0)
    {
        qWarning("QxtMailAttachment::rawData(): Content not set!");
        static QByteArray defaultRv;
        return defaultRv;
    }
    if (qobject_cast<QBuffer *>(qxt_d->content.data()) == 0)
    {
        // content isn't hold in a buffer but in another kind of QIODevice
        // (probably a QFile...). Read the data and cache it into a buffer
        static QByteArray empty;
        QIODevice* c = content();
        if (!c->isOpen() && !c->open(QIODevice::ReadOnly))
        {
            qWarning() << "QxtMailAttachment::rawData(): Cannot open content for reading";
            return empty;
        }
        QBuffer* cache = new QBuffer();
        cache->open(QIODevice::WriteOnly);
        char buf[1024];
        while (!c->atEnd())
        {
            cache->write(buf, c->read(buf, 1024));
        }
        if (qxt_d->deleteContent && qxt_d->content)
        qxt_d->content->deleteLater();
        qxt_d->content = cache;
        qxt_d->deleteContent = true;
    }
    return qobject_cast<QBuffer *>(qxt_d->content.data())->data();
}
Пример #8
0
void KoImageDataPrivate::copyToTemporary(QIODevice &device)
{
    delete temporaryFile;
    temporaryFile = new QTemporaryFile(QDir::tempPath() + "/" + qAppName() + QLatin1String("_XXXXXX"));
    if (!temporaryFile->open()) {
        warnFlake << "open temporary file for writing failed";
        errorCode = KoImageData::StorageFailed;
        return;
    }
    QCryptographicHash md5(QCryptographicHash::Md5);
    char buf[8096];
    while (true) {
        device.waitForReadyRead(-1);
        qint64 bytes = device.read(buf, sizeof(buf));
        if (bytes <= 0)
            break; // done!
        md5.addData(buf, bytes);
        do {
            bytes -= temporaryFile->write(buf, bytes);
        } while (bytes > 0);
    }
    key = KoImageDataPrivate::generateKey(md5.result());

    temporaryFile->close();

    dataStoreState = StateNotLoaded;
}
Пример #9
0
QVariant parseFixedNumber(QIODevice &data)
{
    Q_ASSERT((sizeof(Type) == 4) || (sizeof(Type) == 8));
    const QByteArray array = data.read(sizeof(Type));
    if (array.size() != sizeof(Type)) return QVariant();
    return qFromLittleEndian<Type>(reinterpret_cast<const uchar *>(array.constData()));
}
Пример #10
0
static qint64 streamReadData(QIODevice &source, char *data, qint64 bytesTotal) {
	qint64 bytesRead = 0;
	qint64 bytesLeft = bytesTotal;
	int result;

	while (bytesLeft > 0) {
		result = source.read(data, bytesLeft);
		if (result < 0) {
			qDebug() << "Source had error:" << source.errorString();
			return result;
		}

		if (result == 0) {
			if (!source.waitForReadyRead(-1)) {
				qDebug() << "Source is done, closing";
				break;
			}
		}

		if (result > bytesTotal) {
			qDebug() << "Very bad.  Wanted " << bytesTotal << ", but got " << result;
		}
		bytesRead += result;
		data += result;
		if (bytesLeft - result < 0) {
			qDebug() << "That was a really strange read";
		}
		bytesLeft -= result;
	}
	if (bytesLeft < 0) {
		qDebug() << "How could bytesLeft (" << bytesLeft << ") be less than zero?";
	}
	return bytesRead;
}
Пример #11
0
bool KArchiveFile::copyTo(const QString &dest) const
{
    QFile f(dest + QLatin1Char('/')  + name());
    if (f.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
        QIODevice *inputDev = createDevice();

        // Read and write data in chunks to minimize memory usage
        const qint64 chunkSize = 1024 * 1024;
        qint64 remainingSize = d->size;
        QByteArray array;
        array.resize(int(qMin(chunkSize, remainingSize)));

        while (remainingSize > 0) {
            const qint64 currentChunkSize = qMin(chunkSize, remainingSize);
            const qint64 n = inputDev->read(array.data(), currentChunkSize);
            Q_UNUSED(n) // except in Q_ASSERT
            Q_ASSERT(n == currentChunkSize);
            f.write(array.data(), currentChunkSize);
            remainingSize -= currentChunkSize;
        }
        f.setPermissions(withExecutablePerms(f.permissions(), permissions()));
        f.close();

        delete inputDev;
        return true;
    }
    return false;
}
Пример #12
0
/**
 * This tests the decompression using kfilterdev, basically.
 * To debug KTarPrivate::fillTempFile().
 *
 * @dataProvider setupData
 */
void KArchiveTest::testUncompress()
{
    QFETCH(QString, fileName);
    QFETCH(QString, mimeType);

    // testCreateTar must have been run first.
    QVERIFY(QFile::exists(fileName));
    QIODevice *filterDev = KFilterDev::deviceForFile(fileName, mimeType, true);
    QVERIFY(filterDev);
    QByteArray buffer;
    buffer.resize(8*1024);
    kDebug() << "buffer.size()=" << buffer.size();
    QVERIFY(filterDev->open(QIODevice::ReadOnly));

    qint64 totalSize = 0;
    qint64 len = -1;
    while (!filterDev->atEnd() && len != 0) {
        len = filterDev->read(buffer.data(), buffer.size());
        QVERIFY(len >= 0);
        totalSize += len;
        // kDebug() << "read len=" << len << " totalSize=" << totalSize;
    }
    filterDev->close();
    delete filterDev;
    // kDebug() << "totalSize=" << totalSize;
    QVERIFY(totalSize > 26000); // 27648 here when using gunzip
}
/*!
    \reimp
 */
void QxtXmlFileLoggerEngine::initLoggerEngine()
{
    QxtAbstractFileLoggerEngine::initLoggerEngine();

    // Mkay, we have an open file.  We need to check that it's all valid.
    // at the end of this block of code, we either can't log, or the carat is ready for writing.
    /*
    <?xml version="1.0" encoding="UTF-8"?>
    <log>
        <entry type="Error" time="sometime">
            <message>What's going on?</message>
            <message?Hi there</message>
        </entry>
    </log>
    */
    QIODevice* file = device();
    Q_ASSERT(file);
    if (file->size() == 0)
    {
        file->write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
        file->write("<log>\n");
        file->write("</log>");
    }
    else
    {
        QByteArray data = file->read(64);
        if (!data.startsWith(QByteArray("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<log>")))
        {
            QFile* ptr_fileTarget = static_cast<QFile*>(file);
            qxtLog->warning(QString(" is not a valid XML log file.").prepend(ptr_fileTarget->fileName()));
            killLoggerEngine();
            return;
        }
    }
}
QByteArray QIODeviceProto::read(qint64 maxSize)
{
  QIODevice *item = qscriptvalue_cast<QIODevice*>(thisObject());
  if (item)
    return item->read(maxSize);
  return QByteArray();
}
Пример #15
0
/*!
    \reimp
*/
void QNetworkDiskCache::updateMetaData(const QNetworkCacheMetaData &metaData)
{
#if defined(QNETWORKDISKCACHE_DEBUG)
    qDebug() << "QNetworkDiskCache::updateMetaData()" << metaData.url();
#endif
    QUrl url = metaData.url();
    QIODevice *oldDevice = data(url);
    if (!oldDevice) {
#if defined(QNETWORKDISKCACHE_DEBUG)
        qDebug() << "QNetworkDiskCache::updateMetaData(), no device!";
#endif
        return;
    }

    QIODevice *newDevice = prepare(metaData);
    if (!newDevice) {
#if defined(QNETWORKDISKCACHE_DEBUG)
        qDebug() << "QNetworkDiskCache::updateMetaData(), no new device!" << url;
#endif
        return;
    }
    char data[1024];
    while (!oldDevice->atEnd()) {
        qint64 s = oldDevice->read(data, 1024);
        newDevice->write(data, s);
    }
    delete oldDevice;
    insert(newDevice);
}
Пример #16
0
// streaming callbacks
static int ReadFunc(void *opaque, uint8_t *buf, int buf_size)
{
    QIODevice *io = (QIODevice*)opaque;

    buf_size = min(buf_size, (int) io->bytesAvailable());
    return io->read((char*)buf, buf_size);
}
qint64 QIODeviceProto::read(char *data, qint64 maxSize)
{
  QIODevice *item = qscriptvalue_cast<QIODevice*>(thisObject());
  if (item)
    return item->read(data, maxSize);
  return 0;
}
Пример #18
0
void VideoData::copyToTemporary(QIODevice &device)
{
    delete d;
    d = new VideoDataPrivate();
    d->temporaryFile = new KTemporaryFile();
    d->refCount.ref();
    d->temporaryFile->setPrefix("KoVideoData");
    if (!d->temporaryFile->open()) {
        kWarning(30006) << "open temporary file for writing failed";
        d->errorCode = VideoData::StorageFailed;
        delete d;
        d = 0;
        return;
    }
    QCryptographicHash md5(QCryptographicHash::Md5);
    char buf[8192];
    while (true) {
        device.waitForReadyRead(-1);
        qint64 bytes = device.read(buf, sizeof(buf));
        if (bytes <= 0)
            break; // done!
        md5.addData(buf, bytes);
        do {
            bytes -= d->temporaryFile->write(buf, bytes);
        } while (bytes > 0);
    }
    d->key = VideoData::generateKey(md5.result());
    d->temporaryFile->close();

    QFileInfo fi(*(d->temporaryFile));
    d->dataStoreState = StateSpooled;
}
Пример #19
0
int QIOInputFunction(void* data, uint8_t* buf, size_t count)
{
    QIODevice* io = static_cast<QIODevice*>(data);
    if (io->atEnd())
        return 0;
    return io->read(reinterpret_cast<char*>(buf),count);
}
Пример #20
0
quint32 Nicookie::readUint32LE(QIODevice &device)
{
    QDataStream stream(device.read(4));
    stream.setByteOrder(QDataStream::LittleEndian);
    quint32 i;
    stream >> i;
    return i;
}
bool LibSingleFileInterface::copyFiles(const QList<QVariant> & files, const QString & destinationDirectory, Kerfuffle::ExtractionOptions options)
{
    Q_UNUSED(files)
    Q_UNUSED(options)

    QString outputFileName = destinationDirectory;
    if (!destinationDirectory.endsWith(QLatin1Char('/'))) {
        outputFileName += QLatin1Char('/');
    }
    outputFileName += uncompressedFileName();

    outputFileName = overwriteFileName(outputFileName);
    if (outputFileName.isEmpty()) {
        return true;
    }

    kDebug() << "Extracting to" << outputFileName;

    QFile outputFile(outputFileName);
    if (!outputFile.open(QIODevice::WriteOnly)) {
        kDebug() << "Failed to open output file" << outputFile.errorString();
        emit error(i18nc("@info", "Ark could not extract <filename>%1</filename>.", outputFile.fileName()));

        return false;
    }

    QIODevice *device = KFilterDev::deviceForFile(filename(), m_mimeType, false);
    if (!device) {
        kDebug() << "Could not create KFilterDev";
        emit error(i18nc("@info", "Ark could not open <filename>%1</filename> for extraction.", filename()));

        return false;
    }

    device->open(QIODevice::ReadOnly);

    qint64 bytesRead;
    QByteArray dataChunk(1024*16, '\0');   // 16Kb

    while (true) {
        bytesRead = device->read(dataChunk.data(), dataChunk.size());

        if (bytesRead == -1) {
            emit error(i18nc("@info", "There was an error while reading <filename>%1</filename> during extraction.", filename()));
            break;
        } else if (bytesRead == 0) {
            break;
        }

        outputFile.write(dataChunk.data(), bytesRead);
    }

    delete device;

    return true;
}
Пример #22
0
qint8 readSignedByte(QIODevice &device)
{
    qint8 result = 0;
    if (device.read(reinterpret_cast<char *> (&result),
            Q_INT64_C(1)) != Q_INT64_C(1))
    {
        throw std::runtime_error("Unable to read file");
    }
    return result;
}
Пример #23
0
qint64 FlushedProcess::read(char * data, qint64 maxlen) {
    QIODevice * dev = readingIODevice();
    if (dev == NULL) return -1;
    qint64 ret = dev->read(data,maxlen);
    if (ret < 0) {
        process.setErrorString(tr("Error reading from device!"));
        QMetaObject::invokeMethod(this,"error",Qt::QueuedConnection,Q_ARG(UnixProcess::ProcessError,UnixProcess::ReadError));
    }
    return ret;
}
Пример #24
0
qint32 readSignedDWord(QIODevice &device)
{
    qint32 result = 0;
    if (device.read(reinterpret_cast<char *> (&result),
            Q_INT64_C(4)) != Q_INT64_C(4))
    {
        throw std::runtime_error("Unable to read file");
    }
    result = qFromLittleEndian(result);
    return result;
}
Пример #25
0
QVariant parseUnsignedVarint(QIODevice &data)
{
    quint64 result = 0;
    for (uchar byte = 0xFF, index = 0; byte >= 0x80; ++index) {
        const QByteArray array = data.read(1);
        if (array.isEmpty()) return QVariant();
        byte = static_cast<uchar>(array.at(0));
        result += (byte & Q_UINT64_C(0x7F)) << (7 * index);
    }
    return result;
}
Пример #26
0
static bool copyData(QIODevice &inFile, QIODevice &outFile)
{
    while (!inFile.atEnd()) {
        char buf[4096];
        qint64 readLen = inFile.read(buf, 4096);
        if (readLen <= 0)
            return false;
        if (outFile.write(buf, readLen) != readLen)
            return false;
    }
    return true;
}
Пример #27
0
QVariant Message::readLengthDelimitedValue(QIODevice &data) const
{
    // Note: We're assuming length-delimited values use unsigned varints for lengths.
    // I haven't found any Protocl Buffers documentation to support / dispute this.
    const QVariant length = parseUnsignedVarint(data);
    if (!length.isValid()) {
        qWarning() << "failed to read prefix-delimited length";
        return QVariant();
    }
    const QByteArray value = data.read(length.toULongLong());
    return (value.length() == length.toInt()) ? value : QVariant();
}
Пример #28
0
/* callback function for libisofs */
static int readf(char *buf, unsigned int start, unsigned int len, void *udata)
{
    KISOFUNC;

    QIODevice* dev = (static_cast<KIso*>(udata))->device();

    if (dev->seek((qint64)start << (qint64)11)) {
        if ((dev->read(buf, len << 11u)) != -1) return (len);
    }
    //qDebug() << "KIso::ReadRequest failed start: " << start << " len: " << len << endl;

    return -1;
}
Пример #29
0
static void readPngChunk(png_structp png_ptr, png_bytep data, png_size_t length)
{
    QIODevice *in = (QIODevice *)png_get_io_ptr(png_ptr);

    while (length) {
        int nr = in->read((char*)data, length);
        if (nr <= 0) {
            png_error(png_ptr, "Read Error");
            return;
        }
        length -= nr;
    }
}
Пример #30
0
bool copyData(QIODevice& src, QIODevice& dest)
{
	bool success = false;
	if ((src.openMode() & QIODevice::ReadOnly) == 0)
		return false;
	if ((dest.openMode() & QIODevice::WriteOnly) == 0)
		return false;
	QByteArray bb( 65536, ' ' );
	if (bb.size() > 0) // Check for memory allocation failure
	{
		qint64 byteswritten;
		qint64 bytesread = src.read( bb.data(), bb.size() );
		success = (bytesread > 0);
		while (bytesread > 0)
		{
			byteswritten = dest.write( bb.data(), bytesread );
			success  &= (bytesread == byteswritten);
			bytesread = src.read( bb.data(), bb.size() );
		}
	}
	return success;
}