dlls/msi/files.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Aric Stewart for CodeWeavers
   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
  22 /*
  23  * Actions dealing with files:
  24  *
  25  * InstallFiles
  26  * DuplicateFiles
  27  * MoveFiles
  28  * PatchFiles
  29  * RemoveDuplicateFiles
  30  * RemoveFiles
  31  */
  32
  33 #include <stdarg.h>
  34
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winerror.h"
  38 #include "wine/debug.h"
  39 #include "fdi.h"
  40 #include "msi.h"
  41 #include "msidefs.h"
  42 #include "msipriv.h"
  43 #include "winuser.h"
  44 #include "winreg.h"
  45 #include "shlwapi.h"
  46 #include "wine/unicode.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  49
  50 static HMODULE hmspatcha;
  51 static BOOL (WINAPI *ApplyPatchToFileW)(LPCWSTR, LPCWSTR, LPCWSTR, ULONG);
  52
  53 static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
  54 {
  55     MSIRECORD *uirow;
  56
  57     uirow = MSI_CreateRecord( 9 );
  58     MSI_RecordSetStringW( uirow, 1, f->FileName );
  59     MSI_RecordSetStringW( uirow, 9, f->Component->Directory );
  60     MSI_RecordSetInteger( uirow, 6, f->FileSize );
  61     msi_ui_actiondata( package, action, uirow );
  62     msiobj_release( &uirow->hdr );
  63     msi_ui_progress( package, 2, f->FileSize, 0, 0 );
  64 }
  65
  66 static msi_file_state calculate_install_state( MSIPACKAGE *package, MSIFILE *file )
  67 {
  68     MSICOMPONENT *comp = file->Component;
  69     VS_FIXEDFILEINFO *file_version;
  70     WCHAR *font_version;
  71     msi_file_state state;
  72
  73     comp->Action = msi_get_component_action( package, comp );
  74     if (comp->Action != INSTALLSTATE_LOCAL || (comp->assembly && comp->assembly->installed))
  75     {
  76         TRACE("file %s is not scheduled for install\n", debugstr_w(file->File));
  77         return msifs_skipped;
  78     }
  79     if ((comp->assembly && !comp->assembly->application && !comp->assembly->installed) ||
  80         GetFileAttributesW( file->TargetPath ) == INVALID_FILE_ATTRIBUTES)
  81     {
  82         TRACE("file %s is missing\n", debugstr_w(file->File));
  83         return msifs_missing;
  84     }
  85     if (file->Version)
  86     {
  87         if ((file_version = msi_get_disk_file_version( file->TargetPath )))
  88         {
  89             TRACE("new %s old %u.%u.%u.%u\n", debugstr_w(file->Version),
  90                   HIWORD(file_version->dwFileVersionMS),
  91                   LOWORD(file_version->dwFileVersionMS),
  92                   HIWORD(file_version->dwFileVersionLS),
  93                   LOWORD(file_version->dwFileVersionLS));
  94
  95             if (msi_compare_file_versions( file_version, file->Version ) < 0)
  96                 state = msifs_overwrite;
  97             else
  98             {
  99                 TRACE("destination file version equal or greater, not overwriting\n");
 100                 state = msifs_present;
 101             }
 102             msi_free( file_version );
 103             return state;
 104         }
 105         else if ((font_version = msi_font_version_from_file( file->TargetPath )))
 106         {
 107             TRACE("new %s old %s\n", debugstr_w(file->Version), debugstr_w(font_version));
 108
 109             if (msi_compare_font_versions( font_version, file->Version ) < 0)
 110                 state = msifs_overwrite;
 111             else
 112             {
 113                 TRACE("destination file version equal or greater, not overwriting\n");
 114                 state = msifs_present;
 115             }
 116             msi_free( font_version );
 117             return state;
 118         }
 119     }
 120     if (msi_get_disk_file_size( file->TargetPath ) != file->FileSize)
 121     {
 122         return msifs_overwrite;
 123     }
 124     if (file->hash.dwFileHashInfoSize)
 125     {
 126         if (msi_file_hash_matches( file ))
 127         {
 128             TRACE("file hashes match, not overwriting\n");
 129             return msifs_hashmatch;
 130         }
 131         else
 132         {
 133             TRACE("file hashes do not match, overwriting\n");
 134             return msifs_overwrite;
 135         }
 136     }
 137     /* assume present */
 138     return msifs_present;
 139 }
 140
 141 static void schedule_install_files(MSIPACKAGE *package)
 142 {
 143     MSIFILE *file;
 144
 145     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
 146     {
 147         MSICOMPONENT *comp = file->Component;
 148
 149         file->state = calculate_install_state( package, file );
 150         if (file->state == msifs_overwrite && (comp->Attributes & msidbComponentAttributesNeverOverwrite))
 151         {
 152             TRACE("not overwriting %s\n", debugstr_w(file->TargetPath));
 153             file->state = msifs_skipped;
 154         }
 155     }
 156 }
 157
 158 static UINT copy_file(MSIFILE *file, LPWSTR source)
 159 {
 160     BOOL ret;
 161
 162     ret = CopyFileW(source, file->TargetPath, FALSE);
 163     if (!ret)
 164         return GetLastError();
 165
 166     SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 167
 168     file->state = msifs_installed;
 169     return ERROR_SUCCESS;
 170 }
 171
 172 static UINT copy_install_file(MSIPACKAGE *package, MSIFILE *file, LPWSTR source)
 173 {
 174     UINT gle;
 175
 176     TRACE("Copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 177
 178     gle = copy_file(file, source);
 179     if (gle == ERROR_SUCCESS)
 180         return gle;
 181
 182     if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
 183     {
 184         TRACE("overwriting existing file\n");
 185         return ERROR_SUCCESS;
 186     }
 187     else if (gle == ERROR_ACCESS_DENIED)
 188     {
 189         SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 190
 191         gle = copy_file(file, source);
 192         TRACE("Overwriting existing file: %d\n", gle);
 193     }
 194     if (gle == ERROR_SHARING_VIOLATION || gle == ERROR_USER_MAPPED_FILE)
 195     {
 196         WCHAR *tmpfileW, *pathW, *p;
 197         DWORD len;
 198
 199         TRACE("file in use, scheduling rename operation\n");
 200
 201         if (!(pathW = strdupW( file->TargetPath ))) return ERROR_OUTOFMEMORY;
 202         if ((p = strrchrW(pathW, '\\'))) *p = 0;
 203         len = strlenW( pathW ) + 16;
 204         if (!(tmpfileW = msi_alloc(len * sizeof(WCHAR))))
 205         {
 206             msi_free( pathW );
 207             return ERROR_OUTOFMEMORY;
 208         }
 209         if (!GetTempFileNameW( pathW, szMsi, 0, tmpfileW )) tmpfileW[0] = 0;
 210         msi_free( pathW );
 211
 212         if (CopyFileW(source, tmpfileW, FALSE) &&
 213             MoveFileExW(file->TargetPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT) &&
 214             MoveFileExW(tmpfileW, file->TargetPath, MOVEFILE_DELAY_UNTIL_REBOOT))
 215         {
 216             file->state = msifs_installed;
 217             package->need_reboot_at_end = 1;
 218             gle = ERROR_SUCCESS;
 219         }
 220         else
 221         {
 222             gle = GetLastError();
 223             WARN("failed to schedule rename operation: %d)\n", gle);
 224             DeleteFileW( tmpfileW );
 225         }
 226         msi_free(tmpfileW);
 227     }
 228
 229     return gle;
 230 }
 231
 232 static UINT msi_create_directory( MSIPACKAGE *package, const WCHAR *dir )
 233 {
 234     MSIFOLDER *folder;
 235     const WCHAR *install_path;
 236
 237     install_path = msi_get_target_folder( package, dir );
 238     if (!install_path) return ERROR_FUNCTION_FAILED;
 239
 240     folder = msi_get_loaded_folder( package, dir );
 241     if (folder->State == FOLDER_STATE_UNINITIALIZED)
 242     {
 243         msi_create_full_path( install_path );
 244         folder->State = FOLDER_STATE_CREATED;
 245     }
 246     return ERROR_SUCCESS;
 247 }
 248
 249 static MSIFILE *find_file( MSIPACKAGE *package, const WCHAR *filename )
 250 {
 251     MSIFILE *file;
 252
 253     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 254     {
 255         if (file->state != msifs_installed && !strcmpiW( filename, file->File )) return file;
 256     }
 257     return NULL;
 258 }
 259
 260 static BOOL installfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
 261                             LPWSTR *path, DWORD *attrs, PVOID user)
 262 {
 263     static MSIFILE *f = NULL;
 264     UINT_PTR disk_id = (UINT_PTR)user;
 265
 266     if (action == MSICABEXTRACT_BEGINEXTRACT)
 267     {
 268         if (!(f = find_file( package, file )))
 269         {
 270             TRACE("unknown file in cabinet (%s)\n", debugstr_w(file));
 271             return FALSE;
 272         }
 273         if (f->disk_id != disk_id || (f->state != msifs_missing && f->state != msifs_overwrite))
 274             return FALSE;
 275
 276         if (!f->Component->assembly || f->Component->assembly->application)
 277         {
 278             msi_create_directory(package, f->Component->Directory);
 279         }
 280         *path = strdupW(f->TargetPath);
 281         *attrs = f->Attributes;
 282     }
 283     else if (action == MSICABEXTRACT_FILEEXTRACTED)
 284     {
 285         f->state = msifs_installed;
 286         f = NULL;
 287     }
 288
 289     return TRUE;
 290 }
 291
 292 WCHAR *msi_resolve_file_source( MSIPACKAGE *package, MSIFILE *file )
 293 {
 294     WCHAR *p, *path;
 295
 296     TRACE("Working to resolve source of file %s\n", debugstr_w(file->File));
 297
 298     if (file->IsCompressed) return NULL;
 299
 300     p = msi_resolve_source_folder( package, file->Component->Directory, NULL );
 301     path = msi_build_directory_name( 2, p, file->ShortName );
 302
 303     if (file->LongName && GetFileAttributesW( path ) == INVALID_FILE_ATTRIBUTES)
 304     {
 305         msi_free( path );
 306         path = msi_build_directory_name( 2, p, file->LongName );
 307     }
 308     msi_free( p );
 309     TRACE("file %s source resolves to %s\n", debugstr_w(file->File), debugstr_w(path));
 310     return path;
 311 }
 312
 313 /*
 314  * ACTION_InstallFiles()
 315  *
 316  * For efficiency, this is done in two passes:
 317  * 1) Correct all the TargetPaths and determine what files are to be installed.
 318  * 2) Extract Cabinets and copy files.
 319  */
 320 UINT ACTION_InstallFiles(MSIPACKAGE *package)
 321 {
 322     MSIMEDIAINFO *mi;
 323     MSICOMPONENT *comp;
 324     UINT rc = ERROR_SUCCESS;
 325     MSIFILE *file;
 326
 327     schedule_install_files(package);
 328     mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
 329
 330     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 331     {
 332         msi_file_update_ui( package, file, szInstallFiles );
 333
 334         rc = msi_load_media_info( package, file->Sequence, mi );
 335         if (rc != ERROR_SUCCESS)
 336         {
 337             ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
 338             rc = ERROR_FUNCTION_FAILED;
 339             goto done;
 340         }
 341         if (!file->Component->Enabled) continue;
 342
 343         if (file->state != msifs_hashmatch &&
 344             file->state != msifs_skipped &&
 345             (file->state != msifs_present || !msi_get_property_int( package->db, szInstalled, 0 )) &&
 346             (rc = ready_media( package, file->IsCompressed, mi )))
 347         {
 348             ERR("Failed to ready media for %s\n", debugstr_w(file->File));
 349             goto done;
 350         }
 351
 352         if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
 353             continue;
 354
 355         if (file->Sequence > mi->last_sequence || mi->is_continuous ||
 356             (file->IsCompressed && !mi->is_extracted))
 357         {
 358             MSICABDATA data;
 359
 360             data.mi = mi;
 361             data.package = package;
 362             data.cb = installfiles_cb;
 363             data.user = (PVOID)(UINT_PTR)mi->disk_id;
 364
 365             if (file->IsCompressed &&
 366                 !msi_cabextract(package, mi, &data))
 367             {
 368                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
 369                 rc = ERROR_INSTALL_FAILURE;
 370                 goto done;
 371             }
 372         }
 373
 374         if (!file->IsCompressed)
 375         {
 376             WCHAR *source = msi_resolve_file_source(package, file);
 377
 378             TRACE("copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 379
 380             if (!file->Component->assembly || file->Component->assembly->application)
 381             {
 382                 msi_create_directory(package, file->Component->Directory);
 383             }
 384             rc = copy_install_file(package, file, source);
 385             if (rc != ERROR_SUCCESS)
 386             {
 387                 ERR("Failed to copy %s to %s (%d)\n", debugstr_w(source),
 388                     debugstr_w(file->TargetPath), rc);
 389                 rc = ERROR_INSTALL_FAILURE;
 390                 msi_free(source);
 391                 goto done;
 392             }
 393             msi_free(source);
 394         }
 395         else if (file->state != msifs_installed && !(file->Attributes & msidbFileAttributesPatchAdded))
 396         {
 397             ERR("compressed file wasn't installed (%s)\n", debugstr_w(file->TargetPath));
 398             rc = ERROR_INSTALL_FAILURE;
 399             goto done;
 400         }
 401     }
 402     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
 403     {
 404         comp->Action = msi_get_component_action( package, comp );
 405         if (comp->Action == INSTALLSTATE_LOCAL && comp->assembly && !comp->assembly->installed)
 406         {
 407             rc = msi_install_assembly( package, comp );
 408             if (rc != ERROR_SUCCESS)
 409             {
 410                 ERR("Failed to install assembly\n");
 411                 rc = ERROR_INSTALL_FAILURE;
 412                 break;
 413             }
 414         }
 415     }
 416
 417 done:
 418     msi_free_media_info(mi);
 419     return rc;
 420 }
 421
 422 static BOOL load_mspatcha(void)
 423 {
 424     hmspatcha = LoadLibraryA("mspatcha.dll");
 425     if (!hmspatcha)
 426     {
 427         ERR("Failed to load mspatcha.dll: %d\n", GetLastError());
 428         return FALSE;
 429     }
 430
 431     ApplyPatchToFileW = (void*)GetProcAddress(hmspatcha, "ApplyPatchToFileW");
 432     if(!ApplyPatchToFileW)
 433     {
 434         ERR("GetProcAddress(ApplyPatchToFileW) failed: %d.\n", GetLastError());
 435         return FALSE;
 436     }
 437
 438     return TRUE;
 439 }
 440
 441 static void unload_mspatch(void)
 442 {
 443     FreeLibrary(hmspatcha);
 444 }
 445
 446 static MSIFILEPATCH *get_next_filepatch( MSIPACKAGE *package, const WCHAR *key )
 447 {
 448     MSIFILEPATCH *patch;
 449
 450     LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
 451     {
 452         if (!patch->IsApplied && !strcmpW( key, patch->File->File )) return patch;
 453     }
 454     return NULL;
 455 }
 456
 457 static BOOL patchfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
 458                           LPWSTR *path, DWORD *attrs, PVOID user)
 459 {
 460     static MSIFILEPATCH *p = NULL;
 461     static WCHAR patch_path[MAX_PATH] = {0};
 462     static WCHAR temp_folder[MAX_PATH] = {0};
 463
 464     if (action == MSICABEXTRACT_BEGINEXTRACT)
 465     {
 466         if (temp_folder[0] == '\0')
 467             GetTempPathW(MAX_PATH, temp_folder);
 468
 469         if (!(p = get_next_filepatch(package, file)) || !p->File->Component->Enabled)
 470             return FALSE;
 471
 472         GetTempFileNameW(temp_folder, NULL, 0, patch_path);
 473
 474         *path = strdupW(patch_path);
 475         *attrs = p->File->Attributes;
 476     }
 477     else if (action == MSICABEXTRACT_FILEEXTRACTED)
 478     {
 479         WCHAR patched_file[MAX_PATH];
 480         BOOL br;
 481
 482         GetTempFileNameW(temp_folder, NULL, 0, patched_file);
 483
 484         br = ApplyPatchToFileW(patch_path, p->File->TargetPath, patched_file, 0);
 485         if (br)
 486         {
 487             /* FIXME: baseline cache */
 488
 489             DeleteFileW( p->File->TargetPath );
 490             MoveFileW( patched_file, p->File->TargetPath );
 491
 492             p->IsApplied = TRUE;
 493         }
 494         else
 495             ERR("Failed patch %s: %d.\n", debugstr_w(p->File->TargetPath), GetLastError());
 496
 497         DeleteFileW(patch_path);
 498         p = NULL;
 499     }
 500
 501     return TRUE;
 502 }
 503
 504 UINT ACTION_PatchFiles( MSIPACKAGE *package )
 505 {
 506     MSIFILEPATCH *patch;
 507     MSIMEDIAINFO *mi;
 508     UINT rc = ERROR_SUCCESS;
 509     BOOL mspatcha_loaded = FALSE;
 510
 511     TRACE("%p\n", package);
 512
 513     mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
 514
 515     LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
 516     {
 517         MSIFILE *file = patch->File;
 518         MSICOMPONENT *comp = file->Component;
 519
 520         rc = msi_load_media_info( package, patch->Sequence, mi );
 521         if (rc != ERROR_SUCCESS)
 522         {
 523             ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
 524             rc = ERROR_FUNCTION_FAILED;
 525             goto done;
 526         }
 527         comp->Action = msi_get_component_action( package, comp );
 528         if (!comp->Enabled || comp->Action != INSTALLSTATE_LOCAL) continue;
 529
 530         if (!patch->IsApplied)
 531         {
 532             MSICABDATA data;
 533
 534             rc = ready_media( package, TRUE, mi );
 535             if (rc != ERROR_SUCCESS)
 536             {
 537                 ERR("Failed to ready media for %s\n", debugstr_w(file->File));
 538                 goto done;
 539             }
 540
 541             if (!mspatcha_loaded && !load_mspatcha())
 542             {
 543                 rc = ERROR_FUNCTION_FAILED;
 544                 goto done;
 545             }
 546             mspatcha_loaded = TRUE;
 547
 548             data.mi = mi;
 549             data.package = package;
 550             data.cb = patchfiles_cb;
 551             data.user = (PVOID)(UINT_PTR)mi->disk_id;
 552
 553             if (!msi_cabextract(package, mi, &data))
 554             {
 555                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
 556                 rc = ERROR_INSTALL_FAILURE;
 557                 goto done;
 558             }
 559         }
 560
 561         if (!patch->IsApplied && !(patch->Attributes & msidbPatchAttributesNonVital))
 562         {
 563             ERR("Failed to apply patch to file: %s\n", debugstr_w(file->File));
 564             rc = ERROR_INSTALL_FAILURE;
 565             goto done;
 566         }
 567     }
 568
 569 done:
 570     msi_free_media_info(mi);
 571     if (mspatcha_loaded)
 572         unload_mspatch();
 573     return rc;
 574 }
 575
 576 #define is_dot_dir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
 577
 578 typedef struct
 579 {
 580     struct list entry;
 581     LPWSTR sourcename;
 582     LPWSTR destname;
 583     LPWSTR source;
 584     LPWSTR dest;
 585 } FILE_LIST;
 586
 587 static BOOL msi_move_file(LPCWSTR source, LPCWSTR dest, int options)
 588 {
 589     BOOL ret;
 590
 591     if (GetFileAttributesW(source) == FILE_ATTRIBUTE_DIRECTORY ||
 592         GetFileAttributesW(dest) == FILE_ATTRIBUTE_DIRECTORY)
 593     {
 594         WARN("Source or dest is directory, not moving\n");
 595         return FALSE;
 596     }
 597
 598     if (options == msidbMoveFileOptionsMove)
 599     {
 600         TRACE("moving %s -> %s\n", debugstr_w(source), debugstr_w(dest));
 601         ret = MoveFileExW(source, dest, MOVEFILE_REPLACE_EXISTING);
 602         if (!ret)
 603         {
 604             WARN("MoveFile failed: %d\n", GetLastError());
 605             return FALSE;
 606         }
 607     }
 608     else
 609     {
 610         TRACE("copying %s -> %s\n", debugstr_w(source), debugstr_w(dest));
 611         ret = CopyFileW(source, dest, FALSE);
 612         if (!ret)
 613         {
 614             WARN("CopyFile failed: %d\n", GetLastError());
 615             return FALSE;
 616         }
 617     }
 618
 619     return TRUE;
 620 }
 621
 622 static LPWSTR wildcard_to_file(LPWSTR wildcard, LPWSTR filename)
 623 {
 624     LPWSTR path, ptr;
 625     DWORD dirlen, pathlen;
 626
 627     ptr = strrchrW(wildcard, '\\');
 628     dirlen = ptr - wildcard + 1;
 629
 630     pathlen = dirlen + lstrlenW(filename) + 1;
 631     path = msi_alloc(pathlen * sizeof(WCHAR));
 632
 633     lstrcpynW(path, wildcard, dirlen + 1);
 634     lstrcatW(path, filename);
 635
 636     return path;
 637 }
 638
 639 static void free_file_entry(FILE_LIST *file)
 640 {
 641     msi_free(file->source);
 642     msi_free(file->dest);
 643     msi_free(file);
 644 }
 645
 646 static void free_list(FILE_LIST *list)
 647 {
 648     while (!list_empty(&list->entry))
 649     {
 650         FILE_LIST *file = LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
 651
 652         list_remove(&file->entry);
 653         free_file_entry(file);
 654     }
 655 }
 656
 657 static BOOL add_wildcard(FILE_LIST *files, LPWSTR source, LPWSTR dest)
 658 {
 659     FILE_LIST *new, *file;
 660     LPWSTR ptr, filename;
 661     DWORD size;
 662
 663     new = msi_alloc_zero(sizeof(FILE_LIST));
 664     if (!new)
 665         return FALSE;
 666
 667     new->source = strdupW(source);
 668     ptr = strrchrW(dest, '\\') + 1;
 669     filename = strrchrW(new->source, '\\') + 1;
 670
 671     new->sourcename = filename;
 672
 673     if (*ptr)
 674         new->destname = ptr;
 675     else
 676         new->destname = new->sourcename;
 677
 678     size = (ptr - dest) + lstrlenW(filename) + 1;
 679     new->dest = msi_alloc(size * sizeof(WCHAR));
 680     if (!new->dest)
 681     {
 682         free_file_entry(new);
 683         return FALSE;
 684     }
 685
 686     lstrcpynW(new->dest, dest, ptr - dest + 1);
 687     lstrcatW(new->dest, filename);
 688
 689     if (list_empty(&files->entry))
 690     {
 691         list_add_head(&files->entry, &new->entry);
 692         return TRUE;
 693     }
 694
 695     LIST_FOR_EACH_ENTRY(file, &files->entry, FILE_LIST, entry)
 696     {
 697         if (strcmpW( source, file->source ) < 0)
 698         {
 699             list_add_before(&file->entry, &new->entry);
 700             return TRUE;
 701         }
 702     }
 703
 704     list_add_after(&file->entry, &new->entry);
 705     return TRUE;
 706 }
 707
 708 static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
 709 {
 710     WIN32_FIND_DATAW wfd;
 711     HANDLE hfile;
 712     LPWSTR path;
 713     BOOL res;
 714     FILE_LIST files, *file;
 715     DWORD size;
 716
 717     hfile = FindFirstFileW(source, &wfd);
 718     if (hfile == INVALID_HANDLE_VALUE) return FALSE;
 719
 720     list_init(&files.entry);
 721
 722     for (res = TRUE; res; res = FindNextFileW(hfile, &wfd))
 723     {
 724         if (is_dot_dir(wfd.cFileName)) continue;
 725
 726         path = wildcard_to_file(source, wfd.cFileName);
 727         if (!path)
 728         {
 729             res = FALSE;
 730             goto done;
 731         }
 732
 733         add_wildcard(&files, path, dest);
 734         msi_free(path);
 735     }
 736
 737     /* no files match the wildcard */
 738     if (list_empty(&files.entry))
 739         goto done;
 740
 741     /* only the first wildcard match gets renamed to dest */
 742     file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
 743     size = (strrchrW(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
 744     file->dest = msi_realloc(file->dest, size * sizeof(WCHAR));
 745     if (!file->dest)
 746     {
 747         res = FALSE;
 748         goto done;
 749     }
 750
 751     /* file->dest may be shorter after the reallocation, so add a NULL
 752      * terminator.  This is needed for the call to strrchrW, as there will no
 753      * longer be a NULL terminator within the bounds of the allocation in this case.
 754      */
 755     file->dest[size - 1] = '\0';
 756     lstrcpyW(strrchrW(file->dest, '\\') + 1, file->destname);
 757
 758     while (!list_empty(&files.entry))
 759     {
 760         file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
 761
 762         msi_move_file(file->source, file->dest, options);
 763
 764         list_remove(&file->entry);
 765         free_file_entry(file);
 766     }
 767
 768     res = TRUE;
 769
 770 done:
 771     free_list(&files);
 772     FindClose(hfile);
 773     return res;
 774 }
 775
 776 void msi_reduce_to_long_filename( WCHAR *filename )
 777 {
 778     WCHAR *p = strchrW( filename, '|' );
 779     if (p) memmove( filename, p + 1, (strlenW( p + 1 ) + 1) * sizeof(WCHAR) );
 780 }
 781
 782 static UINT ITERATE_MoveFiles( MSIRECORD *rec, LPVOID param )
 783 {
 784     MSIPACKAGE *package = param;
 785     MSIRECORD *uirow;
 786     MSICOMPONENT *comp;
 787     LPCWSTR sourcename, component;
 788     LPWSTR sourcedir, destname = NULL, destdir = NULL, source = NULL, dest = NULL;
 789     int options;
 790     DWORD size;
 791     BOOL wildcards;
 792
 793     component = MSI_RecordGetString(rec, 2);
 794     comp = msi_get_loaded_component(package, component);
 795     if (!comp)
 796         return ERROR_SUCCESS;
 797
 798     comp->Action = msi_get_component_action( package, comp );
 799     if (comp->Action != INSTALLSTATE_LOCAL)
 800     {
 801         TRACE("component not scheduled for installation %s\n", debugstr_w(component));
 802         return ERROR_SUCCESS;
 803     }
 804
 805     sourcename = MSI_RecordGetString(rec, 3);
 806     options = MSI_RecordGetInteger(rec, 7);
 807
 808     sourcedir = msi_dup_property(package->db, MSI_RecordGetString(rec, 5));
 809     if (!sourcedir)
 810         goto done;
 811
 812     destdir = msi_dup_property(package->db, MSI_RecordGetString(rec, 6));
 813     if (!destdir)
 814         goto done;
 815
 816     if (!sourcename)
 817     {
 818         if (GetFileAttributesW(sourcedir) == INVALID_FILE_ATTRIBUTES)
 819             goto done;
 820
 821         source = strdupW(sourcedir);
 822         if (!source)
 823             goto done;
 824     }
 825     else
 826     {
 827         size = lstrlenW(sourcedir) + lstrlenW(sourcename) + 2;
 828         source = msi_alloc(size * sizeof(WCHAR));
 829         if (!source)
 830             goto done;
 831
 832         lstrcpyW(source, sourcedir);
 833         if (source[lstrlenW(source) - 1] != '\\')
 834             lstrcatW(source, szBackSlash);
 835         lstrcatW(source, sourcename);
 836     }
 837
 838     wildcards = strchrW(source, '*') || strchrW(source, '?');
 839
 840     if (MSI_RecordIsNull(rec, 4))
 841     {
 842         if (!wildcards)
 843         {
 844             destname = strdupW(sourcename);
 845             if (!destname)
 846                 goto done;
 847         }
 848     }
 849     else
 850     {
 851         destname = strdupW(MSI_RecordGetString(rec, 4));
 852         if (destname) msi_reduce_to_long_filename(destname);
 853     }
 854
 855     size = 0;
 856     if (destname)
 857         size = lstrlenW(destname);
 858
 859     size += lstrlenW(destdir) + 2;
 860     dest = msi_alloc(size * sizeof(WCHAR));
 861     if (!dest)
 862         goto done;
 863
 864     lstrcpyW(dest, destdir);
 865     if (dest[lstrlenW(dest) - 1] != '\\')
 866         lstrcatW(dest, szBackSlash);
 867
 868     if (destname)
 869         lstrcatW(dest, destname);
 870
 871     if (GetFileAttributesW(destdir) == INVALID_FILE_ATTRIBUTES)
 872     {
 873         if (!msi_create_full_path(destdir))
 874         {
 875             WARN("failed to create directory %u\n", GetLastError());
 876             goto done;
 877         }
 878     }
 879
 880     if (!wildcards)
 881         msi_move_file(source, dest, options);
 882     else
 883         move_files_wildcard(source, dest, options);
 884
 885 done:
 886     uirow = MSI_CreateRecord( 9 );
 887     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(rec, 1) );
 888     MSI_RecordSetInteger( uirow, 6, 1 ); /* FIXME */
 889     MSI_RecordSetStringW( uirow, 9, destdir );
 890     msi_ui_actiondata( package, szMoveFiles, uirow );
 891     msiobj_release( &uirow->hdr );
 892
 893     msi_free(sourcedir);
 894     msi_free(destdir);
 895     msi_free(destname);
 896     msi_free(source);
 897     msi_free(dest);
 898
 899     return ERROR_SUCCESS;
 900 }
 901
 902 UINT ACTION_MoveFiles( MSIPACKAGE *package )
 903 {
 904     static const WCHAR query[] = {
 905         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 906         '`','M','o','v','e','F','i','l','e','`',0};
 907     MSIQUERY *view;
 908     UINT rc;
 909
 910     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
 911     if (rc != ERROR_SUCCESS)
 912         return ERROR_SUCCESS;
 913
 914     rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
 915     msiobj_release(&view->hdr);
 916     return rc;
 917 }
 918
 919 static WCHAR *get_duplicate_filename( MSIPACKAGE *package, MSIRECORD *row, const WCHAR *file_key, const WCHAR *src )
 920 {
 921     DWORD len;
 922     WCHAR *dst_name, *dst_path, *dst;
 923
 924     if (MSI_RecordIsNull( row, 4 ))
 925     {
 926         len = strlenW( src ) + 1;
 927         if (!(dst_name = msi_alloc( len * sizeof(WCHAR)))) return NULL;
 928         strcpyW( dst_name, strrchrW( src, '\\' ) + 1 );
 929     }
 930     else
 931     {
 932         MSI_RecordGetStringW( row, 4, NULL, &len );
 933         if (!(dst_name = msi_alloc( ++len * sizeof(WCHAR) ))) return NULL;
 934         MSI_RecordGetStringW( row, 4, dst_name, &len );
 935         msi_reduce_to_long_filename( dst_name );
 936     }
 937
 938     if (MSI_RecordIsNull( row, 5 ))
 939     {
 940         WCHAR *p;
 941         dst_path = strdupW( src );
 942         p = strrchrW( dst_path, '\\' );
 943         if (p) *p = 0;
 944     }
 945     else
 946     {
 947         const WCHAR *dst_key = MSI_RecordGetString( row, 5 );
 948
 949         dst_path = strdupW( msi_get_target_folder( package, dst_key ) );
 950         if (!dst_path)
 951         {
 952             /* try a property */
 953             dst_path = msi_dup_property( package->db, dst_key );
 954             if (!dst_path)
 955             {
 956                 FIXME("Unable to get destination folder, try AppSearch properties\n");
 957                 msi_free( dst_name );
 958                 return NULL;
 959             }
 960         }
 961     }
 962
 963     dst = msi_build_directory_name( 2, dst_path, dst_name );
 964     msi_create_full_path( dst_path );
 965
 966     msi_free( dst_name );
 967     msi_free( dst_path );
 968     return dst;
 969 }
 970
 971 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
 972 {
 973     MSIPACKAGE *package = param;
 974     LPWSTR dest;
 975     LPCWSTR file_key, component;
 976     MSICOMPONENT *comp;
 977     MSIRECORD *uirow;
 978     MSIFILE *file;
 979
 980     component = MSI_RecordGetString(row,2);
 981     comp = msi_get_loaded_component(package, component);
 982     if (!comp)
 983         return ERROR_SUCCESS;
 984
 985     comp->Action = msi_get_component_action( package, comp );
 986     if (comp->Action != INSTALLSTATE_LOCAL)
 987     {
 988         TRACE("component not scheduled for installation %s\n", debugstr_w(component));
 989         return ERROR_SUCCESS;
 990     }
 991
 992     file_key = MSI_RecordGetString(row,3);
 993     if (!file_key)
 994     {
 995         ERR("Unable to get file key\n");
 996         return ERROR_FUNCTION_FAILED;
 997     }
 998
 999     file = msi_get_loaded_file( package, file_key );
1000     if (!file)
1001     {
1002         ERR("Original file unknown %s\n", debugstr_w(file_key));
1003         return ERROR_SUCCESS;
1004     }
1005
1006     dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
1007     if (!dest)
1008     {
1009         WARN("Unable to get duplicate filename\n");
1010         return ERROR_SUCCESS;
1011     }
1012
1013     TRACE("Duplicating file %s to %s\n", debugstr_w(file->TargetPath), debugstr_w(dest));
1014
1015     if (!CopyFileW( file->TargetPath, dest, TRUE ))
1016     {
1017         WARN("Failed to copy file %s -> %s (%u)\n",
1018              debugstr_w(file->TargetPath), debugstr_w(dest), GetLastError());
1019     }
1020
1021     FIXME("We should track these duplicate files as well\n");
1022
1023     uirow = MSI_CreateRecord( 9 );
1024     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
1025     MSI_RecordSetInteger( uirow, 6, file->FileSize );
1026     MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
1027     msi_ui_actiondata( package, szDuplicateFiles, uirow );
1028     msiobj_release( &uirow->hdr );
1029
1030     msi_free(dest);
1031     return ERROR_SUCCESS;
1032 }
1033
1034 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
1035 {
1036     static const WCHAR query[] = {
1037         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1038         '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
1039     MSIQUERY *view;
1040     UINT rc;
1041
1042     rc = MSI_DatabaseOpenViewW(package->db, query, &view);
1043     if (rc != ERROR_SUCCESS)
1044         return ERROR_SUCCESS;
1045
1046     rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
1047     msiobj_release(&view->hdr);
1048     return rc;
1049 }
1050
1051 static UINT ITERATE_RemoveDuplicateFiles( MSIRECORD *row, LPVOID param )
1052 {
1053     MSIPACKAGE *package = param;
1054     LPWSTR dest;
1055     LPCWSTR file_key, component;
1056     MSICOMPONENT *comp;
1057     MSIRECORD *uirow;
1058     MSIFILE *file;
1059
1060     component = MSI_RecordGetString( row, 2 );
1061     comp = msi_get_loaded_component( package, component );
1062     if (!comp)
1063         return ERROR_SUCCESS;
1064
1065     comp->Action = msi_get_component_action( package, comp );
1066     if (comp->Action != INSTALLSTATE_ABSENT)
1067     {
1068         TRACE("component not scheduled for removal %s\n", debugstr_w(component));
1069         return ERROR_SUCCESS;
1070     }
1071
1072     file_key = MSI_RecordGetString( row, 3 );
1073     if (!file_key)
1074     {
1075         ERR("Unable to get file key\n");
1076         return ERROR_FUNCTION_FAILED;
1077     }
1078
1079     file = msi_get_loaded_file( package, file_key );
1080     if (!file)
1081     {
1082         ERR("Original file unknown %s\n", debugstr_w(file_key));
1083         return ERROR_SUCCESS;
1084     }
1085
1086     dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
1087     if (!dest)
1088     {
1089         WARN("Unable to get duplicate filename\n");
1090         return ERROR_SUCCESS;
1091     }
1092
1093     TRACE("Removing duplicate %s of %s\n", debugstr_w(dest), debugstr_w(file->TargetPath));
1094
1095     if (!DeleteFileW( dest ))
1096     {
1097         WARN("Failed to delete duplicate file %s (%u)\n", debugstr_w(dest), GetLastError());
1098     }
1099
1100     uirow = MSI_CreateRecord( 9 );
1101     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
1102     MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
1103     msi_ui_actiondata( package, szRemoveDuplicateFiles, uirow );
1104     msiobj_release( &uirow->hdr );
1105
1106     msi_free(dest);
1107     return ERROR_SUCCESS;
1108 }
1109
1110 UINT ACTION_RemoveDuplicateFiles( MSIPACKAGE *package )
1111 {
1112     static const WCHAR query[] = {
1113         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1114         '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
1115     MSIQUERY *view;
1116     UINT rc;
1117
1118     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
1119     if (rc != ERROR_SUCCESS)
1120         return ERROR_SUCCESS;
1121
1122     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveDuplicateFiles, package );
1123     msiobj_release( &view->hdr );
1124     return rc;
1125 }
1126
1127 static BOOL verify_comp_for_removal(MSICOMPONENT *comp, UINT install_mode)
1128 {
1129     /* special case */
1130     if (comp->Action != INSTALLSTATE_SOURCE &&
1131         comp->Attributes & msidbComponentAttributesSourceOnly &&
1132         (install_mode == msidbRemoveFileInstallModeOnRemove ||
1133          install_mode == msidbRemoveFileInstallModeOnBoth)) return TRUE;
1134
1135     switch (comp->Action)
1136     {
1137     case INSTALLSTATE_LOCAL:
1138     case INSTALLSTATE_SOURCE:
1139         if (install_mode == msidbRemoveFileInstallModeOnInstall ||
1140             install_mode == msidbRemoveFileInstallModeOnBoth) return TRUE;
1141         break;
1142     case INSTALLSTATE_ABSENT:
1143         if (install_mode == msidbRemoveFileInstallModeOnRemove ||
1144             install_mode == msidbRemoveFileInstallModeOnBoth) return TRUE;
1145         break;
1146     default: break;
1147     }
1148     return FALSE;
1149 }
1150
1151 static UINT ITERATE_RemoveFiles(MSIRECORD *row, LPVOID param)
1152 {
1153     MSIPACKAGE *package = param;
1154     MSICOMPONENT *comp;
1155     MSIRECORD *uirow;
1156     LPCWSTR component, dirprop;
1157     UINT install_mode;
1158     LPWSTR dir = NULL, path = NULL, filename = NULL;
1159     DWORD size;
1160     UINT ret = ERROR_SUCCESS;
1161
1162     component = MSI_RecordGetString(row, 2);
1163     dirprop = MSI_RecordGetString(row, 4);
1164     install_mode = MSI_RecordGetInteger(row, 5);
1165
1166     comp = msi_get_loaded_component(package, component);
1167     if (!comp)
1168         return ERROR_SUCCESS;
1169
1170     comp->Action = msi_get_component_action( package, comp );
1171     if (!verify_comp_for_removal(comp, install_mode))
1172     {
1173         TRACE("Skipping removal due to install mode\n");
1174         return ERROR_SUCCESS;
1175     }
1176     if (comp->assembly && !comp->assembly->application)
1177     {
1178         return ERROR_SUCCESS;
1179     }
1180     if (comp->Attributes & msidbComponentAttributesPermanent)
1181     {
1182         TRACE("permanent component, not removing file\n");
1183         return ERROR_SUCCESS;
1184     }
1185
1186     dir = msi_dup_property(package->db, dirprop);
1187     if (!dir)
1188     {
1189         WARN("directory property has no value\n");
1190         return ERROR_SUCCESS;
1191     }
1192     size = 0;
1193     if ((filename = strdupW( MSI_RecordGetString(row, 3) )))
1194     {
1195         msi_reduce_to_long_filename( filename );
1196         size = lstrlenW( filename );
1197     }
1198     size += lstrlenW(dir) + 2;
1199     path = msi_alloc(size * sizeof(WCHAR));
1200     if (!path)
1201     {
1202         ret = ERROR_OUTOFMEMORY;
1203         goto done;
1204     }
1205
1206     if (filename)
1207     {
1208         lstrcpyW(path, dir);
1209         PathAddBackslashW(path);
1210         lstrcatW(path, filename);
1211
1212         TRACE("Deleting misc file: %s\n", debugstr_w(path));
1213         DeleteFileW(path);
1214     }
1215     else
1216     {
1217         TRACE("Removing misc directory: %s\n", debugstr_w(dir));
1218         RemoveDirectoryW(dir);
1219     }
1220
1221 done:
1222     uirow = MSI_CreateRecord( 9 );
1223     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(row, 1) );
1224     MSI_RecordSetStringW( uirow, 9, dir );
1225     msi_ui_actiondata( package, szRemoveFiles, uirow );
1226     msiobj_release( &uirow->hdr );
1227
1228     msi_free(filename);
1229     msi_free(path);
1230     msi_free(dir);
1231     return ret;
1232 }
1233
1234 static void remove_folder( MSIFOLDER *folder )
1235 {
1236     FolderList *fl;
1237
1238     LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
1239     {
1240         remove_folder( fl->folder );
1241     }
1242     if (!folder->persistent && folder->State != FOLDER_STATE_REMOVED)
1243     {
1244         if (RemoveDirectoryW( folder->ResolvedTarget )) folder->State = FOLDER_STATE_REMOVED;
1245     }
1246 }
1247
1248 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
1249 {
1250     static const WCHAR query[] = {
1251         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1252         '`','R','e','m','o','v','e','F','i','l','e','`',0};
1253     MSIQUERY *view;
1254     MSICOMPONENT *comp;
1255     MSIFILE *file;
1256     UINT r;
1257
1258     r = MSI_DatabaseOpenViewW(package->db, query, &view);
1259     if (r == ERROR_SUCCESS)
1260     {
1261         r = MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
1262         msiobj_release(&view->hdr);
1263         if (r != ERROR_SUCCESS)
1264             return r;
1265     }
1266
1267     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
1268     {
1269         MSIRECORD *uirow;
1270         VS_FIXEDFILEINFO *ver;
1271
1272         comp = file->Component;
1273         msi_file_update_ui( package, file, szRemoveFiles );
1274
1275         comp->Action = msi_get_component_action( package, comp );
1276         if (comp->Action != INSTALLSTATE_ABSENT || comp->Installed == INSTALLSTATE_SOURCE)
1277             continue;
1278
1279         if (comp->assembly && !comp->assembly->application)
1280             continue;
1281
1282         if (comp->Attributes & msidbComponentAttributesPermanent)
1283         {
1284             TRACE("permanent component, not removing file\n");
1285             continue;
1286         }
1287
1288         if (file->Version)
1289         {
1290             ver = msi_get_disk_file_version( file->TargetPath );
1291             if (ver && msi_compare_file_versions( ver, file->Version ) > 0)
1292             {
1293                 TRACE("newer version detected, not removing file\n");
1294                 msi_free( ver );
1295                 continue;
1296             }
1297             msi_free( ver );
1298         }
1299
1300         if (file->state == msifs_installed)
1301             WARN("removing installed file %s\n", debugstr_w(file->TargetPath));
1302
1303         TRACE("removing %s\n", debugstr_w(file->File) );
1304
1305         SetFileAttributesW( file->TargetPath, FILE_ATTRIBUTE_NORMAL );
1306         if (!DeleteFileW( file->TargetPath ))
1307         {
1308             WARN("failed to delete %s (%u)\n",  debugstr_w(file->TargetPath), GetLastError());
1309         }
1310         file->state = msifs_missing;
1311
1312         uirow = MSI_CreateRecord( 9 );
1313         MSI_RecordSetStringW( uirow, 1, file->FileName );
1314         MSI_RecordSetStringW( uirow, 9, comp->Directory );
1315         msi_ui_actiondata( package, szRemoveFiles, uirow );
1316         msiobj_release( &uirow->hdr );
1317     }
1318
1319     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1320     {
1321         comp->Action = msi_get_component_action( package, comp );
1322         if (comp->Action != INSTALLSTATE_ABSENT) continue;
1323
1324         if (comp->Attributes & msidbComponentAttributesPermanent)
1325         {
1326             TRACE("permanent component, not removing directory\n");
1327             continue;
1328         }
1329         if (comp->assembly && !comp->assembly->application)
1330             msi_uninstall_assembly( package, comp );
1331         else
1332         {
1333             MSIFOLDER *folder = msi_get_loaded_folder( package, comp->Directory );
1334             remove_folder( folder );
1335         }
1336     }
1337     return ERROR_SUCCESS;
1338 }