Exemplo n.º 1
1
void UncompressInc(
	std::vector<unsigned char> &outBuf,
	const std::vector<unsigned char> &inBuf)
{
	CLzmaDec dec;

	UInt64 unpackSize = 0;
	for (int i = 0; i < 8; i++)
		unpackSize += (UInt64)inBuf[5 + i] << (i * 8);

	LzmaDec_Construct(&dec);
	SRes res = LzmaDec_Allocate(&dec, &inBuf[0], LZMA_PROPS_SIZE, &SzAllocForLzma);
	assert(res == SZ_OK);

	LzmaDec_Init(&dec);

	//printf("uint64 resLen : %" PRIu64 "\n", unpackSize);		//print uint64

	outBuf.resize(unpackSize);
	unsigned outPos = 0, inPos = LZMA_PROPS_SIZE;
	ELzmaStatus status;
	const unsigned BUF_SIZE = 10240;
	while (outPos < outBuf.size())
	{
		unsigned destLen = min(BUF_SIZE, outBuf.size() - outPos);
		unsigned srcLen = min(BUF_SIZE, inBuf.size() - 8 - inPos);

		res = LzmaDec_DecodeToBuf(&dec,
			&outBuf[outPos], &destLen,
			&inBuf[inPos+8], &srcLen,
			(outPos + destLen == outBuf.size())
			? LZMA_FINISH_END : LZMA_FINISH_ANY, &status);
		assert(res == SZ_OK);
		inPos += srcLen;
		outPos += destLen;
		if (status == LZMA_STATUS_FINISHED_WITH_MARK)
			break;
	}

	LzmaDec_Free(&dec, &g_Alloc);
	outBuf.resize(outPos);

	FILE *fout = fopen("data33.dc", "wb+");
	fwrite(&outBuf[0], 1, outBuf.size(), fout);
	fclose(fout);

}
Exemplo n.º 2
0
static SRes Decode(ISeqOutStream *outStream, ISeqInStream *inStream, Gate2<int64, int64> progress)
{
	UInt64 unpackSize;
	int i;
	SRes res = 0;

	CLzmaDec state;

	/* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
	unsigned char header[LZMA_PROPS_SIZE + 8];

	/* Read and parse header */
	IUppInStream *is = (IUppInStream *)inStream;
	if(is->in.Get(header, sizeof(header)) != sizeof(header))
		return SZ_ERROR_READ;

	unpackSize = 0;
	for(i = 0; i < 8; i++)
		unpackSize += (UInt64)header[LZMA_PROPS_SIZE + i] << (i * 8);

	LzmaDec_Construct(&state);
	RINOK(LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc));
	res = Decode2(&state, outStream, inStream, unpackSize, progress);
	LzmaDec_Free(&state, &g_Alloc);
	return res;
}
Exemplo n.º 3
0
static SRes Decode(ISeqOutStream *outStream, ISeqInStream *inStream)
{
  UInt64 unpackSize;
  int i;
  SRes res = 0;

  CLzmaDec state;

  /* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
  unsigned char header[LZMA_PROPS_SIZE + 8];

  /* Read and parse header */

  RINOK(SeqInStream_Read(inStream, header, sizeof(header)));

  unpackSize = 0;
  for (i = 0; i < 8; i++)
    unpackSize += (UInt64)header[LZMA_PROPS_SIZE + i] << (i * 8);

  LzmaDec_Construct(&state);
  RINOK(LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc));
  res = Decode2(&state, outStream, inStream, unpackSize);
  LzmaDec_Free(&state, &g_Alloc);
  return res;
}
Exemplo n.º 4
0
FileReaderLZMA::FileReaderLZMA (FileReader &file, size_t uncompressed_size, bool zip)
: File(file), SawEOF(false)
{
	BYTE header[4 + LZMA_PROPS_SIZE];
	int err;

	assert(zip == true);

	Size = uncompressed_size;
	OutProcessed = 0;

	// Read zip LZMA properties header
	if (File.Read(header, sizeof(header)) < (long)sizeof(header))
	{
		I_Error("FileReaderLZMA: File too shart\n");
	}
	if (header[2] + header[3] * 256 != LZMA_PROPS_SIZE)
	{
		I_Error("FileReaderLZMA: LZMA props size is %d (expected %d)\n",
			header[2] + header[3] * 256, LZMA_PROPS_SIZE);
	}

	FillBuffer();

	Streamp = new StreamPointer;
	LzmaDec_Construct(&Streamp->Stream);
	err = LzmaDec_Allocate(&Streamp->Stream, header + 4, LZMA_PROPS_SIZE, &g_Alloc);

	if (err != SZ_OK)
	{
		I_Error("FileReaderLZMA: LzmaDec_Allocate failed: %d\n", err);
	}

	LzmaDec_Init(&Streamp->Stream);
}
Exemplo n.º 5
0
STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
{
  RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_Alloc)));

  if (_inBuf == 0)
  {
    _inBuf = (Byte *)MyAlloc(kInBufSize);
    if (_inBuf == 0)
      return E_OUTOFMEMORY;
  }

  return S_OK;
}
Exemplo n.º 6
0
        inline TImpl(TInputStream* slave)
            : Slave_(slave)
            , InPos_(0)
            , InSize_(0)
        {
            LzmaDec_Construct(&H_);

            Byte buf[LZMA_PROPS_SIZE];

            Slave_->Load(buf, sizeof(buf));

            Check(LzmaDec_Allocate(&H_, buf, sizeof(buf), Alloc()));
            LzmaDec_Init(&H_);
        }
Exemplo n.º 7
0
SRes IS_LzmaDec_Init(CLzmaDec *state, size_t stateSize, const Byte *props,
	unsigned propsSize, ISzAlloc *alloc)
{
	if (stateSize != sizeof(*state)) {
		return SZ_ERROR_PARAM;
	}

	// Not needed; just sets fields to 0, which will leak memory if Init was already called previously
	//LzmaDec_Construct(state);

	RINOK(LzmaDec_Allocate(state, props, propsSize, alloc));
	LzmaDec_Init(state);

	return SZ_OK;
}
Exemplo n.º 8
0
Arquivo: lzma.c Projeto: 99plus2/ads
struct lzma_dec_state *lzma_dec_init(void* props) {
  struct lzma_dec_state *state = malloc(sizeof(struct lzma_dec_state));
  memset(state, 0, sizeof(*state));

  if (!state) {
    return NULL;
  }
  
  state->alloc.Alloc = &alloc_impl;
  state->alloc.Free = &free_impl;

  if (LzmaDec_Allocate(&state->decoder, props, 5, &state->alloc)) {
    free (state);
    return NULL;
  }

  LzmaDec_Init(&state->decoder);

  return state;
}
Exemplo n.º 9
0
int cli_LzmaInit(struct CLI_LZMA *L, uint64_t size_override) {
    int fail;

    if(!L->init) {
	L->p_cnt = LZMA_PROPS_SIZE;
	if(size_override)
	    L->usize = size_override;
	else
	    L->s_cnt = 8;
	L->init = 1;
    } else if(size_override)
	cli_warnmsg("cli_LzmaInit: ignoring late size override\n");

    if(L->freeme) return LZMA_RESULT_OK;

    while(L->p_cnt) {
	L->header[LZMA_PROPS_SIZE - L->p_cnt] = lzma_getbyte(L, &fail);
	if(fail) return LZMA_RESULT_OK;
	L->p_cnt--;
    }

    while(L->s_cnt) {
	uint64_t c = (uint64_t)lzma_getbyte(L, &fail);
	if(fail) return LZMA_RESULT_OK;
	L->usize = c << (8 * (8 - L->s_cnt));
	L->s_cnt--;
    }

    LzmaDec_Construct(&L->state);
    if(LzmaDec_Allocate(&L->state, L->header, LZMA_PROPS_SIZE, &g_Alloc) != SZ_OK)
	return LZMA_RESULT_DATA_ERROR;
    LzmaDec_Init(&L->state);

    L->freeme = 1;
    return LZMA_RESULT_OK;
}
Exemplo n.º 10
0
STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *prop, UInt32 size)
{
  RINOK(SResToHRESULT(LzmaDec_Allocate(&_state, prop, size, &g_Alloc)));
  _propsWereSet = true;
  return CreateInputBuffer();
}
Exemplo n.º 11
0
int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hFileIn  = ::CreateFile(_T("C:\\Users\\Christoph\\Desktop\\S.csv.lzma"), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	HANDLE hFileOut = ::CreateFile(_T("C:\\Users\\Christoph\\Desktop\\S.csv.decd"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

	BYTE header[LZMA_PROPS_SIZE + 8];
	DWORD dwBytesRead = 0;
	DWORD dwBytesWritten = 0;
	::ReadFile(hFileIn, header, sizeof(header), &dwBytesRead, NULL);

	ELzmaStatus status;
	CLzmaDec state;
	LzmaDec_Construct(&state);
	LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc);
	LzmaDec_Init(&state);

	__int64 nSize = *reinterpret_cast<__int64*>(header + LZMA_PROPS_SIZE);
	_tprintf(_T("Extracted size: %d\n"), nSize);

	BYTE *pDataIn  = new BYTE[BUFFER_SIZE];
	BYTE *pDataOut = new BYTE[BUFFER_SIZE];

	size_t nTotalSize = (size_t)nSize;
	size_t nInSize = BUFFER_SIZE, nInPos = 0;
	size_t nOutSize = BUFFER_SIZE;

	while (nTotalSize)
	{
		if (!::ReadFile(hFileIn, pDataIn, BUFFER_SIZE, &dwBytesRead, NULL)) break;
		if (dwBytesRead == 0) break;
		nInSize = dwBytesRead;
		nInPos = 0;
		_tprintf(_T("."));
		
		while (nInPos < nInSize)
		{
			size_t nInProcessed  = nInSize - nInPos;
			size_t nOutProcessed = BUFFER_SIZE;
			LzmaDec_DecodeToBuf(&state, pDataOut, &nOutProcessed,
				                        pDataIn + nInPos, &nInProcessed,
										(nOutProcessed > nTotalSize)? LZMA_FINISH_END : LZMA_FINISH_ANY,
										&status);
			::WriteFile(hFileOut, pDataOut, nOutProcessed, &dwBytesRead, NULL);
			nInPos += nInProcessed;
			nTotalSize -= nOutProcessed;

			if (nInProcessed == 0 && nOutProcessed == 0)
			{
				nInPos = nInSize = 0;
				nTotalSize = 0;
			}
		}
	}

	delete[] pDataOut;
	delete[] pDataIn;

	LzmaDec_Free(&state, &g_Alloc);

	::CloseHandle(hFileOut);
	::CloseHandle(hFileIn);

#ifdef _DEBUG
	_tsystem(_T("pause"));
#endif
	return 0;
}
Exemplo n.º 12
0
static PyObject *
pylzma_decomp_decompress(CDecompressionObject *self, PyObject *args)
{
    PyObject *result=NULL;
    unsigned char *data;
    Byte *next_in, *next_out;
    int length, res, bufsize=BLOCK_SIZE;
    SizeT avail_in;
    SizeT inProcessed, outProcessed;
    ELzmaStatus status;
    
    if (!PyArg_ParseTuple(args, "s#|i", &data, &length, &bufsize)){
        return NULL;
    }

    if (bufsize <= 0) {
        PyErr_SetString(PyExc_ValueError, "bufsize must be greater than zero");
        return NULL;
    }
    
    if (self->unconsumed_length > 0) {
        self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length + length);
        next_in = (unsigned char *) self->unconsumed_tail;
        memcpy(next_in + self->unconsumed_length, data, length);
    } else {
        next_in = data;
    }
    
    if (self->need_properties) {
        if ((self->unconsumed_length + length) < LZMA_PROPS_SIZE) {
            // we need enough bytes to read the properties
            self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length + length);
            if (self->unconsumed_tail == NULL) {
                PyErr_NoMemory();
                return NULL;
            }
            memcpy(self->unconsumed_tail + self->unconsumed_length, data, length);
            self->unconsumed_length += length;
            return PyString_FromString("");
        }

        self->unconsumed_length += length;
        res = LzmaDec_Allocate(&self->state, next_in, LZMA_PROPS_SIZE, &allocator);
        if (res != SZ_OK) {
            PyErr_SetString(PyExc_TypeError, "Incorrect stream properties");
            return NULL;
        }
        
        next_in += LZMA_PROPS_SIZE;
        self->unconsumed_length -= LZMA_PROPS_SIZE;
        if (self->unconsumed_length > 0) {
            if (self->unconsumed_tail == NULL) {
                // No remaining data yet
                self->unconsumed_tail = (unsigned char *) malloc(self->unconsumed_length);
                if (self->unconsumed_tail == NULL) {
                    PyErr_NoMemory();
                    return NULL;
                }
                memcpy(self->unconsumed_tail, next_in, self->unconsumed_length);
                next_in = self->unconsumed_tail;
            } else {
                // Skip properties in remaining data
                memmove(self->unconsumed_tail, self->unconsumed_tail+LZMA_PROPS_SIZE, self->unconsumed_length);
                self->unconsumed_tail = next_in = (unsigned char *) realloc(self->unconsumed_tail, self->unconsumed_length);
                if (self->unconsumed_tail == NULL) {
                    PyErr_NoMemory();
                    return NULL;
                }
            }
        } else {
            FREE_AND_NULL(self->unconsumed_tail);
        }
        
        self->need_properties = 0;
        LzmaDec_Init(&self->state);
    } else {
        self->unconsumed_length += length;
    }
    avail_in = self->unconsumed_length;
    if (avail_in == 0) {
        // no more bytes to decompress
        return PyString_FromString("");
    }
    
    result = PyString_FromStringAndSize(NULL, bufsize);
    if (result == NULL) {
        PyErr_NoMemory();
        goto exit;
    }
    
    next_out = (unsigned char *) PyString_AS_STRING(result);
    Py_BEGIN_ALLOW_THREADS
    // Decompress until EOS marker is reached
    inProcessed = avail_in;
    outProcessed = bufsize;
    res = LzmaDec_DecodeToBuf(&self->state, next_out, &outProcessed,
                    next_in, &inProcessed, LZMA_FINISH_ANY, &status);
    Py_END_ALLOW_THREADS
    self->total_out += outProcessed;
    next_in += inProcessed;
    avail_in -= inProcessed;
    
    if (res != SZ_OK) {
        DEC_AND_NULL(result);
        PyErr_SetString(PyExc_ValueError, "data error during decompression");
        goto exit;
    }

    // Not all of the compressed data could be accomodated in the output buffer
    // of specified size. Return the unconsumed tail in an attribute.
    if (avail_in > 0) {
        if (self->unconsumed_tail == NULL) {
            // data are in "data"
            self->unconsumed_tail = (unsigned char *) malloc(avail_in);
            if (self->unconsumed_tail == NULL) {
                Py_DECREF(result);
                PyErr_NoMemory();
                goto exit;
            }
            memcpy(self->unconsumed_tail, next_in, avail_in);
        } else {
            memmove(self->unconsumed_tail, next_in, avail_in);
            self->unconsumed_tail = (unsigned char *) realloc(self->unconsumed_tail, avail_in);
        }
    } else {
        FREE_AND_NULL(self->unconsumed_tail);
    }
    
    self->unconsumed_length = avail_in;
    _PyString_Resize(&result, outProcessed);
    
exit:
    return result;
}
Exemplo n.º 13
0
PakEntry Pak::read(uint32_t tag) const
{
  int entryIndex = findEntry(tag);
  if(entryIndex < 0)
  {
    return PakEntry(NULL, 0, false);
  }

  const Header *header = reinterpret_cast<const Header*>(m_pakData);
  const Entry *entry = reinterpret_cast<const Entry*>(header + 1) + entryIndex;

  size_t entrySize = (entry+1)->offset - entry->offset;
  if(entry->offset>m_pakDataSize || entrySize>=4*1024*1024 || entry->offset+entrySize>m_pakDataSize)
  {
    ERROR("Pak::findEntry: invalid entry offset/size (tag=0x%08x index=%u offset=%u size=%u)", tag, entryIndex, entry->offset, entrySize);
    return PakEntry(NULL, 0, false);
  }

  const uint8_t *entryData = cast<uint8_t>(m_pakData, entry->offset);
  const LzmaHeader *lzmaHeader = cast<LzmaHeader>(entryData, 0);

  if(memcmp(lzmaHeader->magic, "lzma", 4) != 0)
  {
    DEBUG("Pak::findEntry: found uncompressed 0x%08x at %u size %zu", tag, entry->offset, entrySize);
    return PakEntry(entryData, entrySize, false);
  }

  if(lzmaHeader->decompressedSize<entrySize/2 || lzmaHeader->decompressedSize>=8*1024*1024)
  {
    ERROR("Pak::findEntry: invalid uncompressed size (tag=0x%08x size=%u decompressedsize=%u)", tag, entrySize, lzmaHeader->decompressedSize);
    return PakEntry(NULL, 0, false);
  }

  CLzmaDec dec;
  LzmaDec_Construct(&dec);
  LzmaDec_Init(&dec);
  SRes res = LzmaDec_Allocate(&dec, lzmaHeader->props, LZMA_PROPS_SIZE, &lzmaAllocFuncs);
  if(res != SZ_OK)
  {
    ERROR("Pak::findEntry: LzmaDec_Allocate failed: %d (tag=0x%08x)", res, tag);
    return PakEntry(NULL, 0, false);
  }

  void *decdata = malloc(lzmaHeader->decompressedSize);
  if(decdata == NULL)
  {
    ERROR("Pak::findEntry: LzmaDec_Allocate failed to allocate %u bytes", lzmaHeader->decompressedSize);
    LzmaDec_Free(&dec, &lzmaAllocFuncs);
    return PakEntry(NULL, 0, false);
  }

  size_t destSize = lzmaHeader->decompressedSize;
  size_t srcSize = entrySize - sizeof(lzmaHeader);
  ELzmaStatus status;
  res = LzmaDec_DecodeToBuf(&dec,
      (Byte*)decdata, &destSize,
      lzmaHeader->data, &srcSize,
      LZMA_FINISH_END, &status);

  if(res != SZ_OK)
  {
    ERROR("Pak::findEntry: LzmaDec_DecodeToBuf failed: %d (tag=0x%08x)", res, tag);
    LzmaDec_Free(&dec, &lzmaAllocFuncs);
    free(decdata);
    return PakEntry(NULL, 0, false);
  }

  if(!(status==LZMA_STATUS_FINISHED_WITH_MARK || (status==LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK && destSize!=lzmaHeader->decompressedSize)))
  {
    ERROR("Pak::findEntry: LzmaDec_DecodeToBuf ended with unexpected status: %d (tag=0x%08x)", status, tag);
    LzmaDec_Free(&dec, &lzmaAllocFuncs);
    free(decdata);
    return PakEntry(NULL, 0, false);
  }

  if(destSize != lzmaHeader->decompressedSize)
  {
    ERROR("Pak::findEntry: LzmaDec_DecodeToBuf failed to decompress whole buffer: %zu!=%u (tag=0x%08x)", destSize, lzmaHeader->decompressedSize, tag);
    LzmaDec_Free(&dec, &lzmaAllocFuncs);
    free(decdata);
    return PakEntry(NULL, 0, false);
  }

  LzmaDec_Free(&dec, &lzmaAllocFuncs);
  return PakEntry(decdata, lzmaHeader->decompressedSize, true);
}
Exemplo n.º 14
0
static int Decode(FILE *inFile, FILE *outFile, char *rs)
{
  UInt64 unpackSize;
  int thereIsSize; /* = 1, if there is uncompressed size in headers */
  int i;
  int res = 0;
  
  CLzmaDec state;

  /* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
  unsigned char header[LZMA_PROPS_SIZE + 8];

  /* Read and parse header */

  if (!MyReadFileAndCheck(inFile, header, sizeof(header)))
    return PrintError(rs, kCantReadMessage);

  unpackSize = 0;
  thereIsSize = 0;
  for (i = 0; i < 8; i++)
  {
    unsigned char b = header[LZMA_PROPS_SIZE + i];
    if (b != 0xFF)
      thereIsSize = 1;
    unpackSize += (UInt64)b << (i * 8);
  }

  LzmaDec_Construct(&state);
  res = LzmaDec_Allocate(&state, header, LZMA_PROPS_SIZE, &g_Alloc);
  if (res != SZ_OK)
    return res;
  {
    Byte inBuf[IN_BUF_SIZE];
    Byte outBuf[OUT_BUF_SIZE];
    size_t inPos = 0, inSize = 0, outPos = 0;
    LzmaDec_Init(&state);
    for (;;)
    {
      if (inPos == inSize)
      {
        inSize = MyReadFile(inFile, inBuf, IN_BUF_SIZE);
        inPos = 0;
      }
      {
        SizeT inProcessed = inSize - inPos;
        SizeT outProcessed = OUT_BUF_SIZE - outPos;
        ELzmaFinishMode finishMode = LZMA_FINISH_ANY;
        ELzmaStatus status;
        if (thereIsSize && outProcessed > unpackSize)
        {
          outProcessed = (SizeT)unpackSize;
          finishMode = LZMA_FINISH_END;
        }

        res = LzmaDec_DecodeToBuf(&state, outBuf + outPos, &outProcessed,
            inBuf + inPos, &inProcessed, finishMode, &status);
        inPos += (UInt32)inProcessed;
        outPos += outProcessed;
        unpackSize -= outProcessed;

        if (outFile != 0)
          MyWriteFile(outFile, outBuf, outPos);
        outPos = 0;

        if (res != SZ_OK || thereIsSize && unpackSize == 0)
          break;

        if (inProcessed == 0 && outProcessed == 0)
        {
          if (thereIsSize || status != LZMA_STATUS_FINISHED_WITH_MARK)
            res = SZ_ERROR_DATA;
          break;
        }
      }
    }
  }

  LzmaDec_Free(&state, &g_Alloc);
  return res;
}
Exemplo n.º 15
0
static int lzmafs_fileop_open(void **ref,void *fsctx_arg,char *filename,int mode)
{
    lzmafs_fsctx_t *fsctx;
    lzmafs_file_t *file;
    int err = 0, i;
	/* header: 5 bytes of LZMA properties and 8 bytes of uncompressed size */
	unsigned char header[LZMA_PROPS_SIZE + 8];

	if (mode != FILE_MODE_READ) 
		return CFE_ERR_UNSUPPORTED;

	fsctx = (lzmafs_fsctx_t *) fsctx_arg;

	file = KMALLOC(sizeof(lzmafs_file_t), 0);
	if (!file) {
		return CFE_ERR_NOMEM;
	}

	file->lzmafs_fileoffset = 0;
	file->lzmafs_fsctx = fsctx;
	file->lzmafs_inlen = 0;
	file->lzmafs_eofseen = 0;
	file->lzmafs_state = KMALLOC(sizeof(CLzmaDec), 0);
	if (!file->lzmafs_state)
		goto error2;

	file->lzmafs_outlen = 0;
	
    /* Open the raw file system */
    err = BDOPEN(fsctx->lzmafsctx_subops, &(file->lzmafs_subfile),
		 fsctx->lzmafsctx_subfsctx, filename);
    if (err != 0)
		goto error2;

	err = BDREAD(file->lzmafs_fsctx->lzmafsctx_subops,
				 file->lzmafs_subfile,
				 header,		   
				 sizeof(header));
	if (err < 0)
		goto error;

	file->lzmafs_unpackSize = 0;
	/* uncompressed size */
	for (i = 0; i < 8; i++)
		file->lzmafs_unpackSize += header[LZMA_PROPS_SIZE + i] << (i * 8);

	LzmaDec_Construct(file->lzmafs_state);
	RINOK(LzmaDec_Allocate(file->lzmafs_state, header, LZMA_PROPS_SIZE, &g_Alloc));

	file->lzmafs_inbuf = KMALLOC(LZMAFS_INBUFSIZE, 0);
	file->lzmafs_outbuf = KMALLOC(LZMAFS_OUTBUFSIZE, 0);
	if (!file->lzmafs_inbuf || !file->lzmafs_outbuf) {
		err = CFE_ERR_NOMEM;
		goto error;
	}

	file->lzmafs_outptr = file->lzmafs_outbuf;
	LzmaDec_Init(file->lzmafs_state);	
	fsctx->lzmafsctx_refcnt++;
    *ref = file;
    return 0;

error:
    BDCLOSE(file->lzmafs_fsctx->lzmafsctx_subops, file->lzmafs_subfile);
error2:
    if (file->lzmafs_inbuf) 
		KFREE(file->lzmafs_inbuf);
    if (file->lzmafs_outbuf) 
		KFREE(file->lzmafs_outbuf);
	if (file->lzmafs_state) {
		LzmaDec_Free(file->lzmafs_state, &g_Alloc);
		KFREE(file->lzmafs_state);
	}
	if (file)
		KFREE(file);
    return err;
}
Exemplo n.º 16
0
SRes Lzma2Dec_Allocate(CLzma2Dec *p, Byte prop, ISzAllocPtr alloc)
{
  Byte props[LZMA_PROPS_SIZE];
  RINOK(Lzma2Dec_GetOldProps(prop, props));
  return LzmaDec_Allocate(&p->decoder, props, LZMA_PROPS_SIZE, alloc);
}
Exemplo n.º 17
0
int
BCMINITFN(_nvram_read)(void *buf, int idx)
{
	uint32 *src, *dst;
	uint i;

	if (!nvram_header)
		return -19; /* -ENODEV */

#if defined(_CFE_) && defined(BCM_DEVINFO)
	if ((!devinfo_nvram_header) && (idx == 1)) {
		return -19; /* -ENODEV */
	}

	src = idx == 0 ? (uint32 *) nvram_header : (uint32 *) devinfo_nvram_nvh;
#else
	src = (uint32 *) nvram_header;
#endif /* _CFE_ && BCM_DEVINFO */

	dst = (uint32 *) buf;

	for (i = 0; i < sizeof(struct nvram_header); i += 4)
		*dst++ = *src++;

	/* Since we know what the first 3 bytes of the lzma properties
	 * should be based on what we used to compress, check them
	 * to see if we need to decompress (uncompressed this would show up a
	 * a single [ and then the end of nvram marker so its invalid in an
	 * uncompressed nvram block
	 */
	if ((((unsigned char *)src)[0] == 0x5d) &&
	    (((unsigned char *)src)[1] == 0) &&
	    (((unsigned char *)src)[2] == 0)) {
		unsigned int dstlen = nvram_header->len;
		unsigned int srclen = MAX_NVRAM_SPACE-LZMA_PROPS_SIZE-NVRAM_HEADER_SIZE;
		unsigned char *cp = (unsigned char *)src;
		CLzmaDec state;
		SRes res;
		ELzmaStatus status;

		LzmaDec_Construct(&state);
		res = LzmaDec_Allocate(&state, cp, LZMA_PROPS_SIZE, &g_Alloc);
		if (res != SZ_OK) {
			printf("Error Initializing LZMA Library\n");
			return -19;
		}
		LzmaDec_Init(&state);
		res = LzmaDec_DecodeToBuf(&state,
		                          (unsigned char *)dst, &dstlen,
		                          &cp[LZMA_PROPS_SIZE], &srclen,
		                          LZMA_FINISH_ANY,
		                          &status);

		LzmaDec_Free(&state, &g_Alloc);
		if (res != SZ_OK) {
			printf("Error Decompressing eNVRAM\n");
			return -19;
		}
	} else {
		for (; i < nvram_header->len && i < MAX_NVRAM_SPACE; i += 4)
			*dst++ = ltoh32(*src++);
	}
	return 0;
}
Exemplo n.º 18
0
int
elzma_decompress_run(elzma_decompress_handle hand,
                     elzma_read_callback inputStream, void * inputContext,
                     elzma_write_callback outputStream, void * outputContext,
                     elzma_file_format format)
{
    unsigned long long int totalRead = 0; /* total amount read from stream */
    unsigned int crc32 = CRC_INIT_VAL; /* running crc32 (lzip case) */     
    CLzmaDec dec;
    unsigned int errorCode = ELZMA_E_OK;
    struct elzma_format_handler formatHandler;
    struct elzma_file_header h;
    struct elzma_file_footer f;

    /* switch between supported formats */ 
    if (format == ELZMA_lzma) {
        initializeLZMAFormatHandler(&formatHandler);
    } else if (format == ELZMA_lzip) {
        CrcGenerateTable();        
        initializeLZIPFormatHandler(&formatHandler);
    } else {
        return ELZMA_E_BAD_PARAMS;        
    }

    /* initialize footer */
    f.crc32 = 0;
    f.uncompressedSize = 0;
    
    /* initialize decoder memory */
    memset((void *) &dec, 0, sizeof(dec));
    LzmaDec_Init(&dec);

    /* decode the header. */
    {
        unsigned char * hdr = 
            hand->allocStruct.Alloc(&(hand->allocStruct),
                                    formatHandler.header_size);

        size_t sz = formatHandler.header_size;

        formatHandler.init_header(&h);        

        if (inputStream(inputContext, hdr, &sz) != 0 ||
            sz != formatHandler.header_size)
        {
            hand->allocStruct.Free(&(hand->allocStruct), hdr);
            return ELZMA_E_INPUT_ERROR;
        }

        if (0 != formatHandler.parse_header(hdr, &h)) {
            hand->allocStruct.Free(&(hand->allocStruct), hdr);
            return ELZMA_E_CORRUPT_HEADER;
        }

        /* the LzmaDec_Allocate call requires 5 bytes which have
         * compression properties encoded in them.  In the case of
         * lzip, the header format does not already contain what
         * LzmaDec_Allocate expects, so we must craft it, silly */
        {
            unsigned char propsBuf[13];
            const unsigned char * propsPtr = hdr;            

            if (format == ELZMA_lzip) {
                struct elzma_format_handler lzmaHand;
                initializeLZMAFormatHandler(&lzmaHand);
                lzmaHand.serialize_header(propsBuf, &h);
                propsPtr = propsBuf;
            }

            /* now we're ready to allocate the decoder */
            LzmaDec_Allocate(&dec, propsPtr, 5,
                             (ISzAlloc *) &(hand->allocStruct));
        }
        
        hand->allocStruct.Free(&(hand->allocStruct), hdr);
    }

    /* perform the decoding */
    for (;;)
    {
        size_t dstLen = ELZMA_DECOMPRESS_OUTPUT_BUFSIZE;
        size_t srcLen = ELZMA_DECOMPRESS_INPUT_BUFSIZE;
        size_t amt = 0;
        size_t bufOff = 0;
		ELzmaStatus stat;

        if (0 != inputStream(inputContext, hand->inbuf, &srcLen))
        {
            errorCode = ELZMA_E_INPUT_ERROR;
            goto decompressEnd;                    
        }

        /* handle the case where the input prematurely finishes */
        if (srcLen == 0) {
            errorCode = ELZMA_E_INSUFFICIENT_INPUT;
            goto decompressEnd;
        }
        
        amt = srcLen;

        /* handle the case where a single read buffer of compressed bytes
         * will translate into multiple buffers of uncompressed bytes,
         * with this inner loop */
        stat = LZMA_STATUS_NOT_SPECIFIED;

        while (bufOff < srcLen) {
            SRes r = LzmaDec_DecodeToBuf(&dec, (Byte *) hand->outbuf, &dstLen,
                                         ((Byte *) hand->inbuf + bufOff), &amt,
                                         LZMA_FINISH_ANY, &stat);

            /* XXX deal with result code more granularly*/
            if (r != SZ_OK) {
                errorCode = ELZMA_E_DECOMPRESS_ERROR;
                goto decompressEnd;
            }
            
            /* write what we've read */
            {
                size_t wt;
                
                /* if decoding lzip, update our crc32 value */
                if (format == ELZMA_lzip && dstLen > 0) {
                    crc32 = CrcUpdate(crc32, hand->outbuf, dstLen);

                }
                totalRead += dstLen;
                
                wt = outputStream(outputContext, hand->outbuf, dstLen);
                if (wt != dstLen) {
                    errorCode = ELZMA_E_OUTPUT_ERROR;
                    goto decompressEnd;                    
                }
            }
            
            /* do we have more data on the input buffer? */
            bufOff += amt;
            assert( bufOff <= srcLen );
            if (bufOff >= srcLen) break;
            amt = srcLen - bufOff;

            /* with lzip, we will have the footer left on the buffer! */
            if (stat == LZMA_STATUS_FINISHED_WITH_MARK) {
                break;
            }
        }

        /* now check status */
        if (stat == LZMA_STATUS_FINISHED_WITH_MARK) {
            /* read a footer if one is expected and
             * present */ 
            if (formatHandler.footer_size > 0 &&
                amt >= formatHandler.footer_size &&
                formatHandler.parse_footer != NULL)
            {
                formatHandler.parse_footer(
                    (unsigned char *) hand->inbuf + bufOff, &f);
            }

            break;
        }
        /* for LZMA utils,  we don't always have a finished mark */
        if (!h.isStreamed && totalRead >= h.uncompressedSize) {
            break;
        }
    }

    /* finish the calculated crc32 */
    crc32 ^= 0xFFFFFFFF;

    /* if we have a footer, check that the calculated crc32 matches
     * the encoded crc32, and that the sizes match */
    if (formatHandler.footer_size)
    {
        if (f.crc32 != crc32) {
            errorCode = ELZMA_E_CRC32_MISMATCH;
        } else if (f.uncompressedSize != totalRead) {
            errorCode = ELZMA_E_SIZE_MISMATCH;            
        }
    }
    else if (!h.isStreamed)
    {
        /* if the format does not support a footer and has an uncompressed
         * size in the header, let's compare that with how much we actually
         * read */
        if (h.uncompressedSize != totalRead) {
            errorCode = ELZMA_E_SIZE_MISMATCH;
        }
    }

  decompressEnd:
    LzmaDec_Free(&dec, (ISzAlloc *) &(hand->allocStruct));

    return errorCode;
}