dlls/combase/errorinfo.c

   1 /*
   2  * ErrorInfo API
   3  *
   4  * Copyright 2000 Patrik Stridvall, Juergen Schmied
   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 #define COBJMACROS
  22
  23 #include "oleauto.h"
  24
  25 #include "combase_private.h"
  26
  27 #include "wine/debug.h"
  28 #include "wine/heap.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  31
  32 static WCHAR *heap_strdupW(const WCHAR *str)
  33 {
  34     WCHAR *ret = NULL;
  35
  36     if (str)
  37     {
  38         size_t size;
  39
  40         size = (lstrlenW(str)+1)*sizeof(WCHAR);
  41         ret = heap_alloc(size);
  42         if (ret)
  43             memcpy(ret, str, size);
  44     }
  45
  46     return ret;
  47 }
  48
  49 struct error_info
  50 {
  51     IErrorInfo IErrorInfo_iface;
  52     ICreateErrorInfo ICreateErrorInfo_iface;
  53     ISupportErrorInfo ISupportErrorInfo_iface;
  54     LONG refcount;
  55
  56     GUID guid;
  57     WCHAR *source;
  58     WCHAR *description;
  59     WCHAR *help_file;
  60     DWORD help_context;
  61 };
  62
  63 static struct error_info *impl_from_IErrorInfo(IErrorInfo *iface)
  64 {
  65     return CONTAINING_RECORD(iface, struct error_info, IErrorInfo_iface);
  66 }
  67
  68 static struct error_info *impl_from_ICreateErrorInfo(ICreateErrorInfo *iface)
  69 {
  70     return CONTAINING_RECORD(iface, struct error_info, ICreateErrorInfo_iface);
  71 }
  72
  73 static struct error_info *impl_from_ISupportErrorInfo(ISupportErrorInfo *iface)
  74 {
  75     return CONTAINING_RECORD(iface, struct error_info, ISupportErrorInfo_iface);
  76 }
  77
  78 static HRESULT WINAPI errorinfo_QueryInterface(IErrorInfo *iface, REFIID riid, void **obj)
  79 {
  80     struct error_info *error_info = impl_from_IErrorInfo(iface);
  81
  82     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
  83
  84     *obj = NULL;
  85
  86     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IErrorInfo))
  87     {
  88         *obj = &error_info->IErrorInfo_iface;
  89     }
  90     else if (IsEqualIID(riid, &IID_ICreateErrorInfo))
  91     {
  92         *obj = &error_info->ICreateErrorInfo_iface;
  93     }
  94     else if (IsEqualIID(riid, &IID_ISupportErrorInfo))
  95     {
  96         *obj = &error_info->ISupportErrorInfo_iface;
  97     }
  98
  99     if (*obj)
 100     {
 101         IUnknown_AddRef((IUnknown *)*obj);
 102         return S_OK;
 103     }
 104
 105     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 106     return E_NOINTERFACE;
 107 }
 108
 109 static ULONG WINAPI errorinfo_AddRef(IErrorInfo *iface)
 110 {
 111     struct error_info *error_info = impl_from_IErrorInfo(iface);
 112     ULONG refcount = InterlockedIncrement(&error_info->refcount);
 113
 114     TRACE("%p, refcount %u.\n", iface, refcount);
 115
 116     return refcount;
 117 }
 118
 119 static ULONG WINAPI errorinfo_Release(IErrorInfo *iface)
 120 {
 121     struct error_info *error_info = impl_from_IErrorInfo(iface);
 122     ULONG refcount = InterlockedDecrement(&error_info->refcount);
 123
 124     TRACE("%p, refcount %u.\n", iface, refcount);
 125
 126     if (!refcount)
 127     {
 128         heap_free(error_info->source);
 129         heap_free(error_info->description);
 130         heap_free(error_info->help_file);
 131         heap_free(error_info);
 132     }
 133
 134     return refcount;
 135 }
 136
 137 static HRESULT WINAPI errorinfo_GetGUID(IErrorInfo *iface, GUID *guid)
 138 {
 139     struct error_info *error_info = impl_from_IErrorInfo(iface);
 140
 141     TRACE("%p, %p.\n", iface, guid);
 142
 143     if (!guid) return E_INVALIDARG;
 144     *guid = error_info->guid;
 145     return S_OK;
 146 }
 147
 148 static HRESULT WINAPI errorinfo_GetSource(IErrorInfo* iface, BSTR *source)
 149 {
 150     struct error_info *error_info = impl_from_IErrorInfo(iface);
 151
 152     TRACE("%p, %p.\n", iface, source);
 153
 154     if (!source)
 155         return E_INVALIDARG;
 156     *source = SysAllocString(error_info->source);
 157     return S_OK;
 158 }
 159
 160 static HRESULT WINAPI errorinfo_GetDescription(IErrorInfo *iface, BSTR *description)
 161 {
 162     struct error_info *error_info = impl_from_IErrorInfo(iface);
 163
 164     TRACE("%p, %p.\n", iface, description);
 165
 166     if (!description)
 167         return E_INVALIDARG;
 168     *description = SysAllocString(error_info->description);
 169     return S_OK;
 170 }
 171
 172 static HRESULT WINAPI errorinfo_GetHelpFile(IErrorInfo *iface, BSTR *helpfile)
 173 {
 174     struct error_info *error_info = impl_from_IErrorInfo(iface);
 175
 176     TRACE("%p, %p.\n", iface, helpfile);
 177
 178     if (!helpfile)
 179         return E_INVALIDARG;
 180     *helpfile = SysAllocString(error_info->help_file);
 181     return S_OK;
 182 }
 183
 184 static HRESULT WINAPI errorinfo_GetHelpContext(IErrorInfo *iface, DWORD *help_context)
 185 {
 186     struct error_info *error_info = impl_from_IErrorInfo(iface);
 187
 188     TRACE("%p, %p.\n", iface, help_context);
 189
 190     if (!help_context)
 191         return E_INVALIDARG;
 192     *help_context = error_info->help_context;
 193
 194     return S_OK;
 195 }
 196
 197 static const IErrorInfoVtbl errorinfo_vtbl =
 198 {
 199     errorinfo_QueryInterface,
 200     errorinfo_AddRef,
 201     errorinfo_Release,
 202     errorinfo_GetGUID,
 203     errorinfo_GetSource,
 204     errorinfo_GetDescription,
 205     errorinfo_GetHelpFile,
 206     errorinfo_GetHelpContext
 207 };
 208
 209 static HRESULT WINAPI create_errorinfo_QueryInterface(ICreateErrorInfo *iface, REFIID riid, void **obj)
 210 {
 211     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 212     return IErrorInfo_QueryInterface(&error_info->IErrorInfo_iface, riid, obj);
 213 }
 214
 215 static ULONG WINAPI create_errorinfo_AddRef(ICreateErrorInfo *iface)
 216 {
 217     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 218     return IErrorInfo_AddRef(&error_info->IErrorInfo_iface);
 219 }
 220
 221 static ULONG WINAPI create_errorinfo_Release(ICreateErrorInfo *iface)
 222 {
 223     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 224     return IErrorInfo_Release(&error_info->IErrorInfo_iface);
 225 }
 226
 227 static HRESULT WINAPI create_errorinfo_SetGUID(ICreateErrorInfo *iface, REFGUID guid)
 228 {
 229     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 230
 231     TRACE("%p, %s.\n", iface, debugstr_guid(guid));
 232
 233     error_info->guid = *guid;
 234
 235     return S_OK;
 236 }
 237
 238 static HRESULT WINAPI create_errorinfo_SetSource(ICreateErrorInfo *iface, LPOLESTR source)
 239 {
 240     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 241
 242     TRACE("%p, %s.\n", iface, debugstr_w(source));
 243
 244     heap_free(error_info->source);
 245     error_info->source = heap_strdupW(source);
 246
 247     return S_OK;
 248 }
 249
 250 static HRESULT WINAPI create_errorinfo_SetDescription(ICreateErrorInfo *iface, LPOLESTR description)
 251 {
 252     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 253
 254     TRACE("%p, %s.\n", iface, debugstr_w(description));
 255
 256     heap_free(error_info->description);
 257     error_info->description = heap_strdupW(description);
 258
 259     return S_OK;
 260 }
 261
 262 static HRESULT WINAPI create_errorinfo_SetHelpFile(ICreateErrorInfo *iface, LPOLESTR helpfile)
 263 {
 264     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 265
 266     TRACE("%p, %s.\n", iface, debugstr_w(helpfile));
 267
 268     heap_free(error_info->help_file);
 269     error_info->help_file = heap_strdupW(helpfile);
 270
 271     return S_OK;
 272 }
 273
 274 static HRESULT WINAPI create_errorinfo_SetHelpContext(ICreateErrorInfo *iface, DWORD help_context)
 275 {
 276     struct error_info *error_info = impl_from_ICreateErrorInfo(iface);
 277
 278     TRACE("%p, %#x.\n", iface, help_context);
 279
 280     error_info->help_context = help_context;
 281
 282     return S_OK;
 283 }
 284
 285 static const ICreateErrorInfoVtbl create_errorinfo_vtbl =
 286 {
 287     create_errorinfo_QueryInterface,
 288     create_errorinfo_AddRef,
 289     create_errorinfo_Release,
 290     create_errorinfo_SetGUID,
 291     create_errorinfo_SetSource,
 292     create_errorinfo_SetDescription,
 293     create_errorinfo_SetHelpFile,
 294     create_errorinfo_SetHelpContext
 295 };
 296
 297 static HRESULT WINAPI support_errorinfo_QueryInterface(ISupportErrorInfo *iface, REFIID riid, void **obj)
 298 {
 299     struct error_info *error_info = impl_from_ISupportErrorInfo(iface);
 300     return IErrorInfo_QueryInterface(&error_info->IErrorInfo_iface, riid, obj);
 301 }
 302
 303 static ULONG WINAPI support_errorinfo_AddRef(ISupportErrorInfo *iface)
 304 {
 305     struct error_info *error_info = impl_from_ISupportErrorInfo(iface);
 306     return IErrorInfo_AddRef(&error_info->IErrorInfo_iface);
 307 }
 308
 309 static ULONG WINAPI support_errorinfo_Release(ISupportErrorInfo *iface)
 310 {
 311     struct error_info *error_info = impl_from_ISupportErrorInfo(iface);
 312     return IErrorInfo_Release(&error_info->IErrorInfo_iface);
 313 }
 314
 315 static HRESULT WINAPI support_errorinfo_InterfaceSupportsErrorInfo(ISupportErrorInfo *iface, REFIID riid)
 316 {
 317     struct error_info *error_info = impl_from_ISupportErrorInfo(iface);
 318
 319     TRACE("%p, %s.\n", iface, debugstr_guid(riid));
 320
 321     return IsEqualIID(riid, &error_info->guid) ? S_OK : S_FALSE;
 322 }
 323
 324 static const ISupportErrorInfoVtbl support_errorinfo_vtbl =
 325 {
 326     support_errorinfo_QueryInterface,
 327     support_errorinfo_AddRef,
 328     support_errorinfo_Release,
 329     support_errorinfo_InterfaceSupportsErrorInfo
 330 };
 331
 332 /***********************************************************************
 333  *                CreateErrorInfo (combase.@)
 334  */
 335 HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo **ret)
 336 {
 337     struct error_info *error_info;
 338
 339     TRACE("%p.\n", ret);
 340
 341     if (!ret) return E_INVALIDARG;
 342
 343     if (!(error_info = heap_alloc(sizeof(*error_info))))
 344         return E_OUTOFMEMORY;
 345
 346     error_info->IErrorInfo_iface.lpVtbl = &errorinfo_vtbl;
 347     error_info->ICreateErrorInfo_iface.lpVtbl = &create_errorinfo_vtbl;
 348     error_info->ISupportErrorInfo_iface.lpVtbl = &support_errorinfo_vtbl;
 349     error_info->refcount = 1;
 350     error_info->source = NULL;
 351     error_info->description = NULL;
 352     error_info->help_file = NULL;
 353     error_info->help_context = 0;
 354
 355     *ret = &error_info->ICreateErrorInfo_iface;
 356
 357     return S_OK;
 358 }
 359
 360 /***********************************************************************
 361  *                GetErrorInfo    (combase.@)
 362  */
 363 HRESULT WINAPI GetErrorInfo(ULONG reserved, IErrorInfo **error_info)
 364 {
 365     struct tlsdata *tlsdata;
 366     HRESULT hr;
 367
 368     TRACE("%u, %p\n", reserved, error_info);
 369
 370     if (reserved || !error_info)
 371         return E_INVALIDARG;
 372
 373     if (FAILED(hr = com_get_tlsdata(&tlsdata)))
 374         return hr;
 375
 376     if (!tlsdata->errorinfo)
 377     {
 378         *error_info = NULL;
 379         return S_FALSE;
 380     }
 381
 382     *error_info = tlsdata->errorinfo;
 383     tlsdata->errorinfo = NULL;
 384
 385     return S_OK;
 386 }
 387
 388 /***********************************************************************
 389  *               SetErrorInfo    (combase.@)
 390  */
 391 HRESULT WINAPI SetErrorInfo(ULONG reserved, IErrorInfo *error_info)
 392 {
 393     struct tlsdata *tlsdata;
 394     HRESULT hr;
 395
 396     TRACE("%u, %p\n", reserved, error_info);
 397
 398     if (reserved)
 399         return E_INVALIDARG;
 400
 401     if (FAILED(hr = com_get_tlsdata(&tlsdata)))
 402         return hr;
 403
 404     if (tlsdata->errorinfo)
 405         IErrorInfo_Release(tlsdata->errorinfo);
 406
 407     tlsdata->errorinfo = error_info;
 408     if (error_info)
 409         IErrorInfo_AddRef(error_info);
 410
 411     return S_OK;
 412 }