| /* |
| * Asynchronous Call Support Functions |
| * |
| * Copyright 2007 Robert Shearman (for CodeWeavers) |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| * |
| */ |
| |
| #include <stdarg.h> |
| |
| #include "rpc.h" |
| #include "rpcndr.h" |
| #include "rpcasync.h" |
| |
| #include "wine/debug.h" |
| |
| #include "rpc_binding.h" |
| #include "rpc_message.h" |
| #include "ndr_stubless.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(rpc); |
| |
| #define RPC_ASYNC_SIGNATURE 0x43595341 |
| |
| static inline BOOL valid_async_handle(PRPC_ASYNC_STATE pAsync) |
| { |
| return pAsync->Signature == RPC_ASYNC_SIGNATURE; |
| } |
| |
| /*********************************************************************** |
| * RpcAsyncInitializeHandle [RPCRT4.@] |
| * |
| * Initialises an asynchronous state so it can be used in other asynchronous |
| * functions and for use in asynchronous calls. |
| * |
| * PARAMS |
| * pAsync [I] Asynchronous state to initialise. |
| * Size [I] Size of the memory pointed to by pAsync. |
| * |
| * RETURNS |
| * Success: RPC_S_OK. |
| * Failure: Any error code. |
| */ |
| RPC_STATUS WINAPI RpcAsyncInitializeHandle(PRPC_ASYNC_STATE pAsync, unsigned int Size) |
| { |
| TRACE("(%p, %d)\n", pAsync, Size); |
| |
| if (Size != sizeof(*pAsync)) |
| { |
| ERR("invalid Size %d\n", Size); |
| return ERROR_INVALID_PARAMETER; |
| } |
| |
| pAsync->Size = sizeof(*pAsync); |
| pAsync->Signature = RPC_ASYNC_SIGNATURE; |
| pAsync->Lock = 0; |
| pAsync->Flags = 0; |
| pAsync->StubInfo = NULL; |
| pAsync->RuntimeInfo = NULL; |
| memset(pAsync->Reserved, 0, sizeof(*pAsync) - FIELD_OFFSET(RPC_ASYNC_STATE, Reserved)); |
| |
| return RPC_S_OK; |
| } |
| |
| /*********************************************************************** |
| * RpcAsyncGetCallStatus [RPCRT4.@] |
| * |
| * Retrieves the current status of the asynchronous call taking place. |
| * |
| * PARAMS |
| * pAsync [I] Asynchronous state to initialise. |
| * |
| * RETURNS |
| * RPC_S_OK - The call was successfully completed. |
| * RPC_S_INVALID_ASYNC_HANDLE - The asynchronous structure is not valid. |
| * RPC_S_ASYNC_CALL_PENDING - The call is still in progress and has not been completed. |
| * Any other error code - The call failed. |
| */ |
| RPC_STATUS WINAPI RpcAsyncGetCallStatus(PRPC_ASYNC_STATE pAsync) |
| { |
| FIXME("(%p): stub\n", pAsync); |
| return RPC_S_INVALID_ASYNC_HANDLE; |
| } |
| |
| /*********************************************************************** |
| * RpcAsyncCompleteCall [RPCRT4.@] |
| * |
| * Completes a client or server asynchronous call. |
| * |
| * PARAMS |
| * pAsync [I] Asynchronous state to initialise. |
| * Reply [I] The return value of the asynchronous function. |
| * |
| * RETURNS |
| * Success: RPC_S_OK. |
| * Failure: Any error code. |
| */ |
| RPC_STATUS WINAPI RpcAsyncCompleteCall(PRPC_ASYNC_STATE pAsync, void *Reply) |
| { |
| TRACE("(%p, %p)\n", pAsync, Reply); |
| |
| if (!valid_async_handle(pAsync)) |
| return RPC_S_INVALID_ASYNC_HANDLE; |
| |
| /* FIXME: check completed */ |
| |
| return NdrpCompleteAsyncClientCall(pAsync, Reply); |
| } |
| |
| /*********************************************************************** |
| * RpcAsyncAbortCall [RPCRT4.@] |
| * |
| * Aborts the asynchronous server call taking place. |
| * |
| * PARAMS |
| * pAsync [I] Asynchronous server state to abort. |
| * ExceptionCode [I] Exception code to return to the client in a fault packet. |
| * |
| * RETURNS |
| * Success: RPC_S_OK. |
| * Failure: Any error code. |
| */ |
| RPC_STATUS WINAPI RpcAsyncAbortCall(PRPC_ASYNC_STATE pAsync, ULONG ExceptionCode) |
| { |
| FIXME("(%p, %d/0x%x): stub\n", pAsync, ExceptionCode, ExceptionCode); |
| return RPC_S_INVALID_ASYNC_HANDLE; |
| } |
| |
| /*********************************************************************** |
| * RpcAsyncCancelCall [RPCRT4.@] |
| * |
| * Cancels the asynchronous client call taking place. |
| * |
| * PARAMS |
| * pAsync [I] Asynchronous client state to abort. |
| * fAbortCall [I] If TRUE, then send a cancel to the server, otherwise |
| * just wait for the call to complete. |
| * |
| * RETURNS |
| * Success: RPC_S_OK. |
| * Failure: Any error code. |
| */ |
| RPC_STATUS WINAPI RpcAsyncCancelCall(PRPC_ASYNC_STATE pAsync, BOOL fAbortCall) |
| { |
| FIXME("(%p, %s): stub\n", pAsync, fAbortCall ? "TRUE" : "FALSE"); |
| return RPC_S_INVALID_ASYNC_HANDLE; |
| } |