vcs.maemo.org Git - physicsfs/blob - lzma/CPP/7zip/UI/Client7z/Client7z.cpp

   1 // Client7z.cpp
   2
   3 #include "StdAfx.h"
   4
   5 #include "Common/MyInitGuid.h"
   6 #include "Common/StringConvert.h"
   7 #include "Common/IntToString.h"
   8
   9 #include "Windows/PropVariant.h"
  10 #include "Windows/PropVariantConversions.h"
  11 #include "Windows/DLL.h"
  12 #include "Windows/FileDir.h"
  13 #include "Windows/FileName.h"
  14 #include "Windows/FileFind.h"
  15
  16 #include "../../Common/FileStreams.h"
  17 #include "../../Archive/IArchive.h"
  18 #include "../../IPassword.h"
  19 #include "../../MyVersion.h"
  20
  21
  22 // {23170F69-40C1-278A-1000-000110070000}
  23 DEFINE_GUID(CLSID_CFormat7z,
  24   0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x07, 0x00, 0x00);
  25
  26 using namespace NWindows;
  27
  28 #define kDllName "7z.dll"
  29
  30 static const char *kCopyrightString = MY_7ZIP_VERSION
  31 " ("  kDllName " client) "
  32 MY_COPYRIGHT " " MY_DATE;
  33
  34 static const char *kHelpString =
  35 "Usage: Client7z.exe [a | l | x ] archive.7z [fileName ...]\n"
  36 "Examples:\n"
  37 "  Client7z.exe a archive.7z f1.txt f2.txt  : compress two files to archive.7z\n"
  38 "  Client7z.exe l archive.7z   : List contents of archive.7z\n"
  39 "  Client7z.exe x archive.7z   : eXtract files from archive.7z\n";
  40
  41
  42 typedef UINT32 (WINAPI * CreateObjectFunc)(
  43     const GUID *clsID,
  44     const GUID *interfaceID,
  45     void **outObject);
  46
  47 #ifdef _WIN32
  48 #ifndef _UNICODE
  49 bool g_IsNT = false;
  50 static inline bool IsItWindowsNT()
  51 {
  52   OSVERSIONINFO versionInfo;
  53   versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
  54   if (!::GetVersionEx(&versionInfo))
  55     return false;
  56   return (versionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
  57 }
  58 #endif
  59 #endif
  60
  61 void PrintString(const UString &s)
  62 {
  63   printf("%s", (LPCSTR)GetOemString(s));
  64 }
  65
  66 void PrintString(const AString &s)
  67 {
  68   printf("%s", (LPCSTR)s);
  69 }
  70
  71 void PrintNewLine()
  72 {
  73   PrintString("\n");
  74 }
  75
  76 void PrintStringLn(const AString &s)
  77 {
  78   PrintString(s);
  79   PrintNewLine();
  80 }
  81
  82 void PrintError(const AString &s)
  83 {
  84   PrintNewLine();
  85   PrintString(s);
  86   PrintNewLine();
  87 }
  88
  89 static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)
  90 {
  91   NCOM::CPropVariant prop;
  92   RINOK(archive->GetProperty(index, propID, &prop));
  93   if(prop.vt == VT_BOOL)
  94     result = VARIANT_BOOLToBool(prop.boolVal);
  95   else if (prop.vt == VT_EMPTY)
  96     result = false;
  97   else
  98     return E_FAIL;
  99   return S_OK;
 100 }
 101
 102 static HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result)
 103 {
 104   return IsArchiveItemProp(archive, index, kpidIsFolder, result);
 105 }
 106
 107
 108 static const wchar_t *kEmptyFileAlias = L"[Content]";
 109
 110
 111 //////////////////////////////////////////////////////////////
 112 // Archive Open callback class
 113
 114
 115 class CArchiveOpenCallback:
 116   public IArchiveOpenCallback,
 117   public ICryptoGetTextPassword,
 118   public CMyUnknownImp
 119 {
 120 public:
 121   MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
 122
 123   STDMETHOD(SetTotal)(const UInt64 *files, const UInt64 *bytes);
 124   STDMETHOD(SetCompleted)(const UInt64 *files, const UInt64 *bytes);
 125
 126   STDMETHOD(CryptoGetTextPassword)(BSTR *password);
 127
 128   bool PasswordIsDefined;
 129   UString Password;
 130
 131   CArchiveOpenCallback() : PasswordIsDefined(false) {}
 132 };
 133
 134 STDMETHODIMP CArchiveOpenCallback::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */)
 135 {
 136   return S_OK;
 137 }
 138
 139 STDMETHODIMP CArchiveOpenCallback::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */)
 140 {
 141   return S_OK;
 142 }
 143
 144 STDMETHODIMP CArchiveOpenCallback::CryptoGetTextPassword(BSTR *password)
 145 {
 146   if (!PasswordIsDefined)
 147   {
 148     // You can ask real password here from user
 149     // Password = GetPassword(OutStream);
 150     // PasswordIsDefined = true;
 151     PrintError("Password is not defined");
 152     return E_ABORT;
 153   }
 154   CMyComBSTR tempName(Password);
 155   *password = tempName.Detach();
 156   return S_OK;
 157 }
 158
 159
 160 //////////////////////////////////////////////////////////////
 161 // Archive Extracting callback class
 162
 163 static const wchar_t *kCantDeleteOutputFile = L"ERROR: Can not delete output file ";
 164
 165 static const char *kTestingString    =  "Testing     ";
 166 static const char *kExtractingString =  "Extracting  ";
 167 static const char *kSkippingString   =  "Skipping    ";
 168
 169 static const char *kUnsupportedMethod = "Unsupported Method";
 170 static const char *kCRCFailed = "CRC Failed";
 171 static const char *kDataError = "Data Error";
 172 static const char *kUnknownError = "Unknown Error";
 173
 174 class CArchiveExtractCallback:
 175   public IArchiveExtractCallback,
 176   public ICryptoGetTextPassword,
 177   public CMyUnknownImp
 178 {
 179 public:
 180   MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
 181
 182   // IProgress
 183   STDMETHOD(SetTotal)(UInt64 size);
 184   STDMETHOD(SetCompleted)(const UInt64 *completeValue);
 185
 186   // IArchiveExtractCallback
 187   STDMETHOD(GetStream)(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode);
 188   STDMETHOD(PrepareOperation)(Int32 askExtractMode);
 189   STDMETHOD(SetOperationResult)(Int32 resultEOperationResult);
 190
 191   // ICryptoGetTextPassword
 192   STDMETHOD(CryptoGetTextPassword)(BSTR *aPassword);
 193
 194 private:
 195   CMyComPtr<IInArchive> _archiveHandler;
 196   UString _directoryPath;  // Output directory
 197   UString _filePath;       // name inside arcvhive
 198   UString _diskFilePath;   // full path to file on disk
 199   bool _extractMode;
 200   struct CProcessedFileInfo
 201   {
 202     FILETIME UTCLastWriteTime;
 203     UInt32 Attributes;
 204     bool IsDirectory;
 205     bool AttributesAreDefined;
 206     bool UTCLastWriteTimeIsDefined;
 207   } _processedFileInfo;
 208
 209   COutFileStream *_outFileStreamSpec;
 210   CMyComPtr<ISequentialOutStream> _outFileStream;
 211
 212 public:
 213   void Init(IInArchive *archiveHandler, const UString &directoryPath);
 214
 215   UInt64 NumErrors;
 216   bool PasswordIsDefined;
 217   UString Password;
 218
 219   CArchiveExtractCallback() : PasswordIsDefined(false) {}
 220 };
 221
 222 void CArchiveExtractCallback::Init(IInArchive *archiveHandler, const UString &directoryPath)
 223 {
 224   NumErrors = 0;
 225   _archiveHandler = archiveHandler;
 226   _directoryPath = directoryPath;
 227   NFile::NName::NormalizeDirPathPrefix(_directoryPath);
 228 }
 229
 230 STDMETHODIMP CArchiveExtractCallback::SetTotal(UInt64 /* size */)
 231 {
 232   return S_OK;
 233 }
 234
 235 STDMETHODIMP CArchiveExtractCallback::SetCompleted(const UInt64 * /* completeValue */)
 236 {
 237   return S_OK;
 238 }
 239
 240 STDMETHODIMP CArchiveExtractCallback::GetStream(UInt32 index,
 241     ISequentialOutStream **outStream, Int32 askExtractMode)
 242 {
 243   *outStream = 0;
 244   _outFileStream.Release();
 245
 246   {
 247     // Get Name
 248     NCOM::CPropVariant propVariant;
 249     RINOK(_archiveHandler->GetProperty(index, kpidPath, &propVariant));
 250
 251     UString fullPath;
 252     if(propVariant.vt == VT_EMPTY)
 253       fullPath = kEmptyFileAlias;
 254     else
 255     {
 256       if(propVariant.vt != VT_BSTR)
 257         return E_FAIL;
 258       fullPath = propVariant.bstrVal;
 259     }
 260     _filePath = fullPath;
 261   }
 262
 263   if (askExtractMode != NArchive::NExtract::NAskMode::kExtract)
 264     return S_OK;
 265
 266   {
 267     // Get Attributes
 268     NCOM::CPropVariant propVariant;
 269     RINOK(_archiveHandler->GetProperty(index, kpidAttributes, &propVariant));
 270     if (propVariant.vt == VT_EMPTY)
 271     {
 272       _processedFileInfo.Attributes = 0;
 273       _processedFileInfo.AttributesAreDefined = false;
 274     }
 275     else
 276     {
 277       if (propVariant.vt != VT_UI4)
 278         throw "incorrect item";
 279       _processedFileInfo.Attributes = propVariant.ulVal;
 280       _processedFileInfo.AttributesAreDefined = true;
 281     }
 282   }
 283
 284   RINOK(IsArchiveItemFolder(_archiveHandler, index, _processedFileInfo.IsDirectory));
 285
 286   {
 287     // Get Modified Time
 288     NCOM::CPropVariant propVariant;
 289     RINOK(_archiveHandler->GetProperty(index, kpidLastWriteTime, &propVariant));
 290     _processedFileInfo.UTCLastWriteTimeIsDefined = false;
 291     switch(propVariant.vt)
 292     {
 293       case VT_EMPTY:
 294         // _processedFileInfo.UTCLastWriteTime = _utcLastWriteTimeDefault;
 295         break;
 296       case VT_FILETIME:
 297         _processedFileInfo.UTCLastWriteTime = propVariant.filetime;
 298         _processedFileInfo.UTCLastWriteTimeIsDefined = true;
 299         break;
 300       default:
 301         return E_FAIL;
 302     }
 303
 304   }
 305   {
 306     // Get Size
 307     NCOM::CPropVariant propVariant;
 308     RINOK(_archiveHandler->GetProperty(index, kpidSize, &propVariant));
 309     bool newFileSizeDefined = (propVariant.vt != VT_EMPTY);
 310     UInt64 newFileSize;
 311     if (newFileSizeDefined)
 312       newFileSize = ConvertPropVariantToUInt64(propVariant);
 313   }
 314
 315
 316   {
 317     // Create folders for file
 318     int slashPos = _filePath.ReverseFind(WCHAR_PATH_SEPARATOR);
 319     if (slashPos >= 0)
 320       NFile::NDirectory::CreateComplexDirectory(_directoryPath + _filePath.Left(slashPos));
 321   }
 322
 323   UString fullProcessedPath = _directoryPath + _filePath;
 324   _diskFilePath = fullProcessedPath;
 325
 326   if (_processedFileInfo.IsDirectory)
 327   {
 328     NFile::NDirectory::CreateComplexDirectory(fullProcessedPath);
 329   }
 330   else
 331   {
 332     NFile::NFind::CFileInfoW fileInfo;
 333     if(NFile::NFind::FindFile(fullProcessedPath, fileInfo))
 334     {
 335       if (!NFile::NDirectory::DeleteFileAlways(fullProcessedPath))
 336       {
 337         PrintString(UString(kCantDeleteOutputFile) + fullProcessedPath);
 338         return E_ABORT;
 339       }
 340     }
 341
 342     _outFileStreamSpec = new COutFileStream;
 343     CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
 344     if (!_outFileStreamSpec->Open(fullProcessedPath, CREATE_ALWAYS))
 345     {
 346       PrintString((UString)L"can not open output file " + fullProcessedPath);
 347       return E_ABORT;
 348     }
 349     _outFileStream = outStreamLoc;
 350     *outStream = outStreamLoc.Detach();
 351   }
 352   return S_OK;
 353 }
 354
 355 STDMETHODIMP CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode)
 356 {
 357   _extractMode = false;
 358   switch (askExtractMode)
 359   {
 360     case NArchive::NExtract::NAskMode::kExtract:
 361       _extractMode = true;
 362   };
 363   switch (askExtractMode)
 364   {
 365     case NArchive::NExtract::NAskMode::kExtract:
 366       PrintString(kExtractingString);
 367       break;
 368     case NArchive::NExtract::NAskMode::kTest:
 369       PrintString(kTestingString);
 370       break;
 371     case NArchive::NExtract::NAskMode::kSkip:
 372       PrintString(kSkippingString);
 373       break;
 374   };
 375   PrintString(_filePath);
 376   return S_OK;
 377 }
 378
 379 STDMETHODIMP CArchiveExtractCallback::SetOperationResult(Int32 operationResult)
 380 {
 381   switch(operationResult)
 382   {
 383     case NArchive::NExtract::NOperationResult::kOK:
 384       break;
 385     default:
 386     {
 387       NumErrors++;
 388       PrintString("     ");
 389       switch(operationResult)
 390       {
 391         case NArchive::NExtract::NOperationResult::kUnSupportedMethod:
 392           PrintString(kUnsupportedMethod);
 393           break;
 394         case NArchive::NExtract::NOperationResult::kCRCError:
 395           PrintString(kCRCFailed);
 396           break;
 397         case NArchive::NExtract::NOperationResult::kDataError:
 398           PrintString(kDataError);
 399           break;
 400         default:
 401           PrintString(kUnknownError);
 402       }
 403     }
 404   }
 405
 406   if (_outFileStream != NULL)
 407   {
 408     if (_processedFileInfo.UTCLastWriteTimeIsDefined)
 409       _outFileStreamSpec->SetLastWriteTime(&_processedFileInfo.UTCLastWriteTime);
 410     RINOK(_outFileStreamSpec->Close());
 411   }
 412   _outFileStream.Release();
 413   if (_extractMode && _processedFileInfo.AttributesAreDefined)
 414     NFile::NDirectory::MySetFileAttributes(_diskFilePath, _processedFileInfo.Attributes);
 415   PrintNewLine();
 416   return S_OK;
 417 }
 418
 419
 420 STDMETHODIMP CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password)
 421 {
 422   if (!PasswordIsDefined)
 423   {
 424     // You can ask real password here from user
 425     // Password = GetPassword(OutStream);
 426     // PasswordIsDefined = true;
 427     PrintError("Password is not defined");
 428     return E_ABORT;
 429   }
 430   CMyComBSTR tempName(Password);
 431   *password = tempName.Detach();
 432   return S_OK;
 433 }
 434
 435
 436
 437 //////////////////////////////////////////////////////////////
 438 // Archive Creating callback class
 439
 440 struct CDirItem
 441 {
 442   UInt32 Attributes;
 443   FILETIME CreationTime;
 444   FILETIME LastAccessTime;
 445   FILETIME LastWriteTime;
 446   UInt64 Size;
 447   UString Name;
 448   UString FullPath;
 449   bool IsDirectory() const { return (Attributes & FILE_ATTRIBUTE_DIRECTORY) != 0 ; }
 450 };
 451
 452 class CArchiveUpdateCallback:
 453   public IArchiveUpdateCallback2,
 454   public ICryptoGetTextPassword2,
 455   public CMyUnknownImp
 456 {
 457 public:
 458   MY_UNKNOWN_IMP2(IArchiveUpdateCallback2, ICryptoGetTextPassword2)
 459
 460   // IProgress
 461   STDMETHOD(SetTotal)(UInt64 size);
 462   STDMETHOD(SetCompleted)(const UInt64 *completeValue);
 463
 464   // IUpdateCallback2
 465   STDMETHOD(EnumProperties)(IEnumSTATPROPSTG **enumerator);
 466   STDMETHOD(GetUpdateItemInfo)(UInt32 index,
 467       Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive);
 468   STDMETHOD(GetProperty)(UInt32 index, PROPID propID, PROPVARIANT *value);
 469   STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **inStream);
 470   STDMETHOD(SetOperationResult)(Int32 operationResult);
 471   STDMETHOD(GetVolumeSize)(UInt32 index, UInt64 *size);
 472   STDMETHOD(GetVolumeStream)(UInt32 index, ISequentialOutStream **volumeStream);
 473
 474   STDMETHOD(CryptoGetTextPassword2)(Int32 *passwordIsDefined, BSTR *password);
 475
 476 public:
 477   CRecordVector<UInt64> VolumesSizes;
 478   UString VolName;
 479   UString VolExt;
 480
 481   UString DirPrefix;
 482   const CObjectVector<CDirItem> *DirItems;
 483
 484   bool PasswordIsDefined;
 485   UString Password;
 486   bool AskPassword;
 487
 488   bool m_NeedBeClosed;
 489
 490   UStringVector FailedFiles;
 491   CRecordVector<HRESULT> FailedCodes;
 492
 493   CArchiveUpdateCallback(): PasswordIsDefined(false), AskPassword(false), DirItems(0) {};
 494
 495   ~CArchiveUpdateCallback() { Finilize(); }
 496   HRESULT Finilize();
 497
 498   void Init(const CObjectVector<CDirItem> *dirItems)
 499   {
 500     DirItems = dirItems;
 501     m_NeedBeClosed = false;
 502     FailedFiles.Clear();
 503     FailedCodes.Clear();
 504   }
 505 };
 506
 507 STDMETHODIMP CArchiveUpdateCallback::SetTotal(UInt64 /* size */)
 508 {
 509   return S_OK;
 510 }
 511
 512 STDMETHODIMP CArchiveUpdateCallback::SetCompleted(const UInt64 * /* completeValue */)
 513 {
 514   return S_OK;
 515 }
 516
 517
 518 STDMETHODIMP CArchiveUpdateCallback::EnumProperties(IEnumSTATPROPSTG ** /* enumerator */)
 519 {
 520   return E_NOTIMPL;
 521 }
 522
 523 STDMETHODIMP CArchiveUpdateCallback::GetUpdateItemInfo(UInt32 /* index */,
 524       Int32 *newData, Int32 *newProperties, UInt32 *indexInArchive)
 525 {
 526   if(newData != NULL)
 527     *newData = BoolToInt(true);
 528   if(newProperties != NULL)
 529     *newProperties = BoolToInt(true);
 530   if(indexInArchive != NULL)
 531     *indexInArchive = UInt32(-1);
 532   return S_OK;
 533 }
 534
 535 STDMETHODIMP CArchiveUpdateCallback::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 536 {
 537   NWindows::NCOM::CPropVariant propVariant;
 538
 539   if (propID == kpidIsAnti)
 540   {
 541     propVariant = false;
 542     propVariant.Detach(value);
 543     return S_OK;
 544   }
 545
 546   {
 547     const CDirItem &dirItem = (*DirItems)[index];
 548     switch(propID)
 549     {
 550       case kpidPath:
 551         propVariant = dirItem.Name;
 552         break;
 553       case kpidIsFolder:
 554         propVariant = dirItem.IsDirectory();
 555         break;
 556       case kpidSize:
 557         propVariant = dirItem.Size;
 558         break;
 559       case kpidAttributes:
 560         propVariant = dirItem.Attributes;
 561         break;
 562       case kpidLastAccessTime:
 563         propVariant = dirItem.LastAccessTime;
 564         break;
 565       case kpidCreationTime:
 566         propVariant = dirItem.CreationTime;
 567         break;
 568       case kpidLastWriteTime:
 569         propVariant = dirItem.LastWriteTime;
 570         break;
 571     }
 572   }
 573   propVariant.Detach(value);
 574   return S_OK;
 575 }
 576
 577 HRESULT CArchiveUpdateCallback::Finilize()
 578 {
 579   if (m_NeedBeClosed)
 580   {
 581     PrintNewLine();
 582     m_NeedBeClosed = false;
 583   }
 584   return S_OK;
 585 }
 586
 587 static void GetStream2(const wchar_t *name)
 588 {
 589   PrintString("Compressing  ");
 590   if (name[0] == 0)
 591     name = kEmptyFileAlias;
 592   PrintString(name);
 593 }
 594
 595 STDMETHODIMP CArchiveUpdateCallback::GetStream(UInt32 index, ISequentialInStream **inStream)
 596 {
 597   RINOK(Finilize());
 598
 599   const CDirItem &dirItem = (*DirItems)[index];
 600   GetStream2(dirItem.Name);
 601
 602   if(dirItem.IsDirectory())
 603     return S_OK;
 604
 605   {
 606     CInFileStream *inStreamSpec = new CInFileStream;
 607     CMyComPtr<ISequentialInStream> inStreamLoc(inStreamSpec);
 608     UString path = DirPrefix + dirItem.FullPath;
 609     if(!inStreamSpec->Open(path))
 610     {
 611       DWORD sysError = ::GetLastError();
 612       FailedCodes.Add(sysError);
 613       FailedFiles.Add(path);
 614       // if (systemError == ERROR_SHARING_VIOLATION)
 615       {
 616         PrintNewLine();
 617         PrintError("WARNING: can't open file");
 618         // PrintString(NError::MyFormatMessageW(systemError));
 619         return S_FALSE;
 620       }
 621       // return sysError;
 622     }
 623     *inStream = inStreamLoc.Detach();
 624   }
 625   return S_OK;
 626 }
 627
 628 STDMETHODIMP CArchiveUpdateCallback::SetOperationResult(Int32 /* operationResult */)
 629 {
 630   m_NeedBeClosed = true;
 631   return S_OK;
 632 }
 633
 634 STDMETHODIMP CArchiveUpdateCallback::GetVolumeSize(UInt32 index, UInt64 *size)
 635 {
 636   if (VolumesSizes.Size() == 0)
 637     return S_FALSE;
 638   if (index >= (UInt32)VolumesSizes.Size())
 639     index = VolumesSizes.Size() - 1;
 640   *size = VolumesSizes[index];
 641   return S_OK;
 642 }
 643
 644 STDMETHODIMP CArchiveUpdateCallback::GetVolumeStream(UInt32 index, ISequentialOutStream **volumeStream)
 645 {
 646   wchar_t temp[32];
 647   ConvertUInt64ToString(index + 1, temp);
 648   UString res = temp;
 649   while (res.Length() < 2)
 650     res = UString(L'0') + res;
 651   UString fileName = VolName;
 652   fileName += L'.';
 653   fileName += res;
 654   fileName += VolExt;
 655   COutFileStream *streamSpec = new COutFileStream;
 656   CMyComPtr<ISequentialOutStream> streamLoc(streamSpec);
 657   if(!streamSpec->Create(fileName, false))
 658     return ::GetLastError();
 659   *volumeStream = streamLoc.Detach();
 660   return S_OK;
 661 }
 662
 663 STDMETHODIMP CArchiveUpdateCallback::CryptoGetTextPassword2(Int32 *passwordIsDefined, BSTR *password)
 664 {
 665   if (!PasswordIsDefined)
 666   {
 667     if (AskPassword)
 668     {
 669       // You can ask real password here from user
 670       // Password = GetPassword(OutStream);
 671       // PasswordIsDefined = true;
 672       PrintError("Password is not defined");
 673       return E_ABORT;
 674     }
 675   }
 676   *passwordIsDefined = BoolToInt(PasswordIsDefined);
 677   CMyComBSTR tempName(Password);
 678   *password = tempName.Detach();
 679   return S_OK;
 680 }
 681
 682
 683
 684 //////////////////////////////////////////////////////////////////////////
 685 // Main function
 686
 687 int
 688 #ifdef _MSC_VER
 689 __cdecl
 690 #endif
 691 main(int argc, char* argv[])
 692 {
 693   #ifdef _WIN32
 694   #ifndef _UNICODE
 695   g_IsNT = IsItWindowsNT();
 696   #endif
 697   #endif
 698
 699   PrintStringLn(kCopyrightString);
 700
 701   if (argc < 3)
 702   {
 703     PrintStringLn(kHelpString);
 704     return 1;
 705   }
 706   NWindows::NDLL::CLibrary library;
 707   if (!library.Load(TEXT(kDllName)))
 708   {
 709     PrintError("Can not load library");
 710     return 1;
 711   }
 712   CreateObjectFunc createObjectFunc = (CreateObjectFunc)library.GetProcAddress("CreateObject");
 713   if (createObjectFunc == 0)
 714   {
 715     PrintError("Can not get CreateObject");
 716     return 1;
 717   }
 718
 719   AString command = argv[1];
 720   UString archiveName = GetUnicodeString(argv[2], CP_OEMCP);
 721   if (command.CompareNoCase("a") == 0)
 722   {
 723     // create archive command
 724     if (argc < 4)
 725     {
 726       PrintStringLn(kHelpString);
 727       return 1;
 728     }
 729     CObjectVector<CDirItem> dirItems;
 730     int i;
 731     for (i = 3; i < argc; i++)
 732     {
 733       CDirItem item;
 734       UString name = GetUnicodeString(argv[i], CP_OEMCP);
 735
 736       NFile::NFind::CFileInfoW fileInfo;
 737       if (!NFile::NFind::FindFile(name, fileInfo))
 738       {
 739         PrintString(UString(L"Can't find file") + name);
 740         return 1;
 741       }
 742
 743       item.Attributes = fileInfo.Attributes;
 744       item.Size = fileInfo.Size;
 745       item.CreationTime = fileInfo.CreationTime;
 746       item.LastAccessTime = fileInfo.LastAccessTime;
 747       item.LastWriteTime = fileInfo.LastWriteTime;
 748       item.Name = name;
 749       item.FullPath = name;
 750       dirItems.Add(item);
 751     }
 752     COutFileStream *outFileStreamSpec = new COutFileStream;
 753     CMyComPtr<IOutStream> outFileStream = outFileStreamSpec;
 754     if (!outFileStreamSpec->Create(archiveName, false))
 755     {
 756       PrintError("can't create archive file");
 757       return 1;
 758     }
 759
 760     CMyComPtr<IOutArchive> outArchive;
 761     if (createObjectFunc(&CLSID_CFormat7z, &IID_IOutArchive, (void **)&outArchive) != S_OK)
 762     {
 763       PrintError("Can not get class object");
 764       return 1;
 765     }
 766
 767     CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
 768     CMyComPtr<IArchiveUpdateCallback2> updateCallback(updateCallbackSpec);
 769     updateCallbackSpec->Init(&dirItems);
 770     // updateCallbackSpec->PasswordIsDefined = true;
 771     // updateCallbackSpec->Password = L"1";
 772
 773     HRESULT result = outArchive->UpdateItems(outFileStream, dirItems.Size(), updateCallback);
 774     updateCallbackSpec->Finilize();
 775     if (result != S_OK)
 776     {
 777       PrintError("Update Error");
 778       return 1;
 779     }
 780     for (i = 0; i < updateCallbackSpec->FailedFiles.Size(); i++)
 781     {
 782       PrintNewLine();
 783       PrintString((UString)L"Error for file: " + updateCallbackSpec->FailedFiles[i]);
 784     }
 785     if (updateCallbackSpec->FailedFiles.Size() != 0)
 786       return 1;
 787   }
 788   else
 789   {
 790     if (argc != 3)
 791     {
 792       PrintStringLn(kHelpString);
 793       return 1;
 794     }
 795
 796     bool listCommand;
 797     if (command.CompareNoCase("l") == 0)
 798       listCommand = true;
 799     else if (command.CompareNoCase("x") == 0)
 800       listCommand = false;
 801     else
 802     {
 803       PrintError("incorrect command");
 804       return 1;
 805     }
 806
 807     CMyComPtr<IInArchive> archive;
 808     if (createObjectFunc(&CLSID_CFormat7z, &IID_IInArchive, (void **)&archive) != S_OK)
 809     {
 810       PrintError("Can not get class object");
 811       return 1;
 812     }
 813
 814     CInFileStream *fileSpec = new CInFileStream;
 815     CMyComPtr<IInStream> file = fileSpec;
 816
 817     if (!fileSpec->Open(archiveName))
 818     {
 819       PrintError("Can not open archive file");
 820       return 1;
 821     }
 822
 823     {
 824       CArchiveOpenCallback *openCallbackSpec = new CArchiveOpenCallback;
 825       CMyComPtr<IArchiveOpenCallback> openCallback(openCallbackSpec);
 826       openCallbackSpec->PasswordIsDefined = false;
 827       // openCallbackSpec->PasswordIsDefined = true;
 828       // openCallbackSpec->Password = L"1";
 829
 830       if (archive->Open(file, 0, openCallback) != S_OK)
 831       {
 832         PrintError("Can not open archive");
 833         return 1;
 834       }
 835     }
 836
 837     if (listCommand)
 838     {
 839       // List command
 840       UInt32 numItems = 0;
 841       archive->GetNumberOfItems(&numItems);
 842       for (UInt32 i = 0; i < numItems; i++)
 843       {
 844         {
 845           // Get uncompressed size of file
 846           NWindows::NCOM::CPropVariant propVariant;
 847           archive->GetProperty(i, kpidSize, &propVariant);
 848           UString s = ConvertPropVariantToString(propVariant);
 849           PrintString(s);
 850           PrintString("  ");
 851         }
 852         {
 853           // Get name of file
 854           NWindows::NCOM::CPropVariant propVariant;
 855           archive->GetProperty(i, kpidPath, &propVariant);
 856           UString s = ConvertPropVariantToString(propVariant);
 857           PrintString(s);
 858         }
 859         PrintString("\n");
 860       }
 861     }
 862     else
 863     {
 864       // Extract command
 865       CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
 866       CMyComPtr<IArchiveExtractCallback> extractCallback(extractCallbackSpec);
 867       extractCallbackSpec->Init(archive, L""); // second parameter is output folder path
 868       extractCallbackSpec->PasswordIsDefined = false;
 869       // extractCallbackSpec->PasswordIsDefined = true;
 870       // extractCallbackSpec->Password = L"1";
 871       HRESULT result = archive->Extract(NULL, (UInt32)(Int32)(-1), false, extractCallback);
 872       if (result != S_OK)
 873       {
 874         PrintError("Extract Error");
 875         return 1;
 876       }
 877     }
 878   }
 879   return 0;
 880 }