programs/cabarc/cabarc.c

   1 /*
   2  * Tool to manipulate cabinet files
   3  *
   4  * Copyright 2011 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #define WIN32_LEAN_AND_MEAN
  28 #include "windows.h"
  29 #include "fci.h"
  30 #include "fdi.h"
  31
  32 #include "wine/unicode.h"
  33 #include "wine/debug.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(cabarc);
  36
  37 /* from msvcrt */
  38 #define _O_RDONLY      0
  39 #define _O_WRONLY      1
  40 #define _O_RDWR        2
  41 #define _O_ACCMODE     (_O_RDONLY|_O_WRONLY|_O_RDWR)
  42 #define _O_APPEND      0x0008
  43 #define _O_RANDOM      0x0010
  44 #define _O_SEQUENTIAL  0x0020
  45 #define _O_TEMPORARY   0x0040
  46 #define _O_NOINHERIT   0x0080
  47 #define _O_CREAT       0x0100
  48 #define _O_TRUNC       0x0200
  49 #define _O_EXCL        0x0400
  50 #define _O_SHORT_LIVED 0x1000
  51 #define _O_TEXT        0x4000
  52 #define _O_BINARY      0x8000
  53
  54 #define _SH_COMPAT     0x00
  55 #define _SH_DENYRW     0x10
  56 #define _SH_DENYWR     0x20
  57 #define _SH_DENYRD     0x30
  58 #define _SH_DENYNO     0x40
  59
  60 #define _A_RDONLY      0x01
  61 #define _A_HIDDEN      0x02
  62 #define _A_SYSTEM      0x04
  63 #define _A_ARCH        0x20
  64
  65 /* command-line options */
  66 static int opt_cabinet_size = CB_MAX_DISK;
  67 static int opt_cabinet_id;
  68 static int opt_compression = tcompTYPE_MSZIP;
  69 static int opt_recurse;
  70 static int opt_preserve_paths;
  71 static int opt_reserve_space;
  72 static int opt_verbose;
  73 static char *opt_cab_file;
  74 static WCHAR *opt_dest_dir;
  75 static WCHAR **opt_files;
  76
  77 static void * CDECL cab_alloc( ULONG size )
  78 {
  79     return HeapAlloc( GetProcessHeap(), 0, size );
  80 }
  81
  82 static void CDECL cab_free( void *ptr )
  83 {
  84     HeapFree( GetProcessHeap(), 0, ptr );
  85 }
  86
  87 static WCHAR *strdupAtoW( UINT cp, const char *str )
  88 {
  89     WCHAR *ret = NULL;
  90     if (str)
  91     {
  92         DWORD len = MultiByteToWideChar( cp, 0, str, -1, NULL, 0 );
  93         if ((ret = cab_alloc( len * sizeof(WCHAR) )))
  94             MultiByteToWideChar( cp, 0, str, -1, ret, len );
  95     }
  96     return ret;
  97 }
  98
  99 static char *strdupWtoA( UINT cp, const WCHAR *str )
 100 {
 101     char *ret = NULL;
 102     if (str)
 103     {
 104         DWORD len = WideCharToMultiByte( cp, 0, str, -1, NULL, 0, NULL, NULL );
 105         if ((ret = cab_alloc( len )))
 106             WideCharToMultiByte( cp, 0, str, -1, ret, len, NULL, NULL );
 107     }
 108     return ret;
 109 }
 110
 111 /* format a cabinet name by replacing the '*' wildcard by the cabinet id */
 112 static BOOL format_cab_name( char *dest, int id, const char *name )
 113 {
 114     const char *num = strchr( name, '*' );
 115     int len;
 116
 117     if (!num)
 118     {
 119         if (id == 1)
 120         {
 121             strcpy( dest, name );
 122             return TRUE;
 123         }
 124         WINE_MESSAGE( "cabarc: Cabinet name must contain a '*' character\n" );
 125         return FALSE;
 126     }
 127     len = num - name;
 128     memcpy( dest, name, len );
 129     len += sprintf( dest + len, "%u", id );
 130     lstrcpynA( dest + len, num + 1, CB_MAX_CABINET_NAME - len );
 131     return TRUE;
 132 }
 133
 134 static int CDECL fci_file_placed( CCAB *cab, char *file, LONG size, BOOL continuation, void *ptr )
 135 {
 136     if (!continuation && opt_verbose) printf( "adding %s\n", file );
 137     return 0;
 138 }
 139
 140 static INT_PTR CDECL fci_open( char *file, int oflag, int pmode, int *err, void *ptr )
 141 {
 142     DWORD creation = 0, sharing = 0;
 143     int ioflag = 0;
 144     HANDLE handle;
 145
 146     switch (oflag & _O_ACCMODE)
 147     {
 148     case _O_RDONLY: ioflag |= GENERIC_READ; break;
 149     case _O_WRONLY: ioflag |= GENERIC_WRITE; break;
 150     case _O_RDWR:   ioflag |= GENERIC_READ | GENERIC_WRITE; break;
 151     }
 152
 153     if (oflag & _O_CREAT)
 154     {
 155         if (oflag & _O_EXCL) creation = CREATE_NEW;
 156         else if (oflag & _O_TRUNC) creation = CREATE_ALWAYS;
 157         else creation = OPEN_ALWAYS;
 158     }
 159     else
 160     {
 161         if (oflag & _O_TRUNC) creation = TRUNCATE_EXISTING;
 162         else creation = OPEN_EXISTING;
 163     }
 164
 165     switch (pmode & 0x70)
 166     {
 167     case _SH_DENYRW: sharing = 0; break;
 168     case _SH_DENYWR: sharing = FILE_SHARE_READ; break;
 169     case _SH_DENYRD: sharing = FILE_SHARE_WRITE; break;
 170     default:         sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
 171     }
 172
 173     handle = CreateFileA( file, ioflag, sharing, NULL, creation, FILE_ATTRIBUTE_NORMAL, NULL );
 174     if (handle == INVALID_HANDLE_VALUE) *err = GetLastError();
 175     return (INT_PTR)handle;
 176 }
 177
 178 static UINT CDECL fci_read( INT_PTR hf, void *pv, UINT cb, int *err, void *ptr )
 179 {
 180     DWORD num_read;
 181
 182     if (!ReadFile( (HANDLE)hf, pv, cb, &num_read, NULL ))
 183     {
 184         *err = GetLastError();
 185         return -1;
 186     }
 187     return num_read;
 188 }
 189
 190 static UINT CDECL fci_write( INT_PTR hf, void *pv, UINT cb, int *err, void *ptr )
 191 {
 192     DWORD written;
 193
 194     if (!WriteFile( (HANDLE) hf, pv, cb, &written, NULL ))
 195     {
 196         *err = GetLastError();
 197         return -1;
 198     }
 199     return written;
 200 }
 201
 202 static int CDECL fci_close( INT_PTR hf, int *err, void *ptr )
 203 {
 204     if (!CloseHandle( (HANDLE)hf ))
 205     {
 206         *err = GetLastError();
 207         return -1;
 208     }
 209     return 0;
 210 }
 211
 212 static LONG CDECL fci_lseek( INT_PTR hf, LONG dist, int seektype, int *err, void *ptr )
 213 {
 214     DWORD ret;
 215
 216     ret = SetFilePointer( (HANDLE)hf, dist, NULL, seektype );
 217     if (ret == INVALID_SET_FILE_POINTER && GetLastError())
 218     {
 219         *err = GetLastError();
 220         return -1;
 221     }
 222     return ret;
 223 }
 224
 225 static int CDECL fci_delete( char *file, int *err, void *ptr )
 226 {
 227     if (!DeleteFileA( file ))
 228     {
 229         *err = GetLastError();
 230         return -1;
 231     }
 232     return 0;
 233 }
 234
 235 static BOOL CDECL fci_get_temp( char *name, int size, void *ptr )
 236 {
 237     char path[MAX_PATH];
 238
 239     if (!GetTempPathA( MAX_PATH, path )) return FALSE;
 240     if (!GetTempFileNameA( path, "cab", 0, name )) return FALSE;
 241     DeleteFileA( name );
 242     return TRUE;
 243 }
 244
 245 static BOOL CDECL fci_get_next_cab( CCAB *cab, ULONG prev_size, void *ptr )
 246 {
 247     return format_cab_name( cab->szCab, cab->iCab + 1, opt_cab_file );
 248 }
 249
 250 static LONG CDECL fci_status( UINT type, ULONG cb1, ULONG cb2, void *ptr )
 251 {
 252     return 0;
 253 }
 254
 255 static INT_PTR CDECL fci_get_open_info( char *name, USHORT *date, USHORT *time,
 256                                         USHORT *attribs, int *err, void *ptr )
 257 {
 258     HANDLE handle;
 259     BY_HANDLE_FILE_INFORMATION info;
 260     WCHAR *p, *nameW = strdupAtoW( CP_UTF8, name );
 261
 262     handle = CreateFileW( nameW, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
 263                           NULL, OPEN_EXISTING, 0, NULL );
 264     if (handle == INVALID_HANDLE_VALUE)
 265     {
 266         *err = GetLastError();
 267         WINE_ERR( "failed to open %s: error %u\n", wine_dbgstr_w(nameW), *err );
 268         cab_free( nameW );
 269         return -1;
 270     }
 271     if (!GetFileInformationByHandle( handle, &info ))
 272     {
 273         *err = GetLastError();
 274         CloseHandle( handle );
 275         cab_free( nameW );
 276         return -1;
 277     }
 278     FileTimeToDosDateTime( &info.ftLastWriteTime, date, time );
 279     *attribs = info.dwFileAttributes & (_A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_ARCH);
 280     for (p = nameW; *p; p++) if (*p >= 0x80) break;
 281     if (*p) *attribs |= _A_NAME_IS_UTF;
 282     cab_free( nameW );
 283     return (INT_PTR)handle;
 284 }
 285
 286 static INT_PTR CDECL fdi_open( char *file, int oflag, int pmode )
 287 {
 288     int err;
 289     return fci_open( file, oflag, pmode, &err, NULL );
 290 }
 291
 292 static UINT CDECL fdi_read( INT_PTR hf, void *pv, UINT cb )
 293 {
 294     int err;
 295     return fci_read( hf, pv, cb, &err, NULL );
 296 }
 297
 298 static UINT CDECL fdi_write( INT_PTR hf, void *pv, UINT cb )
 299 {
 300     int err;
 301     return fci_write( hf, pv, cb, &err, NULL );
 302 }
 303
 304 static int CDECL fdi_close( INT_PTR hf )
 305 {
 306     int err;
 307     return fci_close( hf, &err, NULL );
 308 }
 309
 310 static LONG CDECL fdi_lseek( INT_PTR hf, LONG dist, int whence )
 311 {
 312     int err;
 313     return fci_lseek( hf, dist, whence, &err, NULL );
 314 }
 315
 316
 317 /* create directories leading to a given file */
 318 static void create_directories( const WCHAR *name )
 319 {
 320     WCHAR *path, *p;
 321
 322     /* create the directory/directories */
 323     path = cab_alloc( (strlenW(name) + 1) * sizeof(WCHAR) );
 324     strcpyW(path, name);
 325
 326     p = strchrW(path, '\\');
 327     while (p != NULL)
 328     {
 329         *p = 0;
 330         if (!CreateDirectoryW( path, NULL ))
 331             WINE_TRACE("Couldn't create directory %s - error: %d\n", wine_dbgstr_w(path), GetLastError());
 332         *p = '\\';
 333         p = strchrW(p+1, '\\');
 334     }
 335     cab_free( path );
 336 }
 337
 338 /* check if file name matches against one of the files specification */
 339 static BOOL match_files( const WCHAR *name )
 340 {
 341     int i;
 342
 343     if (!*opt_files) return TRUE;
 344     for (i = 0; opt_files[i]; i++)
 345     {
 346         unsigned int len = strlenW( opt_files[i] );
 347         /* FIXME: do smarter matching, and wildcards */
 348         if (!len) continue;
 349         if (strncmpiW( name, opt_files[i], len )) continue;
 350         if (opt_files[i][len - 1] == '\\' || !name[len] || name[len] == '\\') return TRUE;
 351     }
 352     return FALSE;
 353 }
 354
 355 static INT_PTR CDECL list_notify( FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin )
 356 {
 357     WCHAR *nameW;
 358
 359     switch (fdint)
 360     {
 361     case fdintCABINET_INFO:
 362         return 0;
 363     case fdintCOPY_FILE:
 364         nameW = strdupAtoW( (pfdin->attribs & _A_NAME_IS_UTF) ? CP_UTF8 : CP_ACP, pfdin->psz1 );
 365         if (match_files( nameW ))
 366         {
 367             char *nameU = strdupWtoA( CP_UNIXCP, nameW );
 368             if (opt_verbose)
 369             {
 370                 char attrs[] = "rxash";
 371                 if (!(pfdin->attribs & _A_RDONLY)) attrs[0] = '-';
 372                 if (!(pfdin->attribs & _A_EXEC))   attrs[1] = '-';
 373                 if (!(pfdin->attribs & _A_ARCH))   attrs[2] = '-';
 374                 if (!(pfdin->attribs & _A_SYSTEM)) attrs[3] = '-';
 375                 if (!(pfdin->attribs & _A_HIDDEN)) attrs[4] = '-';
 376                 printf( " %s %9u  %04u/%02u/%02u %02u:%02u:%02u  ", attrs, pfdin->cb,
 377                         (pfdin->date >> 9) + 1980, (pfdin->date >> 5) & 0x0f, pfdin->date & 0x1f,
 378                         pfdin->time >> 11, (pfdin->time >> 5) & 0x3f, (pfdin->time & 0x1f) * 2 );
 379             }
 380             printf( "%s\n", nameU );
 381             cab_free( nameU );
 382         }
 383         cab_free( nameW );
 384         return 0;
 385     default:
 386         WINE_FIXME( "Unexpected notification type %d.\n", fdint );
 387         return 0;
 388     }
 389 }
 390
 391 static int list_cabinet( char *cab_dir )
 392 {
 393     ERF erf;
 394     int ret = 0;
 395     HFDI fdi = FDICreate( cab_alloc, cab_free, fdi_open, fdi_read,
 396                           fdi_write, fdi_close, fdi_lseek, cpuUNKNOWN, &erf );
 397
 398     if (!FDICopy( fdi, opt_cab_file, cab_dir, 0, list_notify, NULL, NULL )) ret = GetLastError();
 399     FDIDestroy( fdi );
 400     return ret;
 401 }
 402
 403 static INT_PTR CDECL extract_notify( FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin )
 404 {
 405     WCHAR *file, *nameW, *path = NULL;
 406     INT_PTR ret;
 407
 408     switch (fdint)
 409     {
 410     case fdintCABINET_INFO:
 411         return 0;
 412
 413     case fdintCOPY_FILE:
 414         nameW = strdupAtoW( (pfdin->attribs & _A_NAME_IS_UTF) ? CP_UTF8 : CP_ACP, pfdin->psz1 );
 415         if (opt_preserve_paths)
 416         {
 417             file = nameW;
 418             while (*file == '\\') file++;  /* remove leading backslashes */
 419         }
 420         else
 421         {
 422             if ((file = strrchrW( nameW, '\\' ))) file++;
 423             else file = nameW;
 424         }
 425
 426         if (opt_dest_dir)
 427         {
 428             path = cab_alloc( (strlenW(opt_dest_dir) + strlenW(file) + 1) * sizeof(WCHAR) );
 429             strcpyW( path, opt_dest_dir );
 430             strcatW( path, file );
 431         }
 432         else path = file;
 433
 434         if (match_files( file ))
 435         {
 436             if (opt_verbose)
 437             {
 438                 char *nameU = strdupWtoA( CP_UNIXCP, path );
 439                 printf( "extracting %s\n", nameU );
 440                 cab_free( nameU );
 441             }
 442             create_directories( path );
 443             /* FIXME: check for existing file and overwrite mode */
 444             ret = (INT_PTR)CreateFileW( path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
 445                                         NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
 446         }
 447         else ret = 0;
 448
 449         cab_free( nameW );
 450         if (path != file) cab_free( path );
 451         return ret;
 452
 453     case fdintCLOSE_FILE_INFO:
 454         CloseHandle( (HANDLE)pfdin->hf );
 455         return 0;
 456
 457     default:
 458         WINE_FIXME( "Unexpected notification type %d.\n", fdint );
 459         return 0;
 460     }
 461 }
 462
 463 static int extract_cabinet( char *cab_dir )
 464 {
 465     ERF erf;
 466     int ret = 0;
 467     HFDI fdi = FDICreate( cab_alloc, cab_free, fdi_open, fdi_read,
 468                           fdi_write, fdi_close, fdi_lseek, cpuUNKNOWN, &erf );
 469
 470     if (!FDICopy( fdi, opt_cab_file, cab_dir, 0, extract_notify, NULL, NULL )) ret = GetLastError();
 471     FDIDestroy( fdi );
 472     return ret;
 473 }
 474
 475 static BOOL add_file( HFCI fci, WCHAR *name )
 476 {
 477     BOOL ret;
 478     char *filename, *path = strdupWtoA( CP_UTF8, name );
 479
 480     if (!opt_preserve_paths)
 481     {
 482         if ((filename = strrchr( path, '\\' ))) filename++;
 483         else filename = path;
 484     }
 485     else
 486     {
 487         filename = path;
 488         while (*filename == '\\') filename++;  /* remove leading backslashes */
 489     }
 490     ret = FCIAddFile( fci, path, filename, FALSE,
 491                       fci_get_next_cab, fci_status, fci_get_open_info, opt_compression );
 492     cab_free( path );
 493     return ret;
 494 }
 495
 496 static BOOL add_directory( HFCI fci, WCHAR *dir )
 497 {
 498     static const WCHAR wildcardW[] = {'*',0};
 499     WCHAR *p, *buffer;
 500     HANDLE handle;
 501     WIN32_FIND_DATAW data;
 502     BOOL ret = TRUE;
 503
 504     if (!(buffer = cab_alloc( (strlenW(dir) + MAX_PATH + 2) * sizeof(WCHAR) ))) return FALSE;
 505     strcpyW( buffer, dir );
 506     p = buffer + strlenW( buffer );
 507     if (p > buffer && p[-1] != '\\') *p++ = '\\';
 508     strcpyW( p, wildcardW );
 509
 510     if ((handle = FindFirstFileW( buffer, &data )) != INVALID_HANDLE_VALUE)
 511     {
 512         do
 513         {
 514             if (data.cFileName[0] == '.' && !data.cFileName[1]) continue;
 515             if (data.cFileName[0] == '.' && data.cFileName[1] == '.' && !data.cFileName[2]) continue;
 516             if (data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) continue;
 517
 518             strcpyW( p, data.cFileName );
 519             if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 520                 ret = add_directory( fci, buffer );
 521             else
 522                 ret = add_file( fci, buffer );
 523             if (!ret) break;
 524         } while (FindNextFileW( handle, &data ));
 525         FindClose( handle );
 526     }
 527     cab_free( buffer );
 528     return TRUE;
 529 }
 530
 531 static BOOL add_file_or_directory( HFCI fci, WCHAR *name )
 532 {
 533     DWORD attr = GetFileAttributesW( name );
 534
 535     if (attr == INVALID_FILE_ATTRIBUTES)
 536     {
 537         WINE_MESSAGE( "cannot open %s\n", wine_dbgstr_w(name) );
 538         return FALSE;
 539     }
 540     if (attr & FILE_ATTRIBUTE_DIRECTORY)
 541     {
 542         if (opt_recurse) return add_directory( fci, name );
 543         WINE_MESSAGE( "cabarc: Cannot add %s, it's a directory (use -r for recursive add)\n",
 544                       wine_dbgstr_w(name) );
 545         return FALSE;
 546     }
 547     return add_file( fci, name );
 548 }
 549
 550 static int new_cabinet( char *cab_dir )
 551 {
 552     static const WCHAR plusW[] = {'+',0};
 553     WCHAR **file;
 554     ERF erf;
 555     BOOL ret = FALSE;
 556     HFCI fci;
 557     CCAB cab;
 558
 559     cab.cb                = opt_cabinet_size;
 560     cab.cbFolderThresh    = CB_MAX_DISK;
 561     cab.cbReserveCFHeader = opt_reserve_space;
 562     cab.cbReserveCFFolder = 0;
 563     cab.cbReserveCFData   = 0;
 564     cab.iCab              = 0;
 565     cab.iDisk             = 0;
 566     cab.setID             = opt_cabinet_id;
 567     cab.szDisk[0]         = 0;
 568
 569     strcpy( cab.szCabPath, cab_dir );
 570     strcat( cab.szCabPath, "\\" );
 571     format_cab_name( cab.szCab, 1, opt_cab_file );
 572
 573     fci = FCICreate( &erf, fci_file_placed, cab_alloc, cab_free,fci_open, fci_read,
 574                      fci_write, fci_close, fci_lseek, fci_delete, fci_get_temp, &cab, NULL );
 575
 576     for (file = opt_files; *file; file++)
 577     {
 578         if (!strcmpW( *file, plusW ))
 579             FCIFlushFolder( fci, fci_get_next_cab, fci_status );
 580         else
 581             if (!(ret = add_file_or_directory( fci, *file ))) break;
 582     }
 583
 584     if (ret)
 585     {
 586         if (!(ret = FCIFlushCabinet( fci, FALSE, fci_get_next_cab, fci_status )))
 587             WINE_MESSAGE( "cabarc: Failed to create cabinet %s\n", wine_dbgstr_a(opt_cab_file) );
 588     }
 589     FCIDestroy( fci );
 590     return !ret;
 591 }
 592
 593 static void usage( void )
 594 {
 595     WINE_MESSAGE(
 596         "Usage: cabarc [options] command file.cab [files...] [dest_dir\\]\n"
 597         "\nCommands:\n"
 598         "   L   List the contents of the cabinet\n"
 599         "   N   Create a new cabinet\n"
 600         "   X   Extract files from the cabinet into dest_dir\n"
 601         "\nOptions:\n"
 602         "  -d size  Set maximum disk size\n"
 603         "  -h       Display this help\n"
 604         "  -i id    Set cabinet id\n"
 605         "  -m type  Set compression type (mszip|none)\n"
 606         "  -p       Preserve directory names\n"
 607         "  -r       Recurse into directories\n"
 608         "  -s size  Reserve space in the cabinet header\n"
 609         "  -v       More verbose output\n" );
 610 }
 611
 612 int wmain( int argc, WCHAR *argv[] )
 613 {
 614     static const WCHAR noneW[] = {'n','o','n','e',0};
 615     static const WCHAR mszipW[] = {'m','s','z','i','p',0};
 616
 617     WCHAR *p, *command;
 618     char buffer[MAX_PATH];
 619     char *cab_file, *file_part;
 620     int i;
 621
 622     while (argv[1] && argv[1][0] == '-')
 623     {
 624         switch (argv[1][1])
 625         {
 626         case 'd':
 627             argv++; argc--;
 628             opt_cabinet_size = atoiW( argv[1] );
 629             if (opt_cabinet_size < 50000)
 630             {
 631                 WINE_MESSAGE( "cabarc: Cabinet size must be at least 50000\n" );
 632                 return 1;
 633             }
 634             break;
 635         case 'h':
 636             usage();
 637             return 0;
 638         case 'i':
 639             argv++; argc--;
 640             opt_cabinet_id = atoiW( argv[1] );
 641             break;
 642         case 'm':
 643             argv++; argc--;
 644             if (!strcmpiW( argv[1], noneW )) opt_compression = tcompTYPE_NONE;
 645             else if (!strcmpiW( argv[1], mszipW )) opt_compression = tcompTYPE_MSZIP;
 646             else
 647             {
 648                 WINE_MESSAGE( "cabarc: Unknown compression type '%s'\n", optarg );
 649                 return 1;
 650             }
 651             break;
 652         case 'p':
 653             opt_preserve_paths = 1;
 654             break;
 655         case 'r':
 656             opt_recurse = 1;
 657             break;
 658         case 's':
 659             argv++; argc--;
 660             opt_reserve_space = atoiW( argv[1] );
 661             break;
 662         case 'v':
 663             opt_verbose++;
 664             break;
 665         default:
 666             usage();
 667             return 1;
 668         }
 669         argv++; argc--;
 670     }
 671
 672     command = argv[1];
 673     if (argc < 3 || !command[0] || command[1])
 674     {
 675         usage();
 676         return 1;
 677     }
 678     cab_file = strdupWtoA( CP_ACP, argv[2] );
 679     argv += 2;
 680     argc -= 2;
 681
 682     if (!GetFullPathNameA( cab_file, MAX_PATH, buffer, &file_part ) || !file_part)
 683     {
 684         WINE_ERR( "cannot get full name for %s\n", wine_dbgstr_a( cab_file ));
 685         return 1;
 686     }
 687     file_part[-1] = 0;
 688     cab_free( cab_file );
 689
 690     /* map slash to backslash in all file arguments */
 691     for (i = 1; i < argc; i++)
 692         for (p = argv[i]; *p; p++)
 693             if (*p == '/') *p = '\\';
 694     opt_files = argv + 1;
 695     opt_cab_file = file_part;
 696
 697     switch (*command)
 698     {
 699     case 'l':
 700     case 'L':
 701         return list_cabinet( buffer );
 702     case 'n':
 703     case 'N':
 704         return new_cabinet( buffer );
 705     case 'x':
 706     case 'X':
 707         if (argc > 1)  /* check for destination dir as last argument */
 708         {
 709             WCHAR *last = argv[argc - 1];
 710             if (last[0] && last[strlenW(last) - 1] == '\\')
 711             {
 712                 opt_dest_dir = last;
 713                 argv[--argc] = NULL;
 714             }
 715         }
 716         return extract_cabinet( buffer );
 717     default:
 718         usage();
 719         return 1;
 720     }
 721 }