dlls/oledb32/errorinfo.c

   1 /* OLE DB ErrorInfo
   2  *
   3  * Copyright 2013 Alistair Leslie-Hughes
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19 #include <stdarg.h>
  20 #include <string.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27 #include "oleauto.h"
  28 #include "winerror.h"
  29 #include "oledb.h"
  30 #include "oledberr.h"
  31
  32 #include "oledb_private.h"
  33
  34 #include "wine/unicode.h"
  35 #include "wine/heap.h"
  36 #include "wine/list.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  41
  42 struct ErrorEntry
  43 {
  44     ERRORINFO       info;
  45     DISPPARAMS      dispparams;
  46     IUnknown        *custom_error;
  47     DWORD           lookupID;
  48 };
  49
  50 typedef struct errorrecords
  51 {
  52     IErrorInfo     IErrorInfo_iface;
  53     IErrorRecords  IErrorRecords_iface;
  54     LONG ref;
  55
  56     struct ErrorEntry *records;
  57     unsigned int allocated;
  58     unsigned int count;
  59 } errorrecords;
  60
  61 static inline errorrecords *impl_from_IErrorInfo( IErrorInfo *iface )
  62 {
  63     return CONTAINING_RECORD(iface, errorrecords, IErrorInfo_iface);
  64 }
  65
  66 static inline errorrecords *impl_from_IErrorRecords( IErrorRecords *iface )
  67 {
  68     return CONTAINING_RECORD(iface, errorrecords, IErrorRecords_iface);
  69 }
  70
  71 static HRESULT WINAPI errorrecords_QueryInterface(IErrorInfo* iface, REFIID riid, void **ppvoid)
  72 {
  73     errorrecords *This = impl_from_IErrorInfo(iface);
  74     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid),ppvoid);
  75
  76     *ppvoid = NULL;
  77
  78     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IErrorInfo))
  79     {
  80       *ppvoid = &This->IErrorInfo_iface;
  81     }
  82     else if (IsEqualIID(riid, &IID_IErrorRecords))
  83     {
  84       *ppvoid = &This->IErrorRecords_iface;
  85     }
  86
  87     if(*ppvoid)
  88     {
  89       IUnknown_AddRef( (IUnknown*)*ppvoid );
  90       return S_OK;
  91     }
  92
  93     FIXME("interface %s not implemented\n", debugstr_guid(riid));
  94     return E_NOINTERFACE;
  95 }
  96
  97 static ULONG WINAPI errorrecords_AddRef(IErrorInfo* iface)
  98 {
  99     errorrecords *This = impl_from_IErrorInfo(iface);
 100     TRACE("(%p)->%u\n",This,This->ref);
 101     return InterlockedIncrement(&This->ref);
 102 }
 103
 104 static ULONG WINAPI errorrecords_Release(IErrorInfo* iface)
 105 {
 106     errorrecords *This = impl_from_IErrorInfo(iface);
 107     ULONG ref = InterlockedDecrement(&This->ref);
 108
 109     TRACE("(%p)->%u\n",This,ref+1);
 110
 111     if (!ref)
 112     {
 113         unsigned int i;
 114
 115         for (i = 0; i < This->count; i++)
 116         {
 117             DISPPARAMS *dispparams = &This->records[i].dispparams;
 118             unsigned int j;
 119
 120             if (This->records[i].custom_error)
 121                 IUnknown_Release(This->records[i].custom_error);
 122
 123             for (j = 0; j < dispparams->cArgs && dispparams->rgvarg; j++)
 124                 VariantClear(&dispparams->rgvarg[i]);
 125             CoTaskMemFree(dispparams->rgvarg);
 126             CoTaskMemFree(dispparams->rgdispidNamedArgs);
 127         }
 128         heap_free(This->records);
 129         heap_free(This);
 130     }
 131     return ref;
 132 }
 133
 134 static HRESULT WINAPI errorrecords_GetGUID(IErrorInfo* iface, GUID *guid)
 135 {
 136     errorrecords *This = impl_from_IErrorInfo(iface);
 137
 138     TRACE("(%p)->(%p)\n", This, guid);
 139
 140     if (!guid)
 141         return E_INVALIDARG;
 142
 143     *guid = GUID_NULL;
 144
 145     return S_OK;
 146 }
 147
 148 static HRESULT WINAPI errorrecords_GetSource(IErrorInfo* iface, BSTR *source)
 149 {
 150     errorrecords *This = impl_from_IErrorInfo(iface);
 151
 152     TRACE("(%p)->(%p)\n", This, source);
 153
 154     if (!source)
 155         return E_INVALIDARG;
 156
 157     *source = NULL;
 158
 159     return E_FAIL;
 160 }
 161
 162 static HRESULT WINAPI errorrecords_GetDescription(IErrorInfo* iface, BSTR *description)
 163 {
 164     errorrecords *This = impl_from_IErrorInfo(iface);
 165
 166     TRACE("(%p)->(%p)\n", This, description);
 167
 168     if (!description)
 169         return E_INVALIDARG;
 170
 171     *description = NULL;
 172
 173     return E_FAIL;
 174 }
 175
 176 static HRESULT WINAPI errorrecords_GetHelpFile(IErrorInfo* iface, BSTR *helpfile)
 177 {
 178     errorrecords *This = impl_from_IErrorInfo(iface);
 179
 180     TRACE("(%p)->(%p)\n", This, helpfile);
 181
 182     if (!helpfile)
 183         return E_INVALIDARG;
 184
 185     *helpfile = NULL;
 186
 187     return E_FAIL;
 188 }
 189
 190 static HRESULT WINAPI errorrecords_GetHelpContext(IErrorInfo* iface, DWORD *context)
 191 {
 192     errorrecords *This = impl_from_IErrorInfo(iface);
 193
 194     TRACE("(%p)->(%p)\n", This, context);
 195
 196     if (!context)
 197         return E_INVALIDARG;
 198
 199     *context = 0;
 200
 201     return E_FAIL;
 202 }
 203
 204 static const IErrorInfoVtbl ErrorInfoVtbl =
 205 {
 206     errorrecords_QueryInterface,
 207     errorrecords_AddRef,
 208     errorrecords_Release,
 209     errorrecords_GetGUID,
 210     errorrecords_GetSource,
 211     errorrecords_GetDescription,
 212     errorrecords_GetHelpFile,
 213     errorrecords_GetHelpContext
 214 };
 215
 216 static HRESULT WINAPI errorrec_QueryInterface(IErrorRecords *iface, REFIID riid, void **ppvObject)
 217 {
 218     errorrecords *This = impl_from_IErrorRecords(iface);
 219     return IErrorInfo_QueryInterface(&This->IErrorInfo_iface, riid, ppvObject);
 220 }
 221
 222 static ULONG WINAPI WINAPI errorrec_AddRef(IErrorRecords *iface)
 223 {
 224     errorrecords *This = impl_from_IErrorRecords(iface);
 225     return IErrorInfo_AddRef(&This->IErrorInfo_iface);
 226 }
 227
 228 static ULONG WINAPI WINAPI errorrec_Release(IErrorRecords *iface)
 229 {
 230     errorrecords *This = impl_from_IErrorRecords(iface);
 231     return IErrorInfo_Release(&This->IErrorInfo_iface);
 232 }
 233
 234 static HRESULT dup_dispparams(DISPPARAMS *src, DISPPARAMS *dest)
 235 {
 236     unsigned int i;
 237
 238     if (!src)
 239     {
 240         memset(dest, 0, sizeof(*dest));
 241         return S_OK;
 242     }
 243
 244     *dest = *src;
 245
 246     if (src->cArgs)
 247     {
 248         dest->rgvarg = CoTaskMemAlloc(dest->cArgs * sizeof(*dest->rgvarg));
 249         for (i = 0; i < src->cArgs; i++)
 250         {
 251             VariantInit(&dest->rgvarg[i]);
 252             VariantCopy(&dest->rgvarg[i], &src->rgvarg[i]);
 253         }
 254     }
 255
 256     if (src->cNamedArgs)
 257     {
 258         dest->rgdispidNamedArgs = CoTaskMemAlloc(dest->cNamedArgs * sizeof(*dest->rgdispidNamedArgs));
 259         memcpy(dest->rgdispidNamedArgs, src->rgdispidNamedArgs, dest->cNamedArgs * sizeof(*dest->rgdispidNamedArgs));
 260     }
 261
 262     return S_OK;
 263 }
 264
 265 static HRESULT WINAPI errorrec_AddErrorRecord(IErrorRecords *iface, ERRORINFO *pErrorInfo,
 266         DWORD dwLookupID, DISPPARAMS *pdispparams, IUnknown *punkCustomError, DWORD dwDynamicErrorID)
 267 {
 268     errorrecords *This = impl_from_IErrorRecords(iface);
 269     struct ErrorEntry *entry;
 270     HRESULT hr;
 271
 272     TRACE("(%p)->(%p %d %p %p %d)\n", This, pErrorInfo, dwLookupID, pdispparams, punkCustomError, dwDynamicErrorID);
 273
 274     if(!pErrorInfo)
 275         return E_INVALIDARG;
 276
 277     if (!This->records)
 278     {
 279         const unsigned int initial_size = 16;
 280         if (!(This->records = heap_alloc(initial_size * sizeof(*This->records))))
 281             return E_OUTOFMEMORY;
 282
 283         This->allocated = initial_size;
 284     }
 285     else if (This->count == This->allocated)
 286     {
 287         struct ErrorEntry *new_ptr;
 288
 289         new_ptr = heap_realloc(This->records, 2 * This->allocated * sizeof(*This->records));
 290         if (!new_ptr)
 291             return E_OUTOFMEMORY;
 292
 293         This->records = new_ptr;
 294         This->allocated *= 2;
 295     }
 296
 297     entry = This->records + This->count;
 298     entry->info = *pErrorInfo;
 299
 300     if (FAILED(hr = dup_dispparams(pdispparams, &entry->dispparams)))
 301         return hr;
 302
 303     entry->custom_error = punkCustomError;
 304     if (entry->custom_error)
 305         IUnknown_AddRef(entry->custom_error);
 306     entry->lookupID = dwDynamicErrorID;
 307
 308     This->count++;
 309
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI errorrec_GetBasicErrorInfo(IErrorRecords *iface, ULONG index, ERRORINFO *info)
 314 {
 315     errorrecords *This = impl_from_IErrorRecords(iface);
 316
 317     TRACE("(%p)->(%u %p)\n", This, index, info);
 318
 319     if (!info)
 320         return E_INVALIDARG;
 321
 322     if (index >= This->count)
 323         return DB_E_BADRECORDNUM;
 324
 325     index = This->count - index - 1;
 326     *info = This->records[index].info;
 327     return S_OK;
 328 }
 329
 330 static HRESULT WINAPI errorrec_GetCustomErrorObject(IErrorRecords *iface, ULONG index,
 331         REFIID riid, IUnknown **object)
 332 {
 333     errorrecords *This = impl_from_IErrorRecords(iface);
 334
 335     TRACE("(%p)->(%u %s %p)\n", This, index, debugstr_guid(riid), object);
 336
 337     if (!object)
 338         return E_INVALIDARG;
 339
 340     *object = NULL;
 341
 342     if (index >= This->count)
 343         return DB_E_BADRECORDNUM;
 344
 345     index = This->count - index - 1;
 346     if (This->records[index].custom_error)
 347         return IUnknown_QueryInterface(This->records[index].custom_error, riid, (void **)object);
 348     else
 349         return S_OK;
 350 }
 351
 352 static HRESULT WINAPI errorrec_GetErrorInfo(IErrorRecords *iface, ULONG index,
 353         LCID lcid, IErrorInfo **ppErrorInfo)
 354 {
 355     errorrecords *This = impl_from_IErrorRecords(iface);
 356
 357     FIXME("(%p)->(%u %d, %p)\n", This, index, lcid, ppErrorInfo);
 358
 359     if (!ppErrorInfo)
 360         return E_INVALIDARG;
 361
 362     if (index >= This->count)
 363         return DB_E_BADRECORDNUM;
 364
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI errorrec_GetErrorParameters(IErrorRecords *iface, ULONG index, DISPPARAMS *pdispparams)
 369 {
 370     errorrecords *This = impl_from_IErrorRecords(iface);
 371
 372     TRACE("(%p)->(%u %p)\n", This, index, pdispparams);
 373
 374     if (!pdispparams)
 375         return E_INVALIDARG;
 376
 377     if (index >= This->count)
 378         return DB_E_BADRECORDNUM;
 379
 380     index = This->count - index - 1;
 381     return dup_dispparams(&This->records[index].dispparams, pdispparams);
 382 }
 383
 384 static HRESULT WINAPI errorrec_GetRecordCount(IErrorRecords *iface, ULONG *count)
 385 {
 386     errorrecords *This = impl_from_IErrorRecords(iface);
 387
 388     TRACE("(%p)->(%p)\n", This, count);
 389
 390     if(!count)
 391         return E_INVALIDARG;
 392
 393     *count = This->count;
 394
 395     TRACE("<--(%u)\n", *count);
 396
 397     return S_OK;
 398 }
 399
 400 static const IErrorRecordsVtbl ErrorRecordsVtbl =
 401 {
 402     errorrec_QueryInterface,
 403     errorrec_AddRef,
 404     errorrec_Release,
 405     errorrec_AddErrorRecord,
 406     errorrec_GetBasicErrorInfo,
 407     errorrec_GetCustomErrorObject,
 408     errorrec_GetErrorInfo,
 409     errorrec_GetErrorParameters,
 410     errorrec_GetRecordCount
 411 };
 412
 413 HRESULT create_error_info(IUnknown *outer, void **obj)
 414 {
 415     errorrecords *This;
 416
 417     TRACE("(%p, %p)\n", outer, obj);
 418
 419     *obj = NULL;
 420
 421     if(outer) return CLASS_E_NOAGGREGATION;
 422
 423     This = heap_alloc(sizeof(*This));
 424     if(!This) return E_OUTOFMEMORY;
 425
 426     This->IErrorInfo_iface.lpVtbl = &ErrorInfoVtbl;
 427     This->IErrorRecords_iface.lpVtbl = &ErrorRecordsVtbl;
 428     This->ref = 1;
 429
 430     This->records = NULL;
 431     This->allocated = 0;
 432     This->count = 0;
 433
 434     *obj = &This->IErrorInfo_iface;
 435
 436     return S_OK;
 437 }