dlls/sxs/name.c

   1 /*
   2  * IAssemblyName implementation
   3  *
   4  * Copyright 2012 Hans Leidekker 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 #include <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "ole2.h"
  28 #include "winsxs.h"
  29
  30 #include "wine/debug.h"
  31 #include "sxs_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(sxs);
  34
  35 struct name
  36 {
  37     IAssemblyName IAssemblyName_iface;
  38     LONG   refs;
  39     WCHAR *name;
  40     WCHAR *arch;
  41     WCHAR *token;
  42     WCHAR *type;
  43     WCHAR *version;
  44 };
  45
  46 static inline struct name *impl_from_IAssemblyName( IAssemblyName *iface )
  47 {
  48     return CONTAINING_RECORD( iface, struct name, IAssemblyName_iface );
  49 }
  50
  51 static HRESULT WINAPI name_QueryInterface(
  52     IAssemblyName *iface,
  53     REFIID riid,
  54     void **ret_iface )
  55 {
  56     TRACE("%p, %s, %p\n", iface, debugstr_guid(riid), ret_iface);
  57
  58     *ret_iface = NULL;
  59
  60     if (IsEqualIID( riid, &IID_IUnknown ) ||
  61         IsEqualIID( riid, &IID_IAssemblyName ))
  62     {
  63         IAssemblyName_AddRef( iface );
  64         *ret_iface = iface;
  65         return S_OK;
  66     }
  67
  68     return E_NOINTERFACE;
  69 }
  70
  71 static ULONG WINAPI name_AddRef(
  72     IAssemblyName *iface )
  73 {
  74     struct name *name = impl_from_IAssemblyName( iface );
  75     return InterlockedIncrement( &name->refs );
  76 }
  77
  78 static ULONG WINAPI name_Release( IAssemblyName *iface )
  79 {
  80     struct name *name = impl_from_IAssemblyName( iface );
  81     ULONG refs = InterlockedDecrement( &name->refs );
  82
  83     if (!refs)
  84     {
  85         TRACE("destroying %p\n", name);
  86         free( name->name );
  87         free( name->arch );
  88         free( name->token );
  89         free( name->type );
  90         free( name->version );
  91         free( name );
  92     }
  93     return refs;
  94 }
  95
  96 static HRESULT WINAPI name_SetProperty(
  97     IAssemblyName *iface,
  98     DWORD id,
  99     LPVOID property,
 100     DWORD size )
 101 {
 102     FIXME("%p, %ld, %p, %ld\n", iface, id, property, size);
 103     return E_NOTIMPL;
 104 }
 105
 106 static HRESULT WINAPI name_GetProperty(
 107     IAssemblyName *iface,
 108     DWORD id,
 109     LPVOID buffer,
 110     LPDWORD buflen )
 111 {
 112     FIXME("%p, %ld, %p, %p\n", iface, id, buffer, buflen);
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI name_Finalize(
 117     IAssemblyName *iface )
 118 {
 119     FIXME("%p\n", iface);
 120     return E_NOTIMPL;
 121 }
 122
 123 static HRESULT WINAPI name_GetDisplayName(
 124     IAssemblyName *iface,
 125     LPOLESTR buffer,
 126     LPDWORD buflen,
 127     DWORD flags )
 128 {
 129     static const WCHAR fmtW[] = {',','%','s','=','\"','%','s','\"',0};
 130     struct name *name = impl_from_IAssemblyName( iface );
 131     unsigned int len;
 132
 133     TRACE("%p, %p, %p, 0x%08lx\n", iface, buffer, buflen, flags);
 134
 135     if (!buflen || flags) return E_INVALIDARG;
 136
 137     len = lstrlenW( name->name ) + 1;
 138     if (name->arch)    len += lstrlenW( L"processorArchitecture" ) + lstrlenW( name->arch ) + 4;
 139     if (name->token)   len += lstrlenW( L"publicKeyToken" ) + lstrlenW( name->token ) + 4;
 140     if (name->type)    len += lstrlenW( L"type" ) + lstrlenW( name->type ) + 4;
 141     if (name->version) len += lstrlenW( L"version" ) + lstrlenW( name->version ) + 4;
 142     if (len > *buflen)
 143     {
 144         *buflen = len;
 145         return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
 146     }
 147     lstrcpyW( buffer, name->name );
 148     len = lstrlenW( buffer );
 149     if (name->arch)    len += swprintf( buffer + len, *buflen - len, fmtW, L"processorArchitecture", name->arch );
 150     if (name->token)   len += swprintf( buffer + len, *buflen - len, fmtW, L"publicKeyToken", name->token );
 151     if (name->type)    len += swprintf( buffer + len, *buflen - len, fmtW, L"type", name->type );
 152     if (name->version) len += swprintf( buffer + len, *buflen - len, fmtW, L"version", name->version );
 153     return S_OK;
 154 }
 155
 156 static HRESULT WINAPI name_Reserved(
 157     IAssemblyName *iface,
 158     REFIID riid,
 159     IUnknown *pUnkReserved1,
 160     IUnknown *pUnkReserved2,
 161     LPCOLESTR szReserved,
 162     LONGLONG llReserved,
 163     LPVOID pvReserved,
 164     DWORD cbReserved,
 165     LPVOID *ppReserved )
 166 {
 167     FIXME("%p, %s, %p, %p, %s, %s, %p, %ld, %p\n", iface,
 168           debugstr_guid(riid), pUnkReserved1, pUnkReserved2,
 169           debugstr_w(szReserved), wine_dbgstr_longlong(llReserved),
 170           pvReserved, cbReserved, ppReserved);
 171     return E_NOTIMPL;
 172 }
 173
 174 const WCHAR *get_name_attribute( IAssemblyName *iface, enum name_attr_id id )
 175 {
 176     struct name *name = impl_from_IAssemblyName( iface );
 177
 178     switch (id)
 179     {
 180     case NAME_ATTR_ID_NAME:    return name->name;
 181     case NAME_ATTR_ID_ARCH:    return name->arch;
 182     case NAME_ATTR_ID_TOKEN:   return name->token;
 183     case NAME_ATTR_ID_TYPE:    return name->type;
 184     case NAME_ATTR_ID_VERSION: return name->version;
 185     default:
 186         ERR("unhandled name attribute %u\n", id);
 187         break;
 188     }
 189     return NULL;
 190 }
 191
 192 static HRESULT WINAPI name_GetName(
 193     IAssemblyName *iface,
 194     LPDWORD buflen,
 195     WCHAR *buffer )
 196 {
 197     const WCHAR *name;
 198     int len;
 199
 200     TRACE("%p, %p, %p\n", iface, buflen, buffer);
 201
 202     if (!buflen || !buffer) return E_INVALIDARG;
 203
 204     name = get_name_attribute( iface, NAME_ATTR_ID_NAME );
 205     len = lstrlenW( name ) + 1;
 206     if (len > *buflen)
 207     {
 208         *buflen = len;
 209         return HRESULT_FROM_WIN32( ERROR_INSUFFICIENT_BUFFER );
 210     }
 211     lstrcpyW( buffer, name );
 212     *buflen = len + 3;
 213     return S_OK;
 214 }
 215
 216 static HRESULT parse_version( WCHAR *version, DWORD *high, DWORD *low )
 217 {
 218     WORD ver[4];
 219     WCHAR *p, *q;
 220     unsigned int i;
 221
 222     memset( ver, 0, sizeof(ver) );
 223     for (i = 0, p = version; i < 4; i++)
 224     {
 225         if (!*p) break;
 226         q = wcschr( p, '.' );
 227         if (q) *q = 0;
 228         ver[i] = wcstol( p, NULL, 10 );
 229         if (!q && i < 3) break;
 230         p = q + 1;
 231     }
 232     *high = (ver[0] << 16) + ver[1];
 233     *low = (ver[2] << 16) + ver[3];
 234     return S_OK;
 235 }
 236
 237 static HRESULT WINAPI name_GetVersion(
 238     IAssemblyName *iface,
 239     LPDWORD high,
 240     LPDWORD low )
 241 {
 242     struct name *name = impl_from_IAssemblyName( iface );
 243     WCHAR *version;
 244     HRESULT hr;
 245
 246     TRACE("%p, %p, %p\n", iface, high, low);
 247
 248     if (!name->version) return HRESULT_FROM_WIN32( ERROR_NOT_FOUND );
 249     if (!(version = wcsdup( name->version ))) return E_OUTOFMEMORY;
 250     hr = parse_version( version, high, low );
 251     free( version );
 252     return hr;
 253 }
 254
 255 static HRESULT WINAPI name_IsEqual(
 256     IAssemblyName *name1,
 257     IAssemblyName *name2,
 258     DWORD flags )
 259 {
 260     FIXME("%p, %p, 0x%08lx\n", name1, name2, flags);
 261     return E_NOTIMPL;
 262 }
 263
 264 static HRESULT WINAPI name_Clone(
 265     IAssemblyName *iface,
 266     IAssemblyName **name )
 267 {
 268     FIXME("%p, %p\n", iface, name);
 269     return E_NOTIMPL;
 270 }
 271
 272 static const IAssemblyNameVtbl name_vtbl =
 273 {
 274     name_QueryInterface,
 275     name_AddRef,
 276     name_Release,
 277     name_SetProperty,
 278     name_GetProperty,
 279     name_Finalize,
 280     name_GetDisplayName,
 281     name_Reserved,
 282     name_GetName,
 283     name_GetVersion,
 284     name_IsEqual,
 285     name_Clone
 286 };
 287
 288 static WCHAR *parse_value( const WCHAR *str, unsigned int *len )
 289 {
 290     WCHAR *ret;
 291     const WCHAR *p = str;
 292
 293     if (*p++ != '\"') return NULL;
 294     while (*p && *p != '\"') p++;
 295     if (!*p) return NULL;
 296
 297     *len = p - str;
 298     if (!(ret = malloc( *len * sizeof(WCHAR) ))) return NULL;
 299     memcpy( ret, str + 1, (*len - 1) * sizeof(WCHAR) );
 300     ret[*len - 1] = 0;
 301     return ret;
 302 }
 303
 304 static HRESULT parse_displayname( struct name *name, const WCHAR *displayname )
 305 {
 306     const WCHAR *p, *q;
 307     unsigned int len;
 308
 309     p = q = displayname;
 310     while (*q && *q != ',') q++;
 311     len = q - p;
 312     if (!(name->name = malloc( (len + 1) * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
 313     memcpy( name->name, p, len * sizeof(WCHAR) );
 314     name->name[len] = 0;
 315     if (!*q) return S_OK;
 316
 317     for (;;)
 318     {
 319         p = ++q;
 320         while (*q && *q != '=') q++;
 321         if (!*q) return E_INVALIDARG;
 322         len = q - p;
 323         if (len == ARRAY_SIZE(L"processorArchitecture") - 1 && !memcmp( p, L"processorArchitecture", len * sizeof(WCHAR) ))
 324         {
 325             p = ++q;
 326             if (!(name->arch = parse_value( p, &len ))) return E_INVALIDARG;
 327             q += len;
 328         }
 329         else if (len == ARRAY_SIZE(L"publicKeyToken") - 1 && !memcmp( p, L"publicKeyToken", len * sizeof(WCHAR) ))
 330         {
 331             p = ++q;
 332             if (!(name->token = parse_value( p, &len ))) return E_INVALIDARG;
 333             q += len;
 334         }
 335         else if (len == ARRAY_SIZE(L"type") - 1 && !memcmp( p, L"type", len * sizeof(WCHAR) ))
 336         {
 337             p = ++q;
 338             if (!(name->type = parse_value( p, &len ))) return E_INVALIDARG;
 339             q += len;
 340         }
 341         else if (len == ARRAY_SIZE(L"version") - 1 && !memcmp( p, L"version", len * sizeof(WCHAR) ))
 342         {
 343             p = ++q;
 344             if (!(name->version = parse_value( p, &len ))) return E_INVALIDARG;
 345             q += len;
 346         }
 347         else return HRESULT_FROM_WIN32( ERROR_SXS_INVALID_ASSEMBLY_IDENTITY_ATTRIBUTE_NAME );
 348         while (*q && *q != ',') q++;
 349         if (!*q) break;
 350     }
 351     return S_OK;
 352 }
 353
 354 /******************************************************************
 355  *  CreateAssemblyNameObject   (SXS.@)
 356  */
 357 HRESULT WINAPI CreateAssemblyNameObject(
 358     LPASSEMBLYNAME *obj,
 359     LPCWSTR assembly,
 360     DWORD flags,
 361     LPVOID reserved )
 362 {
 363     struct name *name;
 364     HRESULT hr;
 365
 366     TRACE("%p, %s, 0x%08lx, %p\n", obj, debugstr_w(assembly), flags, reserved);
 367
 368     if (!obj) return E_INVALIDARG;
 369
 370     *obj = NULL;
 371     if (!assembly || !assembly[0] || flags != CANOF_PARSE_DISPLAY_NAME)
 372         return E_INVALIDARG;
 373
 374     if (!(name = calloc(1, sizeof(*name) )))
 375         return E_OUTOFMEMORY;
 376
 377     name->IAssemblyName_iface.lpVtbl = &name_vtbl;
 378     name->refs = 1;
 379
 380     hr = parse_displayname( name, assembly );
 381     if (hr != S_OK)
 382     {
 383         free( name->name );
 384         free( name->arch );
 385         free( name->token );
 386         free( name->type );
 387         free( name->version );
 388         free( name );
 389         return hr;
 390     }
 391     *obj = &name->IAssemblyName_iface;
 392     return S_OK;
 393 }