UpdateCallback.cpp (19665B)
1 // UpdateCallback.cpp 2 3 #include "StdAfx.h" 4 5 #ifndef _7ZIP_ST 6 #include "../../../Windows/Synchronization.h" 7 #endif 8 9 #include "../../../Common/ComTry.h" 10 #include "../../../Common/IntToString.h" 11 #include "../../../Common/StringConvert.h" 12 #include "../../../Common/Wildcard.h" 13 14 #include "../../../Windows/FileDir.h" 15 #include "../../../Windows/FileName.h" 16 #include "../../../Windows/PropVariant.h" 17 18 #include "../../Common/StreamObjects.h" 19 20 #include "UpdateCallback.h" 21 22 #if defined(_WIN32) && !defined(UNDER_CE) 23 #define _USE_SECURITY_CODE 24 #include "../../../Windows/SecurityUtils.h" 25 #endif 26 27 using namespace NWindows; 28 using namespace NFile; 29 30 #ifndef _7ZIP_ST 31 static NSynchronization::CCriticalSection g_CriticalSection; 32 #define MT_LOCK NSynchronization::CCriticalSectionLock lock(g_CriticalSection); 33 #else 34 #define MT_LOCK 35 #endif 36 37 38 #ifdef _USE_SECURITY_CODE 39 bool InitLocalPrivileges(); 40 #endif 41 42 CArchiveUpdateCallback::CArchiveUpdateCallback(): 43 _hardIndex_From((UInt32)(Int32)-1), 44 45 Callback(NULL), 46 47 DirItems(NULL), 48 ParentDirItem(NULL), 49 50 Arc(NULL), 51 ArcItems(NULL), 52 UpdatePairs(NULL), 53 NewNames(NULL), 54 CommentIndex(-1), 55 Comment(NULL), 56 57 ShareForWrite(false), 58 StopAfterOpenError(false), 59 StdInMode(false), 60 61 KeepOriginalItemNames(false), 62 StoreNtSecurity(false), 63 StoreHardLinks(false), 64 StoreSymLinks(false), 65 66 ProcessedItemsStatuses(NULL) 67 { 68 #ifdef _USE_SECURITY_CODE 69 _saclEnabled = InitLocalPrivileges(); 70 #endif 71 } 72 73 74 STDMETHODIMP CArchiveUpdateCallback::SetTotal(UInt64 size) 75 { 76 COM_TRY_BEGIN 77 return Callback->SetTotal(size); 78 COM_TRY_END 79 } 80 81 STDMETHODIMP CArchiveUpdateCallback::SetCompleted(const UInt64 *completeValue) 82 { 83 COM_TRY_BEGIN 84 return Callback->SetCompleted(completeValue); 85 COM_TRY_END 86 } 87 88 STDMETHODIMP CArchiveUpdateCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize) 89 { 90 COM_TRY_BEGIN 91 return Callback->SetRatioInfo(inSize, outSize); 92 COM_TRY_END 93 } 94 95 96 /* 97 static const CStatProp kProps[] = 98 { 99 { NULL, kpidPath, VT_BSTR}, 100 { NULL, kpidIsDir, VT_BOOL}, 101 { NULL, kpidSize, VT_UI8}, 102 { NULL, kpidCTime, VT_FILETIME}, 103 { NULL, kpidATime, VT_FILETIME}, 104 { NULL, kpidMTime, VT_FILETIME}, 105 { NULL, kpidAttrib, VT_UI4}, 106 { NULL, kpidIsAnti, VT_BOOL} 107 }; 108 109 STDMETHODIMP CArchiveUpdateCallback::EnumProperties(IEnumSTATPROPSTG **) 110 { 111 return CStatPropEnumerator::CreateEnumerator(kProps, ARRAY_SIZE(kProps), enumerator); 112 } 113 */ 114 115 STDMETHODIMP CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 index, 116 Int32 *newData, Int32 *newProps, UInt32 *indexInArchive) 117 { 118 COM_TRY_BEGIN 119 RINOK(Callback->CheckBreak()); 120 const CUpdatePair2 &up = (*UpdatePairs)[index]; 121 if (newData) *newData = BoolToInt(up.NewData); 122 if (newProps) *newProps = BoolToInt(up.NewProps); 123 if (indexInArchive) 124 { 125 *indexInArchive = (UInt32)(Int32)-1; 126 if (up.ExistInArchive()) 127 *indexInArchive = (ArcItems == 0) ? up.ArcIndex : (*ArcItems)[up.ArcIndex].IndexInServer; 128 } 129 return S_OK; 130 COM_TRY_END 131 } 132 133 STDMETHODIMP CArchiveUpdateCallback::GetRootProp(PROPID propID, PROPVARIANT *value) 134 { 135 NCOM::CPropVariant prop; 136 switch (propID) 137 { 138 case kpidIsDir: prop = true; break; 139 case kpidAttrib: if (ParentDirItem) prop = ParentDirItem->Attrib; break; 140 case kpidCTime: if (ParentDirItem) prop = ParentDirItem->CTime; break; 141 case kpidATime: if (ParentDirItem) prop = ParentDirItem->ATime; break; 142 case kpidMTime: if (ParentDirItem) prop = ParentDirItem->MTime; break; 143 } 144 prop.Detach(value); 145 return S_OK; 146 } 147 148 STDMETHODIMP CArchiveUpdateCallback::GetParent(UInt32 /* index */, UInt32 *parent, UInt32 *parentType) 149 { 150 *parentType = NParentType::kDir; 151 *parent = (UInt32)(Int32)-1; 152 return S_OK; 153 } 154 155 STDMETHODIMP CArchiveUpdateCallback::GetNumRawProps(UInt32 *numProps) 156 { 157 *numProps = 0; 158 if (StoreNtSecurity) 159 *numProps = 1; 160 return S_OK; 161 } 162 163 STDMETHODIMP CArchiveUpdateCallback::GetRawPropInfo(UInt32 /* index */, BSTR *name, PROPID *propID) 164 { 165 *name = NULL; 166 *propID = kpidNtSecure; 167 return S_OK; 168 } 169 170 STDMETHODIMP CArchiveUpdateCallback::GetRootRawProp(PROPID 171 #ifdef _USE_SECURITY_CODE 172 propID 173 #endif 174 , const void **data, UInt32 *dataSize, UInt32 *propType) 175 { 176 *data = 0; 177 *dataSize = 0; 178 *propType = 0; 179 if (!StoreNtSecurity) 180 return S_OK; 181 #ifdef _USE_SECURITY_CODE 182 if (propID == kpidNtSecure) 183 { 184 if (StdInMode) 185 return S_OK; 186 187 if (ParentDirItem) 188 { 189 if (ParentDirItem->SecureIndex < 0) 190 return S_OK; 191 const CByteBuffer &buf = DirItems->SecureBlocks.Bufs[ParentDirItem->SecureIndex]; 192 *data = buf; 193 *dataSize = (UInt32)buf.Size(); 194 *propType = NPropDataType::kRaw; 195 return S_OK; 196 } 197 198 if (Arc && Arc->GetRootProps) 199 return Arc->GetRootProps->GetRootRawProp(propID, data, dataSize, propType); 200 } 201 #endif 202 return S_OK; 203 } 204 205 // #ifdef _USE_SECURITY_CODE 206 // #endif 207 208 STDMETHODIMP CArchiveUpdateCallback::GetRawProp(UInt32 index, PROPID propID, const void **data, UInt32 *dataSize, UInt32 *propType) 209 { 210 *data = 0; 211 *dataSize = 0; 212 *propType = 0; 213 214 if (propID == kpidNtSecure || 215 propID == kpidNtReparse) 216 { 217 if (StdInMode) 218 return S_OK; 219 220 const CUpdatePair2 &up = (*UpdatePairs)[index]; 221 if (up.UseArcProps && up.ExistInArchive() && Arc->GetRawProps) 222 return Arc->GetRawProps->GetRawProp( 223 ArcItems ? (*ArcItems)[up.ArcIndex].IndexInServer : up.ArcIndex, 224 propID, data, dataSize, propType); 225 { 226 /* 227 if (!up.NewData) 228 return E_FAIL; 229 */ 230 if (up.IsAnti) 231 return S_OK; 232 233 #ifndef UNDER_CE 234 const CDirItem &di = DirItems->Items[up.DirIndex]; 235 #endif 236 237 #ifdef _USE_SECURITY_CODE 238 if (propID == kpidNtSecure) 239 { 240 if (!StoreNtSecurity) 241 return S_OK; 242 if (di.SecureIndex < 0) 243 return S_OK; 244 const CByteBuffer &buf = DirItems->SecureBlocks.Bufs[di.SecureIndex]; 245 *data = buf; 246 *dataSize = (UInt32)buf.Size(); 247 *propType = NPropDataType::kRaw; 248 } 249 else 250 #endif 251 { 252 // propID == kpidNtReparse 253 if (!StoreSymLinks) 254 return S_OK; 255 #ifndef UNDER_CE 256 const CByteBuffer *buf = &di.ReparseData2; 257 if (buf->Size() == 0) 258 buf = &di.ReparseData; 259 if (buf->Size() != 0) 260 { 261 *data = *buf; 262 *dataSize = (UInt32)buf->Size(); 263 *propType = NPropDataType::kRaw; 264 } 265 #endif 266 } 267 268 return S_OK; 269 } 270 } 271 272 return S_OK; 273 } 274 275 #ifndef UNDER_CE 276 277 static UString GetRelativePath(const UString &to, const UString &from) 278 { 279 UStringVector partsTo, partsFrom; 280 SplitPathToParts(to, partsTo); 281 SplitPathToParts(from, partsFrom); 282 283 unsigned i; 284 for (i = 0;; i++) 285 { 286 if (i + 1 >= partsFrom.Size() || 287 i + 1 >= partsTo.Size()) 288 break; 289 if (CompareFileNames(partsFrom[i], partsTo[i]) != 0) 290 break; 291 } 292 293 if (i == 0) 294 { 295 #ifdef _WIN32 296 if (NName::IsDrivePath(to) || 297 NName::IsDrivePath(from)) 298 return to; 299 #endif 300 } 301 302 UString s; 303 unsigned k; 304 305 for (k = i + 1; k < partsFrom.Size(); k++) 306 s += ".." STRING_PATH_SEPARATOR; 307 308 for (k = i; k < partsTo.Size(); k++) 309 { 310 if (k != i) 311 s.Add_PathSepar(); 312 s += partsTo[k]; 313 } 314 315 return s; 316 } 317 318 #endif 319 320 STDMETHODIMP CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value) 321 { 322 COM_TRY_BEGIN 323 const CUpdatePair2 &up = (*UpdatePairs)[index]; 324 NCOM::CPropVariant prop; 325 326 if (up.NewData) 327 { 328 /* 329 if (propID == kpidIsHardLink) 330 { 331 prop = _isHardLink; 332 prop.Detach(value); 333 return S_OK; 334 } 335 */ 336 if (propID == kpidSymLink) 337 { 338 if (index == _hardIndex_From) 339 { 340 prop.Detach(value); 341 return S_OK; 342 } 343 if (up.DirIndex >= 0) 344 { 345 #ifndef UNDER_CE 346 const CDirItem &di = DirItems->Items[up.DirIndex]; 347 // if (di.IsDir()) 348 { 349 CReparseAttr attr; 350 DWORD errorCode = 0; 351 if (attr.Parse(di.ReparseData, di.ReparseData.Size(), errorCode)) 352 { 353 UString simpleName = attr.GetPath(); 354 if (attr.IsRelative()) 355 prop = simpleName; 356 else 357 { 358 const FString phyPath = DirItems->GetPhyPath(up.DirIndex); 359 FString fullPath; 360 if (NDir::MyGetFullPathName(phyPath, fullPath)) 361 { 362 prop = GetRelativePath(simpleName, fs2us(fullPath)); 363 } 364 } 365 prop.Detach(value); 366 return S_OK; 367 } 368 } 369 #endif 370 } 371 } 372 else if (propID == kpidHardLink) 373 { 374 if (index == _hardIndex_From) 375 { 376 const CKeyKeyValPair &pair = _map[_hardIndex_To]; 377 const CUpdatePair2 &up2 = (*UpdatePairs)[pair.Value]; 378 prop = DirItems->GetLogPath(up2.DirIndex); 379 prop.Detach(value); 380 return S_OK; 381 } 382 if (up.DirIndex >= 0) 383 { 384 prop.Detach(value); 385 return S_OK; 386 } 387 } 388 } 389 390 if (up.IsAnti 391 && propID != kpidIsDir 392 && propID != kpidPath 393 && propID != kpidIsAltStream) 394 { 395 switch (propID) 396 { 397 case kpidSize: prop = (UInt64)0; break; 398 case kpidIsAnti: prop = true; break; 399 } 400 } 401 else if (propID == kpidPath && up.NewNameIndex >= 0) 402 prop = (*NewNames)[up.NewNameIndex]; 403 else if (propID == kpidComment 404 && CommentIndex >= 0 405 && (unsigned)CommentIndex == index 406 && Comment) 407 prop = *Comment; 408 else if (propID == kpidShortName && up.NewNameIndex >= 0 && up.IsMainRenameItem) 409 { 410 // we can generate new ShortName here; 411 } 412 else if ((up.UseArcProps || (KeepOriginalItemNames && (propID == kpidPath || propID == kpidIsAltStream))) 413 && up.ExistInArchive() && Archive) 414 return Archive->GetProperty(ArcItems ? (*ArcItems)[up.ArcIndex].IndexInServer : up.ArcIndex, propID, value); 415 else if (up.ExistOnDisk()) 416 { 417 const CDirItem &di = DirItems->Items[up.DirIndex]; 418 switch (propID) 419 { 420 case kpidPath: prop = DirItems->GetLogPath(up.DirIndex); break; 421 case kpidIsDir: prop = di.IsDir(); break; 422 case kpidSize: prop = di.IsDir() ? (UInt64)0 : di.Size; break; 423 case kpidAttrib: prop = di.Attrib; break; 424 case kpidCTime: prop = di.CTime; break; 425 case kpidATime: prop = di.ATime; break; 426 case kpidMTime: prop = di.MTime; break; 427 case kpidIsAltStream: prop = di.IsAltStream; break; 428 #if defined(_WIN32) && !defined(UNDER_CE) 429 // case kpidShortName: prop = di.ShortName; break; 430 #endif 431 } 432 } 433 prop.Detach(value); 434 return S_OK; 435 COM_TRY_END 436 } 437 438 #ifndef _7ZIP_ST 439 static NSynchronization::CCriticalSection CS; 440 #endif 441 442 STDMETHODIMP CArchiveUpdateCallback::GetStream2(UInt32 index, ISequentialInStream **inStream, UInt32 mode) 443 { 444 COM_TRY_BEGIN 445 *inStream = NULL; 446 const CUpdatePair2 &up = (*UpdatePairs)[index]; 447 if (!up.NewData) 448 return E_FAIL; 449 450 RINOK(Callback->CheckBreak()); 451 // RINOK(Callback->Finalize()); 452 453 bool isDir = IsDir(up); 454 455 if (up.IsAnti) 456 { 457 UString name; 458 if (up.ArcIndex >= 0) 459 name = (*ArcItems)[up.ArcIndex].Name; 460 else if (up.DirIndex >= 0) 461 name = DirItems->GetLogPath(up.DirIndex); 462 RINOK(Callback->GetStream(name, isDir, true, mode)); 463 464 /* 9.33: fixed. Handlers expect real stream object for files, even for anti-file. 465 so we return empty stream */ 466 467 if (!isDir) 468 { 469 CBufInStream *inStreamSpec = new CBufInStream(); 470 CMyComPtr<ISequentialInStream> inStreamLoc = inStreamSpec; 471 inStreamSpec->Init(NULL, 0); 472 *inStream = inStreamLoc.Detach(); 473 } 474 return S_OK; 475 } 476 477 RINOK(Callback->GetStream(DirItems->GetLogPath(up.DirIndex), isDir, false, mode)); 478 479 if (isDir) 480 return S_OK; 481 482 if (StdInMode) 483 { 484 if (mode != NUpdateNotifyOp::kAdd && 485 mode != NUpdateNotifyOp::kUpdate) 486 return S_OK; 487 488 CStdInFileStream *inStreamSpec = new CStdInFileStream; 489 CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec); 490 *inStream = inStreamLoc.Detach(); 491 } 492 else 493 { 494 CInFileStream *inStreamSpec = new CInFileStream; 495 CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec); 496 497 inStreamSpec->SupportHardLinks = StoreHardLinks; 498 inStreamSpec->Callback = this; 499 inStreamSpec->CallbackRef = index; 500 501 const FString path = DirItems->GetPhyPath(up.DirIndex); 502 _openFiles_Indexes.Add(index); 503 _openFiles_Paths.Add(path); 504 505 #if defined(_WIN32) && !defined(UNDER_CE) 506 if (DirItems->Items[up.DirIndex].AreReparseData()) 507 { 508 if (!inStreamSpec->File.OpenReparse(path)) 509 { 510 return Callback->OpenFileError(path, ::GetLastError()); 511 } 512 } 513 else 514 #endif 515 if (!inStreamSpec->OpenShared(path, ShareForWrite)) 516 { 517 DWORD error = ::GetLastError(); 518 HRESULT hres = Callback->OpenFileError(path, error); 519 if (StopAfterOpenError) 520 if (hres == S_OK || hres == S_FALSE) 521 return HRESULT_FROM_WIN32(error); 522 return hres; 523 } 524 525 if (StoreHardLinks) 526 { 527 CStreamFileProps props; 528 if (inStreamSpec->GetProps2(&props) == S_OK) 529 { 530 if (props.NumLinks > 1) 531 { 532 CKeyKeyValPair pair; 533 pair.Key1 = props.VolID; 534 pair.Key2 = props.FileID_Low; 535 pair.Value = index; 536 unsigned numItems = _map.Size(); 537 unsigned pairIndex = _map.AddToUniqueSorted2(pair); 538 if (numItems == _map.Size()) 539 { 540 // const CKeyKeyValPair &pair2 = _map.Pairs[pairIndex]; 541 _hardIndex_From = index; 542 _hardIndex_To = pairIndex; 543 // we could return NULL as stream, but it's better to return real stream 544 // return S_OK; 545 } 546 } 547 } 548 } 549 550 if (ProcessedItemsStatuses) 551 { 552 #ifndef _7ZIP_ST 553 NSynchronization::CCriticalSectionLock lock(CS); 554 #endif 555 ProcessedItemsStatuses[(unsigned)up.DirIndex] = 1; 556 } 557 *inStream = inStreamLoc.Detach(); 558 } 559 560 return S_OK; 561 COM_TRY_END 562 } 563 564 STDMETHODIMP CArchiveUpdateCallback::SetOperationResult(Int32 opRes) 565 { 566 COM_TRY_BEGIN 567 return Callback->SetOperationResult(opRes); 568 COM_TRY_END 569 } 570 571 STDMETHODIMP CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream) 572 { 573 COM_TRY_BEGIN 574 return GetStream2(index, inStream, 575 (*UpdatePairs)[index].ArcIndex < 0 ? 576 NUpdateNotifyOp::kAdd : 577 NUpdateNotifyOp::kUpdate); 578 COM_TRY_END 579 } 580 581 STDMETHODIMP CArchiveUpdateCallback::ReportOperation(UInt32 indexType, UInt32 index, UInt32 op) 582 { 583 COM_TRY_BEGIN 584 585 bool isDir = false; 586 587 if (indexType == NArchive::NEventIndexType::kOutArcIndex) 588 { 589 UString name; 590 if (index != (UInt32)(Int32)-1) 591 { 592 const CUpdatePair2 &up = (*UpdatePairs)[index]; 593 if (up.ExistOnDisk()) 594 { 595 name = DirItems->GetLogPath(up.DirIndex); 596 isDir = DirItems->Items[up.DirIndex].IsDir(); 597 } 598 } 599 return Callback->ReportUpdateOpeartion(op, name.IsEmpty() ? NULL : name.Ptr(), isDir); 600 } 601 602 wchar_t temp[16]; 603 UString s2; 604 const wchar_t *s = NULL; 605 606 if (indexType == NArchive::NEventIndexType::kInArcIndex) 607 { 608 if (index != (UInt32)(Int32)-1) 609 { 610 if (ArcItems) 611 { 612 const CArcItem &ai = (*ArcItems)[index]; 613 s = ai.Name; 614 isDir = ai.IsDir; 615 } 616 else if (Arc) 617 { 618 RINOK(Arc->GetItemPath(index, s2)); 619 s = s2; 620 RINOK(Archive_IsItem_Dir(Arc->Archive, index, isDir)); 621 } 622 } 623 } 624 else if (indexType == NArchive::NEventIndexType::kBlockIndex) 625 { 626 temp[0] = '#'; 627 ConvertUInt32ToString(index, temp + 1); 628 s = temp; 629 } 630 631 if (!s) 632 s = L""; 633 634 return Callback->ReportUpdateOpeartion(op, s, isDir); 635 636 COM_TRY_END 637 } 638 639 STDMETHODIMP CArchiveUpdateCallback::ReportExtractResult(UInt32 indexType, UInt32 index, Int32 opRes) 640 { 641 COM_TRY_BEGIN 642 643 bool isEncrypted = false; 644 wchar_t temp[16]; 645 UString s2; 646 const wchar_t *s = NULL; 647 648 if (indexType == NArchive::NEventIndexType::kOutArcIndex) 649 { 650 /* 651 UString name; 652 if (index != (UInt32)(Int32)-1) 653 { 654 const CUpdatePair2 &up = (*UpdatePairs)[index]; 655 if (up.ExistOnDisk()) 656 { 657 s2 = DirItems->GetLogPath(up.DirIndex); 658 s = s2; 659 } 660 } 661 */ 662 return E_FAIL; 663 } 664 665 if (indexType == NArchive::NEventIndexType::kInArcIndex) 666 { 667 if (index != (UInt32)(Int32)-1) 668 { 669 if (ArcItems) 670 s = (*ArcItems)[index].Name; 671 else if (Arc) 672 { 673 RINOK(Arc->GetItemPath(index, s2)); 674 s = s2; 675 } 676 if (Archive) 677 { 678 RINOK(Archive_GetItemBoolProp(Archive, index, kpidEncrypted, isEncrypted)); 679 } 680 } 681 } 682 else if (indexType == NArchive::NEventIndexType::kBlockIndex) 683 { 684 temp[0] = '#'; 685 ConvertUInt32ToString(index, temp + 1); 686 s = temp; 687 } 688 689 return Callback->ReportExtractResult(opRes, BoolToInt(isEncrypted), s); 690 691 COM_TRY_END 692 } 693 694 STDMETHODIMP CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size) 695 { 696 if (VolumesSizes.Size() == 0) 697 return S_FALSE; 698 if (index >= (UInt32)VolumesSizes.Size()) 699 index = VolumesSizes.Size() - 1; 700 *size = VolumesSizes[index]; 701 return S_OK; 702 } 703 704 STDMETHODIMP CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream) 705 { 706 COM_TRY_BEGIN 707 char temp[16]; 708 ConvertUInt32ToString(index + 1, temp); 709 FString res (temp); 710 while (res.Len() < 2) 711 res.InsertAtFront(FTEXT('0')); 712 FString fileName = VolName; 713 fileName += '.'; 714 fileName += res; 715 fileName += VolExt; 716 COutFileStream *streamSpec = new COutFileStream; 717 CMyComPtr<ISequentialOutStream> streamLoc(streamSpec); 718 if (!streamSpec->Create(fileName, false)) 719 return ::GetLastError(); 720 *volumeStream = streamLoc.Detach(); 721 return S_OK; 722 COM_TRY_END 723 } 724 725 STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password) 726 { 727 COM_TRY_BEGIN 728 return Callback->CryptoGetTextPassword2(passwordIsDefined, password); 729 COM_TRY_END 730 } 731 732 STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword(BSTR *password) 733 { 734 COM_TRY_BEGIN 735 return Callback->CryptoGetTextPassword(password); 736 COM_TRY_END 737 } 738 739 HRESULT CArchiveUpdateCallback::InFileStream_On_Error(UINT_PTR val, DWORD error) 740 { 741 if (error == ERROR_LOCK_VIOLATION) 742 { 743 MT_LOCK 744 UInt32 index = (UInt32)val; 745 FOR_VECTOR(i, _openFiles_Indexes) 746 { 747 if (_openFiles_Indexes[i] == index) 748 { 749 RINOK(Callback->ReadingFileError(_openFiles_Paths[i], error)); 750 break; 751 } 752 } 753 } 754 return HRESULT_FROM_WIN32(error); 755 } 756 757 void CArchiveUpdateCallback::InFileStream_On_Destroy(UINT_PTR val) 758 { 759 MT_LOCK 760 UInt32 index = (UInt32)val; 761 FOR_VECTOR(i, _openFiles_Indexes) 762 { 763 if (_openFiles_Indexes[i] == index) 764 { 765 _openFiles_Indexes.Delete(i); 766 _openFiles_Paths.Delete(i); 767 return; 768 } 769 } 770 throw 20141125; 771 }