ryzom/tools/client/ryzom_installer/src/filesextractor.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdpch.h"
  18 #include "filesextractor.h"
  19 #include "operation.h"
  20 #include "utils.h"
  21
  22 #include "nel/misc/big_file.h"
  23 #include "nel/misc/callback.h"
  24 #include "nel/misc/file.h"
  25 #include "nel/misc/path.h"
  26
  27 #include "7z.h"
  28 #include "7zAlloc.h"
  29 #include "7zBuf.h"
  30 #include "7zCrc.h"
  31
  32 #include "qzipreader.h"
  33
  34 #include <sys/stat.h>
  35
  36 #ifndef FILE_ATTRIBUTE_READONLY
  37 #define FILE_ATTRIBUTE_READONLY            0x1
  38 #endif
  39 #ifndef FILE_ATTRIBUTE_HIDDEN
  40 #define FILE_ATTRIBUTE_HIDDEN              0x2
  41 #endif
  42
  43 #ifndef FILE_ATTRIBUTE_SYSTEM
  44 #define FILE_ATTRIBUTE_SYSTEM              0x4
  45 #endif
  46
  47 #ifndef FILE_ATTRIBUTE_DIRECTORY
  48 #define FILE_ATTRIBUTE_DIRECTORY          0x10
  49 #endif
  50
  51 #ifndef FILE_ATTRIBUTE_ARCHIVE
  52 #define FILE_ATTRIBUTE_ARCHIVE            0x20
  53 #endif
  54
  55 #ifndef FILE_ATTRIBUTE_DEVICE
  56 #define FILE_ATTRIBUTE_DEVICE             0x40
  57 #endif
  58
  59 #ifndef FILE_ATTRIBUTE_NORMAL
  60 #define FILE_ATTRIBUTE_NORMAL             0x80
  61 #endif
  62
  63 #ifndef FILE_ATTRIBUTE_TEMPORARY
  64 #define FILE_ATTRIBUTE_TEMPORARY         0x100
  65 #endif
  66
  67 #ifndef FILE_ATTRIBUTE_SPARSE_FILE
  68 #define FILE_ATTRIBUTE_SPARSE_FILE       0x200
  69 #endif
  70
  71 #ifndef FILE_ATTRIBUTE_REPARSE_POINT
  72 #define FILE_ATTRIBUTE_REPARSE_POINT     0x400
  73 #endif
  74
  75 #ifndef FILE_ATTRIBUTE_COMPRESSED
  76 #define FILE_ATTRIBUTE_COMPRESSED        0x800
  77 #endif
  78
  79 #ifndef FILE_ATTRIBUTE_OFFLINE
  80 #define FILE_ATTRIBUTE_OFFLINE          0x1000
  81 #endif
  82
  83 #ifndef FILE_ATTRIBUTE_ENCRYPTED
  84 #define FILE_ATTRIBUTE_ENCRYPTED        0x4000
  85 #endif
  86
  87 #define FILE_ATTRIBUTE_UNIX_EXTENSION   0x8000   /* trick for Unix */
  88
  89 #define FILE_ATTRIBUTE_WINDOWS          0x7fff
  90 #define FILE_ATTRIBUTE_UNIX         0xffff0000
  91
  92 #define kInputBufSize ((size_t)1 << 18)
  93
  94 bool Set7zFileAttrib(const QString &filename, uint32 fileAttributes)
  95 {
  96         if (filename.isEmpty()) return false;
  97
  98         bool attrReadOnly = (fileAttributes & FILE_ATTRIBUTE_READONLY) != 0;
  99         bool attrHidden = (fileAttributes & FILE_ATTRIBUTE_HIDDEN) != 0;
 100         bool attrSystem = (fileAttributes & FILE_ATTRIBUTE_SYSTEM) != 0;
 101         bool attrDir = (fileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
 102         bool attrArchive = (fileAttributes & FILE_ATTRIBUTE_ARCHIVE) != 0;
 103         bool attrDevice = (fileAttributes & FILE_ATTRIBUTE_DEVICE) != 0;
 104         bool attrNormal = (fileAttributes & FILE_ATTRIBUTE_NORMAL) != 0;
 105         bool attrTemp = (fileAttributes & FILE_ATTRIBUTE_TEMPORARY) != 0;
 106         bool attrSparceFile = (fileAttributes & FILE_ATTRIBUTE_SPARSE_FILE) != 0;
 107         bool attrReparsePoint = (fileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
 108         bool attrCompressed = (fileAttributes & FILE_ATTRIBUTE_COMPRESSED) != 0;
 109         bool attrOffline = (fileAttributes & FILE_ATTRIBUTE_OFFLINE) != 0;
 110         bool attrEncrypted = (fileAttributes & FILE_ATTRIBUTE_ENCRYPTED) != 0;
 111         bool attrUnix = (fileAttributes & FILE_ATTRIBUTE_UNIX_EXTENSION) != 0;
 112
 113         uint32 unixAttributes = (fileAttributes & FILE_ATTRIBUTE_UNIX) >> 16;
 114         uint32 windowsAttributes = fileAttributes & FILE_ATTRIBUTE_WINDOWS;
 115
 116 //      qDebug() << "attribs" << QByteArray::fromRawData((const char*)&fileAttributes, 4).toHex();
 117
 118 #ifdef Q_OS_WIN
 119         SetFileAttributesW((wchar_t*)filename.utf16(), windowsAttributes);
 120 #else
 121         std::string name = filename.toUtf8().constData();
 122
 123         mode_t current_umask = umask(0); // get and set the umask
 124         umask(current_umask); // restore the umask
 125         mode_t mask = 0777 & (~current_umask);
 126
 127         struct stat stat_info;
 128
 129         if (lstat(name.c_str(), &stat_info) != 0)
 130         {
 131                 nlwarning("Unable to get file attributes for %s", name.c_str());
 132                 return false;
 133         }
 134
 135         if (attrUnix)
 136         {
 137                 stat_info.st_mode = unixAttributes;
 138
 139                 // ignore symbolic links
 140                 if (!S_ISLNK(stat_info.st_mode))
 141                 {
 142                         if (S_ISREG(stat_info.st_mode))
 143                         {
 144                                 chmod(name.c_str(), stat_info.st_mode & mask);
 145                         }
 146                         else if (S_ISDIR(stat_info.st_mode))
 147                         {
 148                                 // user/7za must be able to create files in this directory
 149                                 stat_info.st_mode |= (S_IRUSR | S_IWUSR | S_IXUSR);
 150                                 chmod(name.c_str(), stat_info.st_mode & mask);
 151                         }
 152                 }
 153         }
 154         else if (!S_ISLNK(stat_info.st_mode) && !S_ISDIR(stat_info.st_mode) && attrReadOnly)
 155         {
 156                 // do not use chmod on a link
 157                 // Remark : FILE_ATTRIBUTE_READONLY ignored for directory.
 158                 // Only Windows Attributes
 159
 160                 // octal!, clear write permission bits
 161                 stat_info.st_mode &= ~0222;
 162
 163                 chmod(name.c_str(), stat_info.st_mode & mask);
 164         }
 165 #endif
 166
 167         return true;
 168 }
 169
 170 #ifdef DEBUG_NEW
 171         #define new DEBUG_NEW
 172 #endif
 173
 174 #define SZ_ERROR_INTERRUPTED 18
 175
 176 class Q7zFile : public ISeekInStream
 177 {
 178         QFile m_file;
 179
 180 public:
 181         Q7zFile(const QString &filename):m_file(filename)
 182         {
 183                 Read = readFunc;
 184                 Seek = seekFunc;
 185         }
 186
 187         ~Q7zFile()
 188         {
 189         }
 190
 191         bool open()
 192         {
 193                 return m_file.open(QFile::ReadOnly);
 194         }
 195
 196         // the read function called by 7zip to read data
 197         static SRes readFunc(const ISeekInStream *object, void *buffer, size_t *size)
 198         {
 199                 Q7zFile *me = (Q7zFile*)object;
 200                 qint64 len = *size;
 201                 len = me->m_file.read((char*)buffer, len);
 202
 203                 if (len == *size)
 204                 {
 205                         *size = len;
 206                         return SZ_OK;
 207                 }
 208                 else
 209                 {
 210                         return SZ_ERROR_READ;
 211                 }
 212         }
 213
 214         // the seek function called by seven zip to seek inside stream
 215         static SRes seekFunc(const ISeekInStream *object, Int64 *pos, ESzSeek origin)
 216         {
 217                 Q7zFile *me = (Q7zFile*)object;
 218                 qint64 newPos = 0;
 219
 220                 switch(origin)
 221                 {
 222                         case SZ_SEEK_SET: newPos = *pos; break;
 223                         case SZ_SEEK_CUR: newPos = me->m_file.pos() + *pos; break;
 224                         case SZ_SEEK_END: newPos = me->m_file.size() - *pos; break;
 225                 }
 226
 227                 if (me->m_file.seek(newPos))
 228                 {
 229                         *pos = newPos;
 230                         return SZ_OK;
 231                 }
 232                 else
 233                 {
 234                         return SZ_ERROR_READ;
 235                 }
 236         }
 237 };
 238
 239 CFilesExtractor::CFilesExtractor(IOperationProgressListener *listener):m_listener(listener)
 240 {
 241 }
 242
 243 CFilesExtractor::~CFilesExtractor()
 244 {
 245 }
 246
 247 void CFilesExtractor::setSourceFile(const QString &src)
 248 {
 249         m_sourceFile = src;
 250 }
 251
 252 void CFilesExtractor::setDestinationDirectory(const QString &dst)
 253 {
 254         m_destinationDirectory = dst;
 255 }
 256
 257 bool CFilesExtractor::exec()
 258 {
 259         if (m_sourceFile.isEmpty() || m_destinationDirectory.isEmpty()) return false;
 260
 261         if (m_listener) m_listener->operationPrepare();
 262
 263         QFile file(m_sourceFile);
 264
 265         // open archive file to check format
 266         if (!file.open(QFile::ReadOnly)) return false;
 267
 268         // read 2 first bytes
 269         QByteArray header = file.read(2);
 270
 271         // close file
 272         file.close();
 273
 274         // create destination directory
 275         QDir dir;
 276         dir.mkpath(m_destinationDirectory);
 277
 278         // compare to supported formats and call the appropriate decompressor
 279         if (header == "7z")
 280         {
 281                 return extract7z();
 282         }
 283
 284         if (header == "PK")
 285         {
 286                 return extractZip();
 287         }
 288
 289         if (QFileInfo(m_sourceFile).suffix().toLower() == "bnp")
 290         {
 291                 return extractBnp();
 292         }
 293
 294         nlwarning("Unsupported format for file %s", Q2C(m_sourceFile));
 295         return false;
 296 }
 297
 298 static uint32 convertWindowsFileTimeToUnixTimestamp(const CNtfsFileTime &nt)
 299 {
 300         // first, convert it into second since jan1, 1601
 301         uint64 t = nt.Low | (uint64(nt.High) << 32);
 302
 303         // offset to convert Windows file times to UNIX timestamp
 304         uint64 offset = UINT64_CONSTANT(116444736000000000);
 305
 306         // adjust time base to unix epoch base
 307         t -= offset;
 308
 309         // convert the resulting time into seconds
 310         t /= 10;        // microsec
 311         t /= 1000;      // millisec
 312         t /= 1000;      // sec
 313
 314         // return the resulting time
 315         return uint32(t);
 316 }
 317
 318 bool CFilesExtractor::extract7z()
 319 {
 320         Q7zFile inFile(m_sourceFile);
 321
 322         if (!inFile.open())
 323         {
 324                 nlwarning("Unable to open %s", Q2C(m_sourceFile));
 325
 326                 if (m_listener) m_listener->operationFail(QApplication::tr("Unable to open %1").arg(m_sourceFile));
 327                 return false;
 328         }
 329
 330         UInt16 *temp = NULL;
 331         size_t tempSize = 0;
 332
 333         // register allocators
 334         ISzAlloc allocImp;
 335         allocImp.Alloc = SzAlloc;
 336         allocImp.Free = SzFree;
 337
 338         ISzAlloc allocTempImp;
 339         allocTempImp.Alloc = SzAllocTemp;
 340         allocTempImp.Free = SzFreeTemp;
 341
 342         // register the files read handlers
 343         CLookToRead2 lookStream;
 344         LookToRead2_CreateVTable(&lookStream, False);
 345         lookStream.buf = (Byte*)ISzAlloc_Alloc(&allocImp, kInputBufSize);
 346
 347         if (!lookStream.buf)
 348         {
 349                 nlwarning("Unable to allocate %u bytes", (uint32)kInputBufSize);
 350
 351                 if (m_listener) m_listener->operationFail(QApplication::tr("Unable to allocate %1 bytes").arg(kInputBufSize));
 352                 return false;
 353         }
 354
 355         LookToRead2_Init(&lookStream);
 356
 357         lookStream.bufSize = kInputBufSize;
 358         lookStream.realStream = &inFile;
 359         LookToRead2_Init(&lookStream);
 360
 361         // init CRC table
 362         CrcGenerateTable();
 363
 364         // init 7z
 365         CSzArEx db;
 366         SzArEx_Init(&db);
 367
 368         qint64 total = 0, totalUncompressed = 0;
 369         QString error;
 370
 371         // open 7z archive
 372         SRes res = SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp);
 373
 374         if (res == SZ_OK)
 375         {
 376                 // process each file in archive
 377                 for (UInt32 i = 0; i < db.NumFiles; ++i)
 378                 {
 379                         bool isDir = SzArEx_IsDir(&db, i) != 0;
 380
 381                         if (!isDir) total += SzArEx_GetFileSize(&db, i);
 382                 }
 383
 384                 if (m_listener)
 385                 {
 386                         m_listener->operationInit(0, total);
 387                         m_listener->operationStart();
 388                 }
 389
 390                 // variables used for decompression
 391                 UInt32 blockIndex = 0xFFFFFFFF;
 392                 Byte *outBuffer = NULL;
 393                 size_t outBufferSize = 0;
 394
 395                 // process each file in archive
 396                 for (UInt32 i = 0; i < db.NumFiles; ++i)
 397                 {
 398                         if (m_listener && m_listener->operationShouldStop())
 399                         {
 400                                 res = SZ_ERROR_INTERRUPTED;
 401                                 break;
 402                         }
 403
 404                         size_t offset = 0;
 405                         size_t outSizeProcessed = 0;
 406
 407                         bool isDir = SzArEx_IsDir(&db, i) != 0;
 408
 409                         size_t len = SzArEx_GetFileNameUtf16(&db, i, NULL);
 410
 411                         if (len > tempSize)
 412                         {
 413                                 SzFree(NULL, temp);
 414                                 tempSize = len;
 415                                 temp = (UInt16 *)SzAlloc(NULL, tempSize * sizeof(temp[0]));
 416                                 if (!temp)
 417                                 {
 418                                         res = SZ_ERROR_MEM;
 419                                         break;
 420                                 }
 421                         }
 422
 423                         SzArEx_GetFileNameUtf16(&db, i, temp);
 424
 425                         QString path = QString::fromUtf16(temp);
 426                         QString filename = QFileInfo(path).fileName();
 427
 428                         QString destPath = m_destinationDirectory + '/' + path;
 429
 430                         // get uncompressed size
 431                         quint64 uncompressedSize = SzArEx_GetFileSize(&db, i);
 432
 433                         // get modification time
 434                         quint32 modificationTime = 0, creationTime = 0;
 435
 436                         if (SzBitWithVals_Check(&db.MTime, i))
 437                         {
 438                                 modificationTime = convertWindowsFileTimeToUnixTimestamp(db.MTime.Vals[i]);
 439                         }
 440
 441                         if (SzBitWithVals_Check(&db.CTime, i))
 442                         {
 443                                 creationTime = convertWindowsFileTimeToUnixTimestamp(db.CTime.Vals[i]);
 444                         }
 445
 446                         if (isDir)
 447                         {
 448                                 QDir().mkpath(destPath);
 449                                 continue;
 450                         }
 451
 452                         // check if file exists
 453                         if (QFile::exists(destPath))
 454                         {
 455                                 QFileInfo currentFileInfo(destPath);
 456
 457                                 // skip file if same size and same modification date
 458                                 if (currentFileInfo.lastModified().toTime_t() == modificationTime && currentFileInfo.size() == uncompressedSize)
 459                                 {
 460                                         // update progress
 461                                         totalUncompressed += uncompressedSize;
 462
 463                                         if (m_listener) m_listener->operationProgress(totalUncompressed, filename);
 464
 465                                         continue;
 466                                 }
 467                         }
 468
 469                         if (m_listener) m_listener->operationProgress(totalUncompressed, filename);
 470
 471                         res = SzArEx_Extract(&db, &lookStream.vt, i, &blockIndex, &outBuffer, &outBufferSize,
 472                                 &offset, &outSizeProcessed, &allocImp, &allocTempImp);
 473
 474                         if (res != SZ_OK) break;
 475
 476                         QString destSubPath = QFileInfo(destPath).absolutePath();
 477
 478                         // create file directory
 479                         if (!QDir().mkpath(destSubPath))
 480                         {
 481                                 nlwarning("Unable to create directory %s", Q2C(destSubPath));
 482                         }
 483
 484                         // create file
 485                         QSaveFile outFile(destPath);
 486
 487                         if (!outFile.open(QFile::WriteOnly))
 488                         {
 489                                 nlwarning("Unable to open file %s", Q2C(destPath));
 490
 491                                 error = QApplication::tr("Unable to open output file %1").arg(destPath);
 492                                 res = SZ_ERROR_FAIL;
 493                                 break;
 494                         }
 495
 496                         qint64 currentSizeToProcess = outSizeProcessed;
 497
 498                         do
 499                         {
 500                                 qint64 currentProcessedSize = outFile.write((const char*)(outBuffer + offset), currentSizeToProcess);
 501
 502                                 // errors only occur when returned size is -1
 503                                 if (currentProcessedSize < 0) break;
 504
 505                                 offset += currentProcessedSize;
 506                                 currentSizeToProcess -= currentProcessedSize;
 507                         }
 508                         while (currentSizeToProcess > 0);
 509
 510                         if (offset != outSizeProcessed)
 511                         {
 512                                 nlwarning("Unable to write output file %s (%u bytes written but expecting %u bytes)", Q2C(destPath), (uint32)offset, (uint32)outSizeProcessed);
 513
 514                                 error = QApplication::tr("Unable to write output file %1 (%2 bytes written but expecting %3 bytes)").arg(destPath).arg(offset).arg(outSizeProcessed);
 515                                 res = SZ_ERROR_FAIL;
 516                                 break;
 517                         }
 518
 519                         outFile.commit();
 520
 521                         totalUncompressed += uncompressedSize;
 522
 523                         if (m_listener) m_listener->operationProgress(totalUncompressed, filename);
 524
 525                         // set attributes
 526                         if (SzBitWithVals_Check(&db.Attribs, i))
 527                         {
 528                                 Set7zFileAttrib(destPath, db.Attribs.Vals[i]);
 529                         }
 530
 531                         // set modification time
 532                         if (!NLMISC::CFile::setFileModificationDate(qToUtf8(destPath), modificationTime))
 533                         {
 534                                 nlwarning("Unable to change date of %s", Q2C(destPath));
 535                         }
 536                 }
 537
 538                 IAlloc_Free(&allocImp, outBuffer);
 539         }
 540
 541         SzFree(NULL, temp);
 542         SzArEx_Free(&db, &allocImp);
 543         ISzAlloc_Free(&allocImp, lookStream.buf);
 544
 545         switch(res)
 546         {
 547                 case SZ_OK:
 548                 if (m_listener)
 549                 {
 550                         m_listener->operationSuccess(totalUncompressed);
 551                 }
 552                 return true;
 553
 554                 case SZ_ERROR_INTERRUPTED:
 555                 if (m_listener) m_listener->operationStop();
 556                 return true;
 557
 558                 case SZ_ERROR_UNSUPPORTED:
 559                 error = QApplication::tr("7zip decoder doesn't support this archive");
 560                 break;
 561
 562                 case SZ_ERROR_MEM:
 563                 error = QApplication::tr("Unable to allocate memory");
 564                 break;
 565
 566                 case SZ_ERROR_CRC:
 567                 error = QApplication::tr("7zip decoder doesn't support this archive");
 568                 break;
 569
 570                 case SZ_ERROR_INPUT_EOF:
 571                 error = QApplication::tr("File %1 is corrupted, unable to uncompress it").arg(m_sourceFile);
 572                 break;
 573
 574                 case SZ_ERROR_FAIL:
 575                 // error already defined
 576                 break;
 577
 578                 default:
 579                 error = QApplication::tr("Error %1").arg(res);
 580         }
 581
 582         if (m_listener) m_listener->operationFail(error);
 583
 584         return false;
 585 }
 586
 587 bool CFilesExtractor::extractZip()
 588 {
 589         QZipReader reader(m_sourceFile);
 590
 591         QDir baseDir(m_destinationDirectory);
 592
 593         // create directories first
 594         QList<QZipReader::FileInfo> allFiles = reader.fileInfoList();
 595
 596         qint64 totalSize = 0, currentSize = 0;
 597
 598         foreach (const QZipReader::FileInfo &fi, allFiles)
 599         {
 600                 if (fi.isDir)
 601                 {
 602                         const QString absPath = m_destinationDirectory + QDir::separator() + fi.filePath;
 603
 604                         if (!baseDir.mkpath(fi.filePath))
 605                         {
 606                                 nlwarning("Unable to create directory %s", Q2C(fi.filePath));
 607
 608                                 if (m_listener) m_listener->operationFail(QApplication::tr("Unable to create directory %1").arg(fi.filePath));
 609                                 return false;
 610                         }
 611
 612                         if (!QFile::setPermissions(absPath, fi.permissions))
 613                         {
 614                                 nlwarning("Unable to change permissions of %s", Q2C(absPath));
 615
 616                                 if (m_listener) m_listener->operationFail(QApplication::tr("Unable to set permissions of %1").arg(absPath));
 617                                 return false;
 618                         }
 619                 }
 620
 621                 totalSize += fi.size;
 622         }
 623
 624         if (m_listener)
 625         {
 626                 m_listener->operationInit(0, totalSize);
 627                 m_listener->operationStart();
 628         }
 629
 630         // client won't use symbolic links so don't process them
 631
 632         foreach (const QZipReader::FileInfo &fi, allFiles)
 633         {
 634                 const QString absPath = m_destinationDirectory + QDir::separator() + fi.filePath;
 635
 636                 if (fi.isFile)
 637                 {
 638                         if (m_listener && m_listener->operationShouldStop())
 639                         {
 640                                 m_listener->operationStop();
 641                                 return true;
 642                         }
 643
 644                         QSaveFile f(absPath);
 645
 646                         if (!f.open(QIODevice::WriteOnly))
 647                         {
 648                                 nlwarning("Unable to open %s", Q2C(absPath));
 649
 650                                 if (m_listener) m_listener->operationFail(QApplication::tr("Unable to open %1").arg(absPath));
 651                                 return false;
 652                         }
 653
 654                         currentSize += f.write(reader.fileData(fi.filePath));
 655
 656                         if (!f.setPermissions(fi.permissions))
 657                         {
 658                                 nlwarning("Unable to change permissions of %s", Q2C(absPath));
 659                         }
 660
 661                         f.commit();
 662
 663                         // set the right modification date
 664                         if (!NLMISC::CFile::setFileModificationDate(qToUtf8(absPath), fi.lastModified.toTime_t()))
 665                         {
 666                                 nlwarning("Unable to change date of %s", Q2C(absPath));
 667                         }
 668
 669                         if (m_listener) m_listener->operationProgress(currentSize, QFileInfo(absPath).fileName());
 670                 }
 671         }
 672
 673         if (m_listener)
 674         {
 675                 m_listener->operationSuccess(totalSize);
 676         }
 677
 678         return true;
 679 }
 680
 681 bool CFilesExtractor::progress(const std::string &filename, uint32 currentSize, uint32 totalSize)
 682 {
 683         if (m_listener && m_listener->operationShouldStop())
 684         {
 685                 m_listener->operationStop();
 686
 687                 return false;
 688         }
 689
 690         if (currentSize == 0)
 691         {
 692                 if (m_listener)
 693                 {
 694                         m_listener->operationInit(0, (qint64)totalSize);
 695                         m_listener->operationStart();
 696                 }
 697         }
 698
 699         if (m_listener) m_listener->operationProgress((qint64)currentSize, qFromUtf8(filename));
 700
 701         if (currentSize == totalSize)
 702         {
 703                 if (m_listener)
 704                 {
 705                         m_listener->operationSuccess((qint64)totalSize);
 706                 }
 707         }
 708
 709         return true;
 710 }
 711
 712 bool CFilesExtractor::extractBnp()
 713 {
 714         QString error;
 715
 716         NLMISC::CBigFile::TUnpackProgressCallback cbMethod = NLMISC::CBigFile::TUnpackProgressCallback(this, &CFilesExtractor::progress);
 717
 718         try
 719         {
 720                 if (NLMISC::CBigFile::unpack(qToUtf8(m_sourceFile), qToUtf8(m_destinationDirectory), &cbMethod))
 721                 {
 722                         return true;
 723                 }
 724
 725                 if (m_listener && m_listener->operationShouldStop())
 726                 {
 727                         // stopped
 728                         m_listener->operationStop();
 729
 730                         return true;
 731                 }
 732
 733                 error.clear();
 734         }
 735         catch(const NLMISC::EDiskFullError &e)
 736         {
 737                 nlwarning("Disk full when extracting %s to %s", Q2C(m_sourceFile), Q2C(m_destinationDirectory));
 738
 739                 error = QApplication::tr("disk full");
 740         }
 741         catch(const NLMISC::EWriteError &e)
 742         {
 743                 nlwarning("Write error when extracting %s to %s", Q2C(m_sourceFile), Q2C(m_destinationDirectory));
 744
 745                 error = QApplication::tr("unable to write %1").arg(qFromUtf8(e.Filename));
 746         }
 747         catch(const NLMISC::EReadError &e)
 748         {
 749                 nlwarning("Read error when extracting %s to %s", Q2C(m_sourceFile), Q2C(m_destinationDirectory));
 750
 751                 error = QApplication::tr("unable to read %1").arg(qFromUtf8(e.Filename));
 752         }
 753         catch(const std::exception &e)
 754         {
 755                 nlwarning("Unknown exception when extracting %s to %s", Q2C(m_sourceFile), Q2C(m_destinationDirectory));
 756
 757                 error = QApplication::tr("failed (%1)").arg(qFromUtf8(e.what()));
 758         }
 759
 760         if (m_listener) m_listener->operationFail(QApplication::tr("Unable to unpack %1 to %2: %3").arg(m_sourceFile).arg(m_destinationDirectory).arg(error));
 761
 762         return false;
 763 }