1 // HashCalc.cpp
2
3 #include "StdAfx.h"
4
5 #include "../../../../C/Alloc.h"
6
7 #include "../../../Common/StringToInt.h"
8
9 #include "../../Common/FileStreams.h"
10 #include "../../Common/StreamUtils.h"
11
12 #include "EnumDirItems.h"
13 #include "HashCalc.h"
14
15 using namespace NWindows;
16
17 class CHashMidBuf
18 {
19 void *_data;
20 public:
CHashMidBuf()21 CHashMidBuf(): _data(0) {}
operator void*()22 operator void *() { return _data; }
Alloc(size_t size)23 bool Alloc(size_t size)
24 {
25 if (_data != 0)
26 return false;
27 _data = ::MidAlloc(size);
28 return _data != 0;
29 }
~CHashMidBuf()30 ~CHashMidBuf() { ::MidFree(_data); }
31 };
32
33 static const char * const k_DefaultHashMethod = "CRC32";
34
SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVector & hashMethods)35 HRESULT CHashBundle::SetMethods(DECL_EXTERNAL_CODECS_LOC_VARS const UStringVector &hashMethods)
36 {
37 UStringVector names = hashMethods;
38 if (names.IsEmpty())
39 names.Add(UString(k_DefaultHashMethod));
40
41 CRecordVector<CMethodId> ids;
42 CObjectVector<COneMethodInfo> methods;
43
44 unsigned i;
45 for (i = 0; i < names.Size(); i++)
46 {
47 COneMethodInfo m;
48 RINOK(m.ParseMethodFromString(names[i]));
49
50 if (m.MethodName.IsEmpty())
51 m.MethodName = k_DefaultHashMethod;
52
53 if (m.MethodName == "*")
54 {
55 CRecordVector<CMethodId> tempMethods;
56 GetHashMethods(EXTERNAL_CODECS_LOC_VARS tempMethods);
57 methods.Clear();
58 ids.Clear();
59 FOR_VECTOR (t, tempMethods)
60 {
61 unsigned index = ids.AddToUniqueSorted(tempMethods[t]);
62 if (ids.Size() != methods.Size())
63 methods.Insert(index, m);
64 }
65 break;
66 }
67 else
68 {
69 // m.MethodName.RemoveChar(L'-');
70 CMethodId id;
71 if (!FindHashMethod(EXTERNAL_CODECS_LOC_VARS m.MethodName, id))
72 return E_NOTIMPL;
73 unsigned index = ids.AddToUniqueSorted(id);
74 if (ids.Size() != methods.Size())
75 methods.Insert(index, m);
76 }
77 }
78
79 for (i = 0; i < ids.Size(); i++)
80 {
81 CMyComPtr<IHasher> hasher;
82 AString name;
83 RINOK(CreateHasher(EXTERNAL_CODECS_LOC_VARS ids[i], name, hasher));
84 if (!hasher)
85 throw "Can't create hasher";
86 const COneMethodInfo &m = methods[i];
87 {
88 CMyComPtr<ICompressSetCoderProperties> scp;
89 hasher.QueryInterface(IID_ICompressSetCoderProperties, &scp);
90 if (scp)
91 RINOK(m.SetCoderProps(scp, NULL));
92 }
93 UInt32 digestSize = hasher->GetDigestSize();
94 if (digestSize > k_HashCalc_DigestSize_Max)
95 return E_NOTIMPL;
96 CHasherState &h = Hashers.AddNew();
97 h.Hasher = hasher;
98 h.Name = name;
99 h.DigestSize = digestSize;
100 for (unsigned k = 0; k < k_HashCalc_NumGroups; k++)
101 memset(h.Digests[k], 0, digestSize);
102 }
103
104 return S_OK;
105 }
106
InitForNewFile()107 void CHashBundle::InitForNewFile()
108 {
109 CurSize = 0;
110 FOR_VECTOR (i, Hashers)
111 {
112 CHasherState &h = Hashers[i];
113 h.Hasher->Init();
114 memset(h.Digests[k_HashCalc_Index_Current], 0, h.DigestSize);
115 }
116 }
117
Update(const void * data,UInt32 size)118 void CHashBundle::Update(const void *data, UInt32 size)
119 {
120 CurSize += size;
121 FOR_VECTOR (i, Hashers)
122 Hashers[i].Hasher->Update(data, size);
123 }
124
SetSize(UInt64 size)125 void CHashBundle::SetSize(UInt64 size)
126 {
127 CurSize = size;
128 }
129
AddDigests(Byte * dest,const Byte * src,UInt32 size)130 static void AddDigests(Byte *dest, const Byte *src, UInt32 size)
131 {
132 unsigned next = 0;
133 for (UInt32 i = 0; i < size; i++)
134 {
135 next += (unsigned)dest[i] + (unsigned)src[i];
136 dest[i] = (Byte)next;
137 next >>= 8;
138 }
139 }
140
Final(bool isDir,bool isAltStream,const UString & path)141 void CHashBundle::Final(bool isDir, bool isAltStream, const UString &path)
142 {
143 if (isDir)
144 NumDirs++;
145 else if (isAltStream)
146 {
147 NumAltStreams++;
148 AltStreamsSize += CurSize;
149 }
150 else
151 {
152 NumFiles++;
153 FilesSize += CurSize;
154 }
155
156 Byte pre[16];
157 memset(pre, 0, sizeof(pre));
158 if (isDir)
159 pre[0] = 1;
160
161 FOR_VECTOR (i, Hashers)
162 {
163 CHasherState &h = Hashers[i];
164 if (!isDir)
165 {
166 h.Hasher->Final(h.Digests[0]);
167 if (!isAltStream)
168 AddDigests(h.Digests[k_HashCalc_Index_DataSum], h.Digests[0], h.DigestSize);
169 }
170
171 h.Hasher->Init();
172 h.Hasher->Update(pre, sizeof(pre));
173 h.Hasher->Update(h.Digests[0], h.DigestSize);
174
175 for (unsigned k = 0; k < path.Len(); k++)
176 {
177 wchar_t c = path[k];
178 Byte temp[2] = { (Byte)(c & 0xFF), (Byte)((c >> 8) & 0xFF) };
179 h.Hasher->Update(temp, 2);
180 }
181
182 Byte tempDigest[k_HashCalc_DigestSize_Max];
183 h.Hasher->Final(tempDigest);
184 if (!isAltStream)
185 AddDigests(h.Digests[k_HashCalc_Index_NamesSum], tempDigest, h.DigestSize);
186 AddDigests(h.Digests[k_HashCalc_Index_StreamsSum], tempDigest, h.DigestSize);
187 }
188 }
189
190
HashCalc(DECL_EXTERNAL_CODECS_LOC_VARS const NWildcard::CCensor & censor,const CHashOptions & options,AString & errorInfo,IHashCallbackUI * callback)191 HRESULT HashCalc(
192 DECL_EXTERNAL_CODECS_LOC_VARS
193 const NWildcard::CCensor &censor,
194 const CHashOptions &options,
195 AString &errorInfo,
196 IHashCallbackUI *callback)
197 {
198 CDirItems dirItems;
199 dirItems.Callback = callback;
200
201 if (options.StdInMode)
202 {
203 CDirItem di;
204 di.Size = (UInt64)(Int64)-1;
205 di.Attrib = 0;
206 di.MTime.dwLowDateTime = 0;
207 di.MTime.dwHighDateTime = 0;
208 di.CTime = di.ATime = di.MTime;
209 dirItems.Items.Add(di);
210 }
211 else
212 {
213 RINOK(callback->StartScanning());
214 dirItems.ScanAltStreams = options.AltStreamsMode;
215
216 HRESULT res = EnumerateItems(censor,
217 options.PathMode,
218 UString(),
219 dirItems);
220
221 if (res != S_OK)
222 {
223 if (res != E_ABORT)
224 errorInfo = "Scanning error";
225 return res;
226 }
227 RINOK(callback->FinishScanning(dirItems.Stat));
228 }
229
230 unsigned i;
231 CHashBundle hb;
232 RINOK(hb.SetMethods(EXTERNAL_CODECS_LOC_VARS options.Methods));
233 hb.Init();
234
235 hb.NumErrors = dirItems.Stat.NumErrors;
236
237 if (options.StdInMode)
238 {
239 RINOK(callback->SetNumFiles(1));
240 }
241 else
242 {
243 RINOK(callback->SetTotal(dirItems.Stat.GetTotalBytes()));
244 }
245
246 const UInt32 kBufSize = 1 << 15;
247 CHashMidBuf buf;
248 if (!buf.Alloc(kBufSize))
249 return E_OUTOFMEMORY;
250
251 UInt64 completeValue = 0;
252
253 RINOK(callback->BeforeFirstFile(hb));
254
255 for (i = 0; i < dirItems.Items.Size(); i++)
256 {
257 CMyComPtr<ISequentialInStream> inStream;
258 UString path;
259 bool isDir = false;
260 bool isAltStream = false;
261 if (options.StdInMode)
262 {
263 inStream = new CStdInFileStream;
264 }
265 else
266 {
267 CInFileStream *inStreamSpec = new CInFileStream;
268 inStream = inStreamSpec;
269 const CDirItem &dirItem = dirItems.Items[i];
270 isDir = dirItem.IsDir();
271 isAltStream = dirItem.IsAltStream;
272 path = dirItems.GetLogPath(i);
273 if (!isDir)
274 {
275 FString phyPath = dirItems.GetPhyPath(i);
276 if (!inStreamSpec->OpenShared(phyPath, options.OpenShareForWrite))
277 {
278 HRESULT res = callback->OpenFileError(phyPath, ::GetLastError());
279 hb.NumErrors++;
280 if (res != S_FALSE)
281 return res;
282 continue;
283 }
284 }
285 }
286 RINOK(callback->GetStream(path, isDir));
287 UInt64 fileSize = 0;
288
289 hb.InitForNewFile();
290 if (!isDir)
291 {
292 for (UInt32 step = 0;; step++)
293 {
294 if ((step & 0xFF) == 0)
295 RINOK(callback->SetCompleted(&completeValue));
296 UInt32 size;
297 RINOK(inStream->Read(buf, kBufSize, &size));
298 if (size == 0)
299 break;
300 hb.Update(buf, size);
301 fileSize += size;
302 completeValue += size;
303 }
304 }
305 hb.Final(isDir, isAltStream, path);
306 RINOK(callback->SetOperationResult(fileSize, hb, !isDir));
307 RINOK(callback->SetCompleted(&completeValue));
308 }
309 return callback->AfterLastFile(hb);
310 }
311
312
GetHex(unsigned v)313 static inline char GetHex(unsigned v)
314 {
315 return (char)((v < 10) ? ('0' + v) : ('A' + (v - 10)));
316 }
317
AddHashHexToString(char * dest,const Byte * data,UInt32 size)318 void AddHashHexToString(char *dest, const Byte *data, UInt32 size)
319 {
320 dest[size * 2] = 0;
321
322 if (!data)
323 {
324 for (UInt32 i = 0; i < size; i++)
325 {
326 dest[0] = ' ';
327 dest[1] = ' ';
328 dest += 2;
329 }
330 return;
331 }
332
333 int step = 2;
334 if (size <= 8)
335 {
336 step = -2;
337 dest += size * 2 - 2;
338 }
339
340 for (UInt32 i = 0; i < size; i++)
341 {
342 unsigned b = data[i];
343 dest[0] = GetHex((b >> 4) & 0xF);
344 dest[1] = GetHex(b & 0xF);
345 dest += step;
346 }
347 }
348