C/Util/7z/7zMain.c

   1 /* 7zMain.c - Test application for 7z Decoder\r
   2 2010-10-28 : Igor Pavlov : Public domain */\r
   3 \r
   4 #include <stdio.h>\r
   5 #include <string.h>\r
   6 \r
   7 #include "../../7z.h"\r
   8 #include "../../7zAlloc.h"\r
   9 #include "../../7zCrc.h"\r
  10 #include "../../7zFile.h"\r
  11 #include "../../7zVersion.h"\r
  12 \r
  13 #ifndef USE_WINDOWS_FILE\r
  14 /* for mkdir */\r
  15 #ifdef _WIN32\r
  16 #include <direct.h>\r
  17 #else\r
  18 #include <sys/stat.h>\r
  19 #include <errno.h>\r
  20 #endif\r
  21 #endif\r
  22 \r
  23 static ISzAlloc g_Alloc = { SzAlloc, SzFree };\r
  24 \r
  25 static int Buf_EnsureSize(CBuf *dest, size_t size)\r
  26 {\r
  27   if (dest->size >= size)\r
  28     return 1;\r
  29   Buf_Free(dest, &g_Alloc);\r
  30   return Buf_Create(dest, size, &g_Alloc);\r
  31 }\r
  32 \r
  33 #ifndef _WIN32\r
  34 \r
  35 static Byte kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };\r
  36 \r
  37 static Bool Utf16_To_Utf8(Byte *dest, size_t *destLen, const UInt16 *src, size_t srcLen)\r
  38 {\r
  39   size_t destPos = 0, srcPos = 0;\r
  40   for (;;)\r
  41   {\r
  42     unsigned numAdds;\r
  43     UInt32 value;\r
  44     if (srcPos == srcLen)\r
  45     {\r
  46       *destLen = destPos;\r
  47       return True;\r
  48     }\r
  49     value = src[srcPos++];\r
  50     if (value < 0x80)\r
  51     {\r
  52       if (dest)\r
  53         dest[destPos] = (char)value;\r
  54       destPos++;\r
  55       continue;\r
  56     }\r
  57     if (value >= 0xD800 && value < 0xE000)\r
  58     {\r
  59       UInt32 c2;\r
  60       if (value >= 0xDC00 || srcPos == srcLen)\r
  61         break;\r
  62       c2 = src[srcPos++];\r
  63       if (c2 < 0xDC00 || c2 >= 0xE000)\r
  64         break;\r
  65       value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;\r
  66     }\r
  67     for (numAdds = 1; numAdds < 5; numAdds++)\r
  68       if (value < (((UInt32)1) << (numAdds * 5 + 6)))\r
  69         break;\r
  70     if (dest)\r
  71       dest[destPos] = (char)(kUtf8Limits[numAdds - 1] + (value >> (6 * numAdds)));\r
  72     destPos++;\r
  73     do\r
  74     {\r
  75       numAdds--;\r
  76       if (dest)\r
  77         dest[destPos] = (char)(0x80 + ((value >> (6 * numAdds)) & 0x3F));\r
  78       destPos++;\r
  79     }\r
  80     while (numAdds != 0);\r
  81   }\r
  82   *destLen = destPos;\r
  83   return False;\r
  84 }\r
  85 \r
  86 static SRes Utf16_To_Utf8Buf(CBuf *dest, const UInt16 *src, size_t srcLen)\r
  87 {\r
  88   size_t destLen = 0;\r
  89   Bool res;\r
  90   Utf16_To_Utf8(NULL, &destLen, src, srcLen);\r
  91   destLen += 1;\r
  92   if (!Buf_EnsureSize(dest, destLen))\r
  93     return SZ_ERROR_MEM;\r
  94   res = Utf16_To_Utf8(dest->data, &destLen, src, srcLen);\r
  95   dest->data[destLen] = 0;\r
  96   return res ? SZ_OK : SZ_ERROR_FAIL;\r
  97 }\r
  98 #endif\r
  99 \r
 100 static SRes Utf16_To_Char(CBuf *buf, const UInt16 *s, int fileMode)\r
 101 {\r
 102   int len = 0;\r
 103   for (len = 0; s[len] != '\0'; len++);\r
 104 \r
 105   #ifdef _WIN32\r
 106   {\r
 107     int size = len * 3 + 100;\r
 108     if (!Buf_EnsureSize(buf, size))\r
 109       return SZ_ERROR_MEM;\r
 110     {\r
 111       char defaultChar = '_';\r
 112       BOOL defUsed;\r
 113       int numChars = WideCharToMultiByte(fileMode ?\r
 114           (\r
 115           #ifdef UNDER_CE\r
 116           CP_ACP\r
 117           #else\r
 118           AreFileApisANSI() ? CP_ACP : CP_OEMCP\r
 119           #endif\r
 120           ) : CP_OEMCP,\r
 121           0, s, len, (char *)buf->data, size, &defaultChar, &defUsed);\r
 122       if (numChars == 0 || numChars >= size)\r
 123         return SZ_ERROR_FAIL;\r
 124       buf->data[numChars] = 0;\r
 125       return SZ_OK;\r
 126     }\r
 127   }\r
 128   #else\r
 129   fileMode = fileMode;\r
 130   return Utf16_To_Utf8Buf(buf, s, len);\r
 131   #endif\r
 132 }\r
 133 \r
 134 static WRes MyCreateDir(const UInt16 *name)\r
 135 {\r
 136   #ifdef USE_WINDOWS_FILE\r
 137   \r
 138   return CreateDirectoryW(name, NULL) ? 0 : GetLastError();\r
 139   \r
 140   #else\r
 141 \r
 142   CBuf buf;\r
 143   WRes res;\r
 144   Buf_Init(&buf);\r
 145   RINOK(Utf16_To_Char(&buf, name, 1));\r
 146 \r
 147   res =\r
 148   #ifdef _WIN32\r
 149   _mkdir((const char *)buf.data)\r
 150   #else\r
 151   mkdir((const char *)buf.data, 0777)\r
 152   #endif\r
 153   == 0 ? 0 : errno;\r
 154   Buf_Free(&buf, &g_Alloc);\r
 155   return res;\r
 156   \r
 157   #endif\r
 158 }\r
 159 \r
 160 static WRes OutFile_OpenUtf16(CSzFile *p, const UInt16 *name)\r
 161 {\r
 162   #ifdef USE_WINDOWS_FILE\r
 163   return OutFile_OpenW(p, name);\r
 164   #else\r
 165   CBuf buf;\r
 166   WRes res;\r
 167   Buf_Init(&buf);\r
 168   RINOK(Utf16_To_Char(&buf, name, 1));\r
 169   res = OutFile_Open(p, (const char *)buf.data);\r
 170   Buf_Free(&buf, &g_Alloc);\r
 171   return res;\r
 172   #endif\r
 173 }\r
 174 \r
 175 static SRes PrintString(const UInt16 *s)\r
 176 {\r
 177   CBuf buf;\r
 178   SRes res;\r
 179   Buf_Init(&buf);\r
 180   res = Utf16_To_Char(&buf, s, 0);\r
 181   if (res == SZ_OK)\r
 182     fputs((const char *)buf.data, stdout);\r
 183   Buf_Free(&buf, &g_Alloc);\r
 184   return res;\r
 185 }\r
 186 \r
 187 static void UInt64ToStr(UInt64 value, char *s)\r
 188 {\r
 189   char temp[32];\r
 190   int pos = 0;\r
 191   do\r
 192   {\r
 193     temp[pos++] = (char)('0' + (unsigned)(value % 10));\r
 194     value /= 10;\r
 195   }\r
 196   while (value != 0);\r
 197   do\r
 198     *s++ = temp[--pos];\r
 199   while (pos);\r
 200   *s = '\0';\r
 201 }\r
 202 \r
 203 static char *UIntToStr(char *s, unsigned value, int numDigits)\r
 204 {\r
 205   char temp[16];\r
 206   int pos = 0;\r
 207   do\r
 208     temp[pos++] = (char)('0' + (value % 10));\r
 209   while (value /= 10);\r
 210   for (numDigits -= pos; numDigits > 0; numDigits--)\r
 211     *s++ = '0';\r
 212   do\r
 213     *s++ = temp[--pos];\r
 214   while (pos);\r
 215   *s = '\0';\r
 216   return s;\r
 217 }\r
 218 \r
 219 #define PERIOD_4 (4 * 365 + 1)\r
 220 #define PERIOD_100 (PERIOD_4 * 25 - 1)\r
 221 #define PERIOD_400 (PERIOD_100 * 4 + 1)\r
 222 \r
 223 static void ConvertFileTimeToString(const CNtfsFileTime *ft, char *s)\r
 224 {\r
 225   unsigned year, mon, day, hour, min, sec;\r
 226   UInt64 v64 = (ft->Low | ((UInt64)ft->High << 32)) / 10000000;\r
 227   Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };\r
 228   unsigned t;\r
 229   UInt32 v;\r
 230   sec = (unsigned)(v64 % 60); v64 /= 60;\r
 231   min = (unsigned)(v64 % 60); v64 /= 60;\r
 232   hour = (unsigned)(v64 % 24); v64 /= 24;\r
 233 \r
 234   v = (UInt32)v64;\r
 235 \r
 236   year = (unsigned)(1601 + v / PERIOD_400 * 400);\r
 237   v %= PERIOD_400;\r
 238 \r
 239   t = v / PERIOD_100; if (t ==  4) t =  3; year += t * 100; v -= t * PERIOD_100;\r
 240   t = v / PERIOD_4;   if (t == 25) t = 24; year += t * 4;   v -= t * PERIOD_4;\r
 241   t = v / 365;        if (t ==  4) t =  3; year += t;       v -= t * 365;\r
 242 \r
 243   if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))\r
 244     ms[1] = 29;\r
 245   for (mon = 1; mon <= 12; mon++)\r
 246   {\r
 247     unsigned s = ms[mon - 1];\r
 248     if (v < s)\r
 249       break;\r
 250     v -= s;\r
 251   }\r
 252   day = (unsigned)v + 1;\r
 253   s = UIntToStr(s, year, 4); *s++ = '-';\r
 254   s = UIntToStr(s, mon, 2);  *s++ = '-';\r
 255   s = UIntToStr(s, day, 2);  *s++ = ' ';\r
 256   s = UIntToStr(s, hour, 2); *s++ = ':';\r
 257   s = UIntToStr(s, min, 2);  *s++ = ':';\r
 258   s = UIntToStr(s, sec, 2);\r
 259 }\r
 260 \r
 261 void PrintError(char *sz)\r
 262 {\r
 263   printf("\nERROR: %s\n", sz);\r
 264 }\r
 265 \r
 266 #ifdef USE_WINDOWS_FILE\r
 267 #define kEmptyAttribChar '.'\r
 268 static void GetAttribString(UInt32 wa, Bool isDir, char *s)\r
 269 {\r
 270   s[0] = (char)(((wa & FILE_ATTRIBUTE_DIRECTORY) != 0 || isDir) ? 'D' : kEmptyAttribChar);\r
 271   s[1] = (char)(((wa & FILE_ATTRIBUTE_READONLY) != 0) ? 'R': kEmptyAttribChar);\r
 272   s[2] = (char)(((wa & FILE_ATTRIBUTE_HIDDEN) != 0) ? 'H': kEmptyAttribChar);\r
 273   s[3] = (char)(((wa & FILE_ATTRIBUTE_SYSTEM) != 0) ? 'S': kEmptyAttribChar);\r
 274   s[4] = (char)(((wa & FILE_ATTRIBUTE_ARCHIVE) != 0) ? 'A': kEmptyAttribChar);\r
 275   s[5] = '\0';\r
 276 }\r
 277 #else\r
 278 static void GetAttribString(UInt32, Bool, char *s)\r
 279 {\r
 280   s[0] = '\0';\r
 281 }\r
 282 #endif\r
 283 \r
 284 int MY_CDECL main(int numargs, char *args[])\r
 285 {\r
 286   CFileInStream archiveStream;\r
 287   CLookToRead lookStream;\r
 288   CSzArEx db;\r
 289   SRes res;\r
 290   ISzAlloc allocImp;\r
 291   ISzAlloc allocTempImp;\r
 292   UInt16 *temp = NULL;\r
 293   size_t tempSize = 0;\r
 294 \r
 295   printf("\n7z ANSI-C Decoder " MY_VERSION_COPYRIGHT_DATE "\n\n");\r
 296   if (numargs == 1)\r
 297   {\r
 298     printf(\r
 299       "Usage: 7zDec <command> <archive_name>\n\n"\r
 300       "<Commands>\n"\r
 301       "  e: Extract files from archive (without using directory names)\n"\r
 302       "  l: List contents of archive\n"\r
 303       "  t: Test integrity of archive\n"\r
 304       "  x: eXtract files with full paths\n");\r
 305     return 0;\r
 306   }\r
 307   if (numargs < 3)\r
 308   {\r
 309     PrintError("incorrect command");\r
 310     return 1;\r
 311   }\r
 312 \r
 313   allocImp.Alloc = SzAlloc;\r
 314   allocImp.Free = SzFree;\r
 315 \r
 316   allocTempImp.Alloc = SzAllocTemp;\r
 317   allocTempImp.Free = SzFreeTemp;\r
 318 \r
 319   if (InFile_Open(&archiveStream.file, args[2]))\r
 320   {\r
 321     PrintError("can not open input file");\r
 322     return 1;\r
 323   }\r
 324 \r
 325   FileInStream_CreateVTable(&archiveStream);\r
 326   LookToRead_CreateVTable(&lookStream, False);\r
 327   \r
 328   lookStream.realStream = &archiveStream.s;\r
 329   LookToRead_Init(&lookStream);\r
 330 \r
 331   CrcGenerateTable();\r
 332 \r
 333   SzArEx_Init(&db);\r
 334   res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);\r
 335   if (res == SZ_OK)\r
 336   {\r
 337     char *command = args[1];\r
 338     int listCommand = 0, testCommand = 0, extractCommand = 0, fullPaths = 0;\r
 339     if (strcmp(command, "l") == 0) listCommand = 1;\r
 340     else if (strcmp(command, "t") == 0) testCommand = 1;\r
 341     else if (strcmp(command, "e") == 0) extractCommand = 1;\r
 342     else if (strcmp(command, "x") == 0) { extractCommand = 1; fullPaths = 1; }\r
 343     else\r
 344     {\r
 345       PrintError("incorrect command");\r
 346       res = SZ_ERROR_FAIL;\r
 347     }\r
 348 \r
 349     if (res == SZ_OK)\r
 350     {\r
 351       UInt32 i;\r
 352 \r
 353       /*\r
 354       if you need cache, use these 3 variables.\r
 355       if you use external function, you can make these variable as static.\r
 356       */\r
 357       UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */\r
 358       Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */\r
 359       size_t outBufferSize = 0;  /* it can have any value before first call (if outBuffer = 0) */\r
 360 \r
 361       for (i = 0; i < db.db.NumFiles; i++)\r
 362       {\r
 363         size_t offset = 0;\r
 364         size_t outSizeProcessed = 0;\r
 365         const CSzFileItem *f = db.db.Files + i;\r
 366         size_t len;\r
 367         if (listCommand == 0 && f->IsDir && !fullPaths)\r
 368           continue;\r
 369         len = SzArEx_GetFileNameUtf16(&db, i, NULL);\r
 370 \r
 371         if (len > tempSize)\r
 372         {\r
 373           SzFree(NULL, temp);\r
 374           tempSize = len;\r
 375           temp = (UInt16 *)SzAlloc(NULL, tempSize * sizeof(temp[0]));\r
 376           if (temp == 0)\r
 377           {\r
 378             res = SZ_ERROR_MEM;\r
 379             break;\r
 380           }\r
 381         }\r
 382 \r
 383         SzArEx_GetFileNameUtf16(&db, i, temp);\r
 384         if (listCommand)\r
 385         {\r
 386           char attr[8], s[32], t[32];\r
 387 \r
 388           GetAttribString(f->AttribDefined ? f->Attrib : 0, f->IsDir, attr);\r
 389 \r
 390           UInt64ToStr(f->Size, s);\r
 391           if (f->MTimeDefined)\r
 392             ConvertFileTimeToString(&f->MTime, t);\r
 393           else\r
 394           {\r
 395             size_t j;\r
 396             for (j = 0; j < 19; j++)\r
 397               t[j] = ' ';\r
 398             t[j] = '\0';\r
 399           }\r
 400           \r
 401           printf("%s %s %10s  ", t, attr, s);\r
 402           res = PrintString(temp);\r
 403           if (res != SZ_OK)\r
 404             break;\r
 405           if (f->IsDir)\r
 406             printf("/");\r
 407           printf("\n");\r
 408           continue;\r
 409         }\r
 410         fputs(testCommand ?\r
 411             "Testing    ":\r
 412             "Extracting ",\r
 413             stdout);\r
 414         res = PrintString(temp);\r
 415         if (res != SZ_OK)\r
 416           break;\r
 417         if (f->IsDir)\r
 418           printf("/");\r
 419         else\r
 420         {\r
 421           res = SzArEx_Extract(&db, &lookStream.s, i,\r
 422               &blockIndex, &outBuffer, &outBufferSize,\r
 423               &offset, &outSizeProcessed,\r
 424               &allocImp, &allocTempImp);\r
 425           if (res != SZ_OK)\r
 426             break;\r
 427         }\r
 428         if (!testCommand)\r
 429         {\r
 430           CSzFile outFile;\r
 431           size_t processedSize;\r
 432           size_t j;\r
 433           UInt16 *name = (UInt16 *)temp;\r
 434           const UInt16 *destPath = (const UInt16 *)name;\r
 435           for (j = 0; name[j] != 0; j++)\r
 436             if (name[j] == '/')\r
 437             {\r
 438               if (fullPaths)\r
 439               {\r
 440                 name[j] = 0;\r
 441                 MyCreateDir(name);\r
 442                 name[j] = CHAR_PATH_SEPARATOR;\r
 443               }\r
 444               else\r
 445                 destPath = name + j + 1;\r
 446             }\r
 447     \r
 448           if (f->IsDir)\r
 449           {\r
 450             MyCreateDir(destPath);\r
 451             printf("\n");\r
 452             continue;\r
 453           }\r
 454           else if (OutFile_OpenUtf16(&outFile, destPath))\r
 455           {\r
 456             PrintError("can not open output file");\r
 457             res = SZ_ERROR_FAIL;\r
 458             break;\r
 459           }\r
 460           processedSize = outSizeProcessed;\r
 461           if (File_Write(&outFile, outBuffer + offset, &processedSize) != 0 || processedSize != outSizeProcessed)\r
 462           {\r
 463             PrintError("can not write output file");\r
 464             res = SZ_ERROR_FAIL;\r
 465             break;\r
 466           }\r
 467           if (File_Close(&outFile))\r
 468           {\r
 469             PrintError("can not close output file");\r
 470             res = SZ_ERROR_FAIL;\r
 471             break;\r
 472           }\r
 473           #ifdef USE_WINDOWS_FILE\r
 474           if (f->AttribDefined)\r
 475             SetFileAttributesW(destPath, f->Attrib);\r
 476           #endif\r
 477         }\r
 478         printf("\n");\r
 479       }\r
 480       IAlloc_Free(&allocImp, outBuffer);\r
 481     }\r
 482   }\r
 483   SzArEx_Free(&db, &allocImp);\r
 484   SzFree(NULL, temp);\r
 485 \r
 486   File_Close(&archiveStream.file);\r
 487   if (res == SZ_OK)\r
 488   {\r
 489     printf("\nEverything is Ok\n");\r
 490     return 0;\r
 491   }\r
 492   if (res == SZ_ERROR_UNSUPPORTED)\r
 493     PrintError("decoder doesn't support this archive");\r
 494   else if (res == SZ_ERROR_MEM)\r
 495     PrintError("can not allocate memory");\r
 496   else if (res == SZ_ERROR_CRC)\r
 497     PrintError("CRC error");\r
 498   else\r
 499     printf("\nERROR #%d\n", res);\r
 500   return 1;\r
 501 }\r