dlls/rpcrt4/rpc_async.c

   1 /*
   2  * Asynchronous Call Support Functions
   3  *
   4  * Copyright 2007 Robert Shearman (for CodeWeavers)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #include "rpc.h"
  25 #include "rpcndr.h"
  26 #include "rpcasync.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "rpc_binding.h"
  31 #include "rpc_message.h"
  32 #include "ndr_stubless.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
  35
  36 #define RPC_ASYNC_SIGNATURE 0x43595341
  37
  38 static inline BOOL valid_async_handle(PRPC_ASYNC_STATE pAsync)
  39 {
  40     return pAsync->Signature == RPC_ASYNC_SIGNATURE;
  41 }
  42
  43 /***********************************************************************
  44  *           RpcAsyncInitializeHandle [RPCRT4.@]
  45  *
  46  * Initialises an asynchronous state so it can be used in other asynchronous
  47  * functions and for use in asynchronous calls.
  48  *
  49  * PARAMS
  50  *  pAsync [I] Asynchronous state to initialise.
  51  *  Size   [I] Size of the memory pointed to by pAsync.
  52  *
  53  * RETURNS
  54  *  Success: RPC_S_OK.
  55  *  Failure: Any error code.
  56  */
  57 RPC_STATUS WINAPI RpcAsyncInitializeHandle(PRPC_ASYNC_STATE pAsync, unsigned int Size)
  58 {
  59     TRACE("(%p, %d)\n", pAsync, Size);
  60
  61     if (Size != sizeof(*pAsync))
  62     {
  63         ERR("invalid Size %d\n", Size);
  64         return ERROR_INVALID_PARAMETER;
  65     }
  66
  67     pAsync->Size = sizeof(*pAsync);
  68     pAsync->Signature = RPC_ASYNC_SIGNATURE;
  69     pAsync->Lock = 0;
  70     pAsync->Flags = 0;
  71     pAsync->StubInfo = NULL;
  72     pAsync->RuntimeInfo = NULL;
  73     memset(pAsync->Reserved, 0, sizeof(*pAsync) - FIELD_OFFSET(RPC_ASYNC_STATE, Reserved));
  74
  75     return RPC_S_OK;
  76 }
  77
  78 /***********************************************************************
  79  *           RpcAsyncGetCallStatus [RPCRT4.@]
  80  *
  81  * Retrieves the current status of the asynchronous call taking place.
  82  *
  83  * PARAMS
  84  *  pAsync [I] Asynchronous state to initialise.
  85  *
  86  * RETURNS
  87  *  RPC_S_OK - The call was successfully completed.
  88  *  RPC_S_INVALID_ASYNC_HANDLE - The asynchronous structure is not valid.
  89  *  RPC_S_ASYNC_CALL_PENDING - The call is still in progress and has not been completed.
  90  *  Any other error code - The call failed.
  91  */
  92 RPC_STATUS WINAPI RpcAsyncGetCallStatus(PRPC_ASYNC_STATE pAsync)
  93 {
  94     FIXME("(%p): stub\n", pAsync);
  95     return RPC_S_INVALID_ASYNC_HANDLE;
  96 }
  97
  98 /***********************************************************************
  99  *           RpcAsyncCompleteCall [RPCRT4.@]
 100  *
 101  * Completes a client or server asynchronous call.
 102  *
 103  * PARAMS
 104  *  pAsync [I] Asynchronous state to initialise.
 105  *  Reply  [I] The return value of the asynchronous function.
 106  *
 107  * RETURNS
 108  *  Success: RPC_S_OK.
 109  *  Failure: Any error code.
 110  */
 111 RPC_STATUS WINAPI RpcAsyncCompleteCall(PRPC_ASYNC_STATE pAsync, void *Reply)
 112 {
 113     struct async_call_data *data;
 114
 115     TRACE("(%p, %p)\n", pAsync, Reply);
 116
 117     if (!valid_async_handle(pAsync))
 118         return RPC_S_INVALID_ASYNC_HANDLE;
 119
 120     /* FIXME: check completed */
 121
 122     TRACE("pAsync %p, pAsync->StubInfo %p\n", pAsync, pAsync->StubInfo);
 123
 124     data = pAsync->StubInfo;
 125     if (data->pStubMsg->IsClient)
 126         return NdrpCompleteAsyncClientCall(pAsync, Reply);
 127
 128     return NdrpCompleteAsyncServerCall(pAsync, Reply);
 129 }
 130
 131 /***********************************************************************
 132  *           RpcAsyncAbortCall [RPCRT4.@]
 133  *
 134  * Aborts the asynchronous server call taking place.
 135  *
 136  * PARAMS
 137  *  pAsync        [I] Asynchronous server state to abort.
 138  *  ExceptionCode [I] Exception code to return to the client in a fault packet.
 139  *
 140  * RETURNS
 141  *  Success: RPC_S_OK.
 142  *  Failure: Any error code.
 143  */
 144 RPC_STATUS WINAPI RpcAsyncAbortCall(PRPC_ASYNC_STATE pAsync, ULONG ExceptionCode)
 145 {
 146     FIXME("(%p, %ld/0x%lx): stub\n", pAsync, ExceptionCode, ExceptionCode);
 147     return RPC_S_INVALID_ASYNC_HANDLE;
 148 }
 149
 150 /***********************************************************************
 151  *           RpcAsyncCancelCall [RPCRT4.@]
 152  *
 153  * Cancels the asynchronous client call taking place.
 154  *
 155  * PARAMS
 156  *  pAsync        [I] Asynchronous client state to abort.
 157  *  fAbortCall    [I] If TRUE, then send a cancel to the server, otherwise
 158  *                    just wait for the call to complete.
 159  *
 160  * RETURNS
 161  *  Success: RPC_S_OK.
 162  *  Failure: Any error code.
 163  */
 164 RPC_STATUS WINAPI RpcAsyncCancelCall(PRPC_ASYNC_STATE pAsync, BOOL fAbortCall)
 165 {
 166     FIXME("(%p, %s): stub\n", pAsync, fAbortCall ? "TRUE" : "FALSE");
 167     return RPC_S_INVALID_ASYNC_HANDLE;
 168 }