Exemple #1
0
// TODO: consider refactoring this to return error code
void WdtSocket::readEncryptionSettingsOnce(int timeoutMs) {
  if (!encryptionParams_.isSet() || encryptionSettingsRead_) {
    return;
  }
  WDT_CHECK(!encryptionParams_.getSecret().empty());

  int numRead = readInternal(buf_, 1, timeoutMs, true);
  if (numRead != 1) {
    LOG(ERROR) << "Failed to read encryption settings " << numRead << " "
               << port_;
    return;
  }
  if (buf_[0] != Protocol::ENCRYPTION_CMD) {
    LOG(ERROR) << "Expected to read ENCRYPTION_CMD(e), but got " << buf_[0];
    readErrorCode_ = UNEXPECTED_CMD_ERROR;
    return;
  }
  int toRead = Protocol::kMaxEncryption - 1;  // already read 1 byte for cmd
  numRead = readInternal(buf_, toRead,
                         threadCtx_.getOptions().read_timeout_millis, true);
  if (numRead != toRead) {
    LOG(ERROR) << "Failed to read encryption settings " << numRead << " "
               << toRead << " " << port_;
    readErrorCode_ = SOCKET_READ_ERROR;
    return;
  }
  int64_t off = 0;
  EncryptionType encryptionType;
  std::string iv;
  if (!Protocol::decodeEncryptionSettings(buf_, off, Protocol::kMaxEncryption,
                                          encryptionType, iv)) {
    LOG(ERROR) << "Failed to decode encryption settings";
    readErrorCode_ = PROTOCOL_ERROR;
    return;
  }
  if (encryptionType != encryptionParams_.getType()) {
    LOG(ERROR) << "Encryption type mismatch "
               << encryptionTypeToStr(encryptionType) << " "
               << encryptionTypeToStr(encryptionParams_.getType());
    readErrorCode_ = PROTOCOL_ERROR;
    return;
  }
  if (!decryptor_.start(encryptionParams_, iv)) {
    readErrorCode_ = ENCRYPTION_ERROR;
    return;
  }
  LOG(INFO) << "Successfully read encryption settings " << port_ << " "
            << encryptionTypeToStr(encryptionType);
  encryptionSettingsRead_ = true;
}
void NuCachedSource2::onRead(const sp<AMessage> &msg) {
    ALOGV("onRead");

    int64_t offset;
    CHECK(msg->findInt64("offset", &offset));

    void *data;
    CHECK(msg->findPointer("data", &data));

    size_t size;
    CHECK(msg->findSize("size", &size));

    ssize_t result = readInternal(offset, data, size);

    if (result == -EAGAIN) {
        msg->post(50000);
        return;
    }

    Mutex::Autolock autoLock(mLock);
    if (mDisconnecting) {
        mCondition.signal();
        return;
    }

    CHECK(mAsyncResult == NULL);

    mAsyncResult = new AMessage;
    mAsyncResult->setInt32("result", result);

    mCondition.signal();
}
Exemple #3
0
void FileReader::readAsDataURL(Blob* blob, ExceptionState& exceptionState)
{
    ASSERT(blob);
    WTF_LOG(FileAPI, "FileReader: reading as data URL: %s %s\n", utf8BlobUUID(blob).data(), utf8FilePath(blob).data());

    readInternal(blob, FileReaderLoader::ReadAsDataURL, exceptionState);
}
Exemple #4
0
void FileReader::readAsArrayBuffer(Blob* blob, ExceptionState& exceptionState)
{
    ASSERT(blob);
    WTF_LOG(FileAPI, "FileReader: reading as array buffer: %s %s\n", utf8BlobUUID(blob).data(), utf8FilePath(blob).data());

    readInternal(blob, FileReaderLoader::ReadAsArrayBuffer, exceptionState);
}
Exemple #5
0
int WdtSocket::readWithTimeout(char *buf, int nbyte, int timeoutMs,
                               bool tryFull) {
  WDT_CHECK_GT(nbyte, 0);
  if (readErrorCode_ != OK && readErrorCode_ != WDT_TIMEOUT) {
    WLOG(ERROR) << "Socket read failed before, not trying to read again "
                << port_;
    return -1;
  }
  readErrorCode_ = OK;
  int numRead = 0;
  readEncryptionSettingsOnce(timeoutMs);
  if (supportUnencryptedPeer_ && readErrorCode_ == UNEXPECTED_CMD_ERROR) {
    WLOG(WARNING)
        << "Turning off encryption since the other side does not support "
           "encryption "
        << port_;
    readErrorCode_ = OK;
    buf[0] = buf_[0];
    numRead = 1;
    // also turn off encryption
    encryptionParams_.erase();
  } else if (readErrorCode_ != OK) {
    return -1;
  }
  if (nbyte == numRead) {
    return nbyte;
  }
  bool encrypt = encryptionParams_.isSet();
  int ret = readInternal(buf + numRead, nbyte - numRead, timeoutMs, tryFull);
  if (ret >= 0) {
    numRead += ret;
  } else {
    return (numRead > 0 ? numRead : -1);
  }
  if (!encrypt) {
    return numRead;
  }
  int numDecrypted = 0;
  if (ctxSaveOffset_ >= 0) {
    if (ctxSaveOffset_ <= numRead) {
      if (!decryptor_.decrypt(buf, ctxSaveOffset_, buf)) {
        readErrorCode_ = ENCRYPTION_ERROR;
        return -1;
      }
      decryptor_.saveContext();
      numDecrypted = ctxSaveOffset_;
      ctxSaveOffset_ = CTX_SAVED;
    } else {
      ctxSaveOffset_ -= numRead;
    }
  }
  // have to decrypt data
  if (!decryptor_.decrypt((buf + numDecrypted), (numRead - numDecrypted),
                          (buf + numDecrypted))) {
    readErrorCode_ = ENCRYPTION_ERROR;
    return -1;
  }
  return numRead;
}
Exemple #6
0
void FileReader::readAsText(Blob* blob, const String& encoding, ExceptionState& exceptionState)
{
    ASSERT(blob);
    WTF_LOG(FileAPI, "FileReader: reading as text: %s %s\n", utf8BlobUUID(blob).data(), utf8FilePath(blob).data());

    m_encoding = encoding;
    readInternal(blob, FileReaderLoader::ReadAsText, exceptionState);
}
Exemple #7
0
void FileReader::readAsBinaryString(Blob* blob, ExceptionCode& ec)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as binary: %s %s\n", blob->url().string().utf8().data(), blob->isFile() ? toFile(blob)->path().utf8().data() : "");

    readInternal(blob, FileReaderLoader::ReadAsBinaryString, ec);
}
void FileReader::readAsArrayBuffer(Blob* blob, ExceptionCode& ec)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as array buffer: %s %s\n", blob->url().string().utf8().data(), blob->isFile() ? static_cast<File*>(blob)->path().utf8().data() : "");

    readInternal(blob, FileReaderLoader::ReadAsArrayBuffer, ec);
}
Exemple #9
0
void FileReader::readAsDataURL(Blob* blob, ExceptionCode& ec)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as data URL: %s %s\n", blob->url().string().utf8().data(), is<File>(*blob) ? downcast<File>(*blob).path().utf8().data() : "");

    readInternal(blob, FileReaderLoader::ReadAsDataURL, ec);
}
Exemple #10
0
void FileReader::readAsBinaryString(Blob* blob)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as binary: %s %s\n", blob->url().string().utf8().data(), blob->isFile() ? static_cast<File*>(blob)->path().utf8().data() : "");

    readInternal(blob, FileReaderLoader::ReadAsBinaryString);
}
Exemple #11
0
void FileReader::readAsDataURL(Blob* blob, ExceptionCode& ec)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as data URL: %s %s\n", utf8BlobURL(blob).data(), utf8FilePath(blob).data());

    readInternal(blob, FileReaderLoader::ReadAsDataURL, ec);
}
Exemple #12
0
int
LSM9DS1_G::readY()
{
    int data = 0;
    if (readInternal(AG_GYR_Y_H, AG_GYR_Y_L, &data)) {
        _y = data;
    }
    // Decode Gyroscope y-axis  [mdps measurement unit]
    return (g_lsb_sentivity * _y);
}
Exemple #13
0
KoFilter::ConversionStatus XlsxXmlDocumentReader::read(MSOOXML::MsooXmlReaderContext* context)
{
    m_context = dynamic_cast<XlsxXmlDocumentReaderContext*>(context);
    Q_ASSERT(m_context);
    const KoFilter::ConversionStatus result = readInternal();
    m_context = 0;
    if (result == KoFilter::OK)
        return KoFilter::OK;
    return result;
}
Exemple #14
0
void FileReader::readAsText(Blob* blob, const String& encoding, ExceptionCode& ec)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as text: %s %s\n", utf8BlobURL(blob).data(), utf8FilePath(blob).data());

    m_encoding = encoding;
    readInternal(blob, FileReaderLoader::ReadAsText, ec);
}
Exemple #15
0
int
LSM9DS1_A::readX()
{
    int data = 0;
    if (readInternal(AG_ACC_X_H, AG_ACC_X_L, &data)) {
        _x = data;
    }
    // Decode Accel x-axis  [mdps measurement unit]
    return (a_lsb_sentivity * _x);
}
Exemple #16
0
int
LSM9DS1_A::readY()
{
    int data = 0;
    if (readInternal(AG_ACC_Y_H, AG_ACC_Y_L, &data)) {
        _y = data;
    }
    // Decode Accel y-axis  [mdps measurement unit]
    return (a_lsb_sentivity * _y);
}
void FileReader::readAsDataURL(Blob* blob)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as data URL: %s %s\n", blob->url().string().utf8().data(), blob->isFile() ? static_cast<File*>(blob)->path().utf8().data() : "");

    m_fileType = blob->type();
    readInternal(blob, ReadFileAsDataURL);
}
Exemple #18
0
int
LSM9DS1_M::readY()
{
    int data = 0;
    if (readInternal(M_Y_H, M_Y_L, &data)) {
        _y = data;
    }
    // Decode magnetic y-axis  [mgauss measurement unit]
    return (m_lsb_sentivity * _y);
}
Exemple #19
0
int
LSM9DS1_M::readX()
{
    int data = 0;
    if (readInternal(M_X_H, M_X_L, &data)) {
        _x = data;
    }
    // Decode magnetic x-axis  [mgauss measurement unit]
    return (m_lsb_sentivity * _x);
}
Exemple #20
0
int
LSM9DS1_G::readZ()
{
    int data = 0;
    if (readInternal(AG_GYR_Z_H, AG_GYR_Z_L, &data)) {
        _z = data;
    }
    // Decode Gyroscope z-axis  [mdps measurement unit]
    return (g_lsb_sentivity * _z);
}
Exemple #21
0
int
LSM9DS1_G::readX()
{
    int data = 0;
    if (readInternal(AG_GYR_X_H, AG_GYR_X_L, &data)) {
        _x = data;
    }
    // Decode Gyroscope x-axis  [mdps measurement unit]
    return (g_lsb_sentivity * _x);
}
Exemple #22
0
int
LSM9DS1_A::readZ()
{
    int data = 0;
    if (readInternal(AG_ACC_Z_H, AG_ACC_Z_L, &data)) {
        _z = data;
    }
    // Decode Accel z-axis  [mdps measurement unit]
    return (a_lsb_sentivity * _z);
}
Exemple #23
0
int
LSM9DS1_M::readZ()
{
    int data = 0;
    if (readInternal(M_Z_H, M_Z_L, &data)) {
        _z = data;
    }
    // Decode magnetic z-axis  [mgauss measurement unit]
    return (m_lsb_sentivity * _z);
}
void FileReader::readAsText(Blob* blob, const String& encoding, ExceptionCode& ec)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as text: %s %s\n", blob->url().string().utf8().data(), blob->isFile() ? static_cast<File*>(blob)->path().utf8().data() : "");

    m_encoding = encoding;
    readInternal(blob, FileReaderLoader::ReadAsText, ec);
}
Exemple #25
0
void FileReader::readAsDataURL(Blob* blob, ExceptionState& exceptionState)
{
    if (!blob) {
        exceptionState.throwTypeError("The argument is not a Blob.");
        return;
    }

    WTF_LOG(FileAPI, "FileReader: reading as data URL: %s %s\n", utf8BlobUUID(blob).data(), utf8FilePath(blob).data());

    readInternal(blob, FileReaderLoader::ReadAsDataURL, exceptionState);
}
void FileReader::readAsText(Blob* blob, const String& encoding)
{
    if (!blob)
        return;

    LOG(FileAPI, "FileReader: reading as text: %s %s\n", blob->url().string().utf8().data(), blob->isFile() ? static_cast<File*>(blob)->path().utf8().data() : "");

    if (!encoding.isEmpty())
        m_encoding = TextEncoding(encoding);
    readInternal(blob, ReadFileAsText);
}
Exemple #27
0
void FileReader::readAsText(Blob* blob, const String& encoding, ExceptionState& exceptionState)
{
    if (!blob) {
        exceptionState.throwTypeError("The argument is not a Blob.");
        return;
    }

    WTF_LOG(FileAPI, "FileReader: reading as text: %s %s\n", utf8BlobUUID(blob).data(), utf8FilePath(blob).data());

    m_encoding = encoding;
    readInternal(blob, FileReaderLoader::ReadAsText, exceptionState);
}
KoFilter::ConversionStatus XlsxXmlCommentsReader::read(MSOOXML::MsooXmlReaderContext* context)
{
    m_context = dynamic_cast<XlsxXmlCommentsReaderContext*>(context);
    Q_ASSERT(m_context);
    m_colorIndices = m_context->colorIndices;
    m_themes = m_context->themes;
    const KoFilter::ConversionStatus result = readInternal();
    m_context = 0;
    if (result == KoFilter::OK)
        return KoFilter::OK;
    return result;
}
Exemple #29
0
bool X86AtaDevice::read(uint64_t address, uint16_t *buf, size_t sectors)
{
    if (sectors == 0) return false;

    if (sectors > 10) {
        size_t const bufIncr = sectorSize() / sizeof(uint16_t);

        bool success = true;
        for (size_t offset = 0; offset < sectors; offset += 10) {
            size_t const bufOffset = bufIncr * offset;
            size_t sectorsToRead = sectors - offset < 10 ? sectors - offset : 10;
            success = readInternal(address + offset, buf + bufOffset, sectorsToRead);
            if (!success) {
                break;
            }
        }

        return success;
    } else {
        return readInternal(address, buf, sectors);
    }

}
KoFilter::ConversionStatus XlsxXmlCommentsReader::read(MSOOXML::MsooXmlReaderContext* context)
{
    m_context = dynamic_cast<XlsxXmlCommentsReaderContext*>(context);
    Q_ASSERT(m_context);
    m_colorIndices = m_context->colorIndices;
    m_themes = m_context->themes;
    const KoFilter::ConversionStatus result = readInternal();
    m_context = 0;
    if (result != KoFilter::OK) {
        kWarning() << "Failure reading the comments";
    }
    // We're not going to fail reading the whole file because the comments cannot be read
    return KoFilter::OK;
}