#include "rar.hpp"

size_t Archive::ReadHeader()

{

  // Once we failed to decrypt an encrypted block, there is no reason to

  // attempt to do it further. We'll never be successful and only generate

  // endless errors.

  if (FailedHeaderDecryption)

    return 0;

  CurBlockPos=Tell();

  // Other developers asked us to initialize it to suppress "may be used

  // uninitialized" warning in code below in some compilers.

  size_t ReadSize=0;

  switch(Format)

  {

#ifndef SFX_MODULE

    case RARFMT14:

      ReadSize=ReadHeader14();

      break;

    case RARFMT15:

      ReadSize=ReadHeader15();

      break;

#endif

    case RARFMT50:

      ReadSize=ReadHeader50();

      break;

  }

  // It is important to check ReadSize>0 here, because it is normal

  // for RAR2 and RAR3 archives without end of archive block to have

  // NextBlockPos==CurBlockPos after the end of archive has reached.

  if (ReadSize>0 && NextBlockPos<=CurBlockPos)

  {

    BrokenHeaderMsg();

    ReadSize=0;

  }

  if (ReadSize==0)

    CurHeaderType=HEAD_UNKNOWN;

  return ReadSize;

}

size_t Archive::SearchBlock(HEADER_TYPE HeaderType)

{

  size_t Size,Count=0;

  while ((Size=ReadHeader())!=0 &&

         (HeaderType==HEAD_ENDARC || GetHeaderType()!=HEAD_ENDARC))

  {

    if ((++Count & 127)==0)

      Wait();

    if (GetHeaderType()==HeaderType)

      return Size;

    SeekToNext();

  }

  return 0;

}

size_t Archive::SearchSubBlock(const wchar *Type)

{

  size_t Size,Count=0;

  while ((Size=ReadHeader())!=0 && GetHeaderType()!=HEAD_ENDARC)

  {

    if ((++Count & 127)==0)

      Wait();

    if (GetHeaderType()==HEAD_SERVICE && SubHead.CmpName(Type))

      return Size;

    SeekToNext();

  }

  return 0;

}

size_t Archive::SearchRR()

{

  // If locator extra field is available for recovery record, let's utilize it.

  if (MainHead.Locator && MainHead.RROffset!=0)

  {

    uint64 CurPos=Tell();

    Seek(MainHead.RROffset,SEEK_SET);

    size_t Size=ReadHeader();

    if (Size!=0 && !BrokenHeader && GetHeaderType()==HEAD_SERVICE && SubHead.CmpName(SUBHEAD_TYPE_RR))

      return Size;

    Seek(CurPos,SEEK_SET);

  }

  // Otherwise scan the entire archive to find the recovery record.

  return SearchSubBlock(SUBHEAD_TYPE_RR);

}

void Archive::UnexpEndArcMsg()

{

  int64 ArcSize=FileLength();

  // If block positions are equal to file size, this is not an error.

  // It can happen when we reached the end of older RAR 1.5 archive,

  // which did not have the end of archive block.

  // We can't replace this check by checking that read size is exactly 0

  // in the beginning of file header, because in this case the read position

  // still can be beyond the end of archive.

  if (CurBlockPos!=ArcSize || NextBlockPos!=ArcSize)

  {

    uiMsg(UIERROR_UNEXPEOF,FileName);

    if (CurHeaderType!=HEAD_FILE)

      uiMsg(UIERROR_TRUNCSERVICE,FileName,SubHead.FileName);

    ErrHandler.SetErrorCode(RARX_WARNING);

  }

}

void Archive::BrokenHeaderMsg()

{

  uiMsg(UIERROR_HEADERBROKEN,FileName);

  BrokenHeader=true;

  ErrHandler.SetErrorCode(RARX_CRC);

}

void Archive::UnkEncVerMsg(const std::wstring &Name,const std::wstring &Info)

{

  uiMsg(UIERROR_UNKNOWNENCMETHOD,FileName,Name,Info);

  ErrHandler.SetErrorCode(RARX_FATAL);

}

// Return f in case of signed integer overflow or negative parameters

// or v1+v2 otherwise. We use it for file offsets, which are signed

// for compatibility with off_t in POSIX file functions and third party code.

// Signed integer overflow is the undefined behavior according to

// C++ standard and it causes fuzzers to complain.

inline int64 SafeAdd(int64 v1,int64 v2,int64 f)

{

  return v1>=0 && v2>=0 && v1<=MAX_INT64-v2 ? v1+v2 : f;

}

#ifndef SFX_MODULE

size_t Archive::ReadHeader15()

{

  RawRead Raw(this);

  bool Decrypt=Encrypted && CurBlockPos>(int64)SFXSize+SIZEOF_MARKHEAD3;

  if (Decrypt)

  {

#ifdef RAR_NOCRYPT // For rarext.dll, Setup.SFX and unrar_nocrypt.dll.

    return 0;

#else

    RequestArcPassword(NULL);

    byte Salt[SIZE_SALT30];

    if (Read(Salt,SIZE_SALT30)!=SIZE_SALT30)

    {

      UnexpEndArcMsg();

      return 0;

    }

    HeadersCrypt.SetCryptKeys(false,CRYPT_RAR30,&Cmd->Password,Salt,NULL,0,NULL,NULL);

    Raw.SetCrypt(&HeadersCrypt);

#endif

  }

  Raw.Read(SIZEOF_SHORTBLOCKHEAD);

  if (Raw.Size()==0)

  {

    UnexpEndArcMsg();

    return 0;

  }

  ShortBlock.HeadCRC=Raw.Get2();

  ShortBlock.Reset();

  uint HeaderType=Raw.Get1();

  ShortBlock.Flags=Raw.Get2();

  ShortBlock.SkipIfUnknown=(ShortBlock.Flags & SKIP_IF_UNKNOWN)!=0;

  ShortBlock.HeadSize=Raw.Get2();

  ShortBlock.HeaderType=(HEADER_TYPE)HeaderType;

  if (ShortBlock.HeadSize<SIZEOF_SHORTBLOCKHEAD)

  {

    BrokenHeaderMsg();

    return 0;

  }

  // For simpler further processing we map header types common

  // for RAR 1.5 and 5.0 formats to RAR 5.0 values. It does not include

  // header types specific for RAR 1.5 - 4.x only.

  switch(ShortBlock.HeaderType)

  {

    case HEAD3_MAIN:    ShortBlock.HeaderType=HEAD_MAIN;     break;

    case HEAD3_FILE:    ShortBlock.HeaderType=HEAD_FILE;     break;

    case HEAD3_SERVICE: ShortBlock.HeaderType=HEAD_SERVICE;  break;

    case HEAD3_ENDARC:  ShortBlock.HeaderType=HEAD_ENDARC;   break;

  }

  CurHeaderType=ShortBlock.HeaderType;

  if (ShortBlock.HeaderType==HEAD3_CMT)

  {

    // Old style (up to RAR 2.9) comment header embedded into main

    // or file header. We must not read the entire ShortBlock.HeadSize here

    // to not break the comment processing logic later.

    Raw.Read(SIZEOF_COMMHEAD-SIZEOF_SHORTBLOCKHEAD);

  }

  else

    if (ShortBlock.HeaderType==HEAD_MAIN && (ShortBlock.Flags & MHD_COMMENT)!=0)

    {

      // Old style (up to RAR 2.9) main archive comment embedded into

      // the main archive header found. While we can read the entire

      // ShortBlock.HeadSize here and remove this part of "if", it would be

      // waste of memory, because we'll read and process this comment data

      // in other function anyway and we do not need them here now.

      Raw.Read(SIZEOF_MAINHEAD3-SIZEOF_SHORTBLOCKHEAD);

    }

    else

      Raw.Read(ShortBlock.HeadSize-SIZEOF_SHORTBLOCKHEAD);

  NextBlockPos=CurBlockPos+FullHeaderSize(ShortBlock.HeadSize);

  switch(ShortBlock.HeaderType)

  {

    case HEAD_MAIN:

      MainHead.Reset();

      MainHead.SetBaseBlock(ShortBlock);

      MainHead.HighPosAV=Raw.Get2();

      MainHead.PosAV=Raw.Get4();

      Volume=(MainHead.Flags & MHD_VOLUME)!=0;

      Solid=(MainHead.Flags & MHD_SOLID)!=0;

      Locked=(MainHead.Flags & MHD_LOCK)!=0;

      Protected=(MainHead.Flags & MHD_PROTECT)!=0;

      Encrypted=(MainHead.Flags & MHD_PASSWORD)!=0;

      Signed=MainHead.PosAV!=0 || MainHead.HighPosAV!=0;

      MainHead.CommentInHeader=(MainHead.Flags & MHD_COMMENT)!=0;

      // Only for encrypted 3.0+ archives. 2.x archives did not have this

      // flag, so for non-encrypted archives, we'll set it later based on

      // file attributes.

      FirstVolume=(MainHead.Flags & MHD_FIRSTVOLUME)!=0;

      NewNumbering=(MainHead.Flags & MHD_NEWNUMBERING)!=0;

      break;

    case HEAD_FILE:

    case HEAD_SERVICE:

      {

        bool FileBlock=ShortBlock.HeaderType==HEAD_FILE;

        FileHeader *hd=FileBlock ? &FileHead:&SubHead;

        hd->Reset();

        hd->SetBaseBlock(ShortBlock);

        hd->SplitBefore=(hd->Flags & LHD_SPLIT_BEFORE)!=0;

        hd->SplitAfter=(hd->Flags & LHD_SPLIT_AFTER)!=0;

        hd->Encrypted=(hd->Flags & LHD_PASSWORD)!=0;

        hd->SaltSet=(hd->Flags & LHD_SALT)!=0;

        // RAR versions earlier than 2.0 do not set the solid flag

        // in file header. They use only a global solid archive flag.

        hd->Solid=FileBlock && (hd->Flags & LHD_SOLID)!=0;

        hd->SubBlock=!FileBlock && (hd->Flags & LHD_SOLID)!=0;

        hd->Dir=(hd->Flags & LHD_WINDOWMASK)==LHD_DIRECTORY;

        hd->WinSize=hd->Dir ? 0:0x10000<<((hd->Flags & LHD_WINDOWMASK)>>5);

        hd->CommentInHeader=(hd->Flags & LHD_COMMENT)!=0;

        hd->Version=(hd->Flags & LHD_VERSION)!=0;

        hd->DataSize=Raw.Get4();

        uint LowUnpSize=Raw.Get4();

        hd->HostOS=Raw.Get1();

        hd->FileHash.Type=HASH_CRC32;

        hd->FileHash.CRC32=Raw.Get4();

        uint FileTime=Raw.Get4();

        hd->UnpVer=Raw.Get1();

        hd->Method=Raw.Get1()-0x30;

        size_t NameSize=Raw.Get2();

        hd->FileAttr=Raw.Get4();

        // RAR15 did not use the special dictionary size to mark dirs.

        if (hd->UnpVer<20 && (hd->FileAttr & 0x10)!=0)

          hd->Dir=true;

        hd->CryptMethod=CRYPT_NONE;

        if (hd->Encrypted)

          switch(hd->UnpVer)

          {

            case 13: hd->CryptMethod=CRYPT_RAR13; break;

            case 15: hd->CryptMethod=CRYPT_RAR15; break;

            case 20:

            case 26: hd->CryptMethod=CRYPT_RAR20; break;

            default: hd->CryptMethod=CRYPT_RAR30; break;

          }

        hd->HSType=HSYS_UNKNOWN;

        if (hd->HostOS==HOST_UNIX || hd->HostOS==HOST_BEOS)

          hd->HSType=HSYS_UNIX;

        else

          if (hd->HostOS<HOST_MAX)

            hd->HSType=HSYS_WINDOWS;

        hd->RedirType=FSREDIR_NONE;

        // RAR 4.x Unix symlink.

        if (hd->HostOS==HOST_UNIX && (hd->FileAttr & 0xF000)==0xA000)

        {

          hd->RedirType=FSREDIR_UNIXSYMLINK;

          hd->RedirName.clear();

        }

        hd->Inherited=!FileBlock && (hd->SubFlags & SUBHEAD_FLAGS_INHERITED)!=0;

        hd->LargeFile=(hd->Flags & LHD_LARGE)!=0;

        uint HighPackSize,HighUnpSize;

        if (hd->LargeFile)

        {

          HighPackSize=Raw.Get4();

          HighUnpSize=Raw.Get4();

          hd->UnknownUnpSize=(LowUnpSize==0xffffffff && HighUnpSize==0xffffffff);

        }

        else

        {

          HighPackSize=HighUnpSize=0;

          // UnpSize equal to 0xffffffff without LHD_LARGE flag indicates

          // that we do not know the unpacked file size and must unpack it

          // until we find the end of file marker in compressed data.

          hd->UnknownUnpSize=(LowUnpSize==0xffffffff);

        }

        hd->PackSize=INT32TO64(HighPackSize,hd->DataSize);

        hd->UnpSize=INT32TO64(HighUnpSize,LowUnpSize);

        if (hd->UnknownUnpSize)

          hd->UnpSize=INT64NDF;

        size_t ReadNameSize=Min(NameSize,MAXPATHSIZE);

        std::string FileName(ReadNameSize,0);

        Raw.GetB((byte *)&FileName[0],ReadNameSize);

        if (FileBlock)

        {

          hd->FileName.clear();

          if ((hd->Flags & LHD_UNICODE)!=0)

          {

            EncodeFileName NameCoder;

            size_t Length=strlen(FileName.data());

            Length++;

            if (ReadNameSize>Length)

              NameCoder.Decode(FileName.data(),ReadNameSize,

                               (byte *)&FileName[Length],

                               ReadNameSize-Length,hd->FileName);

          }

          if (hd->FileName.empty())

            ArcCharToWide(FileName.data(),hd->FileName,ACTW_OEM);

#ifndef SFX_MODULE

          ConvertNameCase(hd->FileName);

#endif

          ConvertFileHeader(hd);

        }

        else

        {

          CharToWide(FileName.data(),hd->FileName);

          // Calculate the size of optional data.

          int DataSize=int(hd->HeadSize-NameSize-SIZEOF_FILEHEAD3);

          if ((hd->Flags & LHD_SALT)!=0)

            DataSize-=SIZE_SALT30;

          if (DataSize>0)

          {

            // Here we read optional additional fields for subheaders.

            // They are stored after the file name and before salt.

            hd->SubData.resize(DataSize);

            Raw.GetB(hd->SubData.data(),DataSize);

          }

          if (hd->CmpName(SUBHEAD_TYPE_CMT))

            MainComment=true;

        }

        if ((hd->Flags & LHD_SALT)!=0)

          Raw.GetB(hd->Salt,SIZE_SALT30);

        hd->mtime.SetDos(FileTime);

        if ((hd->Flags & LHD_EXTTIME)!=0)

        {

          ushort Flags=Raw.Get2();

          RarTime *tbl[4];

          tbl[0]=&FileHead.mtime;

          tbl[1]=&FileHead.ctime;

          tbl[2]=&FileHead.atime;

          tbl[3]=NULL; // Archive time is not used now.

          for (int I=0;I<4;I++)

          {

            RarTime *CurTime=tbl[I];

            uint rmode=Flags>>(3-I)*4;

            if ((rmode & 8)==0 || CurTime==NULL)

              continue;

            if (I!=0)

            {

              uint DosTime=Raw.Get4();

              CurTime->SetDos(DosTime);

            }

            RarLocalTime rlt;

            CurTime->GetLocal(&rlt);

            if (rmode & 4)

              rlt.Second++;

            rlt.Reminder=0;

            uint count=rmode&3;

            for (uint J=0;J<count;J++)

            {

              byte CurByte=Raw.Get1();

              rlt.Reminder|=(((uint)CurByte)<<((J+3-count)*8));

            }

            // Convert from 100ns RAR precision to REMINDER_PRECISION.

            rlt.Reminder*=RarTime::REMINDER_PRECISION/10000000;

            CurTime->SetLocal(&rlt);

          }

        }

        // Set to 0 in case of overflow, so end of ReadHeader cares about it.

        NextBlockPos=SafeAdd(NextBlockPos,hd->PackSize,0);

        bool CRCProcessedOnly=hd->CommentInHeader;

        uint HeaderCRC=Raw.GetCRC15(CRCProcessedOnly);

        if (hd->HeadCRC!=HeaderCRC)

        {

          BrokenHeader=true;

          ErrHandler.SetErrorCode(RARX_WARNING);

          // If we have a broken encrypted header, we do not need to display

          // the error message here, because it will be displayed for such

          // headers later in this function. Also such headers are unlikely

          // to have anything sensible in file name field, so it is useless

          // to display the file name.

          if (!Decrypt)

            uiMsg(UIERROR_FHEADERBROKEN,Archive::FileName,hd->FileName);

        }

      }

      break;

    case HEAD_ENDARC:

      EndArcHead.SetBaseBlock(ShortBlock);

      EndArcHead.NextVolume=(EndArcHead.Flags & EARC_NEXT_VOLUME)!=0;

      EndArcHead.DataCRC=(EndArcHead.Flags & EARC_DATACRC)!=0;

      EndArcHead.RevSpace=(EndArcHead.Flags & EARC_REVSPACE)!=0;

      EndArcHead.StoreVolNumber=(EndArcHead.Flags & EARC_VOLNUMBER)!=0;

      if (EndArcHead.DataCRC)

        EndArcHead.ArcDataCRC=Raw.Get4();

      if (EndArcHead.StoreVolNumber)

        VolNumber=EndArcHead.VolNumber=Raw.Get2();

      break;

#ifndef SFX_MODULE

    case HEAD3_CMT:

      CommHead.SetBaseBlock(ShortBlock);

      CommHead.UnpSize=Raw.Get2();

      CommHead.UnpVer=Raw.Get1();

      CommHead.Method=Raw.Get1();

      CommHead.CommCRC=Raw.Get2();

      break;

    case HEAD3_PROTECT:

      ProtectHead.SetBaseBlock(ShortBlock);

      ProtectHead.DataSize=Raw.Get4();

      ProtectHead.Version=Raw.Get1();

      ProtectHead.RecSectors=Raw.Get2();

      ProtectHead.TotalBlocks=Raw.Get4();

      Raw.GetB(ProtectHead.Mark,8);

      NextBlockPos+=ProtectHead.DataSize;

      break;

    case HEAD3_OLDSERVICE: // RAR 2.9 and earlier.

      SubBlockHead.SetBaseBlock(ShortBlock);

      SubBlockHead.DataSize=Raw.Get4();

      NextBlockPos+=SubBlockHead.DataSize;

      SubBlockHead.SubType=Raw.Get2();

      SubBlockHead.Level=Raw.Get1();

      switch(SubBlockHead.SubType)

      {

        case NTACL_HEAD:

          *(SubBlockHeader *)&EAHead=SubBlockHead;

          EAHead.UnpSize=Raw.Get4();

          EAHead.UnpVer=Raw.Get1();

          EAHead.Method=Raw.Get1();

          EAHead.EACRC=Raw.Get4();

          break;

        case STREAM_HEAD:

          *(SubBlockHeader *)&StreamHead=SubBlockHead;

          StreamHead.UnpSize=Raw.Get4();

          StreamHead.UnpVer=Raw.Get1();

          StreamHead.Method=Raw.Get1();

          StreamHead.StreamCRC=Raw.Get4();

          StreamHead.StreamNameSize=Raw.Get2();

          const size_t MaxStreamName20=260; // Maximum allowed stream name in RAR 2.x format.

          if (StreamHead.StreamNameSize>MaxStreamName20)

            StreamHead.StreamNameSize=MaxStreamName20;

          StreamHead.StreamName.resize(StreamHead.StreamNameSize);

          Raw.GetB(&StreamHead.StreamName[0],StreamHead.StreamNameSize);

          break;

      }

      break;

#endif

    default:

      if (ShortBlock.Flags & LONG_BLOCK)

        NextBlockPos+=Raw.Get4();

      break;

  }

  uint HeaderCRC=Raw.GetCRC15(false);

  // Old AV header does not have header CRC properly set.

  // Old Unix owners header didn't include string fields into header size,

  // but included them into CRC, so it couldn't be verified with generic

  // approach here.

  if (ShortBlock.HeadCRC!=HeaderCRC && ShortBlock.HeaderType!=HEAD3_SIGN &&

      ShortBlock.HeaderType!=HEAD3_AV && 

      (ShortBlock.HeaderType!=HEAD3_OLDSERVICE || SubBlockHead.SubType!=UO_HEAD))

  {

    bool Recovered=false;

    if (ShortBlock.HeaderType==HEAD_ENDARC && EndArcHead.RevSpace)

    {

      // Last 7 bytes of recovered volume can contain zeroes, because

      // REV files store its own information (volume number, etc.) here.

      int64 Length=Tell();

      Seek(Length-7,SEEK_SET);

      Recovered=true;

      for (int J=0;J<7;J++)

        if (GetByte()!=0)

          Recovered=false;

    }

    if (!Recovered)

    {

      BrokenHeader=true;

      ErrHandler.SetErrorCode(RARX_CRC);

      if (Decrypt)

      {

        uiMsg(UIERROR_CHECKSUMENC,FileName,FileName);

        FailedHeaderDecryption=true;

        return 0;

      }

    }

  }

  return Raw.Size();

}

#endif // #ifndef SFX_MODULE

size_t Archive::ReadHeader50()

{

  RawRead Raw(this);

  bool Decrypt=Encrypted && CurBlockPos>(int64)SFXSize+SIZEOF_MARKHEAD5;

  if (Decrypt)

  {

#if defined(RAR_NOCRYPT)

    return 0;

#else

    if (Cmd->SkipEncrypted)

    {

      uiMsg(UIMSG_SKIPENCARC,FileName);

      FailedHeaderDecryption=true; // Suppress error messages and quit quietly.

      return 0;

    }

    byte HeadersInitV[SIZE_INITV];

    if (Read(HeadersInitV,SIZE_INITV)!=SIZE_INITV)

    {

      UnexpEndArcMsg();

      return 0;

    }

    // We repeat the password request only for manually entered passwords

    // and not for -p<pwd>. Wrong password can be intentionally provided

    // in -p<pwd> to not stop batch processing for encrypted archives.

    bool GlobalPassword=Cmd->Password.IsSet() || uiIsGlobalPasswordSet();

    RarCheckPassword CheckPwd;

    if (CryptHead.UsePswCheck && !BrokenHeader)

      CheckPwd.Set(CryptHead.Salt,HeadersInitV,CryptHead.Lg2Count,CryptHead.PswCheck);

    while (true) // Repeat the password prompt for wrong passwords.

    {

      RequestArcPassword(CheckPwd.IsSet() ? &CheckPwd:NULL);

      byte PswCheck[SIZE_PSWCHECK];

      bool EncSet=HeadersCrypt.SetCryptKeys(false,CRYPT_RAR50,&Cmd->Password,CryptHead.Salt,HeadersInitV,CryptHead.Lg2Count,NULL,PswCheck);

      // Verify password validity. If header is damaged, we cannot rely on

      // password check value, because it can be damaged too.

      if (EncSet && CryptHead.UsePswCheck && !BrokenHeader &&

          memcmp(PswCheck,CryptHead.PswCheck,SIZE_PSWCHECK)!=0)

      {

        if (GlobalPassword) // For -p<pwd> or Ctrl+P.

        {

          // This message is used by Android GUI to reset cached passwords.

          // Update appropriate code if changed.

          uiMsg(UIERROR_BADPSW,FileName,FileName);

          FailedHeaderDecryption=true;

          ErrHandler.SetErrorCode(RARX_BADPWD);

          return 0;

        }

        else // For passwords entered manually.

        {

          // This message is used by Android GUI and Windows GUI and SFX to

          // reset cached passwords. Update appropriate code if changed.

          uiMsg(UIWAIT_BADPSW,FileName,FileName);

          Cmd->Password.Clean();

        }

#ifdef RARDLL

        // Avoid new requests for unrar.dll to prevent the infinite loop

        // if app always returns the same password.

        ErrHandler.SetErrorCode(RARX_BADPWD);

        Cmd->DllError=ERAR_BAD_PASSWORD;

        ErrHandler.Exit(RARX_BADPWD);

#else

        continue; // Request a password again.

#endif

      }

      break;

    }

    Raw.SetCrypt(&HeadersCrypt);

#endif

  }

  // Header size must not occupy more than 3 variable length integer bytes

  // resulting in 2 MB maximum header size (MAX_HEADER_SIZE_RAR5),

  // so here we read 4 byte CRC32 followed by 3 bytes or less of header size.

  const size_t FirstReadSize=7; // Smallest possible block size.

  if (Raw.Read(FirstReadSize)<FirstReadSize)

  {

    UnexpEndArcMsg();

    return 0;

  }

  ShortBlock.Reset();

  ShortBlock.HeadCRC=Raw.Get4();

  uint SizeBytes=Raw.GetVSize(4);

  uint64 BlockSize=Raw.GetV();

  if (BlockSize==0 || SizeBytes==0)

  {

    BrokenHeaderMsg();

    return 0;

  }

  int SizeToRead=int(BlockSize);

  SizeToRead-=int(FirstReadSize-SizeBytes-4); // Adjust overread size bytes if any.

  uint HeaderSize=4+SizeBytes+(uint)BlockSize;

  if (SizeToRead<0 || HeaderSize<SIZEOF_SHORTBLOCKHEAD5)

  {

    BrokenHeaderMsg();

    return 0;

  }

  Raw.Read(SizeToRead);

  if (Raw.Size()<HeaderSize)

  {

    UnexpEndArcMsg();

    return 0;

  }

  uint HeaderCRC=Raw.GetCRC50();

  ShortBlock.HeaderType=(HEADER_TYPE)Raw.GetV();

  ShortBlock.Flags=(uint)Raw.GetV();

  ShortBlock.SkipIfUnknown=(ShortBlock.Flags & HFL_SKIPIFUNKNOWN)!=0;

  ShortBlock.HeadSize=HeaderSize;

  CurHeaderType=ShortBlock.HeaderType;

  bool BadCRC=(ShortBlock.HeadCRC!=HeaderCRC);

  if (BadCRC)

  {

    BrokenHeaderMsg(); // Report, but attempt to process.

    BrokenHeader=true;

    ErrHandler.SetErrorCode(RARX_CRC);

    if (Decrypt)

    {

      uiMsg(UIERROR_CHECKSUMENC,FileName,FileName);

      FailedHeaderDecryption=true;

      return 0;

    }

  }

  uint64 ExtraSize=0;

  if ((ShortBlock.Flags & HFL_EXTRA)!=0)

  {

    ExtraSize=Raw.GetV();

    if (ExtraSize>=ShortBlock.HeadSize)

    {

      BrokenHeaderMsg();

      return 0;

    }

  }

  uint64 DataSize=0;

  if ((ShortBlock.Flags & HFL_DATA)!=0)

    DataSize=Raw.GetV();

  NextBlockPos=CurBlockPos+FullHeaderSize(ShortBlock.HeadSize);

  // Set to 0 in case of overflow, so end of ReadHeader cares about it.

  NextBlockPos=SafeAdd(NextBlockPos,DataSize,0);

  switch(ShortBlock.HeaderType)

  {

    case HEAD_CRYPT:

      {

        CryptHead.SetBaseBlock(ShortBlock);

        uint CryptVersion=(uint)Raw.GetV();

        if (CryptVersion>CRYPT_VERSION)

        {

          UnkEncVerMsg(FileName,L"h" + std::to_wstring(CryptVersion));

          FailedHeaderDecryption=true;

          return 0;

        }

        uint EncFlags=(uint)Raw.GetV();

        CryptHead.UsePswCheck=(EncFlags & CHFL_CRYPT_PSWCHECK)!=0;

        CryptHead.Lg2Count=Raw.Get1();

        if (CryptHead.Lg2Count>CRYPT5_KDF_LG2_COUNT_MAX)

        {

          UnkEncVerMsg(FileName,L"hc" + std::to_wstring(CryptHead.Lg2Count));

          FailedHeaderDecryption=true;

          return 0;

        }

        Raw.GetB(CryptHead.Salt,SIZE_SALT50);

        if (CryptHead.UsePswCheck)

        {

          Raw.GetB(CryptHead.PswCheck,SIZE_PSWCHECK);

          byte csum[SIZE_PSWCHECK_CSUM];

          Raw.GetB(csum,SIZE_PSWCHECK_CSUM);

// Exclude this code for rarext.dll, Setup.SFX and unrar_nocrypt.dll linked

// without sha256. But still set Encrypted=true for rarext.dll here,

// so it can recognize encrypted header archives in archive properties.

#ifndef RAR_NOCRYPT

          byte Digest[SHA256_DIGEST_SIZE];

          sha256_get(CryptHead.PswCheck, SIZE_PSWCHECK, Digest);

          CryptHead.UsePswCheck=memcmp(csum,Digest,SIZE_PSWCHECK_CSUM)==0;

#endif

        }

        Encrypted=true;

      }

      break;

    case HEAD_MAIN:

      {

        MainHead.Reset();

        MainHead.SetBaseBlock(ShortBlock);

        uint ArcFlags=(uint)Raw.GetV();

        Volume=(ArcFlags & MHFL_VOLUME)!=0;

        Solid=(ArcFlags & MHFL_SOLID)!=0;

        Locked=(ArcFlags & MHFL_LOCK)!=0;

        Protected=(ArcFlags & MHFL_PROTECT)!=0;

        Signed=false;

        NewNumbering=true;

        if ((ArcFlags & MHFL_VOLNUMBER)!=0)

          VolNumber=(uint)Raw.GetV();

        else

          VolNumber=0;

        FirstVolume=Volume && VolNumber==0;

        if (ExtraSize!=0)

          ProcessExtra50(&Raw,(size_t)ExtraSize,&MainHead);

#ifdef USE_QOPEN

        if (!ProhibitQOpen && MainHead.Locator && MainHead.QOpenOffset>0 && Cmd->QOpenMode!=QOPEN_NONE)

        {

          // We seek to QO block in the end of archive when processing

          // QOpen.Load, so we need to preserve current block positions

          // to not break normal archive processing by calling function.

          int64 SaveCurBlockPos=CurBlockPos,SaveNextBlockPos=NextBlockPos;

          HEADER_TYPE SaveCurHeaderType=CurHeaderType;

          QOpen.Init(this,false);

          QOpen.Load(MainHead.QOpenOffset);

          CurBlockPos=SaveCurBlockPos;

          NextBlockPos=SaveNextBlockPos;

          CurHeaderType=SaveCurHeaderType;

        }

#endif

      }

      break;

    case HEAD_FILE:

    case HEAD_SERVICE:

      {

        FileHeader *hd=ShortBlock.HeaderType==HEAD_FILE ? &FileHead:&SubHead;

        hd->Reset(); // Clear hash, time fields and other stuff like flags.

        *(BaseBlock *)hd=ShortBlock;

        bool FileBlock=ShortBlock.HeaderType==HEAD_FILE;

        hd->LargeFile=true;

        hd->PackSize=DataSize;

        hd->FileFlags=(uint)Raw.GetV();

        hd->UnpSize=Raw.GetV();

        hd->UnknownUnpSize=(hd->FileFlags & FHFL_UNPUNKNOWN)!=0;

        if (hd->UnknownUnpSize)

          hd->UnpSize=INT64NDF;

        hd->MaxSize=Max(hd->PackSize,hd->UnpSize);

        hd->FileAttr=(uint)Raw.GetV();

        if ((hd->FileFlags & FHFL_UTIME)!=0)

          hd->mtime.SetUnix((time_t)Raw.Get4());

        hd->FileHash.Type=HASH_NONE;

        if ((hd->FileFlags & FHFL_CRC32)!=0)

        {

          hd->FileHash.Type=HASH_CRC32;

          hd->FileHash.CRC32=Raw.Get4();

        }

        hd->RedirType=FSREDIR_NONE;

        uint CompInfo=(uint)Raw.GetV();

        hd->Method=(CompInfo>>7) & 7;

        // "+ 50" to not mix with old RAR format algorithms. For example,

        // we may need to use the compression algorithm 15 in the future,

        // but it was already used in RAR 1.5 and Unpack needs to distinguish

        // them.

        uint UnpVer=(CompInfo & 0x3f);

        if (UnpVer==0)

          hd->UnpVer=VER_PACK5;

        else

          if (UnpVer==1)

            hd->UnpVer=VER_PACK7;

          else

            hd->UnpVer=VER_UNKNOWN;

        hd->HostOS=(byte)Raw.GetV();

        size_t NameSize=(size_t)Raw.GetV();

        hd->Inherited=(ShortBlock.Flags & HFL_INHERITED)!=0;

        hd->HSType=HSYS_UNKNOWN;

        if (hd->HostOS==HOST5_UNIX)

          hd->HSType=HSYS_UNIX;

        else

          if (hd->HostOS==HOST5_WINDOWS)

            hd->HSType=HSYS_WINDOWS;

        hd->SplitBefore=(hd->Flags & HFL_SPLITBEFORE)!=0;

        hd->SplitAfter=(hd->Flags & HFL_SPLITAFTER)!=0;

        hd->SubBlock=(hd->Flags & HFL_CHILD)!=0;

        hd->Solid=FileBlock && (CompInfo & FCI_SOLID)!=0;

        hd->Dir=(hd->FileFlags & FHFL_DIRECTORY)!=0;

        if (hd->Dir || UnpVer>1)

          hd->WinSize=0;

        else

        {

          hd->WinSize=0x20000ULL<<((CompInfo>>10)&(UnpVer==0 ? 0x0f:0x1f));

          if (UnpVer==1)

          {

            hd->WinSize+=hd->WinSize/32*((CompInfo>>15)&0x1f);

            // RAR7 header with RAR5 compression. Needed to append RAR7 files

            // to RAR5 solid stream if new dictionary is larger than existing.

            if ((CompInfo & FCI_RAR5_COMPAT)!=0)

              hd->UnpVer=VER_PACK5;

            if (hd->WinSize>UNPACK_MAX_DICT)

              hd->UnpVer=VER_UNKNOWN;

          }

        }

        size_t ReadNameSize=Min(NameSize,MAXPATHSIZE);

        std::string FileName(ReadNameSize,0);

        Raw.GetB((byte *)&FileName[0],ReadNameSize);

        UtfToWide(FileName.data(),hd->FileName);

        // Should do it before converting names, because extra fields can

        // affect name processing, like in case of NTFS streams.

        if (ExtraSize!=0)

          ProcessExtra50(&Raw,(size_t)ExtraSize,hd);

        if (FileBlock)

        {

#ifndef SFX_MODULE

          ConvertNameCase(hd->FileName);

#endif

          ConvertFileHeader(hd);

        }

        if (!FileBlock && hd->CmpName(SUBHEAD_TYPE_CMT))

          MainComment=true;

        if (BadCRC) // Add the file name to broken header message displayed above.

          uiMsg(UIERROR_FHEADERBROKEN,Archive::FileName,hd->FileName);

      }

      break;

    case HEAD_ENDARC:

      {

        EndArcHead.SetBaseBlock(ShortBlock);

        uint ArcFlags=(uint)Raw.GetV();

        EndArcHead.NextVolume=(ArcFlags & EHFL_NEXTVOLUME)!=0;

        EndArcHead.StoreVolNumber=false;

        EndArcHead.DataCRC=false;

        EndArcHead.RevSpace=false;

      }

      break;

  }

  return Raw.Size();

}

#if !defined(RAR_NOCRYPT)

void Archive::RequestArcPassword(RarCheckPassword *CheckPwd)

{

  if (!Cmd->Password.IsSet())

  {

#ifdef RARDLL

    if (Cmd->Callback!=NULL)

    {

      wchar PasswordW[MAXPASSWORD];

      *PasswordW=0;

      if (Cmd->Callback(UCM_NEEDPASSWORDW,Cmd->UserData,(LPARAM)PasswordW,ASIZE(PasswordW))==-1)

        *PasswordW=0;

      if (*PasswordW==0)

      {

        char PasswordA[MAXPASSWORD];

        *PasswordA=0;

        if (Cmd->Callback(UCM_NEEDPASSWORD,Cmd->UserData,(LPARAM)PasswordA,ASIZE(PasswordA))==-1)

          *PasswordA=0;

        CharToWide(PasswordA,PasswordW,ASIZE(PasswordW));

        cleandata(PasswordA,sizeof(PasswordA));

      }

      Cmd->Password.Set(PasswordW);

      cleandata(PasswordW,sizeof(PasswordW));

    }

    if (!Cmd->Password.IsSet())

    {

      Close();

      Cmd->DllError=ERAR_MISSING_PASSWORD;

      ErrHandler.Exit(RARX_USERBREAK);

    }

#else

    if (!uiGetPassword(UIPASSWORD_ARCHIVE,FileName,&Cmd->Password,CheckPwd))

    {

      Close();

      uiMsg(UIERROR_INCERRCOUNT); // Prevent archive deleting if delete after extraction is on.

      ErrHandler.Exit(RARX_USERBREAK);

    }

#endif

    Cmd->ManualPassword=true;

  }

}

#endif

void Archive::ProcessExtra50(RawRead *Raw,size_t ExtraSize,const BaseBlock *bb)

{

  // Read extra data from the end of block skipping any fields before it.

  size_t ExtraStart=Raw->Size()-ExtraSize;

  if (ExtraStart<Raw->GetPos())

    return;

  Raw->SetPos(ExtraStart);

  while (Raw->DataLeft()>=2)

  {

    int64 FieldSize=Raw->GetV(); // Needs to be signed for check below and can be negative.

    if (FieldSize<=0 || Raw->DataLeft()==0 || FieldSize>(int64)Raw->DataLeft())

      break;

    size_t NextPos=size_t(Raw->GetPos()+FieldSize);

    uint64 FieldType=Raw->GetV();

    FieldSize=int64(NextPos-Raw->GetPos()); // Field size without size and type fields.

    if (FieldSize<0) // FieldType is longer than expected extra field size.

      break;

    if (bb->HeaderType==HEAD_MAIN)

    {

      MainHeader *hd=(MainHeader *)bb;

      switch(FieldType)

      {

        case MHEXTRA_LOCATOR:

          {

            hd->Locator=true;

            uint Flags=(uint)Raw->GetV();

            if ((Flags & MHEXTRA_LOCATOR_QLIST)!=0)

            {

              uint64 Offset=Raw->GetV();

              if (Offset!=0) // 0 means that reserved space was not enough to write the offset.

                hd->QOpenOffset=Offset+CurBlockPos;

            }

            if ((Flags & MHEXTRA_LOCATOR_RR)!=0)

            {

              uint64 Offset=Raw->GetV();

              if (Offset!=0) // 0 means that reserved space was not enough to write the offset.

                hd->RROffset=Offset+CurBlockPos;