int lan_sspmdwpic(utShmHead *psShmHead, int iFd,utMsgHead *psMsgHead){
int iReturn;
unsigned long lSid;
char caFile[256],caPath[128],caFilename[128],caSid[16];
unsigned int pic_time;
unsigned int time_def;
time_t now;
time(&now);
char opera[256] = "";
iReturn = utMsgGetSomeNVar(psMsgHead,1,
"file", UT_TYPE_STRING, 16, caSid);
sprintf(caPath,"/home/ncmysql/nw/online/screen/");
sprintf(caFilename,"%s.jpg",caSid);
sprintf(caFile,"%s%s",caPath,caFilename);
//printf("实时屏幕，下载图片：%s\n",caFile);
pic_time = GetFileAttr(caFile);
time_def = now - pic_time;;
if(time_def > 12){
sprintf(opera,"cp -f %s %s","/home/ncmysql/nw/online/screen/heiping.jpg",caFile);
system(opera);
}
utPltFileDownload(iFd,"image/jpeg",caPath,caFilename,caFilename);
return 0;
}
void CommandData::ProcessCommand()
{
#ifndef SFX_MODULE
const wchar *SingleCharCommands=L"FUADPXETK";
if (Command[0]!=0 && Command[1]!=0 && wcschr(SingleCharCommands,Command[0])!=NULL || *ArcName==0)
OutHelp(*Command==0 ? RARX_SUCCESS:RARX_USERERROR); // Return 'success' for 'rar' without parameters.
#ifdef _UNIX
if (GetExt(ArcName)==NULL && (!FileExist(ArcName) || IsDir(GetFileAttr(ArcName))))
wcsncatz(ArcName,L".rar",ASIZE(ArcName));
#else
if (GetExt(ArcName)==NULL)
wcsncatz(ArcName,L".rar",ASIZE(ArcName));
#endif
if (wcschr(L"AFUMD",*Command)==NULL)
{
if (GenerateArcName)
GenerateArchiveName(ArcName,ASIZE(ArcName),GenerateMask,false);
StringList ArcMasks;
ArcMasks.AddString(ArcName);
ScanTree Scan(&ArcMasks,Recurse,SaveSymLinks,SCAN_SKIPDIRS);
FindData FindData;
while (Scan.GetNext(&FindData)==SCAN_SUCCESS)
AddArcName(FindData.Name);
}
else
AddArcName(ArcName);
#endif
switch(Command[0])
{
case 'P':
case 'X':
case 'E':
case 'T':
case 'I':
{
CmdExtract Extract(this);
Extract.DoExtract();
}
break;
#ifndef SILENT
case 'V':
case 'L':
ListArchive(this);
break;
default:
OutHelp(RARX_USERERROR);
#endif
}
if (!BareOutput)
mprintf(L"\n");
}
void CommandData::ProcessCommand()
{
#ifndef SFX_MODULE
if (Command[1] && strchr("FUADPXETK",*Command)!=NULL || *ArcName==0)
OutHelp();
#ifdef _UNIX
if (GetExt(ArcName)==NULL && (!FileExist(ArcName) || IsDir(GetFileAttr(ArcName))))
strcat(ArcName,".rar");
#else
if (GetExt(ArcName)==NULL)
strcat(ArcName,".rar");
#endif
if (strchr("AFUMD",*Command)==NULL)
{
StringList ArcMasks;
ArcMasks.AddString(ArcName);
ScanTree Scan(&ArcMasks,Recurse,SaveLinks,SCAN_SKIPDIRS);
FindData FindData;
while (Scan.GetNext(&FindData)==SCAN_SUCCESS)
AddArcName(FindData.Name,FindData.NameW);
}
else
AddArcName(ArcName,NULL);
#endif
switch(Command[0])
{
case 'P':
case 'X':
case 'E':
case 'T':
case 'I':
{
CmdExtract Extract;
Extract.DoExtract(this);
}
break;
#if !defined(GUI) && !defined(SILENT)
case 'V':
case 'L':
ListArchive(this);
break;
default:
OutHelp();
#endif
}
#ifndef GUI
if (!BareOutput)
mprintf("\n");
#endif
}
void CommandData::ProcessCommand()
{
#ifndef SFX_MODULE
const char *SingleCharCommands="FUADPXETK";
if (Command[1] && strchr(SingleCharCommands,*Command)!=NULL || *ArcName==0)
OutHelp();
//get filename *ArcName
#ifdef _UNIX
if (GetExt(ArcName)==NULL && (!FileExist(ArcName) || IsDir(GetFileAttr(ArcName))))
strcat(ArcName,".rar");
#endif
//printf("test4 %c %s\n",*Command,ArcName);
//找文件，将ArcName传到FindData.Name
if (strchr("AFUMD",*Command)==NULL)
{
StringList ArcMasks;
ArcMasks.AddString(ArcName);
ScanTree Scan(&ArcMasks,Recurse,SaveLinks,SCAN_SKIPDIRS);
FindData FindData;
while (Scan.GetNext(&FindData)==SCAN_SUCCESS)
AddArcName(FindData.Name,FindData.NameW); //FindData.Name "ere.rar"
}
#endif
switch(Command[0])
{
case 'P':
case 'X':
case 'E':
case 'T':
case 'I':
{
printf("\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n");
CmdExtract Extract;
Extract.DoExtract(this);
printf("\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n");
}
break;
#ifndef SILENT
case 'V':
case 'L':
ListArchive(this);
break;
default:
OutHelp();
#endif
}
if (!BareOutput)
mprintf("\n");
}
bool FileExist(const wchar *Name)
{
#ifdef _WIN_ALL
return GetFileAttr(Name)!=0xffffffff;
#elif defined(ENABLE_ACCESS)
char NameA[NM];
WideToChar(Name,NameA,ASIZE(NameA));
return access(NameA,0)==0;
#else
FindData FD;
return FindFile::FastFind(Name,&FD);
#endif
}
char *
_PR_MD_READ_DIR(_MDDir *d, PRIntn flags)
{
PRUword numFiles = 1;
BOOL rv;
char *fileName;
USHORT fileAttr;
if ( d ) {
while (1) {
if (d->firstEntry) {
d->firstEntry = PR_FALSE;
rv = NO_ERROR;
} else {
rv = DosFindNext(d->d_hdl,
&(d->d_entry),
sizeof(d->d_entry),
&numFiles);
}
if (rv != NO_ERROR) {
break;
}
fileName = GetFileFromDIR(d);
fileAttr = GetFileAttr(d);
if ( (flags & PR_SKIP_DOT) &&
(fileName[0] == '.') && (fileName[1] == '\0'))
continue;
if ( (flags & PR_SKIP_DOT_DOT) &&
(fileName[0] == '.') && (fileName[1] == '.') &&
(fileName[2] == '\0'))
continue;
/*
* XXX
* Is this the correct definition of a hidden file on OS/2?
*/
if ((flags & PR_SKIP_NONE) && (fileAttr & FILE_HIDDEN))
return fileName;
else if ((flags & PR_SKIP_HIDDEN) && (fileAttr & FILE_HIDDEN))
continue;
return fileName;
}
PR_ASSERT(NO_ERROR != rv);
_PR_MD_MAP_READDIR_ERROR(rv);
return NULL;
}
PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
return NULL;
}
void ExtractUnixOwner20(Archive &Arc,const wchar *FileName)
{
char NameA[NM];
WideToChar(FileName,NameA,ASIZE(NameA));
if (Arc.BrokenHeader)
{
Log(Arc.FileName,St(MOwnersBroken),FileName);
ErrHandler.SetErrorCode(RARX_CRC);
return;
}
struct passwd *pw;
errno=0; // Required by getpwnam specification if we need to check errno.
if ((pw=getpwnam(Arc.UOHead.OwnerName))==NULL)
{
Log(Arc.FileName,St(MErrGetOwnerID),GetWide(Arc.UOHead.OwnerName));
ErrHandler.SysErrMsg();
ErrHandler.SetErrorCode(RARX_WARNING);
return;
}
uid_t OwnerID=pw->pw_uid;
struct group *gr;
errno=0; // Required by getgrnam specification if we need to check errno.
if ((gr=getgrnam(Arc.UOHead.GroupName))==NULL)
{
Log(Arc.FileName,St(MErrGetGroupID),GetWide(Arc.UOHead.GroupName));
ErrHandler.SysErrMsg();
ErrHandler.SetErrorCode(RARX_CRC);
return;
}
gid_t GroupID=gr->gr_gid;
#if defined(SAVE_LINKS) && !defined(_APPLE)
if (lchown(NameA,OwnerID,GroupID)!=0)
#else
if (chown(NameA,OwnerID,GroupID)!=0)
#endif
{
Log(Arc.FileName,St(MSetOwnersError),FileName);
ErrHandler.SetErrorCode(RARX_CREATE);
}
#ifndef NOFILECREATE
uint Attr=GetFileAttr(FileName);
SetFileAttr(FileName,Attr);
#endif
}
void ExtractUnixOwner30(Archive &Arc,const wchar *FileName)
{
char NameA[NM];
WideToChar(FileName,NameA,ASIZE(NameA));
char *OwnerName=(char *)&Arc.SubHead.SubData[0];
int OwnerSize=strlen(OwnerName)+1;
int GroupSize=Arc.SubHead.SubData.Size()-OwnerSize;
char GroupName[NM];
strncpy(GroupName,(char *)&Arc.SubHead.SubData[OwnerSize],GroupSize);
GroupName[GroupSize]=0;
struct passwd *pw;
if ((pw=getpwnam(OwnerName))==NULL)
{
Log(Arc.FileName,St(MErrGetOwnerID),GetWide(OwnerName));
ErrHandler.SetErrorCode(RARX_WARNING);
return;
}
uid_t OwnerID=pw->pw_uid;
struct group *gr;
if ((gr=getgrnam(GroupName))==NULL)
{
Log(Arc.FileName,St(MErrGetGroupID),GetWide(GroupName));
ErrHandler.SetErrorCode(RARX_WARNING);
return;
}
gid_t GroupID=gr->gr_gid;
#if defined(SAVE_LINKS) && !defined(_APPLE)
if (lchown(NameA,OwnerID,GroupID)!=0)
#else
if (chown(NameA,OwnerID,GroupID)!=0)
#endif
{
Log(Arc.FileName,St(MSetOwnersError),FileName);
ErrHandler.SetErrorCode(RARX_CREATE);
}
#ifndef NOFILECREATE
uint Attr=GetFileAttr(FileName);
SetFileAttr(FileName,Attr);
#endif
}
void ExtractUnixOwner(Archive &Arc,char *FileName)
{
if (Arc.HeaderCRC!=Arc.UOHead.HeadCRC)
{
Log(Arc.FileName,St(MOwnersBroken),FileName);
ErrHandler.SetErrorCode(RARX_CRC);
return;
}
struct passwd *pw;
errno=0; // Required by getpwnam specification if we need to check errno.
if ((pw=getpwnam(Arc.UOHead.OwnerName))==NULL)
{
Log(Arc.FileName,St(MErrGetOwnerID),Arc.UOHead.OwnerName);
ErrHandler.SysErrMsg();
ErrHandler.SetErrorCode(RARX_WARNING);
return;
}
uid_t OwnerID=pw->pw_uid;
struct group *gr;
errno=0; // Required by getgrnam specification if we need to check errno.
if ((gr=getgrnam(Arc.UOHead.GroupName))==NULL)
{
Log(Arc.FileName,St(MErrGetGroupID),Arc.UOHead.GroupName);
ErrHandler.SysErrMsg();
ErrHandler.SetErrorCode(RARX_CRC);
return;
}
uint Attr=GetFileAttr(FileName,NULL);
gid_t GroupID=gr->gr_gid;
#if defined(SAVE_LINKS) && !defined(_APPLE)
if (lchown(FileName,OwnerID,GroupID)!=0)
#else
if (chown(FileName,OwnerID,GroupID)!=0)
#endif
{
Log(Arc.FileName,St(MSetOwnersError),FileName);
ErrHandler.SetErrorCode(RARX_CREATE);
}
SetFileAttr(FileName,NULL,Attr);
}
void SetDirTime(const wchar *Name,RarTime *ftm,RarTime *ftc,RarTime *fta)
{
#ifdef _WIN_ALL
bool sm=ftm!=NULL && ftm->IsSet();
bool sc=ftc!=NULL && ftc->IsSet();
bool sa=fta!=NULL && fta->IsSet();
uint DirAttr=GetFileAttr(Name);
bool ResetAttr=(DirAttr!=0xffffffff && (DirAttr & FILE_ATTRIBUTE_READONLY)!=0);
if (ResetAttr)
SetFileAttr(Name,0);
HANDLE hFile=CreateFile(Name,GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,OPEN_EXISTING,FILE_FLAG_BACKUP_SEMANTICS,NULL);
if (hFile==INVALID_HANDLE_VALUE)
{
wchar LongName[NM];
if (GetWinLongPath(Name,LongName,ASIZE(LongName)))
hFile=CreateFile(LongName,GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,OPEN_EXISTING,FILE_FLAG_BACKUP_SEMANTICS,NULL);
}
if (hFile==INVALID_HANDLE_VALUE)
return;
FILETIME fm,fc,fa;
if (sm)
ftm->GetWin32(&fm);
if (sc)
ftc->GetWin32(&fc);
if (sa)
fta->GetWin32(&fa);
SetFileTime(hFile,sc ? &fc:NULL,sa ? &fa:NULL,sm ? &fm:NULL);
CloseHandle(hFile);
if (ResetAttr)
SetFileAttr(Name,DirAttr);
#endif
#if defined(_UNIX) || defined(_EMX)
File::SetCloseFileTimeByName(Name,ftm,fta);
#endif
}
void ExtractUnixOwnerNew(Archive &Arc,char *FileName)
{
char *OwnerName=(char *)&Arc.SubHead.SubData[0];
int OwnerSize=strlen(OwnerName)+1;
int GroupSize=Arc.SubHead.SubData.Size()-OwnerSize;
char GroupName[NM];
strncpy(GroupName,(char *)&Arc.SubHead.SubData[OwnerSize],GroupSize);
GroupName[GroupSize]=0;
struct passwd *pw;
if ((pw=getpwnam(OwnerName))==NULL)
{
Log(Arc.FileName,St(MErrGetOwnerID),OwnerName);
ErrHandler.SetErrorCode(WARNING);
return;
}
uid_t OwnerID=pw->pw_uid;
struct group *gr;
if ((gr=getgrnam(GroupName))==NULL)
{
Log(Arc.FileName,St(MErrGetGroupID),GroupName);
ErrHandler.SetErrorCode(CRC_ERROR);
return;
}
uint Attr=GetFileAttr(FileName,NULL);
gid_t GroupID=gr->gr_gid;
#if defined(SAVE_LINKS) && !defined(_APPLE)
if (lchown(FileName,OwnerID,GroupID)!=0)
#else
if (chown(FileName,OwnerID,GroupID)!=0)
#endif
{
Log(Arc.FileName,St(MSetOwnersError),FileName);
ErrHandler.SetErrorCode(CRC_ERROR);
}
SetFileAttr(FileName,NULL,Attr);
}
void ExtractUnixOwner(Archive &Arc,char *FileName)
{
if (Arc.HeaderCRC!=Arc.UOHead.HeadCRC)
{
Log(Arc.FileName,St(MOwnersBroken),FileName);
ErrHandler.SetErrorCode(CRC_ERROR);
return;
}
struct passwd *pw;
if ((pw=getpwnam(Arc.UOHead.OwnerName))==NULL)
{
Log(Arc.FileName,St(MErrGetOwnerID),Arc.UOHead.OwnerName);
ErrHandler.SetErrorCode(WARNING);
return;
}
uid_t OwnerID=pw->pw_uid;
struct group *gr;
if ((gr=getgrnam(Arc.UOHead.GroupName))==NULL)
{
Log(Arc.FileName,St(MErrGetGroupID),Arc.UOHead.GroupName);
ErrHandler.SetErrorCode(CRC_ERROR);
return;
}
uint Attr=GetFileAttr(FileName,NULL);
gid_t GroupID=gr->gr_gid;
#if defined(SAVE_LINKS) && !defined(_APPLE)
if (lchown(FileName,OwnerID,GroupID)!=0)
#else
if (chown(FileName,OwnerID,GroupID)!=0)
#endif
{
Log(Arc.FileName,St(MSetOwnersError),FileName);
ErrHandler.SetErrorCode(CRC_ERROR);
}
SetFileAttr(FileName,NULL,Attr);
}
void SetDirTime(const char *Name,const wchar *NameW,RarTime *ftm,RarTime *ftc,RarTime *fta)
{
#ifdef _WIN_32
if (!WinNT())
return;
bool sm=ftm!=NULL && ftm->IsSet();
bool sc=ftc!=NULL && ftc->IsSet();
bool sa=fta!=NULL && fta->IsSet();
unsigned int DirAttr=GetFileAttr(Name,NameW);
bool ResetAttr=(DirAttr!=0xffffffff && (DirAttr & FA_RDONLY)!=0);
if (ResetAttr)
SetFileAttr(Name,NameW,0);
wchar DirNameW[NM];
GetWideName(Name,NameW,DirNameW);
HANDLE hFile=CreateFileW(DirNameW,GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,OPEN_EXISTING,FILE_FLAG_BACKUP_SEMANTICS,NULL);
if (hFile==INVALID_HANDLE_VALUE)
return;
FILETIME fm,fc,fa;
if (sm)
ftm->GetWin32(&fm);
if (sc)
ftc->GetWin32(&fc);
if (sa)
fta->GetWin32(&fa);
SetFileTime(hFile,sc ? &fc:NULL,sa ? &fa:NULL,sm ? &fm:NULL);
CloseHandle(hFile);
if (ResetAttr)
SetFileAttr(Name,NameW,DirAttr);
#endif
#if defined(_UNIX) || defined(_EMX)
File::SetCloseFileTimeByName(Name,ftm,fta);
#endif
}
void CmdExtract::ExtrCreateDir(Archive &Arc,const wchar *ArcFileName)
{
if (Cmd->Test)
{
#ifndef GUI
mprintf(St(MExtrTestFile),ArcFileName);
mprintf(L" %s",St(MOk));
#endif
return;
}
MKDIR_CODE MDCode=MakeDir(DestFileName,!Cmd->IgnoreGeneralAttr,Arc.FileHead.FileAttr);
bool DirExist=false;
if (MDCode!=MKDIR_SUCCESS)
{
DirExist=FileExist(DestFileName);
if (DirExist && !IsDir(GetFileAttr(DestFileName)))
{
// File with name same as this directory exists. Propose user
// to overwrite it.
bool UserReject;
FileCreate(Cmd,NULL,DestFileName,ASIZE(DestFileName),&UserReject,Arc.FileHead.UnpSize,&Arc.FileHead.mtime);
DirExist=false;
}
if (!DirExist)
{
CreatePath(DestFileName,true);
MDCode=MakeDir(DestFileName,!Cmd->IgnoreGeneralAttr,Arc.FileHead.FileAttr);
if (MDCode!=MKDIR_SUCCESS)
{
wchar OrigName[ASIZE(DestFileName)];
wcsncpyz(OrigName,DestFileName,ASIZE(OrigName));
MakeNameUsable(DestFileName,true);
CreatePath(DestFileName,true);
MDCode=MakeDir(DestFileName,!Cmd->IgnoreGeneralAttr,Arc.FileHead.FileAttr);
#ifndef SFX_MODULE
if (MDCode==MKDIR_SUCCESS)
uiMsg(UIERROR_RENAMING,Arc.FileName,OrigName,DestFileName);
#endif
}
}
}
if (MDCode==MKDIR_SUCCESS)
{
#ifndef GUI
mprintf(St(MCreatDir),DestFileName);
mprintf(L" %s",St(MOk));
#endif
PrevExtracted=true;
}
else
if (DirExist)
{
if (!Cmd->IgnoreGeneralAttr)
SetFileAttr(DestFileName,Arc.FileHead.FileAttr);
PrevExtracted=true;
}
else
{
uiMsg(UIERROR_DIRCREATE,Arc.FileName,DestFileName);
ErrHandler.SysErrMsg();
#ifdef RARDLL
Cmd->DllError=ERAR_ECREATE;
#endif
ErrHandler.SetErrorCode(RARX_CREATE);
}
if (PrevExtracted)
{
#if defined(_WIN_ALL) && !defined(SFX_MODULE)
if (Cmd->SetCompressedAttr &&
(Arc.FileHead.FileAttr & FILE_ATTRIBUTE_COMPRESSED)!=0 && WinNT())
SetFileCompression(DestFileName,true);
#endif
SetDirTime(DestFileName,
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.FileHead.mtime,
Cmd->xctime==EXTTIME_NONE ? NULL:&Arc.FileHead.ctime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.FileHead.atime);
}
}
bool CmdExtract::ExtractCurrentFile(CommandData *Cmd,Archive &Arc,size_t HeaderSize,bool &Repeat)
{
char Command=*Cmd->Command;
if (HeaderSize==0)
if (DataIO.UnpVolume)
{
#ifdef NOVOLUME
return(false);
#else
if (!MergeArchive(Arc,&DataIO,false,Command))
{
ErrHandler.SetErrorCode(WARNING);
return(false);
}
SignatureFound=false;
#endif
}
else
return(false);
int HeadType=Arc.GetHeaderType();
if (HeadType!=FILE_HEAD)
{
if (HeadType==AV_HEAD || HeadType==SIGN_HEAD)
SignatureFound=true;
#if !defined(SFX_MODULE) && !defined(_WIN_CE)
if (HeadType==SUB_HEAD && PrevExtracted)
SetExtraInfo(Cmd,Arc,DestFileName,*DestFileNameW ? DestFileNameW:NULL);
#endif
if (HeadType==NEWSUB_HEAD)
{
if (Arc.SubHead.CmpName(SUBHEAD_TYPE_AV))
SignatureFound=true;
#if !defined(NOSUBBLOCKS) && !defined(_WIN_CE)
if (PrevExtracted)
SetExtraInfoNew(Cmd,Arc,DestFileName,*DestFileNameW ? DestFileNameW:NULL);
#endif
}
if (HeadType==ENDARC_HEAD)
if (Arc.EndArcHead.Flags & EARC_NEXT_VOLUME)
{
#ifndef NOVOLUME
if (!MergeArchive(Arc,&DataIO,false,Command))
{
ErrHandler.SetErrorCode(WARNING);
return(false);
}
SignatureFound=false;
#endif
Arc.Seek(Arc.CurBlockPos,SEEK_SET);
return(true);
}
else
return(false);
Arc.SeekToNext();
return(true);
}
PrevExtracted=false;
if (SignatureFound ||
!Cmd->Recurse && MatchedArgs>=Cmd->FileArgs->ItemsCount() &&
AllMatchesExact)
return(false);
char ArcFileName[NM];
IntToExt(Arc.NewLhd.FileName,Arc.NewLhd.FileName);
strcpy(ArcFileName,Arc.NewLhd.FileName);
wchar ArcFileNameW[NM];
*ArcFileNameW=0;
int MatchType=MATCH_WILDSUBPATH;
bool EqualNames=false;
int MatchNumber=Cmd->IsProcessFile(Arc.NewLhd,&EqualNames,MatchType);
bool ExactMatch=MatchNumber!=0;
#if !defined(SFX_MODULE) && !defined(_WIN_CE)
if (Cmd->ExclPath==EXCL_BASEPATH)
{
*Cmd->ArcPath=0;
if (ExactMatch)
{
Cmd->FileArgs->Rewind();
if (Cmd->FileArgs->GetString(Cmd->ArcPath,NULL,sizeof(Cmd->ArcPath),MatchNumber-1))
*PointToName(Cmd->ArcPath)=0;
}
}
#endif
if (ExactMatch && !EqualNames)
AllMatchesExact=false;
#ifdef UNICODE_SUPPORTED
bool WideName=(Arc.NewLhd.Flags & LHD_UNICODE) && UnicodeEnabled();
#else
bool WideName=false;
#endif
#ifdef _APPLE
if (WideName)
{
WideToUtf(Arc.NewLhd.FileNameW,ArcFileName,sizeof(ArcFileName));
WideName=false;
}
#endif
wchar *DestNameW=WideName ? DestFileNameW:NULL;
#ifdef UNICODE_SUPPORTED
if (WideName)
{
ConvertPath(Arc.NewLhd.FileNameW,ArcFileNameW);
char Name[NM];
if (WideToChar(ArcFileNameW,Name) && IsNameUsable(Name))
strcpy(ArcFileName,Name);
}
#endif
ConvertPath(ArcFileName,ArcFileName);
if (Arc.IsArcLabel())
return(true);
if (Arc.NewLhd.Flags & LHD_VERSION)
{
if (Cmd->VersionControl!=1 && !EqualNames)
{
if (Cmd->VersionControl==0)
ExactMatch=false;
int Version=ParseVersionFileName(ArcFileName,ArcFileNameW,false);
if (Cmd->VersionControl-1==Version)
ParseVersionFileName(ArcFileName,ArcFileNameW,true);
else
ExactMatch=false;
}
}
else
if (!Arc.IsArcDir() && Cmd->VersionControl>1)
ExactMatch=false;
Arc.ConvertAttributes();
#ifndef SFX_MODULE
if ((Arc.NewLhd.Flags & (LHD_SPLIT_BEFORE/*|LHD_SOLID*/)) && FirstFile)
{
char CurVolName[NM];
strcpy(CurVolName,ArcName);
VolNameToFirstName(ArcName,ArcName,(Arc.NewMhd.Flags & MHD_NEWNUMBERING)!=0);
if (stricomp(ArcName,CurVolName)!=0 && FileExist(ArcName))
{
*ArcNameW=0;
Repeat=true;
return(false);
}
#if !defined(RARDLL) && !defined(_WIN_CE)
if (!ReconstructDone)
{
ReconstructDone=true;
RecVolumes RecVol;
if (RecVol.Restore(Cmd,Arc.FileName,Arc.FileNameW,true))
{
Repeat=true;
return(false);
}
}
#endif
strcpy(ArcName,CurVolName);
}
#endif
DataIO.UnpVolume=(Arc.NewLhd.Flags & LHD_SPLIT_AFTER)!=0;
DataIO.NextVolumeMissing=false;
Arc.Seek(Arc.NextBlockPos-Arc.NewLhd.FullPackSize,SEEK_SET);
bool TestMode=false;
bool ExtrFile=false;
bool SkipSolid=false;
#ifndef SFX_MODULE
if (FirstFile && (ExactMatch || Arc.Solid) && (Arc.NewLhd.Flags & (LHD_SPLIT_BEFORE/*|LHD_SOLID*/))!=0)
{
if (ExactMatch)
{
Log(Arc.FileName,St(MUnpCannotMerge),ArcFileName);
#ifdef RARDLL
Cmd->DllError=ERAR_BAD_DATA;
#endif
ErrHandler.SetErrorCode(OPEN_ERROR);
}
ExactMatch=false;
}
FirstFile=false;
#endif
if (ExactMatch || (SkipSolid=Arc.Solid)!=0)
{
if ((Arc.NewLhd.Flags & LHD_PASSWORD)!=0)
#ifndef RARDLL
if (*Password==0)
#endif
{
#ifdef RARDLL
if (*Cmd->Password==0)
if (Cmd->Callback==NULL ||
Cmd->Callback(UCM_NEEDPASSWORD,Cmd->UserData,(LPARAM)Cmd->Password,sizeof(Cmd->Password))==-1)
return(false);
strcpy(Password,Cmd->Password);
#else
if (!GetPassword(PASSWORD_FILE,ArcFileName,Password,sizeof(Password)))
{
PasswordCancelled=true;
return(false);
}
#endif
}
#if !defined(GUI) && !defined(SILENT)
else
if (!PasswordAll && (!Arc.Solid || Arc.NewLhd.UnpVer>=20 && (Arc.NewLhd.Flags & LHD_SOLID)==0))
{
eprintf(St(MUseCurPsw),ArcFileName);
switch(Cmd->AllYes ? 1:Ask(St(MYesNoAll)))
{
case -1:
ErrHandler.Exit(USER_BREAK);
case 2:
if (!GetPassword(PASSWORD_FILE,ArcFileName,Password,sizeof(Password)))
{
return(false);
}
break;
case 3:
PasswordAll=true;
break;
}
}
#endif
#ifndef SFX_MODULE
if (*Cmd->ExtrPath==0 && *Cmd->ExtrPathW!=0)
WideToChar(Cmd->ExtrPathW,DestFileName);
else
#endif
strcpy(DestFileName,Cmd->ExtrPath);
#ifndef SFX_MODULE
if (Cmd->AppendArcNameToPath)
{
strcat(DestFileName,PointToName(Arc.FirstVolumeName));
SetExt(DestFileName,NULL);
AddEndSlash(DestFileName);
}
#endif
char *ExtrName=ArcFileName;
bool EmptyName=false;
#ifndef SFX_MODULE
size_t Length=strlen(Cmd->ArcPath);
if (Length>1 && IsPathDiv(Cmd->ArcPath[Length-1]) &&
strlen(ArcFileName)==Length-1)
Length--;
if (Length>0 && strnicomp(Cmd->ArcPath,ArcFileName,Length)==0)
{
ExtrName+=Length;
while (*ExtrName==CPATHDIVIDER)
ExtrName++;
if (*ExtrName==0)
EmptyName=true;
}
#endif
bool AbsPaths=Cmd->ExclPath==EXCL_ABSPATH && Command=='X' && IsDriveDiv(':');
if (AbsPaths)
*DestFileName=0;
if (Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
strcat(DestFileName,PointToName(ExtrName));
else
strcat(DestFileName,ExtrName);
char DiskLetter=etoupper(DestFileName[0]);
if (AbsPaths && DestFileName[1]=='_' && IsPathDiv(DestFileName[2]) &&
DiskLetter>='A' && DiskLetter<='Z')
DestFileName[1]=':';
#ifndef SFX_MODULE
if (!WideName && *Cmd->ExtrPathW!=0)
{
DestNameW=DestFileNameW;
WideName=true;
CharToWide(ArcFileName,ArcFileNameW);
}
#endif
if (WideName)
{
if (*Cmd->ExtrPathW!=0)
strcpyw(DestFileNameW,Cmd->ExtrPathW);
else
CharToWide(Cmd->ExtrPath,DestFileNameW);
#ifndef SFX_MODULE
if (Cmd->AppendArcNameToPath)
{
wchar FileNameW[NM];
if (*Arc.FirstVolumeNameW!=0)
strcpyw(FileNameW,Arc.FirstVolumeNameW);
else
CharToWide(Arc.FirstVolumeName,FileNameW);
strcatw(DestFileNameW,PointToName(FileNameW));
SetExt(DestFileNameW,NULL);
AddEndSlash(DestFileNameW);
}
#endif
wchar *ExtrNameW=ArcFileNameW;
#ifndef SFX_MODULE
if (Length>0)
{
wchar ArcPathW[NM];
GetWideName(Cmd->ArcPath,Cmd->ArcPathW,ArcPathW);
Length=strlenw(ArcPathW);
}
ExtrNameW+=Length;
while (*ExtrNameW==CPATHDIVIDER)
ExtrNameW++;
#endif
if (AbsPaths)
*DestFileNameW=0;
if (Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
strcatw(DestFileNameW,PointToName(ExtrNameW));
else
strcatw(DestFileNameW,ExtrNameW);
if (AbsPaths && DestFileNameW[1]=='_' && IsPathDiv(DestFileNameW[2]))
DestFileNameW[1]=':';
}
else
*DestFileNameW=0;
ExtrFile=!SkipSolid && !EmptyName && (Arc.NewLhd.Flags & LHD_SPLIT_BEFORE)==0;
if ((Cmd->FreshFiles || Cmd->UpdateFiles) && (Command=='E' || Command=='X'))
{
struct FindData FD;
if (FindFile::FastFind(DestFileName,DestNameW,&FD))
{
if (FD.mtime >= Arc.NewLhd.mtime)
{
// If directory already exists and its modification time is newer
// than start of extraction, it is likely it was created
// when creating a path to one of already extracted items.
// In such case we'll better update its time even if archived
// directory is older.
if (!FD.IsDir || FD.mtime<StartTime)
ExtrFile=false;
}
}
else
if (Cmd->FreshFiles)
ExtrFile=false;
}
// Skip encrypted file if no password is specified.
if ((Arc.NewLhd.Flags & LHD_PASSWORD)!=0 && *Password==0)
{
ErrHandler.SetErrorCode(WARNING);
#ifdef RARDLL
Cmd->DllError=ERAR_MISSING_PASSWORD;
#endif
ExtrFile=false;
}
#ifdef RARDLL
if (*Cmd->DllDestName)
{
strncpyz(DestFileName,Cmd->DllDestName,ASIZE(DestFileName));
*DestFileNameW=0;
if (Cmd->DllOpMode!=RAR_EXTRACT)
ExtrFile=false;
}
if (*Cmd->DllDestNameW)
{
strncpyzw(DestFileNameW,Cmd->DllDestNameW,ASIZE(DestFileNameW));
DestNameW=DestFileNameW;
if (Cmd->DllOpMode!=RAR_EXTRACT)
ExtrFile=false;
}
#endif
#ifdef SFX_MODULE
if ((Arc.NewLhd.UnpVer!=UNP_VER && Arc.NewLhd.UnpVer!=29) &&
Arc.NewLhd.Method!=0x30)
#else
if (Arc.NewLhd.UnpVer<13 || Arc.NewLhd.UnpVer>UNP_VER)
#endif
{
#ifndef SILENT
Log(Arc.FileName,St(MUnknownMeth),ArcFileName);
#ifndef SFX_MODULE
Log(Arc.FileName,St(MVerRequired),Arc.NewLhd.UnpVer/10,Arc.NewLhd.UnpVer%10);
#endif
#endif
ExtrFile=false;
ErrHandler.SetErrorCode(WARNING);
#ifdef RARDLL
Cmd->DllError=ERAR_UNKNOWN_FORMAT;
#endif
}
File CurFile;
if (!IsLink(Arc.NewLhd.FileAttr))
if (Arc.IsArcDir())
{
if (!ExtrFile || Command=='P' || Command=='E' || Cmd->ExclPath==EXCL_SKIPWHOLEPATH)
return(true);
if (SkipSolid)
{
#ifndef GUI
mprintf(St(MExtrSkipFile),ArcFileName);
#endif
return(true);
}
TotalFileCount++;
if (Cmd->Test)
{
#ifndef GUI
mprintf(St(MExtrTestFile),ArcFileName);
mprintf(" %s",St(MOk));
#endif
return(true);
}
MKDIR_CODE MDCode=MakeDir(DestFileName,DestNameW,!Cmd->IgnoreGeneralAttr,Arc.NewLhd.FileAttr);
bool DirExist=false;
if (MDCode!=MKDIR_SUCCESS)
{
DirExist=FileExist(DestFileName,DestNameW);
if (DirExist && !IsDir(GetFileAttr(DestFileName,DestNameW)))
{
bool UserReject;
FileCreate(Cmd,NULL,DestFileName,DestNameW,Cmd->Overwrite,&UserReject,Arc.NewLhd.FullUnpSize,Arc.NewLhd.FileTime);
DirExist=false;
}
CreatePath(DestFileName,DestNameW,true);
MDCode=MakeDir(DestFileName,DestNameW,!Cmd->IgnoreGeneralAttr,Arc.NewLhd.FileAttr);
}
if (MDCode==MKDIR_SUCCESS)
{
#ifndef GUI
mprintf(St(MCreatDir),DestFileName);
mprintf(" %s",St(MOk));
#endif
PrevExtracted=true;
}
else
if (DirExist)
{
if (!Cmd->IgnoreGeneralAttr)
SetFileAttr(DestFileName,DestNameW,Arc.NewLhd.FileAttr);
PrevExtracted=true;
}
else
{
Log(Arc.FileName,St(MExtrErrMkDir),DestFileName);
ErrHandler.SysErrMsg();
#ifdef RARDLL
Cmd->DllError=ERAR_ECREATE;
#endif
ErrHandler.SetErrorCode(CREATE_ERROR);
}
if (PrevExtracted)
{
#if defined(_WIN_32) && !defined(_WIN_CE) && !defined(SFX_MODULE)
if (Cmd->SetCompressedAttr &&
(Arc.NewLhd.FileAttr & FILE_ATTRIBUTE_COMPRESSED)!=0 && WinNT())
SetFileCompression(DestFileName,DestNameW,true);
#endif
SetDirTime(DestFileName,DestNameW,
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.NewLhd.mtime,
Cmd->xctime==EXTTIME_NONE ? NULL:&Arc.NewLhd.ctime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.NewLhd.atime);
}
return(true);
}
else
{
if (Cmd->Test && ExtrFile)
TestMode=true;
#if !defined(GUI) && !defined(SFX_MODULE)
if (Command=='P' && ExtrFile)
CurFile.SetHandleType(FILE_HANDLESTD);
#endif
if ((Command=='E' || Command=='X') && ExtrFile && !Cmd->Test)
{
bool UserReject;
if (!FileCreate(Cmd,&CurFile,DestFileName,DestNameW,Cmd->Overwrite,&UserReject,Arc.NewLhd.FullUnpSize,Arc.NewLhd.FileTime))
{
ExtrFile=false;
if (!UserReject)
{
ErrHandler.CreateErrorMsg(Arc.FileName,DestFileName);
ErrHandler.SetErrorCode(CREATE_ERROR);
#ifdef RARDLL
Cmd->DllError=ERAR_ECREATE;
#endif
if (!IsNameUsable(DestFileName))
{
Log(Arc.FileName,St(MCorrectingName));
char OrigName[sizeof(DestFileName)];
strncpyz(OrigName,DestFileName,ASIZE(OrigName));
MakeNameUsable(DestFileName,true);
CreatePath(DestFileName,NULL,true);
if (FileCreate(Cmd,&CurFile,DestFileName,NULL,Cmd->Overwrite,&UserReject,Arc.NewLhd.FullUnpSize,Arc.NewLhd.FileTime))
{
#ifndef SFX_MODULE
Log(Arc.FileName,St(MRenaming),OrigName,DestFileName);
#endif
ExtrFile=true;
}
else
ErrHandler.CreateErrorMsg(Arc.FileName,DestFileName);
}
}
}
}
}
if (!ExtrFile && Arc.Solid)
{
SkipSolid=true;
TestMode=true;
ExtrFile=true;
}
if (ExtrFile)
{
if (!SkipSolid)
{
if (!TestMode && Command!='P' && CurFile.IsDevice())
{
Log(Arc.FileName,St(MInvalidName),DestFileName);
ErrHandler.WriteError(Arc.FileName,DestFileName);
}
TotalFileCount++;
}
FileCount++;
#ifndef GUI
if (Command!='I')
if (SkipSolid)
mprintf(St(MExtrSkipFile),ArcFileName);
else
switch(Cmd->Test ? 'T':Command)
{
case 'T':
mprintf(St(MExtrTestFile),ArcFileName);
break;
#ifndef SFX_MODULE
case 'P':
mprintf(St(MExtrPrinting),ArcFileName);
break;
#endif
case 'X':
case 'E':
mprintf(St(MExtrFile),DestFileName);
break;
}
if (!Cmd->DisablePercentage)
mprintf(" ");
#endif
DataIO.CurUnpRead=0;
DataIO.CurUnpWrite=0;
DataIO.UnpFileCRC=Arc.OldFormat ? 0 : 0xffffffff;
DataIO.PackedCRC=0xffffffff;
DataIO.SetEncryption(
(Arc.NewLhd.Flags & LHD_PASSWORD) ? Arc.NewLhd.UnpVer:0,Password,
(Arc.NewLhd.Flags & LHD_SALT) ? Arc.NewLhd.Salt:NULL,false,
Arc.NewLhd.UnpVer>=36);
DataIO.SetPackedSizeToRead(Arc.NewLhd.FullPackSize);
DataIO.SetFiles(&Arc,&CurFile);
DataIO.SetTestMode(TestMode);
DataIO.SetSkipUnpCRC(SkipSolid);
#ifndef _WIN_CE
if (!TestMode && !Arc.BrokenFileHeader &&
(Arc.NewLhd.FullPackSize<<11)>Arc.NewLhd.FullUnpSize &&
(Arc.NewLhd.FullUnpSize<100000000 || Arc.FileLength()>Arc.NewLhd.FullPackSize))
CurFile.Prealloc(Arc.NewLhd.FullUnpSize);
#endif
CurFile.SetAllowDelete(!Cmd->KeepBroken);
bool LinkCreateMode=!Cmd->Test && !SkipSolid;
if (ExtractLink(DataIO,Arc,DestFileName,DataIO.UnpFileCRC,LinkCreateMode))
PrevExtracted=LinkCreateMode;
else
if ((Arc.NewLhd.Flags & LHD_SPLIT_BEFORE)==0)
if (Arc.NewLhd.Method==0x30)
UnstoreFile(DataIO,Arc.NewLhd.FullUnpSize);
else
{
Unp->SetDestSize(Arc.NewLhd.FullUnpSize);
#ifndef SFX_MODULE
if (Arc.NewLhd.UnpVer<=15)
Unp->DoUnpack(15,FileCount>1 && Arc.Solid);
else
#endif
Unp->DoUnpack(Arc.NewLhd.UnpVer,(Arc.NewLhd.Flags & LHD_SOLID)!=0);
}
if (Arc.IsOpened())
Arc.SeekToNext();
bool BrokenFile=false;
if (!SkipSolid)
{
if (Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC) ||
!Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC^0xffffffff))
{
#ifndef GUI
if (Command!='P' && Command!='I')
mprintf("%s%s ",Cmd->DisablePercentage ? " ":"\b\b\b\b\b ",St(MOk));
#endif
}
else
{
char *BadArcName=/*(Arc.NewLhd.Flags & LHD_SPLIT_BEFORE) ? NULL:*/Arc.FileName;
if (Arc.NewLhd.Flags & LHD_PASSWORD)
{
Log(BadArcName,St(MEncrBadCRC),ArcFileName);
}
else
{
Log(BadArcName,St(MCRCFailed),ArcFileName);
}
BrokenFile=true;
ErrHandler.SetErrorCode(CRC_ERROR);
#ifdef RARDLL
Cmd->DllError=ERAR_BAD_DATA;
#endif
Alarm();
}
}
#ifndef GUI
else
mprintf("\b\b\b\b\b ");
#endif
if (!TestMode && (Command=='X' || Command=='E') &&
!IsLink(Arc.NewLhd.FileAttr))
{
#if defined(_WIN_32) || defined(_EMX)
if (Cmd->ClearArc)
Arc.NewLhd.FileAttr&=~FA_ARCH;
/*
else
Arc.NewLhd.FileAttr|=FA_ARCH; //set archive bit for unpacked files (file is not backed up)
*/
#endif
if (!BrokenFile || Cmd->KeepBroken)
{
if (BrokenFile)
CurFile.Truncate();
CurFile.SetOpenFileTime(
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.NewLhd.mtime,
Cmd->xctime==EXTTIME_NONE ? NULL:&Arc.NewLhd.ctime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.NewLhd.atime);
CurFile.Close();
#if defined(_WIN_32) && !defined(_WIN_CE) && !defined(SFX_MODULE)
if (Cmd->SetCompressedAttr &&
(Arc.NewLhd.FileAttr & FILE_ATTRIBUTE_COMPRESSED)!=0 && WinNT())
SetFileCompression(CurFile.FileName,CurFile.FileNameW,true);
#endif
CurFile.SetCloseFileTime(
Cmd->xmtime==EXTTIME_NONE ? NULL:&Arc.NewLhd.mtime,
Cmd->xatime==EXTTIME_NONE ? NULL:&Arc.NewLhd.atime);
if (!Cmd->IgnoreGeneralAttr)
SetFileAttr(CurFile.FileName,CurFile.FileNameW,Arc.NewLhd.FileAttr);
PrevExtracted=true;
}
}
}
}
if (ExactMatch)
MatchedArgs++;
if (DataIO.NextVolumeMissing || !Arc.IsOpened())
return(false);
if (!ExtrFile)
if (!Arc.Solid)
Arc.SeekToNext();
else
if (!SkipSolid)
return(false);
return(true);
}
