arcread.cpp

source code for unrar3.3.4,uppack the .rar files,for multi-os

          Raw.Get(StreamHead.UnpVer);
          Raw.Get(StreamHead.Method);
          Raw.Get(StreamHead.StreamCRC);
          Raw.Get(StreamHead.StreamNameSize);
          if (StreamHead.StreamNameSize>NM-1)
            StreamHead.StreamNameSize=NM-1;
          Raw.Get((byte *)StreamHead.StreamName,StreamHead.StreamNameSize);
          StreamHead.StreamName[StreamHead.StreamNameSize]=0;
          break;
      }
      break;
#endif
    default:
      if (ShortBlock.Flags & LONG_BLOCK)
      {
        uint DataSize;
        Raw.Get(DataSize);
        NextBlockPos+=DataSize;
      }
      break;
  }
  HeaderCRC=~Raw.GetCRC(false)&0xffff;
  CurHeaderType=ShortBlock.HeadType;
  if (Decrypt)
  {
    NextBlockPos+=Raw.PaddedSize()+SALT_SIZE;

    if (ShortBlock.HeadCRC!=HeaderCRC)
    {
      bool Recovered=false;
      if (ShortBlock.HeadType==ENDARC_HEAD && (EndArcHead.Flags & EARC_REVSPACE)!=0)
      {
        SaveFilePos SavePos(*this);
        Int64 Length=Tell();
        Seek(Length-7,SEEK_SET);
        Recovered=true;
        for (int J=0;J<7;J++)
          if (GetByte()!=0)
            Recovered=false;
      }
      if (!Recovered)
      {
#ifndef SILENT
        Log(FileName,St(MEncrBadCRC),FileName);
#endif
        Close();

        BrokenFileHeader=true;
        ErrHandler.SetErrorCode(CRC_ERROR);
        return(0);
//        ErrHandler.Exit(CRC_ERROR);
      }
    }
  }

  if (NextBlockPos<=CurBlockPos)
  {
#ifndef SHELL_EXT
    Log(FileName,St(MLogFileHead),"???");
#endif
    BrokenFileHeader=true;
    ErrHandler.SetErrorCode(CRC_ERROR);
    return(0);
  }
  return(Raw.Size());
}


#ifndef SFX_MODULE
int Archive::ReadOldHeader()
{
  RawRead Raw(this);
  if (CurBlockPos<=SFXSize)
  {
    Raw.Read(SIZEOF_OLDMHD);
    Raw.Get(OldMhd.Mark,4);
    Raw.Get(OldMhd.HeadSize);
    Raw.Get(OldMhd.Flags);
    NextBlockPos=CurBlockPos+OldMhd.HeadSize;
    CurHeaderType=MAIN_HEAD;
  }
  else
  {
    OldFileHeader OldLhd;
    Raw.Read(SIZEOF_OLDLHD);
    NewLhd.HeadType=FILE_HEAD;
    Raw.Get(NewLhd.PackSize);
    Raw.Get(NewLhd.UnpSize);
    Raw.Get(OldLhd.FileCRC);
    Raw.Get(NewLhd.HeadSize);
    Raw.Get(NewLhd.FileTime);
    Raw.Get(OldLhd.FileAttr);
    Raw.Get(OldLhd.Flags);
    Raw.Get(OldLhd.UnpVer);
    Raw.Get(OldLhd.NameSize);
    Raw.Get(OldLhd.Method);

    NewLhd.Flags=OldLhd.Flags|LONG_BLOCK;
    NewLhd.UnpVer=(OldLhd.UnpVer==2) ? 13 : 10;
    NewLhd.Method=OldLhd.Method+0x30;
    NewLhd.NameSize=OldLhd.NameSize;
    NewLhd.FileAttr=OldLhd.FileAttr;
    NewLhd.FileCRC=OldLhd.FileCRC;
    NewLhd.FullPackSize=NewLhd.PackSize;
    NewLhd.FullUnpSize=NewLhd.UnpSize;

    Raw.Read(OldLhd.NameSize);
    Raw.Get((byte *)NewLhd.FileName,OldLhd.NameSize);
    NewLhd.FileName[OldLhd.NameSize]=0;
    ConvertNameCase(NewLhd.FileName);
    *NewLhd.FileNameW=0;

    if (Raw.Size()!=0)
      NextBlockPos=CurBlockPos+NewLhd.HeadSize+NewLhd.PackSize;
    CurHeaderType=FILE_HEAD;
  }
  return(Raw.Size());
}
#endif


void Archive::ConvertNameCase(char *Name)
{
  if (Cmd->ConvertNames==NAMES_UPPERCASE)
  {
    IntToExt(Name,Name);
    strupper(Name);
    ExtToInt(Name,Name);
  }
  if (Cmd->ConvertNames==NAMES_LOWERCASE)
  {
    IntToExt(Name,Name);
    strlower(Name);
    ExtToInt(Name,Name);
  }
}


#ifndef SFX_MODULE
void Archive::ConvertNameCase(wchar *Name)
{
  if (Cmd->ConvertNames==NAMES_UPPERCASE)
    strupperw(Name);
  if (Cmd->ConvertNames==NAMES_LOWERCASE)
    strlowerw(Name);
}
#endif


bool Archive::IsArcDir()
{
  return((NewLhd.Flags & LHD_WINDOWMASK)==LHD_DIRECTORY);
}


bool Archive::IsArcLabel()
{
  return(NewLhd.HostOS<=HOST_WIN32 && (NewLhd.FileAttr & 8));
}


void Archive::ConvertAttributes()
{
#if defined(_WIN_32) || defined(_EMX)
  switch(NewLhd.HostOS)
  {
    case HOST_MSDOS:
    case HOST_OS2:
    case HOST_WIN32:
      break;
    case HOST_UNIX:
    case HOST_BEOS:
      if ((NewLhd.Flags & LHD_WINDOWMASK)==LHD_DIRECTORY)
        NewLhd.FileAttr=0x10;
      else
        NewLhd.FileAttr=0x20;
      break;
    default:
      if ((NewLhd.Flags & LHD_WINDOWMASK)==LHD_DIRECTORY)
        NewLhd.FileAttr=0x10;
      else
        NewLhd.FileAttr=0x20;
      break;
  }
#endif
#ifdef _UNIX
  static mode_t mask = (mode_t) -1;

  if (mask == (mode_t) -1)
  {
    mask = umask(022);
    umask(mask);
  }
  switch(NewLhd.HostOS)
  {
    case HOST_MSDOS:
    case HOST_OS2:
    case HOST_WIN32:
      if (NewLhd.FileAttr & 0x10)
        NewLhd.FileAttr=0x41ff & ~mask;
      else
        if (NewLhd.FileAttr & 1)
          NewLhd.FileAttr=0x8124 & ~mask;
        else
          NewLhd.FileAttr=0x81b6 & ~mask;
      break;
    case HOST_UNIX:
    case HOST_BEOS:
      break;
    default:
      if ((NewLhd.Flags & LHD_WINDOWMASK)==LHD_DIRECTORY)
        NewLhd.FileAttr=0x41ff & ~mask;
      else
        NewLhd.FileAttr=0x81b6 & ~mask;
      break;
  }
#endif
}


void Archive::ConvertUnknownHeader()
{
  if (NewLhd.UnpVer<20 && (NewLhd.FileAttr & 0x10))
    NewLhd.Flags|=LHD_DIRECTORY;
  if (NewLhd.HostOS>=HOST_MAX)
  {
    if ((NewLhd.Flags & LHD_WINDOWMASK)==LHD_DIRECTORY)
      NewLhd.FileAttr=0x10;
    else
      NewLhd.FileAttr=0x20;
  }
  for (char *s=NewLhd.FileName;*s!=0;s=charnext(s))
  {
    if (*s=='/' || *s=='\\')
      *s=CPATHDIVIDER;
#if defined(_APPLE) && !defined(UNICODE_SUPPORTED)
    if ((byte)*s<32 || (byte)*s>127)
      *s='_';
#endif
  }
  for (wchar *s=NewLhd.FileNameW;*s!=0;s++)
    if (*s=='/' || *s=='\\')
      *s=CPATHDIVIDER;
}


int Archive::LhdSize()
{
  return((NewLhd.Flags & LHD_LARGE) ? SIZEOF_NEWLHD+8:SIZEOF_NEWLHD);
}


int Archive::LhdExtraSize()
{
  return(NewLhd.HeadSize-NewLhd.NameSize-LhdSize());
}


#ifndef SHELL_EXT
bool Archive::ReadSubData(Array<byte> *UnpData,File *DestFile)
{
  if (HeaderCRC!=SubHead.HeadCRC)
  {
#ifndef SHELL_EXT
    Log(FileName,St(MSubHeadCorrupt));
#endif
    ErrHandler.SetErrorCode(CRC_ERROR);
    return(false);
  }
  if (SubHead.Method<0x30 || SubHead.Method>0x35 || SubHead.UnpVer>PACK_VER)
  {
#ifndef SHELL_EXT
    Log(FileName,St(MSubHeadUnknown));
#endif
    return(false);
  }

  if (SubHead.PackSize==0 && (SubHead.Flags & LHD_SPLIT_AFTER)==0)
    return(true);

  SubDataIO.Init();
  Unpack Unpack(&SubDataIO);
  Unpack.Init();

  if (DestFile==NULL)
  {
    UnpData->Alloc(SubHead.UnpSize);
    SubDataIO.SetUnpackToMemory(&(*UnpData)[0],SubHead.UnpSize);
  }
  if (SubHead.Flags & LHD_PASSWORD)
    if (*Cmd->Password)
      SubDataIO.SetEncryption(SubHead.UnpVer,Cmd->Password,
             (SubHead.Flags & LHD_SALT) ? SubHead.Salt:NULL,false);
    else
      return(false);
  SubDataIO.SetPackedSizeToRead(SubHead.PackSize);
  SubDataIO.EnableShowProgress(false);
  SubDataIO.SetFiles(this,DestFile);
  SubDataIO.UnpVolume=(SubHead.Flags & LHD_SPLIT_AFTER);
  SubDataIO.SetSubHeader(&SubHead,NULL);
  Unpack.SetDestSize(SubHead.UnpSize);
  if (SubHead.Method==0x30)
    CmdExtract::UnstoreFile(SubDataIO,SubHead.UnpSize);
  else
    Unpack.DoUnpack(SubHead.UnpVer,false);

  if (SubHead.FileCRC!=~SubDataIO.UnpFileCRC)
  {
#ifndef SHELL_EXT
    Log(FileName,St(MSubHeadDataCRC),SubHead.FileName);
#endif
    ErrHandler.SetErrorCode(CRC_ERROR);
    if (UnpData!=NULL)
      UnpData->Reset();
    return(false);
  }
  return(true);
}
#endif