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 "msado15_backcompat.h"
  27
  28 #include "wine/debug.h"
  29 #include "wine/heap.h"
  30
  31 #include "msado15_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msado15);
  34
  35 struct connection
  36 {
  37     _Connection               Connection_iface;
  38     ISupportErrorInfo         ISupportErrorInfo_iface;
  39     IConnectionPointContainer IConnectionPointContainer_iface;
  40     LONG                      refs;
  41     ObjectStateEnum           state;
  42     LONG                      timeout;
  43     WCHAR                    *datasource;
  44 };
  45
  46 static inline struct connection *impl_from_Connection( _Connection *iface )
  47 {
  48     return CONTAINING_RECORD( iface, struct connection, Connection_iface );
  49 }
  50
  51 static inline struct connection *impl_from_ISupportErrorInfo( ISupportErrorInfo *iface )
  52 {
  53     return CONTAINING_RECORD( iface, struct connection, ISupportErrorInfo_iface );
  54 }
  55
  56 static inline struct connection *impl_from_IConnectionPointContainer( IConnectionPointContainer *iface )
  57 {
  58     return CONTAINING_RECORD( iface, struct connection, IConnectionPointContainer_iface );
  59 }
  60
  61 static ULONG WINAPI connection_AddRef( _Connection *iface )
  62 {
  63     struct connection *connection = impl_from_Connection( iface );
  64     return InterlockedIncrement( &connection->refs );
  65 }
  66
  67 static ULONG WINAPI connection_Release( _Connection *iface )
  68 {
  69     struct connection *connection = impl_from_Connection( iface );
  70     LONG refs = InterlockedDecrement( &connection->refs );
  71     if (!refs)
  72     {
  73         TRACE( "destroying %p\n", connection );
  74         heap_free( connection->datasource );
  75         heap_free( connection );
  76     }
  77     return refs;
  78 }
  79
  80 static HRESULT WINAPI connection_QueryInterface( _Connection *iface, REFIID riid, void **obj )
  81 {
  82     struct connection *connection = impl_from_Connection( iface );
  83     TRACE( "%p, %s, %p\n", connection, debugstr_guid(riid), obj );
  84
  85     if (IsEqualGUID( riid, &IID__Connection ) || IsEqualGUID( riid, &IID_IDispatch ) ||
  86         IsEqualGUID( riid, &IID_IUnknown ))
  87     {
  88         *obj = iface;
  89     }
  90     else if(IsEqualGUID( riid, &IID_ISupportErrorInfo ))
  91     {
  92         *obj = &connection->ISupportErrorInfo_iface;
  93     }
  94     else if (IsEqualGUID( riid, &IID_IConnectionPointContainer ))
  95     {
  96         *obj = &connection->IConnectionPointContainer_iface;
  97     }
  98     else
  99     {
 100         FIXME( "interface %s not implemented\n", debugstr_guid(riid) );
 101         return E_NOINTERFACE;
 102     }
 103     connection_AddRef( iface );
 104     return S_OK;
 105 }
 106
 107 static HRESULT WINAPI connection_GetTypeInfoCount( _Connection *iface, UINT *count )
 108 {
 109     FIXME( "%p, %p\n", iface, count );
 110     return E_NOTIMPL;
 111 }
 112
 113 static HRESULT WINAPI connection_GetTypeInfo( _Connection *iface, UINT index, LCID lcid, ITypeInfo **info )
 114 {
 115     FIXME( "%p, %u, %u, %p\n", iface, index, lcid, info );
 116     return E_NOTIMPL;
 117 }
 118
 119 static HRESULT WINAPI connection_GetIDsOfNames( _Connection *iface, REFIID riid, LPOLESTR *names, UINT count,
 120                                                 LCID lcid, DISPID *dispid )
 121 {
 122     FIXME( "%p, %s, %p, %u, %u, %p\n", iface, debugstr_guid(riid), names, count, lcid, dispid );
 123     return E_NOTIMPL;
 124 }
 125
 126 static HRESULT WINAPI connection_Invoke( _Connection *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
 127                                          DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep_info, UINT *arg_err )
 128 {
 129     FIXME( "%p, %d, %s, %d, %d, %p, %p, %p, %p\n", iface, member, debugstr_guid(riid), lcid, flags, params,
 130            result, excep_info, arg_err );
 131     return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI connection_get_Properties( _Connection *iface, Properties **obj )
 135 {
 136     FIXME( "%p, %p\n", iface, obj );
 137     return E_NOTIMPL;
 138 }
 139
 140 static HRESULT WINAPI connection_get_ConnectionString( _Connection *iface, BSTR *str )
 141 {
 142     struct connection *connection = impl_from_Connection( iface );
 143     BSTR source = NULL;
 144
 145     TRACE( "%p, %p\n", connection, str );
 146
 147     if (connection->datasource && !(source = SysAllocString( connection->datasource ))) return E_OUTOFMEMORY;
 148     *str = source;
 149     return S_OK;
 150 }
 151
 152 static HRESULT WINAPI connection_put_ConnectionString( _Connection *iface, BSTR str )
 153 {
 154     struct connection *connection = impl_from_Connection( iface );
 155     WCHAR *source = NULL;
 156
 157     TRACE( "%p, %s\n", connection, debugstr_w( !wcsstr( str, L"Password" ) ? L"<hidden>" : str ) );
 158
 159     if (str && !(source = strdupW( str ))) return E_OUTOFMEMORY;
 160     heap_free( connection->datasource );
 161     connection->datasource = source;
 162     return S_OK;
 163 }
 164
 165 static HRESULT WINAPI connection_get_CommandTimeout( _Connection *iface, LONG *timeout )
 166 {
 167     struct connection *connection = impl_from_Connection( iface );
 168     TRACE( "%p, %p\n", connection, timeout );
 169     *timeout = connection->timeout;
 170     return S_OK;
 171 }
 172
 173 static HRESULT WINAPI connection_put_CommandTimeout( _Connection *iface, LONG timeout )
 174 {
 175     struct connection *connection = impl_from_Connection( iface );
 176     TRACE( "%p, %d\n", connection, timeout );
 177     connection->timeout = timeout;
 178     return S_OK;
 179 }
 180
 181 static HRESULT WINAPI connection_get_ConnectionTimeout( _Connection *iface, LONG *timeout )
 182 {
 183     FIXME( "%p, %p\n", iface, timeout );
 184     return E_NOTIMPL;
 185 }
 186
 187 static HRESULT WINAPI connection_put_ConnectionTimeout( _Connection *iface, LONG timeout )
 188 {
 189     FIXME( "%p, %d\n", iface, timeout );
 190     return E_NOTIMPL;
 191 }
 192
 193 static HRESULT WINAPI connection_get_Version( _Connection *iface, BSTR *str )
 194 {
 195     FIXME( "%p, %p\n", iface, str );
 196     return E_NOTIMPL;
 197 }
 198
 199 static HRESULT WINAPI connection_Close( _Connection *iface )
 200 {
 201     FIXME( "%p\n", iface );
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI connection_Execute( _Connection *iface, BSTR command, VARIANT *records_affected,
 206                                           LONG options, _Recordset **record_set )
 207 {
 208     FIXME( "%p, %s, %p, %08x, %p\n", iface, debugstr_w(command), records_affected, options, record_set );
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI connection_BeginTrans( _Connection *iface, LONG *transaction_level )
 213 {
 214     FIXME( "%p, %p\n", iface, transaction_level );
 215     return E_NOTIMPL;
 216 }
 217
 218 static HRESULT WINAPI connection_CommitTrans( _Connection *iface )
 219 {
 220     FIXME( "%p\n", iface );
 221     return E_NOTIMPL;
 222 }
 223
 224 static HRESULT WINAPI connection_RollbackTrans( _Connection *iface )
 225 {
 226     FIXME( "%p\n", iface );
 227     return E_NOTIMPL;
 228 }
 229
 230 static HRESULT WINAPI connection_Open( _Connection *iface, BSTR connect_str, BSTR userid, BSTR password,
 231                                        LONG options )
 232 {
 233     FIXME( "%p, %s, %s, %p, %08x\n", iface, debugstr_w(connect_str), debugstr_w(userid),
 234            password, options );
 235     return E_NOTIMPL;
 236 }
 237
 238 static HRESULT WINAPI connection_get_Errors( _Connection *iface, Errors **obj )
 239 {
 240     FIXME( "%p, %p\n", iface, obj );
 241     return E_NOTIMPL;
 242 }
 243
 244 static HRESULT WINAPI connection_get_DefaultDatabase( _Connection *iface, BSTR *str )
 245 {
 246     FIXME( "%p, %p\n", iface, str );
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI connection_put_DefaultDatabase( _Connection *iface, BSTR str )
 251 {
 252     FIXME( "%p, %s\n", iface, debugstr_w(str) );
 253     return E_NOTIMPL;
 254 }
 255
 256 static HRESULT WINAPI connection_get_IsolationLevel( _Connection *iface, IsolationLevelEnum *level )
 257 {
 258     FIXME( "%p, %p\n", iface, level );
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI connection_put_IsolationLevel( _Connection *iface, IsolationLevelEnum level )
 263 {
 264     FIXME( "%p, %d\n", iface, level );
 265     return E_NOTIMPL;
 266 }
 267
 268 static HRESULT WINAPI connection_get_Attributes( _Connection *iface, LONG *attr )
 269 {
 270     FIXME( "%p, %p\n", iface, attr );
 271     return E_NOTIMPL;
 272 }
 273
 274 static HRESULT WINAPI connection_put_Attributes( _Connection *iface, LONG attr )
 275 {
 276     FIXME( "%p, %d\n", iface, attr );
 277     return E_NOTIMPL;
 278 }
 279
 280 static HRESULT WINAPI connection_get_CursorLocation( _Connection *iface, CursorLocationEnum *cursor_loc )
 281 {
 282     FIXME( "%p, %p\n", iface, cursor_loc );
 283     return E_NOTIMPL;
 284 }
 285
 286 static HRESULT WINAPI connection_put_CursorLocation( _Connection *iface, CursorLocationEnum cursor_loc )
 287 {
 288     FIXME( "%p, %u\n", iface, cursor_loc );
 289     return E_NOTIMPL;
 290 }
 291
 292 static HRESULT WINAPI connection_get_Mode( _Connection *iface, ConnectModeEnum *mode )
 293 {
 294     FIXME( "%p, %p\n", iface, mode );
 295     return E_NOTIMPL;
 296 }
 297
 298 static HRESULT WINAPI connection_put_Mode( _Connection *iface, ConnectModeEnum mode )
 299 {
 300     FIXME( "%p, %u\n", iface, mode );
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI connection_get_Provider( _Connection *iface, BSTR *str )
 305 {
 306     FIXME( "%p, %p\n", iface, str );
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI connection_put_Provider( _Connection *iface, BSTR str )
 311 {
 312     FIXME( "%p, %s\n", iface, debugstr_w(str) );
 313     return E_NOTIMPL;
 314 }
 315
 316 static HRESULT WINAPI connection_get_State( _Connection *iface, LONG *state )
 317 {
 318     struct connection *connection = impl_from_Connection( iface );
 319     TRACE( "%p, %p\n", connection, state );
 320     *state = connection->state;
 321     return S_OK;
 322 }
 323
 324 static HRESULT WINAPI connection_OpenSchema( _Connection *iface, SchemaEnum schema, VARIANT restrictions,
 325                                              VARIANT schema_id, _Recordset **record_set )
 326 {
 327     FIXME( "%p, %d, %s, %s, %p\n", iface, schema, debugstr_variant(&restrictions),
 328            debugstr_variant(&schema_id), record_set );
 329     return E_NOTIMPL;
 330 }
 331
 332 static HRESULT WINAPI connection_Cancel( _Connection *iface )
 333 {
 334     FIXME( "%p\n", iface );
 335     return E_NOTIMPL;
 336 }
 337
 338 static const struct _ConnectionVtbl connection_vtbl =
 339 {
 340     connection_QueryInterface,
 341     connection_AddRef,
 342     connection_Release,
 343     connection_GetTypeInfoCount,
 344     connection_GetTypeInfo,
 345     connection_GetIDsOfNames,
 346     connection_Invoke,
 347     connection_get_Properties,
 348     connection_get_ConnectionString,
 349     connection_put_ConnectionString,
 350     connection_get_CommandTimeout,
 351     connection_put_CommandTimeout,
 352     connection_get_ConnectionTimeout,
 353     connection_put_ConnectionTimeout,
 354     connection_get_Version,
 355     connection_Close,
 356     connection_Execute,
 357     connection_BeginTrans,
 358     connection_CommitTrans,
 359     connection_RollbackTrans,
 360     connection_Open,
 361     connection_get_Errors,
 362     connection_get_DefaultDatabase,
 363     connection_put_DefaultDatabase,
 364     connection_get_IsolationLevel,
 365     connection_put_IsolationLevel,
 366     connection_get_Attributes,
 367     connection_put_Attributes,
 368     connection_get_CursorLocation,
 369     connection_put_CursorLocation,
 370     connection_get_Mode,
 371     connection_put_Mode,
 372     connection_get_Provider,
 373     connection_put_Provider,
 374     connection_get_State,
 375     connection_OpenSchema,
 376     connection_Cancel
 377 };
 378
 379 static HRESULT WINAPI supporterror_QueryInterface( ISupportErrorInfo *iface, REFIID riid, void **obj )
 380 {
 381     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 382     return connection_QueryInterface( &connection->Connection_iface, riid, obj );
 383 }
 384
 385 static ULONG WINAPI supporterror_AddRef( ISupportErrorInfo *iface )
 386 {
 387     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 388     return connection_AddRef( &connection->Connection_iface );
 389 }
 390
 391 static ULONG WINAPI supporterror_Release( ISupportErrorInfo *iface )
 392 {
 393     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 394     return connection_Release( &connection->Connection_iface );
 395 }
 396
 397 static HRESULT WINAPI supporterror_InterfaceSupportsErrorInfo( ISupportErrorInfo *iface, REFIID riid )
 398 {
 399     struct connection *connection = impl_from_ISupportErrorInfo( iface );
 400     FIXME( "%p, %s\n", connection, debugstr_guid(riid) );
 401     return S_FALSE;
 402 }
 403
 404 static const struct ISupportErrorInfoVtbl support_error_vtbl =
 405 {
 406     supporterror_QueryInterface,
 407     supporterror_AddRef,
 408     supporterror_Release,
 409     supporterror_InterfaceSupportsErrorInfo
 410 };
 411
 412 static HRESULT WINAPI connpointcontainer_QueryInterface( IConnectionPointContainer *iface,
 413         REFIID riid, void **obj )
 414 {
 415     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 416     return connection_QueryInterface( &connection->Connection_iface, riid, obj );
 417 }
 418
 419 static ULONG WINAPI connpointcontainer_AddRef( IConnectionPointContainer *iface )
 420 {
 421     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 422     return connection_AddRef( &connection->Connection_iface );
 423 }
 424
 425 static ULONG WINAPI connpointcontainer_Release( IConnectionPointContainer *iface )
 426 {
 427     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 428     return connection_Release( &connection->Connection_iface );
 429 }
 430
 431 static HRESULT WINAPI connpointcontainer_EnumConnectionPoints( IConnectionPointContainer *iface,
 432         IEnumConnectionPoints **points )
 433 {
 434     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 435     FIXME( "%p, %p\n", connection, points );
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI connpointcontainer_FindConnectionPoint( IConnectionPointContainer *iface,
 440         REFIID riid, IConnectionPoint **point )
 441 {
 442     struct connection *connection = impl_from_IConnectionPointContainer( iface );
 443     FIXME( "%p, %s, %p\n", connection, debugstr_guid( riid ), point );
 444     return E_NOTIMPL;
 445 }
 446
 447 static const struct IConnectionPointContainerVtbl connpointcontainer_vtbl =
 448 {
 449     connpointcontainer_QueryInterface,
 450     connpointcontainer_AddRef,
 451     connpointcontainer_Release,
 452     connpointcontainer_EnumConnectionPoints,
 453     connpointcontainer_FindConnectionPoint
 454 };
 455
 456 HRESULT Connection_create( void **obj )
 457 {
 458     struct connection *connection;
 459
 460     if (!(connection = heap_alloc( sizeof(*connection) ))) return E_OUTOFMEMORY;
 461     connection->Connection_iface.lpVtbl = &connection_vtbl;
 462     connection->ISupportErrorInfo_iface.lpVtbl = &support_error_vtbl;
 463     connection->IConnectionPointContainer_iface.lpVtbl = &connpointcontainer_vtbl;
 464     connection->refs = 1;
 465     connection->state = adStateClosed;
 466     connection->timeout = 30;
 467     connection->datasource = NULL;
 468
 469     *obj = &connection->Connection_iface;
 470     TRACE( "returning iface %p\n", *obj );
 471     return S_OK;
 472 }