bool File::RawSeek(Int64 Offset,int Method)
{
if (hFile==BAD_HANDLE)
return(true);
if (!is64plus(Offset) && Method!=SEEK_SET)
{
Offset=(Method==SEEK_CUR ? Tell():FileLength())+Offset;
Method=SEEK_SET;
}
#ifdef _WIN_32
LONG HighDist=int64to32(Offset>>32);
if (SetFilePointer(hFile,int64to32(Offset),&HighDist,Method)==0xffffffff &&
GetLastError()!=NO_ERROR)
return(false);
#else
LastWrite=false;
#ifdef _LARGEFILE_SOURCE
if (fseeko(hFile,Offset,Method)!=0)
#else
if (fseek(hFile,int64to32(Offset),Method)!=0)
#endif
return(false);
#endif
return(true);
}
static void execute_code(unpack_data_t *unpack_data, struct rarvm_prepared_program *prg)
{
rar_dbgmsg("in execute_code\n");
rar_dbgmsg("global_size: %ld\n", prg->global_size);
if (prg->global_size > 0) {
prg->init_r[6] = int64to32(unpack_data->written_size);
rarvm_set_value(0, (unsigned int *)&prg->global_data[0x24],
int64to32(unpack_data->written_size));
rarvm_set_value(0, (unsigned int *)&prg->global_data[0x28],
int64to32(unpack_data->written_size>>32));
rarvm_execute(&unpack_data->rarvm_data, prg);
}
void RarTime::SetRaw(Int64 RawTime)
{
#ifdef _WIN_32
FILETIME ft;
ft.dwHighDateTime=int64to32(RawTime>>32);
ft.dwLowDateTime=int64to32(RawTime);
*this=ft;
#elif defined(_UNIX) || defined(_EMX)
time_t ut=int64to32(RawTime/10000000);
*this=ut;
rlt.Reminder=int64to32(RawTime%10000000);
#endif
}
bool File::RawSeek(Int64 Offset,int Method)
{
/*if (hFile==BAD_HANDLE)
return(true);*/
/*if (!is64plus(Offset) && Method!=SEEK_SET)
{
Offset=(Method==SEEK_CUR ? Tell():FileLength())+Offset;
Method=SEEK_SET;
}*/
#if defined(_WIN_32) || defined(_LINUX)
//LONG HighDist=int64to32(Offset>>32);
//if (SetFilePointer(hFile,int64to32(Offset),&HighDist,Method)==0xffffffff &&
if (Offset > FileLength())
return false;
if (m_File.Seek(Offset,Method) < 0)
{
return(false);
}
#else
LastWrite=false;
#ifdef _LARGEFILE_SOURCE
if (fseeko(hFile,Offset,Method)!=0)
#else
if (fseek(hFile,int64to32(Offset),Method)!=0)
#endif
return(false);
#endif
return(true);
}
int ToPercent(Int64 N1,Int64 N2)
{
if (N2==0)
return(0);
if (N2<N1)
return(100);
return(int64to32(N1*100/N2));
}
uint SecondsToDosTime(uint Seconds)
{
#ifdef _WIN_32
FILETIME ft=SystemTime;
Int64 f=int32to64(ft.dwHighDateTime,ft.dwLowDateTime),s=Seconds;
f=f-s*10000000;
ft.dwHighDateTime=int64to32(f>>32);
ft.dwLowDateTime=int64to32(f);
return(NTTimeToDos(&ft));
#endif
#if defined(_UNIX) || defined(_EMX)
return(UnixTimeToDos(SystemTime-Seconds));
#endif
}
void CmdExtract::UnstoreFile(ComprDataIO &DataIO,Int64 DestUnpSize)
{
Array<byte> Buffer(0x10000);
while (1)
{
unsigned int Code=DataIO.UnpRead(&Buffer[0],Buffer.Size());
if (Code==0 || (int)Code==-1)
break;
Code=Code<DestUnpSize ? Code:int64to32(DestUnpSize);
DataIO.UnpWrite(&Buffer[0],Code);
if (DestUnpSize>=0)
DestUnpSize-=Code;
}
}
void CmdExtract::UnstoreFile(Int64 DestUnpSize)
{
Buffer.Alloc(Min(DestUnpSize,0x10000));
while (1)
{
unsigned int Code=DataIO.UnpRead(&Buffer[0],Buffer.Size());
if (Code==0 || (int)Code==-1)
break;
Code=Code<DestUnpSize ? Code:int64to32(DestUnpSize);
DataIO.UnpWrite(&Buffer[0],Code);
if (DestUnpSize>=0)
DestUnpSize-=Code;
}
Buffer.Reset();
}
long File::Copy(File &Dest,Int64 Length)
{
Array<char> Buffer(0x10000);
long CopySize=0;
bool CopyAll=(Length==INT64ERR);
while (CopyAll || Length>0)
{
Wait();
int SizeToRead=(!CopyAll && Length<Buffer.Size()) ? int64to32(Length):Buffer.Size();
int ReadSize=Read(&Buffer[0],SizeToRead);
if (ReadSize==0)
break;
Dest.Write(&Buffer[0],ReadSize);
CopySize+=ReadSize;
if (!CopyAll)
Length-=ReadSize;
}
return(CopySize);
}
uint CalcFileCRC(File *SrcFile,Int64 Size)
{
SaveFilePos SavePos(*SrcFile);
const int BufSize=0x10000;
Array<byte> Data(BufSize);
int ReadSize,BlockCount=0;
uint DataCRC=0xffffffff;
SrcFile->Seek(0,SEEK_SET);
while ((ReadSize=SrcFile->Read(&Data[0],int64to32(Size==INT64ERR ? Int64(BufSize):Min(Int64(BufSize),Size))))!=0)
{
if ((++BlockCount & 15)==0)
{
Wait();
}
DataCRC=CRC(DataCRC,&Data[0],ReadSize);
if (Size!=INT64ERR)
Size-=ReadSize;
}
return(DataCRC^0xffffffff);
}
void CommandData::ProcessSwitch(char *Switch)
{
switch(toupper(Switch[0]))
{
case 'I':
if (strnicomp(&Switch[1],"LOG",3)==0)
{
strncpy(LogName,Switch[4] ? Switch+4:DefLogName,sizeof(LogName));
break;
}
if (stricomp(&Switch[1],"SND")==0)
{
Sound=true;
break;
}
if (stricomp(&Switch[1],"ERR")==0)
{
MsgStream=MSG_STDERR;
break;
}
if (strnicomp(&Switch[1],"EML",3)==0)
{
strncpy(EmailTo,Switch[4] ? Switch+4:"@",sizeof(EmailTo));
EmailTo[sizeof(EmailTo)-1]=0;
break;
}
if (stricomp(&Switch[1],"NUL")==0)
{
MsgStream=MSG_NULL;
break;
}
if (toupper(Switch[1])=='D')
{
for (int I=2;Switch[I]!=0;I++)
switch(toupper(Switch[I]))
{
case 'Q':
MsgStream=MSG_ERRONLY;
break;
case 'C':
DisableCopyright=true;
break;
case 'D':
DisableDone=true;
break;
case 'P':
DisablePercentage=true;
break;
}
break;
}
if (stricomp(&Switch[1],"OFF")==0)
{
Shutdown=true;
break;
}
break;
case 'T':
switch(toupper(Switch[1]))
{
case 'K':
ArcTime=ARCTIME_KEEP;
break;
case 'L':
ArcTime=ARCTIME_LATEST;
break;
case 'O':
FileTimeBefore.SetAgeText(Switch+2);
break;
case 'N':
FileTimeAfter.SetAgeText(Switch+2);
break;
case 'B':
FileTimeBefore.SetIsoText(Switch+2);
break;
case 'A':
FileTimeAfter.SetIsoText(Switch+2);
break;
case 'S':
{
EXTTIME_MODE Mode=EXTTIME_HIGH3;
bool CommonMode=Switch[2]>='0' && Switch[2]<='4';
if (CommonMode)
Mode=(EXTTIME_MODE)(Switch[2]-'0');
if (Switch[2]=='-')
Mode=EXTTIME_NONE;
if (CommonMode || Switch[2]=='-' || Switch[2]=='+' || Switch[2]==0)
xmtime=xctime=xatime=Mode;
else
{
if (Switch[3]>='0' && Switch[3]<='4')
Mode=(EXTTIME_MODE)(Switch[3]-'0');
if (Switch[3]=='-')
Mode=EXTTIME_NONE;
switch(toupper(Switch[2]))
{
case 'M':
xmtime=Mode;
break;
case 'C':
xctime=Mode;
break;
case 'A':
xatime=Mode;
break;
case 'R':
xarctime=Mode;
break;
}
}
}
break;
case '-':
Test=false;
break;
case 0:
Test=true;
break;
default:
BadSwitch(Switch);
break;
}
break;
case 'A':
switch(toupper(Switch[1]))
{
case 'C':
ClearArc=true;
break;
case 'D':
AppendArcNameToPath=true;
break;
case 'G':
if (Switch[2]=='-' && Switch[3]==0)
GenerateArcName=0;
else
{
GenerateArcName=true;
strncpy(GenerateMask,Switch+2,sizeof(GenerateMask));
}
break;
case 'N': //reserved for archive name
break;
case 'O':
AddArcOnly=true;
break;
case 'P':
strcpy(ArcPath,Switch+2);
break;
case 'S':
SyncFiles=true;
break;
}
break;
case 'D':
if (Switch[2]==0)
switch(toupper(Switch[1]))
{
case 'S':
DisableSortSolid=true;
break;
case 'H':
OpenShared=true;
break;
case 'F':
DeleteFiles=true;
break;
}
break;
case 'O':
switch(toupper(Switch[1]))
{
case '+':
Overwrite=OVERWRITE_ALL;
break;
case '-':
Overwrite=OVERWRITE_NONE;
break;
case 'W':
ProcessOwners=true;
break;
#ifdef SAVE_LINKS
case 'L':
SaveLinks=true;
break;
#endif
#ifdef _WIN_32
case 'S':
SaveStreams=true;
break;
case 'C':
SetCompressedAttr=true;
break;
#endif
default :
BadSwitch(Switch);
break;
}
break;
case 'R':
switch(toupper(Switch[1]))
{
case 0:
Recurse=RECURSE_ALWAYS;
break;
case '-':
Recurse=0;
break;
case '0':
Recurse=RECURSE_WILDCARDS;
break;
case 'I':
{
Priority=atoi(Switch+2);
char *ChPtr=strchr(Switch+2,':');
if (ChPtr!=NULL)
{
SleepTime=atoi(ChPtr+1);
InitSystemOptions(SleepTime);
}
SetPriority(Priority);
}
break;
}
break;
case 'Y':
AllYes=true;
break;
case 'N':
case 'X':
if (Switch[1]!=0)
{
StringList *Args=toupper(Switch[0])=='N' ? InclArgs:ExclArgs;
if (Switch[1]=='@' && !IsWildcard(Switch))
ReadTextFile(Switch+2,Args,false,true,true,true,true);
else
Args->AddString(Switch+1);
}
break;
case 'E':
switch(toupper(Switch[1]))
{
case 'P':
switch(Switch[2])
{
case 0:
ExclPath=EXCL_SKIPWHOLEPATH;
break;
case '1':
ExclPath=EXCL_BASEPATH;
break;
case '2':
ExclPath=EXCL_SAVEFULLPATH;
break;
case '3':
ExclPath=EXCL_ABSPATH;
break;
}
break;
case 'D':
ExclEmptyDir=true;
break;
case 'E':
ProcessEA=false;
break;
case 'N':
NoEndBlock=true;
break;
default:
if (Switch[1]=='+')
{
InclFileAttr=GetExclAttr(&Switch[2]);
InclAttrSet=true;
}
else
ExclFileAttr=GetExclAttr(&Switch[1]);
break;
}
break;
case 'P':
if (Switch[1]==0)
{
GetPassword(PASSWORD_GLOBAL,NULL,Password,sizeof(Password));
eprintf("\n");
}
else
strncpy(Password,Switch+1,sizeof(Password));
break;
case 'H':
if (toupper(Switch[1])=='P')
{
EncryptHeaders=true;
if (Switch[2]!=0)
strncpy(Password,Switch+2,sizeof(Password));
else
if (*Password==0)
{
GetPassword(PASSWORD_GLOBAL,NULL,Password,sizeof(Password));
eprintf("\n");
}
}
break;
case 'Z':
strncpy(CommentFile,Switch[1]!=0 ? Switch+1:"stdin",sizeof(CommentFile));
break;
case 'M':
switch(toupper(Switch[1]))
{
case 'C':
{
char *Str=Switch+2;
if (*Str=='-')
for (int I=0;I<sizeof(FilterModes)/sizeof(FilterModes[0]);I++)
FilterModes[I].State=FILTER_DISABLE;
else
while (*Str)
{
int Param1=0,Param2=0;
FilterState State=FILTER_AUTO;
FilterType Type=FILTER_NONE;
if (isdigit(*Str))
{
Param1=atoi(Str);
while (isdigit(*Str))
Str++;
}
if (*Str==':' && isdigit(Str[1]))
{
Param2=atoi(++Str);
while (isdigit(*Str))
Str++;
}
switch(toupper(*(Str++)))
{
case 'T': Type=FILTER_PPM; break;
case 'E': Type=FILTER_E8; break;
case 'D': Type=FILTER_DELTA; break;
case 'A': Type=FILTER_AUDIO; break;
case 'C': Type=FILTER_RGB; break;
case 'I': Type=FILTER_ITANIUM; break;
case 'L': Type=FILTER_UPCASETOLOW; break;
}
if (*Str=='+' || *Str=='-')
State=*(Str++)=='+' ? FILTER_FORCE:FILTER_DISABLE;
FilterModes[Type].State=State;
FilterModes[Type].Param1=Param1;
FilterModes[Type].Param2=Param2;
}
}
break;
case 'M':
break;
case 'D':
{
if ((WinSize=atoi(&Switch[2]))==0)
WinSize=0x10000<<(toupper(Switch[2])-'A');
else
WinSize*=1024;
if (!CheckWinSize())
BadSwitch(Switch);
}
break;
case 'S':
{
char *Names=Switch+2,DefNames[512];
if (*Names==0)
{
strcpy(DefNames,DefaultStoreList);
Names=DefNames;
}
while (*Names!=0)
{
char *End=strchr(Names,';');
if (End!=NULL)
*End=0;
if (*Names=='.')
Names++;
char Mask[NM];
if (strpbrk(Names,"*?.")==NULL)
sprintf(Mask,"*.%s",Names);
else
strcpy(Mask,Names);
StoreArgs->AddString(Mask);
if (End==NULL)
break;
Names=End+1;
}
}
break;
default:
Method=Switch[1]-'0';
if (Method>5 || Method<0)
BadSwitch(Switch);
break;
}
break;
case 'V':
switch(toupper(Switch[1]))
{
#ifdef _WIN_32
case 'D':
EraseDisk=true;
break;
#endif
case 'N':
OldNumbering=true;
break;
case 'P':
VolumePause=true;
break;
case 'E':
if (toupper(Switch[2])=='R')
VersionControl=atoi(Switch+3)+1;
break;
case '-':
VolSize=0;
break;
default:
{
Int64 NewVolSize=atoil(&Switch[1]);
if (NewVolSize==0)
NewVolSize=INT64ERR;
else
switch (Switch[strlen(Switch)-1])
{
case 'f':
case 'F':
switch(int64to32(NewVolSize))
{
case 360:
NewVolSize=362496;
break;
case 720:
NewVolSize=730112;
break;
case 1200:
NewVolSize=1213952;
break;
case 1440:
NewVolSize=1457664;
break;
case 2880:
NewVolSize=2915328;
break;
}
break;
case 'k':
NewVolSize*=1024;
break;
case 'm':
NewVolSize*=1024*1024;
break;
case 'M':
NewVolSize*=1000*1000;
break;
case 'g':
NewVolSize*=1024*1024;
NewVolSize*=1024;
break;
case 'G':
NewVolSize*=1000*1000;
NewVolSize*=1000;
break;
case 'b':
case 'B':
break;
default:
NewVolSize*=1000;
break;
}
if (VolSize==0)
VolSize=NewVolSize;
else
NextVolSizes.Push(NewVolSize);
}
break;
}
break;
case 'F':
if (Switch[1]==0)
FreshFiles=true;
break;
case 'U':
if (Switch[1]==0)
UpdateFiles=true;
break;
case 'W':
strncpy(TempPath,&Switch[1],sizeof(TempPath)-1);
AddEndSlash(TempPath);
break;
case 'S':
if (strnicomp(Switch,"SFX",3)==0)
{
const char *SFXName=Switch[3] ? Switch+3:DefSFXName;
if (PointToName(SFXName)!=SFXName || FileExist(SFXName))
strcpy(SFXModule,SFXName);
else
GetConfigName(SFXName,SFXModule,true);
}
if (isdigit(Switch[1]))
{
Solid|=SOLID_COUNT;
SolidCount=atoi(&Switch[1]);
}
else
switch(toupper(Switch[1]))
{
case 0:
Solid|=SOLID_NORMAL;
break;
case '-':
Solid=SOLID_NONE;
break;
case 'E':
Solid|=SOLID_FILEEXT;
break;
case 'V':
Solid|=Switch[2]=='-' ? SOLID_VOLUME_DEPENDENT:SOLID_VOLUME_INDEPENDENT;
break;
case 'D':
Solid|=SOLID_VOLUME_DEPENDENT;
break;
}
break;
case 'C':
if (Switch[2]==0)
switch(toupper(Switch[1]))
{
case '-':
DisableComment=true;
break;
case 'U':
ConvertNames=NAMES_UPPERCASE;
break;
case 'L':
ConvertNames=NAMES_LOWERCASE;
break;
}
break;
case 'K':
switch(toupper(Switch[1]))
{
case 'B':
KeepBroken=true;
break;
case 0:
Lock=true;
break;
}
break;
#ifndef GUI
case '?' :
OutHelp();
break;
#endif
default :
BadSwitch(Switch);
break;
}
}
int Archive::ReadHeader()
{
CurBlockPos=Tell();
#ifndef SFX_MODULE
if (OldFormat)
return(ReadOldHeader());
#endif
RawRead Raw(this);
bool Decrypt=Encrypted && CurBlockPos>=SFXSize+SIZEOF_MARKHEAD+SIZEOF_NEWMHD;
if (Decrypt)
{
#if defined(SHELL_EXT) || defined(NOCRYPT)
return(0);
#else
if (Read(HeadersSalt,SALT_SIZE)!=SALT_SIZE)
return(0);
if (*Cmd->Password==0)
#ifdef RARDLL
if (Cmd->Callback==NULL ||
Cmd->Callback(UCM_NEEDPASSWORD,Cmd->UserData,(LPARAM)Cmd->Password,sizeof(Cmd->Password))==-1)
{
Close();
ErrHandler.Exit(USER_BREAK);
}
#else
if (!GetPassword(PASSWORD_ARCHIVE,FileName,Cmd->Password,sizeof(Cmd->Password)))
{
Close();
ErrHandler.Exit(USER_BREAK);
}
#endif
HeadersCrypt.SetCryptKeys(Cmd->Password,HeadersSalt,false,false,NewMhd.EncryptVer>=36);
Raw.SetCrypt(&HeadersCrypt);
#endif
}
Raw.Read(SIZEOF_SHORTBLOCKHEAD);
if (Raw.Size()==0)
{
Int64 ArcSize=FileLength();
if (CurBlockPos>ArcSize || NextBlockPos>ArcSize)
{
#ifndef SHELL_EXT
Log(FileName,St(MLogUnexpEOF));
#endif
ErrHandler.SetErrorCode(WARNING);
}
return(0);
}
Raw.Get(ShortBlock.HeadCRC);
byte HeadType;
Raw.Get(HeadType);
ShortBlock.HeadType=(HEADER_TYPE)HeadType;
Raw.Get(ShortBlock.Flags);
Raw.Get(ShortBlock.HeadSize);
if (ShortBlock.HeadSize<SIZEOF_SHORTBLOCKHEAD)
{
#ifndef SHELL_EXT
Log(FileName,St(MLogFileHead),"???");
#endif
BrokenFileHeader=true;
ErrHandler.SetErrorCode(CRC_ERROR);
return(0);
}
if (ShortBlock.HeadType==COMM_HEAD)
Raw.Read(SIZEOF_COMMHEAD-SIZEOF_SHORTBLOCKHEAD);
else
if (ShortBlock.HeadType==MAIN_HEAD && (ShortBlock.Flags & MHD_COMMENT)!=0)
Raw.Read(SIZEOF_NEWMHD-SIZEOF_SHORTBLOCKHEAD);
else
Raw.Read(ShortBlock.HeadSize-SIZEOF_SHORTBLOCKHEAD);
NextBlockPos=CurBlockPos+ShortBlock.HeadSize;
switch(ShortBlock.HeadType)
{
case MAIN_HEAD:
*(BaseBlock *)&NewMhd=ShortBlock;
Raw.Get(NewMhd.HighPosAV);
Raw.Get(NewMhd.PosAV);
if (NewMhd.Flags & MHD_ENCRYPTVER)
Raw.Get(NewMhd.EncryptVer);
break;
case ENDARC_HEAD:
*(BaseBlock *)&EndArcHead=ShortBlock;
if (EndArcHead.Flags & EARC_DATACRC)
Raw.Get(EndArcHead.ArcDataCRC);
if (EndArcHead.Flags & EARC_VOLNUMBER)
Raw.Get(EndArcHead.VolNumber);
break;
case FILE_HEAD:
case NEWSUB_HEAD:
{
FileHeader *hd=ShortBlock.HeadType==FILE_HEAD ? &NewLhd:&SubHead;
*(BaseBlock *)hd=ShortBlock;
Raw.Get(hd->PackSize);
Raw.Get(hd->UnpSize);
Raw.Get(hd->HostOS);
Raw.Get(hd->FileCRC);
Raw.Get(hd->FileTime);
Raw.Get(hd->UnpVer);
Raw.Get(hd->Method);
Raw.Get(hd->NameSize);
Raw.Get(hd->FileAttr);
if (hd->Flags & LHD_LARGE)
{
Raw.Get(hd->HighPackSize);
Raw.Get(hd->HighUnpSize);
}
else
{
hd->HighPackSize=hd->HighUnpSize=0;
if (hd->UnpSize==0xffffffff)
{
hd->UnpSize=int64to32(INT64MAX);
hd->HighUnpSize=int64to32(INT64MAX>>32);
}
}
hd->FullPackSize=int32to64(hd->HighPackSize,hd->PackSize);
hd->FullUnpSize=int32to64(hd->HighUnpSize,hd->UnpSize);
char FileName[NM*4];
int NameSize=Min(hd->NameSize,sizeof(FileName)-1);
Raw.Get((byte *)FileName,NameSize);
FileName[NameSize]=0;
strncpyz(hd->FileName,FileName,ASIZE(hd->FileName));
if (hd->HeadType==NEWSUB_HEAD)
{
int DataSize=hd->HeadSize-hd->NameSize-SIZEOF_NEWLHD;
if (hd->Flags & LHD_SALT)
DataSize-=SALT_SIZE;
if (DataSize>0)
{
hd->SubData.Alloc(DataSize);
Raw.Get(&hd->SubData[0],DataSize);
if (hd->CmpName(SUBHEAD_TYPE_RR))
{
byte *D=&hd->SubData[8];
RecoverySectors=D[0]+((uint)D[1]<<8)+((uint)D[2]<<16)+((uint)D[3]<<24);
}
}
}
else
if (hd->HeadType==FILE_HEAD)
{
if (hd->Flags & LHD_UNICODE)
{
EncodeFileName NameCoder;
int Length=strlen(FileName);
if (Length==hd->NameSize)
{
UtfToWide(FileName,hd->FileNameW,sizeof(hd->FileNameW)/sizeof(hd->FileNameW[0])-1);
WideToChar(hd->FileNameW,hd->FileName,sizeof(hd->FileName)/sizeof(hd->FileName[0])-1);
ExtToInt(hd->FileName,hd->FileName);
}
else
{
Length++;
NameCoder.Decode(FileName,(byte *)FileName+Length,
hd->NameSize-Length,hd->FileNameW,
sizeof(hd->FileNameW)/sizeof(hd->FileNameW[0]));
}
if (*hd->FileNameW==0)
hd->Flags &= ~LHD_UNICODE;
}
else
*hd->FileNameW=0;
#ifndef SFX_MODULE
ConvertNameCase(hd->FileName);
ConvertNameCase(hd->FileNameW);
#endif
ConvertUnknownHeader();
}
if (hd->Flags & LHD_SALT)
Raw.Get(hd->Salt,SALT_SIZE);
hd->mtime.SetDos(hd->FileTime);
hd->ctime.Reset();
hd->atime.Reset();
hd->arctime.Reset();
if (hd->Flags & LHD_EXTTIME)
{
ushort Flags;
Raw.Get(Flags);
RarTime *tbl[4];
tbl[0]=&NewLhd.mtime;
tbl[1]=&NewLhd.ctime;
tbl[2]=&NewLhd.atime;
tbl[3]=&NewLhd.arctime;
for (int I=0;I<4;I++)
{
RarTime *CurTime=tbl[I];
uint rmode=Flags>>(3-I)*4;
if ((rmode & 8)==0)
continue;
if (I!=0)
{
uint DosTime;
Raw.Get(DosTime);
CurTime->SetDos(DosTime);
}
RarLocalTime rlt;
CurTime->GetLocal(&rlt);
if (rmode & 4)
rlt.Second++;
rlt.Reminder=0;
int count=rmode&3;
for (int J=0;J<count;J++)
{
byte CurByte;
Raw.Get(CurByte);
rlt.Reminder|=(((uint)CurByte)<<((J+3-count)*8));
}
CurTime->SetLocal(&rlt);
}
}
NextBlockPos+=hd->FullPackSize;
bool CRCProcessedOnly=(hd->Flags & LHD_COMMENT)!=0;
HeaderCRC=~Raw.GetCRC(CRCProcessedOnly)&0xffff;
if (hd->HeadCRC!=HeaderCRC)
{
if (hd->HeadType==NEWSUB_HEAD)
strcat(hd->FileName,"- ???");
BrokenFileHeader=true;
ErrHandler.SetErrorCode(WARNING);
#ifndef SHELL_EXT
Log(Archive::FileName,St(MLogFileHead),IntNameToExt(hd->FileName));
Alarm();
#endif
}
}
int ComprDataIO::UnpRead(byte *Addr,uint Count)
{
int RetCode=0,TotalRead=0;
byte *ReadAddr;
ReadAddr=Addr;
while (Count > 0)
{
Archive *SrcArc=(Archive *)SrcFile;
uint ReadSize=(Count>UnpPackedSize) ? int64to32(UnpPackedSize):Count;
if (UnpackFromMemory)
{
memcpy(Addr,UnpackFromMemoryAddr,UnpackFromMemorySize);
RetCode=UnpackFromMemorySize;
UnpackFromMemorySize=0;
}
else
{
if (!SrcFile->IsOpened())
return(-1);
RetCode=SrcFile->Read(ReadAddr,ReadSize);
FileHeader *hd=SubHead!=NULL ? SubHead:&SrcArc->NewLhd;
if (hd->Flags & LHD_SPLIT_AFTER)
PackedCRC=CRC(PackedCRC,ReadAddr,ReadSize);
}
CurUnpRead+=RetCode;
ReadAddr+=RetCode;
TotalRead+=RetCode;
Count-=RetCode;
UnpPackedSize-=RetCode;
if (UnpPackedSize == 0 && UnpVolume)
{
#ifndef NOVOLUME
if (!MergeArchive(*SrcArc,this,true,CurrentCommand))
#endif
{
NextVolumeMissing=true;
return(-1);
}
}
else
break;
}
Archive *SrcArc=(Archive *)SrcFile;
if (SrcArc!=NULL)
ShowUnpRead(SrcArc->CurBlockPos+CurUnpRead,UnpArcSize);
if (RetCode!=-1)
{
RetCode=TotalRead;
#ifndef NOCRYPT
if (Decryption)
#ifndef SFX_MODULE
if (Decryption<20)
Decrypt.Crypt(Addr,RetCode,(Decryption==15) ? NEW_CRYPT : OLD_DECODE);
else
if (Decryption==20)
for (uint I=0;I<RetCode;I+=16)
Decrypt.DecryptBlock20(&Addr[I]);
else
#endif
{
int CryptSize=(RetCode & 0xf)==0 ? RetCode:((RetCode & ~0xf)+16);
Decrypt.DecryptBlock(Addr,CryptSize);
}
#endif
}
Wait();
return(RetCode);
}
int ComprDataIO::UnpRead(byte *Addr,uint Count)
{
int RetCode=0,TotalRead=0;
byte *ReadAddr;
ReadAddr=Addr;
while (Count > 0)
{
Archive *SrcArc=(Archive *)SrcFile;
uint ReadSize=(Count>UnpPackedSize) ? int64to32(UnpPackedSize):Count;
if (UnpackFromMemory)
{
memcpy(Addr,UnpackFromMemoryAddr,UnpackFromMemorySize);
RetCode=UnpackFromMemorySize;
UnpackFromMemorySize=0;
}
else
{
bool bRead = true;
if (!SrcFile->IsOpened())
{
NextVolumeMissing = true;
return(-1);
}
if (UnpackToMemory)
if (hSeek->Wait(1)) // we are seeking
{
if (m_iSeekTo > CurUnpStart+SrcArc->NewLhd.FullPackSize) // need to seek outside this block
{
TotalRead += (int)(SrcArc->NextBlockPos-SrcFile->Tell());
CurUnpRead=CurUnpStart+SrcArc->NewLhd.FullPackSize;
UnpPackedSize=0;
RetCode = 0;
bRead = false;
}
else
{
Int64 iStartOfFile = SrcArc->NextBlockPos-SrcArc->NewLhd.FullPackSize;
m_iStartOfBuffer = CurUnpStart;
Int64 iSeekTo=m_iSeekTo-CurUnpStart<MAXWINMEMSIZE/2?iStartOfFile:iStartOfFile+m_iSeekTo-CurUnpStart-MAXWINMEMSIZE/2;
if (iSeekTo == iStartOfFile) // front
{
if (CurUnpStart+MAXWINMEMSIZE>SrcArc->NewLhd.FullUnpSize)
{
m_iSeekTo=iStartOfFile;
UnpPackedSize = SrcArc->NewLhd.FullPackSize;
}
else
{
m_iSeekTo=MAXWINMEMSIZE-(m_iSeekTo-CurUnpStart);
UnpPackedSize = SrcArc->NewLhd.FullPackSize - (m_iStartOfBuffer - CurUnpStart);
}
}
else
{
m_iStartOfBuffer = m_iSeekTo-MAXWINMEMSIZE/2; // front
if (m_iSeekTo+MAXWINMEMSIZE/2>SrcArc->NewLhd.FullUnpSize)
{
iSeekTo = iStartOfFile+SrcArc->NewLhd.FullPackSize-MAXWINMEMSIZE;
m_iStartOfBuffer = CurUnpStart+SrcArc->NewLhd.FullPackSize-MAXWINMEMSIZE;
m_iSeekTo = MAXWINMEMSIZE-(m_iSeekTo-m_iStartOfBuffer);
UnpPackedSize = MAXWINMEMSIZE;
}
else
{
m_iSeekTo=MAXWINMEMSIZE/2;
UnpPackedSize = SrcArc->NewLhd.FullPackSize - (m_iStartOfBuffer - CurUnpStart);
}
}
SrcFile->Seek(iSeekTo,SEEK_SET);
TotalRead = 0;
CurUnpRead = CurUnpStart + iSeekTo - iStartOfFile;
CurUnpWrite = SrcFile->Tell() - iStartOfFile + CurUnpStart;
hSeek->Reset();
hSeekDone->Signal();
}
}
if (bRead)
{
ReadSize=(Count>UnpPackedSize) ? int64to32(UnpPackedSize):Count;
RetCode=SrcFile->Read(ReadAddr,ReadSize);
FileHeader *hd=SubHead!=NULL ? SubHead:&SrcArc->NewLhd;
if (hd->Flags & LHD_SPLIT_AFTER)
{
PackedCRC=CRC(PackedCRC,ReadAddr,ReadSize);
}
}
}
CurUnpRead+=RetCode;
ReadAddr+=RetCode;
TotalRead+=RetCode;
Count-=RetCode;
UnpPackedSize-=RetCode;
if (UnpPackedSize == 0 && UnpVolume)
{
#ifndef NOVOLUME
if (!MergeArchive(*SrcArc,this,true,CurrentCommand))
#endif
{
NextVolumeMissing=true;
return(-1);
}
CurUnpStart = CurUnpRead;
/*if (m_pDlgProgress)
{
CURL url(SrcArc->FileName);
m_pDlgProgress->SetLine(0,url.GetWithoutUserDetails()); // update currently extracted rar file
m_pDlgProgress->Progress();
}*/
}
else
break;
}
Archive *SrcArc=(Archive *)SrcFile;
if (SrcArc!=NULL)
ShowUnpRead(SrcArc->CurBlockPos+CurUnpRead,UnpArcSize);
if (RetCode!=-1)
{
RetCode=TotalRead;
#ifndef NOCRYPT
if (Decryption)
{
#ifndef SFX_MODULE
if (Decryption<20)
Decrypt.Crypt(Addr,RetCode,(Decryption==15) ? NEW_CRYPT : OLD_DECODE);
else if (Decryption==20)
for (int I=0;I<RetCode;I+=16)
Decrypt.DecryptBlock20(&Addr[I]);
else
#endif
{
int CryptSize=(RetCode & 0xf)==0 ? RetCode:((RetCode & ~0xf)+16);
Decrypt.DecryptBlock(Addr,CryptSize);
}
}
#endif
}
Wait();
return(RetCode);
}
bool Archive::IsArchive(bool EnableBroken)
{
Encrypted=false;
#ifndef SFX_MODULE
if (IsDevice())
{
#ifndef SHELL_EXT
Log(FileName,St(MInvalidName),FileName);
#endif
return(false);
}
#endif
if (Read(MarkHead.Mark,SIZEOF_MARKHEAD)!=SIZEOF_MARKHEAD)
return(false);
SFXSize=0;
if (IsSignature(MarkHead.Mark))
{
if (OldFormat)
Seek(0,SEEK_SET);
}
else
{
Array<char> Buffer(0x40000);
long CurPos=int64to32(Tell());
int ReadSize=Read(&Buffer[0],Buffer.Size()-16);
for (int I=0;I<ReadSize;I++)
if (Buffer[I]==0x52 && IsSignature((byte *)&Buffer[I]))
{
SFXSize=CurPos+I;
Seek(SFXSize,SEEK_SET);
if (!OldFormat)
Read(MarkHead.Mark,SIZEOF_MARKHEAD);
break;
}
if (SFXSize==0)
return(false);
}
ReadHeader();
SeekToNext();
#ifndef SFX_MODULE
if (OldFormat)
{
NewMhd.Flags=OldMhd.Flags & 0x3f;
NewMhd.HeadSize=OldMhd.HeadSize;
}
else
#endif
{
if (HeaderCRC!=NewMhd.HeadCRC)
{
#ifndef SHELL_EXT
Log(FileName,St(MLogMainHead));
#endif
Alarm();
if (!EnableBroken)
return(false);
}
}
Volume=(NewMhd.Flags & MHD_VOLUME);
Solid=(NewMhd.Flags & MHD_SOLID)!=0;
MainComment=(NewMhd.Flags & MHD_COMMENT)!=0;
Locked=(NewMhd.Flags & MHD_LOCK)!=0;
Signed=(NewMhd.PosAV!=0);
Protected=(NewMhd.Flags & MHD_PROTECT)!=0;
Encrypted=(NewMhd.Flags & MHD_PASSWORD)!=0;
#ifdef RARDLL
SilentOpen=true;
#endif
if (!SilentOpen || !Encrypted)
{
SaveFilePos SavePos(*this);
Int64 SaveCurBlockPos=CurBlockPos,SaveNextBlockPos=NextBlockPos;
NotFirstVolume=false;
while (ReadHeader())
{
int HeaderType=GetHeaderType();
if (HeaderType==NEWSUB_HEAD)
{
if (SubHead.CmpName(SUBHEAD_TYPE_CMT))
MainComment=true;
if ((SubHead.Flags & LHD_SPLIT_BEFORE) ||
Volume && (NewMhd.Flags & MHD_FIRSTVOLUME)==0)
NotFirstVolume=true;
}
else
{
if (HeaderType==FILE_HEAD && ((NewLhd.Flags & LHD_SPLIT_BEFORE)!=0 ||
Volume && NewLhd.UnpVer>=29 && (NewMhd.Flags & MHD_FIRSTVOLUME)==0))
NotFirstVolume=true;
break;
}
SeekToNext();
}
CurBlockPos=SaveCurBlockPos;
NextBlockPos=SaveNextBlockPos;
}
return(true);
}
