1/* XzDec.c -- Xz Decode
22014-12-30 : Igor Pavlov : Public domain */
3
4#include "Precomp.h"
5
6/* #define XZ_DUMP */
7
8#ifdef XZ_DUMP
9#include <stdio.h>
10#endif
11
12#include <stdlib.h>
13#include <string.h>
14
15#include "7zCrc.h"
16#include "Alloc.h"
17#include "Bra.h"
18#include "CpuArch.h"
19#include "Delta.h"
20#include "Lzma2Dec.h"
21
22#ifdef USE_SUBBLOCK
23#include "Bcj3Dec.c"
24#include "SbDec.c"
25#endif
26
27#include "Xz.h"
28
29#define XZ_CHECK_SIZE_MAX 64
30
31#define CODER_BUF_SIZE (1 << 17)
32
33unsigned Xz_ReadVarInt(const Byte *p, size_t maxSize, UInt64 *value)
34{
35  int i, limit;
36  *value = 0;
37  limit = (maxSize > 9) ? 9 : (int)maxSize;
38
39  for (i = 0; i < limit;)
40  {
41    Byte b = p[i];
42    *value |= (UInt64)(b & 0x7F) << (7 * i++);
43    if ((b & 0x80) == 0)
44      return (b == 0 && i != 1) ? 0 : i;
45  }
46  return 0;
47}
48
49/* ---------- BraState ---------- */
50
51#define BRA_BUF_SIZE (1 << 14)
52
53typedef struct
54{
55  size_t bufPos;
56  size_t bufConv;
57  size_t bufTotal;
58
59  UInt32 methodId;
60  int encodeMode;
61  UInt32 delta;
62  UInt32 ip;
63  UInt32 x86State;
64  Byte deltaState[DELTA_STATE_SIZE];
65
66  Byte buf[BRA_BUF_SIZE];
67} CBraState;
68
69void BraState_Free(void *pp, ISzAlloc *alloc)
70{
71  alloc->Free(alloc, pp);
72}
73
74SRes BraState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)
75{
76  CBraState *p = ((CBraState *)pp);
77  alloc = alloc;
78  p->ip = 0;
79  if (p->methodId == XZ_ID_Delta)
80  {
81    if (propSize != 1)
82      return SZ_ERROR_UNSUPPORTED;
83    p->delta = (unsigned)props[0] + 1;
84  }
85  else
86  {
87    if (propSize == 4)
88    {
89      UInt32 v = GetUi32(props);
90      switch(p->methodId)
91      {
92        case XZ_ID_PPC:
93        case XZ_ID_ARM:
94        case XZ_ID_SPARC:
95          if ((v & 3) != 0)
96            return SZ_ERROR_UNSUPPORTED;
97          break;
98        case XZ_ID_ARMT:
99          if ((v & 1) != 0)
100            return SZ_ERROR_UNSUPPORTED;
101          break;
102        case XZ_ID_IA64:
103          if ((v & 0xF) != 0)
104            return SZ_ERROR_UNSUPPORTED;
105          break;
106      }
107      p->ip = v;
108    }
109    else if (propSize != 0)
110      return SZ_ERROR_UNSUPPORTED;
111  }
112  return SZ_OK;
113}
114
115void BraState_Init(void *pp)
116{
117  CBraState *p = ((CBraState *)pp);
118  p->bufPos = p->bufConv = p->bufTotal = 0;
119  x86_Convert_Init(p->x86State);
120  if (p->methodId == XZ_ID_Delta)
121    Delta_Init(p->deltaState);
122}
123
124#define CASE_BRA_CONV(isa) case XZ_ID_ ## isa: p->bufConv = isa ## _Convert(p->buf, p->bufTotal, p->ip, p->encodeMode); break;
125
126static SRes BraState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
127    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)
128{
129  CBraState *p = ((CBraState *)pp);
130  SizeT destLenOrig = *destLen;
131  SizeT srcLenOrig = *srcLen;
132  *destLen = 0;
133  *srcLen = 0;
134  finishMode = finishMode;
135  *wasFinished = 0;
136  while (destLenOrig > 0)
137  {
138    if (p->bufPos != p->bufConv)
139    {
140      size_t curSize = p->bufConv - p->bufPos;
141      if (curSize > destLenOrig)
142        curSize = destLenOrig;
143      memcpy(dest, p->buf + p->bufPos, curSize);
144      p->bufPos += curSize;
145      *destLen += curSize;
146      dest += curSize;
147      destLenOrig -= curSize;
148      continue;
149    }
150    p->bufTotal -= p->bufPos;
151    memmove(p->buf, p->buf + p->bufPos, p->bufTotal);
152    p->bufPos = 0;
153    p->bufConv = 0;
154    {
155      size_t curSize = BRA_BUF_SIZE - p->bufTotal;
156      if (curSize > srcLenOrig)
157        curSize = srcLenOrig;
158      memcpy(p->buf + p->bufTotal, src, curSize);
159      *srcLen += curSize;
160      src += curSize;
161      srcLenOrig -= curSize;
162      p->bufTotal += curSize;
163    }
164    if (p->bufTotal == 0)
165      break;
166    switch(p->methodId)
167    {
168      case XZ_ID_Delta:
169        if (p->encodeMode)
170          Delta_Encode(p->deltaState, p->delta, p->buf, p->bufTotal);
171        else
172          Delta_Decode(p->deltaState, p->delta, p->buf, p->bufTotal);
173        p->bufConv = p->bufTotal;
174        break;
175      case XZ_ID_X86:
176        p->bufConv = x86_Convert(p->buf, p->bufTotal, p->ip, &p->x86State, p->encodeMode);
177        break;
178      CASE_BRA_CONV(PPC)
179      CASE_BRA_CONV(IA64)
180      CASE_BRA_CONV(ARM)
181      CASE_BRA_CONV(ARMT)
182      CASE_BRA_CONV(SPARC)
183      default:
184        return SZ_ERROR_UNSUPPORTED;
185    }
186    p->ip += (UInt32)p->bufConv;
187
188    if (p->bufConv == 0)
189    {
190      if (!srcWasFinished)
191        break;
192      p->bufConv = p->bufTotal;
193    }
194  }
195  if (p->bufTotal == p->bufPos && srcLenOrig == 0 && srcWasFinished)
196    *wasFinished = 1;
197  return SZ_OK;
198}
199
200SRes BraState_SetFromMethod(IStateCoder *p, UInt64 id, int encodeMode, ISzAlloc *alloc)
201{
202  CBraState *decoder;
203  if (id != XZ_ID_Delta &&
204      id != XZ_ID_X86 &&
205      id != XZ_ID_PPC &&
206      id != XZ_ID_IA64 &&
207      id != XZ_ID_ARM &&
208      id != XZ_ID_ARMT &&
209      id != XZ_ID_SPARC)
210    return SZ_ERROR_UNSUPPORTED;
211  p->p = 0;
212  decoder = (CBraState *)alloc->Alloc(alloc, sizeof(CBraState));
213  if (decoder == 0)
214    return SZ_ERROR_MEM;
215  decoder->methodId = (UInt32)id;
216  decoder->encodeMode = encodeMode;
217  p->p = decoder;
218  p->Free = BraState_Free;
219  p->SetProps = BraState_SetProps;
220  p->Init = BraState_Init;
221  p->Code = BraState_Code;
222  return SZ_OK;
223}
224
225/* ---------- SbState ---------- */
226
227#ifdef USE_SUBBLOCK
228
229static void SbState_Free(void *pp, ISzAlloc *alloc)
230{
231  CSbDec *p = (CSbDec *)pp;
232  SbDec_Free(p);
233  alloc->Free(alloc, pp);
234}
235
236static SRes SbState_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)
237{
238  pp = pp;
239  props = props;
240  alloc = alloc;
241  return (propSize == 0) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
242}
243
244static void SbState_Init(void *pp)
245{
246  SbDec_Init((CSbDec *)pp);
247}
248
249static SRes SbState_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
250    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)
251{
252  CSbDec *p = (CSbDec *)pp;
253  SRes res;
254  srcWasFinished = srcWasFinished;
255  p->dest = dest;
256  p->destLen = *destLen;
257  p->src = src;
258  p->srcLen = *srcLen;
259  p->finish = finishMode; /* change it */
260  res = SbDec_Decode((CSbDec *)pp);
261  *destLen -= p->destLen;
262  *srcLen -= p->srcLen;
263  *wasFinished = (*destLen == 0 && *srcLen == 0); /* change it */
264  return res;
265}
266
267SRes SbState_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
268{
269  CSbDec *decoder;
270  p->p = 0;
271  decoder = alloc->Alloc(alloc, sizeof(CSbDec));
272  if (decoder == 0)
273    return SZ_ERROR_MEM;
274  p->p = decoder;
275  p->Free = SbState_Free;
276  p->SetProps = SbState_SetProps;
277  p->Init = SbState_Init;
278  p->Code = SbState_Code;
279  SbDec_Construct(decoder);
280  SbDec_SetAlloc(decoder, alloc);
281  return SZ_OK;
282}
283#endif
284
285/* ---------- Lzma2State ---------- */
286
287static void Lzma2State_Free(void *pp, ISzAlloc *alloc)
288{
289  Lzma2Dec_Free((CLzma2Dec *)pp, alloc);
290  alloc->Free(alloc, pp);
291}
292
293static SRes Lzma2State_SetProps(void *pp, const Byte *props, size_t propSize, ISzAlloc *alloc)
294{
295  if (propSize != 1)
296    return SZ_ERROR_UNSUPPORTED;
297  return Lzma2Dec_Allocate((CLzma2Dec *)pp, props[0], alloc);
298}
299
300static void Lzma2State_Init(void *pp)
301{
302  Lzma2Dec_Init((CLzma2Dec *)pp);
303}
304
305static SRes Lzma2State_Code(void *pp, Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
306    int srcWasFinished, ECoderFinishMode finishMode, int *wasFinished)
307{
308  ELzmaStatus status;
309  /* ELzmaFinishMode fm = (finishMode == LZMA_FINISH_ANY) ? LZMA_FINISH_ANY : LZMA_FINISH_END; */
310  SRes res = Lzma2Dec_DecodeToBuf((CLzma2Dec *)pp, dest, destLen, src, srcLen, (ELzmaFinishMode)finishMode, &status);
311  srcWasFinished = srcWasFinished;
312  *wasFinished = (status == LZMA_STATUS_FINISHED_WITH_MARK);
313  return res;
314}
315
316static SRes Lzma2State_SetFromMethod(IStateCoder *p, ISzAlloc *alloc)
317{
318  CLzma2Dec *decoder = (CLzma2Dec *)alloc->Alloc(alloc, sizeof(CLzma2Dec));
319  p->p = decoder;
320  if (decoder == 0)
321    return SZ_ERROR_MEM;
322  p->Free = Lzma2State_Free;
323  p->SetProps = Lzma2State_SetProps;
324  p->Init = Lzma2State_Init;
325  p->Code = Lzma2State_Code;
326  Lzma2Dec_Construct(decoder);
327  return SZ_OK;
328}
329
330
331void MixCoder_Construct(CMixCoder *p, ISzAlloc *alloc)
332{
333  int i;
334  p->alloc = alloc;
335  p->buf = 0;
336  p->numCoders = 0;
337  for (i = 0; i < MIXCODER_NUM_FILTERS_MAX; i++)
338    p->coders[i].p = NULL;
339}
340
341void MixCoder_Free(CMixCoder *p)
342{
343  int i;
344  for (i = 0; i < p->numCoders; i++)
345  {
346    IStateCoder *sc = &p->coders[i];
347    if (p->alloc && sc->p)
348      sc->Free(sc->p, p->alloc);
349  }
350  p->numCoders = 0;
351  if (p->buf)
352  {
353    p->alloc->Free(p->alloc, p->buf);
354    p->buf = 0; /* 9.31: the BUG was fixed */
355  }
356}
357
358void MixCoder_Init(CMixCoder *p)
359{
360  int i;
361  for (i = 0; i < p->numCoders - 1; i++)
362  {
363    p->size[i] = 0;
364    p->pos[i] = 0;
365    p->finished[i] = 0;
366  }
367  for (i = 0; i < p->numCoders; i++)
368  {
369    IStateCoder *coder = &p->coders[i];
370    coder->Init(coder->p);
371  }
372}
373
374SRes MixCoder_SetFromMethod(CMixCoder *p, int coderIndex, UInt64 methodId)
375{
376  IStateCoder *sc = &p->coders[coderIndex];
377  p->ids[coderIndex] = methodId;
378  switch(methodId)
379  {
380    case XZ_ID_LZMA2: return Lzma2State_SetFromMethod(sc, p->alloc);
381    #ifdef USE_SUBBLOCK
382    case XZ_ID_Subblock: return SbState_SetFromMethod(sc, p->alloc);
383    #endif
384  }
385  if (coderIndex == 0)
386    return SZ_ERROR_UNSUPPORTED;
387  return BraState_SetFromMethod(sc, methodId, 0, p->alloc);
388}
389
390SRes MixCoder_Code(CMixCoder *p, Byte *dest, SizeT *destLen,
391    const Byte *src, SizeT *srcLen, int srcWasFinished,
392    ECoderFinishMode finishMode, ECoderStatus *status)
393{
394  SizeT destLenOrig = *destLen;
395  SizeT srcLenOrig = *srcLen;
396  Bool allFinished = True;
397  *destLen = 0;
398  *srcLen = 0;
399  *status = CODER_STATUS_NOT_FINISHED;
400
401  if (p->buf == 0)
402  {
403    p->buf = (Byte *)p->alloc->Alloc(p->alloc, CODER_BUF_SIZE * (MIXCODER_NUM_FILTERS_MAX - 1));
404    if (p->buf == 0)
405      return SZ_ERROR_MEM;
406  }
407
408  if (p->numCoders != 1)
409    finishMode = CODER_FINISH_ANY;
410
411  for (;;)
412  {
413    Bool processed = False;
414    int i;
415    /*
416    if (p->numCoders == 1 && *destLen == destLenOrig && finishMode == LZMA_FINISH_ANY)
417      break;
418    */
419
420    for (i = 0; i < p->numCoders; i++)
421    {
422      SRes res;
423      IStateCoder *coder = &p->coders[i];
424      Byte *destCur;
425      SizeT destLenCur, srcLenCur;
426      const Byte *srcCur;
427      int srcFinishedCur;
428      int encodingWasFinished;
429
430      if (i == 0)
431      {
432        srcCur = src;
433        srcLenCur = srcLenOrig - *srcLen;
434        srcFinishedCur = srcWasFinished;
435      }
436      else
437      {
438        srcCur = p->buf + (CODER_BUF_SIZE * (i - 1)) + p->pos[i - 1];
439        srcLenCur = p->size[i - 1] - p->pos[i - 1];
440        srcFinishedCur = p->finished[i - 1];
441      }
442
443      if (i == p->numCoders - 1)
444      {
445        destCur = dest;
446        destLenCur = destLenOrig - *destLen;
447      }
448      else
449      {
450        if (p->pos[i] != p->size[i])
451          continue;
452        destCur = p->buf + (CODER_BUF_SIZE * i);
453        destLenCur = CODER_BUF_SIZE;
454      }
455
456      res = coder->Code(coder->p, destCur, &destLenCur, srcCur, &srcLenCur, srcFinishedCur, finishMode, &encodingWasFinished);
457
458      if (!encodingWasFinished)
459        allFinished = False;
460
461      if (i == 0)
462      {
463        *srcLen += srcLenCur;
464        src += srcLenCur;
465      }
466      else
467      {
468        p->pos[i - 1] += srcLenCur;
469      }
470
471      if (i == p->numCoders - 1)
472      {
473        *destLen += destLenCur;
474        dest += destLenCur;
475      }
476      else
477      {
478        p->size[i] = destLenCur;
479        p->pos[i] = 0;
480        p->finished[i] = encodingWasFinished;
481      }
482
483      if (res != SZ_OK)
484        return res;
485
486      if (destLenCur != 0 || srcLenCur != 0)
487        processed = True;
488    }
489    if (!processed)
490      break;
491  }
492  if (allFinished)
493    *status = CODER_STATUS_FINISHED_WITH_MARK;
494  return SZ_OK;
495}
496
497SRes Xz_ParseHeader(CXzStreamFlags *p, const Byte *buf)
498{
499  *p = (CXzStreamFlags)GetBe16(buf + XZ_SIG_SIZE);
500  if (CrcCalc(buf + XZ_SIG_SIZE, XZ_STREAM_FLAGS_SIZE) !=
501      GetUi32(buf + XZ_SIG_SIZE + XZ_STREAM_FLAGS_SIZE))
502    return SZ_ERROR_NO_ARCHIVE;
503  return XzFlags_IsSupported(*p) ? SZ_OK : SZ_ERROR_UNSUPPORTED;
504}
505
506static Bool Xz_CheckFooter(CXzStreamFlags flags, UInt64 indexSize, const Byte *buf)
507{
508  return
509      indexSize == (((UInt64)GetUi32(buf + 4) + 1) << 2) &&
510      (GetUi32(buf) == CrcCalc(buf + 4, 6) &&
511      flags == GetBe16(buf + 8) &&
512      memcmp(buf + 10, XZ_FOOTER_SIG, XZ_FOOTER_SIG_SIZE) == 0);
513}
514
515#define READ_VARINT_AND_CHECK(buf, pos, size, res) \
516  { unsigned s = Xz_ReadVarInt(buf + pos, size - pos, res); \
517  if (s == 0) return SZ_ERROR_ARCHIVE; pos += s; }
518
519
520SRes XzBlock_Parse(CXzBlock *p, const Byte *header)
521{
522  unsigned pos;
523  int numFilters, i;
524  UInt32 headerSize = (UInt32)header[0] << 2;
525
526  if (CrcCalc(header, headerSize) != GetUi32(header + headerSize))
527    return SZ_ERROR_ARCHIVE;
528
529  pos = 1;
530  if (pos == headerSize)
531    return SZ_ERROR_ARCHIVE;
532  p->flags = header[pos++];
533
534  if (XzBlock_HasPackSize(p))
535  {
536    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->packSize);
537    if (p->packSize == 0 || p->packSize + headerSize >= (UInt64)1 << 63)
538      return SZ_ERROR_ARCHIVE;
539  }
540
541  if (XzBlock_HasUnpackSize(p))
542    READ_VARINT_AND_CHECK(header, pos, headerSize, &p->unpackSize);
543
544  numFilters = XzBlock_GetNumFilters(p);
545  for (i = 0; i < numFilters; i++)
546  {
547    CXzFilter *filter = p->filters + i;
548    UInt64 size;
549    READ_VARINT_AND_CHECK(header, pos, headerSize, &filter->id);
550    READ_VARINT_AND_CHECK(header, pos, headerSize, &size);
551    if (size > headerSize - pos || size > XZ_FILTER_PROPS_SIZE_MAX)
552      return SZ_ERROR_ARCHIVE;
553    filter->propsSize = (UInt32)size;
554    memcpy(filter->props, header + pos, (size_t)size);
555    pos += (unsigned)size;
556
557    #ifdef XZ_DUMP
558    printf("\nf[%d] = %2X: ", i, filter->id);
559    {
560      int i;
561      for (i = 0; i < size; i++)
562        printf(" %2X", filter->props[i]);
563    }
564    #endif
565  }
566
567  while (pos < headerSize)
568    if (header[pos++] != 0)
569      return SZ_ERROR_ARCHIVE;
570  return SZ_OK;
571}
572
573SRes XzDec_Init(CMixCoder *p, const CXzBlock *block)
574{
575  int i;
576  Bool needReInit = True;
577  int numFilters = XzBlock_GetNumFilters(block);
578  if (numFilters == p->numCoders)
579  {
580    for (i = 0; i < numFilters; i++)
581      if (p->ids[i] != block->filters[numFilters - 1 - i].id)
582        break;
583    needReInit = (i != numFilters);
584  }
585  if (needReInit)
586  {
587    MixCoder_Free(p);
588    p->numCoders = numFilters;
589    for (i = 0; i < numFilters; i++)
590    {
591      const CXzFilter *f = &block->filters[numFilters - 1 - i];
592      RINOK(MixCoder_SetFromMethod(p, i, f->id));
593    }
594  }
595  for (i = 0; i < numFilters; i++)
596  {
597    const CXzFilter *f = &block->filters[numFilters - 1 - i];
598    IStateCoder *sc = &p->coders[i];
599    RINOK(sc->SetProps(sc->p, f->props, f->propsSize, p->alloc));
600  }
601  MixCoder_Init(p);
602  return SZ_OK;
603}
604
605void XzUnpacker_Init(CXzUnpacker *p)
606{
607  p->state = XZ_STATE_STREAM_HEADER;
608  p->pos = 0;
609  p->numStartedStreams = 0;
610  p->numFinishedStreams = 0;
611  p->numTotalBlocks = 0;
612  p->padSize = 0;
613}
614
615void XzUnpacker_Construct(CXzUnpacker *p, ISzAlloc *alloc)
616{
617  MixCoder_Construct(&p->decoder, alloc);
618  XzUnpacker_Init(p);
619}
620
621void XzUnpacker_Free(CXzUnpacker *p)
622{
623  MixCoder_Free(&p->decoder);
624}
625
626SRes XzUnpacker_Code(CXzUnpacker *p, Byte *dest, SizeT *destLen,
627    const Byte *src, SizeT *srcLen, ECoderFinishMode finishMode, ECoderStatus *status)
628{
629  SizeT destLenOrig = *destLen;
630  SizeT srcLenOrig = *srcLen;
631  *destLen = 0;
632  *srcLen = 0;
633  *status = CODER_STATUS_NOT_SPECIFIED;
634  for (;;)
635  {
636    SizeT srcRem = srcLenOrig - *srcLen;
637
638    if (p->state == XZ_STATE_BLOCK)
639    {
640      SizeT destLen2 = destLenOrig - *destLen;
641      SizeT srcLen2 = srcLenOrig - *srcLen;
642      SRes res;
643      if (srcLen2 == 0 && destLen2 == 0)
644      {
645        *status = CODER_STATUS_NOT_FINISHED;
646        return SZ_OK;
647      }
648
649      res = MixCoder_Code(&p->decoder, dest, &destLen2, src, &srcLen2, False, finishMode, status);
650      XzCheck_Update(&p->check, dest, destLen2);
651
652      (*srcLen) += srcLen2;
653      src += srcLen2;
654      p->packSize += srcLen2;
655
656      (*destLen) += destLen2;
657      dest += destLen2;
658      p->unpackSize += destLen2;
659
660      RINOK(res);
661
662      if (*status == CODER_STATUS_FINISHED_WITH_MARK)
663      {
664        Byte temp[32];
665        unsigned num = Xz_WriteVarInt(temp, p->packSize + p->blockHeaderSize + XzFlags_GetCheckSize(p->streamFlags));
666        num += Xz_WriteVarInt(temp + num, p->unpackSize);
667        Sha256_Update(&p->sha, temp, num);
668        p->indexSize += num;
669        p->numBlocks++;
670
671        p->state = XZ_STATE_BLOCK_FOOTER;
672        p->pos = 0;
673        p->alignPos = 0;
674      }
675      else if (srcLen2 == 0 && destLen2 == 0)
676        return SZ_OK;
677
678      continue;
679    }
680
681    if (srcRem == 0)
682    {
683      *status = CODER_STATUS_NEEDS_MORE_INPUT;
684      return SZ_OK;
685    }
686
687    switch (p->state)
688    {
689      case XZ_STATE_STREAM_HEADER:
690      {
691        if (p->pos < XZ_STREAM_HEADER_SIZE)
692        {
693          if (p->pos < XZ_SIG_SIZE && *src != XZ_SIG[p->pos])
694            return SZ_ERROR_NO_ARCHIVE;
695          p->buf[p->pos++] = *src++;
696          (*srcLen)++;
697        }
698        else
699        {
700          RINOK(Xz_ParseHeader(&p->streamFlags, p->buf));
701          p->numStartedStreams++;
702          p->state = XZ_STATE_BLOCK_HEADER;
703          Sha256_Init(&p->sha);
704          p->indexSize = 0;
705          p->numBlocks = 0;
706          p->pos = 0;
707        }
708        break;
709      }
710
711      case XZ_STATE_BLOCK_HEADER:
712      {
713        if (p->pos == 0)
714        {
715          p->buf[p->pos++] = *src++;
716          (*srcLen)++;
717          if (p->buf[0] == 0)
718          {
719            p->indexPreSize = 1 + Xz_WriteVarInt(p->buf + 1, p->numBlocks);
720            p->indexPos = p->indexPreSize;
721            p->indexSize += p->indexPreSize;
722            Sha256_Final(&p->sha, p->shaDigest);
723            Sha256_Init(&p->sha);
724            p->crc = CrcUpdate(CRC_INIT_VAL, p->buf, p->indexPreSize);
725            p->state = XZ_STATE_STREAM_INDEX;
726          }
727          p->blockHeaderSize = ((UInt32)p->buf[0] << 2) + 4;
728        }
729        else if (p->pos != p->blockHeaderSize)
730        {
731          UInt32 cur = p->blockHeaderSize - p->pos;
732          if (cur > srcRem)
733            cur = (UInt32)srcRem;
734          memcpy(p->buf + p->pos, src, cur);
735          p->pos += cur;
736          (*srcLen) += cur;
737          src += cur;
738        }
739        else
740        {
741          RINOK(XzBlock_Parse(&p->block, p->buf));
742          p->numTotalBlocks++;
743          p->state = XZ_STATE_BLOCK;
744          p->packSize = 0;
745          p->unpackSize = 0;
746          XzCheck_Init(&p->check, XzFlags_GetCheckType(p->streamFlags));
747          RINOK(XzDec_Init(&p->decoder, &p->block));
748        }
749        break;
750      }
751
752      case XZ_STATE_BLOCK_FOOTER:
753      {
754        if (((p->packSize + p->alignPos) & 3) != 0)
755        {
756          (*srcLen)++;
757          p->alignPos++;
758          if (*src++ != 0)
759            return SZ_ERROR_CRC;
760        }
761        else
762        {
763          UInt32 checkSize = XzFlags_GetCheckSize(p->streamFlags);
764          UInt32 cur = checkSize - p->pos;
765          if (cur != 0)
766          {
767            if (cur > srcRem)
768              cur = (UInt32)srcRem;
769            memcpy(p->buf + p->pos, src, cur);
770            p->pos += cur;
771            (*srcLen) += cur;
772            src += cur;
773          }
774          else
775          {
776            Byte digest[XZ_CHECK_SIZE_MAX];
777            p->state = XZ_STATE_BLOCK_HEADER;
778            p->pos = 0;
779            if (XzCheck_Final(&p->check, digest) && memcmp(digest, p->buf, checkSize) != 0)
780              return SZ_ERROR_CRC;
781          }
782        }
783        break;
784      }
785
786      case XZ_STATE_STREAM_INDEX:
787      {
788        if (p->pos < p->indexPreSize)
789        {
790          (*srcLen)++;
791          if (*src++ != p->buf[p->pos++])
792            return SZ_ERROR_CRC;
793        }
794        else
795        {
796          if (p->indexPos < p->indexSize)
797          {
798            UInt64 cur = p->indexSize - p->indexPos;
799            if (srcRem > cur)
800              srcRem = (SizeT)cur;
801            p->crc = CrcUpdate(p->crc, src, srcRem);
802            Sha256_Update(&p->sha, src, srcRem);
803            (*srcLen) += srcRem;
804            src += srcRem;
805            p->indexPos += srcRem;
806          }
807          else if ((p->indexPos & 3) != 0)
808          {
809            Byte b = *src++;
810            p->crc = CRC_UPDATE_BYTE(p->crc, b);
811            (*srcLen)++;
812            p->indexPos++;
813            p->indexSize++;
814            if (b != 0)
815              return SZ_ERROR_CRC;
816          }
817          else
818          {
819            Byte digest[SHA256_DIGEST_SIZE];
820            p->state = XZ_STATE_STREAM_INDEX_CRC;
821            p->indexSize += 4;
822            p->pos = 0;
823            Sha256_Final(&p->sha, digest);
824            if (memcmp(digest, p->shaDigest, SHA256_DIGEST_SIZE) != 0)
825              return SZ_ERROR_CRC;
826          }
827        }
828        break;
829      }
830
831      case XZ_STATE_STREAM_INDEX_CRC:
832      {
833        if (p->pos < 4)
834        {
835          (*srcLen)++;
836          p->buf[p->pos++] = *src++;
837        }
838        else
839        {
840          p->state = XZ_STATE_STREAM_FOOTER;
841          p->pos = 0;
842          if (CRC_GET_DIGEST(p->crc) != GetUi32(p->buf))
843            return SZ_ERROR_CRC;
844        }
845        break;
846      }
847
848      case XZ_STATE_STREAM_FOOTER:
849      {
850        UInt32 cur = XZ_STREAM_FOOTER_SIZE - p->pos;
851        if (cur > srcRem)
852          cur = (UInt32)srcRem;
853        memcpy(p->buf + p->pos, src, cur);
854        p->pos += cur;
855        (*srcLen) += cur;
856        src += cur;
857        if (p->pos == XZ_STREAM_FOOTER_SIZE)
858        {
859          p->state = XZ_STATE_STREAM_PADDING;
860          p->numFinishedStreams++;
861          p->padSize = 0;
862          if (!Xz_CheckFooter(p->streamFlags, p->indexSize, p->buf))
863            return SZ_ERROR_CRC;
864        }
865        break;
866      }
867
868      case XZ_STATE_STREAM_PADDING:
869      {
870        if (*src != 0)
871        {
872          if (((UInt32)p->padSize & 3) != 0)
873            return SZ_ERROR_NO_ARCHIVE;
874          p->pos = 0;
875          p->state = XZ_STATE_STREAM_HEADER;
876        }
877        else
878        {
879          (*srcLen)++;
880          src++;
881          p->padSize++;
882        }
883        break;
884      }
885
886      case XZ_STATE_BLOCK: break; /* to disable GCC warning */
887    }
888  }
889  /*
890  if (p->state == XZ_STATE_FINISHED)
891    *status = CODER_STATUS_FINISHED_WITH_MARK;
892  return SZ_OK;
893  */
894}
895
896Bool XzUnpacker_IsStreamWasFinished(CXzUnpacker *p)
897{
898  return (p->state == XZ_STATE_STREAM_PADDING) && (((UInt32)p->padSize & 3) == 0);
899}
900
901UInt64 XzUnpacker_GetExtraSize(CXzUnpacker *p)
902{
903  UInt64 num = 0;
904  if (p->state == XZ_STATE_STREAM_PADDING)
905    num += p->padSize;
906  else if (p->state == XZ_STATE_STREAM_HEADER)
907    num += p->padSize + p->pos;
908  return num;
909}
910