programs/wusa/main.c

   1 /*
   2  * Copyright 2012 Austin English
   3  * Copyright 2015 Michael Müller
   4  * Copyright 2015 Sebastian Lackner
   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 <windows.h>
  22 #include <fcntl.h>
  23 #include <fdi.h>
  24 #include <shlwapi.h>
  25
  26 #include "shlobj.h"
  27 #include "wine/debug.h"
  28 #include "wine/list.h"
  29 #include "wusa.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wusa);
  32
  33 struct strbuf
  34 {
  35     WCHAR *buf;
  36     DWORD pos;
  37     DWORD len;
  38 };
  39
  40 struct installer_tempdir
  41 {
  42     struct list entry;
  43     WCHAR *path;
  44 };
  45
  46 struct installer_state
  47 {
  48     BOOL norestart;
  49     BOOL quiet;
  50     struct list tempdirs;
  51     struct list assemblies;
  52     struct list updates;
  53 };
  54
  55 static void * CDECL cabinet_alloc(ULONG cb)
  56 {
  57     return malloc(cb);
  58 }
  59
  60 static void CDECL cabinet_free(void *pv)
  61 {
  62     free(pv);
  63 }
  64
  65 static INT_PTR CDECL cabinet_open(char *pszFile, int oflag, int pmode)
  66 {
  67     DWORD dwAccess = 0;
  68     DWORD dwShareMode = 0;
  69     DWORD dwCreateDisposition = OPEN_EXISTING;
  70
  71     switch (oflag & _O_ACCMODE)
  72     {
  73     case _O_RDONLY:
  74         dwAccess = GENERIC_READ;
  75         dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
  76         break;
  77     case _O_WRONLY:
  78         dwAccess = GENERIC_WRITE;
  79         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
  80         break;
  81     case _O_RDWR:
  82         dwAccess = GENERIC_READ | GENERIC_WRITE;
  83         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
  84         break;
  85     }
  86
  87     if ((oflag & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
  88         dwCreateDisposition = CREATE_NEW;
  89     else if (oflag & _O_CREAT)
  90         dwCreateDisposition = CREATE_ALWAYS;
  91
  92     return (INT_PTR)CreateFileA(pszFile, dwAccess, dwShareMode, NULL, dwCreateDisposition, 0, NULL);
  93 }
  94
  95 static UINT CDECL cabinet_read(INT_PTR hf, void *pv, UINT cb)
  96 {
  97     HANDLE handle = (HANDLE)hf;
  98     DWORD read;
  99
 100     if (ReadFile(handle, pv, cb, &read, NULL))
 101         return read;
 102
 103     return 0;
 104 }
 105
 106 static UINT CDECL cabinet_write(INT_PTR hf, void *pv, UINT cb)
 107 {
 108     HANDLE handle = (HANDLE)hf;
 109     DWORD written;
 110
 111     if (WriteFile(handle, pv, cb, &written, NULL))
 112         return written;
 113
 114     return 0;
 115 }
 116
 117 static int CDECL cabinet_close(INT_PTR hf)
 118 {
 119     HANDLE handle = (HANDLE)hf;
 120     return CloseHandle(handle) ? 0 : -1;
 121 }
 122
 123 static LONG CDECL cabinet_seek(INT_PTR hf, LONG dist, int seektype)
 124 {
 125     HANDLE handle = (HANDLE)hf;
 126     /* flags are compatible and so are passed straight through */
 127     return SetFilePointer(handle, dist, NULL, seektype);
 128 }
 129
 130 static WCHAR *path_combine(const WCHAR *path, const WCHAR *filename)
 131 {
 132     WCHAR *result;
 133     DWORD length;
 134
 135     if (!path || !filename) return NULL;
 136     length = lstrlenW(path) + lstrlenW(filename) + 2;
 137     if (!(result = malloc(length * sizeof(WCHAR)))) return NULL;
 138
 139     lstrcpyW(result, path);
 140     if (result[0] && result[lstrlenW(result) - 1] != '\\') lstrcatW(result, L"\\");
 141     lstrcatW(result, filename);
 142     return result;
 143 }
 144
 145 static WCHAR *get_uncompressed_path(PFDINOTIFICATION pfdin)
 146 {
 147     WCHAR *file = strdupAtoW(pfdin->psz1);
 148     WCHAR *path = path_combine(pfdin->pv, file);
 149     free(file);
 150     return path;
 151 }
 152
 153 static BOOL is_directory(const WCHAR *path)
 154 {
 155     DWORD attrs = GetFileAttributesW(path);
 156     if (attrs == INVALID_FILE_ATTRIBUTES) return FALSE;
 157     return (attrs & FILE_ATTRIBUTE_DIRECTORY) != 0;
 158 }
 159
 160 static BOOL create_directory(const WCHAR *path)
 161 {
 162     if (is_directory(path)) return TRUE;
 163     if (CreateDirectoryW(path, NULL)) return TRUE;
 164     return (GetLastError() == ERROR_ALREADY_EXISTS);
 165 }
 166
 167 static BOOL create_parent_directory(const WCHAR *filename)
 168 {
 169     WCHAR *p, *path = wcsdup(filename);
 170     BOOL ret = FALSE;
 171
 172     if (!path) return FALSE;
 173     if (!PathRemoveFileSpecW(path)) goto done;
 174     if (is_directory(path))
 175     {
 176         ret = TRUE;
 177         goto done;
 178     }
 179
 180     for (p = path; *p; p++)
 181     {
 182         if (*p != '\\') continue;
 183         *p = 0;
 184         if (!create_directory(path)) goto done;
 185         *p = '\\';
 186     }
 187     ret = create_directory(path);
 188
 189 done:
 190     free(path);
 191     return ret;
 192 }
 193
 194 static INT_PTR cabinet_copy_file(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
 195 {
 196     HANDLE handle = INVALID_HANDLE_VALUE;
 197     WCHAR *file;
 198     DWORD attrs;
 199
 200     if (!(file = get_uncompressed_path(pfdin)))
 201         return -1;
 202
 203     TRACE("Extracting %s -> %s\n", debugstr_a(pfdin->psz1), debugstr_w(file));
 204
 205     if (create_parent_directory(file))
 206     {
 207         attrs = pfdin->attribs;
 208         if (!attrs) attrs = FILE_ATTRIBUTE_NORMAL;
 209         handle = CreateFileW(file, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, attrs, NULL);
 210     }
 211
 212     free(file);
 213     return (handle != INVALID_HANDLE_VALUE) ? (INT_PTR)handle : -1;
 214 }
 215
 216 static INT_PTR cabinet_close_file_info(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
 217 {
 218     HANDLE handle = (HANDLE)pfdin->hf;
 219     CloseHandle(handle);
 220     return 1;
 221 }
 222
 223 static INT_PTR CDECL cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
 224 {
 225     switch (fdint)
 226     {
 227     case fdintPARTIAL_FILE:
 228         FIXME("fdintPARTIAL_FILE not implemented\n");
 229         return 0;
 230
 231     case fdintNEXT_CABINET:
 232         FIXME("fdintNEXT_CABINET not implemented\n");
 233         return 0;
 234
 235     case fdintCOPY_FILE:
 236         return cabinet_copy_file(fdint, pfdin);
 237
 238     case fdintCLOSE_FILE_INFO:
 239         return cabinet_close_file_info(fdint, pfdin);
 240
 241     default:
 242         return 0;
 243     }
 244 }
 245
 246 static BOOL extract_cabinet(const WCHAR *filename, const WCHAR *destination)
 247 {
 248     char *filenameA = NULL;
 249     BOOL ret = FALSE;
 250     HFDI hfdi;
 251     ERF erf;
 252
 253     hfdi = FDICreate(cabinet_alloc, cabinet_free, cabinet_open, cabinet_read,
 254                      cabinet_write, cabinet_close, cabinet_seek, 0, &erf);
 255     if (!hfdi) return FALSE;
 256
 257     if ((filenameA = strdupWtoA(filename)))
 258     {
 259         ret = FDICopy(hfdi, filenameA, NULL, 0, cabinet_notify, NULL, (void *)destination);
 260         free(filenameA);
 261     }
 262
 263     FDIDestroy(hfdi);
 264     return ret;
 265 }
 266
 267 static const WCHAR *create_temp_directory(struct installer_state *state)
 268 {
 269     static UINT id;
 270     struct installer_tempdir *entry;
 271     WCHAR tmp[MAX_PATH];
 272
 273     if (!GetTempPathW(ARRAY_SIZE(tmp), tmp)) return NULL;
 274     if (!(entry = malloc(sizeof(*entry)))) return NULL;
 275     if (!(entry->path = malloc((MAX_PATH + 20) * sizeof(WCHAR))))
 276     {
 277         free(entry);
 278         return NULL;
 279     }
 280     for (;;)
 281     {
 282         if (!GetTempFileNameW(tmp, L"msu", ++id, entry->path))
 283         {
 284             free(entry->path);
 285             free(entry);
 286             return NULL;
 287         }
 288         if (CreateDirectoryW(entry->path, NULL)) break;
 289     }
 290
 291     list_add_tail(&state->tempdirs, &entry->entry);
 292     return entry->path;
 293 }
 294
 295 static BOOL delete_directory(const WCHAR *path)
 296 {
 297     WIN32_FIND_DATAW data;
 298     WCHAR *full_path;
 299     HANDLE search;
 300
 301     if (!(full_path = path_combine(path, L"*"))) return FALSE;
 302     search = FindFirstFileW(full_path, &data);
 303     free(full_path);
 304
 305     if (search != INVALID_HANDLE_VALUE)
 306     {
 307         do
 308         {
 309             if (!wcscmp(data.cFileName, L".")) continue;
 310             if (!wcscmp(data.cFileName, L"..")) continue;
 311             if (!(full_path = path_combine(path, data.cFileName))) continue;
 312             if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 313                 delete_directory(full_path);
 314             else
 315                 DeleteFileW(full_path);
 316             free(full_path);
 317         }
 318         while (FindNextFileW(search, &data));
 319         FindClose(search);
 320     }
 321
 322     return RemoveDirectoryW(path);
 323 }
 324
 325 static void installer_cleanup(struct installer_state *state)
 326 {
 327     struct installer_tempdir *tempdir, *tempdir2;
 328     struct assembly_entry *assembly, *assembly2;
 329     struct dependency_entry *dependency, *dependency2;
 330
 331     LIST_FOR_EACH_ENTRY_SAFE(tempdir, tempdir2, &state->tempdirs, struct installer_tempdir, entry)
 332     {
 333         list_remove(&tempdir->entry);
 334         delete_directory(tempdir->path);
 335         free(tempdir->path);
 336         free(tempdir);
 337     }
 338     LIST_FOR_EACH_ENTRY_SAFE(assembly, assembly2, &state->assemblies, struct assembly_entry, entry)
 339     {
 340         list_remove(&assembly->entry);
 341         free_assembly(assembly);
 342     }
 343     LIST_FOR_EACH_ENTRY_SAFE(dependency, dependency2, &state->updates, struct dependency_entry, entry)
 344     {
 345         list_remove(&dependency->entry);
 346         free_dependency(dependency);
 347     }
 348 }
 349
 350 static BOOL str_ends_with(const WCHAR *str, const WCHAR *suffix)
 351 {
 352     DWORD str_len = lstrlenW(str), suffix_len = lstrlenW(suffix);
 353     if (suffix_len > str_len) return FALSE;
 354     return !wcsicmp(str + str_len - suffix_len, suffix);
 355 }
 356
 357 static BOOL load_assemblies_from_cab(const WCHAR *filename, struct installer_state *state)
 358 {
 359     struct assembly_entry *assembly;
 360     const WCHAR *temp_path;
 361     WIN32_FIND_DATAW data;
 362     HANDLE search;
 363     WCHAR *path;
 364
 365     TRACE("Processing cab file %s\n", debugstr_w(filename));
 366
 367     if (!(temp_path = create_temp_directory(state))) return FALSE;
 368     if (!extract_cabinet(filename, temp_path))
 369     {
 370         ERR("Failed to extract %s\n", debugstr_w(filename));
 371         return FALSE;
 372     }
 373
 374     if (!(path = path_combine(temp_path, L"_manifest_.cix.xml"))) return FALSE;
 375     if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
 376     {
 377         FIXME("Cabinet uses proprietary msdelta file compression which is not (yet) supported\n");
 378         FIXME("Installation of msu file will most likely fail\n");
 379     }
 380     free(path);
 381
 382     if (!(path = path_combine(temp_path, L"*"))) return FALSE;
 383     search = FindFirstFileW(path, &data);
 384     free(path);
 385
 386     if (search != INVALID_HANDLE_VALUE)
 387     {
 388         do
 389         {
 390             if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue;
 391             if (!str_ends_with(data.cFileName, L".manifest") &&
 392                 !str_ends_with(data.cFileName, L".mum")) continue;
 393             if (!(path = path_combine(temp_path, data.cFileName))) continue;
 394             if ((assembly = load_manifest(path)))
 395                 list_add_tail(&state->assemblies, &assembly->entry);
 396             free(path);
 397         }
 398         while (FindNextFileW(search, &data));
 399         FindClose(search);
 400     }
 401
 402     return TRUE;
 403 }
 404
 405 static BOOL compare_assembly_string(const WCHAR *str1, const WCHAR *str2)
 406 {
 407     return !wcscmp(str1, str2) || !wcscmp(str1, L"*") || !wcscmp(str2, L"*");
 408 }
 409
 410 static struct assembly_entry *lookup_assembly(struct list *manifest_list, struct assembly_identity *identity)
 411 {
 412     struct assembly_entry *assembly;
 413
 414     LIST_FOR_EACH_ENTRY(assembly, manifest_list, struct assembly_entry, entry)
 415     {
 416         if (wcsicmp(assembly->identity.name, identity->name)) continue;
 417         if (!compare_assembly_string(assembly->identity.architecture, identity->architecture)) continue;
 418         if (!compare_assembly_string(assembly->identity.language, identity->language)) continue;
 419         if (!compare_assembly_string(assembly->identity.pubkey_token, identity->pubkey_token)) continue;
 420         if (!compare_assembly_string(assembly->identity.version, identity->version))
 421         {
 422             WARN("Ignoring version difference for %s (expected %s, found %s)\n",
 423                  debugstr_w(identity->name), debugstr_w(identity->version), debugstr_w(assembly->identity.version));
 424         }
 425         return assembly;
 426     }
 427
 428     return NULL;
 429 }
 430
 431 static WCHAR *get_assembly_source(struct assembly_entry *assembly)
 432 {
 433     WCHAR *p, *path = wcsdup(assembly->filename);
 434     if (path && (p = wcsrchr(path, '.'))) *p = 0;
 435     return path;
 436 }
 437
 438 static BOOL strbuf_init(struct strbuf *buf)
 439 {
 440     buf->pos = 0;
 441     buf->len = 64;
 442     buf->buf = malloc(buf->len * sizeof(WCHAR));
 443     return buf->buf != NULL;
 444 }
 445
 446 static void strbuf_free(struct strbuf *buf)
 447 {
 448     free(buf->buf);
 449     buf->buf = NULL;
 450 }
 451
 452 static BOOL strbuf_append(struct strbuf *buf, const WCHAR *str, DWORD len)
 453 {
 454     DWORD new_len;
 455     WCHAR *new_buf;
 456
 457     if (!buf->buf) return FALSE;
 458     if (!str) return TRUE;
 459
 460     if (len == ~0U) len = lstrlenW(str);
 461     if (buf->pos + len + 1 > buf->len)
 462     {
 463         new_len = max(buf->pos + len + 1, buf->len * 2);
 464         new_buf = realloc(buf->buf, new_len * sizeof(WCHAR));
 465         if (!new_buf)
 466         {
 467             strbuf_free(buf);
 468             return FALSE;
 469         }
 470         buf->buf = new_buf;
 471         buf->len = new_len;
 472     }
 473
 474     memcpy(&buf->buf[buf->pos], str, len * sizeof(WCHAR));
 475     buf->buf[buf->pos + len] = 0;
 476     buf->pos += len;
 477     return TRUE;
 478 }
 479
 480 static BOOL assembly_is_wow64(const struct assembly_entry *assembly)
 481 {
 482 #ifdef __x86_64__
 483     return !wcsicmp(assembly->identity.architecture, L"x86") || !wcsicmp(assembly->identity.architecture, L"wow64");
 484 #endif
 485     return FALSE;
 486 }
 487
 488 static WCHAR *lookup_expression(struct assembly_entry *assembly, const WCHAR *key)
 489 {
 490     WCHAR path[MAX_PATH];
 491     int csidl = 0;
 492
 493     if (!wcsicmp(key, L"runtime.system32") || !wcsicmp(key, L"runtime.drivers") || !wcsicmp(key, L"runtime.wbem"))
 494     {
 495         if (assembly_is_wow64(assembly)) csidl = CSIDL_SYSTEMX86;
 496         else csidl = CSIDL_SYSTEM;
 497     }
 498     else if (!wcsicmp(key, L"runtime.windows") || !wcsicmp(key, L"runtime.inf")) csidl = CSIDL_WINDOWS;
 499     else if (!wcsicmp(key, L"runtime.programfiles"))
 500     {
 501         if (assembly_is_wow64(assembly)) csidl = CSIDL_PROGRAM_FILESX86;
 502         else csidl = CSIDL_PROGRAM_FILES;
 503     }
 504     else if (!wcsicmp(key, L"runtime.commonfiles"))
 505     {
 506         if (assembly_is_wow64(assembly)) csidl = CSIDL_PROGRAM_FILES_COMMONX86;
 507         else csidl = CSIDL_PROGRAM_FILES_COMMON;
 508     }
 509 #ifdef __x86_64__
 510     else if (!wcsicmp(key, L"runtime.programfilesx86")) csidl = CSIDL_PROGRAM_FILESX86;
 511     else if (!wcsicmp(key, L"runtime.commonfilesx86")) csidl = CSIDL_PROGRAM_FILES_COMMONX86;
 512 #endif
 513     else if (!wcsicmp(key, L"runtime.programdata")) csidl = CSIDL_COMMON_APPDATA;
 514     else if (!wcsicmp(key, L"runtime.fonts")) csidl = CSIDL_FONTS;
 515
 516     if (!csidl)
 517     {
 518         FIXME("Unknown expression %s\n", debugstr_w(key));
 519         return NULL;
 520     }
 521     if (!SHGetSpecialFolderPathW(NULL, path, csidl, TRUE))
 522     {
 523         ERR("Failed to get folder path for %s\n", debugstr_w(key));
 524         return NULL;
 525     }
 526
 527     if (!wcsicmp(key, L"runtime.inf")) wcscat(path, L"\\inf");
 528     else if (!wcsicmp(key, L"runtime.drivers")) wcscat(path, L"\\drivers");
 529     else if (!wcsicmp(key, L"runtime.wbem")) wcscat(path, L"\\wbem");
 530     return wcsdup(path);
 531 }
 532
 533 static WCHAR *expand_expression(struct assembly_entry *assembly, const WCHAR *expression)
 534 {
 535     const WCHAR *pos, *next;
 536     WCHAR *key, *value;
 537     struct strbuf buf;
 538
 539     if (!expression || !strbuf_init(&buf)) return NULL;
 540
 541     for (pos = expression; (next = wcsstr(pos, L"$(")); pos = next + 1)
 542     {
 543         strbuf_append(&buf, pos, next - pos);
 544         pos = next + 2;
 545         if (!(next = wcsstr(pos, L")")))
 546         {
 547             strbuf_append(&buf, L"$(", 2);
 548             break;
 549         }
 550
 551         if (!(key = strdupWn(pos, next - pos))) goto error;
 552         value = lookup_expression(assembly, key);
 553         free(key);
 554         if (!value) goto error;
 555         strbuf_append(&buf, value, ~0U);
 556         free(value);
 557     }
 558
 559     strbuf_append(&buf, pos, ~0U);
 560     return buf.buf;
 561
 562 error:
 563     FIXME("Couldn't resolve expression %s\n", debugstr_w(expression));
 564     strbuf_free(&buf);
 565     return NULL;
 566 }
 567
 568 static BOOL install_files_copy(struct assembly_entry *assembly, const WCHAR *source_path, struct fileop_entry *fileop, BOOL dryrun)
 569 {
 570     WCHAR *target_path, *target, *source = NULL;
 571     BOOL ret = FALSE;
 572
 573     if (!(target_path = expand_expression(assembly, fileop->target))) return FALSE;
 574     if (!(target = path_combine(target_path, fileop->source))) goto error;
 575     if (!(source = path_combine(source_path, fileop->source))) goto error;
 576
 577     if (dryrun)
 578     {
 579         if (!(ret = PathFileExistsW(source)))
 580         {
 581             ERR("Required file %s not found\n", debugstr_w(source));
 582             goto error;
 583         }
 584     }
 585     else
 586     {
 587         TRACE("Copying %s -> %s\n", debugstr_w(source), debugstr_w(target));
 588
 589         if (!create_parent_directory(target))
 590         {
 591             ERR("Failed to create parent directory for %s\n", debugstr_w(target));
 592             goto error;
 593         }
 594         if (!(ret = CopyFileExW(source, target, NULL, NULL, NULL, 0)))
 595         {
 596             ERR("Failed to copy %s to %s\n", debugstr_w(source), debugstr_w(target));
 597             goto error;
 598         }
 599     }
 600
 601 error:
 602     free(target_path);
 603     free(target);
 604     free(source);
 605     return ret;
 606 }
 607
 608 static BOOL install_files(struct assembly_entry *assembly, BOOL dryrun)
 609 {
 610     struct fileop_entry *fileop;
 611     WCHAR *source_path;
 612     BOOL ret = TRUE;
 613
 614     if (!(source_path = get_assembly_source(assembly)))
 615     {
 616         ERR("Failed to get assembly source directory\n");
 617         return FALSE;
 618     }
 619
 620     LIST_FOR_EACH_ENTRY(fileop, &assembly->fileops, struct fileop_entry, entry)
 621     {
 622         if (!(ret = install_files_copy(assembly, source_path, fileop, dryrun))) break;
 623     }
 624
 625     free(source_path);
 626     return ret;
 627 }
 628
 629 static WCHAR *split_registry_key(WCHAR *key, HKEY *root)
 630 {
 631     DWORD size;
 632     WCHAR *p;
 633
 634     if (!(p = wcschr(key, '\\'))) return NULL;
 635     size = p - key;
 636
 637     if (lstrlenW(L"HKEY_CLASSES_ROOT") == size && !wcsncmp(key, L"HKEY_CLASSES_ROOT", size))
 638         *root = HKEY_CLASSES_ROOT;
 639     else if (lstrlenW(L"HKEY_CURRENT_CONFIG") == size && !wcsncmp(key, L"HKEY_CURRENT_CONFIG", size))
 640         *root = HKEY_CURRENT_CONFIG;
 641     else if (lstrlenW(L"HKEY_CURRENT_USER") == size && !wcsncmp(key, L"HKEY_CURRENT_USER", size))
 642         *root = HKEY_CURRENT_USER;
 643     else if (lstrlenW(L"HKEY_LOCAL_MACHINE") == size && !wcsncmp(key, L"HKEY_LOCAL_MACHINE", size))
 644         *root = HKEY_LOCAL_MACHINE;
 645     else if (lstrlenW(L"HKEY_USERS") == size && !wcsncmp(key, L"HKEY_USERS", size))
 646         *root = HKEY_USERS;
 647     else
 648     {
 649         FIXME("Unknown root key %s\n", debugstr_wn(key, size));
 650         return NULL;
 651     }
 652
 653     return p + 1;
 654 }
 655
 656 static BOOL install_registry_string(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, DWORD type, BOOL dryrun)
 657 {
 658     DWORD value_size;
 659     WCHAR *value = expand_expression(assembly, registrykv->value);
 660     BOOL ret = TRUE;
 661
 662     if (registrykv->value && !value)
 663         return FALSE;
 664
 665     value_size = value ? (lstrlenW(value) + 1) * sizeof(WCHAR) : 0;
 666     if (!dryrun && RegSetValueExW(key, registrykv->name, 0, type, (void *)value, value_size))
 667     {
 668         ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name));
 669         ret = FALSE;
 670     }
 671
 672     free(value);
 673     return ret;
 674 }
 675
 676 static WCHAR *parse_multisz(const WCHAR *input, DWORD *size)
 677 {
 678     const WCHAR *pos, *next;
 679     struct strbuf buf;
 680
 681     *size = 0;
 682     if (!input || !input[0] || !strbuf_init(&buf)) return NULL;
 683
 684     for (pos = input; pos[0] == '"'; pos++)
 685     {
 686         pos++;
 687         if (!(next = wcsstr(pos, L"\""))) goto error;
 688         strbuf_append(&buf, pos, next - pos);
 689         strbuf_append(&buf, L"", ARRAY_SIZE(L""));
 690
 691         pos = next + 1;
 692         if (!pos[0]) break;
 693         if (pos[0] != ',')
 694         {
 695             FIXME("Error while parsing REG_MULTI_SZ string: Expected comma but got '%c'\n", pos[0]);
 696             goto error;
 697         }
 698     }
 699
 700     if (pos[0])
 701     {
 702         FIXME("Error while parsing REG_MULTI_SZ string: Garbage at end of string\n");
 703         goto error;
 704     }
 705
 706     strbuf_append(&buf, L"", ARRAY_SIZE(L""));
 707     *size = buf.pos * sizeof(WCHAR);
 708     return buf.buf;
 709
 710 error:
 711     strbuf_free(&buf);
 712     return NULL;
 713 }
 714
 715 static BOOL install_registry_multisz(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun)
 716 {
 717     DWORD value_size;
 718     WCHAR *value = parse_multisz(registrykv->value, &value_size);
 719     BOOL ret = TRUE;
 720
 721     if (registrykv->value && registrykv->value[0] && !value)
 722         return FALSE;
 723
 724     if (!dryrun && RegSetValueExW(key, registrykv->name, 0, REG_MULTI_SZ, (void *)value, value_size))
 725     {
 726         ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name));
 727         ret = FALSE;
 728     }
 729
 730     free(value);
 731     return ret;
 732 }
 733
 734 static BOOL install_registry_dword(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun)
 735 {
 736     DWORD value = registrykv->value_type ? wcstoul(registrykv->value_type, NULL, 16) : 0;
 737     BOOL ret = TRUE;
 738
 739     if (!dryrun && RegSetValueExW(key, registrykv->name, 0, REG_DWORD, (void *)&value, sizeof(value)))
 740     {
 741         ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name));
 742         ret = FALSE;
 743     }
 744
 745     return ret;
 746 }
 747
 748 static BYTE *parse_hex(const WCHAR *input, DWORD *size)
 749 {
 750     WCHAR number[3] = {0, 0, 0};
 751     BYTE *output, *p;
 752     int length;
 753
 754     *size = 0;
 755     if (!input) return NULL;
 756     length = lstrlenW(input);
 757     if (length & 1) return NULL;
 758     length >>= 1;
 759
 760     if (!(output = malloc(length))) return NULL;
 761     for (p = output; *input; input += 2)
 762     {
 763         number[0] = input[0];
 764         number[1] = input[1];
 765         *p++ = wcstoul(number, 0, 16);
 766     }
 767     *size = length;
 768     return output;
 769 }
 770
 771 static BOOL install_registry_binary(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun)
 772 {
 773     DWORD value_size;
 774     BYTE *value = parse_hex(registrykv->value, &value_size);
 775     BOOL ret = TRUE;
 776
 777     if (registrykv->value && !value)
 778         return FALSE;
 779
 780     if (!dryrun && RegSetValueExW(key, registrykv->name, 0, REG_BINARY, value, value_size))
 781     {
 782         ERR("Failed to set registry key %s\n", debugstr_w(registrykv->name));
 783         ret = FALSE;
 784     }
 785
 786     free(value);
 787     return ret;
 788 }
 789
 790 static BOOL install_registry_value(struct assembly_entry *assembly, HKEY key, struct registrykv_entry *registrykv, BOOL dryrun)
 791 {
 792     TRACE("Setting registry key %s = %s\n", debugstr_w(registrykv->name), debugstr_w(registrykv->value));
 793
 794     if (!wcscmp(registrykv->value_type, L"REG_SZ"))
 795         return install_registry_string(assembly, key, registrykv, REG_SZ, dryrun);
 796     if (!wcscmp(registrykv->value_type, L"REG_EXPAND_SZ"))
 797         return install_registry_string(assembly, key, registrykv, REG_EXPAND_SZ, dryrun);
 798     if (!wcscmp(registrykv->value_type, L"REG_MULTI_SZ"))
 799         return install_registry_multisz(assembly, key, registrykv, dryrun);
 800     if (!wcscmp(registrykv->value_type, L"REG_DWORD"))
 801         return install_registry_dword(assembly, key, registrykv, dryrun);
 802     if (!wcscmp(registrykv->value_type, L"REG_BINARY"))
 803         return install_registry_binary(assembly, key, registrykv, dryrun);
 804
 805     FIXME("Unsupported registry value type %s\n", debugstr_w(registrykv->value_type));
 806     return FALSE;
 807 }
 808
 809 static BOOL install_registry(struct assembly_entry *assembly, BOOL dryrun)
 810 {
 811     struct registryop_entry *registryop;
 812     struct registrykv_entry *registrykv;
 813     HKEY root, subkey;
 814     WCHAR *path;
 815     REGSAM sam = KEY_ALL_ACCESS;
 816     BOOL ret = TRUE;
 817
 818 #ifdef __x86_64__
 819     if (!wcscmp(assembly->identity.architecture, L"x86")) sam |= KEY_WOW64_32KEY;
 820 #endif
 821
 822     LIST_FOR_EACH_ENTRY(registryop, &assembly->registryops, struct registryop_entry, entry)
 823     {
 824         if (!(path = split_registry_key(registryop->key, &root)))
 825         {
 826             ret = FALSE;
 827             break;
 828         }
 829
 830         TRACE("Processing registry key %s\n", debugstr_w(registryop->key));
 831
 832         if (!dryrun && RegCreateKeyExW(root, path, 0, NULL, 0, sam, NULL, &subkey, NULL))
 833         {
 834             ERR("Failed to open registry key %s\n", debugstr_w(registryop->key));
 835             ret = FALSE;
 836             break;
 837         }
 838
 839         LIST_FOR_EACH_ENTRY(registrykv, &registryop->keyvalues, struct registrykv_entry, entry)
 840         {
 841             if (!(ret = install_registry_value(assembly, subkey, registrykv, dryrun))) break;
 842         }
 843
 844         if (!dryrun) RegCloseKey(subkey);
 845         if (!ret) break;
 846     }
 847
 848     return ret;
 849 }
 850
 851 static BOOL install_assembly(struct list *manifest_list, struct assembly_identity *identity, BOOL dryrun)
 852 {
 853     struct dependency_entry *dependency;
 854     struct assembly_entry *assembly;
 855     const WCHAR *name;
 856
 857     if (!(assembly = lookup_assembly(manifest_list, identity)))
 858     {
 859         FIXME("Assembly %s not found\n", debugstr_w(identity->name));
 860         return FALSE;
 861     }
 862
 863     name = assembly->identity.name;
 864
 865     if (assembly->status == ASSEMBLY_STATUS_INSTALLED)
 866     {
 867         TRACE("Assembly %s already installed\n", debugstr_w(name));
 868         return TRUE;
 869     }
 870     if (assembly->status == ASSEMBLY_STATUS_IN_PROGRESS)
 871     {
 872         ERR("Assembly %s caused circular dependency\n", debugstr_w(name));
 873         return FALSE;
 874     }
 875
 876 #ifdef __i386__
 877     if (!wcscmp(assembly->identity.architecture, L"amd64"))
 878     {
 879         ERR("Cannot install amd64 assembly in 32-bit prefix\n");
 880         return FALSE;
 881     }
 882 #endif
 883
 884     assembly->status = ASSEMBLY_STATUS_IN_PROGRESS;
 885
 886     LIST_FOR_EACH_ENTRY(dependency, &assembly->dependencies, struct dependency_entry, entry)
 887     {
 888         if (!install_assembly(manifest_list, &dependency->identity, dryrun)) return FALSE;
 889     }
 890
 891     TRACE("Installing assembly %s%s\n", debugstr_w(name), dryrun ? " (dryrun)" : "");
 892
 893     if (!install_files(assembly, dryrun))
 894     {
 895         ERR("Failed to install all files for %s\n", debugstr_w(name));
 896         return FALSE;
 897     }
 898
 899     if (!install_registry(assembly, dryrun))
 900     {
 901         ERR("Failed to install registry keys for %s\n", debugstr_w(name));
 902         return FALSE;
 903     }
 904
 905     TRACE("Installation of %s finished\n", debugstr_w(name));
 906
 907     assembly->status = ASSEMBLY_STATUS_INSTALLED;
 908     return TRUE;
 909 }
 910
 911 static BOOL install_updates(struct installer_state *state, BOOL dryrun)
 912 {
 913     struct dependency_entry *dependency;
 914     LIST_FOR_EACH_ENTRY(dependency, &state->updates, struct dependency_entry, entry)
 915     {
 916         if (!install_assembly(&state->assemblies, &dependency->identity, dryrun))
 917         {
 918             ERR("Failed to install update %s\n", debugstr_w(dependency->identity.name));
 919             return FALSE;
 920         }
 921     }
 922     return TRUE;
 923 }
 924
 925 static void set_assembly_status(struct list *manifest_list, DWORD status)
 926 {
 927     struct assembly_entry *assembly;
 928     LIST_FOR_EACH_ENTRY(assembly, manifest_list, struct assembly_entry, entry)
 929     {
 930         assembly->status = status;
 931     }
 932 }
 933
 934 static BOOL install_msu(const WCHAR *filename, struct installer_state *state)
 935 {
 936     const WCHAR *temp_path;
 937     WIN32_FIND_DATAW data;
 938     HANDLE search;
 939     WCHAR *path;
 940     BOOL ret = FALSE;
 941
 942     list_init(&state->tempdirs);
 943     list_init(&state->assemblies);
 944     list_init(&state->updates);
 945     CoInitialize(NULL);
 946
 947     TRACE("Processing msu file %s\n", debugstr_w(filename));
 948
 949     if (!(temp_path = create_temp_directory(state))) return FALSE;
 950     if (!extract_cabinet(filename, temp_path))
 951     {
 952         ERR("Failed to extract %s\n", debugstr_w(filename));
 953         goto done;
 954     }
 955
 956     /* load all manifests from contained cabinet archives */
 957     if (!(path = path_combine(temp_path, L"*.cab"))) goto done;
 958     search = FindFirstFileW(path, &data);
 959     free(path);
 960
 961     if (search != INVALID_HANDLE_VALUE)
 962     {
 963         do
 964         {
 965             if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue;
 966             if (!wcsicmp(data.cFileName, L"WSUSSCAN.cab")) continue;
 967             if (!(path = path_combine(temp_path, data.cFileName))) continue;
 968             if (!load_assemblies_from_cab(path, state))
 969                 ERR("Failed to load all manifests from %s, ignoring\n", debugstr_w(path));
 970             free(path);
 971         }
 972         while (FindNextFileW(search, &data));
 973         FindClose(search);
 974     }
 975
 976     /* load all update descriptions */
 977     if (!(path = path_combine(temp_path, L"*.xml"))) goto done;
 978     search = FindFirstFileW(path, &data);
 979     free(path);
 980
 981     if (search != INVALID_HANDLE_VALUE)
 982     {
 983         do
 984         {
 985             if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue;
 986             if (!(path = path_combine(temp_path, data.cFileName))) continue;
 987             if (!load_update(path, &state->updates))
 988                 ERR("Failed to load all updates from %s, ignoring\n", debugstr_w(path));
 989             free(path);
 990         }
 991         while (FindNextFileW(search, &data));
 992         FindClose(search);
 993     }
 994
 995     /* dump package information (for debugging) */
 996     if (TRACE_ON(wusa))
 997     {
 998         struct dependency_entry *dependency;
 999         struct assembly_entry *assembly;
1000
1001         TRACE("List of updates:\n");
1002         LIST_FOR_EACH_ENTRY(dependency, &state->updates, struct dependency_entry, entry)
1003             TRACE(" * %s\n", debugstr_w(dependency->identity.name));
1004
1005         TRACE("List of manifests (with dependencies):\n");
1006         LIST_FOR_EACH_ENTRY(assembly, &state->assemblies, struct assembly_entry, entry)
1007         {
1008             TRACE(" * %s\n", debugstr_w(assembly->identity.name));
1009             LIST_FOR_EACH_ENTRY(dependency, &assembly->dependencies, struct dependency_entry, entry)
1010                 TRACE("   -> %s\n", debugstr_w(dependency->identity.name));
1011         }
1012     }
1013
1014     if (list_empty(&state->updates))
1015     {
1016         ERR("No updates found, probably incompatible MSU file format?\n");
1017         goto done;
1018     }
1019
1020     /* perform dry run */
1021     set_assembly_status(&state->assemblies, ASSEMBLY_STATUS_NONE);
1022     if (!install_updates(state, TRUE))
1023     {
1024         ERR("Dry run failed, aborting installation\n");
1025         goto done;
1026     }
1027
1028     /* installation */
1029     set_assembly_status(&state->assemblies, ASSEMBLY_STATUS_NONE);
1030     if (!install_updates(state, FALSE))
1031     {
1032         ERR("Installation failed\n");
1033         goto done;
1034     }
1035
1036     TRACE("Installation finished\n");
1037     ret = TRUE;
1038
1039 done:
1040     installer_cleanup(state);
1041     return ret;
1042 }
1043
1044 static void restart_as_x86_64(void)
1045 {
1046     WCHAR filename[MAX_PATH];
1047     PROCESS_INFORMATION pi;
1048     STARTUPINFOW si;
1049     DWORD exit_code = 1;
1050     void *redir;
1051
1052     memset(&si, 0, sizeof(si));
1053     si.cb = sizeof(si);
1054     GetSystemDirectoryW( filename, MAX_PATH );
1055     wcscat( filename, L"\\wusa.exe" );
1056
1057     Wow64DisableWow64FsRedirection(&redir);
1058     if (CreateProcessW(filename, GetCommandLineW(), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
1059     {
1060         TRACE("Restarting %s\n", wine_dbgstr_w(filename));
1061         WaitForSingleObject(pi.hProcess, INFINITE);
1062         GetExitCodeProcess(pi.hProcess, &exit_code);
1063         CloseHandle(pi.hProcess);
1064         CloseHandle(pi.hThread);
1065     }
1066     else ERR("Failed to restart 64-bit %s, err %lu\n", wine_dbgstr_w(filename), GetLastError());
1067     Wow64RevertWow64FsRedirection(redir);
1068
1069     ExitProcess(exit_code);
1070 }
1071
1072 int __cdecl wmain(int argc, WCHAR *argv[])
1073 {
1074     struct installer_state state;
1075     const WCHAR *filename = NULL;
1076     BOOL is_wow64;
1077     int i;
1078
1079     if (IsWow64Process( GetCurrentProcess(), &is_wow64 ) && is_wow64) restart_as_x86_64();
1080
1081     state.norestart = FALSE;
1082     state.quiet = FALSE;
1083
1084     if (TRACE_ON(wusa))
1085     {
1086         TRACE("Command line:");
1087         for (i = 0; i < argc; i++)
1088             TRACE(" %s", wine_dbgstr_w(argv[i]));
1089         TRACE("\n");
1090     }
1091
1092     for (i = 1; i < argc; i++)
1093     {
1094         if (argv[i][0] == '/')
1095         {
1096             if (!wcscmp(argv[i], L"/norestart"))
1097                 state.norestart = TRUE;
1098             else if (!wcscmp(argv[i], L"/quiet"))
1099                 state.quiet = TRUE;
1100             else
1101                 FIXME("Unknown option: %s\n", wine_dbgstr_w(argv[i]));
1102         }
1103         else if (!filename)
1104             filename = argv[i];
1105         else
1106             FIXME("Unknown option: %s\n", wine_dbgstr_w(argv[i]));
1107     }
1108
1109     if (!filename)
1110     {
1111         FIXME("Missing filename argument\n");
1112         return 1;
1113     }
1114
1115     return !install_msu(filename, &state);
1116 }