dlls/fusion/asmname.c

   1 /*
   2  * IAssemblyName implementation
   3  *
   4  * Copyright 2008 James Hawkins
   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 <stdarg.h>
  22 #include <assert.h>
  23
  24 #define COBJMACROS
  25 #define INITGUID
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "guiddef.h"
  32 #include "fusion.h"
  33 #include "corerror.h"
  34
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37 #include "fusionpriv.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(fusion);
  40
  41 typedef struct {
  42     IAssemblyName IAssemblyName_iface;
  43
  44     LPWSTR path;
  45
  46     LPWSTR displayname;
  47     LPWSTR name;
  48     LPWSTR culture;
  49     LPWSTR procarch;
  50
  51     WORD version[4];
  52     DWORD versize;
  53
  54     BYTE pubkey[8];
  55     BOOL haspubkey;
  56
  57     LONG ref;
  58 } IAssemblyNameImpl;
  59
  60 static const WCHAR separator[] = {',',' ',0};
  61 static const WCHAR version[] = {'V','e','r','s','i','o','n',0};
  62 static const WCHAR culture[] = {'C','u','l','t','u','r','e',0};
  63 static const WCHAR pubkey[] =
  64     {'P','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
  65 static const WCHAR procarch[] = {'p','r','o','c','e','s','s','o','r',
  66     'A','r','c','h','i','t','e','c','t','u','r','e',0};
  67
  68 #define CHARS_PER_PUBKEY 16
  69
  70 static inline IAssemblyNameImpl *impl_from_IAssemblyName(IAssemblyName *iface)
  71 {
  72     return CONTAINING_RECORD(iface, IAssemblyNameImpl, IAssemblyName_iface);
  73 }
  74
  75 static HRESULT WINAPI IAssemblyNameImpl_QueryInterface(IAssemblyName *iface,
  76                                                        REFIID riid, LPVOID *ppobj)
  77 {
  78     IAssemblyNameImpl *This = impl_from_IAssemblyName(iface);
  79
  80     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
  81
  82     *ppobj = NULL;
  83
  84     if (IsEqualIID(riid, &IID_IUnknown) ||
  85         IsEqualIID(riid, &IID_IAssemblyName))
  86     {
  87         IAssemblyName_AddRef(iface);
  88         *ppobj = &This->IAssemblyName_iface;
  89         return S_OK;
  90     }
  91
  92     WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
  93     return E_NOINTERFACE;
  94 }
  95
  96 static ULONG WINAPI IAssemblyNameImpl_AddRef(IAssemblyName *iface)
  97 {
  98     IAssemblyNameImpl *This = impl_from_IAssemblyName(iface);
  99     ULONG refCount = InterlockedIncrement(&This->ref);
 100
 101     TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
 102
 103     return refCount;
 104 }
 105
 106 static ULONG WINAPI IAssemblyNameImpl_Release(IAssemblyName *iface)
 107 {
 108     IAssemblyNameImpl *This = impl_from_IAssemblyName(iface);
 109     ULONG refCount = InterlockedDecrement(&This->ref);
 110
 111     TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
 112
 113     if (!refCount)
 114     {
 115         HeapFree(GetProcessHeap(), 0, This->path);
 116         HeapFree(GetProcessHeap(), 0, This->displayname);
 117         HeapFree(GetProcessHeap(), 0, This->name);
 118         HeapFree(GetProcessHeap(), 0, This->culture);
 119         HeapFree(GetProcessHeap(), 0, This->procarch);
 120         HeapFree(GetProcessHeap(), 0, This);
 121     }
 122
 123     return refCount;
 124 }
 125
 126 static HRESULT WINAPI IAssemblyNameImpl_SetProperty(IAssemblyName *iface,
 127                                                     DWORD PropertyId,
 128                                                     LPVOID pvProperty,
 129                                                     DWORD cbProperty)
 130 {
 131     FIXME("(%p, %d, %p, %d) stub!\n", iface, PropertyId, pvProperty, cbProperty);
 132     return E_NOTIMPL;
 133 }
 134
 135 static HRESULT WINAPI IAssemblyNameImpl_GetProperty(IAssemblyName *iface,
 136                                                     DWORD PropertyId,
 137                                                     LPVOID pvProperty,
 138                                                     LPDWORD pcbProperty)
 139 {
 140     IAssemblyNameImpl *name = impl_from_IAssemblyName(iface);
 141
 142     TRACE("(%p, %d, %p, %p)\n", iface, PropertyId, pvProperty, pcbProperty);
 143
 144     *((LPWSTR)pvProperty) = '\0';
 145
 146     switch (PropertyId)
 147     {
 148         case ASM_NAME_NULL_PUBLIC_KEY:
 149         case ASM_NAME_NULL_PUBLIC_KEY_TOKEN:
 150             if (name->haspubkey)
 151                 return S_OK;
 152             return S_FALSE;
 153
 154         case ASM_NAME_NULL_CUSTOM:
 155             return S_OK;
 156
 157         case ASM_NAME_NAME:
 158             *pcbProperty = 0;
 159             if (name->name)
 160             {
 161                 lstrcpyW(pvProperty, name->name);
 162                 *pcbProperty = (lstrlenW(name->name) + 1) * 2;
 163             }
 164             break;
 165
 166         case ASM_NAME_MAJOR_VERSION:
 167             *pcbProperty = 0;
 168             *((WORD *)pvProperty) = name->version[0];
 169             if (name->versize >= 1)
 170                 *pcbProperty = sizeof(WORD);
 171             break;
 172
 173         case ASM_NAME_MINOR_VERSION:
 174             *pcbProperty = 0;
 175             *((WORD *)pvProperty) = name->version[1];
 176             if (name->versize >= 2)
 177                 *pcbProperty = sizeof(WORD);
 178             break;
 179
 180         case ASM_NAME_BUILD_NUMBER:
 181             *pcbProperty = 0;
 182             *((WORD *)pvProperty) = name->version[2];
 183             if (name->versize >= 3)
 184                 *pcbProperty = sizeof(WORD);
 185             break;
 186
 187         case ASM_NAME_REVISION_NUMBER:
 188             *pcbProperty = 0;
 189             *((WORD *)pvProperty) = name->version[3];
 190             if (name->versize >= 4)
 191                 *pcbProperty = sizeof(WORD);
 192             break;
 193
 194         case ASM_NAME_CULTURE:
 195             *pcbProperty = 0;
 196             if (name->culture)
 197             {
 198                 lstrcpyW(pvProperty, name->culture);
 199                 *pcbProperty = (lstrlenW(name->culture) + 1) * 2;
 200             }
 201             break;
 202
 203         case ASM_NAME_PUBLIC_KEY_TOKEN:
 204             *pcbProperty = 0;
 205             if (name->haspubkey)
 206             {
 207                 memcpy(pvProperty, name->pubkey, sizeof(DWORD) * 2);
 208                 *pcbProperty = sizeof(DWORD) * 2;
 209             }
 210             break;
 211
 212         default:
 213             *pcbProperty = 0;
 214             break;
 215     }
 216
 217     return S_OK;
 218 }
 219
 220 static HRESULT WINAPI IAssemblyNameImpl_Finalize(IAssemblyName *iface)
 221 {
 222     FIXME("(%p) stub!\n", iface);
 223     return E_NOTIMPL;
 224 }
 225
 226 static HRESULT WINAPI IAssemblyNameImpl_GetDisplayName(IAssemblyName *iface,
 227                                                        LPOLESTR szDisplayName,
 228                                                        LPDWORD pccDisplayName,
 229                                                        DWORD dwDisplayFlags)
 230 {
 231     static const WCHAR equals[] = {'=',0};
 232     IAssemblyNameImpl *name = impl_from_IAssemblyName(iface);
 233     WCHAR verstr[30], *cultureval = NULL;
 234     DWORD size;
 235
 236     TRACE("(%p, %p, %p, %d)\n", iface, szDisplayName,
 237           pccDisplayName, dwDisplayFlags);
 238
 239     if (dwDisplayFlags == 0)
 240     {
 241         if (!name->displayname || !*name->displayname)
 242             return FUSION_E_INVALID_NAME;
 243
 244         size = strlenW(name->displayname) + 1;
 245
 246         if (*pccDisplayName < size)
 247         {
 248             *pccDisplayName = size;
 249             return E_NOT_SUFFICIENT_BUFFER;
 250         }
 251
 252         if (szDisplayName) strcpyW(szDisplayName, name->displayname);
 253         *pccDisplayName = size;
 254
 255         return S_OK;
 256     }
 257
 258     if (!name->name || !*name->name)
 259         return FUSION_E_INVALID_NAME;
 260
 261     /* Verify buffer size is sufficient */
 262     size = lstrlenW(name->name) + 1;
 263
 264     if ((dwDisplayFlags & ASM_DISPLAYF_VERSION) && (name->versize > 0))
 265     {
 266         static const WCHAR spec[] = {'%','d',0};
 267         static const WCHAR period[] = {'.',0};
 268         DWORD i;
 269
 270         wsprintfW(verstr, spec, name->version[0]);
 271
 272         for (i = 1; i < name->versize; i++)
 273         {
 274             WCHAR value[6];
 275             wsprintfW(value, spec, name->version[i]);
 276
 277             lstrcatW(verstr, period);
 278             lstrcatW(verstr, value);
 279         }
 280
 281         size += lstrlenW(separator) + lstrlenW(version) + lstrlenW(equals) + lstrlenW(verstr);
 282     }
 283
 284     if ((dwDisplayFlags & ASM_DISPLAYF_CULTURE) && (name->culture))
 285     {
 286         static const WCHAR neutral[] = {'n','e','u','t','r','a','l', 0};
 287
 288         cultureval = (lstrlenW(name->culture) == 2) ? name->culture : (LPWSTR) neutral;
 289         size += lstrlenW(separator) + lstrlenW(culture) + lstrlenW(equals) + lstrlenW(cultureval);
 290     }
 291
 292     if ((dwDisplayFlags & ASM_DISPLAYF_PUBLIC_KEY_TOKEN) && (name->haspubkey))
 293         size += lstrlenW(separator) + lstrlenW(pubkey) + lstrlenW(equals) + CHARS_PER_PUBKEY;
 294
 295     if ((dwDisplayFlags & ASM_DISPLAYF_PROCESSORARCHITECTURE) && (name->procarch))
 296         size += lstrlenW(separator) + lstrlenW(procarch) + lstrlenW(equals) + lstrlenW(name->procarch);
 297
 298     if (size > *pccDisplayName)
 299         return S_FALSE;
 300
 301     /* Construct the string */
 302     lstrcpyW(szDisplayName, name->name);
 303
 304     if ((dwDisplayFlags & ASM_DISPLAYF_VERSION) && (name->versize > 0))
 305     {
 306         lstrcatW(szDisplayName, separator);
 307
 308         lstrcatW(szDisplayName, version);
 309         lstrcatW(szDisplayName, equals);
 310         lstrcatW(szDisplayName, verstr);
 311     }
 312
 313     if ((dwDisplayFlags & ASM_DISPLAYF_CULTURE) && (name->culture))
 314     {
 315         lstrcatW(szDisplayName, separator);
 316
 317         lstrcatW(szDisplayName, culture);
 318         lstrcatW(szDisplayName, equals);
 319         lstrcatW(szDisplayName, cultureval);
 320     }
 321
 322     if ((dwDisplayFlags & ASM_DISPLAYF_PUBLIC_KEY_TOKEN) && (name->haspubkey))
 323     {
 324         WCHAR pkt[CHARS_PER_PUBKEY + 1];
 325         static const WCHAR spec[] = {'%','0','x','%','0','x','%','0','x',
 326             '%','0','x','%','0','x','%','0','x','%','0','x','%','0','x',0};
 327
 328         lstrcatW(szDisplayName, separator);
 329
 330         lstrcatW(szDisplayName, pubkey);
 331         lstrcatW(szDisplayName, equals);
 332
 333         wsprintfW(pkt, spec, name->pubkey[0], name->pubkey[1], name->pubkey[2],
 334             name->pubkey[3], name->pubkey[4], name->pubkey[5], name->pubkey[6],
 335             name->pubkey[7]);
 336
 337         lstrcatW(szDisplayName, pkt);
 338     }
 339
 340     if ((dwDisplayFlags & ASM_DISPLAYF_PROCESSORARCHITECTURE) && (name->procarch))
 341     {
 342         lstrcatW(szDisplayName, separator);
 343
 344         lstrcatW(szDisplayName, procarch);
 345         lstrcatW(szDisplayName, equals);
 346         lstrcatW(szDisplayName, name->procarch);
 347     }
 348
 349     *pccDisplayName = size;
 350     return S_OK;
 351 }
 352
 353 static HRESULT WINAPI IAssemblyNameImpl_Reserved(IAssemblyName *iface,
 354                                                  REFIID refIID,
 355                                                  IUnknown *pUnkReserved1,
 356                                                  IUnknown *pUnkReserved2,
 357                                                  LPCOLESTR szReserved,
 358                                                  LONGLONG llReserved,
 359                                                  LPVOID pvReserved,
 360                                                  DWORD cbReserved,
 361                                                  LPVOID *ppReserved)
 362 {
 363     TRACE("(%p, %s, %p, %p, %s, %x%08x, %p, %d, %p)\n", iface,
 364           debugstr_guid(refIID), pUnkReserved1, pUnkReserved2,
 365           debugstr_w(szReserved), (DWORD)(llReserved >> 32), (DWORD)llReserved,
 366           pvReserved, cbReserved, ppReserved);
 367
 368     return E_NOTIMPL;
 369 }
 370
 371 static HRESULT WINAPI IAssemblyNameImpl_GetName(IAssemblyName *iface,
 372                                                 LPDWORD lpcwBuffer,
 373                                                 WCHAR *pwzName)
 374 {
 375     IAssemblyNameImpl *name = impl_from_IAssemblyName(iface);
 376     DWORD len;
 377
 378     TRACE("(%p, %p, %p)\n", iface, lpcwBuffer, pwzName);
 379
 380     if (name->name)
 381         len = strlenW(name->name) + 1;
 382     else
 383         len = 0;
 384
 385     if (*lpcwBuffer < len)
 386     {
 387         *lpcwBuffer = len;
 388         return E_NOT_SUFFICIENT_BUFFER;
 389     }
 390     if (!name->name) lpcwBuffer[0] = 0;
 391     else strcpyW(pwzName, name->name);
 392
 393     *lpcwBuffer = len;
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI IAssemblyNameImpl_GetVersion(IAssemblyName *iface,
 398                                                    LPDWORD pdwVersionHi,
 399                                                    LPDWORD pdwVersionLow)
 400 {
 401     IAssemblyNameImpl *name = impl_from_IAssemblyName(iface);
 402
 403     TRACE("(%p, %p, %p)\n", iface, pdwVersionHi, pdwVersionLow);
 404
 405     *pdwVersionHi = 0;
 406     *pdwVersionLow = 0;
 407
 408     if (name->versize != 4)
 409         return FUSION_E_INVALID_NAME;
 410
 411     *pdwVersionHi = (name->version[0] << 16) + name->version[1];
 412     *pdwVersionLow = (name->version[2] << 16) + name->version[3];
 413
 414     return S_OK;
 415 }
 416
 417 static HRESULT WINAPI IAssemblyNameImpl_IsEqual(IAssemblyName *iface,
 418                                                 IAssemblyName *pName,
 419                                                 DWORD flags)
 420 {
 421     IAssemblyNameImpl *name1 = impl_from_IAssemblyName(iface);
 422     IAssemblyNameImpl *name2 = impl_from_IAssemblyName(pName);
 423
 424     TRACE("(%p, %p, 0x%08x)\n", iface, pName, flags);
 425
 426     if (!pName) return S_FALSE;
 427     if (flags & ~ASM_CMPF_IL_ALL) FIXME("unsupported flags\n");
 428
 429     if ((flags & ASM_CMPF_NAME) && strcmpW(name1->name, name2->name)) return S_FALSE;
 430     if (name1->versize && name2->versize)
 431     {
 432         if ((flags & ASM_CMPF_MAJOR_VERSION) &&
 433             name1->version[0] != name2->version[0]) return S_FALSE;
 434         if ((flags & ASM_CMPF_MINOR_VERSION) &&
 435             name1->version[1] != name2->version[1]) return S_FALSE;
 436         if ((flags & ASM_CMPF_BUILD_NUMBER) &&
 437             name1->version[2] != name2->version[2]) return S_FALSE;
 438         if ((flags & ASM_CMPF_REVISION_NUMBER) &&
 439             name1->version[3] != name2->version[3]) return S_FALSE;
 440     }
 441     if ((flags & ASM_CMPF_PUBLIC_KEY_TOKEN) &&
 442         name1->haspubkey && name2->haspubkey &&
 443         memcmp(name1->pubkey, name2->pubkey, sizeof(name1->pubkey))) return S_FALSE;
 444
 445     if ((flags & ASM_CMPF_CULTURE) &&
 446         name1->culture && name2->culture &&
 447         strcmpW(name1->culture, name2->culture)) return S_FALSE;
 448
 449     return S_OK;
 450 }
 451
 452 static HRESULT WINAPI IAssemblyNameImpl_Clone(IAssemblyName *iface,
 453                                               IAssemblyName **pName)
 454 {
 455     FIXME("(%p, %p) stub!\n", iface, pName);
 456     return E_NOTIMPL;
 457 }
 458
 459 static const IAssemblyNameVtbl AssemblyNameVtbl = {
 460     IAssemblyNameImpl_QueryInterface,
 461     IAssemblyNameImpl_AddRef,
 462     IAssemblyNameImpl_Release,
 463     IAssemblyNameImpl_SetProperty,
 464     IAssemblyNameImpl_GetProperty,
 465     IAssemblyNameImpl_Finalize,
 466     IAssemblyNameImpl_GetDisplayName,
 467     IAssemblyNameImpl_Reserved,
 468     IAssemblyNameImpl_GetName,
 469     IAssemblyNameImpl_GetVersion,
 470     IAssemblyNameImpl_IsEqual,
 471     IAssemblyNameImpl_Clone
 472 };
 473
 474 /* Internal methods */
 475 static inline IAssemblyNameImpl *unsafe_impl_from_IAssemblyName(IAssemblyName *iface)
 476 {
 477     assert(iface->lpVtbl == &AssemblyNameVtbl);
 478
 479     return impl_from_IAssemblyName(iface);
 480 }
 481
 482 HRESULT IAssemblyName_SetPath(IAssemblyName *iface, LPCWSTR path)
 483 {
 484     IAssemblyNameImpl *name = unsafe_impl_from_IAssemblyName(iface);
 485
 486     name->path = strdupW(path);
 487     if (!name->path)
 488         return E_OUTOFMEMORY;
 489
 490     return S_OK;
 491 }
 492
 493 HRESULT IAssemblyName_GetPath(IAssemblyName *iface, LPWSTR buf, ULONG *len)
 494 {
 495     ULONG buffer_size = *len;
 496     IAssemblyNameImpl *name = unsafe_impl_from_IAssemblyName(iface);
 497
 498     if (!name->path)
 499         return S_OK;
 500
 501     if (!buf)
 502         buffer_size = 0;
 503
 504     *len = lstrlenW(name->path) + 1;
 505
 506     if (*len <= buffer_size)
 507         lstrcpyW(buf, name->path);
 508     else
 509         return E_NOT_SUFFICIENT_BUFFER;
 510
 511     return S_OK;
 512 }
 513
 514 static HRESULT parse_version(IAssemblyNameImpl *name, LPWSTR version)
 515 {
 516     LPWSTR beg, end;
 517     int i;
 518
 519     for (i = 0, beg = version; i < 4; i++)
 520     {
 521         if (!*beg)
 522             return S_OK;
 523
 524         end = strchrW(beg, '.');
 525
 526         if (end) *end = '\0';
 527         name->version[i] = atolW(beg);
 528         name->versize++;
 529
 530         if (!end && i < 3)
 531             return S_OK;
 532
 533         beg = end + 1;
 534     }
 535
 536     return S_OK;
 537 }
 538
 539 static HRESULT parse_culture(IAssemblyNameImpl *name, LPCWSTR culture)
 540 {
 541     static const WCHAR empty[] = {0};
 542
 543     if (lstrlenW(culture) == 2)
 544         name->culture = strdupW(culture);
 545     else
 546         name->culture = strdupW(empty);
 547
 548     return S_OK;
 549 }
 550
 551 static BOOL is_hex(WCHAR c)
 552 {
 553     return ((c >= 'a' && c <= 'f') ||
 554             (c >= 'A' && c <= 'F') ||
 555             (c >= '0' && c <= '9'));
 556 }
 557
 558 static BYTE hextobyte(WCHAR c)
 559 {
 560     if(c >= '0' && c <= '9')
 561         return c - '0';
 562     if(c >= 'A' && c <= 'F')
 563         return c - 'A' + 10;
 564     if(c >= 'a' && c <= 'f')
 565         return c - 'a' + 10;
 566     return 0;
 567 }
 568
 569 static HRESULT parse_pubkey(IAssemblyNameImpl *name, LPCWSTR pubkey)
 570 {
 571     int i;
 572     BYTE val;
 573     static const WCHAR nullstr[] = {'n','u','l','l',0};
 574
 575     if(lstrcmpiW(pubkey, nullstr) == 0)
 576         return FUSION_E_PRIVATE_ASM_DISALLOWED;
 577
 578     if (lstrlenW(pubkey) < CHARS_PER_PUBKEY)
 579         return FUSION_E_INVALID_NAME;
 580
 581     for (i = 0; i < CHARS_PER_PUBKEY; i++)
 582         if (!is_hex(pubkey[i]))
 583             return FUSION_E_INVALID_NAME;
 584
 585     name->haspubkey = TRUE;
 586
 587     for (i = 0; i < CHARS_PER_PUBKEY; i += 2)
 588     {
 589         val = (hextobyte(pubkey[i]) << 4) + hextobyte(pubkey[i + 1]);
 590         name->pubkey[i / 2] = val;
 591     }
 592
 593     return S_OK;
 594 }
 595
 596 static WCHAR *parse_value( const WCHAR *str, unsigned int len )
 597 {
 598     WCHAR *ret;
 599     const WCHAR *p = str;
 600     BOOL quoted = FALSE;
 601     unsigned int i = 0;
 602
 603     if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) ))) return NULL;
 604     if (*p == '\"')
 605     {
 606         quoted = TRUE;
 607         p++;
 608     }
 609     while (*p && *p != '\"') ret[i++] = *p++;
 610     if ((quoted && *p != '\"') || (!quoted && *p == '\"'))
 611     {
 612         HeapFree( GetProcessHeap(), 0, ret );
 613         return NULL;
 614     }
 615     ret[i] = 0;
 616     return ret;
 617 }
 618
 619 static HRESULT parse_display_name(IAssemblyNameImpl *name, LPCWSTR szAssemblyName)
 620 {
 621     LPWSTR str, save, ptr, ptr2, value;
 622     HRESULT hr = S_OK;
 623     BOOL done = FALSE;
 624
 625     if (!szAssemblyName)
 626         return S_OK;
 627
 628     name->displayname = strdupW(szAssemblyName);
 629     if (!name->displayname)
 630         return E_OUTOFMEMORY;
 631
 632     str = strdupW(szAssemblyName);
 633     save = str;
 634     if (!str)
 635     {
 636         hr = E_OUTOFMEMORY;
 637         goto done;
 638     }
 639
 640     ptr = strchrW(str, ',');
 641     if (ptr) *ptr = '\0';
 642
 643     /* no ',' but ' ' only */
 644     if( !ptr && strchrW(str, ' ') )
 645     {
 646         hr = FUSION_E_INVALID_NAME;
 647         goto done;
 648     }
 649
 650     name->name = strdupW(str);
 651     if (!name->name)
 652     {
 653         hr = E_OUTOFMEMORY;
 654         goto done;
 655     }
 656
 657     if (!ptr)
 658         goto done;
 659
 660     str = ptr + 1;
 661     while (!done)
 662     {
 663         ptr = strchrW(str, '=');
 664         if (!ptr)
 665         {
 666             hr = FUSION_E_INVALID_NAME;
 667             goto done;
 668         }
 669
 670         *(ptr++) = '\0';
 671         if (!*ptr)
 672         {
 673             hr = FUSION_E_INVALID_NAME;
 674             goto done;
 675         }
 676
 677         if (!(ptr2 = strchrW(ptr, ',')))
 678         {
 679             if (!(ptr2 = strchrW(ptr, '\0')))
 680             {
 681                 hr = FUSION_E_INVALID_NAME;
 682                 goto done;
 683             }
 684
 685             done = TRUE;
 686         }
 687
 688         *ptr2 = '\0';
 689         if (!(value = parse_value( ptr, ptr2 - ptr )))
 690         {
 691             hr = FUSION_E_INVALID_NAME;
 692             goto done;
 693         }
 694         while (*str == ' ') str++;
 695
 696         if (!lstrcmpiW(str, version))
 697             hr = parse_version( name, value );
 698         else if (!lstrcmpiW(str, culture))
 699             hr = parse_culture( name, value );
 700         else if (!lstrcmpiW(str, pubkey))
 701             hr = parse_pubkey( name, value );
 702         else if (!lstrcmpiW(str, procarch))
 703         {
 704             name->procarch = value;
 705             value = NULL;
 706         }
 707         HeapFree( GetProcessHeap(), 0, value );
 708
 709         if (FAILED(hr))
 710             goto done;
 711
 712         str = ptr2 + 1;
 713     }
 714
 715 done:
 716     HeapFree(GetProcessHeap(), 0, save);
 717     if (FAILED(hr))
 718     {
 719         HeapFree(GetProcessHeap(), 0, name->displayname);
 720         HeapFree(GetProcessHeap(), 0, name->name);
 721         HeapFree(GetProcessHeap(), 0, name->culture);
 722         HeapFree(GetProcessHeap(), 0, name->procarch);
 723     }
 724     return hr;
 725 }
 726
 727 /******************************************************************
 728  *  CreateAssemblyNameObject   (FUSION.@)
 729  */
 730 HRESULT WINAPI CreateAssemblyNameObject(IAssemblyName **ppAssemblyNameObj,
 731                                         LPCWSTR szAssemblyName, DWORD dwFlags,
 732                                         LPVOID pvReserved)
 733 {
 734     IAssemblyNameImpl *name;
 735     HRESULT hr;
 736
 737     TRACE("(%p, %s, %08x, %p)\n", ppAssemblyNameObj,
 738           debugstr_w(szAssemblyName), dwFlags, pvReserved);
 739
 740     if (!ppAssemblyNameObj)
 741         return E_INVALIDARG;
 742
 743     if ((dwFlags & CANOF_PARSE_DISPLAY_NAME) &&
 744         (!szAssemblyName || !*szAssemblyName))
 745         return E_INVALIDARG;
 746
 747     name = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAssemblyNameImpl));
 748     if (!name)
 749         return E_OUTOFMEMORY;
 750
 751     name->IAssemblyName_iface.lpVtbl = &AssemblyNameVtbl;
 752     name->ref = 1;
 753
 754     hr = parse_display_name(name, szAssemblyName);
 755     if (FAILED(hr))
 756     {
 757         HeapFree(GetProcessHeap(), 0, name);
 758         return hr;
 759     }
 760
 761     *ppAssemblyNameObj = &name->IAssemblyName_iface;
 762
 763     return S_OK;
 764 }