dlls/rpcrt4/ndr_contexthandle.c

   1 /*
   2  * NDR data marshalling
   3  *
   4  * Copyright 2006 Mike McCormack (for CodeWeavers)
   5  * Copyright 2006-2007 Robert Shearman (for CodeWeavers)
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdlib.h>
  23
  24 #include "ndr_misc.h"
  25 #include "rpc_assoc.h"
  26 #include "rpcndr.h"
  27 #include "cguid.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/list.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  33
  34 #define NDR_CONTEXT_HANDLE_MAGIC 0x4352444e
  35
  36 typedef struct ndr_context_handle
  37 {
  38     ULONG      attributes;
  39     GUID       uuid;
  40 } ndr_context_handle;
  41
  42 struct context_handle_entry
  43 {
  44     struct list entry;
  45     DWORD magic;
  46     RPC_BINDING_HANDLE handle;
  47     ndr_context_handle wire_data;
  48 };
  49
  50 static struct list context_handle_list = LIST_INIT(context_handle_list);
  51
  52 static CRITICAL_SECTION ndr_context_cs;
  53 static CRITICAL_SECTION_DEBUG ndr_context_debug =
  54 {
  55     0, 0, &ndr_context_cs,
  56     { &ndr_context_debug.ProcessLocksList, &ndr_context_debug.ProcessLocksList },
  57       0, 0, { (DWORD_PTR)(__FILE__ ": ndr_context") }
  58 };
  59 static CRITICAL_SECTION ndr_context_cs = { &ndr_context_debug, -1, 0, 0, 0, 0 };
  60
  61 static struct context_handle_entry *get_context_entry(NDR_CCONTEXT CContext)
  62 {
  63     struct context_handle_entry *che = CContext;
  64
  65     if (che->magic != NDR_CONTEXT_HANDLE_MAGIC)
  66         return NULL;
  67     return che;
  68 }
  69
  70 static struct context_handle_entry *context_entry_from_guid(LPCGUID uuid)
  71 {
  72     struct context_handle_entry *che;
  73     LIST_FOR_EACH_ENTRY(che, &context_handle_list, struct context_handle_entry, entry)
  74         if (IsEqualGUID(&che->wire_data.uuid, uuid))
  75             return che;
  76     return NULL;
  77 }
  78
  79 RPC_BINDING_HANDLE WINAPI NDRCContextBinding(NDR_CCONTEXT CContext)
  80 {
  81     struct context_handle_entry *che;
  82     RPC_BINDING_HANDLE handle = NULL;
  83
  84     TRACE("%p\n", CContext);
  85
  86     EnterCriticalSection(&ndr_context_cs);
  87     che = get_context_entry(CContext);
  88     if (che)
  89         handle = che->handle;
  90     LeaveCriticalSection(&ndr_context_cs);
  91
  92     if (!handle)
  93     {
  94         ERR("invalid handle %p\n", CContext);
  95         RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
  96     }
  97     return handle;
  98 }
  99
 100 void WINAPI NDRCContextMarshall(NDR_CCONTEXT CContext, void *pBuff)
 101 {
 102     struct context_handle_entry *che;
 103
 104     TRACE("%p %p\n", CContext, pBuff);
 105
 106     if (CContext)
 107     {
 108         EnterCriticalSection(&ndr_context_cs);
 109         che = get_context_entry(CContext);
 110         memcpy(pBuff, &che->wire_data, sizeof (ndr_context_handle));
 111         LeaveCriticalSection(&ndr_context_cs);
 112     }
 113     else
 114     {
 115         ndr_context_handle *wire_data = pBuff;
 116         wire_data->attributes = 0;
 117         wire_data->uuid = GUID_NULL;
 118     }
 119 }
 120
 121 /***********************************************************************
 122  *           RpcSmDestroyClientContext [RPCRT4.@]
 123  */
 124 RPC_STATUS WINAPI RpcSmDestroyClientContext(void **ContextHandle)
 125 {
 126     RPC_STATUS status = RPC_X_SS_CONTEXT_MISMATCH;
 127     struct context_handle_entry *che = NULL;
 128
 129     TRACE("(%p)\n", ContextHandle);
 130
 131     EnterCriticalSection(&ndr_context_cs);
 132     che = get_context_entry(*ContextHandle);
 133     *ContextHandle = NULL;
 134     if (che)
 135     {
 136         status = RPC_S_OK;
 137         list_remove(&che->entry);
 138     }
 139
 140     LeaveCriticalSection(&ndr_context_cs);
 141
 142     if (che)
 143     {
 144         RpcBindingFree(&che->handle);
 145         free(che);
 146     }
 147
 148     return status;
 149 }
 150
 151 /***********************************************************************
 152  *           RpcSsDestroyClientContext [RPCRT4.@]
 153  */
 154 void WINAPI RpcSsDestroyClientContext(void **ContextHandle)
 155 {
 156     RPC_STATUS status = RpcSmDestroyClientContext(ContextHandle);
 157     if (status != RPC_S_OK)
 158         RpcRaiseException(status);
 159 }
 160
 161 /***********************************************************************
 162  *           RpcSsDontSerializeContext [RPCRT4.@]
 163  */
 164  void WINAPI RpcSsDontSerializeContext(void)
 165 {
 166     FIXME("stub\n");
 167 }
 168
 169 static RPC_STATUS ndr_update_context_handle(NDR_CCONTEXT *CContext,
 170                                       RPC_BINDING_HANDLE hBinding,
 171                                       const ndr_context_handle *chi)
 172 {
 173     struct context_handle_entry *che = NULL;
 174
 175     /* a null UUID means we should free the context handle */
 176     if (IsEqualGUID(&chi->uuid, &GUID_NULL))
 177     {
 178         if (*CContext)
 179         {
 180             che = get_context_entry(*CContext);
 181             if (!che)
 182                 return RPC_X_SS_CONTEXT_MISMATCH;
 183             list_remove(&che->entry);
 184             RpcBindingFree(&che->handle);
 185             free(che);
 186             che = NULL;
 187         }
 188     }
 189     /* if there's no existing entry matching the GUID, allocate one */
 190     else if (!(che = context_entry_from_guid(&chi->uuid)))
 191     {
 192         che = malloc(sizeof *che);
 193         if (!che)
 194             return RPC_X_NO_MEMORY;
 195         che->magic = NDR_CONTEXT_HANDLE_MAGIC;
 196         RpcBindingCopy(hBinding, &che->handle);
 197         list_add_tail(&context_handle_list, &che->entry);
 198         che->wire_data = *chi;
 199     }
 200
 201     *CContext = che;
 202
 203     return RPC_S_OK;
 204 }
 205
 206 /***********************************************************************
 207  *           NDRCContextUnmarshall [RPCRT4.@]
 208  */
 209 void WINAPI NDRCContextUnmarshall(NDR_CCONTEXT *CContext,
 210                                   RPC_BINDING_HANDLE hBinding,
 211                                   void *pBuff, ULONG DataRepresentation)
 212 {
 213     RPC_STATUS status;
 214
 215     TRACE("*%p=(%p) %p %p %08lx\n",
 216           CContext, *CContext, hBinding, pBuff, DataRepresentation);
 217
 218     EnterCriticalSection(&ndr_context_cs);
 219     status = ndr_update_context_handle(CContext, hBinding, pBuff);
 220     LeaveCriticalSection(&ndr_context_cs);
 221     if (status)
 222         RpcRaiseException(status);
 223 }
 224
 225 /***********************************************************************
 226  *           NDRSContextMarshall [RPCRT4.@]
 227  */
 228 void WINAPI NDRSContextMarshall(NDR_SCONTEXT SContext,
 229                                void *pBuff,
 230                                NDR_RUNDOWN userRunDownIn)
 231 {
 232     TRACE("(%p %p %p)\n", SContext, pBuff, userRunDownIn);
 233     NDRSContextMarshall2(I_RpcGetCurrentCallHandle(), SContext, pBuff,
 234                          userRunDownIn, NULL, RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
 235 }
 236
 237 /***********************************************************************
 238  *           NDRSContextMarshallEx [RPCRT4.@]
 239  */
 240 void WINAPI NDRSContextMarshallEx(RPC_BINDING_HANDLE hBinding,
 241                                   NDR_SCONTEXT SContext,
 242                                   void *pBuff,
 243                                   NDR_RUNDOWN userRunDownIn)
 244 {
 245     TRACE("(%p %p %p %p)\n", hBinding, SContext, pBuff, userRunDownIn);
 246     NDRSContextMarshall2(hBinding, SContext, pBuff, userRunDownIn, NULL,
 247                          RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
 248 }
 249
 250 /***********************************************************************
 251  *           NDRSContextMarshall2 [RPCRT4.@]
 252  */
 253 void WINAPI NDRSContextMarshall2(RPC_BINDING_HANDLE hBinding,
 254                                  NDR_SCONTEXT SContext,
 255                                  void *pBuff,
 256                                  NDR_RUNDOWN userRunDownIn,
 257                                  void *CtxGuard, ULONG Flags)
 258 {
 259     RpcBinding *binding = hBinding;
 260     RPC_STATUS status;
 261     ndr_context_handle *ndr = pBuff;
 262
 263     TRACE("(%p %p %p %p %p %lu)\n",
 264           hBinding, SContext, pBuff, userRunDownIn, CtxGuard, Flags);
 265
 266     if (!binding->server || !binding->Assoc)
 267         RpcRaiseException(RPC_S_INVALID_BINDING);
 268
 269     if (SContext->userContext)
 270     {
 271         status = RpcServerAssoc_UpdateContextHandle(binding->Assoc, SContext, CtxGuard, userRunDownIn);
 272         if (status != RPC_S_OK)
 273             RpcRaiseException(status);
 274         ndr->attributes = 0;
 275         RpcContextHandle_GetUuid(SContext, &ndr->uuid);
 276
 277         RPCRT4_RemoveThreadContextHandle(SContext);
 278         RpcServerAssoc_ReleaseContextHandle(binding->Assoc, SContext, TRUE);
 279     }
 280     else
 281     {
 282         if (!RpcContextHandle_IsGuardCorrect(SContext, CtxGuard))
 283             RpcRaiseException(RPC_X_SS_CONTEXT_MISMATCH);
 284         memset(ndr, 0, sizeof(*ndr));
 285
 286         RPCRT4_RemoveThreadContextHandle(SContext);
 287         /* Note: release the context handle twice in this case to release
 288          * one ref being kept around for the data and one ref for the
 289          * unmarshall/marshall sequence */
 290         if (!RpcServerAssoc_ReleaseContextHandle(binding->Assoc, SContext, TRUE))
 291             return; /* this is to cope with the case of the data not being valid
 292                      * before and so not having a further reference */
 293         RpcServerAssoc_ReleaseContextHandle(binding->Assoc, SContext, FALSE);
 294     }
 295 }
 296
 297 /***********************************************************************
 298  *           NDRSContextUnmarshall [RPCRT4.@]
 299  */
 300 NDR_SCONTEXT WINAPI NDRSContextUnmarshall(void *pBuff,
 301                                           ULONG DataRepresentation)
 302 {
 303     TRACE("(%p %08lx)\n", pBuff, DataRepresentation);
 304     return NDRSContextUnmarshall2(I_RpcGetCurrentCallHandle(), pBuff,
 305                                   DataRepresentation, NULL,
 306                                   RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
 307 }
 308
 309 /***********************************************************************
 310  *           NDRSContextUnmarshallEx [RPCRT4.@]
 311  */
 312 NDR_SCONTEXT WINAPI NDRSContextUnmarshallEx(RPC_BINDING_HANDLE hBinding,
 313                                             void *pBuff,
 314                                             ULONG DataRepresentation)
 315 {
 316     TRACE("(%p %p %08lx)\n", hBinding, pBuff, DataRepresentation);
 317     return NDRSContextUnmarshall2(hBinding, pBuff, DataRepresentation, NULL,
 318                                   RPC_CONTEXT_HANDLE_DEFAULT_FLAGS);
 319 }
 320
 321 /***********************************************************************
 322  *           NDRSContextUnmarshall2 [RPCRT4.@]
 323  */
 324 NDR_SCONTEXT WINAPI NDRSContextUnmarshall2(RPC_BINDING_HANDLE hBinding,
 325                                            void *pBuff,
 326                                            ULONG DataRepresentation,
 327                                            void *CtxGuard, ULONG Flags)
 328 {
 329     RpcBinding *binding = hBinding;
 330     NDR_SCONTEXT SContext;
 331     RPC_STATUS status;
 332     const ndr_context_handle *context_ndr = pBuff;
 333
 334     TRACE("(%p %p %08lx %p %lu)\n",
 335           hBinding, pBuff, DataRepresentation, CtxGuard, Flags);
 336
 337     if (!binding->server || !binding->Assoc)
 338         RpcRaiseException(RPC_S_INVALID_BINDING);
 339
 340     if (!pBuff || (!context_ndr->attributes &&
 341                    UuidIsNil((UUID *)&context_ndr->uuid, &status)))
 342         status = RpcServerAssoc_AllocateContextHandle(binding->Assoc, CtxGuard,
 343                                                       &SContext);
 344     else
 345     {
 346         if (context_ndr->attributes)
 347         {
 348             ERR("non-null attributes 0x%lx\n", context_ndr->attributes);
 349             status = RPC_X_SS_CONTEXT_MISMATCH;
 350         }
 351         else
 352             status = RpcServerAssoc_FindContextHandle(binding->Assoc,
 353                                                       &context_ndr->uuid,
 354                                                       CtxGuard, Flags,
 355                                                       &SContext);
 356     }
 357
 358     if (status != RPC_S_OK)
 359         RpcRaiseException(status);
 360
 361     RPCRT4_PushThreadContextHandle(SContext);
 362     return SContext;
 363 }