primitiveUncompressWithOffset(void)
{
const char*compressed;
size_t compressedLength;
sqInt compressedObj;
size_t inputOffset;
sqInt num;
char* ptr;
snappy_status status;
char* uncompressed;
size_t uncompressedLength;
if (!((interpreterProxy->methodArgumentCount()) == 2)) {
interpreterProxy->primitiveFail(); return;
}
compressedObj = interpreterProxy->stackValue(1);
/* begin charPointerFor: */
if (!(interpreterProxy->isBytes(compressedObj))) {
compressed = ((char*) null);
goto l1;
}
ptr = ((char*) (interpreterProxy->firstIndexableField(compressedObj)));
compressed = ((char*) ptr);
l1: /* end charPointerFor: */;
if (!(compressed)) {
interpreterProxy->primitiveFail(); return;
}
/* begin stackPositiveIntegerValue: */
num = interpreterProxy->stackValue(0);
if ((interpreterProxy->isIntegerValue(num))
&& (num < 0)) {
inputOffset = ((sqInt) null);
goto l2;
}
inputOffset = ((sqInt) (interpreterProxy->positive32BitValueOf(num)));
l2: /* end stackPositiveIntegerValue: */;
compressedLength = interpreterProxy->byteSizeOf(compressedObj);
status = snappy_uncompressed_length(compressed + inputOffset, compressedLength, &uncompressedLength);
if (!(status == 0)) {
interpreterProxy->primitiveFailFor(status); return;
}
uncompressed = malloc(uncompressedLength);
status = snappy_uncompress(compressed + inputOffset, compressedLength, uncompressed, &uncompressedLength);
if (!(status == 0)) {
/* begin returnErrorInfoFor: */
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->pushInteger(-status);
return;
}
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->push(oopFromCBytessized(uncompressed, uncompressedLength));
free(uncompressed);
}
static int snp_decompress(struct crypto_tfm *tfm, const u8 *src,
unsigned int slen, u8 *dst, unsigned int *dlen)
{
size_t ulen;
if (!snappy_uncompressed_length(src, slen, &ulen))
return -EIO;
if (*dlen < ulen)
return -EINVAL;
*dlen = ulen;
return snappy_uncompress(src, slen, dst) ? 0 : -EIO;
}
static ZEND_FUNCTION(snappy_uncompress)
{
zval *data;
char *output = NULL;
size_t output_len;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
"z", &data) == FAILURE) {
RETURN_FALSE;
}
if (Z_TYPE_P(data) != IS_STRING) {
zend_error(E_WARNING,
"snappy_uncompress : expects parameter to be string.");
RETURN_FALSE;
}
if (snappy_uncompressed_length(Z_STRVAL_P(data), Z_STRLEN_P(data),
&output_len) != SNAPPY_OK) {
zend_error(E_WARNING, "snappy_uncompress : output length error");
RETURN_FALSE;
}
output = (char *)emalloc(output_len);
if (!output) {
zend_error(E_WARNING, "snappy_uncompress : memory error");
RETURN_FALSE;
}
if (snappy_uncompress(Z_STRVAL_P(data), Z_STRLEN_P(data),
output, &output_len) == SNAPPY_OK) {
#if ZEND_MODULE_API_NO >= 20141001
RETVAL_STRINGL(output, output_len);
#else
RETVAL_STRINGL(output, output_len, 1);
#endif
} else {
zend_error(E_WARNING, "snappy_uncompress : data error");
RETVAL_FALSE;
}
efree(output);
}
primitiveUncompress(void)
{
const char*compressed;
size_t compressedLength;
sqInt compressedObj;
char* ptr;
snappy_status status;
char* uncompressed;
size_t uncompressedLength;
if (!((interpreterProxy->methodArgumentCount()) == 1)) {
interpreterProxy->primitiveFail(); return;
}
compressedObj = interpreterProxy->stackValue(0);
/* begin charPointerFor: */
if (!(interpreterProxy->isBytes(compressedObj))) {
compressed = ((char*) null);
goto l1;
}
ptr = ((char*) (interpreterProxy->firstIndexableField(compressedObj)));
compressed = ((char*) ptr);
l1: /* end charPointerFor: */;
if (!(compressed)) {
interpreterProxy->primitiveFail(); return;
}
compressedLength = interpreterProxy->byteSizeOf(compressedObj);
status = snappy_uncompressed_length(compressed, compressedLength, &uncompressedLength);
if (!(status == 0)) {
interpreterProxy->primitiveFailFor(status); return;
}
uncompressed = malloc(uncompressedLength);
status = snappy_uncompress(compressed, compressedLength, uncompressed, &uncompressedLength);
if (!(status == 0)) {
/* begin returnErrorInfoFor: */
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->pushInteger(-status);
return;
}
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->push(oopFromCBytessized(uncompressed, uncompressedLength));
free(uncompressed);
}
static int decode_snappy(avro_codec_t c, void * data, int64_t len)
{
uint32_t crc;
size_t outlen;
if (snappy_uncompressed_length(data, len-4, &outlen) != SNAPPY_OK) {
avro_set_error("Uncompressed length error in snappy");
return 1;
}
if (!c->block_data) {
c->block_data = avro_malloc(outlen);
c->block_size = outlen;
} else if ( (size_t)c->block_size < outlen) {
c->block_data = avro_realloc(c->block_data, c->block_size, outlen);
c->block_size = outlen;
}
if (!c->block_data)
{
avro_set_error("Cannot allocate memory for snappy");
return 1;
}
if (snappy_uncompress(data, len-4, c->block_data, &outlen) != SNAPPY_OK)
{
avro_set_error("Error uncompressing block with Snappy");
return 1;
}
crc = __bswap_32(crc32(0, c->block_data, outlen));
if (memcmp(&crc, (char*)data+len-4, 4))
{
avro_set_error("CRC32 check failure uncompressing block with Snappy");
return 1;
}
c->used_size = outlen;
return 0;
}
primitiveUncompressedLength(void)
{
const char*compressed;
size_t compressedLength;
sqInt compressedObj;
char* ptr;
size_t result;
snappy_status status;
if (!((interpreterProxy->methodArgumentCount()) == 1)) {
interpreterProxy->primitiveFail(); return;
}
compressedObj = interpreterProxy->stackValue(0);
/* begin charPointerFor: */
if (!(interpreterProxy->isBytes(compressedObj))) {
compressed = ((char*) null);
goto l1;
}
ptr = ((char*) (interpreterProxy->firstIndexableField(compressedObj)));
compressed = ((char*) ptr);
l1: /* end charPointerFor: */;
if (!(compressed)) {
interpreterProxy->primitiveFail(); return;
}
compressedLength = interpreterProxy->byteSizeOf(compressedObj);
status = snappy_uncompressed_length(compressed, compressedLength, &result);
if (status == SnOK) {
/* begin returnIntegerFor: */
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
if (result <= 1073741823) {
interpreterProxy->pushInteger(result);
}
else {
interpreterProxy->push(interpreterProxy->positive32BitIntegerFor(result));
}
return;
}
/* begin returnErrorInfoFor: */
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->pushInteger(-status);
}
int pread_bin(int fd, off_t pos, char **ret_ptr)
{
char *new_buf;
int len = pread_bin_int(fd, pos, ret_ptr);
if(len < 0)
{
return len;
}
size_t new_len;
if((*ret_ptr)[0] == 1) //Snappy
{
if(snappy_uncompressed_length((*ret_ptr) + 1, len - 1, &new_len)
!= SNAPPY_OK)
{
//marked as compressed but snappy doesn't see it as valid.
free(*ret_ptr);
return -1;
}
new_buf = (char*) malloc(new_len);
snappy_status ss = (snappy_uncompress((*ret_ptr) + 1, len - 1, new_buf, &new_len));
if(ss == SNAPPY_OK)
{
free(*ret_ptr);
*ret_ptr = new_buf;
return new_len;
}
else
{
free(*ret_ptr);
return -1;
}
}
else
{
return len;
}
}
couchstore_error_t decode_index_header(const char *bytes,
size_t len,
index_header_t **header)
{
index_header_t *h = NULL;
char *b = NULL, *uncomp = NULL;
uint16_t num_seqs, i, j, sz, num_part_versions;
size_t uncompLen;
/* First 16 bytes are md5 checksum (group signature). */
if (len <= 16) {
return COUCHSTORE_ERROR_CORRUPT;
}
if (snappy_uncompressed_length(bytes + 16, len, &uncompLen) != SNAPPY_OK) {
return COUCHSTORE_ERROR_CORRUPT;
}
b = uncomp = (char *) malloc(uncompLen);
if (b == NULL) {
return COUCHSTORE_ERROR_ALLOC_FAIL;
}
if (snappy_uncompress(bytes + 16, len - 16, b, &uncompLen) != SNAPPY_OK) {
goto alloc_error;
}
h = (index_header_t *) malloc(sizeof(index_header_t));
if (h == NULL) {
goto alloc_error;
}
h->seqs = NULL;
h->id_btree_state = NULL;
h->view_states = NULL;
h->replicas_on_transfer = NULL;
h->pending_transition.active = NULL;
h->pending_transition.passive = NULL;
h->pending_transition.unindexable = NULL;
h->unindexable_seqs = NULL;
memcpy(h->signature, bytes, 16);
h->version = (uint8_t) b[0];
b += 1;
h->num_partitions = dec_uint16(b);
b += 2;
memcpy(&h->active_bitmask, b, BITMASK_BYTE_SIZE);
b += BITMASK_BYTE_SIZE;
memcpy(&h->passive_bitmask, b, BITMASK_BYTE_SIZE);
b += BITMASK_BYTE_SIZE;
memcpy(&h->cleanup_bitmask, b, BITMASK_BYTE_SIZE);
b += BITMASK_BYTE_SIZE;
num_seqs = dec_uint16(b);
b += 2;
h->seqs = sorted_list_create(part_seq_cmp);
if (h->seqs == NULL) {
goto alloc_error;
}
for (i = 0; i < num_seqs; ++i) {
part_seq_t pseq;
pseq.part_id = dec_uint16(b);
b += 2;
pseq.seq = dec_uint48(b);
b += 6;
if (sorted_list_add(h->seqs, &pseq, sizeof(pseq)) != 0) {
goto alloc_error;
}
}
sz = dec_uint16(b);
b += 2;
h->id_btree_state = read_root((void *) b, (int) sz);
b += sz;
h->num_views = (uint8_t) b[0];
b += 1;
h->view_states = (node_pointer **) malloc(sizeof(node_pointer *) * h->num_views);
if (h->view_states == NULL) {
goto alloc_error;
}
for (i = 0; i < (uint16_t) h->num_views; ++i) {
sz = dec_uint16(b);
b += 2;
h->view_states[i] = read_root((void *) b, (int) sz);
b += sz;
}
h->has_replica = b[0] == 0 ? 0 : 1;
b += 1;
sz = dec_uint16(b);
b += 2;
h->replicas_on_transfer = sorted_list_create(part_id_cmp);
if (h->replicas_on_transfer == NULL) {
goto alloc_error;
}
for (i = 0; i < sz; ++i) {
uint16_t part_id = dec_uint16(b);
b += 2;
if (sorted_list_add(h->replicas_on_transfer, &part_id, sizeof(part_id)) != 0) {
goto alloc_error;
}
}
sz = dec_uint16(b);
b += 2;
h->pending_transition.active = sorted_list_create(part_id_cmp);
if (h->pending_transition.active == NULL) {
goto alloc_error;
}
for (i = 0; i < sz; ++i) {
uint16_t part_id = dec_uint16(b);
b += 2;
if (sorted_list_add(h->pending_transition.active,
&part_id, sizeof(part_id)) != 0) {
goto alloc_error;
}
}
sz = dec_uint16(b);
b += 2;
h->pending_transition.passive = sorted_list_create(part_id_cmp);
if (h->pending_transition.passive == NULL) {
goto alloc_error;
}
for (i = 0; i < sz; ++i) {
uint16_t part_id = dec_uint16(b);
b += 2;
if (sorted_list_add(h->pending_transition.passive,
&part_id, sizeof(part_id)) != 0) {
goto alloc_error;
}
}
sz = dec_uint16(b);
b += 2;
h->pending_transition.unindexable = sorted_list_create(part_id_cmp);
if (h->pending_transition.unindexable == NULL) {
goto alloc_error;
}
for (i = 0; i < sz; ++i) {
uint16_t part_id = dec_uint16(b);
b += 2;
if (sorted_list_add(h->pending_transition.unindexable,
&part_id, sizeof(part_id)) != 0) {
goto alloc_error;
}
}
num_seqs = dec_uint16(b);
b += 2;
h->unindexable_seqs = sorted_list_create(part_seq_cmp);
if (h->unindexable_seqs == NULL) {
goto alloc_error;
}
for (i = 0; i < num_seqs; ++i) {
part_seq_t pseq;
pseq.part_id = dec_uint16(b);
b += 2;
pseq.seq = dec_uint48(b);
b += 6;
if (sorted_list_add(h->unindexable_seqs, &pseq, sizeof(pseq)) != 0) {
goto alloc_error;
}
}
if (h->version >= 2) {
num_part_versions = dec_uint16(b);
b += 2;
h->part_versions = sorted_list_create(part_versions_cmp);
if (h->part_versions == NULL) {
goto alloc_error;
}
for (i = 0; i < num_part_versions; ++i) {
part_version_t pver;
pver.part_id = dec_uint16(b);
b += 2;
pver.num_failover_log = dec_uint16(b);
b += 2;
pver.failover_log = (failover_log_t *) malloc(
sizeof(failover_log_t) * pver.num_failover_log);
if (pver.failover_log == NULL) {
goto alloc_error;
}
for (j = 0; j < pver.num_failover_log; ++j) {
memcpy(&pver.failover_log[j].uuid, b, 8);
b += 8;
pver.failover_log[j].seq = dec_uint64(b);
b += 8;
}
if (sorted_list_add(h->part_versions, &pver, sizeof(pver)) != 0) {
free(pver.failover_log);
goto alloc_error;
}
}
}
free(uncomp);
*header = h;
return COUCHSTORE_SUCCESS;
alloc_error:
free_index_header(h);
free(uncomp);
return COUCHSTORE_ERROR_ALLOC_FAIL;
}
int bp__uncompressed_length(const char* compressed,
size_t compressed_length,
size_t* result) {
int ret = snappy_uncompressed_length(compressed, compressed_length, result);
return ret == SNAPPY_OK ? BP_OK : BP_EDECOMP;
}
unsigned int HapDecode(const void *inputBuffer, unsigned long inputBufferBytes,
HapDecodeCallback callback, void *info,
void *outputBuffer, unsigned long outputBufferBytes,
unsigned long *outputBufferBytesUsed,
unsigned int *outputBufferTextureFormat)
{
int result = HapResult_No_Error;
uint32_t sectionHeaderLength;
uint32_t sectionLength;
unsigned int sectionType;
unsigned int textureFormat;
unsigned int compressor;
const void *sectionStart;
size_t bytesUsed = 0;
/*
Check arguments
*/
if (inputBuffer == NULL
|| outputBuffer == NULL
|| outputBufferTextureFormat == NULL
)
{
return HapResult_Bad_Arguments;
}
/*
One top-level section type describes texture-format and second-stage compression
*/
result = hap_read_section_header(inputBuffer, (uint32_t)inputBufferBytes, §ionHeaderLength, §ionLength, §ionType);
if (result != HapResult_No_Error)
{
return result;
}
/*
Hap compressor/format constants can be unpacked by reading the top and bottom four bits.
*/
compressor = hap_top_4_bits(sectionType);
textureFormat = hap_bottom_4_bits(sectionType);
if (compressor == kHapCompressorComplex && callback == NULL)
{
return HapResult_Bad_Arguments;
}
/*
Pass the texture format out
*/
*outputBufferTextureFormat = hap_texture_format_constant_for_format_identifier(textureFormat);
if (*outputBufferTextureFormat == 0)
{
return HapResult_Bad_Frame;
}
sectionStart = ((uint8_t *)inputBuffer) + sectionHeaderLength;
if (compressor == kHapCompressorComplex)
{
/*
The top-level section should contain a Decode Instructions Container followed by frame data
*/
const char *frame_data = NULL;
size_t bytes_remaining = 0;
int chunk_count = 0;
const void *compressors = NULL;
const void *chunk_sizes = NULL;
const void *chunk_offsets = NULL;
result = hap_read_section_header(sectionStart, inputBufferBytes - sectionHeaderLength, §ionHeaderLength, §ionLength, §ionType);
if (result == HapResult_No_Error && sectionType != kHapSectionDecodeInstructionsContainer)
{
result = HapResult_Bad_Frame;
}
if (result != HapResult_No_Error)
{
return result;
}
/*
Frame data follows immediately after the Decode Instructions Container
*/
frame_data = ((const char *)sectionStart) + sectionHeaderLength + sectionLength;
/*
Step through the sections inside the Decode Instructions Container
*/
sectionStart = ((uint8_t *)sectionStart) + sectionHeaderLength;
bytes_remaining = sectionLength;
while (bytes_remaining > 0) {
unsigned int section_chunk_count = 0;
result = hap_read_section_header(sectionStart, bytes_remaining, §ionHeaderLength, §ionLength, §ionType);
if (result != HapResult_No_Error)
{
return result;
}
sectionStart = ((uint8_t *)sectionStart) + sectionHeaderLength;
switch (sectionType) {
case kHapSectionChunkSecondStageCompressorTable:
compressors = sectionStart;
section_chunk_count = sectionLength;
break;
case kHapSectionChunkSizeTable:
chunk_sizes = sectionStart;
section_chunk_count = sectionLength / 4;
break;
case kHapSectionChunkOffsetTable:
chunk_offsets = sectionStart;
section_chunk_count = sectionLength / 4;
break;
default:
// Ignore unrecognized sections
break;
}
/*
If we calculated a chunk count and already have one, make sure they match
*/
if (section_chunk_count != 0)
{
if (chunk_count != 0 && section_chunk_count != chunk_count)
{
return HapResult_Bad_Frame;
}
chunk_count = section_chunk_count;
}
sectionStart = ((uint8_t *)sectionStart) + sectionLength;
bytes_remaining -= sectionHeaderLength + sectionLength;
}
/*
The Chunk Second-Stage Compressor Table and Chunk Size Table are required
*/
if (compressors == NULL || chunk_sizes == NULL)
{
return HapResult_Bad_Frame;
}
if (chunk_count > 0)
{
/*
Step through the chunks, storing information for their decompression
*/
HapChunkDecodeInfo *chunk_info = (HapChunkDecodeInfo *)malloc(sizeof(HapChunkDecodeInfo) * chunk_count);
size_t running_compressed_chunk_size = 0;
size_t running_uncompressed_chunk_size = 0;
int i;
if (chunk_info == NULL)
{
return HapResult_Internal_Error;
}
for (i = 0; i < chunk_count; i++) {
chunk_info[i].compressor = *(((uint8_t *)compressors) + i);
chunk_info[i].compressed_chunk_size = hap_read_4_byte_uint(((uint8_t *)chunk_sizes) + (i * 4));
if (chunk_offsets)
{
chunk_info[i].compressed_chunk_data = frame_data + hap_read_4_byte_uint(((uint8_t *)chunk_offsets) + (i * 4));
}
else
{
chunk_info[i].compressed_chunk_data = frame_data + running_compressed_chunk_size;
}
running_compressed_chunk_size += chunk_info[i].compressed_chunk_size;
if (chunk_info[i].compressor == kHapCompressorSnappy)
{
snappy_status snappy_result = snappy_uncompressed_length(chunk_info[i].compressed_chunk_data,
chunk_info[i].compressed_chunk_size,
&(chunk_info[i].uncompressed_chunk_size));
if (snappy_result != SNAPPY_OK)
{
switch (snappy_result)
{
case SNAPPY_INVALID_INPUT:
result = HapResult_Bad_Frame;
break;
default:
result = HapResult_Internal_Error;
break;
}
break;
}
}
else
{
chunk_info[i].uncompressed_chunk_size = chunk_info[i].compressed_chunk_size;
}
chunk_info[i].uncompressed_chunk_data = (char *)(((uint8_t *)outputBuffer) + running_uncompressed_chunk_size);
running_uncompressed_chunk_size += chunk_info[i].uncompressed_chunk_size;
}
if (result == HapResult_No_Error && running_uncompressed_chunk_size > outputBufferBytes)
{
result = HapResult_Buffer_Too_Small;
}
if (result == HapResult_No_Error)
{
/*
Perform decompression
*/
bytesUsed = running_uncompressed_chunk_size;
callback((HapDecodeWorkFunction)hap_decode_chunk, chunk_info, chunk_count, info);
/*
Check to see if we encountered any errors and report one of them
*/
for (i = 0; i < chunk_count; i++)
{
if (chunk_info[i].result != HapResult_No_Error)
{
result = chunk_info[i].result;
break;
}
}
}
free(chunk_info);
if (result != HapResult_No_Error)
{
return result;
}
}
}
else if (compressor == kHapCompressorSnappy)
{
/*
Only one section is present containing a single block of snappy-compressed S3 data
*/
snappy_status snappy_result = snappy_uncompressed_length((const char *)sectionStart, sectionLength, &bytesUsed);
if (snappy_result != SNAPPY_OK)
{
return HapResult_Internal_Error;
}
if (bytesUsed > outputBufferBytes)
{
return HapResult_Buffer_Too_Small;
}
snappy_result = snappy_uncompress((const char *)sectionStart, sectionLength, (char *)outputBuffer, &bytesUsed);
if (snappy_result != SNAPPY_OK)
{
return HapResult_Internal_Error;
}
}
else if (compressor == kHapCompressorNone)
{
/*
Only one section is present containing a single block of uncompressed S3 data
*/
bytesUsed = sectionLength;
if (sectionLength > outputBufferBytes)
{
return HapResult_Buffer_Too_Small;
}
memcpy(outputBuffer, sectionStart, sectionLength);
}
else
{
return HapResult_Bad_Frame;
}
/*
Fill out the remaining return value
*/
if (outputBufferBytesUsed != NULL)
{
*outputBufferBytesUsed = bytesUsed;
}
return HapResult_No_Error;
}
static int snappy_in_java_uncompress(FILE *infp, FILE *outfp, int skip_magic)
{
snappy_in_java_header_t header;
work_buffer_t wb;
int err = 1;
int outfd;
wb.c = NULL;
wb.uc = NULL;
if (!skip_magic) {
/* read header */
if (fread_unlocked(&header, sizeof(header), 1, infp) != 1) {
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
/* check header */
if (memcmp(header.magic, SNAPPY_IN_JAVA_MAGIC, SNAPPY_IN_JAVA_MAGIC_LEN) != 0) {
print_error("This is not a snappy-java file.\n");
goto cleanup;
}
}
/* Use a file descriptor 'outfd' instead of the stdio file pointer 'outfp'
* to reduce the number of write system calls.
*/
fflush(outfp);
outfd = fileno(outfp);
/* read body */
work_buffer_init(&wb, MAX_BLOCK_SIZE);
for (;;) {
int compressed_flag;
size_t length = 0;
unsigned int crc32c = 0;
/* read compressed flag */
compressed_flag = getc_unlocked(infp);
switch (compressed_flag) {
case EOF:
/* read all blocks */
err = 0;
goto cleanup;
case COMPRESSED_FLAG:
case UNCOMPRESSED_FLAG:
/* pass */
break;
default:
print_error("Unknown compressed flag 0x%02x\n", compressed_flag);
goto cleanup;
}
/* read data length. */
length |= (getc_unlocked(infp) << 8);
length |= (getc_unlocked(infp) << 0);
/* read crc32c. */
crc32c |= (getc_unlocked(infp) << 24);
crc32c |= (getc_unlocked(infp) << 16);
crc32c |= (getc_unlocked(infp) << 8);
crc32c |= (getc_unlocked(infp) << 0);
/* check read error */
if (feof_unlocked(infp)) {
print_error("Unexpected end of file.\n");
goto cleanup;
} else if (ferror_unlocked(infp)) {
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
/* read data */
if (fread_unlocked(wb.c, length, 1, infp) != 1) {
if (feof_unlocked(infp)) {
print_error("Unexpected end of file\n");
} else {
print_error("Failed to read a file: %s\n", strerror(errno));
}
goto cleanup;
}
trace("read %ld bytes.\n", (long)(length));
if (compressed_flag == COMPRESSED_FLAG) {
/* check the uncompressed length */
size_t uncompressed_length;
err = snappy_uncompressed_length(wb.c, length, &uncompressed_length);
if (err != 0) {
print_error("Invalid data: GetUncompressedLength failed %d\n", err);
goto cleanup;
}
err = 1;
if (uncompressed_length > wb.uclen) {
print_error("Invalid data: too long uncompressed length\n");
goto cleanup;
}
/* uncompress and write */
if (snappy_uncompress(wb.c, length, wb.uc, &uncompressed_length)) {
print_error("Invalid data: RawUncompress failed\n");
goto cleanup;
}
if (check_and_write_block(outfd, wb.uc, uncompressed_length, 1, crc32c)) {
goto cleanup;
}
} else {
if (check_and_write_block(outfd, wb.c, length, 1, crc32c)) {
goto cleanup;
}
}
}
cleanup:
work_buffer_free(&wb);
return err;
}
/*
* Decode raw data of chunk's current page into corresponding r/d/bool reader
* and values_buffer, uncompress data if needed.
*/
static void
decodeCurrentPage(ParquetColumnReader *columnReader)
{
ColumnChunkMetadata_4C *chunkmd;
ParquetDataPage page;
ParquetPageHeader header;
uint8_t *buf; /* store uncompressed or decompressed page data */
MemoryContext oldContext;
chunkmd = columnReader->columnMetadata;
page = columnReader->currentPage;
header = page->header;
oldContext = MemoryContextSwitchTo(columnReader->memoryContext);
/*----------------------------------------------------------------
* Decompress raw data. After this, buf & page->data points to
* uncompressed/decompressed data.
*----------------------------------------------------------------*/
if (chunkmd->codec == UNCOMPRESSED)
{
buf = page->data;
}
else
{
/*
* make `buf` points to decompressed buffer,
* which should be large enough for uncompressed data.
*/
if (chunkmd->r > 0)
{
/* repeatable column creates decompression buffer for each page */
buf = palloc0(header->uncompressed_page_size);
}
else
{
/* non-repeatable column reuses pageBuffer for decompression */
if (columnReader->pageBuffer == NULL)
{
columnReader->pageBufferLen = header->uncompressed_page_size * BUFFER_SCALE_FACTOR;
columnReader->pageBuffer = palloc0(columnReader->pageBufferLen);
}
else if (columnReader->pageBufferLen < header->uncompressed_page_size)
{
columnReader->pageBufferLen = header->uncompressed_page_size * BUFFER_SCALE_FACTOR;
columnReader->pageBuffer = repalloc(columnReader->pageBuffer, columnReader->pageBufferLen);
}
buf = (uint8_t *) columnReader->pageBuffer;
}
/*
* call corresponding decompress routine
*/
switch (chunkmd->codec)
{
case SNAPPY:
{
size_t uncompressedLen;
if (snappy_uncompressed_length((char *) page->data,
header->compressed_page_size,
&uncompressedLen) != SNAPPY_OK)
{
ereport(ERROR,
(errcode(ERRCODE_GP_INTERNAL_ERROR),
errmsg("invalid snappy compressed data for column %s, page number %d",
chunkmd->colName, columnReader->dataPageProcessed)));
}
Insist(uncompressedLen == header->uncompressed_page_size);
if (snappy_uncompress((char *) page->data, header->compressed_page_size,
(char *) buf, &uncompressedLen) != SNAPPY_OK)
{
ereport(ERROR,
(errcode(ERRCODE_GP_INTERNAL_ERROR),
errmsg("failed to decompress snappy data for column %s, page number %d, "
"uncompressed size %d, compressed size %d",
chunkmd->colName, columnReader->dataPageProcessed,
header->uncompressed_page_size, header->compressed_page_size)));
}
page->data = buf;
break;
}
case GZIP:
{
int ret;
/* 15(default windowBits for deflate) + 16(ouput GZIP header/tailer) */
const int windowbits = 31;
z_stream stream;
stream.zalloc = Z_NULL;
stream.zfree = Z_NULL;
stream.opaque = Z_NULL;
stream.avail_in = header->compressed_page_size;
stream.next_in = (Bytef *) page->data;
ret = inflateInit2(&stream, windowbits);
if (ret != Z_OK)
{
ereport(ERROR,
(errcode(ERRCODE_GP_INTERNAL_ERROR),
errmsg("zlib inflateInit2 failed: %s", stream.msg)));
}
size_t uncompressedLen = header->uncompressed_page_size;
stream.avail_out = uncompressedLen;
stream.next_out = (Bytef *) buf;
ret = inflate(&stream, Z_FINISH);
if (ret != Z_STREAM_END)
{
ereport(ERROR,
(errcode(ERRCODE_GP_INTERNAL_ERROR),
errmsg("zlib inflate failed: %s", stream.msg)));
}
/* should fill all uncompressed_page_size bytes */
Assert(stream.avail_out == 0);
inflateEnd(&stream);
page->data = buf;
break;
}
case LZO:
/* TODO */
Insist(false);
break;
default:
Insist(false);
break;
}
}
/*----------------------------------------------------------------
* get r/d/value part
*----------------------------------------------------------------*/
if(chunkmd->r != 0)
{
int num_repetition_bytes = /*le32toh(*/ *((uint32_t *) buf) /*)*/;
buf += 4;
page->repetition_level_reader = (RLEDecoder *) palloc0(sizeof(RLEDecoder));
RLEDecoder_Init(page->repetition_level_reader,
widthFromMaxInt(chunkmd->r),
buf,
num_repetition_bytes);
buf += num_repetition_bytes;
}
if(chunkmd->d != 0)
{
int num_definition_bytes = /*le32toh(*/ *((uint32_t *) buf) /*)*/;
buf += 4;
page->definition_level_reader = (RLEDecoder *) palloc0(sizeof(RLEDecoder));
RLEDecoder_Init(page->definition_level_reader,
widthFromMaxInt(chunkmd->d),
buf,
num_definition_bytes);
buf += num_definition_bytes;
}
if (chunkmd->type == BOOLEAN)
{
page->bool_values_reader = (ByteBasedBitPackingDecoder *)
palloc0(sizeof(ByteBasedBitPackingDecoder));
BitPack_InitDecoder(page->bool_values_reader, buf, /*bitwidth=*/1);
}
else
{
page->values_buffer = buf;
}
MemoryContextSwitchTo(oldContext);
}
static int snappy_java_uncompress(FILE *infp, FILE *outfp, int skip_magic)
{
snappy_java_header_t header;
work_buffer_t wb;
int err = 1;
int outfd;
wb.c = NULL;
wb.uc = NULL;
if (skip_magic) {
/* read header except magic */
if (fread_unlocked(&header.version, sizeof(header) - sizeof(header.magic), 1, infp) != 1) {
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
} else {
/* read header */
if (fread_unlocked(&header, sizeof(header), 1, infp) != 1) {
print_error("Failed to read a file: %s\n", strerror(errno));
goto cleanup;
}
/* check magic */
if (memcmp(header.magic, SNAPPY_JAVA_MAGIC, SNAPPY_JAVA_MAGIC_LEN) != 0) {
print_error("This is not a snappy-java file.\n");
goto cleanup;
}
}
/* check rest header */
header.version = ntohl(header.version);
if (header.version != SNAPPY_JAVA_FILE_VERSION) {
print_error("Unknown snappy-java version %d\n", header.version);
goto cleanup;
}
header.compatible_version = ntohl(header.compatible_version);
if (header.compatible_version != SNAPPY_JAVA_FILE_VERSION) {
print_error("Unknown snappy-java compatible version %d\n", header.compatible_version);
goto cleanup;
}
/* Use a file descriptor 'outfd' instead of the stdio file pointer 'outfp'
* to reduce the number of write system calls.
*/
fflush(outfp);
outfd = fileno(outfp);
/* read body */
work_buffer_init(&wb, DEFAULT_BLOCK_SIZE);
for (;;) {
/* read the compressed length in a block */
size_t compressed_length = 0;
size_t uncompressed_length = wb.uclen;
int idx;
for (idx = 3; idx >= 0; idx--) {
int chr = getc_unlocked(infp);
if (chr == -1) {
if (idx == 3) {
/* read all blocks */
err = 0;
goto cleanup;
}
print_error("Unexpected end of file.\n");
goto cleanup;
}
compressed_length |= (chr << (idx * 8));
}
trace("read 4 bytes (compressed_length = %ld)\n", (long)compressed_length);
if (compressed_length == 0) {
print_error("Invalid compressed length %ld\n", (long)compressed_length);
goto cleanup;
}
if (compressed_length > wb.clen) {
work_buffer_resize(&wb, compressed_length, 0);
}
/* read the compressed data */
if (fread_unlocked(wb.c, compressed_length, 1, infp) != 1) {
if (feof_unlocked(infp)) {
print_error("Unexpected end of file\n");
} else {
print_error("Failed to read a file: %s\n", strerror(errno));
}
goto cleanup;
}
trace("read %ld bytes.\n", (long)(compressed_length));
/* check the uncompressed length */
err = snappy_uncompressed_length(wb.c, compressed_length, &uncompressed_length);
if (err != 0) {
print_error("Invalid data: GetUncompressedLength failed %d\n", err);
goto cleanup;
}
err = 1;
if (uncompressed_length > wb.uclen) {
work_buffer_resize(&wb, 0, uncompressed_length);
}
/* uncompress and write */
if (snappy_uncompress(wb.c, compressed_length, wb.uc, &uncompressed_length)) {
print_error("Invalid data: RawUncompress failed\n");
goto cleanup;
}
if (write_full(outfd, wb.uc, uncompressed_length) != uncompressed_length) {
print_error("Failed to write a file: %s\n", strerror(errno));
goto cleanup;
}
trace("write %ld bytes\n", (long)uncompressed_length);
}
cleanup:
work_buffer_free(&wb);
return err;
}
unsigned int hap_decode_single_texture(const void *texture_section, uint32_t texture_section_length,
unsigned int texture_section_type,
HapDecodeCallback callback, void *info,
void *outputBuffer, unsigned long outputBufferBytes,
unsigned long *outputBufferBytesUsed,
unsigned int *outputBufferTextureFormat)
{
int result = HapResult_No_Error;
unsigned int textureFormat;
unsigned int compressor;
size_t bytesUsed = 0;
/*
One top-level section type describes texture-format and second-stage compression
Hap compressor/format constants can be unpacked by reading the top and bottom four bits.
*/
compressor = hap_top_4_bits(texture_section_type);
textureFormat = hap_bottom_4_bits(texture_section_type);
/*
Pass the texture format out
*/
*outputBufferTextureFormat = hap_texture_format_constant_for_format_identifier(textureFormat);
if (*outputBufferTextureFormat == 0)
{
return HapResult_Bad_Frame;
}
if (compressor == kHapCompressorComplex)
{
/*
The top-level section should contain a Decode Instructions Container followed by frame data
*/
int chunk_count = 0;
const void *compressors = NULL;
const void *chunk_sizes = NULL;
const void *chunk_offsets = NULL;
const char *frame_data = NULL;
result = hap_decode_header_complex_instructions(texture_section, texture_section_length, &chunk_count, &compressors, &chunk_sizes, &chunk_offsets, &frame_data);
if (result != HapResult_No_Error)
{
return result;
}
if (chunk_count > 0)
{
/*
Step through the chunks, storing information for their decompression
*/
HapChunkDecodeInfo *chunk_info = (HapChunkDecodeInfo *)malloc(sizeof(HapChunkDecodeInfo) * chunk_count);
size_t running_compressed_chunk_size = 0;
size_t running_uncompressed_chunk_size = 0;
int i;
if (chunk_info == NULL)
{
return HapResult_Internal_Error;
}
for (i = 0; i < chunk_count; i++) {
chunk_info[i].compressor = *(((uint8_t *)compressors) + i);
chunk_info[i].compressed_chunk_size = hap_read_4_byte_uint(((uint8_t *)chunk_sizes) + (i * 4));
if (chunk_offsets)
{
chunk_info[i].compressed_chunk_data = frame_data + hap_read_4_byte_uint(((uint8_t *)chunk_offsets) + (i * 4));
}
else
{
chunk_info[i].compressed_chunk_data = frame_data + running_compressed_chunk_size;
}
running_compressed_chunk_size += chunk_info[i].compressed_chunk_size;
if (chunk_info[i].compressor == kHapCompressorSnappy)
{
snappy_status snappy_result = snappy_uncompressed_length(chunk_info[i].compressed_chunk_data,
chunk_info[i].compressed_chunk_size,
&(chunk_info[i].uncompressed_chunk_size));
if (snappy_result != SNAPPY_OK)
{
switch (snappy_result)
{
case SNAPPY_INVALID_INPUT:
result = HapResult_Bad_Frame;
break;
default:
result = HapResult_Internal_Error;
break;
}
break;
}
}
else
{
chunk_info[i].uncompressed_chunk_size = chunk_info[i].compressed_chunk_size;
}
chunk_info[i].uncompressed_chunk_data = (char *)(((uint8_t *)outputBuffer) + running_uncompressed_chunk_size);
running_uncompressed_chunk_size += chunk_info[i].uncompressed_chunk_size;
}
if (result == HapResult_No_Error && running_uncompressed_chunk_size > outputBufferBytes)
{
result = HapResult_Buffer_Too_Small;
}
if (result == HapResult_No_Error)
{
/*
Perform decompression
*/
bytesUsed = running_uncompressed_chunk_size;
if (chunk_count == 1)
{
/*
We don't invoke the callback for one chunk, just decode it directly
*/
hap_decode_chunk(chunk_info, 0);
}
else
{
callback((HapDecodeWorkFunction)hap_decode_chunk, chunk_info, chunk_count, info);
}
/*
Check to see if we encountered any errors and report one of them
*/
for (i = 0; i < chunk_count; i++)
{
if (chunk_info[i].result != HapResult_No_Error)
{
result = chunk_info[i].result;
break;
}
}
}
free(chunk_info);
if (result != HapResult_No_Error)
{
return result;
}
}
}
else if (compressor == kHapCompressorSnappy)
{
/*
Only one section is present containing a single block of snappy-compressed texture data
*/
snappy_status snappy_result = snappy_uncompressed_length((const char *)texture_section, texture_section_length, &bytesUsed);
if (snappy_result != SNAPPY_OK)
{
return HapResult_Internal_Error;
}
if (bytesUsed > outputBufferBytes)
{
return HapResult_Buffer_Too_Small;
}
snappy_result = snappy_uncompress((const char *)texture_section, texture_section_length, (char *)outputBuffer, &bytesUsed);
if (snappy_result != SNAPPY_OK)
{
return HapResult_Internal_Error;
}
}
else if (compressor == kHapCompressorNone)
{
/*
Only one section is present containing a single block of uncompressed texture data
*/
bytesUsed = texture_section_length;
if (texture_section_length > outputBufferBytes)
{
return HapResult_Buffer_Too_Small;
}
memcpy(outputBuffer, texture_section, texture_section_length);
}
else
{
return HapResult_Bad_Frame;
}
/*
Fill out the remaining return value
*/
if (outputBufferBytesUsed != NULL)
{
*outputBufferBytesUsed = bytesUsed;
}
return HapResult_No_Error;
}
static int foldprint(Db *db, DocInfo *docinfo, void *ctx)
{
int *count = (int *) ctx;
Doc *doc = NULL;
uint64_t cas;
uint32_t expiry, flags;
couchstore_error_t docerr;
(*count)++;
if (dumpJson) {
printf("{\"seq\":%"PRIu64",\"id\":\"", docinfo->db_seq);
printjquote(&docinfo->id);
printf("\",");
} else {
if (mode == DumpBySequence) {
printf("Doc seq: %"PRIu64"\n", docinfo->db_seq);
printf(" id: ");
printsb(&docinfo->id);
} else {
printf(" Doc ID: ");
printsb(&docinfo->id);
if (docinfo->db_seq > 0) {
printf(" seq: %"PRIu64"\n", docinfo->db_seq);
}
}
}
if (docinfo->bp == 0 && docinfo->deleted == 0 && !dumpJson) {
printf(" ** This b-tree node is corrupt; raw node value follows:*\n");
printf(" raw: ");
printsbhex(&docinfo->rev_meta, 1);
return 0;
}
if (dumpJson) {
printf("\"rev\":%"PRIu64",\"content_meta\":%d,", docinfo->rev_seq,
docinfo->content_meta);
printf("\"physical_size\":%zu,", docinfo->size);
} else {
printf(" rev: %"PRIu64"\n", docinfo->rev_seq);
printf(" content_meta: %d\n", docinfo->content_meta);
printf(" size (on disk): %zu\n", docinfo->size);
}
if (docinfo->rev_meta.size >= sizeof(CouchbaseRevMeta)) {
const CouchbaseRevMeta* meta = (const CouchbaseRevMeta*)docinfo->rev_meta.buf;
cas = decode_raw64(meta->cas);
expiry = decode_raw32(meta->expiry);
flags = decode_raw32(meta->flags);
if (dumpJson) {
printf("\"cas\":\"%"PRIu64"\",\"expiry\":%"PRIu32",\"flags\":%"PRIu32",",
cas, expiry, flags);
} else {
printf(" cas: %"PRIu64", expiry: %"PRIu32", flags: %"PRIu32"\n", cas,
expiry,
flags);
}
}
if (docinfo->deleted) {
if (dumpJson) {
printf("\"deleted\":true,");
} else {
printf(" doc deleted\n");
}
}
if (!noBody) {
docerr = couchstore_open_doc_with_docinfo(db, docinfo, &doc, 0);
if (docerr != COUCHSTORE_SUCCESS) {
if (dumpJson) {
printf("\"body\":null}\n");
} else {
printf(" could not read document body: %s\n", couchstore_strerror(docerr));
}
} else if (doc && (docinfo->content_meta & COUCH_DOC_IS_COMPRESSED)) {
size_t rlen;
snappy_uncompressed_length(doc->data.buf, doc->data.size, &rlen);
char *decbuf = (char *) malloc(rlen);
size_t uncompr_len;
snappy_uncompress(doc->data.buf, doc->data.size, decbuf, &uncompr_len);
sized_buf uncompr_body;
uncompr_body.size = uncompr_len;
uncompr_body.buf = decbuf;
if (dumpJson) {
printf("\"size\":%zu,", uncompr_body.size);
printf("\"snappy\":true,\"body\":\"");
if (dumpHex) {
printsbhexraw(&uncompr_body);
} else {
printjquote(&uncompr_body);
}
printf("\"}\n");
} else {
printf(" size: %zu\n", uncompr_body.size);
printf(" data: (snappy) ");
if (dumpHex) {
printsbhexraw(&uncompr_body);
printf("\n");
} else {
printsb(&uncompr_body);
}
}
} else if (doc) {
if (dumpJson) {
printf("\"size\":%zu,", doc->data.size);
printf("\"body\":\"");
printjquote(&doc->data);
printf("\"}\n");
} else {
printf(" size: %zu\n", doc->data.size);
printf(" data: ");
if (dumpHex) {
printsbhexraw(&doc->data);
printf("\n");
} else {
printsb(&doc->data);
}
}
}
} else {
if (dumpJson) {
printf("\"body\":null}\n");
} else {
printf("\n");
}
}
couchstore_free_document(doc);
return 0;
}
int
couchdb_seekread(uint64_t key, char *data, size_t len, off_t offset,
int whence)
{
char *db_key = NULL;
lcb_size_t nkey = 0;
lcb_error_t ret;
int lock_result = -1;
lcb_get_cmd_t item;
const lcb_get_cmd_t* const get_items[] = { &item };
char *compressed_data = NULL, *uncompressed_data = NULL;
size_t compressed_len = 0, uncompressed_len = 0;
int res = 0;
memset(&item, 0, sizeof(lcb_get_cmd_t));
db_key = (char *) malloc(MAX_KEY_SIZE);
if (NULL == db_key) {
syslog(LOG_ERR, "%s: Failed to allocate memory for db_key\n",
__FUNCTION__);
return -ENOMEM;
}
sprintf(db_key,"%"PRId64"", key);
nkey = strlen(db_key);
item.v.v0.key = db_key;
item.v.v0.nkey = nkey;
/* Couchbase doesn't provide internal locking mechanism. We need
to handle the race conditions between various threads */
lock_result = pthread_rwlock_rdlock(&db_rwlock);
if (lock_result != 0) {
syslog(LOG_ERR, "%s: Unable to obtain read lock. Error = %d \n",
__FUNCTION__, errno);
return -errno;
}
ret = lcb_get(couchdb_handle, NULL, 1, get_items);
if (ret != LCB_SUCCESS) {
free(data);
data = NULL;
}
/* Block the thread till this operation completes */
lcb_wait(couchdb_handle);
lock_result = pthread_rwlock_unlock(&db_rwlock);
compressed_data = value;
compressed_len = num_bytes;
if ((res = snappy_uncompressed_length(compressed_data, compressed_len,
&uncompressed_len)) != SNAPPY_OK) {
syslog(LOG_INFO, "%s: Corrupted data\n", __FUNCTION__);
return (-res);
}
if (len > (uncompressed_len - offset)) {
syslog(LOG_ERR, "%s: partial read error\n",
__FUNCTION__);
return (-1);
}
uncompressed_data = (char *) malloc(uncompressed_len);
if (uncompressed_data == NULL) {
syslog(LOG_ERR, "%s: Unable to allocate memory for "
"uncompressed_data\n", __FUNCTION__);
return (-ENOMEM);
}
if ((res = snappy_uncompress((const char *)compressed_data,
compressed_len, uncompressed_data,
&uncompressed_len)) == SNAPPY_OK) {
memcpy((char *)data, (char *)uncompressed_data + offset, len);
free(uncompressed_data);
return (len);
}
free(uncompressed_data);
return (-res);
}
int main(int ac, char **av)
{
int opt;
int to_stdout = 0;
while ((opt = getopt(ac, av, "dcs")) != -1) {
switch (opt) {
case 'd':
mode = uncompress;
break;
case 'c':
mode = compress;
break;
case 's':
to_stdout = 1;
break;
default:
usage();
}
}
char *map;
size_t size;
if (!av[optind])
usage();
if (mode == undef && match_suffix(av[optind], ".snp"))
mode = uncompress;
else
mode = compress;
map = mapfile(av[optind], O_RDONLY, &size);
if (!map) {
fprintf(stderr, "Cannot open %s: %s\n", av[1], strerror(errno));
exit(1);
}
int err;
char *out;
size_t outlen;
if (mode == uncompress) {
if (!snappy_uncompressed_length(map, size, &outlen)) {
fprintf(stderr, "Cannot read length in %s\n",
av[optind]);
exit(1);
}
} else {
outlen = snappy_max_compressed_length(size);
}
out = xmalloc(outlen);
if (mode == compress) {
struct snappy_env env;
snappy_init_env(&env);
err = snappy_compress(&env, map, size, out, &outlen);
} else
err = snappy_uncompress(map, size, out);
if (err) {
fprintf(stderr, "Cannot process %s: %s\n", av[optind],
strerror(-err));
exit(1);
}
char *file;
int fd;
if (to_stdout) {
if(av[optind + 1])
usage();
fd = 1;
file = "<stdout>";
} else {
if (av[optind + 1] && av[optind + 2])
usage();
fd = open_output(av[optind], av[optind + 1], &file);
}
err = 0;
if (write(fd, out, outlen) != outlen) {
fprintf(stderr, "Cannot write to %s: %s\n",
file,
strerror(errno));
err = 1;
}
return err;
}
/*
* ./test -u uri -r request_size -a total_size
* uri: /tmp/testenv/testfs
* request_size: 4096bytes
* total_size: 409600bytes
*/
int main(int argc, char *argv[]){
if (log4c_init()) {
g_message("log4c_init error!");
}
GError *error = NULL;
GOptionContext *context;
context = g_option_context_new("- hlfs test -");
g_option_context_add_main_entries(context, entries, NULL);
g_option_context_set_help_enabled(context, TRUE);
g_option_group_set_error_hook(g_option_context_get_main_group(context),
(GOptionErrorFunc)error_func);
if (!g_option_context_parse(context, &argc, &argv, &error)) {
g_message("option parsing failed: %s", error->message);
exit(EXIT_FAILURE);
}
g_option_context_free(context);
g_print("TEST: uri is %s, request size is %d, total size is %d\n", uri, request_size, total_size);
char *content = (char*)g_malloc0(request_size);
HLFS_CTRL * ctrl = init_hlfs(uri);
g_assert(ctrl != NULL);
uint64_t ret = 0;
ret = hlfs_open(ctrl,1);
g_assert(ret == 0);
g_print("TEST hlfs open over \n");
g_print("test hlfs write\n");
sleep(2);
int offset = 0;
while(offset < total_size){
ret = hlfs_write(ctrl,content,request_size,offset);
g_assert(ret==request_size);
offset +=request_size;
printf("offset:%d\n",offset);
}
g_print("TEST hlfs write over \n");
g_print("test hlfs read\n");
sleep(2);
offset = 0;
while(offset < total_size){
ret = hlfs_read(ctrl,content,request_size,offset);
g_assert(ret==request_size);
offset +=request_size;
printf("offset:%d\n",offset);
}
g_print("again ------------------------\n");
offset = 0;
/******************************************************************************************************************************************/
int fdd;
int len;
int rett;
int i;
//char read_buf[409600];
char *contentt = (char*)g_malloc0(40960);
if((fdd = open("test.c", O_RDONLY )) == -1){
my_err("open", __LINE__);
} else {
g_print("Open file success\n");
}
//if(write(fd, write_buf, strlen(write_buf)) != strlen(write_buf)){
// my_err("write", __LINE__);
//}
if(lseek(fdd, 0, SEEK_END) == -1){
my_err("lseek", __LINE__);
}
if((len = lseek(fdd, 0, SEEK_CUR)) == -1){
my_err("lseek", __LINE__);
}
if((lseek(fdd, 0, SEEK_SET)) == -1){
my_err("lseek", __LINE__);
}
printf("len: %d\n", len);
if((rett = read(fdd, contentt, len)) < 0){
my_err("lseek",__LINE__);
}
strcpy(content, contentt);
//for(i = 0; i< len; i ++){
g_print("%s ", contentt);
//}
g_print("\n");
g_print("/************************************************/");
if(lseek(fdd, 10, SEEK_END) == -1){
my_err("lseek", __LINE__);
}
//close (fdd);
/****************************************************************************************************/
//FILE* srcFile = NULL;
int srcLength = lseek(fdd, 0, SEEK_CUR);
int SNAPPY_OK = 0;
char* pSrcBuffer = (char*)g_malloc0(srcLength);
read(fdd, pSrcBuffer, srcLength);
size_t cbOfCompressed = 32+ srcLength + srcLength/6;
char* pCompressedBuffer = (char*)g_malloc0(cbOfCompressed);
if (snappy_compress(pSrcBuffer, srcLength, pCompressedBuffer, &cbOfCompressed) == SNAPPY_OK)
{
free(pSrcBuffer);
pSrcBuffer = NULL;
if (snappy_validate_compressed_buffer(pCompressedBuffer, cbOfCompressed) == SNAPPY_OK)
{
size_t cbDecompress = 0;
snappy_uncompressed_length(pCompressedBuffer, cbOfCompressed, &cbDecompress);
assert(cbDecompress == srcLength);
char* pDecompressedBuffer = (char*)g_malloc0(cbDecompress);
snappy_uncompress(pCompressedBuffer, cbOfCompressed, pDecompressedBuffer, (size_t*)&cbDecompress);
int file;
file = open("test1.txt", O_CREAT | O_RDWR );
//_wfopen_s(&file, _T("123.pdf"), _T("ab"));
write(file, pDecompressedBuffer, cbDecompress);
close(file);
free(pDecompressedBuffer);
pDecompressedBuffer = NULL;
}
}
close (fdd);
/******************************************************************************************************************************************/
// while(offset < total_size){
// ret = hlfs_write(ctrl,content,request_size,offset);
// g_assert(ret==request_size);
// offset +=request_size;
// printf("offset:%d\n",offset);
// }
// g_print("TEST hlfs write over \n");
// g_print("test hlfs read\n");
// sleep(2);
// offset = 0;
while(offset < len+1){
ret = hlfs_read(ctrl,content,len,offset);
g_assert(ret==len);
offset +=len;
printf("offset:%d\n",offset);
}
g_free(content);
g_free(contentt);
ret = hlfs_close(ctrl);
deinit_hlfs(ctrl);
g_print("TEST hlfs test over \n");
return 0;
}
primitiveRawUncompressedLength(void)
{
const char*compressed;
size_t compressedLength;
sqInt compressedObj;
sqInt num;
sqInt num1;
size_t offset;
char* ptr;
size_t result;
snappy_status status;
if (!((interpreterProxy->methodArgumentCount()) == 3)) {
interpreterProxy->primitiveFail(); return;
}
compressedObj = interpreterProxy->stackValue(2);
/* begin charPointerFor: */
if (!(interpreterProxy->isBytes(compressedObj))) {
compressed = ((char*) null);
goto l1;
}
ptr = ((char*) (interpreterProxy->firstIndexableField(compressedObj)));
compressed = ((char*) ptr);
l1: /* end charPointerFor: */;
if (!(compressed)) {
interpreterProxy->primitiveFail(); return;
}
/* begin stackPositiveIntegerValue: */
num = interpreterProxy->stackValue(1);
if ((interpreterProxy->isIntegerValue(num))
&& (num < 0)) {
offset = ((sqInt) null);
goto l2;
}
offset = ((sqInt) (interpreterProxy->positive32BitValueOf(num)));
l2: /* end stackPositiveIntegerValue: */;
/* begin stackPositiveIntegerValue: */
num1 = interpreterProxy->stackValue(0);
if ((interpreterProxy->isIntegerValue(num1))
&& (num1 < 0)) {
compressedLength = ((sqInt) null);
goto l3;
}
compressedLength = ((sqInt) (interpreterProxy->positive32BitValueOf(num1)));
l3: /* end stackPositiveIntegerValue: */;
status = snappy_uncompressed_length(compressed + offset, compressedLength, &result);
if (status == SnOK) {
/* begin returnIntegerFor: */
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
if (result <= 1073741823) {
interpreterProxy->pushInteger(result);
}
else {
interpreterProxy->push(interpreterProxy->positive32BitIntegerFor(result));
}
return;
}
/* begin returnErrorInfoFor: */
interpreterProxy->pop((interpreterProxy->methodArgumentCount()) + 1);
interpreterProxy->pushInteger(-status);
}