dlls/msado15/connection.c

   1 /*
   2  * Copyright 2019 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include "windef.h"
  21 #include "winbase.h"
  22 #define COBJMACROS
  23 #include "initguid.h"
  24 #include "ocidl.h"
  25 #include "objbase.h"
  26 #include "olectl.h"
  27 #include "msado15_backcompat.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/heap.h"
  31
  32 #include "msado15_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(msado15);
  35
  36 struct connection;
  37
  38 struct connection_point
  39 {
  40     IConnectionPoint   IConnectionPoint_iface;
  41     struct connection *conn;
  42     const IID         *riid;
  43     IUnknown          **sinks;
  44     ULONG              sinks_size;
  45 };
  46
  47 struct connection
  48 {
  49     _Connection               Connection_iface;
  50     ISupportErrorInfo         ISupportErrorInfo_iface;
  51     IConnectionPointContainer IConnectionPointContainer_iface;
  52     LONG                      refs;
  53     ObjectStateEnum           state;
  54     LONG                      timeout;
  55     WCHAR                    *datasource;
  56     WCHAR                    *provider;
  57     ConnectModeEnum           mode;
  58     CursorLocationEnum        location;
  59     struct connection_point   cp_connev;
  60 };
  61
  62 static inline struct connection *impl_from_Connection( _Connection *iface )
  63 {
  64     return CONTAINING_RECORD( iface, struct connection, Connection_iface );
  65 }
  66
  67 static inline struct connection *impl_from_ISupportErrorInfo( ISupportErrorInfo *iface )
  68 {
  69     return CONTAINING_RECORD( iface, struct connection, ISupportErrorInfo_iface );
  70 }
  71
  72 static inline struct connection *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
  73 {
  74     return CONTAINING_RECORD( iface, struct connection, IConnectionPointContainer_iface );
  75 }
  76
  77 static inline struct connection_point *impl_from_IConnectionPoint( IConnectionPoint *iface )
  78 {
  79     return CONTAINING_RECORD( iface, struct connection_point, IConnectionPoint_iface );
  80 }
  81
  82 static ULONG WINAPI connection_AddRef( _Connection *iface )
  83 {
  84     struct connection *connection = impl_from_Connection( iface );
  85     return InterlockedIncrement( &connection->refs );
  86 }
  87
  88 static ULONG WINAPI connection_Release( _Connection *iface )
  89 {
  90     struct connection *connection = impl_from_Connection( iface );
  91     LONG refs = InterlockedDecrement( &connection->refs );
  92     ULONG i;
  93     if (!refs)
  94     {
  95         TRACE( "destroying %p\n", connection );
  96         for (i = 0; i < connection->cp_connev.sinks_size; ++i)
  97         {
  98             if (connection->cp_connev.sinks[i])
  99                 IUnknown_Release( connection->cp_connev.sinks[i] );
 100         }
 101         heap_free( connection->cp_connev.sinks );
 102         heap_free( connection->provider );
 103         heap_free( connection->datasource );
 104         heap_free( connection );
 105     }
 106     return refs;
 107 }
 108
 109 static HRESULT WINAPI connection_QueryInterface( _Connection *iface, REFIID riid, void **obj )
 110 {
 111     struct connection *connection = impl_from_Connection( iface );
 112     TRACE( "%p, %s, %p\n", connection, debugstr_guid(riid), obj );
 113
 114     *obj = NULL;
 115
 116     if (IsEqualGUID( riid, &IID__Connection ) || IsEqualGUID( riid, &IID_IDispatch ) ||
 117         IsEqualGUID( riid, &IID_IUnknown ))
 118     {
 119         *obj = iface;
 120     }
 121     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
 122     {
 123         *obj = &connection->ISupportErrorInfo_iface;
 124     }
 125     else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
 126     {
 127         *obj = &connection->IConnectionPointContainer_iface;
 128     }
 129     else if (IsEqualGUID( riid, &IID_IRunnableObject ))
 130     {
 131         TRACE("IID_IRunnableObject not supported returning NULL\n");
 132         return E_NOINTERFACE;
 133     }
 134     else
 135     {
 136         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 137         return E_NOINTERFACE;
 138     }
 139     connection_AddRef( iface );
 140     return S_OK;
 141 }
 142
 143 static HRESULT WINAPI connection_GetTypeInfoCount( _Connection *iface, UINT *count )
 144 {
 145     FIXME( "%p, %p\n", iface, count );
 146     return E_NOTIMPL;
 147 }
 148
 149 static HRESULT WINAPI connection_GetTypeInfo( _Connection *iface, UINT index, LCID lcid, ITypeInfo **info )
 150 {
 151     FIXME( "%p, %u, %u, %p\n", iface, index, lcid, info );
 152     return E_NOTIMPL;
 153 }
 154
 155 static HRESULT WINAPI connection_GetIDsOfNames( _Connection *iface, REFIID riid, LPOLESTR *names, UINT count,
 156                                                 LCID lcid, DISPID *dispid )
 157 {
 158     FIXME( "%p, %s, %p, %u, %u, %p\n", iface, debugstr_guid(riid), names, count, lcid, dispid );
 159     return E_NOTIMPL;
 160 }
 161
 162 static HRESULT WINAPI connection_Invoke( _Connection *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
 163                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
 164 {
 165     FIXME( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", iface, member, debugstr_guid(riid), lcid, flags, params,
 166            result, excep_info, arg_err );
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI connection_get_Properties( _Connection *iface, Properties **obj )
 171 {
 172     FIXME( "%p, %p\n", iface, obj );
 173     return E_NOTIMPL;
 174 }
 175
 176 static HRESULT WINAPI connection_get_ConnectionString( _Connection *iface, BSTR *str )
 177 {
 178     struct connection *connection = impl_from_Connection( iface );
 179     BSTR source = NULL;
 180
 181     TRACE( "%p, %p\n", connection, str );
 182
 183     if (connection->datasource && !(source = SysAllocString( connection->datasource ))) return E_OUTOFMEMORY;
 184     *str = source;
 185     return S_OK;
 186 }
 187
 188 static HRESULT WINAPI connection_put_ConnectionString( _Connection *iface, BSTR str )
 189 {
 190     struct connection *connection = impl_from_Connection( iface );
 191     WCHAR *source = NULL;
 192
 193     TRACE( "%p, %s\n", connection, debugstr_w( str && !wcsstr( str, L"Password" ) ? L"<hidden>" : str ) );
 194
 195     if (str && !(source = strdupW( str ))) return E_OUTOFMEMORY;
 196     heap_free( connection->datasource );
 197     connection->datasource = source;
 198     return S_OK;
 199 }
 200
 201 static HRESULT WINAPI connection_get_CommandTimeout( _Connection *iface, LONG *timeout )
 202 {
 203     struct connection *connection = impl_from_Connection( iface );
 204     TRACE( "%p, %p\n", connection, timeout );
 205     *timeout = connection->timeout;
 206     return S_OK;
 207 }
 208
 209 static HRESULT WINAPI connection_put_CommandTimeout( _Connection *iface, LONG timeout )
 210 {
 211     struct connection *connection = impl_from_Connection( iface );
 212     TRACE( "%p, %d\n", connection, timeout );
 213     connection->timeout = timeout;
 214     return S_OK;
 215 }
 216
 217 static HRESULT WINAPI connection_get_ConnectionTimeout( _Connection *iface, LONG *timeout )
 218 {
 219     FIXME( "%p, %p\n", iface, timeout );
 220     return E_NOTIMPL;
 221 }
 222
 223 static HRESULT WINAPI connection_put_ConnectionTimeout( _Connection *iface, LONG timeout )
 224 {
 225     FIXME( "%p, %d\n", iface, timeout );
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI connection_get_Version( _Connection *iface, BSTR *str )
 230 {
 231     FIXME( "%p, %p\n", iface, str );
 232     return E_NOTIMPL;
 233 }
 234
 235 static HRESULT WINAPI connection_Close( _Connection *iface )
 236 {
 237     struct connection *connection = impl_from_Connection( iface );
 238
 239     TRACE( "%p\n", connection );
 240
 241     if (connection->state == adStateClosed) return MAKE_ADO_HRESULT( adErrObjectClosed );
 242
 243     connection->state = adStateClosed;
 244     return S_OK;
 245 }
 246
 247 static HRESULT WINAPI connection_Execute( _Connection *iface, BSTR command, VARIANT *records_affected,
 248                                           LONG options, _Recordset **record_set )
 249 {
 250     FIXME( "%p, %s, %p, %08x, %p\n", iface, debugstr_w(command), records_affected, options, record_set );
 251     return E_NOTIMPL;
 252 }
 253
 254 static HRESULT WINAPI connection_BeginTrans( _Connection *iface, LONG *transaction_level )
 255 {
 256     FIXME( "%p, %p\n", iface, transaction_level );
 257     return E_NOTIMPL;
 258 }
 259
 260 static HRESULT WINAPI connection_CommitTrans( _Connection *iface )
 261 {
 262     FIXME( "%p\n", iface );
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI connection_RollbackTrans( _Connection *iface )
 267 {
 268     FIXME( "%p\n", iface );
 269     return E_NOTIMPL;
 270 }
 271
 272 static HRESULT WINAPI connection_Open( _Connection *iface, BSTR connect_str, BSTR userid, BSTR password,
 273                                        LONG options )
 274 {
 275     struct connection *connection = impl_from_Connection( iface );
 276     FIXME( "%p, %s, %s, %p, %08x\n", iface, debugstr_w(connect_str), debugstr_w(userid),
 277            password, options );
 278
 279     if (connection->state == adStateOpen) return MAKE_ADO_HRESULT( adErrObjectOpen );
 280
 281     connection->state = adStateOpen;
 282     return S_OK;
 283 }
 284
 285 static HRESULT WINAPI connection_get_Errors( _Connection *iface, Errors **obj )
 286 {
 287     FIXME( "%p, %p\n", iface, obj );
 288     return E_NOTIMPL;
 289 }
 290
 291 static HRESULT WINAPI connection_get_DefaultDatabase( _Connection *iface, BSTR *str )
 292 {
 293     FIXME( "%p, %p\n", iface, str );
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI connection_put_DefaultDatabase( _Connection *iface, BSTR str )
 298 {
 299     FIXME( "%p, %s\n", iface, debugstr_w(str) );
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI connection_get_IsolationLevel( _Connection *iface, IsolationLevelEnum *level )
 304 {
 305     FIXME( "%p, %p\n", iface, level );
 306     return E_NOTIMPL;
 307 }
 308
 309 static HRESULT WINAPI connection_put_IsolationLevel( _Connection *iface, IsolationLevelEnum level )
 310 {
 311     FIXME( "%p, %d\n", iface, level );
 312     return E_NOTIMPL;
 313 }
 314
 315 static HRESULT WINAPI connection_get_Attributes( _Connection *iface, LONG *attr )
 316 {
 317     FIXME( "%p, %p\n", iface, attr );
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI connection_put_Attributes( _Connection *iface, LONG attr )
 322 {
 323     FIXME( "%p, %d\n", iface, attr );
 324     return E_NOTIMPL;
 325 }
 326
 327 static HRESULT WINAPI connection_get_CursorLocation( _Connection *iface, CursorLocationEnum *cursor_loc )
 328 {
 329     struct connection *connection = impl_from_Connection( iface );
 330
 331     TRACE( "%p, %p\n", iface, cursor_loc );
 332
 333     *cursor_loc = connection->location;
 334     return S_OK;
 335 }
 336
 337 static HRESULT WINAPI connection_put_CursorLocation( _Connection *iface, CursorLocationEnum cursor_loc )
 338 {
 339     struct connection *connection = impl_from_Connection( iface );
 340
 341     TRACE( "%p, %u\n", iface, cursor_loc );
 342
 343     connection->location = cursor_loc;
 344     return S_OK;
 345 }
 346
 347 static HRESULT WINAPI connection_get_Mode( _Connection *iface, ConnectModeEnum *mode )
 348 {
 349     struct connection *connection = impl_from_Connection( iface );
 350
 351     TRACE( "%p, %p\n", iface, mode );
 352
 353     *mode = connection->mode;
 354     return S_OK;
 355 }
 356
 357 static HRESULT WINAPI connection_put_Mode( _Connection *iface, ConnectModeEnum mode )
 358 {
 359     struct connection *connection = impl_from_Connection( iface );
 360
 361     TRACE( "%p, %u\n", iface, mode );
 362
 363     connection->mode = mode;
 364     return S_OK;
 365 }
 366
 367 static HRESULT WINAPI connection_get_Provider( _Connection *iface, BSTR *str )
 368 {
 369     struct connection *connection = impl_from_Connection( iface );
 370     BSTR provider = NULL;
 371
 372     TRACE( "%p, %p\n", iface, str );
 373
 374     if (connection->provider && !(provider = SysAllocString( connection->provider ))) return E_OUTOFMEMORY;
 375     *str = provider;
 376     return S_OK;
 377 }
 378
 379 static HRESULT WINAPI connection_put_Provider( _Connection *iface, BSTR str )
 380 {
 381     struct connection *connection = impl_from_Connection( iface );
 382     WCHAR *provider = NULL;
 383
 384     TRACE( "%p, %s\n", iface, debugstr_w(str) );
 385
 386     if (!str) return MAKE_ADO_HRESULT(adErrInvalidArgument);
 387
 388     if (!(provider = strdupW( str ))) return E_OUTOFMEMORY;
 389     heap_free( connection->provider );
 390     connection->provider = provider;
 391     return S_OK;
 392 }
 393
 394 static HRESULT WINAPI connection_get_State( _Connection *iface, LONG *state )
 395 {
 396     struct connection *connection = impl_from_Connection( iface );
 397     TRACE( "%p, %p\n", connection, state );
 398     *state = connection->state;
 399     return S_OK;
 400 }
 401
 402 static HRESULT WINAPI connection_OpenSchema( _Connection *iface, SchemaEnum schema, VARIANT restrictions,
 403                                              VARIANT schema_id, _Recordset **record_set )
 404 {
 405     FIXME( "%p, %d, %s, %s, %p\n", iface, schema, debugstr_variant(&restrictions),
 406            debugstr_variant(&schema_id), record_set );
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI connection_Cancel( _Connection *iface )
 411 {
 412     FIXME( "%p\n", iface );
 413     return E_NOTIMPL;
 414 }
 415
 416 static const struct _ConnectionVtbl connection_vtbl =
 417 {
 418     connection_QueryInterface,
 419     connection_AddRef,
 420     connection_Release,
 421     connection_GetTypeInfoCount,
 422     connection_GetTypeInfo,
 423     connection_GetIDsOfNames,
 424     connection_Invoke,
 425     connection_get_Properties,
 426     connection_get_ConnectionString,
 427     connection_put_ConnectionString,
 428     connection_get_CommandTimeout,
 429     connection_put_CommandTimeout,
 430     connection_get_ConnectionTimeout,
 431     connection_put_ConnectionTimeout,
 432     connection_get_Version,
 433     connection_Close,
 434     connection_Execute,
 435     connection_BeginTrans,
 436     connection_CommitTrans,
 437     connection_RollbackTrans,
 438     connection_Open,
 439     connection_get_Errors,
 440     connection_get_DefaultDatabase,
 441     connection_put_DefaultDatabase,
 442     connection_get_IsolationLevel,
 443     connection_put_IsolationLevel,
 444     connection_get_Attributes,
 445     connection_put_Attributes,
 446     connection_get_CursorLocation,
 447     connection_put_CursorLocation,
 448     connection_get_Mode,
 449     connection_put_Mode,
 450     connection_get_Provider,
 451     connection_put_Provider,
 452     connection_get_State,
 453     connection_OpenSchema,
 454     connection_Cancel
 455 };
 456
 457 static HRESULT WINAPI supporterror_QueryInterface( ISupportErrorInfo *iface, REFIID riid, void **obj )
 458 {
 459     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 460     return connection_QueryInterface( &connection->Connection_iface, riid, obj );
 461 }
 462
 463 static ULONG WINAPI supporterror_AddRef( ISupportErrorInfo *iface )
 464 {
 465     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 466     return connection_AddRef( &connection->Connection_iface );
 467 }
 468
 469 static ULONG WINAPI supporterror_Release( ISupportErrorInfo *iface )
 470 {
 471     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 472     return connection_Release( &connection->Connection_iface );
 473 }
 474
 475 static HRESULT WINAPI supporterror_InterfaceSupportsErrorInfo( ISupportErrorInfo *iface, REFIID riid )
 476 {
 477     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 478     FIXME( "%p, %s\n", connection, debugstr_guid(riid) );
 479     return S_FALSE;
 480 }
 481
 482 static const struct ISupportErrorInfoVtbl support_error_vtbl =
 483 {
 484     supporterror_QueryInterface,
 485     supporterror_AddRef,
 486     supporterror_Release,
 487     supporterror_InterfaceSupportsErrorInfo
 488 };
 489
 490 static HRESULT WINAPI connpointcontainer_QueryInterface( IConnectionPointContainer *iface,
 491         REFIID riid, void **obj )
 492 {
 493     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 494     return connection_QueryInterface( &connection->Connection_iface, riid, obj );
 495 }
 496
 497 static ULONG WINAPI connpointcontainer_AddRef( IConnectionPointContainer *iface )
 498 {
 499     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 500     return connection_AddRef( &connection->Connection_iface );
 501 }
 502
 503 static ULONG WINAPI connpointcontainer_Release( IConnectionPointContainer *iface )
 504 {
 505     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 506     return connection_Release( &connection->Connection_iface );
 507 }
 508
 509 static HRESULT WINAPI connpointcontainer_EnumConnectionPoints( IConnectionPointContainer *iface,
 510         IEnumConnectionPoints **points )
 511 {
 512     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 513     FIXME( "%p, %p\n", connection, points );
 514     return E_NOTIMPL;
 515 }
 516
 517 static HRESULT WINAPI connpointcontainer_FindConnectionPoint( IConnectionPointContainer *iface,
 518         REFIID riid, IConnectionPoint **point )
 519 {
 520     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 521
 522     TRACE( "%p, %s %p\n", connection, debugstr_guid( riid ), point );
 523
 524     if (!point) return E_POINTER;
 525
 526     if (IsEqualIID( riid, connection->cp_connev.riid ))
 527     {
 528         *point = &connection->cp_connev.IConnectionPoint_iface;
 529         IConnectionPoint_AddRef( *point );
 530         return S_OK;
 531     }
 532
 533     FIXME( "unsupported connection point %s\n", debugstr_guid( riid ) );
 534     return CONNECT_E_NOCONNECTION;
 535 }
 536
 537 static const struct IConnectionPointContainerVtbl connpointcontainer_vtbl =
 538 {
 539     connpointcontainer_QueryInterface,
 540     connpointcontainer_AddRef,
 541     connpointcontainer_Release,
 542     connpointcontainer_EnumConnectionPoints,
 543     connpointcontainer_FindConnectionPoint
 544 };
 545
 546 static HRESULT WINAPI connpoint_QueryInterface( IConnectionPoint *iface, REFIID riid, void **obj )
 547 {
 548     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 549
 550     if (IsEqualGUID( &IID_IUnknown, riid ) || IsEqualGUID( &IID_IConnectionPoint, riid ))
 551     {
 552         *obj = &connpoint->IConnectionPoint_iface;
 553     }
 554     else
 555     {
 556         FIXME( "interface %s not implemented\n", debugstr_guid( riid ) );
 557         return E_NOINTERFACE;
 558     }
 559
 560     connection_AddRef( &connpoint->conn->Connection_iface );
 561     return S_OK;
 562 }
 563
 564 static ULONG WINAPI connpoint_AddRef( IConnectionPoint *iface )
 565 {
 566     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 567     return IConnectionPointContainer_AddRef( &connpoint->conn->IConnectionPointContainer_iface );
 568 }
 569
 570 static ULONG WINAPI connpoint_Release( IConnectionPoint *iface )
 571 {
 572     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 573     return IConnectionPointContainer_Release( &connpoint->conn->IConnectionPointContainer_iface );
 574 }
 575
 576 static HRESULT WINAPI connpoint_GetConnectionInterface( IConnectionPoint *iface, IID *iid )
 577 {
 578     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 579     FIXME( "%p, %p\n", connpoint, iid );
 580     return E_NOTIMPL;
 581 }
 582
 583 static HRESULT WINAPI connpoint_GetConnectionPointContainer( IConnectionPoint *iface,
 584         IConnectionPointContainer **container )
 585 {
 586     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 587     FIXME( "%p, %p\n", connpoint, container );
 588     return E_NOTIMPL;
 589 }
 590
 591 static HRESULT WINAPI connpoint_Advise( IConnectionPoint *iface, IUnknown *unk_sink,
 592         DWORD *cookie )
 593 {
 594     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 595     IUnknown *sink, **tmp;
 596     ULONG new_size;
 597     HRESULT hr;
 598     DWORD i;
 599
 600     TRACE( "%p, %p, %p\n", iface, unk_sink, cookie );
 601
 602     if (!unk_sink || !cookie) return E_FAIL;
 603
 604     if (FAILED(hr = IUnknown_QueryInterface( unk_sink, &IID_ConnectionEventsVt, (void**)&sink )))
 605     {
 606         *cookie = 0;
 607         return E_FAIL;
 608     }
 609
 610     if (connpoint->sinks)
 611     {
 612         for (i = 0; i < connpoint->sinks_size; ++i)
 613         {
 614             if (!connpoint->sinks[i])
 615                 break;
 616         }
 617
 618         if (i == connpoint->sinks_size)
 619         {
 620             new_size = connpoint->sinks_size * 2;
 621             if (!(tmp = heap_realloc_zero( connpoint->sinks, new_size * sizeof(*connpoint->sinks) )))
 622                 return E_OUTOFMEMORY;
 623             connpoint->sinks = tmp;
 624             connpoint->sinks_size = new_size;
 625         }
 626     }
 627     else
 628     {
 629         if (!(connpoint->sinks = heap_alloc_zero( sizeof(*connpoint->sinks) ))) return E_OUTOFMEMORY;
 630         connpoint->sinks_size = 1;
 631         i = 0;
 632     }
 633
 634     connpoint->sinks[i] = sink;
 635     *cookie = i + 1;
 636     return S_OK;
 637 }
 638
 639 static HRESULT WINAPI connpoint_Unadvise( IConnectionPoint *iface, DWORD cookie )
 640 {
 641     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 642     TRACE( "%p, %u\n", connpoint, cookie );
 643
 644     if (!cookie || cookie > connpoint->sinks_size || !connpoint->sinks || !connpoint->sinks[cookie - 1])
 645         return E_FAIL;
 646
 647     IUnknown_Release( connpoint->sinks[cookie - 1] );
 648     connpoint->sinks[cookie - 1] = NULL;
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI connpoint_EnumConnections( IConnectionPoint *iface,
 653         IEnumConnections **points )
 654 {
 655     struct connection_point *connpoint = impl_from_IConnectionPoint( iface );
 656     FIXME( "%p, %p\n", connpoint, points );
 657     return E_NOTIMPL;
 658 }
 659
 660 static const IConnectionPointVtbl connpoint_vtbl =
 661 {
 662     connpoint_QueryInterface,
 663     connpoint_AddRef,
 664     connpoint_Release,
 665     connpoint_GetConnectionInterface,
 666     connpoint_GetConnectionPointContainer,
 667     connpoint_Advise,
 668     connpoint_Unadvise,
 669     connpoint_EnumConnections
 670 };
 671
 672 HRESULT Connection_create( void **obj )
 673 {
 674     struct connection *connection;
 675
 676     if (!(connection = heap_alloc( sizeof(*connection) ))) return E_OUTOFMEMORY;
 677     connection->Connection_iface.lpVtbl = &connection_vtbl;
 678     connection->ISupportErrorInfo_iface.lpVtbl = &support_error_vtbl;
 679     connection->IConnectionPointContainer_iface.lpVtbl = &connpointcontainer_vtbl;
 680     connection->refs = 1;
 681     connection->state = adStateClosed;
 682     connection->timeout = 30;
 683     connection->datasource = NULL;
 684     if (!(connection->provider = strdupW( L"MSDASQL" )))
 685     {
 686         heap_free( connection );
 687         return E_OUTOFMEMORY;
 688     }
 689     connection->mode = adModeUnknown;
 690     connection->location = adUseServer;
 691
 692     connection->cp_connev.conn = connection;
 693     connection->cp_connev.riid = &DIID_ConnectionEvents;
 694     connection->cp_connev.IConnectionPoint_iface.lpVtbl = &connpoint_vtbl;
 695     connection->cp_connev.sinks = NULL;
 696     connection->cp_connev.sinks_size = 0;
 697
 698     *obj = &connection->Connection_iface;
 699     TRACE( "returning iface %p\n", *obj );
 700     return S_OK;
 701 }