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, %d/0x%x): 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 } 169 170 #ifdef __REACTOS__ 171 /*********************************************************************** 172 * RpcGetAuthorizationContextForClient [RPCRT4.@] 173 * 174 * Called by RpcFreeAuthorizationContext to return the Authz context. 175 * 176 * PARAMS 177 * ClientBinding [I] Binding handle, represents a binding to a client on the server. 178 * ImpersonateOnReturn [I] Directs this function to be represented the client on return. 179 * Reserved1 [I] Reserved, equal to null. 180 * expiration_time [I] Points to the exact date and time when the token expires. 181 * Reserved2 [I] Reserved, equal to a LUID structure which has a members, 182 * each of them is set to zero. 183 * Reserved3 [I] Reserved, equal to zero. 184 * Reserved4 [I] Reserved, equal to null. 185 * authz_client_context [I] Points to an AUTHZ_CLIENT_CONTEXT_HANDLE structure 186 * that has direct pass to Authz functions. 187 * 188 * RETURNS 189 * Success: RPC_S_OK. 190 * Failure: Any error code. 191 */ 192 RPC_STATUS 193 WINAPI 194 RpcGetAuthorizationContextForClient(RPC_BINDING_HANDLE ClientBinding, 195 BOOL ImpersonateOnReturn, 196 void * Reserved1, 197 PLARGE_INTEGER expiration_time, 198 LUID Reserved2, 199 DWORD Reserved3, 200 PVOID Reserved4, 201 PVOID *authz_client_context) 202 { 203 FIXME("(%p, %d, %p, %p, (%d, %u), %u, %p, %p): stub\n", 204 ClientBinding, 205 ImpersonateOnReturn, 206 Reserved1, 207 expiration_time, 208 Reserved2.HighPart, 209 Reserved2.LowPart, 210 Reserved3, 211 Reserved4, 212 authz_client_context); 213 return RPC_S_NO_CONTEXT_AVAILABLE; 214 } 215 #endif 216