ServerPicture::ServerPicture(const ServerPicture& picture)
:
fFile(NULL),
fData(NULL),
fPictures(NULL),
fPushed(NULL),
fOwner(NULL)
{
fToken = gTokenSpace.NewToken(kPictureToken, this);
BMallocIO* mallocIO = new(std::nothrow) BMallocIO();
if (mallocIO == NULL)
return;
fData = mallocIO;
const off_t size = picture.DataLength();
if (mallocIO->SetSize(size) < B_OK)
return;
picture.fData->ReadAt(0, const_cast<void*>(mallocIO->Buffer()),
size);
PictureDataWriter::SetTo(fData);
}
// Import
status_t
StyledTextImporter::Import(Icon* icon, const entry_ref* ref)
{
CALLED();
status_t err;
BFile file(ref, B_READ_ONLY);
err = file.InitCheck();
if (err < B_OK)
return err;
BNodeInfo info(&file);
char mime[B_MIME_TYPE_LENGTH];
err = info.GetType(mime);
if (err < B_OK)
return err;
if (strncmp(mime, "text/plain", B_MIME_TYPE_LENGTH))
return EINVAL;
off_t size;
err = file.GetSize(&size);
if (err < B_OK)
return err;
if (size > 1 * 1024 * 1024) // Don't load files that big
return E2BIG;
BMallocIO mio;
mio.SetSize((size_t)size + 1);
memset((void *)mio.Buffer(), 0, (size_t)size + 1);
// TODO: read runs from attribute
return _Import(icon, (const char *)mio.Buffer(), NULL);
}
void
MallocBufferLengthTest::PerformTest(void)
{
BMallocIO mem;
size_t size;
size_t bufLen;
status_t error;
off_t offset;
char writeBuf[11] = "0123456789";
NextSubTest();
bufLen = mem.BufferLength();
CPPUNIT_ASSERT(bufLen == 0);
NextSubTest();
size = mem.Write(writeBuf, 10);
bufLen = mem.BufferLength();
CPPUNIT_ASSERT(bufLen == 10);
CPPUNIT_ASSERT(size = 10);
NextSubTest();
error = mem.SetSize(0);
bufLen = mem.BufferLength();
CPPUNIT_ASSERT(bufLen == 0);
CPPUNIT_ASSERT(error == B_OK);
//This is for the BResource crashing bug
NextSubTest();
error = mem.SetSize(200);
bufLen = mem.BufferLength();
offset = mem.Seek(0, SEEK_END);
CPPUNIT_ASSERT(bufLen == 200);
CPPUNIT_ASSERT(error == B_OK);
CPPUNIT_ASSERT(offset == 200);
NextSubTest();
offset = mem.Seek(0, SEEK_END);
error = mem.SetSize(100);
bufLen = mem.BufferLength();
CPPUNIT_ASSERT(bufLen == 100);
CPPUNIT_ASSERT(mem.Position() == offset);
}
int32 DeriveKey(const void *key, int32 keyLen, const uchar *magic, int32 magicLen, uchar **result) {
uchar hash1[EVP_MAX_MD_SIZE];
uchar hash2[EVP_MAX_MD_SIZE];
uchar hash3[EVP_MAX_MD_SIZE];
uchar hash4[EVP_MAX_MD_SIZE];
unsigned int hash1Len = 0;
unsigned int hash2Len = 0;
unsigned int hash3Len = 0;
unsigned int hash4Len = 0;
int32 length = B_ERROR;
BMallocIO temp;
// HMAC-SHA1(magic)
HMAC(EVP_sha1(), key, keyLen, magic, magicLen, hash1, &hash1Len);
// Key 2 is HMAC-SHA1(HMAC-SHA1(magic) + magic)
temp.Write(hash1, hash1Len);
temp.Write(magic, magicLen);
HMAC(EVP_sha1(), key, keyLen, (uchar *)temp.Buffer(), temp.BufferLength(), hash2, &hash2Len);
// HMAC-SHA1(HMAC-SHA1(magic))
HMAC(EVP_sha1(), key, keyLen, hash1, hash1Len, hash3, &hash3Len);
// Clear the BMallocIO and reset the position to 0
temp.SetSize(0);
temp.Seek(0, SEEK_SET);
// Key 4 is HMAC-SHA1(HMAC-SHA1(HMAC-SHA1(magic)) + magic)
temp.Write(hash3, hash3Len);
temp.Write(magic, magicLen);
HMAC(EVP_sha1(), key, keyLen, (uchar *)temp.Buffer(), temp.BufferLength(), hash4, &hash4Len);
// The key is Hash2 followed by the first four bytes of Hash4
length = hash2Len + 4;
*result = (uchar *)calloc(length, sizeof(uchar));
memcpy(*result, hash2, hash2Len);
memcpy(*result + hash2Len, hash4, 4);
return length;
};
void
CMOVAtom::OnProcessMetaData()
{
BMallocIO *theUncompressedData;
uint8 *outBuffer;
CMVDAtom *aCMVDAtom = NULL;
uint32 compressionID = 0;
uint64 descBytesLeft;
uint32 Size;
descBytesLeft = GetAtomSize();
// Check for Compression Type
while (descBytesLeft > 0) {
AtomBase *aAtomBase = GetAtom(theStream);
aAtomBase->OnProcessMetaData();
if (aAtomBase->GetAtomSize() > 0) {
descBytesLeft = descBytesLeft - aAtomBase->GetAtomSize();
} else {
printf("Invalid Atom found when reading Compressed Headers\n");
descBytesLeft = 0;
}
if (dynamic_cast<DCOMAtom *>(aAtomBase)) {
// DCOM atom
compressionID = dynamic_cast<DCOMAtom *>(aAtomBase)->GetCompressionID();
delete aAtomBase;
} else {
if (dynamic_cast<CMVDAtom *>(aAtomBase)) {
// CMVD atom
aCMVDAtom = dynamic_cast<CMVDAtom *>(aAtomBase);
descBytesLeft = 0;
}
}
}
// Decompress data
if (compressionID == 'zlib') {
Size = aCMVDAtom->GetUncompressedSize();
outBuffer = (uint8 *)(malloc(Size));
printf("Decompressing %ld bytes to %ld bytes\n",aCMVDAtom->GetBufferSize(),Size);
int result = uncompress(outBuffer, &Size, aCMVDAtom->GetCompressedData(), aCMVDAtom->GetBufferSize());
if (result != Z_OK) {
printf("Failed to decompress headers uncompress returned ");
switch (result) {
case Z_MEM_ERROR:
DEBUGGER("Lack of Memory Error\n");
break;
case Z_BUF_ERROR:
DEBUGGER("Lack of Output buffer space Error\n");
break;
case Z_DATA_ERROR:
DEBUGGER("Input Data is corrupt or not a compressed set Error\n");
break;
}
}
// Copy uncompressed data into BMAllocIO
theUncompressedData = new BMallocIO();
theUncompressedData->SetSize(Size);
theUncompressedData->WriteAt(0L,outBuffer,Size);
free(outBuffer);
delete aCMVDAtom;
// reset position on BMAllocIO
theUncompressedData->Seek(SEEK_SET,0L);
// Assign to Stream
theUncompressedStream = theUncompressedData;
// All subsequent reads should use theUncompressedStream
}
}