dlls/oledb32/convert.c

   1 /* OLE DB Conversion library
   2  *
   3  * Copyright 2009 Huw Davies
   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
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23 #define NONAMELESSUNION
  24 #define NONAMELESSSTRUCT
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "ole2.h"
  30 #include "msdadc.h"
  31 #include "oledberr.h"
  32
  33 #include "oledb_private.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
  38
  39 typedef struct
  40 {
  41     const struct IDataConvertVtbl *lpVtbl;
  42     const struct IDCInfoVtbl *lpDCInfoVtbl;
  43
  44     LONG ref;
  45
  46     UINT version; /* Set by IDCInfo_SetInfo */
  47 } convert;
  48
  49 static inline convert *impl_from_IDataConvert(IDataConvert *iface)
  50 {
  51     return (convert *)((char*)iface - FIELD_OFFSET(convert, lpVtbl));
  52 }
  53
  54 static inline convert *impl_from_IDCInfo(IDCInfo *iface)
  55 {
  56     return (convert *)((char*)iface - FIELD_OFFSET(convert, lpDCInfoVtbl));
  57 }
  58
  59 static HRESULT WINAPI convert_QueryInterface(IDataConvert* iface,
  60                                              REFIID riid,
  61                                              void **obj)
  62 {
  63     convert *This = impl_from_IDataConvert(iface);
  64     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
  65
  66     *obj = NULL;
  67
  68     if(IsEqualIID(riid, &IID_IUnknown) ||
  69        IsEqualIID(riid, &IID_IDataConvert))
  70     {
  71         *obj = iface;
  72     }
  73     else if(IsEqualIID(riid, &IID_IDCInfo))
  74     {
  75         *obj = &This->lpDCInfoVtbl;
  76     }
  77     else
  78     {
  79         FIXME("interface %s not implemented\n", debugstr_guid(riid));
  80         return E_NOINTERFACE;
  81     }
  82
  83     IDataConvert_AddRef(iface);
  84     return S_OK;
  85 }
  86
  87
  88 static ULONG WINAPI convert_AddRef(IDataConvert* iface)
  89 {
  90     convert *This = impl_from_IDataConvert(iface);
  91     TRACE("(%p)\n", This);
  92
  93     return InterlockedIncrement(&This->ref);
  94 }
  95
  96
  97 static ULONG WINAPI convert_Release(IDataConvert* iface)
  98 {
  99     convert *This = impl_from_IDataConvert(iface);
 100     LONG ref;
 101
 102     TRACE("(%p)\n", This);
 103
 104     ref = InterlockedDecrement(&This->ref);
 105     if(ref == 0)
 106     {
 107         HeapFree(GetProcessHeap(), 0, This);
 108     }
 109
 110     return ref;
 111 }
 112
 113 static int get_length(DBTYPE type)
 114 {
 115     switch(type)
 116     {
 117     case DBTYPE_I1:
 118     case DBTYPE_UI1:
 119         return 1;
 120     case DBTYPE_I2:
 121     case DBTYPE_UI2:
 122         return 2;
 123     case DBTYPE_I4:
 124     case DBTYPE_UI4:
 125         return 4;
 126     case DBTYPE_I8:
 127     case DBTYPE_UI8:
 128         return 8;
 129     default:
 130         FIXME("Unhandled type %04x\n", type);
 131         return 0;
 132     }
 133 }
 134
 135 static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
 136                                           DBTYPE src_type, DBTYPE dst_type,
 137                                           DBLENGTH src_len, DBLENGTH *dst_len,
 138                                           void *src, void *dst,
 139                                           DBLENGTH dst_max_len,
 140                                           DBSTATUS src_status, DBSTATUS *dst_status,
 141                                           BYTE precision, BYTE scale,
 142                                           DBDATACONVERT flags)
 143 {
 144     convert *This = impl_from_IDataConvert(iface);
 145     HRESULT hr;
 146
 147     TRACE("(%p)->(%d, %d, %d, %p, %p, %p, %d, %d, %p, %d, %d, %x)\n", This,
 148           src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
 149           src_status, dst_status, precision, scale, flags);
 150
 151     *dst_len = get_length(dst_type);
 152     *dst_status = DBSTATUS_E_BADACCESSOR;
 153
 154     if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
 155     {
 156         return DB_E_UNSUPPORTEDCONVERSION;
 157     }
 158
 159     if(src_type == DBTYPE_STR)
 160     {
 161         BSTR b;
 162         DWORD len;
 163
 164         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 165             len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
 166         else
 167             len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
 168         b = SysAllocStringLen(NULL, len);
 169         if(!b) return E_OUTOFMEMORY;
 170         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 171             MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
 172         else
 173             MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
 174
 175         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 176                                       &b, dst, dst_max_len, src_status, dst_status,
 177                                       precision, scale, flags);
 178
 179         SysFreeString(b);
 180         return hr;
 181     }
 182
 183     if(src_type == DBTYPE_WSTR)
 184     {
 185         BSTR b;
 186
 187         if(flags & DBDATACONVERT_LENGTHFROMNTS)
 188             b = SysAllocString(src);
 189         else
 190             b = SysAllocStringLen(src, src_len / 2);
 191         if(!b) return E_OUTOFMEMORY;
 192         hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
 193                                       &b, dst, dst_max_len, src_status, dst_status,
 194                                       precision, scale, flags);
 195         SysFreeString(b);
 196         return hr;
 197     }
 198
 199     switch(dst_type)
 200     {
 201     case DBTYPE_I4:
 202     {
 203         signed int *d = dst;
 204         switch(src_type)
 205         {
 206         case DBTYPE_EMPTY:       *d = 0; hr = S_OK;                              break;
 207         case DBTYPE_I2:          hr = VarI4FromI2(*(signed short*)src, d);       break;
 208         case DBTYPE_I4:          *d = *(signed int*)src; hr = S_OK;              break;
 209         case DBTYPE_R4:          hr = VarI4FromR4(*(FLOAT*)src, d);              break;
 210         case DBTYPE_R8:          hr = VarI4FromR8(*(double*)src, d);             break;
 211         case DBTYPE_CY:          hr = VarI4FromCy(*(CY*)src, d);                 break;
 212         case DBTYPE_DATE:        hr = VarI4FromDate(*(DATE*)src, d);             break;
 213         case DBTYPE_BSTR:        hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
 214         case DBTYPE_BOOL:        hr = VarI4FromBool(*(VARIANT_BOOL*)src, d);     break;
 215         case DBTYPE_DECIMAL:     hr = VarI4FromDec((DECIMAL*)src, d);            break;
 216         case DBTYPE_I1:          hr = VarI4FromI1(*(signed char*)src, d);        break;
 217         case DBTYPE_UI1:         hr = VarI4FromUI1(*(BYTE*)src, d);              break;
 218         case DBTYPE_UI2:         hr = VarI4FromUI2(*(WORD*)src, d);              break;
 219         case DBTYPE_UI4:         hr = VarI4FromUI4(*(DWORD*)src, d);             break;
 220         case DBTYPE_I8:          hr = VarI4FromI8(*(LONGLONG*)src, d);           break;
 221         case DBTYPE_UI8:         hr = VarI4FromUI8(*(ULONGLONG*)src, d);         break;
 222         default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
 223         }
 224         break;
 225     }
 226
 227     default:
 228         FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
 229         return E_NOTIMPL;
 230
 231     }
 232
 233     if(hr == DISP_E_OVERFLOW)
 234     {
 235         *dst_status = DBSTATUS_E_DATAOVERFLOW;
 236         hr = DB_E_ERRORSOCCURRED;
 237     }
 238     else if(hr == S_OK)
 239         *dst_status = DBSTATUS_S_OK;
 240
 241     return hr;
 242 }
 243
 244 static inline WORD get_dbtype_class(DBTYPE type)
 245 {
 246     switch(type)
 247     {
 248     case DBTYPE_I2:
 249     case DBTYPE_R4:
 250     case DBTYPE_R8:
 251     case DBTYPE_I1:
 252     case DBTYPE_UI1:
 253     case DBTYPE_UI2:
 254         return DBTYPE_I2;
 255
 256     case DBTYPE_I4:
 257     case DBTYPE_UI4:
 258         return DBTYPE_I4;
 259
 260     case DBTYPE_I8:
 261     case DBTYPE_UI8:
 262         return DBTYPE_I8;
 263
 264     case DBTYPE_BSTR:
 265     case DBTYPE_STR:
 266     case DBTYPE_WSTR:
 267         return DBTYPE_BSTR;
 268
 269     case DBTYPE_DBDATE:
 270     case DBTYPE_DBTIME:
 271     case DBTYPE_DBTIMESTAMP:
 272         return DBTYPE_DBDATE;
 273     }
 274     return type;
 275 }
 276
 277 /* Many src types will convert to this group of dst types */
 278 static inline BOOL common_class(WORD dst_class)
 279 {
 280     switch(dst_class)
 281     {
 282     case DBTYPE_EMPTY:
 283     case DBTYPE_NULL:
 284     case DBTYPE_I2:
 285     case DBTYPE_I4:
 286     case DBTYPE_BSTR:
 287     case DBTYPE_BOOL:
 288     case DBTYPE_VARIANT:
 289     case DBTYPE_I8:
 290     case DBTYPE_CY:
 291     case DBTYPE_DECIMAL:
 292     case DBTYPE_NUMERIC:
 293         return TRUE;
 294     }
 295     return FALSE;
 296 }
 297
 298 static inline BOOL array_type(DBTYPE type)
 299 {
 300     return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
 301 }
 302
 303 static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
 304                                          DBTYPE src_type, DBTYPE dst_type)
 305 {
 306     convert *This = impl_from_IDataConvert(iface);
 307     DBTYPE src_base_type = src_type & 0x1ff;
 308     DBTYPE dst_base_type = dst_type & 0x1ff;
 309     WORD dst_class = get_dbtype_class(dst_base_type);
 310
 311     TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
 312
 313     if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
 314
 315     if(src_type & DBTYPE_ARRAY)
 316     {
 317         if(!array_type(src_base_type)) return S_FALSE;
 318         if(dst_type & DBTYPE_ARRAY)
 319         {
 320             if(src_type == dst_type) return S_OK;
 321             return S_FALSE;
 322         }
 323         if(dst_type == DBTYPE_VARIANT) return S_OK;
 324         return S_FALSE;
 325     }
 326
 327     if(dst_type & DBTYPE_ARRAY)
 328     {
 329         if(!array_type(dst_base_type)) return S_FALSE;
 330         if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
 331         return S_FALSE;
 332     }
 333
 334     if(dst_type & DBTYPE_BYREF)
 335         if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
 336             return S_FALSE;
 337
 338     switch(get_dbtype_class(src_base_type))
 339     {
 340     case DBTYPE_EMPTY:
 341         if(common_class(dst_class)) return S_OK;
 342         switch(dst_class)
 343         {
 344         case DBTYPE_DATE:
 345         case DBTYPE_GUID:
 346             return S_OK;
 347         default:
 348             if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
 349             return S_FALSE;
 350         }
 351
 352     case DBTYPE_NULL:
 353         switch(dst_base_type)
 354         {
 355         case DBTYPE_NULL:
 356         case DBTYPE_VARIANT: return S_OK;
 357         default: return S_FALSE;
 358         }
 359
 360     case DBTYPE_I4:
 361         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 362         /* fall through */
 363     case DBTYPE_I2:
 364         if(dst_base_type == DBTYPE_DATE) return S_OK;
 365         /* fall through */
 366     case DBTYPE_DECIMAL:
 367         if(common_class(dst_class)) return S_OK;
 368         if(dst_class == DBTYPE_DBDATE) return S_OK;
 369         return S_FALSE;
 370
 371     case DBTYPE_BOOL:
 372         if(dst_base_type == DBTYPE_DATE) return S_OK;
 373     case DBTYPE_NUMERIC:
 374     case DBTYPE_CY:
 375         if(common_class(dst_class)) return S_OK;
 376         return S_FALSE;
 377
 378     case DBTYPE_I8:
 379         if(common_class(dst_class)) return S_OK;
 380         if(dst_base_type == DBTYPE_BYTES) return S_OK;
 381         return S_FALSE;
 382
 383     case DBTYPE_DATE:
 384         switch(dst_class)
 385         {
 386         case DBTYPE_EMPTY:
 387         case DBTYPE_NULL:
 388         case DBTYPE_I2:
 389         case DBTYPE_I4:
 390         case DBTYPE_BSTR:
 391         case DBTYPE_BOOL:
 392         case DBTYPE_VARIANT:
 393         case DBTYPE_I8:
 394         case DBTYPE_DATE:
 395         case DBTYPE_DBDATE:
 396             return S_OK;
 397         default: return S_FALSE;
 398         }
 399
 400     case DBTYPE_IDISPATCH:
 401     case DBTYPE_VARIANT:
 402         switch(dst_base_type)
 403         {
 404         case DBTYPE_IDISPATCH:
 405         case DBTYPE_ERROR:
 406         case DBTYPE_IUNKNOWN:
 407             return S_OK;
 408         }
 409         /* fall through */
 410     case DBTYPE_BSTR:
 411         if(common_class(dst_class)) return S_OK;
 412         switch(dst_class)
 413         {
 414         case DBTYPE_DATE:
 415         case DBTYPE_GUID:
 416         case DBTYPE_BYTES:
 417         case DBTYPE_DBDATE:
 418             return S_OK;
 419         default: return S_FALSE;
 420         }
 421
 422     case DBTYPE_ERROR:
 423         switch(dst_base_type)
 424         {
 425         case DBTYPE_BSTR:
 426         case DBTYPE_ERROR:
 427         case DBTYPE_VARIANT:
 428         case DBTYPE_WSTR:
 429             return S_OK;
 430         default: return S_FALSE;
 431         }
 432
 433     case DBTYPE_IUNKNOWN:
 434         switch(dst_base_type)
 435         {
 436         case DBTYPE_EMPTY:
 437         case DBTYPE_NULL:
 438         case DBTYPE_IDISPATCH:
 439         case DBTYPE_VARIANT:
 440         case DBTYPE_IUNKNOWN:
 441             return S_OK;
 442         default: return S_FALSE;
 443         }
 444
 445     case DBTYPE_BYTES:
 446         if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
 447         /* fall through */
 448     case DBTYPE_GUID:
 449         switch(dst_class)
 450         {
 451         case DBTYPE_EMPTY:
 452         case DBTYPE_NULL:
 453         case DBTYPE_BSTR:
 454         case DBTYPE_VARIANT:
 455         case DBTYPE_GUID:
 456         case DBTYPE_BYTES:
 457             return S_OK;
 458         default: return S_FALSE;
 459         }
 460
 461     case DBTYPE_DBDATE:
 462         switch(dst_class)
 463         {
 464         case DBTYPE_EMPTY:
 465         case DBTYPE_NULL:
 466         case DBTYPE_DATE:
 467         case DBTYPE_BSTR:
 468         case DBTYPE_VARIANT:
 469         case DBTYPE_DBDATE:
 470             return S_OK;
 471         default: return S_FALSE;
 472         }
 473
 474     }
 475     return S_FALSE;
 476 }
 477
 478 static HRESULT WINAPI convert_GetConversionSize(IDataConvert* iface,
 479                                                 DBTYPE wSrcType, DBTYPE wDstType,
 480                                                 DBLENGTH *pcbSrcLength, DBLENGTH *pcbDstLength,
 481                                                 void *pSrc)
 482 {
 483     convert *This = impl_from_IDataConvert(iface);
 484     FIXME("(%p)->(%d, %d, %p, %p, %p): stub\n", This, wSrcType, wDstType, pcbSrcLength, pcbDstLength, pSrc);
 485
 486     return E_NOTIMPL;
 487 }
 488
 489 static const struct IDataConvertVtbl convert_vtbl =
 490 {
 491     convert_QueryInterface,
 492     convert_AddRef,
 493     convert_Release,
 494     convert_DataConvert,
 495     convert_CanConvert,
 496     convert_GetConversionSize
 497 };
 498
 499 static HRESULT WINAPI dcinfo_QueryInterface(IDCInfo* iface, REFIID riid, void **obj)
 500 {
 501     convert *This = impl_from_IDCInfo(iface);
 502
 503     return IDataConvert_QueryInterface((IDataConvert *)This, riid, obj);
 504 }
 505
 506 static ULONG WINAPI dcinfo_AddRef(IDCInfo* iface)
 507 {
 508     convert *This = impl_from_IDCInfo(iface);
 509
 510     return IDataConvert_AddRef((IDataConvert *)This);
 511 }
 512
 513 static ULONG WINAPI dcinfo_Release(IDCInfo* iface)
 514 {
 515     convert *This = impl_from_IDCInfo(iface);
 516
 517     return IDataConvert_Release((IDataConvert *)This);
 518 }
 519
 520 static HRESULT WINAPI dcinfo_GetInfo(IDCInfo *iface, ULONG num, DCINFOTYPE types[], DCINFO **info_ptr)
 521 {
 522     convert *This = impl_from_IDCInfo(iface);
 523     ULONG i;
 524     DCINFO *infos;
 525
 526     TRACE("(%p)->(%d, %p, %p)\n", This, num, types, info_ptr);
 527
 528     *info_ptr = infos = CoTaskMemAlloc(num * sizeof(*infos));
 529     if(!infos) return E_OUTOFMEMORY;
 530
 531     for(i = 0; i < num; i++)
 532     {
 533         infos[i].eInfoType = types[i];
 534         VariantInit(&infos[i].vData);
 535
 536         switch(types[i])
 537         {
 538         case DCINFOTYPE_VERSION:
 539             V_VT(&infos[i].vData) = VT_UI4;
 540             V_UI4(&infos[i].vData) = This->version;
 541             break;
 542         }
 543     }
 544
 545     return S_OK;
 546 }
 547
 548 static HRESULT WINAPI dcinfo_SetInfo(IDCInfo* iface, ULONG num, DCINFO info[])
 549 {
 550     convert *This = impl_from_IDCInfo(iface);
 551     ULONG i;
 552     HRESULT hr = S_OK;
 553
 554     TRACE("(%p)->(%d, %p)\n", This, num, info);
 555
 556     for(i = 0; i < num; i++)
 557     {
 558         switch(info[i].eInfoType)
 559         {
 560         case DCINFOTYPE_VERSION:
 561             if(V_VT(&info[i].vData) != VT_UI4)
 562             {
 563                 FIXME("VERSION with vt %x\n", V_VT(&info[i].vData));
 564                 hr = DB_S_ERRORSOCCURRED;
 565                 break;
 566             }
 567             This->version = V_UI4(&info[i].vData);
 568             break;
 569
 570         default:
 571             FIXME("Unhandled info type %d (vt %x)\n", info[i].eInfoType, V_VT(&info[i].vData));
 572         }
 573     }
 574     return hr;
 575 }
 576
 577 static const struct IDCInfoVtbl dcinfo_vtbl =
 578 {
 579     dcinfo_QueryInterface,
 580     dcinfo_AddRef,
 581     dcinfo_Release,
 582     dcinfo_GetInfo,
 583     dcinfo_SetInfo
 584 };
 585
 586 HRESULT create_oledb_convert(IUnknown *outer, void **obj)
 587 {
 588     convert *This;
 589
 590     TRACE("(%p, %p)\n", outer, obj);
 591
 592     *obj = NULL;
 593
 594     if(outer) return CLASS_E_NOAGGREGATION;
 595
 596     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 597     if(!This) return E_OUTOFMEMORY;
 598
 599     This->lpVtbl = &convert_vtbl;
 600     This->lpDCInfoVtbl = &dcinfo_vtbl;
 601     This->ref = 1;
 602     This->version = 0x110;
 603
 604     *obj = &This->lpVtbl;
 605
 606     return S_OK;
 607 }