1 /* 2 * propsys main 3 * 4 * Copyright 1997, 2002 Alexandre Julliard 5 * Copyright 2008 James Hawkins 6 * 7 * This library is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this library; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 20 */ 21 22 #define COBJMACROS 23 24 #include <stdarg.h> 25 26 #include "windef.h" 27 #include "winbase.h" 28 #include "objbase.h" 29 #include "rpcproxy.h" 30 #include "propsys.h" 31 #include "wine/debug.h" 32 33 #include "propsys_private.h" 34 35 WINE_DEFAULT_DEBUG_CHANNEL(propsys); 36 37 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv) 38 { 39 *ppv = NULL; 40 41 if(IsEqualGUID(&IID_IUnknown, riid)) { 42 TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv); 43 *ppv = iface; 44 }else if(IsEqualGUID(&IID_IClassFactory, riid)) { 45 TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv); 46 *ppv = iface; 47 } 48 49 if(*ppv) { 50 IUnknown_AddRef((IUnknown*)*ppv); 51 return S_OK; 52 } 53 54 FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv); 55 return E_NOINTERFACE; 56 } 57 58 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface) 59 { 60 TRACE("(%p)\n", iface); 61 return 2; 62 } 63 64 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface) 65 { 66 TRACE("(%p)\n", iface); 67 return 1; 68 } 69 70 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock) 71 { 72 TRACE("(%p)->(%x)\n", iface, fLock); 73 74 return S_OK; 75 } 76 77 static HRESULT WINAPI InMemoryPropertyStoreFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, 78 REFIID riid, void **ppv) 79 { 80 TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv); 81 82 return PropertyStore_CreateInstance(outer, riid, ppv); 83 } 84 85 static const IClassFactoryVtbl InMemoryPropertyStoreFactoryVtbl = { 86 ClassFactory_QueryInterface, 87 ClassFactory_AddRef, 88 ClassFactory_Release, 89 InMemoryPropertyStoreFactory_CreateInstance, 90 ClassFactory_LockServer 91 }; 92 93 static IClassFactory InMemoryPropertyStoreFactory = { &InMemoryPropertyStoreFactoryVtbl }; 94 95 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) 96 { 97 if(IsEqualGUID(&CLSID_InMemoryPropertyStore, rclsid)) { 98 TRACE("(CLSID_InMemoryPropertyStore %s %p)\n", debugstr_guid(riid), ppv); 99 return IClassFactory_QueryInterface(&InMemoryPropertyStoreFactory, riid, ppv); 100 } 101 102 FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); 103 return CLASS_E_CLASSNOTAVAILABLE; 104 } 105 106 static HRESULT WINAPI propsys_QueryInterface(IPropertySystem *iface, REFIID riid, void **obj) 107 { 108 *obj = NULL; 109 110 if (IsEqualIID(riid, &IID_IPropertySystem) || IsEqualIID(riid, &IID_IUnknown)) { 111 *obj = iface; 112 IPropertySystem_AddRef(iface); 113 return S_OK; 114 } 115 116 FIXME("%s\n", debugstr_guid(riid)); 117 return E_NOINTERFACE; 118 } 119 120 static ULONG WINAPI propsys_AddRef(IPropertySystem *iface) 121 { 122 return 2; 123 } 124 125 static ULONG WINAPI propsys_Release(IPropertySystem *iface) 126 { 127 return 1; 128 } 129 130 static HRESULT WINAPI propsys_GetPropertyDescription(IPropertySystem *iface, 131 REFPROPERTYKEY propkey, REFIID riid, void **ppv) 132 { 133 return PSGetPropertyDescription(propkey, riid, ppv); 134 } 135 136 static HRESULT WINAPI propsys_GetPropertyDescriptionByName(IPropertySystem *iface, 137 LPCWSTR canonical_name, REFIID riid, void **ppv) 138 { 139 FIXME("%s %s %p: stub\n", debugstr_w(canonical_name), debugstr_guid(riid), ppv); 140 return E_NOTIMPL; 141 } 142 143 static HRESULT WINAPI propsys_GetPropertyDescriptionListFromString(IPropertySystem *iface, 144 LPCWSTR proplist, REFIID riid, void **ppv) 145 { 146 return PSGetPropertyDescriptionListFromString(proplist, riid, ppv); 147 } 148 149 static HRESULT WINAPI propsys_EnumeratePropertyDescriptions(IPropertySystem *iface, 150 PROPDESC_ENUMFILTER filter, REFIID riid, void **ppv) 151 { 152 FIXME("%d %s %p: stub\n", filter, debugstr_guid(riid), ppv); 153 return E_NOTIMPL; 154 } 155 156 static HRESULT WINAPI propsys_FormatForDisplay(IPropertySystem *iface, 157 REFPROPERTYKEY key, REFPROPVARIANT propvar, PROPDESC_FORMAT_FLAGS flags, 158 LPWSTR dest, DWORD destlen) 159 { 160 FIXME("%p %p %x %p %ld: stub\n", key, propvar, flags, dest, destlen); 161 return E_NOTIMPL; 162 } 163 164 static HRESULT WINAPI propsys_FormatForDisplayAlloc(IPropertySystem *iface, 165 REFPROPERTYKEY key, REFPROPVARIANT propvar, PROPDESC_FORMAT_FLAGS flags, 166 LPWSTR *text) 167 { 168 FIXME("%p %p %x %p: stub\n", key, propvar, flags, text); 169 return E_NOTIMPL; 170 } 171 172 static HRESULT WINAPI propsys_RegisterPropertySchema(IPropertySystem *iface, LPCWSTR path) 173 { 174 return PSRegisterPropertySchema(path); 175 } 176 177 static HRESULT WINAPI propsys_UnregisterPropertySchema(IPropertySystem *iface, LPCWSTR path) 178 { 179 return PSUnregisterPropertySchema(path); 180 } 181 182 static HRESULT WINAPI propsys_RefreshPropertySchema(IPropertySystem *iface) 183 { 184 return PSRefreshPropertySchema(); 185 } 186 187 static const IPropertySystemVtbl propsysvtbl = { 188 propsys_QueryInterface, 189 propsys_AddRef, 190 propsys_Release, 191 propsys_GetPropertyDescription, 192 propsys_GetPropertyDescriptionByName, 193 propsys_GetPropertyDescriptionListFromString, 194 propsys_EnumeratePropertyDescriptions, 195 propsys_FormatForDisplay, 196 propsys_FormatForDisplayAlloc, 197 propsys_RegisterPropertySchema, 198 propsys_UnregisterPropertySchema, 199 propsys_RefreshPropertySchema 200 }; 201 202 static IPropertySystem propsys = { &propsysvtbl }; 203 204 HRESULT WINAPI PSGetPropertySystem(REFIID riid, void **obj) 205 { 206 return IPropertySystem_QueryInterface(&propsys, riid, obj); 207 } 208 209 HRESULT WINAPI PSRegisterPropertySchema(PCWSTR path) 210 { 211 FIXME("%s stub\n", debugstr_w(path)); 212 213 return S_OK; 214 } 215 216 HRESULT WINAPI PSUnregisterPropertySchema(PCWSTR path) 217 { 218 FIXME("%s stub\n", debugstr_w(path)); 219 220 return E_NOTIMPL; 221 } 222 223 HRESULT WINAPI PSGetPropertyDescription(REFPROPERTYKEY propkey, REFIID riid, void **ppv) 224 { 225 FIXME("%p, %p, %p\n", propkey, riid, ppv); 226 return E_NOTIMPL; 227 } 228 229 HRESULT WINAPI PSGetPropertyDescriptionListFromString(LPCWSTR proplist, REFIID riid, void **ppv) 230 { 231 FIXME("%s, %p, %p\n", debugstr_w(proplist), riid, ppv); 232 return E_NOTIMPL; 233 } 234 235 HRESULT WINAPI PSGetPropertyKeyFromName(PCWSTR name, PROPERTYKEY *key) 236 { 237 FIXME("%s, %p\n", debugstr_w(name), key); 238 return E_NOTIMPL; 239 } 240 241 HRESULT WINAPI PSRefreshPropertySchema(void) 242 { 243 FIXME("\n"); 244 return S_OK; 245 } 246 247 HRESULT WINAPI PSStringFromPropertyKey(REFPROPERTYKEY pkey, LPWSTR psz, UINT cch) 248 { 249 WCHAR pidW[PKEY_PIDSTR_MAX + 1]; 250 LPWSTR p = psz; 251 int len; 252 253 TRACE("(%p, %p, %u)\n", pkey, psz, cch); 254 255 if (!psz) 256 return E_POINTER; 257 258 /* GUIDSTRING_MAX accounts for null terminator, +1 for space character. */ 259 if (cch <= GUIDSTRING_MAX + 1) 260 return E_NOT_SUFFICIENT_BUFFER; 261 262 if (!pkey) 263 { 264 psz[0] = '\0'; 265 return E_NOT_SUFFICIENT_BUFFER; 266 } 267 268 swprintf(psz, cch, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", pkey->fmtid.Data1, 269 pkey->fmtid.Data2, pkey->fmtid.Data3, pkey->fmtid.Data4[0], pkey->fmtid.Data4[1], 270 pkey->fmtid.Data4[2], pkey->fmtid.Data4[3], pkey->fmtid.Data4[4], 271 pkey->fmtid.Data4[5], pkey->fmtid.Data4[6], pkey->fmtid.Data4[7]); 272 273 /* Overwrite the null terminator with the space character. */ 274 p += GUIDSTRING_MAX - 1; 275 *p++ = ' '; 276 cch -= GUIDSTRING_MAX - 1 + 1; 277 278 len = swprintf(pidW, ARRAY_SIZE(pidW), L"%u", pkey->pid); 279 280 if (cch >= len + 1) 281 { 282 lstrcpyW(p, pidW); 283 return S_OK; 284 } 285 else 286 { 287 WCHAR *ptr = pidW + len - 1; 288 289 psz[0] = '\0'; 290 *p++ = '\0'; 291 cch--; 292 293 /* Replicate a quirk of the native implementation where the contents 294 * of the property ID string are written backwards to the output 295 * buffer, skipping the rightmost digit. */ 296 if (cch) 297 { 298 ptr--; 299 while (cch--) 300 *p++ = *ptr--; 301 } 302 303 return E_NOT_SUFFICIENT_BUFFER; 304 } 305 } 306 307 static const BYTE hex2bin[] = 308 { 309 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */ 310 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */ 311 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */ 312 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */ 313 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */ 314 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */ 315 0,10,11,12,13,14,15 /* 0x60 */ 316 }; 317 318 static BOOL validate_indices(LPCWSTR s, int min, int max) 319 { 320 int i; 321 322 for (i = min; i <= max; i++) 323 { 324 if (!s[i]) 325 return FALSE; 326 327 if (i == 0) 328 { 329 if (s[i] != '{') 330 return FALSE; 331 } 332 else if (i == 9 || i == 14 || i == 19 || i == 24) 333 { 334 if (s[i] != '-') 335 return FALSE; 336 } 337 else if (i == 37) 338 { 339 if (s[i] != '}') 340 return FALSE; 341 } 342 else 343 { 344 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) 345 return FALSE; 346 } 347 } 348 349 return TRUE; 350 } 351 352 /* Adapted from CLSIDFromString helper in dlls/ole32/compobj.c and 353 * UuidFromString in dlls/rpcrt4/rpcrt4_main.c. */ 354 static BOOL string_to_guid(LPCWSTR s, LPGUID id) 355 { 356 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */ 357 358 if (!validate_indices(s, 0, 8)) return FALSE; 359 id->Data1 = (hex2bin[s[1]] << 28 | hex2bin[s[2]] << 24 | hex2bin[s[3]] << 20 | hex2bin[s[4]] << 16 | 360 hex2bin[s[5]] << 12 | hex2bin[s[6]] << 8 | hex2bin[s[7]] << 4 | hex2bin[s[8]]); 361 if (!validate_indices(s, 9, 14)) return FALSE; 362 id->Data2 = hex2bin[s[10]] << 12 | hex2bin[s[11]] << 8 | hex2bin[s[12]] << 4 | hex2bin[s[13]]; 363 if (!validate_indices(s, 15, 19)) return FALSE; 364 id->Data3 = hex2bin[s[15]] << 12 | hex2bin[s[16]] << 8 | hex2bin[s[17]] << 4 | hex2bin[s[18]]; 365 366 /* these are just sequential bytes */ 367 368 if (!validate_indices(s, 20, 21)) return FALSE; 369 id->Data4[0] = hex2bin[s[20]] << 4 | hex2bin[s[21]]; 370 if (!validate_indices(s, 22, 24)) return FALSE; 371 id->Data4[1] = hex2bin[s[22]] << 4 | hex2bin[s[23]]; 372 373 if (!validate_indices(s, 25, 26)) return FALSE; 374 id->Data4[2] = hex2bin[s[25]] << 4 | hex2bin[s[26]]; 375 if (!validate_indices(s, 27, 28)) return FALSE; 376 id->Data4[3] = hex2bin[s[27]] << 4 | hex2bin[s[28]]; 377 if (!validate_indices(s, 29, 30)) return FALSE; 378 id->Data4[4] = hex2bin[s[29]] << 4 | hex2bin[s[30]]; 379 if (!validate_indices(s, 31, 32)) return FALSE; 380 id->Data4[5] = hex2bin[s[31]] << 4 | hex2bin[s[32]]; 381 if (!validate_indices(s, 33, 34)) return FALSE; 382 id->Data4[6] = hex2bin[s[33]] << 4 | hex2bin[s[34]]; 383 if (!validate_indices(s, 35, 37)) return FALSE; 384 id->Data4[7] = hex2bin[s[35]] << 4 | hex2bin[s[36]]; 385 386 return TRUE; 387 } 388 389 HRESULT WINAPI PSPropertyKeyFromString(LPCWSTR pszString, PROPERTYKEY *pkey) 390 { 391 BOOL has_minus = FALSE, has_comma = FALSE; 392 393 TRACE("(%s, %p)\n", debugstr_w(pszString), pkey); 394 395 if (!pszString || !pkey) 396 return E_POINTER; 397 398 memset(pkey, 0, sizeof(PROPERTYKEY)); 399 400 if (!string_to_guid(pszString, &pkey->fmtid)) 401 return E_INVALIDARG; 402 403 pszString += GUIDSTRING_MAX - 1; 404 405 if (!*pszString) 406 return E_INVALIDARG; 407 408 /* Only the space seems to be recognized as whitespace. The comma is only 409 * recognized once and processing terminates if another comma is found. */ 410 while (*pszString == ' ' || *pszString == ',') 411 { 412 if (*pszString == ',') 413 { 414 if (has_comma) 415 return S_OK; 416 else 417 has_comma = TRUE; 418 } 419 pszString++; 420 } 421 422 if (!*pszString) 423 return E_INVALIDARG; 424 425 /* Only two minus signs are recognized if no comma is detected. The first 426 * sign is ignored, and the second is interpreted. If a comma is detected 427 * before the minus sign, then only one minus sign counts, and property ID 428 * interpretation begins with the next character. */ 429 if (has_comma) 430 { 431 if (*pszString == '-') 432 { 433 has_minus = TRUE; 434 pszString++; 435 } 436 } 437 else 438 { 439 if (*pszString == '-') 440 pszString++; 441 442 /* Skip any intermediate spaces after the first minus sign. */ 443 while (*pszString == ' ') 444 pszString++; 445 446 if (*pszString == '-') 447 { 448 has_minus = TRUE; 449 pszString++; 450 } 451 452 /* Skip any remaining spaces after minus sign. */ 453 while (*pszString == ' ') 454 pszString++; 455 } 456 457 /* Overflow is not checked. */ 458 while ('0' <= *pszString && *pszString <= '9') 459 { 460 pkey->pid *= 10; 461 pkey->pid += (*pszString - '0'); 462 pszString++; 463 } 464 465 if (has_minus) 466 pkey->pid = ~pkey->pid + 1; 467 468 return S_OK; 469 } 470 471 HRESULT WINAPI PSCreateMemoryPropertyStore(REFIID riid, void **ppv) 472 { 473 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv); 474 475 return PropertyStore_CreateInstance(NULL, riid, ppv); 476 } 477 478 #ifdef __REACTOS__ 479 HRESULT WINAPI DllCanUnloadNow(void) 480 { 481 return S_FALSE; 482 } 483 #endif 484