unrarsrc  6.1.7
About: unrar extracts, views and tests the contents of archives created with the RAR archiver.
  Fossies Dox: unrarsrc-6.1.7.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

recvol5.cpp
Go to the documentation of this file.
1static const uint MaxVolumes=65535;
2
3// We select this limit arbitrarily, to prevent user creating too many
4// rev files by mistake.
5#define MAX_REV_TO_DATA_RATIO 10 // 1000% of rev files.
6
8{
9 RealBuf=NULL;
10 RealReadBuffer=NULL;
11
12 DataCount=0;
13 RecCount=0;
14 TotalCount=0;
16
17#ifdef RAR_SMP
19#else
21#endif
22
24 for (uint I=0;I<MaxUserThreads;I++)
25 {
26 ThreadData[I].RecRSPtr=this;
27 ThreadData[I].RS=NULL;
28 }
29
30 if (TestOnly)
31 {
32#ifdef RAR_SMP
33 RecThreadPool=NULL;
34#endif
35 }
36 else
37 {
38#ifdef RAR_SMP
39 RecThreadPool=new ThreadPool(MaxUserThreads);
40#endif
43 }
44}
45
46
48{
49 delete[] RealBuf;
50 delete[] RealReadBuffer;
51 for (uint I=0;I<RecItems.Size();I++)
52 delete RecItems[I].f;
53 for (uint I=0;I<MaxUserThreads;I++)
54 delete ThreadData[I].RS;
55 delete[] ThreadData;
56#ifdef RAR_SMP
57 delete RecThreadPool;
58#endif
59}
60
61
62
63
64#ifdef RAR_SMP
65THREAD_PROC(RecThreadRS)
66{
68 td->RecRSPtr->ProcessAreaRS(td);
69}
70#endif
71
72
73void RecVolumes5::ProcessRS(RAROptions *Cmd,uint DataNum,const byte *Data,uint MaxRead,bool Encode)
74{
75/*
76 RSCoder16 RS;
77 RS.Init(DataCount,RecCount,Encode ? NULL:ValidFlags);
78 uint Count=Encode ? RecCount : MissingVolumes;
79 for (uint I=0;I<Count;I++)
80 RS.UpdateECC(DataNum, I, Data, Buf+I*RecBufferSize, MaxRead);
81*/
82
83 uint ThreadNumber=MaxUserThreads;
84
85 const uint MinThreadBlock=0x1000;
86 ThreadNumber=Min(ThreadNumber,MaxRead/MinThreadBlock);
87
88 if (ThreadNumber<1)
89 ThreadNumber=1;
90 uint ThreadDataSize=MaxRead/ThreadNumber;
91 ThreadDataSize+=(ThreadDataSize&1); // Must be even for 16-bit RS coder.
92#ifdef USE_SSE
93 ThreadDataSize=ALIGN_VALUE(ThreadDataSize,SSE_ALIGNMENT); // Alignment for SSE operations.
94#endif
95 if (ThreadDataSize<MinThreadBlock)
96 ThreadDataSize=MinThreadBlock;
97
98 for (size_t I=0,CurPos=0;I<ThreadNumber && CurPos<MaxRead;I++)
99 {
101 if (td->RS==NULL)
102 {
103 td->RS=new RSCoder16;
104 td->RS->Init(DataCount,RecCount,Encode ? NULL:ValidFlags);
105 }
106 td->DataNum=DataNum;
107 td->Data=Data;
108 td->Encode=Encode;
109 td->StartPos=CurPos;
110
111 size_t EndPos=CurPos+ThreadDataSize;
112 if (EndPos>MaxRead || I==ThreadNumber-1)
113 EndPos=MaxRead;
114
115 td->Size=EndPos-CurPos;
116
117 CurPos=EndPos;
118
119#ifdef RAR_SMP
120 if (ThreadNumber>1)
121 RecThreadPool->AddTask(RecThreadRS,(void*)td);
122 else
123 ProcessAreaRS(td);
124#else
125 ProcessAreaRS(td);
126#endif
127 }
128#ifdef RAR_SMP
129 RecThreadPool->WaitDone();
130#endif // RAR_SMP
131}
132
133
135{
136 uint Count=td->Encode ? RecCount : MissingVolumes;
137 for (uint I=0;I<Count;I++)
138 td->RS->UpdateECC(td->DataNum, I, td->Data+td->StartPos, Buf+I*RecBufferSize+td->StartPos, td->Size);
139}
140
141
142
143
144bool RecVolumes5::Restore(RAROptions *Cmd,const wchar *Name,bool Silent)
145{
146 wchar ArcName[NM];
147 wcsncpyz(ArcName,Name,ASIZE(ArcName));
148
149 wchar *Num=GetVolNumPart(ArcName);
150 while (Num>ArcName && IsDigit(*(Num-1)))
151 Num--;
152 if (Num<=PointToName(ArcName))
153 return false; // Numeric part is missing or entire volume name is numeric, not possible for RAR or REV volume.
154 wcsncpyz(Num,L"*.*",ASIZE(ArcName)-(Num-ArcName));
155
156 wchar FirstVolName[NM];
157 *FirstVolName=0;
158
159 wchar LongestRevName[NM];
160 *LongestRevName=0;
161
162 int64 RecFileSize=0;
163
164 FindFile VolFind;
165 VolFind.SetMask(ArcName);
166 FindData fd;
167 uint FoundRecVolumes=0;
168 while (VolFind.Next(&fd))
169 {
170 Wait();
171
172 Archive *Vol=new Archive(Cmd);
173 int ItemPos=-1;
174 if (!fd.IsDir && Vol->WOpen(fd.Name))
175 {
176 if (CmpExt(fd.Name,L"rev"))
177 {
178 uint RecNum=ReadHeader(Vol,FoundRecVolumes==0);
179 if (RecNum!=0)
180 {
181 if (FoundRecVolumes==0)
182 RecFileSize=Vol->FileLength();
183
184 ItemPos=RecNum;
185 FoundRecVolumes++;
186
187 if (wcslen(fd.Name)>wcslen(LongestRevName))
188 wcsncpyz(LongestRevName,fd.Name,ASIZE(LongestRevName));
189 }
190 }
191 else
192 if (Vol->IsArchive(true) && (Vol->SFXSize>0 || CmpExt(fd.Name,L"rar")))
193 {
194 if (!Vol->Volume && !Vol->BrokenHeader)
195 {
196 uiMsg(UIERROR_NOTVOLUME,ArcName);
197 return false;
198 }
199 // We work with archive as with raw data file, so we do not want
200 // to spend time to QOpen I/O redirection.
201 Vol->QOpenUnload();
202
203 Vol->Seek(0,SEEK_SET);
204
205 // RAR volume found. Get its number, store the handle in appropriate
206 // array slot, clean slots in between if we had to grow the array.
207 wchar *Num=GetVolNumPart(fd.Name);
208 uint VolNum=0;
209 for (uint K=1;Num>=fd.Name && IsDigit(*Num);K*=10,Num--)
210 VolNum+=(*Num-'0')*K;
211 if (VolNum==0 || VolNum>MaxVolumes)
212 continue;
213 size_t CurSize=RecItems.Size();
214 if (VolNum>CurSize)
215 {
216 RecItems.Alloc(VolNum);
217 for (size_t I=CurSize;I<VolNum;I++)
218 RecItems[I].f=NULL;
219 }
220 ItemPos=VolNum-1;
221
222 if (*FirstVolName==0)
223 VolNameToFirstName(fd.Name,FirstVolName,ASIZE(FirstVolName),true);
224 }
225 }
226 if (ItemPos==-1)
227 delete Vol; // Skip found file, it is not RAR or REV volume.
228 else
229 if ((uint)ItemPos<RecItems.Size()) // Check if found more REV than needed.
230 {
231 // Store found RAR or REV volume.
232 RecVolItem *Item=RecItems+ItemPos;
233 Item->f=Vol;
234 Item->New=false;
235 wcsncpyz(Item->Name,fd.Name,ASIZE(Item->Name));
236 }
237 }
238
239 if (!Silent || FoundRecVolumes!=0)
240 uiMsg(UIMSG_RECVOLFOUND,FoundRecVolumes);
241 if (FoundRecVolumes==0)
242 return false;
243
244 // If we did not find even a single .rar volume, create .rar volume name
245 // based on the longest .rev file name. Use longest .rev, so we have
246 // enough space for volume number.
247 if (*FirstVolName==0)
248 {
249 SetExt(LongestRevName,L"rar",ASIZE(LongestRevName));
250 VolNameToFirstName(LongestRevName,FirstVolName,ASIZE(FirstVolName),true);
251 }
252
254
256 for (uint I=0;I<TotalCount;I++)
257 {
258 RecVolItem *Item=&RecItems[I];
259 if (Item->f!=NULL)
260 {
261 uiMsg(UIMSG_STRING,Item->Name);
262
263 uint RevCRC;
265 Item->Valid=RevCRC==Item->CRC;
266 if (!Item->Valid)
267 {
269
270 // Close only corrupt REV volumes here. We'll close and rename corrupt
271 // RAR volumes later, if we'll know that recovery is possible.
272 if (I>=DataCount)
273 {
274 Item->f->Close();
275 Item->f=NULL;
276 FoundRecVolumes--;
277 }
278 }
279 }
280 if (I<DataCount && (Item->f==NULL || !Item->Valid))
282 }
283
285
286 if (MissingVolumes==0)
287 {
289 return false;
290 }
291
292 if (MissingVolumes>FoundRecVolumes)
293 {
294 uiMsg(UIERROR_RECVOLFOUND,FoundRecVolumes); // Intentionally not displayed in console mode.
296 return false;
297 }
298
300
301 // Create missing and rename bad volumes.
302 uint64 MaxVolSize=0;
303 for (uint I=0;I<DataCount;I++)
304 {
305 RecVolItem *Item=&RecItems[I];
306 if (Item->FileSize>MaxVolSize)
307 MaxVolSize=Item->FileSize;
308 if (Item->f!=NULL && !Item->Valid)
309 {
310 Item->f->Close();
311
312 wchar NewName[NM];
313 wcsncpyz(NewName,Item->Name,ASIZE(NewName));
314 wcsncatz(NewName,L".bad",ASIZE(NewName));
315
317 uiMsg(UIMSG_RENAMING,Item->Name,NewName);
318 RenameFile(Item->Name,NewName);
319 delete Item->f;
320 Item->f=NULL;
321 }
322
323 if ((Item->New=(Item->f==NULL))==true)
324 {
325 wcsncpyz(Item->Name,FirstVolName,ASIZE(Item->Name));
328 File *NewVol=new File;
329 bool UserReject;
330 if (!FileCreate(Cmd,NewVol,Item->Name,ASIZE(Item->Name),&UserReject))
331 {
332 if (!UserReject)
335 }
336 NewVol->Prealloc(Item->FileSize);
337 Item->f=NewVol;
338 }
339 NextVolumeName(FirstVolName,ASIZE(FirstVolName),false);
340 }
341
342
343 int64 ProcessedSize=0;
344 int LastPercent=-1;
345 mprintf(L" ");
346
347 // Even though we already preliminary calculated missing volume number,
348 // let's do it again now, when we have the final and exact information.
350
351 ValidFlags=new bool[TotalCount];
352 for (uint I=0;I<TotalCount;I++)
353 {
354 ValidFlags[I]=RecItems[I].f!=NULL && !RecItems[I].New;
355 if (I<DataCount && !ValidFlags[I])
357 }
358
359 // Size of per file buffer.
361 if ((RecBufferSize&1)==1) // Must be even for our RS16 codec.
363#ifdef USE_SSE
364 RecBufferSize&=~(SSE_ALIGNMENT-1); // Align for SSE.
365#endif
366
367 RSCoder16 RS;
369 {
371 delete[] ValidFlags;
372 return false; // Should not happen, we check parameter validity above.
373 }
374
376 byte *ReadBuf=(byte *)ALIGN_VALUE(RealReadBuffer,SSE_ALIGNMENT);
377
378 while (true)
379 {
380 Wait();
381
382 int MaxRead=0;
383 for (uint I=0,J=DataCount;I<DataCount;I++)
384 {
385 uint VolNum=I;
386 if (!ValidFlags[I]) // If next RAR volume is missing or invalid.
387 {
388 while (!ValidFlags[J]) // Find next valid REV volume.
389 J++;
390 VolNum=J++; // Use next valid REV volume data instead of RAR.
391 }
392 RecVolItem *Item=RecItems+VolNum;
393
394 byte *B=&ReadBuf[0];
395 int ReadSize=0;
396 if (Item->f!=NULL && !Item->New)
397 ReadSize=Item->f->Read(B,RecBufferSize);
398 if (ReadSize!=RecBufferSize)
399 memset(B+ReadSize,0,RecBufferSize-ReadSize);
400 if (ReadSize>MaxRead)
401 MaxRead=ReadSize;
402
403 // We can have volumes of different size. Let's use data chunk
404 // for largest volume size.
405 uint DataToProcess=(uint)Min(RecBufferSize,MaxVolSize-ProcessedSize);
406 ProcessRS(Cmd,I,B,DataToProcess,false);
407 }
408 if (MaxRead==0)
409 break;
410
411 for (uint I=0,J=0;I<DataCount;I++)
412 if (!ValidFlags[I])
413 {
414 RecVolItem *Item=RecItems+I;
415 size_t WriteSize=(size_t)Min(MaxRead,Item->FileSize);
416 Item->f->Write(Buf+(J++)*RecBufferSize,WriteSize);
417 Item->FileSize-=WriteSize;
418 }
419
420 int CurPercent=ToPercent(ProcessedSize,RecFileSize);
421 if (!Cmd->DisablePercentage && CurPercent!=LastPercent)
422 {
423 uiProcessProgress("RV",ProcessedSize,RecFileSize);
424 LastPercent=CurPercent;
425 }
426 ProcessedSize+=MaxRead;
427 }
428
429 for (uint I=0;I<TotalCount;I++)
430 if (RecItems[I].f!=NULL)
431 RecItems[I].f->Close();
432
433 delete[] ValidFlags;
434#if !defined(SILENT)
435 if (!Cmd->DisablePercentage)
436 mprintf(L"\b\b\b\b100%%");
437 if (!Silent && !Cmd->DisableDone)
438 mprintf(St(MDone));
439#endif
440 return true;
441}
442
443
444uint RecVolumes5::ReadHeader(File *RecFile,bool FirstRev)
445{
446 const size_t FirstReadSize=REV5_SIGN_SIZE+8;
447 byte ShortBuf[FirstReadSize];
448 if (RecFile->Read(ShortBuf,FirstReadSize)!=FirstReadSize)
449 return 0;
450 if (memcmp(ShortBuf,REV5_SIGN,REV5_SIGN_SIZE)!=0)
451 return 0;
452 uint HeaderSize=RawGet4(ShortBuf+REV5_SIGN_SIZE+4);
453 if (HeaderSize>0x100000 || HeaderSize<=5)
454 return 0;
455 uint BlockCRC=RawGet4(ShortBuf+REV5_SIGN_SIZE);
456
457 RawRead Raw(RecFile);
458 if (Raw.Read(HeaderSize)!=HeaderSize)
459 return 0;
460
461 // Calculate CRC32 of entire header including 4 byte size field.
462 uint CalcCRC=CRC32(0xffffffff,ShortBuf+REV5_SIGN_SIZE+4,4);
463 if ((CRC32(CalcCRC,Raw.GetDataPtr(),HeaderSize)^0xffffffff)!=BlockCRC)
464 return 0;
465
466 if (Raw.Get1()!=1) // Version check.
467 return 0;
468 DataCount=Raw.Get2();
469 RecCount=Raw.Get2();
471 uint RecNum=Raw.Get2(); // Number of recovery volume.
472 if (RecNum>=TotalCount || TotalCount>MaxVolumes)
473 return 0;
474 uint RevCRC=Raw.Get4(); // CRC of current REV volume.
475
476 if (FirstRev)
477 {
478 // If we have read the first valid REV file, init data structures
479 // using information from REV header.
480 size_t CurSize=RecItems.Size();
482 for (size_t I=CurSize;I<TotalCount;I++)
483 RecItems[I].f=NULL;
484 for (uint I=0;I<DataCount;I++)
485 {
486 RecItems[I].FileSize=Raw.Get8();
487 RecItems[I].CRC=Raw.Get4();
488 }
489 }
490
491 RecItems[RecNum].CRC=RevCRC; // Assign it here, after allocating RecItems.
492
493 return RecNum;
494}
495
496
497void RecVolumes5::Test(RAROptions *Cmd,const wchar *Name)
498{
499 wchar VolName[NM];
500 wcsncpyz(VolName,Name,ASIZE(VolName));
501
502 uint FoundRecVolumes=0;
503 while (FileExist(VolName))
504 {
505 File CurFile;
506 if (!CurFile.Open(VolName))
507 {
508 ErrHandler.OpenErrorMsg(VolName); // It also sets RARX_OPEN.
509 continue;
510 }
511 if (!uiStartFileExtract(VolName,false,true,false))
512 return;
513 mprintf(St(MExtrTestFile),VolName);
514 mprintf(L" ");
515 bool Valid=false;
516 uint RecNum=ReadHeader(&CurFile,FoundRecVolumes==0);
517 if (RecNum!=0)
518 {
519 FoundRecVolumes++;
520
521 uint RevCRC;
522 CalcFileSum(&CurFile,&RevCRC,NULL,1,INT64NDF,CALCFSUM_CURPOS|(Cmd->DisablePercentage ? 0 : CALCFSUM_SHOWPROGRESS));
523 Valid=RevCRC==RecItems[RecNum].CRC;
524 }
525
526 if (Valid)
527 {
528 mprintf(L"%s%s ",L"\b\b\b\b\b ",St(MOk));
529 }
530 else
531 {
532 uiMsg(UIERROR_CHECKSUM,VolName,VolName);
534 }
535
536 NextVolumeName(VolName,ASIZE(VolName),false);
537 }
538}
ErrorHandler ErrHandler
bool BrokenHeader
Definition: archive.hpp:128
bool IsArchive(bool EnableBroken)
Definition: archive.cpp:126
size_t SFXSize
Definition: archive.hpp:127
bool Volume
Definition: archive.hpp:119
size_t Size()
Definition: array.hpp:94
void Alloc(size_t Items)
Definition: array.hpp:139
void OpenErrorMsg(const wchar *FileName)
Definition: errhnd.cpp:164
void SetErrorCode(RAR_EXIT Code)
Definition: errhnd.cpp:243
void CreateErrorMsg(const wchar *FileName)
Definition: errhnd.cpp:179
void Exit(RAR_EXIT ExitCode)
Definition: errhnd.cpp:236
Definition: file.hpp:57
virtual void Seek(int64 Offset, int Method)
Definition: file.cpp:514
int64 FileLength()
Definition: file.cpp:750
bool Write(const void *Data, size_t Size)
Definition: file.cpp:298
virtual int Read(void *Data, size_t Size)
Definition: file.cpp:374
virtual bool Open(const wchar *Name, uint Mode=FMF_READ)
Definition: file.cpp:48
void Prealloc(int64 Size)
Definition: file.cpp:606
virtual bool Close()
Definition: file.cpp:241
bool WOpen(const wchar *Name)
Definition: file.cpp:167
void SetMask(const wchar *Mask)
Definition: find.cpp:27
bool Next(FindData *fd, bool GetSymLink=false)
Definition: find.cpp:34
bool DisableDone
Definition: options.hpp:137
bool DisablePercentage
Definition: options.hpp:135
uint Threads
Definition: options.hpp:206
void UpdateECC(uint DataNum, uint ECCNum, const byte *Data, byte *ECC, size_t BlockSize)
Definition: rs16.cpp:263
bool Init(uint DataCount, uint RecCount, bool *ValidityFlags)
Definition: rs16.cpp:74
uint64 Get8()
Definition: rawread.cpp:108
uint Get4()
Definition: rawread.cpp:95
ushort Get2()
Definition: rawread.cpp:83
byte Get1()
Definition: rawread.cpp:77
size_t Read(size_t Size)
Definition: rawread.cpp:26
byte * GetDataPtr()
Definition: rawread.hpp:28
byte * Buf
Definition: recvol.hpp:61
Array< RecVolItem > RecItems
Definition: recvol.hpp:55
uint MissingVolumes
Definition: recvol.hpp:69
uint DataCount
Definition: recvol.hpp:64
uint MaxUserThreads
Definition: recvol.hpp:74
byte * RealReadBuffer
Definition: recvol.hpp:57
uint TotalCount
Definition: recvol.hpp:66
RecVolumes5(RAROptions *Cmd, bool TestOnly)
Definition: recvol5.cpp:7
void ProcessAreaRS(RecRSThreadData *td)
Definition: recvol5.cpp:134
size_t RecBufferSize
Definition: recvol.hpp:62
uint ReadHeader(File *RecFile, bool FirstRev)
Definition: recvol5.cpp:444
RecRSThreadData * ThreadData
Definition: recvol.hpp:75
void Test(RAROptions *Cmd, const wchar *Name)
Definition: recvol5.cpp:497
~RecVolumes5()
Definition: recvol5.cpp:47
void ProcessRS(RAROptions *Cmd, uint DataNum, const byte *Data, uint MaxRead, bool Encode)
Definition: recvol5.cpp:73
byte * RealBuf
Definition: recvol.hpp:60
uint RecCount
Definition: recvol.hpp:65
bool * ValidFlags
Definition: recvol.hpp:68
bool Restore(RAROptions *Cmd, const wchar *Name, bool Silent)
Definition: recvol5.cpp:144
void mprintf(const wchar *fmt,...)
Definition: consio.cpp:118
uint CRC32(uint StartCRC, const void *Addr, size_t Size)
Definition: crc.cpp:62
@ RARX_USERBREAK
Definition: errhnd.hpp:19
@ RARX_CRC
Definition: errhnd.hpp:9
@ RARX_CREATE
Definition: errhnd.hpp:15
bool FileCreate(RAROptions *Cmd, File *NewFile, wchar *Name, size_t MaxNameSize, bool *UserReject, int64 FileSize, RarTime *FileTime, bool WriteOnly)
Definition: filcreat.cpp:6
void CalcFileSum(File *SrcFile, uint *CRC32, byte *Blake2, uint Threads, int64 Size, uint Flags)
Definition: filefn.cpp:361
bool RenameFile(const wchar *SrcName, const wchar *DestName)
Definition: filefn.cpp:439
bool FileExist(const wchar *Name)
Definition: filefn.cpp:190
@ CALCFSUM_SHOWPROGRESS
Definition: filefn.hpp:34
@ CALCFSUM_CURPOS
Definition: filefn.hpp:34
#define MDone
Definition: loclang.hpp:184
#define MExtrTestFile
Definition: loclang.hpp:216
#define MOk
Definition: loclang.hpp:183
#define SSE_ALIGNMENT
Definition: os.hpp:232
void SetExt(wchar *Name, const wchar *NewExt, size_t MaxSize)
Definition: pathfn.cpp:74
wchar * VolNameToFirstName(const wchar *VolName, wchar *FirstName, size_t MaxSize, bool NewNumbering)
Definition: pathfn.cpp:632
wchar * PointToName(const wchar *Path)
Definition: pathfn.cpp:3
void NextVolumeName(wchar *ArcName, uint MaxLength, bool OldNumbering)
Definition: pathfn.cpp:359
wchar * GetVolNumPart(const wchar *ArcName)
Definition: pathfn.cpp:320
bool CmpExt(const wchar *Name, const wchar *Ext)
Definition: pathfn.cpp:114
#define Min(x, y)
Definition: rardefs.hpp:4
#define ASIZE(x)
Definition: rardefs.hpp:10
#define ALIGN_VALUE(v, a)
Definition: rardefs.hpp:29
#define INT64NDF
Definition: rartypes.hpp:30
wchar_t wchar
Definition: rartypes.hpp:13
int64_t int64
Definition: rartypes.hpp:12
unsigned int uint
Definition: rartypes.hpp:8
uint64_t uint64
Definition: rartypes.hpp:11
uint32 RawGet4(const void *Data)
Definition: rawint.hpp:16
static const size_t TotalBufferSize
Definition: recvol3.cpp:2
static const uint MaxVolumes
Definition: recvol5.cpp:1
#define REV5_SIGN_SIZE
Definition: recvol.hpp:5
#define REV5_SIGN
Definition: recvol.hpp:4
const wchar * St(MSGID StringId)
Definition: resource.cpp:8
static const uint32 K[64]
Definition: sha256.cpp:4
int ToPercent(int64 N1, int64 N2)
Definition: smallfn.cpp:3
void wcsncpyz(wchar *dest, const wchar *src, size_t maxlen)
Definition: strfn.cpp:275
void wcsncatz(wchar *dest, const wchar *src, size_t maxlen)
Definition: strfn.cpp:300
bool IsDigit(int ch)
Definition: strfn.cpp:151
Definition: find.hpp:9
wchar Name[NM]
Definition: find.hpp:10
bool IsDir
Definition: find.hpp:13
const byte * Data
Definition: recvol.hpp:43
RSCoder16 * RS
Definition: recvol.hpp:40
size_t Size
Definition: recvol.hpp:45
RecVolumes5 * RecRSPtr
Definition: recvol.hpp:39
size_t StartPos
Definition: recvol.hpp:44
wchar Name[NM]
Definition: recvol.hpp:28
uint64 FileSize
Definition: recvol.hpp:30
File * f
Definition: recvol.hpp:27
uint CRC
Definition: recvol.hpp:29
bool New
Definition: recvol.hpp:31
bool Valid
Definition: recvol.hpp:32
void Wait()
Definition: system.cpp:80
void uiProcessProgress(const char *Command, int64 CurSize, int64 TotalSize)
Definition: uiconsole.cpp:82
void uiMsg(UIMESSAGE_CODE Code)
Definition: ui.hpp:148
bool uiStartFileExtract(const wchar *FileName, bool Extract, bool Test, bool Skip)
Definition: uiconsole.cpp:66
@ UIERROR_NOTVOLUME
Definition: ui.hpp:25
@ UIEVENT_NEWARCHIVE
Definition: ui.hpp:64
@ UIERROR_RECVOLFOUND
Definition: ui.hpp:27
@ UIMSG_BADARCHIVE
Definition: ui.hpp:49
@ UIMSG_CHECKSUM
Definition: ui.hpp:51
@ UIERROR_OPFAILED
Definition: ui.hpp:28
@ UIMSG_RECVOLFOUND
Definition: ui.hpp:50
@ UIERROR_CHECKSUM
Definition: ui.hpp:11
@ UIMSG_RECVOLCALCCHECKSUM
Definition: ui.hpp:50
@ UIERROR_RECVOLCANNOTFIX
Definition: ui.hpp:28
@ UIMSG_STRING
Definition: ui.hpp:45
@ UIMSG_RECONSTRUCTING
Definition: ui.hpp:51
@ UIMSG_RECVOLMISSING
Definition: ui.hpp:50
@ UIERROR_RECVOLALLEXIST
Definition: ui.hpp:27
@ UIMSG_CREATING
Definition: ui.hpp:49
@ UIMSG_RENAMING
Definition: ui.hpp:49
THREAD_PROC(UnpackDecodeThread)
Definition: unpack50mt.cpp:12